Other: Bridge Millau 2.2.1

GODT-1565: Improve mac icon.
GODT-1475: Improve systray icon size.
2025-12-10 12:46:46 +00:00 · 2022-07-14 13:51:37 +02:00 · 2022-07-14 13:20:33 +02:00 · 2022-07-14 13:20:33 +02:00 · 2022-07-14 13:20:33 +02:00 · 2022-07-14 13:20:33 +02:00
1090 changed files with 62183 additions and 82257 deletions
--- a/.gitignore
+++ b/.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
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -16,230 +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

-stages:
-  - test
-  - build
-
-.rules-branch-and-MR-manual:
-  rules:
-    - if: $CI_COMMIT_BRANCH ||  $CI_PIPELINE_SOURCE == "merge_request_event"
-      when: manual
-      allow_failure: true
-    - when: never
-
-.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
-
-# 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
-  cache:
-    key: linux-vcpkg
-    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
+
+  - make install-dev-dependencies
+
+cache:
+  key: go-mod
+  paths:
+    - .cache
+  policy: pull
+
+stages:
+  - cache
+  - test
+  - build
+  - mirror
+
+# Stage: 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: go-mod
+    paths:
+      - .cache

 # 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

-.script-test:
+test-linux:
  stage: test
-  extends:
-    - .rules-branch-manual-MR-and-devel-always
+  only:
+    - branches
+  script:
+    - 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:
+    - medium
+
+test-windows:
+  extends: .build-windows-base
+  stage: test
+  only:
+    - branches
  script:
    - make test
-  artifacts:
-    paths:
-      - coverage/**

-test-linux:
-  extends:
-    - .script-test
+test-integration:
+  stage: test
+  only:
+    - branches
+  script:
+    - VERBOSITY=debug make -C test 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-windows:
-  extends:
-    - .env-windows
-    - .script-test
-    - .rules-branch-and-MR-manual
-
-test-darwin:
-  extends:
-    - .env-darwin
-    - .script-test
-
-test-coverage:
+dependency-updates:
  stage: test
-  extends:
-    - .rules-branch-manual-MR-and-devel-always
  script:
-    - ./utils/coverage.sh
-  coverage: '/total:.*\(statements\).*\d+\.\d+%/'
-  needs:
-    - test-linux
-    #- test-windows
-    - test-darwin
-    - test-integration
-  tags:
-    - small
-  artifacts:
-    paths:
-      - coverage*
-      - coverage/**
-    when: 'always'
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
+    - 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)"
--- a/.gitmodules
+++ b/.gitmodules
@ -1,3 +0,0 @@
-[submodule "submodules/vcpkg"]
-	path = extern/vcpkg
-	url = https://github.com/Microsoft/vcpkg.git
--- a/.golangci.yml
+++ b/.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.
--- a/BUILDS.md
+++ b/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
--- a/COPYING_NOTES.md
+++ b/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 -->
--- a/Changelog.md
+++ b/Changelog.md
@ -1,825 +1,7 @@
-# Proton Mail Bridge Changelog
+# Proton Mail Bridge and Import-Export app Changelog

 Changelog [format](http://keepachangelog.com/en/1.0.0/)

-
-## Trift Bridge 3.4.1
-
-### Fixed
-* GODT-2859: Trigger user resync while updating from 3.4.0 to 3.4.1.
-* GODT-2833: Fix migration of message flags.
-* GODT-2759: Use examine rather than select for fetching.
-
-
-## Trift Bridge 3.4.0
-
-### Added
-
-### Changed
-* Test: Add require.Eventually to TestBridge_UserAgentFromSMTPClient.
-* Test: Add smtp-send utility.
-* GODT-2759: Check for oprhan messages.
-* GODT-2759: Add prompt to download missing messages for analysis.
-* GODT-2759: CLI debug commands.
-* Remove gRPC auto-generated C++ source files.
-* Test: Force all unit test to use minimum sync spec.
-* Test: Force sync limits to minimum with env variable.
-* GODT-2691: Close logrus output file on exit.
-* GODT-2522: New Gluon database layout.
-* GODT-2678: When internet is off, do not display status dot icon for the user in the context menu.
-* GODT-2686: Change the orientation of the expand/collapse arrow for Advanced settings.
-* Test(GODT-2636): Add step for sending from EML.
-* Log failed message ids during sync.
-* GODT-2510: Remove Ent.
-* Test(GODT-2600): Changing state (read/unread, starred/unstarred) of a message in integration tests.
-* GODT-2703: Got rid of account details dialog with Apple Mail autoconf.
-* GODT-2685: Update to bug report log attachment logic.
-* GODT-2690: Update sentry reporting in GUI for new log file naming.
-* GODT-2668: Implemented new log retention policy.
-* Test(GODT-2683): Save Draft without "Date" & "From" in headers.
-* GODT-2666: Feat(GODT-2667): introduce sessionID in bridge.
-* GODT-2660: Calculate bridge coverage and refactor CI yaml file.
-* Fix dependency_license script to handle dot formated version.
-
-### Fixed
-* GODT-2812: Fix rare sync deadlock.
-* GODT-2822: Better handling 429 during sync and event loop.
-* GODT-2763: Missing Answered flag on Sync and Message Create.
-* GODT-2758: Fix panic in SetFlagsOnMessages.
-* GODT-2578: Refresh literals appended to Sent folder.
-* GODT-2753: Vault test now check that value auto-assigned is first available port.
-* GODT-2522: Handle migration with unreferenced db values.
-* GODT-2693: Allow missing whitespace after header field colon.
-* GODT-2653: Only log when err is not nil.
-* GODT-2680: Fix for C++ debugger not working on ARM64 because of OpenSSL 3.1.
-* GODT-2675: Update GPA to applye togin-gonic/gin patch + update COPYING_NOTES.
-
-
-## Stone Bridge 3.3.2
-
-### Fixed
-* GODT-2782: Filter all labels when doing perma delete check.
-
-
-## Stone Bridge 3.3.1
-
-### Changed
-* GODT-2707: Set bridge-gui default log level to 'debug'.
-* GODT-2674: Add more logs during update failed.
-* GODT-2750: Disable raise on main window when a notification is clicked on Linux.
-* GODT-2709: Remove the config status file when user is removed.
-* GODT-2748: Log calls that cause main window to show, with reason.
-* GODT-2705: Added log entries for focus service on client and server sides.
-* GODT-2712: Feed config_status with user action while pending.
-* GODT-2728: Remove the sentry report for gRPC event stream interruptions in bridge-gui.
-* GODT-2715: Add Unitary test for configStatus event.
-* GODT-2715: Add Functional test for configStatus telemetry event.
-* Disable windows runner.
-* GODT-2714: Apply PR comments.
-* GODT-2714: Set Configuration Status to Failure and send Recovery event when issue is solved.
-* GODT-2713: Send config_progress event once a day if the configuration is stucked in pending for more than a day.
-* GODT-2711: Send config_abort event on User removal.
-* GODT-2710: Send config success on IMAP/SMTP connection..
-* GODT-2716: Make Configuration Statistics persistent.
-* GODT-2709: Init Configuration status.
-* Log errors on failed message Downloads.
-
-### Fixed
-* GODT-2774: Only check telemetry availability for the current user.
-* GODT-2774: Add external context to telemetry tasks.
-* GODT-2774: Add context to Authorize in `gluon.Connector`.
-* GODT-2726: Fix Parsing of Details field in GPA error message.
-* GODT-2708: Fix dimensions event format + handling of ReportClicked event.
-* GODT-2756: Fix for 'Settings' context menu opening the 'Help' page.
-
-
-## Stone Bridge 3.3.0
-
-### Changed
-* GODT-2653: Log API error details on Message import and send.
-* GODT-2655: Display internal build time tag in log and GUI.
-* Add error logs when messages fail to build during sync.
-* GODT-2673: Use NoClient as UserAgent without any client connected and...
-* GODT-2648: Make win build work on AWS machine.
-* Disable building of bridgepp-test app in build script.
-* GODT-2631: Bump go to 1.20.
-* GODT-2639: Enhance sentry init log.
-* GODT-2161: Auto-submit 2FA.
-* Bump Gluon for GODT-2595, GODT-2634 and GODT-2619.
-* Test: Fix TestBridge_Report.
-* Extend the timeout for integration test form 20m to 30.
-* Improve CPC code.
-* GODT-2585: Only Start IMAP/SMTP once one user is loaded.
-* GODT-2585: Server Manager.
-* GODT-2585: Add CPC utility.
-* GODT-2621: Display pop up warning when IMAP login fails because user is locked (connecting).
-* Set default log level to Debug.
-* GODT-2520: Update error message for free users.
-* Test: Disable sync open files test.
-* GODT-2346: Treat external address as disabled one.
-* GODT-2610: Re-use previous password when removing and adding back account.
-* GODT-2611: Bridge CLI exits on the first SIGINT / Ctrl+C.
-* GODT-2540: Make icon loading failure behavior consistent.
-* GODT-2540: Pop-up notification error icon is loaded on startup.
-* GODT-2540: Notify user of wrong IMAP password.
-
-### Fixed
-* GODT-2683: Only validate messages that are not appended to Drafts.
-* GODT-2683: Reduce message checks when appending into Drafts.
-* Fix linter errors.
-* GODT-2669: Display sentry ID in bridge init log.
-* GODT-2672: Fix context cancelled when IMAP/SMTP parameters change is in progress.
-* GODT-2650: Fix crash during header serialization.
-* GODT-2437: Fix lint, test + bump Gluon with silenced report.
-* GODT-2437: Silence harmless report to sentry.
-* GODT-2649: Clean up cache files after failed connector create (Gluon).
-* GODT-2638: Validate messages before import.
-* GODT-2646: Bump GPA and Gluon dependecy after CIRCL upgrade.
-* GODT-2454: Only Send status update if transaction succeeded.
-* Test: fix flaky tests.
-* GODT-2628: Attempt to fix closed channel panic on logout.
-* GODT-2627: Properly handle recording of message with Bcc fields.
-* GODT-2627: Fix crash on closed channel.
-* GODT-2307: Removed deprecated macOS security framework function.
-* GODT-2637: Fix address parser error due to trailing separator.
-* GODT-2635: Ensure Bridge can be compiled with GCC 13.
-* GODT-2626: Handle rare crash due to missing address update ch.
-* GODT-2626: Server Events should not be merged.
-* GODT-2606: Improve Vault concurrency scopes.
-* GODT-2623: Log IMAP/SMTP login failure as error.
-* GODT-2527: Cleanup 503 test since handled by GPA.
-* GODT-2613: Install the TLS certificate in the user keychain.
-* GODT-2618: Crash when address does not have unlocked keyring.
-* GODT-2616: Silence out of Order UID report.
-* Update Gluon for async.Group.Do() fix.
-* Upgraded golangci-lint v1.52.2 and fixed all issues.
-* GODT-2464: Filter attachment name from content-type parameter to not send it twice to the API.
-
-
-## [Bridge 3.2.0] Rialto
-
-### Added
-* GODT-2552, GODT-2553, GODT-2555, GODT-2556: Add telemetry.
-* GODT-2575: Add dev info to cookies.
-
-### Changed
-* GODT-2598: Map Message Size Error to Gluon Error.
-* GODT-2569: Support multiple externalID matching if we send one of it when looking for parentID.
-* GODT-2576: Connector can send any flags to Gluon.
-* GODT-2496: Bump gopenPGP to 2.7.1-proton.
-* GODT-2517: Replace status window with native tray icon context menu.
-* GODT-2586: Two-columns layout for account details.
-* GODT-2580: Updated link to support website in GUI.
-* GODT-2239: Bridgepp worker/overseer unit tests.
-* GODT-2538: Implement smart picking of default IMAP/SMTP ports.
-* GODT-2502: Improve logs.
-* GODT-2551: Store and Recover Last User Agent from Vault.
-* GODT-2550: Verify IMAP ID is set properly.
-* GODT-2554: Compute telemetry availability from API UserSettings.
-* Add missing double quotes in test.
-* GODT-2239: Unit tests for BridgeUtils.cpp in bridgepp.
-* Replace go-rfc5322 with gluon's rfc5322 parser.
-* GODT-2483: Install cert without external tool on macOS.
-
-### Fixed
-* GODT-2625: Update Bridge pubkey for updates.
-* GODT-2620: Avoid stalls in case of panic in gluon.
-* GODT-2615: Remove keyboard shortcut for tray icon context menu on Windows and Linux.
-* GODT-2596: Fix bug when trying to generate Sentry report and there is not log.
-* GODT-1374: Fix tray icon DPI change handling.
-* GODT-2589: Update BUILDS.md.
-* GODT-2581: Update outdated link to bridge homepage in CLI 'manual' command.
-* GODT-2337: Filter reply-to on draft.
-* GODT-2550: Announce IMAP ID Capability.
-* GODT-2574: Fix label/unlabel of large amounts of messages.
-* GODT-2573: Handle invalid header fields in message.
-* GODT-2573: Crash on null update.
-* GODT-2407: Replace invalid email addresses with emtpy for new Drafts.
-
-## [Bridge 3.1.3] Quebec
-
-### Changed
-* GODT-2616: Silence UID of order report.
-* GODT-2614: Handle failed update during sync.
-
-
-## [Bridge 3.1.2] Quebec
-
-### Changed
-* GODT-2582 Dedup recovered messages folder.
-
-## [Bridge 3.1.1] Quebec
-
-### Fixed
-* GODT-2500: Fix handler passing.
-
-
-## [Bridge 3.1.0] Quebec
-
-### Changed
-* GODT-2523: Use software QML rendering backend by default on Windows.
-* GODT-2500: Reorganise async methods.
-* GODT-2500: Add panic handlers everywhere.
-* GODT-2511: Add bridge-gui switches to permanently select the QML rendering backend.
-* GODT-2509: Migrate TLS cert from v1/v2 location during upgrade to v3.
-* GODT-2487: Add windows test job and worker.
-* Update GPA to include detailed error messages.
-* GODT-2479: Ensure messages always have a text body part.
-* GODT-2482: More attachment to relevant exceptions.
-* GODT-2224: Refactor bridge sync to use less memory.
-* GODT-2448: Supported Answered flag.
-* GODT-2382: Added bridge-gui settings file with 'UseSoftwareRenderer' value.
-* GODT-2411: Allow qmake executable to be named qmake6.
-* GODT-2273: Menu with "Close window" and "Quit Bridge" button in main window.
-* GODT-2261: Sync progress in GUI.
-* GODT-2385: Gluon cache fallback.
-* GODT-2366: Handle failed message updates as creates.
-* GODT-2201: Bump Gluon to use pure Go IMAP parser.
-* GODT-2374: Import TLS certs via shell.
-* GODT-2361: Bump GPA to use simple encrypter.
-* GODT-1264: Constraint on Scheduled mailbox in connector + Integration tests.
-* GODT-1264: Creation and visibility of the 'Scheduled' system label.
-* GODT-2283: Limit max import size to 30MB (bump GPA to v0.4.0).
-* GODT-2352: Only copy resource file when needed.
-* GODT-2352: Use go-build-finalize macro to build vault-editor for both mac arch.
-* GODT-2278: Properly override server_name for go.
-* GODT-2255: Randomize the focus service port.
-* GODT-2144: Handle IMAP/SMTP server errors via event stream.
-* GODT-2144: Delay IMAP/SMTP server start until all users are loaded.
-* GODT-2295: Notifications for IMAP login when signed out.
-* GODT-2278: Improve sentry logs.
-* GODT-2289: UIDValidity as Timestamp.
-
-### Fixed
-* GODT-2505: Show notification only for cases when user needs to do actions.
-* GODT-2516: Log error when the vault key cannot be created/loaded from the keychain.
-* GODT-2526: Fix high memory usage with fetch/search.
-* GODT-2514: Apply Retry-After to 503.
-* GODT-2524: Preserve old vault values.
-* GODT-2508: Handle Address Updated for none-existing address.
-* GODT-2504: Fix missing attachments in imported message.
-* GODT-2513: Scanner Crash in Gluon.
-* GODT-2512: Catch unhandled API errors.
-* GODT-2507: Memory consumption bug.
-* GODT-2497: Do not report EOF and network errors.
-* GODT-2481: Fix DBUS Secert Service.
-* GODT-2455: Upper limit for number of merged events.
-* GODT-2480: Do not override X-Original-Date with invalid Date.
-* GODT-2473: Fix handling of complex mime types.
-* GODT-2469: Fix sentry revision hash for cmake on windows.
-* GODT-2424: Sync Builder Message Split.
-* GODT-2419: Use connector.ErrOperationNotAllowed.
-* GODT-2418: Ensure child folders are updated when parent is.
-* GODT-1945: Handle disabled addresses correctly.
-* GODT-2390: Add reports for uncaught json and net.opErr.
-* GODT-2393: Improved handling of unrecoverable error.
-* GODT-2394: Bump Gluon for golang.org/x/text DoS risk.
-* GODT-2387: Ensure vault can be unlocked after factory reset.
-* GODT-2389: Close bridge on exception and add max termination wait time.
-* GODT-2201: Add missing rfc5322.CharsetReader initialization.
-* GODT-1804: Preserve MIME parameters when uploading attachments.
-* GODT-2312: Used space is properly updated.
-* GODT-2319: Seed the math/rand RNG on app startup.
-* GODT-2272: Use shorter filename for gRPC file socket.
-* GODT-2318: Remove gluon DB if label sync was incomplete.
-* GODT-2326: Only run sync after addIMAPUser().
-* GODT-2323: Fix Expunge not issued for move.
-* GODT-2224: Properly handle context cancellation during sync.
-* GODT-2328: Ignore labels that aren't part of user label set.
-* GODT-2326: Fix potential Win32 API deadlock.
-* GODT-1804: Only promote content headers if non-empty.
-* GODT-2327: Remove unnecessary sync when changing address mode.
-* GODT-2343: Only poll after send if sync is complete.
-* GODT-2336: Recover from changed address order while bridge is down.
-* GODT-2347: Prevent updates from being dropped if goroutine doesn't start fast.
-* GODT-2351: Bump GPA to properly handle net.OpError and add tests.
-* GODT-2351: Bump GPA to automatically retry on net.OpError.
-* GODT-2365: Use predictable remote ID for placeholder mailboxes.
-* GODT-2381: Unset draft flag on sent messages.
-* GODT-2380: Only set external ID in header if non-empty.
-
-
-## [Bridge 3.0.21] Perth Narrows
-
-### Added
-* GODT-2509: Migrate TLS cert from v1/v2 location during upgrade to v3.
-
-### Changed
-* GODT-2516: log error when the vault key cannot be created/loaded from the keychain.
-
-### Fixed
-* GODT-2501: Remove additional .desktop file.
-* GODT-2513: Crash in scanner.
-* GODT-2481: Fix DBUS Secert Service.
-* GODT-2512: Catch unhandled API errors.
-* GODT-2469: Fix sentry revision hash for cmake on windows.
-
-
-## [Bridge 3.0.20] Perth Narrows
-
-### Added
-* GODT-2442: Allow user to re-sync DB without logout.
-
-### Changed
-* GODT-2419: Reduce sentry reports.
-* GODT-2458: Wait for both bridge and bridge-gui to be ended before restarting on crash.
-* GODT-2457: Include address if GetPublickKeys() error message.
-* GODT-2446: Attach logs to sentry reports for relevant bridge-gui exceptions.
-* GODT-2425: Out of sync messages and read status.
-* GODT-2435: Group report exception by message if exception message looks corrupted.
-* GODT-2356: Unify sentry release description and add more context to it.
-* GODT-2357: Hide DSN_SENTRY and use single setting point for DSN_SENTRY.
-* GODT-2444: Bad event info.
-* GODT-2447: Don't assume timestamp exists in log filename.
-* GODT-2333: Do not allow modifications to All Mail label.
-* GODT-2429: Do not report context cancel to sentry.
-
-### Fixed
-* GODT-2467: elide long email adresses in 'bad event' QML notification dialog.
-* GODT-2449: fix bug in Bridge-GUI's Exception::what().
-* GODT-2427: Parsing header issues.
-* GODT-2426: Fix crash on user delete.
-* GODT-2417: Do not request gluon recovered message from API.
-
-
-## [Bridge 3.0.19] Perth Narrows
-
-### Fixed
-* GODT-2364: Wait and retry once if the gRPC service config file exists but cannot be opened.
-* GODT-2364: Added optional details to C++ exceptions.
-* GODT-2413: Use qEnvironmentVariable() instead of qgetenv().
-* GODT-2412: Don't treat context cancellation as BadEvent.
-* GODT-2404: Handle unexpected EOF.
-* GODT-2400: Allow state updates to be applied if command fails.
-* GODT-2399: Fix immediate message deletion during updates.
-* GODT-2390: Missing changes from pervious commit.
-* GODT-2390: Add reports for uncaught json and net.opErr.
-* GODT-2414: Multiple deletion bug in WriteControlledStore.
-
-
-## [Bridge 3.0.18] Perth Narrows
-
-### Fixed
-* GODT-2392: Create message if gluon updateMessage returns `no such message`.
-* GODT-2391: Create draft if missing during message update on gluon side.
-
-## [Bridge 3.0.16/17] Perth Narrows
-
-### Fixed
-* GODT-2371: Continue, not return, when handling draft.
-
-## [Bridge 3.0.15] Perth Narrows
-
-### Changed
-* GODT-2355: Improve wording and actions on bad event.
-
-### Fixed
-* GODT-2354: Report failed load users.
-* GODT-2353: Show popup only after 3.0.16.
-* GODT-2351: Bump GPA to better handle net.OpError.
-
-
-## [Bridge 3.0.14] Perth Narrows
-
-### Fixed
-* GODT-2323: Fix Expunge not issued for move.
-* GODT-2341: Handle URL error.
-* GODT-2340: Improve logging.
-* GODT-2278: Improve sentry logs.
-* GODT-2327: Sync issues when migrating DB.
-* GODT-2318: Remove gluon DB if label sync was incomplete.
-* GODT-1804: Only promote content headers if non-empty.
-* GODT-2343: Only poll after send if sync is complete.
-* GODT-2336: Recover from changed address order while bridge is down.
-
-
-
-## [Bridge 3.0.13] Perth Narrows
-
-### Fixed
-GODT-2328: Ignore labels that aren't part of user label set.
-GODT-2326: Sync issue on missing fresh DB file.
-GODT-2319: Seed the math/rand RNG on app startup.
-GODT-1804: Preserve MIME parameters when uploading attachments.
-
-
-## [Bridge 3.0.12] Perth Narrows
-
-### Added
-* GODT-2210: v3.0 splash screen.
-* GODT-1770: handle UserBadEvent in CLI and gRPC.
-
-### Changed
-* GODT-2311: Fix missing headers in re-downloaded Gluon messages.
-* GODT-1453: clicking 'Sign in' from status window now selects the right account.
-* GODT-2297: More significantly improve GPA's paging algorithm.
-* GODT-2145: Fix button spacing w/ Qt 6.4.
-* GODT-2223: Improve event handling.
-* GODT-2305: Detect missing gluon DB.
-* GODT-2291: Change gluon store default location from Cache to Data.
-* Other: Disable dialer test until badssl cert is bumbed.
-* GODT-2292: Updated BUILDS.md doc.
-* GODT-2258: suggest email as login when signing in via status window.
-* Other: Report corrupt and/or insecure vaults to sentry.
-* Other: Better user load logs.
-* GODT-2253: Restart Launcher from the gui when GUI crashes.
-* Other(test): Make All Mail copy test more robust.
-* Other(CI): Make race checks manual.
-* Other: Remove old cert/key file location handling.
-* GODT-2271: Update README with new system files path.
-
-### Fixed
-* GODT-2210: Fix splash screen always showing on CentOS and Ubuntu.
-* GODT-2296: Log error rather than fail if cannot get parent ID.
-* GODT-2266: Pause event stream while sending.
-* GODT-2266: Add test for sent message flags.
-* Other(test): Fix some more integration test placeholders.
-* GODT-2177: Use correct attachment disposition when content ID is set.
-* GODT-1556: If no references, use the in-reply-to header as ParentID.
-* Other: make GUI Tester more resilient to Bridge abrupt termination.
-* GODT-2275: fixed location of bridge-gui log files.
-* Other: Ensure SMTP debug dump works on windows.
-* Other: Fix MaxLogs off-by-one limit and bump limit to 10.
-* Other: fix path of temp folder in README.
-* Other(debug): Dump raw SMTP input to user's home dir.
-
-
-## [Bridge 3.0.11] Perth Narrows
-
-### Changed
-* GODT-2252: Recover from deleted cached messages.
-* GODT-2258: change login label and suggest email instead of username.
-* Other: Don't clean settings path on teardown.
-* Other: Bump GPA to v0.3.0.
-* Other: added user's primary email address to the vault.
-* GODT-2251: gluon store and DB separated.
-* GODT-2093: use the primary email address in the account view and status view.
-* GODT-2202: Report update errors from Gluon.
-* GODT-2229: Own the full path for gluon and do not change Database path.
-* GODT-1797: copyright notice shows a date range with the build year.
-
-### Fixed
-* GODT-2223: Handle bad events by logging user out.
-* GODT-2165: Reduce UTF8 parsing errors from TLS header input.
-* Others: chores fix a QML warning when no account is present* and a few typos in QML.
-* Other(test): Fix integration test steps.
-* GODT-2226: Fix moving drafts to trash.
-* GODT-2246: do not report API error 422 when using an invalid email address.
-
-
-## [Bridge 3.0.10] Perth Narrows
-
-### Changed
-* GODT-2205: use lock file in bridge-gui to detect orphan bridge.
-* GODT-2242: Bump GPA - Don't send any 2fa information if not needed.
-* GODT-2179: added handler for exceptions in QML backend methods.
-* GODT-2181: Match live API behaviour.
-* GODT-2221: Set DOH off by default.
-* GODT-1817: Re-enable all integration tests.
-* Other: C++ Code reformat.
-* GODT-2234: added command-line switch to force Qt to use software rendering for QML.
-* Other: added C/C++ header template file (*.h.in) type to missing_license.sh script.
-* GODT-2236: add log entry when SMTP / IMAP serve method fails.
-* Other: reorganised QMLBackend class code.
-
-### Fixed
-* Other: Flag messages imported into "Sent" mailbox as Sent.
-* Other: Fix testCtx.getMBoxID().
-* Other: Fixed GUI Tester to comply with latest gRPC changes.
-* GODT-2010: add Cocoa app delegate handler for second application instance.
-* Other: Fix double close on event channels.
-* GODT-2233: Fix sub folder creation bug.
-* GODT-2222: Dot not error on unknown Address Events.
-* GODT-2218: Fix invalid UID ranges.
-
-
-## [Bridge 3.0.9] Perth Narrows
-
-### Changed
-* GODT-2181(test): Refactor integration test setup a bit.
-* Other: Updated GUI tester for new gRPC calls.
-* GODT-1847: Add option to export TLS Certificates in GUI.
-
-### Fixed
-* Other: Fix TOTP login (bump go-proton-api).
-* GODT-2188: Do not fail append with invalid mime-type.
-* GODT-2213: Don't unnecessarily enable/disable autostart.
-* Other: Do not decode message body during send record hashing.
-* GODT-2196: Do not generate message updates for unknown labels.
-* Other: Prevent double login.
-* Other: Improve migration logging prefers username over primary address.
-* Other(test): Prefer native API revoke rather than fake server method.
-* GODT-2190: Unify crashpad_handler for darwin.
-* Other(test): Add test that we skip and report bad messages during sync.
-* Other: Catalina build.
-* GODT-2042: Fix setup guide not always showing on first login.
-* GODT-2152: Sign-in dialog validate email and password only when button is pressed.
-* GODT-1556: Add unit test for in-reply-to header without references.
-* GODT-2150: Fixed initial implementation that filtered --no-window in gui instead of bridge.
-* GODT-2167: Bind sign-in buttons availability to loading state.
-* Other: Only send to necessary update channel.
-* GODT-1804: Add parsing ics attachment test.
-* Other: Fix Warning introduced by connecting check timer.
-
-
-## [Bridge 3.0.8] Perth Narrows
-
-### Fixed
-* Other: Add sentry reports for event processing failures.
-* Other: Do not fail on label events.
-
-
-## [Bridge 3.0.7] Perth Narrows
-
-### Fixed
-* Other: Increase default UIDVALIDITY.
-* GODT-2173: fix: Migrate Bridge passwords from v2.X.
-* GODT-2207: Fix encoding of non utf7 mailbox names.
-* Other: Increase worker count (2 -> 4).
-
-
-## [Bridge 3.0.6] Perth Narrows
-
-### Fixed
-* GODT-2187: Skip messages during sync that fail to build/parse.
-
-
-## [Bridge 3.0.5] Perth Narrows
-
-### Fixed
-* GODT-2178: Bump go-proton-api to fix drafts.
-* GODT-2180: Allow login with FIDO2.
-
-
-## [Bridge 3.0.4] Perth Narrows
-
-### Changed
-* Other: Do not list \Deleted flag for All Mail.
-* Other: Disable perma-delete for expunge on Spam folder.
-
-### Fixed
-* Other: Ensure expunge feature test pushes to error stack.
-* GODT-2170: Use client-side draft update in integration tests.
-* GODT-2170: Improving test server behaviour.
-* GODT-2170: Update draft event means delete old and create new message.
-* GODT-2170: User create draft route: first steps.
-
-
-## [Bridge 3.0.3] Perth Narrows
-
-### Fixed
-* GPA v0.1.4: fix token expiration mechanism.
-
-## [Bridge 3.0.2] Perth Narrows
-
-### Changed
-* GODT-2157: Add Sentry to Bridge-Gui.
-* GODT-2153: Use file socket for bridge gRPC on linux & macOS.
-* GODT-2150: Do not forward --no-window flag.
-* GODT-2154: Allow noninteractive mode from launcher.
-* Other: update gui tester to support latest changes in gRPC implementation.
-* Other: GUI Tester supports the 3 states of user (Signed out/Locked/Connected).
-* Other: Bump gluon version to drop non-UTF-8 commands.
-
-### Fixed
-* Other: Wipe vault properly on factory reset.
-* GODT-2160: Prevent double closing of bridge if restart fails.
-* GODT-2041: Crash after factory reset.
-* GODT-2114: Sanitize attachment disposition.
-* GODT-1910: Fix GUI not being notified of SMTP SSL being turned on by ConfigureAppleMail.
-* GODT-1910: Fix save button state not being updated after being clicked once.
-* GODT-2159: Improve 429 retry.
-* GODT-1989: Handle Move with Append and Expunge.
-* Other: SetMailServerSettings is async as it should.
-* Other: Include sentry dll for Windows deploy.
-* Other: Ensure context is string in sentry reports.
-* GODT-2160: Ensure we can safely move cache file.
-
-
-## [Bridge 3.0.1] Perth Narrows
-
-### Changed
-* GODT-2151: Sync backwards to please product people.
-
-### Fixed
-* GODT-2149: Sort logs by timestamp when clearing.
-* GODT-2137: Set sentry sync transport.
-
-## [Bridge 3.0.0] Perth Narrows
-
-### Changed
-* Other(chore): Bump major version to v3.
-* Other: Switch from liteapi to go-proton-api.
-* GODT-2085: Ensure minimum sync worker count.
-* Other: Switch to mail-api.proton.me.
-* GODT-2120: Encrypt gluon store with gzip.
-* GODT-1910: Use a single view for IMAP & SMTP SSL options.
-* GODT-1846: Remove restart cues* implement restart-less behaviour. 
-* GODT-1975: Migrate keychain secrets.
-* GODT-1976: Migrate app settings from prefs.json.
-* GODT-2100: Load users in parallel at startup.
-* GODT-2108: Implement C++ Focus gRPC service client in bridge-gui.
-* GODT-2091: Animated "Connecting..." label.
-* GODT-2003: Introduces 3 phases user state (SignedOut/Locked/Connected).
-* GODT-2056: Kill old bridge from v2 lock file.
-* GODT-2086: Changing the wording for signing in.
-* GODT-2070: Implement SASL login for SMTP.
-* Other: Use liteapi instead of pmapi.
-* GODT-1609: Store password as byte array.
-* GODT-1650: Gluon integration.
-* GODT-1779: Remove go-imap.
-
-### Fixed
-* Other: Retry sync after cooldown if it fails.
-* GODT-2142: Also permit split by comma in References header.
-* GODT-2085: Use time.Since* structured logging.
-* GODT-2139: Validate key pass during login.
-* GODT-2111: Fix restart.
-* GODT-2085: Revise sync algorithm.
-* GODT-2134: Fix dock icon on macOS when launched with '--no-window'.
-* GODT-2131: If refresh token is revoked* user gets signed out.
-* GODT-2119: Only show supported label IDs to clients.
-* GODT-2002: Wait for API events to be applied after send.
-* GODT-2105: Ensure ClientVersion is set in bug report request.
-* GODT-2107: Update user list after session revoke.
-* GODT-2040: Bump UID validity when clearing sync status.
-* GODT-2045: Timeouts should be considered network issues.
-* GODT-2122: Handle check for updates failure.
-* GODT-2033: Only set user agent from IMAP ID if not empty.
-* GODT-2110: Force attachment disposition if content ID is missing.
-* GODT-2081: If keychain cannot be loaded do not wipe Vault and use a temp one.
-* GODT-2103: Trigger the version changed event.
-* GODT-2047: Clear last event ID when clearing sync status.
-* GODT-2109: Removed log message "Parent process XXX is still alive".
-* GODT-1913: Pass reporter to gluon* limit restarts* add crash handlers.
-* GODT-2037: Handle and log API refresh event.
-* GODT-2029: Handle deadlock when reordering user addresses.
-* GODT-2021: Remove gluon data when deleting user.
-* GODT-2030: Rework deletion check on expunge.
-* GODT-1977: Fix launcher for v2 to v3 updates.
-* GODT-2048: Add missing special use attributes.
-* GODT-2034: Basic vault migration ability (proof of concept).
-* GODT-1978: Auto-updates from v2 to v3.
-* GODT-1954: Draft message support.
-* GODT-2022: Fix change between address modes.
-* GODT-1993: Use more efficient filtering for message deletion.
-* GODT-2004: Ensure log files don't have color formatting.
-* GODT-2011: Use new app version format.
-* GODT-2010: Add better logging for app focus feature.
-* GODT-2008: Ensure user's addresses are returned in sorted order.
-* GODT-2002: Poll after SMTP send.
-* GODT-1982: Updated gRPC and GUI for disk cache.
-* GODT-1984: Handle permanent message deletion.
-* GODT-1916: Use XDG_DATA_HOME to store persistent data on linux.
-* GODT-1974: Store everything in v3 path.
-* GODT-1986: Handle case where an address has no decryption entities.
-* GODT-1777: Message de-duplication in SMTP and IMAP.
-* GODT-1940: Fix message encryption.
-* GODT-1742: Implement hide All Mail.
-* GODT-1813: Cleanup old go-imap cache files.
-* GODT-1650: Implement Connector.CreateMessage.
-* GODT-1901: Allow to set IMAP SSL from UI.
-* GODT-1816: Connect Gluon Logs to bridge Logs.
-* GODT-1657: Stable sync.
-* GODT-1815: Gluon User management error.
-
-## [Bridge 2.4.8] Osney
-
-### Fixed
-* GODT-2071: Fix --no-window flag that was broken on Windows.
-
-## [Bridge 2.4.7] Osney
-
-### Fixed
-* GODT-2078: Launcher inception.
-* GODT-2039: fix --parent-pid flag is removed from command-line when restarting the application.
-
-## [Bridge 2.4.6] Osney
-
-### Changed
-* GODT-2019: When signing out and a single user is connecte* we do not go back to the welcome screen.
-* GODT-2071: Bridge-gui report error if an orphan bridge is detected.
-* GODT-2046: Bridge-gui log is included in optional archive sent with bug reports.
-* GODT-2039: Bridge monitors bridge-gui via its PID.
-* GODT-2038: Interrupt gRPC initialisation of bridge process terminates.
-* Other: Added timestamp to bridge-gui logs.
-* GODT-2035: Bridge-gui log includes Qt version info.
-* GODT-2031: Updated bridge description.
-
-### Fixed
-* Other: Fix make run-qt target for Darwin.
-
-## [Bridge 2.4.5] Osney
-
-### Changed
-* GODT-2015: Bridge-gui logs to file until gRPC connection is established.
-* GODT-2016: Added more logging of gRPC events at info level.
-* GODT-2013: CLI flag for frontend is required.
-
-### Fixed
-* GODT-2020: Fix xdg_{home,cache}_home variables.
-* GODT-2014: Bridge quit if gRPC client ends stream.
-
-## [Bridge 2.4.4] Osney
-
-### Changed
-* GODT-1751: Switch from protonmail.com to proton.me domain.
-
-### Fixed
-* Other: Fix make run-cli for Darwin.
-* GODT-1645: Fix CI pipeline.
-* GODT-1938: Account details box values wrap.
-* Other: Also install vcpkg ARM64 on Intel mac hosts.
-* Other: Fix minor typo.
-* GODT-1939: removed vertical overshoot when scrolling.
-* GODT-1479: fix 'Open Bridge' button still hovered when status windows opens for Windows.
-* GODT-1519: Move back to account view after sending bug report.
-* Other: fix QML error with Qt 6.4 and a typo.
-
-## [Bridge 2.4.3] Osney
-
-### Changed
-* Other: implemented tokens in bridge-gui-tester.
-* GODT-1853:
-    * Upgrade dependencies (including x/crypto).
-    * Ignore for CVE-2021-33194 false positive + add several try to gobinsec.
-* GODT-1853: Improve pipeline:
-    * Update gobinsec cache.
-    * Test-windows branch manual, MR always.
-    * Build needs test-linux and lint to start and keep vcpkg cache on linux.
-    * Builds manuall except linux-qa.
-* GODT-1893: Bridge-gui sends bridge's log to stdout, stderr.
-* GODT-1932: Frontend is instantiated before bridge.
-* GODT-1929: Changed gRPC wait timeout.
-* Other: gRPC TLS server is generated for every session.
-* GODT-1917: gRPC service should use random port.
-* GODT-1924: gRPC identity validation with tokens.
-* GODT-1344: Notifications for ApiCertError and NoActiveKeyForRecipient.
-* GODT-1941: Update documentation.
-* Other: Update golangci-lint to v1.50.0.
-* GODT-1936: check gRPC server token via interceptors.
-
-
-
-### Fixed
-* GUI issues:
-    * GODT-1894: Fixed typo in alreadyLoggedIn event error message.
-    * GODT-1479: Fix hover on “Open Bridge” in status window on macOS.
-    * GODT-1899: Status window menu now closes when window is dismissed.
-    * GODT-1851: Port field error label now wraps.
-    * GODT-1566: GUI shows error notifications for IMAP/SMTP port errors on startup.
-    * GODT-1926: Clear port error messages when cancelling the dialog.
-    * Other: Fixed cocoa related warnings in bridge-gui on macOS.
-* Build issues:
-    * GODT-1675: Add resrource file to both launcher and bridge-go.
-    * Other: Add WlShellIntegration lib for rpm package.
-    * GODT-1935: Fix resource file generation for both Launcher and Bridge.
-    * GODT-1942: Use `qmake` to find the `QT6DIR`.
-    * Provide launcher for make run-cli target.
-* GODT-1931: Fixed bridge crash when checking for update while offline.
-
-## [Bridge 2.4.0] Osney
-
-### Added
-* GODT-1551: Upgrade to Qt 6:
-    * Change the app architecture.
-    * Drop therecipe/qt dependency.
-    * Update to go1.18.
-    * Update to Qt 6.3.2.
-* GODT-1170 GODT-1675: Native Mac M1 release.
-
-
-## [Bridge 2.3.0] Nihonbashi
-
-### Added
-* GODT-1739: Opt-out All Mail visibility in settings file.
-    * GODT-1794: CLI wording.
-    * GODT-1794: Add confirmation dialog and change wording.
-    * GODT-1741: GUI and CLI settings to change visibility of All Mail folder.
-    * GODT-1740: Opt-out All Mail visibility in settings file.
-
-### Changed
-* GODT-1737: Improve logging during import.
-* GODT-1754: Add logs for unilateral updates and SEARCH.
-
-### Fixed
-* GODT-1840: Use Safe map for mailboxID cache.
-* GODT-1795: Fix automatic installation of profile for AppleMail on macOS Ventura beta (qt 5).
-* GODT-1833: Fix gobinsec cache.
-* GODT-1799: Fix dependency link.
-* Other: Update SSL certificate fingerprint for test.
-
-
-## [Bridge 2.2.2] Millau
-
-### Added
-* Introduced gobinsec cache.
-
-### Fixed
-* GODT-1743: Terminate running bridge if has old version.
-* GODT-1743: Quit bridge when opening manual install.
-
-
 ## [Bridge 2.2.1] Millau

 ### Added
--- a/360
+++ b/360
@ -5,73 +5,55 @@ 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.4.1+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
+    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

@ -81,111 +63,107 @@ else
    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,34 +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 \
-		${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
+	@# 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
@ -266,15 +224,16 @@ bench:
 coverage: test
 	go tool cover -html=/tmp/coverage.out -o=coverage.html

+integration-test-bridge:
+	${MAKE} -C test test-bridge
+
 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/user MessageDownloader > internal/user/mocks/mocks.go
+	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

@ -292,13 +251,6 @@ lint-golang:
 	$(info linting with GOMAXPROCS=${GOMAXPROCS})
 	golangci-lint run ./...

-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
@ -306,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 $^
@ -319,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:
--- a/README.md
+++ b/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`

--- a/cmd/Desktop-Bridge/main.go
+++ b/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")
 	}
 }
--- a/cmd/launcher/main.go
+++ b/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,26 +18,21 @@
 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"
@ -45,197 +40,115 @@ import (

 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"
+	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()
+func getFallbackExecutable(name string, versioner *versioner.Versioner) (string, error) {
+	logrus.Info("Searching for fallback executable")
+
+	launcher, err := os.Executable()
 	if err != nil {
-			logrus.WithError(err).Error("Could not determine running processes")
-			return
+		return "", errors.Wrap(err, "failed to determine path to launcher")
 	}

-		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)
-	if err != nil {
-		logrus.WithError(err).WithField("file", path).Error("Could not retrieve file info")
-		return false
-	}
-
-	return os.SameFile(pathInfo, info)
+	return versioner.GetExecutableInDirectory(name, filepath.Dir(launcher))
 }
--- a/cmd/launcher/main_test.go
+++ b/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"}))
-}
--- a/dist/bridgeMacOS.svg
+++ b/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>
--- a/dist/info.rc
+++ b/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"
--- a/dist/proton-bridge.desktop
+++ b/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
--- a/extern/vcpkg
+++ b/extern/vcpkg
--- a/go.mod
+++ b/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.16.1-0.20230808094407-85a10f17ae92
-	github.com/ProtonMail/go-autostart v0.0.0-20210130080809-00ed301c8e9a
-	github.com/ProtonMail/go-proton-api v0.4.1-0.20230727082922-9115b4750ec7
-	github.com/ProtonMail/gopenpgp/v2 v2.7.1-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-20230518184743-7afd39499903 // 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
 )
--- a/go.sum
+++ b/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.16.1-0.20230808094407-85a10f17ae92 h1:yoaUatxdB6EXChiWdfIBpasJJxrQ6dHJknG0hwBAqmQ=
-github.com/ProtonMail/gluon v0.16.1-0.20230808094407-85a10f17ae92/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-20230322105811-d73448b7e800/go.mod h1:8TI4H3IbrackdNgv+92dI+rhpCaLqM0IfpgCgenFvRE=
-github.com/ProtonMail/go-crypto v0.0.0-20230518184743-7afd39499903 h1:ZK3C5DtzV2nVAQTx5S5jQvMeDqWtD1By5mOoyY/xJek=
-github.com/ProtonMail/go-crypto v0.0.0-20230518184743-7afd39499903/go.mod h1:8TI4H3IbrackdNgv+92dI+rhpCaLqM0IfpgCgenFvRE=
-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.20230727082922-9115b4750ec7 h1:Rmg3TPK6vFGNWR4hxmPoBhV75Sl716iB46wEi2U4Q+c=
-github.com/ProtonMail/go-proton-api v0.4.1-0.20230727082922-9115b4750ec7/go.mod h1:+aTJoYu8bqzGECXL2DOdiZTZ64bGn3w0NC8VcFpJrFM=
-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.1-proton h1:YS6M20yvjCJPR1r4ADW5TPn6rahs4iAyZaACei86bEc=
-github.com/ProtonMail/gopenpgp/v2 v2.7.1-proton/go.mod h1:S1lYsaGHykYpxxh2SnJL6ypcAlANKj5NRSY6HxKryKQ=
-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/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,75 +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.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=
@ -438,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=
@ -453,23 +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.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=
@ -478,71 +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.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.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.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=
@ -553,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=
@ -580,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=
--- a/internal/api/api.go
+++ b/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)
+}
--- a/internal/api/ctx.go
+++ b/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)
+		}
+	}
+}
--- a/internal/api/focus.go
+++ b/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
+}
--- a/internal/app/app.go
+++ b/internal/app/app.go
@ -1,476 +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"
-
-	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:    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(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
-}
--- a/internal/app/base/args.go
+++ b/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
+}
--- a/internal/app/base/base.go
+++ b/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
+}
--- a/internal/app/base/migration.go
+++ b/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)
+}
--- a/internal/app/base/migration_rebranding.go
+++ b/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
+}
--- a/internal/app/base/profiling.go
+++ b/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()
+}
--- a/internal/app/base/restart.go
+++ b/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
+}
--- a/internal/app/base/restart_test.go
+++ b/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))
+		})
+	}
+}
--- a/internal/app/bridge.go
+++ b/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
-}
--- a/internal/app/bridge/bridge.go
+++ b/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
+}
--- a/internal/app/frontend.go
+++ b/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")
-	}
-}
--- a/internal/app/migration.go
+++ b/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()
-}
--- a/internal/app/migration_test.go
+++ b/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))
-}
--- a/internal/app/singleinstance.go
+++ b/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)
-}
--- a/internal/app/testdata/with_keys/protonmail/bridge/cert.pem
+++ b/internal/app/testdata/with_keys/protonmail/bridge/cert.pem
@ -1 +0,0 @@
-----BEGIN CERTIFICATE-----
--- a/internal/app/testdata/with_keys/protonmail/bridge/key.pem
+++ b/internal/app/testdata/with_keys/protonmail/bridge/key.pem
@ -1 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
--- a/internal/app/testdata/with_keys/protonmail/bridge/prefs.json
+++ b/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"
-}
--- a/internal/app/testdata/without_keys/protonmail/bridge/prefs.json
+++ b/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"
-}
--- a/internal/app/vault.go
+++ b/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)
-}
--- a/internal/bridge/api.go
+++ b/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),
-	}
-}
--- a/internal/bridge/api_default.go
+++ b/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
-
-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)
-}
--- a/internal/bridge/api_qa.go
+++ b/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
-
-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
-}
--- a/internal/frontend/grpc/event_utils.go
+++ b/internal/frontend/grpc/event_utils.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()
 }
--- a/internal/bridge/bridge.go
+++ b/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.
 //
@ -15,540 +15,290 @@
 // 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, 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"
-	"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/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/sentry"
-	"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
-
-	// 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.
+	locations     Locator
+	settings      SettingsProvider
+	clientManager pmapi.Manager
 	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.
+	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()
-
-	uidValidityGenerator imap.UIDValidityGenerator
-
-	serverManager *ServerManager
+	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, // 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,
-	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,
+	u := users.New(
+		locations,
+		panicHandler,
+		eventListener,
+		clientManager,
+		credStorer,
+		newStoreFactory(cacheProvider, sentryReporter, panicHandler, eventListener, cache, builder),
+	)

+	b := &Bridge{
+		Users:         u,
+		locations:     locations,
+		settings:      setting,
+		clientManager: clientManager,
 		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,
-
-		uidValidityGenerator: uidValidityGenerator,
-
-		serverManager: newServerManager(),
+		versioner:     versioner,
+		cacheProvider: cacheProvider,
+		autostart:     autostart,
+		isFirstStart:  false,
 	}

-	if err := bridge.serverManager.Init(bridge); err != nil {
-		return nil, err
+	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)

-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()
-	}
-
-	// 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())
-		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)
-		}
-
-		return nil
-	})
-
-	// 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{})
-		})
-	})
-
-	// 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{})
-		})
-	})
-
-	// 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)
-		})
-	})
-
-	// 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
-		}
-
-		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)
-		})
-	})
-
-	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 the servers
-	if err := bridge.serverManager.CloseServers(ctx); err != nil {
-		logrus.WithError(err).Error("Failed to close servers")
-	}
-
-	// Close all users.
-	safe.Lock(func() {
-		for _, user := range bridge.users {
-			user.Close()
-		}
-	}, bridge.usersLock)
-
-	// Stop all ongoing tasks.
-	bridge.tasks.CancelAndWait()
-
-	// 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
-}
-
-func (bridge *Bridge) publish(event events.Event) {
-	bridge.watchersLock.RLock()
-	defer bridge.watchersLock.RUnlock()
-
-	logrus.WithField("event", event).Debug("Publishing event")
-
-	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")
-			}
-		}
-	}
-}
-
-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
-}
-
-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 {
-		return
-	}
-
-	bridge.watchers = append(bridge.watchers[:idx], bridge.watchers[idx+1:]...)
-
-	watcher.Close()
-}
-
-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():
-			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
-	}
-
-	return &tls.Config{
-		Certificates: []tls.Certificate{cert},
-		MinVersion:   tls.VersionTLS12,
-	}, nil
-}
-
-func newListener(port int, useTLS bool, tlsConfig *tls.Config) (net.Listener, error) {
-	if useTLS {
-		tlsListener, err := tls.Listen("tcp", fmt.Sprintf("%v:%v", constants.Host, port), tlsConfig)
-		if err != nil {
-			return nil, err
-		}
-
-		return tlsListener, nil
-	}
-
-	netListener, err := net.Listen("tcp", fmt.Sprintf("%v:%v", constants.Host, port))
-	if err != nil {
-		return nil, err
-	}
-
-	return netListener, nil
-}
-
-func min(a, b time.Duration) time.Duration {
-	if a < b {
-		return a
-	}
+	go b.heartbeat()

 	return b
 }
+
+// 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
+	}
+
+	// If current version is same as upstream stable version - do nothing.
+	if version.Version.Equal(semver.MustParse(constants.Version)) {
+		return nil
+	}
+
+	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")
+		}
+	}
+
+	if err := b.Users.ClearData(); err != nil {
+		log.WithError(err).Error("Failed to remove bridge data")
+	}
+
+	if err := b.Users.ClearUsers(); err != nil {
+		log.WithError(err).Error("Failed to remove bridge users")
+	}
+}
+
+// GetKeychainApp returns current keychain helper.
+func (b *Bridge) GetKeychainApp() string {
+	return b.settings.Get(settings.PreferredKeychainKey)
+}
+
+// SetKeychainApp sets current keychain helper.
+func (b *Bridge) SetKeychainApp(helper string) {
+	b.settings.Set(settings.PreferredKeychainKey, helper)
+}
+
+func (b *Bridge) EnableCache() error {
+	if err := b.Users.EnableCache(); err != nil {
+		return err
+	}
+
+	b.settings.SetBool(settings.CacheEnabledKey, true)
+
+	return nil
+}
+
+func (b *Bridge) DisableCache() error {
+	if err := b.Users.DisableCache(); err != nil {
+		return err
+	}
+
+	b.settings.SetBool(settings.CacheEnabledKey, false)
+	// Reset back to the default location when disabling.
+	b.settings.Set(settings.CacheLocationKey, b.cacheProvider.GetDefaultMessageCacheDir())
+
+	return nil
+}
+
+func (b *Bridge) MigrateCache(from, to string) error {
+	if err := b.Users.MigrateCache(from, to); err != nil {
+		return err
+	}
+
+	b.settings.Set(settings.CacheLocationKey, to)
+
+	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()
+	}
+}
+
+// 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)
+}
+
+// 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
+	}
+
+	b.errors = append(b.errors, err)
+}
+
+// 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
+		}
+	}
+}
+
+// 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 false
+}
+
+// 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
+}
--- a/internal/bridge/bridge_test.go
+++ b/internal/bridge/bridge_test.go
--- a/internal/bridge/bug_report.go
+++ b/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, 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
-
-	if attachLogs {
-		logsPath, err := bridge.locator.ProvideLogsPath()
-		if err != nil {
-			return err
-		}
-
-		buffer, err := logging.ZipLogsForBugReport(logsPath, DefaultMaxSessionCountForBugReport, DefaultMaxBugReportZipSize)
-		if err != nil {
-			return err
-		}
-
-		body, err := io.ReadAll(buffer)
-		if err != nil {
-			return err
-		}
-
-		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{
+	report := pmapi.ReportBugReq{
 		OS:          osType,
 		OSVersion:   osVersion,
-
+		Browser:     emailClient,
 		Title:       "[Bridge] Bug",
 		Description: description,
-
-		Client:        client,
-		ClientType:    proton.ClientTypeEmail,
-		ClientVersion: constants.AppVersion(bridge.curVersion.Original()),
-
-		Username: account,
-		Email:    email,
-	}, attachment...)
+		Username:    accountName,
+		Email:       address,
+	}
+
+	if attachLogs {
+		logs, err := b.getMatchingLogs(
+			func(filename string) bool {
+				return logging.MatchLogName(filename) && !logging.MatchStackTraceName(filename)
+			},
+		)
+		if err != nil {
+			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")
+		}
+
+		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 {
+			log.WithError(err).Error("Can't zip logs and crashes")
+		}
+
+		if archive != nil {
+			report.AddAttachment("logs.zip", "application/zip", archive)
+		}
+	}
+
+	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
 }
--- a/internal/bridge/config_status.go
+++ b/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)
-}
--- a/internal/bridge/configure.go
+++ b/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)
-}
--- a/internal/logging/sensitive_sensitive.go
+++ b/internal/logging/sensitive_sensitive.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"
+)
--- a/internal/bridge/debug.go
+++ b/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(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
-}
--- a/internal/bridge/draft_test.go
+++ b/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())
-}
--- a/internal/bridge/errors.go
+++ b/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")
-)
--- a/internal/bridge/files.go
+++ b/internal/bridge/files.go
@ -1,134 +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 (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-func moveDir(from, to string) error {
-	entries, err := os.ReadDir(from)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range entries {
-		if entry.IsDir() {
-			if err := os.Mkdir(filepath.Join(to, entry.Name()), 0o700); err != nil {
-				return err
-			}
-
-			if err := moveDir(filepath.Join(from, entry.Name()), filepath.Join(to, entry.Name())); err != nil {
-				return err
-			}
-
-			if err := os.RemoveAll(filepath.Join(from, entry.Name())); err != nil {
-				return err
-			}
-		} else {
-			if err := moveFile(filepath.Join(from, entry.Name()), filepath.Join(to, entry.Name())); err != nil {
-				return err
-			}
-		}
-	}
-
-	return os.Remove(from)
-}
-
-func moveFile(from, to string) error {
-	if err := os.MkdirAll(filepath.Dir(to), 0o700); err != nil {
-		return err
-	}
-
-	return os.Rename(from, to)
-}
-
-func copyDir(from, to string) error {
-	entries, err := os.ReadDir(from)
-	if err != nil {
-		return err
-	}
-	if err := createIfNotExists(to, 0o700); err != nil {
-		return err
-	}
-	for _, entry := range entries {
-		sourcePath := filepath.Join(from, entry.Name())
-		destPath := filepath.Join(to, entry.Name())
-
-		if entry.IsDir() {
-			if err := copyDir(sourcePath, destPath); err != nil {
-				return err
-			}
-		} else {
-			if err := copyFile(sourcePath, destPath); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func copyFile(srcFile, dstFile string) error {
-	out, err := os.Create(filepath.Clean(dstFile))
-	defer func(out *os.File) {
-		_ = out.Close()
-	}(out)
-
-	if err != nil {
-		return err
-	}
-
-	in, err := os.Open(filepath.Clean(srcFile))
-	defer func(in *os.File) {
-		_ = in.Close()
-	}(in)
-
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(out, in)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func exists(filePath string) bool {
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
-		return false
-	}
-
-	return true
-}
-
-func createIfNotExists(dir string, perm os.FileMode) error {
-	if exists(dir) {
-		return nil
-	}
-
-	if err := os.MkdirAll(dir, perm); err != nil {
-		return fmt.Errorf("failed to create directory: '%s', error: '%s'", dir, err.Error())
-	}
-
-	return nil
-}
--- a/internal/bridge/files_test.go
+++ b/internal/bridge/files_test.go
@ -1,73 +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 (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestMoveDir(t *testing.T) {
-	from, to := t.TempDir(), t.TempDir()
-
-	// Create some files in from.
-	if err := os.WriteFile(filepath.Join(from, "a"), []byte("a"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(from, "b"), []byte("b"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Mkdir(filepath.Join(from, "c"), 0o700); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(from, "c", "d"), []byte("d"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	// Move the files.
-	if err := moveDir(from, to); err != nil {
-		t.Fatal(err)
-	}
-
-	// Check that the files were moved.
-	if _, err := os.Stat(filepath.Join(from, "a")); !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(to, "a")); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(from, "b")); !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(to, "b")); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(from, "c")); !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(to, "c")); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(from, "c", "d")); !os.IsNotExist(err) {
-		t.Fatal(err)
-	}
-	if _, err := os.Stat(filepath.Join(to, "c", "d")); err != nil {
-		t.Fatal(err)
-	}
-}
--- a/internal/bridge/heartbeat.go
+++ b/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)
-}
--- a/internal/bridge/identifier.go
+++ b/internal/bridge/identifier.go
@ -1,42 +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")
-		}
-	}
-}
--- a/internal/bridge/imap.go
+++ b/internal/bridge/imap.go
@ -1,199 +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"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon"
-	"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/store"
-	"github.com/ProtonMail/gluon/store/fallback_v0"
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"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)
-}
-
-// addIMAPUser connects the given user to gluon.
-func (bridge *Bridge) addIMAPUser(ctx context.Context, user *user.User) error {
-	return bridge.serverManager.AddIMAPUser(ctx, user)
-}
-
-// removeIMAPUser disconnects the given user from gluon, optionally also removing its files.
-func (bridge *Bridge) removeIMAPUser(ctx context.Context, user *user.User, withData bool) error {
-	return bridge.serverManager.RemoveIMAPUser(ctx, user, withData)
-}
-
-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)
-		}
-	}
-}
-
-func ApplyGluonCachePathSuffix(basePath string) string {
-	return filepath.Join(basePath, "backend", "store")
-}
-
-func ApplyGluonConfigPathSuffix(basePath string) string {
-	return filepath.Join(basePath, "backend", "db")
-}
-
-func newIMAPServer(
-	gluonCacheDir, gluonConfigDir string,
-	version *semver.Version,
-	tlsConfig *tls.Config,
-	reporter reporter.Reporter,
-	logClient, logServer bool,
-	eventCh chan<- imapEvents.Event,
-	tasks *async.Group,
-	uidValidityGenerator imap.UIDValidityGenerator,
-	panicHandler async.PanicHandler,
-) (*gluon.Server, error) {
-	gluonCacheDir = ApplyGluonCachePathSuffix(gluonCacheDir)
-	gluonConfigDir = ApplyGluonConfigPathSuffix(gluonConfigDir)
-
-	logrus.WithFields(logrus.Fields{
-		"gluonStore": gluonCacheDir,
-		"gluonDB":    gluonConfigDir,
-		"version":    version,
-		"logClient":  logClient,
-		"logServer":  logServer,
-	}).Info("Creating IMAP server")
-
-	if logClient || logServer {
-		log := logrus.WithField("protocol", "IMAP")
-		log.Warning("================================================")
-		log.Warning("THIS LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
-		log.Warning("================================================")
-	}
-
-	var imapClientLog io.Writer
-
-	if logClient {
-		imapClientLog = logging.NewIMAPLogger()
-	} else {
-		imapClientLog = io.Discard
-	}
-
-	var imapServerLog io.Writer
-
-	if logServer {
-		imapServerLog = logging.NewIMAPLogger()
-	} else {
-		imapServerLog = io.Discard
-	}
-
-	imapServer, err := gluon.New(
-		gluon.WithTLS(tlsConfig),
-		gluon.WithDataDir(gluonCacheDir),
-		gluon.WithDatabaseDir(gluonConfigDir),
-		gluon.WithStoreBuilder(new(storeBuilder)),
-		gluon.WithLogger(imapClientLog, imapServerLog),
-		getGluonVersionInfo(version),
-		gluon.WithReporter(reporter),
-		gluon.WithUIDValidityGenerator(uidValidityGenerator),
-		gluon.WithPanicHandler(panicHandler),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	tasks.Once(func(ctx context.Context) {
-		async.ForwardContext(ctx, eventCh, imapServer.AddWatcher())
-	})
-
-	tasks.Once(func(ctx context.Context) {
-		async.RangeContext(ctx, imapServer.GetErrorCh(), func(err error) {
-			logrus.WithError(err).Error("IMAP server error")
-		})
-	})
-
-	return imapServer, nil
-}
-
-func getGluonVersionInfo(version *semver.Version) gluon.Option {
-	return gluon.WithVersionInfo(
-		int(version.Major()),
-		int(version.Minor()),
-		int(version.Patch()),
-		constants.FullAppName,
-		"TODO",
-		"TODO",
-	)
-}
-
-type storeBuilder struct{}
-
-func (*storeBuilder) New(path, userID string, passphrase []byte) (store.Store, error) {
-	return store.NewOnDiskStore(
-		filepath.Join(path, userID),
-		passphrase,
-		store.WithFallback(fallback_v0.NewOnDiskStoreV0WithCompressor(&fallback_v0.GZipCompressor{})),
-	)
-}
-
-func (*storeBuilder) Delete(path, userID string) error {
-	return os.RemoveAll(filepath.Join(path, userID))
-}
--- a/internal/bridge/locations.go
+++ b/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()
-}
--- a/internal/bridge/main_test.go
+++ b/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())
-}
--- a/internal/bridge/migration.go
+++ b/internal/bridge/migration.go
@ -1,55 +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 (
-	"strings"
-
-	"github.com/ProtonMail/gluon/reporter"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) databaseResyncNeeded() bool {
-	if strings.HasPrefix(bridge.lastVersion.String(), "3.4.0") &&
-		strings.HasPrefix(bridge.curVersion.String(), "3.4.1") {
-		logrus.WithFields(logrus.Fields{
-			"lastVersion": bridge.lastVersion.String(),
-			"currVersion": bridge.curVersion.String(),
-		}).Warning("Database re-synchronisation needed")
-		return true
-	}
-	return false
-}
-
-func (bridge *Bridge) migrateUser(vault *vault.User) {
-	if bridge.databaseResyncNeeded() {
-		if err := bridge.reporter.ReportMessage("Database need to be re-sync for migration."); err != nil {
-			logrus.WithError(err).Error("Failed to report database re-sync for migration.")
-		}
-		if err := vault.ClearSyncStatus(); err != nil {
-			logrus.WithError(err).Error("Failed reset to SyncStatus.")
-			if err2 := bridge.reporter.ReportMessageWithContext("Failed to reset SyncStatus for Database migration.",
-				reporter.Context{
-					"error": err,
-				}); err2 != nil {
-				logrus.WithError(err2).Error("Failed to report reset SyncStatus error.")
-			}
-		}
-	}
-}
--- a/internal/bridge/mocks.go
+++ b/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
-}
--- a/internal/bridge/mocks/async_mocks.go
+++ b/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)
-}
--- a/internal/bridge/mocks/gluon_mocks.go
+++ b/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)
-}
--- a/internal/bridge/mocks/matcher.go
+++ b/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"
-}
--- a/internal/bridge/mocks/mocks.go
+++ b/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))
-}
--- a/internal/bridge/mocks/telemetry_mocks.go
+++ b/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)
-}
--- a/internal/bridge/refresh_test.go
+++ b/internal/bridge/refresh_test.go
@ -1,113 +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()
-
-			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])
-			}
-		})
-	})
-}
--- a/internal/frontend/bridge-gui/bridge-gui/LogUtils.h
+++ b/internal/frontend/bridge-gui/bridge-gui/LogUtils.h
@ -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
+`
--- a/internal/bridge/send_test.go
+++ b/internal/bridge/send_test.go
@ -1,520 +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)
-				require.Equal(t, 4, len(messages))
-
-				// 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)
-		})
-	})
-}
--- a/internal/bridge/sentry_test.go
+++ b/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")
-		})
-	})
-}
--- a/internal/bridge/server_manager.go
+++ b/internal/bridge/server_manager.go
@ -1,696 +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"
-	"net"
-	"path/filepath"
-
-	"github.com/ProtonMail/gluon"
-	"github.com/ProtonMail/gluon/connector"
-	"github.com/ProtonMail/gluon/logging"
-	"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/ProtonMail/proton-bridge/v3/pkg/cpc"
-	"github.com/emersion/go-smtp"
-	"github.com/sirupsen/logrus"
-)
-
-// ServerManager manages the IMAP & SMTP servers and their listeners.
-type ServerManager struct {
-	requests *cpc.CPC
-
-	imapServer   *gluon.Server
-	imapListener net.Listener
-
-	smtpServer   *smtp.Server
-	smtpListener net.Listener
-
-	loadedUserCount int
-}
-
-func newServerManager() *ServerManager {
-	return &ServerManager{
-		requests: cpc.NewCPC(),
-	}
-}
-
-func (sm *ServerManager) Init(bridge *Bridge) error {
-	imapServer, err := createIMAPServer(bridge)
-	if err != nil {
-		return err
-	}
-
-	smtpServer := createSMTPServer(bridge)
-
-	sm.imapServer = imapServer
-	sm.smtpServer = smtpServer
-
-	bridge.tasks.Once(func(ctx context.Context) {
-		logging.DoAnnotated(ctx, func(ctx context.Context) {
-			sm.run(ctx, bridge)
-		}, logging.Labels{
-			"service": "server-manager",
-		})
-	})
-
-	return nil
-}
-
-func (sm *ServerManager) CloseServers(ctx context.Context) error {
-	defer sm.requests.Close()
-	_, err := sm.requests.Send(ctx, &smRequestClose{})
-
-	return err
-}
-
-func (sm *ServerManager) RestartIMAP(ctx context.Context) error {
-	_, err := sm.requests.Send(ctx, &smRequestRestartIMAP{})
-
-	return err
-}
-
-func (sm *ServerManager) RestartSMTP(ctx context.Context) error {
-	_, err := sm.requests.Send(ctx, &smRequestRestartSMTP{})
-
-	return err
-}
-
-func (sm *ServerManager) AddIMAPUser(ctx context.Context, user *user.User) error {
-	_, err := sm.requests.Send(ctx, &smRequestAddIMAPUser{user: user})
-
-	return err
-}
-
-func (sm *ServerManager) RemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
-	_, err := sm.requests.Send(ctx, &smRequestRemoveIMAPUser{
-		user:     user,
-		withData: withData,
-	})
-
-	return err
-}
-
-func (sm *ServerManager) SetGluonDir(ctx context.Context, gluonDir string) error {
-	_, err := sm.requests.Send(ctx, &smRequestSetGluonDir{
-		dir: gluonDir,
-	})
-
-	return err
-}
-
-func (sm *ServerManager) AddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
-	reply, err := cpc.SendTyped[string](ctx, sm.requests, &smRequestAddGluonUser{
-		conn:       conn,
-		passphrase: passphrase,
-	})
-
-	return reply, err
-}
-
-func (sm *ServerManager) RemoveGluonUser(ctx context.Context, gluonID string) error {
-	_, err := sm.requests.Send(ctx, &smRequestRemoveGluonUser{
-		userID: gluonID,
-	})
-
-	return err
-}
-
-func (sm *ServerManager) run(ctx context.Context, bridge *Bridge) {
-	eventCh, cancel := bridge.GetEvents()
-	defer cancel()
-
-	for {
-		select {
-		case <-ctx.Done():
-			sm.handleClose(ctx, bridge)
-			return
-
-		case evt := <-eventCh:
-			switch evt.(type) {
-			case events.ConnStatusDown:
-				logrus.Info("Server Manager, network down stopping listeners")
-				if err := sm.closeSMTPServer(bridge); err != nil {
-					logrus.WithError(err).Error("Failed to close SMTP server")
-				}
-
-				if err := sm.stopIMAPListener(bridge); err != nil {
-					logrus.WithError(err)
-				}
-			case events.ConnStatusUp:
-				logrus.Info("Server Manager, network up starting listeners")
-				sm.handleLoadedUserCountChange(ctx, bridge)
-			}
-
-		case request, ok := <-sm.requests.ReceiveCh():
-			if !ok {
-				return
-			}
-
-			switch r := request.Value().(type) {
-			case *smRequestClose:
-				sm.handleClose(ctx, bridge)
-				request.Reply(ctx, nil, nil)
-				return
-
-			case *smRequestRestartSMTP:
-				err := sm.restartSMTP(bridge)
-				request.Reply(ctx, nil, err)
-
-			case *smRequestRestartIMAP:
-				err := sm.restartIMAP(ctx, bridge)
-				request.Reply(ctx, nil, err)
-
-			case *smRequestAddIMAPUser:
-				err := sm.handleAddIMAPUser(ctx, r.user)
-				request.Reply(ctx, nil, err)
-				if err == nil {
-					sm.loadedUserCount++
-					sm.handleLoadedUserCountChange(ctx, bridge)
-				}
-
-			case *smRequestRemoveIMAPUser:
-				err := sm.handleRemoveIMAPUser(ctx, r.user, r.withData)
-				request.Reply(ctx, nil, err)
-				if err == nil {
-					sm.loadedUserCount--
-					sm.handleLoadedUserCountChange(ctx, bridge)
-				}
-
-			case *smRequestSetGluonDir:
-				err := sm.handleSetGluonDir(ctx, bridge, r.dir)
-				request.Reply(ctx, nil, err)
-
-			case *smRequestAddGluonUser:
-				id, err := sm.handleAddGluonUser(ctx, r.conn, r.passphrase)
-				request.Reply(ctx, id, err)
-
-			case *smRequestRemoveGluonUser:
-				err := sm.handleRemoveGluonUser(ctx, r.userID)
-				request.Reply(ctx, nil, err)
-			}
-		}
-	}
-}
-
-func (sm *ServerManager) handleLoadedUserCountChange(ctx context.Context, bridge *Bridge) {
-	logrus.Infof("Validating Listener State %v", sm.loadedUserCount)
-	if sm.shouldStartServers() {
-		if sm.imapListener == nil {
-			if err := sm.serveIMAP(ctx, bridge); err != nil {
-				logrus.WithError(err).Error("Failed to start IMAP server")
-			}
-		}
-
-		if sm.smtpListener == nil {
-			if err := sm.restartSMTP(bridge); err != nil {
-				logrus.WithError(err).Error("Failed to start SMTP server")
-			}
-		}
-	} else {
-		if sm.imapListener != nil {
-			if err := sm.stopIMAPListener(bridge); err != nil {
-				logrus.WithError(err).Error("Failed to stop IMAP server")
-			}
-		}
-
-		if sm.smtpListener != nil {
-			if err := sm.closeSMTPServer(bridge); err != nil {
-				logrus.WithError(err).Error("Failed to stop SMTP server")
-			}
-		}
-	}
-}
-
-func (sm *ServerManager) handleClose(ctx context.Context, bridge *Bridge) {
-	// Close the IMAP server.
-	if err := sm.closeIMAPServer(ctx, bridge); err != nil {
-		logrus.WithError(err).Error("Failed to close IMAP server")
-	}
-
-	// Close the SMTP server.
-	if err := sm.closeSMTPServer(bridge); err != nil {
-		logrus.WithError(err).Error("Failed to close SMTP server")
-	}
-}
-
-func (sm *ServerManager) handleAddIMAPUser(ctx context.Context, user *user.User) error {
-	if sm.imapServer == nil {
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	imapConn, err := user.NewIMAPConnectors()
-	if err != nil {
-		return fmt.Errorf("failed to create IMAP connectors: %w", err)
-	}
-
-	for addrID, imapConn := range imapConn {
-		log := logrus.WithFields(logrus.Fields{
-			"userID": user.ID(),
-			"addrID": addrID,
-		})
-
-		if gluonID, ok := user.GetGluonID(addrID); ok {
-			log.WithField("gluonID", gluonID).Info("Loading existing IMAP user")
-
-			// Load the user, checking whether the DB was newly created.
-			isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey())
-			if err != nil {
-				return fmt.Errorf("failed to load IMAP user: %w", err)
-			}
-
-			if isNew {
-				// If the DB was newly created, clear the sync status; gluon's DB was not found.
-				logrus.Warn("IMAP user DB was newly created, clearing sync status")
-
-				// Remove the user from IMAP so we can clear the sync status.
-				if err := sm.imapServer.RemoveUser(ctx, gluonID, false); err != nil {
-					return fmt.Errorf("failed to remove IMAP user: %w", err)
-				}
-
-				// Clear the sync status -- we need to resync all messages.
-				if err := user.ClearSyncStatus(); err != nil {
-					return fmt.Errorf("failed to clear sync status: %w", err)
-				}
-
-				// Add the user back to the IMAP server.
-				if isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey()); err != nil {
-					return fmt.Errorf("failed to add IMAP user: %w", err)
-				} else if isNew {
-					panic("IMAP user should already have a database")
-				}
-			} else if status := user.GetSyncStatus(); !status.HasLabels {
-				// Otherwise, the DB already exists -- if the labels are not yet synced, we need to re-create the DB.
-				if err := sm.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
-					return fmt.Errorf("failed to remove old IMAP user: %w", err)
-				}
-
-				if err := user.RemoveGluonID(addrID, gluonID); err != nil {
-					return fmt.Errorf("failed to remove old IMAP user ID: %w", err)
-				}
-
-				gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
-				if err != nil {
-					return fmt.Errorf("failed to add IMAP user: %w", err)
-				}
-
-				if err := user.SetGluonID(addrID, gluonID); err != nil {
-					return fmt.Errorf("failed to set IMAP user ID: %w", err)
-				}
-
-				log.WithField("gluonID", gluonID).Info("Re-created IMAP user")
-			}
-		} else {
-			log.Info("Creating new IMAP user")
-
-			gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
-			if err != nil {
-				return fmt.Errorf("failed to add IMAP user: %w", err)
-			}
-
-			if err := user.SetGluonID(addrID, gluonID); err != nil {
-				return fmt.Errorf("failed to set IMAP user ID: %w", err)
-			}
-
-			log.WithField("gluonID", gluonID).Info("Created new IMAP user")
-		}
-	}
-
-	// Trigger a sync for the user, if needed.
-	user.TriggerSync()
-
-	return nil
-}
-
-func (sm *ServerManager) handleRemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
-	if sm.imapServer == nil {
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	logrus.WithFields(logrus.Fields{
-		"userID":   user.ID(),
-		"withData": withData,
-	}).Debug("Removing IMAP user")
-
-	for addrID, gluonID := range user.GetGluonIDs() {
-		if err := sm.imapServer.RemoveUser(ctx, gluonID, withData); err != nil {
-			return fmt.Errorf("failed to remove IMAP user: %w", err)
-		}
-
-		if withData {
-			if err := user.RemoveGluonID(addrID, gluonID); err != nil {
-				return fmt.Errorf("failed to remove IMAP user ID: %w", err)
-			}
-		}
-	}
-
-	return nil
-}
-
-func createIMAPServer(bridge *Bridge) (*gluon.Server, error) {
-	gluonDataDir, err := bridge.GetGluonDataDir()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get Gluon Database directory: %w", err)
-	}
-
-	return newIMAPServer(
-		bridge.vault.GetGluonCacheDir(),
-		gluonDataDir,
-		bridge.curVersion,
-		bridge.tlsConfig,
-		bridge.reporter,
-		bridge.logIMAPClient,
-		bridge.logIMAPServer,
-		bridge.imapEventCh,
-		bridge.tasks,
-		bridge.uidValidityGenerator,
-		bridge.panicHandler,
-	)
-}
-
-func createSMTPServer(bridge *Bridge) *smtp.Server {
-	return newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
-}
-
-func (sm *ServerManager) closeSMTPServer(bridge *Bridge) error {
-	// We close the listener ourselves even though it's also closed by smtpServer.Close().
-	// This is because smtpServer.Serve() is called in a separate goroutine and might be executed
-	// after we've already closed the server. However, go-smtp has a bug; it blocks on the listener
-	// even after the server has been closed. So we close the listener ourselves to unblock it.
-
-	if sm.smtpListener != nil {
-		logrus.Info("Closing SMTP Listener")
-		if err := sm.smtpListener.Close(); err != nil {
-			return fmt.Errorf("failed to close SMTP listener: %w", err)
-		}
-
-		sm.smtpListener = nil
-	}
-
-	if sm.smtpServer != nil {
-		logrus.Info("Closing SMTP server")
-		if err := sm.smtpServer.Close(); err != nil {
-			logrus.WithError(err).Debug("Failed to close SMTP server (expected -- we close the listener ourselves)")
-		}
-
-		sm.smtpServer = nil
-
-		bridge.publish(events.SMTPServerStopped{})
-	}
-
-	return nil
-}
-
-func (sm *ServerManager) closeIMAPServer(ctx context.Context, bridge *Bridge) error {
-	if sm.imapListener != nil {
-		logrus.Info("Closing IMAP Listener")
-
-		if err := sm.imapListener.Close(); err != nil {
-			return fmt.Errorf("failed to close IMAP listener: %w", err)
-		}
-
-		sm.imapListener = nil
-
-		bridge.publish(events.IMAPServerStopped{})
-	}
-
-	if sm.imapServer != nil {
-		logrus.Info("Closing IMAP server")
-		if err := sm.imapServer.Close(ctx); err != nil {
-			return fmt.Errorf("failed to close IMAP server: %w", err)
-		}
-
-		sm.imapServer = nil
-	}
-
-	return nil
-}
-
-func (sm *ServerManager) restartIMAP(ctx context.Context, bridge *Bridge) error {
-	logrus.Info("Restarting IMAP server")
-
-	if sm.imapListener != nil {
-		if err := sm.imapListener.Close(); err != nil {
-			return fmt.Errorf("failed to close IMAP listener: %w", err)
-		}
-
-		sm.imapListener = nil
-
-		bridge.publish(events.IMAPServerStopped{})
-	}
-
-	if sm.shouldStartServers() {
-		return sm.serveIMAP(ctx, bridge)
-	}
-
-	return nil
-}
-
-func (sm *ServerManager) restartSMTP(bridge *Bridge) error {
-	logrus.Info("Restarting SMTP server")
-
-	if err := sm.closeSMTPServer(bridge); err != nil {
-		return fmt.Errorf("failed to close SMTP: %w", err)
-	}
-
-	bridge.publish(events.SMTPServerStopped{})
-
-	sm.smtpServer = newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
-
-	if sm.shouldStartServers() {
-		return sm.serveSMTP(bridge)
-	}
-
-	return nil
-}
-
-func (sm *ServerManager) serveSMTP(bridge *Bridge) error {
-	port, err := func() (int, error) {
-		logrus.WithFields(logrus.Fields{
-			"port": bridge.vault.GetSMTPPort(),
-			"ssl":  bridge.vault.GetSMTPSSL(),
-		}).Info("Starting SMTP server")
-
-		smtpListener, err := newListener(bridge.vault.GetSMTPPort(), bridge.vault.GetSMTPSSL(), bridge.tlsConfig)
-		if err != nil {
-			return 0, fmt.Errorf("failed to create SMTP listener: %w", err)
-		}
-
-		sm.smtpListener = smtpListener
-
-		bridge.tasks.Once(func(context.Context) {
-			if err := sm.smtpServer.Serve(smtpListener); err != nil {
-				logrus.WithError(err).Info("SMTP server stopped")
-			}
-		})
-
-		if err := bridge.vault.SetSMTPPort(getPort(smtpListener.Addr())); err != nil {
-			return 0, fmt.Errorf("failed to store SMTP port in vault: %w", err)
-		}
-
-		return getPort(smtpListener.Addr()), nil
-	}()
-
-	if err != nil {
-		bridge.publish(events.SMTPServerError{
-			Error: err,
-		})
-
-		return err
-	}
-
-	bridge.publish(events.SMTPServerReady{
-		Port: port,
-	})
-
-	return nil
-}
-
-func (sm *ServerManager) serveIMAP(ctx context.Context, bridge *Bridge) error {
-	port, err := func() (int, error) {
-		if sm.imapServer == nil {
-			return 0, fmt.Errorf("no IMAP server instance running")
-		}
-
-		logrus.WithFields(logrus.Fields{
-			"port": bridge.vault.GetIMAPPort(),
-			"ssl":  bridge.vault.GetIMAPSSL(),
-		}).Info("Starting IMAP server")
-
-		imapListener, err := newListener(bridge.vault.GetIMAPPort(), bridge.vault.GetIMAPSSL(), bridge.tlsConfig)
-		if err != nil {
-			return 0, fmt.Errorf("failed to create IMAP listener: %w", err)
-		}
-
-		sm.imapListener = imapListener
-
-		if err := sm.imapServer.Serve(ctx, sm.imapListener); err != nil {
-			return 0, fmt.Errorf("failed to serve IMAP: %w", err)
-		}
-
-		if err := bridge.vault.SetIMAPPort(getPort(imapListener.Addr())); err != nil {
-			return 0, fmt.Errorf("failed to store IMAP port in vault: %w", err)
-		}
-
-		return getPort(imapListener.Addr()), nil
-	}()
-
-	if err != nil {
-		bridge.publish(events.IMAPServerError{
-			Error: err,
-		})
-
-		return err
-	}
-
-	bridge.publish(events.IMAPServerReady{
-		Port: port,
-	})
-
-	return nil
-}
-
-func (sm *ServerManager) stopIMAPListener(bridge *Bridge) error {
-	logrus.Info("Stopping IMAP listener")
-	if sm.imapListener != nil {
-		if err := sm.imapListener.Close(); err != nil {
-			return err
-		}
-
-		sm.imapListener = nil
-
-		bridge.publish(events.IMAPServerStopped{})
-	}
-
-	return nil
-}
-
-func (sm *ServerManager) handleSetGluonDir(ctx context.Context, bridge *Bridge, newGluonDir string) error {
-	return safe.RLockRet(func() error {
-		currentGluonDir := bridge.GetGluonCacheDir()
-		newGluonDir = filepath.Join(newGluonDir, "gluon")
-		if newGluonDir == currentGluonDir {
-			return fmt.Errorf("new gluon dir is the same as the old one")
-		}
-
-		if err := sm.closeIMAPServer(context.Background(), bridge); err != nil {
-			return fmt.Errorf("failed to close IMAP: %w", err)
-		}
-
-		sm.loadedUserCount = 0
-
-		if err := bridge.moveGluonCacheDir(currentGluonDir, newGluonDir); err != nil {
-			logrus.WithError(err).Error("failed to move GluonCacheDir")
-
-			if err := bridge.vault.SetGluonDir(currentGluonDir); err != nil {
-				return fmt.Errorf("failed to revert GluonCacheDir: %w", err)
-			}
-		}
-
-		bridge.heartbeat.SetCacheLocation(newGluonDir)
-
-		gluonDataDir, err := bridge.GetGluonDataDir()
-		if err != nil {
-			return fmt.Errorf("failed to get Gluon Database directory: %w", err)
-		}
-
-		imapServer, err := newIMAPServer(
-			bridge.vault.GetGluonCacheDir(),
-			gluonDataDir,
-			bridge.curVersion,
-			bridge.tlsConfig,
-			bridge.reporter,
-			bridge.logIMAPClient,
-			bridge.logIMAPServer,
-			bridge.imapEventCh,
-			bridge.tasks,
-			bridge.uidValidityGenerator,
-			bridge.panicHandler,
-		)
-		if err != nil {
-			return fmt.Errorf("failed to create new IMAP server: %w", err)
-		}
-
-		sm.imapServer = imapServer
-		for _, bridgeUser := range bridge.users {
-			if err := sm.handleAddIMAPUser(ctx, bridgeUser); err != nil {
-				return fmt.Errorf("failed to add users to new IMAP server: %w", err)
-			}
-			sm.loadedUserCount++
-		}
-
-		if sm.shouldStartServers() {
-			if err := sm.serveIMAP(ctx, bridge); err != nil {
-				return fmt.Errorf("failed to serve IMAP: %w", err)
-			}
-		}
-
-		return nil
-	}, bridge.usersLock)
-}
-
-func (sm *ServerManager) handleAddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
-	if sm.imapServer == nil {
-		return "", fmt.Errorf("no imap server instance running")
-	}
-
-	return sm.imapServer.AddUser(ctx, conn, passphrase)
-}
-
-func (sm *ServerManager) handleRemoveGluonUser(ctx context.Context, userID string) error {
-	if sm.imapServer == nil {
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	return sm.imapServer.RemoveUser(ctx, userID, true)
-}
-
-func (sm *ServerManager) shouldStartServers() bool {
-	return sm.loadedUserCount >= 1
-}
-
-type smRequestClose struct{}
-
-type smRequestRestartIMAP struct{}
-
-type smRequestRestartSMTP struct{}
-
-type smRequestAddIMAPUser struct {
-	user *user.User
-}
-
-type smRequestRemoveIMAPUser struct {
-	user     *user.User
-	withData bool
-}
-
-type smRequestSetGluonDir struct {
-	dir string
-}
-
-type smRequestAddGluonUser struct {
-	conn       connector.Connector
-	passphrase []byte
-}
-
-type smRequestRemoveGluonUser struct {
-	userID string
-}
--- a/internal/bridge/server_manager_test.go
+++ b/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()
-		})
-	})
-}
--- a/internal/bridge/settings.go
+++ b/internal/bridge/settings.go
@ -1,333 +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"
-	"net"
-	"os"
-
-	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"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 {
-	return bridge.serverManager.SetGluonDir(ctx, newGluonDir)
-}
-
-func (bridge *Bridge) moveGluonCacheDir(oldGluonDir, newGluonDir string) error {
-	logrus.Infof("gluon cache moving from %s to %s", oldGluonDir, newGluonDir)
-	oldCacheDir := ApplyGluonCachePathSuffix(oldGluonDir)
-	if err := copyDir(oldCacheDir, ApplyGluonCachePathSuffix(newGluonDir)); err != nil {
-		return fmt.Errorf("failed to copy gluon dir: %w", err)
-	}
-
-	if err := bridge.vault.SetGluonDir(newGluonDir); err != nil {
-		return fmt.Errorf("failed to set new gluon cache dir: %w", err)
-	}
-
-	if err := os.RemoveAll(oldCacheDir); err != nil {
-		logrus.WithError(err).Error("failed to remove old gluon cache dir")
-	}
-	return nil
-}
-
-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")
-	}
-}
-
-func getPort(addr net.Addr) int {
-	switch addr := addr.(type) {
-	case *net.TCPAddr:
-		return addr.Port
-
-	case *net.UDPAddr:
-		return addr.Port
-
-	default:
-		return 0
-	}
-}
--- a/internal/bridge/settings_test.go
+++ b/internal/bridge/settings_test.go
@ -1,168 +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/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_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.
-		})
-	})
-}
--- a/internal/bridge/smtp.go
+++ b/internal/bridge/smtp.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/>.
-
-package bridge
-
-import (
-	"context"
-	"crypto/tls"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
-	"github.com/emersion/go-sasl"
-	"github.com/emersion/go-smtp"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) restartSMTP(ctx context.Context) error {
-	return bridge.serverManager.RestartSMTP(ctx)
-}
-
-func newSMTPServer(bridge *Bridge, tlsConfig *tls.Config, logSMTP bool) *smtp.Server {
-	logrus.WithField("logSMTP", logSMTP).Info("Creating SMTP server")
-
-	smtpServer := smtp.NewServer(&smtpBackend{Bridge: bridge})
-
-	smtpServer.TLSConfig = tlsConfig
-	smtpServer.Domain = constants.Host
-	smtpServer.AllowInsecureAuth = true
-	smtpServer.MaxLineLength = 1 << 16
-	smtpServer.ErrorLog = logging.NewSMTPLogger()
-
-	// go-smtp suppors SASL PLAIN but not LOGIN. We need to add LOGIN support ourselves.
-	smtpServer.EnableAuth(sasl.Login, func(conn *smtp.Conn) sasl.Server {
-		return sasl.NewLoginServer(func(username, password string) error {
-			return conn.Session().AuthPlain(username, password)
-		})
-	})
-
-	if logSMTP {
-		log := logrus.WithField("protocol", "SMTP")
-		log.Warning("================================================")
-		log.Warning("THIS LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
-		log.Warning("================================================")
-
-		smtpServer.Debug = logging.NewSMTPDebugLogger()
-	}
-
-	return smtpServer
-}
--- a/internal/bridge/smtp_backend.go
+++ b/internal/bridge/smtp_backend.go
@ -1,125 +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"
-	"strings"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
-	"github.com/ProtonMail/proton-bridge/v3/internal/useragent"
-	"github.com/emersion/go-smtp"
-	"github.com/sirupsen/logrus"
-)
-
-type smtpBackend struct {
-	*Bridge
-}
-
-type smtpSession struct {
-	*Bridge
-
-	userID string
-	authID string
-
-	from string
-	to   []string
-}
-
-func (be *smtpBackend) NewSession(*smtp.Conn) (smtp.Session, error) {
-	return &smtpSession{Bridge: be.Bridge}, nil
-}
-
-func (s *smtpSession) AuthPlain(username, password string) error {
-	return safe.RLockRet(func() error {
-		for _, user := range s.users {
-			addrID, err := user.CheckAuth(username, []byte(password))
-			if err != nil {
-				continue
-			}
-
-			s.userID = user.ID()
-			s.authID = addrID
-
-			if strings.Contains(s.Bridge.GetCurrentUserAgent(), useragent.DefaultUserAgent) {
-				s.Bridge.setUserAgent(useragent.UnknownClient, useragent.DefaultVersion)
-			}
-
-			user.SendConfigStatusSuccess(context.Background())
-
-			return nil
-		}
-
-		logrus.WithFields(logrus.Fields{
-			"username": username,
-			"pkg":      "smtp",
-		}).Error("Incorrect login credentials.")
-		err := fmt.Errorf("invalid username or password")
-		for _, user := range s.users {
-			for _, mail := range user.Emails() {
-				if mail == username {
-					user.ReportConfigStatusFailure(err.Error())
-					return err
-				}
-			}
-		}
-		return err
-	}, s.usersLock)
-}
-
-func (s *smtpSession) Reset() {
-	s.from = ""
-	s.to = nil
-}
-
-func (s *smtpSession) Logout() error {
-	s.Reset()
-	return nil
-}
-
-func (s *smtpSession) Mail(from string, _ *smtp.MailOptions) error {
-	s.from = from
-	return nil
-}
-
-func (s *smtpSession) Rcpt(to string) error {
-	if len(to) > 0 {
-		s.to = append(s.to, to)
-	}
-
-	return nil
-}
-
-func (s *smtpSession) Data(r io.Reader) error {
-	err := safe.RLockRet(func() error {
-		user, ok := s.users[s.userID]
-		if !ok {
-			return ErrNoSuchUser
-		}
-
-		return user.SendMail(s.authID, s.from, s.to, r)
-	}, s.usersLock)
-
-	if err != nil {
-		logrus.WithField("pkg", "smtp").WithError(err).Error("Send mail failed.")
-	}
-
-	return err
-}
--- a/internal/bridge/store_factory.go
+++ 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))
+}
--- a/internal/bridge/sync_test.go
+++ b/internal/bridge/sync_test.go
@ -1,467 +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"
-	"os"
-	"path/filepath"
-	"runtime"
-	"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/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.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)
-			}
-
-			// 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)
-
-			{
-				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)
-				// Original folder should have more than 0 messages and less than the total.
-				require.Greater(t, status.Messages, uint32(0))
-				require.Less(t, status.Messages, uint32(numMsg))
-
-				// 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 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
-}
--- a/internal/bridge/sync_unix_test.go
+++ b/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 flakyness.
-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))
-}
--- a/internal/bridge/testdata/invite.eml
+++ b/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
-
--- a/internal/bridge/testdata/text-plain.eml
+++ b/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
--- a/internal/bridge/tls.go
+++ b/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)
-}
--- a/internal/bridge/types.go
+++ b/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.
 //
@ -18,47 +18,37 @@
 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
 }

-type Identifier interface {
-	GetUserAgent() string
-	HasClient() bool
-	SetClient(name, version string)
-	SetPlatform(platform string)
-	SetClientString(client string)
-	GetClientString() string
+type CacheProvider interface {
+	GetIMAPCachePath() string
+	GetDBDir() string
+	GetDefaultMessageCacheDir() string
 }

-type ProxyController interface {
-	AllowProxy()
-	DisallowProxy()
-}
-
-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
 }
--- a/internal/bridge/updates.go
+++ b/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)
-}
--- a/internal/bridge/user.go
+++ b/internal/bridge/user.go
@ -1,661 +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/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")
-
-	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 := 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 := bridge.removeIMAPUser(ctx, user, true); err != nil {
-			return fmt.Errorf("failed to remove IMAP user: %w", err)
-		}
-
-		if err := user.SetAddressMode(ctx, mode); err != nil {
-			return fmt.Errorf("failed to set address mode: %w", err)
-		}
-
-		if err := bridge.addIMAPUser(ctx, user); err != nil {
-			return fmt.Errorf("failed to add IMAP user: %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")
-			}
-
-			if err := bridge.addIMAPUser(ctx, user); err != nil {
-				return fmt.Errorf("failed to add IMAP user: %w", err)
-			}
-
-			user.BadEventFeedbackResync(ctx)
-
-			return nil
-		}
-
-		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)
-	}
-
-	// re-set SyncStatus if database need to be re-synced for migration.
-	bridge.migrateUser(vault)
-
-	user, err := user.New(
-		ctx,
-		vault,
-		client,
-		bridge.reporter,
-		apiUser,
-		bridge.panicHandler,
-		bridge.vault.GetShowAllMail(),
-		bridge.vault.GetMaxSyncMemory(),
-		statsPath,
-		bridge,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to create user: %w", err)
-	}
-
-	// Connect the user's address(es) to gluon.
-	if err := bridge.addIMAPUser(ctx, user); err != nil {
-		return fmt.Errorf("failed to add IMAP 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")
-
-			if err := bridge.handleUserEvent(ctx, user, event); err != nil {
-				logrus.WithError(err).Error("Failed to handle user event")
-			} else {
-				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 := bridge.removeIMAPUser(ctx, user, withData); err != nil {
-		logrus.WithError(err).Error("Failed to remove IMAP 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
-}
--- a/internal/bridge/user_event_test.go
+++ b/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)
-}
--- a/internal/bridge/user_events.go
+++ b/internal/bridge/user_events.go
@ -1,203 +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/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/ProtonMail/proton-bridge/v3/internal/vault"
-	"github.com/sirupsen/logrus"
-)
-
-func (bridge *Bridge) handleUserEvent(ctx context.Context, user *user.User, event events.Event) error {
-	switch event := event.(type) {
-	case events.UserAddressCreated:
-		if err := bridge.handleUserAddressCreated(ctx, user, event); err != nil {
-			return fmt.Errorf("failed to handle user address created event: %w", err)
-		}
-
-	case events.UserAddressEnabled:
-		if err := bridge.handleUserAddressEnabled(ctx, user, event); err != nil {
-			return fmt.Errorf("failed to handle user address enabled event: %w", err)
-		}
-
-	case events.UserAddressDisabled:
-		if err := bridge.handleUserAddressDisabled(ctx, user, event); err != nil {
-			return fmt.Errorf("failed to handle user address disabled event: %w", err)
-		}
-
-	case events.UserAddressDeleted:
-		if err := bridge.handleUserAddressDeleted(ctx, user, event); err != nil {
-			return fmt.Errorf("failed to handle user address deleted event: %w", err)
-		}
-
-	case events.UserRefreshed:
-		if err := bridge.handleUserRefreshed(ctx, user, event); err != nil {
-			return fmt.Errorf("failed to handle user refreshed event: %w", err)
-		}
-
-	case events.UserDeauth:
-		bridge.handleUserDeauth(ctx, user)
-
-	case events.UserBadEvent:
-		bridge.handleUserBadEvent(ctx, user, event)
-
-	case events.UncategorizedEventError:
-		bridge.handleUncategorizedErrorEvent(event)
-	}
-
-	return nil
-}
-
-func (bridge *Bridge) handleUserAddressCreated(ctx context.Context, user *user.User, event events.UserAddressCreated) error {
-	if user.GetAddressMode() == vault.CombinedMode {
-		return nil
-	}
-
-	gluonID, err := bridge.serverManager.AddGluonUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
-	if err != nil {
-		return fmt.Errorf("failed to add user to IMAP server: %w", err)
-	}
-
-	if err := user.SetGluonID(event.AddressID, gluonID); err != nil {
-		return fmt.Errorf("failed to set gluon ID: %w", err)
-	}
-
-	return nil
-}
-
-func (bridge *Bridge) handleUserAddressEnabled(ctx context.Context, user *user.User, event events.UserAddressEnabled) error {
-	if user.GetAddressMode() == vault.CombinedMode {
-		return nil
-	}
-
-	gluonID, err := bridge.serverManager.AddGluonUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
-	if err != nil {
-		return fmt.Errorf("failed to add user to IMAP server: %w", err)
-	}
-
-	if err := user.SetGluonID(event.AddressID, gluonID); err != nil {
-		return fmt.Errorf("failed to set gluon ID: %w", err)
-	}
-
-	return nil
-}
-
-func (bridge *Bridge) handleUserAddressDisabled(ctx context.Context, user *user.User, event events.UserAddressDisabled) error {
-	if user.GetAddressMode() == vault.CombinedMode {
-		return nil
-	}
-
-	gluonID, ok := user.GetGluonID(event.AddressID)
-	if !ok {
-		return fmt.Errorf("gluon ID not found for address %s", event.AddressID)
-	}
-
-	if err := bridge.serverManager.RemoveGluonUser(ctx, gluonID); err != nil {
-		return fmt.Errorf("failed to remove user from IMAP server: %w", err)
-	}
-
-	if err := user.RemoveGluonID(event.AddressID, gluonID); err != nil {
-		return fmt.Errorf("failed to remove gluon ID for address: %w", err)
-	}
-
-	return nil
-}
-
-func (bridge *Bridge) handleUserAddressDeleted(ctx context.Context, user *user.User, event events.UserAddressDeleted) error {
-	if user.GetAddressMode() == vault.CombinedMode {
-		return nil
-	}
-
-	gluonID, ok := user.GetGluonID(event.AddressID)
-	if !ok {
-		return fmt.Errorf("gluon ID not found for address %s", event.AddressID)
-	}
-
-	if err := bridge.serverManager.handleRemoveGluonUser(ctx, gluonID); err != nil {
-		return fmt.Errorf("failed to remove user from IMAP server: %w", err)
-	}
-
-	if err := user.RemoveGluonID(event.AddressID, gluonID); err != nil {
-		return fmt.Errorf("failed to remove gluon ID for address: %w", err)
-	}
-
-	return nil
-}
-
-func (bridge *Bridge) handleUserRefreshed(ctx context.Context, user *user.User, event events.UserRefreshed) error {
-	return safe.RLockRet(func() error {
-		if event.CancelEventPool {
-			user.CancelSyncAndEventPoll()
-		}
-
-		if err := bridge.removeIMAPUser(ctx, user, true); err != nil {
-			return fmt.Errorf("failed to remove IMAP user: %w", err)
-		}
-
-		if err := bridge.addIMAPUser(ctx, user); err != nil {
-			return fmt.Errorf("failed to add IMAP user: %w", err)
-		}
-
-		return nil
-	}, bridge.usersLock)
-}
-
-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(_ 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.CancelSyncAndEventPoll()
-
-		// Disable IMAP user
-		if err := bridge.removeIMAPUser(context.Background(), user, false); err != nil {
-			logrus.WithError(err).Error("Failed to remove IMAP user")
-		}
-	}, 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")
-	}
-}
--- a/internal/bridge/user_test.go
+++ b/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
-}
--- a/internal/certs/cert_store_darwin.go
+++ b/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
-}
--- a/internal/certs/cert_store_darwin_test.go
+++ b/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.
-}
--- a/internal/certs/installer.go
+++ b/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)
-}
--- a/internal/clientconfig/applemail.go
+++ b/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
-}
--- a/internal/config/cache/cache.go
+++ b/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)
+}
--- a/internal/config/cache/cache_test.go
+++ b/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())
+	}
+}
--- a/internal/config/settings/kvs.go
+++ b/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))
+}
--- a/internal/config/settings/kvs_test.go
+++ b/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))
+}
--- a/internal/config/settings/settings.go
+++ b/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")
+}
--- a/internal/config/tls/cert_store_darwin.go
+++ b/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())
+}
--- a/internal/config/tls/cert_store_linux.go
+++ b/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.
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jakub	6bb7162263	Other: Bridge Millau 2.2.1	2022-07-14 13:51:37 +02:00
Jakub	0a48323043	GODT-1565: Improve mac icon.	2022-07-14 13:20:33 +02:00
Jakub	b347a926c2	GODT-1475: Improve systray icon size.	2022-07-14 13:20:33 +02:00
Jakub	d2a179f58b	GODT-1565: Update Bridge application icons.	2022-07-14 13:20:33 +02:00
Jakub	3330cdc69b	GODT-1564: Update welcome illustration	2022-07-14 13:20:33 +02:00
Romain Le Jeune	dd1e2b2100	GODT-1686: Add Label/Folder filtering to pmapi	2022-07-13 13:02:11 +00:00
Jakub	2566bdcedf	GODT-1659: Convert charset only for `text/*` MIME types.	2022-07-12 18:27:39 +02:00
Leander Beernaert	1ff3fe194e	GODT-1626: Update gopenpgp v2.4.7 This patch also replaces the deprecated calls to `SeparateKeyAndData` with `SplitMessage`.	2022-06-30 14:55:38 +02:00
Leander Beernaert	6e2476df02	GODT-1627: Update go-srvp to v0.0.5	2022-06-30 11:34:19 +02:00
Jakub	e3fe33245e	GODT-1523: Reduce unnecessary shell executions. Inspired by @kortschak. - check opened file descriptors - detection of darwin version - detection of apple interface color theme - test for update sync (copy files) - replace exec with execabs	2022-06-28 08:33:39 +00:00