@zonease/happy 0.6.37 → 0.6.39

package/dist/claudeLocal-CPT3zcIU.mjs

@@ -0,0 +1,344 @@
+import { spawn } from 'node:child_process';
+import { resolve, join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { l as logger } from './persistence-BFjvtUad.mjs';
+import { homedir } from 'node:os';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { g as getBaseSystemPrompt } from './prompt-BsAZsPbo.mjs';
+
+function getProjectPath(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "projects", projectId);
+}
+
+function claudeCheckSession(sessionId, path) {
+  const projectDir = getProjectPath(path);
+  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
+  }
+  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v, index) => {
+    if (!v.trim()) return false;
+    try {
+      const parsed = JSON.parse(v);
+      return typeof parsed.uuid === "string" && parsed.uuid.length > 0 || // Claude Code 2.1.x
+      typeof parsed.messageId === "string" && parsed.messageId.length > 0 || // Older Claude Code
+      typeof parsed.leafUuid === "string" && parsed.leafUuid.length > 0;
+    } catch (e) {
+      logger.debug(`[claudeCheckSession] Malformed JSON at line ${index + 1}:`, e);
+      return false;
+    }
+  });
+  logger.debug(`[claudeCheckSession] Session ${sessionId}: ${hasGoodMessage ? "valid" : "invalid"}`);
+  return hasGoodMessage;
+}
+
+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;
+  }
+}
+
+const DEFAULT_COMMIT_ATTRIBUTION = [
+  "Generated with [Claude Code](https://claude.ai/code)",
+  "",
+  "Co-Authored-By: Claude <noreply@anthropic.com>"
+].join("\n");
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "settings.json");
+}
+function readClaudeSettings() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!existsSync(settingsPath)) {
+      logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.debug(`[ClaudeSettings] attribution: ${JSON.stringify(settings.attribution)}, includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
+    return null;
+  }
+}
+function getCommitAttribution() {
+  const settings = readClaudeSettings();
+  if (!settings) return null;
+  if (settings.attribution?.commit !== void 0) {
+    return settings.attribution.commit || null;
+  }
+  if (settings.includeCoAuthoredBy === true) {
+    return DEFAULT_COMMIT_ATTRIBUTION;
+  }
+  return null;
+}
+
+const systemPrompt = (() => {
+  const base = getBaseSystemPrompt();
+  if (base === null) return "";
+  const attribution = getCommitAttribution();
+  if (!attribution) return base;
+  return base + "\n\n# Commit\n\nWhen making commit messages, add this footer:\n\n" + attribution;
+})();
+
+class ExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code: ${exitCode}`);
+    this.name = "ExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launcher.cjs"));
+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();
+    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
+      };
+      logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
+      const child = spawn("node", [claudeCliPath, ...args], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path,
+        env
+      });
+      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: ${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", (code, signal) => {
+        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();
+        }
+      });
+    });
+  } finally {
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
+    }
+    updateThinking(false);
+  }
+  return effectiveSessionId;
+}
+
+var claudeLocal$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ExitCodeError: ExitCodeError,
+    claudeCliPath: claudeCliPath,
+    claudeLocal: claudeLocal
+});
+
+export { ExitCodeError as E, claudeLocal as a, claudeCheckSession as b, claudeCliPath as c, claudeLocal$1 as d, getProjectPath as g, systemPrompt as s };

package/dist/claudeLocal-WkgLbl1a.cjs

@@ -0,0 +1,352 @@
+'use strict';
+
+var node_child_process = require('node:child_process');
+var path = require('node:path');
+var node_readline = require('node:readline');
+var fs = require('node:fs');
+var node_crypto = require('node:crypto');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var os = require('node:os');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var prompt = require('./prompt-BTWDZZO0.cjs');
+
+function getProjectPath(workingDirectory) {
+  const projectId = path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return path.join(claudeConfigDir, "projects", projectId);
+}
+
+function claudeCheckSession(sessionId, path$1) {
+  const projectDir = getProjectPath(path$1);
+  const sessionFile = path.join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = fs.existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
+  }
+  const sessionData = fs.readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v, index) => {
+    if (!v.trim()) return false;
+    try {
+      const parsed = JSON.parse(v);
+      return typeof parsed.uuid === "string" && parsed.uuid.length > 0 || // Claude Code 2.1.x
+      typeof parsed.messageId === "string" && parsed.messageId.length > 0 || // Older Claude Code
+      typeof parsed.leafUuid === "string" && parsed.leafUuid.length > 0;
+    } catch (e) {
+      logger.logger.debug(`[claudeCheckSession] Malformed JSON at line ${index + 1}:`, e);
+      return false;
+    }
+  });
+  logger.logger.debug(`[claudeCheckSession] Session ${sessionId}: ${hasGoodMessage ? "valid" : "invalid"}`);
+  return hasGoodMessage;
+}
+
+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 = fs.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: fs.statSync(path.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;
+  }
+}
+
+const DEFAULT_COMMIT_ATTRIBUTION = [
+  "Generated with [Claude Code](https://claude.ai/code)",
+  "",
+  "Co-Authored-By: Claude <noreply@anthropic.com>"
+].join("\n");
+function getClaudeSettingsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return path.join(claudeConfigDir, "settings.json");
+}
+function readClaudeSettings() {
+  try {
+    const settingsPath = getClaudeSettingsPath();
+    if (!fs.existsSync(settingsPath)) {
+      logger.logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
+      return null;
+    }
+    const settingsContent = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsContent);
+    logger.logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
+    logger.logger.debug(`[ClaudeSettings] attribution: ${JSON.stringify(settings.attribution)}, includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
+    return settings;
+  } catch (error) {
+    logger.logger.debug(`[ClaudeSettings] Error reading Claude settings: ${error}`);
+    return null;
+  }
+}
+function getCommitAttribution() {
+  const settings = readClaudeSettings();
+  if (!settings) return null;
+  if (settings.attribution?.commit !== void 0) {
+    return settings.attribution.commit || null;
+  }
+  if (settings.includeCoAuthoredBy === true) {
+    return DEFAULT_COMMIT_ATTRIBUTION;
+  }
+  return null;
+}
+
+const systemPrompt = (() => {
+  const base = prompt.getBaseSystemPrompt();
+  if (base === null) return "";
+  const attribution = getCommitAttribution();
+  if (!attribution) return base;
+  return base + "\n\n# Commit\n\nWhen making commit messages, add this footer:\n\n" + attribution;
+})();
+
+class ExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Process exited with code: ${exitCode}`);
+    this.name = "ExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+const claudeCliPath = path.resolve(path.join(projectPath.projectPath(), "scripts", "claude_local_launcher.cjs"));
+async function claudeLocal(opts) {
+  const projectDir = getProjectPath(opts.path);
+  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();
+    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.logger.debug(`[ClaudeLocal] Using hook settings: ${opts.hookSettingsPath}`);
+      }
+      if (!claudeCliPath || !fs.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
+      };
+      logger.logger.debug(`[ClaudeLocal] Spawning launcher: ${claudeCliPath}`);
+      logger.logger.debug(`[ClaudeLocal] Args: ${JSON.stringify(args)}`);
+      const child = node_child_process.spawn("node", [claudeCliPath, ...args], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path,
+        env
+      });
+      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: ${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", (code, signal) => {
+        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();
+        }
+      });
+    });
+  } finally {
+    process.stdin.resume();
+    if (stopThinkingTimeout) {
+      clearTimeout(stopThinkingTimeout);
+      stopThinkingTimeout = null;
+    }
+    updateThinking(false);
+  }
+  return effectiveSessionId;
+}
+
+var claudeLocal$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ExitCodeError: ExitCodeError,
+    claudeCliPath: claudeCliPath,
+    claudeLocal: claudeLocal
+});
+
+exports.ExitCodeError = ExitCodeError;
+exports.claudeCheckSession = claudeCheckSession;
+exports.claudeCliPath = claudeCliPath;
+exports.claudeLocal = claudeLocal;
+exports.claudeLocal$1 = claudeLocal$1;
+exports.getProjectPath = getProjectPath;
+exports.systemPrompt = systemPrompt;