@vacbo/opencode-anthropic-fix 0.0.43 → 0.0.45

package/dist/bun-proxy.mjs

@@ -1,5 +1,5 @@
 // src/bun-proxy.ts
-var PORT = parseInt(process.argv[2] || "0", 10);
+var PORT = parseInt(process.argv[2] || "48372", 10);
 var server = Bun.serve({
   port: PORT,
   async fetch(req) {

package/dist/opencode-anthropic-auth-plugin.js

@@ -4,10 +4,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export = (target, all) => {
@@ -5558,14 +5564,25 @@ function buildAnthropicBillingHeader(claudeCliVersion, messages) {
   let versionSuffix = "";
   if (Array.isArray(messages)) {
     const firstUserMsg = messages.find(
-      (m) => m !== null && typeof m === "object" && m.role === "user" && typeof m.content === "string"
+      (m) => m !== null && typeof m === "object" && m.role === "user"
     );
     if (firstUserMsg) {
-      const text = firstUserMsg.content;
-      const salt = "59cf53e54c78";
-      const picked = [4, 7, 20].map((i) => i < text.length ? text[i] : "0").join("");
-      const hash = createHash2("sha256").update(salt + picked + claudeCliVersion).digest("hex");
-      versionSuffix = `.${hash.slice(0, 3)}`;
+      let text = "";
+      const content = firstUserMsg.content;
+      if (typeof content === "string") {
+        text = content;
+      } else if (Array.isArray(content)) {
+        const textBlock = content.find((b) => b.type === "text");
+        if (textBlock && typeof textBlock.text === "string") {
+          text = textBlock.text;
+        }
+      }
+      if (text) {
+        const salt = "59cf53e54c78";
+        const picked = [4, 7, 20].map((i) => i < text.length ? text[i] : "0").join("");
+        const hash = createHash2("sha256").update(salt + picked + claudeCliVersion).digest("hex");
+        versionSuffix = `.${hash.slice(0, 3)}`;
+      }
     }
   }
   const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT || "cli";
@@ -6375,12 +6392,28 @@ function formatSwitchReason(status, reason) {
 
 // src/bun-fetch.ts
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync } from "node:fs";
 import { dirname as dirname4, join as join6 } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 var proxyPort = null;
 var proxyProcess = null;
 var starting = null;
+var healthCheckFails = 0;
+var FIXED_PORT = 48372;
+var PID_FILE = join6(tmpdir(), "opencode-bun-proxy.pid");
+var MAX_HEALTH_FAILS = 2;
+var exitHandlerRegistered = false;
+function registerExitHandler() {
+  if (exitHandlerRegistered) return;
+  exitHandlerRegistered = true;
+  const cleanup = () => {
+    stopBunProxy();
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
 function findProxyScript() {
   const dir = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath(import.meta.url));
   for (const candidate of [
@@ -6392,45 +6425,78 @@ function findProxyScript() {
   }
   return null;
 }
+var _hasBun = null;
 function hasBun() {
+  if (_hasBun !== null) return _hasBun;
   try {
     execFileSync("which", ["bun"], { stdio: "ignore" });
-    return true;
+    _hasBun = true;
+  } catch {
+    _hasBun = false;
+  }
+  return _hasBun;
+}
+function killStaleProxy() {
+  try {
+    const raw = readFileSync6(PID_FILE, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    if (pid > 0) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    unlinkSync(PID_FILE);
+  } catch {
+  }
+}
+async function isProxyHealthy(port) {
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/__health`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    return resp.ok;
   } catch {
     return false;
   }
 }
-async function ensureBunProxy() {
-  if (process.env.VITEST || process.env.NODE_ENV === "test") return null;
-  if (proxyPort) return proxyPort;
-  if (starting) return starting;
-  starting = new Promise((resolve2) => {
+function spawnProxy() {
+  return new Promise((resolve2) => {
     const script = findProxyScript();
     if (!script || !hasBun()) {
       resolve2(null);
-      starting = null;
       return;
     }
+    killStaleProxy();
     try {
-      const child = spawn("bun", ["run", script, "0"], {
-        stdio: ["ignore", "pipe", "ignore"],
+      const child = spawn("bun", ["run", script, String(FIXED_PORT)], {
+        stdio: ["ignore", "pipe", "pipe"],
         detached: false
       });
       proxyProcess = child;
+      registerExitHandler();
       let done = false;
+      const finish = (port) => {
+        if (done) return;
+        done = true;
+        if (port && child.pid) {
+          try {
+            writeFileSync5(PID_FILE, String(child.pid));
+          } catch {
+          }
+        }
+        resolve2(port);
+      };
       child.stdout?.on("data", (chunk) => {
         const m = chunk.toString().match(/BUN_PROXY_PORT=(\d+)/);
-        if (m && !done) {
-          done = true;
+        if (m) {
           proxyPort = parseInt(m[1], 10);
-          resolve2(proxyPort);
+          healthCheckFails = 0;
+          finish(proxyPort);
         }
       });
       child.on("error", () => {
-        if (!done) {
-          done = true;
-          resolve2(null);
-        }
+        finish(null);
         proxyPort = null;
         proxyProcess = null;
         starting = null;
@@ -6439,35 +6505,102 @@ async function ensureBunProxy() {
         proxyPort = null;
         proxyProcess = null;
         starting = null;
-        if (!done) {
-          done = true;
-          resolve2(null);
-        }
+        finish(null);
       });
-      setTimeout(() => {
-        if (!done) {
-          done = true;
-          resolve2(null);
-        }
-      }, 5e3);
+      setTimeout(() => finish(null), 5e3);
     } catch {
       resolve2(null);
-      starting = null;
     }
   });
-  return starting;
+}
+async function ensureBunProxy() {
+  if (process.env.VITEST || process.env.NODE_ENV === "test") return null;
+  if (proxyPort && proxyProcess && !proxyProcess.killed) {
+    return proxyPort;
+  }
+  if (!proxyPort && await isProxyHealthy(FIXED_PORT)) {
+    proxyPort = FIXED_PORT;
+    console.error("[bun-fetch] Reusing existing Bun proxy on port", FIXED_PORT);
+    return proxyPort;
+  }
+  if (proxyPort && (!proxyProcess || proxyProcess.killed)) {
+    proxyPort = null;
+    proxyProcess = null;
+    starting = null;
+  }
+  if (starting) return starting;
+  starting = spawnProxy();
+  const port = await starting;
+  starting = null;
+  if (port) console.error("[bun-fetch] Bun proxy started on port", port);
+  else console.error("[bun-fetch] Failed to start Bun proxy, falling back to Node.js fetch");
+  return port;
+}
+function stopBunProxy() {
+  if (proxyProcess) {
+    try {
+      proxyProcess.kill();
+    } catch {
+    }
+    proxyProcess = null;
+  }
+  proxyPort = null;
+  starting = null;
+  killStaleProxy();
 }
 async function fetchViaBun(input, init) {
   const port = await ensureBunProxy();
   const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-  if (!port) return fetch(input, init);
+  if (!port) {
+    console.error("[bun-fetch] WARNING: No proxy available, using Node.js fetch (will route to extra usage!)");
+    return fetch(input, init);
+  }
+  console.error(`[bun-fetch] Routing through Bun proxy at :${port} \u2192 ${url}`);
+  if (init.body && url.includes("/v1/messages") && !url.includes("count_tokens")) {
+    try {
+      const { writeFileSync: writeFileSync6 } = __require("node:fs");
+      writeFileSync6("/tmp/opencode-last-request.json", typeof init.body === "string" ? init.body : JSON.stringify(init.body));
+      const hdrs = {};
+      init.headers.forEach((v, k) => {
+        hdrs[k] = k === "authorization" ? "Bearer ***" : v;
+      });
+      writeFileSync6("/tmp/opencode-last-headers.json", JSON.stringify(hdrs, null, 2));
+      console.error("[bun-fetch] Dumped request to /tmp/opencode-last-request.json");
+    } catch {
+    }
+  }
   const headers = new Headers(init.headers);
   headers.set("x-proxy-url", url);
-  return fetch(`http://127.0.0.1:${port}/`, {
-    method: init.method || "POST",
-    headers,
-    body: init.body
-  });
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/`, {
+      method: init.method || "POST",
+      headers,
+      body: init.body
+    });
+    if (resp.status === 502) {
+      const errText = await resp.text();
+      throw new Error(`Bun proxy upstream error: ${errText}`);
+    }
+    healthCheckFails = 0;
+    return resp;
+  } catch (err) {
+    healthCheckFails++;
+    if (healthCheckFails >= MAX_HEALTH_FAILS) {
+      stopBunProxy();
+      const newPort = await ensureBunProxy();
+      if (newPort) {
+        healthCheckFails = 0;
+        const retryHeaders = new Headers(init.headers);
+        retryHeaders.set("x-proxy-url", url);
+        return fetch(`http://127.0.0.1:${newPort}/`, {
+          method: init.method || "POST",
+          headers: retryHeaders,
+          body: init.body
+        });
+      }
+    }
+    throw err;
+  }
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vacbo/opencode-anthropic-fix",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "main": "./dist/opencode-anthropic-auth-plugin.js",
   "bin": {
     "opencode-anthropic-auth": "./dist/opencode-anthropic-auth-cli.mjs",

package/src/bun-fetch.ts

@@ -1,15 +1,33 @@
 // ---------------------------------------------------------------------------
-// Bun TLS proxy manager — spawns a Bun subprocess for BoringSSL TLS.
+// Bun TLS proxy manager — spawns a single Bun subprocess for BoringSSL TLS.
+// Hardened: health checks, auto-restart, single-instance guarantee.
 // ---------------------------------------------------------------------------
 
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 let proxyPort: number | null = null;
 let proxyProcess: ReturnType<typeof spawn> | null = null;
 let starting: Promise<number | null> | null = null;
+let healthCheckFails = 0;
+
+const FIXED_PORT = 48372;
+const PID_FILE = join(tmpdir(), "opencode-bun-proxy.pid");
+const MAX_HEALTH_FAILS = 2;
+
+// Kill proxy when parent process exits
+let exitHandlerRegistered = false;
+function registerExitHandler(): void {
+  if (exitHandlerRegistered) return;
+  exitHandlerRegistered = true;
+  const cleanup = () => { stopBunProxy(); };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
 
 function findProxyScript(): string | null {
   const dir = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
@@ -23,75 +41,147 @@ function findProxyScript(): string | null {
   return null;
 }
 
+let _hasBun: boolean | null = null;
 function hasBun(): boolean {
+  if (_hasBun !== null) return _hasBun;
   try {
     execFileSync("which", ["bun"], { stdio: "ignore" });
-    return true;
+    _hasBun = true;
   } catch {
-    return false;
+    _hasBun = false;
   }
+  return _hasBun;
 }
 
-export async function ensureBunProxy(): Promise<number | null> {
-  // Skip proxy in test environments
-  if (process.env.VITEST || process.env.NODE_ENV === "test") return null;
-  if (proxyPort) return proxyPort;
-  if (starting) return starting;
+function killStaleProxy(): void {
+  try {
+    const raw = readFileSync(PID_FILE, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    if (pid > 0) {
+      try { process.kill(pid, "SIGTERM"); } catch { /* already dead */ }
+    }
+    unlinkSync(PID_FILE);
+  } catch {
+    // No PID file or already cleaned
+  }
+}
 
-  starting = new Promise<number | null>((resolve) => {
+async function isProxyHealthy(port: number): Promise<boolean> {
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/__health`, {
+      signal: AbortSignal.timeout(2000),
+    });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}
+
+function spawnProxy(): Promise<number | null> {
+  return new Promise<number | null>((resolve) => {
     const script = findProxyScript();
     if (!script || !hasBun()) {
       resolve(null);
-      starting = null;
       return;
     }
 
+    // Kill any stale instance first
+    killStaleProxy();
+
     try {
-      const child = spawn("bun", ["run", script, "0"], {
-        stdio: ["ignore", "pipe", "ignore"],
+      const child = spawn("bun", ["run", script, String(FIXED_PORT)], {
+        stdio: ["ignore", "pipe", "pipe"],
         detached: false,
       });
       proxyProcess = child;
+      registerExitHandler();
 
       let done = false;
+      const finish = (port: number | null) => {
+        if (done) return;
+        done = true;
+        if (port && child.pid) {
+          try { writeFileSync(PID_FILE, String(child.pid)); } catch { /* ok */ }
+        }
+        resolve(port);
+      };
+
       child.stdout?.on("data", (chunk: Buffer) => {
         const m = chunk.toString().match(/BUN_PROXY_PORT=(\d+)/);
-        if (m && !done) {
-          done = true;
+        if (m) {
           proxyPort = parseInt(m[1], 10);
-          resolve(proxyPort);
+          healthCheckFails = 0;
+          finish(proxyPort);
         }
       });
+
       child.on("error", () => {
-        if (!done) { done = true; resolve(null); }
-        proxyPort = null; proxyProcess = null; starting = null;
+        finish(null);
+        proxyPort = null;
+        proxyProcess = null;
+        starting = null;
       });
+
       child.on("exit", () => {
-        proxyPort = null; proxyProcess = null; starting = null;
-        if (!done) { done = true; resolve(null); }
+        proxyPort = null;
+        proxyProcess = null;
+        starting = null;
+        finish(null);
       });
-      setTimeout(() => {
-        if (!done) { done = true; resolve(null); }
-      }, 5000);
+
+      // Timeout
+      setTimeout(() => finish(null), 5000);
     } catch {
       resolve(null);
-      starting = null;
     }
   });
+}
 
-  return starting;
+export async function ensureBunProxy(): Promise<number | null> {
+  if (process.env.VITEST || process.env.NODE_ENV === "test") return null;
+
+  // Fast path: proxy already running and healthy
+  if (proxyPort && proxyProcess && !proxyProcess.killed) {
+    return proxyPort;
+  }
+
+  // Check if a proxy is already running on the fixed port (from previous session)
+  if (!proxyPort && await isProxyHealthy(FIXED_PORT)) {
+    proxyPort = FIXED_PORT;
+    console.error("[bun-fetch] Reusing existing Bun proxy on port", FIXED_PORT);
+    return proxyPort;
+  }
+
+  // Restart if previous instance died
+  if (proxyPort && (!proxyProcess || proxyProcess.killed)) {
+    proxyPort = null;
+    proxyProcess = null;
+    starting = null;
+  }
+
+  if (starting) return starting;
+
+  starting = spawnProxy();
+  const port = await starting;
+  starting = null;
+  if (port) console.error("[bun-fetch] Bun proxy started on port", port);
+  else console.error("[bun-fetch] Failed to start Bun proxy, falling back to Node.js fetch");
+  return port;
 }
 
 export function stopBunProxy(): void {
   if (proxyProcess) {
-    try { proxyProcess.kill(); } catch { /* already dead */ }
-    proxyProcess = null; proxyPort = null; starting = null;
+    try { proxyProcess.kill(); } catch { /* */ }
+    proxyProcess = null;
   }
+  proxyPort = null;
+  starting = null;
+  killStaleProxy();
 }
 
 /**
  * Fetch via Bun proxy for BoringSSL TLS fingerprint.
- * Falls back to native Node fetch if Bun is unavailable.
+ * Auto-restarts proxy on failure. Falls back to native fetch only if Bun is unavailable.
  */
 export async function fetchViaBun(
   input: string | URL | Request,
@@ -100,14 +190,63 @@ export async function fetchViaBun(
   const port = await ensureBunProxy();
   const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 
-  if (!port) return fetch(input, init as RequestInit);
+  if (!port) {
+    console.error("[bun-fetch] WARNING: No proxy available, using Node.js fetch (will route to extra usage!)");
+    return fetch(input, init as RequestInit);
+  }
+
+  console.error(`[bun-fetch] Routing through Bun proxy at :${port} → ${url}`);
+
+  // Dump full request for debugging
+  if (init.body && url.includes("/v1/messages") && !url.includes("count_tokens")) {
+    try {
+      const { writeFileSync } = require("node:fs");
+      writeFileSync("/tmp/opencode-last-request.json", typeof init.body === "string" ? init.body : JSON.stringify(init.body));
+      const hdrs: Record<string, string> = {};
+      init.headers.forEach((v: string, k: string) => { hdrs[k] = k === "authorization" ? "Bearer ***" : v; });
+      writeFileSync("/tmp/opencode-last-headers.json", JSON.stringify(hdrs, null, 2));
+      console.error("[bun-fetch] Dumped request to /tmp/opencode-last-request.json");
+    } catch { /* ignore */ }
+  }
 
   const headers = new Headers(init.headers);
   headers.set("x-proxy-url", url);
 
-  return fetch(`http://127.0.0.1:${port}/`, {
-    method: init.method || "POST",
-    headers,
-    body: init.body,
-  });
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/`, {
+      method: init.method || "POST",
+      headers,
+      body: init.body,
+    });
+
+    // Proxy returned a 502 — Bun proxy couldn't reach Anthropic
+    if (resp.status === 502) {
+      const errText = await resp.text();
+      throw new Error(`Bun proxy upstream error: ${errText}`);
+    }
+
+    healthCheckFails = 0;
+    return resp;
+  } catch (err) {
+    healthCheckFails++;
+
+    // If proxy seems dead, restart it and retry once
+    if (healthCheckFails >= MAX_HEALTH_FAILS) {
+      stopBunProxy();
+      const newPort = await ensureBunProxy();
+      if (newPort) {
+        healthCheckFails = 0;
+        const retryHeaders = new Headers(init.headers);
+        retryHeaders.set("x-proxy-url", url);
+        return fetch(`http://127.0.0.1:${newPort}/`, {
+          method: init.method || "POST",
+          headers: retryHeaders,
+          body: init.body,
+        });
+      }
+    }
+
+    // Final fallback: native fetch (will use Node TLS — not ideal but better than failing)
+    throw err;
+  }
 }

package/src/bun-proxy.ts

@@ -1,7 +1,7 @@
 // Standalone Bun TLS proxy — run with: bun dist/bun-proxy.mjs [port]
 // Forwards requests using Bun's native fetch (BoringSSL TLS fingerprint).
 
-const PORT = parseInt(process.argv[2] || "0", 10);
+const PORT = parseInt(process.argv[2] || "48372", 10);
 
 const server = Bun.serve({
   port: PORT,

package/src/headers/billing.ts

@@ -9,21 +9,33 @@ export function buildAnthropicBillingHeader(claudeCliVersion: string, messages:
   // the CLI version, then taking the first 3 hex chars of that combined string.
   let versionSuffix = "";
   if (Array.isArray(messages)) {
+    // Find first user message (CC uses first non-meta user turn)
     const firstUserMsg = messages.find(
       (m) =>
         m !== null &&
         typeof m === "object" &&
-        (m as Record<string, unknown>).role === "user" &&
-        typeof (m as Record<string, unknown>).content === "string",
+        (m as Record<string, unknown>).role === "user",
     ) as Record<string, unknown> | undefined;
     if (firstUserMsg) {
-      const text = firstUserMsg.content as string;
-      const salt = "59cf53e54c78";
-      const picked = [4, 7, 20].map((i) => (i < text.length ? text[i] : "0")).join("");
-      const hash = createHash("sha256")
-        .update(salt + picked + claudeCliVersion)
-        .digest("hex");
-      versionSuffix = `.${hash.slice(0, 3)}`;
+      // Extract text from string or content-block array
+      let text = "";
+      const content = firstUserMsg.content;
+      if (typeof content === "string") {
+        text = content;
+      } else if (Array.isArray(content)) {
+        const textBlock = (content as Array<Record<string, unknown>>).find((b) => b.type === "text");
+        if (textBlock && typeof textBlock.text === "string") {
+          text = textBlock.text;
+        }
+      }
+      if (text) {
+        const salt = "59cf53e54c78";
+        const picked = [4, 7, 20].map((i) => (i < text.length ? text[i] : "0")).join("");
+        const hash = createHash("sha256")
+          .update(salt + picked + claudeCliVersion)
+          .digest("hex");
+        versionSuffix = `.${hash.slice(0, 3)}`;
+      }
     }
   }