Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(cli): classify keychain read failures as keychain_denied, not token_expired (#4684)

ydflow49a0ade98cdb
diff --git a/cli/internal/cmdutil/authrefresh.go b/cli/internal/cmdutil/authrefresh.go
index b8cc51eaf..1d6db251f 100644
--- a/cli/internal/cmdutil/authrefresh.go
+++ b/cli/internal/cmdutil/authrefresh.go
@@ -25,6 +25,12 @@ type Refresher interface {
// six-step sequence with subtly diverging error wording.
func RefreshAndPersist(ctx context.Context, store secrets.Store, refresher Refresher, profileName string) (string, error) {
refresh, err := store.Get(profileName, "refresh")
+ // A read failure means the local store is unusable (keychain denied,
+ // unreadable file) — a different failure from "no refresh token stored",
+ // and it must not send agents down the re-login path.
+ if err != nil && !errors.Is(err, secrets.ErrNotFound) {
+ return "", Wrapf(CodeLocalKeychainDenied, err, "load refresh token")
+ }
if errors.Is(err, secrets.ErrNotFound) || refresh == "" {
return "", &Error{
Code: CodeAuthTokenExpired,
@@ -32,9 +38,6 @@ func RefreshAndPersist(ctx context.Context, store secrets.Store, refresher Refre
Hint: "run `weknora auth login` to re-authenticate",
}
}
- if err != nil {
- return "", Wrapf(CodeLocalKeychainDenied, err, "load refresh token")
- }
resp, err := refresher.RefreshToken(ctx, refresh)
if err != nil {
diff --git a/cli/internal/cmdutil/authrefresh_keychain_test.go b/cli/internal/cmdutil/authrefresh_keychain_test.go
new file mode 100644
index 000000000..aacf9df73
--- /dev/null
+++ b/cli/internal/cmdutil/authrefresh_keychain_test.go
@@ -0,0 +1,93 @@
+package cmdutil
+
+import (
+ "context"
+ "errors"
+ "testing"
+
+ "github.com/Tencent/WeKnora/cli/internal/secrets"
+ sdk "github.com/Tencent/WeKnora/client"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// failingStore simulates a secrets backend that answers reads with a hard
+// error — macOS keychain denied, or a file store whose backing file is
+// unreadable. Set/Delete record calls so the happy path can assert writes.
+type failingStore struct {
+ getErr error
+ getValue string
+ sets [][2]string
+ deleteErr error
+}
+
+func (f *failingStore) Get(_, _ string) (string, error) {
+ return f.getValue, f.getErr
+}
+
+func (f *failingStore) Set(_ string, key, value string) error {
+ f.sets = append(f.sets, [2]string{key, value})
+ return nil
+}
+
+func (f *failingStore) Delete(_, _ string) error { return f.deleteErr }
+
+func (f *failingStore) Ref(_, _ string) string { return "" }
+
+type stubRefresher struct {
+ called bool
+ gotToken string
+ resp *sdk.RefreshTokenResponse
+ err error
+}
+
+func (s *stubRefresher) RefreshToken(_ context.Context, refreshToken string) (*sdk.RefreshTokenResponse, error) {
+ s.called = true
+ s.gotToken = refreshToken
+ return s.resp, s.err
+}
+
+// A keychain or file-store failure is a different failure from "no refresh
+// token stored": it must surface as local.keychain_denied (exit 1, "verify
+// keyring access"), not auth.token_expired (exit 3, "run auth login"), or an
+// agent following the hint re-logins without ever fixing the real problem.
+func TestRefreshAndPersistClassifiesStoreReadFailureAsKeychainDenied(t *testing.T) {
+ boom := errors.New("keychain access denied")
+ store := &failingStore{getErr: boom}
+ _, err := RefreshAndPersist(context.Background(), store, &stubRefresher{}, "prod")
+ require.Error(t, err)
+ var e *Error
+ require.ErrorAs(t, err, &e)
+ assert.Equal(t, CodeLocalKeychainDenied, e.Code)
+ assert.Equal(t, 1, ExitCode(e))
+ assert.Contains(t, err.Error(), "load refresh token")
+}
+
+// Missing-but-readable stays token_expired: the stored credential is gone,
+// re-login is the right recovery.
+func TestRefreshAndPersistMissingTokenStaysTokenExpired(t *testing.T) {
+ store := &failingStore{getErr: secrets.ErrNotFound}
+ _, err := RefreshAndPersist(context.Background(), store, &stubRefresher{}, "prod")
+ require.Error(t, err)
+ var e *Error
+ require.ErrorAs(t, err, &e)
+ assert.Equal(t, CodeAuthTokenExpired, e.Code)
+ assert.Equal(t, 3, ExitCode(e))
+}
+
+// Readable store with a stored token reaches the refresher and persists the
+// new pair.
+func TestRefreshAndPersistHappyPathRefreshesAndPersists(t *testing.T) {
+ store := &failingStore{getValue: "stored-refresh"}
+ refresher := &stubRefresher{resp: &sdk.RefreshTokenResponse{
+ Success: true, AccessToken: "new-access", RefreshToken: "new-refresh",
+ }}
+ access, err := RefreshAndPersist(context.Background(), store, refresher, "prod")
+ require.NoError(t, err)
+ assert.True(t, refresher.called)
+ assert.Equal(t, "stored-refresh", refresher.gotToken)
+ assert.Equal(t, "new-access", access)
+ require.Len(t, store.sets, 2)
+ assert.Equal(t, [2]string{"access", "new-access"}, store.sets[0])
+ assert.Equal(t, [2]string{"refresh", "new-refresh"}, store.sets[1])
+}