link to forked keyring and bring back vault command

cli/packages/cmd/login.go

@@ -107,7 +107,7 @@ var loginCmd = &cobra.Command{
 
 		//call browser login function
 		if !interactiveLogin {
-			fmt.Printf("\nLogging in via browser... Hit '%s' to cancel\n", QUIT_BROWSER_LOGIN)
+			fmt.Println("Logging in via browser... To login via interactive mode run [infisical login -i]")
 			userCredentialsToBeStored, err = browserCliLogin()
 			if err != nil {
 				//default to cli login on error
@@ -540,7 +540,12 @@ func browserCliLogin() (models.UserCredentials, error) {
 	quit := make(chan bool)
 
 	//terminal state
-	var oldState term.State
+	oldState, err := term.GetState(int(os.Stdin.Fd()))
+	if err != nil {
+		return models.UserCredentials{}, err
+	}
+
+	defer restoreTerminal(oldState)
 
 	//create handler
 	c := cors.New(cors.Options{
@@ -553,29 +558,25 @@ func browserCliLogin() (models.UserCredentials, error) {
 	corsHandler := c.Handler(browserLoginHandler(success, failure))
 
 	log.Debug().Msgf("Callback server listening on port %d", callbackPort)
-	go quitBrowserLogin(quit, &oldState)
+
 	go http.Serve(listener, corsHandler)
 
 	for {
 		select {
 		case loginResponse := <-success:
-			err = closeListener(&listener)
-			restoreTerminal(&oldState)
+			_ = closeListener(&listener)
 			return loginResponse, nil
 
-		case err = <-failure:
+		case <-failure:
 			err = closeListener(&listener)
-			restoreTerminal(&oldState)
 			return models.UserCredentials{}, err
 
-		case _ = <-timeout:
-			err = closeListener(&listener)
-			restoreTerminal(&oldState)
+		case <-timeout:
+			_ = closeListener(&listener)
 			return models.UserCredentials{}, errors.New("server timeout")
 
-		case _ = <-quit:
+		case <-quit:
 			return models.UserCredentials{}, errors.New("quitting browser login, defaulting to cli...")
-
 		}
 	}
 }
@@ -584,25 +585,24 @@ func restoreTerminal(oldState *term.State) {
 	term.Restore(int(os.Stdin.Fd()), oldState)
 }
 
-// listens to 'q' input on terminal and
-// sends 'true' to 'quit' channel
-func quitBrowserLogin(quit chan bool, oState *term.State) {
-	//
-	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
-	if err != nil {
-		return
-	}
-	*oState = *oldState
-	defer restoreTerminal(oldState)
-	b := make([]byte, 1)
-	for {
-		_, _ = os.Stdin.Read(b)
-		if string(b) == QUIT_BROWSER_LOGIN {
-			quit <- true
-			break
-		}
-	}
-}
+// // listens to 'q' input on terminal and
+// // sends 'true' to 'quit' channel
+// func quitBrowserLogin(quit chan bool, oState *term.State) {
+// 	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
+// 	if err != nil {
+// 		return
+// 	}
+// 	*oState = *oldState
+// 	defer restoreTerminal(oldState)
+// 	b := make([]byte, 1)
+// 	for {
+// 		_, _ = os.Stdin.Read(b)
+// 		if string(b) == QUIT_BROWSER_LOGIN {
+// 			quit <- true
+// 			break
+// 		}
+// 	}
+// }
 
 func closeListener(listener *net.Listener) error {
 	err := (*listener).Close()

cli/packages/cmd/reset.go

@@ -18,6 +18,12 @@ var resetCmd = &cobra.Command{
 	Example:               "infisical reset",
 	Args:                  cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
+		// delete keyring item of current logged in user
+		configFile, _ := util.GetConfigFile()
+
+		// delete from keyring
+		util.DeleteValueInKeyring(configFile.LoggedInUserEmail)
+
 		// delete config
 		_, pathToDir, err := util.GetFullConfigFilePath()
 		if err != nil {

cli/packages/cmd/vault.go

@@ -0,0 +1,93 @@
+/*
+Copyright (c) 2023 Infisical Inc.
+*/
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/Infisical/infisical-merge/packages/util"
+	"github.com/posthog/posthog-go"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+var AvailableVaultsAndDescriptions = []string{"auto (automatically select native vault on system)", "file (encrypted file vault)"}
+var AvailableVaults = []string{"auto", "file"}
+
+var vaultSetCmd = &cobra.Command{
+	Example:               `infisical vault set pass`,
+	Use:                   "set [vault-name]",
+	Short:                 "Used to set the vault backend to store your login details securely at rest",
+	DisableFlagsInUseLine: true,
+	Args:                  cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		wantedVaultTypeName := args[0]
+		currentVaultBackend, err := util.GetCurrentVaultBackend()
+		if err != nil {
+			log.Error().Msgf("Unable to set vault to [%s] because of [err=%s]", wantedVaultTypeName, err)
+			return
+		}
+
+		if wantedVaultTypeName == string(currentVaultBackend) {
+			log.Error().Msgf("You are already on vault backend [%s]", currentVaultBackend)
+			return
+		}
+
+		if wantedVaultTypeName == "auto" || wantedVaultTypeName == "file" {
+			configFile, err := util.GetConfigFile()
+			if err != nil {
+				log.Error().Msgf("Unable to set vault to [%s] because of [err=%s]", wantedVaultTypeName, err)
+				return
+			}
+
+			configFile.VaultBackendType = wantedVaultTypeName // save selected vault
+			configFile.LoggedInUserEmail = ""                 // reset the logged in user to prompt them to re login
+
+			err = util.WriteConfigFile(&configFile)
+			if err != nil {
+				log.Error().Msgf("Unable to set vault to [%s] because an error occurred when saving the config file [err=%s]", wantedVaultTypeName, err)
+				return
+			}
+
+			fmt.Printf("\nSuccessfully, switched vault backend from [%s] to [%s]. Please login in again to store your login details in the new vault with [infisical login]\n", currentVaultBackend, wantedVaultTypeName)
+
+			Telemetry.CaptureEvent("cli-command:vault set", posthog.NewProperties().Set("currentVault", currentVaultBackend).Set("wantedVault", wantedVaultTypeName).Set("version", util.CLI_VERSION))
+		} else {
+			log.Error().Msgf("The requested vault type [%s] is not available on this system. Only the following vault backends are available for you system: %s", wantedVaultTypeName, strings.Join(AvailableVaults, ", "))
+		}
+	},
+}
+
+// runCmd represents the run command
+var vaultCmd = &cobra.Command{
+	Use:                   "vault",
+	Short:                 "Used to manage where your Infisical login token is saved on your machine",
+	DisableFlagsInUseLine: true,
+	Args:                  cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		printAvailableVaultBackends()
+	},
+}
+
+func printAvailableVaultBackends() {
+	fmt.Printf("Vaults are used to securely store your login details locally. Available vaults:")
+	for _, backend := range AvailableVaultsAndDescriptions {
+		fmt.Printf("\n- %s", backend)
+	}
+
+	currentVaultBackend, err := util.GetCurrentVaultBackend()
+	if err != nil {
+		log.Error().Msgf("printAvailableVaultBackends: unable to print the available vault backend because of error [err=%s]", err)
+	}
+
+	Telemetry.CaptureEvent("cli-command:vault", posthog.NewProperties().Set("currentVault", currentVaultBackend).Set("version", util.CLI_VERSION))
+
+	fmt.Printf("\n\nYou are currently using [%s] vault to store your login credentials\n", string(currentVaultBackend))
+}
+
+func init() {
+	vaultCmd.AddCommand(vaultSetCmd)
+	rootCmd.AddCommand(vaultCmd)
+}

cli/packages/models/cli.go

@@ -12,6 +12,7 @@ type ConfigFile struct {
 	LoggedInUserEmail  string         `json:"loggedInUserEmail"`
 	LoggedInUserDomain string         `json:"LoggedInUserDomain,omitempty"`
 	LoggedInUsers      []LoggedInUser `json:"loggedInUsers,omitempty"`
+	VaultBackendType   string         `json:"vaultBackendType,omitempty"`
 }
 
 type LoggedInUser struct {

cli/packages/util/config.go

@@ -53,6 +53,7 @@ func WriteInitalConfig(userCredentials *models.UserCredentials) error {
 		LoggedInUserEmail:  userCredentials.Email,
 		LoggedInUserDomain: config.INFISICAL_URL,
 		LoggedInUsers:      existingConfigFile.LoggedInUsers,
+		VaultBackendType:   existingConfigFile.VaultBackendType,
 	}
 
 	configFileMarshalled, err := json.Marshal(configFile)

cli/packages/util/credentials.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"strings"
 
-	keyringwrapper "github.com/Infisical/infisical-merge/internal"
 	"github.com/Infisical/infisical-merge/packages/api"
 	"github.com/Infisical/infisical-merge/packages/config"
 	"github.com/Infisical/infisical-merge/packages/models"
@@ -26,7 +25,7 @@ func StoreUserCredsInKeyRing(userCred *models.UserCredentials) error {
 		return fmt.Errorf("StoreUserCredsInKeyRing: something went wrong when marshalling user creds [err=%s]", err)
 	}
 
-	err = keyringwrapper.Set(userCred.Email, string(userCredMarshalled))
+	err = SetValueInKeyring(userCred.Email, string(userCredMarshalled))
 	if err != nil {
 		return fmt.Errorf("StoreUserCredsInKeyRing: unable to store user credentials because [err=%s]", err)
 	}
@@ -35,7 +34,7 @@ func StoreUserCredsInKeyRing(userCred *models.UserCredentials) error {
 }
 
 func GetUserCredsFromKeyRing(userEmail string) (credentials models.UserCredentials, err error) {
-	credentialsValue, err := keyringwrapper.Get(userEmail)
+	credentialsValue, err := GetValueInKeyring(userEmail)
 	if err != nil {
 		if err == keyring.ErrUnsupportedPlatform {
 			return models.UserCredentials{}, errors.New("your OS does not support keyring. Consider using a service token https://infisical.com/docs/documentation/platform/token")

cli/packages/util/keyringwrapper.go

@@ -0,0 +1,42 @@
+package util
+
+import (
+	"github.com/zalando/go-keyring"
+)
+
+const MAIN_KEYRING_SERVICE = "infisical-cli"
+
+type TimeoutError struct {
+	message string
+}
+
+func (e *TimeoutError) Error() string {
+	return e.message
+}
+
+func SetValueInKeyring(key, value string) error {
+	currentVaultBackend, err := GetCurrentVaultBackend()
+	if err != nil {
+		PrintErrorAndExit(1, err, "Unable to get current vault. Tip: run [infisical rest] then try again")
+	}
+
+	return keyring.Set(currentVaultBackend, MAIN_KEYRING_SERVICE, key, value)
+}
+
+func GetValueInKeyring(key string) (string, error) {
+	currentVaultBackend, err := GetCurrentVaultBackend()
+	if err != nil {
+		PrintErrorAndExit(1, err, "Unable to get current vault. Tip: run [infisical rest] then try again")
+	}
+
+	return keyring.Get(currentVaultBackend, MAIN_KEYRING_SERVICE, key)
+}
+
+func DeleteValueInKeyring(key string) error {
+	currentVaultBackend, err := GetCurrentVaultBackend()
+	if err != nil {
+		return err
+	}
+
+	return keyring.Delete(currentVaultBackend, MAIN_KEYRING_SERVICE, key)
+}

cli/packages/util/vault.go

@@ -0,0 +1,22 @@
+package util
+
+import (
+	"fmt"
+)
+
+func GetCurrentVaultBackend() (string, error) {
+	configFile, err := GetConfigFile()
+	if err != nil {
+		return "", fmt.Errorf("getCurrentVaultBackend: unable to get config file [err=%s]", err)
+	}
+
+	if configFile.VaultBackendType == "" {
+		return "auto", nil
+	}
+
+	if configFile.VaultBackendType != "auto" && configFile.VaultBackendType != "file" {
+		return "auto", nil
+	}
+
+	return configFile.VaultBackendType, nil
+}