happy-imou-cloud 2.0.1 → 2.0.3

package/dist/{runClaude-C_WLfM6c.mjs → runClaude-D6Pdkevn.mjs}

@@ -1,14 +1,13 @@
 import os, { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { l as logger, d as backoff, f as delay, g as AsyncLock, c as configuration, b as connectionState, A as ApiClient, p as packageJson, i as isAuthenticationRequiredError, s as startOfflineReconnection } from './api-B5Ui8Fw0.mjs';
-import { e as getProjectPath, h as claudeLocal, E as ExitCodeError, j as isBun, k as trimIdent, l as claudeCheckSession, p as projectPath, m as getEnvironmentInfo, i as initialMachineMetadata, b as stopCaffeinate, n as notifyDaemonSessionStarted, o as startCaffeinate } from './index-BByhFIIq.mjs';
-import { F as Future } from './future-xRdLl3vf.mjs';
+import { l as logger, d as backoff, f as delay, g as AsyncLock, c as configuration, b as connectionState, A as ApiClient, p as packageJson, i as isAuthenticationRequiredError, s as startOfflineReconnection } from './api-DpQIC-DJ.mjs';
+import { e as getProjectPath, h as claudeLocal, E as ExitCodeError, j as isBun, k as trimIdent, l as claudeCheckSession, p as projectPath, m as getEnvironmentInfo, i as initialMachineMetadata, b as stopCaffeinate, n as notifyDaemonSessionStarted, o as startCaffeinate } from './index-CriPm_z9.mjs';
 import { R as RawJSONLinesSchema } from './types-CiliQpqS.mjs';
-import { join, resolve } from 'node:path';
+import { dirname, basename, join, resolve } from 'node:path';
 import { readFile } from 'node:fs/promises';
-import { watch, access } from 'fs/promises';
+import { stat, watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { a as MessageBuffer, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler } from './registerKillSessionHandler-BtSK7IOa.mjs';
+import { a as MessageBuffer, M as MessageQueue2, h as hashObject, r as registerKillSessionHandler } from './registerKillSessionHandler-C3M_-4Zg.mjs';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { execSync, spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
@@ -21,7 +20,7 @@ import 'tweetnacl';
 import 'expo-server-sdk';
 import 'chalk';
 import { isDeepStrictEqual } from 'node:util';
-import { readSettings } from './persistence-CzpZpiL3.mjs';
+import { readSettings } from './persistence-CqgPgbzN.mjs';
 import { createServer } from 'node:http';
 import 'fs';
 import 'zod';
@@ -59,6 +58,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 */
@@ -112,15 +112,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
     }));
-    logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
+    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);
     }
   };
   /**
@@ -143,6 +161,7 @@ class Session {
    */
   clearSessionId = () => {
     this.sessionId = null;
+    this.transcriptPath = null;
     logger.debug("[Session] Session ID cleared");
   };
   /**
@@ -179,6 +198,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;
@@ -247,9 +287,51 @@ class InvalidateSync {
 
 function startFileWatcher(file, onFileChange) {
   const abortController = new AbortController();
+  const parentDir = dirname(file);
+  const targetName = basename(file);
   void (async () => {
     while (true) {
       try {
+        try {
+          await stat(file);
+        } catch (e) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          if (e?.code === "ENOENT") {
+            logger.debug(`[FILE_WATCHER] Waiting for file to exist: ${file}`);
+            const dirWatcher = watch(parentDir, { persistent: true, signal: abortController.signal });
+            try {
+              await 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 stat(file);
+                  logger.debug(`[FILE_WATCHER] File appeared: ${file}`);
+                  break;
+                } catch (nextErr) {
+                  if (nextErr?.code === "ENOENT") {
+                    continue;
+                  }
+                  throw nextErr;
+                }
+              }
+            }
+          } else {
+            throw e;
+          }
+        }
+        onFileChange(file);
         logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
         const watcher = watch(file, { persistent: true, signal: abortController.signal });
         for await (const event of watcher) {
@@ -279,19 +361,67 @@ const INTERNAL_CLAUDE_EVENT_TYPES = /* @__PURE__ */ new Set([
   "queue-operation"
 ]);
 async function createSessionScanner(opts) {
-  const projectDir = getProjectPath(opts.workingDirectory);
+  const initialProjectDir = 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 ?? 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 readFile(filePath, "utf-8");
+        return;
+      } catch {
+      }
+      warnedMissingTranscripts.add(sessionId);
+      try {
+        opts.onTranscriptMissing?.({ sessionId, filePath });
+      } catch (err) {
+        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 = dirname(transcriptPath);
+  }
   if (opts.sessionId) {
-    let messages = await readSessionLog(projectDir, opts.sessionId);
+    let messages = await readSessionLog(getSessionFilePath(opts.sessionId));
     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 = [];
@@ -307,7 +437,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) {
@@ -332,11 +462,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) {
         logger.debug(`[SESSION_SCANNER] Starting watcher for session: ${p}`);
-        watchers.set(p, startFileWatcher(join(projectDir, `${p}.jsonl`), () => {
-          sync.invalidate();
-        }));
+        watchers.set(p, {
+          filePath: desiredPath,
+          stop: startFileWatcher(desiredPath, () => {
+            sync.invalidate();
+          })
+        });
+        continue;
+      }
+      if (existing.filePath !== desiredPath) {
+        logger.debug(`[SESSION_SCANNER] Restarting watcher for session: ${p} (${existing.filePath} -> ${desiredPath})`);
+        existing.stop();
+        watchers.set(p, {
+          filePath: desiredPath,
+          stop: startFileWatcher(desiredPath, () => {
+            sync.invalidate();
+          })
+        });
       }
     }
   });
@@ -348,23 +494,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 = dirname(transcriptPath);
+        if (projectDirOverride !== nextProjectDir) {
+          projectDirOverride = nextProjectDir;
+          didUpdatePaths = true;
+        }
+      }
       if (currentSessionId === sessionId) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
+        }
         return;
       }
       if (finishedSessions.has(sessionId)) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
+        }
         return;
       }
       if (pendingSessions.has(sessionId)) {
-        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        if (didUpdatePaths) {
+          sync.invalidate();
+        } else {
+          logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        }
         return;
       }
       if (currentSessionId) {
@@ -372,6 +550,7 @@ async function createSessionScanner(opts) {
       }
       logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
       currentSessionId = sessionId;
+      scheduleTranscriptMissingWarning(sessionId);
       sync.invalidate();
     }
   };
@@ -389,14 +568,13 @@ function messageKey(message) {
     throw Error();
   }
 }
-async function readSessionLog(projectDir, sessionId) {
-  const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
-  logger.debug(`[SESSION_SCANNER] Reading session file: ${expectedSessionFile}`);
+async function readSessionLog(sessionFilePath) {
+  logger.debug(`[SESSION_SCANNER] Reading session file: ${sessionFilePath}`);
   let file;
   try {
-    file = await readFile(expectedSessionFile, "utf-8");
+    file = await readFile(sessionFilePath, "utf-8");
   } catch (error) {
-    logger.debug(`[SESSION_SCANNER] Session file not found: ${expectedSessionFile}`);
+    logger.debug(`[SESSION_SCANNER] Session file not found: ${sessionFilePath}`);
     return [];
   }
   let lines = file.split("\n");
@@ -426,15 +604,25 @@ 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;
@@ -472,7 +660,6 @@ async function claudeLocalLauncher(session) {
     }
     const handleSessionStart = (sessionId) => {
       session.onSessionFound(sessionId);
-      scanner.onNewSession(sessionId);
     };
     while (true) {
       if (exitReason) {
@@ -1421,7 +1608,7 @@ const systemPrompt = (() => {
 
 async function claudeRemote(opts) {
   let startFrom = opts.sessionId;
-  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path, opts.transcriptPath)) {
     startFrom = null;
   }
   if (!startFrom && opts.claudeArgs) {
@@ -1523,11 +1710,14 @@ async function claudeRemote(opts) {
         updateThinking(true);
         const systemInit = message;
         if (systemInit.session_id) {
-          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${systemInit.session_id}`);
-          const projectDir = getProjectPath(opts.path);
-          const found = await awaitFileExist(join(projectDir, `${systemInit.session_id}.jsonl`));
+          const transcriptPath = opts.transcriptPath && opts.sessionId === systemInit.session_id ? opts.transcriptPath : join(getProjectPath(opts.path), `${systemInit.session_id}.jsonl`);
+          logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${transcriptPath}`);
+          const found = await awaitFileExist(transcriptPath);
           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") {
@@ -1980,11 +2170,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);
@@ -2630,6 +2830,7 @@ async function claudeRemoteLauncher(session) {
       try {
         const remoteResult = await claudeRemote({
           sessionId: session.sessionId,
+          transcriptPath: session.transcriptPath,
           path: session.path,
           allowedTools: session.allowedTools ?? [],
           mcpServers: session.mcpServers,
@@ -2663,9 +2864,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,
@@ -2854,13 +3055,20 @@ async function startHookServer(options) {
           }
           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);
           }
+          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) {
             logger.debug(`[hookServer] Session hook received session ID: ${sessionId}`);
@@ -3062,11 +3270,7 @@ async function runClaude(credentials, options = {}) {
     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);
-        }
+        currentSession.onSessionFound(sessionId, data);
       }
     }
   });