diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 64285bd8..a2aca728 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -158,6 +158,9 @@ func ApiCmd(ch *cmdutil.Helper, userAgent string, defaultHeaders map[string]stri originalHost := req.URL.Hostname() redirectCheck := makeRedirectCheck(originalHost) + if err := ch.Config.LoadAccessToken(); err != nil { + return err + } var cl *http.Client if ch.Config.AccessToken != "" { // Create a transport chain that uses OAuth2 token but honors our redirect policy diff --git a/internal/cmd/auth/check.go b/internal/cmd/auth/check.go index 323138c6..2268d035 100644 --- a/internal/cmd/auth/check.go +++ b/internal/cmd/auth/check.go @@ -13,6 +13,9 @@ func CheckCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Check if you are authenticated", RunE: func(cmd *cobra.Command, args []string) error { + if err := ch.Config.LoadAccessToken(); err != nil { + return err + } ctx := cmd.Context() resp := buildAuthCheckResponse(ctx, ch) diff --git a/internal/cmd/auth/logout.go b/internal/cmd/auth/logout.go index e333b0f8..653248c5 100644 --- a/internal/cmd/auth/logout.go +++ b/internal/cmd/auth/logout.go @@ -2,6 +2,8 @@ package auth import ( "bufio" + "errors" + "fmt" "io" "github.com/planetscale/cli/internal/auth" @@ -23,7 +25,9 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Log out of the PlanetScale API", RunE: func(cmd *cobra.Command, args []string) error { - if ch.Config.AccessToken == "" { + // An unreadable token can't be revoked, but deleting it still logs out. + readErr := ch.Config.LoadStoredAccessToken() + if readErr == nil && ch.Config.AccessToken == "" { ch.Printer.Println("Already logged out. Exiting...") return nil } @@ -42,15 +46,20 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { end := ch.Printer.PrintProgress("Logging out...") defer end() - err = authenticator.RevokeToken(ctx, ch.Config.AccessToken) - if err != nil { - return err + if readErr == nil { + err = authenticator.RevokeToken(ctx, ch.Config.AccessToken) + if err != nil { + return err + } } err = config.DeleteAccessToken() if err != nil { - return err + return errors.Join(readErr, err) } end() + if readErr != nil { + fmt.Fprintf(cmd.ErrOrStderr(), "Warning: deleted the stored access token without revoking it: %v\n", readErr) + } ch.Printer.Println("Successfully logged out.") return nil diff --git a/internal/cmd/branch/connections/client.go b/internal/cmd/branch/connections/client.go index b15c8727..35fdf983 100644 --- a/internal/cmd/branch/connections/client.go +++ b/internal/cmd/branch/connections/client.go @@ -146,6 +146,9 @@ func branchIsProduction(ctx context.Context, ch *cmdutil.Helper, database, branc } func newConnectionsClient(ch *cmdutil.Helper, database, branch string, target ConnectionTarget) (*live.Client, error) { + if err := ch.Config.LoadAccessToken(); err != nil { + return nil, err + } return live.NewClient(live.ClientConfig{ BaseURL: ch.Config.BaseURL, Organization: ch.Config.Organization, diff --git a/internal/cmd/root.go b/internal/cmd/root.go index eb428a71..c58a35ce 100644 --- a/internal/cmd/root.go +++ b/internal/cmd/root.go @@ -188,15 +188,12 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer. rootCmd.Flags().BoolVar(&skillFlag, "skill", false, "Print the agent skill file and exit") - cfg, err := config.New() - if err != nil { - return err - } + cfg := config.New() rootCmd.PersistentFlags().StringVar(&cfg.BaseURL, "api-url", ps.DefaultBaseURL, "The base URL for the PlanetScale API.") rootCmd.PersistentFlags().StringVar(&cfg.AccessToken, - "api-token", cfg.AccessToken, "The API token to use for authenticating against the PlanetScale API.") + "api-token", "", "The API token to use for authenticating against the PlanetScale API.") rootCmd.PersistentFlags().VarP(printer.NewFormatValue(printer.Human, format), "format", "f", "Show output in a specific format. Possible values: [human, json, csv]") @@ -242,9 +239,6 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer. rootCmd.PersistentFlags().MarkDeprecated("service-token-name", "use --service-token-id instead") rootCmd.PersistentFlags().MarkHidden("service-token-name") - // We don't want to show the default value - rootCmd.PersistentFlags().Lookup("api-token").DefValue = "" - // Add command groups for better organization // Every command's help/usage output ends with a pointer to the embedded // agent guide, so agents that discover pscale via --help (rather than a diff --git a/internal/cmd/root_test.go b/internal/cmd/root_test.go index 8865423d..9a7e3b3f 100644 --- a/internal/cmd/root_test.go +++ b/internal/cmd/root_test.go @@ -3,6 +3,7 @@ package cmd import ( "bytes" "context" + "encoding/json" "errors" "os" "os/exec" @@ -10,6 +11,7 @@ import ( "strings" "testing" + "github.com/99designs/keyring" "github.com/planetscale/cli/internal/cmd/agentguide" "github.com/planetscale/cli/internal/cmdutil" "github.com/spf13/cobra" @@ -28,6 +30,58 @@ func TestAddCommandGroupsOmitsNeki(t *testing.T) { const rootCLIHelperEnv = "PSCALE_ROOT_CLI_HELPER" +func TestStoredTokenLoadingIsLazyAndReportsJSONErrors(t *testing.T) { + for _, backend := range keyring.AvailableBackends() { + switch backend { + case keyring.KeychainBackend, keyring.SecretServiceBackend, keyring.KWalletBackend, keyring.WinCredBackend: + t.Skip("requires file fallback; run with CGO_ENABLED=0 on macOS") + } + } + home := writeHomeConfig(t, "") + // Reading a directory as a token reliably fails without touching a keychain. + if err := os.Mkdir(filepath.Join(home, ".config", "planetscale", "access-token"), 0o700); err != nil { + t.Fatal(err) + } + for _, args := range [][]string{ + {"--help", "--format", "json"}, + {"--version", "--format", "json"}, + {"--skill", "--format", "json"}, + } { + result := runRootCLIWithHome(t, home, args...) + if result.exitCode != 0 { + t.Fatalf("%v loaded stored credentials: stdout=%q stderr=%q", args, result.stdout, result.stderr) + } + } + for _, args := range [][]string{ + {"org", "list", "--format", "json"}, + {"auth", "check", "--format", "json"}, + } { + result := runRootCLIWithHome(t, home, args...) + if result.exitCode != cmdutil.FatalErrExitCode { + t.Fatalf("%v exit code = %d, stdout=%q stderr=%q", args, result.exitCode, result.stdout, result.stderr) + } + var resp struct { + Status string `json:"status"` + Error string `json:"error"` + Issues []any `json:"issues"` + NextSteps []string `json:"next_steps"` + } + if err := json.Unmarshal([]byte(result.stdout), &resp); err != nil { + t.Fatalf("%v did not return one JSON envelope: %v, stdout=%q", args, err, result.stdout) + } + if resp.Status != "error" || !strings.Contains(resp.Error, "access-token") || len(resp.Issues) == 0 || len(resp.NextSteps) == 0 { + t.Fatalf("%v invalid JSON error envelope: %s", args, result.stdout) + } + } + result := runRootCLIWithHome(t, home, "auth", "logout", "--format", "json") + if result.exitCode != 0 { + t.Fatalf("auth logout exit code = %d, stdout=%q stderr=%q", result.exitCode, result.stdout, result.stderr) + } + if _, err := os.Stat(filepath.Join(home, ".config", "planetscale", "access-token")); !os.IsNotExist(err) { + t.Fatalf("auth logout left unreadable token in place: %v", err) + } +} + func TestRootSkillFlag(t *testing.T) { for _, args := range [][]string{ {"--skill", "--format", "json"}, diff --git a/internal/cmdutil/cmdutil.go b/internal/cmdutil/cmdutil.go index 94734b9b..71fc569d 100644 --- a/internal/cmdutil/cmdutil.go +++ b/internal/cmdutil/cmdutil.go @@ -166,6 +166,9 @@ func WarnDeprecated(name, message string, next func(cmd *cobra.Command, args []s // actionable error message. func CheckAuthentication(cfg *config.Config) func(cmd *cobra.Command, args []string) error { return func(cmd *cobra.Command, args []string) error { + if err := cfg.LoadAccessToken(); err != nil { + return err + } if err := cfg.IsAuthenticated(); err != nil { if commandFormat(cmd) == printer.JSON.String() { resp := struct { diff --git a/internal/config/config.go b/internal/config/config.go index 60303875..0e0ae483 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -7,6 +7,7 @@ import ( "os" "path/filepath" "strings" + "sync" "github.com/99designs/keyring" ps "github.com/planetscale/cli/internal/planetscale" @@ -34,21 +35,41 @@ type Config struct { ServiceTokenID string ServiceToken string + loadAccessToken func() (string, error) + // Project Configuration Database string Branch string } -func New() (*Config, error) { - accessToken, err := readAccessToken() - if err != nil { - return nil, err +func New() *Config { + return &Config{ + BaseURL: ps.DefaultBaseURL, + loadAccessToken: sync.OnceValues(readAccessToken), } +} - return &Config{ - AccessToken: accessToken, - BaseURL: ps.DefaultBaseURL, - }, nil +// LoadAccessToken fills AccessToken from credential storage unless explicit +// credentials were provided. +func (c *Config) LoadAccessToken() error { + if c.ServiceTokenID != "" || c.ServiceToken != "" { + return nil + } + return c.LoadStoredAccessToken() +} + +// LoadStoredAccessToken fills AccessToken from credential storage unless an +// access token was provided, even when service token credentials are set. +func (c *Config) LoadStoredAccessToken() error { + if c.AccessToken != "" || c.loadAccessToken == nil { + return nil + } + token, err := c.loadAccessToken() + if err != nil { + return err + } + c.AccessToken = token + return nil } func (c *Config) IsAuthenticated() error { @@ -63,6 +84,9 @@ func (c *Config) IsAuthenticated() error { if c.ServiceTokenIsSet() { return nil } + if err := c.LoadAccessToken(); err != nil { + return err + } if c.AccessToken == "" { return errors.New("you must run 'pscale auth login' to authenticate before using this command") @@ -92,6 +116,9 @@ func (c *Config) NewClientFromConfig(clientOpts ...ps.ClientOption) (*ps.Client, if c.ServiceTokenIsSet() { opts = append(opts, ps.WithServiceToken(c.ServiceTokenID, c.ServiceToken)) } else { + if err := c.LoadAccessToken(); err != nil { + return nil, err + } opts = append(opts, ps.WithAccessToken(c.AccessToken)) } opts = append(opts, clientOpts...) @@ -175,7 +202,10 @@ func readAccessToken() (string, error) { if errors.Is(err, keyring.ErrKeyNotFound) { // Migrate to keychain accessToken, tokenErr := readAccessTokenPath() - if len(accessToken) > 0 && tokenErr == nil { + if tokenErr != nil && !os.IsNotExist(tokenErr) { + return "", tokenErr + } + if len(accessToken) > 0 { return migrateAccessToken(ring, accessToken) } // Might need to improve this, but today the empty @@ -229,10 +259,19 @@ func DeleteAccessToken() error { return deleteAccessTokenPath() } - return ring.Remove(keyringKey) + // Remove the token file left by keyring migration so a later read + // doesn't migrate it back or fail on it. + if err := deleteAccessTokenFile(); err != nil { + return err + } + err = ring.Remove(keyringKey) + if err != nil && !errors.Is(err, keyring.ErrKeyNotFound) { + return err + } + return nil } -func openKeyring() (keyring.Keyring, error) { +var openKeyring = func() (keyring.Keyring, error) { return keyring.Open(keyring.Config{ AllowedBackends: []keyring.BackendType{ keyring.SecretServiceBackend, @@ -264,9 +303,6 @@ func readAccessTokenPath() ([]byte, error) { stat, err := os.Stat(tokenPath) if err != nil { - if !os.IsNotExist(err) { - log.Fatal(err) - } return nil, err } else { if stat.Mode()&^tokenFileMode != 0 { @@ -277,24 +313,29 @@ func readAccessTokenPath() ([]byte, error) { } accessToken, err = os.ReadFile(tokenPath) if err != nil { - log.Fatal(err) + return nil, err } } return accessToken, nil } -func deleteAccessTokenPath() error { +func deleteAccessTokenFile() error { tokenPath, err := accessTokenPath() if err != nil { return err } err = os.Remove(tokenPath) - if err != nil { - if !os.IsNotExist(err) { - return fmt.Errorf("error removing access token file: %w", err) - } + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("error removing access token file: %w", err) + } + return nil +} + +func deleteAccessTokenPath() error { + if err := deleteAccessTokenFile(); err != nil { + return err } configFile, err := DefaultConfigPath() diff --git a/internal/config/config_test.go b/internal/config/config_test.go new file mode 100644 index 00000000..e8eb8904 --- /dev/null +++ b/internal/config/config_test.go @@ -0,0 +1,130 @@ +package config + +import ( + "errors" + "os" + "path/filepath" + "sync" + "testing" + + "github.com/99designs/keyring" + "github.com/mitchellh/go-homedir" +) + +func TestAccessTokenLookupCached(t *testing.T) { + lookupErr := errors.New("keychain access denied") + for _, tt := range []struct { + name string + token string + err error + }{ + {name: "token", token: "stored-token"}, + {name: "empty"}, + {name: "failure", err: lookupErr}, + } { + t.Run(tt.name, func(t *testing.T) { + calls := 0 + cfg := New() + cfg.loadAccessToken = sync.OnceValues(func() (string, error) { + calls++ + return tt.token, tt.err + }) + if calls != 0 { + t.Fatal("constructor loaded credentials") + } + for range 2 { + if err := cfg.LoadAccessToken(); !errors.Is(err, tt.err) { + t.Fatalf("LoadAccessToken error = %v, want %v", err, tt.err) + } + if _, err := cfg.NewClientFromConfig(); tt.err != nil && !errors.Is(err, tt.err) { + t.Fatalf("NewClientFromConfig error = %v, want %v", err, tt.err) + } + if err := cfg.IsAuthenticated(); tt.err != nil && !errors.Is(err, tt.err) { + t.Fatalf("IsAuthenticated error = %v, want %v", err, tt.err) + } + } + if calls != 1 { + t.Fatalf("credential lookups = %d, want 1", calls) + } + if cfg.AccessToken != tt.token { + t.Fatalf("access token = %q, want %q", cfg.AccessToken, tt.token) + } + }) + } +} + +func TestExplicitCredentialsSkipAccessTokenLookup(t *testing.T) { + for _, tt := range []struct { + name, token, serviceID, serviceToken string + invalid bool + }{ + {name: "api token", token: "explicit-token"}, + {name: "service token", serviceID: "id", serviceToken: "secret"}, + {name: "missing service secret", serviceID: "id", invalid: true}, + {name: "missing service id", serviceToken: "secret", invalid: true}, + } { + t.Run(tt.name, func(t *testing.T) { + cfg := New() + cfg.AccessToken, cfg.ServiceTokenID, cfg.ServiceToken = tt.token, tt.serviceID, tt.serviceToken + cfg.loadAccessToken = func() (string, error) { + t.Fatal("explicit credentials opened the keychain") + return "", nil + } + if err := cfg.LoadAccessToken(); err != nil { + t.Fatal(err) + } + if err := cfg.IsAuthenticated(); (err != nil) != tt.invalid { + t.Fatalf("IsAuthenticated error = %v, invalid = %v", err, tt.invalid) + } + if _, err := cfg.NewClientFromConfig(); (err != nil) != tt.invalid { + t.Fatalf("NewClientFromConfig error = %v, invalid = %v", err, tt.invalid) + } + }) + } +} + +func TestStoredAccessTokenLoadsWithServiceToken(t *testing.T) { + cfg := New() + cfg.ServiceTokenID, cfg.ServiceToken = "id", "secret" + cfg.loadAccessToken = func() (string, error) { return "stored-token", nil } + if err := cfg.LoadAccessToken(); err != nil { + t.Fatal(err) + } + if cfg.AccessToken != "" { + t.Fatalf("LoadAccessToken loaded %q despite service token", cfg.AccessToken) + } + if err := cfg.LoadStoredAccessToken(); err != nil { + t.Fatal(err) + } + if cfg.AccessToken != "stored-token" { + t.Fatalf("access token = %q, want stored-token", cfg.AccessToken) + } +} + +func TestDeleteAccessTokenRemovesUnreadableTokenFile(t *testing.T) { + home := t.TempDir() + t.Setenv("HOME", home) + homedir.Reset() + t.Cleanup(homedir.Reset) + ring := keyring.NewArrayKeyring(nil) + original := openKeyring + openKeyring = func() (keyring.Keyring, error) { return ring, nil } + t.Cleanup(func() { openKeyring = original }) + + tokenPath := filepath.Join(home, ".config", "planetscale", "access-token") + if err := os.MkdirAll(tokenPath, 0o700); err != nil { + t.Fatal(err) + } + if _, err := readAccessToken(); err == nil { + t.Fatal("readAccessToken succeeded on an unreadable token file") + } + if err := DeleteAccessToken(); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(tokenPath); !os.IsNotExist(err) { + t.Fatalf("token file still exists: %v", err) + } + if token, err := readAccessToken(); token != "" || err != nil { + t.Fatalf("readAccessToken = %q, %v after delete", token, err) + } +}