happy-imou-cloud 2.1.49 → 2.1.51

package/dist/{runCodex-BbgLVjb9.mjs → runCodex-BSnyN4m7.mjs}

@@ -1,6 +1,6 @@
-import { p as preserveSessionRuntimeMetadata, l as logger, h as hashObject, d as AssistantMessageStream, b as connectionState, A as ApiClient } from './api-DnqaNvyV.mjs';
-import { B as BasePermissionHandler, d as MessageBuffer, C as ConversationHistory$1, f as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, h as finalizeHappyOrgTurnWithBusinessAck, i as buildTurnResultPushNotification, c as registerKillSessionHandler, j as buildReadyPushNotification, l as launchRuntimeHandleWithFactoryResult, t as createSessionTranscriptInkRenderer, k as extractPermissionRequestPushContext, m as buildPermissionPushNotification, n as renderTerminalOutputPreview, p as prepareTerminalOutputForForwarding, o as inferToolResultError, q as forwardAgentMessageToProviderSession, e as ensureManagedProviderMachine, M as MissingMachineIdError, b as MessageQueue2, r as resolveHappyOrgQueuedTurn, s as syncControlledByUserState } from './registerKillSessionHandler-DLDg2EES.mjs';
-import { f as formatDisplayMessage, v as validateCodexAcpSpawn, h as createCodexBackend, A as AcpBackend, t as truncateDisplayMessage, b as closeProviderSession, e as stopCaffeinate, i as resolveCodexExecutable, j as shouldUseShellForCodex, F as Future, k as readManagedSessionTag, l as resolveManagedSessionTag } from './index-7Z93BoVn.mjs';
+import { m as preserveSessionRuntimeMetadata, l as logger, h as hashObject, d as AssistantMessageStream, b as connectionState, A as ApiClient } from './types-B5vtxa38.mjs';
+import { B as BasePermissionHandler, d as buildHappyOrgTurnPrompt, w as waitForResponseCompleteWithAbort, f as finalizeHappyOrgTurnWithBusinessAck, r as registerKillSessionHandler, i as renderTerminalOutputPreview, p as prepareTerminalOutputForForwarding, j as inferToolResultError, h as forwardAgentMessageToProviderSession, e as ensureManagedProviderMachine, M as MissingMachineIdError, b as MessageQueue2, c as resolveHappyOrgQueuedTurn, s as syncControlledByUserState } from './sessionControl-1bT_7OI6.mjs';
+import { b as closeProviderSession, s as stopCaffeinate, r as readManagedSessionTag, a as resolveManagedSessionTag } from './index-CX-F_fuk.mjs';
 import 'cross-spawn';
 import '@agentclientprotocol/sdk';
 import { randomUUID } from 'node:crypto';
@@ -10,7 +10,7 @@ import 'path';
 import 'os';
 import 'child_process';
 import fs from 'node:fs';
-import { join, basename, normalize, delimiter } from 'node:path';
+import { join, normalize, basename, delimiter } from 'node:path';
 import os from 'node:os';
 import { spawn, execFileSync } from 'node:child_process';
 import 'node:readline';
@@ -24,12 +24,19 @@ import 'tweetnacl';
 import 'open';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-DIYidT13.mjs';
-import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-CAVeOdyo.mjs';
-import 'zod';
+import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-uQ8jzdzr.mjs';
 import 'socket.io-client';
 import 'expo-server-sdk';
-import './types-CiliQpqS.mjs';
+import { M as MessageBuffer, C as ConversationHistory$1, b as buildTurnResultPushNotification, a as buildReadyPushNotification, l as launchRuntimeHandleWithFactoryResult, d as createSessionTranscriptInkRenderer, e as extractPermissionRequestPushContext, c as buildPermissionPushNotification } from './ConversationHistory-CI5bBfuA.mjs';
+import { f as formatDisplayMessage, t as truncateDisplayMessage } from './RuntimeShell-BDt42io_.mjs';
+import { A as AcpBackend } from './AcpBackend-CqO3D07V.mjs';
+import { v as validateCodexAcpSpawn } from './resolveCommand-B3BGyBE2.mjs';
+import { c as createCodexBackend, a as resolveCodexExecutable, s as shouldUseShellForCodex } from './codex-DLGP8WF6.mjs';
+import { B as BaseReasoningProcessor } from './BaseReasoningProcessor-CjlayL2f.mjs';
+import { F as Future } from './future-xRdLl3vf.mjs';
+import { b as bootstrapManagedProviderSession } from './bootstrapManagedProviderSession-D2Z6YU3n.mjs';
+import { i as installFatalProcessHandlers } from './installFatalProcessHandlers-0vaw9MAz.mjs';
+import 'zod';
 import 'qrcode-terminal';
 import 'node:module';
 import 'url';
@@ -238,12 +245,19 @@ class CodexSession {
     this.sessionId = sessionId;
     this.client.updateMetadata((metadata) => ({
       ...metadata,
-      codexSessionId: sessionId
+      codexSessionId: sessionId,
+      codexSessionCwd: this.path
     }));
     logger.debug(`[CodexSession] Session ID ${sessionId} added to metadata`);
   };
   clearSessionId = () => {
     this.sessionId = null;
+    this.client.updateMetadata((metadata) => {
+      const nextMetadata = { ...metadata };
+      delete nextMetadata.codexSessionId;
+      delete nextMetadata.codexSessionCwd;
+      return nextMetadata;
+    });
     logger.debug("[CodexSession] Session ID cleared");
   };
   handleUserObserverEphemeral = (event) => {
@@ -515,6 +529,113 @@ function getCodexExecutionFingerprint(mode) {
   });
 }
 
+function getCodexSessionsRoot(options = {}) {
+  const codexHomeDir = options.codexHomeDir || process.env.CODEX_HOME || join(os.homedir(), ".codex");
+  return join(codexHomeDir, "sessions");
+}
+function collectFilesRecursive(dir, acc = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFilesRecursive(full, acc);
+    } else if (entry.isFile()) {
+      acc.push(full);
+    }
+  }
+  return acc;
+}
+function extractCodexSessionIdFromPath(filePath) {
+  const match = filePath.match(/-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/);
+  return match?.[1] ?? null;
+}
+function normalizePathForSessionMatch(path) {
+  const normalizedPath = normalize(path).replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+}
+function extractCodexSessionCwdFromFile(filePath) {
+  let contents;
+  try {
+    contents = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of contents.split(/\r?\n/)) {
+    if (!line.trim()) {
+      continue;
+    }
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record.type !== "session_meta" || typeof record.payload !== "object" || record.payload === null) {
+      continue;
+    }
+    const cwd = record.payload.cwd;
+    return typeof cwd === "string" && cwd.trim().length > 0 ? cwd : null;
+  }
+  return null;
+}
+function codexSessionFileMatchesCwd(filePath, cwd) {
+  const expectedCwd = cwd?.trim();
+  if (!expectedCwd) {
+    return true;
+  }
+  const actualCwd = extractCodexSessionCwdFromFile(filePath);
+  if (!actualCwd) {
+    return false;
+  }
+  return normalizePathForSessionMatch(actualCwd) === normalizePathForSessionMatch(expectedCwd);
+}
+function findCodexResumeFile(sessionId, options = {}) {
+  if (!sessionId) return null;
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
+      try {
+        return fs.statSync(full).isFile();
+      } catch {
+        return false;
+      }
+    }).filter((full) => codexSessionFileMatchesCwd(full, options.cwd)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return candidates[0] || null;
+  } catch {
+    return null;
+  }
+}
+function isCodexResumeSessionValidForCwd(sessionId, cwd, options = {}) {
+  if (!sessionId?.trim()) {
+    return false;
+  }
+  return findCodexResumeFile(sessionId, { ...options, cwd }) !== null;
+}
+function findLatestCodexSessionIdSince(startTimeMs, options = {}) {
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).filter((full) => full.endsWith(".jsonl")).filter((full) => {
+      try {
+        return fs.statSync(full).mtimeMs >= startTimeMs;
+      } catch {
+        return false;
+      }
+    }).filter((full) => codexSessionFileMatchesCwd(full, options.cwd)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    for (const candidate of candidates) {
+      const sessionId = extractCodexSessionIdFromPath(candidate);
+      if (sessionId) {
+        return sessionId;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -690,6 +811,17 @@ function shouldInjectLargeOutputRecoveryHint(error) {
   ].filter(Boolean).join("\n").toLowerCase();
   return searchableText.includes("memory allocation of") || searchableText.includes("out of memory") || searchableText.includes("oversized command output");
 }
+function isCodexUnknownResumeSessionError(error) {
+  const record = typeof error === "object" && error !== null ? error : null;
+  const searchableText = [
+    formatDisplayMessage(error).trim(),
+    record ? formatDisplayMessage(record.message).trim() : "",
+    record ? formatDisplayMessage(record.stderr).trim() : "",
+    record ? formatDisplayMessage(record.detail).trim() : "",
+    record ? formatDisplayMessage(record.data).trim() : ""
+  ].filter(Boolean).join("\n");
+  return /unknown (session|thread)|session .* not found|thread .* not found|conversation .* not found|missing rollout path for thread|state db missing rollout path|no rollout found for thread id|resource not found/i.test(searchableText);
+}
 function normalizeCodexBackendError(error) {
   const record = typeof error === "object" && error !== null ? error : null;
   const text = formatDisplayMessage(error).trim();
@@ -1173,6 +1305,11 @@ async function codexRemoteLauncher(session) {
   };
   const createRuntimeHandle = async (mode) => {
     const executionMode = resolveCodexAcpExecutionMode(mode);
+    const resumeSessionId = session.sessionId && isCodexResumeSessionValidForCwd(session.sessionId, session.path) ? session.sessionId : null;
+    if (session.sessionId && !resumeSessionId) {
+      logger.debug(`[Codex] Refusing to resume Codex session ${session.sessionId} because its local session file does not match cwd ${session.path}`);
+      session.clearSessionId();
+    }
     const validation = validateCodexAcpSpawn({
       command: process.env.HAPPY_CODEX_ACP_COMMAND,
       model: executionMode.model,
@@ -1193,7 +1330,7 @@ async function codexRemoteLauncher(session) {
         sandbox: executionMode.sandbox,
         approvalPolicy: executionMode.approvalPolicy,
         permissionHandler,
-        resumeSessionId: session.sessionId,
+        resumeSessionId,
         selectionHandler: {
           handleSelection: (request) => selectionHandler.requestSelection(request)
         }
@@ -1344,12 +1481,31 @@ async function codexRemoteLauncher(session) {
       const turnSignal = abortController.signal;
       let sentTurnResultPush = false;
       let turnStatus = "task_complete";
+      let retryingWithFreshSession = false;
       currentHappyOrgTurn = message.mode.happyOrg ?? null;
       try {
         turnInFlight = true;
         shouldCommitAccumulatedResponse = false;
         const isNewRuntimeSession = runtimeHandle === null;
-        const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        const attemptedResumeSessionId = isNewRuntimeSession ? session.sessionId : null;
+        let activeRuntimeHandle;
+        try {
+          activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        } catch (error) {
+          if (!isNewRuntimeSession || !attemptedResumeSessionId || !isCodexUnknownResumeSessionError(error) || turnSignal.aborted) {
+            throw error;
+          }
+          logger.debug(`[Codex] Resume session ${attemptedResumeSessionId} failed during ACP startup; retrying with a fresh session`, error);
+          queueHistoryInjectionForRestart("Codex resume session is unavailable. Retrying with a fresh Codex session...");
+          session.clearSessionId();
+          currentModeHash = null;
+          permissionHandler.reset();
+          selectionHandler.reset();
+          resetTurnState();
+          pending = message;
+          retryingWithFreshSession = true;
+          continue;
+        }
         if (!activeRuntimeHandle) {
           throw new Error("Failed to create Codex ACP backend");
         }
@@ -1376,8 +1532,25 @@ ${message.message}` : message.message;
           promptToSend = buildHappyOrgTurnPrompt(promptToSend, message.mode.happyOrg);
         }
         conversationHistory.addUserMessage(message.message);
-        await activeRuntimeHandle.sendPrompt(promptToSend);
-        await waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
+        try {
+          await activeRuntimeHandle.sendPrompt(promptToSend);
+          await waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
+        } catch (error) {
+          if (!isNewRuntimeSession || !attemptedResumeSessionId || !isCodexUnknownResumeSessionError(error) || turnSignal.aborted) {
+            throw error;
+          }
+          logger.debug(`[Codex] Resume session ${attemptedResumeSessionId} is unavailable; retrying with a fresh ACP session`, error);
+          queueHistoryInjectionForRestart("Codex resume session is unavailable. Retrying with a fresh Codex session...");
+          await disposeRuntimeHandle();
+          session.clearSessionId();
+          currentModeHash = null;
+          permissionHandler.reset();
+          selectionHandler.reset();
+          resetTurnState();
+          pending = message;
+          retryingWithFreshSession = true;
+          continue;
+        }
         reasoningProcessor.completeCurrent();
         shouldCommitAccumulatedResponse = true;
         shouldInjectHistoryOnNextSession = false;
@@ -1407,6 +1580,9 @@ ${message.message}` : message.message;
         }
       } finally {
         turnInFlight = false;
+        if (retryingWithFreshSession) {
+          continue;
+        }
         const finalizedTurn = await finalizeHappyOrgTurnWithBusinessAck({
           metadata: session.runtimeSession.getMetadataSnapshot?.() ?? null,
           queuedTurn: message.mode.happyOrg,
@@ -1502,52 +1678,6 @@ ${message.message}` : message.message;
   return shouldSwitchToLocal ? "switch" : "exit";
 }
 
-function getCodexSessionsRoot(options = {}) {
-  const codexHomeDir = options.codexHomeDir || process.env.CODEX_HOME || join(os.homedir(), ".codex");
-  return join(codexHomeDir, "sessions");
-}
-function collectFilesRecursive(dir, acc = []) {
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return acc;
-  }
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      collectFilesRecursive(full, acc);
-    } else if (entry.isFile()) {
-      acc.push(full);
-    }
-  }
-  return acc;
-}
-function extractCodexSessionIdFromPath(filePath) {
-  const match = filePath.match(/-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/);
-  return match?.[1] ?? null;
-}
-function findLatestCodexSessionIdSince(startTimeMs, options = {}) {
-  try {
-    const candidates = collectFilesRecursive(getCodexSessionsRoot(options)).filter((full) => full.endsWith(".jsonl")).filter((full) => {
-      try {
-        return fs.statSync(full).mtimeMs >= startTimeMs;
-      } catch {
-        return false;
-      }
-    }).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    for (const candidate of candidates) {
-      const sessionId = extractCodexSessionIdFromPath(candidate);
-      if (sessionId) {
-        return sessionId;
-      }
-    }
-  } catch {
-    return null;
-  }
-  return null;
-}
-
 const MANAGED_CODEX_HOME_PREFIX = "happy-codex-home-";
 function isManagedCodexHomePath(value) {
   const trimmed = value?.trim();
@@ -1614,12 +1744,17 @@ function terminateCodexLocalChild(pid) {
 }
 async function codexLocal(opts) {
   const baseArgs = [...opts.codexArgs ?? []];
-  const args = opts.sessionId ? ["resume", opts.sessionId, ...baseArgs] : baseArgs;
-  const startTime = Date.now();
-  let detectedSessionId = opts.sessionId;
-  const codexExecutable = resolveCodexExecutable();
   const codexEnv = buildCodexLocalEnv(process.env);
   const codexHomeDir = resolveCodexLocalHomeDir(codexEnv);
+  const resumeSessionId = opts.sessionId && isCodexResumeSessionValidForCwd(opts.sessionId, opts.path, { codexHomeDir }) ? opts.sessionId : null;
+  if (opts.sessionId && !resumeSessionId) {
+    logger.debug(`[CodexLocal] Refusing to resume Codex session ${opts.sessionId} because its local session file does not match cwd ${opts.path}`);
+    opts.onResumeSessionInvalid?.(opts.sessionId);
+  }
+  const args = resumeSessionId ? ["resume", resumeSessionId, ...baseArgs] : baseArgs;
+  const startTime = Date.now();
+  let detectedSessionId = resumeSessionId;
+  const codexExecutable = resolveCodexExecutable();
   logger.debug(`[CodexLocal] Spawning ${codexExecutable} with args: ${JSON.stringify(args)}`);
   releaseTerminalInputForChild();
   clearTerminalForChild();
@@ -1645,7 +1780,7 @@ async function codexLocal(opts) {
         if (detectedSessionId) {
           return;
         }
-        const nextSessionId = findLatestCodexSessionIdSince(startTime, { codexHomeDir });
+        const nextSessionId = findLatestCodexSessionIdSince(startTime, { codexHomeDir, cwd: opts.path });
         if (nextSessionId) {
           detectedSessionId = nextSessionId;
           logger.debug(`[CodexLocal] Detected session ID: ${nextSessionId}`);
@@ -1788,6 +1923,7 @@ async function codexLocalLauncher(session) {
           abort: processAbortController.signal,
           codexArgs: session.codexArgs,
           onSessionFound: recordSessionFound,
+          onResumeSessionInvalid: session.clearSessionId,
           onThinkingChange: session.onThinkingChange
         });
         if (sessionId) {
@@ -1861,58 +1997,6 @@ async function codexLoop(opts) {
   });
 }
 
-function normalizeFatalProcessError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  const message = typeof error === "string" ? error : (() => {
-    try {
-      const serialized = JSON.stringify(error);
-      return serialized && serialized !== "{}" ? serialized : String(error);
-    } catch {
-      return String(error);
-    }
-  })();
-  return new Error(message || "Unknown fatal process error");
-}
-function installFatalProcessHandlers(options) {
-  const target = options.target ?? process;
-  const exit = options.exit ?? process.exit;
-  let shuttingDown = false;
-  let disposed = false;
-  const handleFatalEvent = async (event, reason) => {
-    const error = normalizeFatalProcessError(reason);
-    logger.debug(`[${options.label}] Fatal ${event}`, error);
-    if (shuttingDown) {
-      logger.debug(`[${options.label}] Ignoring duplicate fatal ${event} while shutdown is already in progress`);
-      return;
-    }
-    shuttingDown = true;
-    try {
-      await options.cleanup({ event, error });
-    } catch (cleanupError) {
-      logger.debug(`[${options.label}] Fatal cleanup failed`, cleanupError);
-    }
-    exit(1);
-  };
-  const onUncaughtException = (error) => {
-    void handleFatalEvent("uncaughtException", error);
-  };
-  const onUnhandledRejection = (reason) => {
-    void handleFatalEvent("unhandledRejection", reason);
-  };
-  target.on("uncaughtException", onUncaughtException);
-  target.on("unhandledRejection", onUnhandledRejection);
-  return () => {
-    if (disposed) {
-      return;
-    }
-    disposed = true;
-    target.off("uncaughtException", onUncaughtException);
-    target.off("unhandledRejection", onUnhandledRejection);
-  };
-}
-
 function normalizeResumeSessionId(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -1957,6 +2041,17 @@ function normalizeCodexArgsForHappy(options) {
   };
 }
 
+function normalizePathForCodexResumeIdentity(path) {
+  const normalized = path.trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function codexResumeCwdMatches(expected, actual) {
+  const normalizedExpected = expected?.trim();
+  if (!normalizedExpected) {
+    return true;
+  }
+  return normalizePathForCodexResumeIdentity(normalizedExpected) === normalizePathForCodexResumeIdentity(actual);
+}
 function resolveInitialCodexPermissionMode(opts) {
   if (opts.permissionMode) {
     return opts.permissionMode;
@@ -2056,6 +2151,20 @@ async function runCodex(opts) {
     }
   });
   sessionClient = initialSession;
+  const metadataCodexSessionCwd = typeof metadata.codexSessionCwd === "string" ? metadata.codexSessionCwd : null;
+  const requestedResumeSessionId = normalizedArgs.resumeSessionId;
+  const requestedResumeCwd = opts.resumeSessionCwd ?? metadataCodexSessionCwd;
+  const resumeSessionMatchesCwd = requestedResumeSessionId ? codexResumeCwdMatches(requestedResumeCwd, metadata.path) && isCodexResumeSessionValidForCwd(requestedResumeSessionId, metadata.path) : false;
+  const initialCodexSessionId = requestedResumeSessionId && resumeSessionMatchesCwd ? requestedResumeSessionId : null;
+  if (requestedResumeSessionId && !resumeSessionMatchesCwd) {
+    logger.debug(`[codex] Ignoring resume session ${requestedResumeSessionId} because it does not match cwd ${metadata.path}`);
+    sessionClient.updateMetadata((currentMetadata) => {
+      const nextMetadata = { ...currentMetadata };
+      delete nextMetadata.codexSessionId;
+      delete nextMetadata.codexSessionCwd;
+      return nextMetadata;
+    });
+  }
   const messageQueue = new MessageQueue2(getCodexExecutionFingerprint);
   let currentPermissionMode = initialPermissionMode;
   let currentModel;
@@ -2102,7 +2211,7 @@ async function runCodex(opts) {
     path: metadata.path,
     logPath: logger.logFilePath,
     startupRolePrompt: happyOrgStartupBinding?.identityPrompt ?? null,
-    sessionId: normalizedArgs.resumeSessionId,
+    sessionId: initialCodexSessionId,
     mode: requestedStartingMode,
     messageQueue,
     codexArgs: normalizedArgs.codexArgs,