happy-imou-cloud 2.0.1 → 2.0.3

package/dist/{runClaude-CNVufgZb.cjs → runClaude-IeRSC5qX.cjs}

@@ -2,19 +2,18 @@
 
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var api = require('./api-B8v4tczT.cjs');
-var index = require('./index-BOqJ9hwi.cjs');
-var future = require('./future-Dq4Ha1Dn.cjs');
+var api = require('./api-D9dIR956.cjs');
+var index = require('./index-LYPXVO_L.cjs');
 var types = require('./types-DVk3crez.cjs');
-var path = require('node:path');
+var node_path = require('node:path');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
-var registerKillSessionHandler = require('./registerKillSessionHandler-BkzQulD9.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BDBPoQSA.cjs');
 var React = require('react');
 var node_child_process = require('node:child_process');
 var node_readline = require('node:readline');
-var fs$1 = require('node:fs');
+var node_fs = require('node:fs');
 var node_url = require('node:url');
 require('axios');
 require('node:events');
@@ -23,7 +22,7 @@ require('tweetnacl');
 require('expo-server-sdk');
 require('chalk');
 var node_util = require('node:util');
-var persistence = require('./persistence-C33AMdtv.cjs');
+var persistence = require('./persistence-PzKU0QCa.cjs');
 var node_http = require('node:http');
 require('fs');
 require('zod');
@@ -62,6 +61,7 @@ class Session {
   /** JavaScript runtime to use for spawning Claude Code (default: 'node') */
   jsRuntime;
   sessionId;
+  transcriptPath = null;
   mode = "local";
   thinking = false;
   /** Callbacks to be notified when session ID is found/changed */
@@ -115,15 +115,33 @@ class Session {
    * Updates internal state, syncs to API metadata, and notifies
    * all registered callbacks (e.g., SessionScanner) about the change.
    */
-  onSessionFound = (sessionId) => {
+  onSessionFound = (sessionId, hookData) => {
+    const nextTranscriptPathRaw = hookData?.transcript_path ?? hookData?.transcriptPath;
+    const nextTranscriptPath = typeof nextTranscriptPathRaw === "string" ? nextTranscriptPathRaw : null;
+    const previousSessionId = this.sessionId;
+    const previousTranscriptPath = this.transcriptPath;
     this.sessionId = sessionId;
+    if (previousSessionId !== sessionId) {
+      this.transcriptPath = nextTranscriptPath;
+    } else if (nextTranscriptPath) {
+      this.transcriptPath = nextTranscriptPath;
+    }
     this.client.updateMetadata((metadata) => ({
       ...metadata,
-      claudeSessionId: sessionId
+      claudeSessionId: sessionId,
+      claudeTranscriptPath: this.transcriptPath || void 0
     }));
-    api.logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    api.logger.debug(`[Session] Claude session info updated: sessionId=${sessionId}, transcriptPath=${this.transcriptPath ?? "none"}`);
+    const didTranscriptPathChange = nextTranscriptPath !== null && nextTranscriptPath !== previousTranscriptPath;
+    if (previousSessionId === sessionId && !didTranscriptPathChange) {
+      return;
+    }
+    const info = {
+      sessionId,
+      transcriptPath: this.transcriptPath
+    };
     for (const callback of this.sessionFoundCallbacks) {
-      callback(sessionId);
+      callback(info);
     }
   };
   /**
@@ -146,6 +164,7 @@ class Session {
    */
   clearSessionId = () => {
     this.sessionId = null;
+    this.transcriptPath = null;
     api.logger.debug("[Session] Session ID cleared");
   };
   /**
@@ -182,6 +201,27 @@ class Session {
   };
 }
 
+class Future {
+  _resolve;
+  _reject;
+  _promise;
+  constructor() {
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  resolve(value) {
+    this._resolve(value);
+  }
+  reject(reason) {
+    this._reject(reason);
+  }
+  get promise() {
+    return this._promise;
+  }
+}
+
 class InvalidateSync {
   _invalidated = false;
   _invalidatedDouble = false;
@@ -250,9 +290,51 @@ class InvalidateSync {
 
 function startFileWatcher(file, onFileChange) {
   const abortController = new AbortController();
+  const parentDir = node_path.dirname(file);
+  const targetName = node_path.basename(file);
   void (async () => {
     while (true) {
       try {
+        try {
+          await fs.stat(file);
+        } catch (e) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          if (e?.code === "ENOENT") {
+            api.logger.debug(`[FILE_WATCHER] Waiting for file to exist: ${file}`);
+            const dirWatcher = fs.watch(parentDir, { persistent: true, signal: abortController.signal });
+            try {
+              await fs.stat(file);
+            } catch (err) {
+              if (err?.code !== "ENOENT") {
+                throw err;
+              }
+              for await (const event of dirWatcher) {
+                if (abortController.signal.aborted) {
+                  return;
+                }
+                const name = typeof event?.filename === "string" ? String(event.filename) : null;
+                if (name && name !== targetName) {
+                  continue;
+                }
+                try {
+                  await fs.stat(file);
+                  api.logger.debug(`[FILE_WATCHER] File appeared: ${file}`);
+                  break;
+                } catch (nextErr) {
+                  if (nextErr?.code === "ENOENT") {
+                    continue;
+                  }
+                  throw nextErr;
+                }
+              }
+            }
+          } else {
+            throw e;
+          }
+        }
+        onFileChange(file);
         api.logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
         const watcher = fs.watch(file, { persistent: true, signal: abortController.signal });
         for await (const event of watcher) {
@@ -282,19 +364,67 @@ const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "queue-operation"
 ]);
 async function createSessionScanner(opts) {
-  const projectDir = index.getProjectPath(opts.workingDirectory);
+  const initialProjectDir = index.getProjectPath(opts.workingDirectory);
+  let projectDirOverride = null;
+  const sessionFileOverrides = /* @__PURE__ */ new Map();
+  const transcriptMissingWarningMs = opts.transcriptMissingWarningMs ?? 5e3;
+  const warnedMissingTranscripts = /* @__PURE__ */ new Set();
+  const missingTranscriptTimers = /* @__PURE__ */ new Map();
+  function effectiveProjectDir() {
+    return projectDirOverride ?? initialProjectDir;
+  }
+  function getSessionFilePath(sessionId) {
+    const override = sessionFileOverrides.get(sessionId);
+    return override ?? node_path.join(effectiveProjectDir(), `${sessionId}.jsonl`);
+  }
+  function scheduleTranscriptMissingWarning(sessionId) {
+    if (!opts.onTranscriptMissing) {
+      return;
+    }
+    if (!Number.isFinite(transcriptMissingWarningMs) || transcriptMissingWarningMs <= 0) {
+      return;
+    }
+    if (warnedMissingTranscripts.has(sessionId) || missingTranscriptTimers.has(sessionId)) {
+      return;
+    }
+    const timeoutId = setTimeout(async () => {
+      missingTranscriptTimers.delete(sessionId);
+      if (warnedMissingTranscripts.has(sessionId)) {
+        return;
+      }
+      const filePath = getSessionFilePath(sessionId);
+      try {
+        await promises.readFile(filePath, "utf-8");
+        return;
+      } catch {
+      }
+      warnedMissingTranscripts.add(sessionId);
+      try {
+        opts.onTranscriptMissing?.({ sessionId, filePath });
+      } catch (err) {
+        api.logger.debug("[SESSION_SCANNER] onTranscriptMissing callback threw:", err);
+      }
+    }, transcriptMissingWarningMs);
+    missingTranscriptTimers.set(sessionId, timeoutId);
+  }
   let finishedSessions = /* @__PURE__ */ new Set();
   let pendingSessions = /* @__PURE__ */ new Set();
   let currentSessionId = null;
   let watchers = /* @__PURE__ */ new Map();
   let processedMessageKeys = /* @__PURE__ */ new Set();
+  if (opts.sessionId && typeof opts.transcriptPath === "string" && opts.transcriptPath.trim()) {
+    const transcriptPath = opts.transcriptPath.trim();
+    sessionFileOverrides.set(opts.sessionId, transcriptPath);
+    projectDirOverride = node_path.dirname(transcriptPath);
+  }
   if (opts.sessionId) {
-    let messages = await readSessionLog(projectDir, opts.sessionId);
+    let messages = await readSessionLog(getSessionFilePath(opts.sessionId));
     api.logger.debug(`[SESSION_SCANNER] Marking ${messages.length} existing messages as processed from session ${opts.sessionId}`);
     for (let m of messages) {
       processedMessageKeys.add(messageKey(m));
     }
     currentSessionId = opts.sessionId;
+    scheduleTranscriptMissingWarning(opts.sessionId);
   }
   const sync = new InvalidateSync(async () => {
     let sessions = [];
@@ -310,7 +440,7 @@ async function createSessionScanner(opts) {
       }
     }
     for (let session of sessions) {
-      const sessionMessages = await readSessionLog(projectDir, session);
+      const sessionMessages = await readSessionLog(getSessionFilePath(session));
       let skipped = 0;
       let sent = 0;
       for (let file of sessionMessages) {
@@ -335,11 +465,27 @@ async function createSessionScanner(opts) {
       }
     }
     for (let p of sessions) {
-      if (!watchers.has(p)) {
+      const desiredPath = getSessionFilePath(p);
+      const existing = watchers.get(p);
+      if (!existing) {
         api.logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
-        watchers.set(p, startFileWatcher(path.join(projectDir, `${p}.jsonl`), () => {
-          sync.invalidate();
-        }));
+        watchers.set(p, {
+          filePath: desiredPath,
+          stop: startFileWatcher(desiredPath, () => {
+            sync.invalidate();
+          })
+        });
+        continue;
+      }
+      if (existing.filePath !== desiredPath) {
+        api.logger.debug(`[SESSION_SCANNER] Restarting watcher for session: ${p} (${existing.filePath} -> ${desiredPath})`);
+        existing.stop();
+        watchers.set(p, {
+          filePath: desiredPath,
+          stop: startFileWatcher(desiredPath, () => {
+            sync.invalidate();
+          })
+        });
       }
     }
   });
@@ -351,23 +497,55 @@ async function createSessionScanner(opts) {
     cleanup: async () => {
       clearInterval(intervalId);
       for (let w of watchers.values()) {
-        w();
+        w.stop();
       }
       watchers.clear();
+      for (const timeoutId of missingTranscriptTimers.values()) {
+        clearTimeout(timeoutId);
+      }
+      missingTranscriptTimers.clear();
       await sync.invalidateAndAwait();
       sync.stop();
     },
-    onNewSession: (sessionId) => {
+    onNewSession: (arg) => {
+      const sessionId = typeof arg === "string" ? arg : arg.sessionId;
+      const transcriptPathRaw = typeof arg === "string" ? null : arg.transcriptPath;
+      const transcriptPath = typeof transcriptPathRaw === "string" && transcriptPathRaw.trim() ? transcriptPathRaw.trim() : null;
+      let didUpdatePaths = false;
+      if (transcriptPath) {
+        const previousOverride = sessionFileOverrides.get(sessionId);
+        if (previousOverride !== transcriptPath) {
+          sessionFileOverrides.set(sessionId, transcriptPath);
+          didUpdatePaths = true;
+        }
+        const nextProjectDir = node_path.dirname(transcriptPath);
+        if (projectDirOverride !== nextProjectDir) {
+          projectDirOverride = nextProjectDir;
+          didUpdatePaths = true;
+        }
+      }
       if (currentSessionId === sessionId) {
-        api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        }
         return;
       }
       if (finishedSessions.has(sessionId)) {
-        api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        }
         return;
       }
       if (pendingSessions.has(sessionId)) {
-        api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        }
         return;
       }
       if (currentSessionId) {
@@ -375,6 +553,7 @@ async function createSessionScanner(opts) {
       }
       api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
       currentSessionId = sessionId;
+      scheduleTranscriptMissingWarning(sessionId);
       sync.invalidate();
     }
   };
@@ -392,14 +571,13 @@ function messageKey(message) {
     throw Error();
   }
 }
-async function readSessionLog(projectDir, sessionId) {
-  const expectedSessionFile = path.join(projectDir, `${sessionId}.jsonl`);
-  api.logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+async function readSessionLog(sessionFilePath) {
+  api.logger.debug(`[SESSION_SCANNER] Reading session file: ${sessionFilePath}`);
   let file;
   try {
-    file = await promises.readFile(expectedSessionFile, "utf-8");
+    file = await promises.readFile(sessionFilePath, "utf-8");
   } catch (error) {
-    api.logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    api.logger.debug(`[SESSION_SCANNER] Session file not found: ${sessionFilePath}`);
     return [];
   }
   let lines = file.split("\n");
@@ -429,20 +607,30 @@ async function readSessionLog(projectDir, sessionId) {
 async function claudeLocalLauncher(session) {
   const scanner = await createSessionScanner({
     sessionId: session.sessionId,
+    transcriptPath: session.transcriptPath,
     workingDirectory: session.path,
     onMessage: (message) => {
       if (message.type !== "summary") {
         session.client.sendClaudeSessionMessage(message);
       }
+    },
+    onTranscriptMissing: () => {
+      session.client.sendSessionEvent({
+        type: "message",
+        message: "Claude transcript file not found yet, waiting for it to appear..."
+      });
     }
   });
-  const scannerSessionCallback = (sessionId) => {
-    scanner.onNewSession(sessionId);
+  const scannerSessionCallback = (info) => {
+    scanner.onNewSession({
+      sessionId: info.sessionId,
+      transcriptPath: info.transcriptPath
+    });
   };
   session.addSessionFoundCallback(scannerSessionCallback);
   let exitReason = null;
   const processAbortController = new AbortController();
-  let exutFuture = new future.Future();
+  let exutFuture = new Future();
   try {
     async function abort() {
       if (!processAbortController.signal.aborted) {
@@ -475,7 +663,6 @@ async function claudeLocalLauncher(session) {
     }
     const handleSessionStart = (sessionId) => {
       session.onSessionFound(sessionId);
-      scanner.onNewSession(sessionId);
     };
     while (true) {
       if (exitReason) {
@@ -750,8 +937,8 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runClaude-CNVufgZb.cjs', document.baseURI).href)));
-const __dirname$1 = path.join(__filename$1, "..");
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runClaude-IeRSC5qX.cjs', document.baseURI).href)));
+const __dirname$1 = node_path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
     const cleanEnv = getCleanEnv();
@@ -815,7 +1002,7 @@ function findGlobalClaudePath() {
         cwd: homeDir,
         env: cleanEnv
       }).trim();
-      if (result && fs$1.existsSync(result)) {
+      if (result && node_fs.existsSync(result)) {
         api.logger.debug(`[Claude SDK] Found global claude path via which: ${result}`);
         return result;
       }
@@ -825,7 +1012,7 @@ function findGlobalClaudePath() {
   return null;
 }
 function getDefaultClaudeCodePath() {
-  const nodeModulesPath = path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+  const nodeModulesPath = node_path.join(__dirname$1, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
   if (process.env.HAPPY_CLAUDE_PATH) {
     api.logger.debug(`[Claude SDK] Using HAPPY_CLAUDE_PATH: ${process.env.HAPPY_CLAUDE_PATH}`);
     return process.env.HAPPY_CLAUDE_PATH;
@@ -1114,7 +1301,7 @@ function query(config) {
   }
   const isJsFile = pathToClaudeCodeExecutable.endsWith(".js") || pathToClaudeCodeExecutable.endsWith(".cjs");
   const isCommandOnly = pathToClaudeCodeExecutable === "claude";
-  if (!isCommandOnly && !fs$1.existsSync(pathToClaudeCodeExecutable)) {
+  if (!isCommandOnly && !node_fs.existsSync(pathToClaudeCodeExecutable)) {
     throw new ReferenceError(`Claude Code executable not found at ${pathToClaudeCodeExecutable}. Is options.pathToClaudeCodeExecutable set?`);
   }
   const spawnCommand = isJsFile ? executable : pathToClaudeCodeExecutable;
@@ -1371,17 +1558,17 @@ async function awaitFileExist(file, timeout = 1e4) {
 }
 
 function getClaudeSettingsPath() {
-  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
-  return path.join(claudeConfigDir, "settings.json");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || node_path.join(os.homedir(), ".claude");
+  return node_path.join(claudeConfigDir, "settings.json");
 }
 function readClaudeSettings() {
   try {
     const settingsPath = getClaudeSettingsPath();
-    if (!fs$1.existsSync(settingsPath)) {
+    if (!node_fs.existsSync(settingsPath)) {
       api.logger.debug(`[ClaudeSettings] No Claude settings file found at ${settingsPath}`);
       return null;
     }
-    const settingsContent = fs$1.readFileSync(settingsPath, "utf-8");
+    const settingsContent = node_fs.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(settingsContent);
     api.logger.debug(`[ClaudeSettings] Successfully read Claude settings from ${settingsPath}`);
     api.logger.debug(`[ClaudeSettings] includeCoAuthoredBy: ${settings.includeCoAuthoredBy}`);
@@ -1424,7 +1611,7 @@ const systemPrompt = (() => {
 
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
-  if (opts.sessionId && !index.claudeCheckSession(opts.sessionId, opts.path)) {
+  if (opts.sessionId && !index.claudeCheckSession(opts.sessionId, opts.path, opts.transcriptPath)) {
     startFrom = null;
   }
   if (!startFrom && opts.claudeArgs) {
@@ -1490,7 +1677,7 @@ async function claudeRemote(opts) {
     executable: opts.jsRuntime ?? "node",
     abort: opts.signal,
     pathToClaudeCodeExecutable: (() => {
-      return path.resolve(path.join(index.projectPath(), "scripts", "claude_remote_launcher.cjs"));
+      return node_path.resolve(node_path.join(index.projectPath(), "scripts", "claude_remote_launcher.cjs"));
     })(),
     settingsPath: opts.hookSettingsPath
   };
@@ -1526,11 +1713,14 @@ async function claudeRemote(opts) {
         updateThinking(true);
         const systemInit = message;
         if (systemInit.session_id) {
-          api.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
-          const projectDir = index.getProjectPath(opts.path);
-          const found = await awaitFileExist(path.join(projectDir, `${systemInit.session_id}.jsonl`));
+          const transcriptPath = opts.transcriptPath && opts.sessionId === systemInit.session_id ? opts.transcriptPath : node_path.join(index.getProjectPath(opts.path), `${systemInit.session_id}.jsonl`);
+          api.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${transcriptPath}`);
+          const found = await awaitFileExist(transcriptPath);
           api.logger.debug(`[claudeRemote] Session file found: ${systemInit.session_id} ${found}`);
-          opts.onSessionFound(systemInit.session_id);
+          opts.onSessionFound(systemInit.session_id, {
+            transcript_path: transcriptPath,
+            transcriptPath
+          });
         }
       }
       if (message.type === "result") {
@@ -1983,11 +2173,21 @@ function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
     case "assistant": {
       const assistantMsg = message;
       if (assistantMsg.message && assistantMsg.message.content) {
-        messageBuffer.addMessage("\u{1F916} Assistant:", "assistant");
+        let assistantHeaderShown = false;
         for (const block of assistantMsg.message.content) {
-          if (block.type === "text") {
+          if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim()) {
+            messageBuffer.addMessage(`[Thinking] ${block.thinking}`, "status");
+          } else if (block.type === "text") {
+            if (!assistantHeaderShown) {
+              messageBuffer.addMessage("\u{1F916} Assistant:", "assistant");
+              assistantHeaderShown = true;
+            }
             messageBuffer.addMessage(block.text || "", "assistant");
           } else if (block.type === "tool_use") {
+            if (!assistantHeaderShown) {
+              messageBuffer.addMessage("\u{1F916} Assistant:", "assistant");
+              assistantHeaderShown = true;
+            }
             messageBuffer.addMessage(`\u{1F527} Tool: ${block.name}`, "tool");
             if (block.input) {
               const inputStr = JSON.stringify(block.input, null, 2);
@@ -2627,12 +2827,13 @@ async function claudeRemoteLauncher(session) {
       previousSessionId = session.sessionId;
       const controller = new AbortController();
       abortController = controller;
-      abortFuture = new future.Future();
+      abortFuture = new Future();
       let modeHash = null;
       let mode = null;
       try {
         const remoteResult = await claudeRemote({
           sessionId: session.sessionId,
+          transcriptPath: session.transcriptPath,
           path: session.path,
           allowedTools: session.allowedTools ?? [],
           mcpServers: session.mcpServers,
@@ -2666,9 +2867,9 @@ async function claudeRemoteLauncher(session) {
             }
             return null;
           },
-          onSessionFound: (sessionId) => {
+          onSessionFound: (sessionId, data) => {
             sdkToLogConverter.updateSessionId(sessionId);
-            session.onSessionFound(sessionId);
+            session.onSessionFound(sessionId, data);
           },
           onThinkingChange: session.onThinkingChange,
           claudeEnvVars: session.claudeEnvVars,
@@ -2857,13 +3058,20 @@ async function startHookServer(options) {
           }
           clearTimeout(timeout);
           const body = Buffer.concat(chunks).toString("utf-8");
-          api.logger.debug("[hookServer] Received session hook:", body);
           let data = {};
           try {
             data = JSON.parse(body);
           } catch (parseError) {
             api.logger.debug("[hookServer] Failed to parse hook data as JSON:", parseError);
           }
+          api.logger.debug("[hookServer] Received session hook", {
+            sessionId: data.session_id || data.sessionId || null,
+            transcriptPath: data.transcript_path || data.transcriptPath || null,
+            cwd: data.cwd,
+            hookEventName: data.hook_event_name,
+            source: data.source,
+            bodyLength: body.length
+          });
           const sessionId = data.session_id || data.sessionId;
           if (sessionId) {
             api.logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
@@ -2907,11 +3115,11 @@ async function startHookServer(options) {
 }
 
 function generateHookSettingsFile(port) {
-  const hooksDir = path.join(api.configuration.happyCloudHomeDir, "tmp", "hooks");
-  fs$1.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = node_path.join(api.configuration.happyCloudHomeDir, "tmp", "hooks");
+  node_fs.mkdirSync(hooksDir, { recursive: true });
   const filename = `session-hook-${process.pid}.json`;
-  const filepath = path.join(hooksDir, filename);
-  const forwarderScript = path.resolve(index.projectPath(), "scripts", "session_hook_forwarder.cjs");
+  const filepath = node_path.join(hooksDir, filename);
+  const forwarderScript = node_path.resolve(index.projectPath(), "scripts", "session_hook_forwarder.cjs");
   const hookCommand = `node "${forwarderScript}" ${port}`;
   const settings = {
     hooks: {
@@ -2928,14 +3136,14 @@ function generateHookSettingsFile(port) {
       ]
     }
   };
-  fs$1.writeFileSync(filepath, JSON.stringify(settings, null, 2));
+  node_fs.writeFileSync(filepath, JSON.stringify(settings, null, 2));
   api.logger.debug(`[generateHookSettings] Created hook settings file: ${filepath}`);
   return filepath;
 }
 function cleanupHookSettingsFile(filepath) {
   try {
-    if (fs$1.existsSync(filepath)) {
-      fs$1.unlinkSync(filepath);
+    if (node_fs.existsSync(filepath)) {
+      node_fs.unlinkSync(filepath);
       api.logger.debug(`[generateHookSettings] Cleaned up hook settings file: ${filepath}`);
     }
   } catch (error) {
@@ -2976,7 +3184,7 @@ async function runClaude(credentials, options = {}) {
     homeDir: os.homedir(),
     happyHomeDir: api.configuration.happyCloudHomeDir,
     happyLibDir: index.projectPath(),
-    happyToolsDir: path.resolve(index.projectPath(), "tools", "unpacked"),
+    happyToolsDir: node_path.resolve(index.projectPath(), "tools", "unpacked"),
     startedFromDaemon: options.startedBy === "daemon",
     hostPid: process.pid,
     startedBy: options.startedBy || "terminal",
@@ -3065,11 +3273,7 @@ async function runClaude(credentials, options = {}) {
     onSessionHook: (sessionId, data) => {
       api.logger.debug(`[START] Session hook received: ${sessionId}`, data);
       if (currentSession) {
-        const previousSessionId = currentSession.sessionId;
-        if (previousSessionId !== sessionId) {
-          api.logger.debug(`[START] Claude session ID changed: ${previousSessionId} -> ${sessionId}`);
-          currentSession.onSessionFound(sessionId);
-        }
+        currentSession.onSessionFound(sessionId, data);
       }
     }
   });