@bitkyc08/opencodex 2.81.0 → 2.82.0

package/src/lib/translator-budget.ts

@@ -191,6 +191,7 @@ class Budget implements TranslatorBudget {
   }
 
   openCall(id: string): void {
+    if (this.disposed) return;
     if (!this.calls.has(id)) {
       this.calls.set(id, { logicalBytes: 0, physicalBytes: 0 });
       aggregateActiveCalls += 1;
@@ -210,6 +211,7 @@ class Budget implements TranslatorBudget {
     bytes: number,
     scope: { kind: TranslatorBufferKind; callId?: string },
   ): TranslatorTransientReservation {
+    if (this.disposed) return { commitRetained() {}, release() {} };
     const admitted = normalizeBytes(bytes);
     if (scope.callId && admitted > this.maxCallArgumentBytes) {
       this.reject("tool_args", this.maxCallArgumentBytes);
@@ -222,6 +224,7 @@ class Budget implements TranslatorBudget {
     return {
       commitRetained: () => {
         if (state !== "reserved") return;
+        if (this.disposed) { state = "released"; return; }
         state = "committed";
         if (!scope.callId) return;
         const call = this.calls.get(scope.callId) ?? { logicalBytes: 0, physicalBytes: 0 };
@@ -234,6 +237,7 @@ class Budget implements TranslatorBudget {
       release: () => {
         if (state !== "reserved") return;
         state = "released";
+        if (this.disposed) return;
         this.charged.set(scope.kind, Math.max(0, (this.charged.get(scope.kind) ?? 0) - admitted));
         this.hardChargedBytes = Math.max(0, this.hardChargedBytes - admitted);
         this.changed();
@@ -242,6 +246,7 @@ class Budget implements TranslatorBudget {
   }
 
   chargeRetained(delta: number, scope: { kind: TranslatorBufferKind; callId?: string }): void {
+    if (this.disposed) return;
     const admitted = normalizeBytes(delta);
     if (scope.callId) {
       const call = this.calls.get(scope.callId) ?? { logicalBytes: 0, physicalBytes: 0 };
@@ -279,6 +284,7 @@ class Budget implements TranslatorBudget {
   }
 
   private observe(bytes: number): () => void {
+    if (this.disposed) return () => {};
     const observed = normalizeBytes(bytes);
     this.observedBytes += observed;
     this.changed();
@@ -369,7 +375,7 @@ export function resetTranslatorAggregateForTests(): void {
   aggregateOverflows = 0;
 }
 
-export function finalizeTranslatorBudgetResponse(response: Response, budget: TranslatorBudget): Response {
+export function finalizeTranslatorBudgetResponse(response: Response, budget: TranslatorBudget, signal?: AbortSignal): Response {
   if (!response.body) {
     budget.dispose();
     return response;
@@ -379,9 +385,12 @@ export function finalizeTranslatorBudgetResponse(response: Response, budget: Tra
   const finalize = () => {
     if (finalized) return;
     finalized = true;
+    signal?.removeEventListener("abort", finalize);
     budget.dispose();
   };
-  return new Response(new ReadableStream<Uint8Array>({
+  // The transport owns cancellation and terminal precedence. Abort releases only
+  // accounting here, including when no consumer ever pulls or cancels this body.
+  const body = new ReadableStream<Uint8Array>({
     async pull(controller) {
       try {
         const result = await reader.read();
@@ -395,7 +404,11 @@ export function finalizeTranslatorBudgetResponse(response: Response, budget: Tra
       }
     },
     async cancel(reason) {
-      try { await reader.cancel(reason); } finally { finalize(); }
+      finalize();
+      await reader.cancel(reason);
     },
-  }), { status: response.status, statusText: response.statusText, headers: response.headers });
+  });
+  if (signal?.aborted) finalize();
+  else signal?.addEventListener("abort", finalize, { once: true });
+  return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
 }

package/src/lib/windows-atomic-replace.ts

@@ -37,6 +37,9 @@ export type ReplacePublisher =
   | "storage-cleanup"
   | "tray";
 
+/** Called immediately before every rename attempt, including each Windows retry. */
+export interface RenameValidationHooks { validateBeforeRename?: (destination: string) => void }
+
 /** The Windows error codes this module treats as a momentary hold. */
 export type ReplaceRetryCode = "EBUSY" | "EPERM" | "EACCES";
 
@@ -97,7 +100,7 @@ const MAX_RETRIES = 2;
  * Windows sharing violations only, returning the code so the caller can record
  * which one. Any other error is the caller's to see, immediately.
  */
-function transientWindowsReplaceCode(
+export function transientWindowsReplaceCode(
   platform: NodeJS.Platform,
   error: unknown,
 ): ReplaceRetryCode | null {
@@ -106,6 +109,32 @@ function transientWindowsReplaceCode(
   return code === "EBUSY" || code === "EPERM" || code === "EACCES" ? code : null;
 }
 
+/** One filesystem operation plus its retry observers, carried as members (not free callbacks). */
+export interface WindowsFileOperationStep<T> {
+  run: () => T;
+  onRetry?: (code: ReplaceRetryCode, exhausted: boolean) => void;
+  beforeAttempt?: () => void;
+}
+
+/** Bounded sharing-violation retries for one filesystem operation, never a transaction. */
+export function retryWindowsFileOperation<T>(
+  step: WindowsFileOperationStep<T>,
+  io: Pick<AtomicRenameIO, "platform" | "sleep"> = { platform: process.platform, sleep: Bun.sleepSync },
+): T {
+  for (let attempt = 0; ; attempt += 1) {
+    step.beforeAttempt?.();
+    try { return step.run(); }
+    catch (error) {
+      const code = transientWindowsReplaceCode(io.platform, error);
+      if (!code) throw error;
+      const exhausted = attempt >= MAX_RETRIES;
+      step.onRetry?.(code, exhausted);
+      if (exhausted) throw error;
+      io.sleep(25 * (attempt + 1));
+    }
+  }
+}
+
 export function renameAtomicFile(
   source: string,
   destination: string,
@@ -115,30 +144,23 @@ export function renameAtomicFile(
     sleep: Bun.sleepSync,
   },
   publisher: ReplacePublisher = "config",
+  hooks: RenameValidationHooks = {},
 ): void {
-  for (let attempt = 0; ; attempt += 1) {
-    try {
-      io.rename(source, destination);
-      return;
-    } catch (error) {
-      const code = transientWindowsReplaceCode(io.platform, error);
-      if (!code) throw error;
-      if (attempt >= MAX_RETRIES) {
-        bump(publisher, code, "exhausted");
-        throw error;
-      }
-      bump(publisher, code, "retried");
-      io.sleep(25 * (attempt + 1));
-    }
-  }
+  retryWindowsFileOperation({
+    run: () => io.rename(source, destination),
+    onRetry: (code, exhausted) => bump(publisher, code, exhausted ? "exhausted" : "retried"),
+    beforeAttempt: () => hooks.validateBeforeRename?.(destination),
+  }, io);
 }
 
 export async function renameAtomicFileAsync(
   source: string,
   destination: string,
   publisher: ReplacePublisher = "config",
+  hooks: RenameValidationHooks = {},
 ): Promise<void> {
   for (let attempt = 0; ; attempt += 1) {
+    hooks.validateBeforeRename?.(destination);
     try {
       renameSync(source, destination);
       return;

package/src/lib/windows-elevation.ts

@@ -203,6 +203,12 @@ export function resolveTrustedWindowsPowerShellExe(): string {
   return assertTrustedSystemExecutable(candidate, "PowerShell");
 }
 
+/** Absolute System32\\reg.exe path; PATH, SystemRoot and WINDIR cannot select it. */
+export function resolveTrustedWindowsRegExe(): string {
+  const candidate = join(resolveTrustedWindowsSystemDirectory(), "reg.exe");
+  return assertTrustedSystemExecutable(candidate, "reg.exe");
+}
+
 /** Absolute path to System32\\schtasks.exe from a trusted system directory. */
 export function resolveTrustedWindowsSchtasksExe(): string {
   if (elevationExeOverridesForTests?.schtasks) {

package/src/lib/windows-secret-acl.ts

@@ -36,8 +36,8 @@
  *     own caches so one shape never satisfies the other's lookup.
  */
 
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { env, platform } from "node:process";
 import {
   SUBPROCESS_KILL_GRACE_MS,
@@ -82,7 +82,10 @@ const timedOutPaths = new Map<string, { consumed: boolean; consumedAt: number }>
 export const TIMEOUT_MEMO_REARM_MS = 5 * 60_000;
 /** Compatibility slack before the outer belt releases a caller whose killed child has not reaped. */
 const ASYNC_ICACLS_BELT_MARGIN_MS = 250;
-const pendingAsyncIcaclsReaps = new Map<string, Set<Promise<void>>>();
+interface RemovalIdentity { readonly lexical: string; readonly canonical: string | undefined }
+interface AsyncAclWork { readonly identity: RemovalIdentity; readonly reap: Promise<void> }
+const pendingAsyncIcaclsReaps = new Map<string, Set<AsyncAclWork>>();
+const activeAsyncAclWork = new Map<string, Set<AsyncAclWork>>();
 
 const scheduleAsyncIcaclsBelt: SubprocessDeadlineScheduler = (callback, milliseconds) => {
   const timer = setTimeout(callback, milliseconds);
@@ -414,10 +417,13 @@ function awaitAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<Icac
       cancelBelt?.();
       resolve(result);
     };
-    const runner = asyncIcaclsRunner(args, timeoutMs).then(
+    const run = () => asyncIcaclsRunner(args, timeoutMs).then(
       result => { finish(result); },
       () => { finish(spawnFailedResult()); },
     );
+    // Capture and register ownership before the child can start or mutate its alias.
+    const tracked = args[0] ? startTrackedAsyncAclWork(args[0], run) : undefined;
+    if (!tracked) run();
     // The belt has to outlast the runner it is guarding, or it is not a belt -- it is the
     // deadline. The runner may now legitimately outlive it while a killed child is reaped. The
     // caller is still released, but the target is registered so removal can wait for the distinct
@@ -425,7 +431,7 @@ function awaitAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<Icac
     cancelBelt = asyncIcaclsBeltScheduler(
       () => {
         const targetPath = args[0];
-        if (targetPath) registerPendingAsyncIcaclsReap(targetPath, runner);
+        if (targetPath && tracked) registerPendingAsyncIcaclsReap(targetPath, tracked.entry);
         finish({ success: false, exitCode: null, timedOut: true, stdout: "" });
       },
       Math.max(1, timeoutMs) + SUBPROCESS_KILL_GRACE_MS + ASYNC_ICACLS_BELT_MARGIN_MS,
@@ -433,22 +439,69 @@ function awaitAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<Icac
   });
 }
 
-function registerPendingAsyncIcaclsReap(targetPath: string, reap: Promise<void>): void {
-  let pending = pendingAsyncIcaclsReaps.get(targetPath);
+function registerPendingAsyncIcaclsReap(
+  targetPath: string,
+  entry: AsyncAclWork,
+  registry = pendingAsyncIcaclsReaps,
+): void {
+  let pending = registry.get(targetPath);
   if (!pending) {
     pending = new Set();
-    pendingAsyncIcaclsReaps.set(targetPath, pending);
+    registry.set(targetPath, pending);
   }
-  pending.add(reap);
-  void reap.finally(() => {
-    pending!.delete(reap);
-    if (pending!.size === 0) pendingAsyncIcaclsReaps.delete(targetPath);
+  pending.add(entry);
+  void entry.reap.then(() => {
+    pending!.delete(entry);
+    if (pending!.size === 0) registry.delete(targetPath);
   });
 }
 
-function pathIsAtOrBelow(targetPath: string, rootPath: string): boolean {
-  const relativePath = relative(resolve(rootPath), resolve(targetPath));
-  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+/** Register the captured identity before invoking a work/child factory. */
+function startTrackedAsyncAclWork<T>(targetPath: string, start: () => Promise<T>): { work: Promise<T>; entry: AsyncAclWork } {
+  const identity = captureRemovalIdentity(targetPath);
+  let release!: () => void;
+  const entry: AsyncAclWork = { identity, reap: new Promise<void>(done => { release = done; }) };
+  registerPendingAsyncIcaclsReap(targetPath, entry, activeAsyncAclWork);
+  try {
+    const work = start();
+    void work.then(release, release);
+    return { work, entry };
+  } catch (error) { release(); throw error; }
+}
+
+function canonicalRemovalPath(path: string): string | undefined {
+  const missing: string[] = [];
+  let current = resolve(path);
+  while (true) {
+    try { return resolve(realpathSync.native(current), ...missing); }
+    catch (error) {
+      if (!["ENOENT", "ENOTDIR"].includes((error as NodeJS.ErrnoException).code ?? "")) return undefined;
+      const parent = dirname(current);
+      if (parent === current) return undefined;
+      missing.unshift(basename(current));
+      current = parent;
+    }
+  }
+}
+
+function captureRemovalIdentity(path: string): RemovalIdentity {
+  return { lexical: resolve(path), canonical: canonicalRemovalPath(path) };
+}
+
+function pathIsAtOrBelow(target: string, root: string): boolean {
+  const suffix = relative(root, target);
+  return suffix !== ".." && !suffix.startsWith(`..${sep}`) && !isAbsolute(suffix);
+}
+
+function retainedWorkIsAtOrBelow(entry: AsyncAclWork, root: RemovalIdentity): boolean {
+  const target = entry.identity;
+  // Failure at capture stays conservative, even if the alias later becomes readable.
+  if (target.canonical === undefined || root.canonical === undefined) return true;
+  const current = canonicalRemovalPath(target.lexical);
+  if (current === undefined) return true;
+  const targets = [target.lexical, target.canonical, current];
+  return [root.lexical, root.canonical].some(rootPath =>
+    targets.some(targetPath => pathIsAtOrBelow(targetPath, rootPath)));
 }
 
 /** True while an async icacls runner still owns this exact path after its caller's belt fired. */
@@ -458,22 +511,25 @@ export function windowsSecretAclReapPendingForPath(targetPath: string): boolean
 
 /** Non-blocking removal guard for callers that must refuse rather than wait for a stuck child. */
 export function windowsSecretAclReapPendingAtOrBelow(rootPath: string): boolean {
-  return [...pendingAsyncIcaclsReaps.keys()]
-    .some(targetPath => pathIsAtOrBelow(targetPath, rootPath));
+  const root = captureRemovalIdentity(rootPath);
+  return [...activeAsyncAclWork.values(), ...pendingAsyncIcaclsReaps.values()]
+    .some(entries => [...entries].some(entry => retainedWorkIsAtOrBelow(entry, root)));
 }
 
 /**
- * Removal barrier for a file or tree that may still be held by a timed-out icacls child.
+ * Removal barrier for a file or tree held by a normal or timed-out async icacls child.
  *
  * This wait is deliberately separate from ordinary startup and shutdown: a genuinely stuck child
  * must not defeat the caller-facing belt. Code that chooses to remove the target has the stricter
  * contract and must not proceed until every registered runner at or below it has actually reaped.
  */
 export async function flushWindowsSecretAclReapsBeforeRemoval(rootPath: string): Promise<void> {
+  const root = captureRemovalIdentity(rootPath);
   while (true) {
-    const pending = [...pendingAsyncIcaclsReaps]
-      .filter(([targetPath]) => pathIsAtOrBelow(targetPath, rootPath))
-      .flatMap(([, reaps]) => [...reaps]);
+    const pending = [...activeAsyncAclWork.values(), ...pendingAsyncIcaclsReaps.values()]
+      .flatMap(entries => [...entries])
+      .filter(entry => retainedWorkIsAtOrBelow(entry, root))
+      .map(entry => entry.reap);
     if (pending.length === 0) return;
     await Promise.all(pending);
   }
@@ -1058,17 +1114,28 @@ function hardenEntry(
   return { ok: false, diagnostics };
 }
 
+/** Retain removal ownership across principal lookup, every ACL command and diagnostics. */
+function hardenEntryAsync(
+  targetPath: string,
+  directory: boolean,
+  opts: HardenOptions,
+  cache: Map<string, HardenedIdentity>,
+  extraReadAces: readonly string[],
+): Promise<HardenResult> {
+  if (!existsSync(targetPath)) { cache.delete(targetPath); return Promise.resolve({ ok: true }); }
+  if (effectivePlatform() !== "win32" || memoSatisfied(cache, targetPath)) return Promise.resolve({ ok: true });
+  return startTrackedAsyncAclWork(targetPath,
+    () => runHardenEntryAsync(targetPath, directory, opts, cache, extraReadAces)).work;
+}
+
 /** Async counterpart of hardenEntry — yields while waiting on icacls (#612). */
-async function hardenEntryAsync(
+async function runHardenEntryAsync(
   targetPath: string,
   directory: boolean,
   opts: HardenOptions,
   cache: Map<string, HardenedIdentity>,
   extraReadAces: readonly string[],
 ): Promise<HardenResult> {
-  if (!existsSync(targetPath)) { cache.delete(targetPath); return { ok: true }; }
-  if (effectivePlatform() !== "win32") return { ok: true };
-  if (memoSatisfied(cache, targetPath)) return { ok: true };
   const deadline = nowFn() + resolveHardenDeadlineMs(opts.deadlineMs);
   if (extraReadAces.length === 0 && await existingAclAlreadyCompliantAsync(targetPath, directory, deadline)) return { ok: true };
   const memoKey = timeoutMemoKey(targetPath, opts);

package/src/lib/winsw.ts

@@ -20,7 +20,7 @@ import { homedir } from "node:os";
 import { join, resolve, win32 } from "node:path";
 import { expandUserPath, getConfigDir, loadConfig } from "../config";
 import { recordOwnedConfigPath } from "./config-ownership";
-import { BUN_RUNTIME_PATH_ENV, BUN_RUNTIME_SOURCE_ENV, durableBunRuntime } from "./bun-runtime";
+import { BUN_RUNTIME_PATH_ENV, BUN_RUNTIME_SOURCE_ENV, durableBunRuntime, type DurableBunRuntime } from "./bun-runtime";
 import type { BunRuntimeSource } from "./bun-runtime";
 import { serviceApiTokenFilePath } from "./service-secrets";
 import { filterTransientServicePath } from "./transient-service-path";
@@ -408,7 +408,6 @@ export function winswStatusSummary(): string {
 }
 
 /** Default entry mirrors the Task Scheduler baking: durable Bun + cli.ts. */
-export function defaultWinswEntry(cliDir: string): WinswEntry {
-  const runtime = durableBunRuntime();
+export function defaultWinswEntry(cliDir: string, runtime: DurableBunRuntime = durableBunRuntime()): WinswEntry {
   return { bun: runtime.path, bunRuntimeSource: runtime.source, cli: join(cliDir, "cli", "index.ts") };
 }

package/src/oauth/anthropic-account-refusal.ts

@@ -3,7 +3,7 @@ import { anthropicModelFamily } from "./anthropic-model-quota";
 import { readBoundedResponseBody } from "../lib/bounded-body";
 import { classifyAnthropic429, anthropicRetryAfterMs, anthropicRatePolicyFor, ANTHROPIC_SHORT_RETRY_MS, ANTHROPIC_MAX_INLINE_THROTTLE_MS } from "./anthropic-rate-limit-policy";
 import { isNonReplayableResponse, sleepWithAbort } from "../lib/upstream-retry";
-import { credentialGeneration, getAccountCredentialWithStatus } from "./store";
+import { credentialGeneration, getAccountCredentialWithStatus, markAccountNeedsReauthIfGeneration } from "./store";
 import type { OAuthAccessSnapshot } from "./index";
 import type { OcxConfig } from "../types";
 import type { AnthropicRouteDecision } from "./anthropic-model-routes";
@@ -31,6 +31,22 @@ export function bindAnthropicRefusalCredentialForSend(response: Response, owner:
   responseCredentials.set(response, Object.freeze({ ...owner, providerAccountUuid, checkProviderUuid: arguments.length >= 3 }));
 }
 
+async function isRevokedOAuthToken(response: Response, signal?: AbortSignal): Promise<boolean> {
+  if (response.status !== 401) return false;
+  try {
+    const body = await readBoundedResponseBody(response.clone(), { signal, fatalUtf8: true });
+    if (!body.displaySafe || body.truncated) return false;
+    const payload: unknown = JSON.parse(body.text);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)
+      || !("type" in payload) || payload.type !== "error" || !("error" in payload)) return false;
+    const error = payload.error;
+    return !!error && typeof error === "object" && !Array.isArray(error)
+      && "type" in error && error.type === "authentication_error"
+      && "message" in error && error.message === "OAuth access token has been revoked."
+      && (!("code" in error) || error.code == null);
+  } catch { return false; }
+}
+
 async function isAccountRefusal(response: Response, signal?: AbortSignal): Promise<boolean> {
   try {
     const body = await readBoundedResponseBody(response.clone(), { signal });
@@ -91,6 +107,28 @@ export async function rotateAnthropicAccountOnResponseForInstance(
       && credentialGeneration(row.credential) === sent.generation
       && (!sent.checkProviderUuid || row.credential.accountId === sent.providerAccountUuid) ? row : undefined;
   };
+  if (response.status === 401) {
+    if (options.allowAccountRefusal === false) return null;
+    let verdict = verdicts.get(response);
+    if (!verdict) { verdict = isRevokedOAuthToken(response, options.signal); verdicts.set(response, verdict); }
+    if (!await verdict || options.signal?.aborted || !ownedCurrent()) return null;
+    options.currentDecision?.();
+    let marked: boolean;
+    try {
+      marked = await markAccountNeedsReauthIfGeneration(instance, sent.accountId, sent.generation, undefined, undefined, store => {
+        const row = store[instance]?.accounts.find(account => account.id === sent.accountId);
+        return !options.signal?.aborted && configuredAnthropicInstance(options.config, instance) === instance
+          && anthropicPhysicalSendOwnershipIsCurrent(sent, store)
+          && (!sent.checkProviderUuid || row?.credential.accountId === sent.providerAccountUuid);
+      });
+    } catch { return null; }
+    if (!marked || configuredAnthropicInstance(options.config, instance) !== instance
+      || !anthropicPhysicalSendOwnershipIsCurrent(sent)) return null;
+    routing.clearAnthropicSessionAffinityForAccount(sent.accountId);
+    if (!options.canRetry || options.signal?.aborted) return null;
+    const decision = options.currentDecision ? options.currentDecision() : options.decision ?? null;
+    return pickAlternateAnthropicAccount(options.config, sent.accountId, Date.now(), decision, options.model, options.excludedAccountIds);
+  }
   if (response.status === 429) {
     const current = ownedCurrent();
     if (!current) return null;

package/src/oauth/anthropic-routing.ts

@@ -704,7 +704,7 @@ function createAnthropicRouting(instance: AnthropicInstanceId): AnthropicRouting
     excludedAccountIds?: ReadonlySet<string>,
   ): string | null {
     if (!admitted(config)) return null;
-    const strategy = anthropicPoolStrategy(config);
+    const strategy = isAnthropicAccountPoolEnabled(config) ? anthropicPoolStrategy(config) : "quota";
     const eligible = routeCandidates(getEligibleAnthropicAccounts(now, model), decision).filter(id => id !== excludeId && !excludedAccountIds?.has(id));
     if (strategy === "round-robin") {
       return peekRoundRobinAccount(poolKey, eligible, stickyLimitForPool(config));

package/src/oauth/anthropic-send-ownership.ts

@@ -1,6 +1,6 @@
 /** Ownership captured before a physical send, independent of subsequent cooldown observations. */
 import type { OAuthAccessSnapshot } from "./index";
-import { credentialGeneration, getAccountSet } from "./store";
+import { credentialGeneration, getAccountSet, type AuthStore } from "./store";
 import { isAnthropicInstanceId, type AnthropicInstanceId } from "../providers/anthropic-instance-id";
 import { anthropicCooldownRecoveryFor } from "../providers/quota/anthropic-cooldown-recovery";
 import { captureProviderAccountQuotaEpoch } from "../providers/quota/account-cache";
@@ -32,8 +32,8 @@ export function captureAnthropicPhysicalSendOwnership(snapshot: OAuthAccessSnaps
 }
 
 /** Pure ownership read: never adopt or reserve the replacement account's current incarnation. */
-export function anthropicPhysicalSendOwnershipIsCurrent(owner: AnthropicPhysicalSendOwnership): boolean {
-  const row = getAccountSet(owner.provider)?.accounts.find(account => account.id === owner.accountId);
+export function anthropicPhysicalSendOwnershipIsCurrent(owner: AnthropicPhysicalSendOwnership, store?: AuthStore): boolean {
+  const row = (store ? store[owner.provider] : getAccountSet(owner.provider))?.accounts.find(account => account.id === owner.accountId);
   return !!row && row.loginId === owner.loginId && row.addedAt === owner.addedAt
     && row.credential.access === owner.accessToken && credentialGeneration(row.credential) === owner.generation
     && anthropicCooldownRecoveryFor(owner.provider).anthropicAccountIncarnation(owner.accountId) === owner.accountIncarnation

package/src/oauth/chatgpt.ts

@@ -1,6 +1,106 @@
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 import { generatePKCE } from "./pkce";
+import { classifyChatgptRefreshFailure } from "../codex/chatgpt-refresh-failure";
+import { readBoundedResponseBytes } from "../lib/bounded-body";
+
+/**
+ * Per-fetch deadline for ChatGPT auth endpoint calls. The deviceauth grant got the
+ * same bound in #3898 after one stuck TCP connection held the login slot for the
+ * whole grant; a hung refresh would pin the refresh intent lock indefinitely.
+ */
+export const CHATGPT_FETCH_TIMEOUT_MS = 30_000;
+
+/** Non-HTTP failures retain no caller reason, upstream error, or cause. */
+export class ChatGptTokenRequestError extends Error {
+  readonly terminal = false;
+
+  constructor(kind: "abort" | "timeout" | "transport") {
+    super(kind === "abort" ? "ChatGPT token request cancelled"
+      : kind === "timeout" ? "ChatGPT token request timed out" : "ChatGPT token request failed");
+    this.name = kind === "abort" ? "AbortError" : kind === "timeout" ? "TimeoutError" : "ChatGptTokenRequestError";
+  }
+}
+
+const CHATGPT_ERROR_BODY_MAX_BYTES = 16 * 1024;
+const CHATGPT_SUCCESS_BODY_MAX_BYTES = 64 * 1024;
+
+/** One deadline covers headers and body; every settled call detaches its caller. */
+async function chatGptTokenRequest(
+  body: URLSearchParams,
+  label: "ChatGPT refresh" | "ChatGPT token exchange",
+  options: { signal?: AbortSignal; timeoutMs?: number },
+): Promise<OAuthCredentials> {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(new ChatGptTokenRequestError("abort"));
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  if (options.signal?.aborted) onAbort();
+  const timer = setTimeout(() => controller.abort(new ChatGptTokenRequestError("timeout")),
+    options.timeoutMs ?? CHATGPT_FETCH_TIMEOUT_MS);
+  let endpointError: ChatGptTokenError | undefined;
+  try {
+    controller.signal.throwIfAborted();
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString(),
+      signal: controller.signal,
+    });
+    const result = await readBoundedResponseBytes(response, {
+      signal: controller.signal,
+      maxBytes: response.ok ? CHATGPT_SUCCESS_BODY_MAX_BYTES : CHATGPT_ERROR_BODY_MAX_BYTES,
+    });
+    controller.signal.throwIfAborted();
+    const text = new TextDecoder().decode(result.bytes);
+    if (!response.ok) {
+      endpointError = chatGptTokenError(response.status, result.oversized ? "" : text, label);
+      throw endpointError;
+    }
+    if (result.oversized) throw new ChatGptTokenRequestError("transport");
+    return credsFromToken(JSON.parse(text) as Record<string, unknown>);
+  } catch (error) {
+    if (controller.signal.aborted) throw controller.signal.reason;
+    if (endpointError && error === endpointError) throw endpointError;
+    throw new ChatGptTokenRequestError("transport");
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+/**
+ * Token-endpoint failure carrying the HTTP status, the allowlisted OAuth error code,
+ * and a terminal verdict requiring an explicit grant-refusal code. The shared
+ * Codex classifier supplies the code vocabulary; free text is never grant evidence.
+ */
+export class ChatGptTokenError extends Error {
+  constructor(
+    public readonly httpStatus: number,
+    public readonly oauthError: string | undefined,
+    public readonly terminal: boolean,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ChatGptTokenError";
+  }
+}
+
+function chatGptTokenError(status: number, body: string, label: string): ChatGptTokenError {
+  const failure = classifyChatgptRefreshFailure(status, body);
+  // Reclassify the allowlisted code alone to reuse the shared terminal vocabulary
+  // without its description-only compatibility rule for other Codex callers.
+  const terminal = failure.reason !== "unknown" && failure.code !== undefined
+    && classifyChatgptRefreshFailure(status, JSON.stringify({ error: failure.code })).reason !== "unknown";
+  // The message carries the status and the allowlisted OAuth code only — never the
+  // free-text `error_description`, which can echo OAuth material into log surfaces
+  // (the same closed vocabulary the pool's noteChatgptRefreshFailure logs with).
+  return new ChatGptTokenError(
+    status,
+    failure.code,
+    terminal,
+    `${label} failed: ${status} code=${failure.code ?? "none"}`,
+  );
+}
 
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 const AUTH_URL = "https://auth.openai.com/oauth/authorize";
@@ -202,34 +302,16 @@ export class ChatGPTOAuthFlow extends OAuthCallbackFlow {
 
   async exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials> {
     if (!this.#verifier) throw new Error("ChatGPT PKCE verifier not initialized");
-    const resp = await fetch(TOKEN_URL, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        client_id: CLIENT_ID,
-        code,
-        redirect_uri: redirectUri,
-        code_verifier: this.#verifier,
-      }).toString(),
-    });
-    if (!resp.ok) {
-      const errDesc = await safeErrorDescription(resp);
-      throw new Error(`ChatGPT token exchange failed: ${resp.status} ${errDesc}`);
-    }
-    return credsFromToken((await resp.json()) as Record<string, unknown>);
+    return chatGptTokenRequest(new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      redirect_uri: redirectUri,
+      code_verifier: this.#verifier,
+    }), "ChatGPT token exchange", { signal: this.ctrl.signal });
   }
 }
 
-function safeErrorDescription(resp: Response): Promise<string> {
-  return resp.text().catch(() => "").then(text => {
-    try {
-      const parsed = JSON.parse(text) as { error?: string; error_description?: string };
-      return [parsed.error, parsed.error_description].filter(Boolean).join(": ") || `HTTP ${resp.status}`;
-    } catch { return `HTTP ${resp.status}`; }
-  });
-}
-
 /**
  * How the user proves identity. `browser` runs the localhost:1455 callback flow;
  * `device` runs the deviceauth grant, which needs no local browser or listener
@@ -255,21 +337,11 @@ export async function loginChatGPT(
 // Codex-rs uses JSON for refresh — intentional divergence; both accepted by auth.openai.com.
 export async function refreshChatGPTToken(
   refreshToken: string,
-  options: { signal?: AbortSignal } = {},
+  options: { signal?: AbortSignal; timeoutMs?: number } = {},
 ): Promise<OAuthCredentials> {
-  const resp = await fetch(TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      client_id: CLIENT_ID,
-      refresh_token: refreshToken,
-    }).toString(),
-    signal: options.signal,
-  });
-  if (!resp.ok) {
-    const errDesc = await safeErrorDescription(resp);
-    throw new Error(`ChatGPT refresh failed: ${resp.status} ${errDesc}`);
-  }
-  return credsFromToken((await resp.json()) as Record<string, unknown>);
+  return chatGptTokenRequest(new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID,
+    refresh_token: refreshToken,
+  }), "ChatGPT refresh", options);
 }