Other: Bridge Millau 2.2.1

This patch also replaces the deprecated calls to `SeparateKeyAndData`
with `SplitMessage`.

.gitignore

@@ -6,13 +6,11 @@
 .*.sw?
 *~
 .idea
-.vscode
 
 # Test files
 godog.test
 debug.test
 coverage.html
-gobinsec-cache*.yml
 
 # Run files
 mem.pprof
@@ -33,15 +31,3 @@ vendor-cache
 cmd/Desktop-Bridge/deploy
 cmd/Import-Export/deploy
 proton-bridge
-cmd/Desktop-Bridge/*.exe
-cmd/launcher/*.exe
-
-# Jetbrains (CLion, Golang) cmake build dirs
-cmake-build-*/
-
-# Doxygen doc files
-_doc/
-
-# gRPC auto-generated C++ source files
-*.pb.cc
-*.pb.h

.gitlab-ci.yml

@@ -16,270 +16,252 @@
 # along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
 ---
-image: gitlab.protontech.ch:4567/go/bridge-internal:test-go1.20
-
-variables:
-  GOPRIVATE: gitlab.protontech.ch
-  GOMAXPROCS: $(( ${CI_TAG_CPU} / 2 ))
+image: gitlab.protontech.ch:4567/go/bridge-internal:latest
 
 before_script:
-  - apt update && apt-get -y install libsecret-1-dev
-  - git config --global url.https://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}.insteadOf https://${CI_SERVER_HOST}
+  - eval $(ssh-agent -s)
+  - echo "$SSH_PRIVATE_KEY" | tr -d '\r' | ssh-add - > /dev/null
+
+  - mkdir -p .cache/bin
+  - export PATH=$(pwd)/.cache/bin:$PATH
+  - export GOPATH="$CI_PROJECT_DIR/.cache"
+
+  - make install-dev-dependencies
+
+cache:
+  key: go-mod
+  paths:
+    - .cache
+  policy: pull
 
 stages:
+  - cache
   - test
   - build
+  - mirror
 
-.rules-branch-and-MR-manual:
-  rules:
-    - if: $CI_COMMIT_BRANCH ||  $CI_PIPELINE_SOURCE == "merge_request_event"
-      when: manual
-      allow_failure: true
-    - when: never
+# Stage: CACHE
 
-.rules-branch-manual-MR-and-devel-always:
-  rules:
-    - if: $CI_COMMIT_BRANCH == "devel" || $CI_PIPELINE_SOURCE == "merge_request_event"
-      when: always
-      allow_failure: false
-    - if: $CI_COMMIT_BRANCH
-      when: manual
-      allow_failure: true
-    - when: never
-
-.rules-branch-manual-scheduled-and-test-branch-always:
-  rules:
-    - if: $CI_PIPELINE_SOURCE == "schedule"
-      when: always
-      allow_failure: false
-    - if: $CI_MERGE_REQUEST_SOURCE_BRANCH_NAME=~ /^test/
-      when: always
-      allow_failure: false
-    - if: $CI_COMMIT_BRANCH
-      when: manual
-      allow_failure: true
-    - when: never
-
-# ENV
-.env-windows:
-  before_script:
-    - export BRIDGE_SYNC_FORCE_MINIMUM_SPEC=1
-    - export GOROOT=/c/Go1.20/
-    - export PATH=$GOROOT/bin:$PATH
-    - export GOARCH=amd64
-    - export GOPATH=~/go1.20
-    - export GO111MODULE=on
-    - export PATH="${GOPATH}/bin:${PATH}"
-    - export MSYSTEM=
-    - export QT6DIR=/c/grrrQt/6.3.2/msvc2019_64
-    - export PATH=$PATH:${QT6DIR}/bin
-    - export PATH="/c/Program Files/Microsoft Visual Studio/2022/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin:$PATH"
-    - $(git config --global -l | grep -o 'url.*gitlab.protontech.ch.*insteadof' | xargs -L 1 git config --global --unset &> /dev/null) || echo "nothing to remove"
-    - git config --global url.https://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}.insteadOf https://${CI_SERVER_HOST}
-    - git config --global safe.directory '*'
-    - git status --porcelain
-  cache: {}
-  tags:
-    - windows-bridge
-
-.env-darwin:
-  before_script:
-    - export BRIDGE_SYNC_FORCE_MINIMUM_SPEC=1
-    - export PATH=/usr/local/bin:$PATH
-    - export PATH=/usr/local/opt/git/bin:$PATH
-    - export PATH=/usr/local/opt/make/libexec/gnubin:$PATH
-    - export PATH=/usr/local/opt/gnu-sed/libexec/gnubin:$PATH
-    - export GOROOT=~/local/opt/go@1.20
-    - export PATH="${GOROOT}/bin:$PATH"
-    - export GOPATH=~/go1.20
-    - export PATH="${GOPATH}/bin:$PATH"
-    - export QT6DIR=/opt/Qt/6.3.2/macos
-    - export PATH="${QT6DIR}/bin:$PATH"
-    - uname -a
-  cache: {}
-  tags:
-    - macos-m1-bridge
-
-.env-linux-build:
-  image: gitlab.protontech.ch:4567/go/bridge-internal:build-go1.20-qt6.3.2
-  variables:
-    VCPKG_DEFAULT_BINARY_CACHE: ${CI_PROJECT_DIR}/.cache
+# This will ensure latest dependency versions and updates the cache for
+# all other following jobs which only pull the cache.
+cache-push:
+  stage: cache
+  only:
+    - branches
+  script:
+    - echo ""
   cache:
-    key: linux-vcpkg
+    key: go-mod
     paths:
       - .cache
-    when: 'always'
-  before_script:
-    - mkdir -p .cache/bin
-    - export BRIDGE_SYNC_FORCE_MINIMUM_SPEC=1
-    - export PATH=$(pwd)/.cache/bin:$PATH
-    - export GOPATH="$CI_PROJECT_DIR/.cache"
-    - export PATH=$PATH:$QT6DIR/bin
-    - $(git config --global -l | grep -o 'url.*gitlab.protontech.ch.*insteadof' | xargs -L 1 git config --global --unset &> /dev/null) || echo "nothing to remove"
-    - git config --global url.https://gitlab-ci-token:${CI_JOB_TOKEN}@${CI_SERVER_HOST}.insteadOf https://${CI_SERVER_HOST}
-  tags:
-    - large
 
 # Stage: TEST
 
 lint:
   stage: test
-  extends:
-    - .rules-branch-manual-MR-and-devel-always
+  only:
+    - branches
+  before_script:
+    - mkdir -p .cache/bin
+    - export PATH=$(pwd)/.cache/bin:$PATH
+    - export GOPATH="$CI_PROJECT_DIR/.cache"
   script:
-    - make lint
+    - env GOMAXPROCS=$(( ${CI_TAG_CPU} / 2 )) make lint
   tags:
     - medium
 
-bug-report-preview:
-  stage: test
-  extends:
-    - .rules-branch-and-MR-manual
-  script:
-    - make lint-bug-report-preview
-  tags:
-    - medium
-
-.script-test:
-  stage: test
-  extends:
-    - .rules-branch-manual-MR-and-devel-always
-  script:
-    - make test
-  artifacts:
-    paths:
-      - coverage/**
-
 test-linux:
-  extends:
-    - .script-test
-  tags:
-    - large
-
-fuzz-linux:
   stage: test
-  extends:
-    - .rules-branch-manual-MR-and-devel-always
+  only:
+    - branches
   script:
-    - make fuzz
+    - apt-get -y install pass gnupg rng-tools
+    # First have enough of entropy (cat /proc/sys/kernel/random/entropy_avail).
+    - rngd -r /dev/urandom
+    # Generate GPG key without password for the password manager.
+    - gpg --batch --yes --passphrase '' --quick-generate-key 'tester@example.com'
+    # Use the last created GPG ID for the password manager.
+    - pass init `gpg --list-keys | grep "^   " | tail -1 | tr -d '[:space:]'`
+    # Then finally run the tests
+    - make test
   tags:
-    - large
-
-test-linux-race:
-  extends:
-    - test-linux
-    - .rules-branch-and-MR-manual
-  script:
-    - make test-race
-
-test-integration:
-  extends:
-    - test-linux
-  script:
-    - make test-integration
-
-test-integration-race:
-  extends:
-    - test-integration
-    - .rules-branch-and-MR-manual
-  script:
-    - make test-integration-race
-
-test-integration-nightly:
-  extends:
-    - test-integration
-    - .rules-branch-manual-scheduled-and-test-branch-always
-  needs:
-    - test-integration
-  script:
-    - make test-integration-nightly
+    - medium
 
 test-windows:
-  extends:
-    - .env-windows
-    - .script-test
-
-test-darwin:
-  extends:
-    - .env-darwin
-    - .script-test
-
-test-coverage:
+  extends: .build-windows-base
   stage: test
-  extends:
-    - .rules-branch-manual-scheduled-and-test-branch-always
+  only:
+    - branches
   script:
-    - ./utils/coverage.sh
-  coverage: '/total:.*\(statements\).*\d+\.\d+%/'
-  needs:
-    - test-linux
-    - test-windows
-    - test-darwin
-    - test-integration
-    - test-integration-nightly
+    - make test
+
+test-integration:
+  stage: test
+  only:
+    - branches
+  script:
+    - VERBOSITY=debug make -C test test
   tags:
-    - small
-  artifacts:
-    paths:
-      - coverage*
-      - coverage/**
-    when: 'always'
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
+    - large
+
+dependency-updates:
+  stage: test
+  script:
+    - make updates
 
 # Stage: BUILD
 
-.script-build:
+build-qml:
+  tags:
+    - small
+  only:
+    - branches
   stage: build
-  needs: ["lint"]
-  extends:
-    - .rules-branch-and-MR-manual
+  artifacts:
+    name: "bridge-qml-$CI_COMMIT_SHORT_SHA"
+    expire_in: 1 day
+    paths:
+      - bridge_qml.tgz
+  script:
+    - cd internal/frontend/qml
+    - tar -cvzf ../../../bridge_qml.tgz ./*
+
+
+.build-base:
+  stage: build
+  only:
+    - manual
+  before_script:
+    - mkdir -p .cache/bin
+    - export PATH=$(pwd)/.cache/bin:$PATH
+    - export GOPATH="$CI_PROJECT_DIR/.cache"
   script:
     - make build
     - git diff && git diff-index --quiet HEAD
-    - make vault-editor
+    - curl -L https://services.nvd.nist.gov/rest/json/cves/1.0/
+    - gobinsec -verbose -wait -config utils/gobinsec_conf.yml
+      cmd/Desktop-Bridge/deploy/linux/proton-bridge
   artifacts:
+    # Note: The latest artifacts for refs are locked against deletion, and kept
+    # regardless of the expiry time. Introduced in GitLab 13.0 behind a
+    # disabled feature flag, and made the default behavior in GitLab 13.4.
     expire_in: 1 day
     when: always
-    name: "$CI_JOB_NAME-$CI_COMMIT_SHORT_SHA"
     paths:
       - bridge_*.tgz
-      - vault-editor
+  tags:
+    - large
 
 build-linux:
-  extends:
-    - .script-build
-    - .env-linux-build
+  extends: .build-base
+  artifacts:
+    name: "bridge-linux-$CI_COMMIT_SHORT_SHA"
 
 build-linux-qa:
-  extends:
-    - build-linux
-    - .rules-branch-manual-MR-and-devel-always
+  extends: build-linux
+  only:
+    - web
+    - branches
   variables:
     BUILD_TAGS: "build_qa"
+  artifacts:
+    name: "bridge-linux-qa-$CI_COMMIT_SHORT_SHA"
+
+
+.build-darwin-base:
+  extends: .build-base
+  before_script:
+    - export PATH=/usr/local/bin:$PATH
+    - export PATH=/usr/local/opt/git/bin:$PATH
+    - export PATH=/usr/local/opt/make/libexec/gnubin:$PATH
+    - export PATH=/usr/local/opt/go@1.13/bin:$PATH
+    - export PATH=/usr/local/opt/gnu-sed/libexec/gnubin:$PATH
+    - export GOPATH=~/go
+    - export PATH=$GOPATH/bin:$PATH
+    - export CGO_CPPFLAGS='-Wno-error -Wno-nullability-completeness -Wno-expansion-to-defined -Wno-builtin-requires-header'
+  script:
+    - go version
+    - make build
+    - git diff && git diff-index --quiet HEAD
+  cache: {}
+  tags:
+    - macOS
 
 build-darwin:
-  extends:
-    - .script-build
-    - .env-darwin
+  extends: .build-darwin-base
+  artifacts:
+    name: "bridge-darwin-$CI_COMMIT_SHORT_SHA"
 
 build-darwin-qa:
-  extends:
-    - build-darwin
+  extends: .build-darwin-base
+  only:
+    - web
+    - branches
   variables:
     BUILD_TAGS: "build_qa"
+  artifacts:
+    name: "bridge-darwin-qa-$CI_COMMIT_SHORT_SHA"
+
+
+.build-windows-base:
+  extends: .build-base
+  before_script:
+    - export GOROOT=/c/Go
+    - export PATH=$GOROOT/bin:$PATH
+    - export GOARCH=amd64
+    - export GOPATH=~/go
+    - export GO111MODULE=on
+    - export PATH=$GOPATH/bin:$PATH
+    - export MSYSTEM=
+    - export PATH=$PATH:/c/grrrQt/5.13.2/mingw73_64/bin
+  script:
+    - make build
+    - git diff && git diff-index --quiet HEAD
+  tags:
+    - windows-bridge
 
 build-windows:
-  extends:
-    - .script-build
-    - .env-windows
+  extends: .build-windows-base
+  artifacts:
+    name: "bridge-windows-$CI_COMMIT_SHORT_SHA"
 
 build-windows-qa:
-  extends:
-    - build-windows
+  extends: .build-windows-base
+  only:
+    - web
+    - branches
   variables:
     BUILD_TAGS: "build_qa"
+  artifacts:
+    name: "bridge-windows-qa-$CI_COMMIT_SHORT_SHA"
 
-# TODO: PUT BACK ALL THE JOBS! JUST DID THIS FOR NOW TO GET CI WORKING AGAIN...
+# Stage: MIRROR
+
+mirror-repo:
+  stage: mirror
+  only:
+    refs:
+      - master
+  script:
+    - |
+      cat <<EOF > ~/.ssh/config
+      Host github.com
+          Hostname ssh.github.com
+          User git
+          Port 443
+          ProxyCommand connect-proxy -H $http_proxy %h %p
+      EOF
+    - ssh-keyscan -t rsa ${CI_SERVER_HOST} > ~/.ssh/known_hosts
+    - |
+      cat <<EOF >> ~/.ssh/known_hosts
+      # ssh.github.com:443 SSH-2.0-babeld-2e9d163d
+      [ssh.github.com]:443 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==
+      EOF
+    - echo "$mirror_key" | tr -d '\r' | ssh-add - > /dev/null
+    - ssh-add -l
+    - git clone "$CI_REPOSITORY_URL" --branch master _REPO_CLONE;
+    - cd _REPO_CLONE
+    - git remote add public $mirror_url
+    - git push public master
+    # Pushing the latest tag from master history
+    - git push public "$(git describe --tags --abbrev=0 || echo master)"

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "submodules/vcpkg"]
-	path = extern/vcpkg
-	url = https://github.com/Microsoft/vcpkg.git

.golangci.yml

@@ -3,7 +3,6 @@ run:
   timeout: 10m
   skip-dirs:
     - pkg/mime
-    - extern
 
 issues:
   exclude-use-default: false
@@ -13,37 +12,15 @@ issues:
     - should have comment (\([^)]+\) )?or be unexported
     # For now we are missing a lot of comments.
     - at least one file in a package should have a package comment
-    # Package comments.
-    - "package-comments: should have a package comment"
-    # Migration uses underscores to make versions clearer.
-    - "var-naming: don't use underscores in Go names"
-    - "ST1003: should not use underscores in Go names"
 
   exclude-rules:
     - path: _test\.go
       linters:
         - dupl
+        - funlen
         - gochecknoglobals
         - gochecknoinits
         - gosec
-        - goconst
-        - dogsled
-    - path: test
-      linters:
-        - dupl
-        - gochecknoglobals
-        - gochecknoinits
-        - gosec
-        - goconst
-        - dogsled
-    - path: utils/smtp-send
-      linters:
-        - dupl
-        - gochecknoglobals
-        - gochecknoinits
-        - gosec
-        - goconst
-        - dogsled
 
 linters-settings:
   godox:
@@ -56,17 +33,21 @@ linters:
   disable-all: true
 
   enable:
+    - deadcode          # Finds unused code [fast: true, auto-fix: false]
     - errcheck          # Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases [fast: true, auto-fix: false]
     - gosimple          # Linter for Go source code that specializes in simplifying a code [fast: true, auto-fix: false]
     - govet             # Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string [fast: true, auto-fix: false]
     - ineffassign       # Detects when assignments to existing variables are not used [fast: true, auto-fix: false]
     - staticcheck       # Staticcheck is a go vet on steroids, applying a ton of static analysis checks [fast: true, auto-fix: false]
+    - structcheck       # Finds unused struct fields [fast: true, auto-fix: false]
     - typecheck         # Like the front-end of a Go compiler, parses and type-checks Go code [fast: true, auto-fix: false]
     - unused            # Checks Go code for unused constants, variables, functions and types [fast: false, auto-fix: false]
+    - varcheck          # Finds unused global variables and constants [fast: true, auto-fix: false]
     - bodyclose         # checks whether HTTP response body is closed successfully [fast: true, auto-fix: false]
-    #- depguard          # Go linter that checks if package imports are in a list of acceptable packages [fast: true, auto-fix: false]
+    - depguard          # Go linter that checks if package imports are in a list of acceptable packages [fast: true, auto-fix: false]
     - dogsled           # Checks assignments with too many blank identifiers (e.g. x, _, _, _, := f()) [fast: true, auto-fix: false]
     - dupl              # Tool for code clone detection [fast: true, auto-fix: false]
+    - funlen            # Tool for detection of long functions [fast: true, auto-fix: false]
     - gochecknoglobals  # Checks that no globals are present in Go code [fast: true, auto-fix: false]
     - gochecknoinits    # Checks that no init functions are present in Go code [fast: true, auto-fix: false]
     - goconst           # Finds repeated strings that could be replaced by a constant [fast: true, auto-fix: false]
@@ -125,7 +106,3 @@ linters:
     # - thelper           # thelper detects golang test helpers without t.Helper() call and checks the consistency of test helpers [fast: false, auto-fix: false]
     # - wrapcheck         # Checks that errors returned from external packages are wrapped [fast: false, auto-fix: false]
 
-    # Deprecated:
-    # - structcheck       # Finds unused struct fields [fast: true, auto-fix: false] deprecated (since v1.49.0) due to: The owner seems to have abandoned the linter. Replaced by unused.
-    # - deadcode          # Finds unused code [fast: true, auto-fix: false] deprecated (since v1.49.0) due to: The owner seems to have abandoned the linter. Replaced by unused.
-    # - varcheck          # Finds unused global variables and constants [fast: true, auto-fix: false] deprecated (since v1.49.0) due to: The owner seems to have abandoned the linter. Replaced by unused.

BUILDS.md

@@ -1,28 +1,31 @@
-# Building Proton Mail Bridge
+# Building Proton Mail Bridge and Import-Export app
 
 ## Prerequisites
-* 64-bit OS:
+* 64-bit AMD OS:
     - the go-rfc5322 module cannot currently be compiled for 32-bit OSes
-* Go 1.20
+    - the Apple M1 builds are not supported yet due to dependencies
+* Go 1.13
 * Bash with basic build utils: make, gcc, sed, find, grep, ...
-  - For Windows, it is recommended to use MinGW 64bit shell from [MSYS2](https://www.msys2.org/)
-* GCC (Linux), msvc (Windows) or Xcode (macOS)
-* Windres (Windows)
-* libglvnd and libsecret development files (Linux)
-* pkg-config (Linux)
-* cmake, ninja-build and Qt 6 are required to build the graphical user interface. On Linux, 
-the Mesa OpenGL development files are also needed.
+* For Windows it is recommended to use MinGW 64bit shell from [MSYS2](https://www.msys2.org/)
+* GCC (linux, windows) or Xcode (macOS)
+* Windres (windows)
+* libglvnd and libsecret development files (linux)
 
 To enable the sending of crash reports using Sentry please set the
-`DSN_SENTRY` environment variable with the client key of your sentry project before build.
+`main.DSNSentry` value with the client key of your sentry project before build.
 Otherwise, the sending of crash reports will be disabled.
 
 ## Build
-In order to build Bridge app with Qt interface we are using
-[Qt 6.3](https://doc.qt.io/qt-6/gettingstarted.html).
+In order to build Bridge or Import-Export app with Qt interface we are using
+[Qt Go Binding](https://github.com/therecipe/qt).  The dependencies and
+installation of this tool is part of `make build` target.  If you have issues
+with installation of therecipe/qt we recommend to follow [this
+wiki](https://github.com/therecipe/qt/wiki/Installation-on-Linux)
+
+Please note that `$(go env GOPATH)/bin` must be in your `PATH` to ensure
+binaries installed by `therecipe/qt` (such as `qtdeploy`) are found. Also,
+before you start build **on Windows**, please unset the `MSYSTEM` variable
 
-Please note that qmake path must be in your `PATH` to ensure Qt to be found.
-Also, before you start build **on Windows**, please unset the `MSYSTEM` variable
 
 ```bash
 export MSYSTEM=
@@ -47,17 +50,28 @@ make build
 make build-nogui
 ```
 
-* To launch Bridge without GUI, you can invoke the `bridge` executable with one the following command-line switches:
-  * `--noninteractive` or `-n` to start Bridge without any interface (i.e., there is no way to add or remove client, get bridge password, etc.)
-  * `--cli` or `-c` to start Bridge with an interactive terminal interface.
-* NOTE: You still need to set up a supported keychain on your system.
+* Bridge without GUI will start by default without any interface (i.e., there is no way to add or remove client, get bridge password, etc)
+* Bridge always has the option (whether built with Qt or without) to use a CLI interface by starting it with the argument `-c`
+* NOTE: You still need to setup supported keychain on your system
 
-## Launchers
+### Build Import-Export
+* in project root run
+
+```bash
+make build-ie
+```
+
+* The result will be stored in `./cmd/Import-Export/deploy/${GOOS}/`
+    * for `linux`, the binary will have the name of the project directory (e.g `proton-bridge`)
+    * for `windows`, the binary will have the file extension `.exe` (e.g `proton-bridge.exe`)
+    * for `darwin`, the application will be created with name of the project directory (e.g `proton-bridge.app`)
+
+### Launchers
 Launchers are only included in official distributions and provide the public
 key used to verify signed app binaries, allowing the automatic update feature.
 See README for more information.
 
-## Tags
+### Tags
 Note that repository contains both Bridge and Import-Export apps and they are
 not released together. Therefore, each app has own tag prefix. Bridge tags
 starts with `br-` and Import-Export tags starts with `ie-`. Both tags continue

COPYING_NOTES.md

@@ -21,26 +21,39 @@ Proton Mail Bridge includes the following 3rd party software:
 * [Qt](https://www.qt.io/)                                | Available under [multiple licences](https://www.qt.io/licensing)
 
 <!-- START AUTOGEN -->
+* [docker-credential-helpers](https://github.com/docker/docker-credential-helpers) available under [license](https://github.com/docker/docker-credential-helpers/blob/master/LICENSE) 
+* [go-imap](https://github.com/emersion/go-imap) available under [license](https://github.com/emersion/go-imap/blob/master/LICENSE) 
 * [notificator](https://github.com/0xAX/notificator) available under [license](https://github.com/0xAX/notificator/blob/master/LICENSE) 
 * [semver](https://github.com/Masterminds/semver/v3) available under [license](https://github.com/Masterminds/semver/v3/blob/master/LICENSE) 
-* [gluon](https://github.com/ProtonMail/gluon) available under [license](https://github.com/ProtonMail/gluon/blob/master/LICENSE) 
+* [bcrypt](https://github.com/ProtonMail/bcrypt) available under [license](https://github.com/ProtonMail/bcrypt/blob/master/LICENSE) 
 * [go-autostart](https://github.com/ProtonMail/go-autostart) available under [license](https://github.com/ProtonMail/go-autostart/blob/master/LICENSE) 
-* [go-proton-api](https://github.com/ProtonMail/go-proton-api) available under [license](https://github.com/ProtonMail/go-proton-api/blob/master/LICENSE) 
+* [go-crypto](https://github.com/ProtonMail/go-crypto) available under [license](https://github.com/ProtonMail/go-crypto/blob/master/LICENSE) 
+* [go-imap-id](https://github.com/ProtonMail/go-imap-id) available under [license](https://github.com/ProtonMail/go-imap-id/blob/master/LICENSE) 
+* [go-rfc5322](https://github.com/ProtonMail/go-rfc5322) available under [license](https://github.com/ProtonMail/go-rfc5322/blob/master/LICENSE) 
+* [go-srp](https://github.com/ProtonMail/go-srp) available under [license](https://github.com/ProtonMail/go-srp/blob/master/LICENSE) 
+* [go-vcard](https://github.com/ProtonMail/go-vcard) available under [license](https://github.com/ProtonMail/go-vcard/blob/master/LICENSE) 
 * [gopenpgp](https://github.com/ProtonMail/gopenpgp/v2) available under [license](https://github.com/ProtonMail/gopenpgp/v2/blob/master/LICENSE) 
 * [goquery](https://github.com/PuerkitoBio/goquery) available under [license](https://github.com/PuerkitoBio/goquery/blob/master/LICENSE) 
 * [ishell](https://github.com/abiosoft/ishell) available under [license](https://github.com/abiosoft/ishell/blob/master/LICENSE) 
+* [readline](https://github.com/abiosoft/readline) available under [license](https://github.com/abiosoft/readline/blob/master/LICENSE) 
 * [go-singleinstance](https://github.com/allan-simon/go-singleinstance) available under [license](https://github.com/allan-simon/go-singleinstance/blob/master/LICENSE) 
-* [juniper](https://github.com/bradenaw/juniper) available under [license](https://github.com/bradenaw/juniper/blob/master/LICENSE) 
+* [logex](https://github.com/chzyer/logex) available under [license](https://github.com/chzyer/logex/blob/master/LICENSE) 
+* [test](https://github.com/chzyer/test) available under [license](https://github.com/chzyer/test/blob/master/LICENSE) 
 * [godog](https://github.com/cucumber/godog) available under [license](https://github.com/cucumber/godog/blob/master/LICENSE) 
 * [messages-go](https://github.com/cucumber/messages-go/v16) available under [license](https://github.com/cucumber/messages-go/v16/blob/master/LICENSE) 
-* [docker-credential-helpers](https://github.com/docker/docker-credential-helpers) available under [license](https://github.com/docker/docker-credential-helpers/blob/master/LICENSE) 
 * [go-sysinfo](https://github.com/elastic/go-sysinfo) available under [license](https://github.com/elastic/go-sysinfo/blob/master/LICENSE) 
-* [go-imap](https://github.com/emersion/go-imap) available under [license](https://github.com/emersion/go-imap/blob/master/LICENSE) 
-* [go-imap-id](https://github.com/emersion/go-imap-id) available under [license](https://github.com/emersion/go-imap-id/blob/master/LICENSE) 
+* [go-windows](https://github.com/elastic/go-windows) available under [license](https://github.com/elastic/go-windows/blob/master/LICENSE) 
+* [go-imap-appendlimit](https://github.com/emersion/go-imap-appendlimit) available under [license](https://github.com/emersion/go-imap-appendlimit/blob/master/LICENSE) 
+* [go-imap-move](https://github.com/emersion/go-imap-move) available under [license](https://github.com/emersion/go-imap-move/blob/master/LICENSE) 
+* [go-imap-quota](https://github.com/emersion/go-imap-quota) available under [license](https://github.com/emersion/go-imap-quota/blob/master/LICENSE) 
+* [go-imap-unselect](https://github.com/emersion/go-imap-unselect) available under [license](https://github.com/emersion/go-imap-unselect/blob/master/LICENSE) 
 * [go-message](https://github.com/emersion/go-message) available under [license](https://github.com/emersion/go-message/blob/master/LICENSE) 
 * [go-sasl](https://github.com/emersion/go-sasl) available under [license](https://github.com/emersion/go-sasl/blob/master/LICENSE) 
 * [go-smtp](https://github.com/emersion/go-smtp) available under [license](https://github.com/emersion/go-smtp/blob/master/LICENSE) 
+* [go-textwrapper](https://github.com/emersion/go-textwrapper) available under [license](https://github.com/emersion/go-textwrapper/blob/master/LICENSE) 
+* [go-vcard](https://github.com/emersion/go-vcard) available under [license](https://github.com/emersion/go-vcard/blob/master/LICENSE) 
 * [color](https://github.com/fatih/color) available under [license](https://github.com/fatih/color/blob/master/LICENSE) 
+* [go-shlex](https://github.com/flynn-archive/go-shlex) available under [license](https://github.com/flynn-archive/go-shlex/blob/master/LICENSE) 
 * [sentry-go](https://github.com/getsentry/sentry-go) available under [license](https://github.com/getsentry/sentry-go/blob/master/LICENSE) 
 * [resty](https://github.com/go-resty/resty/v2) available under [license](https://github.com/go-resty/resty/v2/blob/master/LICENSE) 
 * [dbus](https://github.com/godbus/dbus) available under [license](https://github.com/godbus/dbus/blob/master/LICENSE) 
@@ -48,89 +61,33 @@ Proton Mail Bridge includes the following 3rd party software:
 * [go-cmp](https://github.com/google/go-cmp) available under [license](https://github.com/google/go-cmp/blob/master/LICENSE) 
 * [uuid](https://github.com/google/uuid) available under [license](https://github.com/google/uuid/blob/master/LICENSE) 
 * [go-multierror](https://github.com/hashicorp/go-multierror) available under [license](https://github.com/hashicorp/go-multierror/blob/master/LICENSE) 
+* [bcrypt](https://github.com/jameskeane/bcrypt) available under [license](https://github.com/jameskeane/bcrypt/blob/master/LICENSE) 
 * [html2text](https://github.com/jaytaylor/html2text) available under [license](https://github.com/jaytaylor/html2text/blob/master/LICENSE) 
 * [go-keychain](https://github.com/keybase/go-keychain) available under [license](https://github.com/keybase/go-keychain/blob/master/LICENSE) 
+* [text](https://github.com/kr/text) available under [license](https://github.com/kr/text/blob/master/LICENSE) 
+* [aurora](https://github.com/logrusorgru/aurora) available under [license](https://github.com/logrusorgru/aurora/blob/master/LICENSE) 
+* [go-runewidth](https://github.com/mattn/go-runewidth) available under [license](https://github.com/mattn/go-runewidth/blob/master/LICENSE) 
 * [dns](https://github.com/miekg/dns) available under [license](https://github.com/miekg/dns/blob/master/LICENSE) 
-* [memory](https://github.com/pbnjay/memory) available under [license](https://github.com/pbnjay/memory/blob/master/LICENSE) 
+* [pretty](https://github.com/niemeyer/pretty) available under [license](https://github.com/niemeyer/pretty/blob/master/LICENSE) 
+* [jsondiff](https://github.com/nsf/jsondiff) available under [license](https://github.com/nsf/jsondiff/blob/master/LICENSE) 
+* [tablewriter](https://github.com/olekukonko/tablewriter) available under [license](https://github.com/olekukonko/tablewriter/blob/master/LICENSE) 
 * [errors](https://github.com/pkg/errors) available under [license](https://github.com/pkg/errors/blob/master/LICENSE) 
-* [profile](https://github.com/pkg/profile) available under [license](https://github.com/pkg/profile/blob/master/LICENSE) 
+* [procfs](https://github.com/prometheus/procfs) available under [license](https://github.com/prometheus/procfs/blob/master/LICENSE) 
+* [du](https://github.com/ricochet2200/go-disk-usage/du) available under [license](https://github.com/ricochet2200/go-disk-usage/du/blob/master/LICENSE) 
 * [logrus](https://github.com/sirupsen/logrus) available under [license](https://github.com/sirupsen/logrus/blob/master/LICENSE) 
+* [bom](https://github.com/ssor/bom) available under [license](https://github.com/ssor/bom/blob/master/LICENSE) 
 * [testify](https://github.com/stretchr/testify) available under [license](https://github.com/stretchr/testify/blob/master/LICENSE) 
+* [qt](https://github.com/therecipe/qt) available under [license](https://github.com/therecipe/qt/blob/master/LICENSE) 
 * [cli](https://github.com/urfave/cli/v2) available under [license](https://github.com/urfave/cli/v2/blob/master/LICENSE) 
 * [msgpack](https://github.com/vmihailenco/msgpack/v5) available under [license](https://github.com/vmihailenco/msgpack/v5/blob/master/LICENSE) 
-* [goleak](https://go.uber.org/goleak) available under [license](https://pkg.go.dev/go.uber.org/goleak?tab=licenses) 
-* [exp](https://golang.org/x/exp) available under [license](https://cs.opensource.google/go/x/exp/+/master:LICENSE) 
+* [bbolt](https://go.etcd.io/bbolt) available under [license](https://github.com/etcd-io/bbolt/blob/master/LICENSE) 
+* [crypto](https://golang.org/x/crypto) available under [license](https://cs.opensource.google/go/x/crypto/+/master:LICENSE) 
 * [net](https://golang.org/x/net) available under [license](https://cs.opensource.google/go/x/net/+/master:LICENSE) 
 * [sys](https://golang.org/x/sys) available under [license](https://cs.opensource.google/go/x/sys/+/master:LICENSE) 
 * [text](https://golang.org/x/text) available under [license](https://cs.opensource.google/go/x/text/+/master:LICENSE) 
-* [grpc](https://google.golang.org/grpc) available under [license](https://github.com/grpc/grpc-go/blob/master/LICENSE) 
-* [protobuf](https://google.golang.org/protobuf) available under [license](https://github.com/protocolbuffers/protobuf/blob/main/LICENSE) 
 * [plist](https://howett.net/plist) available under [license](https://github.com/DHowett/go-plist/blob/main/LICENSE) 
-* [bcrypt](https://github.com/ProtonMail/bcrypt) available under [license](https://github.com/ProtonMail/bcrypt/blob/master/LICENSE) 
-* [go-crypto](https://github.com/ProtonMail/go-crypto) available under [license](https://github.com/ProtonMail/go-crypto/blob/master/LICENSE) 
-* [go-mime](https://github.com/ProtonMail/go-mime) available under [license](https://github.com/ProtonMail/go-mime/blob/master/LICENSE) 
-* [go-srp](https://github.com/ProtonMail/go-srp) available under [license](https://github.com/ProtonMail/go-srp/blob/master/LICENSE) 
-* [readline](https://github.com/abiosoft/readline) available under [license](https://github.com/abiosoft/readline/blob/master/LICENSE) 
-* [cascadia](https://github.com/andybalholm/cascadia) available under [license](https://github.com/andybalholm/cascadia/blob/master/LICENSE) 
-* [sonic](https://github.com/bytedance/sonic) available under [license](https://github.com/bytedance/sonic/blob/master/LICENSE) 
-* [base64x](https://github.com/chenzhuoyu/base64x) available under [license](https://github.com/chenzhuoyu/base64x/blob/master/LICENSE) 
-* [test](https://github.com/chzyer/test) available under [license](https://github.com/chzyer/test/blob/master/LICENSE) 
-* [circl](https://github.com/cloudflare/circl) available under [license](https://github.com/cloudflare/circl/blob/master/LICENSE) 
-* [go-md2man](https://github.com/cpuguy83/go-md2man/v2) available under [license](https://github.com/cpuguy83/go-md2man/v2/blob/master/LICENSE) 
-* [saferith](https://github.com/cronokirby/saferith) available under [license](https://github.com/cronokirby/saferith/blob/master/LICENSE) 
-* [gherkin-go](https://github.com/cucumber/gherkin-go/v19) available under [license](https://github.com/cucumber/gherkin-go/v19/blob/master/LICENSE) 
-* [wincred](https://github.com/danieljoos/wincred) available under [license](https://github.com/danieljoos/wincred/blob/master/LICENSE) 
-* [go-spew](https://github.com/davecgh/go-spew) available under [license](https://github.com/davecgh/go-spew/blob/master/LICENSE) 
-* [go-windows](https://github.com/elastic/go-windows) available under [license](https://github.com/elastic/go-windows/blob/master/LICENSE) 
-* [go-textwrapper](https://github.com/emersion/go-textwrapper) available under [license](https://github.com/emersion/go-textwrapper/blob/master/LICENSE) 
-* [go-vcard](https://github.com/emersion/go-vcard) available under [license](https://github.com/emersion/go-vcard/blob/master/LICENSE) 
-* [fgprof](https://github.com/felixge/fgprof) available under [license](https://github.com/felixge/fgprof/blob/master/LICENSE) 
-* [go-shlex](https://github.com/flynn-archive/go-shlex) available under [license](https://github.com/flynn-archive/go-shlex/blob/master/LICENSE) 
-* [mimetype](https://github.com/gabriel-vasile/mimetype) available under [license](https://github.com/gabriel-vasile/mimetype/blob/master/LICENSE) 
-* [sse](https://github.com/gin-contrib/sse) available under [license](https://github.com/gin-contrib/sse/blob/master/LICENSE) 
-* [gin](https://github.com/gin-gonic/gin) available under [license](https://github.com/gin-gonic/gin/blob/master/LICENSE) 
-* [locales](https://github.com/go-playground/locales) available under [license](https://github.com/go-playground/locales/blob/master/LICENSE) 
-* [universal-translator](https://github.com/go-playground/universal-translator) available under [license](https://github.com/go-playground/universal-translator/blob/master/LICENSE) 
-* [validator](https://github.com/go-playground/validator/v10) available under [license](https://github.com/go-playground/validator/v10/blob/master/LICENSE) 
-* [go-json](https://github.com/goccy/go-json) available under [license](https://github.com/goccy/go-json/blob/master/LICENSE) 
-* [uuid](https://github.com/gofrs/uuid) available under [license](https://github.com/gofrs/uuid/blob/master/LICENSE) 
-* [protobuf](https://github.com/golang/protobuf) available under [license](https://github.com/golang/protobuf/blob/master/LICENSE) 
-* [pprof](https://github.com/google/pprof) available under [license](https://github.com/google/pprof/blob/master/LICENSE) 
-* [errwrap](https://github.com/hashicorp/errwrap) available under [license](https://github.com/hashicorp/errwrap/blob/master/LICENSE) 
-* [go-immutable-radix](https://github.com/hashicorp/go-immutable-radix) available under [license](https://github.com/hashicorp/go-immutable-radix/blob/master/LICENSE) 
-* [go-memdb](https://github.com/hashicorp/go-memdb) available under [license](https://github.com/hashicorp/go-memdb/blob/master/LICENSE) 
-* [golang-lru](https://github.com/hashicorp/golang-lru) available under [license](https://github.com/hashicorp/golang-lru/blob/master/LICENSE) 
-* [multierror](https://github.com/joeshaw/multierror) available under [license](https://github.com/joeshaw/multierror/blob/master/LICENSE) 
-* [go](https://github.com/json-iterator/go) available under [license](https://github.com/json-iterator/go/blob/master/LICENSE) 
-* [cpuid](https://github.com/klauspost/cpuid/v2) available under [license](https://github.com/klauspost/cpuid/v2/blob/master/LICENSE) 
-* [go-urn](https://github.com/leodido/go-urn) available under [license](https://github.com/leodido/go-urn/blob/master/LICENSE) 
-* [go-colorable](https://github.com/mattn/go-colorable) available under [license](https://github.com/mattn/go-colorable/blob/master/LICENSE) 
-* [go-isatty](https://github.com/mattn/go-isatty) available under [license](https://github.com/mattn/go-isatty/blob/master/LICENSE) 
-* [go-runewidth](https://github.com/mattn/go-runewidth) available under [license](https://github.com/mattn/go-runewidth/blob/master/LICENSE) 
-* [go-sqlite3](https://github.com/mattn/go-sqlite3) available under [license](https://github.com/mattn/go-sqlite3/blob/master/LICENSE) 
-* [concurrent](https://github.com/modern-go/concurrent) available under [license](https://github.com/modern-go/concurrent/blob/master/LICENSE) 
-* [reflect2](https://github.com/modern-go/reflect2) available under [license](https://github.com/modern-go/reflect2/blob/master/LICENSE) 
-* [tablewriter](https://github.com/olekukonko/tablewriter) available under [license](https://github.com/olekukonko/tablewriter/blob/master/LICENSE) 
-* [go-toml](https://github.com/pelletier/go-toml/v2) available under [license](https://github.com/pelletier/go-toml/v2/blob/master/LICENSE) 
-* [lz4](https://github.com/pierrec/lz4/v4) available under [license](https://github.com/pierrec/lz4/v4/blob/master/LICENSE) 
-* [go-difflib](https://github.com/pmezard/go-difflib) available under [license](https://github.com/pmezard/go-difflib/blob/master/LICENSE) 
-* [procfs](https://github.com/prometheus/procfs) available under [license](https://github.com/prometheus/procfs/blob/master/LICENSE) 
-* [uniseg](https://github.com/rivo/uniseg) available under [license](https://github.com/rivo/uniseg/blob/master/LICENSE) 
-* [blackfriday](https://github.com/russross/blackfriday/v2) available under [license](https://github.com/russross/blackfriday/v2/blob/master/LICENSE) 
-* [pflag](https://github.com/spf13/pflag) available under [license](https://github.com/spf13/pflag/blob/master/LICENSE) 
-* [bom](https://github.com/ssor/bom) available under [license](https://github.com/ssor/bom/blob/master/LICENSE) 
-* [golang-asm](https://github.com/twitchyliquid64/golang-asm) available under [license](https://github.com/twitchyliquid64/golang-asm/blob/master/LICENSE) 
-* [codec](https://github.com/ugorji/go/codec) available under [license](https://github.com/ugorji/go/codec/blob/master/LICENSE) 
-* [tagparser](https://github.com/vmihailenco/tagparser/v2) available under [license](https://github.com/vmihailenco/tagparser/v2/blob/master/LICENSE) 
-* [smetrics](https://github.com/xrash/smetrics) available under [license](https://github.com/xrash/smetrics/blob/master/LICENSE) 
-* [arch](https://golang.org/x/arch) available under [license](https://cs.opensource.google/go/x/arch/+/master:LICENSE) 
-* [crypto](https://golang.org/x/crypto) available under [license](https://cs.opensource.google/go/x/crypto/+/master:LICENSE) 
-* [mod](https://golang.org/x/mod) available under [license](https://cs.opensource.google/go/x/mod/+/master:LICENSE) 
-* [sync](https://golang.org/x/sync) available under [license](https://cs.opensource.google/go/x/sync/+/master:LICENSE) 
-* [tools](https://golang.org/x/tools) available under [license](https://cs.opensource.google/go/x/tools/+/master:LICENSE) 
-* [genproto](https://google.golang.org/genproto) available under [license](https://pkg.go.dev/google.golang.org/genproto?tab=licenses) 
-* [yaml](https://gopkg.in/yaml.v3) available under [license](https://github.com/go-yaml/yaml/blob/v3.0.1/LICENSE) 
 * [docker-credential-helpers](https://github.com/ProtonMail/docker-credential-helpers) available under [license](https://github.com/ProtonMail/docker-credential-helpers/blob/master/LICENSE) 
+* [go-imap](https://github.com/ProtonMail/go-imap) available under [license](https://github.com/ProtonMail/go-imap/blob/master/LICENSE) 
 * [go-message](https://github.com/ProtonMail/go-message) available under [license](https://github.com/ProtonMail/go-message/blob/master/LICENSE) 
 * [go-keychain](https://github.com/cuthix/go-keychain) available under [license](https://github.com/cuthix/go-keychain/blob/master/LICENSE) 
 <!-- END AUTOGEN -->

Makefile

@@ -5,187 +5,165 @@ export GO111MODULE=on
 GOOS:=$(shell go env GOOS)
 TARGET_CMD?=Desktop-Bridge
 TARGET_OS?=${GOOS}
-ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
 
 ## Build
-.PHONY: build build-gui build-nogui build-launcher versioner hasher
+.PHONY: build build-nogui build-launcher versioner hasher
 
 # Keep version hardcoded so app build works also without Git repository.
-BRIDGE_APP_VERSION?=3.5.4+git
+BRIDGE_APP_VERSION?=2.2.1+git
 APP_VERSION:=${BRIDGE_APP_VERSION}
-APP_FULL_NAME:=Proton Mail Bridge
-APP_VENDOR:=Proton AG
 SRC_ICO:=bridge.ico
 SRC_ICNS:=Bridge.icns
 SRC_SVG:=bridge.svg
 EXE_NAME:=proton-bridge
-REVISION:=$(shell ./utils/get_revision.sh)
-TAG:=$(shell ./utils/get_revision.sh tag)
+CONFIGNAME:=bridge
+REVISION:=$(shell git rev-parse --short=10 HEAD)
 BUILD_TIME:=$(shell date +%FT%T%z)
-MACOS_MIN_VERSION_ARM64=11.0
-MACOS_MIN_VERSION_AMD64=10.15
-BUILD_ENV?=dev
 
 BUILD_FLAGS:=-tags='${BUILD_TAGS}'
 BUILD_FLAGS_LAUNCHER:=${BUILD_FLAGS}
-GO_LDFLAGS:=$(addprefix -X github.com/ProtonMail/proton-bridge/v3/internal/constants., Version=${APP_VERSION} Revision=${REVISION} Tag=${TAG} BuildTime=${BUILD_TIME})
-GO_LDFLAGS+=-X "github.com/ProtonMail/proton-bridge/v3/internal/constants.FullAppName=${APP_FULL_NAME}"
-
-ifneq "${DSN_SENTRY}" ""
-	GO_LDFLAGS+=-X github.com/ProtonMail/proton-bridge/v3/internal/constants.DSNSentry=${DSN_SENTRY}
+BUILD_FLAGS_GUI:=-tags='${BUILD_TAGS} build_qt'
+GO_LDFLAGS:=$(addprefix -X github.com/ProtonMail/proton-bridge/v2/internal/constants.,Version=${APP_VERSION} Revision=${REVISION} BuildTime=${BUILD_TIME})
+ifneq "${BUILD_LDFLAGS}" ""
+    GO_LDFLAGS+=${BUILD_LDFLAGS}
 endif
-
-ifneq "${BUILD_ENV}" ""
-	GO_LDFLAGS+=-X github.com/ProtonMail/proton-bridge/v3/internal/constants.BuildEnv=${BUILD_ENV}
-endif
-
 GO_LDFLAGS_LAUNCHER:=${GO_LDFLAGS}
 ifeq "${TARGET_OS}" "windows"
-	#GO_LDFLAGS+=-H=windowsgui # Disabled so we can inspect trace logs from the bridge for debugging.
-	GO_LDFLAGS_LAUNCHER+=-H=windowsgui # Having this flag prevent a temporary cmd.exe window from popping when starting the application on Windows 11.
+    GO_LDFLAGS_LAUNCHER+=-H=windowsgui
 endif
 
 BUILD_FLAGS+=-ldflags '${GO_LDFLAGS}'
+BUILD_FLAGS_GUI+=-ldflags '${GO_LDFLAGS}'
 BUILD_FLAGS_LAUNCHER+=-ldflags '${GO_LDFLAGS_LAUNCHER}'
+
 DEPLOY_DIR:=cmd/${TARGET_CMD}/deploy
+ICO_FILES:=
 DIRNAME:=$(shell basename ${CURDIR})
-
-LAUNCHER_EXE:=proton-bridge
-BRIDGE_EXE=bridge
-BRIDGE_GUI_EXE_NAME=bridge-gui
-BRIDGE_GUI_EXE=${BRIDGE_GUI_EXE_NAME}
-LAUNCHER_PATH:=cmd/launcher
-
+EXE:=${EXE_NAME}
+EXE_QT:=${DIRNAME}
 ifeq "${TARGET_OS}" "windows"
-	BRIDGE_EXE:=${BRIDGE_EXE}.exe
-	BRIDGE_GUI_EXE:=${BRIDGE_GUI_EXE}.exe
-	LAUNCHER_EXE:=${LAUNCHER_EXE}.exe
-	RESOURCE_FILE:=resource.syso
+    EXE:=${EXE}.exe
+    EXE_QT:=${EXE_QT}.exe
+    RESOURCE_FILE:=resource.syso
 endif
 ifeq "${TARGET_OS}" "darwin"
-	BRIDGE_EXE_NAME:=${BRIDGE_EXE}
-	BRIDGE_EXE:=${BRIDGE_EXE}.app
-	BRIDGE_GUI_EXE:=${BRIDGE_GUI_EXE}.app
-	EXE_BINARY_DARWIN:=Contents/MacOS/${BRIDGE_GUI_EXE_NAME}
-	EXE_TARGET_DARWIN:=${DEPLOY_DIR}/${TARGET_OS}/${LAUNCHER_EXE}.app
-	DARWINAPP_CONTENTS:=${EXE_TARGET_DARWIN}/Contents
+    DARWINAPP_CONTENTS:=${DEPLOY_DIR}/darwin/${EXE}.app/Contents
+    EXE:=${EXE}.app
+    EXE_QT:=${EXE_QT}.app
+    EXE_BINARY_DARWIN:=/Contents/MacOS/${EXE_NAME}
 endif
-EXE_TARGET:=${DEPLOY_DIR}/${TARGET_OS}/${BRIDGE_EXE}
-EXE_GUI_TARGET:=${DEPLOY_DIR}/${TARGET_OS}/${BRIDGE_GUI_EXE}
+EXE_TARGET:=${DEPLOY_DIR}/${TARGET_OS}/${EXE}
+EXE_QT_TARGET:=${DEPLOY_DIR}/${TARGET_OS}/${EXE_QT}
 
 TGZ_TARGET:=bridge_${TARGET_OS}_${REVISION}.tgz
 
 ifdef QT_API
-	VENDOR_TARGET:=prepare-vendor update-qt-docs
+    VENDOR_TARGET:=prepare-vendor update-qt-docs
 else
-	VENDOR_TARGET=update-vendor
+    VENDOR_TARGET=update-vendor
 endif
 
-build: build-gui
+build: ${TGZ_TARGET}
 
-build-gui: ${TGZ_TARGET}
-
-build-nogui: ${EXE_NAME} build-launcher
-ifeq "${TARGET_OS}" "darwin"
-	mv ${BRIDGE_EXE} ${BRIDGE_EXE_NAME}
-endif
-
-go-build=go build $(1) -o $(2) $(3)
-go-build-finalize=${go-build}
-ifeq "${GOOS}-$(shell uname -m)" "darwin-arm64"
-	go-build-finalize= \
-		MACOSX_DEPLOYMENT_TARGET=${MACOS_MIN_VERSION_ARM64} CGO_ENABLED=1 CGO_CFLAGS="-mmacosx-version-min=${MACOS_MIN_VERSION_ARM64}" GOARCH=arm64 $(call go-build,$(1),$(2)_arm,$(3)) && \
-		MACOSX_DEPLOYMENT_TARGET=${MACOS_MIN_VERSION_AMD64} CGO_ENABLED=1 CGO_CFLAGS="-mmacosx-version-min=${MACOS_MIN_VERSION_AMD64}" GOARCH=amd64 $(call go-build,$(1),$(2)_amd,$(3)) && \
-		lipo -create -output $(2) $(2)_arm $(2)_amd && rm -f $(2)_arm $(2)_amd
-endif
+build-nogui: gofiles
+	go build ${BUILD_FLAGS} -o ${EXE_NAME} cmd/${TARGET_CMD}/main.go
 
 ifeq "${GOOS}" "windows"
-	go-build-finalize= \
-		$(if $(4),powershell Copy-Item ${ROOT_DIR}/${RESOURCE_FILE} ${4}  &&,) \
-		$(call go-build,$(1),$(2),$(3)) \
-		$(if $(4), && powershell Remove-Item ${4} -Force,)
+  	PRERESOURCECMD:=cp ./resource.syso ./cmd/launcher/resource.syso
+	POSTRESOURCECMD:=rm -f ./cmd/launcher/resource.syso
 endif
-
-${EXE_NAME}: gofiles  ${RESOURCE_FILE}
-	$(call go-build-finalize,${BUILD_FLAGS},"${LAUNCHER_EXE}","./cmd/${TARGET_CMD}/","${ROOT_DIR}/cmd/${TARGET_CMD}/${RESOURCE_FILE}")
-	mv ${LAUNCHER_EXE} ${BRIDGE_EXE}
-
 build-launcher: ${RESOURCE_FILE}
-	$(call go-build-finalize,${BUILD_FLAGS_LAUNCHER},"${LAUNCHER_EXE}","${ROOT_DIR}/${LAUNCHER_PATH}/","${ROOT_DIR}/${LAUNCHER_PATH}/${RESOURCE_FILE}")
+	${PRERESOURCECMD}
+	go build ${BUILD_FLAGS_LAUNCHER} -o launcher-${EXE} ./cmd/launcher/
+	${POSTRESOURCECMD}
 
 versioner:
 	go build ${BUILD_FLAGS} -o versioner utils/versioner/main.go
 
-vault-editor:
-	$(call go-build-finalize,"-tags=debug","vault-editor","./utils/vault-editor/main.go")
-
 hasher:
 	go build -o hasher utils/hasher/main.go
 
 ${TGZ_TARGET}: ${DEPLOY_DIR}/${TARGET_OS}
 	rm -f $@
-	tar -czvf $@ -C ${DEPLOY_DIR}/${TARGET_OS} .
+	cd ${DEPLOY_DIR}/${TARGET_OS} && tar -czvf ../../../../$@ .
 
-${DEPLOY_DIR}/linux: ${EXE_TARGET} build-launcher
+${DEPLOY_DIR}/linux: ${EXE_TARGET}
 	cp -pf ./dist/${SRC_SVG} ${DEPLOY_DIR}/linux/logo.svg
 	cp -pf ./LICENSE ${DEPLOY_DIR}/linux/
 	cp -pf ./Changelog.md ${DEPLOY_DIR}/linux/
 	cp -pf ./dist/${EXE_NAME}.desktop ${DEPLOY_DIR}/linux/
-	mv ${LAUNCHER_EXE} ${DEPLOY_DIR}/linux/
 
-${DEPLOY_DIR}/darwin: ${EXE_TARGET} build-launcher
-	mv ${EXE_GUI_TARGET} ${EXE_TARGET_DARWIN}
-	mv ${EXE_TARGET} ${DARWINAPP_CONTENTS}/MacOS/${BRIDGE_EXE_NAME}
-	perl -i -pe"s/>${BRIDGE_GUI_EXE_NAME}/>${LAUNCHER_EXE}/g" ${DARWINAPP_CONTENTS}/Info.plist
+${DEPLOY_DIR}/darwin: ${EXE_TARGET}
+	if [ "${DIRNAME}" != "${EXE_NAME}" ]; then \
+		mv ${EXE_TARGET}/Contents/MacOS/{${DIRNAME},${EXE_NAME}}; \
+		perl -i -pe"s/>${DIRNAME}/>${EXE_NAME}/g" ${EXE_TARGET}/Contents/Info.plist; \
+	fi
 	cp ./dist/${SRC_ICNS} ${DARWINAPP_CONTENTS}/Resources/${SRC_ICNS}
 	cp LICENSE ${DARWINAPP_CONTENTS}/Resources/
 	rm -rf "${DARWINAPP_CONTENTS}/Frameworks/QtWebEngine.framework"
 	rm -rf "${DARWINAPP_CONTENTS}/Frameworks/QtWebView.framework"
 	rm -rf "${DARWINAPP_CONTENTS}/Frameworks/QtWebEngineCore.framework"
-	mv ${LAUNCHER_EXE}  ${DARWINAPP_CONTENTS}/MacOS/${LAUNCHER_EXE}
-	./utils/remove_non_relative_links_darwin.sh "${EXE_TARGET_DARWIN}/${EXE_BINARY_DARWIN}"
+	./utils/remove_non_relative_links_darwin.sh "${EXE_TARGET}${EXE_BINARY_DARWIN}"
 
-${DEPLOY_DIR}/windows: ${EXE_TARGET} build-launcher
+${DEPLOY_DIR}/windows: ${EXE_TARGET}
 	cp ./dist/${SRC_ICO} ${DEPLOY_DIR}/windows/logo.ico
-	cp LICENSE ${DEPLOY_DIR}/windows/LICENSE.txt
-	mv ${LAUNCHER_EXE} ${DEPLOY_DIR}/windows/$(notdir ${LAUNCHER_EXE})
-	# plugins are installed in a plugins folder while needs to be near the exe
-	cp -rf ${DEPLOY_DIR}/windows/plugins/* ${DEPLOY_DIR}/windows/.
-	rm -rf ${DEPLOY_DIR}/windows/plugins
+	cp LICENSE ${DEPLOY_DIR}/windows/
+
+QT_BUILD_TARGET:=build desktop
+ifneq "${GOOS}" "${TARGET_OS}"
+  ifeq "${TARGET_OS}" "windows"
+    QT_BUILD_TARGET:=-docker build windows_64_shared
+  endif
+endif
+
+${EXE_TARGET}: check-has-go gofiles ${RESOURCE_FILE} ${VENDOR_TARGET}
+	rm -rf deploy ${TARGET_OS} ${DEPLOY_DIR}
+	cp cmd/${TARGET_CMD}/main.go .
+	qtdeploy ${BUILD_FLAGS_GUI} ${QT_BUILD_TARGET}
+	mv deploy cmd/${TARGET_CMD}
+	if [ "${EXE_QT_TARGET}" != "${EXE_TARGET}" ]; then mv ${EXE_QT_TARGET} ${EXE_TARGET}; fi
+	rm -rf ${TARGET_OS} main.go
 
-${EXE_TARGET}: check-build-essentials ${EXE_NAME}
-	cd internal/frontend/bridge-gui/bridge-gui && \
-		BRIDGE_APP_FULL_NAME="${APP_FULL_NAME}" \
-		BRIDGE_VENDOR="${APP_VENDOR}" \
-		BRIDGE_APP_VERSION=${APP_VERSION} \
-		BRIDGE_REVISION=${REVISION} \
-		BRIDGE_TAG=${TAG} \
-		BRIDGE_DSN_SENTRY=${DSN_SENTRY} \
- 		BRIDGE_BUILD_TIME=${BUILD_TIME} \
-		BRIDGE_GUI_BUILD_CONFIG=Release \
-		BRIDGE_BUILD_ENV=${BUILD_ENV} \
-		BRIDGE_INSTALL_PATH=${ROOT_DIR}/${DEPLOY_DIR}/${GOOS} \
-		./build.sh install
-	mv "${ROOT_DIR}/${BRIDGE_EXE}" "$(ROOT_DIR)/${EXE_TARGET}"
 
 WINDRES_YEAR:=$(shell date +%Y)
 APP_VERSION_COMMA:=$(shell echo "${APP_VERSION}" | sed -e 's/[^0-9,.]*//g' -e 's/\./,/g')
-${RESOURCE_FILE}: ./dist/info.rc ./dist/${SRC_ICO} .FORCE
+resource.syso: ./dist/info.rc ./dist/${SRC_ICO} .FORCE
 	rm -f ./*.syso
-	windres --target=pe-x86-64 \
-		-I ./internal/frontend/share/ \
-		-D ICO_FILE=${SRC_ICO} \
-		-D EXE_NAME="${EXE_NAME}" \
-		-D FILE_VERSION="${APP_VERSION}" \
-		-D ORIGINAL_FILE_NAME="${EXE}" \
-		-D PRODUCT_VERSION="${APP_VERSION}" \
-		-D FILE_VERSION_COMMA=${APP_VERSION_COMMA} \
-		-D YEAR=${WINDRES_YEAR} \
-		-o ./${RESOURCE_FILE} $<
+	windres --target=pe-x86-64 -I ./internal/frontend/share/ -D ICO_FILE=${SRC_ICO} -D EXE_NAME="${EXE_NAME}" -D FILE_VERSION="${APP_VERSION}" -D ORIGINAL_FILE_NAME="${EXE}" -D PRODUCT_VERSION="${APP_VERSION}" -D FILE_VERSION_COMMA=${APP_VERSION_COMMA} -D YEAR=${WINDRES_YEAR} -o $@ $<
+
+## Rules for therecipe/qt
+.PHONY: prepare-vendor update-vendor update-qt-docs
+THERECIPE_ENV:=github.com/therecipe/env_${TARGET_OS}_amd64_513
+
+# vendor folder will be deleted by gomod hence we cache the big repo
+# therecipe/env in order to download it only once
+vendor-cache/${THERECIPE_ENV}:
+	git clone https://${THERECIPE_ENV}.git vendor-cache/${THERECIPE_ENV}
+	if [ "${TARGET_OS}" == "darwin" ]; then cp -f "./utils/QTBUG-88600/libqcocoa.dylib" "./vendor-cache/${THERECIPE_ENV}/5.13.0/clang_64/plugins/platforms/"; fi;
+
+# The command used to make symlinks is different on windows.
+# So if the GOOS is windows and we aren't crossbuilding (in which case the host os would still be *nix)
+# we need to change the LINKCMD to something windowsy.
+LINKCMD:=ln -sf ${CURDIR}/vendor-cache/${THERECIPE_ENV} vendor/${THERECIPE_ENV}
+ifeq "${GOOS}" "windows"
+  WINDIR:=$(subst /c/,c:\\,${CURDIR})/vendor-cache/${THERECIPE_ENV}
+  LINKCMD:=cmd //c 'mklink $(subst /,\,vendor\${THERECIPE_ENV} ${WINDIR})'
+endif
+
+prepare-vendor:
+	go install -v -tags=no_env github.com/therecipe/qt/cmd/...
+	go mod vendor
+
+# update-vendor is PHONY because we need to make sure that we always have updated vendor
+update-vendor: vendor-cache/${THERECIPE_ENV} prepare-vendor
+	${LINKCMD}
+
+update-qt-docs:
+	go get github.com/therecipe/qt/internal/binding/files/docs/$(QT_API)
 
 ## Dev dependencies
 .PHONY: install-devel-tools install-linter install-go-mod-outdated install-git-hooks
-LINTVER:="v1.52.2"
+LINTVER:="v1.39.0"
 LINTSRC:="https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh"
 
 install-dev-dependencies: install-devel-tools install-linter install-go-mod-outdated
@@ -199,29 +177,16 @@ install-linter: check-has-go
 	curl -sfL $(LINTSRC) | sh -s -- -b $(shell go env GOPATH)/bin $(LINTVER)
 
 install-go-mod-outdated:
-	which go-mod-outdated || go install github.com/psampaz/go-mod-outdated@latest
+	which go-mod-outdated || go get -u github.com/psampaz/go-mod-outdated
 
 install-git-hooks:
 	cp utils/githooks/* .git/hooks/
 	chmod +x .git/hooks/*
 
 ## Checks, mocks and docs
-.PHONY: check-has-go check-build-essentials add-license change-copyright-year test bench coverage mocks lint-license lint-golang lint updates doc release-notes
+.PHONY: check-has-go add-license change-copyright-year test bench coverage mocks lint-license lint-golang lint updates doc release-notes
 check-has-go:
 	@which go || (echo "Install Go-lang!" && exit 1)
-	go version
-
-
-check_is_installed=if ! which $(1) > /dev/null; then echo "Please install $(1)"; exit 1; fi
-check-build-essentials:
-	@$(call check_is_installed,zip)
-	@$(call check_is_installed,unzip)
-	@$(call check_is_installed,tar)
-	@$(call check_is_installed,curl)
-ifneq "${GOOS}" "windows"
-	@$(call check_is_installed,cmake)
-	@$(call check_is_installed,ninja)
-endif
 
 add-license:
 	./utils/missing_license.sh add
@@ -229,50 +194,27 @@ add-license:
 change-copyright-year:
 	./utils/missing_license.sh change-year
 
-GOCOVERAGE=-covermode=count -coverpkg=github.com/ProtonMail/proton-bridge/v3/internal/...,github.com/ProtonMail/proton-bridge/v3/pkg/...,
-GOCOVERDIR=-args -test.gocoverdir=$$PWD/coverage
-
 test: gofiles
-	mkdir -p coverage/unit-${GOOS}
-	go test \
-		-v -timeout=20m -p=1 -count=1 \
-		${GOCOVERAGE} \
-		-run=${TESTRUN} ./internal/... ./pkg/... \
-		${GOCOVERDIR}/unit-${GOOS}
-
-test-race: gofiles
-	go test -v -timeout=40m -p=1 -count=1 -race -failfast -run=${TESTRUN} ./internal/... ./pkg/...
-
-test-integration: gofiles
-	mkdir -p coverage/integration
-	go test \
-		-v -timeout=60m -p=1 -count=1 -tags=test_integration \
-		${GOCOVERAGE} \
-		github.com/ProtonMail/proton-bridge/v3/tests \
-		${GOCOVERDIR}/integration
-
-
-test-integration-debug: gofiles
-	dlv test github.com/ProtonMail/proton-bridge/v3/tests -- -test.v -test.timeout=10m -test.parallel=1 -test.count=1
-
-test-integration-race: gofiles
-	go test -v -timeout=60m -p=1 -count=1 -race -failfast github.com/ProtonMail/proton-bridge/v3/tests
-
-test-integration-nightly: gofiles
-	mkdir -p coverage/integration
-	go test \
-		-v -timeout=90m -p=1 -count=1 -tags=test_integration \
-		${GOCOVERAGE} \
-		github.com/ProtonMail/proton-bridge/v3/tests \
-		${GOCOVERDIR}/integration \
-		nightly
-
-fuzz: gofiles
-	go test -fuzz=FuzzUnmarshal 	 -parallel=4 -fuzztime=60s $(PWD)/internal/legacy/credentials
-	go test -fuzz=FuzzNewParser 	 -parallel=4 -fuzztime=60s $(PWD)/pkg/message/parser
-	go test -fuzz=FuzzReadHeaderBody -parallel=4 -fuzztime=60s $(PWD)/pkg/message
-	go test -fuzz=FuzzDecodeHeader 	 -parallel=4 -fuzztime=60s $(PWD)/pkg/mime
-	go test -fuzz=FuzzDecodeCharset  -parallel=4 -fuzztime=60s $(PWD)/pkg/mime
+	@# Listing packages manually to not run Qt folder (which needs to run qtsetup first) and integration tests.
+	go test -coverprofile=/tmp/coverage.out -run=${TESTRUN} \
+		./internal/api/... \
+		./internal/bridge/... \
+		./internal/config/... \
+		./internal/constants/... \
+		./internal/cookies/... \
+		./internal/crash/... \
+		./internal/events/... \
+		./internal/frontend/cli/... \
+		./internal/imap/... \
+		./internal/locations/... \
+		./internal/logging/... \
+		./internal/metrics/... \
+		./internal/smtp/... \
+		./internal/store/... \
+		./internal/updater/... \
+		./internal/users/... \
+		./internal/versioner/... \
+		./pkg/...
 
 bench:
 	go test -run '^$$' -bench=. -memprofile bench_mem.pprof -cpuprofile bench_cpu.pprof ./internal/store
@@ -282,31 +224,18 @@ bench:
 coverage: test
 	go tool cover -html=/tmp/coverage.out -o=coverage.html
 
-mocks:
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/bridge TLSReporter,ProxyController,Autostarter > tmp
-	mv tmp internal/bridge/mocks/mocks.go
-	mockgen --package mocks github.com/ProtonMail/gluon/async PanicHandler > internal/bridge/mocks/async_mocks.go
-	mockgen --package mocks github.com/ProtonMail/gluon/reporter Reporter > internal/bridge/mocks/gluon_mocks.go
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/updater Downloader,Installer > internal/updater/mocks/mocks.go
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/telemetry HeartbeatManager > internal/telemetry/mocks/mocks.go
-	cp internal/telemetry/mocks/mocks.go internal/bridge/mocks/telemetry_mocks.go
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/services/userevents \
-EventSource,EventIDStore  > internal/services/userevents/mocks/mocks.go
-	mockgen --package userevents github.com/ProtonMail/proton-bridge/v3/internal/services/userevents \
-EventSubscriber,MessageEventHandler,LabelEventHandler,AddressEventHandler,RefreshEventHandler,UserEventHandler,UserUsedSpaceEventHandler > tmp
-	mv tmp internal/services/userevents/mocks_test.go
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/events EventPublisher \
-> internal/events/mocks/mocks.go
-	mockgen --package mocks github.com/ProtonMail/proton-bridge/v3/internal/services/useridentity IdentityProvider,Telemetry \
-> internal/services/useridentity/mocks/mocks.go
-	mockgen --self_package "github.com/ProtonMail/proton-bridge/v3/internal/services/syncservice" -package syncservice github.com/ProtonMail/proton-bridge/v3/internal/services/syncservice \
-ApplyStageInput,BuildStageInput,BuildStageOutput,DownloadStageInput,DownloadStageOutput,MetadataStageInput,MetadataStageOutput,\
-StateProvider,Regulator,UpdateApplier,MessageBuilder,APIClient,Reporter,DownloadRateModifier \
-> tmp
-	mv tmp internal/services/syncservice/mocks_test.go
-	mockgen --package mocks github.com/ProtonMail/gluon/connector IMAPStateWrite > internal/services/imapservice/mocks/mocks.go
+integration-test-bridge:
+	${MAKE} -C test test-bridge
 
-lint: gofiles lint-golang lint-license lint-dependencies lint-changelog lint-bug-report
+mocks:
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/internal/users Locator,PanicHandler,CredentialsStorer,StoreMaker > internal/users/mocks/mocks.go
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/pkg/listener Listener > internal/users/mocks/listener_mocks.go
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/internal/store PanicHandler,BridgeUser,ChangeNotifier,Storer > internal/store/mocks/mocks.go
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/pkg/listener Listener > internal/store/mocks/utils_mocks.go
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/pkg/pmapi Client,Manager > pkg/pmapi/mocks/mocks.go
+	mockgen --package mocks github.com/ProtonMail/proton-bridge/v2/pkg/message Fetcher > pkg/message/mocks/mocks.go
+
+lint: gofiles lint-golang lint-license lint-dependencies lint-changelog
 
 lint-license:
 	./utils/missing_license.sh check
@@ -322,19 +251,6 @@ lint-golang:
 	$(info linting with GOMAXPROCS=${GOMAXPROCS})
 	golangci-lint run ./...
 
-lint-bug-report:
-	python3 utils/validate_bug_report_file.py --file "internal/frontend/bridge-gui/bridge-gui/qml/Resources/bug_report_flow.json"
-
-lint-bug-report-preview:
-	python3 utils/validate_bug_report_file.py --file "internal/frontend/bridge-gui/bridge-gui/qml/Resources/bug_report_flow.json" --preview
-
-gobinsec: gobinsec-cache.yml build
-	gobinsec -wait -cache -config utils/gobinsec_conf.yml ${EXE_TARGET} ${DEPLOY_DIR}/${TARGET_OS}/${LAUNCHER_EXE}
-
-gobinsec-cache.yml:
-	./utils/gobinsec_update.sh
-	cp ./utils/gobinsec_update/gobinsec-cache-valid.yml ./gobinsec-cache.yml
-
 updates: install-go-mod-outdated
 	# Uncomment the "-ci" to fail the job if something can be updated.
 	go list -u -m -json all | go-mod-outdated -update -direct #-ci
@@ -342,7 +258,7 @@ updates: install-go-mod-outdated
 doc:
 	godoc -http=:6060
 
-release-notes: release-notes/bridge_stable.html release-notes/bridge_early.html utils/release_notes.sh
+release-notes: release-notes/bridge_stable.html release-notes/bridge_early.html
 
 release-notes/%.html: release-notes/%.md
 	./utils/release_notes.sh $^
@@ -355,79 +271,51 @@ gofiles: ./internal/bridge/credits.go
 	cd ./utils/ && ./credits.sh bridge
 
 ## Run and debug
-.PHONY: run run-qt run-qt-cli run-nogui run-cli run-noninteractive run-debug run-gui-tester clean-vendor clean-frontend-qt clean-frontend-qt-common clean
+.PHONY: run run-qt run-qt-cli run-nogui run-nogui-cli run-debug run-qml-preview clean-vendor clean-frontend-qt clean-frontend-qt-common clean
 
 LOG?=debug
 LOG_IMAP?=client # client/server/all, or empty to turn it off
 LOG_SMTP?=--log-smtp # empty to turn it off
-RUN_FLAGS?=-l=${LOG} --log-imap=${LOG_IMAP} ${LOG_SMTP}
+RUN_FLAGS?=-m -l=${LOG} --log-imap=${LOG_IMAP} ${LOG_SMTP}
 
-run: run-qt
+run: run-nogui-cli
 
-run-cli: run-nogui
+run-qt: ${EXE_TARGET}
+	PROTONMAIL_ENV=dev ./$< ${RUN_FLAGS} 2>&1 | tee last.log
+run-qt-cli: ${EXE_TARGET}
+	PROTONMAIL_ENV=dev ./$< ${RUN_FLAGS} -c
 
-run-noninteractive: build-nogui clean-vendor gofiles
-	PROTONMAIL_ENV=dev ./${LAUNCHER_EXE} ${RUN_FLAGS} -n
-
-run-qt: build-gui
-ifeq "${TARGET_OS}" "darwin"
-	PROTONMAIL_ENV=dev ${DARWINAPP_CONTENTS}/MacOS/${LAUNCHER_EXE}  ${RUN_FLAGS}
-else
-	PROTONMAIL_ENV=dev ./${DEPLOY_DIR}/${TARGET_OS}/${LAUNCHER_EXE} ${RUN_FLAGS}
-endif
-
-run-nogui: build-nogui clean-vendor gofiles
-	PROTONMAIL_ENV=dev ./${LAUNCHER_EXE} ${RUN_FLAGS} -c
+run-nogui: clean-vendor gofiles
+	PROTONMAIL_ENV=dev go run ${BUILD_FLAGS} cmd/${TARGET_CMD}/main.go ${RUN_FLAGS} | tee last.log
+run-nogui-cli: clean-vendor gofiles
+	PROTONMAIL_ENV=dev go run ${BUILD_FLAGS} cmd/${TARGET_CMD}/main.go ${RUN_FLAGS} -c
 
 run-debug:
-	dlv debug \
-		--build-flags "-ldflags '-X github.com/ProtonMail/proton-bridge/v3/internal/constants.Version=3.1.0+git'" \
-		./cmd/Desktop-Bridge/main.go \
-		-- \
-		-n -l=trace
+	PROTONMAIL_ENV=dev dlv debug --build-flags "${BUILD_FLAGS}" cmd/${TARGET_CMD}/main.go -- ${RUN_FLAGS} --noninteractive
 
-ifeq "${TARGET_OS}" "windows"
-	EXE_SUFFIX=.exe
-endif
-
-bridge-gui-tester:  build-gui
-	cp ./cmd/Desktop-Bridge/deploy/${TARGET_OS}/bridge-gui${EXE_SUFFIX} .
-	cd ./internal/frontend/bridge-gui/bridge-gui-tester && cmake . && make
-
-run-gui-tester: bridge-gui-tester
-	# copying tester as bridge so bridge-gui will start it and connect to it automatically
-	cp ./internal/frontend/bridge-gui/bridge-gui-tester/bridge-gui-tester${EXE_SUFFIX} bridge${EXE_SUFFIX}
-	./bridge-gui${EXE_SUFFIX}
+run-qml-preview:
+	find internal/frontend/qml/ -iname '*qmlc' | xargs rm -f
+	bridge_preview internal/frontend/qml/Bridge_test.qml
 	
 
-clean-vendor:
+clean-frontend-qt:
+	$(MAKE) -C internal/frontend -f Makefile.local clean
+
+clean-vendor: clean-frontend-qt clean-frontend-qt-common
 	rm -rf ./vendor
 
-clean-gui:
-	cd internal/frontend/bridge-gui/ && \
-		rm -f BuildConfig.h && \
-		rm -rf cmake-build-*/
-
-clean-vcpkg:
-	git submodule deinit -f ./extern/vcpkg
-	rm -rf ./.git/submodule/vcpkg
-	rm -rf ./extern/vcpkg
-	git checkout -- extern/vcpkg
-
-clean: clean-vendor clean-gui clean-vcpkg
+clean: clean-vendor
 	rm -rf vendor-cache
 	rm -rf cmd/Desktop-Bridge/deploy
 	rm -rf cmd/Import-Export/deploy
 	rm -f build last.log mem.pprof main.go
-	rm -f ./*.syso
+	rm -f resource.syso
 	rm -f release-notes/bridge.html
 	rm -f release-notes/import-export.html
-	rm -f ${LAUNCHER_EXE} ${BRIDGE_EXE} ${BRIDGE_EXE_NAME}
-
 
 .PHONY: generate
 generate:
 	go generate ./...
-	$(MAKE) build
+	$(MAKE) add-license
 
 .FORCE:

README.md

@@ -1,5 +1,5 @@
 # Proton Mail Bridge and Import Export app
-Copyright (c) 2023 Proton AG
+Copyright (c) 2022 Proton AG
 
 This repository holds the Proton Mail Bridge and the Proton Mail Import-Export applications.
 For a detailed build information see [BUILDS](./BUILDS.md).
@@ -22,7 +22,22 @@ to start Bridge on startup is enabled by default.
 When the main window is closed, Bridge will continue to run in the
 background.
 
-More details [on the public website](https://proton.me/mail/bridge).
+More details [on the public website](https://protonmail.com/bridge).
+
+## Description Import-Export app
+Proton Mail Import-Export app for importing and exporting messages.
+
+To transfer messages, firstly log in using your Proton Mail credentials.
+For import, expand your account, and pick the address to which to import
+messages from IMAP server or local EML or MBOX files. For export, pick
+the whole account or only a specific address. Then, in both cases,
+configure transfer rules (match source and target mailboxes, set time
+range limits and so on) and hit start. Once the transfer is complete,
+check the results.
+
+More details [on the public website](https://protonmail.com/import-export).
+
+The Import-Export app is developed in separate branch `master-ie`.
 
 ## Launchers
 Launchers are binaries used to run the Proton Mail Bridge or Import-Export apps.
@@ -48,6 +63,9 @@ major problems.
 
 ## Environment Variables
 
+### Bridge application
+- `BRIDGESTRICTMODE`: tells bridge to turn on `bbolt`'s "strict mode" which checks the database after every `Commit`. Set to `1` to enable.
+
 ### Dev build or run
 - `APP_VERSION`: set the bridge app version used during testing or building
 - `PROTONMAIL_ENV`: when set to `dev` it is not using Sentry to report crashes
@@ -59,34 +77,35 @@ major problems.
 - `TAGS`: set build tags for tests
 - `FEATURES`: set feature dir, file or scenario to test
 
-## Folders
-
-There are now three types of system folders which Bridge recognises:
-
-|        | Windows                             | Mac                                                 | Linux                               | Linux (XDG)                           |
-|--------|-------------------------------------|-----------------------------------------------------|-------------------------------------|---------------------------------------|
-| config | %APPDATA%\protonmail\bridge-v3      | ~/Library/Application Support/protonmail/bridge-v3  | ~/.config/protonmail/bridge-v3      | $XDG_CONFIG_HOME/protonmail/bridge-v3 |
-| cache  | %LOCALAPPDATA%\protonmail\bridge-v3 | ~/Library/Caches/protonmail/bridge-v3               | ~/.cache/protonmail/bridge-v3       | $XDG_CACHE_HOME/protonmail/bridge-v3  |
-| data	  | %APPDATA%\protonmail\bridge-v3      | ~/Library/Application Support/protonmail/bridge-v3  | ~/.local/share/protonmail/bridge-v3 | $XDG_DATA_HOME/protonmail/bridge-v3   |
-| temp   | %LOCALAPPDATA%\Temp                 | $TMPDIR if non-empty, else /tmp                     | $TMPDIR if non-empty, else /tmp     | $TMPDIR if non-empty, else /tmp       |
-
-
 
 ## Files
+### Database
+The database stores metadata necessary for presenting messages and mailboxes to an email client:
+- Linux: `~/.cache/protonmail/bridge/<cacheVersion>/mailbox-<userID>.db` (unless `XDG_CACHE_HOME` is set, in which case that is used as your `~`)
+- macOS: `~/Library/Caches/protonmail/bridge/<cacheVersion>/mailbox-<userID>.db`
+- Windows: `%LOCALAPPDATA%\protonmail\bridge\<cacheVersion>\mailbox-<userID>.db`
 
-|                        | Base Dir | Path                       |
-|------------------------|----------|----------------------------|
-| bridge lock file       | cache    | bridge.lock                |
-| bridge-gui lock file   | cache    | bridge-gui.lock            |
-| vault                  | config   | vault.enc                  |
-| gRPC server json       | config   | grpcServerConfig.json      |
-| gRPC client json       | config   | grpcClientConfig_<id>.json |
-| gRPC Focus server json | config   | grpcFocusServerConfig.json |
-| Logs                   | data     | logs                       |
-| gluon DB               | data     | gluon/backend/db           |
-| gluon messages         | data     | gluon/backend/store        |
-| Update files           | data     | updates                    |
-| sentry cache           | data     | sentry_cache               |
-| Mac/Linux File Socket  | temp     | bridge{4_DIGITS}           |
+### Preferences
+User preferences are stored in json at the following location:
+- Linux: `~/.config/protonmail/bridge/prefs.json`
+- macOS: `~/Library/ApplicationSupport/protonmail/bridge/prefs.json`
+- Windows: `%APPDATA%\protonmail\bridge\prefs.json`
 
+### IMAP Cache
+The currently subscribed mailboxes are held in a json file:
+- Linux: `~/.cache/protonmail/bridge/<cacheVersion>/user_info.json` (unless `XDG_CACHE_HOME` is set, in which case that is used as your `~`)
+- macOS: `~/Library/Caches/protonmail/bridge/<cacheVersion>/user_info.json`
+- Windows: `%LOCALAPPDATA%\protonmail\bridge\<cacheVersion>\user_info.json`
+
+### Lock file
+Bridge utilises an on-disk lock to ensure only one instance is run at once. The lock file is here: 
+- Linux: `~/.cache/protonmail/bridge/<cacheVersion>/bridge.lock` (unless `XDG_CACHE_HOME` is set, in which case that is used as your `~`)
+- macOS: `~/Library/Caches/protonmail/bridge/<cacheVersion>/bridge.lock`
+- Windows: `%LOCALAPPDATA%\protonmail\bridge\<cacheVersion>\bridge.lock`
+
+### TLS Certificate and Key
+When bridge first starts, it generates a unique TLS certificate and key file at the following locations:
+- Linux: `~/.config/protonmail/bridge/{cert,key}.pem` (unless `XDG_CONFIG_HOME` is set, in which case that is used as your `~/.config`)
+- macOS: `~/Library/ApplicationSupport/protonmail/bridge/{cert,key}.pem`
+- Windows: `%APPDATA%\protonmail\bridge\{cert,key}.pem`
 

cmd/Desktop-Bridge/main.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -17,15 +17,6 @@
 
 package main
 
-import (
-	"os"
-	"strings"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/app"
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/sirupsen/logrus"
-)
-
 /*
                              ___....___
    ^^                __..-:'':__:..:__:'':-..__
@@ -43,8 +34,41 @@ import (
    ~~^_~^~/   \~^-~^~ _~^-~_^~-^~_^~~-^~_~^~-~_~-^~_^/   \~^ ~~_ ^
 */
 
+import (
+	"os"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/app/base"
+	"github.com/ProtonMail/proton-bridge/v2/internal/app/bridge"
+	"github.com/sirupsen/logrus"
+)
+
+const (
+	appName       = "Proton Mail Bridge"
+	appUsage      = "Proton Mail IMAP and SMTP Bridge"
+	configName    = "bridge"
+	updateURLName = "bridge"
+	keychainName  = "bridge"
+	cacheVersion  = "c11"
+)
+
 func main() {
-	if err := app.New().Run(xslices.Filter(os.Args, func(arg string) bool { return !strings.Contains(arg, "-psn_") })); err != nil {
-		logrus.Fatal(err)
+	base, err := base.New(
+		appName,
+		appUsage,
+		configName,
+		updateURLName,
+		keychainName,
+		cacheVersion,
+	)
+	if err != nil {
+		logrus.WithError(err).Fatal("Failed to create app base")
+	}
+	// Other instance already running.
+	if base == nil {
+		return
+	}
+
+	if err := bridge.New(base).Run(os.Args); err != nil {
+		logrus.WithError(err).Fatal("Bridge exited with error")
 	}
 }

cmd/launcher/main.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -18,224 +18,137 @@
 package main
 
 import (
-	"io"
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
-	"time"
 
 	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
 	"github.com/ProtonMail/gopenpgp/v2/crypto"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/crash"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/sentry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/ProtonMail/proton-bridge/v3/internal/versioner"
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/elastic/go-sysinfo"
-	"github.com/elastic/go-sysinfo/types"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/useragent"
+	"github.com/ProtonMail/proton-bridge/v2/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v2/internal/crash"
+	"github.com/ProtonMail/proton-bridge/v2/internal/locations"
+	"github.com/ProtonMail/proton-bridge/v2/internal/logging"
+	"github.com/ProtonMail/proton-bridge/v2/internal/sentry"
+	"github.com/ProtonMail/proton-bridge/v2/internal/updater"
+	"github.com/ProtonMail/proton-bridge/v2/internal/versioner"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/sys/execabs"
 )
 
 const (
-	appName      = "Proton Mail Launcher"
-	exeName      = "bridge"
-	guiName      = "bridge-gui"
-	launcherName = "launcher"
-
-	FlagCLI                 = "cli"
-	FlagCLIShort            = "c"
-	FlagNonInteractive      = "noninteractive"
-	FlagNonInteractiveShort = "n"
-	FlagLauncher            = "--launcher"
-	FlagWait                = "--wait"
-	FlagSessionID           = "--session-id"
+	appName    = "Proton Mail Launcher"
+	configName = "bridge"
+	exeName    = "proton-bridge"
 )
 
 func main() { //nolint:funlen
-	logrus.SetLevel(logrus.DebugLevel)
-	l := logrus.WithField("launcher_version", constants.Version)
-
-	reporter := sentry.NewReporter(appName, useragent.New())
+	reporter := sentry.NewReporter(appName, constants.Version, useragent.New())
 
 	crashHandler := crash.NewHandler(reporter.ReportException)
-	defer async.HandlePanic(crashHandler)
+	defer crashHandler.HandlePanic()
 
-	locationsProvider, err := locations.NewDefaultProvider(filepath.Join(constants.VendorName, constants.ConfigName))
+	locationsProvider, err := locations.NewDefaultProvider(filepath.Join(constants.VendorName, configName))
 	if err != nil {
-		l.WithError(err).Fatal("Failed to get locations provider")
+		logrus.WithError(err).Fatal("Failed to get locations provider")
 	}
 
-	locations := locations.New(locationsProvider, constants.ConfigName)
+	locations := locations.New(locationsProvider, configName)
 
 	logsPath, err := locations.ProvideLogsPath()
 	if err != nil {
-		l.WithError(err).Fatal("Failed to get logs path")
+		logrus.WithError(err).Fatal("Failed to get logs path")
+	}
+	crashHandler.AddRecoveryAction(logging.DumpStackTrace(logsPath))
+
+	if err := logging.Init(logsPath); err != nil {
+		logrus.WithError(err).Fatal("Failed to setup logging")
 	}
 
-	sessionID := logging.NewSessionID()
-	crashHandler.AddRecoveryAction(logging.DumpStackTrace(logsPath, sessionID, launcherName))
-
-	var closer io.Closer
-	if closer, err = logging.Init(
-		logsPath,
-		sessionID,
-		logging.LauncherShortAppName,
-		logging.DefaultMaxLogFileSize,
-		logging.NoPruning,
-		os.Getenv("VERBOSITY"),
-	); err != nil {
-		l.WithError(err).Fatal("Failed to setup logging")
-	}
-
-	defer func() {
-		_ = logging.Close(closer)
-	}()
+	logging.SetLevel(os.Getenv("VERBOSITY"))
 
 	updatesPath, err := locations.ProvideUpdatesPath()
 	if err != nil {
-		l.WithError(err).Fatal("Failed to get updates path")
+		logrus.WithError(err).Fatal("Failed to get updates path")
 	}
 
 	key, err := crypto.NewKeyFromArmored(updater.DefaultPublicKey)
 	if err != nil {
-		l.WithError(err).Fatal("Failed to create new verification key")
+		logrus.WithError(err).Fatal("Failed to create new verification key")
 	}
 
 	kr, err := crypto.NewKeyRing(key)
 	if err != nil {
-		l.WithError(err).Fatal("Failed to create new verification keyring")
+		logrus.WithError(err).Fatal("Failed to create new verification keyring")
 	}
 
 	versioner := versioner.New(updatesPath)
 
+	exe, err := getPathToUpdatedExecutable(exeName, versioner, kr, reporter)
+	if err != nil {
+		if exe, err = getFallbackExecutable(exeName, versioner); err != nil {
+			logrus.WithError(err).Fatal("Failed to find any launchable executable")
+		}
+	}
+
 	launcher, err := os.Executable()
 	if err != nil {
 		logrus.WithError(err).Fatal("Failed to determine path to launcher")
 	}
 
-	l = l.WithField("launcher_path", launcher)
-
-	args := os.Args[1:]
-
-	exe, err := getPathToUpdatedExecutable(filepath.Base(launcher), versioner, kr)
-	if err != nil {
-		exeToLaunch := guiName
-		if inCLIMode(args) {
-			exeToLaunch = exeName
-		}
-
-		l = l.WithField("exe_to_launch", exeToLaunch)
-		l.WithError(err).Info("No more updates found, looking up bridge executable")
-
-		path, err := versioner.GetExecutableInDirectory(exeToLaunch, filepath.Dir(launcher))
-		if err != nil {
-			l.WithError(err).Fatal("No executable in launcher directory")
-		}
-
-		exe = path
-	}
-
-	l = l.WithField("exe_path", exe)
-
-	args, wait, mainExes := findAndStripWait(args)
-	if wait {
-		for _, mainExe := range mainExes {
-			waitForProcessToFinish(mainExe)
-		}
-	}
-
-	cmd := execabs.Command(exe, appendLauncherPath(launcher, append(args, FlagSessionID, string(sessionID)))...) //nolint:gosec
+	cmd := execabs.Command(exe, appendLauncherPath(launcher, os.Args[1:])...) //nolint:gosec
 
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
-	cmd.Env = os.Environ()
 
 	// On windows, if you use Run(), a terminal stays open; we don't want that.
-	if //goland:noinspection GoBoolExpressions
-	runtime.GOOS == "windows" {
+	if runtime.GOOS == "windows" {
 		err = cmd.Start()
 	} else {
 		err = cmd.Run()
 	}
 
 	if err != nil {
-		l.WithError(err).Fatal("Failed to launch")
+		logrus.WithError(err).Fatal("Failed to launch")
 	}
 }
 
-// appendLauncherPath add launcher path if missing.
 func appendLauncherPath(path string, args []string) []string {
-	if !sliceContains(args, FlagLauncher) {
-		res := append([]string{}, args...)
-		res = append(res, FlagLauncher, path)
-		return res
-	}
-	return args
-}
-
-// sliceContains checks if a value is present in a list.
-func sliceContains[T comparable](list []T, s T) bool {
-	return xslices.Any(list, func(arg T) bool { return arg == s })
-}
-
-// inCLIMode detect if CLI mode is asked.
-func inCLIMode(args []string) bool {
-	return hasFlag(args, FlagCLI) || hasFlag(args, FlagCLIShort) || hasFlag(args, FlagNonInteractive) || hasFlag(args, FlagNonInteractiveShort)
-}
-
-// hasFlag checks if a flag is present in a list.
-func hasFlag(args []string, flag string) bool {
-	return xslices.Any(args, func(arg string) bool { return (arg == "-"+flag) || (arg == "--"+flag) })
-}
-
-// findAndStrip check if a value is present in s list and remove all occurrences of the value from this list.
-func findAndStrip[T comparable](slice []T, v T) (strippedList []T, found bool) {
-	strippedList = xslices.Filter(slice, func(value T) bool {
-		return value != v
-	})
-	return strippedList, len(strippedList) != len(slice)
-}
-
-// findAndStripWait Check for waiter flag get its value and clean them both.
-func findAndStripWait(args []string) ([]string, bool, []string) {
 	res := append([]string{}, args...)
 
 	hasFlag := false
-	values := make([]string, 0)
+
 	for k, v := range res {
-		if v != FlagWait {
+		if v != "--launcher" {
 			continue
 		}
+
+		hasFlag = true
+
 		if k+1 >= len(res) {
 			continue
 		}
-		hasFlag = true
-		values = append(values, res[k+1])
+
+		res[k+1] = path
 	}
 
-	if hasFlag {
-		res, _ = findAndStrip(res, FlagWait)
-		for _, v := range values {
-			res, _ = findAndStrip(res, v)
-		}
+	if !hasFlag {
+		res = append(res, "--launcher", path)
 	}
-	return res, hasFlag, values
+
+	return res
 }
 
 func getPathToUpdatedExecutable(
 	name string,
-	ver *versioner.Versioner,
+	versioner *versioner.Versioner,
 	kr *crypto.KeyRing,
+	reporter *sentry.Reporter,
 ) (string, error) {
-	versions, err := ver.ListVersions()
+	versions, err := versioner.ListVersions()
 	if err != nil {
 		return "", errors.Wrap(err, "failed to list available versions")
 	}
@@ -246,15 +159,15 @@ func getPathToUpdatedExecutable(
 	}
 
 	for _, version := range versions {
-		vlog := logrus.WithFields(logrus.Fields{
-			"version":       constants.Version,
-			"check_version": version,
-			"name":          name,
-		})
+		vlog := logrus.WithField("version", version)
 
 		if err := version.VerifyFiles(kr); err != nil {
 			vlog.WithError(err).Error("Files failed verification and will be removed")
 
+			if err := reporter.ReportMessage(fmt.Sprintf("version %v failed verification: %v", version, err)); err != nil {
+				vlog.WithError(err).Error("Failed to report corrupt update files")
+			}
+
 			if err := version.Remove(); err != nil {
 				vlog.WithError(err).Error("Failed to remove files")
 			}
@@ -279,45 +192,13 @@ func getPathToUpdatedExecutable(
 	return "", errors.New("no available newer versions")
 }
 
-// waitForProcessToFinish waits until the process with the given path is finished.
-func waitForProcessToFinish(exePath string) {
-	for {
-		processes, err := sysinfo.Processes()
-		if err != nil {
-			logrus.WithError(err).Error("Could not determine running processes")
-			return
-		}
+func getFallbackExecutable(name string, versioner *versioner.Versioner) (string, error) {
+	logrus.Info("Searching for fallback executable")
 
-		exeInfo, err := os.Stat(exePath)
-		if err != nil {
-			logrus.WithError(err).WithField("file", exeInfo).Error("Could not retrieve file info")
-			return
-		}
-
-		if xslices.Any(processes, func(process types.Process) bool {
-			info, err := process.Info()
-			if err != nil {
-				logrus.WithError(err).Trace("Could not retrieve process info")
-				return false
-			}
-
-			return sameFile(exeInfo, info.Exe)
-		}) {
-			logrus.Infof("Waiting for %v to finish.", exeInfo.Name())
-			time.Sleep(1 * time.Second)
-			continue
-		}
-
-		return
-	}
-}
-
-func sameFile(info os.FileInfo, path string) bool {
-	pathInfo, err := os.Stat(path)
+	launcher, err := os.Executable()
 	if err != nil {
-		logrus.WithError(err).WithField("file", path).Error("Could not retrieve file info")
-		return false
+		return "", errors.Wrap(err, "failed to determine path to launcher")
 	}
 
-	return os.SameFile(pathInfo, info)
+	return versioner.GetExecutableInDirectory(name, filepath.Dir(launcher))
 }

cmd/launcher/main_test.go

@@ -1,80 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"testing"
-
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSliceContains(t *testing.T) {
-	assert.True(t, sliceContains([]string{"a", "b", "c"}, "a"))
-	assert.True(t, sliceContains([]int{1, 2, 3}, 2))
-	assert.False(t, sliceContains([]string{"a", "b", "c"}, "A"))
-	assert.False(t, sliceContains([]int{1, 2, 3}, 4))
-	assert.False(t, sliceContains([]string{}, "a"))
-	assert.True(t, sliceContains([]string{"a", "a"}, "a"))
-}
-
-func TestFindAndStrip(t *testing.T) {
-	list := []string{"a", "b", "c", "c", "b", "c"}
-
-	result, found := findAndStrip(list, "a")
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{"b", "c", "c", "b", "c"}))
-
-	result, found = findAndStrip(list, "c")
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{"a", "b", "b"}))
-
-	result, found = findAndStrip([]string{"c", "c", "c"}, "c")
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{}))
-
-	result, found = findAndStrip(list, "A")
-	assert.False(t, found)
-	assert.True(t, xslices.Equal(result, list))
-
-	result, found = findAndStrip([]string{}, "a")
-	assert.False(t, found)
-	assert.True(t, xslices.Equal(result, []string{}))
-}
-
-func TestFindAndStripWait(t *testing.T) {
-	result, found, values := findAndStripWait([]string{"a", "b", "c"})
-	assert.False(t, found)
-	assert.True(t, xslices.Equal(result, []string{"a", "b", "c"}))
-	assert.True(t, xslices.Equal(values, []string{}))
-
-	result, found, values = findAndStripWait([]string{"a", "--wait", "b"})
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{"a"}))
-	assert.True(t, xslices.Equal(values, []string{"b"}))
-
-	result, found, values = findAndStripWait([]string{"a", "--wait", "b", "--wait", "c"})
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{"a"}))
-	assert.True(t, xslices.Equal(values, []string{"b", "c"}))
-
-	result, found, values = findAndStripWait([]string{"a", "--wait", "b", "--wait", "c", "--wait", "d"})
-	assert.True(t, found)
-	assert.True(t, xslices.Equal(result, []string{"a"}))
-	assert.True(t, xslices.Equal(values, []string{"b", "c", "d"}))
-}

dist/bridgeMacOS.svg

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg width="100%" height="100%" viewBox="0 0 260 260" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
-    <g>
-        <g transform="matrix(1.27944,0,0,1.35453,-34.9539,-16.0513)">
-            <path d="M40,62.391C40,38.979 58.979,20 82.391,20L177.609,20C201.021,20 220,38.979 220,62.391L220,157.609C220,181.021 201.021,200 177.609,200L82.391,200C58.979,200 40,181.021 40,157.609L40,62.391Z" style="fill:white;fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(1.41874,0,0,1.41874,-55.214,-18.9171)">
-            <path d="M129.748,48.657C101.923,48.657 79.369,71.21 79.369,99.035L79.369,149.747C79.369,155.139 83.74,159.509 89.131,159.509L171.407,159.509C176.22,159.509 180.126,155.604 180.126,150.79L180.126,99.035C180.126,71.214 157.572,48.657 129.748,48.657ZM158.746,98.755L136.726,117.305C132.752,120.655 126.939,120.655 122.965,117.305L100.945,98.755C100.945,83.014 113.708,70.251 129.45,70.251L130.242,70.251C145.983,70.251 158.746,83.014 158.746,98.755Z" style="fill:rgb(109,74,255);fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(1.41874,0,0,1.41874,-55.214,-18.9171)">
-            <path d="M129.748,48.657C101.923,48.657 79.369,71.21 79.369,99.035L79.369,149.748C79.369,155.139 83.74,159.509 89.131,159.509L171.407,159.509C176.22,159.509 180.126,155.604 180.126,150.79L180.126,99.035C180.126,71.214 157.572,48.657 129.748,48.657ZM158.746,98.755L136.726,117.305C132.752,120.655 126.939,120.655 122.965,117.305L100.945,98.755C100.945,83.014 113.708,70.251 129.45,70.251L130.242,70.251C145.983,70.251 158.746,83.014 158.746,98.755Z" style="fill:url(#_Linear1);fill-rule:nonzero;"/>
-        </g>
-        <g transform="matrix(1.41874,0,0,1.41874,-55.214,-18.9171)">
-            <path d="M136.764,117.529C134.468,119.388 128.499,121.99 122.989,117.529C117.479,113.069 106.044,103.208 101.015,98.835L101.041,98.835L100.946,98.756C100.946,83.014 113.709,70.251 129.45,70.251L130.242,70.251C145.984,70.251 158.746,83.014 158.746,98.756L158.652,98.835L158.737,98.835L158.737,159.51L171.407,159.51C176.221,159.51 180.126,155.604 180.126,150.79L180.126,99.035C180.126,71.214 157.573,48.657 129.748,48.657C101.923,48.657 79.37,71.211 79.37,99.035L79.37,102.219L110.526,129.008C112.822,131.195 118.857,134.256 124.629,129.008C130.401,123.761 135.124,119.169 136.764,117.529Z" style="fill:url(#_Radial2);fill-rule:nonzero;"/>
-        </g>
-    </g>
-    <defs>
-        <linearGradient id="_Linear1" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(15.0864,-42.636,42.636,15.0864,82.9769,172.3)"><stop offset="0" style="stop-color:rgb(40,176,232);stop-opacity:1"/><stop offset="1" style="stop-color:rgb(197,183,255);stop-opacity:0"/></linearGradient>
-        <radialGradient id="_Radial2" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="matrix(-94.8157,-85.2706,69.7189,-77.5232,174.186,168.693)"><stop offset="0" style="stop-color:rgb(226,219,255);stop-opacity:1"/><stop offset="1" style="stop-color:rgb(109,74,255);stop-opacity:1"/></radialGradient>
-    </defs>
-</svg>

dist/info.rc

@@ -3,7 +3,7 @@
 
 IDI_ICON1 ICON DISCARDABLE STRINGIZE(ICO_FILE)
 
-#define FILE_COMMENTS "Proton Mail Bridge is a desktop application that runs in the background, encrypting and decrypting messages as they enter and leave your computer."
+#define FILE_COMMENTS "The Bridge is an application that runs on your computer in the background and seamlessly encrypts and decrypts your mail as it enters and leaves your computer."
 #define FILE_DESCRIPTION "Proton Mail Bridge"
 #define INTERNAL_NAME STRINGIZE(EXE_NAME)
 #define PRODUCT_NAME "Proton Mail Bridge for Windows"

dist/proton-bridge.desktop

@@ -3,7 +3,7 @@ Type=Application
 Version=1.1
 Name=Proton Mail Bridge
 GenericName=Proton Mail Bridge for Linux
-Comment=Proton Mail Bridge is a desktop application that runs in the background, encrypting and decrypting messages as they enter and leave your computer.
+Comment=The Bridge is an application that runs on your computer in the background and seamlessly encrypts and decrypts your mail as it enters and leaves your computer.
 Icon=protonmail-bridge
 Exec=protonmail-bridge
 Terminal=false

doc/communication.md

@@ -2,13 +2,13 @@
 
 ## First login and sync
 
-When user logs in to the bridge for the first time, immediately starts the first sync.
+When user logs in to the bridge for the first time, immediatelly starts the first sync.
 First sync downloads all headers of all e-mails and creates database to have proper UIDs
 and indexes for IMAP. See [database](database.md) for more information.
 
 By default, whenever it's possible, sync downloads only all e-mails maiblox which already
 have list of labels so we can construct all mailboxes (inbox, sent, trash, custom folders
-and labels) without need to download each e-mail headers many times.
+and lables) without need to download each e-mail headers many times.
 
 Note that we need to download also bodies to calculate size of the e-mail and set proper
 content type (clients uses content type for guess if e-mail contains attachment)--but only
@@ -22,7 +22,7 @@ client right after adding account.
 
 When account is added to client, client start the sync. This sync will ask Bridge app
 for all headers (done quickly) and then starts to download all bodies and attachment.
-Unfortunately for some e-mail more than once if the same e-mail is in more mailboxes
+Unfortunatelly for some e-mail more than once if the same e-mail is in more mailboxes
 (e.g. inbox and all mail)--there is no way to tell over IMAP it's the same message.
 
 After successful login of client to IMAP, Bridge starts event loop. That periodicly ask
@@ -37,7 +37,7 @@ sequenceDiagram
     Note right of B: Set up PM account<br/>by user
 
     loop First sync
-        B ->> S: Fetch body and attachments
+        B ->> S: Fetch body and attachements
         Note right of B: Build local database<br/>(e-mail UIDs)
     end
 
@@ -58,8 +58,8 @@ sequenceDiagram
         C ->> B: IMAP SELECT directory
         C ->> B: IMAP SEARCH e-mails UIDs
         C ->> B: IMAP FETCH of e-mail UID
-        B ->> S: Fetch body and attachments
-        Note right of B: Decrypt message<br/>and attachment
+        B ->> S: Fetch body and attachements
+        Note right of B: Decrypt message<br/>and attachement
         B ->> C: IMAP response
     end
 ```

doc/updates.md

@@ -1,12 +1,12 @@
 # Update mechanism of Bridge
 
-There are multiple options how to change version of application:
+There are mulitple options how to change version of application:
 * Automatic in-app update
 * Manual in-app update
 * Manual install
 
 In-app update ends with restarting bridge into new version. Automatic in-app
-update is downloading, verifying and installing the new version immediately
+update is downloading, verifying and installing the new version immediatelly
 without user confirmation. For manual in-app update user needs to confirm first.
 Update is done from special update file published on website.
 
@@ -25,7 +25,7 @@ The bridge is installed and executed differently for given OS:
 
 * macOS app does not use launcher
     * No launcher, only one executable
-    * In-App update replaces the bridge files in installation path directly
+    * In-App udpate replaces the bridge files in installation path directly
 
 
 ```mermaid

go.mod

@@ -1,124 +1,85 @@
-module github.com/ProtonMail/proton-bridge/v3
+module github.com/ProtonMail/proton-bridge/v2
 
-go 1.20
+go 1.15
 
+// These dependencies are `replace`d below, so the version numbers should be ignored.
+// They are in a separate require block to highlight this.
 require (
-	github.com/0xAX/notificator v0.0.0-20220220101646-ee9b8921e557
-	github.com/Masterminds/semver/v3 v3.2.0
-	github.com/ProtonMail/gluon v0.17.1-0.20231009084701-3af0474b0b3c
-	github.com/ProtonMail/go-autostart v0.0.0-20210130080809-00ed301c8e9a
-	github.com/ProtonMail/go-proton-api v0.4.1-0.20231011062329-f3b976b7dbca
-	github.com/ProtonMail/gopenpgp/v2 v2.7.3-proton
-	github.com/PuerkitoBio/goquery v1.8.1
-	github.com/abiosoft/ishell v2.0.0+incompatible
-	github.com/allan-simon/go-singleinstance v0.0.0-20210120080615-d0997106ab37
-	github.com/bradenaw/juniper v0.12.0
-	github.com/cucumber/godog v0.12.5
-	github.com/cucumber/messages-go/v16 v16.0.1
 	github.com/docker/docker-credential-helpers v0.6.3
-	github.com/elastic/go-sysinfo v1.8.1
-	github.com/emersion/go-imap v1.2.1
-	github.com/emersion/go-imap-id v0.0.0-20190926060100-f94a56b9ecde
-	github.com/emersion/go-message v0.16.0
-	github.com/emersion/go-sasl v0.0.0-20220912192320-0145f2c60ead
-	github.com/emersion/go-smtp v0.15.1-0.20221021114529-49b17434419d
-	github.com/fatih/color v1.13.0
-	github.com/getsentry/sentry-go v0.15.0
-	github.com/go-resty/resty/v2 v2.7.0
-	github.com/godbus/dbus v4.1.0+incompatible
-	github.com/golang/mock v1.6.0
-	github.com/google/go-cmp v0.5.9
-	github.com/google/uuid v1.3.0
-	github.com/hashicorp/go-multierror v1.1.1
-	github.com/jaytaylor/html2text v0.0.0-20211105163654-bc68cce691ba
-	github.com/keybase/go-keychain v0.0.0
-	github.com/miekg/dns v1.1.50
-	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58
-	github.com/pkg/errors v0.9.1
-	github.com/pkg/profile v1.7.0
-	github.com/sirupsen/logrus v1.9.2
-	github.com/stretchr/testify v1.8.3
-	github.com/urfave/cli/v2 v2.24.4
-	github.com/vmihailenco/msgpack/v5 v5.3.5
-	go.uber.org/goleak v1.2.1
-	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1
-	golang.org/x/net v0.10.0
-	golang.org/x/sys v0.8.0
-	golang.org/x/text v0.9.0
-	google.golang.org/grpc v1.53.0
-	google.golang.org/protobuf v1.30.0
-	howett.net/plist v1.0.0
+	github.com/emersion/go-imap v1.0.6
 )
 
 require (
+	github.com/0xAX/notificator v0.0.0-20191016112426-3962a5ea8da1
+	github.com/Masterminds/semver/v3 v3.1.0
 	github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf // indirect
-	github.com/ProtonMail/go-crypto v0.0.0-20230717121622-edf196117233 // indirect
-	github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // indirect
-	github.com/ProtonMail/go-srp v0.0.7 // indirect
+	github.com/ProtonMail/go-autostart v0.0.0-20181114175602-c5272053443a
+	github.com/ProtonMail/go-crypto v0.0.0-20220623141421-5afb4c282135
+	github.com/ProtonMail/go-imap-id v0.0.0-20190926060100-f94a56b9ecde
+	github.com/ProtonMail/go-rfc5322 v0.8.0
+	github.com/ProtonMail/go-srp v0.0.5
+	github.com/ProtonMail/go-vcard v0.0.0-20180326232728-33aaa0a0c8a5
+	github.com/ProtonMail/gopenpgp/v2 v2.4.7
+	github.com/PuerkitoBio/goquery v1.5.1
+	github.com/abiosoft/ishell v2.0.0+incompatible
 	github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db // indirect
-	github.com/andybalholm/cascadia v1.3.2 // indirect
-	github.com/bytedance/sonic v1.9.1 // indirect
-	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
-	github.com/chzyer/test v1.0.0 // indirect
-	github.com/cloudflare/circl v1.3.3 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/cronokirby/saferith v0.33.0 // indirect
-	github.com/cucumber/gherkin-go/v19 v19.0.3 // indirect
-	github.com/danieljoos/wincred v1.1.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/allan-simon/go-singleinstance v0.0.0-20160830203053-79edcfdc2dfc
+	github.com/chzyer/logex v1.1.10 // indirect
+	github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 // indirect
+	github.com/cucumber/godog v0.12.1
+	github.com/cucumber/messages-go/v16 v16.0.1
+	github.com/elastic/go-sysinfo v1.7.1
 	github.com/elastic/go-windows v1.0.1 // indirect
-	github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 // indirect
-	github.com/emersion/go-vcard v0.0.0-20230331202150-f3d26859ccd3 // indirect
-	github.com/felixge/fgprof v0.9.3 // indirect
+	github.com/emersion/go-imap-appendlimit v0.0.0-20190308131241-25671c986a6a
+	github.com/emersion/go-imap-move v0.0.0-20190710073258-6e5a51a5b342
+	github.com/emersion/go-imap-quota v0.0.0-20210203125329-619074823f3c
+	github.com/emersion/go-imap-unselect v0.0.0-20171113212723-b985794e5f26
+	github.com/emersion/go-message v0.12.1-0.20201221184100-40c3f864532b
+	github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21
+	github.com/emersion/go-smtp v0.14.0
+	github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594
+	github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5 // indirect
+	github.com/fatih/color v1.9.0
 	github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
-	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/gin-gonic/gin v1.9.1 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.14.0 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/gofrs/uuid v4.3.0+incompatible // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect
-	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
-	github.com/hashicorp/go-memdb v1.3.3 // indirect
-	github.com/hashicorp/golang-lru v0.5.4 // indirect
-	github.com/joeshaw/multierror v0.0.0-20140124173710-69b34d4ec901 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
-	github.com/leodido/go-urn v1.2.4 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.17 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
-	github.com/pierrec/lz4/v4 v4.1.17 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/procfs v0.8.0 // indirect
-	github.com/rivo/uniseg v0.4.2 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/getsentry/sentry-go v0.12.0
+	github.com/go-resty/resty/v2 v2.6.0
+	github.com/godbus/dbus v4.1.0+incompatible
+	github.com/golang/mock v1.4.4
+	github.com/google/go-cmp v0.5.5
+	github.com/google/uuid v1.1.1
+	github.com/hashicorp/go-multierror v1.1.0
+	github.com/jameskeane/bcrypt v0.0.0-20120420032655-c3cd44c1e20f // indirect
+	github.com/jaytaylor/html2text v0.0.0-20200412013138-3577fbdbcff7
+	github.com/keybase/go-keychain v0.0.0
+	github.com/kr/text v0.2.0 // indirect
+	github.com/logrusorgru/aurora v2.0.3+incompatible
+	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/miekg/dns v1.1.41
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/nsf/jsondiff v0.0.0-20200515183724-f29ed568f4ce
+	github.com/olekukonko/tablewriter v0.0.4 // indirect
+	github.com/pkg/errors v0.9.1
+	github.com/prometheus/procfs v0.7.3 // indirect
+	github.com/ricochet2200/go-disk-usage/du v0.0.0-20210707232629-ac9918953285
+	github.com/sirupsen/logrus v1.7.0
 	github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.11 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	golang.org/x/arch v0.3.0 // indirect
-	golang.org/x/crypto v0.9.0 // indirect
-	golang.org/x/mod v0.8.0 // indirect
-	golang.org/x/sync v0.2.0 // indirect
-	golang.org/x/tools v0.6.0 // indirect
-	google.golang.org/genproto v0.0.0-20230221151758-ace64dc21148 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	github.com/stretchr/testify v1.7.0
+	github.com/therecipe/qt v0.0.0-20200701200531-7f61353ee73e
+	github.com/therecipe/qt/internal/binding/files/docs/5.12.0 v0.0.0-20200904063919-c0c124a5770d // indirect
+	github.com/therecipe/qt/internal/binding/files/docs/5.13.0 v0.0.0-20200904063919-c0c124a5770d // indirect
+	github.com/urfave/cli/v2 v2.2.0
+	github.com/vmihailenco/msgpack/v5 v5.1.3
+	go.etcd.io/bbolt v1.3.6
+	golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d // indirect
+	golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4
+	golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b
+	golang.org/x/text v0.3.7
+	howett.net/plist v1.0.0
 )
 
 replace (
 	github.com/docker/docker-credential-helpers => github.com/ProtonMail/docker-credential-helpers v1.1.0
-	github.com/emersion/go-message => github.com/ProtonMail/go-message v0.13.1-0.20230526094639-b62c999c85b7
-	github.com/keybase/go-keychain => github.com/cuthix/go-keychain v0.0.0-20230517073537-fc1740a83768
+	github.com/emersion/go-imap => github.com/ProtonMail/go-imap v0.0.0-20201228133358-4db68cea0cac
+	github.com/emersion/go-message => github.com/ProtonMail/go-message v0.0.0-20210611055058-fabeff2ec753
+	github.com/keybase/go-keychain => github.com/cuthix/go-keychain v0.0.0-20220405075754-31e7cee908fe
 )

go.sum

@@ -11,216 +11,231 @@ cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqCl
 cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
 cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/0xAX/notificator v0.0.0-20220220101646-ee9b8921e557 h1:l6surSnJ3RP4qA1qmKJ+hQn3UjytosdoG27WGjrDlVs=
-github.com/0xAX/notificator v0.0.0-20220220101646-ee9b8921e557/go.mod h1:sTrmvD/TxuypdOERsDOS7SndZg0rzzcCi1b6wQMXUYM=
+github.com/0xAX/notificator v0.0.0-20191016112426-3962a5ea8da1 h1:j9HaafapDbPbGRDku6e/HRs6KBMcKHiWcm1/9Sbxnl4=
+github.com/0xAX/notificator v0.0.0-20191016112426-3962a5ea8da1/go.mod h1:NtXa9WwQsukMHZpjNakTTz0LArxvGYdPA9CjIcUSZ6s=
+github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g=
-github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=
+github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno=
+github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo=
+github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
+github.com/Masterminds/semver/v3 v3.1.0 h1:Y2lUDsFKVRSYGojLJ1yLxSXdMmMYTYls0rCvoqmMUQk=
+github.com/Masterminds/semver/v3 v3.1.0/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/ProtonMail/bcrypt v0.0.0-20210511135022-227b4adcab57 h1:pHA4K54ifoogVLunGGHi3xyF5Nz4x+Uh3dJuy3NwGQQ=
 github.com/ProtonMail/bcrypt v0.0.0-20210511135022-227b4adcab57/go.mod h1:HecWFHognK8GfRDGnFQbW/LiV7A3MX3gZVs45vk5h8I=
 github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf h1:yc9daCCYUefEs69zUkSzubzjBbL+cmOXgnmt9Fyd9ug=
 github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf/go.mod h1:o0ESU9p83twszAU8LBeJKFAAMX14tISa0yk4Oo5TOqo=
 github.com/ProtonMail/docker-credential-helpers v1.1.0 h1:+kvUIpwWcbtP3WFv5sSvkFn/XLzSqPOB5AAthuk9xPk=
 github.com/ProtonMail/docker-credential-helpers v1.1.0/go.mod h1:mK0aBveCxhnQ756AmaTfXMZDeULvheYVhF/MWMErN5g=
-github.com/ProtonMail/gluon v0.17.1-0.20231009084701-3af0474b0b3c h1:gUDu4pOswgbou0QczfreNiXQFrmvVlpSh8Q+vft/JvI=
-github.com/ProtonMail/gluon v0.17.1-0.20231009084701-3af0474b0b3c/go.mod h1:Og5/Dz1MiGpCJn51XujZwxiLG7WzvvjE5PRpZBQmAHo=
-github.com/ProtonMail/go-autostart v0.0.0-20210130080809-00ed301c8e9a h1:D+aZah+k14Gn6kmL7eKxoo/4Dr/lK3ChBcwce2+SQP4=
-github.com/ProtonMail/go-autostart v0.0.0-20210130080809-00ed301c8e9a/go.mod h1:oTGdE7/DlWIr23G0IKW3OXK9wZ5Hw1GGiaJFccTvZi4=
-github.com/ProtonMail/go-crypto v0.0.0-20230321155629-9a39f2531310/go.mod h1:8TI4H3IbrackdNgv+92dI+rhpCaLqM0IfpgCgenFvRE=
-github.com/ProtonMail/go-crypto v0.0.0-20230717121622-edf196117233 h1:bdoKdh0f66/lrgVfYlxw0aqISY/KOqXmFJyGt7rGmnc=
-github.com/ProtonMail/go-crypto v0.0.0-20230717121622-edf196117233/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
-github.com/ProtonMail/go-message v0.13.1-0.20230526094639-b62c999c85b7 h1:+j+Kd/DyZ/qGfMT9htAT7HxqIEbZHsatsx+m8AoV6fc=
-github.com/ProtonMail/go-message v0.13.1-0.20230526094639-b62c999c85b7/go.mod h1:NBAn21zgCJ/52WLDyed18YvYFm5tEoeDauubFqLokM4=
-github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f h1:tCbYj7/299ekTTXpdwKYF8eBlsYsDVoggDAuAjoK66k=
-github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f/go.mod h1:gcr0kNtGBqin9zDW9GOHcVntrwnjrK+qdJ06mWYBybw=
-github.com/ProtonMail/go-proton-api v0.4.1-0.20231011062329-f3b976b7dbca h1:nO/xuvyEgWWLo2cBAqfxCHh7Ri0ofV3PXnTOfk0QcyI=
-github.com/ProtonMail/go-proton-api v0.4.1-0.20231011062329-f3b976b7dbca/go.mod h1:IGVXKy6NLHt4WeWiOnAFmSsXRpd6elkjDZMtr5vBLJ8=
-github.com/ProtonMail/go-srp v0.0.7 h1:Sos3Qk+th4tQR64vsxGIxYpN3rdnG9Wf9K4ZloC1JrI=
-github.com/ProtonMail/go-srp v0.0.7/go.mod h1:giCp+7qRnMIcCvI6V6U3S1lDDXDQYx2ewJ6F/9wdlJk=
-github.com/ProtonMail/gopenpgp/v2 v2.7.3-proton h1:wuAxBUU9qF2wyDVJprn/2xPDx000eol5gwlKbOUYY88=
-github.com/ProtonMail/gopenpgp/v2 v2.7.3-proton/go.mod h1:omVkSsfPAhmptzPF/piMXb16wKIWUvVhZbVW7sJKh0A=
-github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
-github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
+github.com/ProtonMail/go-autostart v0.0.0-20181114175602-c5272053443a h1:fXK2KsfnkBV9Nh+9SKzHchYjuE9s0vI20JG1mbtEAcc=
+github.com/ProtonMail/go-autostart v0.0.0-20181114175602-c5272053443a/go.mod h1:oTGdE7/DlWIr23G0IKW3OXK9wZ5Hw1GGiaJFccTvZi4=
+github.com/ProtonMail/go-crypto v0.0.0-20210428141323-04723f9f07d7/go.mod h1:z4/9nQmJSSwwds7ejkxaJwO37dru3geImFUdJlaLzQo=
+github.com/ProtonMail/go-crypto v0.0.0-20211221144345-a4f6767435ab h1:5FiL/TCaiKCss/BLMIACDxxadYrx767l9kh0qYX+sLQ=
+github.com/ProtonMail/go-crypto v0.0.0-20211221144345-a4f6767435ab/go.mod h1:z4/9nQmJSSwwds7ejkxaJwO37dru3geImFUdJlaLzQo=
+github.com/ProtonMail/go-crypto v0.0.0-20220113124808-70ae35bab23f/go.mod h1:z4/9nQmJSSwwds7ejkxaJwO37dru3geImFUdJlaLzQo=
+github.com/ProtonMail/go-crypto v0.0.0-20220623141421-5afb4c282135 h1:xDc/cFH/hwyr9KyWc0sm26lpsscqtfZBvU8NpRLHwJ0=
+github.com/ProtonMail/go-crypto v0.0.0-20220623141421-5afb4c282135/go.mod h1:z4/9nQmJSSwwds7ejkxaJwO37dru3geImFUdJlaLzQo=
+github.com/ProtonMail/go-imap v0.0.0-20201228133358-4db68cea0cac h1:2xU3QncAiS/W3UlWZTkbNKW5WkLzk6Egl1T0xX+sbjs=
+github.com/ProtonMail/go-imap v0.0.0-20201228133358-4db68cea0cac/go.mod h1:yKASt+C3ZiDAiCSssxg9caIckWF/JG7ZQTO7GAmvicU=
+github.com/ProtonMail/go-imap-id v0.0.0-20190926060100-f94a56b9ecde h1:5koQozTDELymYOyFbQ/VSubexAEXzDR8qGM5mO8GRdw=
+github.com/ProtonMail/go-imap-id v0.0.0-20190926060100-f94a56b9ecde/go.mod h1:795VPXcRUIQ9JyMNHP4el582VokQfippgjkQP3Gk0r0=
+github.com/ProtonMail/go-message v0.0.0-20210611055058-fabeff2ec753 h1:I8IsYA297x0QLU80G5I6aLYUu3JYNSpo8j5fkXtFDW0=
+github.com/ProtonMail/go-message v0.0.0-20210611055058-fabeff2ec753/go.mod h1:NBAn21zgCJ/52WLDyed18YvYFm5tEoeDauubFqLokM4=
+github.com/ProtonMail/go-mime v0.0.0-20190923161245-9b5a4261663a h1:W6RrgN/sTxg1msqzFFb+G80MFmpjMw61IU+slm+wln4=
+github.com/ProtonMail/go-mime v0.0.0-20190923161245-9b5a4261663a/go.mod h1:NYt+V3/4rEeDuaev/zw1zCq8uqVEuPHzDPo3OZrlGJ4=
+github.com/ProtonMail/go-mime v0.0.0-20220302105931-303f85f7fe0f h1:CGq7OieOz3wyQJ1fO8S0eO9TCW1JyvLrf8fhzz1i8ko=
+github.com/ProtonMail/go-mime v0.0.0-20220302105931-303f85f7fe0f/go.mod h1:NYt+V3/4rEeDuaev/zw1zCq8uqVEuPHzDPo3OZrlGJ4=
+github.com/ProtonMail/go-rfc5322 v0.8.0 h1:7emrf75n3CDIduQflx7aT1nJa5h/kGsiFKUYX/+IAkU=
+github.com/ProtonMail/go-rfc5322 v0.8.0/go.mod h1:BwpTbkJxkMGkc+pC84AXZnwuWOisEULBpfPIyIKS/Us=
+github.com/ProtonMail/go-srp v0.0.1 h1:J0O9Zb5XTC6iDrB7feH41cu+TUEB+l7uHctXIK6oS2o=
+github.com/ProtonMail/go-srp v0.0.1/go.mod h1:Uvv5cqSGCs8MTZ8sbKiCkBnaB6/OA3eq2mc77tl2VVA=
+github.com/ProtonMail/go-srp v0.0.5 h1:xhUioxZgDbCnpo9JehyFhwwsn9JLWkUGfB0oiKXgiGg=
+github.com/ProtonMail/go-srp v0.0.5/go.mod h1:06iYHtLXW8vjLtccWj++x3MKy65sIT8yZd7nrJF49rs=
+github.com/ProtonMail/go-vcard v0.0.0-20180326232728-33aaa0a0c8a5 h1:Uga1DHFN4GUxuDQr0F71tpi8I9HqPIlZodZAI1lR6VQ=
+github.com/ProtonMail/go-vcard v0.0.0-20180326232728-33aaa0a0c8a5/go.mod h1:oeP9CMN+ajWp5jKp1kue5daJNwMMxLF+ujPaUIoJWlA=
+github.com/ProtonMail/gopenpgp/v2 v2.4.1 h1:b3El0zabaKi73u4sRnb3hOOUczuKuYpN8wnp7wRsZSc=
+github.com/ProtonMail/gopenpgp/v2 v2.4.1/go.mod h1:RFjoVjfhV8f78tjz/fLrp/OXkugL3QmWsiJq/fsQYA4=
+github.com/ProtonMail/gopenpgp/v2 v2.4.7 h1:V3xeelvXgJiZXZuPtSSE+uYbtPw4RmbmyPqXDAESPhg=
+github.com/ProtonMail/gopenpgp/v2 v2.4.7/go.mod h1:ZW1KxHNG6q5LMgFKf9Ap/d2eVYeyGf5+fAUEAjJWtmo=
+github.com/PuerkitoBio/goquery v1.5.1 h1:PSPBGne8NIUWw+/7vFBV+kG2J/5MOjbzc7154OaKCSE=
+github.com/PuerkitoBio/goquery v1.5.1/go.mod h1:GsLWisAFVj4WgDibEWF4pvYnkVQBpKBKeU+7zCJoLcc=
+github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
 github.com/abiosoft/ishell v2.0.0+incompatible h1:zpwIuEHc37EzrsIYah3cpevrIc8Oma7oZPxr03tlmmw=
 github.com/abiosoft/ishell v2.0.0+incompatible/go.mod h1:HQR9AqF2R3P4XXpMpI0NAzgHf/aS6+zVXRj14cVk9qg=
 github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db h1:CjPUSXOiYptLbTdr1RceuZgSFDQ7U15ITERUGrUORx8=
 github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db/go.mod h1:rB3B4rKii8V21ydCbIzH5hZiCQE7f5E9SzUb/ZZx530=
+github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/allan-simon/go-singleinstance v0.0.0-20210120080615-d0997106ab37 h1:28uU3TtuvQ6KRndxg9TrC868jBWmSKgh0GTXkACCXmA=
-github.com/allan-simon/go-singleinstance v0.0.0-20210120080615-d0997106ab37/go.mod h1:6AXRstqK+32jeFmw89QGL2748+dj34Av4xc/I9oo9BY=
-github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
-github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
-github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
+github.com/allan-simon/go-singleinstance v0.0.0-20160830203053-79edcfdc2dfc h1:mZca0/HZ/XWXP9txkfdl2GH6mUzBqAlyJz3u5Lg8fuA=
+github.com/allan-simon/go-singleinstance v0.0.0-20160830203053-79edcfdc2dfc/go.mod h1:qqsTQiwdyqxU05iDCsi0oN3P4nrVxAmn8xCtODDSf/U=
+github.com/andybalholm/cascadia v1.1.0 h1:BuuO6sSfQNFRu1LppgbD25Hr2vLYW25JvxHs5zzsLTo=
+github.com/andybalholm/cascadia v1.1.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
+github.com/antlr/antlr4 v0.0.0-20201029161626-9a95f0cc3d7c h1:j/C2kxPfyE0d87/ggAjIsCV5Cdkqmjb+O0W8W+1J+IY=
+github.com/antlr/antlr4 v0.0.0-20201029161626-9a95f0cc3d7c/go.mod h1:T7PbCXFs94rrTttyxjbyT5+/1V8T2TYDejxUfHJjw1Y=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
-github.com/bradenaw/juniper v0.12.0 h1:Q/7icpPQD1nH/La5DobQfNEtwyrBSiSu47jOQx7lJEM=
-github.com/bradenaw/juniper v0.12.0/go.mod h1:Z2B7aJlQ7xbfWsnMLROj5t/5FQ94/MkIdKC30J4WvzI=
-github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
-github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
-github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
-github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
-github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
-github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
-github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
-github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 h1:q763qf9huN11kDQavWsoZXJNW3xEE4JJyHa5Q25/sd8=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
-github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I=
-github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs=
-github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
+github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cronokirby/saferith v0.31.0 h1:TIlhldetKLeGAb19bZvWiuwQEzfzwSPthDEyJ9Ah8xs=
+github.com/cronokirby/saferith v0.31.0/go.mod h1:QKJhjoqUtBsXCAVEjw38mFqoi7DebT7kthcD7UzbnoA=
 github.com/cronokirby/saferith v0.33.0 h1:TgoQlfsD4LIwx71+ChfRcIpjkw+RPOapDEVxa+LhwLo=
 github.com/cronokirby/saferith v0.33.0/go.mod h1:QKJhjoqUtBsXCAVEjw38mFqoi7DebT7kthcD7UzbnoA=
 github.com/cucumber/gherkin-go/v19 v19.0.3 h1:mMSKu1077ffLbTJULUfM5HPokgeBcIGboyeNUof1MdE=
 github.com/cucumber/gherkin-go/v19 v19.0.3/go.mod h1:jY/NP6jUtRSArQQJ5h1FXOUgk5fZK24qtE7vKi776Vw=
-github.com/cucumber/godog v0.12.5 h1:FZIy6VCfMbmGHts9qd6UjBMT9abctws/pQYO/ZcwOVs=
-github.com/cucumber/godog v0.12.5/go.mod h1:u6SD7IXC49dLpPN35kal0oYEjsXZWee4pW6Tm9t5pIc=
+github.com/cucumber/godog v0.12.1 h1:IhWVYFKDReM5WsuA9AuRLRPWOyvFNO9UBUKrNfLPais=
+github.com/cucumber/godog v0.12.1/go.mod h1:u6SD7IXC49dLpPN35kal0oYEjsXZWee4pW6Tm9t5pIc=
 github.com/cucumber/messages-go/v16 v16.0.0/go.mod h1:EJcyR5Mm5ZuDsKJnT2N9KRnBK30BGjtYotDKpwQ0v6g=
 github.com/cucumber/messages-go/v16 v16.0.1 h1:fvkpwsLgnIm0qugftrw2YwNlio+ABe2Iu94Ap8GMYIY=
 github.com/cucumber/messages-go/v16 v16.0.1/go.mod h1:EJcyR5Mm5ZuDsKJnT2N9KRnBK30BGjtYotDKpwQ0v6g=
-github.com/cuthix/go-keychain v0.0.0-20230517073537-fc1740a83768 h1:Jrcoxtrk4qpuzKIYPlEkjIK0M+bABs0oW2QzrOuwlzk=
-github.com/cuthix/go-keychain v0.0.0-20230517073537-fc1740a83768/go.mod h1:ZoZU1fnBy3mOLWr3Pg+Y2+nTKtu6ypDte2kZg9HvSwY=
+github.com/cuthix/go-keychain v0.0.0-20220405075754-31e7cee908fe h1:KRj3wdvA9yE92prNmOjS7x5DOqoyjxqdE30qnrmTasc=
+github.com/cuthix/go-keychain v0.0.0-20220405075754-31e7cee908fe/go.mod h1:ZoZU1fnBy3mOLWr3Pg+Y2+nTKtu6ypDte2kZg9HvSwY=
+github.com/danieljoos/wincred v1.1.0 h1:3RNcEpBg4IhIChZdFRSdlQt1QjCp1sMAPIrOnm7Yf8g=
 github.com/danieljoos/wincred v1.1.0/go.mod h1:XYlo+eRTsVA9aHGp7NGjFkPla4m+DCL7hqDjlFjiygg=
-github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0=
-github.com/danieljoos/wincred v1.1.2/go.mod h1:GijpziifJoIBfYh+S7BbkdUTU4LfM+QnGqR5Vl2tAx0=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/elastic/go-sysinfo v1.8.1 h1:4Yhj+HdV6WjbCRgGdZpPJ8lZQlXZLKDAeIkmQ/VRvi4=
-github.com/elastic/go-sysinfo v1.8.1/go.mod h1:JfllUnzoQV/JRYymbH3dO1yggI3mV2oTKSXsDHM+uIM=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
+github.com/elastic/go-sysinfo v1.7.1 h1:Wx4DSARcKLllpKT2TnFVdSUJOsybqMYCNQZq1/wO+s0=
+github.com/elastic/go-sysinfo v1.7.1/go.mod h1:i1ZYdU10oLNfRzq4vq62BEwD2fH8KaWh6eh0ikPT9F0=
+github.com/elastic/go-windows v1.0.0/go.mod h1:TsU0Nrp7/y3+VwE82FoZF8gC/XFg/Elz6CcloAxnPgU=
 github.com/elastic/go-windows v1.0.1 h1:AlYZOldA+UJ0/2nBuqWdo90GFCgG9xuyw9SYzGUtJm0=
 github.com/elastic/go-windows v1.0.1/go.mod h1:FoVvqWSun28vaDQPbj2Elfc0JahhPB7WQEGa3c814Ss=
-github.com/emersion/go-imap v1.2.1 h1:+s9ZjMEjOB8NzZMVTM3cCenz2JrQIGGo5j1df19WjTA=
-github.com/emersion/go-imap v1.2.1/go.mod h1:Qlx1FSx2FTxjnjWpIlVNEuX+ylerZQNFE5NsmKFSejY=
-github.com/emersion/go-imap-id v0.0.0-20190926060100-f94a56b9ecde h1:43mBoVwooyLm1+1YVf5nvn1pSFWhw7rOpcrp1Jg/qk0=
-github.com/emersion/go-imap-id v0.0.0-20190926060100-f94a56b9ecde/go.mod h1:sPwp0FFboaK/bxsrUz1lNrDMUCsZUsKC5YuM4uRVRVs=
+github.com/emersion/go-imap-appendlimit v0.0.0-20190308131241-25671c986a6a h1:bMdSPm6sssuOFpIaveu3XGAijMS3Tq2S3EqFZmZxidc=
+github.com/emersion/go-imap-appendlimit v0.0.0-20190308131241-25671c986a6a/go.mod h1:ikgISoP7pRAolqsVP64yMteJa2FIpS6ju88eBT6K1yQ=
+github.com/emersion/go-imap-move v0.0.0-20190710073258-6e5a51a5b342 h1:5p1t3e1PomYgLWwEwhwEU5kVBwcyAcVrOpexv8AeZx0=
+github.com/emersion/go-imap-move v0.0.0-20190710073258-6e5a51a5b342/go.mod h1:QuMaZcKFDVI0yCrnAbPLfbwllz1wtOrZH8/vZ5yzp4w=
+github.com/emersion/go-imap-quota v0.0.0-20210203125329-619074823f3c h1:khcEdu1yFiZjBgi7gGnQiLhpSgghJ0YTnKD0l4EUqqc=
+github.com/emersion/go-imap-quota v0.0.0-20210203125329-619074823f3c/go.mod h1:iApyhIQBiU4XFyr+3kdJyyGqle82TbQyuP2o+OZHrV0=
+github.com/emersion/go-imap-unselect v0.0.0-20171113212723-b985794e5f26 h1:FiSb8+XBQQSkcX3ubr+1tAtlRJBYaFmRZqOAweZ9Wy8=
+github.com/emersion/go-imap-unselect v0.0.0-20171113212723-b985794e5f26/go.mod h1:+gnnZx3Mg3MnCzZrv0eZdp5puxXQUgGT/6N6L7ShKfM=
+github.com/emersion/go-sasl v0.0.0-20191210011802-430746ea8b9b/go.mod h1:G/dpzLu16WtQpBfQ/z3LYiYJn3ZhKSGWn83fyoyQe/k=
+github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21 h1:OJyUGMJTzHTd1XQp98QTaHernxMYzRaOasRir9hUlFQ=
 github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ=
-github.com/emersion/go-sasl v0.0.0-20220912192320-0145f2c60ead h1:fI1Jck0vUrXT8bnphprS1EoVRe2Q5CKCX8iDlpqjQ/Y=
-github.com/emersion/go-sasl v0.0.0-20220912192320-0145f2c60ead/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ=
-github.com/emersion/go-smtp v0.15.1-0.20221021114529-49b17434419d h1:hFRM6zCBSc+Xa0rBOqSlG6Qe9dKC/2vLhGAuZlWxTsc=
-github.com/emersion/go-smtp v0.15.1-0.20221021114529-49b17434419d/go.mod h1:qm27SGYgoIPRot6ubfQ/GpiPy/g3PaZAVRxiO/sDUgQ=
+github.com/emersion/go-smtp v0.14.0 h1:RYW203p+EcPjL8Z/ZpT9lZ6iOc8MG1MQzEx1UKEkXlA=
+github.com/emersion/go-smtp v0.14.0/go.mod h1:qm27SGYgoIPRot6ubfQ/GpiPy/g3PaZAVRxiO/sDUgQ=
 github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 h1:IbFBtwoTQyw0fIM5xv1HF+Y+3ZijDR839WMulgxCcUY=
 github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594/go.mod h1:aqO8z8wPrjkscevZJFVE1wXJrLpC5LtJG7fqLOsPb2U=
-github.com/emersion/go-vcard v0.0.0-20230331202150-f3d26859ccd3 h1:hQ1wTMaKcGfobYRT88RM8NFNyX+IQHvagkm/tqViU98=
-github.com/emersion/go-vcard v0.0.0-20230331202150-f3d26859ccd3/go.mod h1:HMJKR5wlh/ziNp+sHEDV2ltblO4JD2+IdDOWtGcQBTM=
+github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5 h1:n9qx98xiS5V4x2WIpPC2rr9mUM5ri9r/YhCEKbhCHro=
+github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5/go.mod h1:WIi9g8OKJQHXtQbx7GExlo6UAFaui9WDMYabJ+Be4WI=
+github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
+github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
-github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
-github.com/felixge/fgprof v0.9.3 h1:VvyZxILNuCiUCSXtPtYmmtGvb65nqXh2QFWc0Wpf2/g=
-github.com/felixge/fgprof v0.9.3/go.mod h1:RdbpDgzqYVh/T9fPELJyV7EYJuHB55UTEULNun8eiPw=
+github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BMXYYRWTLOJKlh+lOBt6nUQgXAfB7oVIQt5cNreqSLI=
 github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:rZfgFAXFS/z/lEd6LJmf9HVZ1LkgYiHx5pHhV5DR16M=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
-github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
-github.com/getsentry/sentry-go v0.15.0 h1:CP9bmA7pralrVUedYZsmIHWpq/pBtXTSew7xvVpfLaA=
-github.com/getsentry/sentry-go v0.15.0/go.mod h1:RZPJKSw+adu8PBNygiri/A98FqVr2HtRckJk9XVxJ9I=
+github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
+github.com/getsentry/sentry-go v0.12.0 h1:era7g0re5iY13bHSdN/xMkyV+5zZppjRVQhZrXCaEIk=
+github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
-github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
-github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
-github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
+github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
+github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
+github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
-github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
-github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
-github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
-github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
-github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
-github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY=
-github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I=
+github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8=
+github.com/go-resty/resty/v2 v2.6.0 h1:joIR5PNLM2EFqqESUjCMGXrWmXNHEU9CEiK813oKYS4=
+github.com/go-resty/resty/v2 v2.6.0/go.mod h1:PwvJS6hvaPkjtjNg9ph+VrSD92bi5Zq73w/BIH7cC3Q=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
-github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
+github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/godbus/dbus v4.1.0+incompatible h1:WqqLRTsQic3apZUK9qC5sGNfXthmPXzUZ7nQPrNITa4=
 github.com/godbus/dbus v4.1.0+incompatible/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
+github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
 github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/gofrs/uuid v4.3.0+incompatible h1:CaSVZxm5B+7o45rtab4jC2G37WGYX1zQfuU2i6DSvnc=
-github.com/gofrs/uuid v4.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
-github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20211214055906-6f57359322fd h1:1FjCyPC+syAzJ5/2S8fqdZK1R22vvA0J7JZKcuOIQ7Y=
-github.com/google/pprof v0.0.0-20211214055906-6f57359322fd/go.mod h1:KgnwoLYCZ8IQu3XUZ8Nc/bM9CCZFOyjUNOSygVozoDg=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gopherjs/gopherjs v0.0.0-20190411002643-bd77b112433e h1:XWcjeEtTFTOVA9Fs1w7n2XBftk5ib4oZrhzWk0B+3eA=
+github.com/gopherjs/gopherjs v0.0.0-20190411002643-bd77b112433e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
 github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
-github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
 github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-immutable-radix v1.3.0 h1:8exGP7ego3OmkfksihtSouGMZ+hQrhxx+FVELeXpVPE=
 github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
-github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-memdb v1.3.0 h1:xdXq34gBOMEloa9rlGStLxmfX/dyIK8htOv36dQUwHU=
 github.com/hashicorp/go-memdb v1.3.0/go.mod h1:Mluclgwib3R93Hk5fxEfiRhB+6Dar64wWh71LpNSe3g=
-github.com/hashicorp/go-memdb v1.3.3 h1:oGfEWrFuxtIUF3W2q/Jzt6G85TrMk9ey6XfYLvVe1Wo=
-github.com/hashicorp/go-memdb v1.3.3/go.mod h1:uBTr1oQbtuMgd1SSGoR8YV27eT3sBHbYiNm53bMpgSg=
 github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
-github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
-github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g4TbElacI=
+github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
 github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
 github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
 github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
@@ -228,6 +243,7 @@ github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b
 github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE=
 github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -238,56 +254,83 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
-github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jaytaylor/html2text v0.0.0-20211105163654-bc68cce691ba h1:QFQpJdgbON7I0jr2hYW7Bs+XV0qjc3d5tZoDnRFnqTg=
-github.com/jaytaylor/html2text v0.0.0-20211105163654-bc68cce691ba/go.mod h1:CVKlgaMiht+LXvHG173ujK6JUhZXKb2u/BQtjPDIvyk=
+github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
+github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
+github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk=
+github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g=
+github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
+github.com/jameskeane/bcrypt v0.0.0-20120420032655-c3cd44c1e20f/go.mod h1:u+9Snq0w+ZdYKi8BBoaxnEwWu0fY4Kvu9ByFpM51t1s=
+github.com/jaytaylor/html2text v0.0.0-20200412013138-3577fbdbcff7 h1:g0fAGBisHaEQ0TRq1iBvemFRf+8AEWEmBESSiWB3Vsc=
+github.com/jaytaylor/html2text v0.0.0-20200412013138-3577fbdbcff7/go.mod h1:CVKlgaMiht+LXvHG173ujK6JUhZXKb2u/BQtjPDIvyk=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/joeshaw/multierror v0.0.0-20140124173710-69b34d4ec901 h1:rp+c0RAYOWj8l6qbCUTSiRLG/iKnW3K3/QfPPuSsBt4=
 github.com/joeshaw/multierror v0.0.0-20140124173710-69b34d4ec901/go.mod h1:Z86h9688Y0wesXCyonoVr47MasHilkuLMqGhRZ4Hpak=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
+github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8=
+github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE=
+github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE=
+github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro=
+github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8=
+github.com/keybase/go-keychain v0.0.0-20200502122510-cda31fe0c86d h1:gVjhBCfVGl32RIBooOANzfw+0UqX8HU+yPlMv8vypcg=
+github.com/keybase/go-keychain v0.0.0-20200502122510-cda31fe0c86d/go.mod h1:W6EbaYmb4RldPn0N3gvVHjY1wmU59kbymhW9NATWhwY=
+github.com/keybase/go-keychain v0.0.0-20211119201326-e02f34051621 h1:aMQ7pA4f06yOVXSulygyGvy4xA94fyzjUGs0iqQdMOI=
+github.com/keybase/go-keychain v0.0.0-20211119201326-e02f34051621/go.mod h1:enrU/ug069Om7vWxuFE6nikLI2BZNwevMiGSo43Kt5w=
+github.com/keybase/go.dbus v0.0.0-20200324223359-a94be52c0b03/go.mod h1:a8clEhrrGV/d76/f9r2I41BwANMihfZYV9C223vaxqE=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
-github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
+github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
-github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
+github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
+github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8=
+github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.11 h1:nQ+aFkoE2TMGc0b68U2OKSexC+eq46+XwZzWXHRmPYs=
+github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
-github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.17 h1:mCRHCLDUBXgpKAqIKsaAaAsrAlbkeomtRFKXh2L6YIM=
-github.com/mattn/go-sqlite3 v1.14.17/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
+github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
-github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
+github.com/miekg/dns v1.1.41 h1:WMszZWJG0XmzbK9FEmzH2TVcqYzFesusSIB41b8KHxY=
+github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
@@ -297,30 +340,32 @@ github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0Qu
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/nsf/jsondiff v0.0.0-20200515183724-f29ed568f4ce h1:RPclfga2SEJmgMmz2k+Mg7cowZ8yv4Trqw9UsJby758=
+github.com/nsf/jsondiff v0.0.0-20200515183724-f29ed568f4ce/go.mod h1:uFMI8w+ref4v2r9jz+c9i1IfIttS/OkmLfrk1jne5hs=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
+github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0=
-github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
-github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
-github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
-github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA=
-github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
@@ -331,25 +376,31 @@ github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190425082905-87a4384529e0/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo=
-github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.2 h1:YwD0ulJSJytLpiaWua0sBDusfsCZohxjxzVTYjwxfV8=
-github.com/rivo/uniseg v0.4.2/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/ricochet2200/go-disk-usage/du v0.0.0-20210707232629-ac9918953285 h1:d54EL9l+XteliUfUCGsEwwuk65dmmxX85VXF+9T6+50=
+github.com/ricochet2200/go-disk-usage/du v0.0.0-20210707232629-ac9918953285/go.mod h1:fxIDly1xtudczrZeOOlfaUvd2OPb2qZAPuWdU2BsBTk=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.9.2 h1:oxx1eChJGI6Uks2ZC4W1zpLlVgqB8ner4EuQwV4Ik1Y=
-github.com/sirupsen/logrus v1.9.2/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.7.0 h1:ShrD1U9pZB12TX0cVy0DtePoCH97K8EtX+mg7ZARUtM=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
@@ -358,76 +409,92 @@ github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4k
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
 github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf h1:pvbZ0lM0XWPBqUKqFU8cmavspvIl9nulOYwdy6IFRRo=
 github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf/go.mod h1:RJID2RhlZKId02nZ62WenDCkgHFerpIOmW0iT7GKmXM=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
+github.com/therecipe/qt v0.0.0-20200701200531-7f61353ee73e h1:G0DQ/TRQyrEZjtLlLwevFjaRiG8eeCMlq9WXQ2OO2bk=
+github.com/therecipe/qt v0.0.0-20200701200531-7f61353ee73e/go.mod h1:SUUR2j3aE1z6/g76SdD6NwACEpvCxb3fvG82eKbD6us=
+github.com/therecipe/qt/internal/binding/files/docs/5.12.0 v0.0.0-20200904063919-c0c124a5770d h1:hAZyEG2swPRWjF0kqqdGERXUazYnRJdAk4a58f14z7Y=
+github.com/therecipe/qt/internal/binding/files/docs/5.12.0 v0.0.0-20200904063919-c0c124a5770d/go.mod h1:7m8PDYDEtEVqfjoUQc2UrFqhG0CDmoVJjRlQxexndFc=
+github.com/therecipe/qt/internal/binding/files/docs/5.13.0 v0.0.0-20200904063919-c0c124a5770d h1:AJRoBel/g9cDS+yE8BcN3E+TDD/xNAguG21aoR8DAIE=
+github.com/therecipe/qt/internal/binding/files/docs/5.13.0 v0.0.0-20200904063919-c0c124a5770d/go.mod h1:mH55Ek7AZcdns5KPp99O0bg+78el64YCYWHiQKrOdt4=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
-github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
-github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
-github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
-github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
-github.com/urfave/cli/v2 v2.24.4 h1:0gyJJEBYtCV87zI/x2nZCPyDxD51K6xM8SkwjHFCNEU=
-github.com/urfave/cli/v2 v2.24.4/go.mod h1:GHupkWPMM0M/sj1a2b4wUrWBPzazNrIjouW6fmdJLxc=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/urfave/cli/v2 v2.2.0 h1:JTTnM6wKzdA0Jqodd966MVj4vWbbquZykeX1sKbe2C4=
+github.com/urfave/cli/v2 v2.2.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
+github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
+github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
+github.com/vmihailenco/msgpack/v5 v5.1.3 h1:FwC9KPjyW8OqTUqMt6rQw9y50vA2cTLXPKCcBCRbQgg=
+github.com/vmihailenco/msgpack/v5 v5.1.3/go.mod h1:C5gboKD0TJPqWDTVTtrQNfRbiBwHZGo8UTqP/9/XvLI=
+github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc=
+github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
+github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
-github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
+github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
+github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
+github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU=
+go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
-golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190418165655-df01cb2cc480/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
-golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
-golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
-golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 h1:kUhD7nTDoI3fVd9G4ORWrbV5NY0liEs/Jg2pv5f+bBA=
+golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d h1:sK3txAijHtOK88l68nt020reeT1ZdKLIYetKl95FzVY=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4=
 golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
 golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
-golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -439,14 +506,15 @@ golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHl
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mobile v0.0.0-20200801112145-973feb4309de/go.mod h1:skQtrUTUwhdJvXM/2KKJzY8pDgNr9I/FOMqDVRPBUS4=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191209134235-331c550502dd/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -454,24 +522,23 @@ golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190420063019-afa5a82059c6/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211029224645-99673261e6eb/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.0.0-20211008194852-3b03d305991f h1:1scJEYZBaF48BaG6tYbtxmLcXqwYGSfGcMoStTqkkIw=
+golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 h1:HVyaeDAYux4pnY+D/SiwmLOR36ewZ4iGQIIrtnuCjFA=
+golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -480,75 +547,77 @@ golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
-golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191025021431-6c3a3bfe00ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210819135213-f52c844e1c1c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
+golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220111092808-5a964db01320 h1:0jf+tOCoZ3LyutmCOWpVni1chK4VfFLhRsDK7MhqGRY=
+golang.org/x/sys v0.0.0-20220111092808-5a964db01320/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b h1:2n253B2r0pYSmEV+UNCQoPfU/FiaizQEK5Gu4Bq4JE8=
+golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5-0.20201125200606-c27b9fd57aec/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
@@ -559,15 +628,12 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.0.0-20200117012304-6edc0a871e69 h1:yBHHx+XZqXJBm6Exke3N7V9gnlsyXxoCPEb1yVenjfk=
+golang.org/x/tools v0.0.0-20200117012304-6edc0a871e69/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
 google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
@@ -586,40 +652,39 @@ google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20230221151758-ace64dc21148 h1:muK+gVBJBfFb4SejshDBlN2/UgxCCOKH9Y34ljqEGOc=
-google.golang.org/genproto v0.0.0-20230221151758-ace64dc21148/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc=
-google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ=
 gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+howett.net/plist v0.0.0-20181124034731-591f970eefbb/go.mod h1:vMygbs4qMhSZSc4lCUl2OEE+rDiIIJAIdR4m7MiMcm0=
 howett.net/plist v1.0.0 h1:7CrbWYbPPO/PyNy38b2EB/+gYbjCe2DXBxgtOOZbSQM=
 howett.net/plist v1.0.0/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

internal/api/api.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+// Package api provides HTTP API of the Bridge.
+//
+// API endpoints:
+//  * /focus, see focusHandler
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/v2/internal/events"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/listener"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/ports"
+	"github.com/sirupsen/logrus"
+)
+
+var log = logrus.WithField("pkg", "api") //nolint:gochecknoglobals
+
+type apiServer struct {
+	host          string
+	settings      *settings.Settings
+	eventListener listener.Listener
+}
+
+// NewAPIServer returns prepared API server struct.
+func NewAPIServer(settings *settings.Settings, eventListener listener.Listener) *apiServer { //nolint:revive
+	return &apiServer{
+		host:          bridge.Host,
+		settings:      settings,
+		eventListener: eventListener,
+	}
+}
+
+// Starts the server.
+func (api *apiServer) ListenAndServe() {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/focus", wrapper(api, focusHandler))
+
+	addr := api.getAddress()
+	server := &http.Server{
+		Addr:    addr,
+		Handler: mux,
+	}
+
+	log.Info("API listening at ", addr)
+	if err := server.ListenAndServe(); err != nil {
+		api.eventListener.Emit(events.ErrorEvent, "API failed: "+err.Error())
+		log.Error("API failed: ", err)
+	}
+	defer server.Close() //nolint:errcheck
+}
+
+func (api *apiServer) getAddress() string {
+	port := api.settings.GetInt(settings.APIPortKey)
+	newPort := ports.FindFreePortFrom(port)
+	if newPort != port {
+		api.settings.SetInt(settings.APIPortKey, newPort)
+	}
+	return getAPIAddress(api.host, newPort)
+}
+
+func getAPIAddress(host string, port int) string {
+	return fmt.Sprintf("%s:%d", host, port)
+}

internal/api/ctx.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"net/http"
+
+	"github.com/ProtonMail/proton-bridge/v2/pkg/listener"
+)
+
+// httpHandler with Go's Response and Request.
+type httpHandler func(http.ResponseWriter, *http.Request)
+
+// handler with our context.
+type handler func(handlerContext) error
+
+type handlerContext struct {
+	req           *http.Request
+	resp          http.ResponseWriter
+	eventListener listener.Listener
+}
+
+func wrapper(api *apiServer, callback handler) httpHandler {
+	return func(w http.ResponseWriter, req *http.Request) {
+		ctx := handlerContext{
+			req:           req,
+			resp:          w,
+			eventListener: api.eventListener,
+		}
+		err := callback(ctx)
+		if err != nil {
+			log.Error("API callback of ", req.URL, " failed: ", err)
+			http.Error(w, err.Error(), 500)
+		}
+	}
+}

internal/api/focus.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/v2/internal/events"
+)
+
+// focusHandler should be called from other instances (attempt to start bridge
+// for the second time) to get focus in the currently running instance.
+func focusHandler(ctx handlerContext) error {
+	log.Info("Focus from other instance")
+	ctx.eventListener.Emit(events.SecondInstanceEvent, "")
+	fmt.Fprintf(ctx.resp, "OK")
+	return nil
+}
+
+// CheckOtherInstanceAndFocus is helper for new instances to check if there is
+// already a running instance and get it's focus.
+func CheckOtherInstanceAndFocus(port int) error {
+	addr := getAPIAddress(bridge.Host, port)
+	resp, err := (&http.Client{}).Get("http://" + addr + "/focus")
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close() //nolint:errcheck
+
+	if resp.StatusCode != 200 {
+		log.Error("Focus error: ", resp.StatusCode)
+	}
+	return nil
+}

internal/app/app.go

@@ -1,489 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/cookies"
-	"github.com/ProtonMail/proton-bridge/v3/internal/crash"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/focus"
-	"github.com/ProtonMail/proton-bridge/v3/internal/frontend/theme"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/sentry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/restarter"
-	"github.com/pkg/profile"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
-)
-
-// Visible flags.
-const (
-	flagCPUProfile      = "cpu-prof"
-	flagCPUProfileShort = "p"
-
-	flagTraceProfile      = "trace-prof"
-	flagTraceProfileShort = "t"
-
-	flagMemProfile      = "mem-prof"
-	flagMemProfileShort = "m"
-
-	flagLogLevel      = "log-level"
-	flagLogLevelShort = "l"
-
-	flagGRPC      = "grpc"
-	flagGRPCShort = "g"
-
-	flagCLI      = "cli"
-	flagCLIShort = "c"
-
-	flagNonInteractive      = "noninteractive"
-	flagNonInteractiveShort = "n"
-
-	flagLogIMAP = "log-imap"
-	flagLogSMTP = "log-smtp"
-)
-
-// Hidden flags.
-const (
-	flagLauncher         = "launcher"
-	flagNoWindow         = "no-window"
-	flagParentPID        = "parent-pid"
-	flagSoftwareRenderer = "software-renderer"
-	flagSessionID        = "session-id"
-)
-
-const (
-	appUsage     = "Proton Mail IMAP and SMTP Bridge"
-	appShortName = "bridge"
-)
-
-func New() *cli.App {
-	app := cli.NewApp()
-
-	app.Name = constants.FullAppName
-	app.Usage = appUsage
-	app.Flags = []cli.Flag{
-		&cli.BoolFlag{
-			Name:    flagCPUProfile,
-			Aliases: []string{flagCPUProfileShort},
-			Usage:   "Generate CPU profile",
-		},
-		&cli.BoolFlag{
-			Name:    flagTraceProfile,
-			Aliases: []string{flagTraceProfileShort},
-			Usage:   "Generate Trace profile",
-		},
-		&cli.BoolFlag{
-			Name:    flagMemProfile,
-			Aliases: []string{flagMemProfileShort},
-			Usage:   "Generate memory profile",
-		},
-		&cli.StringFlag{
-			Name:    flagLogLevel,
-			Aliases: []string{flagLogLevelShort},
-			Usage:   "Set the log level (one of panic, fatal, error, warn, info, debug)",
-		},
-		&cli.BoolFlag{
-			Name:    flagGRPC,
-			Aliases: []string{flagGRPCShort},
-			Usage:   "Start the gRPC service",
-		},
-		&cli.BoolFlag{
-			Name:    flagCLI,
-			Aliases: []string{flagCLIShort},
-			Usage:   "Start the command line interface",
-		},
-		&cli.BoolFlag{
-			Name:    flagNonInteractive,
-			Aliases: []string{flagNonInteractiveShort},
-			Usage:   "Start the app in non-interactive mode",
-		},
-		&cli.StringFlag{
-			Name:  flagLogIMAP,
-			Usage: "Enable logging of IMAP communications (all|client|server) (may contain decrypted data!)",
-		},
-		&cli.BoolFlag{
-			Name:  flagLogSMTP,
-			Usage: "Enable logging of SMTP communications (may contain decrypted data!)",
-		},
-
-		// Hidden flags
-		&cli.BoolFlag{
-			Name:   flagNoWindow,
-			Usage:  "Don't show window after start",
-			Hidden: true,
-		},
-		&cli.StringFlag{
-			Name:   flagLauncher,
-			Usage:  "The launcher used to start the app",
-			Hidden: true,
-		},
-		&cli.IntFlag{
-			Name:   flagParentPID,
-			Usage:  "Process ID of the parent",
-			Hidden: true,
-			Value:  -1,
-		},
-		&cli.BoolFlag{
-			Name:   flagSoftwareRenderer, // This flag is ignored by bridge, but should be passed to launcher in case of restart, so it need to be accepted by the CLI parser.
-			Usage:  "GUI is using software renderer",
-			Hidden: true,
-			Value:  false,
-		},
-		&cli.StringFlag{
-			Name:   flagSessionID,
-			Hidden: true,
-		},
-	}
-
-	app.Action = run
-
-	return app
-}
-
-func run(c *cli.Context) error {
-	// Get the current bridge version.
-	version, err := semver.NewVersion(constants.Version)
-	if err != nil {
-		return fmt.Errorf("could not create version: %w", err)
-	}
-
-	// Create a user agent that will be used for all requests.
-	identifier := useragent.New()
-
-	// Create a new Sentry client that will be used to report crashes etc.
-	reporter := sentry.NewReporter(constants.FullAppName, identifier)
-
-	// Determine the exe that should be used to restart/autostart the app.
-	// By default, this is the launcher, if used. Otherwise, we try to get
-	// the current exe, and fall back to os.Args[0] if that fails.
-	var exe string
-
-	if launcher := c.String(flagLauncher); launcher != "" {
-		exe = launcher
-	} else if executable, err := os.Executable(); err == nil {
-		exe = executable
-	} else {
-		exe = os.Args[0]
-	}
-
-	var logCloser io.Closer
-	defer func() {
-		_ = logging.Close(logCloser)
-	}()
-
-	// Restart the app if requested.
-	return withRestarter(exe, func(restarter *restarter.Restarter) error {
-		// Handle crashes with various actions.
-		return withCrashHandler(restarter, reporter, func(crashHandler *crash.Handler, quitCh <-chan struct{}) error {
-			migrationErr := migrateOldVersions()
-
-			// Run with profiling if requested.
-			return withProfiler(c, func() error {
-				// Load the locations where we store our files.
-				return WithLocations(func(locations *locations.Locations) error {
-					// Migrate the keychain helper.
-					if err := migrateKeychainHelper(locations); err != nil {
-						logrus.WithError(err).Error("Failed to migrate keychain helper")
-					}
-
-					// Initialize logging.
-					return withLogging(c, crashHandler, locations, func(closer io.Closer) error {
-						logCloser = closer
-
-						// If there was an error during migration, log it now.
-						if migrationErr != nil {
-							logrus.WithError(migrationErr).Error("Failed to migrate old app data")
-						}
-
-						// Ensure we are the only instance running.
-						settings, err := locations.ProvideSettingsPath()
-						if err != nil {
-							logrus.WithError(err).Error("Failed to get settings path")
-						}
-
-						return withSingleInstance(settings, locations.GetLockFile(), version, func() error {
-							// Unlock the encrypted vault.
-							return WithVault(locations, crashHandler, func(v *vault.Vault, insecure, corrupt bool) error {
-								if !v.Migrated() {
-									// Migrate old settings into the vault.
-									if err := migrateOldSettings(v); err != nil {
-										logrus.WithError(err).Error("Failed to migrate old settings")
-									}
-
-									// Migrate old accounts into the vault.
-									if err := migrateOldAccounts(locations, v); err != nil {
-										logrus.WithError(err).Error("Failed to migrate old accounts")
-									}
-
-									// The vault has been migrated.
-									if err := v.SetMigrated(); err != nil {
-										logrus.WithError(err).Error("Failed to mark vault as migrated")
-									}
-								}
-
-								logrus.WithFields(logrus.Fields{
-									"lastVersion": v.GetLastVersion().String(),
-									"showAllMail": v.GetShowAllMail(),
-									"updateCh":    v.GetUpdateChannel(),
-									"autoUpdate":  v.GetAutoUpdate(),
-									"rollout":     v.GetUpdateRollout(),
-									"DoH":         v.GetProxyAllowed(),
-								}).Info("Vault loaded")
-
-								// Load the cookies from the vault.
-								return withCookieJar(v, func(cookieJar http.CookieJar) error {
-									// Create a new bridge instance.
-									return withBridge(c, exe, locations, version, identifier, crashHandler, reporter, v, cookieJar, func(b *bridge.Bridge, eventCh <-chan events.Event) error {
-										if insecure {
-											logrus.Warn("The vault key could not be retrieved; the vault will not be encrypted")
-											b.PushError(bridge.ErrVaultInsecure)
-										}
-
-										if corrupt {
-											logrus.Warn("The vault is corrupt and has been wiped")
-											b.PushError(bridge.ErrVaultCorrupt)
-										}
-
-										// Start telemetry heartbeat process
-										b.StartHeartbeat(b)
-
-										// Run the frontend.
-										return runFrontend(c, crashHandler, restarter, locations, b, eventCh, quitCh, c.Int(flagParentPID))
-									})
-								})
-							})
-						})
-					})
-				})
-			})
-		})
-	})
-}
-
-// If there's another instance already running, try to raise it and exit.
-func withSingleInstance(settingPath, lockFile string, version *semver.Version, fn func() error) error {
-	logrus.Debug("Checking for other instances")
-	defer logrus.Debug("Single instance stopped")
-
-	lock, err := checkSingleInstance(settingPath, lockFile, version)
-	if err != nil {
-		logrus.Info("Another instance is already running; raising it")
-
-		if ok := focus.TryRaise(settingPath); !ok {
-			return fmt.Errorf("another instance is already running but it could not be raised")
-		}
-
-		logrus.Info("The other instance has been raised")
-
-		return nil
-	}
-
-	defer func() {
-		if err := lock.Close(); err != nil {
-			logrus.WithError(err).Error("Failed to close lock file")
-		}
-	}()
-
-	return fn()
-}
-
-// Initialize our logging system.
-func withLogging(c *cli.Context, crashHandler *crash.Handler, locations *locations.Locations, fn func(closer io.Closer) error) error {
-	logrus.Debug("Initializing logging")
-	defer logrus.Debug("Logging stopped")
-
-	// Get a place to keep our logs.
-	logsPath, err := locations.ProvideLogsPath()
-	if err != nil {
-		return fmt.Errorf("could not provide logs path: %w", err)
-	}
-
-	logrus.WithField("path", logsPath).Debug("Received logs path")
-
-	// Initialize logging.
-	sessionID := logging.NewSessionIDFromString(c.String(flagSessionID))
-	var closer io.Closer
-	if closer, err = logging.Init(
-		logsPath,
-		sessionID,
-		logging.BridgeShortAppName,
-		logging.DefaultMaxLogFileSize,
-		logging.DefaultPruningSize,
-		c.String(flagLogLevel),
-	); err != nil {
-		return fmt.Errorf("could not initialize logging: %w", err)
-	}
-
-	// Ensure we dump a stack trace if we crash.
-	crashHandler.AddRecoveryAction(logging.DumpStackTrace(logsPath, sessionID, appShortName))
-
-	logrus.
-		WithField("appName", constants.FullAppName).
-		WithField("version", constants.Version).
-		WithField("revision", constants.Revision).
-		WithField("tag", constants.Tag).
-		WithField("build", constants.BuildTime).
-		WithField("runtime", runtime.GOOS).
-		WithField("args", os.Args).
-		WithField("SentryID", sentry.GetProtectedHostname()).
-		Info("Run app")
-
-	return fn(closer)
-}
-
-// WithLocations provides access to locations where we store our files.
-func WithLocations(fn func(*locations.Locations) error) error {
-	logrus.Debug("Creating locations")
-	defer logrus.Debug("Locations stopped")
-
-	// Create a locations provider to determine where to store our files.
-	provider, err := locations.NewDefaultProvider(filepath.Join(constants.VendorName, constants.ConfigName))
-	if err != nil {
-		return fmt.Errorf("could not create locations provider: %w", err)
-	}
-
-	// Create a new locations object that will be used to provide paths to store files.
-	return fn(locations.New(provider, constants.ConfigName))
-}
-
-// Start profiling if requested.
-func withProfiler(c *cli.Context, fn func() error) error {
-	defer logrus.Debug("Profiler stopped")
-
-	if c.Bool(flagCPUProfile) {
-		logrus.Debug("Running with CPU profiling")
-		defer profile.Start(profile.CPUProfile, profile.ProfilePath(".")).Stop()
-	}
-
-	if c.Bool(flagTraceProfile) {
-		logrus.Debug("Running with Trace profiling")
-		defer profile.Start(profile.TraceProfile, profile.ProfilePath(".")).Stop()
-	}
-
-	if c.Bool(flagMemProfile) {
-		logrus.Debug("Running with memory profiling")
-		defer profile.Start(profile.MemProfile, profile.MemProfileAllocs, profile.ProfilePath(".")).Stop()
-	}
-
-	return fn()
-}
-
-// Restart the app if necessary.
-func withRestarter(exe string, fn func(*restarter.Restarter) error) error {
-	logrus.Debug("Creating restarter")
-	defer logrus.Debug("Restarter stopped")
-
-	restarter := restarter.New(exe)
-	defer restarter.Restart()
-
-	return fn(restarter)
-}
-
-// Handle crashes if they occur.
-func withCrashHandler(restarter *restarter.Restarter, reporter *sentry.Reporter, fn func(*crash.Handler, <-chan struct{}) error) error {
-	logrus.Debug("Creating crash handler")
-	defer logrus.Debug("Crash handler stopped")
-
-	crashHandler := crash.NewHandler(crash.ShowErrorNotification(constants.FullAppName))
-	defer async.HandlePanic(crashHandler)
-
-	// On crash, send crash report to Sentry.
-	crashHandler.AddRecoveryAction(reporter.ReportException)
-
-	// On crash, notify the user and restart the app.
-	crashHandler.AddRecoveryAction(crash.ShowErrorNotification(constants.FullAppName))
-
-	// On crash, restart the app.
-	crashHandler.AddRecoveryAction(func(any) error { restarter.Set(true, true); return nil })
-
-	// quitCh is closed when the app is quitting.
-	quitCh := make(chan struct{})
-
-	// On crash, quit the app.
-	crashHandler.AddRecoveryAction(func(any) error { close(quitCh); return nil })
-
-	return fn(crashHandler, quitCh)
-}
-
-// Use a custom cookie jar to persist values across runs.
-func withCookieJar(vault *vault.Vault, fn func(http.CookieJar) error) error {
-	logrus.Debug("Creating cookie jar")
-	defer logrus.Debug("Cookie jar stopped")
-
-	// Create the underlying cookie jar.
-	jar, err := cookiejar.New(nil)
-	if err != nil {
-		return fmt.Errorf("could not create cookie jar: %w", err)
-	}
-
-	// Create the cookie jar which persists to the vault.
-	persister, err := cookies.NewCookieJar(jar, vault)
-	if err != nil {
-		return fmt.Errorf("could not create cookie jar: %w", err)
-	}
-
-	if err := setDeviceCookies(persister); err != nil {
-		return fmt.Errorf("could not set device cookies: %w", err)
-	}
-
-	// Persist the cookies to the vault when we close.
-	defer func() {
-		logrus.Debug("Persisting cookies")
-
-		if err := persister.PersistCookies(); err != nil {
-			logrus.WithError(err).Error("Failed to persist cookies")
-		}
-	}()
-
-	return fn(persister)
-}
-
-func setDeviceCookies(jar *cookies.Jar) error {
-	url, err := url.Parse(constants.APIHost)
-	if err != nil {
-		return err
-	}
-
-	for name, value := range map[string]string{
-		"hhn": sentry.GetProtectedHostname(),
-		"tz":  sentry.GetTimeZone(),
-		"lng": sentry.GetSystemLang(),
-		"clr": string(theme.DefaultTheme()),
-	} {
-		jar.SetCookies(url, []*http.Cookie{{Name: name, Value: value, Secure: true}})
-	}
-
-	return nil
-}

internal/app/base/args.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import "strings"
+
+// StripProcessSerialNumber removes additional flag from macOS.
+// More info:
+// http://mirror.informatimago.com/next/developer.apple.com/documentation/Carbon/Reference/Process_Manager/prmref_main/data_type_5.html#//apple_ref/doc/uid/TP30000208/C001951
+func StripProcessSerialNumber(args []string) []string {
+	res := args[:0]
+
+	for _, arg := range args {
+		if !strings.Contains(arg, "-psn_") {
+			res = append(res, arg)
+		}
+	}
+
+	return res
+}

internal/app/base/base.go

@@ -0,0 +1,405 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+// Package base implements a common application base currently shared by bridge and IE.
+// The base includes the following:
+//  - access to standard filesystem locations like config, cache, logging dirs
+//  - an extensible crash handler
+//  - versioned cache directory
+//  - persistent settings
+//  - event listener
+//  - credentials store
+//  - pmapi Manager
+// In addition, the base initialises logging and reacts to command line arguments
+// which control the log verbosity and enable cpu/memory profiling.
+package base
+
+import (
+	"math/rand"
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/go-autostart"
+	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/ProtonMail/proton-bridge/v2/internal/api"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/cache"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/tls"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/useragent"
+	"github.com/ProtonMail/proton-bridge/v2/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v2/internal/cookies"
+	"github.com/ProtonMail/proton-bridge/v2/internal/crash"
+	"github.com/ProtonMail/proton-bridge/v2/internal/events"
+	"github.com/ProtonMail/proton-bridge/v2/internal/locations"
+	"github.com/ProtonMail/proton-bridge/v2/internal/logging"
+	"github.com/ProtonMail/proton-bridge/v2/internal/sentry"
+	"github.com/ProtonMail/proton-bridge/v2/internal/updater"
+	"github.com/ProtonMail/proton-bridge/v2/internal/users/credentials"
+	"github.com/ProtonMail/proton-bridge/v2/internal/versioner"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/keychain"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/listener"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/pmapi"
+	"github.com/allan-simon/go-singleinstance"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+const (
+	flagCPUProfile      = "cpu-prof"
+	flagCPUProfileShort = "p"
+	flagMemProfile      = "mem-prof"
+	flagMemProfileShort = "m"
+	flagLogLevel        = "log-level"
+	flagLogLevelShort   = "l"
+	// FlagCLI indicate to start with command line interface.
+	FlagCLI      = "cli"
+	flagCLIShort = "c"
+	flagRestart  = "restart"
+	FlagLauncher = "launcher"
+	FlagNoWindow = "no-window"
+)
+
+type Base struct {
+	SentryReporter *sentry.Reporter
+	CrashHandler   *crash.Handler
+	Locations      *locations.Locations
+	Settings       *settings.Settings
+	Lock           *os.File
+	Cache          *cache.Cache
+	Listener       listener.Listener
+	Creds          *credentials.Store
+	CM             pmapi.Manager
+	CookieJar      *cookies.Jar
+	UserAgent      *useragent.UserAgent
+	Updater        *updater.Updater
+	Versioner      *versioner.Versioner
+	TLS            *tls.TLS
+	Autostart      *autostart.App
+
+	Name    string // the app's name
+	usage   string // the app's usage description
+	command string // the command used to launch the app (either the exe path or the launcher path)
+	restart bool   // whether the app is currently set to restart
+
+	teardown []func() error // actions to perform when app is exiting
+}
+
+func New( //nolint:funlen
+	appName,
+	appUsage,
+	configName,
+	updateURLName,
+	keychainName,
+	cacheVersion string,
+) (*Base, error) {
+	userAgent := useragent.New()
+
+	sentryReporter := sentry.NewReporter(appName, constants.Version, userAgent)
+
+	crashHandler := crash.NewHandler(
+		sentryReporter.ReportException,
+		crash.ShowErrorNotification(appName),
+	)
+	defer crashHandler.HandlePanic()
+
+	rand.Seed(time.Now().UnixNano())
+	os.Args = StripProcessSerialNumber(os.Args)
+
+	locationsProvider, err := locations.NewDefaultProvider(filepath.Join(constants.VendorName, configName))
+	if err != nil {
+		return nil, err
+	}
+
+	locations := locations.New(locationsProvider, configName)
+
+	logsPath, err := locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	if err := logging.Init(logsPath); err != nil {
+		return nil, err
+	}
+	crashHandler.AddRecoveryAction(logging.DumpStackTrace(logsPath))
+
+	if err := migrateFiles(configName); err != nil {
+		logrus.WithError(err).Warn("Old config files could not be migrated")
+	}
+
+	if err := locations.Clean(); err != nil {
+		return nil, err
+	}
+
+	settingsPath, err := locations.ProvideSettingsPath()
+	if err != nil {
+		return nil, err
+	}
+	settingsObj := settings.New(settingsPath)
+
+	lock, err := singleinstance.CreateLockFile(locations.GetLockFile())
+	if err != nil {
+		logrus.Warnf("%v is already running", appName)
+		return nil, api.CheckOtherInstanceAndFocus(settingsObj.GetInt(settings.APIPortKey))
+	}
+
+	if err := migrateRebranding(settingsObj, keychainName); err != nil {
+		logrus.WithError(err).Warn("Rebranding migration failed")
+	}
+
+	cachePath, err := locations.ProvideCachePath()
+	if err != nil {
+		return nil, err
+	}
+	cache, err := cache.New(cachePath, cacheVersion)
+	if err != nil {
+		return nil, err
+	}
+	if err := cache.RemoveOldVersions(); err != nil {
+		return nil, err
+	}
+
+	listener := listener.New()
+	events.SetupEvents(listener)
+
+	// If we can't load the keychain for whatever reason,
+	// we signal to frontend and supply a dummy keychain that always returns errors.
+	kc, err := keychain.NewKeychain(settingsObj, keychainName)
+	if err != nil {
+		listener.Emit(events.CredentialsErrorEvent, err.Error())
+		kc = keychain.NewMissingKeychain()
+	}
+
+	cfg := pmapi.NewConfig(configName, constants.Version)
+	cfg.GetUserAgent = userAgent.String
+	cfg.UpgradeApplicationHandler = func() { listener.Emit(events.UpgradeApplicationEvent, "") }
+	cfg.TLSIssueHandler = func() { listener.Emit(events.TLSCertIssue, "") }
+
+	cm := pmapi.New(cfg)
+
+	sentryReporter.SetClientFromManager(cm)
+
+	cm.AddConnectionObserver(pmapi.NewConnectionObserver(
+		func() { listener.Emit(events.InternetConnChangedEvent, events.InternetOff) },
+		func() { listener.Emit(events.InternetConnChangedEvent, events.InternetOn) },
+	))
+
+	jar, err := cookies.NewCookieJar(settingsObj)
+	if err != nil {
+		return nil, err
+	}
+
+	cm.SetCookieJar(jar)
+
+	key, err := crypto.NewKeyFromArmored(updater.DefaultPublicKey)
+	if err != nil {
+		return nil, err
+	}
+
+	kr, err := crypto.NewKeyRing(key)
+	if err != nil {
+		return nil, err
+	}
+
+	updatesDir, err := locations.ProvideUpdatesPath()
+	if err != nil {
+		return nil, err
+	}
+
+	versioner := versioner.New(updatesDir)
+	installer := updater.NewInstaller(versioner)
+	updater := updater.New(
+		cm,
+		installer,
+		settingsObj,
+		kr,
+		semver.MustParse(constants.Version),
+		updateURLName,
+		runtime.GOOS,
+	)
+
+	exe, err := os.Executable()
+	if err != nil {
+		return nil, err
+	}
+
+	autostart := &autostart.App{
+		Name:        startupNameForRebranding(appName),
+		DisplayName: appName,
+		Exec:        []string{exe, "--" + FlagNoWindow},
+	}
+
+	return &Base{
+		SentryReporter: sentryReporter,
+		CrashHandler:   crashHandler,
+		Locations:      locations,
+		Settings:       settingsObj,
+		Lock:           lock,
+		Cache:          cache,
+		Listener:       listener,
+		Creds:          credentials.NewStore(kc),
+		CM:             cm,
+		CookieJar:      jar,
+		UserAgent:      userAgent,
+		Updater:        updater,
+		Versioner:      versioner,
+		TLS:            tls.New(settingsPath),
+		Autostart:      autostart,
+
+		Name:  appName,
+		usage: appUsage,
+
+		// By default, the command is the app's executable.
+		// This can be changed at runtime by using the "--launcher" flag.
+		command: exe,
+	}, nil
+}
+
+func (b *Base) NewApp(mainLoop func(*Base, *cli.Context) error) *cli.App {
+	app := cli.NewApp()
+
+	app.Name = b.Name
+	app.Usage = b.usage
+	app.Version = constants.Version
+	app.Action = b.wrapMainLoop(mainLoop)
+	app.Flags = []cli.Flag{
+		&cli.BoolFlag{
+			Name:    flagCPUProfile,
+			Aliases: []string{flagCPUProfileShort},
+			Usage:   "Generate CPU profile",
+		},
+		&cli.BoolFlag{
+			Name:    flagMemProfile,
+			Aliases: []string{flagMemProfileShort},
+			Usage:   "Generate memory profile",
+		},
+		&cli.StringFlag{
+			Name:    flagLogLevel,
+			Aliases: []string{flagLogLevelShort},
+			Usage:   "Set the log level (one of panic, fatal, error, warn, info, debug)",
+		},
+		&cli.BoolFlag{
+			Name:    FlagCLI,
+			Aliases: []string{flagCLIShort},
+			Usage:   "Use command line interface",
+		},
+		&cli.BoolFlag{
+			Name:  FlagNoWindow,
+			Usage: "Don't show window after start",
+		},
+		&cli.StringFlag{
+			Name:   flagRestart,
+			Usage:  "The number of times the application has already restarted",
+			Hidden: true,
+		},
+		&cli.StringFlag{
+			Name:   FlagLauncher,
+			Usage:  "The launcher to use to restart the application",
+			Hidden: true,
+		},
+	}
+
+	return app
+}
+
+// SetToRestart sets the app to restart the next time it is closed.
+func (b *Base) SetToRestart() {
+	b.restart = true
+}
+
+// AddTeardownAction adds an action to perform during app teardown.
+func (b *Base) AddTeardownAction(fn func() error) {
+	b.teardown = append(b.teardown, fn)
+}
+
+func (b *Base) wrapMainLoop(appMainLoop func(*Base, *cli.Context) error) cli.ActionFunc { //nolint:funlen
+	return func(c *cli.Context) error {
+		defer b.CrashHandler.HandlePanic()
+		defer func() { _ = b.Lock.Close() }()
+
+		// If launcher was used to start the app, use that for restart
+		// and autostart.
+		if launcher := c.String(FlagLauncher); launcher != "" {
+			b.command = launcher
+			// Bridge supports no-window option which we should use
+			// for autostart.
+			b.Autostart.Exec = []string{launcher, "--" + FlagNoWindow}
+		}
+
+		if c.Bool(flagCPUProfile) {
+			startCPUProfile()
+			defer pprof.StopCPUProfile()
+		}
+
+		if c.Bool(flagMemProfile) {
+			defer makeMemoryProfile()
+		}
+
+		logging.SetLevel(c.String(flagLogLevel))
+		b.CM.SetLogging(logrus.WithField("pkg", "pmapi"), logrus.GetLevel() == logrus.TraceLevel)
+
+		logrus.
+			WithField("appName", b.Name).
+			WithField("version", constants.Version).
+			WithField("revision", constants.Revision).
+			WithField("build", constants.BuildTime).
+			WithField("runtime", runtime.GOOS).
+			WithField("args", os.Args).
+			Info("Run app")
+
+		b.CrashHandler.AddRecoveryAction(func(interface{}) error {
+			sentry.Flush(2 * time.Second)
+
+			if c.Int(flagRestart) > maxAllowedRestarts {
+				logrus.
+					WithField("restart", c.Int("restart")).
+					Warn("Not restarting, already restarted too many times")
+				os.Exit(1)
+
+				return nil
+			}
+
+			return b.restartApp(true)
+		})
+
+		if err := appMainLoop(b, c); err != nil {
+			return err
+		}
+
+		if err := b.doTeardown(); err != nil {
+			return err
+		}
+
+		if b.restart {
+			return b.restartApp(false)
+		}
+
+		return nil
+	}
+}
+
+func (b *Base) doTeardown() error {
+	for _, action := range b.teardown {
+		if err := action(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

internal/app/base/migration.go

@@ -0,0 +1,131 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v2/internal/locations"
+	"github.com/sirupsen/logrus"
+)
+
+// migrateFiles migrates files from their old (pre-refactor) locations to their new locations.
+// We can remove this eventually.
+//
+// | entity    |               old location                |            new location                |
+// |-----------|-------------------------------------------|----------------------------------------|
+// | prefs     | ~/.cache/protonmail/<app>/c11/prefs.json  | ~/.config/protonmail/<app>/prefs.json  |
+// | c11 1.5.x | ~/.cache/protonmail/<app>/c11             | ~/.cache/protonmail/<app>/cache/c11    |
+// | c11 1.6.x | ~/.cache/protonmail/<app>/cache/c11       | ~/.config/protonmail/<app>/cache/c11   |
+// | updates   | ~/.cache/protonmail/<app>/updates         | ~/.config/protonmail/<app>/updates     |.
+func migrateFiles(configName string) error {
+	locationsProvider, err := locations.NewDefaultProvider(filepath.Join(constants.VendorName, configName))
+	if err != nil {
+		return err
+	}
+
+	locations := locations.New(locationsProvider, configName)
+	userCacheDir := locationsProvider.UserCache()
+
+	if err := migratePrefsFrom15x(locations, userCacheDir); err != nil {
+		return err
+	}
+	if err := migrateCacheFromBoth15xAnd16x(locations, userCacheDir); err != nil {
+		return err
+	}
+	if err := migrateUpdatesFrom16x(configName, locations); err != nil { //nolint:revive It is more clear to structure this way
+		return err
+	}
+	return nil
+}
+
+func migratePrefsFrom15x(locations *locations.Locations, userCacheDir string) error {
+	newSettingsDir, err := locations.ProvideSettingsPath()
+	if err != nil {
+		return err
+	}
+
+	return moveIfExists(
+		filepath.Join(userCacheDir, "c11", "prefs.json"),
+		filepath.Join(newSettingsDir, "prefs.json"),
+	)
+}
+
+func migrateCacheFromBoth15xAnd16x(locations *locations.Locations, userCacheDir string) error {
+	olderCacheDir := userCacheDir
+	newerCacheDir := locations.GetOldCachePath()
+	latestCacheDir, err := locations.ProvideCachePath()
+	if err != nil {
+		return err
+	}
+
+	// Migration for versions before 1.6.x.
+	if err := moveIfExists(
+		filepath.Join(olderCacheDir, "c11"),
+		filepath.Join(latestCacheDir, "c11"),
+	); err != nil {
+		return err
+	}
+
+	// Migration for versions 1.6.x.
+	return moveIfExists(
+		filepath.Join(newerCacheDir, "c11"),
+		filepath.Join(latestCacheDir, "c11"),
+	)
+}
+
+func migrateUpdatesFrom16x(configName string, locations *locations.Locations) error {
+	// In order to properly update Bridge 1.6.X and higher we need to
+	// change the launcher first. Since this is not part of automatic
+	// updates the migration must wait until manual update. Until that
+	// we need to keep old path.
+	if configName == "bridge" {
+		return nil
+	}
+
+	oldUpdatesPath := locations.GetOldUpdatesPath()
+	// Do not use ProvideUpdatesPath, that creates dir right away.
+	newUpdatesPath := locations.GetUpdatesPath()
+
+	return moveIfExists(oldUpdatesPath, newUpdatesPath)
+}
+
+func moveIfExists(source, destination string) error {
+	l := logrus.WithField("source", source).WithField("destination", destination)
+
+	if _, err := os.Stat(source); os.IsNotExist(err) {
+		l.Info("No need to migrate file, source doesn't exist")
+		return nil
+	}
+
+	if _, err := os.Stat(destination); !os.IsNotExist(err) {
+		// Once migrated, files should not stay in source anymore. Therefore
+		// if some files are still in source location but target already exist,
+		// it's suspicious. Could happen by installing new version, then the
+		// old one because of some reason, and then the new one again.
+		// Good to see as warning because it could be a reason why Bridge is
+		// behaving weirdly, like wrong configuration, or db re-sync and so on.
+		l.Warn("No need to migrate file, target already exists")
+		return nil
+	}
+
+	l.Info("Migrating files")
+	return os.Rename(source, destination)
+}

internal/app/base/migration_rebranding.go

@@ -0,0 +1,197 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/keychain"
+	"github.com/hashicorp/go-multierror"
+	"github.com/sirupsen/logrus"
+)
+
+const darwin = "darwin"
+
+func migrateRebranding(settingsObj *settings.Settings, keychainName string) (result error) {
+	if err := migrateStartupBeforeRebranding(); err != nil {
+		result = multierror.Append(result, err)
+	}
+
+	lastUsedVersion := settingsObj.Get(settings.LastVersionKey)
+
+	// Skipping migration: it is first bridge start or cache was cleared.
+	if lastUsedVersion == "" {
+		settingsObj.SetBool(settings.RebrandingMigrationKey, true)
+		return
+	}
+
+	// Skipping rest of migration: already done
+	if settingsObj.GetBool(settings.RebrandingMigrationKey) {
+		return
+	}
+
+	switch runtime.GOOS {
+	case "windows", "linux":
+		// GODT-1260 we would need admin rights to changes desktop files
+		// and start menu items.
+		settingsObj.SetBool(settings.RebrandingMigrationKey, true)
+	case darwin:
+		if shouldContinue, err := isMacBeforeRebranding(); !shouldContinue || err != nil {
+			if err != nil {
+				result = multierror.Append(result, err)
+			}
+			break
+		}
+
+		if err := migrateMacKeychainBeforeRebranding(settingsObj, keychainName); err != nil {
+			result = multierror.Append(result, err)
+		}
+
+		settingsObj.SetBool(settings.RebrandingMigrationKey, true)
+	}
+
+	return result
+}
+
+// migrateMacKeychainBeforeRebranding deals with write access restriction to
+// mac keychain passwords which are caused by application renaming. The old
+// passwords are copied under new name in order to have write access afer
+// renaming.
+func migrateMacKeychainBeforeRebranding(settingsObj *settings.Settings, keychainName string) error {
+	l := logrus.WithField("pkg", "app/base/migration")
+	l.Warn("Migrating mac keychain")
+
+	helperConstructor, ok := keychain.Helpers["macos-keychain"]
+	if !ok {
+		return errors.New("cannot find macos-keychain helper")
+	}
+
+	oldKC, err := helperConstructor("ProtonMailBridgeService")
+	if err != nil {
+		l.WithError(err).Error("Keychain constructor failed")
+		return err
+	}
+
+	idByURL, err := oldKC.List()
+	if err != nil {
+		l.WithError(err).Error("List old keychain failed")
+		return err
+	}
+
+	newKC, err := keychain.NewKeychain(settingsObj, keychainName)
+	if err != nil {
+		return err
+	}
+
+	for url, id := range idByURL {
+		li := l.WithField("id", id).WithField("url", url)
+		userID, secret, err := oldKC.Get(url)
+		if err != nil {
+			li.WithField("userID", userID).
+				WithField("err", err).
+				Error("Faild to get old item")
+			continue
+		}
+
+		if _, _, err := newKC.Get(userID); err == nil {
+			li.Warn("Skipping migration, item already exists.")
+			continue
+		}
+
+		if err := newKC.Put(userID, secret); err != nil {
+			li.WithError(err).Error("Failed to migrate user")
+		}
+
+		li.Info("Item migrated")
+	}
+
+	return nil
+}
+
+// migrateStartupBeforeRebranding removes old startup links. The creation of new links is
+// handled by bridge initialisation.
+func migrateStartupBeforeRebranding() error {
+	path, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	switch runtime.GOOS {
+	case "windows":
+		path = filepath.Join(path, `AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\ProtonMail Bridge.lnk`)
+	case "linux":
+		path = filepath.Join(path, `.config/autostart/ProtonMail Bridge.desktop`)
+	case darwin:
+		path = filepath.Join(path, `Library/LaunchAgents/ProtonMail Bridge.plist`)
+	default:
+		return errors.New("unknown GOOS")
+	}
+
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		return nil
+	}
+
+	logrus.WithField("pkg", "app/base/migration").Warn("Migrating autostartup links")
+	return os.Remove(path)
+}
+
+// startupNameForRebranding returns the name for autostart launcher based on
+// type of rebranded instance i.e. update or manual.
+//
+// This only affects darwin when udpate re-writes the old startup and then
+// manual installed it would not run proper exe. Therefore we return "old" name
+// for updates and "new" name for manual which would be properly migrated.
+//
+// For orther (linux and windows) the link is always pointing to launcher which
+// path didn't changed.
+func startupNameForRebranding(origin string) string {
+	if runtime.GOOS == darwin {
+		if path, err := os.Executable(); err == nil && strings.Contains(path, "ProtonMail Bridge") {
+			return "ProtonMail Bridge"
+		}
+	}
+
+	// No need to solve for other OS. See comment above.
+	return origin
+}
+
+// isBeforeRebranding decide if last used version was older than 2.2.0. If
+// cannot decide it returns false with error.
+func isMacBeforeRebranding() (bool, error) {
+	// previous version | update | do mac migration |
+	//                  | first  | false            |
+	// cleared-cache    | manual | false            |
+	// cleared-cache    | in-app | false            |
+	// old              | in-app | false            |
+	// old in-app       | in-app | false            |
+	// old              | manual | true             |
+	// old in-app       | manual | true             |
+	// manual           | in-app | false            |
+
+	// Skip if it was in-app update and not manual
+	if path, err := os.Executable(); err != nil || strings.Contains(path, "ProtonMail Bridge") {
+		return false, err
+	}
+
+	return true, nil
+}

internal/app/base/profiling.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/sirupsen/logrus"
+)
+
+// startCPUProfile starts CPU pprof.
+func startCPUProfile() {
+	f, err := os.Create("./cpu.pprof")
+	if err != nil {
+		logrus.Fatal("Could not create CPU profile: ", err)
+	}
+	if err := pprof.StartCPUProfile(f); err != nil {
+		logrus.Fatal("Could not start CPU profile: ", err)
+	}
+}
+
+// makeMemoryProfile generates memory pprof.
+func makeMemoryProfile() {
+	name := "./mem.pprof"
+	f, err := os.Create(name)
+	if err != nil {
+		logrus.Fatal("Could not create memory profile: ", err)
+	}
+	if abs, err := filepath.Abs(name); err == nil {
+		name = abs
+	}
+	logrus.Info("Writing memory profile to ", name)
+	runtime.GC() // get up-to-date statistics
+	if err := pprof.WriteHeapProfile(f); err != nil {
+		logrus.Fatal("Could not write memory profile: ", err)
+	}
+	_ = f.Close()
+}

internal/app/base/restart.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"strconv"
+
+	"github.com/sirupsen/logrus"
+	"golang.org/x/sys/execabs"
+)
+
+// maxAllowedRestarts controls after how many crashes the app will give up restarting.
+const maxAllowedRestarts = 10
+
+func (b *Base) restartApp(crash bool) error {
+	var args []string
+
+	if crash {
+		args = incrementRestartFlag(os.Args)[1:]
+		defer func() { os.Exit(1) }()
+	} else {
+		args = os.Args[1:]
+	}
+
+	logrus.
+		WithField("command", b.command).
+		WithField("args", args).
+		Warn("Restarting")
+
+	return execabs.Command(b.command, args...).Start() //nolint:gosec
+}
+
+// incrementRestartFlag increments the value of the restart flag.
+// If no such flag is present, it is added with initial value 1.
+func incrementRestartFlag(args []string) []string {
+	res := append([]string{}, args...)
+
+	hasFlag := false
+
+	for k, v := range res {
+		if v != "--restart" {
+			continue
+		}
+
+		hasFlag = true
+
+		if k+1 >= len(res) {
+			continue
+		}
+
+		n, err := strconv.Atoi(res[k+1])
+		if err != nil {
+			res[k+1] = "1"
+		} else {
+			res[k+1] = strconv.Itoa(n + 1)
+		}
+	}
+
+	if !hasFlag {
+		res = append(res, "--restart", "1")
+	}
+
+	return res
+}

internal/app/base/restart_test.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIncrementRestartFlag(t *testing.T) {
+	tests := []struct {
+		in  []string
+		out []string
+	}{
+		{[]string{"./bridge", "--restart", "1"}, []string{"./bridge", "--restart", "2"}},
+		{[]string{"./bridge", "--restart", "2"}, []string{"./bridge", "--restart", "3"}},
+		{[]string{"./bridge", "--other", "--restart", "2"}, []string{"./bridge", "--other", "--restart", "3"}},
+		{[]string{"./bridge", "--restart", "2", "--other"}, []string{"./bridge", "--restart", "3", "--other"}},
+		{[]string{"./bridge", "--restart", "2", "--other", "2"}, []string{"./bridge", "--restart", "3", "--other", "2"}},
+		{[]string{"./bridge"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--something"}, []string{"./bridge", "--something", "--restart", "1"}},
+		{[]string{"./bridge", "--something", "--else"}, []string{"./bridge", "--something", "--else", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad", "--other"}, []string{"./bridge", "--restart", "1", "--other"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(strings.Join(tt.in, " "), func(t *testing.T) {
+			assert.Equal(t, tt.out, incrementRestartFlag(tt.in))
+		})
+	}
+}

internal/app/bridge.go

@@ -1,163 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"fmt"
-	"net/http"
-	"runtime"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/imap"
-	"github.com/ProtonMail/go-autostart"
-	"github.com/ProtonMail/gopenpgp/v2/crypto"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/crash"
-	"github.com/ProtonMail/proton-bridge/v3/internal/dialer"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/sentry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/internal/versioner"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
-)
-
-// deleteOldGoIMAPFiles Set with `-ldflags -X app.deleteOldGoIMAPFiles=true` to enable cleanup of old imap cache data.
-var deleteOldGoIMAPFiles bool //nolint:gochecknoglobals
-
-// withBridge creates and tears down the bridge.
-func withBridge(
-	c *cli.Context,
-	exe string,
-	locations *locations.Locations,
-	version *semver.Version,
-	identifier *useragent.UserAgent,
-	crashHandler *crash.Handler,
-	reporter *sentry.Reporter,
-	vault *vault.Vault,
-	cookieJar http.CookieJar,
-	fn func(*bridge.Bridge, <-chan events.Event) error,
-) error {
-	logrus.Debug("Creating bridge")
-	defer logrus.Debug("Bridge stopped")
-
-	// Delete old go-imap cache files
-	if deleteOldGoIMAPFiles {
-		logrus.Debug("Deleting old go-imap cache files")
-
-		if err := locations.CleanGoIMAPCache(); err != nil {
-			logrus.WithError(err).Error("Failed to remove old go-imap cache")
-		}
-	}
-
-	// Create the underlying dialer used by the bridge.
-	// It only connects to trusted servers and reports any untrusted servers it finds.
-	pinningDialer := dialer.NewPinningTLSDialer(
-		dialer.NewBasicTLSDialer(constants.APIHost),
-		dialer.NewTLSReporter(constants.APIHost, constants.AppVersion(version.Original()), identifier, dialer.TrustedAPIPins),
-		dialer.NewTLSPinChecker(dialer.TrustedAPIPins),
-	)
-
-	// Create a proxy dialer which switches to a proxy if the request fails.
-	proxyDialer := dialer.NewProxyTLSDialer(pinningDialer, constants.APIHost, crashHandler)
-
-	// Create the autostarter.
-	autostarter := newAutostarter(exe)
-
-	// Create the update installer.
-	updater, err := newUpdater(locations)
-	if err != nil {
-		return fmt.Errorf("could not create updater: %w", err)
-	}
-
-	// Create a new bridge.
-	bridge, eventCh, err := bridge.New(
-		// The app stuff.
-		locations,
-		vault,
-		autostarter,
-		updater,
-		version,
-
-		// The API stuff.
-		constants.APIHost,
-		cookieJar,
-		identifier,
-		pinningDialer,
-		dialer.CreateTransportWithDialer(proxyDialer),
-		proxyDialer,
-
-		// Crash and report stuff
-		crashHandler,
-		reporter,
-		imap.DefaultEpochUIDValidityGenerator(),
-
-		// The logging stuff.
-		c.String(flagLogIMAP) == "client" || c.String(flagLogIMAP) == "all",
-		c.String(flagLogIMAP) == "server" || c.String(flagLogIMAP) == "all",
-		c.Bool(flagLogSMTP),
-	)
-	if err != nil {
-		return fmt.Errorf("could not create bridge: %w", err)
-	}
-
-	// Ensure we close bridge when we exit.
-	defer bridge.Close(c.Context)
-
-	return fn(bridge, eventCh)
-}
-
-func newAutostarter(exe string) *autostart.App {
-	logrus.Debug("Creating autostarter")
-
-	return &autostart.App{
-		Name:        constants.FullAppName,
-		DisplayName: constants.FullAppName,
-		Exec:        []string{exe, "--" + flagNoWindow},
-	}
-}
-
-func newUpdater(locations *locations.Locations) (*updater.Updater, error) {
-	updatesDir, err := locations.ProvideUpdatesPath()
-	if err != nil {
-		return nil, fmt.Errorf("could not provide updates path: %w", err)
-	}
-
-	logrus.WithField("updates", updatesDir).Debug("Creating updater")
-
-	key, err := crypto.NewKeyFromArmored(updater.DefaultPublicKey)
-	if err != nil {
-		return nil, fmt.Errorf("could not create key from armored: %w", err)
-	}
-
-	verifier, err := crypto.NewKeyRing(key)
-	if err != nil {
-		return nil, fmt.Errorf("could not create key ring: %w", err)
-	}
-
-	return updater.NewUpdater(
-		updater.NewInstaller(versioner.New(updatesDir)),
-		verifier,
-		constants.UpdateName,
-		runtime.GOOS,
-	), nil
-}

internal/app/bridge/bridge.go

@@ -0,0 +1,316 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+// Package bridge implements the bridge CLI application.
+package bridge
+
+import (
+	"crypto/tls"
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/api"
+	"github.com/ProtonMail/proton-bridge/v2/internal/app/base"
+	pkgBridge "github.com/ProtonMail/proton-bridge/v2/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
+	pkgTLS "github.com/ProtonMail/proton-bridge/v2/internal/config/tls"
+	"github.com/ProtonMail/proton-bridge/v2/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v2/internal/frontend"
+	"github.com/ProtonMail/proton-bridge/v2/internal/frontend/types"
+	"github.com/ProtonMail/proton-bridge/v2/internal/imap"
+	"github.com/ProtonMail/proton-bridge/v2/internal/smtp"
+	"github.com/ProtonMail/proton-bridge/v2/internal/store"
+	"github.com/ProtonMail/proton-bridge/v2/internal/store/cache"
+	"github.com/ProtonMail/proton-bridge/v2/internal/updater"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/message"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+const (
+	flagLogIMAP        = "log-imap"
+	flagLogSMTP        = "log-smtp"
+	flagNonInteractive = "noninteractive"
+
+	// Memory cache was estimated by empirical usage in past and it was set to 100MB.
+	// NOTE: This value must not be less than maximal size of one email (~30MB).
+	inMemoryCacheLimnit = 100 * (1 << 20)
+)
+
+func New(base *base.Base) *cli.App {
+	app := base.NewApp(mailLoop)
+
+	app.Flags = append(app.Flags, []cli.Flag{
+		&cli.StringFlag{
+			Name:  flagLogIMAP,
+			Usage: "Enable logging of IMAP communications (all|client|server) (may contain decrypted data!)",
+		},
+		&cli.BoolFlag{
+			Name:  flagLogSMTP,
+			Usage: "Enable logging of SMTP communications (may contain decrypted data!)",
+		},
+		&cli.BoolFlag{
+			Name:  flagNonInteractive,
+			Usage: "Start Bridge entirely noninteractively",
+		},
+	}...)
+
+	return app
+}
+
+func mailLoop(b *base.Base, c *cli.Context) error { //nolint:funlen
+	tlsConfig, err := loadTLSConfig(b)
+	if err != nil {
+		return err
+	}
+
+	// GODT-1481: Always turn off reporting of unencrypted recipient in v2.
+	b.Settings.SetBool(settings.ReportOutgoingNoEncKey, false)
+
+	cache, cacheErr := loadMessageCache(b)
+	if cacheErr != nil {
+		logrus.WithError(cacheErr).Error("Could not load local cache.")
+	}
+
+	builder := message.NewBuilder(
+		b.Settings.GetInt(settings.FetchWorkers),
+		b.Settings.GetInt(settings.AttachmentWorkers),
+	)
+
+	bridge := pkgBridge.New(
+		b.Locations,
+		b.Cache,
+		b.Settings,
+		b.SentryReporter,
+		b.CrashHandler,
+		b.Listener,
+		cache,
+		builder,
+		b.CM,
+		b.Creds,
+		b.Updater,
+		b.Versioner,
+		b.Autostart,
+	)
+	imapBackend := imap.NewIMAPBackend(b.CrashHandler, b.Listener, b.Cache, b.Settings, bridge)
+	smtpBackend := smtp.NewSMTPBackend(b.CrashHandler, b.Listener, b.Settings, bridge)
+
+	if cacheErr != nil {
+		bridge.AddError(pkgBridge.ErrLocalCacheUnavailable)
+	}
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		api.NewAPIServer(b.Settings, b.Listener).ListenAndServe()
+	}()
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		imapPort := b.Settings.GetInt(settings.IMAPPortKey)
+		imap.NewIMAPServer(
+			b.CrashHandler,
+			c.String(flagLogIMAP) == "client" || c.String(flagLogIMAP) == "all",
+			c.String(flagLogIMAP) == "server" || c.String(flagLogIMAP) == "all",
+			imapPort, tlsConfig, imapBackend, b.UserAgent, b.Listener).ListenAndServe()
+	}()
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		smtpPort := b.Settings.GetInt(settings.SMTPPortKey)
+		useSSL := b.Settings.GetBool(settings.SMTPSSLKey)
+		smtp.NewSMTPServer(
+			b.CrashHandler,
+			c.Bool(flagLogSMTP),
+			smtpPort, useSSL, tlsConfig, smtpBackend, b.Listener).ListenAndServe()
+	}()
+
+	// We want to remove old versions if the app exits successfully.
+	b.AddTeardownAction(b.Versioner.RemoveOldVersions)
+
+	// We want cookies to be saved to disk so they are loaded the next time.
+	b.AddTeardownAction(b.CookieJar.PersistCookies)
+
+	var frontendMode string
+
+	switch {
+	case c.Bool(base.FlagCLI):
+		frontendMode = "cli"
+	case c.Bool(flagNonInteractive):
+		return <-(make(chan error)) // Block forever.
+	default:
+		frontendMode = "qt"
+	}
+
+	f := frontend.New(
+		constants.Version,
+		constants.BuildVersion,
+		b.Name,
+		frontendMode,
+		!c.Bool(base.FlagNoWindow),
+		b.CrashHandler,
+		b.Locations,
+		b.Settings,
+		b.Listener,
+		b.Updater,
+		b.UserAgent,
+		bridge,
+		smtpBackend,
+		b,
+	)
+
+	// Watch for updates routine
+	go func() {
+		ticker := time.NewTicker(constants.UpdateCheckInterval)
+
+		for {
+			checkAndHandleUpdate(b.Updater, f, b.Settings.GetBool(settings.AutoUpdateKey))
+			<-ticker.C
+		}
+	}()
+
+	return f.Loop()
+}
+
+func loadTLSConfig(b *base.Base) (*tls.Config, error) {
+	if !b.TLS.HasCerts() {
+		if err := generateTLSCerts(b); err != nil {
+			return nil, err
+		}
+	}
+
+	tlsConfig, err := b.TLS.GetConfig()
+	if err == nil {
+		return tlsConfig, nil
+	}
+
+	logrus.WithError(err).Error("Failed to load TLS config, regenerating certificates")
+
+	if err := generateTLSCerts(b); err != nil {
+		return nil, err
+	}
+
+	return b.TLS.GetConfig()
+}
+
+func generateTLSCerts(b *base.Base) error {
+	template, err := pkgTLS.NewTLSTemplate()
+	if err != nil {
+		return errors.Wrap(err, "failed to generate TLS template")
+	}
+
+	if err := b.TLS.GenerateCerts(template); err != nil {
+		return errors.Wrap(err, "failed to generate TLS certs")
+	}
+
+	if err := b.TLS.InstallCerts(); err != nil {
+		return errors.Wrap(err, "failed to install TLS certs")
+	}
+
+	return nil
+}
+
+func checkAndHandleUpdate(u types.Updater, f frontend.Frontend, autoUpdate bool) {
+	log := logrus.WithField("pkg", "app/bridge")
+	version, err := u.Check()
+	if err != nil {
+		log.WithError(err).Error("An error occurred while checking for updates")
+		return
+	}
+
+	f.WaitUntilFrontendIsReady()
+
+	// Update links in UI
+	f.SetVersion(version)
+
+	if !u.IsUpdateApplicable(version) {
+		log.Info("No need to update")
+		return
+	}
+
+	log.WithField("version", version.Version).Info("An update is available")
+
+	if !autoUpdate {
+		f.NotifyManualUpdate(version, u.CanInstall(version))
+		return
+	}
+
+	if !u.CanInstall(version) {
+		log.Info("A manual update is required")
+		f.NotifySilentUpdateError(updater.ErrManualUpdateRequired)
+		return
+	}
+
+	if err := u.InstallUpdate(version); err != nil {
+		if errors.Cause(err) == updater.ErrDownloadVerify {
+			log.WithError(err).Warning("Skipping update installation due to temporary error")
+		} else {
+			log.WithError(err).Error("The update couldn't be installed")
+			f.NotifySilentUpdateError(err)
+		}
+
+		return
+	}
+
+	f.NotifySilentUpdateInstalled()
+}
+
+// loadMessageCache loads local cache in case it is enabled in settings and available.
+// In any other case it is returning in-memory cache. Could also return an error in case
+// local cache is enabled but unavailable (in-memory cache will be returned nevertheless).
+func loadMessageCache(b *base.Base) (cache.Cache, error) {
+	if !b.Settings.GetBool(settings.CacheEnabledKey) {
+		return cache.NewInMemoryCache(inMemoryCacheLimnit), nil
+	}
+
+	var compressor cache.Compressor
+
+	// NOTE(GODT-1158): Changing compression is not an option currently
+	// available for user but, if user changes compression setting we have
+	// to nuke the cache.
+	if b.Settings.GetBool(settings.CacheCompressionKey) {
+		compressor = &cache.GZipCompressor{}
+	} else {
+		compressor = &cache.NoopCompressor{}
+	}
+
+	var path string
+
+	if customPath := b.Settings.Get(settings.CacheLocationKey); customPath != "" {
+		path = customPath
+	} else {
+		path = b.Cache.GetDefaultMessageCacheDir()
+		// Store path so it will allways persist if default location
+		// will be changed in new version.
+		b.Settings.Set(settings.CacheLocationKey, path)
+	}
+
+	// To prevent memory peaks we set maximal write concurency for store
+	// build jobs.
+	store.SetBuildAndCacheJobLimit(b.Settings.GetInt(settings.CacheConcurrencyWrite))
+
+	messageCache, err := cache.NewOnDiskCache(path, compressor, cache.Options{
+		MinFreeAbs:      uint64(b.Settings.GetInt(settings.CacheMinFreeAbsKey)),
+		MinFreeRat:      b.Settings.GetFloat64(settings.CacheMinFreeRatKey),
+		ConcurrentRead:  b.Settings.GetInt(settings.CacheConcurrencyRead),
+		ConcurrentWrite: b.Settings.GetInt(settings.CacheConcurrencyWrite),
+	})
+	if err != nil {
+		return cache.NewInMemoryCache(inMemoryCacheLimnit), err
+	}
+
+	return messageCache, nil
+}

internal/app/frontend.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"fmt"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/crash"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	bridgeCLI "github.com/ProtonMail/proton-bridge/v3/internal/frontend/cli"
-	"github.com/ProtonMail/proton-bridge/v3/internal/frontend/grpc"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/restarter"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli/v2"
-)
-
-func runFrontend(
-	c *cli.Context,
-	crashHandler *crash.Handler,
-	restarter *restarter.Restarter,
-	locations *locations.Locations,
-	bridge *bridge.Bridge,
-	eventCh <-chan events.Event,
-	quitCh <-chan struct{},
-	parentPID int,
-) error {
-	logrus.Debug("Running frontend")
-	defer logrus.Debug("Frontend stopped")
-
-	switch {
-	case c.Bool(flagCLI):
-		return bridgeCLI.New(bridge, restarter, eventCh, crashHandler, quitCh).Loop()
-
-	case c.Bool(flagNonInteractive):
-		<-quitCh
-		return nil
-
-	case c.Bool(flagGRPC):
-		service, err := grpc.NewService(crashHandler, restarter, locations, bridge, eventCh, quitCh, !c.Bool(flagNoWindow), parentPID)
-		if err != nil {
-			return fmt.Errorf("could not create service: %w", err)
-		}
-
-		return service.Loop()
-
-	default:
-		if err := cli.ShowAppHelp(c); err != nil {
-			logrus.WithError(err).Error("Failed to show app help")
-		}
-
-		return fmt.Errorf("no frontend specified, use --cli, --grpc or --noninteractive")
-	}
-}

internal/app/migration.go

@@ -1,372 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/proton-bridge/v3/internal/legacy/credentials"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/algo"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/keychain"
-	"github.com/allan-simon/go-singleinstance"
-	"github.com/hashicorp/go-multierror"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-// nolint:gosec
-func migrateKeychainHelper(locations *locations.Locations) error {
-	logrus.Info("Migrating keychain helper")
-
-	settings, err := locations.ProvideSettingsPath()
-	if err != nil {
-		return fmt.Errorf("failed to get settings path: %w", err)
-	}
-
-	// If keychain helper file is already there do not migrate again.
-	if keychainName, _ := vault.GetHelper(settings); keychainName != "" {
-		return nil
-	}
-
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return fmt.Errorf("failed to get user config dir: %w", err)
-	}
-
-	b, err := os.ReadFile(filepath.Join(configDir, "protonmail", "bridge", "prefs.json"))
-	if errors.Is(err, fs.ErrNotExist) {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to read old prefs file: %w", err)
-	}
-
-	var prefs struct {
-		Helper string `json:"preferred_keychain"`
-	}
-
-	if err := json.Unmarshal(b, &prefs); err != nil {
-		return fmt.Errorf("failed to unmarshal old prefs file: %w", err)
-	}
-
-	return vault.SetHelper(settings, prefs.Helper)
-}
-
-// nolint:gosec
-func migrateOldSettings(v *vault.Vault) error {
-	logrus.Info("Migrating settings")
-
-	configDir, err := os.UserConfigDir()
-	if err != nil {
-		return fmt.Errorf("failed to get user config dir: %w", err)
-	}
-
-	return migrateOldSettingsWithDir(configDir, v)
-}
-
-// nolint:gosec
-func migrateOldSettingsWithDir(configDir string, v *vault.Vault) error {
-	b, err := os.ReadFile(filepath.Join(configDir, "protonmail", "bridge", "prefs.json"))
-	if errors.Is(err, fs.ErrNotExist) {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to read old prefs file: %w", err)
-	}
-
-	if err := migratePrefsToVault(v, b); err != nil {
-		return fmt.Errorf("failed to migrate prefs to vault: %w", err)
-	}
-
-	logrus.Info("Migrating TLS certificate")
-
-	certPEM, err := os.ReadFile(filepath.Join(configDir, "protonmail", "bridge", "cert.pem"))
-	if errors.Is(err, fs.ErrNotExist) {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to read old cert file: %w", err)
-	}
-
-	keyPEM, err := os.ReadFile(filepath.Join(configDir, "protonmail", "bridge", "key.pem"))
-	if errors.Is(err, fs.ErrNotExist) {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("failed to read old key file: %w", err)
-	}
-
-	return v.SetBridgeTLSCertKey(certPEM, keyPEM)
-}
-
-func migrateOldAccounts(locations *locations.Locations, v *vault.Vault) error {
-	logrus.Info("Migrating accounts")
-
-	settings, err := locations.ProvideSettingsPath()
-	if err != nil {
-		return fmt.Errorf("failed to get settings path: %w", err)
-	}
-
-	helper, err := vault.GetHelper(settings)
-	if err != nil {
-		return fmt.Errorf("failed to get helper: %w", err)
-	}
-
-	keychain, err := keychain.NewKeychain(helper, "bridge")
-	if err != nil {
-		return fmt.Errorf("failed to create keychain: %w", err)
-	}
-
-	store := credentials.NewStore(keychain)
-
-	users, err := store.List()
-	if err != nil {
-		return fmt.Errorf("failed to create credentials store: %w", err)
-	}
-
-	var migrationErrors error
-
-	for _, userID := range users {
-		if err := migrateOldAccount(userID, store, v); err != nil {
-			migrationErrors = multierror.Append(migrationErrors, err)
-		}
-	}
-
-	return migrationErrors
-}
-
-func migrateOldAccount(userID string, store *credentials.Store, v *vault.Vault) error {
-	l := logrus.WithField("userID", userID)
-	l.Info("Migrating account")
-
-	creds, err := store.Get(userID)
-	if err != nil {
-		return fmt.Errorf("failed to get user %q: %w", userID, err)
-	}
-
-	authUID, authRef, err := creds.SplitAPIToken()
-	if err != nil {
-		return fmt.Errorf("failed to split api token for user %q: %w", userID, err)
-	}
-
-	var primaryEmail string
-	if len(creds.EmailList()) > 0 {
-		primaryEmail = creds.EmailList()[0]
-	}
-
-	user, err := v.AddUser(creds.UserID, creds.Name, primaryEmail, authUID, authRef, creds.MailboxPassword)
-	if err != nil {
-		return fmt.Errorf("failed to add user %q: %w", userID, err)
-	}
-
-	l = l.WithField("username", logging.Sensitive(user.Username()))
-	l.Info("Migrated account with random bridge password")
-
-	defer func() {
-		if err := user.Close(); err != nil {
-			logrus.WithField("userID", userID).WithError(err).Error("Failed to close vault user after migration")
-		}
-	}()
-
-	dec, err := algo.B64RawDecode([]byte(creds.BridgePassword))
-	if err != nil {
-		return fmt.Errorf("failed to decode bridge password for user %q: %w", userID, err)
-	}
-
-	if err := user.SetBridgePass(dec); err != nil {
-		return fmt.Errorf("failed to set bridge password for user %q: %w", userID, err)
-	}
-
-	l = l.WithField("password", logging.Sensitive(string(algo.B64RawEncode(dec))))
-	l.Info("Migrated existing bridge password")
-
-	if !creds.IsCombinedAddressMode {
-		if err := user.SetAddressMode(vault.SplitMode); err != nil {
-			return fmt.Errorf("failed to set split address mode to user %q: %w", userID, err)
-		}
-	}
-
-	return nil
-}
-
-func migratePrefsToVault(vault *vault.Vault, b []byte) error {
-	var prefs struct {
-		IMAPPort int  `json:"user_port_imap,,string"`
-		SMTPPort int  `json:"user_port_smtp,,string"`
-		SMTPSSL  bool `json:"user_ssl_smtp,,string"`
-
-		AutoUpdate    bool            `json:"autoupdate,,string"`
-		UpdateChannel updater.Channel `json:"update_channel"`
-		UpdateRollout float64         `json:"rollout,,string"`
-
-		FirstStart  bool            `json:"first_time_start,,string"`
-		ColorScheme string          `json:"color_scheme"`
-		LastVersion *semver.Version `json:"last_used_version"`
-		Autostart   bool            `json:"autostart,,string"`
-
-		AllowProxy        bool `json:"allow_proxy,,string"`
-		FetchWorkers      int  `json:"fetch_workers,,string"`
-		AttachmentWorkers int  `json:"attachment_workers,,string"`
-		ShowAllMail       bool `json:"is_all_mail_visible,,string"`
-
-		Cookies string `json:"cookies"`
-	}
-
-	if err := json.Unmarshal(b, &prefs); err != nil {
-		return fmt.Errorf("failed to unmarshal old prefs file: %w", err)
-	}
-
-	var errs error
-
-	if err := vault.SetIMAPPort(prefs.IMAPPort); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate IMAP port: %w", err))
-	}
-
-	if err := vault.SetSMTPPort(prefs.SMTPPort); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate SMTP port: %w", err))
-	}
-
-	if err := vault.SetSMTPSSL(prefs.SMTPSSL); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate SMTP SSL: %w", err))
-	}
-
-	if err := vault.SetAutoUpdate(prefs.AutoUpdate); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate auto update: %w", err))
-	}
-
-	if err := vault.SetUpdateChannel(prefs.UpdateChannel); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate update channel: %w", err))
-	}
-
-	if err := vault.SetUpdateRollout(prefs.UpdateRollout); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate rollout: %w", err))
-	}
-
-	if err := vault.SetFirstStart(prefs.FirstStart); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate first start: %w", err))
-	}
-
-	if err := vault.SetColorScheme(prefs.ColorScheme); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate color scheme: %w", err))
-	}
-
-	if err := vault.SetLastVersion(prefs.LastVersion); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate last version: %w", err))
-	}
-
-	if err := vault.SetAutostart(prefs.Autostart); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate autostart: %w", err))
-	}
-
-	if err := vault.SetProxyAllowed(prefs.AllowProxy); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate allow proxy: %w", err))
-	}
-
-	if err := vault.SetShowAllMail(prefs.ShowAllMail); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate show all mail: %w", err))
-	}
-
-	if err := vault.SetCookies([]byte(prefs.Cookies)); err != nil {
-		errs = multierror.Append(errs, fmt.Errorf("failed to migrate cookies: %w", err))
-	}
-
-	return errs
-}
-
-func migrateOldVersions() (allErrors error) {
-	cacheDir, cacheError := os.UserCacheDir()
-	if cacheError != nil {
-		allErrors = multierror.Append(allErrors, errors.Wrap(cacheError, "cannot get os cache"))
-		return // not need to continue for now (with more migrations might be still ok to continue)
-	}
-
-	if err := killV2AppAndRemoveV2LockFiles(filepath.Join(cacheDir, "protonmail", "bridge", "bridge.lock")); err != nil {
-		allErrors = multierror.Append(allErrors, errors.Wrap(err, "cannot migrate lockfiles"))
-	}
-
-	return
-}
-
-func killV2AppAndRemoveV2LockFiles(lockFilePathV2 string) error {
-	l := logrus.WithField("path", lockFilePathV2)
-
-	if _, err := os.Stat(lockFilePathV2); os.IsNotExist(err) {
-		l.Debug("no v2 lockfile")
-		return nil
-	}
-
-	lock, err := singleinstance.CreateLockFile(lockFilePathV2)
-
-	if err == nil {
-		l.Debug("no other v2 instance is running")
-
-		if errClose := lock.Close(); errClose != nil {
-			l.WithError(errClose).Error("Cannot close lock file")
-		}
-
-		return os.Remove(lockFilePathV2)
-	}
-
-	// The other instance is an older version, so we should kill it.
-	pid, err := getPID(lockFilePathV2)
-	if err != nil {
-		return errors.Wrap(err, "cannot get v2 pid")
-	}
-
-	if err := killPID(pid); err != nil {
-		return errors.Wrapf(err, "cannot kill v2 app (PID %d)", pid)
-	}
-
-	// Need to wait some time to release file lock
-	time.Sleep(time.Second)
-
-	return nil
-}
-
-func getPID(lockFilePath string) (int, error) {
-	file, err := os.Open(filepath.Clean(lockFilePath))
-	if err != nil {
-		return 0, err
-	}
-	defer func() { _ = file.Close() }()
-
-	rawPID := make([]byte, 10) // PID is probably up to 7 digits long, 10 should be enough
-	n, err := file.Read(rawPID)
-	if err != nil {
-		return 0, err
-	}
-
-	return strconv.Atoi(strings.TrimSpace(string(rawPID[:n])))
-}
-
-func killPID(pid int) error {
-	p, err := os.FindProcess(pid)
-	if err != nil {
-		return err
-	}
-
-	return p.Kill()
-}

internal/app/migration_test.go

@@ -1,230 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/gopenpgp/v2/crypto"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/cookies"
-	"github.com/ProtonMail/proton-bridge/v3/internal/legacy/credentials"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/algo"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/keychain"
-	dockerCredentials "github.com/docker/docker-credential-helpers/credentials"
-	"github.com/stretchr/testify/require"
-)
-
-func TestMigratePrefsToVaultWithKeys(t *testing.T) {
-	// Create a new vault.
-	vault, corrupt, err := vault.New(t.TempDir(), t.TempDir(), []byte("my secret key"), async.NoopPanicHandler{})
-	require.NoError(t, err)
-	require.False(t, corrupt)
-
-	// load the old prefs file.
-	configDir := filepath.Join("testdata", "with_keys")
-
-	// Migrate the old prefs file to the new vault.
-	require.NoError(t, migrateOldSettingsWithDir(configDir, vault))
-
-	// Check Json Settings
-	validateJSONPrefs(t, vault)
-
-	cert, key := vault.GetBridgeTLSCert()
-	// Check the keys were found and collected.
-	require.Equal(t, "-----BEGIN CERTIFICATE-----", string(cert))
-	require.Equal(t, "-----BEGIN RSA PRIVATE KEY-----", string(key))
-}
-
-func TestMigratePrefsToVaultWithoutKeys(t *testing.T) {
-	// Create a new vault.
-	vault, corrupt, err := vault.New(t.TempDir(), t.TempDir(), []byte("my secret key"), async.NoopPanicHandler{})
-	require.NoError(t, err)
-	require.False(t, corrupt)
-
-	// load the old prefs file.
-	configDir := filepath.Join("testdata", "without_keys")
-
-	// Migrate the old prefs file to the new vault.
-	require.NoError(t, migrateOldSettingsWithDir(configDir, vault))
-
-	// Migrate the old prefs file to the new vault.
-	require.NoError(t, migrateOldSettingsWithDir(configDir, vault))
-
-	// Check Json Settings
-	validateJSONPrefs(t, vault)
-
-	// Check the keys were found and collected.
-	cert, key := vault.GetBridgeTLSCert()
-	require.NotEqual(t, []byte("-----BEGIN CERTIFICATE-----"), cert)
-	require.NotEqual(t, []byte("-----BEGIN RSA PRIVATE KEY-----"), key)
-}
-
-func TestKeychainMigration(t *testing.T) {
-	// Migration tested only for linux.
-	if runtime.GOOS != "linux" {
-		return
-	}
-
-	tmpDir := t.TempDir()
-
-	// Prepare for keychain migration test
-	{
-		require.NoError(t, os.Setenv("XDG_CONFIG_HOME", tmpDir))
-		oldCacheDir := filepath.Join(tmpDir, "protonmail", "bridge")
-		require.NoError(t, os.MkdirAll(oldCacheDir, 0o700))
-
-		oldPrefs, err := os.ReadFile(filepath.Join("testdata", "without_keys", "protonmail", "bridge", "prefs.json"))
-		require.NoError(t, err)
-
-		require.NoError(t, os.WriteFile(
-			filepath.Join(oldCacheDir, "prefs.json"),
-			oldPrefs, 0o600,
-		))
-	}
-
-	locations := locations.New(bridge.NewTestLocationsProvider(tmpDir), "config-name")
-	settingsFolder, err := locations.ProvideSettingsPath()
-	require.NoError(t, err)
-
-	// Check that there is nothing yet
-	keychainName, err := vault.GetHelper(settingsFolder)
-	require.NoError(t, err)
-	require.Equal(t, "", keychainName)
-
-	// Check migration
-	require.NoError(t, migrateKeychainHelper(locations))
-	keychainName, err = vault.GetHelper(settingsFolder)
-	require.NoError(t, err)
-	require.Equal(t, "secret-service", keychainName)
-
-	// Change the migrated value
-	require.NoError(t, vault.SetHelper(settingsFolder, "different"))
-
-	// Calling migration again will not overwrite existing prefs
-	require.NoError(t, migrateKeychainHelper(locations))
-	keychainName, err = vault.GetHelper(settingsFolder)
-	require.NoError(t, err)
-	require.Equal(t, "different", keychainName)
-}
-
-func TestUserMigration(t *testing.T) {
-	keychainHelper := keychain.NewTestHelper()
-
-	keychain.Helpers["mock"] = func(string) (dockerCredentials.Helper, error) { return keychainHelper, nil }
-
-	kc, err := keychain.NewKeychain("mock", "bridge")
-	require.NoError(t, err)
-
-	require.NoError(t, kc.Put("brokenID", "broken"))
-	require.NoError(t, kc.Put(
-		"emptyID",
-		(&credentials.Credentials{}).Marshal(),
-	))
-
-	wantUID := "uidtoken"
-	wantRefresh := "refreshtoken"
-
-	wantCredentials := credentials.Credentials{
-		UserID:                "validID",
-		Name:                  "user@pm.me",
-		Emails:                "user@pm.me;alias@pm.me",
-		APIToken:              wantUID + ":" + wantRefresh,
-		MailboxPassword:       []byte("secret"),
-		BridgePassword:        "bElu2Q1Vusy28J3Wf56cIg",
-		Version:               "v2.3.X",
-		Timestamp:             100,
-		IsCombinedAddressMode: true,
-	}
-	require.NoError(t, kc.Put(
-		wantCredentials.UserID,
-		wantCredentials.Marshal(),
-	))
-
-	tmpDir := t.TempDir()
-	locations := locations.New(bridge.NewTestLocationsProvider(tmpDir), "config-name")
-	settingsFolder, err := locations.ProvideSettingsPath()
-	require.NoError(t, err)
-	require.NoError(t, vault.SetHelper(settingsFolder, "mock"))
-
-	token, err := crypto.RandomToken(32)
-	require.NoError(t, err)
-
-	v, corrupt, err := vault.New(settingsFolder, settingsFolder, token, async.NoopPanicHandler{})
-	require.NoError(t, err)
-	require.False(t, corrupt)
-
-	require.NoError(t, migrateOldAccounts(locations, v))
-	require.Equal(t, []string{wantCredentials.UserID}, v.GetUserIDs())
-
-	require.NoError(t, v.GetUser(wantCredentials.UserID, func(u *vault.User) {
-		require.Equal(t, wantCredentials.UserID, u.UserID())
-		require.Equal(t, wantUID, u.AuthUID())
-		require.Equal(t, wantRefresh, u.AuthRef())
-		require.Equal(t, wantCredentials.MailboxPassword, u.KeyPass())
-		require.Equal(t,
-			[]byte(wantCredentials.BridgePassword),
-			algo.B64RawEncode(u.BridgePass()),
-		)
-		require.Equal(t, vault.CombinedMode, u.AddressMode())
-	}))
-}
-
-func validateJSONPrefs(t *testing.T, vault *vault.Vault) {
-	// Check that the IMAP and SMTP prefs are migrated.
-	require.Equal(t, 2143, vault.GetIMAPPort())
-	require.Equal(t, 2025, vault.GetSMTPPort())
-	require.True(t, vault.GetSMTPSSL())
-
-	// Check that the update channel is migrated.
-	require.True(t, vault.GetAutoUpdate())
-	require.Equal(t, updater.EarlyChannel, vault.GetUpdateChannel())
-	require.Equal(t, 0.4849529004202015, vault.GetUpdateRollout())
-
-	// Check that the app settings have been migrated.
-	require.False(t, vault.GetFirstStart())
-	require.Equal(t, "blablabla", vault.GetColorScheme())
-	require.Equal(t, "2.3.0+git", vault.GetLastVersion().String())
-	require.True(t, vault.GetAutostart())
-
-	// Check that the other app settings have been migrated.
-	require.False(t, vault.GetProxyAllowed())
-	require.False(t, vault.GetShowAllMail())
-
-	// Check that the cookies have been migrated.
-	jar, err := cookiejar.New(nil)
-	require.NoError(t, err)
-
-	cookies, err := cookies.NewCookieJar(jar, vault)
-	require.NoError(t, err)
-
-	url, err := url.Parse("https://api.protonmail.ch")
-	require.NoError(t, err)
-
-	// There should be a cookie for the API.
-	require.NotEmpty(t, cookies.Cookies(url))
-}

internal/app/singleinstance.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/proton-bridge/v3/internal/focus"
-	"github.com/allan-simon/go-singleinstance"
-	"github.com/sirupsen/logrus"
-)
-
-// checkSingleInstance checks if another instance of the application is already running.
-// It tries to create a lock file at the given path.
-// If it succeeds, it returns the lock file and a nil error.
-//
-// For macOS and Linux when already running version is older than this instance
-// it will kill old and continue with this new bridge (i.e. no error returned).
-func checkSingleInstance(settingPath, lockFilePath string, curVersion *semver.Version) (*os.File, error) {
-	if lock, err := singleinstance.CreateLockFile(lockFilePath); err == nil {
-		logrus.WithField("path", lockFilePath).Debug("Created lock file; no other instance is running")
-		return lock, nil
-	}
-
-	logrus.Warn("Failed to create lock file; another instance is running")
-
-	// We couldn't create the lock file, so another instance is probably running.
-	// Check if it's an older version of the app.
-	lastVersion, ok := focus.TryVersion(settingPath)
-	if !ok {
-		return nil, fmt.Errorf("failed to determine version of running instance")
-	}
-
-	if !lastVersion.LessThan(curVersion) {
-		return nil, fmt.Errorf("running instance is newer than this one")
-	}
-
-	// The other instance is an older version, so we should kill it.
-	pid, err := getPID(lockFilePath)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := killPID(pid); err != nil {
-		return nil, err
-	}
-
-	// Need to wait some time to release file lock
-	time.Sleep(time.Second)
-
-	return singleinstance.CreateLockFile(lockFilePath)
-}

internal/app/testdata/with_keys/protonmail/bridge/cert.pem

@@ -1 +0,0 @@
------BEGIN CERTIFICATE-----

internal/app/testdata/with_keys/protonmail/bridge/key.pem

@@ -1 +0,0 @@
------BEGIN RSA PRIVATE KEY-----

internal/app/testdata/with_keys/protonmail/bridge/prefs.json

@@ -1,31 +0,0 @@
-{
-	"allow_proxy": "false",
-	"attachment_workers": "16",
-	"autostart": "true",
-	"autoupdate": "true",
-	"cache_compression": "true",
-	"cache_concurrent_read": "16",
-	"cache_concurrent_write": "16",
-	"cache_enabled": "true",
-	"cache_location": "/home/user/.config/protonmail/bridge/cache/c11/messages",
-	"cache_min_free_abs": "250000000",
-	"cache_min_free_rat": "",
-	"color_scheme": "blablabla",
-	"cookies": "{\"https://api.protonmail.ch\":[{\"Name\":\"Session-Id\",\"Value\":\"blablablablablablablablabla\",\"Path\":\"/\",\"Domain\":\"protonmail.ch\",\"Expires\":\"2023-02-19T00:20:40.269424437+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":true,\"SameSite\":0,\"Raw\":\"Session-Id=blablablablablablablablabla; Domain=protonmail.ch; Path=/; HttpOnly; Secure; Max-Age=7776000\",\"Unparsed\":null},{\"Name\":\"Tag\",\"Value\":\"default\",\"Path\":\"/\",\"Domain\":\"\",\"Expires\":\"2023-02-19T00:20:40.269428627+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":false,\"SameSite\":0,\"Raw\":\"Tag=default; Path=/; Secure; Max-Age=7776000\",\"Unparsed\":null}],\"https://protonmail.com\":[{\"Name\":\"Session-Id\",\"Value\":\"blablablablablablablablabla\",\"Path\":\"/\",\"Domain\":\"protonmail.com\",\"Expires\":\"2023-02-19T00:20:18.315084712+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":true,\"SameSite\":0,\"Raw\":\"Session-Id=Y3q2Mh-ClvqL6LWeYdfyPgAAABI; Domain=protonmail.com; Path=/; HttpOnly; Secure; Max-Age=7776000\",\"Unparsed\":null},{\"Name\":\"Tag\",\"Value\":\"redirect\",\"Path\":\"/\",\"Domain\":\"\",\"Expires\":\"2023-02-19T00:20:18.315087646+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":false,\"SameSite\":0,\"Raw\":\"Tag=redirect; Path=/; Secure; Max-Age=7776000\",\"Unparsed\":null}]}",
-	"fetch_workers": "16",
-	"first_time_start": "false",
-	"first_time_start_gui": "true",
-	"imap_workers": "16",
-	"is_all_mail_visible": "false",
-	"last_heartbeat": "325",
-	"last_used_version": "2.3.0+git",
-	"preferred_keychain": "secret-service",
-	"rebranding_migrated": "true",
-	"report_outgoing_email_without_encryption": "false",
-	"rollout": "0.4849529004202015",
-	"user_port_api": "1042",
-	"update_channel": "early",
-	"user_port_imap": "2143",
-	"user_port_smtp": "2025",
-	"user_ssl_smtp": "true"
-}

internal/app/testdata/without_keys/protonmail/bridge/prefs.json

@@ -1,31 +0,0 @@
-{
-	"allow_proxy": "false",
-	"attachment_workers": "16",
-	"autostart": "true",
-	"autoupdate": "true",
-	"cache_compression": "true",
-	"cache_concurrent_read": "16",
-	"cache_concurrent_write": "16",
-	"cache_enabled": "true",
-	"cache_location": "/home/user/.config/protonmail/bridge/cache/c11/messages",
-	"cache_min_free_abs": "250000000",
-	"cache_min_free_rat": "",
-	"color_scheme": "blablabla",
-	"cookies": "{\"https://api.protonmail.ch\":[{\"Name\":\"Session-Id\",\"Value\":\"blablablablablablablablabla\",\"Path\":\"/\",\"Domain\":\"protonmail.ch\",\"Expires\":\"2023-02-19T00:20:40.269424437+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":true,\"SameSite\":0,\"Raw\":\"Session-Id=blablablablablablablablabla; Domain=protonmail.ch; Path=/; HttpOnly; Secure; Max-Age=7776000\",\"Unparsed\":null},{\"Name\":\"Tag\",\"Value\":\"default\",\"Path\":\"/\",\"Domain\":\"\",\"Expires\":\"2023-02-19T00:20:40.269428627+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":false,\"SameSite\":0,\"Raw\":\"Tag=default; Path=/; Secure; Max-Age=7776000\",\"Unparsed\":null}],\"https://protonmail.com\":[{\"Name\":\"Session-Id\",\"Value\":\"blablablablablablablablabla\",\"Path\":\"/\",\"Domain\":\"protonmail.com\",\"Expires\":\"2023-02-19T00:20:18.315084712+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":true,\"SameSite\":0,\"Raw\":\"Session-Id=Y3q2Mh-ClvqL6LWeYdfyPgAAABI; Domain=protonmail.com; Path=/; HttpOnly; Secure; Max-Age=7776000\",\"Unparsed\":null},{\"Name\":\"Tag\",\"Value\":\"redirect\",\"Path\":\"/\",\"Domain\":\"\",\"Expires\":\"2023-02-19T00:20:18.315087646+01:00\",\"RawExpires\":\"\",\"MaxAge\":7776000,\"Secure\":true,\"HttpOnly\":false,\"SameSite\":0,\"Raw\":\"Tag=redirect; Path=/; Secure; Max-Age=7776000\",\"Unparsed\":null}]}",
-	"fetch_workers": "16",
-	"first_time_start": "false",
-	"first_time_start_gui": "true",
-	"imap_workers": "16",
-	"is_all_mail_visible": "false",
-	"last_heartbeat": "325",
-	"last_used_version": "2.3.0+git",
-	"preferred_keychain": "secret-service",
-	"rebranding_migrated": "true",
-	"report_outgoing_email_without_encryption": "false",
-	"rollout": "0.4849529004202015",
-	"user_port_api": "1042",
-	"update_channel": "early",
-	"user_port_imap": "2143",
-	"user_port_smtp": "2025",
-	"user_ssl_smtp": "true"
-}

internal/app/vault.go

@@ -1,127 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package app
-
-import (
-	"fmt"
-	"path"
-
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/proton-bridge/v3/internal/certs"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/locations"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/keychain"
-	"github.com/sirupsen/logrus"
-)
-
-func WithVault(locations *locations.Locations, panicHandler async.PanicHandler, fn func(*vault.Vault, bool, bool) error) error {
-	logrus.Debug("Creating vault")
-	defer logrus.Debug("Vault stopped")
-
-	// Create the encVault.
-	encVault, insecure, corrupt, err := newVault(locations, panicHandler)
-	if err != nil {
-		return fmt.Errorf("could not create vault: %w", err)
-	}
-
-	logrus.WithFields(logrus.Fields{
-		"insecure": insecure,
-		"corrupt":  corrupt,
-	}).Debug("Vault created")
-
-	// Install the certificates if needed.
-	if installed := encVault.GetCertsInstalled(); !installed {
-		logrus.Debug("Installing certificates")
-
-		certPEM, _ := encVault.GetBridgeTLSCert()
-
-		if err := certs.NewInstaller().InstallCert(certPEM); err != nil {
-			return fmt.Errorf("failed to install certs: %w", err)
-		}
-
-		if err := encVault.SetCertsInstalled(true); err != nil {
-			return fmt.Errorf("failed to set certs installed: %w", err)
-		}
-
-		logrus.Debug("Certificates successfully installed")
-	}
-
-	// GODT-1950: Add teardown actions (e.g. to close the vault).
-
-	return fn(encVault, insecure, corrupt)
-}
-
-func newVault(locations *locations.Locations, panicHandler async.PanicHandler) (*vault.Vault, bool, bool, error) {
-	vaultDir, err := locations.ProvideSettingsPath()
-	if err != nil {
-		return nil, false, false, fmt.Errorf("could not get vault dir: %w", err)
-	}
-
-	logrus.WithField("vaultDir", vaultDir).Debug("Loading vault from directory")
-
-	var (
-		vaultKey []byte
-		insecure bool
-	)
-
-	if key, err := loadVaultKey(vaultDir); err != nil {
-		logrus.WithError(err).Error("Could not load/create vault key")
-		insecure = true
-
-		// We store the insecure vault in a separate directory
-		vaultDir = path.Join(vaultDir, "insecure")
-	} else {
-		vaultKey = key
-	}
-
-	gluonCacheDir, err := locations.ProvideGluonCachePath()
-	if err != nil {
-		return nil, false, false, fmt.Errorf("could not provide gluon path: %w", err)
-	}
-
-	vault, corrupt, err := vault.New(vaultDir, gluonCacheDir, vaultKey, panicHandler)
-	if err != nil {
-		return nil, false, false, fmt.Errorf("could not create vault: %w", err)
-	}
-
-	return vault, insecure, corrupt, nil
-}
-
-func loadVaultKey(vaultDir string) ([]byte, error) {
-	helper, err := vault.GetHelper(vaultDir)
-	if err != nil {
-		return nil, fmt.Errorf("could not get keychain helper: %w", err)
-	}
-
-	kc, err := keychain.NewKeychain(helper, constants.KeyChainName)
-	if err != nil {
-		return nil, fmt.Errorf("could not create keychain: %w", err)
-	}
-
-	has, err := vault.HasVaultKey(kc)
-	if err != nil {
-		return nil, fmt.Errorf("could not check for vault key: %w", err)
-	}
-
-	if has {
-		return vault.GetVaultKey(kc)
-	}
-
-	return vault.NewVaultKey(kc)
-}

internal/bridge/api.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"net/http"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/sirupsen/logrus"
-)
-
-// defaultAPIOptions returns a set of default API options for the given parameters.
-func defaultAPIOptions(
-	apiURL string,
-	version *semver.Version,
-	cookieJar http.CookieJar,
-	transport http.RoundTripper,
-	panicHandler async.PanicHandler,
-) []proton.Option {
-	return []proton.Option{
-		proton.WithHostURL(apiURL),
-		proton.WithAppVersion(constants.AppVersion(version.Original())),
-		proton.WithCookieJar(cookieJar),
-		proton.WithTransport(transport),
-		proton.WithLogger(logrus.StandardLogger()),
-		proton.WithPanicHandler(panicHandler),
-	}
-}

internal/bridge/api_default.go

@@ -1,39 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-//go:build !build_qa && !test_integration
-
-package bridge
-
-import (
-	"net/http"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/go-proton-api"
-)
-
-// newAPIOptions returns a set of API options for the given parameters.
-func newAPIOptions(
-	apiURL string,
-	version *semver.Version,
-	cookieJar http.CookieJar,
-	transport http.RoundTripper,
-	panicHandler async.PanicHandler,
-) []proton.Option {
-	return defaultAPIOptions(apiURL, version, cookieJar, transport, panicHandler)
-}

internal/bridge/api_qa.go

@@ -1,63 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-//go:build build_qa || test_integration
-
-package bridge
-
-import (
-	"crypto/tls"
-	"net/http"
-	"os"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/go-proton-api"
-)
-
-// newAPIOptions returns a set of API options for the given parameters.
-func newAPIOptions(
-	apiURL string,
-	version *semver.Version,
-	cookieJar http.CookieJar,
-	transport http.RoundTripper,
-	panicHandler async.PanicHandler,
-) []proton.Option {
-
-	if allow := os.Getenv("BRIDGE_ALLOW_PROXY"); allow != "" {
-		transport = &http.Transport{
-			Proxy:           http.ProxyFromEnvironment,
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-		}
-	}
-
-	opt := defaultAPIOptions(apiURL, version, cookieJar, transport, panicHandler)
-
-	if host := os.Getenv("BRIDGE_API_HOST"); host != "" {
-		opt = append(opt, proton.WithHostURL(host))
-	}
-
-	if debug := os.Getenv("BRIDGE_API_DEBUG"); debug != "" {
-		opt = append(opt, proton.WithDebug(true))
-	}
-
-	if skipVerify := os.Getenv("BRIDGE_API_SKIP_VERIFY"); skipVerify != "" {
-		opt = append(opt, proton.WithSkipVerifyProofs())
-	}
-
-	return opt
-}

internal/bridge/autostart.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -15,18 +15,24 @@
 // You should have received a copy of the GNU General Public License
 // along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
-package grpc
+// Package bridge provides core functionality of Bridge app.
+package bridge
 
-import "github.com/bradenaw/juniper/xslices"
+import "github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
 
-// isInternetStatus returns true iff the event is InternetStatus.
-func (x *StreamEvent) isInternetStatus() bool {
-	appEvent := x.GetApp()
-
-	return (appEvent != nil) && (appEvent.GetInternetStatus() != nil)
+// IsAutostartEnabled checks if link file exits.
+func (b *Bridge) IsAutostartEnabled() bool {
+	return b.autostart.IsEnabled()
 }
 
-// filterOutInternetStatusEvents return a copy of the events list where all internet connection events have been removed.
-func filterOutInternetStatusEvents(events []*StreamEvent) []*StreamEvent {
-	return xslices.Filter(events, func(event *StreamEvent) bool { return !event.isInternetStatus() })
+// EnableAutostart creates link and sets the preferences.
+func (b *Bridge) EnableAutostart() error {
+	b.settings.SetBool(settings.AutostartKey, true)
+	return b.autostart.Enable()
+}
+
+// DisableAutostart removes link and sets the preferences.
+func (b *Bridge) DisableAutostart() error {
+	b.settings.SetBool(settings.AutostartKey, false)
+	return b.autostart.Disable()
 }

internal/bridge/bridge.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -13,534 +13,292 @@
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
-// Package bridge implements the Bridge, which acts as the backend to the UI.
+// Package bridge provides core functionality of Bridge app.
 package bridge
 
 import (
-	"context"
-	"crypto/tls"
 	"errors"
 	"fmt"
-	"net/http"
-	"sync"
+	"strconv"
 	"time"
 
 	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon/async"
-	imapEvents "github.com/ProtonMail/gluon/events"
-	"github.com/ProtonMail/gluon/imap"
-	"github.com/ProtonMail/gluon/reporter"
-	"github.com/ProtonMail/gluon/watcher"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/focus"
-	"github.com/ProtonMail/proton-bridge/v3/internal/identifier"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/sentry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/imapsmtpserver"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/syncservice"
-	"github.com/ProtonMail/proton-bridge/v3/internal/telemetry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/go-resty/resty/v2"
-	"github.com/sirupsen/logrus"
+	"github.com/ProtonMail/go-autostart"
+	"github.com/ProtonMail/proton-bridge/v2/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/v2/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v2/internal/metrics"
+	"github.com/ProtonMail/proton-bridge/v2/internal/sentry"
+	"github.com/ProtonMail/proton-bridge/v2/internal/store/cache"
+	"github.com/ProtonMail/proton-bridge/v2/internal/updater"
+	"github.com/ProtonMail/proton-bridge/v2/internal/users"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/message"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/pmapi"
+
+	"github.com/ProtonMail/proton-bridge/v2/pkg/listener"
+	logrus "github.com/sirupsen/logrus"
 )
 
+var log = logrus.WithField("pkg", "bridge") //nolint:gochecknoglobals
+
+var ErrLocalCacheUnavailable = errors.New("local cache is unavailable")
+
 type Bridge struct {
-	// vault holds bridge-specific data, such as preferences and known users (authorized or not).
-	vault *vault.Vault
+	*users.Users
 
-	// users holds authorized users.
-	users     map[string]*user.User
-	usersLock safe.RWMutex
-
-	// api manages user API clients.
-	api        *proton.Manager
-	proxyCtl   ProxyController
-	identifier identifier.Identifier
-
-	// tlsConfig holds the bridge TLS config used by the IMAP and SMTP servers.
-	tlsConfig *tls.Config
-
-	// imapServer is the bridge's IMAP server.
-	imapEventCh chan imapEvents.Event
-
-	// updater is the bridge's updater.
-	updater   Updater
-	installCh chan installJob
-
-	// heartbeat is the telemetry heartbeat for metrics.
-	heartbeat telemetry.Heartbeat
-
-	// curVersion is the current version of the bridge,
-	// newVersion is the version that was installed by the updater.
-	curVersion     *semver.Version
-	newVersion     *semver.Version
-	newVersionLock safe.RWMutex
-
-	// focusService is used to raise the bridge window when needed.
-	focusService *focus.Service
-
-	// autostarter is the bridge's autostarter.
-	autostarter Autostarter
-
-	// locator is the bridge's locator.
-	locator Locator
-
-	// panicHandler
-	panicHandler async.PanicHandler
-
-	// reporter
-	reporter reporter.Reporter
-
-	// watchers holds all registered event watchers.
-	watchers     []*watcher.Watcher[events.Event]
-	watchersLock sync.RWMutex
-
-	// errors contains errors encountered during startup.
+	locations     Locator
+	settings      SettingsProvider
+	clientManager pmapi.Manager
+	updater       Updater
+	versioner     Versioner
+	cacheProvider CacheProvider
+	autostart     *autostart.App
+	// Bridge's global errors list.
 	errors []error
 
-	// These control the bridge's IMAP and SMTP logging behaviour.
-	logIMAPClient bool
-	logIMAPServer bool
-	logSMTP       bool
-
-	// These two variables keep track of the startup values for the two settings of the same name.
-	// They are updated in the vault on startup so that we're sure they're updated in case of kill/crash,
-	// but we need to keep their initial value for the current instance of bridge.
-	firstStart  bool
-	lastVersion *semver.Version
-
-	// tasks manages the bridge's goroutines.
-	tasks *async.Group
-
-	// goLoad triggers a load of disconnected users from the vault.
-	goLoad func()
-
-	// goUpdate triggers a check/install of updates.
-	goUpdate func()
-
-	// goHeartbeat triggers a check/sending if heartbeat is needed.
-	goHeartbeat func()
-
-	serverManager *imapsmtpserver.Service
-	syncService   *syncservice.Service
+	isFirstStart bool
+	lastVersion  string
 }
 
-// New creates a new bridge.
 func New(
-	locator Locator, // the locator to provide paths to store data
-	vault *vault.Vault, // the bridge's encrypted data store
-	autostarter Autostarter, // the autostarter to manage autostart settings
-	updater Updater, // the updater to fetch and install updates
-	curVersion *semver.Version, // the current version of the bridge
-
-	apiURL string, // the URL of the API to use
-	cookieJar http.CookieJar, // the cookie jar to use
-	identifier identifier.Identifier, // the identifier to keep track of the user agent
-	tlsReporter TLSReporter, // the TLS reporter to report TLS errors
-	roundTripper http.RoundTripper, // the round tripper to use for API requests
-	proxyCtl ProxyController, // the DoH controller
-	panicHandler async.PanicHandler,
-	reporter reporter.Reporter,
-	uidValidityGenerator imap.UIDValidityGenerator,
-
-	logIMAPClient, logIMAPServer bool, // whether to log IMAP client/server activity
-	logSMTP bool, // whether to log SMTP activity
-) (*Bridge, <-chan events.Event, error) {
-	// api is the user's API manager.
-	api := proton.New(newAPIOptions(apiURL, curVersion, cookieJar, roundTripper, panicHandler)...)
-
-	// tasks holds all the bridge's background tasks.
-	tasks := async.NewGroup(context.Background(), panicHandler)
-
-	// imapEventCh forwards IMAP events from gluon instances to the bridge for processing.
-	imapEventCh := make(chan imapEvents.Event)
-
-	// bridge is the bridge.
-	bridge, err := newBridge(
-		tasks,
-		imapEventCh,
-
-		locator,
-		vault,
-		autostarter,
-		updater,
-		curVersion,
-		panicHandler,
-		reporter,
-
-		api,
-		identifier,
-		proxyCtl,
-		uidValidityGenerator,
-		logIMAPClient, logIMAPServer, logSMTP,
-	)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create bridge: %w", err)
-	}
-
-	// Get an event channel for all events (individual events can be subscribed to later).
-	eventCh, _ := bridge.GetEvents()
-
-	// Initialize all of bridge's background tasks and operations.
-	if err := bridge.init(tlsReporter); err != nil {
-		return nil, nil, fmt.Errorf("failed to initialize bridge: %w", err)
-	}
-
-	return bridge, eventCh, nil
-}
-
-func newBridge(
-	tasks *async.Group,
-	imapEventCh chan imapEvents.Event,
-
-	locator Locator,
-	vault *vault.Vault,
-	autostarter Autostarter,
+	locations Locator,
+	cacheProvider CacheProvider,
+	setting SettingsProvider,
+	sentryReporter *sentry.Reporter,
+	panicHandler users.PanicHandler,
+	eventListener listener.Listener,
+	cache cache.Cache,
+	builder *message.Builder,
+	clientManager pmapi.Manager,
+	credStorer users.CredentialsStorer,
 	updater Updater,
-	curVersion *semver.Version,
-	panicHandler async.PanicHandler,
-	reporter reporter.Reporter,
-
-	api *proton.Manager,
-	identifier identifier.Identifier,
-	proxyCtl ProxyController,
-	uidValidityGenerator imap.UIDValidityGenerator,
-
-	logIMAPClient, logIMAPServer, logSMTP bool,
-) (*Bridge, error) {
-	tlsConfig, err := loadTLSConfig(vault)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load TLS config: %w", err)
+	versioner Versioner,
+	autostart *autostart.App,
+) *Bridge {
+	// Allow DoH before starting the app if the user has previously set this setting.
+	// This allows us to start even if protonmail is blocked.
+	if setting.GetBool(settings.AllowProxyKey) {
+		clientManager.AllowProxy()
 	}
 
-	firstStart := vault.GetFirstStart()
-	if err := vault.SetFirstStart(false); err != nil {
-		return nil, fmt.Errorf("failed to save first start indicator: %w", err)
-	}
-
-	lastVersion := vault.GetLastVersion()
-	if err := vault.SetLastVersion(curVersion); err != nil {
-		return nil, fmt.Errorf("failed to save last version indicator: %w", err)
-	}
-
-	identifier.SetClientString(vault.GetLastUserAgent())
-
-	focusService, err := focus.NewService(locator, curVersion, panicHandler)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create focus service: %w", err)
-	}
-
-	bridge := &Bridge{
-		vault: vault,
-
-		users:     make(map[string]*user.User),
-		usersLock: safe.NewRWMutex(),
-
-		api:        api,
-		proxyCtl:   proxyCtl,
-		identifier: identifier,
-
-		tlsConfig:   tlsConfig,
-		imapEventCh: imapEventCh,
-
-		updater:   updater,
-		installCh: make(chan installJob),
-
-		curVersion:     curVersion,
-		newVersion:     curVersion,
-		newVersionLock: safe.NewRWMutex(),
-
-		panicHandler: panicHandler,
-		reporter:     reporter,
-
-		focusService: focusService,
-		autostarter:  autostarter,
-		locator:      locator,
-
-		logIMAPClient: logIMAPClient,
-		logIMAPServer: logIMAPServer,
-		logSMTP:       logSMTP,
-
-		firstStart:  firstStart,
-		lastVersion: lastVersion,
-
-		tasks:       tasks,
-		syncService: syncservice.NewService(reporter, panicHandler),
-	}
-
-	bridge.serverManager = imapsmtpserver.NewService(context.Background(),
-		&bridgeSMTPSettings{b: bridge},
-		&bridgeIMAPSettings{b: bridge},
-		&bridgeEventPublisher{b: bridge},
+	u := users.New(
+		locations,
 		panicHandler,
-		reporter,
-		uidValidityGenerator,
-		&bridgeIMAPSMTPTelemetry{b: bridge},
+		eventListener,
+		clientManager,
+		credStorer,
+		newStoreFactory(cacheProvider, sentryReporter, panicHandler, eventListener, cache, builder),
 	)
 
-	if err := bridge.serverManager.Init(context.Background(), bridge.tasks, &bridgeEventSubscription{b: bridge}); err != nil {
-		return nil, err
+	b := &Bridge{
+		Users:         u,
+		locations:     locations,
+		settings:      setting,
+		clientManager: clientManager,
+		updater:       updater,
+		versioner:     versioner,
+		cacheProvider: cacheProvider,
+		autostart:     autostart,
+		isFirstStart:  false,
 	}
 
-	bridge.syncService.Run(bridge.tasks)
+	if setting.GetBool(settings.FirstStartKey) {
+		b.isFirstStart = true
+		if err := b.SendMetric(metrics.New(metrics.Setup, metrics.FirstStart, metrics.Label(constants.Version))); err != nil {
+			logrus.WithError(err).Error("Failed to send metric")
+		}
+		setting.SetBool(settings.FirstStartKey, false)
+	}
 
-	return bridge, nil
+	// Keep in bridge and update in settings the last used version.
+	b.lastVersion = b.settings.Get(settings.LastVersionKey)
+	b.settings.Set(settings.LastVersionKey, constants.Version)
+
+	go b.heartbeat()
+
+	return b
 }
 
-func (bridge *Bridge) init(tlsReporter TLSReporter) error {
-	// Enable or disable the proxy at startup.
-	if bridge.vault.GetProxyAllowed() {
-		bridge.proxyCtl.AllowProxy()
-	} else {
-		bridge.proxyCtl.DisallowProxy()
+// heartbeat sends a heartbeat signal once a day.
+func (b *Bridge) heartbeat() {
+	for range time.Tick(time.Minute) {
+		lastHeartbeatDay, err := strconv.ParseInt(b.settings.Get(settings.LastHeartbeatKey), 10, 64)
+		if err != nil {
+			continue
+		}
+
+		// If we're still on the same day, don't send a heartbeat.
+		if time.Now().YearDay() == int(lastHeartbeatDay) {
+			continue
+		}
+
+		// We're on the next (or a different) day, so send a heartbeat.
+		if err := b.SendMetric(metrics.New(metrics.Heartbeat, metrics.Daily, metrics.NoLabel)); err != nil {
+			logrus.WithError(err).Error("Failed to send heartbeat")
+			continue
+		}
+
+		// Heartbeat was sent successfully so update the last heartbeat day.
+		b.settings.Set(settings.LastHeartbeatKey, fmt.Sprintf("%v", time.Now().YearDay()))
+	}
+}
+
+// GetUpdateChannel returns currently set update channel.
+func (b *Bridge) GetUpdateChannel() updater.UpdateChannel {
+	return updater.UpdateChannel(b.settings.Get(settings.UpdateChannelKey))
+}
+
+// SetUpdateChannel switches update channel.
+func (b *Bridge) SetUpdateChannel(channel updater.UpdateChannel) {
+	b.settings.Set(settings.UpdateChannelKey, string(channel))
+}
+
+func (b *Bridge) resetToLatestStable() error {
+	version, err := b.updater.Check()
+	if err != nil {
+		// If we can not check for updates - just remove all local updates and reset to base installer version.
+		// Not using `b.locations.ClearUpdates()` because `versioner.RemoveOtherVersions` can also handle
+		// case when it is needed to remove currently running verion.
+		if err := b.versioner.RemoveOtherVersions(semver.MustParse("0.0.0")); err != nil {
+			log.WithError(err).Error("Failed to clear updates while downgrading channel")
+		}
+		return nil
 	}
 
-	// Handle connection up/down events.
-	bridge.api.AddStatusObserver(func(status proton.Status) {
-		logrus.Info("API status changed: ", status)
-
-		switch {
-		case status == proton.StatusUp:
-			bridge.publish(events.ConnStatusUp{})
-			bridge.tasks.Once(bridge.onStatusUp)
-
-		case status == proton.StatusDown:
-			bridge.publish(events.ConnStatusDown{})
-			bridge.tasks.Once(bridge.onStatusDown)
-		}
-	})
-
-	// If any call returns a bad version code, we need to update.
-	bridge.api.AddErrorHandler(proton.AppVersionBadCode, func() {
-		logrus.Warn("App version is bad")
-		bridge.publish(events.UpdateForced{})
-	})
-
-	// Ensure all outgoing headers have the correct user agent.
-	bridge.api.AddPreRequestHook(func(_ *resty.Client, req *resty.Request) error {
-		req.SetHeader("User-Agent", bridge.identifier.GetUserAgent())
+	// If current version is same as upstream stable version - do nothing.
+	if version.Version.Equal(semver.MustParse(constants.Version)) {
 		return nil
-	})
+	}
 
-	// Log all manager API requests (client requests are logged separately).
-	bridge.api.AddPostRequestHook(func(_ *resty.Client, r *resty.Response) error {
-		if _, ok := proton.ClientIDFromContext(r.Request.Context()); !ok {
-			logrus.Infof("[MANAGER] %v: %v %v", r.Status(), r.Request.Method, r.Request.URL)
+	if err := b.updater.InstallUpdate(version); err != nil {
+		return err
+	}
+
+	return b.versioner.RemoveOtherVersions(version.Version)
+}
+
+// FactoryReset will remove all local cache and settings.
+// It will also downgrade to latest stable version if user is on early version.
+func (b *Bridge) FactoryReset() {
+	wasEarly := b.GetUpdateChannel() == updater.EarlyChannel
+
+	b.settings.Set(settings.UpdateChannelKey, string(updater.StableChannel))
+
+	if wasEarly {
+		if err := b.resetToLatestStable(); err != nil {
+			log.WithError(err).Error("Failed to reset to latest stable version")
 		}
+	}
 
-		return nil
-	})
+	if err := b.Users.ClearData(); err != nil {
+		log.WithError(err).Error("Failed to remove bridge data")
+	}
 
-	// Publish a TLS issue event if a TLS issue is encountered.
-	bridge.tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, tlsReporter.GetTLSIssueCh(), func(struct{}) {
-			logrus.Warn("TLS issue encountered")
-			bridge.publish(events.TLSIssue{})
-		})
-	})
+	if err := b.Users.ClearUsers(); err != nil {
+		log.WithError(err).Error("Failed to remove bridge users")
+	}
+}
 
-	// Publish a raise event if the focus service is called.
-	bridge.tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, bridge.focusService.GetRaiseCh(), func(struct{}) {
-			logrus.Info("Focus service requested raise")
-			bridge.publish(events.Raise{})
-		})
-	})
+// GetKeychainApp returns current keychain helper.
+func (b *Bridge) GetKeychainApp() string {
+	return b.settings.Get(settings.PreferredKeychainKey)
+}
 
-	// Handle any IMAP events that are forwarded to the bridge from gluon.
-	bridge.tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, bridge.imapEventCh, func(event imapEvents.Event) {
-			logrus.WithField("event", fmt.Sprintf("%T", event)).Debug("Received IMAP event")
-			bridge.handleIMAPEvent(event)
-		})
-	})
+// SetKeychainApp sets current keychain helper.
+func (b *Bridge) SetKeychainApp(helper string) {
+	b.settings.Set(settings.PreferredKeychainKey, helper)
+}
 
-	// Attempt to load users from the vault when triggered.
-	bridge.goLoad = bridge.tasks.Trigger(func(ctx context.Context) {
-		if err := bridge.loadUsers(ctx); err != nil {
-			logrus.WithError(err).Error("Failed to load users")
-			if netErr := new(proton.NetError); !errors.As(err, &netErr) {
-				sentry.ReportError(bridge.reporter, "Failed to load users", err)
-			}
-			return
-		}
+func (b *Bridge) EnableCache() error {
+	if err := b.Users.EnableCache(); err != nil {
+		return err
+	}
 
-		bridge.publish(events.AllUsersLoaded{})
-	})
-	defer bridge.goLoad()
-
-	// Check for updates when triggered.
-	bridge.goUpdate = bridge.tasks.PeriodicOrTrigger(constants.UpdateCheckInterval, 0, func(ctx context.Context) {
-		logrus.Info("Checking for updates")
-
-		version, err := bridge.updater.GetVersionInfo(ctx, bridge.api, bridge.vault.GetUpdateChannel())
-		if err != nil {
-			bridge.publish(events.UpdateCheckFailed{Error: err})
-		} else {
-			bridge.handleUpdate(version)
-		}
-	})
-	defer bridge.goUpdate()
-
-	// Install updates when available.
-	bridge.tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, bridge.installCh, func(job installJob) {
-			bridge.installUpdate(ctx, job)
-		})
-	})
+	b.settings.SetBool(settings.CacheEnabledKey, true)
 
 	return nil
 }
 
-// GetEvents returns a channel of events of the given type.
-// If no types are supplied, all events are returned.
-func (bridge *Bridge) GetEvents(ofType ...events.Event) (<-chan events.Event, context.CancelFunc) {
-	watcher := bridge.addWatcher(ofType...)
-
-	return watcher.GetChannel(), func() { bridge.remWatcher(watcher) }
-}
-
-func (bridge *Bridge) PushError(err error) {
-	bridge.errors = append(bridge.errors, err)
-}
-
-func (bridge *Bridge) GetErrors() []error {
-	return bridge.errors
-}
-
-func (bridge *Bridge) Close(ctx context.Context) {
-	logrus.Info("Closing bridge")
-
-	// Close all users.
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.Close()
-		}
-	}, bridge.usersLock)
-
-	// Close the servers
-	if err := bridge.serverManager.CloseServers(ctx); err != nil {
-		logrus.WithError(err).Error("Failed to close servers")
+func (b *Bridge) DisableCache() error {
+	if err := b.Users.DisableCache(); err != nil {
+		return err
 	}
 
-	// Stop all ongoing tasks.
-	bridge.tasks.CancelAndWait()
+	b.settings.SetBool(settings.CacheEnabledKey, false)
+	// Reset back to the default location when disabling.
+	b.settings.Set(settings.CacheLocationKey, b.cacheProvider.GetDefaultMessageCacheDir())
 
-	// Close the focus service.
-	bridge.focusService.Close()
-
-	// Close the watchers.
-	bridge.watchersLock.Lock()
-	defer bridge.watchersLock.Unlock()
-
-	for _, watcher := range bridge.watchers {
-		watcher.Close()
-	}
-
-	bridge.watchers = nil
+	return nil
 }
 
-func (bridge *Bridge) publish(event events.Event) {
-	bridge.watchersLock.RLock()
-	defer bridge.watchersLock.RUnlock()
+func (b *Bridge) MigrateCache(from, to string) error {
+	if err := b.Users.MigrateCache(from, to); err != nil {
+		return err
+	}
 
-	logrus.WithField("event", event).Debug("Publishing event")
+	b.settings.Set(settings.CacheLocationKey, to)
 
-	for _, watcher := range bridge.watchers {
-		if watcher.IsWatching(event) {
-			if ok := watcher.Send(event); !ok {
-				logrus.WithField("event", event).Warn("Failed to send event to watcher")
-			}
-		}
+	return nil
+}
+
+// SetProxyAllowed instructs the app whether to use DoH to access an API proxy if necessary.
+// It also needs to work before the app is initialised (because we may need to use the proxy at startup).
+func (b *Bridge) SetProxyAllowed(proxyAllowed bool) {
+	b.settings.SetBool(settings.AllowProxyKey, proxyAllowed)
+	if proxyAllowed {
+		b.clientManager.AllowProxy()
+	} else {
+		b.clientManager.DisallowProxy()
 	}
 }
 
-func (bridge *Bridge) addWatcher(ofType ...events.Event) *watcher.Watcher[events.Event] {
-	bridge.watchersLock.Lock()
-	defer bridge.watchersLock.Unlock()
-
-	watcher := watcher.New(bridge.panicHandler, ofType...)
-
-	bridge.watchers = append(bridge.watchers, watcher)
-
-	return watcher
+// GetProxyAllowed returns whether use of DoH is enabled to access an API proxy if necessary.
+func (b *Bridge) GetProxyAllowed() bool {
+	return b.settings.GetBool(settings.AllowProxyKey)
 }
 
-func (bridge *Bridge) remWatcher(watcher *watcher.Watcher[events.Event]) {
-	bridge.watchersLock.Lock()
-	defer bridge.watchersLock.Unlock()
-
-	idx := xslices.Index(bridge.watchers, watcher)
-
-	if idx < 0 {
+// AddError add an error to a global error list if it does not contain it yet. Adding nil is noop.
+func (b *Bridge) AddError(err error) {
+	if err == nil {
+		return
+	}
+	if b.HasError(err) {
 		return
 	}
 
-	bridge.watchers = append(bridge.watchers[:idx], bridge.watchers[idx+1:]...)
-
-	watcher.Close()
+	b.errors = append(b.errors, err)
 }
 
-func (bridge *Bridge) onStatusUp(ctx context.Context) {
-	logrus.Info("Handling API status up")
-
-	safe.RLock(func() {
-		for _, user := range bridge.users {
-			user.OnStatusUp(ctx)
-		}
-	}, bridge.usersLock)
-
-	bridge.goLoad()
-}
-
-func (bridge *Bridge) onStatusDown(ctx context.Context) {
-	logrus.Info("Handling API status down")
-
-	safe.RLock(func() {
-		for _, user := range bridge.users {
-			user.OnStatusDown(ctx)
-		}
-	}, bridge.usersLock)
-
-	for backoff := time.Second; ; backoff = min(backoff*2, 30*time.Second) {
-		select {
-		case <-ctx.Done():
+// DelError removes an error from global error list.
+func (b *Bridge) DelError(err error) {
+	for idx, val := range b.errors {
+		if val == err {
+			b.errors = append(b.errors[:idx], b.errors[idx+1:]...)
 			return
-
-		case <-time.After(backoff):
-			logrus.Info("Pinging API")
-
-			if err := bridge.api.Ping(ctx); err != nil {
-				logrus.WithError(err).Warn("Ping failed, API is still unreachable")
-			} else {
-				return
-			}
 		}
 	}
 }
 
-func loadTLSConfig(vault *vault.Vault) (*tls.Config, error) {
-	cert, err := tls.X509KeyPair(vault.GetBridgeTLSCert())
-	if err != nil {
-		return nil, err
+// HasError returnes true if global error list contains an err.
+func (b *Bridge) HasError(err error) bool {
+	for _, val := range b.errors {
+		if val == err {
+			return true
+		}
 	}
 
-	return &tls.Config{
-		Certificates: []tls.Certificate{cert},
-		MinVersion:   tls.VersionTLS12,
-	}, nil
+	return false
 }
 
-func min(a, b time.Duration) time.Duration {
-	if a < b {
-		return a
-	}
-
-	return b
+// GetLastVersion returns the version which was used in previous execution of
+// Bridge.
+func (b *Bridge) GetLastVersion() string {
+	return b.lastVersion
+}
+
+// IsFirstStart returns true when Bridge is running for first time or after
+// factory reset.
+func (b *Bridge) IsFirstStart() bool {
+	return b.isFirstStart
 }

internal/bridge/bug_report.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -18,78 +18,190 @@
 package bridge
 
 import (
+	"archive/zip"
+	"bytes"
 	"context"
+	"errors"
 	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
 
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
+	"github.com/ProtonMail/proton-bridge/v2/internal/logging"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/pmapi"
 )
 
 const (
-	DefaultMaxBugReportZipSize         = 7 * 1024 * 1024
-	DefaultMaxSessionCountForBugReport = 10
+	MaxAttachmentSize       = 7 * 1024 * 1024 // 7 MB total limit
+	MaxCompressedFilesCount = 6
 )
 
-func (bridge *Bridge) ReportBug(ctx context.Context, osType, osVersion, title, description, username, email, client string, attachLogs bool) error {
-	var account string
+var ErrSizeTooLarge = errors.New("file is too big")
 
-	if info, err := bridge.QueryUserInfo(username); err == nil {
-		account = info.Username
-	} else if userIDs := bridge.GetUserIDs(); len(userIDs) > 0 {
-		if err := bridge.vault.GetUser(userIDs[0], func(user *vault.User) {
-			account = user.Username()
-		}); err != nil {
-			return err
-		}
+// ReportBug reports a new bug from the user.
+func (b *Bridge) ReportBug(osType, osVersion, description, accountName, address, emailClient string, attachLogs bool) error {
+	if user, err := b.GetUser(address); err == nil {
+		accountName = user.Username()
+	} else if users := b.GetUsers(); len(users) > 0 {
+		accountName = users[0].Username()
 	}
 
-	var attachment []proton.ReportBugAttachment
+	report := pmapi.ReportBugReq{
+		OS:          osType,
+		OSVersion:   osVersion,
+		Browser:     emailClient,
+		Title:       "[Bridge] Bug",
+		Description: description,
+		Username:    accountName,
+		Email:       address,
+	}
 
 	if attachLogs {
-		logsPath, err := bridge.locator.ProvideLogsPath()
+		logs, err := b.getMatchingLogs(
+			func(filename string) bool {
+				return logging.MatchLogName(filename) && !logging.MatchStackTraceName(filename)
+			},
+		)
 		if err != nil {
-			return err
+			log.WithError(err).Error("Can't get log files list")
+		}
+		crashes, err := b.getMatchingLogs(
+			func(filename string) bool {
+				return logging.MatchLogName(filename) && logging.MatchStackTraceName(filename)
+			},
+		)
+		if err != nil {
+			log.WithError(err).Error("Can't get crash files list")
 		}
 
-		buffer, err := logging.ZipLogsForBugReport(logsPath, DefaultMaxSessionCountForBugReport, DefaultMaxBugReportZipSize)
+		var matchFiles []string
+
+		matchFiles = append(matchFiles, logs[max(0, len(logs)-(MaxCompressedFilesCount/2)):]...)
+		matchFiles = append(matchFiles, crashes[max(0, len(crashes)-(MaxCompressedFilesCount/2)):]...)
+
+		archive, err := zipFiles(matchFiles)
 		if err != nil {
-			return err
+			log.WithError(err).Error("Can't zip logs and crashes")
 		}
 
-		body, err := io.ReadAll(buffer)
-		if err != nil {
-			return err
+		if archive != nil {
+			report.AddAttachment("logs.zip", "application/zip", archive)
 		}
-
-		attachment = append(attachment, proton.ReportBugAttachment{
-			Name:     "logs.zip",
-			Filename: "logs.zip",
-			MIMEType: "application/zip",
-			Body:     body,
-		})
 	}
 
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.ReportBugSent()
-		}
-	}, bridge.usersLock)
-
-	return bridge.api.ReportBug(ctx, proton.ReportBugReq{
-		OS:        osType,
-		OSVersion: osVersion,
-
-		Title:       "[Bridge] Bug - " + title,
-		Description: description,
-
-		Client:        client,
-		ClientType:    proton.ClientTypeEmail,
-		ClientVersion: constants.AppVersion(bridge.curVersion.Original()),
-
-		Username: account,
-		Email:    email,
-	}, attachment...)
+	return b.clientManager.ReportBug(context.Background(), report)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func (b *Bridge) getMatchingLogs(filenameMatchFunc func(string) bool) (filenames []string, err error) {
+	logsPath, err := b.locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+
+	files, err := ioutil.ReadDir(logsPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var matchFiles []string
+
+	for _, file := range files {
+		if filenameMatchFunc(file.Name()) {
+			matchFiles = append(matchFiles, filepath.Join(logsPath, file.Name()))
+		}
+	}
+	sort.Strings(matchFiles) // Sorted by timestamp: oldest first.
+
+	return matchFiles, nil
+}
+
+type LimitedBuffer struct {
+	capacity int
+	buf      *bytes.Buffer
+}
+
+func NewLimitedBuffer(capacity int) *LimitedBuffer {
+	return &LimitedBuffer{
+		capacity: capacity,
+		buf:      bytes.NewBuffer(make([]byte, 0, capacity)),
+	}
+}
+
+func (b *LimitedBuffer) Write(p []byte) (n int, err error) {
+	if len(p)+b.buf.Len() > b.capacity {
+		return 0, ErrSizeTooLarge
+	}
+
+	return b.buf.Write(p)
+}
+
+func (b *LimitedBuffer) Read(p []byte) (n int, err error) {
+	return b.buf.Read(p)
+}
+
+func zipFiles(filenames []string) (io.Reader, error) {
+	if len(filenames) == 0 {
+		return nil, nil
+	}
+
+	buf := NewLimitedBuffer(MaxAttachmentSize)
+
+	w := zip.NewWriter(buf)
+	defer w.Close() //nolint:errcheck
+
+	for _, file := range filenames {
+		err := addFileToZip(file, w)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if err := w.Close(); err != nil {
+		return nil, err
+	}
+
+	return buf, nil
+}
+
+func addFileToZip(filename string, writer *zip.Writer) error {
+	fileReader, err := os.Open(filepath.Clean(filename))
+	if err != nil {
+		return err
+	}
+	defer fileReader.Close() //nolint:errcheck,gosec
+
+	fileInfo, err := fileReader.Stat()
+	if err != nil {
+		return err
+	}
+
+	header, err := zip.FileInfoHeader(fileInfo)
+	if err != nil {
+		return err
+	}
+
+	header.Method = zip.Deflate
+	header.Name = filepath.Base(filename)
+
+	fileWriter, err := writer.CreateHeader(header)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(fileWriter, fileReader)
+	if err != nil {
+		return err
+	}
+
+	err = fileReader.Close()
+
+	return err
 }

internal/bridge/config_status.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-)
-
-func (bridge *Bridge) ReportBugClicked() {
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.ReportBugClicked()
-		}
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) AutoconfigUsed(client string) {
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.AutoconfigUsed(client)
-		}
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) KBArticleOpened(article string) {
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.KBArticleOpened(article)
-		}
-	}, bridge.usersLock)
-}

internal/bridge/configure.go

@@ -1,76 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"strings"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/clientconfig"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/sirupsen/logrus"
-)
-
-// ConfigureAppleMail configures apple mail for the given userID and address.
-// If configuring apple mail for Catalina or newer, it ensures Bridge is using SSL.
-func (bridge *Bridge) ConfigureAppleMail(ctx context.Context, userID, address string) error {
-	logrus.WithFields(logrus.Fields{
-		"userID":  userID,
-		"address": logging.Sensitive(address),
-	}).Info("Configuring Apple Mail")
-
-	return safe.RLockRet(func() error {
-		user, ok := bridge.users[userID]
-		if !ok {
-			return ErrNoSuchUser
-		}
-
-		if address == "" {
-			address = user.Emails()[0]
-		}
-
-		username := address
-		addresses := address
-
-		if user.GetAddressMode() == vault.CombinedMode {
-			username = user.Emails()[0]
-			addresses = strings.Join(user.Emails(), ",")
-		}
-
-		if useragent.IsCatalinaOrNewer() && !bridge.vault.GetSMTPSSL() {
-			if err := bridge.SetSMTPSSL(ctx, true); err != nil {
-				return err
-			}
-		}
-
-		return (&clientconfig.AppleMail{}).Configure(
-			constants.Host,
-			bridge.vault.GetIMAPPort(),
-			bridge.vault.GetSMTPPort(),
-			bridge.vault.GetIMAPSSL(),
-			bridge.vault.GetSMTPSSL(),
-			username,
-			addresses,
-			user.BridgePass(),
-		)
-	}, bridge.usersLock)
-}

internal/bridge/constants.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -15,10 +15,9 @@
 // You should have received a copy of the GNU General Public License
 // along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
-//go:build sensitive
+package bridge
 
-package logging
-
-func Sensitive(s string) string {
-	return s
-}
+// Host settings.
+const (
+	Host = "127.0.0.1"
+)

internal/bridge/debug.go

@@ -1,297 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/ProtonMail/gluon/imap"
-	"github.com/ProtonMail/gluon/rfc822"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/bradenaw/juniper/iterator"
-	"github.com/bradenaw/juniper/xslices"
-	goimap "github.com/emersion/go-imap"
-	goimapclient "github.com/emersion/go-imap/client"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/exp/maps"
-)
-
-type CheckClientStateResult struct {
-	MissingMessages map[string]map[string]user.DiagMailboxMessage
-}
-
-func (c *CheckClientStateResult) AddMissingMessage(userID string, message user.DiagMailboxMessage) {
-	v, ok := c.MissingMessages[userID]
-	if !ok {
-		c.MissingMessages[userID] = map[string]user.DiagMailboxMessage{message.ID: message}
-	} else {
-		v[message.ID] = message
-	}
-}
-
-// CheckClientState checks the current IMAP client reported state against the proton server state and reports
-// anything that is out of place.
-func (bridge *Bridge) CheckClientState(ctx context.Context, checkFlags bool, progressCB func(string)) (CheckClientStateResult, error) {
-	bridge.usersLock.RLock()
-	defer bridge.usersLock.RUnlock()
-
-	users := maps.Values(bridge.users)
-
-	result := CheckClientStateResult{
-		MissingMessages: make(map[string]map[string]user.DiagMailboxMessage),
-	}
-
-	for _, usr := range users {
-		if progressCB != nil {
-			progressCB(fmt.Sprintf("Checking state for user %v", usr.Name()))
-		}
-		log := logrus.WithField("user", usr.Name()).WithField("diag", "state-check")
-		log.Debug("Retrieving all server metadata")
-		meta, err := usr.GetDiagnosticMetadata(ctx)
-		if err != nil {
-			return result, err
-		}
-
-		success := true
-
-		if len(meta.Metadata) != len(meta.MessageIDs) {
-			log.Errorf("Metadata (%v) and message(%v) list sizes do not match", len(meta.Metadata), len(meta.MessageIDs))
-		}
-
-		log.Debug("Building state")
-		state, err := meta.BuildMailboxToMessageMap(ctx, usr)
-		if err != nil {
-			log.WithError(err).Error("Failed to build state")
-			return result, err
-		}
-
-		info, err := bridge.GetUserInfo(usr.ID())
-		if err != nil {
-			log.WithError(err).Error("Failed to get user info")
-			return result, err
-		}
-
-		addr := fmt.Sprintf("127.0.0.1:%v", bridge.GetIMAPPort())
-
-		for account, mboxMap := range state {
-			if progressCB != nil {
-				progressCB(fmt.Sprintf("Checking state for user %v's account '%v'", usr.Name(), account))
-			}
-			if err := func(account string, mboxMap user.AccountMailboxMap) error {
-				client, err := goimapclient.Dial(addr)
-				if err != nil {
-					log.WithError(err).Error("Failed to connect to imap client")
-					return err
-				}
-
-				defer func() {
-					_ = client.Logout()
-				}()
-
-				if err := client.Login(account, string(info.BridgePass)); err != nil {
-					return fmt.Errorf("failed to login for user %v:%w", usr.Name(), err)
-				}
-
-				log := log.WithField("account", account)
-				for mboxName, messageList := range mboxMap {
-					log := log.WithField("mbox", mboxName)
-					status, err := client.Select(mboxName, true)
-					if err != nil {
-						log.WithError(err).Errorf("Failed to select mailbox %v", messageList)
-						return fmt.Errorf("failed to select '%v':%w", mboxName, err)
-					}
-
-					log.Debug("Checking message count")
-
-					if int(status.Messages) != len(messageList) {
-						success = false
-						log.Errorf("Message count doesn't match, got '%v' expected '%v'", status.Messages, len(messageList))
-					}
-
-					ids, err := clientGetMessageIDs(client, mboxName)
-					if err != nil {
-						return fmt.Errorf("failed to get message ids for mbox '%v': %w", mboxName, err)
-					}
-
-					for _, msg := range messageList {
-						imapFlags, ok := ids[msg.ID]
-						if !ok {
-							if meta.FailedMessageIDs.Contains(msg.ID) {
-								log.Warningf("Missing message '%v', but it is part of failed message set", msg.ID)
-							} else {
-								log.Errorf("Missing message '%v'", msg.ID)
-							}
-
-							result.AddMissingMessage(msg.UserID, msg)
-							continue
-						}
-
-						if checkFlags {
-							if !imapFlags.Equals(msg.Flags) {
-								log.Errorf("Message '%v' flags do mot match, got=%v, expected=%v",
-									msg.ID,
-									imapFlags.ToSlice(),
-									msg.Flags.ToSlice(),
-								)
-							}
-						}
-					}
-				}
-
-				if !success {
-					log.Errorf("State does not match")
-				} else {
-					log.Info("State matches")
-				}
-
-				return nil
-			}(account, mboxMap); err != nil {
-				return result, err
-			}
-		}
-
-		// Check for orphaned messages (only present in All Mail)
-		if progressCB != nil {
-			progressCB(fmt.Sprintf("Checking user %v for orphans", usr.Name()))
-		}
-		log.Debugf("Checking for orphans")
-
-		for _, m := range meta.Metadata {
-			filteredLabels := xslices.Filter(m.LabelIDs, func(t string) bool {
-				switch t {
-				case proton.AllMailLabel:
-					return false
-				case proton.AllSentLabel:
-					return false
-				case proton.AllDraftsLabel:
-					return false
-				case proton.OutboxLabel:
-					return false
-				default:
-					return true
-				}
-			})
-
-			if len(filteredLabels) == 0 {
-				log.Warnf("Message %v is only present in All Mail (Subject=%v)", m.ID, m.Subject)
-			}
-		}
-	}
-
-	return result, nil
-}
-
-func (bridge *Bridge) DebugDownloadFailedMessages(
-	ctx context.Context,
-	result CheckClientStateResult,
-	exportPath string,
-	progressCB func(string, int, int),
-) error {
-	bridge.usersLock.RLock()
-	defer bridge.usersLock.RUnlock()
-
-	for userID, messages := range result.MissingMessages {
-		usr, ok := bridge.users[userID]
-		if !ok {
-			return fmt.Errorf("failed to find user with id %v", userID)
-		}
-
-		userDir := filepath.Join(exportPath, userID)
-		if err := os.MkdirAll(userDir, 0o700); err != nil {
-			return fmt.Errorf("failed to create directory '%v': %w", userDir, err)
-		}
-
-		if err := usr.DebugDownloadMessages(ctx, userDir, messages, progressCB); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func clientGetMessageIDs(client *goimapclient.Client, mailbox string) (map[string]imap.FlagSet, error) {
-	status, err := client.Select(mailbox, true)
-	if err != nil {
-		return nil, err
-	}
-
-	if status.Messages == 0 {
-		return nil, nil
-	}
-
-	resCh := make(chan *goimap.Message)
-
-	section, err := goimap.ParseBodySectionName("BODY[HEADER]")
-	if err != nil {
-		return nil, err
-	}
-
-	fetchItems := []goimap.FetchItem{"BODY[HEADER]", goimap.FetchFlags}
-
-	seq, err := goimap.ParseSeqSet("1:*")
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		if err := client.Fetch(
-			seq,
-			fetchItems,
-			resCh,
-		); err != nil {
-			panic(err)
-		}
-	}()
-
-	messages := iterator.Collect(iterator.Chan(resCh))
-
-	ids := make(map[string]imap.FlagSet, len(messages))
-
-	for i, m := range messages {
-		literal, err := io.ReadAll(m.GetBody(section))
-		if err != nil {
-			return nil, err
-		}
-
-		header, err := rfc822.NewHeader(literal)
-		if err != nil {
-			return nil, fmt.Errorf("failed to parse header for msg %v: %w", i, err)
-		}
-
-		internalID, ok := header.GetChecked("X-Pm-Internal-Id")
-		if !ok {
-			logrus.Errorf("Message %v does not have internal id", internalID)
-			continue
-		}
-
-		messageFlags := imap.NewFlagSet(m.Flags...)
-
-		// Recent and Deleted are not part of the proton flag set.
-		messageFlags.RemoveFromSelf("\\Recent")
-		messageFlags.RemoveFromSelf("\\Deleted")
-
-		ids[internalID] = messageFlags
-	}
-
-	return ids, nil
-}

internal/bridge/draft_test.go

@@ -1,175 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ProtonMail/gluon/rfc822"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	go_imap "github.com/emersion/go-imap"
-	"github.com/emersion/go-sasl"
-	"github.com/emersion/go-smtp"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_HandleDraftsSendFromOtherClient(t *testing.T) {
-	getGluonHeaderID := func(literal []byte) (string, string) {
-		h, err := rfc822.NewHeader(literal)
-		require.NoError(t, err)
-
-		gluonID, ok := h.GetChecked("X-Pm-Gluon-Id")
-		require.True(t, ok)
-
-		externalID, ok := h.GetChecked("Message-Id")
-		require.True(t, ok)
-
-		return gluonID, externalID
-	}
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		_, _, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		_, _, err = s.CreateUser("bar", password)
-		require.NoError(t, err)
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, _ *bridge.Mocks) {
-			waiter := waitForIMAPServerReady(b)
-			defer waiter.Done()
-
-			syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := b.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-			waiter.Wait()
-
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			// Create first draft in client.
-			literal := fmt.Sprintf(`From: %v
-To: %v
-Date: Fri, 3 Feb 2023 01:04:32 +0100
-Subject: Foo
-
-Hello
-`, info.Addresses[0], "bar@proton.local")
-
-			require.NoError(t, client.Append("Drafts", nil, time.Now(), strings.NewReader(literal)))
-			// Verify the draft is available in client.
-			require.Eventually(t, func() bool {
-				status, err := client.Status("Drafts", []go_imap.StatusItem{go_imap.StatusMessages})
-				require.NoError(t, err)
-				return status.Messages == 1
-			}, 2*time.Second, time.Second)
-
-			// Retrieve the new literal so we can have the Proton Message ID.
-			messages, err := clientFetch(client, "Drafts")
-			require.NoError(t, err)
-			require.Equal(t, 1, len(messages))
-
-			newLiteral, err := io.ReadAll(messages[0].GetBody(must(go_imap.ParseBodySectionName("BODY[]"))))
-			require.NoError(t, err)
-			logrus.Info(string(newLiteral))
-
-			newLiteralID, newLiteralExternID := getGluonHeaderID(newLiteral)
-
-			// Modify new literal.
-			newLiteralModified := append(newLiteral, []byte(" world from client2")...) //nolint:gocritic
-
-			func() {
-				smtpClient, err := smtp.Dial(net.JoinHostPort(constants.Host, fmt.Sprint(b.GetSMTPPort())))
-				require.NoError(t, err)
-				defer func() { _ = smtpClient.Close() }()
-
-				// Upgrade to TLS.
-				require.NoError(t, smtpClient.StartTLS(&tls.Config{InsecureSkipVerify: true}))
-
-				// Authorize with SASL PLAIN.
-				require.NoError(t, smtpClient.Auth(sasl.NewPlainClient(
-					info.Addresses[0],
-					info.Addresses[0],
-					string(info.BridgePass)),
-				))
-
-				// Send the message.
-				require.NoError(t, smtpClient.SendMail(
-					info.Addresses[0],
-					[]string{"bar@proton.local"},
-					bytes.NewReader(newLiteralModified),
-				))
-			}()
-
-			// Append message to Sent as the imap client would.
-			require.NoError(t, client.Append("Sent", nil, time.Now(), strings.NewReader(literal)))
-
-			// Verify the sent message gets updated with the new literal.
-			require.Eventually(t, func() bool {
-				// Check if sent message matches the latest draft.
-				messagesClient1, err := clientFetch(client, "Sent", "BODY[TEXT]", "BODY[]")
-				require.NoError(t, err)
-
-				if len(messagesClient1) != 1 {
-					return false
-				}
-
-				sentLiteral, err := io.ReadAll(messagesClient1[0].GetBody(must(go_imap.ParseBodySectionName("BODY[]"))))
-				require.NoError(t, err)
-
-				sentLiteralID, sentLiteralExternID := getGluonHeaderID(sentLiteral)
-
-				sentLiteralText, err := io.ReadAll(messagesClient1[0].GetBody(must(go_imap.ParseBodySectionName("BODY[TEXT]"))))
-				require.NoError(t, err)
-
-				sentLiteralStr := string(sentLiteralText)
-
-				literalMatches := sentLiteralStr == "Hello\r\n world from client2\r\n"
-
-				idIsDifferent := sentLiteralID != newLiteralID
-
-				externIDMatches := sentLiteralExternID == newLiteralExternID
-
-				return literalMatches && idIsDifferent && externIDMatches
-			}, 2*time.Second, time.Second)
-		})
-	}, server.WithMessageDedup())
-}

internal/bridge/errors.go

@@ -1,33 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import "errors"
-
-var (
-	ErrVaultInsecure = errors.New("the vault is insecure")
-	ErrVaultCorrupt  = errors.New("the vault is corrupt")
-	ErrWatchUpdates  = errors.New("failed to watch for updates")
-
-	ErrNoSuchUser          = errors.New("no such user")
-	ErrUserAlreadyExists   = errors.New("user already exists")
-	ErrUserAlreadyLoggedIn = errors.New("the user is already logged in")
-	ErrNotImplemented      = errors.New("not implemented")
-
-	ErrSizeTooLarge = errors.New("file is too big")
-)

internal/bridge/events.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-
-	"github.com/ProtonMail/gluon/watcher"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-)
-
-type bridgeEventSubscription struct {
-	b *Bridge
-}
-
-func (b bridgeEventSubscription) Add(ofType ...events.Event) *watcher.Watcher[events.Event] {
-	return b.b.addWatcher(ofType...)
-}
-
-func (b bridgeEventSubscription) Remove(watcher *watcher.Watcher[events.Event]) {
-	b.b.remWatcher(watcher)
-}
-
-type bridgeEventPublisher struct {
-	b *Bridge
-}
-
-func (b bridgeEventPublisher) PublishEvent(_ context.Context, event events.Event) {
-	b.b.publish(event)
-}

internal/bridge/heartbeat.go

@@ -1,128 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"encoding/json"
-	"time"
-
-	"github.com/ProtonMail/gluon/reporter"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/telemetry"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/keychain"
-	"github.com/sirupsen/logrus"
-)
-
-const HeartbeatCheckInterval = time.Hour
-
-func (bridge *Bridge) IsTelemetryAvailable(ctx context.Context) bool {
-	var flag = true
-	if bridge.GetTelemetryDisabled() {
-		return false
-	}
-
-	safe.RLock(func() {
-		for _, user := range bridge.users {
-			flag = flag && user.IsTelemetryEnabled(ctx)
-		}
-	}, bridge.usersLock)
-
-	return flag
-}
-
-func (bridge *Bridge) SendHeartbeat(ctx context.Context, heartbeat *telemetry.HeartbeatData) bool {
-	data, err := json.Marshal(heartbeat)
-	if err != nil {
-		if err := bridge.reporter.ReportMessageWithContext("Cannot parse heartbeat data.", reporter.Context{
-			"error": err,
-		}); err != nil {
-			logrus.WithError(err).Error("Failed to parse heartbeat data.")
-		}
-		return false
-	}
-
-	var sent = false
-
-	safe.RLock(func() {
-		for _, user := range bridge.users {
-			if err := user.SendTelemetry(ctx, data); err == nil {
-				sent = true
-				break
-			}
-		}
-	}, bridge.usersLock)
-
-	return sent
-}
-
-func (bridge *Bridge) GetLastHeartbeatSent() time.Time {
-	return bridge.vault.GetLastHeartbeatSent()
-}
-
-func (bridge *Bridge) SetLastHeartbeatSent(timestamp time.Time) error {
-	return bridge.vault.SetLastHeartbeatSent(timestamp)
-}
-
-func (bridge *Bridge) StartHeartbeat(manager telemetry.HeartbeatManager) {
-	bridge.heartbeat = telemetry.NewHeartbeat(manager, 1143, 1025, bridge.GetGluonCacheDir(), keychain.DefaultHelper)
-
-	// Check for heartbeat when triggered.
-	bridge.goHeartbeat = bridge.tasks.PeriodicOrTrigger(HeartbeatCheckInterval, 0, func(ctx context.Context) {
-		logrus.Debug("Checking for heartbeat")
-
-		bridge.heartbeat.TrySending(ctx)
-	})
-
-	bridge.heartbeat.SetRollout(bridge.GetUpdateRollout())
-	bridge.heartbeat.SetAutoStart(bridge.GetAutostart())
-	bridge.heartbeat.SetAutoUpdate(bridge.GetAutoUpdate())
-	bridge.heartbeat.SetBeta(bridge.GetUpdateChannel())
-	bridge.heartbeat.SetDoh(bridge.GetProxyAllowed())
-	bridge.heartbeat.SetShowAllMail(bridge.GetShowAllMail())
-	bridge.heartbeat.SetIMAPConnectionMode(bridge.GetIMAPSSL())
-	bridge.heartbeat.SetSMTPConnectionMode(bridge.GetSMTPSSL())
-	bridge.heartbeat.SetIMAPPort(bridge.GetIMAPPort())
-	bridge.heartbeat.SetSMTPPort(bridge.GetSMTPPort())
-	bridge.heartbeat.SetCacheLocation(bridge.GetGluonCacheDir())
-	if val, err := bridge.GetKeychainApp(); err != nil {
-		bridge.heartbeat.SetKeyChainPref(val)
-	} else {
-		bridge.heartbeat.SetKeyChainPref(keychain.DefaultHelper)
-	}
-	bridge.heartbeat.SetPrevVersion(bridge.GetLastVersion().String())
-
-	safe.RLock(func() {
-		var splitMode = false
-		for _, user := range bridge.users {
-			if user.GetAddressMode() == vault.SplitMode {
-				splitMode = true
-				break
-			}
-		}
-		var nbAccount = len(bridge.users)
-		bridge.heartbeat.SetNbAccount(nbAccount)
-		bridge.heartbeat.SetSplitMode(splitMode)
-
-		// Do not try to send if there is no user yet.
-		if nbAccount > 0 {
-			defer bridge.goHeartbeat()
-		}
-	}, bridge.usersLock)
-}

internal/bridge/identifier.go

@@ -1,74 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import "github.com/sirupsen/logrus"
-
-func (bridge *Bridge) GetCurrentUserAgent() string {
-	return bridge.identifier.GetUserAgent()
-}
-
-func (bridge *Bridge) SetCurrentPlatform(platform string) {
-	bridge.identifier.SetPlatform(platform)
-}
-
-func (bridge *Bridge) setUserAgent(name, version string) {
-	currentUserAgent := bridge.identifier.GetClientString()
-
-	bridge.identifier.SetClient(name, version)
-
-	newUserAgent := bridge.identifier.GetClientString()
-
-	if currentUserAgent != newUserAgent {
-		if err := bridge.vault.SetLastUserAgent(newUserAgent); err != nil {
-			logrus.WithError(err).Error("Failed to write new user agent to vault")
-		}
-	}
-}
-
-type bridgeUserAgentUpdater struct {
-	*Bridge
-}
-
-func (b *bridgeUserAgentUpdater) GetUserAgent() string {
-	return b.identifier.GetUserAgent()
-}
-
-func (b *bridgeUserAgentUpdater) HasClient() bool {
-	return b.identifier.HasClient()
-}
-
-func (b *bridgeUserAgentUpdater) SetClient(name, version string) {
-	b.identifier.SetClient(name, version)
-}
-
-func (b *bridgeUserAgentUpdater) SetPlatform(platform string) {
-	b.identifier.SetPlatform(platform)
-}
-
-func (b *bridgeUserAgentUpdater) SetClientString(client string) {
-	b.identifier.SetClientString(client)
-}
-
-func (b *bridgeUserAgentUpdater) GetClientString() string {
-	return b.identifier.GetClientString()
-}
-
-func (b *bridgeUserAgentUpdater) SetUserAgent(name, version string) {
-	b.setUserAgent(name, version)
-}

internal/bridge/imap.go

@@ -1,129 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"crypto/tls"
-	"strings"
-
-	"github.com/Masterminds/semver/v3"
-	imapEvents "github.com/ProtonMail/gluon/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/imapsmtpserver"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) restartIMAP(ctx context.Context) error {
-	return bridge.serverManager.RestartIMAP(ctx)
-}
-
-func (bridge *Bridge) handleIMAPEvent(event imapEvents.Event) {
-	switch event := event.(type) {
-	case imapEvents.UserAdded:
-		for labelID, count := range event.Counts {
-			logrus.WithFields(logrus.Fields{
-				"gluonID": event.UserID,
-				"labelID": labelID,
-				"count":   count,
-			}).Info("Received mailbox message count")
-		}
-
-	case imapEvents.IMAPID:
-		logrus.WithFields(logrus.Fields{
-			"sessionID": event.SessionID,
-			"name":      event.IMAPID.Name,
-			"version":   event.IMAPID.Version,
-		}).Info("Received IMAP ID")
-
-		if event.IMAPID.Name != "" && event.IMAPID.Version != "" {
-			bridge.setUserAgent(event.IMAPID.Name, event.IMAPID.Version)
-		}
-
-	case imapEvents.LoginFailed:
-		logrus.WithFields(logrus.Fields{
-			"sessionID": event.SessionID,
-			"username":  event.Username,
-			"pkg":       "imap",
-		}).Error("Incorrect login credentials.")
-		bridge.publish(events.IMAPLoginFailed{Username: event.Username})
-
-	case imapEvents.Login:
-		if strings.Contains(bridge.GetCurrentUserAgent(), useragent.DefaultUserAgent) {
-			bridge.setUserAgent(useragent.UnknownClient, useragent.DefaultVersion)
-		}
-	}
-}
-
-type bridgeIMAPSettings struct {
-	b *Bridge
-}
-
-func (b *bridgeIMAPSettings) EventPublisher() imapsmtpserver.IMAPEventPublisher {
-	return b
-}
-
-func (b *bridgeIMAPSettings) TLSConfig() *tls.Config {
-	return b.b.tlsConfig
-}
-
-func (b *bridgeIMAPSettings) LogClient() bool {
-	return b.b.logIMAPClient
-}
-
-func (b *bridgeIMAPSettings) LogServer() bool {
-	return b.b.logIMAPServer
-}
-
-func (b *bridgeIMAPSettings) Port() int {
-	return b.b.vault.GetIMAPPort()
-}
-
-func (b *bridgeIMAPSettings) SetPort(i int) error {
-	return b.b.vault.SetIMAPPort(i)
-}
-
-func (b *bridgeIMAPSettings) UseSSL() bool {
-	return b.b.vault.GetIMAPSSL()
-}
-
-func (b *bridgeIMAPSettings) CacheDirectory() string {
-	return b.b.GetGluonCacheDir()
-}
-
-func (b *bridgeIMAPSettings) DataDirectory() (string, error) {
-	return b.b.GetGluonDataDir()
-}
-
-func (b *bridgeIMAPSettings) SetCacheDirectory(s string) error {
-	return b.b.vault.SetGluonDir(s)
-}
-
-func (b *bridgeIMAPSettings) Version() *semver.Version {
-	return b.b.curVersion
-}
-
-func (b *bridgeIMAPSettings) PublishIMAPEvent(ctx context.Context, event imapEvents.Event) {
-	select {
-	case <-ctx.Done():
-		return
-	case b.b.imapEventCh <- event:
-		// do nothing
-	}
-}

internal/bridge/imapsmtp_telemetry.go

@@ -1,26 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-type bridgeIMAPSMTPTelemetry struct {
-	b *Bridge
-}
-
-func (b bridgeIMAPSMTPTelemetry) SetCacheLocation(s string) {
-	b.b.heartbeat.SetCacheLocation(s)
-}

internal/bridge/locations.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-func (bridge *Bridge) GetLogsPath() (string, error) {
-	return bridge.locator.ProvideLogsPath()
-}
-
-func (bridge *Bridge) GetLicenseFilePath() string {
-	return bridge.locator.GetLicenseFilePath()
-}
-
-func (bridge *Bridge) GetDependencyLicensesLink() string {
-	return bridge.locator.GetDependencyLicensesLink()
-}

internal/bridge/main_test.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"os"
-	"testing"
-
-	"github.com/sirupsen/logrus"
-	"go.uber.org/goleak"
-)
-
-func TestMain(m *testing.M) {
-	if level := os.Getenv("BRIDGE_LOG_LEVEL"); level != "" {
-		if parsed, err := logrus.ParseLevel(level); err == nil {
-			logrus.SetLevel(parsed)
-		}
-	}
-
-	goleak.VerifyTestMain(m, goleak.IgnoreCurrent())
-}

internal/bridge/mocks.go

@@ -1,156 +0,0 @@
-package bridge
-
-import (
-	"context"
-	"net/http"
-	"net/url"
-	"os"
-	"sync"
-	"testing"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge/mocks"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/golang/mock/gomock"
-)
-
-type Mocks struct {
-	ProxyCtl    *mocks.MockProxyController
-	TLSReporter *mocks.MockTLSReporter
-	TLSIssueCh  chan struct{}
-
-	Updater     *TestUpdater
-	Autostarter *mocks.MockAutostarter
-
-	CrashHandler *mocks.MockPanicHandler
-	Reporter     *mocks.MockReporter
-	Heartbeat    *mocks.MockHeartbeatManager
-}
-
-func NewMocks(tb testing.TB, version, minAuto *semver.Version) *Mocks {
-	ctl := gomock.NewController(tb)
-
-	mocks := &Mocks{
-		ProxyCtl:    mocks.NewMockProxyController(ctl),
-		TLSReporter: mocks.NewMockTLSReporter(ctl),
-		TLSIssueCh:  make(chan struct{}),
-
-		Updater:     NewTestUpdater(version, minAuto),
-		Autostarter: mocks.NewMockAutostarter(ctl),
-
-		CrashHandler: mocks.NewMockPanicHandler(ctl),
-		Reporter:     mocks.NewMockReporter(ctl),
-		Heartbeat:    mocks.NewMockHeartbeatManager(ctl),
-	}
-
-	// When getting the TLS issue channel, we want to return the test channel.
-	mocks.TLSReporter.EXPECT().GetTLSIssueCh().Return(mocks.TLSIssueCh).AnyTimes()
-
-	// This is called at the end of any go-routine:
-	mocks.CrashHandler.EXPECT().HandlePanic(gomock.Any()).AnyTimes()
-
-	// this is called at start of heartbeat process.
-	mocks.Heartbeat.EXPECT().IsTelemetryAvailable(gomock.Any()).AnyTimes()
-
-	return mocks
-}
-
-func (mocks *Mocks) Close() {
-	close(mocks.TLSIssueCh)
-}
-
-type TestCookieJar struct {
-	cookies map[string][]*http.Cookie
-}
-
-func NewTestCookieJar() *TestCookieJar {
-	return &TestCookieJar{
-		cookies: make(map[string][]*http.Cookie),
-	}
-}
-
-func (j *TestCookieJar) SetCookies(u *url.URL, cookies []*http.Cookie) {
-	j.cookies[u.Host] = cookies
-}
-
-func (j *TestCookieJar) Cookies(u *url.URL) []*http.Cookie {
-	return j.cookies[u.Host]
-}
-
-type TestLocationsProvider struct {
-	config, data, cache string
-}
-
-func NewTestLocationsProvider(dir string) *TestLocationsProvider {
-	config, err := os.MkdirTemp(dir, "config")
-	if err != nil {
-		panic(err)
-	}
-
-	data, err := os.MkdirTemp(dir, "data")
-	if err != nil {
-		panic(err)
-	}
-
-	cache, err := os.MkdirTemp(dir, "cache")
-	if err != nil {
-		panic(err)
-	}
-
-	return &TestLocationsProvider{
-		config: config,
-		data:   data,
-		cache:  cache,
-	}
-}
-
-func (provider *TestLocationsProvider) UserConfig() string {
-	return provider.config
-}
-
-func (provider *TestLocationsProvider) UserData() string {
-	return provider.data
-}
-
-func (provider *TestLocationsProvider) UserCache() string {
-	return provider.cache
-}
-
-type TestUpdater struct {
-	latest updater.VersionInfo
-	lock   sync.RWMutex
-}
-
-func NewTestUpdater(version, minAuto *semver.Version) *TestUpdater {
-	return &TestUpdater{
-		latest: updater.VersionInfo{
-			Version: version,
-			MinAuto: minAuto,
-
-			RolloutProportion: 1.0,
-		},
-	}
-}
-
-func (testUpdater *TestUpdater) SetLatestVersion(version, minAuto *semver.Version) {
-	testUpdater.lock.Lock()
-	defer testUpdater.lock.Unlock()
-
-	testUpdater.latest = updater.VersionInfo{
-		Version: version,
-		MinAuto: minAuto,
-
-		RolloutProportion: 1.0,
-	}
-}
-
-func (testUpdater *TestUpdater) GetVersionInfo(_ context.Context, _ updater.Downloader, _ updater.Channel) (updater.VersionInfo, error) {
-	testUpdater.lock.RLock()
-	defer testUpdater.lock.RUnlock()
-
-	return testUpdater.latest, nil
-}
-
-func (testUpdater *TestUpdater) InstallUpdate(_ context.Context, _ updater.Downloader, _ updater.VersionInfo) error {
-	return nil
-}

internal/bridge/mocks/async_mocks.go

@@ -1,46 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/gluon/async (interfaces: PanicHandler)
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	reflect "reflect"
-
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockPanicHandler is a mock of PanicHandler interface.
-type MockPanicHandler struct {
-	ctrl     *gomock.Controller
-	recorder *MockPanicHandlerMockRecorder
-}
-
-// MockPanicHandlerMockRecorder is the mock recorder for MockPanicHandler.
-type MockPanicHandlerMockRecorder struct {
-	mock *MockPanicHandler
-}
-
-// NewMockPanicHandler creates a new mock instance.
-func NewMockPanicHandler(ctrl *gomock.Controller) *MockPanicHandler {
-	mock := &MockPanicHandler{ctrl: ctrl}
-	mock.recorder = &MockPanicHandlerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockPanicHandler) EXPECT() *MockPanicHandlerMockRecorder {
-	return m.recorder
-}
-
-// HandlePanic mocks base method.
-func (m *MockPanicHandler) HandlePanic(arg0 interface{}) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "HandlePanic", arg0)
-}
-
-// HandlePanic indicates an expected call of HandlePanic.
-func (mr *MockPanicHandlerMockRecorder) HandlePanic(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandlePanic", reflect.TypeOf((*MockPanicHandler)(nil).HandlePanic), arg0)
-}

internal/bridge/mocks/gluon_mocks.go

@@ -1,90 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/gluon/reporter (interfaces: Reporter)
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	reflect "reflect"
-
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockReporter is a mock of Reporter interface.
-type MockReporter struct {
-	ctrl     *gomock.Controller
-	recorder *MockReporterMockRecorder
-}
-
-// MockReporterMockRecorder is the mock recorder for MockReporter.
-type MockReporterMockRecorder struct {
-	mock *MockReporter
-}
-
-// NewMockReporter creates a new mock instance.
-func NewMockReporter(ctrl *gomock.Controller) *MockReporter {
-	mock := &MockReporter{ctrl: ctrl}
-	mock.recorder = &MockReporterMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockReporter) EXPECT() *MockReporterMockRecorder {
-	return m.recorder
-}
-
-// ReportException mocks base method.
-func (m *MockReporter) ReportException(arg0 interface{}) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportException", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ReportException indicates an expected call of ReportException.
-func (mr *MockReporterMockRecorder) ReportException(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportException", reflect.TypeOf((*MockReporter)(nil).ReportException), arg0)
-}
-
-// ReportExceptionWithContext mocks base method.
-func (m *MockReporter) ReportExceptionWithContext(arg0 interface{}, arg1 map[string]interface{}) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportExceptionWithContext", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ReportExceptionWithContext indicates an expected call of ReportExceptionWithContext.
-func (mr *MockReporterMockRecorder) ReportExceptionWithContext(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportExceptionWithContext", reflect.TypeOf((*MockReporter)(nil).ReportExceptionWithContext), arg0, arg1)
-}
-
-// ReportMessage mocks base method.
-func (m *MockReporter) ReportMessage(arg0 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportMessage", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ReportMessage indicates an expected call of ReportMessage.
-func (mr *MockReporterMockRecorder) ReportMessage(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportMessage", reflect.TypeOf((*MockReporter)(nil).ReportMessage), arg0)
-}
-
-// ReportMessageWithContext mocks base method.
-func (m *MockReporter) ReportMessageWithContext(arg0 string, arg1 map[string]interface{}) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReportMessageWithContext", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// ReportMessageWithContext indicates an expected call of ReportMessageWithContext.
-func (mr *MockReporterMockRecorder) ReportMessageWithContext(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportMessageWithContext", reflect.TypeOf((*MockReporter)(nil).ReportMessageWithContext), arg0, arg1)
-}

internal/bridge/mocks/matcher.go

@@ -1,108 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package mocks
-
-import (
-	"strings"
-
-	"github.com/ProtonMail/go-proton-api"
-)
-
-type refreshContextMatcher struct {
-	wantRefresh proton.RefreshFlag
-}
-
-func NewRefreshContextMatcher(refreshFlag proton.RefreshFlag) *refreshContextMatcher { //nolint:revive
-	return &refreshContextMatcher{wantRefresh: refreshFlag}
-}
-
-func (m *refreshContextMatcher) Matches(x interface{}) bool {
-	context, ok := x.(map[string]interface{})
-	if !ok {
-		return false
-	}
-
-	i, ok := context["EventLoop"]
-	if !ok {
-		return false
-	}
-
-	el, ok := i.(map[string]interface{})
-	if !ok {
-		return false
-	}
-
-	vID, ok := el["EventID"]
-	if !ok {
-		return false
-	}
-
-	id, ok := vID.(string)
-	if !ok {
-		return false
-	}
-
-	if id == "" {
-		return false
-	}
-
-	vRefresh, ok := el["Refresh"]
-	if !ok {
-		return false
-	}
-
-	refresh, ok := vRefresh.(proton.RefreshFlag)
-	if !ok {
-		return false
-	}
-
-	return refresh == m.wantRefresh
-}
-
-func (m *refreshContextMatcher) String() string {
-	return `map[string]interface which contains "Refresh" field with value proton.RefreshAll`
-}
-
-type closedConnectionMatcher struct{}
-
-func NewClosedConnectionMatcher() *closedConnectionMatcher { //nolint:revive
-	return &closedConnectionMatcher{}
-}
-
-func (m *closedConnectionMatcher) Matches(x interface{}) bool {
-	context, ok := x.(map[string]interface{})
-	if !ok {
-		return false
-	}
-
-	vErr, ok := context["error"]
-	if !ok {
-		return false
-	}
-
-	err, ok := vErr.(error)
-	if !ok {
-		return false
-	}
-
-	return strings.Contains(err.Error(), "used of closed network connection")
-}
-
-func (m *closedConnectionMatcher) String() string {
-	return "map containing error of closed network connection"
-}

internal/bridge/mocks/mocks.go

@@ -1,160 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/proton-bridge/v3/internal/bridge (interfaces: TLSReporter,ProxyController,Autostarter)
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	reflect "reflect"
-
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockTLSReporter is a mock of TLSReporter interface.
-type MockTLSReporter struct {
-	ctrl     *gomock.Controller
-	recorder *MockTLSReporterMockRecorder
-}
-
-// MockTLSReporterMockRecorder is the mock recorder for MockTLSReporter.
-type MockTLSReporterMockRecorder struct {
-	mock *MockTLSReporter
-}
-
-// NewMockTLSReporter creates a new mock instance.
-func NewMockTLSReporter(ctrl *gomock.Controller) *MockTLSReporter {
-	mock := &MockTLSReporter{ctrl: ctrl}
-	mock.recorder = &MockTLSReporterMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockTLSReporter) EXPECT() *MockTLSReporterMockRecorder {
-	return m.recorder
-}
-
-// GetTLSIssueCh mocks base method.
-func (m *MockTLSReporter) GetTLSIssueCh() <-chan struct{} {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTLSIssueCh")
-	ret0, _ := ret[0].(<-chan struct{})
-	return ret0
-}
-
-// GetTLSIssueCh indicates an expected call of GetTLSIssueCh.
-func (mr *MockTLSReporterMockRecorder) GetTLSIssueCh() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTLSIssueCh", reflect.TypeOf((*MockTLSReporter)(nil).GetTLSIssueCh))
-}
-
-// MockProxyController is a mock of ProxyController interface.
-type MockProxyController struct {
-	ctrl     *gomock.Controller
-	recorder *MockProxyControllerMockRecorder
-}
-
-// MockProxyControllerMockRecorder is the mock recorder for MockProxyController.
-type MockProxyControllerMockRecorder struct {
-	mock *MockProxyController
-}
-
-// NewMockProxyController creates a new mock instance.
-func NewMockProxyController(ctrl *gomock.Controller) *MockProxyController {
-	mock := &MockProxyController{ctrl: ctrl}
-	mock.recorder = &MockProxyControllerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockProxyController) EXPECT() *MockProxyControllerMockRecorder {
-	return m.recorder
-}
-
-// AllowProxy mocks base method.
-func (m *MockProxyController) AllowProxy() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "AllowProxy")
-}
-
-// AllowProxy indicates an expected call of AllowProxy.
-func (mr *MockProxyControllerMockRecorder) AllowProxy() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllowProxy", reflect.TypeOf((*MockProxyController)(nil).AllowProxy))
-}
-
-// DisallowProxy mocks base method.
-func (m *MockProxyController) DisallowProxy() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "DisallowProxy")
-}
-
-// DisallowProxy indicates an expected call of DisallowProxy.
-func (mr *MockProxyControllerMockRecorder) DisallowProxy() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisallowProxy", reflect.TypeOf((*MockProxyController)(nil).DisallowProxy))
-}
-
-// MockAutostarter is a mock of Autostarter interface.
-type MockAutostarter struct {
-	ctrl     *gomock.Controller
-	recorder *MockAutostarterMockRecorder
-}
-
-// MockAutostarterMockRecorder is the mock recorder for MockAutostarter.
-type MockAutostarterMockRecorder struct {
-	mock *MockAutostarter
-}
-
-// NewMockAutostarter creates a new mock instance.
-func NewMockAutostarter(ctrl *gomock.Controller) *MockAutostarter {
-	mock := &MockAutostarter{ctrl: ctrl}
-	mock.recorder = &MockAutostarterMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockAutostarter) EXPECT() *MockAutostarterMockRecorder {
-	return m.recorder
-}
-
-// Disable mocks base method.
-func (m *MockAutostarter) Disable() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Disable")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Disable indicates an expected call of Disable.
-func (mr *MockAutostarterMockRecorder) Disable() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disable", reflect.TypeOf((*MockAutostarter)(nil).Disable))
-}
-
-// Enable mocks base method.
-func (m *MockAutostarter) Enable() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Enable")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Enable indicates an expected call of Enable.
-func (mr *MockAutostarterMockRecorder) Enable() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enable", reflect.TypeOf((*MockAutostarter)(nil).Enable))
-}
-
-// IsEnabled mocks base method.
-func (m *MockAutostarter) IsEnabled() bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsEnabled")
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// IsEnabled indicates an expected call of IsEnabled.
-func (mr *MockAutostarterMockRecorder) IsEnabled() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEnabled", reflect.TypeOf((*MockAutostarter)(nil).IsEnabled))
-}

internal/bridge/mocks/telemetry_mocks.go

@@ -1,93 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/proton-bridge/v3/internal/telemetry (interfaces: HeartbeatManager)
-
-// Package mocks is a generated GoMock package.
-package mocks
-
-import (
-	context "context"
-	reflect "reflect"
-	time "time"
-
-	telemetry "github.com/ProtonMail/proton-bridge/v3/internal/telemetry"
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockHeartbeatManager is a mock of HeartbeatManager interface.
-type MockHeartbeatManager struct {
-	ctrl     *gomock.Controller
-	recorder *MockHeartbeatManagerMockRecorder
-}
-
-// MockHeartbeatManagerMockRecorder is the mock recorder for MockHeartbeatManager.
-type MockHeartbeatManagerMockRecorder struct {
-	mock *MockHeartbeatManager
-}
-
-// NewMockHeartbeatManager creates a new mock instance.
-func NewMockHeartbeatManager(ctrl *gomock.Controller) *MockHeartbeatManager {
-	mock := &MockHeartbeatManager{ctrl: ctrl}
-	mock.recorder = &MockHeartbeatManagerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockHeartbeatManager) EXPECT() *MockHeartbeatManagerMockRecorder {
-	return m.recorder
-}
-
-// GetLastHeartbeatSent mocks base method.
-func (m *MockHeartbeatManager) GetLastHeartbeatSent() time.Time {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetLastHeartbeatSent")
-	ret0, _ := ret[0].(time.Time)
-	return ret0
-}
-
-// GetLastHeartbeatSent indicates an expected call of GetLastHeartbeatSent.
-func (mr *MockHeartbeatManagerMockRecorder) GetLastHeartbeatSent() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastHeartbeatSent", reflect.TypeOf((*MockHeartbeatManager)(nil).GetLastHeartbeatSent))
-}
-
-// IsTelemetryAvailable mocks base method.
-func (m *MockHeartbeatManager) IsTelemetryAvailable(arg0 context.Context) bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IsTelemetryAvailable", arg0)
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// IsTelemetryAvailable indicates an expected call of IsTelemetryAvailable.
-func (mr *MockHeartbeatManagerMockRecorder) IsTelemetryAvailable(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsTelemetryAvailable", reflect.TypeOf((*MockHeartbeatManager)(nil).IsTelemetryAvailable), arg0)
-}
-
-// SendHeartbeat mocks base method.
-func (m *MockHeartbeatManager) SendHeartbeat(arg0 context.Context, arg1 *telemetry.HeartbeatData) bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendHeartbeat", arg0, arg1)
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// SendHeartbeat indicates an expected call of SendHeartbeat.
-func (mr *MockHeartbeatManagerMockRecorder) SendHeartbeat(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeartbeat", reflect.TypeOf((*MockHeartbeatManager)(nil).SendHeartbeat), arg0, arg1)
-}
-
-// SetLastHeartbeatSent mocks base method.
-func (m *MockHeartbeatManager) SetLastHeartbeatSent(arg0 time.Time) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetLastHeartbeatSent", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SetLastHeartbeatSent indicates an expected call of SetLastHeartbeatSent.
-func (mr *MockHeartbeatManagerMockRecorder) SetLastHeartbeatSent(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastHeartbeatSent", reflect.TypeOf((*MockHeartbeatManager)(nil).SetLastHeartbeatSent), arg0)
-}

internal/bridge/refresh_test.go

@@ -1,118 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/bradenaw/juniper/iterator"
-	"github.com/golang/mock/gomock"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_Refresh(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, _, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		names := iterator.Collect(iterator.Map(iterator.Counter(10), func(i int) string {
-			return fmt.Sprintf("folder%v", i)
-		}))
-
-		for _, name := range names {
-			must(s.CreateLabel(userID, name, "", proton.LabelTypeFolder))
-		}
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := b.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		var uidValidities = make(map[string]uint32, len(names))
-		// If we then connect an IMAP client, it should see all the labels with UID validity of 1.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, mocks *bridge.Mocks) {
-			mocks.Reporter.EXPECT().ReportMessageWithContext(gomock.Any(), gomock.Any()).AnyTimes()
-
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			for _, name := range names {
-				status, err := client.Select("Folders/"+name, false)
-				require.NoError(t, err)
-				uidValidities[name] = status.UidValidity
-			}
-		})
-
-		// Refresh the user; this will force a resync.
-		require.NoError(t, s.RefreshUser(userID, proton.RefreshAll))
-
-		// If we then connect an IMAP client, it should see all the labels with UID validity of 1.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, mocks *bridge.Mocks) {
-			mocks.Reporter.EXPECT().ReportMessageWithContext(gomock.Any(), gomock.Any()).AnyTimes()
-
-			// Wait for refresh event first
-			refreshCh, refreshChDone := chToType[events.Event, events.UserRefreshed](b.GetEvents(events.UserRefreshed{}))
-			defer refreshChDone()
-			require.Equal(t, userID, (<-refreshCh).UserID)
-			// Then sync event
-			syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		// After resync, the IMAP client should see all the labels with UID validity of 2.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, mocks *bridge.Mocks) {
-			mocks.Reporter.EXPECT().ReportMessageWithContext(gomock.Any(), gomock.Any()).AnyTimes()
-
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			for _, name := range names {
-				status, err := client.Select("Folders/"+name, false)
-				require.NoError(t, err)
-				require.Greater(t, status.UidValidity, uidValidities[name])
-			}
-		})
-	})
-}

internal/bridge/release_notes.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -15,15 +15,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
+// Code generated by ./release-notes.sh at 'Fri Jan 22 11:01:06 AM CET 2021'. DO NOT EDIT.
 
-#ifndef BRIDGE_GUI_LOG_UTILS_H
-#define BRIDGE_GUI_LOG_UTILS_H
+package bridge
 
+const ReleaseNotes = `
+`
 
-#include <bridgepp/Log/Log.h>
-
-
-bridgepp::Log &initLog(); ///< Initialize the application log.
-
-
-#endif //BRIDGE_GUI_LOG_UTILS_H
+const ReleaseFixedBugs = `• Fixed sending error caused by inconsistent use of upper and lower case in sender’s email address
+`

internal/bridge/send_test.go

@@ -1,522 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"bytes"
-	"context"
-	"crypto/tls"
-	"fmt"
-	"net"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/emersion/go-imap"
-	"github.com/emersion/go-sasl"
-	"github.com/emersion/go-smtp"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_Send(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		_, _, err := s.CreateUser("recipient", password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			senderUserID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			recipientUserID, err := bridge.LoginFull(ctx, "recipient", password, nil, nil)
-			require.NoError(t, err)
-
-			smtpWaiter.Wait()
-
-			senderInfo, err := bridge.GetUserInfo(senderUserID)
-			require.NoError(t, err)
-
-			recipientInfo, err := bridge.GetUserInfo(recipientUserID)
-			require.NoError(t, err)
-
-			for i := 0; i < 10; i++ {
-				// Dial the server.
-				client, err := smtp.Dial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetSMTPPort())))
-				require.NoError(t, err)
-				defer client.Close() //nolint:errcheck
-
-				// Upgrade to TLS.
-				require.NoError(t, client.StartTLS(&tls.Config{InsecureSkipVerify: true}))
-
-				if i%2 == 0 {
-					// Authorize with SASL PLAIN.
-					require.NoError(t, client.Auth(sasl.NewPlainClient(
-						senderInfo.Addresses[0],
-						senderInfo.Addresses[0],
-						string(senderInfo.BridgePass)),
-					))
-				} else {
-					// Authorize with SASL LOGIN.
-					require.NoError(t, client.Auth(sasl.NewLoginClient(
-						senderInfo.Addresses[0],
-						string(senderInfo.BridgePass)),
-					))
-				}
-
-				// Send the message.
-				require.NoError(t, client.SendMail(
-					senderInfo.Addresses[0],
-					[]string{recipientInfo.Addresses[0]},
-					strings.NewReader(fmt.Sprintf("Subject: Test %v\r\n\r\nHello world!", i)),
-				))
-			}
-
-			// Connect the sender IMAP client.
-			senderIMAPClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, senderIMAPClient.Login(senderInfo.Addresses[0], string(senderInfo.BridgePass)))
-			defer senderIMAPClient.Logout() //nolint:errcheck
-
-			// Connect the recipient IMAP client.
-			recipientIMAPClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, recipientIMAPClient.Login(recipientInfo.Addresses[0], string(recipientInfo.BridgePass)))
-			defer recipientIMAPClient.Logout() //nolint:errcheck
-
-			// Sender should have 10 messages in the sent folder.
-			// Recipient should have 10 messages in inbox.
-			require.Eventually(t, func() bool {
-				sent, err := senderIMAPClient.Status(`Sent`, []imap.StatusItem{imap.StatusMessages})
-				require.NoError(t, err)
-
-				inbox, err := recipientIMAPClient.Status(`Inbox`, []imap.StatusItem{imap.StatusMessages})
-				require.NoError(t, err)
-
-				return sent.Messages == 10 && inbox.Messages == 10
-			}, 10*time.Second, 100*time.Millisecond)
-		})
-	})
-}
-
-func TestBridge_SendDraftFlags(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a recipient user.
-		_, _, err := s.CreateUser("recipient", password)
-		require.NoError(t, err)
-
-		// The sender should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		// Start the bridge.
-		withBridgeWaitForServers(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			// Get the sender user info.
-			userInfo, err := bridge.QueryUserInfo(username)
-			require.NoError(t, err)
-
-			// Connect the sender IMAP client.
-			imapClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, imapClient.Login(userInfo.Addresses[0], string(userInfo.BridgePass)))
-			defer imapClient.Logout() //nolint:errcheck
-
-			// The message to send.
-			message := fmt.Sprintf("From: %v\r\nDate: 01 Jan 1980 00:00:00 +0000\r\nSubject: Test\r\n\r\nHello world!", userInfo.Addresses[0])
-
-			// Save a draft.
-			require.NoError(t, imapClient.Append("Drafts", []string{imap.DraftFlag}, time.Now(), strings.NewReader(message)))
-
-			// Assert that the draft exists and is marked as a draft.
-			{
-				messages, err := clientFetch(imapClient, "Drafts")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.Contains(t, messages[0].Flags, imap.DraftFlag)
-			}
-
-			// Connect the SMTP client.
-			smtpClient, err := smtp.Dial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetSMTPPort())))
-			require.NoError(t, err)
-			defer smtpClient.Close() //nolint:errcheck
-
-			// Upgrade to TLS.
-			require.NoError(t, smtpClient.StartTLS(&tls.Config{InsecureSkipVerify: true}))
-
-			// Authorize with SASL PLAIN.
-			require.NoError(t, smtpClient.Auth(sasl.NewPlainClient(
-				userInfo.Addresses[0],
-				userInfo.Addresses[0],
-				string(userInfo.BridgePass)),
-			))
-
-			// Send the message.
-			require.NoError(t, smtpClient.SendMail(
-				userInfo.Addresses[0],
-				[]string{"recipient@" + s.GetDomain()},
-				strings.NewReader(message),
-			))
-
-			// Delete the draft: add the \Deleted flag and expunge.
-			{
-				status, err := imapClient.Select("Drafts", false)
-				require.NoError(t, err)
-				require.Equal(t, uint32(1), status.Messages)
-
-				// Add the \Deleted flag.
-				require.NoError(t, clientStore(imapClient, 1, 1, true, imap.FormatFlagsOp(imap.AddFlags, true), imap.DeletedFlag))
-
-				// Expunge.
-				require.NoError(t, imapClient.Expunge(nil))
-			}
-
-			// Assert that the draft is eventually gone.
-			require.Eventually(t, func() bool {
-				status, err := imapClient.Select("Drafts", false)
-				require.NoError(t, err)
-				return status.Messages == 0
-			}, 10*time.Second, 100*time.Millisecond)
-
-			// Assert that the message is eventually in the sent folder.
-			require.Eventually(t, func() bool {
-				messages, err := clientFetch(imapClient, "Sent")
-				require.NoError(t, err)
-				return len(messages) == 1
-			}, 10*time.Second, 100*time.Millisecond)
-
-			// Assert that the message is not marked as a draft.
-			{
-				messages, err := clientFetch(imapClient, "Sent")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.NotContains(t, messages[0].Flags, imap.DraftFlag)
-			}
-		})
-	})
-}
-
-func TestBridge_SendInvite(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a recipient user.
-		_, _, err := s.CreateUser("recipient", password)
-		require.NoError(t, err)
-
-		// Set "attach public keys" to true for the user.
-		withClient(ctx, t, s, username, password, func(ctx context.Context, client *proton.Client) {
-			settings, err := client.SetAttachPublicKey(ctx, proton.SetAttachPublicKeyReq{AttachPublicKey: true})
-			require.NoError(t, err)
-			require.Equal(t, proton.Bool(true), settings.AttachPublicKey)
-		})
-
-		// The sender should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		// Start the bridge.
-		withBridgeWaitForServers(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			// Get the sender user info.
-			userInfo, err := bridge.QueryUserInfo(username)
-			require.NoError(t, err)
-
-			// Connect the sender IMAP client.
-			imapClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, imapClient.Login(userInfo.Addresses[0], string(userInfo.BridgePass)))
-			defer imapClient.Logout() //nolint:errcheck
-
-			// The message to send.
-			b, err := os.ReadFile("testdata/invite.eml")
-			require.NoError(t, err)
-
-			// Save a draft.
-			require.NoError(t, imapClient.Append("Drafts", []string{imap.DraftFlag}, time.Now(), bytes.NewReader(b)))
-
-			// Assert that the draft exists and is marked as a draft.
-			{
-				messages, err := clientFetch(imapClient, "Drafts")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.Contains(t, messages[0].Flags, imap.DraftFlag)
-			}
-
-			// Connect the SMTP client.
-			smtpClient, err := smtp.Dial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetSMTPPort())))
-			require.NoError(t, err)
-			defer smtpClient.Close() //nolint:errcheck
-
-			// Upgrade to TLS.
-			require.NoError(t, smtpClient.StartTLS(&tls.Config{InsecureSkipVerify: true}))
-
-			// Authorize with SASL PLAIN.
-			require.NoError(t, smtpClient.Auth(sasl.NewPlainClient(
-				userInfo.Addresses[0],
-				userInfo.Addresses[0],
-				string(userInfo.BridgePass)),
-			))
-
-			// Send the message.
-			require.NoError(t, smtpClient.SendMail(
-				userInfo.Addresses[0],
-				[]string{"recipient@" + s.GetDomain()},
-				bytes.NewReader(b),
-			))
-
-			// Delete the draft: add the \Deleted flag and expunge.
-			{
-				status, err := imapClient.Select("Drafts", false)
-				require.NoError(t, err)
-				require.Equal(t, uint32(1), status.Messages)
-
-				// Add the \Deleted flag.
-				require.NoError(t, clientStore(imapClient, 1, 1, true, imap.FormatFlagsOp(imap.AddFlags, true), imap.DeletedFlag))
-
-				// Expunge.
-				require.NoError(t, imapClient.Expunge(nil))
-			}
-
-			// Assert that the draft is eventually gone.
-			require.Eventually(t, func() bool {
-				status, err := imapClient.Select("Drafts", false)
-				require.NoError(t, err)
-				return status.Messages == 0
-			}, 10*time.Second, 100*time.Millisecond)
-
-			// Assert that the message is eventually in the sent folder.
-			require.Eventually(t, func() bool {
-				messages, err := clientFetch(imapClient, "Sent")
-				require.NoError(t, err)
-				return len(messages) == 1
-			}, 10*time.Second, 100*time.Millisecond)
-
-			// Assert that the message is not marked as a draft.
-			{
-				messages, err := clientFetch(imapClient, "Sent")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.NotContains(t, messages[0].Flags, imap.DraftFlag)
-			}
-		})
-	})
-}
-
-func TestBridge_SendAddTextBodyPartIfNotExists(t *testing.T) {
-	const messageMultipartWithoutText = `Content-Type: multipart/mixed;
-  boundary="Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84"
-Subject: A new message
-Date: Mon, 13 Mar 2023 16:06:16 +0100
-
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84
-Content-Disposition: inline;
-  filename=Cat_August_2010-4.jpeg
-Content-Type: image/jpeg;
-  name="Cat_August_2010-4.jpeg"
-Content-Transfer-Encoding: base64
-
-SGVsbG8gd29ybGQ=
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84--
-	`
-
-	const messageMultipartWithText = `Content-Type: multipart/mixed;
-  boundary="Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84"
-Subject: A new message Part2 
-Date: Mon, 13 Mar 2023 16:06:16 +0100
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84
-Content-Disposition: inline;
-  filename=Cat_August_2010-4.jpeg
-Content-Type: image/jpeg;
-  name="Cat_August_2010-4.jpeg"
-Content-Transfer-Encoding: base64
-
-SGVsbG8gd29ybGQ=
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84
-Content-Type: text/html;charset=utf8
-Content-Transfer-Encoding: quoted-printable
-
-Hello world
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84--
-`
-
-	const messageWithTextOnly = `Content-Type: text/plain;charset=utf8
-Content-Transfer-Encoding: quoted-printable
-Subject: A new message Part3
-Date: Mon, 13 Mar 2023 16:06:16 +0100
-
-Hello world
-
-`
-
-	const messageMultipartWithoutTextWithTextAttachment = `Content-Type: multipart/mixed;
-  boundary="Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84"
-Subject: A new message Part4
-Date: Mon, 13 Mar 2023 16:06:16 +0100
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84
-Content-Type: text/plain; charset=UTF-8; name="text.txt"
-Content-Disposition: attachment; filename="text.txt"
-Content-Transfer-Encoding: base64
-
-SGVsbG8gd29ybGQK
-
---Apple-Mail=_E7AC06C7-4EB2-4453-8CBB-80F4412A7C84--
-`
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		_, _, err := s.CreateUser("recipient", password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			senderUserID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			recipientUserID, err := bridge.LoginFull(ctx, "recipient", password, nil, nil)
-			require.NoError(t, err)
-
-			senderInfo, err := bridge.GetUserInfo(senderUserID)
-			require.NoError(t, err)
-
-			recipientInfo, err := bridge.GetUserInfo(recipientUserID)
-			require.NoError(t, err)
-
-			messages := []string{
-				messageMultipartWithoutText,
-				messageMultipartWithText,
-				messageWithTextOnly,
-				messageMultipartWithoutTextWithTextAttachment,
-			}
-
-			smtpWaiter.Wait()
-
-			for _, m := range messages {
-				// Dial the server.
-				client, err := smtp.Dial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetSMTPPort())))
-				require.NoError(t, err)
-				defer client.Close() //nolint:errcheck
-
-				// Upgrade to TLS.
-				require.NoError(t, client.StartTLS(&tls.Config{InsecureSkipVerify: true}))
-
-				// Authorize with SASL LOGIN.
-				require.NoError(t, client.Auth(sasl.NewLoginClient(
-					senderInfo.Addresses[0],
-					string(senderInfo.BridgePass)),
-				))
-
-				// Send the message.
-				require.NoError(t, client.SendMail(
-					senderInfo.Addresses[0],
-					[]string{recipientInfo.Addresses[0]},
-					strings.NewReader(m),
-				))
-			}
-
-			// Connect the sender IMAP client.
-			senderIMAPClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, senderIMAPClient.Login(senderInfo.Addresses[0], string(senderInfo.BridgePass)))
-			defer senderIMAPClient.Logout() //nolint:errcheck
-
-			// Connect the recipient IMAP client.
-			recipientIMAPClient, err := eventuallyDial(net.JoinHostPort(constants.Host, fmt.Sprint(bridge.GetIMAPPort())))
-			require.NoError(t, err)
-			require.NoError(t, recipientIMAPClient.Login(recipientInfo.Addresses[0], string(recipientInfo.BridgePass)))
-			defer recipientIMAPClient.Logout() //nolint:errcheck
-
-			require.Eventually(t, func() bool {
-				messages, err := clientFetch(senderIMAPClient, `Sent`, imap.FetchBodyStructure)
-				require.NoError(t, err)
-				if len(messages) != 4 {
-					return false
-				}
-
-				// messages may not be in order
-				for _, message := range messages {
-					switch {
-					case message.Envelope.Subject == "A new message":
-						// The message that was sent should now include an empty text/plain body part since there was none
-						// in the original message.
-						require.Equal(t, 2, len(message.BodyStructure.Parts))
-
-						require.Equal(t, "text", message.BodyStructure.Parts[0].MIMEType)
-						require.Equal(t, "plain", message.BodyStructure.Parts[0].MIMESubType)
-						require.Equal(t, uint32(0), message.BodyStructure.Parts[0].Size)
-						require.Equal(t, "image", message.BodyStructure.Parts[1].MIMEType)
-						require.Equal(t, "jpeg", message.BodyStructure.Parts[1].MIMESubType)
-
-					case message.Envelope.Subject == "A new message Part2":
-						// This message already has a text body, should be unchanged
-						require.Equal(t, 2, len(message.BodyStructure.Parts))
-
-						require.Equal(t, "image", message.BodyStructure.Parts[1].MIMEType)
-						require.Equal(t, "jpeg", message.BodyStructure.Parts[1].MIMESubType)
-						require.Equal(t, "text", message.BodyStructure.Parts[0].MIMEType)
-						require.Equal(t, "html", message.BodyStructure.Parts[0].MIMESubType)
-
-					case message.Envelope.Subject == "A new message Part3":
-						// This message already has a text body, should be unchanged
-						require.Equal(t, 0, len(message.BodyStructure.Parts))
-
-						require.Equal(t, "text", message.BodyStructure.MIMEType)
-						require.Equal(t, "plain", message.BodyStructure.MIMESubType)
-
-					case message.Envelope.Subject == "A new message Part4":
-						// The message that was sent should now include an empty text/plain body part since even though
-						// there was only a text/plain attachment in the original message.
-						require.Equal(t, 2, len(message.BodyStructure.Parts))
-
-						require.Equal(t, "text", message.BodyStructure.Parts[0].MIMEType)
-						require.Equal(t, "plain", message.BodyStructure.Parts[0].MIMESubType)
-						require.Equal(t, uint32(0), message.BodyStructure.Parts[0].Size)
-						require.Equal(t, "text", message.BodyStructure.Parts[1].MIMEType)
-						require.Equal(t, "plain", message.BodyStructure.Parts[1].MIMESubType)
-						require.Equal(t, "attachment", message.BodyStructure.Parts[1].Disposition)
-					}
-				}
-
-				return true
-			}, 10*time.Second, 100*time.Millisecond)
-		})
-	})
-}

internal/bridge/sentry_test.go

@@ -1,83 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"testing"
-
-	"github.com/ProtonMail/gluon/liner"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/golang/mock/gomock"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_Report(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(b)
-			defer imapWaiter.Done()
-
-			syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			// Log in the user.
-			userID, err := b.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// Wait until the sync has finished.
-			require.Equal(t, userID, (<-syncCh).UserID)
-
-			// Get the IMAP info.
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			imapWaiter.Wait()
-
-			// Dial the IMAP port.
-			conn, err := net.Dial("tcp", fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			defer func() { require.NoError(t, conn.Close()) }()
-
-			// Sending garbage to the IMAP port should cause the bridge to report it.
-			mocks.Reporter.EXPECT().ReportMessageWithContext(
-				gomock.Eq("Failed to parse IMAP command"),
-				gomock.Any(),
-			).Return(nil)
-
-			// Read lines from the IMAP port.
-			lineCh := liner.New(conn).Lines(func() error { return nil })
-
-			// On connection, we should get the greeting.
-			require.Contains(t, string((<-lineCh).Line), "* OK")
-
-			// Send garbage data.
-			must(conn.Write([]byte("tag garbage\r\n")))
-
-			// Bridge will reply with BAD.
-			require.Contains(t, string((<-lineCh).Line), "tag BAD")
-		})
-	})
-}

internal/bridge/server_manager_test.go

@@ -1,179 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/stretchr/testify/require"
-)
-
-func TestServerManager_NoLoadedUsersNoServers(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			_, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.Error(t, err)
-		})
-	})
-}
-
-func TestServerManager_ServersStartAfterFirstConnectedUser(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(bridge)
-			defer imapWaiter.Done()
-
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			_, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-		})
-	})
-}
-
-func TestServerManager_ServersStopsAfterUserLogsOut(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(bridge)
-			defer imapWaiter.Done()
-
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-
-			imapWaiterStopped := waitForIMAPServerStopped(bridge)
-			defer imapWaiterStopped.Done()
-
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-
-			imapWaiterStopped.Wait()
-		})
-	})
-}
-
-func TestServerManager_ServersDoNotStopWhenThereIsStillOneActiveUser(t *testing.T) {
-	otherPassword := []byte("bar")
-	otherUser := "foo"
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		_, _, err := s.CreateUser(otherUser, otherPassword)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(bridge)
-			defer imapWaiter.Done()
-
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			_, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			userIDOther, err := bridge.LoginFull(ctx, otherUser, otherPassword, nil, nil)
-			require.NoError(t, err)
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-
-			evtCh, cancel := bridge.GetEvents(events.UserDeauth{})
-			defer cancel()
-
-			require.NoError(t, s.RevokeUser(userIDOther))
-
-			waitForEvent(t, evtCh, events.UserDeauth{})
-
-			imapClient, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, imapClient.Logout())
-		})
-	})
-}
-
-func TestServerManager_ServersStartIfAtLeastOneUserIsLoggedIn(t *testing.T) {
-	otherPassword := []byte("bar")
-	otherUser := "foo"
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userIDOther, _, err := s.CreateUser(otherUser, otherPassword)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			_, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			_, err = bridge.LoginFull(ctx, otherUser, otherPassword, nil, nil)
-			require.NoError(t, err)
-		})
-
-		require.NoError(t, s.RevokeUser(userIDOther))
-
-		withBridgeWaitForServers(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapClient, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, imapClient.Logout())
-		})
-	})
-}
-
-func TestServerManager_NetworkLossStopsServers(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(bridge)
-			defer imapWaiter.Done()
-
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			imapWaiterStop := waitForIMAPServerStopped(bridge)
-			defer imapWaiterStop.Done()
-
-			smtpWaiterStop := waitForSMTPServerStopped(bridge)
-			defer smtpWaiterStop.Done()
-
-			_, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-
-			netCtl.Disable()
-
-			imapWaiterStop.Wait()
-			smtpWaiterStop.Wait()
-
-			netCtl.Enable()
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-		})
-	})
-}

internal/bridge/settings.go

@@ -1,334 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/userevents"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) GetKeychainApp() (string, error) {
-	vaultDir, err := bridge.locator.ProvideSettingsPath()
-	if err != nil {
-		return "", err
-	}
-
-	return vault.GetHelper(vaultDir)
-}
-
-func (bridge *Bridge) SetKeychainApp(helper string) error {
-	vaultDir, err := bridge.locator.ProvideSettingsPath()
-	if err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetKeyChainPref(helper)
-
-	return vault.SetHelper(vaultDir, helper)
-}
-
-func (bridge *Bridge) GetIMAPPort() int {
-	return bridge.vault.GetIMAPPort()
-}
-
-func (bridge *Bridge) SetIMAPPort(ctx context.Context, newPort int) error {
-	if newPort == bridge.vault.GetIMAPPort() {
-		return nil
-	}
-
-	if err := bridge.vault.SetIMAPPort(newPort); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetIMAPPort(newPort)
-
-	return bridge.restartIMAP(ctx)
-}
-
-func (bridge *Bridge) GetIMAPSSL() bool {
-	return bridge.vault.GetIMAPSSL()
-}
-
-func (bridge *Bridge) SetIMAPSSL(ctx context.Context, newSSL bool) error {
-	if newSSL == bridge.vault.GetIMAPSSL() {
-		return nil
-	}
-
-	if err := bridge.vault.SetIMAPSSL(newSSL); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetIMAPConnectionMode(newSSL)
-
-	return bridge.restartIMAP(ctx)
-}
-
-func (bridge *Bridge) GetSMTPPort() int {
-	return bridge.vault.GetSMTPPort()
-}
-
-func (bridge *Bridge) SetSMTPPort(ctx context.Context, newPort int) error {
-	if newPort == bridge.vault.GetSMTPPort() {
-		return nil
-	}
-
-	if err := bridge.vault.SetSMTPPort(newPort); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetSMTPPort(newPort)
-
-	return bridge.restartSMTP(ctx)
-}
-
-func (bridge *Bridge) GetSMTPSSL() bool {
-	return bridge.vault.GetSMTPSSL()
-}
-
-func (bridge *Bridge) SetSMTPSSL(ctx context.Context, newSSL bool) error {
-	if newSSL == bridge.vault.GetSMTPSSL() {
-		return nil
-	}
-
-	if err := bridge.vault.SetSMTPSSL(newSSL); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetSMTPConnectionMode(newSSL)
-
-	return bridge.restartSMTP(ctx)
-}
-
-func (bridge *Bridge) GetGluonCacheDir() string {
-	return bridge.vault.GetGluonCacheDir()
-}
-
-func (bridge *Bridge) GetGluonDataDir() (string, error) {
-	return bridge.locator.ProvideGluonDataPath()
-}
-
-func (bridge *Bridge) SetGluonDir(ctx context.Context, newGluonDir string) error {
-	bridge.usersLock.RLock()
-
-	defer func() {
-		logrus.Info("Restarting user event loops")
-		for _, u := range bridge.users {
-			u.ResumeEventLoop()
-		}
-
-		bridge.usersLock.RUnlock()
-	}()
-
-	type waiter struct {
-		w  *userevents.EventPollWaiter
-		id string
-	}
-
-	waiters := make([]waiter, 0, len(bridge.users))
-
-	logrus.Info("Pausing user event loops for gluon dir change")
-	for id, u := range bridge.users {
-		waiters = append(waiters, waiter{w: u.PauseEventLoopWithWaiter(), id: id})
-	}
-
-	logrus.Info("Waiting on user event loop completion")
-	for _, waiter := range waiters {
-		if err := waiter.w.WaitPollFinished(ctx); err != nil {
-			logrus.WithError(err).Errorf("Failed to wait on event loop pause for user %v", waiter.id)
-			return fmt.Errorf("failed on event loop pause: %w", err)
-		}
-	}
-
-	logrus.Info("Changing gluon directory")
-	return bridge.serverManager.SetGluonDir(ctx, newGluonDir)
-}
-
-func (bridge *Bridge) GetProxyAllowed() bool {
-	return bridge.vault.GetProxyAllowed()
-}
-
-func (bridge *Bridge) SetProxyAllowed(allowed bool) error {
-	if allowed {
-		bridge.proxyCtl.AllowProxy()
-	} else {
-		bridge.proxyCtl.DisallowProxy()
-	}
-
-	bridge.heartbeat.SetDoh(allowed)
-
-	return bridge.vault.SetProxyAllowed(allowed)
-}
-
-func (bridge *Bridge) GetShowAllMail() bool {
-	return bridge.vault.GetShowAllMail()
-}
-
-func (bridge *Bridge) SetShowAllMail(show bool) error {
-	return safe.RLockRet(func() error {
-		for _, user := range bridge.users {
-			user.SetShowAllMail(show)
-		}
-
-		bridge.heartbeat.SetShowAllMail(show)
-
-		return bridge.vault.SetShowAllMail(show)
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) GetAutostart() bool {
-	return bridge.vault.GetAutostart()
-}
-
-func (bridge *Bridge) SetAutostart(autostart bool) error {
-	if autostart != bridge.vault.GetAutostart() {
-		if err := bridge.vault.SetAutostart(autostart); err != nil {
-			return err
-		}
-
-		bridge.heartbeat.SetAutoStart(autostart)
-	}
-
-	var err error
-	if autostart {
-		// do nothing if already enabled
-		if bridge.autostarter.IsEnabled() {
-			return nil
-		}
-		err = bridge.autostarter.Enable()
-	} else {
-		// do nothing if already disabled
-		if !bridge.autostarter.IsEnabled() {
-			return nil
-		}
-		err = bridge.autostarter.Disable()
-	}
-
-	return err
-}
-
-func (bridge *Bridge) GetUpdateRollout() float64 {
-	return bridge.vault.GetUpdateRollout()
-}
-
-func (bridge *Bridge) GetAutoUpdate() bool {
-	return bridge.vault.GetAutoUpdate()
-}
-
-func (bridge *Bridge) SetAutoUpdate(autoUpdate bool) error {
-	if bridge.vault.GetAutoUpdate() == autoUpdate {
-		return nil
-	}
-
-	if err := bridge.vault.SetAutoUpdate(autoUpdate); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetAutoUpdate(autoUpdate)
-
-	bridge.goUpdate()
-
-	return nil
-}
-
-func (bridge *Bridge) GetTelemetryDisabled() bool {
-	return bridge.vault.GetTelemetryDisabled()
-}
-
-func (bridge *Bridge) SetTelemetryDisabled(isDisabled bool) error {
-	if err := bridge.vault.SetTelemetryDisabled(isDisabled); err != nil {
-		return err
-	}
-	// If telemetry is re-enabled locally, try to send the heartbeat.
-	if !isDisabled {
-		defer bridge.goHeartbeat()
-	}
-	return nil
-}
-
-func (bridge *Bridge) GetUpdateChannel() updater.Channel {
-	return bridge.vault.GetUpdateChannel()
-}
-
-func (bridge *Bridge) SetUpdateChannel(channel updater.Channel) error {
-	if bridge.vault.GetUpdateChannel() == channel {
-		return nil
-	}
-
-	if err := bridge.vault.SetUpdateChannel(channel); err != nil {
-		return err
-	}
-
-	bridge.heartbeat.SetBeta(channel)
-
-	bridge.goUpdate()
-
-	return nil
-}
-
-func (bridge *Bridge) GetCurrentVersion() *semver.Version {
-	return bridge.curVersion
-}
-
-func (bridge *Bridge) GetLastVersion() *semver.Version {
-	return bridge.lastVersion
-}
-
-func (bridge *Bridge) GetFirstStart() bool {
-	return bridge.firstStart
-}
-
-func (bridge *Bridge) GetColorScheme() string {
-	return bridge.vault.GetColorScheme()
-}
-
-func (bridge *Bridge) SetColorScheme(colorScheme string) error {
-	return bridge.vault.SetColorScheme(colorScheme)
-}
-
-// FactoryReset deletes all users, wipes the vault, and deletes all files.
-// Note: it does not clear the keychain. The only entry in the keychain is the vault password,
-// which we need at next startup to decrypt the vault.
-func (bridge *Bridge) FactoryReset(ctx context.Context) {
-	useTelemetry := !bridge.GetTelemetryDisabled()
-	// Delete all the users.
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			bridge.logoutUser(ctx, user, true, true, useTelemetry)
-		}
-	}, bridge.usersLock)
-
-	// Wipe the vault.
-	gluonCacheDir, err := bridge.locator.ProvideGluonCachePath()
-	if err != nil {
-		logrus.WithError(err).Error("Failed to provide gluon dir")
-	} else if err := bridge.vault.Reset(gluonCacheDir); err != nil {
-		logrus.WithError(err).Error("Failed to reset vault")
-	}
-
-	// Lastly, delete all files except the vault.
-	if err := bridge.locator.Clear(bridge.vault.Path()); err != nil {
-		logrus.WithError(err).Error("Failed to clear data paths")
-	}
-}

internal/bridge/settings_test.go

@@ -1,208 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"os"
-	"testing"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_Settings_GluonDir(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Create a user.
-			_, err := bridge.LoginFull(context.Background(), username, password, nil, nil)
-			require.NoError(t, err)
-
-			// Create a new location for the Gluon data.
-			newGluonDir := t.TempDir()
-
-			// Move the gluon dir; it should also move the user's data.
-			require.NoError(t, bridge.SetGluonDir(context.Background(), newGluonDir))
-
-			// Check that the new directory is not empty.
-			entries, err := os.ReadDir(newGluonDir)
-			require.NoError(t, err)
-
-			// There should be at least one entry.
-			require.NotEmpty(t, entries)
-		})
-	})
-}
-
-func TestBridge_Settings_GluonDirWithOnGoingEvents(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			_, err := bridge.LoginFull(context.Background(), "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			<-syncCh
-		})
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, 200)
-		})
-
-		withBridgeWaitForServers(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Create a new location for the Gluon data.
-			newGluonDir := t.TempDir()
-
-			// Move the gluon dir; it should also move the user's data.
-			require.NoError(t, bridge.SetGluonDir(context.Background(), newGluonDir))
-
-			// Check that the new directory is not empty.
-			entries, err := os.ReadDir(newGluonDir)
-			require.NoError(t, err)
-
-			// There should be at least one entry.
-			require.NotEmpty(t, entries)
-		})
-	})
-}
-
-func TestBridge_Settings_IMAPPort(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			curPort := bridge.GetIMAPPort()
-
-			// Set the port to 1144.
-			require.NoError(t, bridge.SetIMAPPort(ctx, 1144))
-
-			// Get the new setting.
-			require.Equal(t, 1144, bridge.GetIMAPPort())
-
-			// Assert that it has changed.
-			require.NotEqual(t, curPort, bridge.GetIMAPPort())
-		})
-	})
-}
-
-func TestBridge_Settings_IMAPSSL(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// By default, IMAP SSL is disabled.
-			require.False(t, bridge.GetIMAPSSL())
-
-			// Enable IMAP SSL.
-			require.NoError(t, bridge.SetIMAPSSL(ctx, true))
-
-			// Get the new setting.
-			require.True(t, bridge.GetIMAPSSL())
-		})
-	})
-}
-
-func TestBridge_Settings_SMTPPort(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			curPort := bridge.GetSMTPPort()
-
-			// Set the port to 1024.
-			require.NoError(t, bridge.SetSMTPPort(ctx, 1024))
-
-			// Get the new setting.
-			require.Equal(t, 1024, bridge.GetSMTPPort())
-
-			// Assert that it has changed.
-			require.NotEqual(t, curPort, bridge.GetSMTPPort())
-		})
-	})
-}
-
-func TestBridge_Settings_SMTPSSL(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// By default, SMTP SSL is disabled.
-			require.False(t, bridge.GetSMTPSSL())
-
-			// Enable SMTP SSL.
-			require.NoError(t, bridge.SetSMTPSSL(ctx, true))
-
-			// Get the new setting.
-			require.True(t, bridge.GetSMTPSSL())
-		})
-	})
-}
-
-func TestBridge_Settings_Proxy(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// By default, proxy is allowed.
-			require.False(t, bridge.GetProxyAllowed())
-
-			// Disallow proxy.
-			mocks.ProxyCtl.EXPECT().AllowProxy()
-			require.NoError(t, bridge.SetProxyAllowed(true))
-
-			// Get the new setting.
-			require.True(t, bridge.GetProxyAllowed())
-		})
-	})
-}
-
-func TestBridge_Settings_Autostart(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// By default, autostart is enabled.
-			require.True(t, bridge.GetAutostart())
-
-			// Disable autostart.
-			mocks.Autostarter.EXPECT().IsEnabled().Return(true)
-			mocks.Autostarter.EXPECT().Disable().Return(nil)
-			require.NoError(t, bridge.SetAutostart(false))
-
-			// Get the new setting.
-			require.False(t, bridge.GetAutostart())
-
-			// Re Enable autostart.
-			mocks.Autostarter.EXPECT().IsEnabled().Return(false)
-			mocks.Autostarter.EXPECT().Enable().Return(nil)
-			require.NoError(t, bridge.SetAutostart(true))
-
-			// Get the new setting.
-			require.True(t, bridge.GetAutostart())
-		})
-	})
-}
-
-func TestBridge_Settings_FirstStart(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// By default, first start is true.
-			require.True(t, bridge.GetFirstStart())
-
-			// the setting of the first start value is managed by bridge itself, so the setter is not exported.
-		})
-	})
-}

internal/bridge/smtp.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"crypto/tls"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/identifier"
-)
-
-func (bridge *Bridge) restartSMTP(ctx context.Context) error {
-	return bridge.serverManager.RestartSMTP(ctx)
-}
-
-type bridgeSMTPSettings struct {
-	b *Bridge
-}
-
-func (b *bridgeSMTPSettings) TLSConfig() *tls.Config {
-	return b.b.tlsConfig
-}
-
-func (b *bridgeSMTPSettings) Log() bool {
-	return b.b.logSMTP
-}
-
-func (b *bridgeSMTPSettings) Port() int {
-	return b.b.vault.GetSMTPPort()
-}
-
-func (b *bridgeSMTPSettings) SetPort(i int) error {
-	return b.b.vault.SetSMTPPort(i)
-}
-
-func (b *bridgeSMTPSettings) UseSSL() bool {
-	return b.b.vault.GetSMTPSSL()
-}
-
-func (b *bridgeSMTPSettings) Identifier() identifier.UserAgentUpdater {
-	return &bridgeUserAgentUpdater{Bridge: b.b}
-}

internal/bridge/store_factory.go

@@ -0,0 +1,87 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package bridge
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/ProtonMail/proton-bridge/v2/internal/sentry"
+	"github.com/ProtonMail/proton-bridge/v2/internal/store"
+	"github.com/ProtonMail/proton-bridge/v2/internal/store/cache"
+	"github.com/ProtonMail/proton-bridge/v2/internal/users"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/listener"
+	"github.com/ProtonMail/proton-bridge/v2/pkg/message"
+)
+
+type storeFactory struct {
+	cacheProvider  CacheProvider
+	sentryReporter *sentry.Reporter
+	panicHandler   users.PanicHandler
+	eventListener  listener.Listener
+	events         *store.Events
+	cache          cache.Cache
+	builder        *message.Builder
+}
+
+func newStoreFactory(
+	cacheProvider CacheProvider,
+	sentryReporter *sentry.Reporter,
+	panicHandler users.PanicHandler,
+	eventListener listener.Listener,
+	cache cache.Cache,
+	builder *message.Builder,
+) *storeFactory {
+	return &storeFactory{
+		cacheProvider:  cacheProvider,
+		sentryReporter: sentryReporter,
+		panicHandler:   panicHandler,
+		eventListener:  eventListener,
+		events:         store.NewEvents(cacheProvider.GetIMAPCachePath()),
+		cache:          cache,
+		builder:        builder,
+	}
+}
+
+// New creates new store for given user.
+func (f *storeFactory) New(user store.BridgeUser) (*store.Store, error) {
+	return store.New(
+		f.sentryReporter,
+		f.panicHandler,
+		user,
+		f.eventListener,
+		f.cache,
+		f.builder,
+		getUserStorePath(f.cacheProvider.GetDBDir(), user.ID()),
+		f.events,
+	)
+}
+
+// Remove removes all store files for given user.
+func (f *storeFactory) Remove(userID string) error {
+	return store.RemoveStore(
+		f.events,
+		getUserStorePath(f.cacheProvider.GetDBDir(), userID),
+		userID,
+	)
+}
+
+// getUserStorePath returns the file path of the store database for the given userID.
+func getUserStorePath(storeDir string, userID string) (path string) {
+	return filepath.Join(storeDir, fmt.Sprintf("mailbox-%v.db", userID))
+}

internal/bridge/sync_test.go

@@ -1,787 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/gluon/rfc822"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/imapservice"
-	"github.com/bradenaw/juniper/iterator"
-	"github.com/bradenaw/juniper/stream"
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/emersion/go-imap"
-	"github.com/emersion/go-imap/client"
-	"github.com/golang/mock/gomock"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_Sync(t *testing.T) {
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		var total uint64
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			// Count how many bytes it takes to fully sync the user.
-			total = countBytesRead(netCtl, func() {
-				userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-				require.NoError(t, err)
-
-				require.Equal(t, userID, (<-syncCh).UserID)
-			})
-		})
-
-		// If we then connect an IMAP client, it should see all the messages.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, _ *bridge.Mocks) {
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			status, err := client.Select(`Folders/folder`, false)
-			require.NoError(t, err)
-			require.Equal(t, uint32(numMsg), status.Messages)
-		})
-
-		// Now let's remove the user and simulate a network error.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-		})
-
-		// Pretend we can only sync 2/3 of the original messages.
-		netCtl.SetReadLimit(2 * total / 3)
-
-		// Login the user; its sync should fail.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, _ *bridge.Mocks) {
-			{
-				syncCh, done := chToType[events.Event, events.SyncFailed](b.GetEvents(events.SyncFailed{}))
-				defer done()
-
-				userID, err := b.LoginFull(ctx, "imap", password, nil, nil)
-				require.NoError(t, err)
-
-				require.Equal(t, userID, (<-syncCh).UserID)
-
-				info, err := b.GetUserInfo(userID)
-				require.NoError(t, err)
-				require.True(t, info.State == bridge.Connected)
-			}
-
-			// Remove the network limit, allowing the sync to finish.
-			netCtl.SetReadLimit(0)
-
-			{
-				syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-				defer done()
-
-				require.Equal(t, userID, (<-syncCh).UserID)
-
-				info, err := b.GetUserInfo(userID)
-				require.NoError(t, err)
-				require.True(t, info.State == bridge.Connected)
-
-				client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-				require.NoError(t, err)
-				require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-				defer func() { _ = client.Logout() }()
-
-				status, err := client.Select(`Folders/folder`, false)
-				require.NoError(t, err)
-				require.Equal(t, uint32(numMsg), status.Messages)
-			}
-		})
-	}, server.WithTLS(false))
-}
-
-// GODT-2215: This test no longer works since it's now possible to import messages into Gluon with bad ContentType header.
-func _TestBridge_Sync_BadMessage(t *testing.T) { //nolint:unused,deadcode
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		var messageIDs []string
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			messageIDs = createMessages(ctx, t, c, addrID, labelID,
-				[]byte("To: someone@pm.me\r\nSubject: Good message\r\n\r\nHello!"),
-				[]byte("To: someone@pm.me\r\nSubject: Bad message\r\nContentType: this is not a valid content type\r\n\r\nHello!"),
-			)
-		})
-
-		// The initial user should be fully synced and should skip the bad message.
-		// We should report the bad message to sentry.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			mocks.Reporter.EXPECT().ReportMessageWithContext("Failed to build message (sync)", gomock.Any())
-
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		// If we then connect an IMAP client, it should see the good message but not the bad one.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, _ *bridge.Mocks) {
-			info, err := b.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.True(t, info.State == bridge.Connected)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			status, err := client.Select(`Folders/folder`, false)
-			require.NoError(t, err)
-			require.Equal(t, uint32(1), status.Messages)
-
-			messages, err := clientFetch(client, `Folders/folder`)
-			require.NoError(t, err)
-			require.Len(t, messages, 1)
-
-			// The bad message should have been skipped.
-			literal, err := io.ReadAll(messages[0].GetBody(must(imap.ParseBodySectionName("BODY[]"))))
-			require.NoError(t, err)
-
-			header, err := rfc822.Parse(literal).ParseHeader()
-			require.NoError(t, err)
-			require.Equal(t, "Good message", header.Get("Subject"))
-			require.Equal(t, messageIDs[0], header.Get("X-Pm-Internal-Id"))
-		})
-	})
-}
-
-func TestBridge_SyncWithOngoingEvents(t *testing.T) {
-	numMsg := 1 << 8
-	messageSplitIndex := numMsg * 2 / 3
-	renmainingMessageCount := numMsg - messageSplitIndex
-
-	messages := make([]string, 0, numMsg)
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			importResults := createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-			for _, v := range importResults {
-				if len(v) != 0 {
-					messages = append(messages, v)
-				}
-			}
-		})
-
-		var total uint64
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			// Count how many bytes it takes to fully sync the user.
-			total = countBytesRead(netCtl, func() {
-				userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-				require.NoError(t, err)
-
-				require.Equal(t, userID, (<-syncCh).UserID)
-			})
-		})
-
-		// Now let's remove the user and stop the network at 2/3 of the data.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-		})
-
-		// Pretend we can only sync 2/3 of the original messages.
-		netCtl.SetReadLimit(2 * total / 3)
-
-		// Login the user; its sync should fail.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(b *bridge.Bridge, mocks *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](b.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			{
-				syncFailedCh, syncFailedDone := chToType[events.Event, events.SyncFailed](b.GetEvents(events.SyncFailed{}))
-				defer syncFailedDone()
-
-				userID, err := b.LoginFull(ctx, "imap", password, nil, nil)
-				require.NoError(t, err)
-
-				require.Equal(t, userID, (<-syncFailedCh).UserID)
-
-				info, err := b.GetUserInfo(userID)
-				require.NoError(t, err)
-				require.True(t, info.State == bridge.Connected)
-			}
-
-			// Create a new mailbox and move that last 1/3 of the messages into it to simulate user
-			// actions during sync.
-			{
-				newLabelID, err := s.CreateLabel(userID, "folder2", "", proton.LabelTypeFolder)
-				require.NoError(t, err)
-
-				messages := messages[messageSplitIndex:]
-
-				withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-					require.NoError(t, c.UnlabelMessages(ctx, messages, labelID))
-					require.NoError(t, c.LabelMessages(ctx, messages, newLabelID))
-				})
-			}
-
-			// Remove the network limit, allowing the sync to finish.
-			netCtl.SetReadLimit(0)
-			{
-				require.Equal(t, userID, (<-syncCh).UserID)
-
-				info, err := b.GetUserInfo(userID)
-				require.NoError(t, err)
-				require.True(t, info.State == bridge.Connected)
-
-				client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, b.GetIMAPPort()))
-				require.NoError(t, err)
-				require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-				defer func() { _ = client.Logout() }()
-
-				// Check that the new messages arrive in the right location.
-				require.Eventually(t, func() bool {
-					status, err := client.Select(`Folders/folder2`, true)
-					if err != nil {
-						return false
-					}
-					if status.Messages != uint32(renmainingMessageCount) {
-						return false
-					}
-
-					return true
-				}, 10*time.Second, 500*time.Millisecond)
-			}
-		})
-	}, server.WithTLS(false))
-}
-
-func TestBridge_CanProcessEventsDuringSync(t *testing.T) {
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		// Simulate 429 to prevent sync from progressing.
-		s.AddStatusHook(func(request *http.Request) (int, bool) {
-			if strings.Contains(request.URL.Path, "/mail/v4/messages/") {
-				return http.StatusTooManyRequests, true
-			}
-
-			return 0, false
-		})
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncStartedCh, syncStartedDone := chToType[events.Event, events.SyncStarted](bridge.GetEvents(events.SyncStarted{}))
-			defer syncStartedDone()
-
-			addressCreatedCh, addressCreatedDone := chToType[events.Event, events.UserAddressCreated](bridge.GetEvents(events.UserAddressCreated{}))
-			defer addressCreatedDone()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncStartedCh).UserID)
-
-			// Create a new address
-			newAddress := "foo@proton.ch"
-			addrID, err := s.CreateAddress(userID, newAddress, password)
-			require.NoError(t, err)
-
-			event := <-addressCreatedCh
-			require.Equal(t, userID, event.UserID)
-			require.Equal(t, newAddress, event.Email)
-			require.Equal(t, addrID, event.AddressID)
-		})
-	}, server.WithTLS(false))
-}
-
-func TestBridge_RefreshDuringSyncRestartSync(t *testing.T) {
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		var refreshPerformed atomic.Bool
-		refreshPerformed.Store(false)
-
-		// Simulate 429 to prevent sync from progressing.
-		s.AddStatusHook(func(request *http.Request) (int, bool) {
-			if strings.Contains(request.URL.Path, "/mail/v4/messages/") {
-				if !refreshPerformed.Load() {
-					return http.StatusTooManyRequests, true
-				}
-			}
-
-			return 0, false
-		})
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			syncStartedCh, syncStartedDone := chToType[events.Event, events.SyncStarted](bridge.GetEvents(events.SyncStarted{}))
-			defer syncStartedDone()
-
-			require.Equal(t, userID, (<-syncStartedCh).UserID)
-
-			require.NoError(t, err, s.RefreshUser(userID, proton.RefreshMail))
-			require.Equal(t, userID, (<-syncStartedCh).UserID)
-			refreshPerformed.Store(true)
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-	}, server.WithTLS(false))
-}
-
-func TestBridge_EventReplayAfterSyncHasFinished(t *testing.T) {
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		addrID1, err := s.CreateAddress(userID, "foo@proton.ch", password)
-		require.NoError(t, err)
-
-		var allowSyncToProgress atomic.Bool
-		allowSyncToProgress.Store(false)
-
-		// Simulate 429 to prevent sync from progressing.
-		s.AddStatusHook(func(request *http.Request) (int, bool) {
-			if request.Method == "GET" && strings.Contains(request.URL.Path, "/mail/v4/messages/") {
-				if !allowSyncToProgress.Load() {
-					return http.StatusTooManyRequests, true
-				}
-			}
-
-			return 0, false
-		})
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			syncStartedCh, syncStartedDone := chToType[events.Event, events.SyncStarted](bridge.GetEvents(events.SyncStarted{}))
-			defer syncStartedDone()
-
-			addressCreatedCh, addressCreatedDone := chToType[events.Event, events.UserAddressCreated](bridge.GetEvents(events.UserAddressCreated{}))
-			defer addressCreatedDone()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncStartedCh).UserID)
-
-			// create 20 more messages and move them to inbox
-			withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 20)
-			})
-
-			// User AddrID2 event as a check point to see when the new address was created.
-			addrID2, err := s.CreateAddress(userID, "bar@proton.ch", password)
-			require.NoError(t, err)
-
-			allowSyncToProgress.Store(true)
-			require.Equal(t, userID, (<-syncCh).UserID)
-
-			// At most two events can be published, one for the first address, then for the second.
-			// if the second event is not `addrID2` then something went wrong.
-			event := <-addressCreatedCh
-			if event.AddressID == addrID1 {
-				event = <-addressCreatedCh
-			}
-
-			require.Equal(t, addrID2, event.AddressID)
-
-			info, err := bridge.GetUserInfo(userID)
-			require.NoError(t, err)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			// Finally check if the 20 messages are in INBOX.
-			status, err := client.Status("INBOX", []imap.StatusItem{imap.StatusMessages})
-			require.NoError(t, err)
-			require.Equal(t, uint32(20), status.Messages)
-
-			// Finally check if the numMsg are in the folder.
-			status, err = client.Status("Folders/folder", []imap.StatusItem{imap.StatusMessages})
-			require.NoError(t, err)
-			require.Equal(t, uint32(numMsg), status.Messages)
-		})
-	}, server.WithTLS(false))
-}
-
-func TestBridge_MessageCreateDuringSync(t *testing.T) {
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		var allowSyncToProgress atomic.Bool
-		allowSyncToProgress.Store(false)
-
-		// Simulate 429 to prevent sync from progressing.
-		s.AddStatusHook(func(request *http.Request) (int, bool) {
-			if request.Method == "GET" && strings.Contains(request.URL.Path, "/mail/v4/messages/") {
-				if !allowSyncToProgress.Load() {
-					return http.StatusTooManyRequests, true
-				}
-			}
-
-			return 0, false
-		})
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncStartedCh, syncStartedDone := chToType[events.Event, events.SyncStarted](bridge.GetEvents(events.SyncStarted{}))
-			defer syncStartedDone()
-
-			addressCreatedCh, addressCreatedDone := chToType[events.Event, events.UserAddressCreated](bridge.GetEvents(events.UserAddressCreated{}))
-			defer addressCreatedDone()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			require.Equal(t, userID, (<-syncStartedCh).UserID)
-
-			// create 20 more messages and move them to inbox
-			withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 20)
-			})
-
-			// User AddrID2 event as a check point to see when the new address was created.
-			addrID, err := s.CreateAddress(userID, "bar@proton.ch", password)
-			require.NoError(t, err)
-
-			// At most two events can be published, one for the first address, then for the second.
-			// if the second event is not `addrID` then something went wrong.
-			event := <-addressCreatedCh
-			require.Equal(t, addrID, event.AddressID)
-			allowSyncToProgress.Store(true)
-
-			info, err := bridge.GetUserInfo(userID)
-			require.NoError(t, err)
-
-			client, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, client.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = client.Logout() }()
-
-			require.Eventually(t, func() bool {
-				// Finally check if the 20 messages are in INBOX.
-				status, err := client.Status("INBOX", []imap.StatusItem{imap.StatusMessages})
-				require.NoError(t, err)
-
-				return uint32(20) == status.Messages
-			}, 10*time.Second, time.Second)
-		})
-	}, server.WithTLS(false))
-}
-
-func TestBridge_CorruptedVaultClearsPreviousIMAPSyncState(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, vaultKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, 100)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, vaultKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			var err error
-
-			userID, err = bridge.LoginFull(context.Background(), "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			// Wait for sync to finish
-			require.Equal(t, userID, (<-syncCh).UserID)
-		})
-
-		settingsPath, err := locator.ProvideSettingsPath()
-		require.NoError(t, err)
-
-		syncConfigPath, err := locator.ProvideIMAPSyncConfigPath()
-		require.NoError(t, err)
-
-		syncStatePath := imapservice.GetSyncConfigPath(syncConfigPath, userID)
-		// Check sync state is complete
-		{
-			state, err := imapservice.NewSyncState(syncStatePath)
-			require.NoError(t, err)
-			syncStatus, err := state.GetSyncStatus(context.Background())
-			require.NoError(t, err)
-			require.True(t, syncStatus.IsComplete())
-		}
-
-		// corrupt the vault
-		require.NoError(t, os.WriteFile(filepath.Join(settingsPath, "vault.enc"), []byte("Trash!"), 0o600))
-
-		// Bridge starts but can't find the gluon database dir; there should be no error.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, vaultKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			_, err := bridge.LoginFull(context.Background(), "imap", password, nil, nil)
-			require.NoError(t, err)
-		})
-
-		// Check sync state is reset.
-		{
-			state, err := imapservice.NewSyncState(syncStatePath)
-			require.NoError(t, err)
-			syncStatus, err := state.GetSyncStatus(context.Background())
-			require.NoError(t, err)
-			require.False(t, syncStatus.IsComplete())
-		}
-	})
-}
-
-func withClient(ctx context.Context, t *testing.T, s *server.Server, username string, password []byte, fn func(context.Context, *proton.Client)) { //nolint:unparam
-	m := proton.New(
-		proton.WithHostURL(s.GetHostURL()),
-		proton.WithTransport(proton.InsecureTransport()),
-	)
-
-	c, _, err := m.NewClientWithLogin(ctx, username, password)
-	require.NoError(t, err)
-	defer c.Close()
-
-	fn(ctx, c)
-}
-
-func clientFetch(client *client.Client, mailbox string, extraItems ...imap.FetchItem) ([]*imap.Message, error) {
-	status, err := client.Select(mailbox, false)
-	if err != nil {
-		return nil, err
-	}
-
-	if status.Messages == 0 {
-		return nil, nil
-	}
-
-	resCh := make(chan *imap.Message)
-
-	fetchItems := []imap.FetchItem{imap.FetchFlags, imap.FetchEnvelope, imap.FetchUid, imap.FetchBodyStructure, "BODY.PEEK[]"}
-	fetchItems = append(fetchItems, extraItems...)
-
-	go func() {
-		if err := client.Fetch(
-			&imap.SeqSet{Set: []imap.Seq{{Start: 1, Stop: status.Messages}}},
-			fetchItems,
-			resCh,
-		); err != nil {
-			panic(err)
-		}
-	}()
-
-	return iterator.Collect(iterator.Chan(resCh)), nil
-}
-
-func clientStore(client *client.Client, from, to int, isUID bool, item imap.StoreItem, flags ...string) error {
-	var storeFunc func(seqset *imap.SeqSet, item imap.StoreItem, value interface{}, ch chan *imap.Message) error
-
-	if isUID {
-		storeFunc = client.UidStore
-	} else {
-		storeFunc = client.Store
-	}
-
-	return storeFunc(
-		&imap.SeqSet{Set: []imap.Seq{{Start: uint32(from), Stop: uint32(to)}}},
-		item,
-		xslices.Map(flags, func(flag string) interface{} { return flag }),
-		nil,
-	)
-}
-
-func clientList(client *client.Client) []*imap.MailboxInfo {
-	resCh := make(chan *imap.MailboxInfo)
-
-	go func() {
-		if err := client.List("", "*", resCh); err != nil {
-			panic(err)
-		}
-	}()
-
-	return iterator.Collect(iterator.Chan(resCh))
-}
-
-func createNumMessages(ctx context.Context, t *testing.T, c *proton.Client, addrID, labelID string, count int) []string {
-	literal, err := os.ReadFile(filepath.Join("testdata", "text-plain.eml"))
-	require.NoError(t, err)
-
-	return createMessages(ctx, t, c, addrID, labelID, xslices.Repeat(literal, count)...)
-}
-
-func createMessages(ctx context.Context, t *testing.T, c *proton.Client, addrID, labelID string, messages ...[]byte) []string {
-	return createMessagesWithFlags(ctx, t, c, addrID, labelID, 0, messages...)
-}
-
-func createMessagesWithFlags(ctx context.Context, t *testing.T, c *proton.Client, addrID, labelID string, flags proton.MessageFlag, messages ...[]byte) []string {
-	user, err := c.GetUser(ctx)
-	require.NoError(t, err)
-
-	addr, err := c.GetAddresses(ctx)
-	require.NoError(t, err)
-
-	salt, err := c.GetSalts(ctx)
-	require.NoError(t, err)
-
-	keyPass, err := salt.SaltForKey(password, user.Keys.Primary().ID)
-	require.NoError(t, err)
-
-	_, addrKRs, err := proton.Unlock(user, addr, keyPass, async.NoopPanicHandler{})
-	require.NoError(t, err)
-
-	_, ok := addrKRs[addrID]
-	require.True(t, ok)
-
-	var msgFlags proton.MessageFlag
-	if flags == 0 {
-		msgFlags = proton.MessageFlagReceived
-	} else {
-		msgFlags = flags
-	}
-
-	str, err := c.ImportMessages(
-		ctx,
-		addrKRs[addrID],
-		runtime.NumCPU(),
-		runtime.NumCPU(),
-		xslices.Map(messages, func(message []byte) proton.ImportReq {
-			return proton.ImportReq{
-				Metadata: proton.ImportMetadata{
-					AddressID: addrID,
-					LabelIDs:  []string{labelID},
-					Flags:     msgFlags,
-				},
-				Message: message,
-			}
-		})...,
-	)
-	require.NoError(t, err)
-
-	res, err := stream.Collect(ctx, str)
-	require.NoError(t, err)
-
-	return xslices.Map(res, func(res proton.ImportRes) string {
-		return res.MessageID
-	})
-}
-
-func countBytesRead(ctl *proton.NetCtl, fn func()) uint64 {
-	var read uint64
-
-	ctl.OnRead(func(b []byte) {
-		atomic.AddUint64(&read, uint64(len(b)))
-	})
-
-	fn()
-
-	return read
-}

internal/bridge/sync_unix_test.go

@@ -1,82 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-//go:build !windows
-
-package bridge_test
-
-import (
-	"context"
-	"syscall"
-	"testing"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/stretchr/testify/require"
-)
-
-// Disabled due to flakiness.
-func _TestBridge_SyncExistsWithErrorWhenTooManyFilesAreOpen(t *testing.T) { //nolint:unused
-	var rlimitCurrent syscall.Rlimit
-
-	require.NoError(t, syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimitCurrent))
-
-	// Restore RLimit for Process at the end of this test
-	defer func() {
-		require.NoError(t, syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlimitCurrent))
-	}()
-
-	rlimit := syscall.Rlimit{
-		Max: 100,
-		Cur: 100,
-	}
-
-	require.NoError(t, syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlimit))
-
-	numMsg := 1 << 8
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		userID, addrID, err := s.CreateUser("imap", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		withClient(ctx, t, s, "imap", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, numMsg)
-		})
-
-		// The initial user should be fully synced.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			syncCh, done := bridge.GetEvents(events.SyncFailed{})
-			defer done()
-
-			userID, err := bridge.LoginFull(ctx, "imap", password, nil, nil)
-			require.NoError(t, err)
-
-			evt := <-syncCh
-			switch e := evt.(type) {
-			case events.SyncFailed:
-				require.Equal(t, userID, e.UserID)
-			default:
-				require.Fail(t, "Expected events.SyncFailed{}")
-			}
-		})
-	}, server.WithTLS(false))
-}

internal/bridge/testdata/invite.eml

@@ -1,85 +0,0 @@
-From: <username@proton.local>
-To: <recipient@proton.local>
-Subject: Testing calendar invite
-Date: Fri, 3 Feb 2023 01:04:32 +0100
-Message-ID: <000001d93763$183b74e0$48b25ea0$@proton.local>
-MIME-Version: 1.0
-Content-Type: text/calendar; method=REQUEST;
-	charset="utf-8"
-Content-Transfer-Encoding: 7bit
-X-Mailer: Microsoft Outlook 16.0
-Thread-Index: Adk3Yw5pLdgwsT46RviXb/nfvQlesQAAAmGA
-Content-Language: en-gb
-
-BEGIN:VCALENDAR
-PRODID:-//Microsoft Corporation//Outlook 16.0 MIMEDIR//EN
-VERSION:2.0
-METHOD:REQUEST
-X-MS-OLK-FORCEINSPECTOROPEN:TRUE
-BEGIN:VTIMEZONE
-TZID:Central European Standard Time
-BEGIN:STANDARD
-DTSTART:16011028T030000
-RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10
-TZOFFSETFROM:+0200
-TZOFFSETTO:+0100
-END:STANDARD
-BEGIN:DAYLIGHT
-DTSTART:16010325T020000
-RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=3
-TZOFFSETFROM:+0100
-TZOFFSETTO:+0200
-END:DAYLIGHT
-END:VTIMEZONE
-BEGIN:VEVENT
-ATTENDEE;CN=recipient@proton.local;RSVP=TRUE:mailto:recipient@proton.local
-CLASS:PUBLIC
-CREATED:20230203T000432Z
-DESCRIPTION:qweqweqweqweqweqwe/gn\\n
-DTEND;TZID="Central European Standard Time":20230203T020000
-DTSTAMP:20230203T000432Z
-DTSTART;TZID="Central European Standard Time":20230203T013000
-LAST-MODIFIED:20230203T000432Z
-LOCATION:qweqwe
-ORGANIZER;CN=username@proton.local:mailto:username@proton.local
-PRIORITY:5
-SEQUENCE:0
-SUMMARY;LANGUAGE=en-gb:Testing calendar invite
-TRANSP:OPAQUE
-UID:040000008200E00074C5B7101A82E008000000003080B2796B37D901000000000000000
-	0100000001236CD1CD93CA9449C6FF1AC4DEAC44E
-X-ALT-DESC;FMTTYPE=text/html:<html xmlns:v="urn:schemas-microsoft-com:vml" 
-	xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-mic
-	rosoft-com:office:word" xmlns:m="http://schemas.microsoft.com/office/2004/
-	12/omml" xmlns="http://www.w3.org/TR/REC-html40"><head><meta http-equiv=Co
-	ntent-Type content="text/html/g; charset=us-ascii"><meta name=Generator con
-	tent="Microsoft Word 15 (filtered medium)"><style><!--/gn/* Font Definition
-	s *//gn@font-face\\n	{font-family:"Cambria Math"\\;\\n	panose-1:2 4 5 3 5 4 6 
-	3 2 4/g;}\\n@font-face\\n	{font-family:Calibri\\;\\n	panose-1:2 15 5 2 2 2 4 3 
-	2 4/g;}\\n/* Style Definitions */\\np.MsoNormal\\, li.MsoNormal\\, div.MsoNorma
-	l/gn	{margin:0cm\\;\\n	font-size:11.0pt\\;\\n	font-family:"Calibri"\\,sans-serif
-	/g;\\n	mso-fareast-language:EN-US\\;}\\nspan.EmailStyle18\\n	{mso-style-type:pe
-	rsonal-compose/g;\\n	font-family:"Calibri"\\,sans-serif\\;\\n	color:windowtext\\
-	;}/gn.MsoChpDefault\\n	{mso-style-type:export-only\\;\\n	font-size:10.0pt\\;}\\n
-	@page WordSection1/gn	{size:612.0pt 792.0pt\\;\\n	margin:72.0pt 72.0pt 72.0pt
-	 72.0pt/g;}\\ndiv.WordSection1\\n	{page:WordSection1\\;}\\n--></style><!--[if g
-	te mso 9]><xml>/gn<o:shapedefaults v:ext="edit" spidmax="1026" />\\n</xml><!
-	[endif]--><!--[if gte mso 9]><xml>/gn<o:shapelayout v:ext="edit">\\n<o:idmap
-	 v:ext="edit" data="1" />/gn</o:shapelayout></xml><![endif]--></head><body 
-	lang=EN-GB link="#0563C1" vlink="#954F72" style='word-wrap:break-word'><di
-	v class=WordSection1><p class=MsoNormal><span lang=EN-US>qweqweqweqweqweqw
-	e<o:p></o:p></span></p></div></body></html>
-X-MICROSOFT-CDO-BUSYSTATUS:TENTATIVE
-X-MICROSOFT-CDO-IMPORTANCE:1
-X-MICROSOFT-CDO-INTENDEDSTATUS:BUSY
-X-MICROSOFT-DISALLOW-COUNTER:FALSE
-X-MS-OLK-AUTOSTARTCHECK:FALSE
-X-MS-OLK-CONFTYPE:0
-BEGIN:VALARM
-TRIGGER:-PT15M
-ACTION:DISPLAY
-DESCRIPTION:Reminder
-END:VALARM
-END:VEVENT
-END:VCALENDAR
-

internal/bridge/testdata/text-plain.eml

@@ -1,6 +0,0 @@
-To: recipient@pm.me
-From: sender@pm.me
-Subject: Test
-Content-Type: text/plain; charset=utf-8
-
-Test

internal/bridge/tls.go

@@ -1,26 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-func (bridge *Bridge) GetBridgeTLSCert() ([]byte, []byte) {
-	return bridge.vault.GetBridgeTLSCert()
-}
-
-func (bridge *Bridge) SetBridgeTLSCertPath(certPath, keyPath string) error {
-	return bridge.vault.SetBridgeTLSCertPath(certPath, keyPath)
-}

internal/bridge/types.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -13,44 +13,42 @@
 // GNU General Public License for more details.
 //
 // You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
 package bridge
 
 import (
-	"context"
+	"github.com/Masterminds/semver/v3"
 
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
+	"github.com/ProtonMail/proton-bridge/v2/internal/updater"
 )
 
 type Locator interface {
-	ProvideSettingsPath() (string, error)
+	Clear() error
+	ClearUpdates() error
 	ProvideLogsPath() (string, error)
-	ProvideGluonCachePath() (string, error)
-	ProvideGluonDataPath() (string, error)
-	ProvideStatsPath() (string, error)
-	GetLicenseFilePath() string
-	GetDependencyLicensesLink() string
-	Clear(...string) error
-	ProvideIMAPSyncConfigPath() (string, error)
 }
 
-type ProxyController interface {
-	AllowProxy()
-	DisallowProxy()
+type CacheProvider interface {
+	GetIMAPCachePath() string
+	GetDBDir() string
+	GetDefaultMessageCacheDir() string
 }
 
-type TLSReporter interface {
-	GetTLSIssueCh() <-chan struct{}
-}
-
-type Autostarter interface {
-	Enable() error
-	Disable() error
-	IsEnabled() bool
+type SettingsProvider interface {
+	Get(key string) string
+	Set(key string, value string)
+	GetBool(key string) bool
+	SetBool(key string, val bool)
+	GetInt(key string) int
 }
 
 type Updater interface {
-	GetVersionInfo(context.Context, updater.Downloader, updater.Channel) (updater.VersionInfo, error)
-	InstallUpdate(context.Context, updater.Downloader, updater.VersionInfo) error
+	Check() (updater.VersionInfo, error)
+	IsDowngrade(updater.VersionInfo) bool
+	InstallUpdate(updater.VersionInfo) error
+}
+
+type Versioner interface {
+	RemoveOtherVersions(*semver.Version) error
 }

internal/bridge/updates.go

@@ -1,141 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"errors"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/updater"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) CheckForUpdates() {
-	bridge.goUpdate()
-}
-
-func (bridge *Bridge) InstallUpdate(version updater.VersionInfo) {
-	bridge.installCh <- installJob{version: version, silent: false}
-}
-
-func (bridge *Bridge) handleUpdate(version updater.VersionInfo) {
-	log := logrus.WithFields(logrus.Fields{
-		"version": version.Version,
-		"current": bridge.curVersion,
-		"channel": bridge.vault.GetUpdateChannel(),
-	})
-
-	bridge.publish(events.UpdateLatest{
-		Version: version,
-	})
-
-	switch {
-	case !version.Version.GreaterThan(bridge.curVersion):
-		log.Debug("No update available")
-
-		bridge.publish(events.UpdateNotAvailable{})
-
-	case version.RolloutProportion < bridge.vault.GetUpdateRollout():
-		log.Info("An update is available but has not been rolled out yet")
-
-		bridge.publish(events.UpdateNotAvailable{})
-
-	case bridge.curVersion.LessThan(version.MinAuto):
-		log.Info("An update is available but is incompatible with this version")
-
-		bridge.publish(events.UpdateAvailable{
-			Version:    version,
-			Compatible: false,
-			Silent:     false,
-		})
-
-	case !bridge.vault.GetAutoUpdate():
-		log.Info("An update is available but auto-update is disabled")
-
-		bridge.publish(events.UpdateAvailable{
-			Version:    version,
-			Compatible: true,
-			Silent:     false,
-		})
-
-	default:
-		safe.RLock(func() {
-			bridge.installCh <- installJob{version: version, silent: true}
-		}, bridge.newVersionLock)
-	}
-}
-
-type installJob struct {
-	version updater.VersionInfo
-	silent  bool
-}
-
-func (bridge *Bridge) installUpdate(ctx context.Context, job installJob) {
-	safe.Lock(func() {
-		log := logrus.WithFields(logrus.Fields{
-			"version": job.version.Version,
-			"current": bridge.curVersion,
-			"channel": bridge.vault.GetUpdateChannel(),
-		})
-
-		if !job.version.Version.GreaterThan(bridge.newVersion) {
-			return
-		}
-
-		log.WithField("silent", job.silent).Info("An update is available")
-
-		bridge.publish(events.UpdateAvailable{
-			Version:    job.version,
-			Compatible: true,
-			Silent:     job.silent,
-		})
-
-		bridge.publish(events.UpdateInstalling{
-			Version: job.version,
-			Silent:  job.silent,
-		})
-
-		err := bridge.updater.InstallUpdate(ctx, bridge.api, job.version)
-
-		switch {
-		case errors.Is(err, updater.ErrUpdateAlreadyInstalled):
-			log.Info("The update was already installed")
-
-		case err != nil:
-			log.WithError(err).Error("The update could not be installed")
-
-			bridge.publish(events.UpdateFailed{
-				Version: job.version,
-				Silent:  job.silent,
-				Error:   err,
-			})
-
-		default:
-			log.Info("The update was installed successfully")
-
-			bridge.publish(events.UpdateInstalled{
-				Version: job.version,
-				Silent:  job.silent,
-			})
-
-			bridge.newVersion = job.version.Version
-		}
-	}, bridge.newVersionLock)
-}

internal/bridge/user.go

@@ -1,652 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"runtime"
-
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/gluon/imap"
-	"github.com/ProtonMail/gluon/reporter"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/services/imapservice"
-	"github.com/ProtonMail/proton-bridge/v3/internal/try"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/go-resty/resty/v2"
-	"github.com/sirupsen/logrus"
-)
-
-type UserState int
-
-const (
-	SignedOut UserState = iota
-	Locked
-	Connected
-)
-
-type UserInfo struct {
-	// UserID is the user's API ID.
-	UserID string
-
-	// Username is the user's API username.
-	Username string
-
-	// Signed Out is true if the user is signed out (no AuthUID, user will need to provide credentials to log in again)
-	State UserState
-
-	// Addresses holds the user's email addresses. The first address is the primary address.
-	Addresses []string
-
-	// AddressMode is the user's address mode.
-	AddressMode vault.AddressMode
-
-	// BridgePass is the user's bridge password.
-	BridgePass []byte
-
-	// UsedSpace is the amount of space used by the user.
-	UsedSpace int
-
-	// MaxSpace is the total amount of space available to the user.
-	MaxSpace int
-}
-
-// GetUserIDs returns the IDs of all known users (authorized or not).
-func (bridge *Bridge) GetUserIDs() []string {
-	return bridge.vault.GetUserIDs()
-}
-
-// HasUser returns true iff the given user is known (authorized or not).
-func (bridge *Bridge) HasUser(userID string) bool {
-	return bridge.vault.HasUser(userID)
-}
-
-// GetUserInfo returns info about the given user.
-func (bridge *Bridge) GetUserInfo(userID string) (UserInfo, error) {
-	return safe.RLockRetErr(func() (UserInfo, error) {
-		if user, ok := bridge.users[userID]; ok {
-			return getConnUserInfo(user), nil
-		}
-
-		var info UserInfo
-
-		if err := bridge.vault.GetUser(userID, func(user *vault.User) {
-			state := Locked
-			if len(user.AuthUID()) == 0 {
-				state = SignedOut
-			}
-			info = getUserInfo(user.UserID(), user.Username(), user.PrimaryEmail(), state, user.AddressMode())
-		}); err != nil {
-			return UserInfo{}, fmt.Errorf("failed to get user info: %w", err)
-		}
-
-		return info, nil
-	}, bridge.usersLock)
-}
-
-// QueryUserInfo queries the user info by username or address.
-func (bridge *Bridge) QueryUserInfo(query string) (UserInfo, error) {
-	return safe.RLockRetErr(func() (UserInfo, error) {
-		for _, user := range bridge.users {
-			if user.Match(query) {
-				return getConnUserInfo(user), nil
-			}
-		}
-
-		return UserInfo{}, ErrNoSuchUser
-	}, bridge.usersLock)
-}
-
-// LoginAuth begins the login process. It returns an authorized client that might need 2FA.
-func (bridge *Bridge) LoginAuth(ctx context.Context, username string, password []byte) (*proton.Client, proton.Auth, error) {
-	logrus.WithField("username", logging.Sensitive(username)).Info("Authorizing user for login")
-
-	if username == "crash@bandicoot" {
-		panic("Your wish is my command.. I crash!")
-	}
-
-	client, auth, err := bridge.api.NewClientWithLogin(ctx, username, password)
-	if err != nil {
-		return nil, proton.Auth{}, fmt.Errorf("failed to create new API client: %w", err)
-	}
-
-	if ok := safe.RLockRet(func() bool { return mapHas(bridge.users, auth.UserID) }, bridge.usersLock); ok {
-		logrus.WithField("userID", auth.UserID).Warn("User already logged in")
-
-		if err := client.AuthDelete(ctx); err != nil {
-			logrus.WithError(err).Warn("Failed to delete auth")
-		}
-
-		return nil, proton.Auth{}, ErrUserAlreadyLoggedIn
-	}
-
-	return client, auth, nil
-}
-
-// LoginUser finishes the user login process using the client and auth received from LoginAuth.
-func (bridge *Bridge) LoginUser(
-	ctx context.Context,
-	client *proton.Client,
-	auth proton.Auth,
-	keyPass []byte,
-) (string, error) {
-	logrus.WithField("userID", auth.UserID).Info("Logging in authorized user")
-
-	userID, err := try.CatchVal(
-		func() (string, error) {
-			return bridge.loginUser(ctx, client, auth.UID, auth.RefreshToken, keyPass)
-		},
-		func() error {
-			return client.AuthDelete(ctx)
-		},
-	)
-	if err != nil {
-		return "", fmt.Errorf("failed to login user: %w", err)
-	}
-
-	bridge.publish(events.UserLoggedIn{
-		UserID: userID,
-	})
-
-	return userID, nil
-}
-
-// LoginFull authorizes a new bridge user with the given username and password.
-// If necessary, a TOTP and mailbox password are requested via the callbacks.
-// This is equivalent to doing LoginAuth and LoginUser separately.
-func (bridge *Bridge) LoginFull(
-	ctx context.Context,
-	username string,
-	password []byte,
-	getTOTP func() (string, error),
-	getKeyPass func() ([]byte, error),
-) (string, error) {
-	logrus.WithField("username", logging.Sensitive(username)).Info("Performing full user login")
-
-	client, auth, err := bridge.LoginAuth(ctx, username, password)
-	if err != nil {
-		return "", fmt.Errorf("failed to begin login process: %w", err)
-	}
-
-	if auth.TwoFA.Enabled&proton.HasTOTP != 0 {
-		logrus.WithField("userID", auth.UserID).Info("Requesting TOTP")
-
-		totp, err := getTOTP()
-		if err != nil {
-			return "", fmt.Errorf("failed to get TOTP: %w", err)
-		}
-
-		if err := client.Auth2FA(ctx, proton.Auth2FAReq{TwoFactorCode: totp}); err != nil {
-			return "", fmt.Errorf("failed to authorize 2FA: %w", err)
-		}
-	}
-
-	var keyPass []byte
-
-	if auth.PasswordMode == proton.TwoPasswordMode {
-		logrus.WithField("userID", auth.UserID).Info("Requesting mailbox password")
-
-		userKeyPass, err := getKeyPass()
-		if err != nil {
-			return "", fmt.Errorf("failed to get key password: %w", err)
-		}
-
-		keyPass = userKeyPass
-	} else {
-		keyPass = password
-	}
-
-	return bridge.LoginUser(ctx, client, auth, keyPass)
-}
-
-// LogoutUser logs out the given user.
-func (bridge *Bridge) LogoutUser(ctx context.Context, userID string) error {
-	logrus.WithField("userID", userID).Info("Logging out user")
-
-	return safe.LockRet(func() error {
-		user, ok := bridge.users[userID]
-		if !ok {
-			return ErrNoSuchUser
-		}
-
-		bridge.logoutUser(ctx, user, true, false, false)
-
-		bridge.publish(events.UserLoggedOut{
-			UserID: userID,
-		})
-
-		return nil
-	}, bridge.usersLock)
-}
-
-// DeleteUser deletes the given user.
-func (bridge *Bridge) DeleteUser(ctx context.Context, userID string) error {
-	logrus.WithField("userID", userID).Info("Deleting user")
-
-	syncConfigDir, err := bridge.locator.ProvideIMAPSyncConfigPath()
-	if err != nil {
-		return fmt.Errorf("failed to get sync config path")
-	}
-
-	return safe.LockRet(func() error {
-		if !bridge.vault.HasUser(userID) {
-			return ErrNoSuchUser
-		}
-
-		if user, ok := bridge.users[userID]; ok {
-			bridge.logoutUser(ctx, user, true, true, !bridge.GetTelemetryDisabled())
-		}
-
-		if err := imapservice.DeleteSyncState(syncConfigDir, userID); err != nil {
-			return fmt.Errorf("failed to delete use sync config")
-		}
-
-		if err := bridge.vault.DeleteUser(userID); err != nil {
-			logrus.WithError(err).Error("Failed to delete vault user")
-		}
-
-		bridge.publish(events.UserDeleted{
-			UserID: userID,
-		})
-
-		return nil
-	}, bridge.usersLock)
-}
-
-// SetAddressMode sets the address mode for the given user.
-func (bridge *Bridge) SetAddressMode(ctx context.Context, userID string, mode vault.AddressMode) error {
-	logrus.WithField("userID", userID).WithField("mode", mode).Info("Setting address mode")
-
-	return safe.RLockRet(func() error {
-		user, ok := bridge.users[userID]
-		if !ok {
-			return ErrNoSuchUser
-		}
-
-		if user.GetAddressMode() == mode {
-			return fmt.Errorf("address mode is already %q", mode)
-		}
-
-		if err := user.SetAddressMode(ctx, mode); err != nil {
-			return fmt.Errorf("failed to set address mode: %w", err)
-		}
-
-		bridge.publish(events.AddressModeChanged{
-			UserID:      userID,
-			AddressMode: mode,
-		})
-
-		var splitMode = false
-		for _, user := range bridge.users {
-			if user.GetAddressMode() == vault.SplitMode {
-				splitMode = true
-				break
-			}
-		}
-		bridge.heartbeat.SetSplitMode(splitMode)
-
-		return nil
-	}, bridge.usersLock)
-}
-
-// SendBadEventUserFeedback passes the feedback to the given user.
-func (bridge *Bridge) SendBadEventUserFeedback(_ context.Context, userID string, doResync bool) error {
-	logrus.WithField("userID", userID).WithField("doResync", doResync).Info("Passing bad event feedback to user")
-
-	return safe.LockRet(func() error {
-		ctx := context.Background()
-
-		user, ok := bridge.users[userID]
-		if !ok {
-			if rerr := bridge.reporter.ReportMessageWithContext(
-				"Failed to handle event: feedback failed: no such user",
-				reporter.Context{"user_id": userID},
-			); rerr != nil {
-				logrus.WithError(rerr).Error("Failed to report feedback failure")
-			}
-
-			return ErrNoSuchUser
-		}
-
-		if doResync {
-			if rerr := bridge.reporter.ReportMessageWithContext(
-				"Failed to handle event: feedback resync",
-				reporter.Context{"user_id": userID},
-			); rerr != nil {
-				logrus.WithError(rerr).Error("Failed to report feedback failure")
-			}
-
-			return user.BadEventFeedbackResync(ctx)
-		}
-
-		if rerr := bridge.reporter.ReportMessageWithContext(
-			"Failed to handle event: feedback logout",
-			reporter.Context{"user_id": userID},
-		); rerr != nil {
-			logrus.WithError(rerr).Error("Failed to report feedback failure")
-		}
-
-		bridge.logoutUser(ctx, user, true, false, false)
-
-		bridge.publish(events.UserLoggedOut{
-			UserID: userID,
-		})
-
-		return nil
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) loginUser(ctx context.Context, client *proton.Client, authUID, authRef string, keyPass []byte) (string, error) {
-	apiUser, err := client.GetUser(ctx)
-	if err != nil {
-		return "", fmt.Errorf("failed to get API user: %w", err)
-	}
-
-	salts, err := client.GetSalts(ctx)
-	if err != nil {
-		return "", fmt.Errorf("failed to get key salts: %w", err)
-	}
-
-	saltedKeyPass, err := salts.SaltForKey(keyPass, apiUser.Keys.Primary().ID)
-	if err != nil {
-		return "", fmt.Errorf("failed to salt key password: %w", err)
-	}
-
-	if userKR, err := apiUser.Keys.Unlock(saltedKeyPass, nil); err != nil {
-		return "", fmt.Errorf("failed to unlock user keys: %w", err)
-	} else if userKR.CountDecryptionEntities() == 0 {
-		return "", fmt.Errorf("failed to unlock user keys")
-	}
-
-	if err := bridge.addUser(ctx, client, apiUser, authUID, authRef, saltedKeyPass, true); err != nil {
-		return "", fmt.Errorf("failed to add bridge user: %w", err)
-	}
-
-	return apiUser.ID, nil
-}
-
-// loadUsers tries to load each user in the vault that isn't already loaded.
-func (bridge *Bridge) loadUsers(ctx context.Context) error {
-	logrus.WithField("count", len(bridge.vault.GetUserIDs())).Info("Loading users")
-	defer logrus.Info("Finished loading users")
-
-	return bridge.vault.ForUser(runtime.NumCPU(), func(user *vault.User) error {
-		log := logrus.WithField("userID", user.UserID())
-
-		if user.AuthUID() == "" {
-			log.Info("User is not connected (skipping)")
-			return nil
-		}
-
-		if safe.RLockRet(func() bool { return mapHas(bridge.users, user.UserID()) }, bridge.usersLock) {
-			log.Info("User is already loaded (skipping)")
-			return nil
-		}
-
-		log.WithField("mode", user.AddressMode()).Info("Loading connected user")
-
-		bridge.publish(events.UserLoading{
-			UserID: user.UserID(),
-		})
-
-		if err := bridge.loadUser(ctx, user); err != nil {
-			log.WithError(err).Error("Failed to load connected user")
-
-			bridge.publish(events.UserLoadFail{
-				UserID: user.UserID(),
-				Error:  err,
-			})
-		} else {
-			log.Info("Successfully loaded connected user")
-
-			bridge.publish(events.UserLoadSuccess{
-				UserID: user.UserID(),
-			})
-		}
-
-		return nil
-	})
-}
-
-// loadUser loads an existing user from the vault.
-func (bridge *Bridge) loadUser(ctx context.Context, user *vault.User) error {
-	client, auth, err := bridge.api.NewClientWithRefresh(ctx, user.AuthUID(), user.AuthRef())
-	if err != nil {
-		if apiErr := new(proton.APIError); errors.As(err, &apiErr) && (apiErr.Code == proton.AuthRefreshTokenInvalid) {
-			// The session cannot be refreshed, we sign out the user by clearing his auth secrets.
-			if err := user.Clear(); err != nil {
-				logrus.WithError(err).Warn("Failed to clear user secrets")
-			}
-		}
-
-		return fmt.Errorf("failed to create API client: %w", err)
-	}
-
-	if err := user.SetAuth(auth.UID, auth.RefreshToken); err != nil {
-		return fmt.Errorf("failed to set auth: %w", err)
-	}
-
-	apiUser, err := client.GetUser(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to get user: %w", err)
-	}
-
-	if err := bridge.addUser(ctx, client, apiUser, auth.UID, auth.RefreshToken, user.KeyPass(), false); err != nil {
-		return fmt.Errorf("failed to add user: %w", err)
-	}
-
-	if user.PrimaryEmail() != apiUser.Email {
-		if err := user.SetPrimaryEmail(apiUser.Email); err != nil {
-			return fmt.Errorf("failed to modify user primary email: %w", err)
-		}
-	}
-
-	return nil
-}
-
-// addUser adds a new user with an already salted mailbox password.
-func (bridge *Bridge) addUser(
-	ctx context.Context,
-	client *proton.Client,
-	apiUser proton.User,
-	authUID, authRef string,
-	saltedKeyPass []byte,
-	isLogin bool,
-) error {
-	vaultUser, isNew, err := bridge.newVaultUser(apiUser, authUID, authRef, saltedKeyPass)
-	if err != nil {
-		return fmt.Errorf("failed to add vault user: %w", err)
-	}
-
-	if err := bridge.addUserWithVault(ctx, client, apiUser, vaultUser); err != nil {
-		if _, ok := err.(*resty.ResponseError); ok || isLogin {
-			logrus.WithError(err).Error("Failed to add user, clearing its secrets from vault")
-
-			if err := vaultUser.Clear(); err != nil {
-				logrus.WithError(err).Error("Failed to clear user secrets")
-			}
-		} else {
-			logrus.WithError(err).Error("Failed to add user")
-		}
-
-		if err := vaultUser.Close(); err != nil {
-			logrus.WithError(err).Error("Failed to close vault user")
-		}
-
-		if isNew {
-			logrus.Warn("Deleting newly added vault user")
-
-			if err := bridge.vault.DeleteUser(apiUser.ID); err != nil {
-				logrus.WithError(err).Error("Failed to delete vault user")
-			}
-		}
-
-		return fmt.Errorf("failed to add user with vault: %w", err)
-	}
-
-	return nil
-}
-
-// addUserWithVault adds a new user to bridge with the given vault.
-func (bridge *Bridge) addUserWithVault(
-	ctx context.Context,
-	client *proton.Client,
-	apiUser proton.User,
-	vault *vault.User,
-) error {
-	statsPath, err := bridge.locator.ProvideStatsPath()
-	if err != nil {
-		return fmt.Errorf("failed to get Statistics directory: %w", err)
-	}
-
-	syncSettingsPath, err := bridge.locator.ProvideIMAPSyncConfigPath()
-	if err != nil {
-		return fmt.Errorf("failed to get IMAP sync config path: %w", err)
-	}
-
-	user, err := user.New(
-		ctx,
-		vault,
-		client,
-		bridge.reporter,
-		apiUser,
-		bridge.panicHandler,
-		bridge.vault.GetShowAllMail(),
-		bridge.vault.GetMaxSyncMemory(),
-		statsPath,
-		bridge,
-		bridge.serverManager,
-		bridge.serverManager,
-		&bridgeEventSubscription{b: bridge},
-		bridge.syncService,
-		syncSettingsPath,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to create user: %w", err)
-	}
-
-	// Handle events coming from the user before forwarding them to the bridge.
-	// For example, if the user's addresses change, we need to update them in gluon.
-	bridge.tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, user.GetEventCh(), func(event events.Event) {
-			logrus.WithFields(logrus.Fields{
-				"userID": apiUser.ID,
-				"event":  event,
-			}).Debug("Received user event")
-
-			bridge.handleUserEvent(ctx, user, event)
-			bridge.publish(event)
-		})
-	})
-
-	// Gluon will set the IMAP ID in the context, if known, before making requests on behalf of this user.
-	// As such, if we find this ID in the context, we should use it to update our user agent.
-	client.AddPreRequestHook(func(_ *resty.Client, r *resty.Request) error {
-		if imapID, ok := imap.GetIMAPIDFromContext(r.Context()); ok {
-			bridge.setUserAgent(imapID.Name, imapID.Version)
-		}
-
-		return nil
-	})
-
-	// Finally, save the user in the bridge.
-	safe.Lock(func() {
-		bridge.users[apiUser.ID] = user
-		bridge.heartbeat.SetNbAccount(len(bridge.users))
-	}, bridge.usersLock)
-
-	// As we need at least one user to send heartbeat, try to send it.
-	defer bridge.goHeartbeat()
-
-	return nil
-}
-
-// newVaultUser creates a new vault user from the given auth information.
-// If one already exists in the vault, its data will be updated.
-func (bridge *Bridge) newVaultUser(
-	apiUser proton.User,
-	authUID, authRef string,
-	saltedKeyPass []byte,
-) (*vault.User, bool, error) {
-	return bridge.vault.GetOrAddUser(apiUser.ID, apiUser.Name, apiUser.Email, authUID, authRef, saltedKeyPass)
-}
-
-// logout logs out the given user, optionally logging them out from the API too.
-func (bridge *Bridge) logoutUser(ctx context.Context, user *user.User, withAPI, withData, withTelemetry bool) {
-	defer delete(bridge.users, user.ID())
-
-	// if this is actually a remove account
-	if withData && withAPI {
-		user.SendConfigStatusAbort(ctx, withTelemetry)
-	}
-
-	logrus.WithFields(logrus.Fields{
-		"userID":   user.ID(),
-		"withAPI":  withAPI,
-		"withData": withData,
-	}).Debug("Logging out user")
-
-	if err := user.Logout(ctx, withAPI); err != nil {
-		logrus.WithError(err).Error("Failed to logout user")
-	}
-
-	bridge.heartbeat.SetNbAccount(len(bridge.users))
-
-	user.Close()
-}
-
-// getUserInfo returns information about a disconnected user.
-func getUserInfo(userID, username, primaryEmail string, state UserState, addressMode vault.AddressMode) UserInfo {
-	var addresses []string
-	if len(primaryEmail) > 0 {
-		addresses = []string{primaryEmail}
-	}
-
-	return UserInfo{
-		State:       state,
-		UserID:      userID,
-		Username:    username,
-		Addresses:   addresses,
-		AddressMode: addressMode,
-	}
-}
-
-// getConnUserInfo returns information about a connected user.
-func getConnUserInfo(user *user.User) UserInfo {
-	return UserInfo{
-		State:       Connected,
-		UserID:      user.ID(),
-		Username:    user.Name(),
-		Addresses:   user.Emails(),
-		AddressMode: user.GetAddressMode(),
-		BridgePass:  user.BridgePass(),
-		UsedSpace:   user.UsedSpace(),
-		MaxSpace:    user.MaxSpace(),
-	}
-}
-
-func mapHas[Key comparable, Val any](m map[Key]Val, key Key) bool {
-	_, ok := m[key]
-	return ok
-}

internal/bridge/user_event_test.go

@@ -1,938 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"net/mail"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/ProtonMail/gluon/async"
-	"github.com/ProtonMail/gluon/rfc822"
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/gopenpgp/v2/crypto"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/bradenaw/juniper/stream"
-	"github.com/bradenaw/juniper/xslices"
-	"github.com/emersion/go-imap"
-	"github.com/emersion/go-imap/client"
-	"github.com/golang/mock/gomock"
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_User_RefreshEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		var messageIDs []string
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			messageIDs = createNumMessages(ctx, t, c, addrID, labelID, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-		})
-
-		// Remove a message
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			require.NoError(t, c.DeleteMessage(ctx, messageIDs[0]))
-		})
-
-		require.NoError(t, s.RefreshUser(userID, proton.RefreshMail))
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			syncCh, closeCh := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-
-			require.Equal(t, userID, (<-syncCh).UserID)
-			closeCh()
-
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, labelID, 10)
-			})
-
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_BadMessage_BadEvent(t *testing.T) {
-	t.Run("Resync", test_badMessage_badEvent(func(t *testing.T, ctx context.Context, bridge *bridge.Bridge, badUserID string) {
-		// User feedback is resync
-		require.NoError(t, bridge.SendBadEventUserFeedback(ctx, badUserID, true))
-
-		// Wait for sync to finish
-		syncCh, closeCh := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-		require.Equal(t, badUserID, (<-syncCh).UserID)
-		closeCh()
-	}))
-
-	t.Run("LogoutAndLogin", test_badMessage_badEvent(func(t *testing.T, ctx context.Context, bridge *bridge.Bridge, badUserID string) {
-		logoutCh, closeCh := chToType[events.Event, events.UserLoggedOut](bridge.GetEvents(events.UserLoggedOut{}))
-
-		// User feedback is logout
-		require.NoError(t, bridge.SendBadEventUserFeedback(ctx, badUserID, false))
-
-		require.Equal(t, badUserID, (<-logoutCh).UserID)
-		closeCh()
-
-		// The user will eventually be logged out due to the bad request errors.
-		require.Eventually(t, func() bool {
-			return len(bridge.GetUserIDs()) == 1 && len(getConnectedUserIDs(t, bridge)) == 0
-		}, 100*user.EventPeriod, user.EventPeriod)
-
-		// Login again
-		_, err := bridge.LoginFull(ctx, "user", password, nil, nil)
-		require.NoError(t, err)
-	}))
-}
-
-func test_badMessage_badEvent(userFeedback func(t *testing.T, ctx context.Context, bridge *bridge.Bridge, badUserID string)) func(t *testing.T) {
-	return func(t *testing.T) {
-		withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-			// Create a user.
-			userID, addrID, err := s.CreateUser("user", password)
-			require.NoError(t, err)
-
-			labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-			require.NoError(t, err)
-
-			// Create 10 messages for the user.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, labelID, 10)
-			})
-
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				smtpWaiter := waitForSMTPServerReady(bridge)
-				defer smtpWaiter.Done()
-
-				userLoginAndSync(ctx, t, bridge, "user", password)
-
-				var messageIDs []string
-
-				// Create 10 more messages for the user, generating events.
-				withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-					messageIDs = createNumMessages(ctx, t, c, addrID, labelID, 10)
-				})
-
-				// If bridge attempts to sync the new messages, it should get a BadRequest error.
-				doBadRequest := true
-				s.AddStatusHook(func(req *http.Request) (int, bool) {
-					if !doBadRequest {
-						return 0, false
-					}
-
-					if xslices.Index(xslices.Map(messageIDs[0:5], func(messageID string) string {
-						return "/mail/v4/messages/" + messageID
-					}), req.URL.Path) < 0 {
-						return 0, false
-					}
-
-					return http.StatusBadRequest, true
-				})
-
-				badUserID := userReceivesBadError(t, bridge, mocks)
-
-				// Remove messages, make response OK again
-				withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-					require.NoError(t, c.DeleteMessage(ctx, messageIDs[0:5]...))
-				})
-				doBadRequest = false
-
-				userFeedback(t, ctx, bridge, badUserID)
-
-				smtpWaiter.Wait()
-
-				userContinueEventProcess(ctx, t, s, bridge)
-			})
-		})
-	}
-}
-
-func TestBridge_User_BadMessage_NoBadEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		_, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			var messageIDs []string
-
-			// Create 10 more messages for the user, generating events.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				messageIDs = createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-			})
-
-			// If bridge attempts to sync the new messages, it should get a BadRequest error.
-			s.AddStatusHook(func(req *http.Request) (int, bool) {
-				if strings.Contains(req.URL.Path, "/mail/v4/messages/"+messageIDs[2]) {
-					return http.StatusUnprocessableEntity, true
-				}
-
-				return 0, false
-			})
-
-			// Remove messages
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				require.NoError(t, c.DeleteMessage(ctx, messageIDs...))
-			})
-
-			smtpWaiter.Wait()
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_SameMessageLabelCreated_NoBadEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		var messageIDs []string
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			messageIDs = createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-			require.NoError(t, err)
-
-			// Add NOOP events
-			require.NoError(t, s.AddLabelCreatedEvent(userID, labelID))
-			require.NoError(t, s.AddMessageCreatedEvent(userID, messageIDs[9]))
-
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_MessageLabelDeleted_NoBadEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		labelID, err := s.CreateLabel(userID, "folder", "", proton.LabelTypeFolder)
-		require.NoError(t, err)
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, labelID, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			// Create and delete 10 more messages for the user, generating delete events.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				messageIDs := createNumMessages(ctx, t, c, addrID, labelID, 10)
-				require.NoError(t, c.DeleteMessage(ctx, messageIDs...))
-			})
-
-			// Create and delete 10 labels for the user, generating delete events.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				for i := 0; i < 10; i++ {
-					label, err := c.CreateLabel(ctx, proton.CreateLabelReq{
-						Name:  uuid.NewString(),
-						Color: "#f66",
-						Type:  proton.LabelTypeLabel,
-					})
-					require.NoError(t, err)
-
-					require.NoError(t, c.DeleteLabel(ctx, label.ID))
-				}
-			})
-
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_AddressEvents_NoBadEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			addrID, err = s.CreateAddress(userID, "other@pm.me", password)
-			require.NoError(t, err)
-			userContinueEventProcess(ctx, t, s, bridge)
-
-			require.NoError(t, s.AddAddressCreatedEvent(userID, addrID))
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-
-		otherID, err := s.CreateAddress(userID, "another@pm.me", password)
-		require.NoError(t, err)
-		require.NoError(t, s.RemoveAddress(userID, otherID))
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userContinueEventProcess(ctx, t, s, bridge)
-
-			require.NoError(t, s.CreateAddressKey(userID, addrID, password))
-			userContinueEventProcess(ctx, t, s, bridge)
-
-			require.NoError(t, s.RemoveAddress(userID, addrID))
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_AddressEventUpdatedForAddressThatDoesNotExist_NoBadEvent(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			_, err := s.CreateAddressAsUpdate(userID, "another@pm.me", password)
-			require.NoError(t, err)
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_Network_NoBadEvents(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		retVal := int32(0)
-
-		setResponseAndWait := func(status int32) {
-			atomic.StoreInt32(&retVal, status)
-			time.Sleep(user.EventPeriod)
-		}
-
-		s.AddStatusHook(func(req *http.Request) (int, bool) {
-			status := atomic.LoadInt32(&retVal)
-			if strings.Contains(req.URL.Path, "/core/v4/events/") {
-				return int(status), status != 0
-			}
-
-			return 0, false
-		})
-
-		// Create a user.
-		_, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			// Create 10 more messages for the user, generating events.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-
-				setResponseAndWait(http.StatusInternalServerError)
-				setResponseAndWait(http.StatusServiceUnavailable)
-				setResponseAndWait(http.StatusPaymentRequired)
-				setResponseAndWait(http.StatusForbidden)
-				setResponseAndWait(http.StatusBadRequest)
-				setResponseAndWait(http.StatusUnprocessableEntity)
-				setResponseAndWait(http.StatusTooManyRequests)
-				time.Sleep(10 * time.Second) // needs minimum of 10 seconds to retry
-			})
-
-			setResponseAndWait(0)
-			time.Sleep(10 * time.Second) // needs up to 20 seconds to retry
-			userContinueEventProcess(ctx, t, s, bridge)
-		})
-	})
-}
-
-func TestBridge_User_DropConn_NoBadEvent(t *testing.T) {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-
-	dropListener := proton.NewListener(l, proton.NewDropConn)
-	defer func() { _ = dropListener.Close() }()
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		_, addrID, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Create 10 messages for the user.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			var count int32
-			// The first 10 times bridge attempts to sync any of the messages, drop the connection.
-			s.AddStatusHook(func(req *http.Request) (int, bool) {
-				if strings.Contains(req.URL.Path, "/mail/v4/messages") {
-					if atomic.AddInt32(&count, 1) < 10 {
-						dropListener.DropAll()
-					}
-				}
-
-				return 0, false
-			})
-			userLoginAndSync(ctx, t, bridge, "user", password)
-
-			mocks.Reporter.EXPECT().ReportMessageWithContext(gomock.Any(), gomock.Any()).AnyTimes()
-
-			// Create 10 more messages for the user, generating events.
-			withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-				createNumMessages(ctx, t, c, addrID, proton.InboxLabel, 10)
-			})
-
-			info, err := bridge.QueryUserInfo("user")
-			require.NoError(t, err)
-
-			cli, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, cli.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = cli.Logout() }()
-
-			// The IMAP client will eventually see 20 messages.
-			require.Eventually(t, func() bool {
-				status, err := cli.Status("INBOX", []imap.StatusItem{imap.StatusMessages})
-				return err == nil && status.Messages == 20
-			}, 10*time.Second, 100*time.Millisecond)
-		})
-	}, server.WithListener(dropListener))
-}
-
-func TestBridge_User_UpdateDraft(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a bridge user.
-		_, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Initially sync the user.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-		})
-
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			user, err := c.GetUser(ctx)
-			require.NoError(t, err)
-
-			addrs, err := c.GetAddresses(ctx)
-			require.NoError(t, err)
-
-			salts, err := c.GetSalts(ctx)
-			require.NoError(t, err)
-
-			keyPass, err := salts.SaltForKey(password, user.Keys.Primary().ID)
-			require.NoError(t, err)
-
-			_, addrKRs, err := proton.Unlock(user, addrs, keyPass, async.NoopPanicHandler{})
-			require.NoError(t, err)
-
-			// Create a draft (generating a "create draft message" event).
-			draft, err := c.CreateDraft(ctx, addrKRs[addrs[0].ID], proton.CreateDraftReq{
-				Message: proton.DraftTemplate{
-					Subject:  "subject",
-					Sender:   &mail.Address{Name: "sender", Address: addrs[0].Email},
-					Body:     "body",
-					MIMEType: rfc822.TextPlain,
-				},
-			})
-			require.NoError(t, err)
-			require.Empty(t, draft.ReplyTos)
-
-			// Process those events
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-			})
-
-			// Update the draft (generating an "update draft message" event).
-			draft2, err := c.UpdateDraft(ctx, draft.ID, addrKRs[addrs[0].ID], proton.UpdateDraftReq{
-				Message: proton.DraftTemplate{
-					Subject:  "subject 2",
-					Sender:   &mail.Address{Name: "sender", Address: addrs[0].Email},
-					Body:     "body 2",
-					MIMEType: rfc822.TextPlain,
-				},
-			})
-			require.NoError(t, err)
-			require.Empty(t, draft2.ReplyTos)
-		})
-	})
-}
-
-func TestBridge_User_UpdateDraftAndCreateOtherMessage(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a bridge user.
-		_, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Initially sync the user.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-		})
-
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			user, err := c.GetUser(ctx)
-			require.NoError(t, err)
-
-			addrs, err := c.GetAddresses(ctx)
-			require.NoError(t, err)
-
-			salts, err := c.GetSalts(ctx)
-			require.NoError(t, err)
-
-			keyPass, err := salts.SaltForKey(password, user.Keys.Primary().ID)
-			require.NoError(t, err)
-
-			_, addrKRs, err := proton.Unlock(user, addrs, keyPass, async.NoopPanicHandler{})
-			require.NoError(t, err)
-
-			// Create a draft (generating a "create draft message" event).
-			draft, err := c.CreateDraft(ctx, addrKRs[addrs[0].ID], proton.CreateDraftReq{
-				Message: proton.DraftTemplate{
-					Subject:  "subject",
-					Sender:   &mail.Address{Name: "sender", Address: addrs[0].Email},
-					Body:     "body",
-					MIMEType: rfc822.TextPlain,
-				},
-			})
-			require.NoError(t, err)
-
-			// Process those events
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-			})
-
-			// Update the draft (generating an "update draft message" event).
-			require.NoError(t, getErr(c.UpdateDraft(ctx, draft.ID, addrKRs[addrs[0].ID], proton.UpdateDraftReq{
-				Message: proton.DraftTemplate{
-					Subject:  "subject 2",
-					Sender:   &mail.Address{Name: "sender", Address: addrs[0].Email},
-					Body:     "body 2",
-					MIMEType: rfc822.TextPlain,
-				},
-			})))
-
-			// Import a message (generating a "create message" event).
-			str, err := c.ImportMessages(ctx, addrKRs[addrs[0].ID], 1, 1, proton.ImportReq{
-				Metadata: proton.ImportMetadata{
-					AddressID: addrs[0].ID,
-					Flags:     proton.MessageFlagReceived,
-				},
-				Message: []byte("From: someone@example.com\r\nTo: blabla@example.com\r\n\r\nhello"),
-			})
-			require.NoError(t, err)
-
-			res, err := stream.Collect(ctx, str)
-			require.NoError(t, err)
-
-			// Process those events.
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-			})
-
-			// Update the imported message (generating an "update message" event).
-			require.NoError(t, c.MarkMessagesUnread(ctx, res[0].MessageID))
-
-			// Process those events.
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-			})
-		})
-	})
-}
-
-func TestBridge_User_SendDraftRemoveDraftFlag(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a bridge user.
-		_, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Initially sync the user.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-		})
-
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			user, err := c.GetUser(ctx)
-			require.NoError(t, err)
-
-			addrs, err := c.GetAddresses(ctx)
-			require.NoError(t, err)
-
-			salts, err := c.GetSalts(ctx)
-			require.NoError(t, err)
-
-			keyPass, err := salts.SaltForKey(password, user.Keys.Primary().ID)
-			require.NoError(t, err)
-
-			_, addrKRs, err := proton.Unlock(user, addrs, keyPass, async.NoopPanicHandler{})
-			require.NoError(t, err)
-
-			// Create a draft (generating a "create draft message" event).
-			draft, err := c.CreateDraft(ctx, addrKRs[addrs[0].ID], proton.CreateDraftReq{
-				Message: proton.DraftTemplate{
-					Subject:  "subject",
-					ToList:   []*mail.Address{{Address: addrs[0].Email}},
-					Sender:   &mail.Address{Name: "sender", Address: addrs[0].Email},
-					Body:     "body",
-					MIMEType: rfc822.TextPlain,
-				},
-			})
-			require.NoError(t, err)
-
-			// Process those events
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-
-				info, err := bridge.QueryUserInfo("user")
-				require.NoError(t, err)
-
-				cli, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-				require.NoError(t, err)
-				require.NoError(t, cli.Login(info.Addresses[0], string(info.BridgePass)))
-				defer func() { _ = cli.Logout() }()
-
-				messages, err := clientFetch(cli, "Drafts")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.Contains(t, messages[0].Flags, imap.DraftFlag)
-			})
-
-			// Send the draft (generating an "update message" event).
-			{
-				pubKeys, recType, err := c.GetPublicKeys(ctx, addrs[0].Email)
-				require.NoError(t, err)
-				require.Equal(t, recType, proton.RecipientTypeInternal)
-
-				var req proton.SendDraftReq
-
-				require.NoError(t, req.AddTextPackage(addrKRs[addrs[0].ID], "body", rfc822.TextPlain, map[string]proton.SendPreferences{
-					addrs[0].Email: {
-						Encrypt:          true,
-						PubKey:           must(crypto.NewKeyRing(must(crypto.NewKeyFromArmored(pubKeys[0].PublicKey)))),
-						SignatureType:    proton.DetachedSignature,
-						EncryptionScheme: proton.InternalScheme,
-						MIMEType:         rfc822.TextPlain,
-					},
-				}, nil))
-
-				require.NoError(t, getErr(c.SendDraft(ctx, draft.ID, req)))
-			}
-
-			// Process those events; the draft will move to the sent folder and lose the draft flag.
-			withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-				userContinueEventProcess(ctx, t, s, bridge)
-
-				info, err := bridge.QueryUserInfo("user")
-				require.NoError(t, err)
-
-				cli, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-				require.NoError(t, err)
-				require.NoError(t, cli.Login(info.Addresses[0], string(info.BridgePass)))
-				defer func() { _ = cli.Logout() }()
-
-				messages, err := clientFetch(cli, "Sent")
-				require.NoError(t, err)
-				require.Len(t, messages, 1)
-				require.NotContains(t, messages[0].Flags, imap.DraftFlag)
-			})
-		})
-	})
-}
-
-func TestBridge_User_DisableEnableAddress(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Create an additional address for the user.
-		aliasID, err := s.CreateAddress(userID, "alias@"+s.GetDomain(), password)
-		require.NoError(t, err)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.NoError(t, getErr(bridge.LoginFull(ctx, "user", password, nil, nil)))
-
-			// Initially we should list the address.
-			info, err := bridge.QueryUserInfo("user")
-			require.NoError(t, err)
-			require.Contains(t, info.Addresses, "alias@"+s.GetDomain())
-		})
-
-		// Disable the address.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			require.NoError(t, c.DisableAddress(ctx, aliasID))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Eventually we shouldn't list the address.
-			require.Eventually(t, func() bool {
-				info, err := bridge.QueryUserInfo("user")
-				require.NoError(t, err)
-
-				return xslices.Index(info.Addresses, "alias@"+s.GetDomain()) < 0
-			}, 5*time.Second, 100*time.Millisecond)
-		})
-
-		// Enable the address.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			require.NoError(t, c.EnableAddress(ctx, aliasID))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Eventually we should list the address.
-			require.Eventually(t, func() bool {
-				info, err := bridge.QueryUserInfo("user")
-				require.NoError(t, err)
-
-				return xslices.Index(info.Addresses, "alias@"+s.GetDomain()) >= 0
-			}, 5*time.Second, 100*time.Millisecond)
-		})
-	})
-}
-
-func TestBridge_User_CreateDisabledAddress(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-
-		// Create an additional address for the user.
-		aliasID, err := s.CreateAddress(userID, "alias@"+s.GetDomain(), password)
-		require.NoError(t, err)
-
-		// Immediately disable the address.
-		withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-			require.NoError(t, c.DisableAddress(ctx, aliasID))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.NoError(t, getErr(bridge.LoginFull(ctx, "user", password, nil, nil)))
-
-			// Initially we shouldn't list the address.
-			info, err := bridge.QueryUserInfo("user")
-			require.NoError(t, err)
-			require.NotContains(t, info.Addresses, "alias@"+s.GetDomain())
-		})
-	})
-}
-
-func TestBridge_User_HandleParentLabelRename(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			imapWaiter := waitForIMAPServerReady(bridge)
-			defer imapWaiter.Done()
-
-			smtpWaiter := waitForSMTPServerReady(bridge)
-			defer smtpWaiter.Done()
-
-			require.NoError(t, getErr(bridge.LoginFull(ctx, username, password, nil, nil)))
-
-			info, err := bridge.QueryUserInfo(username)
-			require.NoError(t, err)
-
-			imapWaiter.Wait()
-			smtpWaiter.Wait()
-
-			cli, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-			require.NoError(t, err)
-			require.NoError(t, cli.Login(info.Addresses[0], string(info.BridgePass)))
-			defer func() { _ = cli.Logout() }()
-
-			withClient(ctx, t, s, username, password, func(ctx context.Context, c *proton.Client) {
-				parentName := uuid.NewString()
-				childName := uuid.NewString()
-
-				// Create a folder.
-				parentLabel, err := c.CreateLabel(ctx, proton.CreateLabelReq{
-					Name:  parentName,
-					Type:  proton.LabelTypeFolder,
-					Color: "#f66",
-				})
-				require.NoError(t, err)
-
-				// Wait for the parent folder to be created.
-				require.Eventually(t, func() bool {
-					return xslices.IndexFunc(clientList(cli), func(mailbox *imap.MailboxInfo) bool {
-						return mailbox.Name == fmt.Sprintf("Folders/%v", parentName)
-					}) >= 0
-				}, 100*user.EventPeriod, user.EventPeriod)
-
-				// Create a subfolder.
-				childLabel, err := c.CreateLabel(ctx, proton.CreateLabelReq{
-					Name:     childName,
-					Type:     proton.LabelTypeFolder,
-					Color:    "#f66",
-					ParentID: parentLabel.ID,
-				})
-				require.NoError(t, err)
-				require.Equal(t, parentLabel.ID, childLabel.ParentID)
-
-				// Wait for the parent folder to be created.
-				require.Eventually(t, func() bool {
-					return xslices.IndexFunc(clientList(cli), func(mailbox *imap.MailboxInfo) bool {
-						return mailbox.Name == fmt.Sprintf("Folders/%v/%v", parentName, childName)
-					}) >= 0
-				}, 100*user.EventPeriod, user.EventPeriod)
-
-				newParentName := uuid.NewString()
-
-				// Rename the parent folder.
-				require.NoError(t, getErr(c.UpdateLabel(ctx, parentLabel.ID, proton.UpdateLabelReq{
-					Color: "#f66",
-					Name:  newParentName,
-				})))
-
-				// Wait for the parent folder to be renamed.
-				require.Eventually(t, func() bool {
-					return xslices.IndexFunc(clientList(cli), func(mailbox *imap.MailboxInfo) bool {
-						return mailbox.Name == fmt.Sprintf("Folders/%v", newParentName)
-					}) >= 0
-				}, 100*user.EventPeriod, user.EventPeriod)
-
-				// Wait for the child folder to be renamed.
-				require.Eventually(t, func() bool {
-					return xslices.IndexFunc(clientList(cli), func(mailbox *imap.MailboxInfo) bool {
-						return mailbox.Name == fmt.Sprintf("Folders/%v/%v", newParentName, childName)
-					}) >= 0
-				}, 100*user.EventPeriod, user.EventPeriod)
-			})
-		})
-	})
-}
-
-// userLoginAndSync logs in user and waits until user is fully synced.
-func userLoginAndSync(
-	ctx context.Context,
-	t *testing.T,
-	bridge *bridge.Bridge,
-	username string, password []byte, //nolint:unparam
-) {
-	syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-	defer done()
-
-	userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-	require.NoError(t, err)
-
-	require.Equal(t, userID, (<-syncCh).UserID)
-}
-
-func userReceivesBadError(
-	t *testing.T,
-	bridge *bridge.Bridge,
-	mocks *bridge.Mocks,
-) (userID string) {
-	badEventCh, closeCh := bridge.GetEvents(events.UserBadEvent{})
-
-	// The user will continue to process events and will receive bad request errors.
-	mocks.Reporter.EXPECT().ReportMessageWithContext(gomock.Any(), gomock.Any()).MinTimes(1)
-
-	badEvent, ok := (<-badEventCh).(events.UserBadEvent)
-	require.True(t, ok)
-
-	closeCh()
-
-	return badEvent.UserID
-}
-
-func userContinueEventProcess(
-	ctx context.Context,
-	t *testing.T,
-	s *server.Server,
-	bridge *bridge.Bridge,
-) {
-	info, err := bridge.QueryUserInfo("user")
-	require.NoError(t, err)
-
-	cli, err := eventuallyDial(fmt.Sprintf("%v:%v", constants.Host, bridge.GetIMAPPort()))
-	require.NoError(t, err)
-	require.NoError(t, cli.Login(info.Addresses[0], string(info.BridgePass)))
-	defer func() { _ = cli.Logout() }()
-
-	randomLabel := uuid.NewString()
-
-	// Create a new label.
-	withClient(ctx, t, s, "user", password, func(ctx context.Context, c *proton.Client) {
-		require.NoError(t, getErr(c.CreateLabel(ctx, proton.CreateLabelReq{
-			Name:  randomLabel,
-			Color: "#f66",
-			Type:  proton.LabelTypeLabel,
-		})))
-	})
-
-	// Wait for the label to be created.
-	require.Eventually(t, func() bool {
-		return xslices.IndexFunc(clientList(cli), func(mailbox *imap.MailboxInfo) bool {
-			return mailbox.Name == "Labels/"+randomLabel
-		}) >= 0
-	}, 100*user.EventPeriod, user.EventPeriod)
-}
-
-func eventuallyDial(addr string) (cli *client.Client, err error) {
-	var sleep = 1 * time.Second
-	for i := 0; i < 5; i++ {
-		cli, err := client.Dial(addr)
-		if err == nil {
-			return cli, nil
-		}
-		time.Sleep(sleep)
-		sleep *= 2
-	}
-	return nil, fmt.Errorf("after 5 attempts, last error: %s", err)
-}

internal/bridge/user_events.go

@@ -1,75 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge
-
-import (
-	"context"
-
-	"github.com/ProtonMail/gluon/reporter"
-	"github.com/ProtonMail/proton-bridge/v3/internal"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) handleUserEvent(ctx context.Context, user *user.User, event events.Event) {
-	switch event := event.(type) {
-	case events.UserDeauth:
-		bridge.handleUserDeauth(ctx, user)
-
-	case events.UserBadEvent:
-		bridge.handleUserBadEvent(ctx, user, event)
-
-	case events.UncategorizedEventError:
-		bridge.handleUncategorizedErrorEvent(event)
-	}
-}
-
-func (bridge *Bridge) handleUserDeauth(ctx context.Context, user *user.User) {
-	safe.Lock(func() {
-		bridge.logoutUser(ctx, user, false, false, false)
-		user.ReportConfigStatusFailure("User deauth.")
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) handleUserBadEvent(ctx context.Context, user *user.User, event events.UserBadEvent) {
-	safe.Lock(func() {
-		if rerr := bridge.reporter.ReportMessageWithContext("Failed to handle event", reporter.Context{
-			"user_id":      user.ID(),
-			"old_event_id": event.OldEventID,
-			"new_event_id": event.NewEventID,
-			"event_info":   event.EventInfo,
-			"error":        event.Error,
-			"error_type":   internal.ErrCauseType(event.Error),
-		}); rerr != nil {
-			logrus.WithError(rerr).Error("Failed to report failed event handling")
-		}
-
-		user.OnBadEvent(ctx)
-	}, bridge.usersLock)
-}
-
-func (bridge *Bridge) handleUncategorizedErrorEvent(event events.UncategorizedEventError) {
-	if rerr := bridge.reporter.ReportMessageWithContext("Failed to handle due to uncategorized error", reporter.Context{
-		"error_type": internal.ErrCauseType(event.Error),
-		"error":      event.Error,
-	}); rerr != nil {
-		logrus.WithError(rerr).Error("Failed to report failed event handling")
-	}
-}

internal/bridge/user_test.go

@@ -1,726 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package bridge_test
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/ProtonMail/go-proton-api"
-	"github.com/ProtonMail/go-proton-api/server"
-	"github.com/ProtonMail/proton-bridge/v3/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/stretchr/testify/require"
-)
-
-func TestBridge_WithoutUsers(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_Login(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_Login_DropConn(t *testing.T) {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	require.NoError(t, err)
-
-	dropListener := proton.NewListener(l, proton.NewDropConn)
-	defer func() { _ = dropListener.Close() }()
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-
-		// Whether to allow the user to be created.
-		var allowUser bool
-
-		s.AddStatusHook(func(req *http.Request) (int, bool) {
-			// Drop any request to the users endpoint.
-			if !allowUser && req.URL.Path == "/core/v4/users" {
-				dropListener.DropAll()
-			}
-
-			// After the ping request, allow the user to be created.
-			if req.URL.Path == "/tests/ping" {
-				allowUser = true
-			}
-
-			return 0, false
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The user is eventually connected.
-			require.Eventually(t, func() bool {
-				return len(bridge.GetUserIDs()) == 1 && len(getConnectedUserIDs(t, bridge)) == 1
-			}, 5*time.Second, 100*time.Millisecond)
-		})
-	}, server.WithListener(dropListener))
-}
-
-func TestBridge_LoginTwice(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Additional login should fail.
-			_, err = bridge.LoginFull(ctx, username, password, nil, nil)
-			require.Error(t, err)
-		})
-	})
-}
-
-func TestBridge_LoginLogoutLogin(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Logout the user.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-
-			// The user is now disconnected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-
-			// Login the user again.
-			newUserID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-			require.Equal(t, userID, newUserID)
-
-			// The user is connected again.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginDeleteLogin(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Delete the user.
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-
-			// The user is now gone.
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-
-			// Login the user again.
-			newUserID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-			require.Equal(t, userID, newUserID)
-
-			// The user is connected again.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginDeauthLogin(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Get a channel to receive the deauth event.
-			eventCh, done := bridge.GetEvents(events.UserDeauth{})
-			defer done()
-
-			// Deauth the user.
-			require.NoError(t, s.RevokeUser(userID))
-
-			// The user is eventually disconnected.
-			require.Eventually(t, func() bool {
-				return len(getConnectedUserIDs(t, bridge)) == 0
-			}, 10*time.Second, time.Second)
-
-			// We should get a deauth event.
-			require.IsType(t, events.UserDeauth{}, <-eventCh)
-
-			// Login the user after the disconnection.
-			newUserID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-			require.Equal(t, userID, newUserID)
-
-			// The user is connected again.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginDeauthRestartLogin(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Get a channel to receive the deauth event.
-			eventCh, done := bridge.GetEvents(events.UserDeauth{})
-			defer done()
-
-			// Deauth the user.
-			require.NoError(t, s.RevokeUser(userID))
-
-			// The user is eventually disconnected.
-			require.Eventually(t, func() bool {
-				return len(getConnectedUserIDs(t, bridge)) == 0
-			}, 10*time.Second, time.Second)
-
-			// We should get a deauth event.
-			require.IsType(t, events.UserDeauth{}, <-eventCh)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The user should be disconnected at startup.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-
-			// Login the user after the disconnection.
-			newUserID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-			require.Equal(t, userID, newUserID)
-
-			// The user is connected again.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginExpireLogin(t *testing.T) {
-	const authLife = 2 * time.Second
-
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		s.SetAuthLife(authLife)
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user. Its auth will only be valid for a short time.
-			userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Wait until the auth expires.
-			time.Sleep(authLife)
-
-			// The user will have to refresh but the logout will still succeed.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-		})
-	})
-}
-
-func TestBridge_FailToLoad(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		// Login the user.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-		})
-
-		// Deauth the user while bridge is stopped.
-		require.NoError(t, s.RevokeUser(userID))
-
-		// When bridge starts, the user will not be logged in.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoadWithoutInternet(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		// Login the user.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-		})
-
-		// Simulate loss of internet connection.
-		netCtl.Disable()
-
-		// Start bridge without internet.
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Initially, users are not connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-
-			time.Sleep(5 * time.Second)
-
-			// Simulate internet connection.
-			netCtl.Enable()
-
-			// The user will eventually be connected.
-			require.Eventually(t, func() bool {
-				return len(getConnectedUserIDs(t, bridge)) == 1 && getConnectedUserIDs(t, bridge)[0] == userID
-			}, 10*time.Second, time.Second)
-		})
-	})
-}
-
-func TestBridge_LoginRestart(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginLogoutRestart(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Logout the user.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The user is still disconnected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_LoginDeleteRestart(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Delete the user.
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The user is still gone.
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_FailLoginRecover(t *testing.T) {
-	for i := uint64(1); i < 10; i++ {
-		t.Run(fmt.Sprintf("read %v%% of the data", 100*i/10), func(t *testing.T) {
-			withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-				var userID string
-
-				// Log the user in, wait for it to sync, then log it out.
-				// (We don't want to count message sync data in the test.)
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-					defer done()
-
-					userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-					require.Equal(t, userID, (<-syncCh).UserID)
-					require.NoError(t, bridge.LogoutUser(ctx, userID))
-				})
-
-				var total uint64
-
-				// Now that the user is synced, we can measure exactly how much data is needed during login.
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					total = countBytesRead(netCtl, func() {
-						must(bridge.LoginFull(ctx, username, password, nil, nil))
-					})
-
-					require.NoError(t, bridge.LogoutUser(ctx, userID))
-				})
-
-				// Now simulate failing to login.
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					// Simulate a partial read.
-					netCtl.SetReadLimit(i * total / 10)
-
-					// We should fail to log the user in because we can't fully read its data.
-					require.Error(t, getErr(bridge.LoginFull(ctx, username, password, nil, nil)))
-
-					// The user should still be there (but disconnected).
-					require.Equal(t, []string{userID}, bridge.GetUserIDs())
-					require.Empty(t, getConnectedUserIDs(t, bridge))
-				})
-
-				// Simulate the network recovering.
-				netCtl.SetReadLimit(0)
-
-				// We should now be able to log the user in.
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					require.NoError(t, getErr(bridge.LoginFull(ctx, username, password, nil, nil)))
-
-					// The user should be there, now connected.
-					require.Equal(t, []string{userID}, bridge.GetUserIDs())
-					require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-				})
-			})
-		})
-	}
-}
-
-func TestBridge_FailLoadRecover(t *testing.T) {
-	for i := uint64(1); i < 10; i++ {
-		t.Run(fmt.Sprintf("read %v%% of the data", 100*i/10), func(t *testing.T) {
-			withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-				var userID string
-
-				// Log the user in and wait for it to sync.
-				// (We don't want to count message sync data in the test.)
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					syncCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-					defer done()
-
-					userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-					require.Equal(t, userID, (<-syncCh).UserID)
-				})
-
-				// See how much data it takes to load the user at startup.
-				total := countBytesRead(netCtl, func() {
-					withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-						// ...
-					})
-				})
-
-				// Simulate a partial read.
-				netCtl.SetReadLimit(i * total / 10)
-
-				// We should fail to load the user; it should be listed but disconnected.
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					require.Equal(t, []string{userID}, bridge.GetUserIDs())
-					require.Empty(t, getConnectedUserIDs(t, bridge))
-				})
-
-				// Simulate the network recovering.
-				netCtl.SetReadLimit(0)
-
-				// We should now be able to load the user.
-				withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-					require.Equal(t, []string{userID}, bridge.GetUserIDs())
-					require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-				})
-			})
-		})
-	}
-}
-
-func TestBridge_BridgePass(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		var pass []byte
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// Retrieve the bridge pass.
-			pass = must(bridge.GetUserInfo(userID)).BridgePass
-
-			// Log the user out.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-
-			// Log the user back in.
-			must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// The bridge pass should be the same.
-			require.Equal(t, pass, pass)
-		})
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The bridge should load the user.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// The bridge pass should be the same.
-			require.Equal(t, pass, must(bridge.GetUserInfo(userID)).BridgePass)
-		})
-	})
-}
-
-func TestBridge_AddressMode(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// Get the user's info.
-			info, err := bridge.GetUserInfo(userID)
-			require.NoError(t, err)
-
-			// The user is in combined mode by default.
-			require.Equal(t, vault.CombinedMode, info.AddressMode)
-
-			// Repeatedly switch between address modes.
-			for i := 1; i <= 10; i++ {
-				var target vault.AddressMode
-
-				if i%2 == 0 {
-					target = vault.CombinedMode
-				} else {
-					target = vault.SplitMode
-				}
-
-				// Put the user in the target mode.
-				require.NoError(t, bridge.SetAddressMode(ctx, userID, target))
-
-				// Get the user's info.
-				info, err = bridge.GetUserInfo(userID)
-				require.NoError(t, err)
-
-				// The user is in the target mode.
-				require.Equal(t, target, info.AddressMode)
-			}
-		})
-	})
-}
-
-func TestBridge_LoginLogoutRepeated(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			for i := 0; i < 10; i++ {
-				// Log the user in.
-				userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-				// Log the user out.
-				require.NoError(t, bridge.LogoutUser(ctx, userID))
-			}
-		})
-	})
-}
-
-func TestBridge_LogoutOffline(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		var userID string
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID = must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Go offline.
-			netCtl.Disable()
-
-			// We can still log the user out.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-
-			// The user is now disconnected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-
-		// Go back online.
-		netCtl.Enable()
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// The user is still disconnected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_DeleteDisconnected(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Logout the user.
-			require.NoError(t, bridge.LogoutUser(ctx, userID))
-
-			// The user is now disconnected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-
-			// Delete the user.
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-
-			// The user is now deleted.
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_DeleteOffline(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Login the user.
-			userID, err := bridge.LoginFull(ctx, username, password, nil, nil)
-			require.NoError(t, err)
-
-			// The user is now connected.
-			require.Equal(t, []string{userID}, bridge.GetUserIDs())
-			require.Equal(t, []string{userID}, getConnectedUserIDs(t, bridge))
-
-			// Go offline.
-			netCtl.Disable()
-
-			// We can still log the user out.
-			require.NoError(t, bridge.DeleteUser(ctx, userID))
-
-			// The user is now gone.
-			require.Empty(t, bridge.GetUserIDs())
-			require.Empty(t, getConnectedUserIDs(t, bridge))
-		})
-	})
-}
-
-func TestBridge_UserInfo_Alias(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, vaultKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, vaultKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Create a new user.
-			userID, _, err := s.CreateUser("primary", []byte("password"))
-			require.NoError(t, err)
-
-			// Give the new user an alias.
-			require.NoError(t, getErr(s.CreateAddress(userID, "alias@pm.me", []byte("password"))))
-
-			// Login the user.
-			require.NoError(t, getErr(bridge.LoginFull(ctx, "primary", []byte("password"), nil, nil)))
-
-			// Get user info.
-			info, err := bridge.GetUserInfo(userID)
-			require.NoError(t, err)
-
-			// The user should have two addresses, the primary should be first.
-			require.Equal(t, []string{"primary@" + s.GetDomain(), "alias@pm.me"}, info.Addresses)
-		})
-	})
-}
-
-func TestBridge_User_Refresh(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, vaultKey []byte) {
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, vaultKey, func(bridge *bridge.Bridge, mocks *bridge.Mocks) {
-			// Get a channel of sync started events.
-			syncStartCh, done := chToType[events.Event, events.SyncStarted](bridge.GetEvents(events.SyncStarted{}))
-			defer done()
-
-			// Get a channel of sync finished events.
-			syncFinishCh, done := chToType[events.Event, events.SyncFinished](bridge.GetEvents(events.SyncFinished{}))
-			defer done()
-
-			// Log the user in.
-			userID := must(bridge.LoginFull(ctx, username, password, nil, nil))
-
-			// The sync should start and finish.
-			require.Equal(t, userID, (<-syncStartCh).UserID)
-			require.Equal(t, userID, (<-syncFinishCh).UserID)
-
-			// Trigger a refresh.
-			require.NoError(t, s.RefreshUser(userID, proton.RefreshAll))
-
-			// The sync should start and finish again.
-			require.Equal(t, userID, (<-syncStartCh).UserID)
-			require.Equal(t, userID, (<-syncFinishCh).UserID)
-		})
-	})
-}
-
-func TestBridge_User_GetAddresses(t *testing.T) {
-	withEnv(t, func(ctx context.Context, s *server.Server, netCtl *proton.NetCtl, locator bridge.Locator, storeKey []byte) {
-		// Create a user.
-		userID, _, err := s.CreateUser("user", password)
-		require.NoError(t, err)
-		addrID2, err := s.CreateAddress(userID, "user@external.com", []byte("password"))
-		require.NoError(t, err)
-		require.NoError(t, s.ChangeAddressType(userID, addrID2, proton.AddressTypeExternal))
-
-		withBridge(ctx, t, s.GetHostURL(), netCtl, locator, storeKey, func(bridge *bridge.Bridge, _ *bridge.Mocks) {
-			userLoginAndSync(ctx, t, bridge, "user", password)
-			info, err := bridge.GetUserInfo(userID)
-			require.NoError(t, err)
-			require.Equal(t, 1, len(info.Addresses))
-			require.Equal(t, info.Addresses[0], "user@proton.local")
-		})
-	})
-}
-
-// getErr returns the error that was passed to it.
-func getErr[T any](_ T, err error) error {
-	return err
-}

internal/certs/cert_store_darwin.go

@@ -1,156 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
-
-package certs
-
-/*
-#cgo CFLAGS: -x objective-c
-#cgo LDFLAGS: -framework Foundation -framework Security
-#import <Foundation/Foundation.h>
-#import <Security/Security.h>
-
-
-int installTrustedCert(char const *bytes, unsigned long long length) {
-	if (length == 0) {
-		return errSecInvalidData;
-	}
-
-	NSData *der = [NSData dataWithBytes:bytes length:length];
-
-	// Step 1. Import the certificate in the keychain.
-	SecCertificateRef cert = SecCertificateCreateWithData(NULL, (CFDataRef) der);
-	NSDictionary* addQuery = @{
-		(id)kSecValueRef: (__bridge id) cert,
-		(id)kSecClass: (id)kSecClassCertificate,
-	};
-
-	OSStatus status = SecItemAdd((__bridge CFDictionaryRef) addQuery, NULL);
-	if ((errSecSuccess != status) && (errSecDuplicateItem != status)) {
-		CFRelease(cert);
-		return status;
-	}
-
-	// Step 2. Set the trust for the certificate.
-	SecPolicyRef policy = SecPolicyCreateSSL(true, NULL); // we limit our trust to SSL
-	NSDictionary *trustSettings = @{
-		(id)kSecTrustSettingsResult: [NSNumber numberWithInt:kSecTrustSettingsResultTrustRoot],
-		(id)kSecTrustSettingsPolicy: (__bridge id) policy,
-	};
-	status = SecTrustSettingsSetTrustSettings(cert, kSecTrustSettingsDomainUser, (__bridge CFTypeRef)(trustSettings));
-	CFRelease(policy);
-	CFRelease(cert);
-
-	return status;
-}
-
-
-int removeTrustedCert(char const *bytes, unsigned long long length) {
-	if (0 == length) {
-		return errSecInvalidData;
-	}
-
-	NSData *der = [NSData dataWithBytes: bytes length: length];
-	SecCertificateRef cert = SecCertificateCreateWithData(NULL, (CFDataRef) der);
-
-	// Step 1. Unset the trust for the certificate.
-	SecPolicyRef policy = SecPolicyCreateSSL(true, NULL);
-	NSDictionary * trustSettings = @{
-		(id)kSecTrustSettingsResult: [NSNumber numberWithInt:kSecTrustSettingsResultUnspecified],
-		(id)kSecTrustSettingsPolicy: (__bridge id) policy,
-	};
-	OSStatus status = SecTrustSettingsSetTrustSettings(cert, kSecTrustSettingsDomainUser, (__bridge CFTypeRef)(trustSettings));
-	CFRelease(policy);
-	if (errSecSuccess != status) {
-		CFRelease(cert);
-		return status;
-	}
-
-	// Step 2. Remove the certificate from the keychain.
-	NSDictionary *query = @{ (id)kSecClass: (id)kSecClassCertificate,
-							 (id)kSecMatchItemList: @[(__bridge id)cert],
-							 (id)kSecMatchLimit: (id)kSecMatchLimitOne,
-						   };
-	status = SecItemDelete((__bridge CFDictionaryRef) query);
-
-	CFRelease(cert);
-	return status;
-}
-*/
-import "C"
-
-import (
-	"encoding/pem"
-	"errors"
-	"fmt"
-	"unsafe"
-)
-
-// some of the error codes returned by Apple's Security framework.
-const (
-	errSecSuccess            = 0
-	errAuthorizationCanceled = -60006
-)
-
-// certPEMToDER converts a certificate in PEM format to DER format, which is the format required by Apple's Security framework.
-func certPEMToDER(certPEM []byte) ([]byte, error) {
-	block, left := pem.Decode(certPEM)
-	if block == nil {
-		return []byte{}, errors.New("invalid PEM certificate")
-	}
-
-	if len(left) > 0 {
-		return []byte{}, errors.New("trailing data found at the end of a PEM certificate")
-	}
-
-	return block.Bytes, nil
-}
-
-func installCert(certPEM []byte) error {
-	certDER, err := certPEMToDER(certPEM)
-	if err != nil {
-		return err
-	}
-
-	p := C.CBytes(certDER)
-	defer C.free(unsafe.Pointer(p)) //nolint:unconvert
-
-	errCode := C.installTrustedCert((*C.char)(p), (C.ulonglong)(len(certDER)))
-	switch errCode {
-	case errSecSuccess:
-		return nil
-	case errAuthorizationCanceled:
-		return fmt.Errorf("the user cancelled the authorization dialog")
-	default:
-		return fmt.Errorf("could not install certification into keychain (error %v)", errCode)
-	}
-}
-
-func uninstallCert(certPEM []byte) error {
-	certDER, err := certPEMToDER(certPEM)
-	if err != nil {
-		return err
-	}
-
-	p := C.CBytes(certDER)
-	defer C.free(unsafe.Pointer(p)) //nolint:unconvert
-
-	if errCode := C.removeTrustedCert((*C.char)(p), (C.ulonglong)(len(certDER))); errCode != 0 {
-		return fmt.Errorf("could not install certificate from keychain (error %v)", errCode)
-	}
-
-	return nil
-}

internal/certs/cert_store_darwin_test.go

@@ -1,44 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
-
-//go:build darwin
-
-package certs
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-// This test implies human interactions to enter password and is disabled by default.
-func _TestTrustedCertsDarwin(t *testing.T) { //nolint:unused
-	template, err := NewTLSTemplate()
-	require.NoError(t, err)
-
-	certPEM, _, err := GenerateCert(template)
-	require.NoError(t, err)
-
-	require.Error(t, installCert([]byte{0}))   // Cannot install an invalid cert.
-	require.Error(t, uninstallCert(certPEM))   // Cannot uninstall a cert that is not installed.
-	require.NoError(t, installCert(certPEM))   // Can install a valid cert.
-	require.NoError(t, installCert(certPEM))   // Can install an already installed cert.
-	require.NoError(t, uninstallCert(certPEM)) // Can uninstall an installed cert.
-	require.Error(t, uninstallCert(certPEM))   // Cannot uninstall an already uninstalled cert.
-	require.NoError(t, installCert(certPEM))   // Can reinstall an uninstalled cert.
-	require.NoError(t, uninstallCert(certPEM)) // Can uninstall a reinstalled cert.
-}

internal/certs/installer.go

@@ -1,32 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package certs
-
-type Installer struct{}
-
-func NewInstaller() *Installer {
-	return &Installer{}
-}
-
-func (installer *Installer) InstallCert(certPEM []byte) error {
-	return installCert(certPEM)
-}
-
-func (installer *Installer) UninstallCert(certPEM []byte) error {
-	return uninstallCert(certPEM)
-}

internal/clientconfig/applemail.go

@@ -1,123 +0,0 @@
-// Copyright (c) 2023 Proton AG
-//
-// This file is part of Proton Mail Bridge.
-//
-// Proton Mail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// Proton Mail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
-
-package clientconfig
-
-import (
-	"os"
-	"path/filepath"
-	"strconv"
-	"time"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/ProtonMail/proton-bridge/v3/pkg/mobileconfig"
-	"golang.org/x/sys/execabs"
-)
-
-const (
-	bigSurPreferencesPane  = "/System/Library/PreferencePanes/Profiles.prefPane"
-	venturaPreferencesPane = "x-apple.systempreferences:com.apple.preferences.configurationprofiles"
-)
-
-type AppleMail struct{}
-
-func (c *AppleMail) Configure(
-	hostname string,
-	imapPort, smtpPort int,
-	imapSSL, smtpSSL bool,
-	username, addresses string,
-	password []byte,
-) error {
-	mc := prepareMobileConfig(hostname, imapPort, smtpPort, imapSSL, smtpSSL, username, addresses, password)
-
-	confPath, err := saveConfigTemporarily(mc)
-	if err != nil {
-		return err
-	}
-
-	if useragent.IsBigSurOrNewer() {
-		prefPane := bigSurPreferencesPane
-
-		if useragent.IsVenturaOrNewer() {
-			prefPane = venturaPreferencesPane
-		}
-
-		return execabs.Command("open", prefPane, confPath).Run() //nolint:gosec // G204 open command is safe, mobileconfig is generated by us
-	}
-
-	return execabs.Command("open", confPath).Run() //nolint:gosec // G204 open command is safe, mobileconfig is generated by us
-}
-
-func prepareMobileConfig(
-	hostname string,
-	imapPort, smtpPort int,
-	imapSSL, smtpSSL bool,
-	username, addresses string,
-	password []byte,
-) *mobileconfig.Config {
-	return &mobileconfig.Config{
-		DisplayName:        username,
-		EmailAddress:       addresses,
-		AccountName:        username,
-		AccountDescription: username,
-		Identifier:         "protonmail " + username + strconv.FormatInt(time.Now().Unix(), 10),
-		IMAP: &mobileconfig.IMAP{
-			Hostname: hostname,
-			Port:     imapPort,
-			TLS:      imapSSL,
-			Username: username,
-			Password: string(password),
-		},
-		SMTP: &mobileconfig.SMTP{
-			Hostname: hostname,
-			Port:     smtpPort,
-			TLS:      smtpSSL,
-			Username: username,
-			Password: string(password),
-		},
-	}
-}
-
-func saveConfigTemporarily(mc *mobileconfig.Config) (fname string, err error) {
-	dir, err := os.MkdirTemp("", "protonmail-autoconfig")
-	if err != nil {
-		return
-	}
-
-	// Make sure the temporary file is deleted.
-	go func() {
-		defer recover() //nolint:errcheck
-
-		<-time.After(10 * time.Minute)
-		_ = os.RemoveAll(dir)
-	}()
-
-	// Make sure the file is only readable for the current user.
-	fname = filepath.Clean(filepath.Join(dir, "protonmail.mobileconfig"))
-	f, err := os.OpenFile(fname, os.O_RDWR|os.O_CREATE, 0o600) //nolint:gosec
-	if err != nil {
-		return
-	}
-
-	if err = mc.WriteOut(f); err != nil {
-		_ = f.Close()
-		return
-	}
-	_ = f.Close()
-
-	return
-}

internal/config/cache/cache.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+// Package cache provides access to contents inside a cache directory.
+package cache
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ProtonMail/proton-bridge/v2/pkg/files"
+)
+
+type Cache struct {
+	dir, version string
+}
+
+func New(dir, version string) (*Cache, error) {
+	if err := os.MkdirAll(filepath.Join(dir, version), 0o700); err != nil {
+		return nil, err
+	}
+
+	return &Cache{
+		dir:     dir,
+		version: version,
+	}, nil
+}
+
+// GetDBDir returns folder for db files.
+func (c *Cache) GetDBDir() string {
+	return c.getCurrentCacheDir()
+}
+
+// GetDefaultMessageCacheDir returns folder for cached messages files.
+func (c *Cache) GetDefaultMessageCacheDir() string {
+	return filepath.Join(c.getCurrentCacheDir(), "messages")
+}
+
+// GetIMAPCachePath returns path to file with IMAP status.
+func (c *Cache) GetIMAPCachePath() string {
+	return filepath.Join(c.getCurrentCacheDir(), "user_info.json")
+}
+
+// GetTransferDir returns folder for import-export rules files.
+func (c *Cache) GetTransferDir() string {
+	return c.getCurrentCacheDir()
+}
+
+// RemoveOldVersions removes any cache dirs that are not the current version.
+func (c *Cache) RemoveOldVersions() error {
+	return files.Remove(c.dir).Except(c.getCurrentCacheDir()).Do()
+}
+
+func (c *Cache) getCurrentCacheDir() string {
+	return filepath.Join(c.dir, c.version)
+}

internal/config/cache/cache_test.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package cache
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRemoveOldVersions(t *testing.T) {
+	dir, err := ioutil.TempDir("", "test-cache")
+	require.NoError(t, err)
+
+	cache, err := New(dir, "c4")
+	require.NoError(t, err)
+
+	createFilesInDir(t, dir,
+		"unexpected1.txt",
+		"c1/unexpected1.txt",
+		"c2/unexpected2.txt",
+		"c3/unexpected3.txt",
+		"something.txt",
+	)
+
+	require.DirExists(t, filepath.Join(dir, "c4"))
+	require.FileExists(t, filepath.Join(dir, "unexpected1.txt"))
+	require.FileExists(t, filepath.Join(dir, "c1", "unexpected1.txt"))
+	require.FileExists(t, filepath.Join(dir, "c2", "unexpected2.txt"))
+	require.FileExists(t, filepath.Join(dir, "c3", "unexpected3.txt"))
+	require.FileExists(t, filepath.Join(dir, "something.txt"))
+
+	assert.NoError(t, cache.RemoveOldVersions())
+
+	assert.DirExists(t, filepath.Join(dir, "c4"))
+	assert.NoFileExists(t, filepath.Join(dir, "unexpected1.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c1", "unexpected1.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c2", "unexpected2.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c3", "unexpected3.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "something.txt"))
+}
+
+func createFilesInDir(t *testing.T, dir string, files ...string) {
+	for _, target := range files {
+		require.NoError(t, os.MkdirAll(filepath.Dir(filepath.Join(dir, target)), 0o700))
+
+		f, err := os.Create(filepath.Join(dir, target))
+		require.NoError(t, err)
+		require.NoError(t, f.Close())
+	}
+}

internal/config/settings/kvs.go

@@ -0,0 +1,152 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package settings
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+)
+
+type keyValueStore struct {
+	cache map[string]string
+	path  string
+	lock  *sync.RWMutex
+}
+
+// newKeyValueStore returns loaded preferences.
+func newKeyValueStore(path string) *keyValueStore {
+	p := &keyValueStore{
+		path: path,
+		lock: &sync.RWMutex{},
+	}
+	if err := p.load(); err != nil {
+		logrus.WithError(err).Warn("Cannot load preferences file, creating new one")
+	}
+	return p
+}
+
+func (p *keyValueStore) load() error {
+	if p.cache != nil {
+		return nil
+	}
+
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	p.cache = map[string]string{}
+
+	f, err := os.Open(p.path)
+	if err != nil {
+		return err
+	}
+	defer f.Close() //nolint:errcheck,gosec
+
+	return json.NewDecoder(f).Decode(&p.cache)
+}
+
+func (p *keyValueStore) save() error {
+	if p.cache == nil {
+		return errors.New("cannot save preferences: cache is nil")
+	}
+
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	b, err := json.MarshalIndent(p.cache, "", "\t")
+	if err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile(p.path, b, 0o600)
+}
+
+func (p *keyValueStore) setDefault(key, value string) {
+	if p.Get(key) == "" {
+		p.Set(key, value)
+	}
+}
+
+func (p *keyValueStore) Get(key string) string {
+	p.lock.RLock()
+	defer p.lock.RUnlock()
+
+	return p.cache[key]
+}
+
+func (p *keyValueStore) GetBool(key string) bool {
+	return p.Get(key) == "true"
+}
+
+func (p *keyValueStore) GetInt(key string) int {
+	if p.Get(key) == "" {
+		return 0
+	}
+
+	value, err := strconv.Atoi(p.Get(key))
+	if err != nil {
+		logrus.WithError(err).Error("Cannot parse int")
+	}
+
+	return value
+}
+
+func (p *keyValueStore) GetFloat64(key string) float64 {
+	if p.Get(key) == "" {
+		return 0
+	}
+
+	value, err := strconv.ParseFloat(p.Get(key), 64)
+	if err != nil {
+		logrus.WithError(err).Error("Cannot parse float64")
+	}
+
+	return value
+}
+
+func (p *keyValueStore) Set(key, value string) {
+	p.lock.Lock()
+	p.cache[key] = value
+	p.lock.Unlock()
+
+	if err := p.save(); err != nil {
+		logrus.WithError(err).Warn("Cannot save preferences")
+	}
+}
+
+func (p *keyValueStore) SetBool(key string, value bool) {
+	if value {
+		p.Set(key, "true")
+	} else {
+		p.Set(key, "false")
+	}
+}
+
+func (p *keyValueStore) SetInt(key string, value int) {
+	p.Set(key, strconv.Itoa(value))
+}
+
+func (p *keyValueStore) SetFloat64(key string, value float64) {
+	p.Set(key, fmt.Sprintf("%v", value))
+}

internal/config/settings/kvs_test.go

@@ -0,0 +1,142 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package settings
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadNoKeyValueStore(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestEmptyKeyValueStore(r)
+	defer clean()
+
+	r.Equal("", pref.Get("key"))
+}
+
+func TestLoadBadKeyValueStore(t *testing.T) {
+	r := require.New(t)
+	path, clean := newTmpFile(r)
+	defer clean()
+
+	r.NoError(ioutil.WriteFile(path, []byte("{\"key\":\"MISSING_QUOTES"), 0o700))
+	pref := newKeyValueStore(path)
+	r.Equal("", pref.Get("key"))
+}
+
+func TestKeyValueStor(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestKeyValueStore(r)
+	defer clean()
+
+	r.Equal("value", pref.Get("str"))
+	r.Equal("42", pref.Get("int"))
+	r.Equal("true", pref.Get("bool"))
+	r.Equal("t", pref.Get("falseBool"))
+}
+
+func TestKeyValueStoreGetInt(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestKeyValueStore(r)
+	defer clean()
+
+	r.Equal(0, pref.GetInt("str"))
+	r.Equal(42, pref.GetInt("int"))
+	r.Equal(0, pref.GetInt("bool"))
+	r.Equal(0, pref.GetInt("falseBool"))
+}
+
+func TestKeyValueStoreGetBool(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestKeyValueStore(r)
+	defer clean()
+
+	r.Equal(false, pref.GetBool("str"))
+	r.Equal(false, pref.GetBool("int"))
+	r.Equal(true, pref.GetBool("bool"))
+	r.Equal(false, pref.GetBool("falseBool"))
+}
+
+func TestKeyValueStoreSetDefault(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestEmptyKeyValueStore(r)
+	defer clean()
+
+	pref.setDefault("key", "value")
+	pref.setDefault("key", "othervalue")
+	r.Equal("value", pref.Get("key"))
+}
+
+func TestKeyValueStoreSet(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestEmptyKeyValueStore(r)
+	defer clean()
+
+	pref.Set("str", "value")
+	checkSavedKeyValueStore(r, pref.path, "{\n\t\"str\": \"value\"\n}")
+}
+
+func TestKeyValueStoreSetInt(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestEmptyKeyValueStore(r)
+	defer clean()
+
+	pref.SetInt("int", 42)
+	checkSavedKeyValueStore(r, pref.path, "{\n\t\"int\": \"42\"\n}")
+}
+
+func TestKeyValueStoreSetBool(t *testing.T) {
+	r := require.New(t)
+	pref, clean := newTestEmptyKeyValueStore(r)
+	defer clean()
+
+	pref.SetBool("trueBool", true)
+	pref.SetBool("falseBool", false)
+	checkSavedKeyValueStore(r, pref.path, "{\n\t\"falseBool\": \"false\",\n\t\"trueBool\": \"true\"\n}")
+}
+
+func newTmpFile(r *require.Assertions) (path string, clean func()) {
+	tmpfile, err := ioutil.TempFile("", "pref.*.json")
+	r.NoError(err)
+	defer r.NoError(tmpfile.Close())
+
+	return tmpfile.Name(), func() {
+		r.NoError(os.Remove(tmpfile.Name()))
+	}
+}
+
+func newTestEmptyKeyValueStore(r *require.Assertions) (*keyValueStore, func()) {
+	path, clean := newTmpFile(r)
+	return newKeyValueStore(path), clean
+}
+
+func newTestKeyValueStore(r *require.Assertions) (*keyValueStore, func()) {
+	path, clean := newTmpFile(r)
+	r.NoError(ioutil.WriteFile(path, []byte("{\"str\":\"value\",\"int\":\"42\",\"bool\":\"true\",\"falseBool\":\"t\"}"), 0o700))
+	return newKeyValueStore(path), clean
+}
+
+func checkSavedKeyValueStore(r *require.Assertions, path, expected string) {
+	data, err := ioutil.ReadFile(path)
+	r.NoError(err)
+	r.Equal(expected, string(data))
+}

internal/config/settings/settings.go

@@ -0,0 +1,113 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+// Package settings provides access to persistent user settings.
+package settings
+
+import (
+	"fmt"
+	"math/rand"
+	"path/filepath"
+	"time"
+)
+
+// Keys of preferences in JSON file.
+const (
+	FirstStartKey          = "first_time_start"
+	FirstStartGUIKey       = "first_time_start_gui"
+	LastHeartbeatKey       = "last_heartbeat"
+	APIPortKey             = "user_port_api"
+	IMAPPortKey            = "user_port_imap"
+	SMTPPortKey            = "user_port_smtp"
+	SMTPSSLKey             = "user_ssl_smtp"
+	AllowProxyKey          = "allow_proxy"
+	AutostartKey           = "autostart"
+	AutoUpdateKey          = "autoupdate"
+	CookiesKey             = "cookies"
+	ReportOutgoingNoEncKey = "report_outgoing_email_without_encryption"
+	LastVersionKey         = "last_used_version"
+	UpdateChannelKey       = "update_channel"
+	RolloutKey             = "rollout"
+	PreferredKeychainKey   = "preferred_keychain"
+	CacheEnabledKey        = "cache_enabled"
+	CacheCompressionKey    = "cache_compression"
+	CacheLocationKey       = "cache_location"
+	CacheMinFreeAbsKey     = "cache_min_free_abs"
+	CacheMinFreeRatKey     = "cache_min_free_rat"
+	CacheConcurrencyRead   = "cache_concurrent_read"
+	CacheConcurrencyWrite  = "cache_concurrent_write"
+	IMAPWorkers            = "imap_workers"
+	FetchWorkers           = "fetch_workers"
+	AttachmentWorkers      = "attachment_workers"
+	ColorScheme            = "color_scheme"
+	RebrandingMigrationKey = "rebranding_migrated"
+)
+
+type Settings struct {
+	*keyValueStore
+
+	settingsPath string
+}
+
+func New(settingsPath string) *Settings {
+	s := &Settings{
+		keyValueStore: newKeyValueStore(filepath.Join(settingsPath, "prefs.json")),
+		settingsPath:  settingsPath,
+	}
+
+	s.setDefaultValues()
+
+	return s
+}
+
+const (
+	DefaultIMAPPort = "1143"
+	DefaultSMTPPort = "1025"
+	DefaultAPIPort  = "1042"
+)
+
+func (s *Settings) setDefaultValues() {
+	s.setDefault(FirstStartKey, "true")
+	s.setDefault(FirstStartGUIKey, "true")
+	s.setDefault(LastHeartbeatKey, fmt.Sprintf("%v", time.Now().YearDay()))
+	s.setDefault(AllowProxyKey, "true")
+	s.setDefault(AutostartKey, "true")
+	s.setDefault(AutoUpdateKey, "true")
+	s.setDefault(ReportOutgoingNoEncKey, "false")
+	s.setDefault(LastVersionKey, "")
+	s.setDefault(UpdateChannelKey, "")
+	s.setDefault(RolloutKey, fmt.Sprintf("%v", rand.Float64())) //nolint:gosec // G404 It is OK to use weak random number generator here
+	s.setDefault(PreferredKeychainKey, "")
+	s.setDefault(CacheEnabledKey, "true")
+	s.setDefault(CacheCompressionKey, "true")
+	s.setDefault(CacheLocationKey, "")
+	s.setDefault(CacheMinFreeAbsKey, "250000000")
+	s.setDefault(CacheMinFreeRatKey, "")
+	s.setDefault(CacheConcurrencyRead, "16")
+	s.setDefault(CacheConcurrencyWrite, "16")
+	s.setDefault(IMAPWorkers, "16")
+	s.setDefault(FetchWorkers, "16")
+	s.setDefault(AttachmentWorkers, "16")
+	s.setDefault(ColorScheme, "")
+
+	s.setDefault(APIPortKey, DefaultAPIPort)
+	s.setDefault(IMAPPortKey, DefaultIMAPPort)
+	s.setDefault(SMTPPortKey, DefaultSMTPPort)
+
+	// By default, stick to STARTTLS. If the user uses catalina+applemail they'll have to change to SSL.
+	s.setDefault(SMTPSSLKey, "false")
+}

internal/config/tls/cert_store_darwin.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2022 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
+
+package tls
+
+import "golang.org/x/sys/execabs"
+
+func addTrustedCert(certPath string) error {
+	return execabs.Command( //nolint:gosec
+		"/usr/bin/security",
+		"execute-with-privileges",
+		"/usr/bin/security",
+		"add-trusted-cert",
+		"-d",
+		"-r", "trustRoot",
+		"-p", "ssl",
+		"-k", "/Library/Keychains/System.keychain",
+		certPath,
+	).Run()
+}
+
+func removeTrustedCert(certPath string) error {
+	return execabs.Command( //nolint:gosec
+		"/usr/bin/security",
+		"execute-with-privileges",
+		"/usr/bin/security",
+		"remove-trusted-cert",
+		"-d",
+		certPath,
+	).Run()
+}
+
+func (t *TLS) InstallCerts() error {
+	return addTrustedCert(t.getTLSCertPath())
+}
+
+func (t *TLS) UninstallCerts() error {
+	return removeTrustedCert(t.getTLSCertPath())
+}

internal/config/tls/cert_store_linux.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -15,12 +15,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
-package certs
+package tls
 
-func installCert([]byte) error {
+func (t *TLS) InstallCerts() error {
 	return nil // Linux doesn't have a root cert store.
 }
 
-func uninstallCert([]byte) error {
+func (t *TLS) UninstallCerts() error {
 	return nil // Linux doesn't have a root cert store.
 }

internal/config/tls/cert_store_windows.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2023 Proton AG
+// Copyright (c) 2022 Proton AG
 //
 // This file is part of Proton Mail Bridge.
 //
@@ -15,12 +15,12 @@
 // You should have received a copy of the GNU General Public License
 // along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
 
-package certs
+package tls
 
-func installCert([]byte) error {
+func (t *TLS) InstallCerts() error {
 	return nil // NOTE(GODT-986): Install certs to root cert store?
 }
 
-func uninstallCert([]byte) error {
+func (t *TLS) UninstallCerts() error {
 	return nil // NOTE(GODT-986): Uninstall certs from root cert store?
 }