@modelprofile.com/authswitch 5.2.0 → 6.1.0

package/dist_ts/classes.opencodeharness.js

@@ -2,10 +2,18 @@ import * as plugins from './plugins.js';
 import { FileHarness } from './classes.fileharness.js';
 import { CredentialStore, credentialHash, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw } from './classes.credentialstore.js';
 import { HarnessProcesses } from './classes.harnessprocesses.js';
+import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { CLAUDE_REFRESH_MARGIN_MS } from './classes.claudetokenrefresh.js';
+import { ClaudeLoginRejectedError, ClaudeRateLimitError } from './claudehttp.js';
 import { CodexAccountStatus } from './classes.codexstatus.js';
+import { OpenCodeAnthropicRefresh } from './classes.opencodeanthropicrefresh.js';
 import { writeSecretFileAtomically } from './helpers.js';
 import { beginSavedOpenAiLogin, openCodeCredentialFromLogin } from './classes.login.js';
 import { plainText } from './formatting.js';
+/** Anthropic refused the grant OpenCode's entry holds; no retry and no other account changes that answer. */
+const ANTHROPIC_LOGIN_REJECTED = 'Login expired or was rejected. Log in again with opencode auth login.';
+/** A saved copy is not the login OpenCode uses, so renewing it would rotate a token OpenCode's own entry still holds. */
+const SAVED_ANTHROPIC_EXPIRED = 'This saved Anthropic login\'s access token has expired. authswitch renews the Anthropic login OpenCode has active; activate this one to have it renewed, or log in again with opencode auth login.';
 /** OpenCode owns one login per provider. Replacing a slot never replaces the whole provider set. */
 export class OpenCodeHarness extends FileHarness {
     id = 'opencode';
@@ -15,20 +23,30 @@ export class OpenCodeHarness extends FileHarness {
     liveSwap = false;
     /** Only its OpenAI login reports usage, and a supervisor (AGL) restarts it around a switch, so a watch leaves it alone. */
     autoSwitch = false;
+    /** OpenCode re-reads its credential file on every request; only a request already in flight still holds the previous login. */
+    runningRetention() {
+        return 'They re-read the credential file on every request, but a request already in flight still holds the previous login, and its token refresh can ';
+    }
     loginProviders = [{ providerId: 'openai', label: 'OpenAI', flows: ['device'] }];
     store;
     file;
     env;
     status;
+    claudeStatus;
+    anthropicRefresh;
     processes;
     fetcher;
+    now;
     constructor(options = {}) {
         super();
         this.env = options.env ?? process.env;
         this.file = plugins.path.join(options.dataHome ?? (this.env.XDG_DATA_HOME || plugins.path.join(plugins.os.homedir(), '.local', 'share')), 'opencode', 'auth.json');
         this.store = new CredentialStore(this.id, options.stashRoot);
         this.status = new CodexAccountStatus(options.fetch);
+        this.claudeStatus = new ClaudeAccountStatus(options.fetch, options.now);
+        this.anthropicRefresh = new OpenCodeAnthropicRefresh(options.fetch, options.now);
         this.fetcher = options.fetch;
+        this.now = options.now ?? Date.now;
         this.processes = options.processes ?? new HarnessProcesses('opencode');
     }
     /** Every provider entry lives in one file, so its bytes are the whole stability proof. */
@@ -113,14 +131,93 @@ export class OpenCodeHarness extends FileHarness {
         if (readCredentialDocument(this.file).raw !== raw)
             throw new Error('Active login verification failed. The outgoing login remains saved.');
     }
-    async readAccountStatus(id, optionsArg) {
-        const account = this.readCredential(id);
+    /** The login OpenCode has in a provider slot, read from its file; undefined where the file holds none it can read. */
+    activeSlot(slotIdArg) {
+        return this.snapshot().accounts.find(account => account.slotId === slotIdArg);
+    }
+    /** Whether this login's access token is inside Claude Code's five-minute margin, the margin Claude's own logins use. */
+    renewalDue(credentialArg) {
+        const expires = credentialArg.expires;
+        return typeof expires === 'number' && Number.isFinite(expires) && this.now() + CLAUDE_REFRESH_MARGIN_MS >= expires;
+    }
+    /**
+     * Renews OpenCode's active Anthropic login and writes the rotated pair back into OpenCode's own credential file.
+     *
+     * Nothing is stranded by that write. OpenCode's auth service reads `auth.json` on every `Auth.all()`, `Auth.get()`
+     * is that read (1.18.15 @99100961, 1.18.31 @103733929), and its Anthropic provider -- `opencode-anthropic-auth`
+     * 0.0.13, since the binary carries no Anthropic OAuth code -- calls the `getAuth()` it was initialised with
+     * (@98017331) inside the `fetch` wrapper of every single request. A running OpenCode therefore holds no refresh
+     * token in memory and picks up this rotation on its next request, exactly as it picks up its own.
+     *
+     * The renewal is the only authswitch operation on the store while it runs, and the rotated pair replaces the
+     * entry only while OpenCode still holds the refresh token that was sent: a login OpenCode renewed meanwhile is
+     * returned as it now stands. The write itself is `apply`'s verified compare-and-swap, which preserves every other
+     * provider and replaces the file atomically -- OpenCode writes the same file in place. The slot's switch record
+     * follows that write, because an `anthropic` login's identity is its refresh token and this rotation is
+     * authswitch's own: without that, the next read would report this write as a different account.
+     */
+    renewAnthropic(accountArg, signalArg) {
+        return this.store.locked(async () => {
+            const current = this.activeSlot(accountArg.slotId) ?? accountArg;
+            if (!this.renewalDue(current.credential))
+                return current;
+            const refreshToken = credentialText(current.credential.refresh);
+            if (refreshToken === undefined)
+                throw new Error('This Anthropic login holds no refresh token; log in again with opencode auth login.');
+            signalArg?.throwIfAborted();
+            const tokens = await this.anthropicRefresh.refresh(refreshToken);
+            const latest = this.activeSlot(accountArg.slotId);
+            if (!latest || credentialText(latest.credential.refresh) !== refreshToken)
+                return latest ?? current;
+            const renewed = this.inspect({ ...latest.credential, access: tokens.access, refresh: tokens.refresh, expires: tokens.expires }, latest.slotId);
+            this.apply(latest.slotId, latest, renewed);
+            this.recordRenewal(latest.slotId);
+            return renewed;
+        }, { signal: signalArg });
+    }
+    /**
+     * The subscription and usage of an OpenCode `anthropic` OAuth login.
+     *
+     * That entry holds the same Claude subscriber grant Claude Code stores, so Claude's own account endpoints answer
+     * for it and the account reports real windows instead of no quota API at all. OpenCode keeps no scopes and no
+     * account identity with it, so the service decides both. A due access token is renewed first, with OpenCode's own
+     * request; a refusal is reported and nothing is written, so the entry OpenCode owns is left exactly as it was.
+     *
+     * A saved copy is never renewed: OpenCode's entry holds the same refresh token, and rotating it here would leave
+     * the login OpenCode actually uses holding a token the service has replaced.
+     */
+    async anthropicStatus(accountArg, isActiveArg, optionsArg) {
+        let account = accountArg;
+        if (this.renewalDue(account.credential)) {
+            if (!isActiveArg)
+                return this.claudeStatus.unavailable({}, SAVED_ANTHROPIC_EXPIRED);
+            try {
+                account = await this.renewAnthropic(account, optionsArg.signal);
+            }
+            catch (error) {
+                if (optionsArg.signal?.aborted)
+                    throw error;
+                const problem = error instanceof ClaudeLoginRejectedError ? ANTHROPIC_LOGIN_REJECTED
+                    : error instanceof Error ? error.message : 'the login could not be renewed.';
+                return this.claudeStatus.unavailable({}, `Login refresh: ${problem}`, error instanceof ClaudeRateLimitError ? { retryAt: error.retryAt } : undefined);
+            }
+        }
+        const accessToken = credentialText(account.credential.access);
+        if (accessToken === undefined)
+            return this.claudeStatus.unavailable({}, 'This Anthropic login holds no usable access token; log in again with opencode auth login.');
+        return this.claudeStatus.read({ accessToken, scopes: [] }, optionsArg);
+    }
+    async readAccountStatus(id, optionsArg = {}) {
+        const active = this.activeCredential(id);
+        const account = active ?? this.savedCredential(id);
         if (account.slotId === 'openai' && account.credential.type === 'oauth') {
             const info = this.openAiInfo(account.credential);
             if (!info.accountId)
                 return { facts: [], problems: ['The OpenAI login has no account ID for a status lookup.'] };
             return this.status.readCredential(credentialText(account.credential.access), info.accountId, info.plan, optionsArg);
         }
+        if (account.slotId === 'anthropic' && account.credential.type === 'oauth')
+            return this.anthropicStatus(account, active !== undefined, optionsArg);
         return { facts: [
                 { section: 'Authentication', label: 'Provider', value: account.slotId },
                 { section: 'Authentication', label: 'Login type', value: String(account.credential.type) },
@@ -128,4 +225,4 @@ export class OpenCodeHarness extends FileHarness {
             ], problems: [] };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.opencodeharness.js","sourceRoot":"","sources":["../ts/classes.opencodeharness.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,WAAW,EAAgD,MAAM,0BAA0B,CAAC;AACrG,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAC5J,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAW5C,oGAAoG;AACpG,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC9B,EAAE,GAAG,UAAU,CAAC;IAChB,KAAK,GAAG,UAAU,CAAC;IACnB,SAAS,GAAG,wFAAwF,CAAC;IACrH,uHAAuH;IACvG,QAAQ,GAAG,KAAK,CAAC;IACjC,2HAA2H;IAC3G,UAAU,GAAG,KAAK,CAAC;IACnB,cAAc,GAA4B,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACtG,KAAK,CAAkB;IACzB,IAAI,CAAS;IACb,GAAG,CAAoB;IACvB,MAAM,CAAqB;IAC5B,SAAS,CAAyB;IACjC,OAAO,CAAgB;IAExC,YAAY,UAAmC,EAAE;QAC/C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;QACtC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;QACnK,IAAI,CAAC,KAAK,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,MAAM,GAAG,IAAI,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,IAAI,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACzE,CAAC;IACD,0FAA0F;IAChF,aAAa,KAAwB,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACvF,sGAAsG;IAC/F,qBAAqB;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;QAChF,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IAC7E,CAAC;IACM,UAAU,CAAC,UAAgC,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE;QACxF,OAAO,qBAAqB,CAAC,KAAK,EAAC,MAAM,EAAC,EAAE;YAC1C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,2BAA2B,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YACpG,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,KAAK,KAAK,CAAC,SAAS,CAAE,CAAC;YACnG,OAAO,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,0BAA0B,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,iCAAiC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;QAChN,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IACO,UAAU,CAAC,KAA8B;QAC/C,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;YAAE,OAAO,EAAE,CAAC;QACtC,IAAI,MAA4D,CAAC;QACjE,IAAI,CAAC;YAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAC,cAAc,CAAC,KAAK,CAAC,MAAM,CAAE,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,2CAA2C,CAAC,CAAC;QACnJ,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,MAAM,EAAE,gBAAgB,CAAC;QAC9E,IAAI,KAAK,CAAC,SAAS,IAAI,MAAM,EAAE,gBAAgB,IAAI,KAAK,CAAC,SAAS,KAAK,MAAM,CAAC,gBAAgB;YAAE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC7K,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IAC3F,CAAC;IACS,OAAO,CAAC,UAAmC,EAAE,MAAc;QACnE,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACzF,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC7B,IAAI,MAA0B,CAAC;QAC/B,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACrB,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,OAAO,UAAU,CAAC,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YAC3N,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC9C,CAAC;aAAM,IAAI,IAAI,KAAK,KAAK;YAAE,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;aAC9D,IAAI,IAAI,KAAK,WAAW,IAAI,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,MAAM,GAAG,cAAc,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC3G,IAAI,CAAC,MAAM;YAAE,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;QACnG,MAAM,IAAI,GAAG,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACpE,MAAM,WAAW,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,WAAW,EAAE,CAAC;QACvF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QACzJ,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IACjD,CAAC;IACS,QAAQ;QAChB,IAAI,IAAI,CAAC,GAAG,CAAC,qBAAqB,KAAK,SAAS;YAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,WAAW,EAAE,4FAA4F,EAAE,CAAC;QACrL,MAAM,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;QACpD,MAAM,QAAQ,GAAmB,EAAE,CAAC;QACpC,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,KAAK,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACrD,IAAI,CAAC;gBAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;YAAC,CAAC;YACvE,MAAM,CAAC;gBAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAAC,CAAC;QACvC,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,4GAA4G,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC7K,CAAC;IACS,KAAK,CAAC,MAAc,EAAE,QAAkC,EAAE,MAAgC;QAClG,MAAM,QAAQ,GAAG,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;QAChL,MAAM,IAAI,GAAG,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QAClC,IAAI,MAAM;YAAE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;;YAC/H,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;QACjD,IAAI,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,wFAAwF,CAAC,CAAC;QACtK,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACxF,yBAAyB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC1C,IAAI,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IAC5I,CAAC;IACM,KAAK,CAAC,iBAAiB,CAAC,EAAU,EAAE,UAAkC;QAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QACxC,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACvE,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACjD,IAAI,CAAC,IAAI,CAAC,SAAS;gBAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,yDAAyD,CAAC,EAAE,CAAC;YACjH,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAE,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACvH,CAAC;QACD,OAAO,EAAE,KAAK,EAAE;gBACd,EAAE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE;gBACvE,EAAE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBAC1F,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,2BAA2B,EAAE,KAAK,EAAE,4EAA4E,EAAE;aACrJ,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IACpB,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.opencodeharness.js","sourceRoot":"","sources":["../ts/classes.opencodeharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/claudehttp.d.ts

@@ -7,6 +7,20 @@ export declare const CLAUDE_LOGIN_REJECTED = "Login expired or was rejected. Log
 export declare class ClaudeLoginRejectedError extends ClaudeRequestError {
     constructor();
 }
+/**
+ * Where Claude Code 2.1.273 sends an account the service put on hold (`T5e`, bundle offset @190070402). A hold is
+ * not a dead login: the service refuses the grant while it lasts and accepts it again once it is lifted.
+ */
+export declare const CLAUDE_ACCOUNT_ON_HOLD_URL = "https://claude.ai/restricted";
+/** The service put this account on hold. The login itself is intact, so it is never remembered as refused. */
+export declare class ClaudeAccountOnHoldError extends ClaudeRequestError {
+    constructor();
+}
+/**
+ * The OAuth error code a response names, read as Claude Code 2.1.273 reads it (`xc`, @191165290): the `error` field
+ * as a string, or the `type` of the object some Anthropic endpoints send it as.
+ */
+export declare const oauthErrorCode: (bodyArg: Record<string, unknown> | null) => string | undefined;
 /** The service refused a request for too many requests. That says nothing about the account's usage or login. */
 export declare class ClaudeRateLimitError extends ClaudeRequestError {
     readonly retryAt: string | null;

package/dist_ts/claudehttp.js

@@ -10,6 +10,26 @@ export const CLAUDE_LOGIN_REJECTED = 'Login expired or was rejected. Log in agai
 export class ClaudeLoginRejectedError extends ClaudeRequestError {
     constructor() { super(CLAUDE_LOGIN_REJECTED); }
 }
+/**
+ * Where Claude Code 2.1.273 sends an account the service put on hold (`T5e`, bundle offset @190070402). A hold is
+ * not a dead login: the service refuses the grant while it lasts and accepts it again once it is lifted.
+ */
+export const CLAUDE_ACCOUNT_ON_HOLD_URL = 'https://claude.ai/restricted';
+/** The service put this account on hold. The login itself is intact, so it is never remembered as refused. */
+export class ClaudeAccountOnHoldError extends ClaudeRequestError {
+    constructor() { super(`This Claude account is on hold and cannot sign in. View details or appeal: ${CLAUDE_ACCOUNT_ON_HOLD_URL}`); }
+}
+/**
+ * The OAuth error code a response names, read as Claude Code 2.1.273 reads it (`xc`, @191165290): the `error` field
+ * as a string, or the `type` of the object some Anthropic endpoints send it as.
+ */
+export const oauthErrorCode = (bodyArg) => {
+    const error = bodyArg?.error;
+    if (typeof error === 'string')
+        return error;
+    const type = typeof error === 'object' && error !== null ? error.type : undefined;
+    return typeof type === 'string' ? type : undefined;
+};
 /** The service refused a request for too many requests. That says nothing about the account's usage or login. */
 export class ClaudeRateLimitError extends ClaudeRequestError {
     retryAt;
@@ -80,4 +100,4 @@ export const claudeRequest = async (fetcherArg, requestArg) => {
         throw new ClaudeRequestError(`The ${requestArg.subject} service could not be reached.`);
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/interfaces.harness.d.ts

@@ -236,9 +236,13 @@ export interface IAuthHarness {
      */
     readonly autoSwitch?: boolean;
     /**
-     * The account's live status. It must never activate, switch or clear a login. It may renew the tokens of the
-     * saved copy it reads when the provider leaves it no other way to answer -- the Claude Code adapter does, for
-     * saved and inactive logins only, under its store's lock -- and must leave the active login's credential alone.
+     * The account's live status. It must never activate, switch or clear a login.
+     *
+     * It may renew the tokens of the credential it reads when the provider leaves it no other way to answer, under
+     * its store's lock and with a compare-and-swap on the refresh token it sent. A saved copy is always its own to
+     * renew -- the Claude Code adapter renews one, because Claude Code's active login is Claude Code's. The active
+     * login may only be renewed where the owning harness re-reads its credential file on every request, so that the
+     * rotation strands nothing: OpenCode's Anthropic provider does, and authswitch renews that entry.
      */
     readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
     readonly loginProviders?: IHarnessLoginProvider[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "5.2.0",
+  "version": "6.1.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",

package/readme.md

@@ -109,8 +109,11 @@ never blocked by a waiting switch; after that the operation fails with nothing
 changed. A lock left behind by a Claude Code that died goes stale after its own
 threshold and is taken over, as Claude Code itself would.
 
-**OpenCode keeps the previous login until it restarts.** It holds that login in
-memory and can write it back at its next OAuth token refresh. So before `use` and
+**A running OpenCode can still overwrite a switch.** Not by holding the previous login:
+its auth service caches nothing and re-reads `auth.json` on every lookup. The window is a
+request already in flight, which read the previous login before the switch and can write
+that login's own rotation back afterwards -- and OpenCode replaces the whole provider map
+in place rather than atomically. So before `use` and
 before `stash` without `--keep`, authswitch lists OpenCode's own running instances --
 pid, start time and command line -- and offers to stop them:
 
@@ -214,8 +217,20 @@ every other provider, and `stash openai` without `--keep` clears only OpenAI.
 When several logins are active, the guide asks which to save; scripts must name
 the provider or account. In the TUI, select an active row before pressing `a` or `c`.
 ChatGPT OAuth accounts display their email and use the same direct status APIs as
-Codex. API keys and opaque provider tokens have no reliable email, so their labels
-contain the provider and a SHA-256 fingerprint. Their quota/billing information is
+Codex. An `anthropic` OAuth login holds the same Claude subscriber grant Claude Code
+stores, so it reports Claude's own plan, organization and usage windows through the
+account endpoints described under **Claude Code**; OpenCode keeps no scopes and no
+account identity with that entry, so both are left to the service. An access token inside
+Claude Code's five-minute margin is renewed first, with the request OpenCode's own
+Anthropic provider sends (`opencode-anthropic-auth`: `console.anthropic.com`, Claude
+Code's public client, no scope), and the rotated pair is written back into `auth.json`
+atomically, preserving every other provider. Nothing is stranded by that write: OpenCode's
+auth service re-reads `auth.json` on every lookup and its Anthropic provider asks for the
+credential again inside every request, so a running instance picks up the rotation exactly
+as it picks up its own. A refusal is reported and nothing is written, and a saved copy is
+never renewed, because OpenCode's own entry holds the same refresh token.
+API keys and opaque provider tokens have no reliable email, so their
+labels contain the provider and a SHA-256 fingerprint. Their quota/billing information is
 explicitly unavailable. `OPENCODE_AUTH_CONTENT` overrides the file and blocks file
 management. Provider configuration and environment credentials remain managed by OpenCode.
 
@@ -254,19 +269,27 @@ authswitch does not infer them from account creation or token expiry dates. The
 Claude Code adapter declares that, so `limits` explains it once for the provider
 instead of per account.
 
-Nothing but Claude Code refreshes a Claude login, so a saved one stops being readable
-a few hours after it was saved. Reading a **saved, inactive** account's status therefore
+Nothing but Claude Code refreshes a Claude login, so a saved one stops being readable a
+few hours after it was saved. Reading a **saved, inactive** account's status therefore
 refreshes it first, exactly as Claude Code would: when its access token expires within
 five minutes, authswitch exchanges the stored refresh token at Claude's token endpoint,
 keeps every other field of the login, and writes the result only while the saved record
-still holds the refresh token it sent. The refresh holds the account store's lock, so a
-switch started at the same time waits for it and then activates the refreshed login. The
-**active** login is never refreshed -- Claude Code owns it, and two parties refreshing one
-login can invalidate the grant. A refusal is reported, never worked around -- a rejected
-grant says so and says what fixes it (below), and a service failure, an unreachable service
-or an unsupported response leave the saved login untouched. Requests carry `User-Agent:
-authswitch/<version>`, and HTTP 429 is reported as rate limiting with the service's retry
-time -- never as an exhausted or expired account.
+still holds the refresh token it sent. The request is the one Claude Code sends, down to
+the scopes: a login of Claude Code's own OAuth client is renewed with Claude Code's
+current scope set plus the project scopes the login carries -- not with the set the
+login happens to be stored under, which can be an older or wider one the service no
+longer accepts -- and a set the service refuses as `invalid_scope` is sent once more
+with the stored scopes. A login that names its own OAuth client keeps its stored scopes,
+because only that client's grant knows them. A login that is neither one of Claude
+Code's subscriber logins nor stored with a plan is not sent at all. The refresh holds
+the account store's lock, so a switch started at the same time waits for it and then
+activates the refreshed login. The **active** login is never refreshed -- Claude Code
+owns it, and two parties refreshing one login can invalidate the grant. A refusal is
+reported, never worked around -- a rejected grant says so and says what fixes it
+(below), and a service failure, an unreachable service or an unsupported response leave
+the saved login untouched. Requests carry `User-Agent: authswitch/<version>`, and HTTP
+429 is reported as rate limiting with the service's retry time -- never as an exhausted
+or expired account.
 
 Claude Code also rotates the refresh token of the login it **is** running on, so reading the
 accounts (`list`, `limits`, `active`, `current`, `watch`, the dashboard) mirrors that login
@@ -279,14 +302,57 @@ saved implicitly; `stash` is what saves a login. An installation whose native lo
 authswitch cannot read mirrors nothing, and a read waits at most a second for a lock a
 switch or Claude Code holds before leaving the saved copy to the next read.
 
-A grant the sign-in service refused is remembered in the saved record itself, as a hash of
-the refresh token -- never the token -- so a new authswitch run, a restarted watch or a
-second dashboard does not replay a dead login. Saving that login again clears it, as does
-any refresh that replaces the saved credential. Such a login reports `Login expired or was
-rejected. Log in again with Claude Code and save it. Claude Code rotates a login's refresh
-token as it uses it, and the service can refuse the older one a saved copy still holds once
-that login has been replaced outside authswitch; authswitch claude stash --keep saves the
-new one.`
+An account the service has put **on hold** is not a dead login: the hold refuses the grant
+while it lasts and the same login works again once it is lifted, so such an account keeps
+its stored plan, says that it is on hold and where to appeal, and is asked again on the
+next read.
+
+A grant the sign-in service refused is remembered in the saved record itself, as a hash
+of the request that was refused -- the refresh token, the client and the scopes, never
+the token itself -- so a new authswitch run, a restarted watch or a second dashboard
+does not replay a dead login. Because the hash covers the request and not only the
+token, a release that changes how authswitch asks gives every such login one honest
+attempt under the new derivation, while a refusal of the request authswitch still sends
+stays remembered. Saving that login again clears it, as does any refresh that replaces
+the saved credential. Such a login reports `Login expired or was rejected. Log in again
+with Claude Code and save it. Claude Code rotates a login's refresh token as it uses it,
+and the service can refuse the older one a saved copy still holds once that login has
+been replaced outside authswitch; authswitch claude stash --keep saves the new one.`
+
+Each `n/a` in a Claude row has a reason in the footnote under the table, and each
+reason names what to do:
+
+- `Login refresh: Login expired or was rejected.` -- the sign-in service refused the
+  saved refresh token itself. Log in again in Claude Code for that account and run
+  `authswitch claude stash --keep`; nothing else fixes it.
+- `Login refresh: This Claude account is on hold and cannot sign in.` -- the account,
+  not the login. Appeal at the address in the message; the saved login is kept and is
+  asked again on the next read.
+- `Login refresh: This saved login has no refresh token, and no subscriber scope or
+  plan to refresh with.` -- the saved record is missing what a refresh is made of.
+  Save the login again.
+- `Login refresh: this saved login's access token has expired and cannot be renewed
+  for this installation.` -- authswitch cannot read Claude Code's own files here (the
+  macOS Keychain, or an incomplete native login), so it cannot prove this login is not
+  the active one, and never refreshes a login that might be.
+- `Login refresh: The Claude sign-in service returned HTTP ...`, `... could not be
+  reached.`, `... timed out.`, `... is rate limiting requests (HTTP 429)` -- the
+  service, not the login. The saved login is untouched; read again later.
+- `Profile: ...` or `Usage: ...` -- the account endpoints, asked with a token the
+  refresh had just accepted. `Profile: Login expired or was rejected.` means the access
+  token itself was refused; the other wordings are the service, as above.
+- `Claude returned a different account or organization` -- the answer was about another
+  account and was discarded whole, rather than shown under this account's name.
+- `Claude profile response is unsupported` or `Claude usage response is unsupported` --
+  the service answered in a shape authswitch does not read. Nothing is guessed from a
+  response it does not understand.
+
+An OpenCode `anthropic` row reads the same endpoints and so shows the same reasons. Its
+renewal adds `Login refresh: Login expired or was rejected. Log in again with opencode
+auth login.`, which is Anthropic refusing the refresh token OpenCode's entry holds -- no
+retry changes that, and the refusal is never remembered, because OpenCode owns that entry.
+`This saved Anthropic login's access token has expired.` is a stashed copy, which is left
+alone so that the login OpenCode uses keeps a refresh token the service still accepts.
 
 OpenCode and Claude saved records are separate owner-only files under
 `~/.authswitch/opencode` and `~/.authswitch/claude`. Emails are accepted as account
@@ -982,7 +1048,7 @@ Account identity comes from the `id_token` inside the credential — the email c
 
 **Other Codex clients keep running.** Stopping the managed app-server does not stop an editor extension that spawned its own. Close it, or expect it to keep using the credential it already loaded.
 
-**A running OpenCode can undo a switch.** It holds the previous login in memory and rewrites the credential file at its next token refresh. Authswitch lists those instances, offers to stop them, warns when any keep running, and detects the overwrite afterwards — but it cannot prevent it while they run. Restart them after a switch. A running Claude Code picks the switch up instead; its guarantee rests on the behaviour and lock protocol verified against Claude Code 2.1.273, and `authswitch claude active` still reports a login that changed outside authswitch.
+**A running OpenCode can undo a switch.** Its auth service keeps no login in memory -- every lookup re-reads `auth.json` -- but a request already in flight, which read the previous login before the switch, can write that login's own rotation back afterwards, over a provider map OpenCode replaces in place. Authswitch lists those instances, offers to stop them, warns when any keep running, and detects the overwrite afterwards — but it cannot prevent it while they run. Restart them after a switch. A running Claude Code picks the switch up instead; its guarantee rests on the behaviour and lock protocol verified against Claude Code 2.1.273, and `authswitch claude active` still reports a login that changed outside authswitch.
 
 **The Codex stash is keyed by email.** Two Codex workspaces with the same email
 cannot both be saved under that key. Their account IDs are distinguished during

package/ts/00_commitinfo_data.ts

@@ -2,7 +2,7 @@
  * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
-  name: "@modelprofile.com/authswitch",
-  version: "5.2.0",
-  description: "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status"
+  name: '@modelprofile.com/authswitch',
+  version: '6.1.0',
+  description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/accounts.ts

@@ -239,7 +239,8 @@ const STATUS_LOOKUP_CONCURRENCY = 4;
  * Bounded status lookups: at most four accounts at a time, started in order, each handed the caller's signal.
  * A lookup that fails reports undefined; once the signal aborts, no further lookup starts. A callback that throws
  * rejects the call, and no other lookup starts after it. No lookup activates, switches or clears a login, though an
- * adapter may renew the tokens of the saved copy it reads (`IAuthHarness.readAccountStatus`).
+ * adapter may renew the tokens of the credential it reads, saved or active, on that method's terms
+ * (`IAuthHarness.readAccountStatus`).
  */
 const lookupStatuses = async (
   harnessArg: IAuthHarness,

package/ts/classes.claudecodeharness.ts

@@ -2,9 +2,9 @@ import * as plugins from './plugins.js';
 import { FileHarness, type IFileAccount, type IFileHarnessSnapshot } from './classes.fileharness.js';
 import { CredentialStore, credentialHash, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw, type IStoredCredential } from './classes.credentialstore.js';
 import { HarnessProcesses } from './classes.harnessprocesses.js';
-import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { ClaudeAccountStatus, type IClaudeLogin } from './classes.claudestatus.js';
 import { ClaudeCodeLocks } from './classes.claudecodelocks.js';
-import { ClaudeTokenRefresh, type IClaudeTokens } from './classes.claudetokenrefresh.js';
+import { claudeGrant, ClaudeTokenRefresh, grantScope, type IClaudeTokens } from './classes.claudetokenrefresh.js';
 import { CLAUDE_LOGIN_REJECTED, ClaudeLoginRejectedError, ClaudeRateLimitError } from './claudehttp.js';
 import { writeSecretFileAtomically } from './helpers.js';
 import type { IHarnessAccountStatus, IHarnessProcessControl, IHarnessState, IHarnessStatusOptions } from './interfaces.harness.js';
@@ -160,8 +160,33 @@ export class ClaudeCodeHarness extends FileHarness {
       throw new Error('Claude Code switch failed while updating account metadata and was rolled back. The outgoing login remains saved; check authswitch claude doctor.');
     }
   }
-  /** The hash that identifies a saved login's refresh token, so a rejected grant is remembered without keeping it. */
-  private grantKey(oauthArg: Record<string, unknown>): string { return credentialHash(credentialText(oauthArg.refreshToken) ?? ''); }
+  /**
+   * The hash that identifies a refused sign-in, so it is remembered without keeping anything of the login.
+   *
+   * A refusal is about one request: the refresh token it carried, and the client and scopes authswitch derived for
+   * it. Binding all three means a login keeps its refusal for as long as authswitch would send the same request
+   * again, and that a release which changes the derivation -- adopting a scope set Claude Code changed, say -- gives
+   * every such login one honest attempt under the new one instead of repeating a verdict its request no longer earns.
+   */
+  private grantKey(oauthArg: Record<string, unknown>): string {
+    const grant = claudeGrant(oauthArg);
+    return credentialHash(JSON.stringify([credentialText(oauthArg.refreshToken) ?? '', grant?.clientId ?? '', grant === null ? '' : grantScope(grant.scopes)]));
+  }
+
+  /** The login a status lookup asks with: its token, and what this store knows about it. */
+  private login(accountArg: IFileAccount): IClaudeLogin {
+    const oauth = credentialRecord(accountArg.credential.claudeAiOauth);
+    const account = credentialRecord(accountArg.credential.oauthAccount);
+    const accountUuid = credentialText(account.accountUuid);
+    const organizationUuid = credentialText(account.organizationUuid);
+    const plan = credentialText(oauth.subscriptionType);
+    return {
+      accessToken: credentialText(oauth.accessToken) ?? '',
+      scopes: Array.isArray(oauth.scopes) ? oauth.scopes.filter((scope): scope is string => typeof scope === 'string') : [],
+      ...(accountUuid !== undefined && organizationUuid !== undefined ? { identity: { accountUuid, organizationUuid } } : {}),
+      ...(plan === undefined ? {} : { plan }),
+    };
+  }
 
   /**
    * The harness's accounts, with the saved copy of the active login brought up to date first.
@@ -226,28 +251,28 @@ export class ClaudeCodeHarness extends FileHarness {
    * is due is refreshed first; when that fails, the status says why and keeps the stored plan, and the saved login is
    * left exactly as it was.
    *
-   * A refresh is only ever sent for a login the native files prove is not the active one (`nativeView`), and a grant
-   * the service already rejected is not sent again while the saved record still holds it.
+   * A refresh is only ever sent for a login the native files prove is not the active one (`nativeView`), and a request
+   * the service already refused is not sent again while the saved record would produce the same one (`grantKey`).
    */
   public async readAccountStatus(id: string, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
-    const read = (accountArg: IFileAccount) =>
-      this.status.read(credentialRecord(accountArg.credential.claudeAiOauth), credentialRecord(accountArg.credential.oauthAccount), optionsArg);
+    const read = (accountArg: IFileAccount) => this.status.read(this.login(accountArg), optionsArg);
     const view = this.nativeView(id);
     if (view.active) return read(view.active);
     const saved = this.savedCredential(id);
+    const login = this.login(saved);
     const oauth = credentialRecord(saved.credential.claudeAiOauth);
     if (!this.tokens.due(oauth)) return read(saved);
     if (view.unavailable !== null) {
-      return this.status.unavailable(oauth, `Login refresh: this saved login's access token has expired and cannot be renewed for this installation. ${view.unavailable}`);
+      return this.status.unavailable(login, `Login refresh: this saved login's access token has expired and cannot be renewed for this installation. ${view.unavailable}`);
     }
-    if (this.store.read(id).rejectedGrant === this.grantKey(oauth)) return this.status.unavailable(oauth, `Login refresh: ${SAVED_LOGIN_REJECTED}`);
+    if (this.store.read(id).rejectedGrant === this.grantKey(oauth)) return this.status.unavailable(login, `Login refresh: ${SAVED_LOGIN_REJECTED}`);
     let refreshed: IFileAccount;
     try { refreshed = await this.refreshSaved(id, optionsArg.signal); }
     catch (error) {
       if (optionsArg.signal?.aborted) throw error;
       const problem = error instanceof ClaudeLoginRejectedError ? SAVED_LOGIN_REJECTED
         : error instanceof Error ? error.message : 'the saved login could not be refreshed.';
-      return this.status.unavailable(oauth, `Login refresh: ${problem}`,
+      return this.status.unavailable(login, `Login refresh: ${problem}`,
         error instanceof ClaudeRateLimitError ? { retryAt: error.retryAt } : undefined);
     }
     return read(refreshed);
@@ -260,7 +285,7 @@ export class ClaudeCodeHarness extends FileHarness {
    * became active meanwhile belongs to Claude Code and is returned as it is, one in an installation that can no
    * longer be read is returned unrefreshed, and one another refresh already renewed is not refreshed twice. The new
    * tokens replace the saved ones only while the record still holds the refresh token that was sent, the
-   * compare-and-swap Claude Code 2.1.273 applies to its own store (`$fn`, @15410824).
+   * compare-and-swap Claude Code 2.1.273 applies to its own store (`$fn`, @191212749).
    */
   private refreshSaved(id: string, signal?: AbortSignal): Promise<IFileAccount> {
     return this.store.locked(async () => {