@vacbo/opencode-anthropic-fix 0.0.44 → 0.1.1

package/src/bun-proxy.ts

@@ -1,71 +1,303 @@
-// Standalone Bun TLS proxy — run with: bun dist/bun-proxy.mjs [port]
-// Forwards requests using Bun's native fetch (BoringSSL TLS fingerprint).
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
-const PORT = parseInt(process.argv[2] || "48372", 10);
+import { ParentPidWatcher } from "./parent-pid-watcher.js";
 
-const server = Bun.serve({
-  port: PORT,
-  async fetch(req: Request): Promise<Response> {
-    if (new URL(req.url).pathname === "/__health") {
-      return new Response("ok");
+const DEFAULT_ALLOWED_HOSTS = ["api.anthropic.com", "platform.claude.com"];
+const DEFAULT_REQUEST_TIMEOUT_MS = 600_000;
+const DEFAULT_PARENT_EXIT_CODE = 1;
+const DEFAULT_PARENT_POLL_INTERVAL_MS = 5_000;
+const HEALTH_PATH = "/__health";
+const DEBUG_ENABLED = process.env.OPENCODE_ANTHROPIC_DEBUG === "1";
+
+interface ProxyRequestHandlerOptions {
+  fetchImpl: typeof fetch;
+  allowHosts?: string[];
+  requestTimeoutMs?: number;
+}
+
+interface ProxyProcessRuntimeOptions {
+  argv?: string[];
+  exit?: (code?: number) => void;
+  parentWatcherFactory?: ParentWatcherFactory;
+}
+
+interface ParentWatcher {
+  start(): void;
+  stop(): void;
+}
+
+interface ParentWatcherFactoryOptions {
+  parentPid: number;
+  onParentExit: (exitCode?: number) => void;
+  pollIntervalMs?: number;
+  exitCode?: number;
+}
+
+type ParentWatcherFactory = (options: ParentWatcherFactoryOptions) => ParentWatcher;
+
+type RequestInitWithDuplex = RequestInit & {
+  duplex?: "half";
+};
+
+interface AbortContext {
+  timeoutSignal: AbortSignal;
+  cancelTimeout(): void;
+}
+
+function isMainModule(argv: string[] = process.argv): boolean {
+  return Boolean(argv[1]) && resolve(argv[1]) === fileURLToPath(import.meta.url);
+}
+
+function parseInteger(value: string | undefined): number | null {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+
+function parseParentPid(argv: string[]): number | null {
+  const inlineValue = argv
+    .map((argument) => argument.match(/^--parent-pid=(\d+)$/)?.[1] ?? null)
+    .find((value) => value !== null);
+
+  if (inlineValue) {
+    return parseInteger(inlineValue);
+  }
+
+  const flagIndex = argv.indexOf("--parent-pid");
+  return flagIndex >= 0 ? parseInteger(argv[flagIndex + 1]) : null;
+}
+
+function createNoopWatcher(): ParentWatcher {
+  return {
+    start(): void {},
+    stop(): void {},
+  };
+}
+
+function createDefaultParentWatcherFactory(): ParentWatcherFactory {
+  return ({ parentPid, onParentExit, pollIntervalMs, exitCode }): ParentWatcher =>
+    new ParentPidWatcher({
+      parentPid,
+      pollIntervalMs,
+      onParentGone: () => {
+        onParentExit(exitCode);
+      },
+    });
+}
+
+function sanitizeForwardHeaders(source: Headers): Headers {
+  const headers = new Headers(source);
+  ["x-proxy-url", "host", "connection", "content-length"].forEach((headerName) => {
+    headers.delete(headerName);
+  });
+  return headers;
+}
+
+function copyResponseHeaders(source: Headers): Headers {
+  const headers = new Headers(source);
+  ["transfer-encoding", "content-encoding"].forEach((headerName) => {
+    headers.delete(headerName);
+  });
+  return headers;
+}
+
+function resolveTargetUrl(req: Request, allowedHosts: ReadonlySet<string>): URL | Response {
+  const targetUrl = req.headers.get("x-proxy-url");
+
+  if (!targetUrl) {
+    return new Response("Missing x-proxy-url", { status: 400 });
+  }
+
+  try {
+    const parsedUrl = new URL(targetUrl);
+    if (allowedHosts.size > 0 && !allowedHosts.has(parsedUrl.hostname)) {
+      return new Response(`Host not allowed: ${parsedUrl.hostname}`, { status: 403 });
     }
 
-    const targetUrl = req.headers.get("x-proxy-url");
-    if (!targetUrl) {
-      return new Response("Missing x-proxy-url", { status: 400 });
+    return parsedUrl;
+  } catch {
+    return new Response("Invalid x-proxy-url", { status: 400 });
+  }
+}
+
+function createAbortContext(requestTimeoutMs: number): AbortContext {
+  const timeoutController = new AbortController();
+  const timer = setTimeout(() => {
+    timeoutController.abort(new DOMException("Upstream request timed out", "TimeoutError"));
+  }, requestTimeoutMs);
+
+  timer.unref?.();
+
+  return {
+    timeoutSignal: timeoutController.signal,
+    cancelTimeout(): void {
+      clearTimeout(timer);
+    },
+  };
+}
+
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException
+    ? error.name === "AbortError" || error.name === "TimeoutError"
+    : error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+
+function isTimeoutAbort(signal: AbortSignal): boolean {
+  const reason = signal.reason;
+  return reason instanceof DOMException
+    ? reason.name === "TimeoutError"
+    : reason instanceof Error && reason.name === "TimeoutError";
+}
+
+function createAbortResponse(req: Request, timeoutSignal: AbortSignal): Response {
+  return req.signal.aborted
+    ? new Response("Client disconnected", { status: 499 })
+    : isTimeoutAbort(timeoutSignal)
+      ? new Response("Upstream request timed out", { status: 504 })
+      : new Response("Upstream request aborted", { status: 499 });
+}
+
+async function createUpstreamInit(req: Request, signal: AbortSignal): Promise<RequestInitWithDuplex> {
+  const method = req.method || "GET";
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const bodyText = hasBody ? await req.text() : "";
+
+  return {
+    method,
+    headers: sanitizeForwardHeaders(req.headers),
+    signal,
+    ...(hasBody && bodyText.length > 0 ? { body: bodyText } : {}),
+  };
+}
+
+function logRequest(targetUrl: URL, req: Request): void {
+  if (!DEBUG_ENABLED) {
+    return;
+  }
+
+  const logHeaders = Object.fromEntries(
+    [...sanitizeForwardHeaders(req.headers).entries()].map(([key, value]) => [
+      key,
+      key === "authorization" ? "Bearer ***" : value,
+    ]),
+  );
+
+  console.error("\n[bun-proxy] === FORWARDED REQUEST ===");
+  console.error(`[bun-proxy] ${req.method} ${targetUrl.toString()}`);
+  console.error(`[bun-proxy] Headers: ${JSON.stringify(logHeaders, null, 2)}`);
+  console.error("[bun-proxy] =========================\n");
+}
+
+export function createProxyRequestHandler(options: ProxyRequestHandlerOptions): (req: Request) => Promise<Response> {
+  const allowedHosts = new Set(options.allowHosts ?? DEFAULT_ALLOWED_HOSTS);
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+
+  return async function handleProxyRequest(req: Request): Promise<Response> {
+    if (new URL(req.url).pathname === HEALTH_PATH) {
+      return new Response("ok");
     }
 
-    const headers = new Headers(req.headers);
-    headers.delete("x-proxy-url");
-    headers.delete("host");
-    headers.delete("connection");
-
-    const body = req.method !== "GET" && req.method !== "HEAD" ? await req.arrayBuffer() : undefined;
-
-    // Log full request for comparison debugging
-    if (targetUrl.includes("/v1/messages") && !targetUrl.includes("count_tokens")) {
-      const logHeaders: Record<string, string> = {};
-      headers.forEach((v, k) => { logHeaders[k] = k === "authorization" ? "Bearer ***" : v; });
-      let systemPreview = "";
-      if (body) {
-        try {
-          const parsed = JSON.parse(new TextDecoder().decode(body));
-          if (Array.isArray(parsed.system)) {
-            systemPreview = JSON.stringify(parsed.system.slice(0, 3).map((b: any) => ({
-              text: typeof b.text === "string" ? b.text.slice(0, 200) : "(non-text)",
-              cache_control: b.cache_control,
-            })), null, 2);
-          }
-        } catch { /* ignore */ }
-      }
-      console.error(`\n[bun-proxy] === /v1/messages REQUEST ===`);
-      console.error(`[bun-proxy] URL: ${targetUrl}`);
-      console.error(`[bun-proxy] Headers: ${JSON.stringify(logHeaders, null, 2)}`);
-      if (systemPreview) console.error(`[bun-proxy] System blocks (first 3): ${systemPreview}`);
-      console.error(`[bun-proxy] ===========================\n`);
+    const targetUrl = resolveTargetUrl(req, allowedHosts);
+    if (targetUrl instanceof Response) {
+      return targetUrl;
     }
 
+    const abortContext = createAbortContext(requestTimeoutMs);
+    const upstreamSignal = AbortSignal.any([req.signal, abortContext.timeoutSignal]);
+    const upstreamInit = await createUpstreamInit(req, upstreamSignal);
+    logRequest(targetUrl, req);
+
     try {
-      const resp = await fetch(targetUrl, {
-        method: req.method,
-        headers,
-        body,
+      const upstreamResponse = await options.fetchImpl(targetUrl.toString(), upstreamInit);
+      return new Response(upstreamResponse.body, {
+        status: upstreamResponse.status,
+        statusText: upstreamResponse.statusText,
+        headers: copyResponseHeaders(upstreamResponse.headers),
       });
+    } catch (error) {
+      if (upstreamSignal.aborted && isAbortError(error)) {
+        return createAbortResponse(req, abortContext.timeoutSignal);
+      }
 
-      const respHeaders = new Headers(resp.headers);
-      respHeaders.delete("transfer-encoding");
-      respHeaders.delete("content-encoding");
+      const message = error instanceof Error ? error.message : String(error);
+      return new Response(message, { status: 502 });
+    } finally {
+      abortContext.cancelTimeout();
+    }
+  };
+}
 
-      return new Response(resp.body, {
-        status: resp.status,
-        statusText: resp.statusText,
-        headers: respHeaders,
-      });
-    } catch (err: unknown) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return new Response(msg, { status: 502 });
+export function createProxyProcessRuntime(options: ProxyProcessRuntimeOptions = {}): ParentWatcher {
+  const argv = options.argv ?? process.argv;
+  const parentPid = parseParentPid(argv);
+  if (!parentPid) {
+    return createNoopWatcher();
+  }
+
+  const exit = options.exit ?? process.exit;
+  const parentWatcherFactory = options.parentWatcherFactory ?? createDefaultParentWatcherFactory();
+
+  return parentWatcherFactory({
+    parentPid,
+    pollIntervalMs: DEFAULT_PARENT_POLL_INTERVAL_MS,
+    exitCode: DEFAULT_PARENT_EXIT_CODE,
+    onParentExit: (exitCode) => {
+      exit(exitCode ?? DEFAULT_PARENT_EXIT_CODE);
+    },
+  });
+}
+
+function assertBunRuntime(): typeof Bun {
+  if (typeof Bun === "undefined") {
+    throw new Error("bun-proxy.ts must be executed with Bun.");
+  }
+
+  return Bun;
+}
+
+async function runProxyProcess(): Promise<void> {
+  const bun = assertBunRuntime();
+  const watcher = createProxyProcessRuntime();
+  const server = bun.serve({
+    port: 0,
+    fetch: createProxyRequestHandler({
+      fetchImpl: fetch,
+      allowHosts: DEFAULT_ALLOWED_HOSTS,
+      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    }),
+  });
+
+  const lifecycle = {
+    closed: false,
+  };
+
+  const shutdown = (exitCode = 0): void => {
+    if (lifecycle.closed) {
+      return;
     }
-  },
-});
 
-console.log(`BUN_PROXY_PORT=${server.port}`);
+    lifecycle.closed = true;
+    watcher.stop();
+    server.stop(true);
+    process.exit(exitCode);
+  };
+
+  process.on("SIGTERM", () => {
+    shutdown(0);
+  });
+
+  process.on("SIGINT", () => {
+    shutdown(0);
+  });
+
+  watcher.start();
+  process.stdout.write(`BUN_PROXY_PORT=${server.port}\n`);
+}
+
+if (isMainModule()) {
+  void runProxyProcess().catch((error) => {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+  });
+}

package/src/circuit-breaker.test.ts

@@ -0,0 +1,274 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { createCircuitBreaker, CircuitBreaker, CircuitState } from "./circuit-breaker.js";
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Core State Tests
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - State Management", () => {
+  it("starts in CLOSED state and allows requests", () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+    expect(breaker.canExecute()).toBe(true);
+  });
+
+  it("transitions to OPEN after N consecutive failures", () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+
+    breaker.recordFailure();
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+    expect(breaker.canExecute()).toBe(false);
+  });
+
+  it("resets failure count on success", () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.recordSuccess();
+
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+    expect(breaker.getFailureCount()).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Open State Behavior
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - Open State", () => {
+  it("fails fast without calling upstream when OPEN", () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 5000,
+    });
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+
+    const upstreamCall = vi.fn();
+    const result = breaker.execute(upstreamCall);
+
+    expect(upstreamCall).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("Circuit breaker is OPEN");
+  });
+
+  it("tracks open state duration", () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 5000,
+    });
+
+    const openTime = Date.now();
+    breaker.recordFailure();
+
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+    expect(breaker.getOpenedAt()).toBeGreaterThanOrEqual(openTime);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Half-Open State
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - Half-Open State", () => {
+  it("transitions to HALF_OPEN after timeout expires", async () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 100,
+    });
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
+    expect(breaker.canExecute()).toBe(true);
+  });
+
+  it("closes breaker on success in HALF_OPEN state", () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 0,
+    });
+
+    breaker.recordFailure();
+    breaker.transitionToHalfOpen();
+    expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
+
+    breaker.recordSuccess();
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+    expect(breaker.getFailureCount()).toBe(0);
+  });
+
+  it("reopens breaker on failure in HALF_OPEN state", () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 3,
+      resetTimeoutMs: 0,
+    });
+
+    breaker.recordFailure();
+    breaker.recordFailure();
+    breaker.transitionToHalfOpen();
+    expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Per-Client Isolation
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - Per-Client Isolation", () => {
+  it("client A failures do not affect client B breaker", () => {
+    const clientABreaker = createCircuitBreaker({
+      clientId: "client-a",
+      failureThreshold: 3,
+    });
+    const clientBBreaker = createCircuitBreaker({
+      clientId: "client-b",
+      failureThreshold: 3,
+    });
+
+    // Client A fails 3 times
+    clientABreaker.recordFailure();
+    clientABreaker.recordFailure();
+    clientABreaker.recordFailure();
+
+    // Client A should be OPEN
+    expect(clientABreaker.getState()).toBe(CircuitState.OPEN);
+    expect(clientABreaker.canExecute()).toBe(false);
+
+    // Client B should still be CLOSED
+    expect(clientBBreaker.getState()).toBe(CircuitState.CLOSED);
+    expect(clientBBreaker.canExecute()).toBe(true);
+  });
+
+  it("each client has independent failure count", () => {
+    const clientABreaker = createCircuitBreaker({
+      clientId: "client-a",
+      failureThreshold: 3,
+    });
+    const clientBBreaker = createCircuitBreaker({
+      clientId: "client-b",
+      failureThreshold: 3,
+    });
+
+    clientABreaker.recordFailure();
+    clientABreaker.recordFailure();
+
+    expect(clientABreaker.getFailureCount()).toBe(2);
+    expect(clientBBreaker.getFailureCount()).toBe(0);
+  });
+
+  it("shared registry returns same breaker for same clientId", () => {
+    const breaker1 = createCircuitBreaker({
+      clientId: "shared-client",
+      failureThreshold: 3,
+    });
+    const breaker2 = createCircuitBreaker({
+      clientId: "shared-client",
+      failureThreshold: 3,
+    });
+
+    breaker1.recordFailure();
+    breaker1.recordFailure();
+
+    // Both references should see the same failure count
+    expect(breaker2.getFailureCount()).toBe(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Configuration
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - Configuration", () => {
+  it("uses default values when options not provided", () => {
+    const breaker = createCircuitBreaker({});
+
+    expect(breaker.getConfig().failureThreshold).toBe(5);
+    expect(breaker.getConfig().resetTimeoutMs).toBe(30000);
+  });
+
+  it("respects custom failure threshold", () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 10 });
+
+    for (let i = 0; i < 9; i++) {
+      breaker.recordFailure();
+    }
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+  });
+
+  it("respects custom reset timeout", async () => {
+    const breaker = createCircuitBreaker({
+      failureThreshold: 1,
+      resetTimeoutMs: 50,
+    });
+
+    breaker.recordFailure();
+    expect(breaker.getState()).toBe(CircuitState.OPEN);
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    expect(breaker.getState()).toBe(CircuitState.HALF_OPEN);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Circuit Breaker - Execute Wrapper
+// ---------------------------------------------------------------------------
+
+describe("CircuitBreaker - Execute Wrapper", () => {
+  it("executes upstream function when CLOSED", async () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+    const upstreamFn = vi.fn().mockResolvedValue("success");
+
+    const result = await breaker.execute(upstreamFn);
+
+    expect(upstreamFn).toHaveBeenCalledTimes(1);
+    expect(result.success).toBe(true);
+    expect(result.data).toBe("success");
+  });
+
+  it("records success when upstream succeeds", async () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+    const upstreamFn = vi.fn().mockResolvedValue("data");
+
+    await breaker.execute(upstreamFn);
+
+    expect(breaker.getFailureCount()).toBe(0);
+    expect(breaker.getState()).toBe(CircuitState.CLOSED);
+  });
+
+  it("records failure when upstream throws", async () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+    const upstreamFn = vi.fn().mockRejectedValue(new Error("upstream error"));
+
+    await breaker.execute(upstreamFn);
+
+    expect(breaker.getFailureCount()).toBe(1);
+  });
+
+  it("returns error result when upstream throws", async () => {
+    const breaker = createCircuitBreaker({ failureThreshold: 3 });
+    const error = new Error("upstream error");
+    const upstreamFn = vi.fn().mockRejectedValue(error);
+
+    const result = await breaker.execute(upstreamFn);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("upstream error");
+  });
+});