@modelprofile.com/authswitch 6.0.0 → 6.1.0

package/dist_ts/classes.opencodeharness.js

@@ -4,10 +4,16 @@ import { CredentialStore, credentialHash, credentialRecord, credentialText, read
 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';
@@ -17,12 +23,17 @@ 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;
@@ -33,6 +44,7 @@ export class OpenCodeHarness extends FileHarness {
         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');
@@ -119,28 +131,85 @@ export class OpenCodeHarness extends FileHarness {
         if (readCredentialDocument(this.file).raw !== raw)
             throw new Error('Active login verification failed. The outgoing login remains saved.');
     }
+    /** 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; the token is used exactly as stored. Renewing it is
-     * OpenCode's, because the renewal rotates the refresh token a running OpenCode holds in memory, and authswitch
-     * cannot write that rotation into an instance it does not manage.
+     * 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.
      */
-    anthropicStatus(credentialArg, optionsArg) {
-        const accessToken = credentialText(credentialArg.access);
-        const expires = credentialArg.expires;
-        if (accessToken === undefined || typeof expires !== 'number') {
-            return Promise.resolve(this.claudeStatus.unavailable({}, 'This Anthropic login holds no usable access token; log in again with opencode auth login.'));
-        }
-        if (this.now() + CLAUDE_REFRESH_MARGIN_MS >= expires) {
-            return Promise.resolve(this.claudeStatus.unavailable({}, 'This Anthropic login\'s access token has expired. OpenCode renews it while it runs; authswitch does not, because the renewal rotates the refresh token a running OpenCode keeps in memory. Start OpenCode, or log in again with opencode auth login.'));
+    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 account = this.readCredential(id);
+    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)
@@ -148,7 +217,7 @@ export class OpenCodeHarness extends FileHarness {
             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.credential, optionsArg);
+            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) },
@@ -156,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":"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"}
+//# 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/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": "6.0.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:
 
@@ -217,11 +220,16 @@ ChatGPT OAuth accounts display their email and use the same direct status APIs a
 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. Renewing that token
-stays OpenCode's -- the renewal rotates the refresh token a running OpenCode holds in
-memory, which authswitch cannot write into an instance it does not manage -- so an access
-token inside Claude Code's five-minute margin is reported as expired instead, with the
-two ways to renew it. API keys and opaque provider tokens have no reliable email, so their
+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.
@@ -339,10 +347,12 @@ reason names what to do:
   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,
-plus two of its own: `This Anthropic login's access token has expired.`, which OpenCode
-renews by running or by `opencode auth login`, and `This Anthropic login holds no usable
-access token`, which needs a new `opencode auth login`.
+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
@@ -1038,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

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '6.0.0',
+  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.cli.ts

@@ -108,9 +108,9 @@ ${bold('Options')}
 
 A switch works while OpenCode or Claude Code is running. Claude Code picks the new login
 up on its next request, so its sessions are stopped only on --stop or --force-stop.
-OpenCode keeps the previous login in memory and can write it back at its next token
-refresh, so an OpenCode switch offers to stop it first; without a terminal it leaves
-it running and says so.
+OpenCode caches no login either, but a request already in flight can write the previous
+login's own rotation back, so an OpenCode switch offers to stop it first; without a
+terminal it leaves it running and says so.
 
 Watch covers the harnesses that support automatic switching (${[...this.harnesses.values()].filter(harness => harness.autoSwitch === true).map(harness => harness.id).join(', ') || 'none registered'}).
 --interval takes seconds or a unit (120, 90s, 2m; from 1m to 1d); --threshold takes 50 to 100.

package/ts/classes.credentialstore.ts

@@ -164,8 +164,8 @@ export class CredentialStore {
         && typeof record.switchedAt === 'string' && Number.isFinite(Date.parse(record.switchedAt));
     });
   }
-  public recordSwitch(entry: Omit<ISwitchRecord, 'switchedAt'>): void {
-    this.writeSwitchRecords([...this.switchRecords().filter(item => item.slotId !== entry.slotId), { ...entry, switchedAt: new Date().toISOString() }]);
+  public recordSwitch(entry: Omit<ISwitchRecord, 'switchedAt'> & { switchedAt?: string }): void {
+    this.writeSwitchRecords([...this.switchRecords().filter(item => item.slotId !== entry.slotId), { ...entry, switchedAt: entry.switchedAt ?? new Date().toISOString() }]);
   }
   public clearSwitch(slotId: string): void {
     const remaining = this.switchRecords().filter(item => item.slotId !== slotId);

package/ts/classes.fileharness.ts

@@ -99,9 +99,10 @@ export abstract class FileHarness implements IAuthHarness {
    * Credential slots that no longer hold the account the last switch wrote.
    *
    * The login can change outside authswitch -- a new native login, or, for a harness that does not pick
-   * up swaps live, a running instance writing its previous login back at its next refresh. The recorded
+   * up swaps live, a request already in flight writing the previous login's own rotation back. The recorded
    * hash detects that the file changed at all; comparing the account distinguishes the benign case -- the
-   * switched-in account rotating its own token -- from a different account. Detection is advisory and
+   * switched-in account rotating its own token -- from a different account. A rotation authswitch performed
+   * itself is not drift at all: `recordRenewal` moves the record onto it. Detection is advisory and
    * never turns a read into a failure.
    */
   private credentialDrift(snapshotArg: IFileHarnessSnapshot): IHarnessCredentialDrift[] {
@@ -127,14 +128,18 @@ export abstract class FileHarness implements IAuthHarness {
   private savedLabel(accountIdArg: string): string | null {
     try { return this.store.read(accountIdArg).label; } catch { return null; }
   }
-  /** Instances that keep a replaced or cleared login in memory until they are restarted; none for a live-swap harness. */
+  /** How a running instance still holds the previous login and can write it back; stated per harness. */
+  protected runningRetention(): string {
+    return 'They keep the previous login in memory until they are restarted, and a token refresh by one of them can ';
+  }
+  /** Instances that can still write a replaced or cleared login back; none for a live-swap harness. */
   private runningCaveat(kindArg: 'replaced' | 'cleared'): string[] {
     if (this.liveSwap) return [];
     let count: number;
     try { count = this.processes.list().length; }
     catch { return [`Could not check for running ${this.label} processes. If any are running, restart them: an unrestarted instance can write its previous login back.`]; }
     if (!count) return [];
-    return [`${count} ${this.label} process(es) are still running. They keep the previous login in memory until they are restarted, and a token refresh by one of them can `
+    return [`${count} ${this.label} process(es) are still running. ${this.runningRetention()}`
       + `${kindArg === 'replaced' ? 'overwrite the credential file with the previous account' : 'write the cleared login back into the credential file'}. `
       + `Restart them, then check authswitch ${this.id} active.`];
   }
@@ -154,6 +159,25 @@ export abstract class FileHarness implements IAuthHarness {
       return [];
     } catch { return [`The login was written, but this switch could not be recorded for later credential checks.`]; }
   }
+  /**
+   * Let a slot's switch record follow a credential authswitch itself renewed in place.
+   *
+   * The record must name what authswitch last wrote, or the next read reports authswitch's own rotation as a
+   * login someone else put there -- an account whose identity is its refresh token changes id on every rotation.
+   * A slot no switch armed keeps no record: a renewal never starts watching one. The record is advisory, so an
+   * update that fails costs at most the drift note the next read would have shown anyway; a status read has
+   * nowhere to report it.
+   */
+  protected recordRenewal(slotIdArg: string): void {
+    try {
+      const record = this.store.switchRecords().find(item => item.slotId === slotIdArg);
+      const active = this.snapshot().accounts.find(account => account.slotId === slotIdArg);
+      if (!record || !active) return;
+      // The switch time stays the switch time: a renewal changes what the record names, not when the login was put there.
+      this.store.recordSwitch({ slotId: slotIdArg, accountId: this.store.id(active.slotId, active.identity),
+        credentialHash: credentialHash(JSON.stringify(active.credential)), switchedAt: record.switchedAt });
+    } catch { /* Advisory state only. */ }
+  }
   /** The active login with this account id, read from the native files; undefined when the account is not active. */
   protected activeCredential(id: string): IFileAccount | undefined {
     return this.snapshot().accounts.find(account => this.store.id(account.slotId, account.identity) === id);
@@ -162,10 +186,6 @@ export abstract class FileHarness implements IAuthHarness {
   protected savedCredential(id: string): IFileAccount {
     return this.saved(this.store.read(id));
   }
-  /** The account's current credential: the active login when it is active, which may be newer than its saved copy. */
-  protected readCredential(id: string): IFileAccount {
-    return this.activeCredential(id) ?? this.savedCredential(id);
-  }
   /** Save a newly authenticated credential without changing a native harness's login. */
   public importCredential(slotId: string, credential: Record<string, unknown>): Promise<{ accountId: string }> {
     return this.store.locked(() => ({ accountId: this.store.save(this.inspect(credential, slotId)).id }));

package/ts/classes.opencodeanthropicrefresh.ts

@@ -0,0 +1,64 @@
+import { credentialText } from './classes.credentialstore.js';
+import { claudeRequest, ClaudeLoginRejectedError, ClaudeRequestError, oauthErrorCode } from './claudehttp.js';
+
+/** The token endpoint `opencode-anthropic-auth` 0.0.13 renews an OpenCode `anthropic` login at (`index.mjs`). */
+const TOKEN_URL = 'https://console.anthropic.com/v1/oauth/token';
+/** The OAuth client that plugin sends, Claude Code's public one (`CLIENT_ID`, `index.mjs`). */
+const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+/**
+ * How long one renewal may take. A renewal is never cut shorter than that, nor cancelled once sent: the service may
+ * already have replaced the refresh token the request carries.
+ */
+const REFRESH_TIMEOUT_MS = 30_000;
+
+/** The token fields OpenCode keeps for an OAuth login, as one renewal replaces them. */
+export interface IOpenCodeAnthropicTokens {
+  access: string;
+  refresh: string;
+  /** Milliseconds since the epoch, as OpenCode stores them. */
+  expires: number;
+}
+
+const seconds = (valueArg: unknown): number | undefined =>
+  typeof valueArg === 'number' && Number.isFinite(valueArg) && valueArg >= 0 ? valueArg : undefined;
+
+/**
+ * Renews an OpenCode `anthropic` OAuth login with the request OpenCode's own Anthropic provider sends for it.
+ *
+ * `opencode-anthropic-auth` 0.0.13 -- the plugin that gives OpenCode 1.18.x its `anthropic` OAuth provider; the
+ * binary carries no Anthropic OAuth code of its own -- posts a JSON body of `grant_type`, `refresh_token` and
+ * Claude Code's public client to `console.anthropic.com`, with no scope, and stores `{access, refresh, expires}`
+ * from the answer. This sends exactly that request, so a login renewed here is renewed the way OpenCode renews it.
+ *
+ * It only talks to the token endpoint; which login is renewed, and where the rotated pair is written, belongs to
+ * the harness.
+ */
+export class OpenCodeAnthropicRefresh {
+  constructor(private readonly fetcher: typeof fetch = globalThis.fetch, private readonly now: () => number = Date.now) {}
+
+  /**
+   * New tokens for the login. A response without a refresh token keeps the one that was sent, as the service's own
+   * answer to a grant it did not rotate. Throws `ClaudeRequestError` with a fixed diagnostic; a grant the service
+   * rejects is `ClaudeLoginRejectedError`, and a rate limit is `ClaudeRateLimitError`.
+   */
+  public async refresh(refreshTokenArg: string): Promise<IOpenCodeAnthropicTokens> {
+    const { status, body } = await claudeRequest(this.fetcher, {
+      url: TOKEN_URL, method: 'POST', headers: { 'Content-Type': 'application/json' }, subject: 'Claude sign-in',
+      body: JSON.stringify({ grant_type: 'refresh_token', refresh_token: refreshTokenArg, client_id: CLIENT_ID }),
+      timeoutMs: REFRESH_TIMEOUT_MS, readErrorBody: true, now: this.now,
+    });
+    if ((status === 400 || status === 401) && oauthErrorCode(body) === 'invalid_grant') throw new ClaudeLoginRejectedError();
+    if (status < 200 || status > 299) throw new ClaudeRequestError(`The Claude sign-in service returned HTTP ${status}.`);
+    const receivedAt = this.now();
+    const access = credentialText(body?.access_token);
+    const tokenType = body?.token_type;
+    const expiresIn = seconds(body?.expires_in);
+    const rotated = body?.refresh_token == null ? null : credentialText(body.refresh_token);
+    // Only a response every field of the stored entry can be taken from is written back into a file OpenCode owns.
+    if (!access || (tokenType != null && (typeof tokenType !== 'string' || tokenType.toLowerCase() !== 'bearer'))
+      || expiresIn === undefined || rotated === undefined) {
+      throw new ClaudeRequestError('The Claude sign-in service returned an unsupported token response; the stored login was not changed.');
+    }
+    return { access, refresh: rotated ?? refreshTokenArg, expires: receivedAt + expiresIn * 1000 };
+  }
+}