happy-imou-cloud 1.1.7 → 2.0.0

package/dist/runCodex-Cm0VTqw_.cjs

@@ -0,0 +1,1848 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var api = require('./api-D7OK-mML.cjs');
+var persistence = require('./persistence-DHgf1CTG.cjs');
+var index = require('./index-B_wlQBy2.cjs');
+var BaseReasoningProcessor = require('./BaseReasoningProcessor-BRCQXCZY.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-CLREXN11.cjs');
+var future = require('./future-Dq4Ha1Dn.cjs');
+var node_child_process = require('node:child_process');
+var fs = require('node:fs');
+var os = require('node:os');
+var path = require('node:path');
+var React = require('react');
+var ink = require('ink');
+var index_js = require('@modelcontextprotocol/sdk/client/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
+var z = require('zod');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var child_process = require('child_process');
+require('axios');
+require('chalk');
+require('fs');
+require('node:events');
+require('socket.io-client');
+require('tweetnacl');
+require('util');
+require('fs/promises');
+require('crypto');
+require('path');
+require('expo-server-sdk');
+require('node:fs/promises');
+require('os');
+require('tmp');
+require('qrcode-terminal');
+require('node:module');
+require('open');
+require('url');
+require('ps-list');
+require('cross-spawn');
+require('fastify');
+require('fastify-type-provider-zod');
+require('node:readline');
+require('http');
+require('@agentclientprotocol/sdk');
+require('./types-DVk3crez.cjs');
+
+const DEFAULT_CAPABILITIES = {
+  committedMessageAcks: false,
+  pendingQueueV2: false,
+  userScopedSocket: false,
+  snapshotChangeCatchup: false,
+  structuredSpawnErrors: false,
+  metadataWatch: false
+};
+function normalizeHappyUserMessage(message) {
+  return {
+    text: message.content.text,
+    permissionMode: message.meta?.permissionMode,
+    model: message.meta?.model ?? void 0,
+    localId: message.localKey ?? null,
+    raw: message
+  };
+}
+function createLegacyHappyCodexSessionAdapter(options) {
+  let metadataSnapshot = options.initialMetadata ?? options.session.getMetadataSnapshot?.() ?? null;
+  let agentStateSnapshot = options.initialAgentState ?? options.session.getAgentStateSnapshot?.() ?? null;
+  return {
+    sessionId: options.session.sessionId,
+    capabilities: DEFAULT_CAPABILITIES,
+    onUserMessage(callback) {
+      options.session.onUserMessage((message) => {
+        callback(normalizeHappyUserMessage(message));
+      });
+    },
+    sendCodexMessage(body) {
+      options.session.sendCodexMessage(body);
+    },
+    sendAgentMessage(body) {
+      options.session.sendAgentMessage("codex", body);
+    },
+    sendSessionEvent(event, id) {
+      options.session.sendSessionEvent(event, id);
+    },
+    keepAlive(thinking, mode) {
+      options.session.keepAlive(thinking, mode);
+    },
+    sendSessionDeath() {
+      options.session.sendSessionDeath();
+    },
+    updateMetadata(handler) {
+      options.session.updateMetadata((current) => {
+        const next = handler(current);
+        metadataSnapshot = next;
+        return next;
+      });
+    },
+    updateAgentState(handler) {
+      options.session.updateAgentState((current) => {
+        const next = handler(current);
+        agentStateSnapshot = next;
+        return next;
+      });
+    },
+    getMetadataSnapshot() {
+      return metadataSnapshot;
+    },
+    getAgentStateSnapshot() {
+      return agentStateSnapshot;
+    },
+    async waitForMetadataUpdate(signal) {
+      const metadata = await (options.session.waitForMetadataUpdate?.(signal) ?? Promise.resolve(metadataSnapshot));
+      metadataSnapshot = metadata;
+      return metadata;
+    },
+    async flush() {
+      await options.session.flush();
+    },
+    async close() {
+      await options.session.close();
+    }
+  };
+}
+
+class CodexSession {
+  path;
+  logPath;
+  api;
+  client;
+  runtimeSession;
+  queue;
+  codexArgs;
+  sessionId;
+  mode;
+  thinking = false;
+  keepAliveInterval;
+  onModeChangeCallback;
+  clientSwapCallbacks = [];
+  supersedePendingInteractionsCallback = null;
+  constructor(opts) {
+    this.path = opts.path;
+    this.api = opts.api;
+    this.client = opts.client;
+    this.runtimeSession = createLegacyHappyCodexSessionAdapter({
+      session: opts.client
+    });
+    this.logPath = opts.logPath;
+    this.sessionId = opts.sessionId;
+    this.mode = opts.mode;
+    this.queue = opts.messageQueue;
+    this.codexArgs = opts.codexArgs;
+    this.onModeChangeCallback = opts.onModeChange;
+    this.client.keepAlive(this.thinking, this.mode);
+    this.keepAliveInterval = setInterval(() => {
+      this.client.keepAlive(this.thinking, this.mode);
+    }, 2e3);
+  }
+  cleanup() {
+    clearInterval(this.keepAliveInterval);
+    api.logger.debug("[CodexSession] Cleaned up resources");
+  }
+  updateClient = (client) => {
+    this.client = client;
+    this.runtimeSession = createLegacyHappyCodexSessionAdapter({
+      session: client
+    });
+    for (const callback of this.clientSwapCallbacks) {
+      callback(client);
+    }
+  };
+  addClientSwapCallback = (callback) => {
+    this.clientSwapCallbacks.push(callback);
+  };
+  removeClientSwapCallback = (callback) => {
+    const index = this.clientSwapCallbacks.indexOf(callback);
+    if (index !== -1) {
+      this.clientSwapCallbacks.splice(index, 1);
+    }
+  };
+  setPendingInteractionSuperseder = (callback) => {
+    this.supersedePendingInteractionsCallback = callback;
+  };
+  supersedePendingInteractions = (reason) => {
+    return this.supersedePendingInteractionsCallback?.(reason) ?? false;
+  };
+  onThinkingChange = (thinking) => {
+    this.thinking = thinking;
+    this.client.keepAlive(thinking, this.mode);
+  };
+  onModeChange = (mode) => {
+    this.mode = mode;
+    this.client.keepAlive(this.thinking, mode);
+    this.onModeChangeCallback(mode);
+  };
+  onSessionFound = (sessionId) => {
+    if (this.sessionId === sessionId) {
+      return;
+    }
+    this.sessionId = sessionId;
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      codexSessionId: sessionId
+    }));
+    api.logger.debug(`[CodexSession] Session ID ${sessionId} added to metadata`);
+  };
+  clearSessionId = () => {
+    this.sessionId = null;
+    api.logger.debug("[CodexSession] Session ID cleared");
+  };
+}
+
+function getCodexSessionsRoot() {
+  const codexHomeDir = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+  return path.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 = path.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 findCodexResumeFile(sessionId) {
+  if (!sessionId) return null;
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot()).filter((full) => full.endsWith(`-${sessionId}.jsonl`)).filter((full) => {
+      try {
+        return fs.statSync(full).isFile();
+      } catch {
+        return false;
+      }
+    }).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return candidates[0] || null;
+  } catch {
+    return null;
+  }
+}
+function findLatestCodexSessionIdSince(startTimeMs) {
+  try {
+    const candidates = collectFilesRecursive(getCodexSessionsRoot()).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;
+}
+
+class CodexExitCodeError extends Error {
+  exitCode;
+  constructor(exitCode) {
+    super(`Codex process exited with code: ${exitCode}`);
+    this.name = "CodexExitCodeError";
+    this.exitCode = exitCode;
+  }
+}
+function terminateCodexLocalChild(pid) {
+  if (!pid) {
+    return;
+  }
+  try {
+    if (process.platform === "win32") {
+      node_child_process.execFileSync("taskkill", ["/F", "/T", "/PID", pid.toString()], { stdio: "ignore" });
+      return;
+    }
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    api.logger.debug("[CodexLocal] Failed to terminate child process", error);
+  }
+}
+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 = index.resolveCodexExecutable();
+  api.logger.debug(`[CodexLocal] Spawning ${codexExecutable} with args: ${JSON.stringify(args)}`);
+  process.stdin.pause();
+  try {
+    await new Promise((resolve, reject) => {
+      const child = node_child_process.spawn(codexExecutable, args, {
+        cwd: opts.path,
+        env: process.env,
+        stdio: "inherit",
+        signal: opts.abort,
+        shell: index.shouldUseShellForCodex(codexExecutable)
+      });
+      const abortChild = () => {
+        if (child.exitCode === null) {
+          api.logger.debug(`[CodexLocal] Abort received, terminating child tree pid=${child.pid ?? "none"}`);
+          terminateCodexLocalChild(child.pid);
+        }
+      };
+      opts.abort.addEventListener("abort", abortChild, { once: true });
+      const sessionPoll = setInterval(() => {
+        if (detectedSessionId) {
+          return;
+        }
+        const nextSessionId = findLatestCodexSessionIdSince(startTime);
+        if (nextSessionId) {
+          detectedSessionId = nextSessionId;
+          api.logger.debug(`[CodexLocal] Detected session ID: ${nextSessionId}`);
+          opts.onSessionFound(nextSessionId);
+        }
+      }, 1e3);
+      child.on("error", (error) => {
+        clearInterval(sessionPoll);
+        opts.abort.removeEventListener("abort", abortChild);
+        reject(error);
+      });
+      child.on("exit", (code, signal) => {
+        clearInterval(sessionPoll);
+        opts.abort.removeEventListener("abort", abortChild);
+        opts.onThinkingChange?.(false);
+        if (signal === "SIGTERM" && opts.abort.aborted) {
+          resolve();
+          return;
+        }
+        if (signal) {
+          reject(new Error(`Codex terminated with signal: ${signal}`));
+          return;
+        }
+        if (code !== 0 && code !== null) {
+          reject(new CodexExitCodeError(code));
+          return;
+        }
+        resolve();
+      });
+    });
+  } finally {
+    process.stdin.resume();
+    opts.onThinkingChange?.(false);
+  }
+  return detectedSessionId;
+}
+
+async function codexLocalLauncher(session) {
+  let exitReason = null;
+  const processAbortController = new AbortController();
+  const exitFuture = new future.Future();
+  try {
+    async function abort() {
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+      await exitFuture.promise;
+    }
+    async function doSwitch() {
+      api.logger.debug("[codex-local]: switching to remote mode");
+      if (!exitReason) {
+        exitReason = { type: "switch" };
+      }
+      await abort();
+    }
+    async function doAbort() {
+      api.logger.debug("[codex-local]: abort requested");
+      if (!exitReason) {
+        exitReason = { type: "switch" };
+      }
+      session.queue.reset();
+      await abort();
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    session.queue.setOnMessage(() => {
+      void doSwitch();
+    });
+    if (session.queue.size() > 0) {
+      return { type: "switch" };
+    }
+    while (true) {
+      if (exitReason) {
+        return exitReason;
+      }
+      try {
+        const sessionId = await codexLocal({
+          path: session.path,
+          sessionId: session.sessionId,
+          abort: processAbortController.signal,
+          codexArgs: session.codexArgs,
+          onSessionFound: session.onSessionFound,
+          onThinkingChange: session.onThinkingChange
+        });
+        if (sessionId) {
+          session.onSessionFound(sessionId);
+        }
+        if (!exitReason) {
+          exitReason = { type: "exit", code: 0 };
+          break;
+        }
+      } catch (error) {
+        api.logger.debug("[codex-local]: launch error", error);
+        if (error instanceof CodexExitCodeError && !exitReason) {
+          exitReason = { type: "exit", code: error.exitCode };
+          break;
+        }
+        if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EINVAL") && !exitReason) {
+          exitReason = { type: "exit", code: 1 };
+          session.runtimeSession.sendSessionEvent({ type: "message", message: "Codex CLI not found. Check your local Codex installation." });
+          break;
+        }
+        if (!exitReason) {
+          session.runtimeSession.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          continue;
+        }
+        break;
+      }
+    }
+  } finally {
+    exitFuture.resolve(void 0);
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+  }
+  return exitReason || { type: "exit", code: 0 };
+}
+
+const CodexDisplay = ({ messageBuffer, logPath, onExit, onSwitchToLocal, title }) => {
+  const [messages, setMessages] = React.useState([]);
+  const [confirmationMode, setConfirmationMode] = React.useState(null);
+  const [actionInProgress, setActionInProgress] = React.useState(null);
+  const confirmationTimeoutRef = React.useRef(null);
+  const { stdout } = ink.useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  React.useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
+    };
+  }, [messageBuffer]);
+  const resetConfirmation = React.useCallback(() => {
+    setConfirmationMode(null);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = React.useCallback((mode) => {
+    setConfirmationMode(mode);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  ink.useInput(React.useCallback(async (input, key) => {
+    if (actionInProgress) return;
+    if (key.ctrl && input === "c") {
+      if (confirmationMode === "exit") {
+        resetConfirmation();
+        setActionInProgress("exiting");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onExit?.();
+      } else {
+        setConfirmationWithTimeout("exit");
+      }
+      return;
+    }
+    if (input === " ") {
+      if (confirmationMode === "switch") {
+        resetConfirmation();
+        setActionInProgress("switching");
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onSwitchToLocal?.();
+      } else {
+        setConfirmationWithTimeout("switch");
+      }
+      return;
+    }
+    if (confirmationMode) {
+      resetConfirmation();
+    }
+  }, [confirmationMode, actionInProgress, onExit, onSwitchToLocal, setConfirmationWithTimeout, resetConfirmation]));
+  const getMessageColor = (type) => {
+    switch (type) {
+      case "user":
+        return "magenta";
+      case "assistant":
+        return "cyan";
+      case "system":
+        return "blue";
+      case "tool":
+        return "yellow";
+      case "result":
+        return "green";
+      case "status":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const formatMessage = (msg) => {
+    const lines = msg.content.split("\n");
+    const maxLineLength = terminalWidth - 10;
+    return lines.map((line) => {
+      if (line.length <= maxLineLength) return line;
+      const chunks = [];
+      for (let i = 0; i < line.length; i += maxLineLength) {
+        chunks.push(line.slice(i, i + maxLineLength));
+      }
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, title || "\u{1F916} Codex Agent Messages"), /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(ink.Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode === "exit" ? "red" : confirmationMode === "switch" ? "yellow" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress === "exiting" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : actionInProgress === "switching" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Switching to local mode...") : confirmationMode === "exit" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : confirmationMode === "switch" ? /* @__PURE__ */ React.createElement(ink.Text, { color: "yellow", bold: true }, "\u23F8\uFE0F  Press space again to switch to local mode") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Press space for local \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
+function getCodexMcpCommand() {
+  const codexExecutable = index.resolveCodexExecutable();
+  try {
+    const version = child_process.execSync(`"${codexExecutable}" --version`, { encoding: "utf8" }).trim();
+    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
+    if (!match) {
+      api.logger.debug("[CodexMCP] Could not parse codex version:", version);
+      return null;
+    }
+    const versionStr = match[1];
+    const [major, minor, patch] = versionStr.split(/[-.]/).map(Number);
+    if (major > 0 || minor > 43) return "mcp-server";
+    if (minor === 43 && patch === 0) {
+      if (versionStr.includes("-alpha.")) {
+        const alphaNum = parseInt(versionStr.split("-alpha.")[1]);
+        return alphaNum >= 5 ? "mcp-server" : "mcp";
+      }
+      return "mcp-server";
+    }
+    return "mcp";
+  } catch (error) {
+    api.logger.debug("[CodexMCP] Codex CLI not found or not executable:", error);
+    return null;
+  }
+}
+function resolveCodexMcpTransport(executable, mcpCommand) {
+  return {
+    // Preserve the resolved executable path so daemon/service environments do not
+    // depend on APPDATA npm shims being present on PATH.
+    command: executable,
+    args: [mcpCommand]
+  };
+}
+function extractCodexIdentifiers(response) {
+  const meta = response?.meta || {};
+  const structured = response?.structuredContent || response?.structured_content || response?.structured_output || {};
+  const sessionId = meta.sessionId || meta.session_id || response?.sessionId || response?.session_id || meta.threadId || meta.thread_id || response?.threadId || response?.thread_id || structured.threadId || structured.thread_id || null;
+  const conversationId = meta.conversationId || meta.conversation_id || response?.conversationId || response?.conversation_id || meta.threadId || meta.thread_id || response?.threadId || response?.thread_id || structured.threadId || structured.thread_id || structured.conversationId || structured.conversation_id || null;
+  return { sessionId, conversationId };
+}
+function normalizeCodexPermissionRequest(params) {
+  return {
+    requestId: params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id || `codex-permission-${Date.now()}`,
+    toolName: "CodexBash",
+    input: {
+      command: params.codex_command || params.command,
+      cwd: params.codex_cwd || params.cwd,
+      proposed_execpolicy_amendment: params.proposed_execpolicy_amendment,
+      parsed_cmd: params.parsed_cmd
+    }
+  };
+}
+function resolveCodexPermissionRequest(params, fallback) {
+  const normalized = normalizeCodexPermissionRequest(params);
+  const hasInlinePayload = Boolean(
+    normalized.input.command || normalized.input.cwd || normalized.input.proposed_execpolicy_amendment || normalized.input.parsed_cmd
+  );
+  const hasInlineId = Boolean(
+    params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id
+  );
+  if (!fallback || hasInlinePayload && hasInlineId) {
+    return normalized;
+  }
+  return {
+    requestId: hasInlineId ? normalized.requestId : fallback.call_id || normalized.requestId,
+    toolName: normalized.toolName,
+    input: {
+      command: normalized.input.command || fallback.command,
+      cwd: normalized.input.cwd || fallback.cwd,
+      proposed_execpolicy_amendment: normalized.input.proposed_execpolicy_amendment || fallback.proposed_execpolicy_amendment,
+      parsed_cmd: normalized.input.parsed_cmd || fallback.parsed_cmd
+    }
+  };
+}
+class CodexMcpClient {
+  client;
+  transport = null;
+  connected = false;
+  sessionId = null;
+  conversationId = null;
+  handler = null;
+  permissionHandler = null;
+  selectionHandler = null;
+  pendingExecApprovalContexts = [];
+  constructor() {
+    this.client = this.createClient();
+  }
+  createClient() {
+    const client = new index_js.Client(
+      { name: "happy-codex-client", version: "1.0.0" },
+      { capabilities: { elicitation: {} } }
+    );
+    client.setNotificationHandler(z.z.object({
+      method: z.z.literal("codex/event"),
+      params: z.z.object({
+        msg: z.z.any()
+      })
+    }).passthrough(), (data) => {
+      const msg = data.params.msg;
+      if (msg?.type === "exec_approval_request") {
+        this.pendingExecApprovalContexts.push({
+          call_id: msg.call_id,
+          command: msg.command,
+          cwd: msg.cwd,
+          proposed_execpolicy_amendment: msg.proposed_execpolicy_amendment,
+          parsed_cmd: msg.parsed_cmd
+        });
+      }
+      this.updateIdentifiersFromEvent(msg);
+      this.handler?.(msg);
+    });
+    return client;
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Set the permission handler for tool approval
+   */
+  setPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  setSelectionHandler(handler) {
+    this.selectionHandler = handler;
+  }
+  async connect() {
+    if (this.connected) return;
+    const mcpCommand = getCodexMcpCommand();
+    if (mcpCommand === null) {
+      throw new Error(
+        "Codex CLI not found or not executable.\n\nTo install codex:\n  npm install -g @openai/codex\n\nAlternatively, use Claude:\n  happy claude"
+      );
+    }
+    api.logger.debug(`[CodexMCP] Connecting to Codex MCP server using command: codex ${mcpCommand}`);
+    const codexExecutable = index.resolveCodexExecutable();
+    const transport = resolveCodexMcpTransport(codexExecutable, mcpCommand);
+    this.transport = new stdio_js.StdioClientTransport({
+      command: transport.command,
+      args: transport.args,
+      env: Object.keys(process.env).reduce((acc, key) => {
+        const value = process.env[key];
+        if (typeof value === "string") acc[key] = value;
+        return acc;
+      }, {})
+    });
+    this.registerPermissionHandlers();
+    await this.client.connect(this.transport);
+    this.connected = true;
+    api.logger.debug("[CodexMCP] Connected to Codex");
+  }
+  isClosedTransportError(error) {
+    const record = error;
+    const code = typeof record?.code === "number" ? record.code : null;
+    if (code === -32e3) {
+      return true;
+    }
+    const message = typeof record?.message === "string" ? record.message.toLowerCase() : "";
+    if (code === -32001 && message.includes("aborterror")) {
+      return true;
+    }
+    return message.includes("connection closed") || message.includes("not connected");
+  }
+  async callToolWithReconnectRetry(call) {
+    try {
+      return await call();
+    } catch (error) {
+      if (!this.isClosedTransportError(error)) {
+        throw error;
+      }
+      api.logger.debug("[CodexMCP] Transport closed during tool call; reconnecting and retrying once");
+      try {
+        await this.disconnect();
+      } catch {
+      }
+      await this.connect();
+      return await call();
+    }
+  }
+  registerPermissionHandlers() {
+    this.client.setRequestHandler(
+      types_js.ElicitRequestSchema,
+      async (request) => {
+        const params = request.params;
+        api.logger.debug("[CodexMCP] Received elicitation request:", params);
+        try {
+          if (this.isSelectionRequest(params)) {
+            return await this.handleSelectionRequest(params);
+          }
+          if (!this.permissionHandler) {
+            api.logger.debug("[CodexMCP] No permission handler set, denying by default");
+            return {
+              action: "decline",
+              decision: "denied",
+              content: {
+                decision: "denied"
+              }
+            };
+          }
+          const normalized = resolveCodexPermissionRequest(
+            params,
+            this.takeExecApprovalContextForPermission(params)
+          );
+          const result = await this.permissionHandler.handleToolCall(
+            normalized.requestId,
+            normalized.toolName,
+            normalized.input
+          );
+          api.logger.debug("[CodexMCP] Permission result:", result);
+          return {
+            action: result.decision === "abort" ? "cancel" : result.decision === "denied" ? "decline" : "accept",
+            decision: result.decision,
+            content: {
+              decision: result.decision
+            }
+          };
+        } catch (error) {
+          if (error instanceof Error && error.message === "Session reset") {
+            api.logger.debug("[CodexMCP] Permission request cancelled during session reset");
+            return {
+              action: "cancel"
+            };
+          }
+          if (error instanceof Error && error.message === BaseReasoningProcessor.INTERACTION_SUPERSEDED_ERROR) {
+            api.logger.debug("[CodexMCP] Selection request cancelled because a new user message arrived");
+            return {
+              action: "cancel"
+            };
+          }
+          api.logger.debug("[CodexMCP] Error handling permission request:", error);
+          return {
+            action: "decline",
+            decision: "denied",
+            reason: error instanceof Error ? error.message : "Permission request failed"
+          };
+        }
+      }
+    );
+    api.logger.debug("[CodexMCP] Permission handlers registered");
+  }
+  isSelectionRequest(params) {
+    if (Array.isArray(params.codex_command) && params.codex_command.length > 0) {
+      return false;
+    }
+    if (Array.isArray(params.options) && params.options.length > 0) {
+      return true;
+    }
+    return Boolean(params.requestedSchema?.properties?.optionId);
+  }
+  async handleSelectionRequest(params) {
+    const optionMap = (params.options || []).filter((option) => Boolean(option.optionId));
+    const options = optionMap.map((option) => ({
+      optionId: option.optionId,
+      label: option.label || option.name || option.optionId,
+      description: option.description || option.name || option.optionId
+    }));
+    const defaultOptionId = params.requestedSchema?.properties?.optionId?.default;
+    if (options.length === 0) {
+      api.logger.debug("[CodexMCP] Selection request has no options, cancelling");
+      return {
+        action: "cancel"
+      };
+    }
+    if (!this.selectionHandler) {
+      api.logger.debug("[CodexMCP] No selection handler set, cancelling selection request");
+      return {
+        action: "cancel"
+      };
+    }
+    const requestId = params.codex_event_id || params.codex_elicitation || `selection-${Date.now()}`;
+    const response = await this.selectionHandler.requestSelection({
+      id: requestId,
+      message: params.message,
+      options,
+      defaultOptionId
+    });
+    return {
+      action: "accept",
+      optionId: response.optionId,
+      content: {
+        optionId: response.optionId
+      }
+    };
+  }
+  takeExecApprovalContextForPermission(params) {
+    const hasInlinePayload = Boolean(
+      params.codex_command || params.command || params.codex_cwd || params.cwd || params.proposed_execpolicy_amendment || params.parsed_cmd
+    );
+    const explicitId = params.codex_call_id || params.call_id || params.codex_mcp_tool_call_id || params.codex_event_id;
+    if (hasInlinePayload && explicitId) {
+      return null;
+    }
+    if (!this.pendingExecApprovalContexts.length) {
+      return null;
+    }
+    if (explicitId) {
+      const index = this.pendingExecApprovalContexts.findIndex((context) => context.call_id === explicitId);
+      if (index >= 0) {
+        return this.pendingExecApprovalContexts.splice(index, 1)[0] || null;
+      }
+    }
+    return this.pendingExecApprovalContexts.shift() || null;
+  }
+  async startSession(config, options) {
+    if (!this.connected) await this.connect();
+    api.logger.debug("[CodexMCP] Starting Codex session:", config);
+    const response = await this.callToolWithReconnectRetry(
+      () => this.client.callTool({
+        name: "codex",
+        arguments: config
+      }, void 0, {
+        signal: options?.signal,
+        timeout: DEFAULT_TIMEOUT
+      })
+    );
+    api.logger.debug("[CodexMCP] startSession response:", response);
+    this.extractIdentifiers(response);
+    return response;
+  }
+  async continueSession(prompt, options) {
+    if (!this.connected) await this.connect();
+    if (!this.sessionId) {
+      throw new Error("No active session. Call startSession first.");
+    }
+    if (!this.conversationId) {
+      this.conversationId = this.sessionId;
+      api.logger.debug("[CodexMCP] conversationId missing, defaulting to sessionId:", this.conversationId);
+    }
+    const args = { sessionId: this.sessionId, conversationId: this.conversationId, prompt };
+    api.logger.debug("[CodexMCP] Continuing Codex session:", args);
+    const response = await this.callToolWithReconnectRetry(
+      () => this.client.callTool({
+        name: "codex-reply",
+        arguments: args
+      }, void 0, {
+        signal: options?.signal,
+        timeout: DEFAULT_TIMEOUT
+      })
+    );
+    api.logger.debug("[CodexMCP] continueSession response:", response);
+    this.extractIdentifiers(response);
+    return response;
+  }
+  updateIdentifiersFromEvent(event) {
+    if (!event || typeof event !== "object") {
+      return;
+    }
+    const candidates = [event];
+    if (event.data && typeof event.data === "object") {
+      candidates.push(event.data);
+    }
+    for (const candidate of candidates) {
+      const sessionId = candidate.session_id ?? candidate.sessionId ?? candidate.thread_id ?? candidate.threadId;
+      if (sessionId) {
+        this.sessionId = sessionId;
+        api.logger.debug("[CodexMCP] Session ID extracted from event:", this.sessionId);
+      }
+      const conversationId = candidate.conversation_id ?? candidate.conversationId;
+      if (conversationId) {
+        this.conversationId = conversationId;
+        api.logger.debug("[CodexMCP] Conversation ID extracted from event:", this.conversationId);
+      }
+    }
+  }
+  extractIdentifiers(response) {
+    const identifiers = extractCodexIdentifiers(response);
+    if (identifiers.sessionId) {
+      this.sessionId = identifiers.sessionId;
+      api.logger.debug("[CodexMCP] Session ID extracted:", this.sessionId);
+    }
+    if (identifiers.conversationId) {
+      this.conversationId = identifiers.conversationId;
+      api.logger.debug("[CodexMCP] Conversation ID extracted:", this.conversationId);
+    }
+    const content = response?.content;
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (!this.sessionId && item?.sessionId) {
+          this.sessionId = item.sessionId;
+          api.logger.debug("[CodexMCP] Session ID extracted from content:", this.sessionId);
+        }
+        if (!this.conversationId && item && typeof item === "object" && "conversationId" in item && item.conversationId) {
+          this.conversationId = item.conversationId;
+          api.logger.debug("[CodexMCP] Conversation ID extracted from content:", this.conversationId);
+        }
+      }
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  hasActiveSession() {
+    return this.sessionId !== null;
+  }
+  clearSession() {
+    const previousSessionId = this.sessionId;
+    this.sessionId = null;
+    this.conversationId = null;
+    api.logger.debug("[CodexMCP] Session cleared, previous sessionId:", previousSessionId);
+  }
+  /**
+   * Store the current session ID without clearing it, useful for abort handling
+   */
+  storeSessionForResume() {
+    api.logger.debug("[CodexMCP] Storing session for potential resume:", this.sessionId);
+    return this.sessionId;
+  }
+  /**
+   * Force close the Codex MCP transport and clear all session identifiers.
+   * Use this for permanent shutdown (e.g. kill/exit). Prefer `disconnect()` for
+   * transient connection resets where you may want to keep the session id.
+   */
+  async forceCloseSession() {
+    api.logger.debug("[CodexMCP] Force closing session");
+    try {
+      await this.disconnect();
+    } finally {
+      this.clearSession();
+    }
+    api.logger.debug("[CodexMCP] Session force-closed");
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    const pid = this.transport?.pid ?? null;
+    api.logger.debug(`[CodexMCP] Disconnecting; child pid=${pid ?? "none"}`);
+    try {
+      api.logger.debug("[CodexMCP] client.close begin");
+      await this.client.close();
+      api.logger.debug("[CodexMCP] client.close done");
+    } catch (e) {
+      api.logger.debug("[CodexMCP] Error closing client, attempting transport close directly", e);
+      try {
+        api.logger.debug("[CodexMCP] transport.close begin");
+        await this.transport?.close?.();
+        api.logger.debug("[CodexMCP] transport.close done");
+      } catch {
+      }
+    }
+    if (pid) {
+      try {
+        process.kill(pid, 0);
+        api.logger.debug("[CodexMCP] Child still alive, sending SIGKILL");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      } catch {
+      }
+    }
+    this.transport = null;
+    this.connected = false;
+    this.client = this.createClient();
+    api.logger.debug(`[CodexMCP] Disconnected; session ${this.sessionId ?? "none"} preserved`);
+  }
+}
+
+class CodexPermissionHandler extends BaseReasoningProcessor.BasePermissionHandler {
+  constructor(session) {
+    super(session);
+  }
+  getLogPrefix() {
+    return "[Codex]";
+  }
+  /**
+   * Handle a tool permission request
+   * @param toolCallId - The unique ID of the tool call
+   * @param toolName - The name of the tool being called
+   * @param input - The input parameters for the tool
+   * @returns Promise resolving to permission result
+   */
+  async handleToolCall(toolCallId, toolName, input) {
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(toolCallId, {
+        resolve,
+        reject,
+        toolName,
+        input
+      });
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      api.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})`);
+    });
+  }
+}
+
+class CodexSelectionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  updateSession(newSession) {
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  async requestSelection(request) {
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(request.id, {
+        resolve,
+        reject,
+        request
+      });
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [request.id]: {
+            tool: "AskUserQuestion",
+            arguments: {
+              requestKind: "selection",
+              questions: [
+                {
+                  header: "Codex",
+                  question: request.message,
+                  multiSelect: false,
+                  options: request.options.map((option) => ({
+                    label: option.label,
+                    description: option.description || option.optionId,
+                    optionId: option.optionId
+                  }))
+                }
+              ]
+            },
+            createdAt: Date.now(),
+            requestKind: "selection",
+            options: request.options,
+            defaultOptionId: request.defaultOptionId
+          }
+        }
+      }));
+      api.logger.debug(`[Codex] Selection request sent (${request.id}) with ${request.options.length} options`);
+    });
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = BaseReasoningProcessor.INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    api.logger.debug(`[Codex] Superseded ${pendingSnapshot.length} pending selection request(s)`);
+    return pendingSnapshot.length;
+  }
+  reset(reason = "Session reset") {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    this.pendingRequests.clear();
+    for (const [, pending] of pendingSnapshot) {
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+  }
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler("selection", async (response) => {
+      const pending = this.pendingRequests.get(response.id);
+      if (!pending) {
+        api.logger.debug("[Codex] Selection request not found or already resolved");
+        return;
+      }
+      this.pendingRequests.delete(response.id);
+      pending.resolve(response);
+      this.session.updateAgentState((currentState) => {
+        const request = currentState.requests?.[response.id];
+        if (!request) {
+          return currentState;
+        }
+        const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+        return {
+          ...currentState,
+          requests: remainingRequests,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [response.id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: "approved",
+              requestKind: "selection",
+              selectedOptionId: response.optionId
+            }
+          }
+        };
+      });
+    });
+  }
+}
+
+class ReasoningProcessor extends BaseReasoningProcessor.BaseReasoningProcessor {
+  getToolName() {
+    return "CodexReasoning";
+  }
+  getLogPrefix() {
+    return "[ReasoningProcessor]";
+  }
+  /**
+   * Process a reasoning delta and accumulate content.
+   */
+  processDelta(delta) {
+    this.processInput(delta);
+  }
+  /**
+   * Complete the reasoning section with final text.
+   */
+  complete(fullText) {
+    this.completeReasoning(fullText);
+  }
+}
+
+class DiffProcessor {
+  previousDiff = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+  }
+  /**
+   * Process a turn_diff message and check if the unified_diff has changed
+   */
+  processDiff(unifiedDiff) {
+    if (this.previousDiff !== unifiedDiff) {
+      api.logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
+      const callId = node_crypto.randomUUID();
+      const toolCall = {
+        type: "tool-call",
+        name: "CodexDiff",
+        callId,
+        input: {
+          unified_diff: unifiedDiff
+        },
+        id: node_crypto.randomUUID()
+      };
+      this.onMessage?.(toolCall);
+      const toolResult = {
+        type: "tool-call-result",
+        callId,
+        output: {
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
+      };
+      this.onMessage?.(toolResult);
+    }
+    this.previousDiff = unifiedDiff;
+    api.logger.debug("[DiffProcessor] Updated stored diff");
+  }
+  /**
+   * Reset the processor state (called on task_complete or turn_aborted)
+   */
+  reset() {
+    api.logger.debug("[DiffProcessor] Resetting diff state");
+    this.previousDiff = null;
+  }
+  /**
+   * Set the message callback for sending messages directly
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Get the current diff value
+   */
+  getCurrentDiff() {
+    return this.previousDiff;
+  }
+}
+
+function shouldEmitCodexReadyOnTurnEnd(opts) {
+  return !opts.shouldExit && opts.exitReason !== "switch";
+}
+function shouldEmitCodexReadyAfterWait(opts) {
+  if (opts.readyAlreadySent) {
+    return false;
+  }
+  return !opts.shouldExit && !opts.pending && opts.queueSize === 0;
+}
+function registerCodexRemoteRpcHandlers(clientSession, handlers) {
+  clientSession.rpcHandlerManager.registerHandler("abort", handlers.handleAbort);
+  clientSession.rpcHandlerManager.registerHandler("switch", handlers.handleSwitchToLocal);
+  registerKillSessionHandler.registerKillSessionHandler(clientSession.rpcHandlerManager, handlers.handleKillSession);
+}
+async function codexRemoteLauncher(session) {
+  const messageBuffer = new registerKillSessionHandler.MessageBuffer();
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  let inkInstance = null;
+  let exitReason = null;
+  let shouldExit = false;
+  let abortController = new AbortController();
+  let storedSessionIdForResume = null;
+  const client = new CodexMcpClient();
+  let pendingModeResumeFile = null;
+  const permissionHandler = new CodexPermissionHandler(session.client);
+  const selectionHandler = new CodexSelectionHandler(session.client);
+  const reasoningProcessor = new ReasoningProcessor((message) => {
+    session.runtimeSession.sendCodexMessage(message);
+  });
+  const diffProcessor = new DiffProcessor((message) => {
+    session.runtimeSession.sendCodexMessage(message);
+  });
+  const handleSwitchToLocal = async () => {
+    api.logger.debug("[Codex] Switching to local from RPC");
+    exitReason = "switch";
+    shouldExit = true;
+    await handleAbort();
+  };
+  client.setPermissionHandler(permissionHandler);
+  client.setSelectionHandler(selectionHandler);
+  session.setPendingInteractionSuperseder((reason = BaseReasoningProcessor.INTERACTION_SUPERSEDED_ERROR) => {
+    const supersededPermissions = permissionHandler.supersedePendingRequests(reason);
+    const supersededSelections = selectionHandler.supersedePendingRequests(reason);
+    const total = supersededPermissions + supersededSelections;
+    if (total > 0) {
+      const message = "Previous pending interaction was canceled because a new user message arrived. Processing the latest message instead.";
+      messageBuffer.addMessage(message, "status");
+      session.runtimeSession.sendSessionEvent({ type: "message", message });
+    }
+    return total > 0;
+  });
+  const handleClientSwap = (clientSession) => {
+    permissionHandler.updateSession(clientSession);
+    selectionHandler.updateSession(clientSession);
+    registerCodexRemoteRpcHandlers(clientSession, {
+      handleAbort,
+      handleSwitchToLocal,
+      handleKillSession
+    });
+  };
+  session.addClientSwapCallback(handleClientSwap);
+  const sendReady = () => {
+    session.runtimeSession.sendSessionEvent({ type: "ready" });
+    try {
+      session.api.push().sendToAllDevices(
+        "It's ready!",
+        "Codex is waiting for your command",
+        { sessionId: session.runtimeSession.sessionId }
+      );
+    } catch (pushError) {
+      api.logger.debug("[Codex] Failed to send ready push", pushError);
+    }
+  };
+  async function handleAbort() {
+    api.logger.debug("[Codex] Abort requested - stopping current task");
+    try {
+      if (client.hasActiveSession()) {
+        storedSessionIdForResume = client.storeSessionForResume();
+      }
+      abortController.abort();
+      reasoningProcessor.abort();
+    } catch (error) {
+      api.logger.debug("[Codex] Error during abort:", error);
+    } finally {
+      abortController = new AbortController();
+    }
+  }
+  async function handleKillSession() {
+    api.logger.debug("[Codex] Kill session requested - terminating process");
+    await handleAbort();
+    try {
+      session.runtimeSession.updateMetadata((currentMetadata) => ({
+        ...currentMetadata,
+        lifecycleState: "archived",
+        lifecycleStateSince: Date.now(),
+        archivedBy: "cli",
+        archiveReason: "User terminated"
+      }));
+      session.runtimeSession.sendSessionDeath();
+      await session.runtimeSession.flush();
+      await session.runtimeSession.close();
+      await client.forceCloseSession();
+      index.stopCaffeinate();
+      process.exit(0);
+    } catch (error) {
+      api.logger.debug("[Codex] Error during session termination:", error);
+      process.exit(1);
+    }
+  }
+  if (hasTTY) {
+    console.clear();
+    inkInstance = ink.render(React.createElement(CodexDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? session.logPath : void 0,
+      title: "Remote Mode - Codex Messages",
+      onExit: async () => {
+        api.logger.debug("[Codex] Switching to exit from local keyboard");
+        exitReason = "exit";
+        shouldExit = true;
+        await handleAbort();
+      },
+      onSwitchToLocal: async () => {
+        api.logger.debug("[Codex] Switching to local from local keyboard");
+        exitReason = "switch";
+        shouldExit = true;
+        await handleAbort();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.setEncoding("utf8");
+  }
+  registerCodexRemoteRpcHandlers(session.client, {
+    handleAbort,
+    handleSwitchToLocal,
+    handleKillSession
+  });
+  client.setHandler((msg) => {
+    api.logger.debug(`[Codex] Message: ${JSON.stringify(msg)}`);
+    if (msg.type === "agent_message") {
+      messageBuffer.addMessage(msg.message, "assistant");
+    } else if (msg.type === "agent_reasoning") {
+      messageBuffer.addMessage(`[Thinking] ${msg.text.substring(0, 100)}...`, "system");
+    } else if (msg.type === "exec_command_begin") {
+      messageBuffer.addMessage(`Executing: ${msg.command}`, "tool");
+    } else if (msg.type === "exec_command_end") {
+      const output = msg.output || msg.error || "Command completed";
+      const truncatedOutput = output.substring(0, 200);
+      messageBuffer.addMessage(`Result: ${truncatedOutput}${output.length > 200 ? "..." : ""}`, "result");
+    } else if (msg.type === "task_started") {
+      messageBuffer.addMessage("Starting task...", "status");
+      session.onThinkingChange(true);
+    } else if (msg.type === "task_complete") {
+      messageBuffer.addMessage("Task completed", "status");
+      session.onThinkingChange(false);
+      diffProcessor.reset();
+      if (shouldEmitCodexReadyOnTurnEnd({ shouldExit, exitReason })) {
+        sendReady();
+        readyAlreadySent = true;
+      }
+    } else if (msg.type === "turn_aborted") {
+      messageBuffer.addMessage("Turn aborted", "status");
+      session.onThinkingChange(false);
+      diffProcessor.reset();
+      if (shouldEmitCodexReadyOnTurnEnd({ shouldExit, exitReason })) {
+        sendReady();
+        readyAlreadySent = true;
+      }
+    }
+    if (msg.type === "agent_reasoning_section_break") {
+      reasoningProcessor.handleSectionBreak();
+    }
+    if (msg.type === "agent_reasoning_delta") {
+      reasoningProcessor.processDelta(msg.delta);
+    }
+    if (msg.type === "agent_reasoning") {
+      reasoningProcessor.complete(msg.text);
+    }
+    if (msg.type === "agent_message") {
+      session.runtimeSession.sendCodexMessage({
+        type: "message",
+        message: msg.message,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "exec_command_begin" || msg.type === "exec_approval_request") {
+      const { call_id, type, ...inputs } = msg;
+      session.runtimeSession.sendCodexMessage({
+        type: "tool-call",
+        name: "CodexBash",
+        callId: call_id,
+        input: inputs,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "exec_command_end") {
+      const { call_id, type, ...output } = msg;
+      session.runtimeSession.sendCodexMessage({
+        type: "tool-call-result",
+        callId: call_id,
+        output,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "token_count") {
+      session.runtimeSession.sendCodexMessage({
+        ...msg,
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "patch_apply_begin") {
+      const { call_id, auto_approved, changes } = msg;
+      const changeCount = Object.keys(changes).length;
+      const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
+      messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
+      session.runtimeSession.sendCodexMessage({
+        type: "tool-call",
+        name: "CodexPatch",
+        callId: call_id,
+        input: { auto_approved, changes },
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "patch_apply_end") {
+      const { call_id, stdout, stderr, success } = msg;
+      if (success) {
+        messageBuffer.addMessage((stdout || "Files modified successfully").substring(0, 200), "result");
+      } else {
+        messageBuffer.addMessage(`Error: ${(stderr || "Failed to modify files").substring(0, 200)}`, "result");
+      }
+      session.runtimeSession.sendCodexMessage({
+        type: "tool-call-result",
+        callId: call_id,
+        output: { stdout, stderr, success },
+        id: node_crypto.randomUUID()
+      });
+    }
+    if (msg.type === "turn_diff" && msg.unified_diff) {
+      diffProcessor.processDiff(msg.unified_diff);
+    }
+  });
+  let readyAlreadySent = false;
+  try {
+    await client.connect();
+    let wasCreated = false;
+    let currentModeHash = null;
+    let pending = null;
+    while (!shouldExit) {
+      let message = pending;
+      pending = null;
+      if (!message) {
+        const waitSignal = abortController.signal;
+        const batch = await session.queue.waitForMessagesAndGetAsString(waitSignal);
+        if (!batch) {
+          if (waitSignal.aborted && !shouldExit) {
+            continue;
+          }
+          break;
+        }
+        message = batch;
+      }
+      if (!message) {
+        break;
+      }
+      if (wasCreated && currentModeHash && message.hash !== currentModeHash) {
+        messageBuffer.addMessage("\u2550".repeat(40), "status");
+        messageBuffer.addMessage("Starting new Codex session (mode changed)...", "status");
+        const prevSessionId = client.getSessionId();
+        pendingModeResumeFile = findCodexResumeFile(prevSessionId);
+        client.clearSession();
+        session.clearSessionId();
+        wasCreated = false;
+        currentModeHash = null;
+        pending = message;
+        permissionHandler.reset();
+        selectionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        session.onThinkingChange(false);
+        continue;
+      }
+      currentModeHash = message.hash;
+      readyAlreadySent = false;
+      messageBuffer.addMessage(message.message, "user");
+      try {
+        const approvalPolicy = (() => {
+          switch (message.mode.permissionMode) {
+            case "default":
+              return "untrusted";
+            case "read-only":
+              return "never";
+            case "safe-yolo":
+              return "on-failure";
+            case "yolo":
+              return "on-failure";
+            case "bypassPermissions":
+              return "on-failure";
+            case "acceptEdits":
+              return "on-request";
+            case "plan":
+              return "untrusted";
+            default:
+              return "untrusted";
+          }
+        })();
+        const sandbox = (() => {
+          switch (message.mode.permissionMode) {
+            case "default":
+              return "workspace-write";
+            case "read-only":
+              return "read-only";
+            case "safe-yolo":
+              return "workspace-write";
+            case "yolo":
+              return "danger-full-access";
+            case "bypassPermissions":
+              return "danger-full-access";
+            case "acceptEdits":
+              return "workspace-write";
+            case "plan":
+              return "workspace-write";
+            default:
+              return "workspace-write";
+          }
+        })();
+        if (!wasCreated) {
+          const startConfig = {
+            prompt: message.message,
+            sandbox,
+            "approval-policy": approvalPolicy,
+            config: {}
+          };
+          if (message.mode.model) {
+            startConfig.model = message.mode.model;
+          }
+          let resumeFile = null;
+          if (pendingModeResumeFile) {
+            resumeFile = pendingModeResumeFile;
+            pendingModeResumeFile = null;
+          } else if (storedSessionIdForResume) {
+            resumeFile = findCodexResumeFile(storedSessionIdForResume);
+            storedSessionIdForResume = null;
+          } else if (session.sessionId) {
+            resumeFile = findCodexResumeFile(session.sessionId);
+          }
+          if (resumeFile) {
+            startConfig.config = {
+              ...startConfig.config || {},
+              experimental_resume: resumeFile
+            };
+          }
+          await client.startSession(startConfig, { signal: abortController.signal });
+          const currentSessionId = client.getSessionId();
+          if (currentSessionId) {
+            session.onSessionFound(currentSessionId);
+          }
+          wasCreated = true;
+        } else {
+          await client.continueSession(message.message, { signal: abortController.signal });
+        }
+      } catch (error) {
+        api.logger.warn("Error in codex session:", error);
+        const isAbortError = error instanceof Error && error.name === "AbortError";
+        const isExpectedInterruption = isAbortError || abortController.signal.aborted || shouldExit || exitReason === "switch";
+        if (isExpectedInterruption) {
+          messageBuffer.addMessage("Aborted by user", "status");
+          session.runtimeSession.sendSessionEvent({ type: "message", message: "Aborted by user" });
+        } else {
+          messageBuffer.addMessage("Process exited unexpectedly", "status");
+          session.runtimeSession.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+          if (client.hasActiveSession()) {
+            storedSessionIdForResume = client.storeSessionForResume();
+          }
+        }
+      } finally {
+        permissionHandler.reset();
+        selectionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        session.onThinkingChange(false);
+        if (shouldEmitCodexReadyAfterWait({
+          pending: Boolean(pending),
+          queueSize: session.queue.size(),
+          shouldExit,
+          readyAlreadySent
+        })) {
+          sendReady();
+          readyAlreadySent = true;
+        }
+      }
+    }
+  } finally {
+    client.setHandler(null);
+    client.setPermissionHandler(null);
+    client.setSelectionHandler(null);
+    if (exitReason === "switch") {
+      api.logger.debug("[Codex] Remote launcher exiting via switch; waiting for MCP transport disconnect");
+      await client.disconnect();
+    } else {
+      await client.forceCloseSession();
+    }
+    permissionHandler.reset();
+    selectionHandler.reset();
+    session.setPendingInteractionSuperseder(null);
+    session.removeClientSwapCallback(handleClientSwap);
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+    }
+    if (hasTTY) {
+      try {
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    if (inkInstance) {
+      inkInstance.unmount();
+    }
+    messageBuffer.clear();
+  }
+  api.logger.debug(`[Codex] Remote launcher returning: ${exitReason || "exit"}`);
+  return exitReason || "exit";
+}
+
+async function codexLoop(opts) {
+  let mode = opts.startingMode ?? "local";
+  opts.session.onModeChange(mode);
+  while (true) {
+    api.logger.debug(`[codex-loop] Iteration with mode: ${mode}`);
+    if (mode === "local") {
+      const result = await codexLocalLauncher(opts.session);
+      if (result.type === "switch") {
+        mode = "remote";
+        opts.session.onModeChange(mode);
+        continue;
+      }
+      return result.code;
+    }
+    const reason = await codexRemoteLauncher(opts.session);
+    if (reason === "switch") {
+      mode = "local";
+      opts.session.onModeChange(mode);
+      continue;
+    }
+    return 0;
+  }
+}
+
+async function runCodex(opts) {
+  const sessionTag = node_crypto.randomUUID();
+  api.connectionState.setBackend("Codex");
+  if (opts.startedBy === "daemon" && opts.startingMode === "local") {
+    throw new Error("Daemon-spawned Codex sessions cannot use local mode.");
+  }
+  const api$1 = await api.ApiClient.create(opts.credentials);
+  api.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, startingMode=${opts.startingMode || "local"}`);
+  const settings = await persistence.readSettings();
+  const machineId = settings?.machineId;
+  if (!machineId) {
+    console.error("[START] No machine ID found in settings.");
+    process.exit(1);
+  }
+  await api$1.getOrCreateMachine({
+    machineId,
+    metadata: index.initialMachineMetadata
+  });
+  const { state, metadata } = BaseReasoningProcessor.createSessionMetadata({
+    flavor: "codex",
+    machineId,
+    startedBy: opts.startedBy
+  });
+  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  let sessionClient;
+  let codexSession = null;
+  const { session: initialSession, reconnectionHandle } = BaseReasoningProcessor.setupOfflineReconnection({
+    api: api$1,
+    sessionTag,
+    metadata,
+    state,
+    response,
+    onSessionSwap: (newSession) => {
+      sessionClient = newSession;
+      codexSession?.updateClient(newSession);
+    }
+  });
+  sessionClient = initialSession;
+  if (response) {
+    try {
+      const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+      if (result.error) {
+        api.logger.debug("[START] Failed to report to daemon:", result.error);
+      }
+    } catch (error) {
+      api.logger.debug("[START] Failed to report to daemon:", error);
+    }
+  }
+  const messageQueue = new registerKillSessionHandler.MessageQueue2((mode) => registerKillSessionHandler.hashObject({
+    permissionMode: mode.permissionMode,
+    model: mode.model
+  }));
+  let currentPermissionMode;
+  let currentModel;
+  sessionClient.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      messagePermissionMode = message.meta.permissionMode;
+      currentPermissionMode = messagePermissionMode;
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+    }
+    if (opts.startingMode === "remote") {
+      codexSession?.supersedePendingInteractions(BaseReasoningProcessor.INTERACTION_SUPERSEDED_ERROR);
+    }
+    messageQueue.push(message.content.text, {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel
+    });
+  });
+  codexSession = new CodexSession({
+    api: api$1,
+    client: sessionClient,
+    path: process.cwd(),
+    logPath: api.logger.logFilePath,
+    sessionId: null,
+    mode: opts.startingMode ?? "local",
+    messageQueue,
+    codexArgs: opts.codexArgs,
+    onModeChange: (mode) => {
+      sessionClient.sendSessionEvent({ type: "switch", mode });
+      sessionClient.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: mode === "local"
+      }));
+    }
+  });
+  try {
+    const exitCode = await codexLoop({
+      session: codexSession,
+      startingMode: opts.startingMode ?? "local"
+    });
+    sessionClient.sendSessionDeath();
+    await sessionClient.flush();
+    await sessionClient.close();
+    index.stopCaffeinate();
+    process.exit(exitCode);
+  } finally {
+    reconnectionHandle?.cancel();
+    codexSession.cleanup();
+  }
+}
+
+exports.runCodex = runCodex;