Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
plugin: one renewal of a sign-in at a time across magpie processes (plugins #331)
yetonebac5be067744
diff --git a/internal/plugin/host.js b/internal/plugin/host.jsindex 0f5702594..600d35800 100644--- a/internal/plugin/host.js+++ b/internal/plugin/host.js@@ -26,7 +26,7 @@// plugin's getAuth, client.auth.set and loader see that account alone.import { AsyncLocalStorage } from "node:async_hooks"-import { randomUUID } from "node:crypto"+import { createHash, randomUUID } from "node:crypto"import dns from "node:dns"import fs from "node:fs"import http2 from "node:http2"@@ -2168,14 +2168,103 @@ async function fresh(provider, key) {clearTimeout(t)}+// Each magpie process runs a host of its own (the gateway, a CLI's quota+// or usage, a host restarting), and each renews the same sign-in when it+// comes due: a vendor that spends a refresh token once turned the second+// away, and the account was marked signed out under the token the first+// had saved (plugins #331). So a renewal is made under a lock file of the+// account's beside plugin-auth.json, held across the plugin's refresh,+// and the sign-in is read again under it. The lock names its holder's pid:+// one whose holder is gone is taken over at once, and one held longer+// than RENEW_LOCK_STALE by anyone.+const RENEW_LOCK_STALE = 60 * 1000++function alive(pid) {+ try {+ process.kill(pid, 0)+ return true+ } catch (e) {+ return e?.code === "EPERM" // someone else's process+ }+}++async function lockRenew(key) {+ const lock = `${authPath}.renew-${createHash("sha256").update(key).digest("hex").slice(0, 16)}.lock`+ const me = JSON.stringify({ pid: process.pid, at: Date.now(), n: randomUUID() })+ fs.mkdirSync(path.dirname(authPath), { recursive: true })+ for (let start = Date.now(), wait = 10; ; wait = Math.min(wait * 2, 500)) {+ try {+ fs.writeFileSync(lock, me, { flag: "wx", mode: 0o600 })+ return () => {+ try {+ if (fs.readFileSync(lock, "utf8") === me) fs.unlinkSync(lock)+ } catch {}+ }+ } catch (e) {+ if (!["EEXIST", "EPERM", "EACCES"].includes(e?.code)) throw e+ }+ let raw = null+ let h = null+ let age = 0+ try {+ raw = fs.readFileSync(lock, "utf8")+ age = Date.now() - fs.statSync(lock).mtimeMs+ h = JSON.parse(raw)+ } catch {}+ // a holder gone, or one too long at it; a file not written yet is+ // judged by its age+ const stale = Number.isInteger(h?.pid) ? !alive(h.pid) || Date.now() - h.at > RENEW_LOCK_STALE : age > RENEW_LOCK_STALE+ if (raw !== null && (stale || Date.now() - start > 2 * RENEW_LOCK_STALE)) {+ try {+ if (fs.readFileSync(lock, "utf8") === raw) fs.unlinkSync(lock)+ } catch {}+ continue+ }+ await new Promise((ok) => setTimeout(ok, wait))+ }+}++// changed says the sign-in now isn't was any longer: signed out, signed+// in again or renewed, by this host or another.+function changed(now, was) {+ return !now || secretOf(now) !== secretOf(was) || now.access !== was.access+}+async function renew(provider, key, a) {const was = readAuth()[key]const at = renewAt(a, was)if (!at || Date.now() < at) return // renewed meanwhile+ const unlock = await lockRenew(key)+ try {+ await renewLocked(provider, key, a, was)+ } finally {+ unlock()+ }+}++async function renewLocked(provider, key, a, was) {+ // read past authSeen: another host renewed it while this one waited,+ // and its token stands+ const now = readAuthState().all[key]+ if (changed(now, was)) {+ unrenewed.delete(key)+ forgetAccount(key)+ return+ }+ const at = renewAt(a, now)+ if (!at || Date.now() < at) return+ was = nowlet gottry {got = await inScope(provider, key, () => a.refresh(JSON.parse(JSON.stringify(was)), provider))} catch (e) {+ // the token was spent by a host that didn't wait for this one's lock+ // (a magpie from before it) and saved what it got: not signed out+ if (changed(readAuthState().all[key], was)) {+ send({ event: "log", level: "error", message: `${auths().get(provider)?.spec ?? provider}: auth.refresh: ${e?.message ?? e} (renewed elsewhere meanwhile)` })+ forgetAccount(key)+ return+ }unrenewed.set(key, { at: Date.now(), secret: secretOf(was), gone: e?.signIn === "expired" })if (e?.signIn === "expired") send({ event: "signIn", provider, account: key, said: "expired" })send({ event: "log", level: "error", message: `${auths().get(provider)?.spec ?? provider}: auth.refresh: ${e?.message ?? e}` })@@ -2187,8 +2276,7 @@ async function renew(provider, key, a) {// nothing comes between the two.const { type: _t, ...fields } = gotconst kept = changeAuth((all) => {- const now = all[key]- if (!now || secretOf(now) !== secretOf(was) || now.access !== was.access) return false+ if (changed(all[key], was)) return falseall[key] = { ...was, ...fields, type: "oauth" }})if (kept === false) returndiff --git a/internal/plugin/plugin_renew_race_test.go b/internal/plugin/plugin_renew_race_test.gonew file mode 100644index 000000000..a8f0c8187--- /dev/null+++ b/internal/plugin/plugin_renew_race_test.go@@ -0,0 +1,338 @@+package plugin++import (+ "bufio"+ "context"+ "crypto/sha256"+ "encoding/hex"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "os"+ "os/exec"+ "path/filepath"+ "strings"+ "sync"+ "testing"+ "time"+)++// raceVendor is a vendor that spends a refresh token once (plugins+// #331): the first exchange of r1 gives r2, and r1 again, or a token it+// never gave, is invalid_grant. hold, when set, keeps the first exchange+// from answering until it is closed, and arrived says it came.+type raceVendor struct {+ mu sync.Mutex+ valid map[string]string // refresh token → the one it gives+ exchanges []string+ hold chan struct{}+ arrived chan struct{}+ auths []string // each request's Authorization+ store string // plugin-auth.json+}++func newRaceVendor(t *testing.T) *raceVendor {+ t.Helper()+ v := &raceVendor{valid: map[string]string{"r1": "r2"}, arrived: make(chan struct{}, 8), store: AuthPath()}+ tokens := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ b, _ := io.ReadAll(r.Body)+ v.mu.Lock()+ v.exchanges = append(v.exchanges, string(b))+ next, ok := v.valid[string(b)]+ delete(v.valid, string(b)) // spent, whatever comes of the answer+ first := len(v.exchanges) == 1+ v.mu.Unlock()+ v.arrived <- struct{}{}+ if first && v.hold != nil {+ <-v.hold+ }+ if key, ok := strings.CutPrefix(string(b), "r-raced "); ok {+ // a magpie from before the lock spent it first and saved+ // what it got, then this one is turned away+ var all map[string]map[string]any+ raw, _ := os.ReadFile(v.store)+ json.Unmarshal(raw, &all)+ all[key]["access"], all[key]["refresh"] = "a-elsewhere", "r-elsewhere"+ all[key]["expires"] = time.Now().Add(time.Hour).UnixMilli()+ raw, _ = json.Marshal(all)+ os.WriteFile(v.store, raw, 0o600)+ }+ if !ok {+ w.WriteHeader(400)+ io.WriteString(w, `{"error":"invalid_grant"}`)+ return+ }+ fmt.Fprintf(w, `{"access":"a-%s","refresh":%q}`, next, next)+ }))+ t.Cleanup(tokens.Close)+ api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ v.mu.Lock()+ v.auths = append(v.auths, r.Header.Get("Authorization"))+ v.mu.Unlock()+ io.WriteString(w, "ok")+ }))+ t.Cleanup(api.Close)+ t.Setenv("RACE_TOKEN_URL", tokens.URL)+ t.Setenv("FAKE_BASE", api.URL+"/v1")+ return v+}++func (v *raceVendor) seen() (exchanges, auths []string) {+ v.mu.Lock()+ defer v.mu.Unlock()+ return append([]string(nil), v.exchanges...), append([]string(nil), v.auths...)+}++// raceAccount adds the race plugin and an account due for renewal.+func raceAccount(t *testing.T, ctx context.Context, refresh string) string {+ t.Helper()+ abs, _ := filepath.Abs("testdata/renewrace/index.js")+ if _, err := Add(ctx, abs); err != nil {+ t.Fatal(err)+ }+ soon := time.Now().Add(time.Minute).UnixMilli() // inside the 5 minutes+ k, err := Import(ctx, "raceco", map[string]any{"type": "oauth", "refresh": refresh, "access": "a-old", "expires": soon, "accountId": "me@race"})+ if err != nil {+ t.Fatal(err)+ }+ return k+}++func raceSend(ctx context.Context, account string) error {+ res, err := Fetch(ctx, FetchRequest{Provider: "raceco", Account: account, Model: "race-1", NPM: "@ai-sdk/openai-compatible",+ URL: os.Getenv("FAKE_BASE") + "/chat/completions", Method: "POST", Body: []byte(`{}`)})+ if err != nil {+ return err+ }+ io.ReadAll(res.Body)+ return res.Body.Close()+}++func raceStored(key string) map[string]any {+ var all map[string]map[string]any+ b, _ := os.ReadFile(AuthPath())+ json.Unmarshal(b, &all)+ return all[key]+}++// changeStored sets the refresh token of the account at key in the store.+func changeStored(key, refresh string) error {+ var all map[string]map[string]any+ raw, err := os.ReadFile(AuthPath())+ if err != nil {+ return err+ }+ if err := json.Unmarshal(raw, &all); err != nil {+ return err+ }+ all[key]["refresh"] = refresh+ raw, _ = json.Marshal(all)+ return os.WriteFile(AuthPath(), raw, 0o600)+}++// TestRenewOtherHost is the second magpie of TestRenewOnceAcrossHosts:+// its host starts, it says "ready", and on "go" it sends a request on the+// account, says "renewing" once its host is renewing the sign-in, and+// "said …" for whatever its host says of the sign-in.+func TestRenewOtherHost(t *testing.T) {+ account := os.Getenv("MAGPIE_RENEW_OTHER")+ if account == "" {+ t.Skip("run by TestRenewOnceAcrossHosts")+ }+ t.Cleanup(Settle)+ var mu sync.Mutex+ out := func(s string) { mu.Lock(); os.Stdout.WriteString(s + "\n"); mu.Unlock() }+ OnSignIn(func(_, _, s string) { out("said " + s) })+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ defer cancel()+ h, err := get(ctx)+ if err != nil {+ t.Fatal(err)+ }+ out("ready")+ if line, _ := bufio.NewReader(os.Stdin).ReadString('\n'); line != "go\n" {+ t.Fatalf("told %q", line)+ }+ sent := make(chan error, 1)+ go func() { sent <- raceSend(ctx, account) }()+ // renewing, or done already: a host that didn't wait for the other's+ // renewal, which the first magpie's checks then find+ for h.renewing.Load() == 0 && len(sent) == 0 {+ time.Sleep(5 * time.Millisecond)+ }+ out("renewing")+ if err := <-sent; err != nil {+ t.Fatal(err)+ }+ Told()+ out("sent")+}++// plugins #331: each magpie process runs a host of its own, and two hosts+// renewing one sign-in at once each spent its refresh token, so a vendor+// that spends one once turned the second away and the account was marked+// signed out under the token the first had saved. Two hosts, two+// processes, one store: the first exchange is held until the second host+// is renewing too. The token is exchanged once, neither says the sign-in+// expired, and both send the new token.+func TestRenewOnceAcrossHosts(t *testing.T) {+ sandbox(t)+ v := newRaceVendor(t)+ v.hold = make(chan struct{})+ release := sync.OnceFunc(func() { close(v.hold) })+ t.Cleanup(release)+ var mu sync.Mutex+ var said []string+ OnSignIn(func(_, _, s string) { mu.Lock(); said = append(said, s); mu.Unlock() })+ t.Cleanup(func() { OnSignIn(nil) })+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ defer cancel()+ key := raceAccount(t, ctx, "r1")++ other := exec.Command(os.Args[0], "-test.run=^TestRenewOtherHost$", "-test.count=1", "-test.v")+ other.Env = append(os.Environ(), "MAGPIE_RENEW_OTHER="+key)+ stdin, _ := other.StdinPipe()+ stdout, _ := other.StdoutPipe()+ other.Stderr = os.Stderr+ if err := other.Start(); err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { other.Process.Kill(); other.Wait() })+ lines := make(chan string, 64)+ go func() {+ sc := bufio.NewScanner(stdout)+ for sc.Scan() {+ lines <- sc.Text()+ }+ close(lines)+ }()+ var otherSaid []string+ expect := func(want string) {+ t.Helper()+ for l := range lines {+ if l == want {+ return+ }+ if s, ok := strings.CutPrefix(l, "said "); ok {+ otherSaid = append(otherSaid, s)+ }+ }+ t.Fatalf("the other magpie ended before %q", want)+ }+ expect("ready")++ sent := make(chan error, 1)+ go func() { sent <- raceSend(ctx, key) }()+ <-v.arrived // this host's exchange, held+ io.WriteString(stdin, "go\n")+ expect("renewing")+ release()+ if err := <-sent; err != nil {+ t.Fatal(err)+ }+ expect("sent")+ if err := other.Wait(); err != nil {+ t.Fatalf("the other magpie: %v", err)+ }+ Told()++ exchanges, auths := v.seen()+ if len(exchanges) != 1 {+ t.Errorf("exchanges = %v, want r1 once", exchanges)+ }+ mu.Lock()+ all := append(append([]string(nil), said...), otherSaid...)+ mu.Unlock()+ for _, s := range all {+ if s == "expired" {+ t.Errorf("a host said the sign-in expired: this one %v, the other %v", said, otherSaid)+ }+ }+ if len(auths) != 2 || auths[0] != "Bearer a-r2" || auths[1] != "Bearer a-r2" {+ t.Errorf("requests went with %v, want the new token twice", auths)+ }+ if a := raceStored(key); a["refresh"] != "r2" || a["access"] != "a-r2" {+ t.Errorf("kept %v", a)+ }+}++// A renewal lock left by a magpie that died is taken over at once: the+// renewal is made inside the wait a request gives it, not after the+// lock's minute. A token the vendor turns away still says the sign-in+// expired, and leaves it as it was; one turned away because another+// magpie spent it and saved the new one meanwhile doesn't.+func TestRenewLockOfDeadHostAndRefusal(t *testing.T) {+ sandbox(t)+ v := newRaceVendor(t)+ said := make(chan string, 16)+ OnSignIn(func(_, _, s string) { said <- s })+ t.Cleanup(func() { OnSignIn(nil) })+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)+ defer cancel()+ key := raceAccount(t, ctx, "r1")++ dead := exec.Command(os.Args[0], "-test.run=^$")+ if err := dead.Run(); err != nil {+ t.Fatal(err)+ }+ sum := sha256.Sum256([]byte(key))+ lock := AuthPath() + ".renew-" + hex.EncodeToString(sum[:])[:16] + ".lock"+ held := fmt.Sprintf(`{"pid":%d,"at":%d}`, dead.Process.Pid, time.Now().UnixMilli())+ if err := os.WriteFile(lock, []byte(held), 0o600); err != nil {+ t.Fatal(err)+ }+ if err := raceSend(ctx, key); err != nil {+ t.Fatal(err)+ }+ if s := waitSaid(t, said); s != "renewed" {+ t.Fatalf("said %q", s)+ }+ if exchanges, auths := v.seen(); len(exchanges) != 1 || len(auths) != 1 || auths[0] != "Bearer a-r2" {+ t.Fatalf("exchanges %v, requests %v: the dead magpie's lock was waited out", exchanges, auths)+ }+ if _, err := os.Stat(lock); !os.IsNotExist(err) {+ t.Fatalf("the lock is left: %v", err)+ }++ refused, err := Import(ctx, "raceco", map[string]any{"type": "oauth", "refresh": "r-never", "access": "a-old", "expires": time.Now().Add(time.Minute).UnixMilli(), "accountId": "refused@race"})+ if err != nil {+ t.Fatal(err)+ }+ if err := raceSend(ctx, refused); err != nil {+ t.Fatal(err)+ }+ if s := waitSaid(t, said); s != "expired" {+ t.Fatalf("a refused token said %q, want expired", s)+ }+ if a := raceStored(refused); a["refresh"] != "r-never" || a["access"] != "a-old" {+ t.Fatalf("a refused account was changed: %v", a)+ }++ // turned away because another magpie, one that didn't take the lock,+ // spent the token and saved what it got: not signed out, and its+ // token is the one sent+ raced, err := Import(ctx, "raceco", map[string]any{"type": "oauth", "refresh": "r-raced", "access": "a-old", "expires": time.Now().Add(time.Minute).UnixMilli(), "accountId": "raced@race"})+ if err != nil {+ t.Fatal(err)+ }+ if err := changeStored(raced, "r-raced "+raced); err != nil {+ t.Fatal(err)+ }+ if err := raceSend(ctx, raced); err != nil {+ t.Fatal(err)+ }+ if err := raceSend(ctx, raced); err != nil {+ t.Fatal(err)+ }+ Told()+ select {+ case s := <-said:+ t.Fatalf("a token another magpie renewed meanwhile said %q", s)+ default:+ }+ if _, auths := v.seen(); auths[len(auths)-1] != "Bearer a-elsewhere" {+ t.Fatalf("requests went with %v, want the other magpie's token last", auths)+ }+}diff --git a/internal/plugin/testdata/renewrace/index.js b/internal/plugin/testdata/renewrace/index.jsnew file mode 100644index 000000000..317b5fac8--- /dev/null+++ b/internal/plugin/testdata/renewrace/index.js@@ -0,0 +1,35 @@+// A plugin that leaves renewing its sign-ins to magpie (auth.refresh)+// against a vendor that spends a refresh token once: $RACE_TOKEN_URL+// exchanges it, and answers one sent again, or never given, with+// invalid_grant, which signs the account out. Requests go to $FAKE_BASE.+export const RacePlugin = async () => ({+ config: async (cfg) => {+ cfg.provider = cfg.provider ?? {}+ cfg.provider.raceco = {+ name: "RaceCo",+ npm: "@ai-sdk/openai-compatible",+ api: "https://race.invalid/v1",+ models: { "race-1": { name: "Race One", limit: { context: 1000, output: 100 } } },+ }+ },+ auth: {+ provider: "raceco",+ methods: [{ type: "api", label: "API key" }],+ async refresh(auth) {+ const res = await fetch(process.env.RACE_TOKEN_URL, { method: "POST", body: auth.refresh })+ const t = await res.json()+ if (t.error === "invalid_grant") throw Object.assign(new Error("RaceCo: invalid_grant"), { signIn: "expired" })+ if (!res.ok) throw new Error("RaceCo: " + res.status)+ return { access: t.access, refresh: t.refresh, expires: Date.now() + 3600e3 }+ },+ loader: async (getAuth) => ({+ baseURL: process.env.FAKE_BASE,+ async fetch(url, init) {+ const a = await getAuth()+ const h = new Headers(init.headers)+ h.set("authorization", "Bearer " + a.access)+ return fetch(url, { ...init, headers: h })+ },+ }),+ },+})