opencode-claude-max-proxy 1.12.1 → 1.12.2

package/dist/{cli-s4sk7eks.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 ? {
@@ -13032,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",
@@ -13067,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,
@@ -13099,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-s4sk7eks.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-s4sk7eks.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.1",
+  "version": "1.12.2",
   "description": "Use your Claude Max subscription with OpenCode via proxy server",
   "type": "module",
   "main": "./dist/server.js",