@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/bun-proxy.test.ts

@@ -3,35 +3,35 @@ import { describe, expect, it, vi } from "vitest";
 import { createProxyRequestHandler } from "./bun-proxy.js";
 
 function makeProxyRequest(headers?: HeadersInit): Request {
-  const requestHeaders = new Headers(headers);
-  requestHeaders.set("x-proxy-url", "https://api.anthropic.com/v1/messages");
-  requestHeaders.set("content-type", "application/json");
+    const requestHeaders = new Headers(headers);
+    requestHeaders.set("x-proxy-url", "https://api.anthropic.com/v1/messages");
+    requestHeaders.set("content-type", "application/json");
 
-  return new Request("http://127.0.0.1/proxy", {
-    method: "POST",
-    headers: requestHeaders,
-    body: JSON.stringify({ ok: true }),
-  });
+    return new Request("http://127.0.0.1/proxy", {
+        method: "POST",
+        headers: requestHeaders,
+        body: JSON.stringify({ ok: true }),
+    });
 }
 
 describe("createProxyRequestHandler", () => {
-  it("forwards retry requests with keepalive disabled to the upstream fetch", async () => {
-    const upstreamFetch = vi.fn(async (_input, init?: RequestInit) => {
-      expect(init?.keepalive).toBe(false);
-      const forwardedHeaders = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
-      expect(forwardedHeaders.get("connection")).toBe("close");
-      expect(forwardedHeaders.get("x-proxy-disable-keepalive")).toBeNull();
-      return new Response("ok", { status: 200 });
-    });
-    const handler = createProxyRequestHandler({
-      fetchImpl: upstreamFetch as typeof fetch,
-      allowHosts: ["api.anthropic.com"],
-      requestTimeoutMs: 50,
-    });
+    it("forwards retry requests with keepalive disabled to the upstream fetch", async () => {
+        const upstreamFetch = vi.fn(async (_input, init?: RequestInit) => {
+            expect(init?.keepalive).toBe(false);
+            const forwardedHeaders = init?.headers instanceof Headers ? init.headers : new Headers(init?.headers);
+            expect(forwardedHeaders.get("connection")).toBe("close");
+            expect(forwardedHeaders.get("x-proxy-disable-keepalive")).toBeNull();
+            return new Response("ok", { status: 200 });
+        });
+        const handler = createProxyRequestHandler({
+            fetchImpl: upstreamFetch as typeof fetch,
+            allowHosts: ["api.anthropic.com"],
+            requestTimeoutMs: 50,
+        });
 
-    const response = await handler(makeProxyRequest({ "x-proxy-disable-keepalive": "true" }));
+        const response = await handler(makeProxyRequest({ "x-proxy-disable-keepalive": "true" }));
 
-    await expect(response.text()).resolves.toBe("ok");
-    expect(upstreamFetch).toHaveBeenCalledTimes(1);
-  });
+        await expect(response.text()).resolves.toBe("ok");
+        expect(upstreamFetch).toHaveBeenCalledTimes(1);
+    });
 });

package/src/bun-proxy.ts

@@ -12,300 +12,300 @@ const PROXY_DISABLE_KEEPALIVE_HEADER = "x-proxy-disable-keepalive";
 const DEBUG_ENABLED = process.env.OPENCODE_ANTHROPIC_DEBUG === "1";
 
 interface ProxyRequestHandlerOptions {
-  fetchImpl: typeof fetch;
-  allowHosts?: string[];
-  requestTimeoutMs?: number;
+    fetchImpl: typeof fetch;
+    allowHosts?: string[];
+    requestTimeoutMs?: number;
 }
 
 interface ProxyProcessRuntimeOptions {
-  argv?: string[];
-  exit?: (code?: number) => void;
-  parentWatcherFactory?: ParentWatcherFactory;
+    argv?: string[];
+    exit?: (code?: number) => void;
+    parentWatcherFactory?: ParentWatcherFactory;
 }
 
 interface ParentWatcher {
-  start(): void;
-  stop(): void;
+    start(): void;
+    stop(): void;
 }
 
 interface ParentWatcherFactoryOptions {
-  parentPid: number;
-  onParentExit: (exitCode?: number) => void;
-  pollIntervalMs?: number;
-  exitCode?: number;
+    parentPid: number;
+    onParentExit: (exitCode?: number) => void;
+    pollIntervalMs?: number;
+    exitCode?: number;
 }
 
 type ParentWatcherFactory = (options: ParentWatcherFactoryOptions) => ParentWatcher;
 
 type RequestInitWithDuplex = RequestInit & {
-  duplex?: "half";
+    duplex?: "half";
 };
 
 interface AbortContext {
-  timeoutSignal: AbortSignal;
-  cancelTimeout(): void;
+    timeoutSignal: AbortSignal;
+    cancelTimeout(): void;
 }
 
 function isMainModule(argv: string[] = process.argv): boolean {
-  return Boolean(argv[1]) && resolve(argv[1]) === fileURLToPath(import.meta.url);
+    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;
+    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);
+    const inlineValue = argv
+        .map((argument) => argument.match(/^--parent-pid=(\d+)$/)?.[1] ?? null)
+        .find((value) => value !== null);
 
-  if (inlineValue) {
-    return parseInteger(inlineValue);
-  }
+    if (inlineValue) {
+        return parseInteger(inlineValue);
+    }
 
-  const flagIndex = argv.indexOf("--parent-pid");
-  return flagIndex >= 0 ? parseInteger(argv[flagIndex + 1]) : null;
+    const flagIndex = argv.indexOf("--parent-pid");
+    return flagIndex >= 0 ? parseInteger(argv[flagIndex + 1]) : null;
 }
 
 function createNoopWatcher(): ParentWatcher {
-  return {
-    start(): void {},
-    stop(): void {},
-  };
+    return {
+        start(): void {},
+        stop(): void {},
+    };
 }
 
 function createDefaultParentWatcherFactory(): ParentWatcherFactory {
-  return ({ parentPid, onParentExit, pollIntervalMs, exitCode }): ParentWatcher =>
-    new ParentPidWatcher({
-      parentPid,
-      pollIntervalMs,
-      onParentGone: () => {
-        onParentExit(exitCode);
-      },
-    });
+    return ({ parentPid, onParentExit, pollIntervalMs, exitCode }): ParentWatcher =>
+        new ParentPidWatcher({
+            parentPid,
+            pollIntervalMs,
+            onParentGone: () => {
+                onParentExit(exitCode);
+            },
+        });
 }
 
 function sanitizeForwardHeaders(source: Headers, forceFreshConnection = false): Headers {
-  const headers = new Headers(source);
-  [PROXY_DISABLE_KEEPALIVE_HEADER, "x-proxy-url", "host", "connection", "content-length"].forEach((headerName) => {
-    headers.delete(headerName);
-  });
+    const headers = new Headers(source);
+    [PROXY_DISABLE_KEEPALIVE_HEADER, "x-proxy-url", "host", "connection", "content-length"].forEach((headerName) => {
+        headers.delete(headerName);
+    });
 
-  if (forceFreshConnection) {
-    headers.set("connection", "close");
-  }
+    if (forceFreshConnection) {
+        headers.set("connection", "close");
+    }
 
-  return headers;
+    return headers;
 }
 
 function copyResponseHeaders(source: Headers): Headers {
-  const headers = new Headers(source);
-  ["transfer-encoding", "content-encoding"].forEach((headerName) => {
-    headers.delete(headerName);
-  });
-  return 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 });
-  }
+    const targetUrl = req.headers.get("x-proxy-url");
 
-  try {
-    const parsedUrl = new URL(targetUrl);
-    if (allowedHosts.size > 0 && !allowedHosts.has(parsedUrl.hostname)) {
-      return new Response(`Host not allowed: ${parsedUrl.hostname}`, { status: 403 });
+    if (!targetUrl) {
+        return new Response("Missing x-proxy-url", { status: 400 });
     }
 
-    return parsedUrl;
-  } catch {
-    return new Response("Invalid 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 });
+        }
+
+        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);
-    },
-  };
+    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");
+    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";
+    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 });
+    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() : "";
-  const forceFreshConnection = req.headers.get(PROXY_DISABLE_KEEPALIVE_HEADER) === "true";
-
-  return {
-    method,
-    headers: sanitizeForwardHeaders(req.headers, forceFreshConnection),
-    signal,
-    ...(forceFreshConnection ? { keepalive: false } : {}),
-    ...(hasBody && bodyText.length > 0 ? { body: bodyText } : {}),
-  };
+    const method = req.method || "GET";
+    const hasBody = method !== "GET" && method !== "HEAD";
+    const bodyText = hasBody ? await req.text() : "";
+    const forceFreshConnection = req.headers.get(PROXY_DISABLE_KEEPALIVE_HEADER) === "true";
+
+    return {
+        method,
+        headers: sanitizeForwardHeaders(req.headers, forceFreshConnection),
+        signal,
+        ...(forceFreshConnection ? { keepalive: false } : {}),
+        ...(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");
+    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 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 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 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 message = error instanceof Error ? error.message : String(error);
+            return new Response(message, { status: 502 });
+        } finally {
+            abortContext.cancelTimeout();
+        }
+    };
+}
 
-    const targetUrl = resolveTargetUrl(req, allowedHosts);
-    if (targetUrl instanceof Response) {
-      return targetUrl;
+export function createProxyProcessRuntime(options: ProxyProcessRuntimeOptions = {}): ParentWatcher {
+    const argv = options.argv ?? process.argv;
+    const parentPid = parseParentPid(argv);
+    if (!parentPid) {
+        return createNoopWatcher();
     }
 
-    const abortContext = createAbortContext(requestTimeoutMs);
-    const upstreamSignal = AbortSignal.any([req.signal, abortContext.timeoutSignal]);
-    const upstreamInit = await createUpstreamInit(req, upstreamSignal);
-    logRequest(targetUrl, req);
+    const exit = options.exit ?? process.exit;
+    const parentWatcherFactory = options.parentWatcherFactory ?? createDefaultParentWatcherFactory();
 
-    try {
-      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 message = error instanceof Error ? error.message : String(error);
-      return new Response(message, { status: 502 });
-    } finally {
-      abortContext.cancelTimeout();
-    }
-  };
-}
-
-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);
-    },
-  });
+    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.");
-  }
+    if (typeof Bun === "undefined") {
+        throw new Error("bun-proxy.ts must be executed with Bun.");
+    }
 
-  return 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;
-    }
+    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,
+        }),
+    });
 
-    lifecycle.closed = true;
-    watcher.stop();
-    server.stop(true);
-    process.exit(exitCode);
-  };
+    const lifecycle = {
+        closed: false,
+    };
 
-  process.on("SIGTERM", () => {
-    shutdown(0);
-  });
+    const shutdown = (exitCode = 0): void => {
+        if (lifecycle.closed) {
+            return;
+        }
 
-  process.on("SIGINT", () => {
-    shutdown(0);
-  });
+        lifecycle.closed = true;
+        watcher.stop();
+        server.stop(true);
+        process.exit(exitCode);
+    };
+
+    process.on("SIGTERM", () => {
+        shutdown(0);
+    });
 
-  watcher.start();
-  process.stdout.write(`BUN_PROXY_PORT=${server.port}\n`);
+    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);
-  });
+    void runProxyProcess().catch((error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exit(1);
+    });
 }