claudish 14.18.2 → 14.18.4

package/dist/index.js

@@ -5494,7 +5494,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.18.2";
+var VERSION = "14.18.4";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -93087,8 +93087,29 @@ function bodyToForward(c, payload) {
   const inbound = c.get(INBOUND_BODY_KEY);
   return inbound !== undefined && inbound.canonical === serialized ? inbound.raw : serialized;
 }
-var ALLOWED_NAMES, HOP_BY_HOP, INTERNAL_PREFIX = "x-claudish-", ALLOWED_QUERY_NAMES, INBOUND_BODY_KEY = "inboundBody";
+async function buildForwardRequest(c, payload, endpoint, fallbackKey) {
+  const headers = {
+    ...requestHeadersToForward(c.req.raw.headers),
+    ...inboundAuthHeaders(c.req.raw.headers)
+  };
+  if (headers.authorization && CLAUDE_LOGIN_BEARER.test(headers.authorization)) {
+    delete headers["x-api-key"];
+  }
+  headers["content-type"] = "application/json";
+  if (!headers["anthropic-version"])
+    headers["anthropic-version"] = "2023-06-01";
+  if (!headers.authorization && !headers["x-api-key"]) {
+    const key = await fallbackKey();
+    if (key)
+      headers["x-api-key"] = key;
+  }
+  const url = `${endpoint}${forwardedSearch(c)}`;
+  addSigningSecrets(c, credentialValuesFromRequest(headers, url));
+  return { headers, url, body: bodyToForward(c, payload) };
+}
+var ALLOWED_NAMES, HOP_BY_HOP, INTERNAL_PREFIX = "x-claudish-", ALLOWED_QUERY_NAMES, INBOUND_BODY_KEY = "inboundBody", CLAUDE_LOGIN_BEARER;
 var init_anthropic_forward = __esm(() => {
+  init_call_context();
   ALLOWED_NAMES = new Set([
     "authorization",
     "x-api-key",
@@ -93124,6 +93145,7 @@ var init_anthropic_forward = __esm(() => {
     "content-length"
   ]);
   ALLOWED_QUERY_NAMES = new Set(["beta"]);
+  CLAUDE_LOGIN_BEARER = /^Bearer\s+sk-ant-oat\d+-/i;
 });
 
 // src/handlers/shared/thinking-signature.ts
@@ -93216,36 +93238,26 @@ class NativeHandler {
   }
   async handle(c, incoming) {
     const payload = await this.applyRequestHooks(c, incoming);
-    const headers = {
-      ...requestHeadersToForward(c.req.raw.headers),
-      ...inboundAuthHeaders(c.req.raw.headers)
-    };
     const target = payload.model;
     const strippedThinking = stripUnsignedThinkingBlocks(payload.messages);
     if (strippedThinking > 0) {
       log(`[Native] stripped ${strippedThinking} unsigned thinking block(s) from history for ${target} (foreign-provider origin)`);
     }
     const advisorSwapped = c.get(ADVISOR_SWAPPED_CONTEXT_KEY) === true;
+    const inboundAuth = inboundAuthHeaders(c.req.raw.headers);
     log(`
 === [NATIVE] Claude Code \u2192 Anthropic API Request ===`);
-    log(`[Native] x-api-key: ${headers["x-api-key"] ? maskCredential(headers["x-api-key"]) : "(not set)"}`);
-    log(`[Native] authorization: ${headers.authorization ? maskCredential(headers.authorization) : "(not set)"}`);
+    log(`[Native] x-api-key: ${inboundAuth["x-api-key"] ? maskCredential(inboundAuth["x-api-key"]) : "(not set)"}`);
+    log(`[Native] authorization: ${inboundAuth.authorization ? maskCredential(inboundAuth.authorization) : "(not set)"}`);
     log(`Request body (Model: ${target}):`);
     log(`=== End Request ===
 `);
-    headers["content-type"] = "application/json";
-    if (!headers["anthropic-version"])
-      headers["anthropic-version"] = "2023-06-01";
-    if (!headers.authorization && !headers["x-api-key"]) {
-      let fallbackKey = this.apiKey;
-      if (!fallbackKey) {
-        const auth = await credentials.getRequestAuth("native-anthropic", { model: target });
-        fallbackKey = auth.headers["x-api-key"];
-      }
-      if (fallbackKey) {
-        headers["x-api-key"] = fallbackKey;
-      }
-    }
+    const { headers, url, body } = await buildForwardRequest(c, payload, `${this.baseUrl}/v1/messages`, async () => {
+      if (this.apiKey)
+        return this.apiKey;
+      const auth = await credentials.getRequestAuth("native-anthropic", { model: target });
+      return auth.headers["x-api-key"];
+    });
     const incomingBeta = headers["anthropic-beta"];
     if (incomingBeta && advisorSwapped) {
       const { stripped, changed } = stripAdvisorBeta(incomingBeta);
@@ -93262,9 +93274,6 @@ class NativeHandler {
       else
         delete headers["anthropic-beta"];
     }
-    const url = `${this.baseUrl}/v1/messages${forwardedSearch(c)}`;
-    addSigningSecrets(c, credentialValuesFromRequest(headers, url));
-    const body = bodyToForward(c, payload);
     try {
       const anthropicResponse = await fetch(url, {
         method: "POST",
@@ -93419,7 +93428,6 @@ var init_native_handler = __esm(() => {
   init_native_handler_advisor();
   init_anthropic_error();
   init_anthropic_forward();
-  init_call_context();
 });
 
 // src/hooks/seam-hooks.ts
@@ -94471,43 +94479,31 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
   });
   app.post("/v1/messages/count_tokens", async (c) => {
     try {
-      const body = await c.req.json();
+      const rawBody = await c.req.text();
+      const body = JSON.parse(rawBody);
+      recordInboundBody(c, rawBody, body);
       if (typeof body?.model !== "string" || body.model.length === 0) {
         return c.json(wrapAnthropicError(400, "missing required field: model"), 400);
       }
       const handler = await getHandlerForRequest(body.model);
       if (handler instanceof NativeHandler) {
-        const inbound = c.req.header();
-        const headers = {
-          "Content-Type": "application/json",
-          "anthropic-version": inbound["anthropic-version"] || "2023-06-01"
-        };
-        if (inbound.authorization)
-          headers.authorization = inbound.authorization;
-        if (inbound["x-api-key"])
-          headers["x-api-key"] = inbound["x-api-key"];
-        if (inbound["anthropic-beta"])
-          headers["anthropic-beta"] = inbound["anthropic-beta"];
-        if (!inbound.authorization && !inbound["x-api-key"]) {
-          let fallbackKey = anthropicApiKey;
-          if (!fallbackKey) {
-            try {
-              const auth = await credentials.getRequestAuth("native-anthropic", {
-                model: body.model
-              });
-              fallbackKey = auth.headers["x-api-key"];
-            } catch (err) {
-              log(`[CountTokens] no resolvable Anthropic credential: ${err}`);
-            }
+        const forward = await buildForwardRequest(c, body, resolveUpstreamUrl("https://api.anthropic.com/v1/messages/count_tokens"), async () => {
+          if (anthropicApiKey)
+            return anthropicApiKey;
+          try {
+            const auth = await credentials.getRequestAuth("native-anthropic", {
+              model: body.model
+            });
+            return auth.headers["x-api-key"];
+          } catch (err) {
+            log(`[CountTokens] no resolvable Anthropic credential: ${err}`);
+            return;
           }
-          if (fallbackKey)
-            headers["x-api-key"] = fallbackKey;
-        }
-        addSigningSecrets(c, credentialValuesFromRequest(headers));
-        const res = await fetch(resolveUpstreamUrl("https://api.anthropic.com/v1/messages/count_tokens"), {
+        });
+        const res = await fetch(forward.url, {
           method: "POST",
-          headers,
-          body: JSON.stringify(body)
+          headers: forward.headers,
+          body: forward.body
         });
         if (res.status === 401 || res.status === 403) {
           log(`[CountTokens] upstream ${res.status} \u2014 falling back to the local estimate`);
@@ -96521,11 +96517,12 @@ function readProcessTable() {
   }
   return tableOf(stdout, spawnedAt);
 }
-function readProcessTableAsync() {
+function readProcessTableAsync(cancelAfterMs) {
+  const options = cancelAfterMs === undefined ? PS_OPTIONS : { ...PS_OPTIONS, timeout: cancelAfterMs, killSignal: "SIGKILL" };
   return new Promise((resolve) => {
     const spawnedAt = Date.now();
     try {
-      psSpawn.execFile("ps", PS_ARGS, PS_OPTIONS, (err, stdout) => resolve(tableOf(err ? null : String(stdout), spawnedAt)));
+      psSpawn.execFile("ps", PS_ARGS, options, (err, stdout) => resolve(tableOf(err ? null : String(stdout), spawnedAt)));
     } catch {
       resolve(tableOf(null, spawnedAt));
     }
@@ -96582,11 +96579,14 @@ function escapedDescendants(table, pgid, inGroup) {
   }
   return out;
 }
+function liveMembers(table, members) {
+  const keys = new Set(members.map((m) => `${m.pid} ${collapse(m.lstart)}`));
+  return table.filter((r) => keys.has(`${r.pid} ${r.lstart}`)).map((r) => r.pid);
+}
 function liveEscaped(table, snap) {
   if (!snap?.escaped?.length)
     return [];
-  const keys = new Set(snap.escaped.map((m) => `${m.pid} ${collapse(m.lstart)}`));
-  return table.filter((r) => keys.has(`${r.pid} ${r.lstart}`)).map((r) => r.pid);
+  return liveMembers(table, snap.escaped);
 }
 function mergeSnapshots(a, b, table) {
   if (!a)
@@ -97467,8 +97467,62 @@ function waitForExit(proc, ms) {
     t.unref?.();
   });
 }
+function descendantsOf(table, rootPid) {
+  const childrenOf = new Map;
+  for (const { pid, ppid, lstart } of table) {
+    const siblings = childrenOf.get(ppid);
+    if (siblings)
+      siblings.push({ pid, lstart });
+    else
+      childrenOf.set(ppid, [{ pid, lstart }]);
+  }
+  const seen = new Set([rootPid, process.pid]);
+  const out = [];
+  const queue = [rootPid];
+  for (let parent = queue.shift();parent !== undefined; parent = queue.shift()) {
+    for (const child of childrenOf.get(parent) ?? []) {
+      if (child.pid <= 1 || seen.has(child.pid))
+        continue;
+      seen.add(child.pid);
+      out.push(child);
+      queue.push(child.pid);
+    }
+  }
+  return out;
+}
+async function readTableWithin(budgetMs) {
+  let timer;
+  const table = await Promise.race([
+    readProcessTableAsync(budgetMs),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(null), budgetMs);
+      timer.unref?.();
+    })
+  ]);
+  clearTimeout(timer);
+  return table;
+}
+async function snapshotDescendants(rootPid, budgetMs) {
+  const table = await readTableWithin(budgetMs);
+  return table ? descendantsOf(table, rootPid) : [];
+}
+async function killStillLiveMembers(members, budgetMs) {
+  if (members.length === 0)
+    return 0;
+  const table = await readTableWithin(budgetMs);
+  if (!table)
+    return 0;
+  const pids = liveMembers(table, members);
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+  return pids.length;
+}
 var KILL_PROCESS_GROUP;
 var init_process_tree = __esm(() => {
+  init_process_identity();
   KILL_PROCESS_GROUP = process.platform !== "win32";
 });
 
@@ -98539,6 +98593,8 @@ async function computeMainThreadContextWindow(config, cachePath) {
   let min = Number.POSITIVE_INFINITY;
   const unresolved = [];
   for (const spec of specs) {
+    if (signalShutdownExitCode() !== null)
+      break;
     try {
       const resolved = await resolveLocalContextWindow(spec, cachePath);
       if (!resolved)
@@ -98671,6 +98727,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     statusLine,
     tokenFilePath
   } = createTempSettingsFile(modelId ?? "default", port, proxyAuthMode, userStatusLineCommand);
+  const signalShutdown = setupSignalHandlers(tempSettingsPath, config.quiet, onCleanup);
   mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyAuthMode);
   const claudeArgs = [];
   claudeArgs.push("--settings", tempSettingsPath);
@@ -98810,6 +98867,11 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
 `);
   }
   const claudeBinary = await findClaudeBinary();
+  const stoppedBeforeSpawn = signalShutdownExitCode();
+  if (stoppedBeforeSpawn !== null) {
+    signalShutdown.removeSettingsFile();
+    return stoppedBeforeSpawn;
+  }
   if (!claudeBinary) {
     console.error("Error: Claude Code CLI not found");
     console.error("Install it from: https://claude.com/claude-code");
@@ -98872,6 +98934,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     stdio,
     shell: needsShell
   });
+  signalShutdown.attachClaudeCode(proc);
   if (wrap) {
     wrap.watch(proc);
   }
@@ -98938,7 +99001,6 @@ Or set CLAUDE_PATH to your custom installation:`);
       } catch {}
     });
   }
-  const signalShutdown = setupSignalHandlers(proc, tempSettingsPath, config.quiet, onCleanup);
   const { exitCode, exitSignal } = await new Promise((resolve) => {
     proc.on("exit", (code, signal) => {
       setClaudeCodeRunning(false);
@@ -98962,58 +99024,62 @@ Or set CLAUDE_PATH to your custom installation:`);
   }
   log(exitSignal ? `[Claude Code] Exited from ${exitSignal} (exit code ${exitCode})` : `[Claude Code] Exited with code ${exitCode}`);
   releaseTerminalIsolation();
-  try {
-    unlinkSync11(tempSettingsPath);
-  } catch {}
-  signalShutdown.launcherCleanupDone();
-  if (signalShutdown.started())
-    return new Promise(() => {});
-  return exitCode;
+  signalShutdown.removeSettingsFile();
+  await signalShutdown.claudeCodeStopped();
+  return signalShutdownExitCode() ?? exitCode;
 }
 function sessionOutcomeOf(exitCode) {
   return exitCode === 0 ? { state: "COMPLETED", reason: null, exitCode } : { state: "FAILED", reason: "child_exited", exitCode };
 }
-function delay(ms) {
-  return new Promise((resolve) => {
-    const t = setTimeout(resolve, Math.max(0, ms));
-    t.unref?.();
-  });
+function signalShutdownExitCode() {
+  return signalShutdownCode;
 }
-function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
+function setupSignalHandlers(tempSettingsPath, quiet, onCleanup) {
   const signals = isWindows2() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
   let shuttingDown = null;
-  let markLauncherCleanupDone = () => {};
-  const launcherCleanup = new Promise((resolve) => {
-    markLauncherCleanupDone = resolve;
-  });
-  const shutdown = async (signal) => {
-    const startedAt = Date.now();
+  let claudeCode = null;
+  let claudeCodeStopped = Promise.resolve();
+  let settingsFileRemoved = false;
+  const removeSettingsFile = () => {
+    if (settingsFileRemoved)
+      return;
+    settingsFileRemoved = true;
+    try {
+      unlinkSync11(tempSettingsPath);
+    } catch {}
+  };
+  const stopClaudeCode = async (proc) => {
     try {
       proc.kill("SIGTERM");
-      if (!await waitForExit(proc, SIGNAL_CHILD_EXIT_GRACE_MS)) {
-        log(`[claudish] Claude Code did not exit within ${SIGNAL_CHILD_EXIT_GRACE_MS} ms of SIGTERM; sending SIGKILL`);
-        try {
-          proc.kill("SIGKILL");
-        } catch {}
-        await waitForExit(proc, SIGNAL_CHILD_KILL_WAIT_MS);
+      if (await waitForExit(proc, SIGNAL_CHILD_EXIT_GRACE_MS))
+        return;
+      log(`[claudish] Claude Code did not exit within ${SIGNAL_CHILD_EXIT_GRACE_MS} ms of SIGTERM; sending SIGKILL`);
+      const killStepStartedAt = Date.now();
+      const descendants = proc.pid ? await snapshotDescendants(proc.pid, SIGNAL_DESCENDANT_READ_MS) : [];
+      if (proc.exitCode !== null || proc.signalCode !== null)
+        return;
+      let killed = 0;
+      try {
+        proc.kill("SIGKILL");
+      } finally {
+        killed = await killStillLiveMembers(descendants, SIGNAL_DESCENDANT_READ_MS);
       }
-      await Promise.race([
-        launcherCleanup,
-        delay(SIGNAL_SHUTDOWN_BUDGET_MS - (Date.now() - startedAt))
-      ]);
+      log(`[claudish] Sent SIGKILL to Claude Code and ${killed} of ${descendants.length} descendants`);
+      await waitForExit(proc, SIGNAL_CHILD_KILL_WAIT_MS - (Date.now() - killStepStartedAt));
     } catch (err) {
       log(`[claudish] Signal shutdown error: ${err}`);
-    } finally {
-      if (onCleanup) {
-        try {
-          onCleanup();
-        } catch {}
-      }
+    }
+  };
+  const armDeadline = (code) => {
+    const deadline = setTimeout(() => {
+      log(`[claudish] Signal shutdown passed ${SIGNAL_SHUTDOWN_BUDGET_MS} ms; exiting`);
       try {
-        unlinkSync11(tempSettingsPath);
+        onCleanup?.();
       } catch {}
-      process.exit(signalExitCode(signal));
-    }
+      removeSettingsFile();
+      process.exit(code);
+    }, SIGNAL_SHUTDOWN_BUDGET_MS);
+    deadline.unref?.();
   };
   claimSignalExit();
   for (const signal of signals) {
@@ -99023,17 +99089,25 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
         return;
       }
       shuttingDown = signal;
+      const code = signalExitCode(signal);
+      signalShutdownCode = code;
+      process.exitCode = code;
+      armDeadline(code);
       releaseTerminalIsolation();
       if (!quiet) {
         console.error(`
 [claudish] Received ${signal}, shutting down...`);
       }
-      shutdown(signal);
+      if (claudeCode)
+        claudeCodeStopped = stopClaudeCode(claudeCode);
     });
   }
   return {
-    started: () => shuttingDown !== null,
-    launcherCleanupDone: () => markLauncherCleanupDone()
+    attachClaudeCode: (child) => {
+      claudeCode = child;
+    },
+    removeSettingsFile,
+    claudeCodeStopped: () => claudeCodeStopped
   };
 }
 async function findClaudeBinary(env = process.env) {
@@ -99135,7 +99209,7 @@ var restoreTerminal = null, macosKeychainAnthropicMemo, defaultKeychainAnthropic
   }
   macosKeychainAnthropicMemo.set(memoKey, found);
   return found;
-}, CLAUDISH_PLACEHOLDER_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx", CLAUDISH_PLACEHOLDER_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth", STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, MAX_AUTO_COMPACT_WINDOW = 1e6, ADVISOR_TOOL_ENV_VAR = "CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL", CLAUDISH_CHILD_ADVISOR_MODEL = "sonnet", CHILD_STDERR_NOISE, SIGNAL_CHILD_EXIT_GRACE_MS = 3000, SIGNAL_CHILD_KILL_WAIT_MS = 500, SIGNAL_SHUTDOWN_BUDGET_MS = 4000;
+}, CLAUDISH_PLACEHOLDER_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx", CLAUDISH_PLACEHOLDER_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth", STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, MAX_AUTO_COMPACT_WINDOW = 1e6, ADVISOR_TOOL_ENV_VAR = "CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL", CLAUDISH_CHILD_ADVISOR_MODEL = "sonnet", CHILD_STDERR_NOISE, SIGNAL_CHILD_EXIT_GRACE_MS = 2000, SIGNAL_CHILD_KILL_WAIT_MS = 500, SIGNAL_DESCENDANT_READ_MS = 200, SIGNAL_SHUTDOWN_BUDGET_MS = 4500, signalShutdownCode = null;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
   init_claude_code_facts();
@@ -125287,11 +125361,18 @@ Team Status`);
     }
     finalizeStartupTrace("run", { quiet: cliConfig.quiet });
     let exitCode = 0;
+    let diagCleaned = false;
+    const cleanupDiag = () => {
+      if (diagCleaned)
+        return;
+      diagCleaned = true;
+      diag.cleanup();
+    };
     try {
-      exitCode = await runClaudeWithProxy(cliConfig, proxy.url, () => diag.cleanup());
+      exitCode = await runClaudeWithProxy(cliConfig, proxy.url, cleanupDiag);
     } finally {
       setDiagOutput(null);
-      diag.cleanup();
+      cleanupDiag();
       if (!cliConfig.quiet) {
         const write = cliConfig.interactive ? console.log : console.error;
         write(`
@@ -125331,8 +125412,9 @@ Team Status`);
         console.error(`[claudish] session summary unavailable: ${e}`);
       }
     }
+    exitCode = signalShutdownExitCode() ?? exitCode;
     const sessionLogPath = getAlwaysOnLogPath();
-    const quitBySignal = exitCode === 130 || exitCode === 143;
+    const quitBySignal = exitCode === 130 || exitCode === 143 || signalShutdownExitCode() !== null;
     if (exitCode !== 0 && !quitBySignal && sessionLogPath && !cliConfig.quiet) {
       console.error(`
 [claudish] Session ended with errors (exit code ${exitCode}).`);
@@ -125347,6 +125429,6 @@ Team Status`);
   } catch (error) {
     console.error("[claudish] Fatal error:", error);
     console.error("[claudish] Stack:", error instanceof Error ? error.stack : "no stack");
-    process.exit(1);
+    process.exit(signalShutdownExitCode() ?? 1);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "14.18.2",
+  "version": "14.18.4",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,10 +71,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "14.18.2",
-    "@claudish/magmux-darwin-x64": "14.18.2",
-    "@claudish/magmux-linux-arm64": "14.18.2",
-    "@claudish/magmux-linux-x64": "14.18.2"
+    "@claudish/magmux-darwin-arm64": "14.18.4",
+    "@claudish/magmux-darwin-x64": "14.18.4",
+    "@claudish/magmux-linux-arm64": "14.18.4",
+    "@claudish/magmux-linux-x64": "14.18.4"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",