@gullabs/claude-cli 0.7.0 → 0.16.0

package/dist/index.js

@@ -1,11 +1,109 @@
 import { mkdtemp, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { zodToStandardSchema, toConfigJsonSchema, createModelRegistry, LlmError } from '@gullabs/core';
+import { zodToStandardSchema, toConfigJsonSchema, toConfigKeys, createModelRegistry, LlmError } from '@gullabs/core';
 import { spawn } from 'child_process';
+import { StringDecoder } from 'string_decoder';
 import { z } from 'zod';
 
 // src/adapter.ts
+var INHERITED_NAMES = /* @__PURE__ */ new Set([
+  // Process basics.
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LANGUAGE",
+  "TERM",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "SHELL",
+  "TZ",
+  // Windows equivalents of the above.
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "COMSPEC",
+  "PATHEXT",
+  "USERPROFILE",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "PROGRAMDATA",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  // Network: proxies and trust roots.
+  "HTTPS_PROXY",
+  "HTTP_PROXY",
+  "ALL_PROXY",
+  "NO_PROXY",
+  "https_proxy",
+  "http_proxy",
+  "all_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "SSL_CERT_FILE",
+  "SSL_CERT_DIR",
+  // The CLI's own documented settings that keep the subscription login usable:
+  // where its login lives, the long-lived subscription token from
+  // `claude setup-token`, and client certificates for an mTLS proxy.
+  "CLAUDE_CONFIG_DIR",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "CLAUDE_CODE_CLIENT_CERT",
+  "CLAUDE_CODE_CLIENT_KEY",
+  "CLAUDE_CODE_CLIENT_KEY_PASSPHRASE",
+  "CLAUDE_CODE_PROXY_RESOLVES_HOSTS"
+]);
+var INHERITED_PREFIXES = ["LC_", "XDG_"];
+function isInherited(name, windows) {
+  const key = windows ? name.toUpperCase() : name;
+  if (INHERITED_NAMES.has(key)) return true;
+  return INHERITED_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+function buildChildEnv(parent, extra, windows) {
+  const env = {};
+  for (const [name, value] of Object.entries(parent)) {
+    if (value !== void 0 && isInherited(name, windows)) env[name] = value;
+  }
+  if (extra !== void 0) {
+    if (windows) {
+      const overridden = new Set(Object.keys(extra).map((name) => name.toUpperCase()));
+      for (const name of Object.keys(env)) {
+        if (overridden.has(name.toUpperCase())) delete env[name];
+      }
+    }
+    Object.assign(env, extra);
+  }
+  return env;
+}
+function badEnv(message) {
+  return new LlmError(message, {
+    kind: "bad_request",
+    retryable: false,
+    provider: "claude-cli"
+  });
+}
+function parseExtraEnv(env) {
+  if (env === void 0) return void 0;
+  if (env === null || typeof env !== "object" || Array.isArray(env)) {
+    throw badEnv("claudeCliAdapter: `env` must be an object of string values");
+  }
+  const copy = {};
+  for (const [name, value] of Object.entries(env)) {
+    if (name === "" || name.includes("=") || name.includes("\0")) {
+      throw badEnv(`claudeCliAdapter: \`env\` has an invalid name "${name}"`);
+    }
+    if (typeof value !== "string" || value.includes("\0")) {
+      throw badEnv(
+        `claudeCliAdapter: \`env.${name}\` must be a string without NUL characters`
+      );
+    }
+    copy[name] = value;
+  }
+  return Object.freeze(copy);
+}
+var MAX_STDOUT_BYTES = 32 * 1024 * 1024;
 function buildClaudeCliRunner(claudePath = "claude") {
   return {
     run(args, input, opts) {
@@ -18,9 +116,14 @@ function buildClaudeCliRunner(claudePath = "claude") {
         }
         const child = spawn(claudePath, args, {
           cwd: opts.cwd,
-          stdio: ["pipe", "pipe", "pipe"]
+          stdio: ["pipe", "pipe", "pipe"],
+          detached: process.platform !== "win32",
+          env: buildChildEnv(process.env, opts.env, process.platform === "win32")
         });
+        const stdoutDecoder = new StringDecoder("utf8");
+        const stderrDecoder = new StringDecoder("utf8");
         let stdout = "";
+        let stdoutBytes = 0;
         let stderr = "";
         let settled = false;
         let pendingError;
@@ -36,12 +139,31 @@ function buildClaudeCliRunner(claudePath = "claude") {
             opts.signal.removeEventListener("abort", onAbort);
           }
         };
+        const signalTree = (signal) => {
+          if (process.platform !== "win32" && child.pid !== void 0) {
+            try {
+              process.kill(-child.pid, signal);
+              return;
+            } catch {
+            }
+          }
+          child.kill(signal);
+        };
         const killChild = () => {
-          child.kill("SIGTERM");
+          signalTree("SIGTERM");
           killTimeoutHandle = setTimeout(() => {
-            child.kill("SIGKILL");
+            signalTree("SIGKILL");
+            child.stdout.destroy();
+            child.stderr.destroy();
           }, 5e3);
         };
+        const sweepGroup = () => {
+          if (process.platform === "win32" || child.pid === void 0) return;
+          try {
+            process.kill(-child.pid, "SIGKILL");
+          } catch {
+          }
+        };
         const beginReject = (err) => {
           if (settled || pendingError !== void 0) return;
           pendingError = err;
@@ -64,10 +186,22 @@ function buildClaudeCliRunner(claudePath = "claude") {
           }, opts.timeoutMs);
         }
         child.stdout.on("data", (chunk) => {
-          stdout += chunk.toString("utf8");
+          if (pendingError !== void 0) return;
+          stdoutBytes += chunk.length;
+          if (stdoutBytes > MAX_STDOUT_BYTES) {
+            const err = new Error(
+              `claude-cli stdout exceeded ${MAX_STDOUT_BYTES} bytes; the process was killed`
+            );
+            err.name = "OutputLimitError";
+            beginReject(err);
+            return;
+          }
+          stdout += stdoutDecoder.write(chunk);
         });
         child.stderr.on("data", (chunk) => {
-          stderr += chunk.toString("utf8");
+          stderr = (stderr + stderrDecoder.write(chunk)).slice(-1048576);
+        });
+        child.stdin.on("error", () => {
         });
         child.once("error", (err) => {
           if (settled) return;
@@ -80,8 +214,11 @@ function buildClaudeCliRunner(claudePath = "claude") {
           settled = true;
           cleanup();
           if (pendingError !== void 0) {
+            sweepGroup();
             reject(pendingError);
           } else {
+            stdout += stdoutDecoder.end();
+            stderr = (stderr + stderrDecoder.end()).slice(-1048576);
             resolve({ stdout, stderr, exitCode });
           }
         });
@@ -92,31 +229,52 @@ function buildClaudeCliRunner(claudePath = "claude") {
 }
 
 // src/adapter.ts
+function abortError() {
+  const err = new Error("claude-cli call aborted");
+  err.name = "AbortError";
+  return err;
+}
 var Semaphore = class {
   available;
-  queue = [];
+  waiters = [];
   constructor(max) {
     this.available = max;
   }
-  async acquire() {
+  /**
+   * Take a slot. A caller that has to wait leaves the queue, and rejects with an
+   * `AbortError`, as soon as `signal` fires: a call the engine already gave up
+   * on must not hold a place in line.
+   */
+  acquire(signal) {
+    if (signal?.aborted === true) return Promise.reject(abortError());
     if (this.available > 0) {
       this.available -= 1;
-      return () => {
+      return Promise.resolve(() => {
         this.release();
-      };
+      });
     }
-    await new Promise((resolve) => {
-      this.queue.push(resolve);
+    return new Promise((resolve, reject) => {
+      const grant = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(() => {
+          this.release();
+        });
+      };
+      const onAbort = () => {
+        const at = this.waiters.indexOf(grant);
+        if (at >= 0) this.waiters.splice(at, 1);
+        reject(abortError());
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.waiters.push(grant);
     });
-    this.available -= 1;
-    return () => {
-      this.release();
-    };
   }
+  // A freed slot goes straight to the next waiter, so a new caller cannot
+  // overtake it between the release and the waiter's wake-up.
   release() {
-    this.available += 1;
-    const next = this.queue.shift();
+    const next = this.waiters.shift();
     if (next !== void 0) next();
+    else this.available += 1;
   }
 };
 function mapFinishReason(stopReason) {
@@ -133,14 +291,19 @@ function mapFinishReason(stopReason) {
   }
 }
 function mapUsage(usage) {
-  const inputTokens = usage?.input_tokens ?? 0;
+  const cacheRead = usage?.cache_read_input_tokens;
+  const cacheWrite = usage?.cache_creation_input_tokens;
+  const inputTokens = (usage?.input_tokens ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
   const outputTokens = usage?.output_tokens ?? 0;
-  const cachedInputTokens = usage?.cache_read_input_tokens;
+  const cachedInputTokens = cacheRead;
+  const thinkingTokens = usage?.output_tokens_details?.thinking_tokens;
   const totalTokens = usage !== void 0 ? inputTokens + outputTokens : void 0;
   const details = {
     input: inputTokens,
     output: outputTokens,
     ...cachedInputTokens !== void 0 ? { cached: cachedInputTokens } : {},
+    ...cacheWrite !== void 0 ? { cacheWrite } : {},
+    ...thinkingTokens !== void 0 ? { thinking: thinkingTokens } : {},
     ...totalTokens !== void 0 ? { total: totalTokens } : {}
   };
   const raw = usage !== void 0 ? usage : null;
@@ -150,6 +313,7 @@ function mapUsage(usage) {
     details,
     raw,
     ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+    ...thinkingTokens !== void 0 ? { thinkingTokens } : {},
     ...totalTokens !== void 0 ? { totalTokens } : {}
   };
 }
@@ -179,11 +343,13 @@ function buildPrompt(messages) {
 ${messageText(msg)}`;
   }).join("\n\n");
 }
+var AUTH_FAILURE = /\b(?:log ?in|auth|oauth|authentication|unauthori[sz]ed|401)\b/i;
+var RATE_LIMITED = /\brate[ -]?limit(?:ed|s|ing)?\b|\btoo many requests\b|(?<![\w.:/-])429(?![\w-]|\.\d)/i;
 function looksAuthy(text) {
-  return /login|auth|unauthorized/i.test(text);
+  return AUTH_FAILURE.test(text);
 }
 function looksRateLimited(text) {
-  return /rate limit|429/i.test(text);
+  return RATE_LIMITED.test(text);
 }
 function assertServedModel(envelope, requestedModel) {
   const modelUsage = envelope.modelUsage;
@@ -218,12 +384,6 @@ function classifyRunFailure(envelope, result) {
     });
   }
   const combinedText = `${envelope?.subtype ?? ""} ${result.stderr}`;
-  if (looksAuthy(combinedText)) {
-    return new LlmError(
-      `claude CLI reported an authentication failure: ${result.stderr.slice(-500)}`,
-      { kind: "invalid_auth", retryable: false, provider: "claude-cli" }
-    );
-  }
   if (looksRateLimited(combinedText)) {
     return new LlmError(
       `claude CLI reported rate limiting: ${result.stderr.slice(-500)}`,
@@ -234,6 +394,12 @@ function classifyRunFailure(envelope, result) {
       }
     );
   }
+  if (looksAuthy(combinedText)) {
+    return new LlmError(
+      `claude CLI reported an authentication failure: ${result.stderr.slice(-500)}`,
+      { kind: "invalid_auth", retryable: false, provider: "claude-cli" }
+    );
+  }
   if (envelope?.is_error === true) {
     return new LlmError(
       `claude CLI reported an error (subtype: ${envelope.subtype ?? "unknown"}): ${result.stderr.slice(-500)}`,
@@ -249,6 +415,7 @@ function classifyRunFailure(envelope, result) {
 function claudeCliAdapter(opts) {
   const runner = opts?.runner ?? buildClaudeCliRunner(opts?.claudePath);
   const semaphore = new Semaphore(opts?.maxConcurrency ?? 2);
+  const env = parseExtraEnv(opts?.env);
   return {
     id: "claude-cli",
     async run(req, ctx) {
@@ -320,14 +487,29 @@ function claudeCliAdapter(opts) {
         args.push("--json-schema", JSON.stringify(req.outputJsonSchema));
       }
       const timeoutMs = req.attemptTimeoutMs ?? config.timeoutMs;
-      const cwd = await mkdtemp(join(tmpdir(), "claude-cli-"));
-      const release = await semaphore.acquire();
+      let release;
+      try {
+        release = await semaphore.acquire(ctx.signal);
+      } catch (waitErr) {
+        throw new LlmError(
+          waitErr instanceof Error ? waitErr.message : "claude-cli call aborted",
+          { kind: "aborted", retryable: false, provider: "claude-cli" }
+        );
+      }
+      let cwd;
+      try {
+        cwd = await mkdtemp(join(tmpdir(), "claude-cli-"));
+      } catch (mkdirErr) {
+        release();
+        throw mkdirErr;
+      }
       let result;
       try {
         result = await runner.run(args, prompt, {
           cwd,
           ...timeoutMs !== void 0 ? { timeoutMs } : {},
-          ...ctx.signal !== void 0 ? { signal: ctx.signal } : {}
+          ...ctx.signal !== void 0 ? { signal: ctx.signal } : {},
+          ...env !== void 0 ? { env } : {}
         });
       } catch (rawErr) {
         release();
@@ -392,6 +574,10 @@ function claudeCliAdapter(opts) {
       };
       const adapterResult = {
         model,
+        message: {
+          role: "assistant",
+          parts: text.length > 0 ? [{ kind: "text", text }] : []
+        },
         usage,
         warnings,
         ...text.length > 0 ? { text } : {},
@@ -451,21 +637,30 @@ var CONFIG_SCHEMAS = {
   "claude-sonnet-5": ClaudeSonnet5ConfigSchema,
   "claude-haiku-4-5-20251001": ClaudeHaiku45ConfigSchema
 };
+var CLAUDE_CLI_LIMITS = {
+  "claude-fable-5-1": { contextWindow: 1e6, maxOutputTokens: 64e3 },
+  "claude-opus-5-5": { contextWindow: 1e6, maxOutputTokens: 128e3 },
+  "claude-sonnet-5": { contextWindow: 1e6, maxOutputTokens: 128e3 },
+  "claude-haiku-4-5-20251001": { contextWindow: 2e5, maxOutputTokens: 32e3 }
+};
 var claudeCliModelDescriptors = CLAUDE_CLI_MODEL_IDS.map(
   (id) => {
     const configSchema = CONFIG_SCHEMAS[id];
     return {
       model: id,
       provider: "claude-cli",
+      limits: CLAUDE_CLI_LIMITS[id],
       capabilities: {
+        // The CLI runs text-only: the adapter rejects every non-text part.
+        inputMimeTypes: [],
         structuredOutput: true,
         nativeStructuredOutput: true,
         ...id !== "claude-haiku-4-5-20251001" ? { reasoningApi: "level" } : {},
         admittedReasoningEfforts: id === "claude-haiku-4-5-20251001" ? [] : CLAUDE_CLI_EFFORTS,
-        sampling: "fixed",
-        vision: false
+        sampling: "fixed"
       },
       configSchema,
+      configKeys: toConfigKeys(configSchema),
       configJsonSchema: toConfigJsonSchema(configSchema),
       validateConfig: zodToStandardSchema(configSchema)
     };