History

fix(meta): unify credential minting and preserve auth lifecycle

Kenny committed 2 months ago

Commit 4a0131c1 parent 06660dd10 files · +391 −275Browse files

Unified · Split

10 files
  1. internal/api/handlers/management/api_tools.go +37 −175
  2. internal/api/handlers/management/api_tools_test.go +39 −5
  3. internal/auth/meta/meta.go +33 −26
  4. internal/auth/meta/meta_auth_test.go +61 −1
  5. internal/runtime/executor/meta_executor.go +10 −29
  6. internal/runtime/executor/meta_executor_test.go +148 −29
  7. sdk/cliproxy/auth/conductor_execution.go +29 −9
  8. sdk/cliproxy/auth/conductor_lifecycle.go +13 −1
  9. sdk/cliproxy/auth/metadata_merge.go +6 −0
  10. sdk/cliproxy/auth/metadata_merge_test.go +15 −0
internal/api/handlers/management/api_tools.go+37−175
@@ -11,12 +11,11 @@ import ( · 10 unmodified lines
1111 "time"
1212
1313 "github.com/gin-gonic/gin"
14− metaauth "github.com/router-for-me/CLIProxyAPI/v7/internal/auth/meta"
1514 "github.com/router-for-me/CLIProxyAPI/v7/internal/config"
15+ "github.com/router-for-me/CLIProxyAPI/v7/internal/runtime/executor"
1616 coreauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth"
1717 "github.com/router-for-me/CLIProxyAPI/v7/sdk/proxyutil"
1818 log "github.com/sirupsen/logrus"
19− "golang.org/x/sync/singleflight"
2019 )
2120
2221 const defaultAPICallTimeout = 60 * time.Second
@@ -360,8 +359,6 @@ func (h *Handler) refreshAntigravityOAuthAccessToken(ctx context.Context, auth * · 337 unmodified lines
360359 return strings.TrimSpace(tokenResp.AccessToken), nil
361360 }
362361
363−var metaManagementMintGroup singleflight.Group
364−
365362 func metaTokenFromAuth(auth *coreauth.Auth) string {
366363 if auth == nil {
367364 return ""
@@ -385,6 +382,29 @@ func metaTokenFromAuth(auth *coreauth.Auth) string { · 17 unmodified lines
385382 return ""
386383 }
387384
385+// metaManagementPreparer applies the tool's proxy override only to acquisition.
386+// The saved credential retains its configured proxy.
387+type metaManagementPreparer struct {
388+ executor *executor.MetaExecutor
389+ proxyURL string
390+}
391+
392+func (p metaManagementPreparer) ShouldPrepareRequestAuth(auth *coreauth.Auth) bool {
393+ return p.executor.ShouldPrepareRequestAuth(auth)
394+}
395+
396+func (p metaManagementPreparer) PrepareRequestAuth(ctx context.Context, auth *coreauth.Auth) (*coreauth.Auth, error) {
397+ proxyURL := auth.ProxyURL
398+ if strings.TrimSpace(p.proxyURL) != "" {
399+ auth.ProxyURL = p.proxyURL
400+ }
401+ updated, err := p.executor.PrepareRequestAuth(ctx, auth)
402+ if updated != nil {
403+ updated.ProxyURL = proxyURL
404+ }
405+ return updated, err
406+}
407+
388408 func (h *Handler) resolveMetaToken(ctx context.Context, auth *coreauth.Auth, requestProxyURL string) (string, error) {
389409 if ctx == nil {
390410 ctx = context.Background()
@@ -392,183 +412,25 @@ func (h *Handler) resolveMetaToken(ctx context.Context, auth *coreauth.Auth, req · 1 unmodified line
392412 if auth == nil {
393413 return "", nil
394414 }
395− if tok := metaTokenFromAuth(auth); tok != "" {
396− return tok, nil
415+ if token := metaTokenFromAuth(auth); token != "" {
416+ return token, nil
397417 }
398−
399− var dcaToken string
400− if !coreauth.IsConfigAPIKeyAuth(auth) {
401− if auth.Metadata != nil {
402− if d, ok := auth.Metadata["dca_token"].(string); ok && strings.TrimSpace(d) != "" {
403− dcaToken = strings.TrimSpace(d)
404− } else if t, ok := auth.Metadata["access_token"].(string); ok && strings.HasPrefix(strings.TrimSpace(t), "dca:") {
405− dcaToken = strings.TrimSpace(t)
406− }
407− }
408− if dcaToken == "" && auth.Attributes != nil {
409− if d := strings.TrimSpace(auth.Attributes["dca_token"]); d != "" {
410− dcaToken = d
411− } else if t := strings.TrimSpace(auth.Attributes["access_token"]); strings.HasPrefix(t, "dca:") {
412− dcaToken = t
413− }
414− }
418+ var cfg *config.Config
419+ if h != nil {
420+ cfg = h.cfg
415421 }
416−
417− if dcaToken == "" {
422+ preparer := metaManagementPreparer{executor: executor.NewMetaExecutor(cfg), proxyURL: requestProxyURL}
423+ if !preparer.ShouldPrepareRequestAuth(auth) {
418424 return "", nil
419425 }
420−
421− flightKey := firstNonEmptyString(&auth.ID, &dcaToken)
422−
423− mintRes, errMint, _ := metaManagementMintGroup.Do(flightKey, func() (any, error) {
424− if h != nil && h.authManager != nil {
425− var latest *coreauth.Auth
426− if auth.ID != "" {
427− if a, ok := h.authManager.GetByID(auth.ID); ok && a != nil {
428− latest = a
429− }
430− }
431− if latest == nil && auth.Index != "" {
432− latest = h.authByIndex(auth.Index)
433− }
434− if latest != nil {
435− if k := metaTokenFromAuth(latest); k != "" {
436− return k, nil
437− }
438− }
439− }
440−
441− proxyURL := firstNonEmptyString(&requestProxyURL, &auth.ProxyURL)
442− var cfg *config.Config
443− if h != nil {
444− cfg = h.cfg
445− }
446− authSvc := metaauth.NewMetaAuthWithProxyURL(cfg, proxyURL)
447− minted, err := authSvc.MintAPIKey(ctx, dcaToken)
448− if err != nil {
449− return "", fmt.Errorf("meta token mint failed: %w", err)
450− }
451− if minted == nil || minted.APIKey == "" {
452− return "", fmt.Errorf("meta token mint returned empty key")
453− }
454−
455− base := auth.Clone()
456− baseURL := ""
457− if auth.Attributes != nil {
458− baseURL = strings.TrimSpace(auth.Attributes["base_url"])
459− }
460− if baseURL == "" {
461− baseURL = stringValue(auth.Metadata, "base_url")
462− }
463− if baseURL == "" {
464− baseURL = stringValue(auth.Metadata, "api_base_url")
465− }
466− if baseURL == "" {
467− baseURL = metaauth.DefaultAPIBaseURL
468− }
469− if mintedURL := strings.TrimSpace(minted.BaseURL); mintedURL != "" {
470− baseURL = mintedURL
471− }
472− if auth.Metadata == nil {
473− auth.Metadata = make(map[string]any)
474− }
475− auth.Metadata["base_url"] = baseURL
476− auth.Metadata["api_key"] = minted.APIKey
477− auth.Metadata["access_token"] = minted.APIKey
478− auth.Metadata["dca_token"] = dcaToken
479− delete(auth.Metadata, "expired")
480− if minted.UserEmail != "" {
481− auth.Metadata["email"] = minted.UserEmail
482− }
483− if minted.UserFullName != "" {
484− auth.Metadata["name"] = minted.UserFullName
485− }
486− now := time.Now()
487− nowStr := now.Format(time.RFC3339)
488− auth.LastRefreshedAt = now
489− auth.UpdatedAt = now
490− auth.Metadata["last_refresh"] = nowStr
491−
492− if auth.Attributes == nil {
493− auth.Attributes = make(map[string]string)
494− }
495− auth.Attributes["base_url"] = baseURL
496− auth.Attributes["api_key"] = minted.APIKey
497− auth.Attributes["access_token"] = minted.APIKey
498−
499− storage := &metaauth.MetaTokenStorage{Type: "meta", AuthKind: "oauth"}
500− if existing, ok := auth.Storage.(*metaauth.MetaTokenStorage); ok && existing != nil {
501− copyStorage := *existing
502− storage = &copyStorage
503− }
504− storage.APIKey = minted.APIKey
505− storage.AccessToken = minted.APIKey
506− storage.DCAToken = dcaToken
507− storage.Expired = ""
508− storage.BaseURL = baseURL
509− storage.LastRefresh = nowStr
510− storage.Metadata = auth.Metadata
511− if minted.UserEmail != "" {
512− storage.Email = minted.UserEmail
513− }
514− if minted.UserFullName != "" {
515− storage.Name = minted.UserFullName
516− }
517− auth.Storage = storage
518−
519− // Use the configured backend; direct file writes bypass remote token stores.
520− if !coreauth.IsConfigAPIKeyAuth(auth) {
521− store := h.tokenStoreWithBaseDir()
522− if store == nil {
523− return "", fmt.Errorf("meta token store unavailable")
524− }
525− if _, errSave := store.Save(ctx, auth); errSave != nil {
526− return "", fmt.Errorf("persist meta token: %w", errSave)
527− }
528− }
529− if h != nil && h.authManager != nil {
530− if _, errUpdate := h.authManager.UpdateRefreshedAuth(coreauth.WithSkipPersist(ctx), base, auth); errUpdate != nil {
531− return "", fmt.Errorf("update meta auth: %w", errUpdate)
532− }
533− }
534−
535− return minted.APIKey, nil
536− })
537− if errMint != nil {
538− return "", errMint
426+ if h == nil || h.authManager == nil || auth.ID == "" {
427+ return "", fmt.Errorf("meta token mint requires a registered credential")
539428 }
540−
541− key, _ := mintRes.(string)
542− if h != nil && h.authManager != nil {
543− var latest *coreauth.Auth
544− if auth.ID != "" {
545− if a, ok := h.authManager.GetByID(auth.ID); ok && a != nil {
546− latest = a
547− }
548− }
549− if latest == nil && auth.Index != "" {
550− latest = h.authByIndex(auth.Index)
551− }
552− if latest != nil {
553− if auth.Metadata == nil {
554− auth.Metadata = make(map[string]any)
555− }
556− for k, v := range latest.Metadata {
557− auth.Metadata[k] = v
558− }
559− if auth.Attributes == nil {
560− auth.Attributes = make(map[string]string)
561− }
562− for k, v := range latest.Attributes {
563− auth.Attributes[k] = v
564− }
565− auth.Storage = latest.Storage
566− auth.LastRefreshedAt = latest.LastRefreshedAt
567− auth.UpdatedAt = latest.UpdatedAt
568− }
429+ updated, err := h.authManager.PrepareRequestAuth(ctx, preparer, auth)
430+ if err != nil {
431+ return "", err
569432 }
570−
571− return key, nil
433+ return metaTokenFromAuth(updated), nil
572434 }
573435
574436 func antigravityTokenNeedsRefresh(metadata map[string]any) bool {
internal/api/handlers/management/api_tools_test.go+39−5
@@ -6,7 +6,6 @@ import ( · 5 unmodified lines
66 "errors"
77 "net/http"
88 "net/http/httptest"
9− "runtime"
109 "strings"
1110 "sync"
1211 "sync/atomic"
@@ -14,6 +13,7 @@ import ( · 1 unmodified line
1413
1514 "github.com/gin-gonic/gin"
1615 "github.com/router-for-me/CLIProxyAPI/v7/internal/config"
16+ "github.com/router-for-me/CLIProxyAPI/v7/internal/runtime/executor"
1717 coreauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth"
1818 sdkconfig "github.com/router-for-me/CLIProxyAPI/v7/sdk/config"
1919 )
@@ -524,7 +524,15 @@ func TestResolveMetaToken_ConcurrentSingleflight(t *testing.T) { · 504 unmodified lines
524524 entryWg.Done()
525525 <-ready
526526 inFlight.Done()
527− token, errToken := h.resolveTokenForAuth(context.Background(), h.authByIndex(auth.Index), "")
527+ var token string
528+ var errToken error
529+ if i%2 == 0 {
530+ prepared, err := manager.PrepareRequestAuth(context.Background(), executor.NewMetaExecutor(h.cfg), auth.Clone())
531+ errToken = err
532+ token = metaTokenFromAuth(prepared)
533+ } else {
534+ token, errToken = h.resolveTokenForAuth(context.Background(), auth.Clone(), "")
535+ }
528536 if errToken != nil {
529537 t.Errorf("resolveTokenForAuth error: %v", errToken)
530538 }
@@ -539,9 +547,6 @@ func TestResolveMetaToken_ConcurrentSingleflight(t *testing.T) { · 8 unmodified lines
539547
540548 <-serverStarted
541549 inFlight.Wait()
542− for i := 0; i < 50; i++ {
543− runtime.Gosched()
544− }
545550 close(releaseServer)
546551 doneWg.Wait()
547552
@@ -556,3 +561,32 @@ func TestResolveMetaToken_ConcurrentSingleflight(t *testing.T) { · 8 unmodified lines
556561 t.Error("live manager did not retain minted key in attributes")
557562 }
558563 }
564+
565+func TestResolveMetaTokenUsesRequestProxyWithoutSavingOverride(t *testing.T) {
566+ proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
567+ if r.Header.Get("Authorization") != "Bearer dca:proxy-test" {
568+ t.Error("mint request did not carry the DCA token")
569+ }
570+ _, _ = w.Write([]byte(`{"api_key":"LLM|proxied"}`))
571+ }))
572+ defer proxy.Close()
573+ t.Setenv("META_MINT_URL", "http://meta.invalid/key")
574+ store := &memoryAuthStore{}
575+ manager := coreauth.NewManager(store, nil, nil)
576+ auth, err := manager.Register(coreauth.WithSkipPersist(context.Background()), &coreauth.Auth{
577+ ID: "meta-proxy.json", Provider: "meta", ProxyURL: "http://127.0.0.1:1",
578+ Metadata: map[string]any{"dca_token": "dca:proxy-test"},
579+ })
580+ if err != nil {
581+ t.Fatal(err)
582+ }
583+ h := &Handler{cfg: &config.Config{}, authManager: manager, tokenStore: store}
584+ token, err := h.resolveMetaToken(context.Background(), auth.Clone(), proxy.URL)
585+ if err != nil || token != "LLM|proxied" {
586+ t.Fatalf("resolve via request proxy: token=%q, err=%v", token, err)
587+ }
588+ live, _ := manager.GetByID(auth.ID)
589+ if live.ProxyURL != auth.ProxyURL {
590+ t.Fatal("request proxy override changed the credential's configured proxy")
591+ }
592+}
internal/auth/meta/meta.go+33−26
@@ -173,43 +173,44 @@ func (ts *MetaTokenStorage) SaveTokenToFile(authFilePath string) error { · 172 unmodified lines
173173 if ts.Name != "" {
174174 data["name"] = ts.Name
175175 }
176− if raw, errRead := os.ReadFile(authFilePath); errRead == nil {
177− var existing map[string]any
178− if errJSON := json.Unmarshal(raw, &existing); errJSON == nil {
179− for k, v := range existing {
180− if _, isCred := metaCredentialFields[k]; isCred {
181− continue
182− }
183− if _, exists := data[k]; !exists {
184− data[k] = v
185− }
186− }
176+ // Managed saves supply the current metadata, including deliberate deletions.
177+ // Only login callers without a metadata snapshot inherit settings from disk.
178+ metadata := ts.Metadata
179+ if metadata == nil {
180+ if raw, errRead := os.ReadFile(authFilePath); errRead == nil {
181+ _ = json.Unmarshal(raw, &metadata)
187182 }
188183 }
189− for k, v := range ts.Metadata {
184+ for k, v := range metadata {
190185 if _, isCred := metaCredentialFields[k]; isCred {
191186 continue
192187 }
193− if _, exists := data[k]; !exists {
188+ // Supplied settings take precedence over storage's older snapshot.
189+ if _, exists := data[k]; !exists || ts.Metadata != nil {
194190 data[k] = v
195191 }
196192 }
197193
198− file, err := os.Create(authFilePath)
194+ raw, err := json.MarshalIndent(data, "", " ")
195+ if err != nil {
196+ return fmt.Errorf("meta token storage: encode token file: %w", err)
197+ }
198+ file, err := os.CreateTemp(filepath.Dir(authFilePath), ".meta-token-*")
199199 if err != nil {
200200 return fmt.Errorf("meta token storage: create token file: %w", err)
201201 }
202− defer func() {
203− if errClose := file.Close(); errClose != nil {
204− log.Errorf("meta token storage: close token file error: %v", errClose)
205− }
206− }()
207−
208− encoder := json.NewEncoder(file)
209− encoder.SetIndent("", " ")
210− if err = encoder.Encode(data); err != nil {
211− return fmt.Errorf("meta token storage: write token file: %w", err)
202+ defer func() { _ = os.Remove(file.Name()) }()
203+ if _, errWrite := file.Write(append(raw, '\n')); errWrite != nil {
204+ _ = file.Close()
205+ return fmt.Errorf("meta token storage: write token file: %w", errWrite)
206+ }
207+ if errClose := file.Close(); errClose != nil {
208+ return fmt.Errorf("meta token storage: close token file: %w", errClose)
212209 }
210+ if errRename := os.Rename(file.Name(), authFilePath); errRename != nil {
211+ return fmt.Errorf("meta token storage: replace token file: %w", errRename)
212+ }
213+
213214 return nil
214215 }
215216
@@ -536,7 +537,8 @@ func (a *MetaAuth) CreateTokenStorage(bundle *MetaAuthBundle) *MetaTokenStorage · 320 unmodified lines
536537 }
537538 }
538539
539−// CredentialFileName derives a deterministic, collision-free file name for the credentials.
540+// CredentialFileName keeps a readable account name and hashes the original identity
541+// so distinct emails that sanitize identically cannot overwrite each other.
540542 func CredentialFileName(email, sub string) string {
541543 clean := strings.TrimSpace(email)
542544 if clean != "" {
@@ -546,7 +548,12 @@ func CredentialFileName(email, sub string) string { · 3 unmodified lines
546548 }
547549 return '_'
548550 }, clean)
549− return fmt.Sprintf("meta-%s.json", sanitized)
551+ // Leave room for the prefix, identity hash and extension on common filesystems.
552+ if len(sanitized) > 120 {
553+ sanitized = sanitized[:120]
554+ }
555+ hash := sha256.Sum256([]byte(clean))
556+ return fmt.Sprintf("meta-%s-%s.json", sanitized, hex.EncodeToString(hash[:8]))
550557 }
551558 cleanSub := strings.TrimSpace(sub)
552559 if cleanSub != "" {
internal/auth/meta/meta_auth_test.go+61−1
@@ -7,6 +7,7 @@ import ( · 6 unmodified lines
77 "net/http/httptest"
88 "os"
99 "path/filepath"
10+ "strings"
1011 "testing"
1112
1213 "github.com/router-for-me/CLIProxyAPI/v7/internal/config"
@@ -144,7 +145,7 @@ func TestMetaAuth_WaitForAuthorization(t *testing.T) { · 131 unmodified lines
144145 }
145146
146147 func TestCredentialFileName(t *testing.T) {
147− if got := CredentialFileName("user@example.com", ""); got != "meta-user_example.com.json" {
148+ if got := CredentialFileName("user@example.com", ""); !strings.HasPrefix(got, "meta-user_example.com-") || !strings.HasSuffix(got, ".json") {
148149 t.Errorf("unexpected fileName: %s", got)
149150 }
150151 if got := CredentialFileName("", "12345"); got == "" || !filepath.IsLocal(got) {
@@ -298,3 +299,62 @@ func TestCreateTokenStorageUsesMintedBaseURL(t *testing.T) { · 147 unmodified lines
298299 })
299300 }
300301 }
302+
303+func TestCredentialFileNameSeparatesAccounts(t *testing.T) {
304+ first := CredentialFileName("alice+work@example.com", "dca:first")
305+ second := CredentialFileName("alice_work@example.com", "dca:second")
306+ if first == second {
307+ t.Fatal("distinct accounts overwrite the same file")
308+ }
309+ if first != CredentialFileName("alice+work@example.com", "dca:replacement") {
310+ t.Fatal("re-login changed account file")
311+ }
312+ long := CredentialFileName(strings.Repeat("a", 300)+"@example.com", "")
313+ if len(long) > 255 || !filepath.IsLocal(long) {
314+ t.Fatal("filename cannot be saved on common filesystems")
315+ }
316+}
317+
318+func TestSaveTokenToFileUsesCurrentSettings(t *testing.T) {
319+ path := filepath.Join(t.TempDir(), "meta.json")
320+ if err := os.WriteFile(path, []byte(`{"disabled":false,"priority":1,"notes":"removed"}`), 0600); err != nil {
321+ t.Fatal(err)
322+ }
323+ storage := &MetaTokenStorage{AccessToken: "LLM|key", APIKey: "LLM|key", Metadata: map[string]any{"disabled": true, "priority": float64(2)}}
324+ if err := storage.SaveTokenToFile(path); err != nil {
325+ t.Fatal(err)
326+ }
327+ raw, err := os.ReadFile(path)
328+ if err != nil {
329+ t.Fatal(err)
330+ }
331+ var saved map[string]any
332+ if err := json.Unmarshal(raw, &saved); err != nil {
333+ t.Fatal(err)
334+ }
335+ if saved["disabled"] != true || saved["priority"] != float64(2) {
336+ t.Fatalf("restored old settings: %s", raw)
337+ }
338+ if _, exists := saved["notes"]; exists {
339+ t.Fatal("restored a deleted setting")
340+ }
341+}
342+
343+func TestSaveTokenToFilePreservesFileOnEncodingFailure(t *testing.T) {
344+ path := filepath.Join(t.TempDir(), "meta.json")
345+ initial := `{"access_token":"LLM|previous"}`
346+ if err := os.WriteFile(path, []byte(initial), 0600); err != nil {
347+ t.Fatal(err)
348+ }
349+ storage := &MetaTokenStorage{AccessToken: "LLM|new", Metadata: map[string]any{"invalid": make(chan int)}}
350+ if err := storage.SaveTokenToFile(path); err == nil {
351+ t.Fatal("expected encoding failure")
352+ }
353+ raw, err := os.ReadFile(path)
354+ if err != nil {
355+ t.Fatal(err)
356+ }
357+ if string(raw) != initial {
358+ t.Fatalf("failed save corrupted existing credential: %q", raw)
359+ }
360+}
internal/runtime/executor/meta_executor.go+10−29
@@ -208,46 +208,27 @@ func (e *MetaExecutor) Refresh(ctx context.Context, auth *cliproxyauth.Auth) (*c · 207 unmodified lines
208208 auth.Attributes["api_key"] = minted.APIKey
209209 auth.Attributes["access_token"] = minted.APIKey
210210
211− var storage *metaauth.MetaTokenStorage
212− if ms, ok := auth.Storage.(*metaauth.MetaTokenStorage); ok && ms != nil {
213− storage = ms
211+ // Auth.Clone does not clone Storage. Keep the candidate isolated from live
212+ // login storage; file-loaded records already persist through Metadata.
213+ if existing, ok := auth.Storage.(*metaauth.MetaTokenStorage); ok && existing != nil {
214+ storage := *existing
214215 storage.APIKey = minted.APIKey
215216 storage.AccessToken = minted.APIKey
216217 storage.DCAToken = dcaToken
217218 storage.Expired = ""
219+ storage.BaseURL = baseURL
220+ storage.LastRefresh = nowStr
221+ storage.Metadata = auth.Metadata
218222 if minted.UserEmail != "" {
219223 storage.Email = minted.UserEmail
220224 }
221225 if minted.UserFullName != "" {
222226 storage.Name = minted.UserFullName
223227 }
224− storage.LastRefresh = nowStr
225− } else {
226− storage = &metaauth.MetaTokenStorage{
227− Type: "meta",
228− AuthKind: "oauth",
229− AccessToken: minted.APIKey,
230− APIKey: minted.APIKey,
231− DCAToken: dcaToken,
232− Email: minted.UserEmail,
233− Name: minted.UserFullName,
234− LastRefresh: nowStr,
235− Metadata: auth.Metadata,
236− }
237− auth.Storage = storage
238− }
239−
240− storage.BaseURL = baseURL
241−
242− filePath := strings.TrimSpace(auth.Attributes[cliproxyauth.AttributePath])
243− if filePath == "" {
244− filePath = strings.TrimSpace(auth.FileName)
245− }
246− if filePath != "" {
247− if errSave := storage.SaveTokenToFile(filePath); errSave != nil {
248− log.Warnf("meta executor: failed to persist refreshed token to %s: %v", filePath, errSave)
249− }
228+ auth.Storage = &storage
250229 }
230+ // Only the manager may accept and persist the candidate.
231+ auth.LastRefreshedAt = time.Now()
251232
252233 return auth, nil
253234 }
internal/runtime/executor/meta_executor_test.go+148−29
@@ -8,14 +8,15 @@ import ( · 7 unmodified lines
88 "net/http/httptest"
99 "os"
1010 "path/filepath"
11− "runtime"
1211 "sync"
1312 "sync/atomic"
1413 "testing"
1514 "time"
1615
16+ metaauth "github.com/router-for-me/CLIProxyAPI/v7/internal/auth/meta"
1717 "github.com/router-for-me/CLIProxyAPI/v7/internal/config"
1818 "github.com/router-for-me/CLIProxyAPI/v7/internal/registry"
19+ sdkauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/auth"
1920 cliproxyauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth"
2021 cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/executor"
2122 sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator"
@@ -198,7 +199,7 @@ func mapToJSON(m map[string]any) string { · 176 unmodified lines
198199 return string(b)
199200 }
200201
201−func TestMetaExecutor_Refresh_DCA_MintAndPersist(t *testing.T) {
202+func TestMetaExecutor_Refresh_RequiresManagerAcceptance(t *testing.T) {
202203 tempDir := t.TempDir()
203204 authFilePath := filepath.Join(tempDir, "meta-test.json")
204205 initialContent := `{"type":"meta","auth_kind":"oauth","access_token":"dca:initial-dca","dca_token":"dca:initial-dca","expired":"2020-01-01T00:00:00Z","request-retry":3}`
@@ -223,6 +224,8 @@ func TestMetaExecutor_Refresh_DCA_MintAndPersist(t *testing.T) { · 18 unmodified lines
223224 t.Setenv("META_MINT_URL", server.URL+"/key")
224225
225226 auth := &cliproxyauth.Auth{
227+ ID: "meta-test.json",
228+ FileName: "meta-test.json",
226229 Provider: "meta",
227230 Attributes: map[string]string{
228231 cliproxyauth.AttributePath: authFilePath,
@@ -233,8 +236,17 @@ func TestMetaExecutor_Refresh_DCA_MintAndPersist(t *testing.T) { · 4 unmodified lines
233236 },
234237 }
235238
239+ store := sdkauth.NewFileTokenStore()
240+ store.SetBaseDir(tempDir)
241+ manager := cliproxyauth.NewManager(store, nil, nil)
242+ auth.Metadata["request-retry"] = float64(3)
243+ auth.Storage = &metaauth.MetaTokenStorage{AccessToken: "dca:initial-dca", DCAToken: "dca:initial-dca", Expired: "2020-01-01T00:00:00Z"}
244+ auth, errRegister := manager.Register(cliproxyauth.WithSkipPersist(context.Background()), auth)
245+ if errRegister != nil {
246+ t.Fatal(errRegister)
247+ }
236248 exec := NewMetaExecutor(&config.Config{})
237− refreshed, err := exec.Refresh(context.Background(), auth)
249+ refreshed, err := exec.Refresh(context.Background(), auth.Clone())
238250 if err != nil {
239251 t.Fatalf("exec.Refresh error: %v", err)
240252 }
@@ -249,6 +261,20 @@ func TestMetaExecutor_Refresh_DCA_MintAndPersist(t *testing.T) { · 8 unmodified lines
249261 t.Errorf("expected expired to be removed from metadata after minting")
250262 }
251263
264+ unchanged, errRead := os.ReadFile(authFilePath)
265+ if errRead != nil {
266+ t.Fatal(errRead)
267+ }
268+ if string(unchanged) != initialContent {
269+ t.Fatal("executor wrote candidate before manager acceptance")
270+ }
271+ live, _ := manager.GetByID(auth.ID)
272+ if live.Storage.(*metaauth.MetaTokenStorage).AccessToken != "dca:initial-dca" {
273+ t.Fatal("refresh mutated live token storage")
274+ }
275+ if _, err := manager.UpdateRefreshedAuth(context.Background(), auth, refreshed); err != nil {
276+ t.Fatal(err)
277+ }
252278 // Verify durable file persistence on disk
253279 diskBytes, errRead := os.ReadFile(authFilePath)
254280 if errRead != nil {
@@ -265,12 +291,12 @@ func TestMetaExecutor_Refresh_DCA_MintAndPersist(t *testing.T) { · 10 unmodified lines
265291 t.Errorf("expected persisted access_token LLM|persisted-minted-key, got %v", diskData["access_token"])
266292 }
267293 // Verify existing properties preserved
268− if diskData["request-retry"] != float64(3) {
269− t.Errorf("expected preserved request-retry: 3, got %v", diskData["request-retry"])
294+ if diskData["request_retry"] != float64(3) {
295+ t.Errorf("expected preserved request-retry: 3, got %v", diskData["request_retry"])
270296 }
271297 }
272298
273−func TestMetaExecutor_Refresh_SingleflightAndMultiAccount(t *testing.T) {
299+func TestMetaExecutor_PrepareConcurrentAccounts(t *testing.T) {
274300 var count1, count2 int64
275301
276302 serverStarted := make(chan struct{})
@@ -312,10 +338,15 @@ func TestMetaExecutor_Refresh_SingleflightAndMultiAccount(t *testing.T) { · 35 unmodified lines
312338 // 10 concurrent refreshes for account 1
313339 var wg sync.WaitGroup
314340 auth1 := &cliproxyauth.Auth{
341+ ID: "meta-acct1",
315342 Provider: "meta",
316343 Metadata: map[string]any{"dca_token": "dca:acct1"},
317344 }
318345
346+ manager := cliproxyauth.NewManager(nil, nil, nil)
347+ if _, err := manager.Register(context.Background(), auth1); err != nil {
348+ t.Fatal(err)
349+ }
319350 const goroutines = 10
320351 var entryWg sync.WaitGroup
321352 entryWg.Add(goroutines)
@@ -330,7 +361,7 @@ func TestMetaExecutor_Refresh_SingleflightAndMultiAccount(t *testing.T) { · 8 unmodified lines
330361 entryWg.Done()
331362 <-ready
332363 inFlight.Done()
333− res, err := exec.Refresh(context.Background(), auth1.Clone())
364+ res, err := manager.PrepareRequestAuth(context.Background(), exec, auth1.Clone())
334365 if err != nil {
335366 t.Errorf("Refresh acct1 error: %v", err)
336367 }
@@ -348,12 +379,12 @@ func TestMetaExecutor_Refresh_SingleflightAndMultiAccount(t *testing.T) { · 11 unmodified lines
348379 <-serverStarted
349380 inFlight.Wait()
350381
351− // Allow pending goroutines to enter singleflight.Do while the server holds the in-flight request.
352− for i := 0; i < 50; i++ {
353− runtime.Gosched()
382+ // A second account must complete while the first account's mint is blocked.
383+ auth2 := &cliproxyauth.Auth{ID: "meta-acct2", Provider: "meta", Metadata: map[string]any{"dca_token": "dca:acct2"}}
384+ if _, err := manager.Register(context.Background(), auth2); err != nil {
385+ t.Fatal(err)
354386 }
355−
356− // Release the HTTP server handler to complete the single in-flight mint.
387+ res2, err2 := manager.PrepareRequestAuth(context.Background(), exec, auth2.Clone())
357388 close(releaseServer)
358389 wg.Wait()
359390
@@ -361,12 +392,6 @@ func TestMetaExecutor_Refresh_SingleflightAndMultiAccount(t *testing.T) { · 1 unmodified line
361392 t.Errorf("expected exactly 1 singleflight mint request for acct1, got %d", totalMint1)
362393 }
363394
364− // Account 2 refreshes independently
365− auth2 := &cliproxyauth.Auth{
366− Provider: "meta",
367− Metadata: map[string]any{"dca_token": "dca:acct2"},
368− }
369− res2, err2 := exec.Refresh(context.Background(), auth2.Clone())
370395 if err2 != nil {
371396 t.Fatalf("Refresh acct2 error: %v", err2)
372397 }
@@ -504,17 +529,13 @@ func TestMetaExecutorRefreshUsesMintedBaseURL(t *testing.T) { · 131 unmodified lines
504529 if got, _ := metaCreds(updated); got != tc.want {
505530 t.Errorf("request base URL = %q, want %q", got, tc.want)
506531 }
507− raw, err := os.ReadFile(path)
508− if err != nil {
509− t.Fatal(err)
510− }
511− var saved map[string]any
512− if err = json.Unmarshal(raw, &saved); err != nil {
513− t.Fatal(err)
532+ if updated.Metadata["base_url"] != tc.want {
533+ t.Errorf("candidate base URL = %v, want %q", updated.Metadata["base_url"], tc.want)
514534 }
515− if saved["base_url"] != tc.want {
516− t.Errorf("saved base URL = %v, want %q", saved["base_url"], tc.want)
535+ if _, err := os.Stat(path); !os.IsNotExist(err) {
536+ t.Fatalf("refresh created a file: %v", err)
517537 }
538+
518539 })
519540 }
520541 }
@@ -616,7 +637,7 @@ func TestMetaExecutor_RequestAuthPreparer(t *testing.T) { · 95 unmodified lines
616637 }
617638
618639 authDCAOnly := &cliproxyauth.Auth{
619− ID: "meta-prep-test",
640+ ID: "meta-prep-test.json",
620641 Provider: "meta",
621642 Metadata: map[string]any{
622643 "dca_token": "dca:valid",
@@ -630,7 +651,9 @@ func TestMetaExecutor_RequestAuthPreparer(t *testing.T) { · 7 unmodified lines
630651 t.Errorf("ShouldPrepareRequestAuth should be true when only dca_token is present")
631652 }
632653
633− manager := cliproxyauth.NewManager(nil, nil, nil)
654+ store := sdkauth.NewFileTokenStore()
655+ store.SetBaseDir(t.TempDir())
656+ manager := cliproxyauth.NewManager(store, nil, nil)
634657 manager.RegisterExecutor(exec)
635658 if _, err := manager.Register(context.Background(), authDCAOnly); err != nil {
636659 t.Fatal(err)
@@ -662,6 +685,14 @@ func TestMetaExecutor_RequestAuthPreparer(t *testing.T) { · 25 unmodified lines
662685 t.Errorf("expected stored api_key 'LLM|prepared-key', got %q", key)
663686 }
664687
688+ reloaded, err := store.List(context.Background())
689+ if err != nil || len(reloaded) != 1 {
690+ t.Fatalf("reload auth: %v, records=%d", err, len(reloaded))
691+ }
692+ if reloaded[0].Metadata["api_key"] != "LLM|prepared-key" {
693+ t.Fatal("minted key was not persisted for restart")
694+ }
695+
665696 _, err = manager.Execute(context.Background(), []string{"meta"}, req, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("openai")})
666697 if err != nil {
667698 t.Fatalf("second execute failed: %v", err)
@@ -670,3 +701,91 @@ func TestMetaExecutor_RequestAuthPreparer(t *testing.T) { · 2 unmodified lines
670701 t.Fatalf("mint count after second request = %d, want 1", mints.Load())
671702 }
672703 }
704+
705+func TestMetaMintRejectsRemovedOrReloadedCredential(t *testing.T) {
706+ for _, prepare := range []bool{false, true} {
707+ for _, action := range []string{"remove", "reload"} {
708+ name := action + "/refresh"
709+ if prepare {
710+ name = action + "/prepare"
711+ }
712+ t.Run(name, func(t *testing.T) {
713+ started := make(chan struct{})
714+ release := make(chan struct{})
715+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
716+ close(started)
717+ <-release
718+ _, _ = w.Write([]byte(`{"api_key":"LLM|obsolete"}`))
719+ }))
720+ defer server.Close()
721+ var releaseOnce sync.Once
722+ defer releaseOnce.Do(func() { close(release) })
723+ t.Setenv("META_MINT_URL", server.URL)
724+ dir := t.TempDir()
725+ store := sdkauth.NewFileTokenStore()
726+ store.SetBaseDir(dir)
727+ manager := cliproxyauth.NewManager(store, nil, nil)
728+ storage := &metaauth.MetaTokenStorage{AccessToken: "dca:initial", DCAToken: "dca:initial"}
729+ auth, err := manager.Register(context.Background(), &cliproxyauth.Auth{ID: "meta-lifecycle.json", Provider: "meta", Storage: storage, Metadata: map[string]any{"type": "meta", "access_token": "dca:initial", "dca_token": "dca:initial"}})
730+ if err != nil {
731+ t.Fatal(err)
732+ }
733+ exec := NewMetaExecutor(nil)
734+ done := make(chan error, 1)
735+ go func() {
736+ if prepare {
737+ _, err := manager.PrepareRequestAuth(context.Background(), exec, auth.Clone())
738+ done <- err
739+ return
740+ }
741+ updated, err := exec.Refresh(context.Background(), auth.Clone())
742+ if err == nil {
743+ _, err = manager.UpdateRefreshedAuth(context.Background(), auth, updated)
744+ }
745+ done <- err
746+ }()
747+ <-started
748+ path := filepath.Join(dir, auth.ID)
749+ if action == "remove" {
750+ manager.Remove(context.Background(), auth.ID)
751+ if err := store.Delete(context.Background(), auth.ID); err != nil {
752+ t.Fatal(err)
753+ }
754+ } else {
755+ _, err := manager.Register(context.Background(), &cliproxyauth.Auth{ID: auth.ID, Provider: "meta", Metadata: map[string]any{"type": "meta", "api_key": "LLM|reloaded", "access_token": "LLM|reloaded", "dca_token": "dca:reloaded"}})
756+ if err != nil {
757+ t.Fatal(err)
758+ }
759+ }
760+ releaseOnce.Do(func() { close(release) })
761+ err = <-done
762+ if (prepare || action == "reload") && err == nil {
763+ t.Fatal("obsolete mint was accepted")
764+ }
765+ if storage.AccessToken != "dca:initial" {
766+ t.Fatal("obsolete mint changed shared login storage")
767+ }
768+ raw, errRead := os.ReadFile(path)
769+ if action == "remove" {
770+ if !os.IsNotExist(errRead) {
771+ t.Fatalf("removed auth was recreated: %s, %v", raw, errRead)
772+ }
773+ if _, ok := manager.GetByID(auth.ID); ok {
774+ t.Fatal("removed auth was reinstalled")
775+ }
776+ } else {
777+ if errRead != nil {
778+ t.Fatal(errRead)
779+ }
780+ var saved map[string]any
781+ if err := json.Unmarshal(raw, &saved); err != nil {
782+ t.Fatal(err)
783+ }
784+ if saved["api_key"] != "LLM|reloaded" {
785+ t.Fatalf("obsolete mint overwrote reload: %s", raw)
786+ }
787+ }
788+ })
789+ }
790+ }
791+}
sdk/cliproxy/auth/conductor_execution.go+29−9
@@ -1387,7 +1387,17 @@ func (m *Manager) prepareRequestAuth(ctx context.Context, executor ProviderExecu · 1386 unmodified lines
13871387 return auth, nil
13881388 }
13891389 preparer, ok := executor.(RequestAuthPreparer)
1390− if !ok || preparer == nil || !preparer.ShouldPrepareRequestAuth(auth) {
1390+ if !ok {
1391+ return auth, nil
1392+ }
1393+
1394+ return m.PrepareRequestAuth(ctx, preparer, auth)
1395+}
1396+
1397+// PrepareRequestAuth prepares a registered credential using the same serialization
1398+// and lifecycle checks as normal request execution. Management tools use this path too.
1399+func (m *Manager) PrepareRequestAuth(ctx context.Context, preparer RequestAuthPreparer, auth *Auth) (*Auth, error) {
1400+ if m == nil || preparer == nil || auth == nil || !preparer.ShouldPrepareRequestAuth(auth) {
13911401 return auth, nil
13921402 }
13931403
@@ -1396,21 +1406,28 @@ func (m *Manager) prepareRequestAuth(ctx context.Context, executor ProviderExecu · 2 unmodified lines
13961406 return preparer.PrepareRequestAuth(ctx, auth.Clone())
13971407 }
13981408
1399− lockValue, _ := m.requestPrepareLocks.LoadOrStore(id, &requestAuthPrepareLock{})
1400− lock, ok := lockValue.(*requestAuthPrepareLock)
1401− if !ok || lock == nil {
1402− return preparer.PrepareRequestAuth(ctx, auth.Clone())
1409+ var prepareMu *sync.Mutex
1410+ if strings.EqualFold(strings.TrimSpace(auth.Provider), "meta") {
1411+ // Meta also mints on 401 recovery. Serialize both paths per credential.
1412+ lockValue, _ := m.refreshLocks.LoadOrStore(id, &authRefreshLock{})
1413+ prepareMu = &lockValue.(*authRefreshLock).mu
1414+ } else {
1415+ lockValue, _ := m.requestPrepareLocks.LoadOrStore(id, &requestAuthPrepareLock{})
1416+ prepareMu = &lockValue.(*requestAuthPrepareLock).mu
14031417 }
1404−
1405− lock.mu.Lock()
1406− defer lock.mu.Unlock()
1418+ prepareMu.Lock()
1419+ defer prepareMu.Unlock()
14071420
14081421 target := auth.Clone()
14091422 m.mu.RLock()
1410− if current := m.auths[id]; current != nil {
1423+ current := m.auths[id]
1424+ if current != nil {
14111425 target = current.Clone()
14121426 }
14131427 m.mu.RUnlock()
1428+ if current == nil && strings.EqualFold(strings.TrimSpace(auth.Provider), "meta") {
1429+ return nil, fmt.Errorf("prepare meta auth: credential no longer registered")
1430+ }
14141431
14151432 if !preparer.ShouldPrepareRequestAuth(target) {
14161433 return target, nil
@@ -1432,6 +1449,9 @@ func (m *Manager) prepareRequestAuth(ctx context.Context, executor ProviderExecu · 15 unmodified lines
14321449 if saved != nil {
14331450 return saved, nil
14341451 }
1452+ if strings.EqualFold(strings.TrimSpace(auth.Provider), "meta") {
1453+ return nil, fmt.Errorf("prepare meta auth: credential removed during mint")
1454+ }
14351455 return target, nil
14361456 }
14371457
sdk/cliproxy/auth/conductor_lifecycle.go+13−1
@@ -224,6 +224,16 @@ func (m *Manager) updateInternal(ctx context.Context, base, auth *Auth, mode upd · 223 unmodified lines
224224 cooldownStateChanged = clearCooldownStateForAuth(auth, now) || cooldownStateChanged
225225 }
226226 auth.EnsureIndex()
227+ // A minted Meta key must reach the configured store before requests can use it.
228+ // Keep the epoch check, save and installation together so a concurrent reload
229+ // or removal cannot let an obsolete mint overwrite the credential on disk.
230+ persistMetaMint := (mode == updateModePrepare || mode == updateModeRefresh) && strings.EqualFold(strings.TrimSpace(auth.Provider), "meta")
231+ if persistMetaMint {
232+ if errPersist := m.persist(ctx, auth); errPersist != nil {
233+ m.mu.Unlock()
234+ return nil, fmt.Errorf("persist meta auth: %w", errPersist)
235+ }
236+ }
227237 authClone := auth.Clone()
228238 m.auths[auth.ID] = authClone
229239 m.mu.Unlock()
@@ -234,7 +244,9 @@ func (m *Manager) updateInternal(ctx context.Context, base, auth *Auth, mode upd · 4 unmodified lines
234244 m.scheduler.upsertAuth(authClone.Clone())
235245 }
236246 m.queueRefreshReschedule(auth.ID)
237− _ = m.persist(ctx, auth)
247+ if !persistMetaMint {
248+ _ = m.persist(ctx, auth)
249+ }
238250 m.hook.OnAuthUpdated(ctx, auth.Clone())
239251 if cooldownStateChanged {
240252 m.persistCooldownStates(context.Background())
sdk/cliproxy/auth/metadata_merge.go+6−0
@@ -32,6 +32,12 @@ func MergeExistingAuthMetadata(target *Auth, existingMap map[string]any) { · 31 unmodified lines
3232 if IsAuthTokenPayloadKey(k) {
3333 continue
3434 }
35+ if strings.EqualFold(strings.TrimSpace(target.Provider), "meta") {
36+ switch CanonicalCredentialMetadataKey(k) {
37+ case "api_key", "dca_token", "dca_expired", "dca_expires_at":
38+ continue
39+ }
40+ }
3541 if _, exists := target.Metadata[k]; !exists {
3642 target.Metadata[k] = v
3743 }
sdk/cliproxy/auth/metadata_merge_test.go+15−0
@@ -404,3 +404,18 @@ func TestMergeRefreshedAuth(t *testing.T) { · 403 unmodified lines
404404 }
405405 })
406406 }
407+
408+func TestMergeExistingAuthMetadataMetaDoesNotRestoreOldKey(t *testing.T) {
409+ // A new device login can succeed while API key minting fails.
410+ // Its DCA credential must not inherit the previous login's API key.
411+ auth := &Auth{Provider: "meta", Metadata: map[string]any{"access_token": "dca:new", "dca_token": "dca:new"}}
412+ MergeExistingAuthMetadata(auth, map[string]any{"api_key": "LLM|old", "dca_expired": "old expiry", "dca_expires_at": 42, "priority": 3})
413+ for _, key := range []string{"api_key", "dca_expired", "dca_expires_at"} {
414+ if _, exists := auth.Metadata[key]; exists {
415+ t.Fatalf("restored old Meta credential field %s", key)
416+ }
417+ }
418+ if auth.Metadata["priority"] != 3 || auth.Metadata["dca_token"] != "dca:new" {
419+ t.Fatalf("incorrect merged metadata: %#v", auth.Metadata)
420+ }
421+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t