happy-imou-cloud 2.1.49 → 2.1.50

package/dist/{runCodex-BbgLVjb9.mjs → runCodex-e_D1Jd_w.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 { p as preserveSessionRuntimeMetadata, l as logger, h as hashObject, d as AssistantMessageStream, b as connectionState, A as ApiClient } from './api-6B4EMs47.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-ggfGac_S.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-CyGHrYHl.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,8 +24,8 @@ 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 { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-CO6foZET.mjs';
+import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-2qoX8OA1.mjs';
 import 'zod';
 import 'socket.io-client';
 import 'expo-server-sdk';
@@ -238,12 +238,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 +522,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 +804,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 +1298,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 +1323,7 @@ async function codexRemoteLauncher(session) {
         sandbox: executionMode.sandbox,
         approvalPolicy: executionMode.approvalPolicy,
         permissionHandler,
-        resumeSessionId: session.sessionId,
+        resumeSessionId,
         selectionHandler: {
           handleSelection: (request) => selectionHandler.requestSelection(request)
         }
@@ -1344,12 +1474,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 +1525,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 +1573,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 +1671,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 +1737,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 +1773,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 +1916,7 @@ async function codexLocalLauncher(session) {
           abort: processAbortController.signal,
           codexArgs: session.codexArgs,
           onSessionFound: recordSessionFound,
+          onResumeSessionInvalid: session.clearSessionId,
           onThinkingChange: session.onThinkingChange
         });
         if (sessionId) {
@@ -1957,6 +2086,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 +2196,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 +2256,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,