We build too many walls and not enough bridges

internal/frontend/cli/account_utils.go

@@ -0,0 +1,100 @@
+// 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 cli
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
+	"github.com/abiosoft/ishell"
+)
+
+// completeUsernames is a helper to complete usernames as the user types.
+func (f *frontendCLI) completeUsernames(args []string) (usernames []string) {
+	if len(args) > 1 {
+		return
+	}
+	arg := ""
+	if len(args) == 1 {
+		arg = args[0]
+	}
+	for _, user := range f.bridge.GetUsers() {
+		if strings.HasPrefix(strings.ToLower(user.Username()), strings.ToLower(arg)) {
+			usernames = append(usernames, user.Username())
+		}
+	}
+	return
+}
+
+// noAccountWrapper is a decorator for functions which need any account to be properly functional.
+func (f *frontendCLI) noAccountWrapper(callback func(*ishell.Context)) func(*ishell.Context) {
+	return func(c *ishell.Context) {
+		users := f.bridge.GetUsers()
+		if len(users) == 0 {
+			f.Println("No active accounts. Please add account to continue.")
+		} else {
+			callback(c)
+		}
+	}
+}
+
+func (f *frontendCLI) askUserByIndexOrName(c *ishell.Context) types.BridgeUser {
+	user := f.getUserByIndexOrName("")
+	if user != nil {
+		return user
+	}
+
+	numberOfAccounts := len(f.bridge.GetUsers())
+	indexRange := fmt.Sprintf("number between 0 and %d", numberOfAccounts-1)
+	if len(c.Args) == 0 {
+		f.Printf("Please choose %s or username.\n", indexRange)
+		return nil
+	}
+	arg := c.Args[0]
+	user = f.getUserByIndexOrName(arg)
+	if user == nil {
+		f.Printf("Wrong input '%s'. Choose %s or username.\n", bold(arg), indexRange)
+		return nil
+	}
+	return user
+}
+
+func (f *frontendCLI) getUserByIndexOrName(arg string) types.BridgeUser {
+	users := f.bridge.GetUsers()
+	numberOfAccounts := len(users)
+	if numberOfAccounts == 0 {
+		return nil
+	}
+	if numberOfAccounts == 1 {
+		return users[0]
+	}
+	if index, err := strconv.Atoi(arg); err == nil {
+		if index < 0 || index >= numberOfAccounts {
+			return nil
+		}
+		return users[index]
+	}
+	for _, user := range users {
+		if user.Username() == arg {
+			return user
+		}
+	}
+	return nil
+}

internal/frontend/cli/accounts.go

@@ -0,0 +1,219 @@
+// 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 cli
+
+import (
+	"strings"
+
+	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
+	"github.com/ProtonMail/proton-bridge/internal/preferences"
+	"github.com/abiosoft/ishell"
+)
+
+func (f *frontendCLI) listAccounts(c *ishell.Context) {
+	spacing := "%-2d: %-20s (%-15s, %-15s)\n"
+	f.Printf(bold(strings.Replace(spacing, "d", "s", -1)), "#", "account", "status", "address mode")
+	for idx, user := range f.bridge.GetUsers() {
+		connected := "disconnected"
+		if user.IsConnected() {
+			connected = "connected"
+		}
+		mode := "split"
+		if user.IsCombinedAddressMode() {
+			mode = "combined"
+		}
+		f.Printf(spacing, idx, user.Username(), connected, mode)
+	}
+	f.Println()
+}
+
+func (f *frontendCLI) showAccountInfo(c *ishell.Context) {
+	user := f.askUserByIndexOrName(c)
+	if user == nil {
+		return
+	}
+
+	if !user.IsConnected() {
+		f.Printf("Please login to %s to get email client configuration.\n", bold(user.Username()))
+		return
+	}
+
+	if user.IsCombinedAddressMode() {
+		f.showAccountAddressInfo(user, user.GetPrimaryAddress())
+	} else {
+		for _, address := range user.GetAddresses() {
+			f.showAccountAddressInfo(user, address)
+		}
+	}
+}
+
+func (f *frontendCLI) showAccountAddressInfo(user types.BridgeUser, address string) {
+	smtpSecurity := "STARTTLS"
+	if f.preferences.GetBool(preferences.SMTPSSLKey) {
+		smtpSecurity = "SSL"
+	}
+	f.Println(bold("Configuration for " + address))
+	f.Printf("IMAP Settings\nAddress:   %s\nIMAP port: %d\nUsername:  %s\nPassword:  %s\nSecurity:  %s\n",
+		bridge.Host,
+		f.preferences.GetInt(preferences.IMAPPortKey),
+		address,
+		user.GetBridgePassword(),
+		"STARTTLS",
+	)
+	f.Println("")
+	f.Printf("SMTP Settings\nAddress:   %s\nIMAP port: %d\nUsername:  %s\nPassword:  %s\nSecurity:  %s\n",
+		bridge.Host,
+		f.preferences.GetInt(preferences.SMTPPortKey),
+		address,
+		user.GetBridgePassword(),
+		smtpSecurity,
+	)
+	f.Println("")
+}
+
+func (f *frontendCLI) loginAccount(c *ishell.Context) { // nolint[funlen]
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	loginName := ""
+	if len(c.Args) > 0 {
+		user := f.getUserByIndexOrName(c.Args[0])
+		if user != nil {
+			loginName = user.GetPrimaryAddress()
+		}
+	}
+
+	if loginName == "" {
+		loginName = f.readStringInAttempts("Username", c.ReadLine, isNotEmpty)
+		if loginName == "" {
+			return
+		}
+	} else {
+		f.Println("Username:", loginName)
+	}
+
+	password := f.readStringInAttempts("Password", c.ReadPassword, isNotEmpty)
+	if password == "" {
+		return
+	}
+
+	f.Println("Authenticating ... ")
+	client, auth, err := f.bridge.Login(loginName, password)
+	if err != nil {
+		f.processAPIError(err)
+		return
+	}
+
+	if auth.HasTwoFactor() {
+		twoFactor := f.readStringInAttempts("Two factor code", c.ReadLine, isNotEmpty)
+		if twoFactor == "" {
+			return
+		}
+
+		_, err = client.Auth2FA(twoFactor, auth)
+		if err != nil {
+			f.processAPIError(err)
+			return
+		}
+	}
+
+	mailboxPassword := password
+	if auth.HasMailboxPassword() {
+		mailboxPassword = f.readStringInAttempts("Mailbox password", c.ReadPassword, isNotEmpty)
+	}
+	if mailboxPassword == "" {
+		return
+	}
+
+	f.Println("Adding account ...")
+	user, err := f.bridge.FinishLogin(client, auth, mailboxPassword)
+	if err != nil {
+		log.WithField("username", loginName).WithError(err).Error("Login was unsuccessful")
+		f.Println("Adding account was unsuccessful:", err)
+		return
+	}
+
+	f.Printf("Account %s was added successfully.\n", bold(user.Username()))
+}
+
+func (f *frontendCLI) logoutAccount(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	user := f.askUserByIndexOrName(c)
+	if user == nil {
+		return
+	}
+	if f.yesNoQuestion("Are you sure you want to logout account " + bold(user.Username())) {
+		if err := user.Logout(); err != nil {
+			f.printAndLogError("Logging out failed: ", err)
+		}
+	}
+}
+
+func (f *frontendCLI) deleteAccount(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	user := f.askUserByIndexOrName(c)
+	if user == nil {
+		return
+	}
+	if f.yesNoQuestion("Are you sure you want to " + bold("remove account "+user.Username())) {
+		clearCache := f.yesNoQuestion("Do you want to remove cache for this account")
+		if err := f.bridge.DeleteUser(user.ID(), clearCache); err != nil {
+			f.printAndLogError("Cannot delete account: ", err)
+			return
+		}
+	}
+}
+
+func (f *frontendCLI) deleteAccounts(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	if !f.yesNoQuestion("Do you really want remove all accounts") {
+		return
+	}
+	for _, user := range f.bridge.GetUsers() {
+		if err := f.bridge.DeleteUser(user.ID(), false); err != nil {
+			f.printAndLogError("Cannot delete account ", user.Username(), ": ", err)
+		}
+	}
+	c.Println("Keychain cleared")
+}
+
+func (f *frontendCLI) changeMode(c *ishell.Context) {
+	user := f.askUserByIndexOrName(c)
+	if user == nil {
+		return
+	}
+
+	newMode := "combined mode"
+	if user.IsCombinedAddressMode() {
+		newMode = "split mode"
+	}
+	if !f.yesNoQuestion("Are you sure you want to change the mode for account " + bold(user.Username()) + " to " + bold(newMode)) {
+		return
+	}
+	if err := user.SwitchAddressMode(); err != nil {
+		f.printAndLogError("Cannot switch address mode:", err)
+	}
+	f.Printf("Address mode for account %s changed to %s\n", user.Username(), newMode)
+}

internal/frontend/cli/frontend.go

@@ -0,0 +1,264 @@
+// 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 cli provides CLI interface of the Bridge.
+package cli
+
+import (
+	"github.com/ProtonMail/proton-bridge/internal/events"
+	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
+	"github.com/ProtonMail/proton-bridge/internal/preferences"
+	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/pkg/listener"
+
+	"github.com/abiosoft/ishell"
+)
+
+var (
+	log = config.GetLogEntry("frontend/cli") //nolint[gochecknoglobals]
+)
+
+type frontendCLI struct {
+	*ishell.Shell
+
+	config        *config.Config
+	preferences   *config.Preferences
+	eventListener listener.Listener
+	updates       types.Updater
+	bridge        types.Bridger
+
+	appRestart bool
+}
+
+// New returns a new CLI frontend configured with the given options.
+func New( //nolint[funlen]
+	panicHandler types.PanicHandler,
+	config *config.Config,
+	preferences *config.Preferences,
+	eventListener listener.Listener,
+	updates types.Updater,
+	bridge types.Bridger,
+) *frontendCLI { //nolint[golint]
+	fe := &frontendCLI{
+		Shell: ishell.New(),
+
+		config:        config,
+		preferences:   preferences,
+		eventListener: eventListener,
+		updates:       updates,
+		bridge:        bridge,
+
+		appRestart: false,
+	}
+
+	// Clear commands.
+	clearCmd := &ishell.Cmd{Name: "clear",
+		Help:    "remove stored accounts and preferences. (alias: cl)",
+		Aliases: []string{"cl"},
+	}
+	clearCmd.AddCmd(&ishell.Cmd{Name: "cache",
+		Help:    "remove stored preferences for accounts (aliases: c, prefs, preferences)",
+		Aliases: []string{"c", "prefs", "preferences"},
+		Func:    fe.deleteCache,
+	})
+	clearCmd.AddCmd(&ishell.Cmd{Name: "accounts",
+		Help:    "remove all accounts from keychain. (aliases: k, keychain)",
+		Aliases: []string{"a", "k", "keychain"},
+		Func:    fe.deleteAccounts,
+	})
+	fe.AddCmd(clearCmd)
+
+	// Change commands.
+	changeCmd := &ishell.Cmd{Name: "change",
+		Help:    "change server or account settings (aliases: ch, switch)",
+		Aliases: []string{"ch", "switch"},
+	}
+	changeCmd.AddCmd(&ishell.Cmd{Name: "mode",
+		Help:      "switch between combined addresses and split addresses mode for account. Use index or account name as parameter. (alias: m)",
+		Aliases:   []string{"m"},
+		Func:      fe.changeMode,
+		Completer: fe.completeUsernames,
+	})
+	changeCmd.AddCmd(&ishell.Cmd{Name: "port",
+		Help:    "change port numbers of IMAP and SMTP servers. (alias: p)",
+		Aliases: []string{"p"},
+		Func:    fe.changePort,
+	})
+	changeCmd.AddCmd(&ishell.Cmd{Name: "proxy",
+		Help: "allow or disallow bridge to securely connect to proton via a third party when it is being blocked",
+		Func: fe.toggleAllowProxy,
+	})
+	changeCmd.AddCmd(&ishell.Cmd{Name: "smtp-security",
+		Help:    "change port numbers of IMAP and SMTP servers.(alias: ssl, starttls)",
+		Aliases: []string{"ssl", "starttls"},
+		Func:    fe.changeSMTPSecurity,
+	})
+	fe.AddCmd(changeCmd)
+
+	// Check commands.
+	checkCmd := &ishell.Cmd{Name: "check", Help: "check internet connection or new version."}
+	checkCmd.AddCmd(&ishell.Cmd{Name: "updates",
+		Help:    "check for Bridge updates. (aliases: u, v, version)",
+		Aliases: []string{"u", "version", "v"},
+		Func:    fe.checkUpdates,
+	})
+	checkCmd.AddCmd(&ishell.Cmd{Name: "internet",
+		Help:    "check internet connection. (aliases: i, conn, connection)",
+		Aliases: []string{"i", "con", "connection"},
+		Func:    fe.checkInternetConnection,
+	})
+	fe.AddCmd(checkCmd)
+
+	// Print info commands.
+	fe.AddCmd(&ishell.Cmd{Name: "log-dir",
+		Help:    "print path to directory with logs. (aliases: log, logs)",
+		Aliases: []string{"log", "logs"},
+		Func:    fe.printLogDir,
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "manual",
+		Help:    "print URL with instructions. (alias: man)",
+		Aliases: []string{"man"},
+		Func:    fe.printManual,
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "release-notes",
+		Help:    "print release notes. (aliases: notes, fixed-bugs, bugs, ver, version)",
+		Aliases: []string{"notes", "fixed-bugs", "bugs", "ver", "version"},
+		Func:    fe.printLocalReleaseNotes,
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "credits",
+		Help: "print used resources.",
+		Func: fe.printCredits,
+	})
+
+	// Account commands.
+	fe.AddCmd(&ishell.Cmd{Name: "list",
+		Help:    "print the list of accounts. (aliases: l, ls)",
+		Func:    fe.noAccountWrapper(fe.listAccounts),
+		Aliases: []string{"l", "ls"},
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "info",
+		Help:      "print the configuration for account. Use index or account name as parameter. (alias: i)",
+		Func:      fe.noAccountWrapper(fe.showAccountInfo),
+		Completer: fe.completeUsernames,
+		Aliases:   []string{"i"},
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "login",
+		Help:      "login procedure to add or connect account. Optionally use index or account as parameter. (aliases: a, add, con, connect)",
+		Func:      fe.loginAccount,
+		Aliases:   []string{"add", "a", "con", "connect"},
+		Completer: fe.completeUsernames,
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "logout",
+		Help:      "disconnect the account. Use index or account name as parameter. (aliases: d, disconnect)",
+		Func:      fe.noAccountWrapper(fe.logoutAccount),
+		Aliases:   []string{"d", "disconnect"},
+		Completer: fe.completeUsernames,
+	})
+	fe.AddCmd(&ishell.Cmd{Name: "delete",
+		Help:      "remove the account from keychain. Use index or account name as parameter. (aliases: del, rm, remove)",
+		Func:      fe.noAccountWrapper(fe.deleteAccount),
+		Aliases:   []string{"del", "rm", "remove"},
+		Completer: fe.completeUsernames,
+	})
+
+	// System commands.
+	fe.AddCmd(&ishell.Cmd{Name: "restart",
+		Help: "restart the bridge.",
+		Func: fe.restart,
+	})
+
+	go func() {
+		defer panicHandler.HandlePanic()
+		fe.watchEvents()
+	}()
+	fe.eventListener.RetryEmit(events.TLSCertIssue)
+	fe.eventListener.RetryEmit(events.ErrorEvent)
+	return fe
+}
+
+func (f *frontendCLI) watchEvents() {
+	errorCh := f.getEventChannel(events.ErrorEvent)
+	internetOffCh := f.getEventChannel(events.InternetOffEvent)
+	internetOnCh := f.getEventChannel(events.InternetOnEvent)
+	addressChangedCh := f.getEventChannel(events.AddressChangedEvent)
+	addressChangedLogoutCh := f.getEventChannel(events.AddressChangedLogoutEvent)
+	logoutCh := f.getEventChannel(events.LogoutEvent)
+	certIssue := f.getEventChannel(events.TLSCertIssue)
+	for {
+		select {
+		case errorDetails := <-errorCh:
+			f.Println("Bridge failed:", errorDetails)
+		case <-internetOffCh:
+			f.notifyInternetOff()
+		case <-internetOnCh:
+			f.notifyInternetOn()
+		case address := <-addressChangedCh:
+			f.Printf("Address changed for %s. You may need to reconfigure your email client.", address)
+		case address := <-addressChangedLogoutCh:
+			f.notifyLogout(address)
+		case userID := <-logoutCh:
+			user, err := f.bridge.GetUser(userID)
+			if err != nil {
+				return
+			}
+			f.notifyLogout(user.Username())
+		case <-certIssue:
+			f.notifyCertIssue()
+		}
+	}
+}
+
+func (f *frontendCLI) getEventChannel(event string) <-chan string {
+	ch := make(chan string)
+	f.eventListener.Add(event, ch)
+	return ch
+}
+
+// IsAppRestarting returns whether the app is currently set to restart.
+func (f *frontendCLI) IsAppRestarting() bool {
+	return f.appRestart
+}
+
+// Loop starts the frontend loop with an interactive shell.
+func (f *frontendCLI) Loop(credentialsError error) error {
+	if credentialsError != nil {
+		f.notifyCredentialsError()
+		return credentialsError
+	}
+
+	f.preferences.SetBool(preferences.FirstStartKey, false)
+
+	f.Print(`
+            Welcome to ProtonMail Bridge interactive shell
+                              ___....___
+    ^^                __..-:'':__:..:__:'':-..__
+                  _.-:__:.-:'':  :  :  :'':-.:__:-._
+                .':.-:  :  :  :  :  :  :  :  :  :._:'.
+             _ :.':  :  :  :  :  :  :  :  :  :  :  :'.: _
+            [ ]:  :  :  :  :  :  :  :  :  :  :  :  :  :[ ]
+            [ ]:  :  :  :  :  :  :  :  :  :  :  :  :  :[ ]
+   :::::::::[ ]:__:__:__:__:__:__:__:__:__:__:__:__:__:[ ]:::::::::::
+   !!!!!!!!![ ]!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!![ ]!!!!!!!!!!!
+   ^^^^^^^^^[ ]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^[ ]^^^^^^^^^^^
+            [ ]                                        [ ]
+            [ ]                                        [ ]
+      jgs   [ ]                                        [ ]
+    ~~^_~^~/   \~^-~^~ _~^-~_^~-^~_^~~-^~_~^~-~_~-^~_^/   \~^ ~~_ ^
+`)
+	f.Run()
+	return nil
+}

internal/frontend/cli/system.go

@@ -0,0 +1,164 @@
+// 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 cli
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/preferences"
+	"github.com/ProtonMail/proton-bridge/pkg/connection"
+	"github.com/ProtonMail/proton-bridge/pkg/ports"
+	"github.com/abiosoft/ishell"
+)
+
+var (
+	currentPort = "" //nolint[gochecknoglobals]
+)
+
+func (f *frontendCLI) restart(c *ishell.Context) {
+	if f.yesNoQuestion("Are you sure you want to restart the Bridge") {
+		f.Println("Restarting Bridge...")
+		f.appRestart = true
+		f.Stop()
+	}
+}
+
+func (f *frontendCLI) checkInternetConnection(c *ishell.Context) {
+	if connection.CheckInternetConnection() == nil {
+		f.Println("Internet connection is available.")
+	} else {
+		f.Println("Can not contact server please check you internet connection.")
+	}
+}
+
+func (f *frontendCLI) printLogDir(c *ishell.Context) {
+	f.Println("Log files are stored in\n\n ", f.config.GetLogDir())
+}
+
+func (f *frontendCLI) printManual(c *ishell.Context) {
+	f.Println("More instructions about the Bridge can be found at\n\n  https://protonmail.com/bridge")
+}
+
+func (f *frontendCLI) deleteCache(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	if !f.yesNoQuestion("Do you really want to remove all stored preferences") {
+		return
+	}
+	if err := f.bridge.ClearData(); err != nil {
+		f.printAndLogError("Cache clear failed: ", err.Error())
+		return
+	}
+	f.Println("Cached cleared, restarting bridge")
+	// Clearing data removes everything (db, preferences, ...)
+	// so everything has to be stopped and started again.
+	f.appRestart = true
+	f.Stop()
+}
+
+func (f *frontendCLI) changeSMTPSecurity(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	isSSL := f.preferences.GetBool(preferences.SMTPSSLKey)
+	newSecurity := "SSL"
+	if isSSL {
+		newSecurity = "STARTTLS"
+	}
+
+	msg := fmt.Sprintf("Are you sure you want to change SMTP setting to %q and restart the Bridge", newSecurity)
+
+	if f.yesNoQuestion(msg) {
+		f.preferences.SetBool(preferences.SMTPSSLKey, !isSSL)
+		f.Println("Restarting Bridge...")
+		f.appRestart = true
+		f.Stop()
+	}
+}
+
+func (f *frontendCLI) changePort(c *ishell.Context) {
+	f.ShowPrompt(false)
+	defer f.ShowPrompt(true)
+
+	currentPort = f.preferences.Get(preferences.IMAPPortKey)
+	newIMAPPort := f.readStringInAttempts("Set IMAP port (current "+currentPort+")", c.ReadLine, f.isPortFree)
+	if newIMAPPort == "" {
+		newIMAPPort = currentPort
+	}
+	imapPortChanged := newIMAPPort != currentPort
+
+	currentPort = f.preferences.Get(preferences.SMTPPortKey)
+	newSMTPPort := f.readStringInAttempts("Set SMTP port (current "+currentPort+")", c.ReadLine, f.isPortFree)
+	if newSMTPPort == "" {
+		newSMTPPort = currentPort
+	}
+	smtpPortChanged := newSMTPPort != currentPort
+
+	if newIMAPPort == newSMTPPort {
+		f.Println("SMTP and IMAP ports must be different!")
+		return
+	}
+
+	if imapPortChanged || smtpPortChanged {
+		f.Println("Saving values IMAP:", newIMAPPort, "SMTP:", newSMTPPort)
+		f.preferences.Set(preferences.IMAPPortKey, newIMAPPort)
+		f.preferences.Set(preferences.SMTPPortKey, newSMTPPort)
+		f.Println("Restarting Bridge...")
+		f.appRestart = true
+		f.Stop()
+	} else {
+		f.Println("Nothing changed")
+	}
+}
+
+func (f *frontendCLI) toggleAllowProxy(c *ishell.Context) {
+	if f.preferences.GetBool(preferences.AllowProxyKey) {
+		f.Println("Bridge is currently set to use alternative routing to connect to Proton if it is being blocked.")
+		if f.yesNoQuestion("Are you sure you want to stop bridge from doing this") {
+			f.preferences.SetBool(preferences.AllowProxyKey, false)
+			bridge.DisallowDoH()
+		}
+	} else {
+		f.Println("Bridge is currently set to NOT use alternative routing to connect to Proton if it is being blocked.")
+		if f.yesNoQuestion("Are you sure you want to allow bridge to do this") {
+			f.preferences.SetBool(preferences.AllowProxyKey, true)
+			bridge.AllowDoH()
+		}
+	}
+}
+
+func (f *frontendCLI) isPortFree(port string) bool {
+	port = strings.Replace(port, ":", "", -1)
+	if port == "" || port == currentPort {
+		return true
+	}
+	number, err := strconv.Atoi(port)
+	if err != nil || number < 0 || number > 65535 {
+		f.Println("Input", port, "is not a valid port number.")
+		return false
+	}
+	if !ports.IsPortFree(number) {
+		f.Println("Port", number, "is occupied by another process.")
+		return false
+	}
+	return true
+}

internal/frontend/cli/updates.go

@@ -0,0 +1,65 @@
+// 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 cli
+
+import (
+	"strings"
+
+	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/pkg/updates"
+	"github.com/abiosoft/ishell"
+)
+
+func (f *frontendCLI) checkUpdates(c *ishell.Context) {
+	isUpToDate, latestVersionInfo, err := f.updates.CheckIsBridgeUpToDate()
+	if err != nil {
+		f.printAndLogError("Cannot retrieve version info: ", err)
+		f.checkInternetConnection(c)
+		return
+	}
+	if isUpToDate {
+		f.Println("Your version is up to date.")
+	} else {
+		f.notifyNeedUpgrade()
+		f.Println("")
+		f.printReleaseNotes(latestVersionInfo)
+	}
+}
+
+func (f *frontendCLI) printLocalReleaseNotes(c *ishell.Context) {
+	localVersion := f.updates.GetLocalVersion()
+	f.printReleaseNotes(localVersion)
+}
+
+func (f *frontendCLI) printReleaseNotes(versionInfo updates.VersionInfo) {
+	f.Println(bold("ProtonMail Bridge "+versionInfo.Version), "\n")
+	if versionInfo.ReleaseNotes != "" {
+		f.Println(bold("Release Notes"))
+		f.Println(versionInfo.ReleaseNotes)
+	}
+	if versionInfo.ReleaseFixedBugs != "" {
+		f.Println(bold("Fixed bugs"))
+		f.Println(versionInfo.ReleaseFixedBugs)
+	}
+}
+
+func (f *frontendCLI) printCredits(c *ishell.Context) {
+	for _, pkg := range strings.Split(bridge.Credits, ";") {
+		f.Println(pkg)
+	}
+}

internal/frontend/cli/utils.go

@@ -0,0 +1,123 @@
+// 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 cli
+
+import (
+	"strings"
+
+	pmapi "github.com/ProtonMail/proton-bridge/pkg/pmapi"
+	"github.com/fatih/color"
+)
+
+const (
+	maxInputRepeat = 2
+)
+
+var (
+	bold = color.New(color.Bold).SprintFunc() //nolint[gochecknoglobals]
+)
+
+func isNotEmpty(val string) bool {
+	return val != ""
+}
+
+func (f *frontendCLI) yesNoQuestion(question string) bool {
+	f.Print(question, "? yes/"+bold("no")+": ")
+	yes := "yes"
+	answer := strings.ToLower(f.ReadLine())
+	for i := 0; i < len(answer); i++ {
+		if i >= len(yes) || answer[i] != yes[i] {
+			return false // Everything else is false.
+		}
+	}
+	return len(answer) > 0 // Empty is false.
+}
+
+func (f *frontendCLI) readStringInAttempts(title string, readFunc func() string, isOK func(string) bool) (value string) {
+	f.Printf("%s: ", title)
+	value = readFunc()
+	title = strings.ToLower(string(title[0])) + title[1:]
+	for i := 0; !isOK(value); i++ {
+		if i >= maxInputRepeat {
+			f.Println("Too many attempts")
+			return ""
+		}
+		f.Printf("Please fill %s: ", title)
+		value = readFunc()
+	}
+	return
+}
+
+func (f *frontendCLI) printAndLogError(args ...interface{}) {
+	log.Error(args...)
+	f.Println(args...)
+}
+
+func (f *frontendCLI) processAPIError(err error) {
+	log.Warn("API error: ", err)
+	switch err {
+	case pmapi.ErrAPINotReachable:
+		f.notifyInternetOff()
+	case pmapi.ErrUpgradeApplication:
+		f.notifyNeedUpgrade()
+	default:
+		f.Println("Server error:", err.Error())
+	}
+}
+
+func (f *frontendCLI) notifyInternetOff() {
+	f.Println("Internet connection is not available.")
+}
+
+func (f *frontendCLI) notifyInternetOn() {
+	f.Println("Internet connection is available again.")
+}
+
+func (f *frontendCLI) notifyLogout(address string) {
+	f.Printf("Account %s is disconnected. Login to continue using this account with email client.", address)
+}
+
+func (f *frontendCLI) notifyNeedUpgrade() {
+	f.Println("Please download and install the newest version of application from", f.updates.GetDownloadLink())
+}
+
+func (f *frontendCLI) notifyCredentialsError() {
+	// Print in 80-column width.
+	f.Println("ProtonMail Bridge is not able to detect a supported password manager")
+	f.Println("(pass, gnome-keyring). Please install and set up a supported password manager")
+	f.Println("and restart the application.")
+}
+
+func (f *frontendCLI) notifyCertIssue() {
+	// Print in 80-column width.
+	f.Println(`Connection security error: Your network connection to Proton services may
+be insecure.
+
+Description:
+ProtonMail Bridge was not able to establish a secure connection to Proton
+servers due to a TLS certificate error. This means your connection may
+potentially be insecure and susceptible to monitoring by third parties.
+
+Recommendation:
+* If you trust your network operator, you can continue to use ProtonMail
+  as usual.
+* If you don't trust your network operator, reconnect to ProtonMail over a VPN
+  (such as ProtonVPN) which encrypts your Internet connection, or use
+  a different network to access ProtonMail.
+`)
+}