Stop the test suite from calling live provider endpoints

packages/core/src/accounts.ts

@@ -938,6 +938,25 @@ function mergeConfigAccountAndState(
   return { ...account, ...stateAccount }
 }
 
+function configAccountHasInvalidShape(account: Record<string, unknown>) {
+  if (account.type !== 'api' && account.type !== 'oauth') return true
+  if (
+    account.type === 'api' &&
+    'baseURL' in account &&
+    (typeof account.baseURL !== 'string' || !isValidApiBaseURL(account.baseURL))
+  ) {
+    return true
+  }
+  if (
+    account.type === 'oauth' &&
+    'refresh' in account &&
+    (typeof account.refresh !== 'string' || !account.refresh.trim())
+  ) {
+    return true
+  }
+  return false
+}
+
 function mergeConfigAndState(
   configValue: unknown,
   stateValue: unknown,
@@ -970,10 +989,13 @@ function mergeConfigAndState(
   const accounts = Array.isArray(configValue.accounts)
     ? configValue.accounts.map((account) => {
         if (!isRecord(account)) return account
-        const stateAccount: Record<string, unknown> =
-          typeof account.id === 'string' && isRecord(stateAccounts[account.id])
-            ? (stateAccounts[account.id] as Record<string, unknown>)
-            : {}
+        const rawId = typeof account.id === 'string' ? account.id : undefined
+        const stateValue = rawId
+          ? (stateAccounts[rawId] ?? stateAccounts[rawId.trim()])
+          : undefined
+        const stateAccount: Record<string, unknown> = isRecord(stateValue)
+          ? (stateValue as Record<string, unknown>)
+          : {}
         return mergeConfigAccountAndState(account, stateAccount)
       })
     : []
@@ -1943,31 +1965,78 @@ async function saveAccountStateUnlocked(
 
   if (scope.accounts) {
     const ids = scope.accounts === true ? null : new Set(scope.accounts)
+    const config = (await readJsonIfPresent(path)).value
+    const configuredIds = (() => {
+      if (!isRecord(config) || !Array.isArray(config.accounts)) return null
+      if (config.accounts.length === 0) return new Set<string>()
+      const stateAccounts = isRecord(next.accounts) ? next.accounts : {}
+      const incomingAccounts = Object.fromEntries(
+        storage.accounts.map((account) => [
+          account.id.trim(),
+          accountRuntimeState(account),
+        ]),
+      )
+      // Keep both forms because legacy state may still use either key while
+      // scoped saves must preserve entries not superseded by an incoming account.
+      const memberships = config.accounts.map((account) => {
+        if (!isRecord(account) || typeof account.id !== 'string') return null
+        const id = account.id.trim()
+        if (!id) return null
+        if (configAccountHasInvalidShape(account)) return null
+        const stateValue = stateAccounts[account.id] ?? stateAccounts[id]
+        const stateAccount: Record<string, unknown> = isRecord(stateValue)
+          ? (stateValue as Record<string, unknown>)
+          : {}
+        const incomingAccount = incomingAccounts[id] as
+          | Record<string, unknown>
+          | undefined
+        return normalizeAccount(
+          mergeConfigAccountAndState(account, incomingAccount ?? stateAccount),
+        )
+          ? [account.id, id]
+          : null
+      })
+      // A populated config with any unparseable entry cannot establish safe membership.
+      return memberships.every((membership) => membership !== null)
+        ? new Set(memberships.flatMap((membership) => membership ?? []))
+        : null
+    })()
     next.accounts = { ...(isRecord(next.accounts) ? next.accounts : {}) }
     for (const account of storage.accounts) {
-      if (ids && !ids.has(account.id)) continue
-      next.accounts[account.id] = mergeAccountRuntimeState(
-        next.accounts[account.id],
+      const accountId = account.id.trim()
+      if (ids && !ids.has(account.id) && !ids.has(accountId)) continue
+      if (
+        configuredIds &&
+        !configuredIds.has(account.id) &&
+        !configuredIds.has(accountId)
+      )
+        continue
+      const legacyKeys = Object.keys(next.accounts).filter(
+        (key) => key !== accountId && key.trim() === accountId,
+      )
+      const legacyKey = legacyKeys[0]
+      const existingAccount =
+        next.accounts[accountId] ??
+        (legacyKey ? next.accounts[legacyKey] : undefined)
+      for (const key of legacyKeys) delete next.accounts[key]
+      next.accounts[accountId] = mergeAccountRuntimeState(
+        existingAccount,
         accountRuntimeState(account),
       )
     }
+    if (configuredIds) {
+      // Config membership is authoritative for scoped writes too; otherwise a
+      // stale writer can preserve state for an account removed out of band.
+      for (const id of Object.keys(next.accounts)) {
+        if (!configuredIds.has(id)) delete next.accounts[id]
+      }
+    }
     if (ids) {
       for (const id of ids) {
         if (!storage.accounts.some((account) => account.id === id)) {
           delete next.accounts[id]
         }
       }
-    } else {
-      // Full save: drop any per-account state whose id is no longer present in
-      // storage.accounts. The scoped path above only prunes ids it was asked to
-      // save; on a removal the storage is saved with scope.accounts === true
-      // (ids === null), so without this branch the removed account's runtime
-      // state (quota/lastRefreshError/access/refresh/expires) would be orphaned
-      // in the state file and later merged onto a re-added same-id account.
-      const present = new Set(storage.accounts.map((account) => account.id))
-      for (const id of Object.keys(next.accounts)) {
-        if (!present.has(id)) delete next.accounts[id]
-      }
     }
   }
 
@@ -3598,13 +3667,14 @@ export class FallbackAccountManager {
       await this.refreshDueAccounts()
       await this.refreshQuotaForDueAccounts()
     }
-    void run().catch(() => {})
+    const initialRun = run().catch(() => {})
     if (!this.refreshTimer) {
       this.refreshTimer = this.setIntervalImpl(() => {
         void run().catch(() => {})
       }, BACKGROUND_TICK_MS + jitterMs(BACKGROUND_TICK_JITTER_MS))
       if ('unref' in this.refreshTimer) this.refreshTimer.unref()
     }
+    return initialRun
   }
 
   stopBackgroundRefresh() {

packages/core/src/quota-header-feed.ts

@@ -53,6 +53,7 @@ type QuotaHeaderFeedMetadata = {
   schema_version: typeof QUOTA_HEADER_FEED_SCHEMA_VERSION
   provider: 'anthropic'
   configured_account_count: number
+  /** Header observation time; merged poll-owned fields retain their own checkedAt. */
   observed_at_ms: number
 }
 

packages/opencode/src/index.ts

@@ -1286,9 +1286,7 @@ const anthropicAuthPlugin = async (
         ? {
             ...entry,
             quota: mergedQuota,
-            checkedAt: persistedQuotaBelongsToRequest
-              ? (reloaded.quota?.mainQuotaCheckedAt ?? entry.checkedAt)
-              : entry.checkedAt,
+            checkedAt: entry.checkedAt,
           }
         : entry
     }
@@ -1527,7 +1525,7 @@ const anthropicAuthPlugin = async (
       void refreshSidebarQuota().catch(() => {})
     },
   })
-  fallbackManager.startBackgroundRefresh()
+  const fallbackRefreshReady = fallbackManager.startBackgroundRefresh()
   const cacheDiagnosticsTracker = new CacheDiagnosticsTracker()
   const cacheDiagnosticsBetaTracker = new CacheDiagnosticsBetaTracker()
   type CacheDiagnosticsResponse = {
@@ -6741,6 +6739,7 @@ const anthropicAuthPlugin = async (
     },
     __primeManager: primeManager,
     __quotaManager: quotaManager,
+    __fallbackRefreshReady: fallbackRefreshReady,
     // biome-ignore lint/suspicious/noExplicitAny: Plugin type doesn't include undocumented auth/hooks
   } as any
 }

packages/opencode/src/tests/account-command.test.ts

@@ -1,4 +1,12 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from 'bun:test'
 import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -16,9 +24,23 @@ import {
   setAccountEnabledPersistent,
 } from '@cortexkit/anthropic-auth-core'
 import { AnthropicAuthPlugin } from '../index'
+import { DEFAULT_FETCH_MOCK, installDefaultFetchMock } from './test-fetch'
+import {
+  createTimerTracking,
+  type PluginTimerOverrides,
+} from './timer-tracking'
 
 let tempDir: string
 let accountPath: string
+const tempDirs = new Set<string>()
+const originalFetch = globalThis.fetch
+const timerTracking = createTimerTracking()
+const {
+  activeIntervals,
+  disabledPluginTimerOverrides,
+  trackedClearInterval,
+  trackedSetInterval,
+} = timerTracking
 
 const baseStorage = (): AccountStorage => ({
   version: 1,
@@ -68,15 +90,48 @@ const baseStorage = (): AccountStorage => ({
 })
 
 beforeEach(async () => {
+  installDefaultFetchMock()
+  timerTracking.reset()
+  if (tempDir) {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {})
+  }
   tempDir = await mkdtemp(join(tmpdir(), 'anthropic-auth-acct-cmd-'))
+  tempDirs.add(tempDir)
   accountPath = join(tempDir, 'anthropic-auth.json')
   process.env.OPENCODE_ANTHROPIC_AUTH_FILE = accountPath
 })
 
 afterEach(async () => {
-  delete process.env.OPENCODE_ANTHROPIC_AUTH_FILE
-  await rm(tempDir, { recursive: true, force: true })
-  mock.restore()
+  try {
+    // Restore only the fixture's tagged mock; an untagged custom mock left
+    // installed must reach the preload's leak detector, not be masked here.
+    const currentFetch = globalThis.fetch as
+      | (typeof fetch & { [DEFAULT_FETCH_MOCK]?: true })
+      | undefined
+    if (currentFetch?.[DEFAULT_FETCH_MOCK]) {
+      globalThis.fetch = originalFetch
+    }
+    delete process.env.OPENCODE_ANTHROPIC_AUTH_FILE
+    await Promise.all(
+      [...tempDirs].map((directory) =>
+        rm(directory, { recursive: true, force: true }).catch(() => {}),
+      ),
+    )
+    tempDirs.clear()
+    mock.restore()
+  } finally {
+    // Assert last so a detected leak cannot abort the cleanup above.
+    expect(activeIntervals.size).toBe(0)
+  }
+})
+
+afterAll(async () => {
+  await Promise.all(
+    [...tempDirs, tempDir].map((directory) =>
+      rm(directory, { recursive: true, force: true }).catch(() => {}),
+    ),
+  )
+  tempDirs.clear()
 })
 
 // ---------------------------------------------------------------------------
@@ -513,11 +568,22 @@ describe('account command INFO logs (via plugin)', () => {
     }
   }
 
-  async function getPlugin() {
-    return (await AnthropicAuthPlugin({
-      // @ts-expect-error: minimal mock for testing
-      client: createMockClient(),
-    })) as Promise<any>
+  async function getPlugin(timerOverrides?: PluginTimerOverrides) {
+    const defaultTimerOverrides = disabledPluginTimerOverrides()
+    const plugin = (await (
+      AnthropicAuthPlugin as unknown as (
+        ctx: Parameters<typeof AnthropicAuthPlugin>[0],
+        timers?: PluginTimerOverrides,
+      ) => ReturnType<typeof AnthropicAuthPlugin>
+    )(
+      {
+        // @ts-expect-error: minimal mock for testing
+        client: createMockClient(),
+      },
+      { ...defaultTimerOverrides, ...timerOverrides },
+    )) as any
+    await plugin.__fallbackRefreshReady
+    return plugin
   }
 
   async function executeCommand(
@@ -636,4 +702,20 @@ describe('account command INFO logs (via plugin)', () => {
       capturedRecords.filter((r) => r.channel === 'commands'),
     ).toHaveLength(0)
   })
+
+  test('does not retain a background interval unless the helper opts in', async () => {
+    await saveAccounts(baseStorage(), accountPath)
+    await getPlugin()
+    expect(timerTracking.disabledIntervalCalls).toBe(1)
+    expect(activeIntervals.size).toBe(0)
+
+    await timerTracking.withTrackedInterval(async () => {
+      await getPlugin({
+        setInterval: trackedSetInterval,
+        clearInterval: trackedClearInterval,
+      })
+      expect(activeIntervals.size).toBe(1)
+    })
+    expect(activeIntervals.size).toBe(0)
+  })
 })