very-happy-cli 0.2.158 → 0.2.160

package/dist/claudeLocal-BaY4fZKi.mjs

@@ -0,0 +1,339 @@
+import { spawn } from 'cross-spawn';
+import { createInterface } from 'node:readline';
+import { readdirSync, statSync, mkdirSync, existsSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { p as pinSmallFastModel, e as ensureLocalProxyBypass } from './smallFastModel-BLNgMrwR.mjs';
+import { join } from 'node:path';
+import { g as getProjectPath } from './path-D2wdaNSk.mjs';
+import { c as claudeCheckSession, s as systemPrompt } from './systemPrompt-DX521JJz.mjs';
+import { i as initializeSandbox, a as wrapCommand } from './manager-BQ4flvQZ.mjs';
+import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
+import { claudeCliPath } from './claudeCliPath-BqkaH2oR.mjs';
+import 'chalk';
+import 'node:util';
+import './configuration-RfeNjFmd.mjs';
+import 'node:os';
+import './package-BhaKlnxz.mjs';
+import 'node:fs/promises';
+import './index-qdS1friN.mjs';
+import 'zod';
+import '@paralleldrive/cuid2';
+import './trimIdent-BAjmv_TG.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
+import '@anthropic-ai/sandbox-runtime';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+
+function claudeFindLastSession(workingDirectory) {
+  try {
+    const projectDir = getProjectPath(workingDirectory);
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const files = readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const sessionId = f.replace(".jsonl", "");
+      if (!uuidPattern.test(sessionId)) {
+        return null;
+      }
+      if (claudeCheckSession(sessionId, workingDirectory)) {
+        return {
+          name: f,
+          sessionId,
+          mtime: statSync(join(projectDir, f)).mtime.getTime()
+        };
+      }
+      return null;
+    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+    return files.length > 0 ? files[0].sessionId : null;
+  } catch (e) {
+    logger.debug("[claudeFindLastSession] Error finding sessions:", e);
+    return null;
+  }
+}
+
+class ExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code: ${exitCode}`);
+    this.name = "ExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+function quoteShellArg(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function claudeLocal(opts) {
+  const projectDir = getProjectPath(opts.path);
+  mkdirSync(projectDir, { recursive: true });
+  const hasContinueFlag = opts.claudeArgs?.includes("--continue");
+  const hasResumeFlag = opts.claudeArgs?.includes("--resume");
+  const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
+  let startFrom = opts.sessionId;
+  const extractFlag = (flags, withValue = false) => {
+    if (!opts.claudeArgs) return { found: false };
+    for (const flag of flags) {
+      const index = opts.claudeArgs.indexOf(flag);
+      if (index !== -1) {
+        if (withValue && index + 1 < opts.claudeArgs.length) {
+          const nextArg = opts.claudeArgs[index + 1];
+          if (!nextArg.startsWith("-")) {
+            const value = nextArg;
+            opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index && i !== index + 1);
+            return { found: true, value };
+          }
+        }
+        if (!withValue) {
+          opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index);
+          return { found: true };
+        }
+        return { found: false };
+      }
+    }
+    return { found: false };
+  };
+  const sessionIdFlag = extractFlag(["--session-id"], true);
+  if (sessionIdFlag.found && sessionIdFlag.value) {
+    startFrom = null;
+    logger.debug(`[ClaudeLocal] Using explicit --session-id: ${sessionIdFlag.value}`);
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const resumeFlag = extractFlag(["--resume", "-r"], true);
+    if (resumeFlag.found) {
+      if (resumeFlag.value) {
+        startFrom = resumeFlag.value;
+        logger.debug(`[ClaudeLocal] Using provided session ID from --resume: ${startFrom}`);
+      } else {
+        const lastSession = claudeFindLastSession(opts.path);
+        if (lastSession) {
+          startFrom = lastSession;
+          logger.debug(`[ClaudeLocal] --resume: Found last session: ${lastSession}`);
+        }
+      }
+    }
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const continueFlag = extractFlag(["--continue", "-c"], false);
+    if (continueFlag.found) {
+      const lastSession = claudeFindLastSession(opts.path);
+      if (lastSession) {
+        startFrom = lastSession;
+        logger.debug(`[ClaudeLocal] --continue: Found last session: ${lastSession}`);
+      }
+    }
+  }
+  const explicitSessionId = sessionIdFlag.value || null;
+  let newSessionId = null;
+  let effectiveSessionId = startFrom;
+  if (!opts.hookSettingsPath) {
+    newSessionId = startFrom ? null : explicitSessionId || randomUUID();
+    effectiveSessionId = startFrom || newSessionId;
+    if (startFrom) {
+      logger.debug(`[ClaudeLocal] Resuming session: ${startFrom}`);
+      opts.onSessionFound(startFrom);
+    } else if (explicitSessionId) {
+      logger.debug(`[ClaudeLocal] Using explicit session ID: ${explicitSessionId}`);
+      opts.onSessionFound(explicitSessionId);
+    } else {
+      logger.debug(`[ClaudeLocal] Generated new session ID: ${newSessionId}`);
+      opts.onSessionFound(newSessionId);
+    }
+  } else {
+    if (startFrom) {
+      logger.debug(`[ClaudeLocal] Will resume existing session: ${startFrom}`);
+    } else if (hasUserSessionControl) {
+      logger.debug(`[ClaudeLocal] User passed ${hasContinueFlag ? "--continue" : "--resume"} flag, session ID will be determined by hook`);
+    } else {
+      logger.debug(`[ClaudeLocal] Fresh start, session ID will be provided by hook`);
+    }
+  }
+  let thinking = false;
+  let stopThinkingTimeout = null;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  try {
+    process.stdin.pause();
+    const stdinHandle = process.stdin._handle;
+    if (stdinHandle && typeof stdinHandle.setBlocking === "function") {
+      try {
+        stdinHandle.setBlocking(true);
+        logger.debug("[ClaudeLocal] forced stdin to blocking mode before spawn");
+      } catch (err) {
+        logger.debug("[ClaudeLocal] setBlocking(true) failed: " + String(err));
+      }
+    }
+    await new Promise((r, reject) => {
+      const args = [];
+      if (!opts.hookSettingsPath) {
+        const hasResumeFlag2 = opts.claudeArgs?.includes("--resume") || opts.claudeArgs?.includes("-r");
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        } else if (!hasResumeFlag2 && newSessionId) {
+          args.push("--session-id", newSessionId);
+        }
+      } else {
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        }
+      }
+      args.push("--append-system-prompt", systemPrompt);
+      if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        args.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }));
+      }
+      if (opts.allowedTools && opts.allowedTools.length > 0) {
+        args.push("--allowedTools", opts.allowedTools.join(","));
+      }
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      if (opts.hookSettingsPath) {
+        args.push("--settings", opts.hookSettingsPath);
+        logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
+      }
+      if (!claudeCliPath || !existsSync(claudeCliPath)) {
+        throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
+      }
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
+      pinSmallFastModel(env);
+      if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        ensureLocalProxyBypass(env);
+      }
+      logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
+      (async () => {
+        let cleanupSandbox = null;
+        let spawnCommand = null;
+        let spawnArgs = [claudeCliPath, ...args];
+        let spawnWithShell = false;
+        if (opts.sandboxConfig?.enabled) {
+          if (process.platform === "win32") {
+            logger.warn("[ClaudeLocal] Sandbox is not supported on Windows; continuing without sandbox.");
+          } else {
+            try {
+              cleanupSandbox = await initializeSandbox(opts.sandboxConfig, opts.path);
+              if (!spawnArgs.includes("--dangerously-skip-permissions")) {
+                spawnArgs = [...spawnArgs, "--dangerously-skip-permissions"];
+              }
+              const fullCommand = [
+                "node",
+                ...spawnArgs.map((arg) => quoteShellArg(arg))
+              ].join(" ");
+              spawnCommand = await wrapCommand(fullCommand);
+              spawnWithShell = true;
+              logger.info(
+                `[ClaudeLocal] Sandbox enabled: workspace=${opts.sandboxConfig.workspaceRoot ?? opts.path}, network=${opts.sandboxConfig.networkMode}`
+              );
+            } catch (error) {
+              logger.warn("[ClaudeLocal] Failed to initialize sandbox; continuing without sandbox.", error);
+              cleanupSandbox = null;
+              spawnCommand = null;
+              spawnWithShell = false;
+              spawnArgs = [claudeCliPath, ...args];
+            }
+          }
+        }
+        const child = spawn(
+          spawnWithShell && spawnCommand ? spawnCommand : "node",
+          spawnWithShell ? [] : spawnArgs,
+          {
+            stdio: ["inherit", "inherit", "inherit", "pipe"],
+            signal: opts.abort,
+            cwd: opts.path,
+            env,
+            shell: spawnWithShell,
+            windowsHide: true
+          }
+        );
+        if (child.stdio[3]) {
+          const rl = createInterface({
+            input: child.stdio[3],
+            crlfDelay: Infinity
+          });
+          const activeFetches = /* @__PURE__ */ new Map();
+          rl.on("line", (line) => {
+            try {
+              const message = JSON.parse(line);
+              switch (message.type) {
+                case "fetch-start":
+                  activeFetches.set(message.id, {
+                    hostname: message.hostname,
+                    path: message.path,
+                    startTime: message.timestamp
+                  });
+                  if (stopThinkingTimeout) {
+                    clearTimeout(stopThinkingTimeout);
+                    stopThinkingTimeout = null;
+                  }
+                  updateThinking(true);
+                  break;
+                case "fetch-end":
+                  activeFetches.delete(message.id);
+                  if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                    stopThinkingTimeout = setTimeout(() => {
+                      if (activeFetches.size === 0) {
+                        updateThinking(false);
+                      }
+                      stopThinkingTimeout = null;
+                    }, 500);
+                  }
+                  break;
+                default:
+                  logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
+              }
+            } catch (e) {
+              logger.debug("[ClaudeLocal] Non-JSON line from fd3:", contentLogMetadata(line));
+            }
+          });
+          rl.on("error", (err) => {
+            console.error("Error reading from fd 3:", err);
+          });
+          child.on("exit", () => {
+            if (stopThinkingTimeout) {
+              clearTimeout(stopThinkingTimeout);
+            }
+            updateThinking(false);
+          });
+        }
+        child.on("error", (error) => {
+        });
+        child.on("exit", async (code, signal) => {
+          if (cleanupSandbox) {
+            try {
+              await cleanupSandbox();
+            } catch (error) {
+              logger.warn("[ClaudeLocal] Failed to reset sandbox after session exit.", error);
+            }
+          }
+          if (signal === "SIGTERM" && opts.abort.aborted) {
+            r();
+          } else if (signal) {
+            reject(new Error(`Process terminated with signal: ${signal}`));
+          } else if (code !== 0 && code !== null) {
+            reject(new ExitCodeError(code));
+          } else {
+            r();
+          }
+        });
+      })().catch(reject);
+    });
+  } finally {
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
+    }
+    updateThinking(false);
+  }
+  return effectiveSessionId;
+}
+
+export { ExitCodeError, claudeCliPath, claudeLocal };

package/dist/claudeLocal-CRGG4Pea.cjs

@@ -0,0 +1,343 @@
+'use strict';
+
+var spawn = require('cross-spawn');
+var node_readline = require('node:readline');
+var node_fs = require('node:fs');
+var node_crypto = require('node:crypto');
+var logger = require('./logger-CS0mw3fa.cjs');
+var smallFastModel = require('./smallFastModel-D_uxGMo3.cjs');
+var path$1 = require('node:path');
+var path = require('./path-B7zW-WwE.cjs');
+var systemPrompt = require('./systemPrompt-BwTPWfMu.cjs');
+var manager = require('./manager-Cly8xVIR.cjs');
+var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
+var claudeCliPath = require('./claudeCliPath-U4HHmV4r.cjs');
+require('chalk');
+require('node:util');
+require('./configuration-BSYpcPwE.cjs');
+require('node:os');
+require('./package-BwMrPwqH.cjs');
+require('node:fs/promises');
+require('./index-DA7yINuk.cjs');
+require('zod');
+require('@paralleldrive/cuid2');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('./agentGuidance-B5NATuFa.cjs');
+require('@anthropic-ai/sandbox-runtime');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('url');
+
+function claudeFindLastSession(workingDirectory) {
+  try {
+    const projectDir = path.getProjectPath(workingDirectory);
+    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const files = node_fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
+      const sessionId = f.replace(".jsonl", "");
+      if (!uuidPattern.test(sessionId)) {
+        return null;
+      }
+      if (systemPrompt.claudeCheckSession(sessionId, workingDirectory)) {
+        return {
+          name: f,
+          sessionId,
+          mtime: node_fs.statSync(path$1.join(projectDir, f)).mtime.getTime()
+        };
+      }
+      return null;
+    }).filter((f) => f !== null).sort((a, b) => b.mtime - a.mtime);
+    return files.length > 0 ? files[0].sessionId : null;
+  } catch (e) {
+    logger.logger.debug("[claudeFindLastSession] Error finding sessions:", e);
+    return null;
+  }
+}
+
+class ExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code: ${exitCode}`);
+    this.name = "ExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+function quoteShellArg(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function claudeLocal(opts) {
+  const projectDir = path.getProjectPath(opts.path);
+  node_fs.mkdirSync(projectDir, { recursive: true });
+  const hasContinueFlag = opts.claudeArgs?.includes("--continue");
+  const hasResumeFlag = opts.claudeArgs?.includes("--resume");
+  const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
+  let startFrom = opts.sessionId;
+  const extractFlag = (flags, withValue = false) => {
+    if (!opts.claudeArgs) return { found: false };
+    for (const flag of flags) {
+      const index = opts.claudeArgs.indexOf(flag);
+      if (index !== -1) {
+        if (withValue && index + 1 < opts.claudeArgs.length) {
+          const nextArg = opts.claudeArgs[index + 1];
+          if (!nextArg.startsWith("-")) {
+            const value = nextArg;
+            opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index && i !== index + 1);
+            return { found: true, value };
+          }
+        }
+        if (!withValue) {
+          opts.claudeArgs = opts.claudeArgs.filter((_, i) => i !== index);
+          return { found: true };
+        }
+        return { found: false };
+      }
+    }
+    return { found: false };
+  };
+  const sessionIdFlag = extractFlag(["--session-id"], true);
+  if (sessionIdFlag.found && sessionIdFlag.value) {
+    startFrom = null;
+    logger.logger.debug(`[ClaudeLocal] Using explicit --session-id: ${sessionIdFlag.value}`);
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const resumeFlag = extractFlag(["--resume", "-r"], true);
+    if (resumeFlag.found) {
+      if (resumeFlag.value) {
+        startFrom = resumeFlag.value;
+        logger.logger.debug(`[ClaudeLocal] Using provided session ID from --resume: ${startFrom}`);
+      } else {
+        const lastSession = claudeFindLastSession(opts.path);
+        if (lastSession) {
+          startFrom = lastSession;
+          logger.logger.debug(`[ClaudeLocal] --resume: Found last session: ${lastSession}`);
+        }
+      }
+    }
+  }
+  if (!startFrom && !sessionIdFlag.value) {
+    const continueFlag = extractFlag(["--continue", "-c"], false);
+    if (continueFlag.found) {
+      const lastSession = claudeFindLastSession(opts.path);
+      if (lastSession) {
+        startFrom = lastSession;
+        logger.logger.debug(`[ClaudeLocal] --continue: Found last session: ${lastSession}`);
+      }
+    }
+  }
+  const explicitSessionId = sessionIdFlag.value || null;
+  let newSessionId = null;
+  let effectiveSessionId = startFrom;
+  if (!opts.hookSettingsPath) {
+    newSessionId = startFrom ? null : explicitSessionId || node_crypto.randomUUID();
+    effectiveSessionId = startFrom || newSessionId;
+    if (startFrom) {
+      logger.logger.debug(`[ClaudeLocal] Resuming session: ${startFrom}`);
+      opts.onSessionFound(startFrom);
+    } else if (explicitSessionId) {
+      logger.logger.debug(`[ClaudeLocal] Using explicit session ID: ${explicitSessionId}`);
+      opts.onSessionFound(explicitSessionId);
+    } else {
+      logger.logger.debug(`[ClaudeLocal] Generated new session ID: ${newSessionId}`);
+      opts.onSessionFound(newSessionId);
+    }
+  } else {
+    if (startFrom) {
+      logger.logger.debug(`[ClaudeLocal] Will resume existing session: ${startFrom}`);
+    } else if (hasUserSessionControl) {
+      logger.logger.debug(`[ClaudeLocal] User passed ${hasContinueFlag ? "--continue" : "--resume"} flag, session ID will be determined by hook`);
+    } else {
+      logger.logger.debug(`[ClaudeLocal] Fresh start, session ID will be provided by hook`);
+    }
+  }
+  let thinking = false;
+  let stopThinkingTimeout = null;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      logger.logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  try {
+    process.stdin.pause();
+    const stdinHandle = process.stdin._handle;
+    if (stdinHandle && typeof stdinHandle.setBlocking === "function") {
+      try {
+        stdinHandle.setBlocking(true);
+        logger.logger.debug("[ClaudeLocal] forced stdin to blocking mode before spawn");
+      } catch (err) {
+        logger.logger.debug("[ClaudeLocal] setBlocking(true) failed: " + String(err));
+      }
+    }
+    await new Promise((r, reject) => {
+      const args = [];
+      if (!opts.hookSettingsPath) {
+        const hasResumeFlag2 = opts.claudeArgs?.includes("--resume") || opts.claudeArgs?.includes("-r");
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        } else if (!hasResumeFlag2 && newSessionId) {
+          args.push("--session-id", newSessionId);
+        }
+      } else {
+        if (startFrom) {
+          args.push("--resume", startFrom);
+        }
+      }
+      args.push("--append-system-prompt", systemPrompt.systemPrompt);
+      if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        args.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }));
+      }
+      if (opts.allowedTools && opts.allowedTools.length > 0) {
+        args.push("--allowedTools", opts.allowedTools.join(","));
+      }
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      if (opts.hookSettingsPath) {
+        args.push("--settings", opts.hookSettingsPath);
+        logger.logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
+      }
+      if (!claudeCliPath.claudeCliPath || !node_fs.existsSync(claudeCliPath.claudeCliPath)) {
+        throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
+      }
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
+      smallFastModel.pinSmallFastModel(env);
+      if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        smallFastModel.ensureLocalProxyBypass(env);
+      }
+      logger.logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath.claudeCliPath}`);
+      logger.logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
+      (async () => {
+        let cleanupSandbox = null;
+        let spawnCommand = null;
+        let spawnArgs = [claudeCliPath.claudeCliPath, ...args];
+        let spawnWithShell = false;
+        if (opts.sandboxConfig?.enabled) {
+          if (process.platform === "win32") {
+            logger.logger.warn("[ClaudeLocal] Sandbox is not supported on Windows; continuing without sandbox.");
+          } else {
+            try {
+              cleanupSandbox = await manager.initializeSandbox(opts.sandboxConfig, opts.path);
+              if (!spawnArgs.includes("--dangerously-skip-permissions")) {
+                spawnArgs = [...spawnArgs, "--dangerously-skip-permissions"];
+              }
+              const fullCommand = [
+                "node",
+                ...spawnArgs.map((arg) => quoteShellArg(arg))
+              ].join(" ");
+              spawnCommand = await manager.wrapCommand(fullCommand);
+              spawnWithShell = true;
+              logger.logger.info(
+                `[ClaudeLocal] Sandbox enabled: workspace=${opts.sandboxConfig.workspaceRoot ?? opts.path}, network=${opts.sandboxConfig.networkMode}`
+              );
+            } catch (error) {
+              logger.logger.warn("[ClaudeLocal] Failed to initialize sandbox; continuing without sandbox.", error);
+              cleanupSandbox = null;
+              spawnCommand = null;
+              spawnWithShell = false;
+              spawnArgs = [claudeCliPath.claudeCliPath, ...args];
+            }
+          }
+        }
+        const child = spawn.spawn(
+          spawnWithShell && spawnCommand ? spawnCommand : "node",
+          spawnWithShell ? [] : spawnArgs,
+          {
+            stdio: ["inherit", "inherit", "inherit", "pipe"],
+            signal: opts.abort,
+            cwd: opts.path,
+            env,
+            shell: spawnWithShell,
+            windowsHide: true
+          }
+        );
+        if (child.stdio[3]) {
+          const rl = node_readline.createInterface({
+            input: child.stdio[3],
+            crlfDelay: Infinity
+          });
+          const activeFetches = /* @__PURE__ */ new Map();
+          rl.on("line", (line) => {
+            try {
+              const message = JSON.parse(line);
+              switch (message.type) {
+                case "fetch-start":
+                  activeFetches.set(message.id, {
+                    hostname: message.hostname,
+                    path: message.path,
+                    startTime: message.timestamp
+                  });
+                  if (stopThinkingTimeout) {
+                    clearTimeout(stopThinkingTimeout);
+                    stopThinkingTimeout = null;
+                  }
+                  updateThinking(true);
+                  break;
+                case "fetch-end":
+                  activeFetches.delete(message.id);
+                  if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                    stopThinkingTimeout = setTimeout(() => {
+                      if (activeFetches.size === 0) {
+                        updateThinking(false);
+                      }
+                      stopThinkingTimeout = null;
+                    }, 500);
+                  }
+                  break;
+                default:
+                  logger.logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
+              }
+            } catch (e) {
+              logger.logger.debug("[ClaudeLocal] Non-JSON line from fd3:", contentLogMetadata.contentLogMetadata(line));
+            }
+          });
+          rl.on("error", (err) => {
+            console.error("Error reading from fd 3:", err);
+          });
+          child.on("exit", () => {
+            if (stopThinkingTimeout) {
+              clearTimeout(stopThinkingTimeout);
+            }
+            updateThinking(false);
+          });
+        }
+        child.on("error", (error) => {
+        });
+        child.on("exit", async (code, signal) => {
+          if (cleanupSandbox) {
+            try {
+              await cleanupSandbox();
+            } catch (error) {
+              logger.logger.warn("[ClaudeLocal] Failed to reset sandbox after session exit.", error);
+            }
+          }
+          if (signal === "SIGTERM" && opts.abort.aborted) {
+            r();
+          } else if (signal) {
+            reject(new Error(`Process terminated with signal: ${signal}`));
+          } else if (code !== 0 && code !== null) {
+            reject(new ExitCodeError(code));
+          } else {
+            r();
+          }
+        });
+      })().catch(reject);
+    });
+  } finally {
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
+    }
+    updateThinking(false);
+  }
+  return effectiveSessionId;
+}
+
+exports.claudeCliPath = claudeCliPath.claudeCliPath;
+exports.ExitCodeError = ExitCodeError;
+exports.claudeLocal = claudeLocal;