feat(cli): auth refresh + transparent 401 retry transport
Two halves of v0.3 roadmap item 3-2. (1) `weknora auth refresh` — explicit token renewal: Reads the stored refresh_token, spends it via POST /api/v1/auth/refresh (OAuth refresh-token grant), and persists both new tokens. API-key contexts rejected with input.invalid_argument (no refresh semantic). NOTE: gh CLI has `gh auth refresh` but with different semantics — gh's variant is an OAuth scope expansion / re-prompt via the browser (verified against the gh manual). The two share a name but solve different problems; there's no direct gh parallel for refresh-token grant because gh's PAT/OAuth-app model doesn't expose a short-lived access_token + refresh_token pair to clients. Error mapping: - no current context → auth.unauthenticated - --name unknown → local.context_not_found - missing refresh in keyring → auth.token_expired (hint: re-login) - server Success=false → auth.token_expired - network → network.error Envelope omits the token values (would leak into agent transcripts). (2) AuthRetryTransport — transparent retry: Wraps the SDK http.Client. On a 401 from a non-/auth/* endpoint: - JWT context: read refresh token, hit /auth/refresh, persist new pair, replay original request with new bearer. - API-key context: pass through (no refresh semantic). - Non-replayable body (req.GetBody == nil): pass through. - /auth/login or /auth/refresh: pass through (no recursion). Concurrent 401s are singleflight-coalesced via sync.Mutex — 5 parallel calls trigger exactly 1 refresh. SDK additions (additive, non-breaking): - WithTransport(rt http.RoundTripper) ClientOption. - PathAuthLogin / PathAuthRefresh constants (cli/internal/cmdutil/authretry imports them so the CLI and SDK can't drift on path strings). Refactor surfaced by the post-commit reviewer round: - cmdutil.RefreshAndPersist(ctx, store, refresher, ctxName) — the load-refresh → call-SDK → persist-pair sequence was duplicated between the standalone `auth refresh` and the transport's refresh closure; collapsed to one canonical implementation. - refreshFn signature takes context.Context so Ctrl+C during a transparent refresh cancels. - AuthRetryTransport.CurrentToken() removed — never called. 8 + 8 + 8 unit tests cover happy path / refresh-fail / auth-endpoint skip / api-key passthrough / singleflight under concurrency / non- replayable-body fallback. Roadmap: 3-2.
This commit is contained in:
@@ -0,0 +1,136 @@
|
||||
package cmdutil
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"net/http"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
sdk "github.com/Tencent/WeKnora/client"
|
||||
)
|
||||
|
||||
// AuthRetryTransport wraps a base http.RoundTripper with transparent
|
||||
// recovery from a single 401 response. On a 401 from an authenticated
|
||||
// (non-/auth/*) endpoint, it invokes refreshFn to obtain a new bearer
|
||||
// token, replays the original request with the new Authorization header,
|
||||
// and returns the replayed response.
|
||||
//
|
||||
// Behavior:
|
||||
// - 2xx / 4xx / 5xx other than 401: pass through unchanged.
|
||||
// - 401 on /api/v1/auth/login or /api/v1/auth/refresh: pass through
|
||||
// (otherwise a stale refresh token causes infinite recursion).
|
||||
// - 401 with no initial token configured (api-key contexts): pass through
|
||||
// — api-key credentials have no refresh semantic.
|
||||
// - 401 with non-replayable request body (req.GetBody == nil): pass
|
||||
// through. The SDK always uses bytes.Buffer bodies; this is a safety
|
||||
// net for hand-built requests.
|
||||
//
|
||||
// Concurrency: multiple goroutines may hit 401 simultaneously. The first
|
||||
// one through acquires the mutex and refreshes; subsequent waiters observe
|
||||
// the updated currentToken and replay without re-refreshing (singleflight).
|
||||
//
|
||||
// The transport intentionally shadows the SDK's bearerToken (set via
|
||||
// WithBearerToken). After a refresh, the SDK is unaware of the new token —
|
||||
// the transport's per-request override is the single source of truth for
|
||||
// the Authorization header. Tokens persisted to the secrets store happen
|
||||
// inside refreshFn (see cmdutil.RefreshAndPersist).
|
||||
type AuthRetryTransport struct {
|
||||
base http.RoundTripper
|
||||
|
||||
mu sync.Mutex
|
||||
currentToken string
|
||||
refreshFn func(context.Context) (string, error)
|
||||
}
|
||||
|
||||
// NewAuthRetryTransport builds a retry transport. initialToken seeds the
|
||||
// in-memory token state so the first request's Authorization header
|
||||
// agrees with whatever the SDK was constructed with.
|
||||
//
|
||||
// Pass an empty initialToken to indicate "no bearer credential configured"
|
||||
// (e.g. an api-key context). In that mode the transport never invokes
|
||||
// refreshFn — a 401 is propagated as-is.
|
||||
func NewAuthRetryTransport(base http.RoundTripper, initialToken string, refreshFn func(context.Context) (string, error)) *AuthRetryTransport {
|
||||
if base == nil {
|
||||
base = http.DefaultTransport
|
||||
}
|
||||
return &AuthRetryTransport{
|
||||
base: base,
|
||||
currentToken: initialToken,
|
||||
refreshFn: refreshFn,
|
||||
}
|
||||
}
|
||||
|
||||
// RoundTrip implements http.RoundTripper.
|
||||
func (t *AuthRetryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
|
||||
t.mu.Lock()
|
||||
token := t.currentToken
|
||||
t.mu.Unlock()
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
|
||||
resp, err := t.base.RoundTrip(req)
|
||||
if err != nil || resp.StatusCode != http.StatusUnauthorized {
|
||||
return resp, err
|
||||
}
|
||||
if token == "" {
|
||||
return resp, nil
|
||||
}
|
||||
if isAuthEndpoint(req.URL.Path) {
|
||||
return resp, nil
|
||||
}
|
||||
if req.Body != nil && req.GetBody == nil {
|
||||
return resp, nil
|
||||
}
|
||||
|
||||
// Singleflight: re-check whether another goroutine already refreshed.
|
||||
t.mu.Lock()
|
||||
if t.currentToken != token {
|
||||
token = t.currentToken
|
||||
t.mu.Unlock()
|
||||
} else {
|
||||
newToken, refreshErr := t.refreshFn(req.Context())
|
||||
if refreshErr != nil {
|
||||
t.mu.Unlock()
|
||||
drainAndClose(resp)
|
||||
return nil, refreshErr
|
||||
}
|
||||
t.currentToken = newToken
|
||||
token = newToken
|
||||
t.mu.Unlock()
|
||||
}
|
||||
|
||||
drainAndClose(resp)
|
||||
|
||||
replay := req.Clone(req.Context())
|
||||
if req.GetBody != nil {
|
||||
body, gberr := req.GetBody()
|
||||
if gberr != nil {
|
||||
return nil, gberr
|
||||
}
|
||||
replay.Body = body
|
||||
}
|
||||
replay.Header.Set("Authorization", "Bearer "+token)
|
||||
return t.base.RoundTrip(replay)
|
||||
}
|
||||
|
||||
// isAuthEndpoint reports whether path is one of the auth endpoints where
|
||||
// 401 retry would either recurse (refresh) or duplicate work (login). The
|
||||
// path constants are sourced from the SDK so the CLI and SDK can never
|
||||
// drift on the canonical paths.
|
||||
func isAuthEndpoint(path string) bool {
|
||||
return strings.HasPrefix(path, sdk.PathAuthLogin) ||
|
||||
strings.HasPrefix(path, sdk.PathAuthRefresh)
|
||||
}
|
||||
|
||||
// drainAndClose consumes the response body so the underlying connection
|
||||
// can be reused, then closes it. Errors are ignored because the response
|
||||
// is being discarded anyway.
|
||||
func drainAndClose(resp *http.Response) {
|
||||
if resp == nil || resp.Body == nil {
|
||||
return
|
||||
}
|
||||
_, _ = io.Copy(io.Discard, resp.Body)
|
||||
_ = resp.Body.Close()
|
||||
}
|
||||
Reference in New Issue
Block a user