@zhigang1992/happy-cli 0.12.12 → 0.12.13

package/dist/{index-B0AakJdd.mjs → index-Bzl-ixRP.mjs}

@@ -1,17 +1,17 @@
 import chalk from 'chalk';
 import os$1, { homedir } from 'node:os';
 import { randomUUID, randomBytes, createHmac } from 'node:crypto';
-import { l as logger, p as projectPath, j as backoff, k as delay, R as RawJSONLinesSchema, m as AsyncLock, c as configuration, n as readDaemonState, o as clearDaemonState, i as packageJson, r as readSettings, q as readCredentials, g as encodeBase64, u as updateSettings, s as encodeBase64Url, d as decodeBase64, w as writeCredentialsLegacy, t as writeCredentialsDataKey, v as acquireDaemonLock, x as writeDaemonState, A as ApiClient, y as releaseDaemonLock, z as authChallenge, B as clearCredentials, C as clearMachineId, D as getLatestDaemonLog } from './types-kB4CXGM6.mjs';
-import { spawn, exec as exec$1, execSync, execFileSync } from 'node:child_process';
+import { l as logger, p as projectPath, j as backoff, k as delay, R as RawJSONLinesSchema, m as AsyncLock, c as configuration, n as readDaemonState, o as clearDaemonState, i as packageJson, r as readSettings, q as readCredentials, g as encodeBase64, u as updateSettings, s as encodeBase64Url, d as decodeBase64, w as writeCredentialsLegacy, t as writeCredentialsDataKey, v as acquireDaemonLock, x as writeDaemonState, A as ApiClient, y as releaseDaemonLock, z as authChallenge, B as clearCredentials, C as clearMachineId, D as getLatestDaemonLog } from './types-C1SMg54t.mjs';
+import { spawn, execSync, exec as exec$1, execFileSync } from 'node:child_process';
 import { resolve, join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { existsSync, readFileSync, mkdirSync, watch, readdirSync, statSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, readdirSync, statSync, writeFileSync, unlinkSync, rmSync } from 'node:fs';
 import { exec, spawn as spawn$1, execSync as execSync$1 } from 'child_process';
 import { promisify } from 'util';
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1, chmodSync, unlinkSync as unlinkSync$1 } from 'fs';
 import { join as join$1, dirname, basename } from 'path';
 import { readFile } from 'node:fs/promises';
-import fs, { watch as watch$1, access } from 'fs/promises';
+import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { fileURLToPath } from 'node:url';
@@ -51,9 +51,15 @@ class Session {
   allowedTools;
   _onModeChange;
   initialPermissionMode;
+  /** Path to temporary settings file with SessionStart hook (required for session tracking) */
+  hookSettingsPath;
   sessionId;
   mode = "local";
   thinking = false;
+  /** Callbacks to be notified when session ID is found/changed */
+  sessionFoundCallbacks = [];
+  /** Keep alive interval reference for cleanup */
+  keepAliveInterval;
   constructor(opts) {
     this.path = opts.path;
     this.api = opts.api;
@@ -67,11 +73,20 @@ class Session {
     this.allowedTools = opts.allowedTools;
     this._onModeChange = opts.onModeChange;
     this.initialPermissionMode = opts.initialPermissionMode ?? "default";
+    this.hookSettingsPath = opts.hookSettingsPath;
     this.client.keepAlive(this.thinking, this.mode);
-    setInterval(() => {
+    this.keepAliveInterval = setInterval(() => {
       this.client.keepAlive(this.thinking, this.mode);
     }, 2e3);
   }
+  /**
+   * Cleanup resources (call when session is no longer needed)
+   */
+  cleanup = () => {
+    clearInterval(this.keepAliveInterval);
+    this.sessionFoundCallbacks = [];
+    logger.debug("[Session] Cleaned up resources");
+  };
   onThinkingChange = (thinking) => {
     this.thinking = thinking;
     this.client.keepAlive(thinking, this.mode);
@@ -81,6 +96,17 @@ class Session {
     this.client.keepAlive(this.thinking, mode);
     this._onModeChange(mode);
   };
+  /**
+   * Called when Claude session ID is discovered or changed.
+   *
+   * This is triggered by the SessionStart hook when:
+   * - Claude starts a new session (fresh start)
+   * - Claude resumes a session (--continue, --resume flags)
+   * - Claude forks a session (/compact, double-escape fork)
+   *
+   * Updates internal state, syncs to API metadata, and notifies
+   * all registered callbacks (e.g., SessionScanner) about the change.
+   */
   onSessionFound = (sessionId) => {
     this.sessionId = sessionId;
     this.client.updateMetadata((metadata) => ({
@@ -88,6 +114,24 @@ class Session {
       claudeSessionId: sessionId
     }));
     logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    for (const callback of this.sessionFoundCallbacks) {
+      callback(sessionId);
+    }
+  };
+  /**
+   * Register a callback to be notified when session ID is found/changed
+   */
+  addSessionFoundCallback = (callback) => {
+    this.sessionFoundCallbacks.push(callback);
+  };
+  /**
+   * Remove a session found callback
+   */
+  removeSessionFoundCallback = (callback) => {
+    const index = this.sessionFoundCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.sessionFoundCallbacks.splice(index, 1);
+    }
   };
   /**
    * Clear the current session ID (used by /clear command)
@@ -98,13 +142,18 @@ class Session {
   };
   /**
    * Consume one-time Claude flags from claudeArgs after Claude spawn
-   * Currently handles: --resume (with or without session ID)
+   * Handles: --resume (with or without session ID), --continue
    */
   consumeOneTimeFlags = () => {
     if (!this.claudeArgs) return;
     const filteredArgs = [];
     for (let i = 0; i < this.claudeArgs.length; i++) {
-      if (this.claudeArgs[i] === "--resume") {
+      const arg = this.claudeArgs[i];
+      if (arg === "--continue") {
+        logger.debug("[Session] Consumed --continue flag");
+        continue;
+      }
+      if (arg === "--resume") {
         if (i + 1 < this.claudeArgs.length) {
           const nextArg = this.claudeArgs[i + 1];
           if (!nextArg.startsWith("-") && nextArg.includes("-")) {
@@ -116,9 +165,9 @@ class Session {
         } else {
           logger.debug("[Session] Consumed --resume flag (no session ID)");
         }
-      } else {
-        filteredArgs.push(this.claudeArgs[i]);
+        continue;
       }
+      filteredArgs.push(arg);
     }
     this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : void 0;
     logger.debug(`[Session] Consumed one-time flags, remaining args:`, this.claudeArgs);
@@ -317,31 +366,20 @@ const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launc
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   mkdirSync(projectDir, { recursive: true });
-  const watcher = watch(projectDir);
-  let resolvedSessionId = null;
-  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
-  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
-  watcher.on("change", (event, filename) => {
-    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      logger.debug("change", event, filename);
-      const sessionId = filename.replace(".jsonl", "");
-      if (detectedIdsFileSystem.has(sessionId)) {
-        return;
-      }
-      detectedIdsFileSystem.add(sessionId);
-      if (resolvedSessionId) {
-        return;
-      }
-      if (detectedIdsRandomUUID.has(sessionId)) {
-        resolvedSessionId = sessionId;
-        opts.onSessionFound(sessionId);
-      }
-    }
-  });
+  const hasContinueFlag = opts.claudeArgs?.includes("--continue");
+  const hasResumeFlag = opts.claudeArgs?.includes("--resume");
+  const hasUserSessionControl = hasContinueFlag || hasResumeFlag;
   let startFrom = opts.sessionId;
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
     startFrom = null;
   }
+  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) => {
@@ -358,15 +396,10 @@ async function claudeLocal(opts) {
     if (Object.keys(direnvVars).length > 0) {
       logger.debug(`[ClaudeLocal] Loaded ${Object.keys(direnvVars).length} direnv environment variables`);
     }
-    const env = {
-      ...process.env,
-      ...direnvVars,
-      ...opts.claudeEnvVars
-    };
     process.stdin.pause();
     await new Promise((r, reject) => {
       const args = [];
-      if (startFrom) {
+      if (!hasUserSessionControl && startFrom) {
         args.push("--resume", startFrom);
       }
       args.push("--append-system-prompt", systemPrompt);
@@ -379,9 +412,18 @@ async function claudeLocal(opts) {
       if (opts.claudeArgs) {
         args.push(...opts.claudeArgs);
       }
+      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,
+        ...direnvVars,
+        ...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,
@@ -398,13 +440,6 @@ async function claudeLocal(opts) {
           try {
             const message = JSON.parse(line);
             switch (message.type) {
-              case "uuid":
-                detectedIdsRandomUUID.add(message.value);
-                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
-                  resolvedSessionId = message.value;
-                  opts.onSessionFound(message.value);
-                }
-                break;
               case "fetch-start":
                 activeFetches.set(message.id, {
                   hostname: message.hostname,
@@ -458,7 +493,6 @@ async function claudeLocal(opts) {
       });
     });
   } finally {
-    watcher.close();
     process.stdin.resume();
     if (stopThinkingTimeout) {
       clearTimeout(stopThinkingTimeout);
@@ -466,7 +500,7 @@ async function claudeLocal(opts) {
     }
     updateThinking(false);
   }
-  return resolvedSessionId;
+  return startFrom;
 }
 
 class Future {
@@ -562,7 +596,7 @@ function startFileWatcher(file, onFileChange) {
     while (true) {
       try {
         logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
-        const watcher = watch$1(file, { persistent: true, signal: abortController.signal });
+        const watcher = watch(file, { persistent: true, signal: abortController.signal });
         for await (const event of watcher) {
           if (abortController.signal.aborted) {
             return;
@@ -720,6 +754,10 @@ async function claudeLocalLauncher(session) {
       }
     }
   });
+  const scannerSessionCallback = (sessionId) => {
+    scanner.onNewSession(sessionId);
+  };
+  session.addSessionFoundCallback(scannerSessionCallback);
   let exitReason = null;
   const processAbortController = new AbortController();
   let exutFuture = new Future();
@@ -772,7 +810,8 @@ async function claudeLocalLauncher(session) {
           claudeEnvVars: session.claudeEnvVars,
           claudeArgs: session.claudeArgs,
           mcpServers: session.mcpServers,
-          allowedTools: session.allowedTools
+          allowedTools: session.allowedTools,
+          hookSettingsPath: session.hookSettingsPath
         });
         session.consumeOneTimeFlags();
         if (!exitReason) {
@@ -803,6 +842,7 @@ async function claudeLocalLauncher(session) {
     session.client.rpcHandlerManager.registerHandler("switch", async () => {
     });
     session.queue.setOnMessage(null);
+    session.removeSessionFoundCallback(scannerSessionCallback);
     await scanner.cleanup();
   }
   return exitReason || "exit";
@@ -822,6 +862,39 @@ class MessageBuffer {
     this.messages.push(message);
     this.notifyListeners();
   }
+  /**
+   * Update the last message of a specific type by appending content to it
+   * Useful for streaming responses where deltas should accumulate in one message
+   */
+  updateLastMessage(contentDelta, type = "assistant") {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        const oldMessage = this.messages[i];
+        const updatedMessage = {
+          ...oldMessage,
+          content: oldMessage.content + contentDelta
+        };
+        this.messages[i] = updatedMessage;
+        this.notifyListeners();
+        return;
+      }
+    }
+    this.addMessage(contentDelta, type);
+  }
+  /**
+   * Remove the last message of a specific type
+   * Useful for removing placeholder messages like "Thinking..." when actual response starts
+   */
+  removeLastMessage(type) {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        this.messages.splice(i, 1);
+        this.notifyListeners();
+        return true;
+      }
+    }
+    return false;
+  }
   getMessages() {
     return [...this.messages];
   }
@@ -1069,8 +1142,92 @@ class AbortError extends Error {
 
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = join(__filename$1, "..");
+function getGlobalClaudeVersion() {
+  try {
+    const cleanEnv = getCleanEnv();
+    const output = execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homedir(),
+      env: cleanEnv
+    }).trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    logger.debug(`[Claude SDK] Global claude --version output: ${output}`);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function getCleanEnv() {
+  const env = { ...process.env };
+  const cwd = process.cwd();
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const pathKey = process.platform === "win32" ? "Path" : "PATH";
+  const actualPathKey = Object.keys(env).find((k) => k.toLowerCase() === "path") || pathKey;
+  if (env[actualPathKey]) {
+    const cleanPath = env[actualPathKey].split(pathSep).filter((p) => {
+      const normalizedP = p.replace(/\\/g, "/").toLowerCase();
+      const normalizedCwd = cwd.replace(/\\/g, "/").toLowerCase();
+      return !normalizedP.startsWith(normalizedCwd);
+    }).join(pathSep);
+    env[actualPathKey] = cleanPath;
+    logger.debug(`[Claude SDK] Cleaned PATH, removed local paths from: ${cwd}`);
+  }
+  return env;
+}
+function findGlobalClaudePath() {
+  const homeDir = homedir();
+  const cleanEnv = getCleanEnv();
+  try {
+    execSync("claude --version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: homeDir,
+      env: cleanEnv
+    });
+    logger.debug("[Claude SDK] Global claude command available (checked with clean PATH)");
+    return "claude";
+  } catch {
+  }
+  if (process.platform !== "win32") {
+    try {
+      const result = execSync("which claude", {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: homeDir,
+        env: cleanEnv
+      }).trim();
+      if (result && existsSync(result)) {
+        logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
+        return result;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function getDefaultClaudeCodePath() {
-  return join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  const nodeModulesPath = join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  if (process.env.HAPPY_CLAUDE_PATH) {
+    logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
+    return process.env.HAPPY_CLAUDE_PATH;
+  }
+  if (process.env.HAPPY_USE_BUNDLED_CLAUDE === "1") {
+    logger.debug(`[Claude SDK] Forced bundled version: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalPath = findGlobalClaudePath();
+  if (!globalPath) {
+    logger.debug(`[Claude SDK] No global claude found, using bundled: ${nodeModulesPath}`);
+    return nodeModulesPath;
+  }
+  const globalVersion = getGlobalClaudeVersion();
+  logger.debug(`[Claude SDK] Global version: ${globalVersion || "unknown"}`);
+  if (!globalVersion) {
+    logger.debug(`[Claude SDK] Cannot compare versions, using global: ${globalPath}`);
+    return globalPath;
+  }
+  return globalPath;
 }
 function logDebug(message) {
   if (process.env.DEBUG) {
@@ -2074,6 +2231,16 @@ class PermissionHandler {
       } else {
         pending.resolve({ behavior: "deny", message: response.reason || "Plan rejected" });
       }
+    } else if (pending.toolName === "AskUserQuestion") {
+      if (response.approved) {
+        const inputWithAnswers = {
+          ...pending.input,
+          answers: response.answers || {}
+        };
+        pending.resolve({ behavior: "allow", updatedInput: inputWithAnswers });
+      } else {
+        pending.resolve({ behavior: "deny", message: response.reason || "User declined to answer the questions." });
+      }
     } else {
       const result = response.approved ? { behavior: "allow", updatedInput: pending.input || {} } : { behavior: "deny", message: response.reason || `The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.` };
       pending.resolve(result);
@@ -2099,11 +2266,13 @@ class PermissionHandler {
       return { behavior: "allow", updatedInput: input };
     }
     const descriptor = getToolDescriptor(toolName);
-    if (this.permissionMode === "bypassPermissions") {
-      return { behavior: "allow", updatedInput: input };
-    }
-    if (this.permissionMode === "acceptEdits" && descriptor.edit) {
-      return { behavior: "allow", updatedInput: input };
+    if (toolName !== "AskUserQuestion") {
+      if (this.permissionMode === "bypassPermissions") {
+        return { behavior: "allow", updatedInput: input };
+      }
+      if (this.permissionMode === "acceptEdits" && descriptor.edit) {
+        return { behavior: "allow", updatedInput: input };
+      }
     }
     let toolCallId = this.resolveToolCallId(toolName, input);
     if (!toolCallId) {
@@ -3185,7 +3354,8 @@ async function loop(opts) {
     messageQueue: opts.messageQueue,
     allowedTools: opts.allowedTools,
     onModeChange: opts.onModeChange,
-    initialPermissionMode: opts.permissionMode
+    initialPermissionMode: opts.permissionMode,
+    hookSettingsPath: opts.hookSettingsPath
   });
   if (opts.onSessionReady) {
     opts.onSessionReady(session);
@@ -5085,6 +5255,110 @@ async function startHappyServer(client) {
   };
 }
 
+async function startHookServer(options) {
+  const { onSessionHook } = options;
+  return new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/hook/session-start") {
+        const timeout = setTimeout(() => {
+          if (!res.headersSent) {
+            logger.debug("[hookServer] Request timeout");
+            res.writeHead(408).end("timeout");
+          }
+        }, 5e3);
+        try {
+          const chunks = [];
+          for await (const chunk of req) {
+            chunks.push(chunk);
+          }
+          clearTimeout(timeout);
+          const body = Buffer.concat(chunks).toString("utf-8");
+          logger.debug("[hookServer] Received session hook:", body);
+          let data = {};
+          try {
+            data = JSON.parse(body);
+          } catch (parseError) {
+            logger.debug("[hookServer] Failed to parse hook data as JSON:", parseError);
+          }
+          const sessionId = data.session_id || data.sessionId;
+          if (sessionId) {
+            logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
+            onSessionHook(sessionId, data);
+          } else {
+            logger.debug("[hookServer] Session hook received but no session_id found in data");
+          }
+          res.writeHead(200, { "Content-Type": "text/plain" }).end("ok");
+        } catch (error) {
+          clearTimeout(timeout);
+          logger.debug("[hookServer] Error handling session hook:", error);
+          if (!res.headersSent) {
+            res.writeHead(500).end("error");
+          }
+        }
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      const port = address.port;
+      logger.debug(`[hookServer] Started on port ${port}`);
+      resolve({
+        port,
+        stop: () => {
+          server.close();
+          logger.debug("[hookServer] Stopped");
+        }
+      });
+    });
+    server.on("error", (err) => {
+      logger.debug("[hookServer] Server error:", err);
+      reject(err);
+    });
+  });
+}
+
+function generateHookSettingsFile(port) {
+  const hooksDir = join(configuration.happyHomeDir, "tmp", "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  const filename = `session-hook-${process.pid}.json`;
+  const filepath = join(hooksDir, filename);
+  const forwarderScript = resolve(projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const hookCommand = `node "${forwarderScript}" ${port}`;
+  const settings = {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              type: "command",
+              command: hookCommand
+            }
+          ]
+        }
+      ]
+    }
+  };
+  writeFileSync(filepath, JSON.stringify(settings, null, 2));
+  logger.debug(`[generateHookSettings] Created hook settings file: ${filepath}`);
+  return filepath;
+}
+function cleanupHookSettingsFile(filepath) {
+  try {
+    if (existsSync(filepath)) {
+      unlinkSync(filepath);
+      logger.debug(`[generateHookSettings] Cleaned up hook settings file: ${filepath}`);
+    }
+  } catch (error) {
+    logger.debug(`[generateHookSettings] Failed to cleanup hook settings file: ${error}`);
+  }
+}
+
 function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
   rpcHandlerManager.registerHandler("killSession", async () => {
     logger.debug("Kill session request received");
@@ -5188,6 +5462,22 @@ async function runClaude(credentials, options = {}) {
   const session = api.sessionSyncClient(response);
   const happyServer = await startHappyServer(session);
   logger.debug(`[START] Happy MCP server started at ${happyServer.url}`);
+  let currentSession = null;
+  const hookServer = await startHookServer({
+    onSessionHook: (sessionId, data) => {
+      logger.debug(`[START] Session hook received: ${sessionId}`, data);
+      if (currentSession) {
+        const previousSessionId = currentSession.sessionId;
+        if (previousSessionId !== sessionId) {
+          logger.debug(`[START] Claude session ID changed: ${previousSessionId} -> ${sessionId}`);
+          currentSession.onSessionFound(sessionId);
+        }
+      }
+    }
+  });
+  logger.debug(`[START] Hook server started on port ${hookServer.port}`);
+  const hookSettingsPath = generateHookSettingsFile(hookServer.port);
+  logger.debug(`[START] Generated hook settings file: ${hookSettingsPath}`);
   const logPath = logger.logFilePath;
   logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
@@ -5351,6 +5641,11 @@ async function runClaude(credentials, options = {}) {
       }
       stopCaffeinate();
       happyServer.stop();
+      hookServer.stop();
+      cleanupHookSettingsFile(hookSettingsPath);
+      if (currentSession) {
+        currentSession.cleanup();
+      }
       logger.debug("[START] Cleanup complete, exiting");
       process.exit(0);
     } catch (error) {
@@ -5384,7 +5679,8 @@ async function runClaude(credentials, options = {}) {
         controlledByUser: newMode === "local"
       }));
     },
-    onSessionReady: (_sessionInstance) => {
+    onSessionReady: (sessionInstance) => {
+      currentSession = sessionInstance;
     },
     mcpServers: {
       "happy": {
@@ -5394,7 +5690,8 @@ async function runClaude(credentials, options = {}) {
     },
     session,
     claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs
+    claudeArgs: options.claudeArgs,
+    hookSettingsPath
   });
   session.sendSessionDeath();
   logger.debug("Waiting for socket to flush...");
@@ -5405,6 +5702,9 @@ async function runClaude(credentials, options = {}) {
   logger.debug("Stopped sleep prevention");
   happyServer.stop();
   logger.debug("Stopped Happy MCP server");
+  hookServer.stop();
+  cleanupHookSettingsFile(hookSettingsPath);
+  logger.debug("Stopped hook server");
   process.exit(0);
 }
 
@@ -5456,7 +5756,7 @@ async function install$1() {
             </dict>
             </plist>
         `);
-    writeFileSync(PLIST_FILE$1, plistContent);
+    writeFileSync$1(PLIST_FILE$1, plistContent);
     chmodSync(PLIST_FILE$1, 420);
     logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
     execSync$1(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
@@ -5493,7 +5793,7 @@ async function uninstall$1() {
     } catch (error) {
       logger.info("Failed to unload daemon (it might not be running)");
     }
-    unlinkSync(PLIST_FILE);
+    unlinkSync$1(PLIST_FILE);
     logger.info(`Removed daemon plist from ${PLIST_FILE}`);
     logger.info("Daemon uninstalled successfully");
   } catch (error) {
@@ -6510,7 +6810,7 @@ async function handleConnectVendor(vendor, displayName) {
     return;
   } else if (subcommand === "codex") {
     try {
-      const { runCodex } = await import('./runCodex-Cqxq74Wt.mjs');
+      const { runCodex } = await import('./runCodex-DO1tAsMY.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -6555,7 +6855,7 @@ async function handleConnectVendor(vendor, displayName) {
   } else if (subcommand === "list") {
     try {
       const { credentials } = await authAndSetupMachineIfNeeded();
-      const { listSessions } = await import('./list-CGXN1SEJ.mjs');
+      const { listSessions } = await import('./list-C0F4TAPa.mjs');
       let sessionId;
       let titleFilter;
       let recentMsgs;
@@ -6657,7 +6957,7 @@ Examples:
         process.exit(1);
       }
       const { credentials } = await authAndSetupMachineIfNeeded();
-      const { promptSession } = await import('./prompt-BrXxehR7.mjs');
+      const { promptSession } = await import('./prompt-Br-GiaVj.mjs');
       await promptSession(credentials, sessionId, promptText, timeoutMinutes ?? void 0);
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");