opencode-claude-max-proxy 1.12.0 → 1.12.2

package/README.md

@@ -15,30 +15,22 @@ We avoid that limitation by forwarding tool calls instead of executing them. Whe
 From Claude’s perspective, tool usage proceeds normally. From OpenCode’s perspective, it is interacting with the Anthropic API. Execution remains distributed according to the configured agents, allowing different models to handle different roles without being constrained by the SDK.
 
 ```
-┌──────────┐                ┌───────────────┐              ┌──────────────┐
-│          │                │               │              │              │
-│ OpenCode │ ─────────────► │    Proxy      │ ───────────► │  Claude Max  │
-│          │                │  (localhost)  │              │  (Agent SDK) │
-│          │                │               │              │              │
-│          │                │               │ ◄─────────── │  tool_use    │
-│          │                │ ◄──────────── │              │              │
-│          │                │  Intercept    │              └──────────────┘
-│          │                │  (stop turn)  │
-│          │                │       │
-│          │                │       ▼
-│          │                │  ┌──────────────┐
-│          │                │  │  OpenCode    │
-│          │                │  │  agent       │
-│          │                │  │  system      │
-│          │                │  └──────────────┘
-│          │                │       │
-│          │                │       ▼
-│          │                │ ◄────────────
-│          │                │  Resume turn
-│          │                │
-│          │ ◄───────────── │
-│          │  response      │
-└──────────┘                └───────────────┘
+OpenCode ──► Proxy (localhost) ──► Claude Max (Agent SDK)
+                                        │
+                                   tool_use response
+                                        │
+             Proxy intercepts ◄─────────┘
+             (stop turn)
+                  │
+                  ▼
+             OpenCode agent system
+             (routes to GPT-5.4, Gemini, etc.)
+                  │
+                  ▼
+             Proxy resumes SDK ──► Claude continues
+                  │
+                  ▼
+OpenCode ◄── final response
 ```
 
 ## How Passthrough Works
@@ -54,6 +46,14 @@ The Claude Agent SDK exposes a `PreToolUse` hook that fires before any tool exec
 
 ## Quick Start
 
+### One-Liner Install
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/ianjwhite99/opencode-with-claude/main/install.sh | bash
+```
+
+Installs everything (Claude CLI, OpenCode, proxy) and gives you an `oc` command. See [opencode-with-claude](https://github.com/ianjwhite99/opencode-with-claude) for details.
+
 ### Prerequisites
 
 1. **Claude Max subscription** — [Subscribe here](https://claude.ai/settings/billing)
@@ -361,3 +361,5 @@ MIT
 ## Credits
 
 Built with the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) by Anthropic.
+
+[opencode-with-claude](https://github.com/ianjwhite99/opencode-with-claude) installer by [@ianjwhite99](https://github.com/ianjwhite99). Multimodal support based on work by [@juanferreiramorel](https://github.com/juanferreiramorel). Per-terminal proxy idea by [@calebdw](https://github.com/calebdw). README cleanup by [@skipships](https://github.com/skipships).

package/dist/{cli-x0mnz7nm.js → cli-m99nmtqk.js}

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -12,6 +13,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -2239,10 +2241,11 @@ var claudeLog = (event, extra) => {
 };
 
 // src/proxy/server.ts
-import { execSync } from "child_process";
+import { exec as execCallback } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { join as join2, dirname as dirname3 } from "path";
+import { join as join2, dirname as dirname2 } from "path";
+import { promisify as promisify2 } from "util";
 
 // src/mcpTools.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
@@ -12071,10 +12074,53 @@ function stripMcpPrefix(toolName) {
 }
 
 // src/proxy/sessionStore.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 var SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+var STALE_LOCK_THRESHOLD_MS = 30000;
+function acquireLock(lockPath) {
+  try {
+    const fd = openSync(lockPath, "wx");
+    closeSync(fd);
+    return true;
+  } catch (e) {
+    const err = e;
+    if (err.code !== "EEXIST") {
+      console.error("[sessionStore] lock acquire failed:", err.message);
+      return false;
+    }
+    try {
+      const stat = statSync(lockPath);
+      if (Date.now() - stat.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
+        unlinkSync(lockPath);
+        const fd = openSync(lockPath, "wx");
+        closeSync(fd);
+        return true;
+      }
+    } catch (staleError) {
+      console.error("[sessionStore] stale lock recovery failed:", staleError.message);
+    }
+    return false;
+  }
+}
+function releaseLock(lockPath) {
+  try {
+    unlinkSync(lockPath);
+  } catch (e) {
+    console.error("[sessionStore] lock release failed:", e.message);
+  }
+}
 function getStorePath() {
   const dir = process.env.CLAUDE_PROXY_SESSION_DIR || join(homedir(), ".cache", "opencode-claude-max-proxy");
   if (!existsSync(dir)) {
@@ -12097,20 +12143,24 @@ function readStore() {
       }
     }
     return pruned;
-  } catch {
+  } catch (e) {
+    console.error("[sessionStore] read failed:", e.message);
     return {};
   }
 }
 function writeStore(store) {
   const path3 = getStorePath();
-  const tmp = path3 + ".tmp";
+  const tmp = `${path3}.tmp`;
   try {
     writeFileSync(tmp, JSON.stringify(store, null, 2));
     renameSync(tmp, path3);
-  } catch {
+  } catch (e) {
+    console.error("[sessionStore] write failed:", e.message);
     try {
       writeFileSync(path3, JSON.stringify(store, null, 2));
-    } catch {}
+    } catch (directWriteError) {
+      console.error("[sessionStore] write failed:", directWriteError.message);
+    }
   }
 }
 function lookupSharedSession(key) {
@@ -12123,29 +12173,152 @@ function lookupSharedSession(key) {
   return session;
 }
 function storeSharedSession(key, claudeSessionId, messageCount) {
-  const store = readStore();
-  const existing = store[key];
-  store[key] = {
-    claudeSessionId,
-    createdAt: existing?.createdAt || Date.now(),
-    lastUsedAt: Date.now(),
-    messageCount: messageCount ?? existing?.messageCount ?? 0
-  };
-  writeStore(store);
+  const path3 = getStorePath();
+  const lockPath = `${path3}.lock`;
+  const hasLock = acquireLock(lockPath);
+  if (!hasLock) {
+    console.warn("[sessionStore] could not acquire lock, proceeding without");
+  }
+  try {
+    const store = readStore();
+    const existing = store[key];
+    store[key] = {
+      claudeSessionId,
+      createdAt: existing?.createdAt || Date.now(),
+      lastUsedAt: Date.now(),
+      messageCount: messageCount ?? existing?.messageCount ?? 0
+    };
+    writeStore(store);
+  } finally {
+    if (hasLock) {
+      releaseLock(lockPath);
+    }
+  }
 }
 function clearSharedSessions() {
   const path3 = getStorePath();
   try {
     writeFileSync(path3, "{}");
-  } catch {}
+  } catch (e) {
+    console.error("[sessionStore] clear failed:", e.message);
+  }
+}
+
+// src/utils/lruMap.ts
+class LRUMap {
+  maxSize;
+  onEvict;
+  map = new Map;
+  constructor(maxSize, onEvict) {
+    this.maxSize = maxSize;
+    this.onEvict = onEvict;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === undefined)
+      return;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.maxSize) {
+      this.evictOldest();
+    }
+    this.map.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  values() {
+    return this.map.values();
+  }
+  forEach(callbackfn) {
+    this.map.forEach((value, key) => callbackfn(value, key, this));
+  }
+  [Symbol.iterator]() {
+    return this.map[Symbol.iterator]();
+  }
+  evictOldest() {
+    const oldestKey = this.map.keys().next().value;
+    if (oldestKey === undefined)
+      return;
+    const oldestValue = this.map.get(oldestKey);
+    if (oldestValue === undefined)
+      return;
+    this.map.delete(oldestKey);
+    this.onEvict?.(oldestKey, oldestValue);
+  }
 }
 
 // src/proxy/server.ts
-var sessionCache = new Map;
-var fingerprintCache = new Map;
+var DEFAULT_MAX_SESSIONS = 1000;
+function getMaxSessionsLimit() {
+  const raw2 = process.env.CLAUDE_PROXY_MAX_SESSIONS;
+  if (!raw2)
+    return DEFAULT_MAX_SESSIONS;
+  const parsed = Number.parseInt(raw2, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    console.warn(`[PROXY] Invalid CLAUDE_PROXY_MAX_SESSIONS value "${raw2}"; using default ${DEFAULT_MAX_SESSIONS}`);
+    return DEFAULT_MAX_SESSIONS;
+  }
+  return parsed;
+}
+function removeFingerprintEntriesByClaudeSessionId(claudeSessionId) {
+  for (const [key, state] of fingerprintCache.entries()) {
+    if (state.claudeSessionId === claudeSessionId) {
+      fingerprintCache.delete(key);
+    }
+  }
+}
+function removeSessionEntriesByClaudeSessionId(claudeSessionId) {
+  for (const [key, state] of sessionCache.entries()) {
+    if (state.claudeSessionId === claudeSessionId) {
+      sessionCache.delete(key);
+    }
+  }
+}
+function createSessionCache(maxSize) {
+  return new LRUMap(maxSize, (_key, evictedState) => {
+    removeFingerprintEntriesByClaudeSessionId(evictedState.claudeSessionId);
+  });
+}
+function createFingerprintCache(maxSize) {
+  return new LRUMap(maxSize, (_key, evictedState) => {
+    removeSessionEntriesByClaudeSessionId(evictedState.claudeSessionId);
+  });
+}
+var activeMaxSessions = getMaxSessionsLimit();
+var sessionCache = createSessionCache(activeMaxSessions);
+var fingerprintCache = createFingerprintCache(activeMaxSessions);
 function clearSessionCache() {
-  sessionCache.clear();
-  fingerprintCache.clear();
+  const configuredLimit = getMaxSessionsLimit();
+  if (configuredLimit !== activeMaxSessions) {
+    activeMaxSessions = configuredLimit;
+    sessionCache = createSessionCache(activeMaxSessions);
+    fingerprintCache = createFingerprintCache(activeMaxSessions);
+  } else {
+    sessionCache.clear();
+    fingerprintCache.clear();
+  }
   try {
     clearSharedSessions();
   } catch {}
@@ -12332,21 +12505,40 @@ var ALLOWED_MCP_TOOLS = [
   `mcp__${MCP_SERVER_NAME}__glob`,
   `mcp__${MCP_SERVER_NAME}__grep`
 ];
-function resolveClaudeExecutable() {
-  try {
-    const sdkPath = fileURLToPath3(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
-    const sdkCliJs = join2(dirname3(sdkPath), "cli.js");
-    if (existsSync2(sdkCliJs))
-      return sdkCliJs;
-  } catch {}
+var exec2 = promisify2(execCallback);
+var cachedClaudePath = null;
+var cachedClaudePathPromise = null;
+var claudeExecutable = "";
+async function resolveClaudeExecutableAsync() {
+  if (cachedClaudePath)
+    return cachedClaudePath;
+  if (cachedClaudePathPromise)
+    return cachedClaudePathPromise;
+  cachedClaudePathPromise = (async () => {
+    try {
+      const sdkPath = fileURLToPath3(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
+      const sdkCliJs = join2(dirname2(sdkPath), "cli.js");
+      if (existsSync2(sdkCliJs)) {
+        cachedClaudePath = sdkCliJs;
+        return sdkCliJs;
+      }
+    } catch {}
+    try {
+      const { stdout } = await exec2("which claude");
+      const claudePath = stdout.trim();
+      if (claudePath && existsSync2(claudePath)) {
+        cachedClaudePath = claudePath;
+        return claudePath;
+      }
+    } catch {}
+    throw new Error("Could not find Claude Code executable. Install via: npm install -g @anthropic-ai/claude-code");
+  })();
   try {
-    const claudePath = execSync("which claude", { encoding: "utf-8" }).trim();
-    if (claudePath && existsSync2(claudePath))
-      return claudePath;
-  } catch {}
-  throw new Error("Could not find Claude Code executable. Install via: npm install -g @anthropic-ai/claude-code");
+    return await cachedClaudePathPromise;
+  } finally {
+    cachedClaudePathPromise = null;
+  }
 }
-var claudeExecutable = resolveClaudeExecutable();
 function mapModelToClaudeModel(model) {
   if (model.includes("opus"))
     return "opus";
@@ -12482,13 +12674,6 @@ IMPORTANT: When using the task/Task tool, the subagent_type parameter must be on
               }
             }
           } else {
-            if (systemContext) {
-              structured.push({
-                type: "user",
-                message: { role: "user", content: systemContext },
-                parent_tool_use_id: null
-              });
-            }
             for (const m of messagesToConvert) {
               if (m.role === "user") {
                 structured.push({
@@ -12556,9 +12741,7 @@ IMPORTANT: When using the task/Task tool, the subagent_type parameter must be on
           }).join(`
 
 `) || "";
-          prompt = !isResume && systemContext ? `${systemContext}
-
-${conversationParts}` : conversationParts;
+          prompt = conversationParts;
         }
         const passthrough = Boolean(process.env.CLAUDE_PROXY_PASSTHROUGH);
         const capturedToolUses = [];
@@ -12603,6 +12786,9 @@ ${conversationParts}` : conversationParts;
           let currentSessionId;
           claudeLog("upstream.start", { mode: "non_stream", model });
           try {
+            if (!claudeExecutable) {
+              claudeExecutable = await resolveClaudeExecutableAsync();
+            }
             const response = query({
               prompt,
               options: {
@@ -12612,6 +12798,9 @@ ${conversationParts}` : conversationParts;
                 pathToClaudeCodeExecutable: claudeExecutable,
                 permissionMode: "bypassPermissions",
                 allowDangerouslySkipPermissions: true,
+                ...systemContext ? {
+                  systemPrompt: { type: "preset", preset: "claude_code", append: systemContext }
+                } : {},
                 ...passthrough ? {
                   disallowedTools: [...BLOCKED_BUILTIN_TOOLS, ...CLAUDE_CODE_ONLY_TOOLS],
                   ...passthroughMcp ? {
@@ -12759,6 +12948,9 @@ ${conversationParts}` : conversationParts;
                   includePartialMessages: true,
                   permissionMode: "bypassPermissions",
                   allowDangerouslySkipPermissions: true,
+                  ...systemContext ? {
+                    systemPrompt: { type: "preset", preset: "claude_code", append: systemContext }
+                  } : {},
                   ...passthrough ? {
                     disallowedTools: [...BLOCKED_BUILTIN_TOOLS, ...CLAUDE_CODE_ONLY_TOOLS],
                     ...passthroughMcp ? {
@@ -12799,6 +12991,7 @@ ${conversationParts}` : conversationParts;
                 }
               }, 15000);
               const skipBlockIndices = new Set;
+              const streamedToolUseIds = new Set;
               let messageStartEmitted = false;
               try {
                 for await (const message of response) {
@@ -12836,6 +13029,8 @@ ${conversationParts}` : conversationParts;
                       if (block?.type === "tool_use" && typeof block.name === "string") {
                         if (passthrough && block.name.startsWith(PASSTHROUGH_MCP_PREFIX)) {
                           block.name = stripMcpPrefix(block.name);
+                          if (block.id)
+                            streamedToolUseIds.add(block.id);
                         } else if (block.name.startsWith("mcp__")) {
                           if (eventIndex !== undefined)
                             skipBlockIndices.add(eventIndex);
@@ -12883,9 +13078,10 @@ data: ${JSON.stringify(event)}
                 storeSession(opencodeSessionId, body.messages || [], currentSessionId);
               }
               if (!streamClosed) {
-                if (passthrough && capturedToolUses.length > 0 && messageStartEmitted) {
-                  for (let i = 0;i < capturedToolUses.length; i++) {
-                    const tu = capturedToolUses[i];
+                const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
+                if (passthrough && unseenToolUses.length > 0 && messageStartEmitted) {
+                  for (let i = 0;i < unseenToolUses.length; i++) {
+                    const tu = unseenToolUses[i];
                     const blockIndex = eventsForwarded + i;
                     safeEnqueue(encoder.encode(`event: content_block_start
 data: ${JSON.stringify({
@@ -13028,10 +13224,10 @@ data: ${JSON.stringify({
   };
   app.post("/v1/messages", (c) => handleWithQueue(c, "/v1/messages"));
   app.post("/messages", (c) => handleWithQueue(c, "/messages"));
-  app.get("/health", (c) => {
+  app.get("/health", async (c) => {
     try {
-      const authJson = execSync("claude auth status", { encoding: "utf-8", timeout: 5000 });
-      const auth = JSON.parse(authJson);
+      const { stdout } = await exec2("claude auth status", { timeout: 5000 });
+      const auth = JSON.parse(stdout);
       if (!auth.loggedIn) {
         return c.json({
           status: "unhealthy",
@@ -13063,6 +13259,7 @@ data: ${JSON.stringify({
   return { app, config: finalConfig };
 }
 async function startProxyServer(config = {}) {
+  claudeExecutable = await resolveClaudeExecutableAsync();
   const { app, config: finalConfig } = createProxyServer(config);
   const server = serve({
     fetch: app.fetch,
@@ -13095,4 +13292,4 @@ Or use a different port:`);
   return server;
 }
 
-export { clearSessionCache, createProxyServer, startProxyServer };
+export { __require, getMaxSessionsLimit, clearSessionCache, createProxyServer, startProxyServer };

package/dist/cli.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import {
+  __require,
   startProxyServer
-} from "./cli-x0mnz7nm.js";
+} from "./cli-m99nmtqk.js";
 
 // bin/cli.ts
-import { execSync } from "child_process";
+import { exec as execCallback } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execCallback);
 process.on("uncaughtException", (err) => {
   console.error(`[PROXY] Uncaught exception (recovered): ${err.message}`);
 });
@@ -14,17 +17,25 @@ process.on("unhandledRejection", (reason) => {
 var port = parseInt(process.env.CLAUDE_PROXY_PORT || "3456", 10);
 var host = process.env.CLAUDE_PROXY_HOST || "127.0.0.1";
 var idleTimeoutSeconds = parseInt(process.env.CLAUDE_PROXY_IDLE_TIMEOUT_SECONDS || "120", 10);
-try {
-  const authJson = execSync("claude auth status", { encoding: "utf-8", timeout: 5000 });
-  const auth = JSON.parse(authJson);
-  if (!auth.loggedIn) {
-    console.error("\x1B[31m✗ Not logged in to Claude.\x1B[0m Run: claude login");
-    process.exit(1);
+async function runCli(start = startProxyServer, runExec = exec) {
+  try {
+    const { stdout } = await runExec("claude auth status", { timeout: 5000 });
+    const auth = JSON.parse(stdout);
+    if (!auth.loggedIn) {
+      console.error("\x1B[31m✗ Not logged in to Claude.\x1B[0m Run: claude login");
+      process.exit(1);
+    }
+    if (auth.subscriptionType !== "max") {
+      console.error(`\x1B[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1B[0m`);
+    }
+  } catch {
+    console.error("\x1B[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1B[0m");
   }
-  if (auth.subscriptionType !== "max") {
-    console.error(`\x1B[33m⚠ Claude subscription: ${auth.subscriptionType || "unknown"} (Max recommended)\x1B[0m`);
-  }
-} catch {
-  console.error("\x1B[33m⚠ Could not verify Claude auth status. If requests fail, run: claude login\x1B[0m");
+  await start({ port, host, idleTimeoutSeconds });
+}
+if (__require.main == __require.module) {
+  await runCli();
 }
-await startProxyServer({ port, host, idleTimeoutSeconds });
+export {
+  runCli
+};

package/dist/server.js

@@ -1,10 +1,12 @@
 import {
   clearSessionCache,
   createProxyServer,
+  getMaxSessionsLimit,
   startProxyServer
-} from "./cli-x0mnz7nm.js";
+} from "./cli-m99nmtqk.js";
 export {
   startProxyServer,
+  getMaxSessionsLimit,
   createProxyServer,
   clearSessionCache
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-max-proxy",
-  "version": "1.12.0",
+  "version": "1.12.2",
   "description": "Use your Claude Max subscription with OpenCode via proxy server",
   "type": "module",
   "main": "./dist/server.js",