@vacbo/opencode-anthropic-fix 0.0.43 → 0.0.44

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

@@ -6375,12 +6375,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 +6408,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,23 +6488,48 @@ 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();
@@ -6463,11 +6537,36 @@ async function fetchViaBun(input, init) {
   if (!port) return fetch(input, init);
   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.44",
   "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;
     }
   });
+}
+
+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;
+  }
 
-  return starting;
+  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,
@@ -105,9 +195,41 @@ export async function fetchViaBun(
   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,