happy-imou-cloud 2.0.0 → 2.0.2

package/dist/{runClaude-CwAitpX-.cjs → runClaude-B-GNEkKg.cjs}

@@ -2,15 +2,15 @@
 
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var api = require('./api-D7OK-mML.cjs');
-var index = require('./index-B_wlQBy2.cjs');
+var api = require('./api-D2Njw9Im.cjs');
+var index = require('./index-Bg-YziG2.cjs');
 var future = require('./future-Dq4Ha1Dn.cjs');
 var types = require('./types-DVk3crez.cjs');
 var path = require('node:path');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
-var registerKillSessionHandler = require('./registerKillSessionHandler-CLREXN11.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-BAXmJQRt.cjs');
 var React = require('react');
 var node_child_process = require('node:child_process');
 var node_readline = require('node:readline');
@@ -23,7 +23,7 @@ require('tweetnacl');
 require('expo-server-sdk');
 require('chalk');
 var node_util = require('node:util');
-var persistence = require('./persistence-DHgf1CTG.cjs');
+var persistence = require('./persistence-D_2GkJAO.cjs');
 var node_http = require('node:http');
 require('fs');
 require('zod');
@@ -62,6 +62,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 +116,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 +165,7 @@ class Session {
    */
   clearSessionId = () => {
     this.sessionId = null;
+    this.transcriptPath = null;
     api.logger.debug("[Session] Session ID cleared");
   };
   /**
@@ -250,9 +270,51 @@ class InvalidateSync {
 
 function startFileWatcher(file, onFileChange) {
   const abortController = new AbortController();
+  const parentDir = path.dirname(file);
+  const targetName = 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 +344,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 ?? 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 = 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 +420,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 +445,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 +477,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 = 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 +533,7 @@ async function createSessionScanner(opts) {
       }
       api.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
       currentSessionId = sessionId;
+      scheduleTranscriptMissingWarning(sessionId);
       sync.invalidate();
     }
   };
@@ -392,14 +551,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,15 +587,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;
@@ -475,7 +643,6 @@ async function claudeLocalLauncher(session) {
     }
     const handleSessionStart = (sessionId) => {
       session.onSessionFound(sessionId);
-      scanner.onNewSession(sessionId);
     };
     while (true) {
       if (exitReason) {
@@ -750,7 +917,7 @@ 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-CwAitpX-.cjs', document.baseURI).href)));
+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-B-GNEkKg.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -1424,7 +1591,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) {
@@ -1526,11 +1693,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 : 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 +2153,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);
@@ -2633,6 +2813,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,
@@ -2666,9 +2847,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 +3038,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}`);
@@ -2985,7 +3173,15 @@ async function runClaude(credentials, options = {}) {
     lifecycleStateSince: Date.now(),
     flavor: "claude"
   };
-  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  let response = null;
+  try {
+    response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  } catch (error) {
+    if (!api.isAuthenticationRequiredError(error)) {
+      throw error;
+    }
+    api.logger.debug("[START] Falling back to local/offline mode after authentication failure");
+  }
   if (!response) {
     let offlineSessionId = null;
     const reconnection = api.startOfflineReconnection({
@@ -3057,11 +3253,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);
       }
     }
   });