@zonease/happy 0.6.38 → 0.6.40

package/dist/auth-DxJ3VvrX.mjs

@@ -0,0 +1,270 @@
+import { g as encodeBase64, c as configuration, l as logger, r as readCredentials, u as updateSettings, i as isDebug, s as encodeBase64Url, f as decodeBase64, t as writeCredentialsLegacy, w as writeCredentialsDataKey } from './persistence-DKfF81pd.mjs';
+import { randomBytes, randomUUID } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import axios from 'axios';
+import qrcode from 'qrcode-terminal';
+import { d as delay } from './time-DgsBLJA_.mjs';
+import { o as openBrowser } from './browser-AoVGRX7y.mjs';
+import React, { useState } from 'react';
+import { useInput, Box, Text, render } from 'ink';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'chalk';
+import 'fs';
+import 'open';
+
+function displayQRCode(url) {
+  console.log("=".repeat(80));
+  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
+  console.log("=".repeat(80));
+  qrcode.generate(url, { small: true }, (qr) => {
+    for (let l of qr.split("\n")) {
+      console.log(" ".repeat(10) + l);
+    }
+  });
+  console.log("=".repeat(80));
+}
+
+function generateWebAuthUrl(publicKey) {
+  const publicKeyBase64 = encodeBase64(publicKey, "base64url");
+  return `${configuration.webappUrl}/terminal/connect#key=${publicKeyBase64}`;
+}
+
+const AuthSelector = ({ onSelect, onCancel }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const options = [
+    {
+      method: "mobile",
+      label: "Mobile App"
+    },
+    {
+      method: "web",
+      label: "Web Browser"
+    }
+  ];
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(options.length - 1, prev + 1));
+    } else if (key.return) {
+      onSelect(options[selectedIndex].method);
+    } else if (key.escape || key.ctrl && input === "c") {
+      onCancel();
+    } else if (input === "1") {
+      setSelectedIndex(0);
+      onSelect("mobile");
+    } else if (input === "2") {
+      setSelectedIndex(1);
+      onSelect("web");
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingY: 1 }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "How would you like to authenticate?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
+    const isSelected = selectedIndex === index;
+    return /* @__PURE__ */ React.createElement(Box, { key: option.method, marginY: 0 }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "cyan" : "gray" }, isSelected ? "\u203A " : "  ", index + 1, ". ", option.label));
+  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Use arrows or 1-2 to select, Enter to confirm")));
+};
+
+async function doAuth() {
+  console.clear();
+  const authMethod = await selectAuthenticationMethod();
+  if (!authMethod) {
+    console.log("\nAuthentication cancelled.\n");
+    process.exit(0);
+  }
+  const secret = new Uint8Array(randomBytes(32));
+  const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
+  try {
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Sending auth request to: ${configuration.serverUrl}/v1/auth/request`);
+      console.log(`[AUTH DEBUG] Public key: ${encodeBase64(keypair.publicKey).substring(0, 20)}...`);
+    }
+    await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
+      publicKey: encodeBase64(keypair.publicKey),
+      supportsV2: true
+    });
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Auth request sent successfully`);
+    }
+  } catch (error) {
+    if (isDebug()) {
+      console.log(`[AUTH DEBUG] Failed to send auth request:`, error);
+    }
+    console.log("Failed to create authentication request, please try again later.");
+    return null;
+  }
+  if (authMethod === "mobile") {
+    return await doMobileAuth(keypair);
+  } else {
+    return await doWebAuth(keypair);
+  }
+}
+function selectAuthenticationMethod() {
+  return new Promise((resolve) => {
+    let hasResolved = false;
+    const onSelect = (method) => {
+      if (!hasResolved) {
+        hasResolved = true;
+        app.unmount();
+        resolve(method);
+      }
+    };
+    const onCancel = () => {
+      if (!hasResolved) {
+        hasResolved = true;
+        app.unmount();
+        resolve(null);
+      }
+    };
+    const app = render(React.createElement(AuthSelector, { onSelect, onCancel }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  });
+}
+async function doMobileAuth(keypair) {
+  console.clear();
+  console.log("\nMobile Authentication\n");
+  console.log("Scan this QR code with your Happy mobile app:\n");
+  const authUrl = "happy://terminal?" + encodeBase64Url(keypair.publicKey);
+  displayQRCode(authUrl);
+  console.log("\nOr manually enter this URL:");
+  console.log(authUrl);
+  console.log("");
+  return await waitForAuthentication(keypair);
+}
+async function doWebAuth(keypair) {
+  console.clear();
+  console.log("\nWeb Authentication\n");
+  const webUrl = generateWebAuthUrl(keypair.publicKey);
+  console.log("Opening your browser...");
+  const browserOpened = await openBrowser(webUrl);
+  if (browserOpened) {
+    console.log("\u2713 Browser opened\n");
+    console.log("Complete authentication in your browser window.");
+  } else {
+    console.log("Could not open browser automatically.");
+  }
+  console.log("\nIf the browser did not open, please copy and paste this URL:");
+  console.log(webUrl);
+  console.log("");
+  return await waitForAuthentication(keypair);
+}
+async function waitForAuthentication(keypair) {
+  process.stdout.write("Waiting for authentication");
+  let dots = 0;
+  let cancelled = false;
+  const handleInterrupt = () => {
+    cancelled = true;
+    console.log("\n\nAuthentication cancelled.");
+    process.exit(0);
+  };
+  process.on("SIGINT", handleInterrupt);
+  try {
+    while (!cancelled) {
+      try {
+        const response = await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
+          publicKey: encodeBase64(keypair.publicKey),
+          supportsV2: true
+        });
+        if (response.data.state === "authorized") {
+          let token = response.data.token;
+          let r = decodeBase64(response.data.response);
+          let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
+          if (decrypted) {
+            if (decrypted.length === 32) {
+              const credentials = {
+                secret: decrypted,
+                token
+              };
+              await writeCredentialsLegacy(credentials);
+              console.log("\n\n\u2713 Authentication successful\n");
+              return {
+                encryption: {
+                  type: "legacy",
+                  secret: decrypted
+                },
+                token
+              };
+            } else {
+              if (decrypted[0] === 0) {
+                const credentials = {
+                  publicKey: decrypted.slice(1, 33),
+                  machineKey: randomBytes(32),
+                  token
+                };
+                await writeCredentialsDataKey(credentials);
+                console.log("\n\n\u2713 Authentication successful\n");
+                return {
+                  encryption: {
+                    type: "dataKey",
+                    publicKey: credentials.publicKey,
+                    machineKey: credentials.machineKey
+                  },
+                  token
+                };
+              } else {
+                console.log("\n\nFailed to decrypt response. Please try again.");
+                return null;
+              }
+            }
+          } else {
+            console.log("\n\nFailed to decrypt response. Please try again.");
+            return null;
+          }
+        }
+      } catch (error) {
+        console.log("\n\nFailed to check authentication status. Please try again.");
+        return null;
+      }
+      process.stdout.write("\rWaiting for authentication" + ".".repeat(dots % 3 + 1) + "   ");
+      dots++;
+      await delay(1e3);
+    }
+  } finally {
+    process.off("SIGINT", handleInterrupt);
+  }
+  return null;
+}
+function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
+  const ephemeralPublicKey = encryptedBundle.slice(0, 32);
+  const nonce = encryptedBundle.slice(32, 32 + tweetnacl.box.nonceLength);
+  const encrypted = encryptedBundle.slice(32 + tweetnacl.box.nonceLength);
+  const decrypted = tweetnacl.box.open(encrypted, nonce, ephemeralPublicKey, recipientSecretKey);
+  if (!decrypted) {
+    return null;
+  }
+  return decrypted;
+}
+async function authAndSetupMachineIfNeeded() {
+  logger.debug("[AUTH] Starting auth and machine setup...");
+  let credentials = await readCredentials();
+  let newAuth = false;
+  if (!credentials) {
+    logger.debug("[AUTH] No credentials found, starting authentication flow...");
+    const authResult = await doAuth();
+    if (!authResult) {
+      throw new Error("Authentication failed or was cancelled");
+    }
+    credentials = authResult;
+    newAuth = true;
+  } else {
+    logger.debug("[AUTH] Using existing credentials");
+  }
+  const settings = await updateSettings(async (s) => {
+    if (newAuth || !s.machineId) {
+      return {
+        ...s,
+        machineId: randomUUID()
+      };
+    }
+    return s;
+  });
+  logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
+  return { credentials, machineId: settings.machineId };
+}
+
+export { authAndSetupMachineIfNeeded, decryptWithEphemeralKey, doAuth };

package/dist/browser-AoVGRX7y.mjs

@@ -0,0 +1,20 @@
+import open from 'open';
+import { l as logger } from './persistence-DKfF81pd.mjs';
+
+async function openBrowser(url) {
+  try {
+    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
+      logger.debug("[browser] Headless environment detected, skipping browser open");
+      return false;
+    }
+    logger.debug(`[browser] Attempting to open URL: ${url}`);
+    await open(url);
+    logger.debug("[browser] Browser opened successfully");
+    return true;
+  } catch (error) {
+    logger.debug("[browser] Failed to open browser:", error);
+    return false;
+  }
+}
+
+export { openBrowser as o };

package/dist/browser-DzgO4oaD.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var open = require('open');
+var logger = require('./persistence-CBTtC_dm.cjs');
+
+async function openBrowser(url) {
+  try {
+    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
+      logger.logger.debug("[browser] Headless environment detected, skipping browser open");
+      return false;
+    }
+    logger.logger.debug(`[browser] Attempting to open URL: ${url}`);
+    await open(url);
+    logger.logger.debug("[browser] Browser opened successfully");
+    return true;
+  } catch (error) {
+    logger.logger.debug("[browser] Failed to open browser:", error);
+    return false;
+  }
+}
+
+exports.openBrowser = openBrowser;

package/dist/claudeLocal-C6BdzhDx.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-CBTtC_dm.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;