@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/bun-fetch.ts

@@ -17,107 +17,107 @@ type FetchInput = string | URL | Request;
 type ForwardFetch = (input: FetchInput, init?: RequestInit) => Promise<Response>;
 
 type ProxyChildProcess = ChildProcess & {
-  stdout: NodeJS.ReadableStream | null;
-  stderr: NodeJS.ReadableStream | null;
-  forwardFetch?: ForwardFetch;
+    stdout: NodeJS.ReadableStream | null;
+    stderr: NodeJS.ReadableStream | null;
+    forwardFetch?: ForwardFetch;
 };
 
 export interface BunFetchStatus {
-  status: "state" | "fallback";
-  mode: "native" | "starting" | "proxy";
-  port: number | null;
-  bunAvailable: boolean | null;
-  childPid: number | null;
-  circuitState: CircuitState;
-  circuitFailureCount: number;
-  reason: string;
+    status: "state" | "fallback";
+    mode: "native" | "starting" | "proxy";
+    port: number | null;
+    bunAvailable: boolean | null;
+    childPid: number | null;
+    circuitState: CircuitState;
+    circuitFailureCount: number;
+    reason: string;
 }
 
 export interface BunFetchOptions {
-  debug?: boolean;
-  onProxyStatus?: (status: BunFetchStatus) => void;
+    debug?: boolean;
+    onProxyStatus?: (status: BunFetchStatus) => void;
 }
 
 export interface BunFetchInstance {
-  fetch: (input: FetchInput, init?: RequestInit) => Promise<Response>;
-  shutdown: () => Promise<void>;
-  getStatus: () => BunFetchStatus;
+    fetch: (input: FetchInput, init?: RequestInit) => Promise<Response>;
+    shutdown: () => Promise<void>;
+    getStatus: () => BunFetchStatus;
 }
 
 interface BunFetchInternal extends BunFetchInstance {
-  ensureProxy: (debugOverride?: boolean) => Promise<number | null>;
-  fetchWithDebug: (input: FetchInput, init?: RequestInit, debugOverride?: boolean) => Promise<Response>;
+    ensureProxy: (debugOverride?: boolean) => Promise<number | null>;
+    fetchWithDebug: (input: FetchInput, init?: RequestInit, debugOverride?: boolean) => Promise<Response>;
 }
 
 interface StartProxyResult {
-  child: ProxyChildProcess;
-  port: number;
+    child: ProxyChildProcess;
+    port: number;
 }
 
 interface InstanceState {
-  activeChild: ProxyChildProcess | null;
-  activePort: number | null;
-  startingChild: ProxyChildProcess | null;
-  startPromise: Promise<number | null> | null;
-  bunAvailable: boolean | null;
-  pendingFetches: Array<{
-    runProxy: (useForwardFetch: boolean) => void;
-    runNative: (reason: string) => void;
-  }>;
+    activeChild: ProxyChildProcess | null;
+    activePort: number | null;
+    startingChild: ProxyChildProcess | null;
+    startPromise: Promise<number | null> | null;
+    bunAvailable: boolean | null;
+    pendingFetches: Array<{
+        runProxy: (useForwardFetch: boolean) => void;
+        runNative: (reason: string) => void;
+    }>;
 }
 
 function findProxyScript(): string | null {
-  const dir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
-
-  for (const candidate of [
-    join(dir, "bun-proxy.mjs"),
-    join(dir, "..", "dist", "bun-proxy.mjs"),
-    join(dir, "bun-proxy.ts"),
-  ]) {
-    if (existsSync(candidate)) {
-      return candidate;
+    const dir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+
+    for (const candidate of [
+        join(dir, "bun-proxy.mjs"),
+        join(dir, "..", "dist", "bun-proxy.mjs"),
+        join(dir, "bun-proxy.ts"),
+    ]) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
     }
-  }
 
-  return null;
+    return null;
 }
 
 function detectBunAvailability(): boolean {
-  try {
-    execFileSync("bun", ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
+    try {
+        execFileSync("bun", ["--version"], { stdio: "ignore" });
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 function toHeaders(headersInit?: RequestInit["headers"]): Headers {
-  return new Headers(headersInit ?? undefined);
+    return new Headers(headersInit ?? undefined);
 }
 
 function toRequestUrl(input: FetchInput): string {
-  return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 }
 
 function resolveProxySignal(input: FetchInput, init?: RequestInit): AbortSignal | undefined {
-  if (init?.signal) {
-    return init.signal;
-  }
+    if (init?.signal) {
+        return init.signal;
+    }
 
-  return input instanceof Request ? input.signal : undefined;
+    return input instanceof Request ? input.signal : undefined;
 }
 
 function buildProxyRequestInit(input: FetchInput, init?: RequestInit): RequestInit {
-  const targetUrl = toRequestUrl(input);
-  const headers = toHeaders(init?.headers);
-  const signal = resolveProxySignal(input, init);
-  headers.set("x-proxy-url", targetUrl);
-
-  return {
-    ...init,
-    headers,
-    ...(signal ? { signal } : {}),
-  };
+    const targetUrl = toRequestUrl(input);
+    const headers = toHeaders(init?.headers);
+    const signal = resolveProxySignal(input, init);
+    headers.set("x-proxy-url", targetUrl);
+
+    return {
+        ...init,
+        headers,
+        ...(signal ? { signal } : {}),
+    };
 }
 
 const DEBUG_DUMP_DIR = "/tmp";
@@ -125,420 +125,420 @@ const DEBUG_LATEST_REQUEST_PATH = `${DEBUG_DUMP_DIR}/opencode-last-request.json`
 const DEBUG_LATEST_HEADERS_PATH = `${DEBUG_DUMP_DIR}/opencode-last-headers.json`;
 
 interface DebugDumpPaths {
-  requestPath: string;
-  headersPath: string;
-  latestRequestPath: string;
-  latestHeadersPath: string;
+    requestPath: string;
+    headersPath: string;
+    latestRequestPath: string;
+    latestHeadersPath: string;
 }
 
 function makeDebugDumpId(): string {
-  const filesystemSafeTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const subMillisecondCollisionGuard = randomUUID().slice(0, 8);
-  return `${filesystemSafeTimestamp}-${subMillisecondCollisionGuard}`;
+    const filesystemSafeTimestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const subMillisecondCollisionGuard = randomUUID().slice(0, 8);
+    return `${filesystemSafeTimestamp}-${subMillisecondCollisionGuard}`;
 }
 
 async function writeDebugArtifacts(url: string, init: RequestInit): Promise<DebugDumpPaths | null> {
-  if (!init.body || !url.includes("/v1/messages") || url.includes("count_tokens")) {
-    return null;
-  }
-
-  const { writeFileSync } = await import("node:fs");
-  const id = makeDebugDumpId();
-  const requestPath = `${DEBUG_DUMP_DIR}/opencode-request-${id}.json`;
-  const headersPath = `${DEBUG_DUMP_DIR}/opencode-headers-${id}.json`;
-
-  const bodyText = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
-
-  const logHeaders: Record<string, string> = {};
-  toHeaders(init.headers).forEach((value, key) => {
-    logHeaders[key] = key === "authorization" ? "Bearer ***" : value;
-  });
-  const headersText = JSON.stringify(logHeaders, null, 2);
-
-  writeFileSync(requestPath, bodyText);
-  writeFileSync(headersPath, headersText);
-  writeFileSync(DEBUG_LATEST_REQUEST_PATH, bodyText);
-  writeFileSync(DEBUG_LATEST_HEADERS_PATH, headersText);
-
-  return {
-    requestPath,
-    headersPath,
-    latestRequestPath: DEBUG_LATEST_REQUEST_PATH,
-    latestHeadersPath: DEBUG_LATEST_HEADERS_PATH,
-  };
-}
-
-export function createBunFetch(options: BunFetchOptions = {}): BunFetchInstance {
-  const breaker = createCircuitBreaker({
-    failureThreshold: DEFAULT_BREAKER_FAILURE_THRESHOLD,
-    resetTimeoutMs: DEFAULT_BREAKER_RESET_TIMEOUT_MS,
-  });
-  const closingChildren = new WeakSet<ProxyChildProcess>();
-  const defaultDebug = options.debug ?? false;
-  const onProxyStatus = options.onProxyStatus;
-  const state: InstanceState = {
-    activeChild: null,
-    activePort: null,
-    startingChild: null,
-    startPromise: null,
-    bunAvailable: null,
-    pendingFetches: [],
-  };
-
-  const getStatus = (reason = "idle", status: BunFetchStatus["status"] = "state"): BunFetchStatus => ({
-    status,
-    mode: state.activePort !== null ? "proxy" : state.startPromise ? "starting" : "native",
-    port: state.activePort,
-    bunAvailable: state.bunAvailable,
-    childPid: state.activeChild?.pid ?? state.startingChild?.pid ?? null,
-    circuitState: breaker.getState(),
-    circuitFailureCount: breaker.getFailureCount(),
-    reason,
-  });
-
-  const reportStatus = (reason: string): void => {
-    onProxyStatus?.(getStatus(reason));
-  };
-
-  const reportFallback = (reason: string, _debugOverride?: boolean): void => {
-    onProxyStatus?.(getStatus(reason, "fallback"));
-    // eslint-disable-next-line no-console -- startup diagnostic for Bun unavailability; user-facing fallback notice
-    console.error(
-      `[opencode-anthropic-auth] Native fetch fallback engaged (${reason}); Bun proxy fingerprint mimicry disabled for this request`,
-    );
-  };
-
-  const resolveDebug = (debugOverride?: boolean): boolean => debugOverride ?? defaultDebug;
-
-  const clearActiveProxy = (child: ProxyChildProcess | null): void => {
-    if (child && state.activeChild === child) {
-      state.activeChild = null;
-      state.activePort = null;
+    if (!init.body || !url.includes("/v1/messages") || url.includes("count_tokens")) {
+        return null;
     }
 
-    if (child && state.startingChild === child) {
-      state.startingChild = null;
-    }
-  };
-
-  const flushPendingFetches = (mode: "proxy" | "native", reason = "proxy-unavailable"): void => {
-    const pendingFetches = state.pendingFetches.splice(0, state.pendingFetches.length);
-    const useForwardFetch = pendingFetches.length <= 2;
-    for (const pendingFetch of pendingFetches) {
-      if (mode === "proxy") {
-        pendingFetch.runProxy(useForwardFetch);
-        continue;
-      }
-
-      pendingFetch.runNative(reason);
-    }
-  };
+    const { writeFileSync } = await import("node:fs");
+    const id = makeDebugDumpId();
+    const requestPath = `${DEBUG_DUMP_DIR}/opencode-request-${id}.json`;
+    const headersPath = `${DEBUG_DUMP_DIR}/opencode-headers-${id}.json`;
 
-  const startProxy = async (debugOverride?: boolean): Promise<number | null> => {
-    if (state.activeChild && state.activePort !== null && !state.activeChild.killed) {
-      return state.activePort;
-    }
+    const bodyText = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
 
-    if (state.startPromise) {
-      return state.startPromise;
-    }
+    const logHeaders: Record<string, string> = {};
+    toHeaders(init.headers).forEach((value, key) => {
+        logHeaders[key] = key === "authorization" ? "Bearer ***" : value;
+    });
+    const headersText = JSON.stringify(logHeaders, null, 2);
+
+    writeFileSync(requestPath, bodyText);
+    writeFileSync(headersPath, headersText);
+    writeFileSync(DEBUG_LATEST_REQUEST_PATH, bodyText);
+    writeFileSync(DEBUG_LATEST_HEADERS_PATH, headersText);
+
+    return {
+        requestPath,
+        headersPath,
+        latestRequestPath: DEBUG_LATEST_REQUEST_PATH,
+        latestHeadersPath: DEBUG_LATEST_HEADERS_PATH,
+    };
+}
 
-    if (!breaker.canExecute()) {
-      reportStatus("breaker-open");
-      flushPendingFetches("native", "breaker-open");
-      return null;
-    }
+export function createBunFetch(options: BunFetchOptions = {}): BunFetchInstance {
+    const breaker = createCircuitBreaker({
+        failureThreshold: DEFAULT_BREAKER_FAILURE_THRESHOLD,
+        resetTimeoutMs: DEFAULT_BREAKER_RESET_TIMEOUT_MS,
+    });
+    const closingChildren = new WeakSet<ProxyChildProcess>();
+    const defaultDebug = options.debug ?? false;
+    const onProxyStatus = options.onProxyStatus;
+    const state: InstanceState = {
+        activeChild: null,
+        activePort: null,
+        startingChild: null,
+        startPromise: null,
+        bunAvailable: null,
+        pendingFetches: [],
+    };
 
-    if (state.bunAvailable === false) {
-      reportStatus("bun-unavailable");
-      flushPendingFetches("native", "bun-unavailable");
-      return null;
-    }
+    const getStatus = (reason = "idle", status: BunFetchStatus["status"] = "state"): BunFetchStatus => ({
+        status,
+        mode: state.activePort !== null ? "proxy" : state.startPromise ? "starting" : "native",
+        port: state.activePort,
+        bunAvailable: state.bunAvailable,
+        childPid: state.activeChild?.pid ?? state.startingChild?.pid ?? null,
+        circuitState: breaker.getState(),
+        circuitFailureCount: breaker.getFailureCount(),
+        reason,
+    });
 
-    const script = findProxyScript();
-    state.bunAvailable = detectBunAvailability();
+    const reportStatus = (reason: string): void => {
+        onProxyStatus?.(getStatus(reason));
+    };
 
-    if (!script || !state.bunAvailable) {
-      breaker.recordFailure();
-      reportStatus(script ? "bun-unavailable" : "proxy-script-missing");
-      flushPendingFetches("native", script ? "bun-unavailable" : "proxy-script-missing");
-      return null;
-    }
+    const reportFallback = (reason: string, _debugOverride?: boolean): void => {
+        onProxyStatus?.(getStatus(reason, "fallback"));
+        // eslint-disable-next-line no-console -- startup diagnostic for Bun unavailability; user-facing fallback notice
+        console.error(
+            `[opencode-anthropic-auth] Native fetch fallback engaged (${reason}); Bun proxy fingerprint mimicry disabled for this request`,
+        );
+    };
 
-    state.startPromise = new Promise<number | null>((resolve) => {
-      const debugEnabled = resolveDebug(debugOverride);
-
-      let child: ProxyChildProcess;
-
-      try {
-        child = spawn("bun", ["run", script, "--parent-pid", String(process.pid)], {
-          stdio: ["ignore", "pipe", "pipe"],
-          env: {
-            ...process.env,
-            OPENCODE_ANTHROPIC_DEBUG: debugEnabled ? "1" : "0",
-          },
-        }) as ProxyChildProcess;
-      } catch {
-        breaker.recordFailure();
-        reportStatus("spawn-failed");
-        flushPendingFetches("native", "spawn-failed");
-        resolve(null);
-        return;
-      }
-
-      state.startingChild = child;
-      reportStatus("starting");
-
-      const stdout = child.stdout;
-      if (!stdout) {
-        clearActiveProxy(child);
-        breaker.recordFailure();
-        reportStatus("stdout-missing");
-        flushPendingFetches("native", "stdout-missing");
-        resolve(null);
-        return;
-      }
-
-      let settled = false;
-      const stdoutLines = readline.createInterface({ input: stdout });
-      const startupTimeout = setTimeout(() => {
-        finalize(null, "startup-timeout");
-      }, DEFAULT_STARTUP_TIMEOUT_MS);
-
-      startupTimeout.unref?.();
-
-      const cleanupStartupResources = (): void => {
-        clearTimeout(startupTimeout);
-        stdoutLines.close();
-      };
-
-      const finalize = (result: StartProxyResult | null, reason: string): void => {
-        if (settled) {
-          return;
-        }
+    const resolveDebug = (debugOverride?: boolean): boolean => debugOverride ?? defaultDebug;
 
-        settled = true;
-        cleanupStartupResources();
-
-        if (result) {
-          state.startingChild = null;
-          state.activeChild = result.child;
-          state.activePort = result.port;
-          breaker.recordSuccess();
-          reportStatus(reason);
-          flushPendingFetches("proxy");
-          resolve(result.port);
-          return;
+    const clearActiveProxy = (child: ProxyChildProcess | null): void => {
+        if (child && state.activeChild === child) {
+            state.activeChild = null;
+            state.activePort = null;
         }
 
-        clearActiveProxy(child);
-        breaker.recordFailure();
-        reportStatus(reason);
-        flushPendingFetches("native", reason);
-        resolve(null);
-      };
-
-      stdoutLines.on("line", (line) => {
-        const match = line.match(/^BUN_PROXY_PORT=(\d+)$/);
-        if (!match) {
-          return;
+        if (child && state.startingChild === child) {
+            state.startingChild = null;
         }
+    };
 
-        finalize(
-          {
-            child,
-            port: Number.parseInt(match[1], 10),
-          },
-          "proxy-ready",
-        );
-      });
-
-      child.once("error", () => {
-        finalize(null, "child-error");
-      });
-
-      child.once("exit", () => {
-        const shutdownOwned = closingChildren.has(child);
-        const isCurrentChild = state.activeChild === child || state.startingChild === child;
+    const flushPendingFetches = (mode: "proxy" | "native", reason = "proxy-unavailable"): void => {
+        const pendingFetches = state.pendingFetches.splice(0, state.pendingFetches.length);
+        const useForwardFetch = pendingFetches.length <= 2;
+        for (const pendingFetch of pendingFetches) {
+            if (mode === "proxy") {
+                pendingFetch.runProxy(useForwardFetch);
+                continue;
+            }
 
-        clearActiveProxy(child);
+            pendingFetch.runNative(reason);
+        }
+    };
 
-        if (!settled) {
-          finalize(null, shutdownOwned ? "shutdown-complete" : "child-exit-before-ready");
-          return;
+    const startProxy = async (debugOverride?: boolean): Promise<number | null> => {
+        if (state.activeChild && state.activePort !== null && !state.activeChild.killed) {
+            return state.activePort;
         }
 
-        if (!shutdownOwned && isCurrentChild) {
-          breaker.recordFailure();
-          reportStatus("child-exited");
+        if (state.startPromise) {
+            return state.startPromise;
         }
-      });
-    }).finally(() => {
-      state.startPromise = null;
-    });
 
-    return state.startPromise;
-  };
-
-  const shutdown = async (): Promise<void> => {
-    const children = [state.startingChild, state.activeChild].filter(
-      (child): child is ProxyChildProcess => child !== null,
-    );
-
-    state.startPromise = null;
-    state.startingChild = null;
-    state.activeChild = null;
-    state.activePort = null;
-
-    for (const child of children) {
-      closingChildren.add(child);
-      if (!child.killed) {
-        try {
-          child.kill("SIGTERM");
-        } catch {
-          // Process may have already exited; ignore kill failures
+        if (!breaker.canExecute()) {
+            reportStatus("breaker-open");
+            flushPendingFetches("native", "breaker-open");
+            return null;
         }
-      }
-    }
 
-    breaker.dispose();
-    reportStatus("shutdown-requested");
-  };
+        if (state.bunAvailable === false) {
+            reportStatus("bun-unavailable");
+            flushPendingFetches("native", "bun-unavailable");
+            return null;
+        }
 
-  const fetchThroughProxy = async (
-    input: FetchInput,
-    init: RequestInit | undefined,
-    debugOverride?: boolean,
-  ): Promise<Response> => {
-    const url = toRequestUrl(input);
-    const fetchNative = async (reason: string): Promise<Response> => {
-      reportFallback(reason, debugOverride);
-
-      return globalThis.fetch(input, init);
-    };
+        const script = findProxyScript();
+        state.bunAvailable = detectBunAvailability();
 
-    const fetchFromActiveProxy = async (useForwardFetch: boolean): Promise<Response> => {
-      const port = state.activePort;
-      if (port === null) {
-        return fetchNative("proxy-port-missing");
-      }
-
-      if (resolveDebug(debugOverride)) {
-        // eslint-disable-next-line no-console -- debug-gated proxy status log; only emits when OPENCODE_ANTHROPIC_DEBUG=1
-        console.error(`[opencode-anthropic-auth] Routing through Bun proxy at :${port} → ${url}`);
-      }
-
-      if (resolveDebug(debugOverride)) {
-        try {
-          const dumped = await writeDebugArtifacts(url, init ?? {});
-          if (dumped) {
-            // eslint-disable-next-line no-console -- debug-gated diagnostic; confirms request artifact dump location
-            console.error(
-              `[opencode-anthropic-auth] Dumped request to ${dumped.requestPath} (latest alias: ${dumped.latestRequestPath})`,
-            );
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console -- error-path diagnostic surfaced to stderr for operator visibility
-          console.error("[opencode-anthropic-auth] Failed to dump request:", error);
+        if (!script || !state.bunAvailable) {
+            breaker.recordFailure();
+            reportStatus(script ? "bun-unavailable" : "proxy-script-missing");
+            flushPendingFetches("native", script ? "bun-unavailable" : "proxy-script-missing");
+            return null;
         }
-      }
 
-      const proxyInit = buildProxyRequestInit(input, init);
-      const forwardFetch = state.activeChild?.forwardFetch;
+        state.startPromise = new Promise<number | null>((resolve) => {
+            const debugEnabled = resolveDebug(debugOverride);
+
+            let child: ProxyChildProcess;
+
+            try {
+                child = spawn("bun", ["run", script, "--parent-pid", String(process.pid)], {
+                    stdio: ["ignore", "pipe", "pipe"],
+                    env: {
+                        ...process.env,
+                        OPENCODE_ANTHROPIC_DEBUG: debugEnabled ? "1" : "0",
+                    },
+                }) as ProxyChildProcess;
+            } catch {
+                breaker.recordFailure();
+                reportStatus("spawn-failed");
+                flushPendingFetches("native", "spawn-failed");
+                resolve(null);
+                return;
+            }
+
+            state.startingChild = child;
+            reportStatus("starting");
+
+            const stdout = child.stdout;
+            if (!stdout) {
+                clearActiveProxy(child);
+                breaker.recordFailure();
+                reportStatus("stdout-missing");
+                flushPendingFetches("native", "stdout-missing");
+                resolve(null);
+                return;
+            }
+
+            let settled = false;
+            const stdoutLines = readline.createInterface({ input: stdout });
+            const startupTimeout = setTimeout(() => {
+                finalize(null, "startup-timeout");
+            }, DEFAULT_STARTUP_TIMEOUT_MS);
+
+            startupTimeout.unref?.();
+
+            const cleanupStartupResources = (): void => {
+                clearTimeout(startupTimeout);
+                stdoutLines.close();
+            };
+
+            const finalize = (result: StartProxyResult | null, reason: string): void => {
+                if (settled) {
+                    return;
+                }
+
+                settled = true;
+                cleanupStartupResources();
+
+                if (result) {
+                    state.startingChild = null;
+                    state.activeChild = result.child;
+                    state.activePort = result.port;
+                    breaker.recordSuccess();
+                    reportStatus(reason);
+                    flushPendingFetches("proxy");
+                    resolve(result.port);
+                    return;
+                }
+
+                clearActiveProxy(child);
+                breaker.recordFailure();
+                reportStatus(reason);
+                flushPendingFetches("native", reason);
+                resolve(null);
+            };
+
+            stdoutLines.on("line", (line) => {
+                const match = line.match(/^BUN_PROXY_PORT=(\d+)$/);
+                if (!match) {
+                    return;
+                }
+
+                finalize(
+                    {
+                        child,
+                        port: Number.parseInt(match[1], 10),
+                    },
+                    "proxy-ready",
+                );
+            });
+
+            child.once("error", () => {
+                finalize(null, "child-error");
+            });
+
+            child.once("exit", () => {
+                const shutdownOwned = closingChildren.has(child);
+                const isCurrentChild = state.activeChild === child || state.startingChild === child;
+
+                clearActiveProxy(child);
+
+                if (!settled) {
+                    finalize(null, shutdownOwned ? "shutdown-complete" : "child-exit-before-ready");
+                    return;
+                }
+
+                if (!shutdownOwned && isCurrentChild) {
+                    breaker.recordFailure();
+                    reportStatus("child-exited");
+                }
+            });
+        }).finally(() => {
+            state.startPromise = null;
+        });
+
+        return state.startPromise;
+    };
 
-      const response = await (useForwardFetch && typeof forwardFetch === "function"
-        ? forwardFetch(`http://${DEFAULT_PROXY_HOST}:${port}/`, proxyInit)
-        : fetch(`http://${DEFAULT_PROXY_HOST}:${port}/`, proxyInit));
+    const shutdown = async (): Promise<void> => {
+        const children = [state.startingChild, state.activeChild].filter(
+            (child): child is ProxyChildProcess => child !== null,
+        );
 
-      if (response.status === 502) {
-        const errorText = await response.text();
-        throw new Error(`Bun proxy upstream error: ${errorText}`);
-      }
+        state.startPromise = null;
+        state.startingChild = null;
+        state.activeChild = null;
+        state.activePort = null;
+
+        for (const child of children) {
+            closingChildren.add(child);
+            if (!child.killed) {
+                try {
+                    child.kill("SIGTERM");
+                } catch {
+                    // Process may have already exited; ignore kill failures
+                }
+            }
+        }
 
-      return response;
+        breaker.dispose();
+        reportStatus("shutdown-requested");
     };
 
-    if (state.activeChild && state.activePort !== null && !state.activeChild.killed) {
-      return fetchFromActiveProxy(true);
-    }
-
-    return new Promise<Response>((resolve, reject) => {
-      let settled = false;
-      const pendingFetch: InstanceState["pendingFetches"][number] = {
-        runProxy: (useForwardFetch: boolean) => {
-          if (settled) {
-            return;
-          }
+    const fetchThroughProxy = async (
+        input: FetchInput,
+        init: RequestInit | undefined,
+        debugOverride?: boolean,
+    ): Promise<Response> => {
+        const url = toRequestUrl(input);
+        const fetchNative = async (reason: string): Promise<Response> => {
+            reportFallback(reason, debugOverride);
+
+            return globalThis.fetch(input, init);
+        };
+
+        const fetchFromActiveProxy = async (useForwardFetch: boolean): Promise<Response> => {
+            const port = state.activePort;
+            if (port === null) {
+                return fetchNative("proxy-port-missing");
+            }
+
+            if (resolveDebug(debugOverride)) {
+                // eslint-disable-next-line no-console -- debug-gated proxy status log; only emits when OPENCODE_ANTHROPIC_DEBUG=1
+                console.error(`[opencode-anthropic-auth] Routing through Bun proxy at :${port} → ${url}`);
+            }
+
+            if (resolveDebug(debugOverride)) {
+                try {
+                    const dumped = await writeDebugArtifacts(url, init ?? {});
+                    if (dumped) {
+                        // eslint-disable-next-line no-console -- debug-gated diagnostic; confirms request artifact dump location
+                        console.error(
+                            `[opencode-anthropic-auth] Dumped request to ${dumped.requestPath} (latest alias: ${dumped.latestRequestPath})`,
+                        );
+                    }
+                } catch (error) {
+                    // eslint-disable-next-line no-console -- error-path diagnostic surfaced to stderr for operator visibility
+                    console.error("[opencode-anthropic-auth] Failed to dump request:", error);
+                }
+            }
+
+            const proxyInit = buildProxyRequestInit(input, init);
+            const forwardFetch = state.activeChild?.forwardFetch;
+
+            const response = await (useForwardFetch && typeof forwardFetch === "function"
+                ? forwardFetch(`http://${DEFAULT_PROXY_HOST}:${port}/`, proxyInit)
+                : fetch(`http://${DEFAULT_PROXY_HOST}:${port}/`, proxyInit));
+
+            if (response.status === 502) {
+                const errorText = await response.text();
+                throw new Error(`Bun proxy upstream error: ${errorText}`);
+            }
+
+            return response;
+        };
+
+        if (state.activeChild && state.activePort !== null && !state.activeChild.killed) {
+            return fetchFromActiveProxy(true);
+        }
 
-          settled = true;
-          void fetchFromActiveProxy(useForwardFetch).then(resolve, reject);
-        },
-        runNative: (reason: string) => {
-          if (settled) {
-            return;
-          }
+        return new Promise<Response>((resolve, reject) => {
+            let settled = false;
+            const pendingFetch: InstanceState["pendingFetches"][number] = {
+                runProxy: (useForwardFetch: boolean) => {
+                    if (settled) {
+                        return;
+                    }
+
+                    settled = true;
+                    void fetchFromActiveProxy(useForwardFetch).then(resolve, reject);
+                },
+                runNative: (reason: string) => {
+                    if (settled) {
+                        return;
+                    }
+
+                    settled = true;
+                    void fetchNative(reason).then(resolve, reject);
+                },
+            };
+
+            state.pendingFetches.push(pendingFetch);
+
+            void startProxy(debugOverride).catch(() => {
+                state.pendingFetches = state.pendingFetches.filter((candidate) => candidate !== pendingFetch);
+                pendingFetch.runNative("proxy-start-error");
+            });
+        });
+    };
 
-          settled = true;
-          void fetchNative(reason).then(resolve, reject);
+    const instance: BunFetchInternal = {
+        fetch(input, init) {
+            return fetchThroughProxy(input, init);
         },
-      };
-
-      state.pendingFetches.push(pendingFetch);
+        ensureProxy: startProxy,
+        fetchWithDebug: fetchThroughProxy,
+        shutdown,
+        getStatus: () => getStatus(),
+    };
 
-      void startProxy(debugOverride).catch(() => {
-        state.pendingFetches = state.pendingFetches.filter((candidate) => candidate !== pendingFetch);
-        pendingFetch.runNative("proxy-start-error");
-      });
-    });
-  };
-
-  const instance: BunFetchInternal = {
-    fetch(input, init) {
-      return fetchThroughProxy(input, init);
-    },
-    ensureProxy: startProxy,
-    fetchWithDebug: fetchThroughProxy,
-    shutdown,
-    getStatus: () => getStatus(),
-  };
-
-  return instance;
+    return instance;
 }
 
 const defaultBunFetch = (() => {
-  let instance: BunFetchInternal | null = null;
-
-  return {
-    get(): BunFetchInternal {
-      if (!instance) {
-        instance = createBunFetch() as BunFetchInternal;
-      }
-
-      return instance;
-    },
-    async reset(): Promise<void> {
-      if (!instance) {
-        return;
-      }
-
-      await instance.shutdown();
-      instance = null;
-    },
-  };
+    let instance: BunFetchInternal | null = null;
+
+    return {
+        get(): BunFetchInternal {
+            if (!instance) {
+                instance = createBunFetch() as BunFetchInternal;
+            }
+
+            return instance;
+        },
+        async reset(): Promise<void> {
+            if (!instance) {
+                return;
+            }
+
+            await instance.shutdown();
+            instance = null;
+        },
+    };
 })();
 
 export async function ensureBunProxy(debug: boolean): Promise<number | null> {
-  return defaultBunFetch.get().ensureProxy(debug);
+    return defaultBunFetch.get().ensureProxy(debug);
 }
 
 export const stopBunProxy = (): void => {
-  void defaultBunFetch.reset();
+    void defaultBunFetch.reset();
 };
 
 export async function fetchViaBun(
-  input: FetchInput,
-  init: { headers: Headers; body?: string | null; method?: string; [key: string]: unknown },
-  debug: boolean,
+    input: FetchInput,
+    init: { headers: Headers; body?: string | null; method?: string; [key: string]: unknown },
+    debug: boolean,
 ): Promise<Response> {
-  return defaultBunFetch.get().fetchWithDebug(input, init as RequestInit & { headers: Headers }, debug);
+    return defaultBunFetch.get().fetchWithDebug(input, init as RequestInit & { headers: Headers }, debug);
 }