Launcher, app/base, sentry, update service

internal/app/base/args.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import "strings"
+
+// StripProcessSerialNumber removes additional flag from macOS.
+// More info:
+// http://mirror.informatimago.com/next/developer.apple.com/documentation/Carbon/Reference/Process_Manager/prmref_main/data_type_5.html#//apple_ref/doc/uid/TP30000208/C001951
+func StripProcessSerialNumber(args []string) []string {
+	res := args[:0]
+
+	for _, arg := range args {
+		if !strings.Contains(arg, "-psn_") {
+			res = append(res, arg)
+		}
+	}
+
+	return res
+}

internal/app/base/base.go

@@ -0,0 +1,307 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail 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 ClientManager
+// 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 (
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/go-appdir"
+	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/config/cache"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/config/tls"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/cookies"
+	"github.com/ProtonMail/proton-bridge/internal/crash"
+	"github.com/ProtonMail/proton-bridge/internal/events"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/logging"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/ProtonMail/proton-bridge/internal/users/credentials"
+	"github.com/ProtonMail/proton-bridge/internal/versioner"
+	"github.com/ProtonMail/proton-bridge/pkg/listener"
+	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
+	"github.com/ProtonMail/proton-bridge/pkg/sentry"
+	"github.com/allan-simon/go-singleinstance"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+type Base struct {
+	CrashHandler *crash.Handler
+	Locations    *locations.Locations
+	Settings     *settings.Settings
+	Lock         *os.File
+	Cache        *cache.Cache
+	Listener     listener.Listener
+	Creds        *credentials.Store
+	CM           *pmapi.ClientManager
+	Updater      *updater.Updater
+	Versioner    *versioner.Versioner
+	TLS          *tls.TLS
+
+	name  string
+	usage string
+
+	restart bool
+}
+
+func New( // nolint[funlen]
+	appName,
+	appUsage,
+	configName,
+	updateURLName,
+	keychainName,
+	cacheVersion string,
+) (*Base, error) {
+	sentryReporter := sentry.NewReporter(appName, constants.Version)
+
+	crashHandler := crash.NewHandler(
+		sentryReporter.Report,
+		crash.ShowErrorNotification(appName),
+	)
+	defer crashHandler.HandlePanic()
+
+	locations := locations.New(
+		appdir.New(filepath.Join(constants.VendorName, configName)),
+		configName,
+	)
+	if err := locations.Clean(); err != nil {
+		return nil, err
+	}
+
+	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))
+
+	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))
+	}
+
+	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)
+
+	// NOTE: If we can't load the credentials for whatever reason,
+	// do we really want to error out? Need to signal to frontend.
+	creds, err := credentials.NewStore(keychainName)
+	if err != nil {
+		logrus.WithError(err).Error("Could not get credentials store")
+		listener.Emit(events.CredentialsErrorEvent, err.Error())
+	}
+
+	jar, err := cookies.NewCookieJar(settingsObj)
+	if err != nil {
+		return nil, err
+	}
+
+	cm := pmapi.NewClientManager(pmapi.GetAPIConfig(configName, constants.Version))
+	cm.SetRoundTripper(pmapi.GetRoundTripper(cm, listener))
+	cm.SetCookieJar(jar)
+
+	sentryReporter.SetUserAgentProvider(cm)
+
+	tls := tls.New(settingsPath)
+
+	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,
+		kr,
+		semver.MustParse(constants.Version),
+		updateURLName,
+		runtime.GOOS,
+		settingsObj.GetFloat64(settings.RolloutKey),
+	)
+
+	return &Base{
+		CrashHandler: crashHandler,
+		Locations:    locations,
+		Settings:     settingsObj,
+		Lock:         lock,
+		Cache:        cache,
+		Listener:     listener,
+		Creds:        creds,
+		CM:           cm,
+		Updater:      updater,
+		Versioner:    versioner,
+		TLS:          tls,
+
+		name:  appName,
+		usage: appUsage,
+	}, nil
+}
+
+func (b *Base) NewApp(action 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.run(action)
+	app.Flags = []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "cpu-prof",
+			Aliases: []string{"p"},
+			Usage:   "Generate CPU profile",
+		},
+		&cli.BoolFlag{
+			Name:    "mem-prof",
+			Aliases: []string{"m"},
+			Usage:   "Generate memory profile",
+		},
+		&cli.StringFlag{
+			Name:    "log-level",
+			Aliases: []string{"l"},
+			Usage:   "Set the log level (one of panic, fatal, error, warn, info, debug)",
+		},
+		&cli.BoolFlag{
+			Name:    "cli",
+			Aliases: []string{"c"},
+			Usage:   "Use command line interface",
+		},
+		&cli.StringFlag{
+			Name:   "restart",
+			Usage:  "The number of times the application has already restarted",
+			Hidden: true,
+		},
+		&cli.StringFlag{
+			Name:   "launcher",
+			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
+}
+
+func (b *Base) run(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 doCPUProfile := c.Bool("cpu-prof"); doCPUProfile {
+			startCPUProfile()
+			defer pprof.StopCPUProfile()
+		}
+
+		if doMemoryProfile := c.Bool("mem-prof"); doMemoryProfile {
+			defer makeMemoryProfile()
+		}
+
+		logging.SetLevel(c.String("log-level"))
+
+		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 {
+			if c.Int("restart") > maxAllowedRestarts {
+				logrus.
+					WithField("restart", c.Int("restart")).
+					Warn("Not restarting, already restarted too many times")
+
+				return nil
+			}
+
+			return restartApp(c.String("launcher"), true)
+		})
+
+		if err := appMainLoop(b, c); err != nil {
+			return err
+		}
+
+		if b.restart {
+			return restartApp(c.String("launcher"), false)
+		}
+
+		if err := b.Versioner.RemoveOldVersions(); err != nil {
+			return err
+		}
+
+		return nil
+	}
+}

internal/app/base/migration.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ProtonMail/go-appdir"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/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    | ~/.cache/protonmail/<app>/c11             | ~/.cache/protonmail/<app>/cache/c11    |
+func MigrateFiles(configName string) error {
+	appDirs := appdir.New(filepath.Join(constants.VendorName, configName))
+	locations := locations.New(appDirs, configName)
+
+	userCacheDir := appDirs.UserCache()
+	newSettingsDir, err := locations.ProvideSettingsPath()
+	if err != nil {
+		return err
+	}
+
+	if err := moveIfExists(
+		filepath.Join(userCacheDir, "c11", "prefs.json"),
+		filepath.Join(newSettingsDir, "prefs.json"),
+	); err != nil {
+		return err
+	}
+
+	newCacheDir, err := locations.ProvideCachePath()
+	if err != nil {
+		return err
+	}
+
+	if err := moveIfExists(
+		filepath.Join(userCacheDir, "c11"),
+		filepath.Join(newCacheDir, "c11"),
+	); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func moveIfExists(source, destination string) error {
+	if _, err := os.Stat(source); os.IsNotExist(err) {
+		logrus.WithField("source", source).WithField("destination", destination).Debug("No need to migrate file")
+		return nil
+	}
+
+	if _, err := os.Stat(destination); !os.IsNotExist(err) {
+		logrus.WithField("source", source).WithField("destination", destination).Debug("No need to migrate file")
+		return nil
+	}
+
+	return os.Rename(source, destination)
+}

internal/app/base/profiling.go

@@ -0,0 +1,56 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/sirupsen/logrus"
+)
+
+// startCPUProfile starts CPU pprof.
+func startCPUProfile() {
+	f, err := os.Create("./cpu.pprof")
+	if err != nil {
+		logrus.Fatal("Could not create CPU profile: ", err)
+	}
+	if err := pprof.StartCPUProfile(f); err != nil {
+		logrus.Fatal("Could not start CPU profile: ", err)
+	}
+}
+
+// makeMemoryProfile generates memory pprof.
+func makeMemoryProfile() {
+	name := "./mem.pprof"
+	f, err := os.Create(name)
+	if err != nil {
+		logrus.Fatal("Could not create memory profile: ", err)
+	}
+	if abs, err := filepath.Abs(name); err == nil {
+		name = abs
+	}
+	logrus.Info("Writing memory profile to ", name)
+	runtime.GC() // get up-to-date statistics
+	if err := pprof.WriteHeapProfile(f); err != nil {
+		logrus.Fatal("Could not write memory profile: ", err)
+	}
+	_ = f.Close()
+}

internal/app/base/restart.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"os/exec"
+	"strconv"
+
+	"github.com/sirupsen/logrus"
+)
+
+// maxAllowedRestarts controls after how many crashes the app will give up restarting.
+const maxAllowedRestarts = 10
+
+func restartApp(path string, crash bool) error {
+	if path == "" {
+		exe, err := os.Executable()
+		if err != nil {
+			return err
+		}
+
+		path = exe
+	}
+
+	var args []string
+
+	if crash {
+		args = incrementRestartFlag(os.Args)[1:]
+	} else {
+		args = os.Args[1:]
+	}
+
+	logrus.
+		WithField("path", path).
+		WithField("args", args).
+		Warn("Restarting")
+
+	return exec.Command(path, args...).Start() // nolint[gosec]
+}
+
+// incrementRestartFlag increments the value of the restart flag.
+// If no such flag is present, it is added with initial value 1.
+func incrementRestartFlag(args []string) []string {
+	res := append([]string{}, args...)
+
+	hasFlag := false
+
+	for k, v := range res {
+		if v != "--restart" {
+			continue
+		}
+
+		hasFlag = true
+
+		if k+1 >= len(res) {
+			continue
+		}
+
+		n, err := strconv.Atoi(res[k+1])
+		if err != nil {
+			res[k+1] = "1"
+		} else {
+			res[k+1] = strconv.Itoa(n + 1)
+		}
+	}
+
+	if !hasFlag {
+		res = append(res, "--restart", "1")
+	}
+
+	return res
+}

internal/app/base/restart_test.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIncrementRestartFlag(t *testing.T) {
+	var tests = []struct {
+		in  []string
+		out []string
+	}{
+		{[]string{"./bridge", "--restart", "1"}, []string{"./bridge", "--restart", "2"}},
+		{[]string{"./bridge", "--restart", "2"}, []string{"./bridge", "--restart", "3"}},
+		{[]string{"./bridge", "--other", "--restart", "2"}, []string{"./bridge", "--other", "--restart", "3"}},
+		{[]string{"./bridge", "--restart", "2", "--other"}, []string{"./bridge", "--restart", "3", "--other"}},
+		{[]string{"./bridge", "--restart", "2", "--other", "2"}, []string{"./bridge", "--restart", "3", "--other", "2"}},
+		{[]string{"./bridge"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--something"}, []string{"./bridge", "--something", "--restart", "1"}},
+		{[]string{"./bridge", "--something", "--else"}, []string{"./bridge", "--something", "--else", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad", "--other"}, []string{"./bridge", "--restart", "1", "--other"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(strings.Join(tt.in, " "), func(t *testing.T) {
+			assert.Equal(t, tt.out, incrementRestartFlag(tt.in))
+		})
+	}
+}

internal/app/bridge/bridge.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package bridge implements the bridge CLI application.
+package bridge
+
+import (
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/app/base"
+	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/frontend"
+	"github.com/ProtonMail/proton-bridge/internal/imap"
+	"github.com/ProtonMail/proton-bridge/internal/smtp"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+func New(base *base.Base) *cli.App {
+	app := base.NewApp(run)
+
+	app.Flags = append(app.Flags, []cli.Flag{
+		&cli.StringFlag{
+			Name:  "log-imap",
+			Usage: "Enable logging of IMAP communications (all|client|server) (may contain decrypted data!)"},
+		&cli.BoolFlag{
+			Name:  "log-smtp",
+			Usage: "Enable logging of SMTP communications (may contain decrypted data!)"},
+		&cli.BoolFlag{
+			Name:  "no-window",
+			Usage: "Don't show window after start"},
+		&cli.BoolFlag{
+			Name:  "noninteractive",
+			Usage: "Start Bridge entirely noninteractively"},
+	}...)
+
+	return app
+}
+
+func run(b *base.Base, c *cli.Context) error { // nolint[funlen]
+	tls, err := b.TLS.GetConfig()
+	if err != nil {
+		logrus.WithError(err).Fatal("Failed to create TLS config")
+	}
+
+	bridge := bridge.New(b.Locations, b.Cache, b.Settings, b.CrashHandler, b.Listener, b.CM, b.Creds)
+	imapBackend := imap.NewIMAPBackend(b.CrashHandler, b.Listener, b.Cache, bridge)
+	smtpBackend := smtp.NewSMTPBackend(b.CrashHandler, b.Listener, b.Settings, bridge)
+
+	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(
+			c.String("log-imap") == "client" || c.String("log-imap") == "all",
+			c.String("log-imap") == "server" || c.String("log-imap") == "all",
+			imapPort, tls, imapBackend, b.Listener).ListenAndServe()
+	}()
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		smtpPort := b.Settings.GetInt(settings.SMTPPortKey)
+		useSSL := b.Settings.GetBool(settings.SMTPSSLKey)
+		smtp.NewSMTPServer(
+			c.Bool("log-smtp"),
+			smtpPort, useSSL, tls, smtpBackend, b.Listener).ListenAndServe()
+	}()
+
+	var frontendMode string
+
+	switch {
+	case c.Bool("cli"):
+		frontendMode = "cli"
+	case c.Bool("noninteractive"):
+		frontendMode = "noninteractive"
+	default:
+		frontendMode = "qt"
+	}
+
+	if frontendMode == "noninteractive" {
+		<-(make(chan struct{}))
+		return nil
+	}
+
+	f := frontend.New(
+		constants.Version,
+		constants.BuildVersion,
+		frontendMode,
+		!c.Bool("no-window"),
+		b.CrashHandler,
+		b.Locations,
+		b.Settings,
+		b.Listener,
+		b.Updater,
+		bridge,
+		smtpBackend,
+		b,
+	)
+
+	b.Updater.Watch(
+		time.Hour,
+		func(update updater.VersionInfo) error {
+			if !b.Settings.GetBool(settings.AutoUpdateKey) {
+				return f.NotifyManualUpdate(update)
+			}
+
+			return b.Updater.InstallUpdate(update)
+		},
+		func(err error) {
+			logrus.WithError(err).Error("An error occurred while watching for updates")
+		},
+	)
+
+	return f.Loop()
+}

internal/app/ie/ie.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail 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.
+//
+// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package ie implements the ie CLI application.
+package ie
+
+import (
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/app/base"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/frontend"
+	"github.com/ProtonMail/proton-bridge/internal/importexport"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+func New(b *base.Base) *cli.App {
+	return b.NewApp(run)
+}
+
+func run(b *base.Base, c *cli.Context) error {
+	ie := importexport.New(b.Locations, b.Cache, b.CrashHandler, b.Listener, b.CM, b.Creds)
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		api.NewAPIServer(b.Settings, b.Listener).ListenAndServe()
+	}()
+
+	var frontendMode string
+
+	switch {
+	case c.Bool("cli"):
+		frontendMode = "cli"
+	default:
+		frontendMode = "qt"
+	}
+
+	f := frontend.NewImportExport(
+		constants.Version,
+		constants.BuildVersion,
+		frontendMode,
+		b.CrashHandler,
+		b.Locations,
+		b.Listener,
+		b.Updater,
+		ie,
+		b,
+	)
+
+	b.Updater.Watch(
+		time.Hour,
+		func(update updater.VersionInfo) error {
+			if !b.Settings.GetBool(settings.AutoUpdateKey) {
+				return f.NotifyManualUpdate(update)
+			}
+
+			return b.Updater.InstallUpdate(update)
+		},
+		func(err error) {
+			logrus.WithError(err).Error("An error occurred while watching for updates")
+		},
+	)
+
+	return f.Loop()
+}