@cerulin/chell 0.2.5

package/dist/runCodex-DHtm7TWT.cjs

@@ -0,0 +1,2020 @@
+'use strict';
+
+var os = require('node:os');
+var node_crypto = require('node:crypto');
+var types = require('./types-DBjv5m4J.cjs');
+var node_child_process = require('node:child_process');
+var nodePty = require('node-pty');
+var node_path = require('node:path');
+var node_readline = require('node:readline');
+var node_fs = require('node:fs');
+var node_module = require('node:module');
+require('node:https');
+require('node:http');
+var index = require('./index-qS668VWY.cjs');
+var promises = require('node:fs/promises');
+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');
+var ink = require('ink');
+var React = require('react');
+require('axios');
+require('chalk');
+require('fs');
+require('tweetnacl');
+require('node:events');
+require('socket.io-client');
+require('util');
+require('fs/promises');
+require('crypto');
+require('path');
+require('url');
+require('os');
+require('expo-server-sdk');
+require('node:url');
+require('ps-list');
+require('cross-spawn');
+require('qrcode-terminal');
+require('open');
+require('fastify');
+require('fastify-type-provider-zod');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('http');
+require('readline');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+class CodexSession {
+  path;
+  logPath;
+  api;
+  client;
+  queue;
+  mcpServers;
+  _onModeChange;
+  sessionId;
+  conversationId = null;
+  mode = "local";
+  thinking = false;
+  constructor(opts) {
+    this.path = opts.path;
+    this.api = opts.api;
+    this.client = opts.client;
+    this.logPath = opts.logPath;
+    this.sessionId = opts.sessionId;
+    this.queue = opts.messageQueue;
+    this.mcpServers = opts.mcpServers;
+    this._onModeChange = opts.onModeChange;
+    this.client.keepAlive(this.thinking, this.mode);
+    setInterval(() => {
+      this.client.keepAlive(this.thinking, this.mode);
+    }, 2e3);
+  }
+  onThinkingChange = (thinking) => {
+    this.thinking = thinking;
+    this.client.keepAlive(thinking, this.mode);
+  };
+  onModeChange = (mode) => {
+    this.mode = mode;
+    this.client.keepAlive(this.thinking, mode);
+    this._onModeChange(mode);
+  };
+  onSessionFound = (sessionId) => {
+    this.sessionId = sessionId;
+    types.logger.debug(`[CodexSession] Codex session ID ${sessionId} set for resume`);
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      codexSessionId: sessionId
+    }));
+  };
+  onConversationFound = (conversationId) => {
+    if (!conversationId || this.conversationId === conversationId) return;
+    this.conversationId = conversationId;
+    types.logger.debug(`[CodexSession] Codex conversation ID ${conversationId} recorded`);
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      codexConversationId: conversationId
+    }));
+  };
+}
+
+function resolveBundledCodexCli() {
+  try {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runCodex-DHtm7TWT.cjs', document.baseURI).href)));
+    const pkgJsonPath = require$1.resolve("@openai/codex/package.json");
+    const pkgDir = node_path.dirname(pkgJsonPath);
+    const cliPath = node_path.resolve(node_path.join(pkgDir, "bin", "codex.js"));
+    return cliPath;
+  } catch {
+    types.logger.debug("[CodexLocal] Failed to resolve @openai/codex locally, using PATH fallback");
+    return "codex";
+  }
+}
+function quoteForShellDisplay(s) {
+  return `'${s.replace(/'/g, `"'"'`)}'`;
+}
+function visitUrlWithCurl(url) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-sS",
+      // silent but show errors
+      "-L",
+      // follow redirects
+      "--max-time",
+      "10",
+      "--retry",
+      "2",
+      "--retry-delay",
+      "0",
+      "--retry-max-time",
+      "15",
+      "--fail-with-body",
+      "-o",
+      "/dev/null",
+      "--url",
+      url
+    ];
+    const cmdDisplay = `curl -sS -L --max-time 10 --retry 2 --retry-delay 0 --retry-max-time 15 --fail-with-body -o /dev/null --url ${quoteForShellDisplay(url)}`;
+    types.logger.debug(`[CodexLocal] Executing: ${cmdDisplay}`);
+    console.log(`[AUTH] curl: ${cmdDisplay}`);
+    const child = node_child_process.spawn("curl", args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    if (child.stderr) {
+      child.stderr.on("data", (d) => {
+        try {
+          stderr += d.toString();
+        } catch {
+        }
+      });
+    }
+    child.on("error", (err) => {
+      types.logger.debug(`[CodexLocal] curl spawn error: ${err}`);
+      reject(err);
+    });
+    child.on("exit", (code) => {
+      types.logger.debug(`[CodexLocal] curl exit code: ${code}${stderr ? `, stderr: ${stderr.trim().slice(-500)}` : ""}`);
+      if (code === 0) return resolve();
+      reject(new Error(`curl exited with code ${code}${stderr ? `: ${stderr.trim().slice(-200)}` : ""}`));
+    });
+  });
+}
+async function codexLocal(opts) {
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      types.logger.debug(`[CodexLocal] Thinking state: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  const isHeadless = process.env.CHELL_HEADLESS === "1";
+  const showUi = process.env.CHELL_HEADLESS_SHOW_UI === "1";
+  let sessionDetected = false;
+  let fileWatcher = null;
+  const codexHome = process.env.CODEX_HOME || node_path.join(os.homedir(), ".codex");
+  const sessionsDir = node_path.join(codexHome, "sessions");
+  try {
+    node_fs.mkdirSync(sessionsDir, { recursive: true });
+    fileWatcher = node_fs.watch(sessionsDir, { recursive: true }, (eventType, filename) => {
+      if (sessionDetected || !filename) return;
+      const filenameStr = String(filename);
+      const match = filenameStr.match(/rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+      if (match) {
+        const sessionId = match[1];
+        types.logger.debug(`[CodexLocal] Detected new session file: ${filenameStr}`);
+        types.logger.debug(`[CodexLocal] Extracted session ID: ${sessionId}`);
+        sessionDetected = true;
+        opts.onSessionFound(sessionId);
+      }
+    });
+    types.logger.debug(`[CodexLocal] Watching for session files in: ${sessionsDir}`);
+  } catch (err) {
+    types.logger.debug(`[CodexLocal] Failed to setup file watcher: ${err}`);
+  }
+  try {
+    process.stdin.pause();
+    let restartRequested = false;
+    const runOnce = () => new Promise((resolve, reject) => {
+      const args = [];
+      const resumeId = opts.sessionId || opts.conversationId || null;
+      if (resumeId) {
+        args.push("resume", resumeId);
+      }
+      const preloadPath = node_path.resolve(node_path.join(types.projectPath(), "scripts", "codex_preload.cjs"));
+      const launcherPath = node_path.resolve(node_path.join(types.projectPath(), "scripts", "codex_local_launcher.cjs"));
+      const useLauncher = node_fs.existsSync(launcherPath);
+      const codexEntrypoint = resolveBundledCodexCli();
+      types.logger.debug(`[CodexLocal] Spawning Codex locally (${useLauncher ? launcherPath : codexEntrypoint}): ${args.join(" ")}`);
+      types.logger.debug(`[CodexLocal] Working directory: ${opts.path}`);
+      types.logger.debug(`[CodexLocal] Headless mode: ${isHeadless}`);
+      types.logger.debug(`[CodexLocal] useLauncher: ${useLauncher}, codexEntrypoint: ${codexEntrypoint}`);
+      if (isHeadless) {
+        const cols = process.stdout.columns || 120;
+        const rows = process.stdout.rows || 24;
+        const ptyEnv = {
+          ...process.env,
+          COLUMNS: cols.toString(),
+          LINES: rows.toString(),
+          // Encourage non-interactive fallbacks and reduce fancy terminal behavior
+          CI: process.env.CI || "1",
+          NO_COLOR: process.env.NO_COLOR || "1"
+        };
+        const ptyArgv = codexEntrypoint === "codex" ? ["codex", ...args] : [process.execPath, "-r", preloadPath, codexEntrypoint, ...args];
+        types.logger.debug(`[CodexLocal] PTY spawn command: ${ptyArgv[0]}`);
+        types.logger.debug(`[CodexLocal] PTY spawn args: ${JSON.stringify(ptyArgv.slice(1))}`);
+        console.log(`[CodexLocal] Spawning: ${ptyArgv.join(" ")}
+`);
+        const pty = nodePty.spawn(ptyArgv[0], ptyArgv.slice(1), {
+          name: "xterm-color",
+          // Use same terminal type as Claude
+          cols,
+          rows,
+          cwd: opts.path,
+          env: {
+            ...ptyEnv,
+            TERM: "xterm-256color",
+            DISABLE_AUTOUPDATER: "1",
+            ...codexEntrypoint === "codex" ? { NODE_OPTIONS: `${process.env.NODE_OPTIONS ?? ""} -r ${preloadPath}`.trim() } : {}
+          }
+        });
+        if (showUi) {
+          try {
+            if (process.stdin.isTTY) process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on("data", (d) => {
+              try {
+                pty.write(d.toString());
+              } catch {
+              }
+            });
+          } catch {
+          }
+        }
+        let buffer = "";
+        let authStep = 0;
+        const capturedUrls = /* @__PURE__ */ new Set();
+        const teePath = node_path.join(types.configuration.happyHomeDir, "link", "codex-headless-output");
+        let teeWriteCount = 0;
+        const TEE_MAX_BYTES = Number(process.env.CHELL_HEADLESS_TEE_MAX_BYTES || 512 * 1024);
+        let lastSnippet = "";
+        let lastSnippetAt = 0;
+        const stripAnsi = (s) => s.replace(/\x1B\[[0-9;?]*[ -\/]*[@-~]/g, "");
+        const isMostlySpinner = (s) => {
+          const clean = s.replace(/\n/g, "");
+          const crCount = (clean.match(/\r/g) || []).length;
+          const hasAlphaNum = /[A-Za-z0-9]/.test(stripAnsi(clean));
+          return crCount >= 1 && !hasAlphaNum && clean.length <= 200;
+        };
+        const isInteresting = (s) => {
+          const t = stripAnsi(s);
+          return t.includes("auth.openai.com") || t.toLowerCase().includes("oauth") || t.toLowerCase().includes("authorization code") || t.toLowerCase().includes("sign in") || t.toLowerCase().includes("provide your own api key") || t.toLowerCase().includes("callback") || t.toLowerCase().includes("[auth]");
+        };
+        const writeTee = (text) => {
+          try {
+            if (isMostlySpinner(text)) return;
+            const now = Date.now();
+            const normalized = stripAnsi(text).replace(/\r/g, "");
+            if (normalized && normalized === lastSnippet && now - lastSnippetAt < 1e3) {
+              return;
+            }
+            node_fs.mkdirSync(types.configuration.happyHomeDir + "/link", { recursive: true });
+            if (node_fs.existsSync(teePath)) {
+              try {
+                const size = node_fs.statSync(teePath).size;
+                if (size > TEE_MAX_BYTES) {
+                  node_fs.writeFileSync(teePath, `[truncated at ${(/* @__PURE__ */ new Date()).toISOString()}]
+`);
+                }
+              } catch {
+              }
+            }
+            node_fs.appendFileSync(teePath, text);
+            lastSnippet = normalized;
+            lastSnippetAt = now;
+            teeWriteCount++;
+          } catch {
+          }
+        };
+        const findAndSaveOAuthUrls = (cleanBuf) => {
+          try {
+            const hay = cleanBuf;
+            const needle = "https://auth.openai.com/";
+            let idx = 0;
+            const maxLen = 2048;
+            const isAllowed = (ch) => /[A-Za-z0-9\-._~:/?#\[\]@!$&'()*+,;=%]/.test(ch);
+            while ((idx = hay.indexOf(needle, idx)) !== -1) {
+              let i = idx;
+              let out = "";
+              while (i < hay.length && out.length < maxLen) {
+                const ch = hay[i];
+                if (isAllowed(ch)) {
+                  out += ch;
+                  i++;
+                  continue;
+                }
+                if (ch === " " || ch === '"' || ch === "'" || ch === "<" || ch === ">" || ch === ")" || ch === "]" || ch === "\\") {
+                  break;
+                }
+                if (ch === "\\r" || ch === "\\n" || ch === "\\t") {
+                  i++;
+                  continue;
+                }
+                break;
+              }
+              idx = i;
+              if (out.includes("?") && !capturedUrls.has(out)) {
+                capturedUrls.add(out);
+                try {
+                  types.writeHeadlessJson({ codex_auth_url: out });
+                  const jsonPath = node_path.join(types.configuration.happyHomeDir, "link", "headless.json");
+                  console.log(`
+[AUTH] OAuth URL saved to: ${jsonPath}
+`);
+                  types.logger.debug(`[CodexLocal] OAuth URL captured: ${out}`);
+                } catch (err) {
+                  types.logger.debug(`[CodexLocal] Failed to write OAuth URL to headless.json: ${err}`);
+                }
+              }
+            }
+          } catch {
+          }
+        };
+        const sendToStdin = (text) => {
+          try {
+            pty.write(text);
+          } catch (err) {
+            types.logger.debug(`[CodexLocal] Failed to write to PTY: ${err}`);
+          }
+        };
+        const sendEnter = () => sendToStdin("\r");
+        const sendCtrlC = () => {
+          try {
+            pty.write("");
+          } catch (err) {
+            types.logger.debug(`[CodexLocal] Failed to send Ctrl+C: ${err}`);
+          }
+        };
+        const headlessJsonPath = node_path.join(types.configuration.happyHomeDir, "link", "headless.json");
+        let lastSeenCodexReturnAuth = null;
+        let callbackVisited = false;
+        let lastRestartAt = 0;
+        let pendingAuthCode = null;
+        const pollReturnAuth = setInterval(async () => {
+          if (callbackVisited) return;
+          try {
+            if (!node_fs.existsSync(headlessJsonPath)) return;
+            const raw = node_fs.readFileSync(headlessJsonPath, "utf8");
+            if (!raw) return;
+            const data = JSON.parse(raw);
+            const val = typeof data.codex_return_auth === "string" ? data.codex_return_auth.trim() : "";
+            if (val && val !== lastSeenCodexReturnAuth) {
+              lastSeenCodexReturnAuth = val;
+              callbackVisited = true;
+              types.logger.debug(`[CodexLocal] Handling return auth via curl`);
+              console.log(`[AUTH] Visiting callback URL (curl)...
+`);
+              try {
+                await visitUrlWithCurl(val);
+                console.log(`[AUTH] Callback visited
+`);
+              } catch (err) {
+                types.logger.debug(`[CodexLocal] curl visit failed: ${err}`);
+                console.log(`[AUTH] Callback visit failed: ${err}
+`);
+              } finally {
+                try {
+                  types.writeHeadlessJson({ codex_return_auth: "" });
+                } catch {
+                }
+                const now = Date.now();
+                if (!restartRequested && now - lastRestartAt > 4e3) {
+                  restartRequested = true;
+                  lastRestartAt = now + 1e3;
+                  setTimeout(() => {
+                    try {
+                      pty.kill();
+                    } catch {
+                    }
+                  }, 1e3);
+                }
+              }
+            }
+          } catch (err) {
+          }
+        }, 500);
+        pty.onData((data) => {
+          if (data.includes("\x1B[6n")) {
+            try {
+              const reply = `\x1B[${rows};1R`;
+              pty.write(reply);
+              types.logger.debug("[CodexLocal] Responded to DSR (cursor position) with", reply);
+            } catch {
+            }
+          }
+          if (showUi) {
+            try {
+              process.stdout.write(data);
+            } catch {
+            }
+          }
+          writeTee(data);
+          buffer += data;
+          const cleanBuffer = stripAnsi(buffer);
+          findAndSaveOAuthUrls(cleanBuffer);
+          if (authStep === 0 && (cleanBuffer.includes("Sign in with ChatGPT") || cleanBuffer.includes("Provide your own API key") || cleanBuffer.includes("Press Enter to continue"))) {
+            if (cleanBuffer.includes("1. Sign in with ChatGPT") || cleanBuffer.includes("1) Sign in with ChatGPT")) {
+              types.logger.debug("[CodexLocal] Detected login method selection prompt");
+              console.log(`
+[AUTH] Auto-selecting "Sign in with ChatGPT"...
+`);
+              authStep = 1;
+              setTimeout(() => {
+                sendToStdin("1");
+                types.logger.debug('[CodexLocal] Sent "1" to select ChatGPT login');
+              }, 500);
+            }
+          }
+          if (authStep === 1 && capturedUrls.size > 0) {
+            types.logger.debug("[CodexLocal] OAuth URL detected, waiting for callback...");
+            console.log(`[AUTH] Waiting for callback URL in headless.json...
+`);
+            authStep = 2;
+          }
+          if (pendingAuthCode) {
+            const lower = cleanBuffer.toLowerCase();
+            if (lower.includes("enter authorization code") || lower.includes("paste code") || lower.includes("enter code")) {
+              try {
+                const code = pendingAuthCode;
+                pendingAuthCode = null;
+                pty.write(code + "\r");
+                types.logger.debug("[CodexLocal] Submitted authorization code to CLI");
+              } catch {
+              }
+            }
+          }
+          if (buffer.length > 2e4) buffer = buffer.slice(-1e4);
+        });
+        process.stdout.on("resize", () => {
+          try {
+            pty.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+          } catch {
+          }
+        });
+        opts.abort.addEventListener("abort", () => {
+          try {
+            pty.kill();
+          } catch {
+          }
+        });
+        pty.onExit((exitCode) => {
+          clearInterval(pollReturnAuth);
+          types.logger.debug(`[CodexLocal] PTY exited with code: ${exitCode.exitCode}, signal: ${exitCode.signal}`);
+          console.log(`
+[CodexLocal] Codex process exited (code: ${exitCode.exitCode})
+`);
+          resolve();
+        });
+        return;
+      }
+      const interactiveEnv = {
+        ...process.env,
+        COLUMNS: (process.stdout.columns || 120).toString(),
+        LINES: (process.stdout.rows || 24).toString()
+      };
+      let command;
+      let childArgs;
+      let childEnv = {
+        ...interactiveEnv,
+        DISABLE_AUTOUPDATER: "1"
+      };
+      if (useLauncher) {
+        command = process.execPath;
+        childArgs = [launcherPath, ...args];
+      } else if (codexEntrypoint === "codex") {
+        command = "codex";
+        childArgs = [...args];
+        childEnv.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ""} -r ${preloadPath}`.trim();
+      } else {
+        command = process.execPath;
+        childArgs = ["-r", preloadPath, codexEntrypoint, ...args];
+      }
+      const child = node_child_process.spawn(command, childArgs, {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path,
+        env: childEnv
+      });
+      if (child.stdio[3]) {
+        const rl = node_readline.createInterface({
+          input: child.stdio[3],
+          crlfDelay: Infinity
+        });
+        rl.on("line", (line) => {
+          try {
+            const message = JSON.parse(line);
+            types.logger.debug(`[CodexLocal] fd3 message: ${JSON.stringify(message)}`);
+            switch (message.type) {
+              case "launcher_start":
+                types.logger.debug(`[CodexLocal] Launcher started`);
+                break;
+              case "import_attempt":
+                types.logger.debug(`[CodexLocal] Attempting to import: ${message.path}`);
+                break;
+              case "import_success":
+                types.logger.debug(`[CodexLocal] Successfully imported: ${message.path}`);
+                break;
+              case "import_failed":
+                types.logger.debug(`[CodexLocal] Failed to import Codex: ${message.error}`);
+                break;
+              case "uuid":
+                types.logger.debug(`[CodexLocal] Session UUID detected: ${message.value}`);
+                opts.onSessionFound(message.value);
+                break;
+              case "fetch-start":
+                types.logger.debug(`[CodexLocal] Fetch start detected (thinking)`);
+                updateThinking(true);
+                break;
+              case "fetch-end":
+                types.logger.debug(`[CodexLocal] Fetch end detected (done thinking)`);
+                updateThinking(false);
+                break;
+              default:
+                types.logger.debug(`[CodexLocal] Unknown fd3 message type: ${message.type}`);
+            }
+          } catch (e) {
+            types.logger.debug(`[CodexLocal] Non-JSON line from fd3: ${line}`);
+          }
+        });
+        rl.on("error", (err) => {
+          types.logger.debug("[CodexLocal] Error reading from fd3:", err);
+        });
+      }
+      child.on("error", (error) => {
+        if (error?.name === "AbortError" || error?.code === "ABORT_ERR") {
+          types.logger.debug("[CodexLocal] Spawn aborted during mode switch");
+          return resolve();
+        }
+        types.logger.debug("[CodexLocal] Spawn error:", error);
+        console.error("\n\u274C Failed to spawn codex CLI:", error?.message || String(error));
+        console.error('Make sure "codex" is installed and available in your PATH.');
+        console.error("Try installing it from: https://github.com/openai/codex\n");
+        reject(error);
+      });
+      child.on("exit", (code, signal) => {
+        if (signal === "SIGTERM" && opts.abort.aborted) {
+          resolve();
+        } else if (signal) {
+          reject(new Error(`Process terminated with signal: ${signal}`));
+        } else {
+          resolve();
+        }
+      });
+    });
+    do {
+      restartRequested = false;
+      await runOnce();
+    } while (restartRequested);
+  } finally {
+    if (fileWatcher) {
+      fileWatcher.close();
+    }
+    process.stdin.resume();
+    updateThinking(false);
+  }
+  return null;
+}
+
+function getCodexHomeDir() {
+  return process.env.CODEX_HOME || node_path.resolve(os.homedir(), ".codex");
+}
+function getCodexSessionsDir() {
+  return node_path.join(getCodexHomeDir(), "sessions");
+}
+function getCodexSessionDirForDate(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return node_path.join(getCodexSessionsDir(), String(year), month, day);
+}
+
+async function createCodexSessionScanner(opts) {
+  let finishedSessions = /* @__PURE__ */ new Set();
+  let pendingSessions = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  let watchers = /* @__PURE__ */ new Map();
+  let processedMessageKeys = /* @__PURE__ */ new Set();
+  let sessionFilePaths = /* @__PURE__ */ new Map();
+  if (opts.sessionId) {
+    const filePath = await findSessionFile$1(opts.sessionId);
+    if (filePath) {
+      sessionFilePaths.set(opts.sessionId, filePath);
+      const messages = await readSessionLog(filePath);
+      for (const m of messages) {
+        processedMessageKeys.add(messageKey(m));
+      }
+      currentSessionId = opts.sessionId;
+      types.logger.debug(`[CODEX_SESSION_SCANNER] Initialized with resumed session: ${opts.sessionId}`);
+    }
+  }
+  const sync = new index.InvalidateSync(async () => {
+    const sessions = [];
+    for (const p of pendingSessions) {
+      sessions.push(p);
+    }
+    if (currentSessionId) {
+      sessions.push(currentSessionId);
+    }
+    for (const sessionId of sessions) {
+      if (!sessionFilePaths.has(sessionId)) {
+        const filePath2 = await findSessionFile$1(sessionId);
+        if (filePath2) {
+          sessionFilePaths.set(sessionId, filePath2);
+        }
+      }
+      const filePath = sessionFilePaths.get(sessionId);
+      if (!filePath) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] No file path found for session: ${sessionId}`);
+        continue;
+      }
+      const messages = await readSessionLog(filePath);
+      for (const message of messages) {
+        const key = messageKey(message);
+        if (processedMessageKeys.has(key)) {
+          continue;
+        }
+        processedMessageKeys.add(key);
+        if (shouldFilterMessage(message)) {
+          types.logger.debug(`[CODEX_SESSION_SCANNER] Filtering out message: ${message.type || "unknown"}`);
+          continue;
+        }
+        opts.onMessage(message);
+      }
+    }
+    for (const p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    for (const sessionId of sessions) {
+      const filePath = sessionFilePaths.get(sessionId);
+      if (filePath && !watchers.has(sessionId)) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] Setting up watcher for: ${filePath}`);
+        watchers.set(sessionId, index.startFileWatcher(filePath, () => {
+          types.logger.debug(`[CODEX_SESSION_SCANNER] File change detected for session: ${sessionId}`);
+          sync.invalidate();
+        }));
+      }
+    }
+  });
+  await sync.invalidateAndAwait();
+  const intervalId = setInterval(() => {
+    sync.invalidate();
+  }, 3e3);
+  return {
+    cleanup: async () => {
+      clearInterval(intervalId);
+      for (const w of watchers.values()) {
+        w();
+      }
+      watchers.clear();
+      await sync.invalidateAndAwait();
+      sync.stop();
+    },
+    onNewSession: (sessionId) => {
+      if (currentSessionId === sessionId) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] New session: ${sessionId} is the same as current, skipping`);
+        return;
+      }
+      if (pendingSessions.has(sessionId)) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
+        return;
+      }
+      if (finishedSessions.has(sessionId)) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] Reactivating finished session: ${sessionId}`);
+        finishedSessions.delete(sessionId);
+      }
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      types.logger.debug(`[CODEX_SESSION_SCANNER] New session: ${sessionId}`);
+      currentSessionId = sessionId;
+      sync.invalidate();
+    }
+  };
+}
+function messageKey(message) {
+  if (message.id) {
+    return `id:${String(message.id)}`;
+  }
+  if (message.uuid) {
+    return `uuid:${String(message.uuid)}`;
+  }
+  const parts = [];
+  if (message.type) {
+    parts.push(`type:${message.type}`);
+  }
+  if (message.timestamp || message.time || message.created_at) {
+    const ts = message.timestamp || message.time || message.created_at;
+    parts.push(`ts:${ts}`);
+  }
+  const contentStr = JSON.stringify(message);
+  const len = contentStr.length;
+  const sample = contentStr.substring(0, 100) + contentStr.substring(Math.max(0, len - 100));
+  parts.push(`len:${len}`);
+  parts.push(`hash:${Buffer.from(sample).toString("base64").substring(0, 32)}`);
+  return parts.join("|");
+}
+function shouldFilterMessage(message) {
+  if (message.type === "session_meta") {
+    return true;
+  }
+  if (message.type === "event_msg" && message.payload?.type === "user_message") {
+    return true;
+  }
+  if (message.type === "event_msg") {
+    const pt = message.payload?.type;
+    if (pt === "agent_message_delta" || pt === "agent_reasoning_delta" || pt === "agent_reasoning_section_break") {
+      return true;
+    }
+    if (pt === "agent_message") {
+      return true;
+    }
+  }
+  if (message.type === "response_item" && message.payload) {
+    const payload = message.payload;
+    if (payload.role === "user" && Array.isArray(payload.content)) {
+      for (const contentItem of payload.content) {
+        if (contentItem.text && typeof contentItem.text === "string") {
+          const text = contentItem.text.trim();
+          if (text.startsWith("<environment_context>") && text.endsWith("</environment_context>")) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+async function findSessionFile$1(sessionId) {
+  const today = /* @__PURE__ */ new Date();
+  let sessionDir = getCodexSessionDirForDate(today);
+  if (!node_fs.existsSync(sessionDir)) {
+    types.logger.debug(`[CODEX_SESSION_SCANNER] Session directory does not exist: ${sessionDir}`);
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    sessionDir = getCodexSessionDirForDate(yesterday);
+    if (!node_fs.existsSync(sessionDir)) {
+      types.logger.debug(`[CODEX_SESSION_SCANNER] Yesterday's directory also doesn't exist: ${sessionDir}`);
+      return null;
+    }
+  }
+  try {
+    const files = await promises.readdir(sessionDir);
+    const matchingFile = files.find(
+      (file) => file.startsWith("rollout-") && file.endsWith(`-${sessionId}.jsonl`)
+    );
+    if (matchingFile) {
+      const fullPath = node_path.join(sessionDir, matchingFile);
+      types.logger.debug(`[CODEX_SESSION_SCANNER] Found session file: ${fullPath}`);
+      return fullPath;
+    }
+    types.logger.debug(`[CODEX_SESSION_SCANNER] No matching file found for session: ${sessionId}`);
+    return null;
+  } catch (error) {
+    types.logger.debug(`[CODEX_SESSION_SCANNER] Error reading session directory: ${error}`);
+    return null;
+  }
+}
+async function readSessionLog(filePath) {
+  try {
+    const content = await promises.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const messages = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "") {
+        continue;
+      }
+      try {
+        const message = JSON.parse(trimmed);
+        messages.push(message);
+      } catch (error) {
+        types.logger.debug(`[CODEX_SESSION_SCANNER] Failed to parse line: ${trimmed.substring(0, 100)}`);
+        continue;
+      }
+    }
+    return messages;
+  } catch (error) {
+    types.logger.debug(`[CODEX_SESSION_SCANNER] Error reading session file: ${error}`);
+    return [];
+  }
+}
+
+async function codexLocalLauncher(session) {
+  const scanner = await createCodexSessionScanner({
+    sessionId: session.sessionId,
+    onMessage: (message) => {
+      let shouldForwardRaw = true;
+      try {
+        const t = message?.type;
+        if (t === "event_msg") {
+          const pt = message?.payload?.type;
+          if (pt === "agent_message_delta" || pt === "agent_reasoning_delta" || pt === "agent_reasoning_section_break" || pt === "agent_message") {
+            shouldForwardRaw = false;
+          }
+        }
+        if (t === "response_item" && message?.payload?.type === "message" && message?.payload?.role === "assistant" && Array.isArray(message?.payload?.content)) {
+          shouldForwardRaw = false;
+        }
+      } catch {
+      }
+      if (shouldForwardRaw) {
+        types.logger.debug(`[CodexLocal] Forwarding message to mobile: ${message.type || "unknown"}`);
+        session.client.sendCodexMessage(message);
+      }
+      try {
+        if (message && typeof message === "object" && message.type === "response_item" && message.payload && message.payload.type === "message" && message.payload.role === "assistant" && Array.isArray(message.payload.content)) {
+          for (const block of message.payload.content) {
+            if (block && typeof block === "object" && block.type === "output_text" && typeof block.text === "string") {
+              const text = block.text;
+              session.client.sendCodexMessage({
+                type: "message",
+                message: text,
+                id: node_crypto.randomUUID()
+              });
+              try {
+                session.client.sendClaudeSessionMessage({
+                  type: "assistant",
+                  uuid: node_crypto.randomUUID(),
+                  message: { content: [{ type: "text", text }] }
+                });
+              } catch {
+              }
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  });
+  let exitReason = null;
+  const processAbortController = new AbortController();
+  let exitFuture = new index.Future();
+  try {
+    async function abort() {
+      if (!processAbortController.signal.aborted) {
+        processAbortController.abort();
+      }
+      await exitFuture.promise;
+    }
+    async function doAbort() {
+      types.logger.debug("[CodexLocal]: doAbort");
+      if (!exitReason) {
+        exitReason = "switch";
+      }
+      session.queue.reset();
+      await abort();
+    }
+    async function doSwitch() {
+      types.logger.debug("[CodexLocal]: doSwitch");
+      if (!exitReason) {
+        exitReason = "switch";
+      }
+      await abort();
+    }
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    session.queue.setOnMessage((message, mode) => {
+      doSwitch();
+    });
+    if (session.queue.size() > 0) {
+      return "switch";
+    }
+    const handleSessionStart = (sessionId) => {
+      session.onSessionFound(sessionId);
+      scanner.onNewSession(sessionId);
+      (async () => {
+        try {
+          const filePath = await findSessionFile(sessionId);
+          if (!filePath) return;
+          const content = await promises.readFile(filePath, "utf-8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+              const obj = JSON.parse(trimmed);
+              const conv = obj.conversation_id || obj.conversationId || obj?.payload?.conversation_id || obj?.payload?.conversationId;
+              if (typeof conv === "string" && conv) {
+                session.onConversationFound(conv);
+                break;
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      })();
+    };
+    types.logger.debug(`[CodexLocal]: Starting Codex CLI (headless=${process.env.CHELL_HEADLESS === "1"})`);
+    const result = codexLocal({
+      abort: processAbortController.signal,
+      sessionId: session.sessionId,
+      conversationId: session.conversationId ?? null,
+      mcpServers: session.mcpServers,
+      path: session.path,
+      onSessionFound: handleSessionStart,
+      onThinkingChange: session.onThinkingChange
+    });
+    await result;
+    exitFuture.resolve();
+    types.logger.debug("[CodexLocal]: Process exited");
+  } catch (error) {
+    exitFuture.resolve();
+    if (error?.message?.includes("SIGTERM") || processAbortController.signal.aborted) {
+      types.logger.debug("[CodexLocal]: Process aborted (switching modes)");
+    } else {
+      types.logger.debug("[CodexLocal]: Process error:", error);
+      throw error;
+    }
+  } finally {
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
+    });
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    session.queue.setOnMessage(null);
+    await scanner.cleanup();
+  }
+  return exitReason || "exit";
+}
+async function findSessionFile(sessionId) {
+  const today = /* @__PURE__ */ new Date();
+  let dir = getCodexSessionDirForDate(today);
+  if (!node_fs.existsSync(dir)) {
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    dir = getCodexSessionDirForDate(yesterday);
+    if (!node_fs.existsSync(dir)) return null;
+  }
+  try {
+    const files = await promises.readdir(dir);
+    const match = files.find((f) => f.startsWith("rollout-") && f.endsWith(`-${sessionId}.jsonl`));
+    return match ? node_path.join(dir, match) : null;
+  } catch {
+    return null;
+  }
+}
+
+const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
+function resolveCodexCliPath() {
+  try {
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runCodex-DHtm7TWT.cjs', document.baseURI).href)));
+    const pkgJsonPath = require$1.resolve("@openai/codex/package.json");
+    const pkgDir = node_path.dirname(pkgJsonPath);
+    const cliPath = node_path.resolve(node_path.join(pkgDir, "bin", "codex.js"));
+    return cliPath;
+  } catch (e) {
+    types.logger.debug("[CodexMCP] Failed to resolve @openai/codex locally, using PATH fallback");
+    return "codex";
+  }
+}
+function detectMcpSubcommand(codexEntrypoint) {
+  try {
+    const cmd = codexEntrypoint === "codex" ? "codex --version" : `"${process.execPath}" "${codexEntrypoint}" --version`;
+    const version = child_process.execSync(cmd, { encoding: "utf8" }).trim();
+    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
+    if (!match) return "mcp-server";
+    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) {
+    types.logger.debug("[CodexMCP] Error detecting codex version, defaulting to mcp-server:", error);
+    return "mcp-server";
+  }
+}
+class CodexMcpClient {
+  client;
+  transport = null;
+  connected = false;
+  sessionId = null;
+  conversationId = null;
+  handler = null;
+  permissionHandler = null;
+  launchConfig = null;
+  constructor() {
+    this.client = new index_js.Client(
+      { name: "happy-codex-client", version: "1.0.0" },
+      { capabilities: { tools: {}, elicitation: {} } }
+    );
+    this.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;
+      this.updateIdentifiersFromEvent(msg);
+      this.handler?.(msg);
+    });
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Provide initial Codex config key/values to pass via `-c key=value` when spawning mcp-server.
+   */
+  setLaunchConfig(config) {
+    this.launchConfig = config && Object.keys(config).length > 0 ? config : null;
+  }
+  /**
+   * Set the permission handler for tool approval
+   */
+  setPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  async connect() {
+    if (this.connected) return;
+    const codexEntrypoint = resolveCodexCliPath();
+    const mcpCommand = detectMcpSubcommand(codexEntrypoint);
+    types.logger.debug(`[CodexMCP] Connecting to Codex MCP server using command: ${codexEntrypoint === "codex" ? "codex" : codexEntrypoint} ${mcpCommand}`);
+    const baseArgs = [mcpCommand];
+    if (this.launchConfig) {
+      for (const [k, v] of Object.entries(this.launchConfig)) {
+        baseArgs.push("-c");
+        baseArgs.push(`${k}=${v}`);
+      }
+    }
+    try {
+      const fullCmd = codexEntrypoint === "codex" ? ["codex", ...baseArgs] : [process.execPath, codexEntrypoint, ...baseArgs];
+      types.logger.debug("[CodexMCP] Spawn argv:", fullCmd);
+      if (this.launchConfig) {
+        types.logger.debug("[CodexMCP] Launch config (-c flags):", this.launchConfig);
+      }
+    } catch {
+    }
+    this.transport = new stdio_js.StdioClientTransport({
+      command: codexEntrypoint === "codex" ? "codex" : process.execPath,
+      args: codexEntrypoint === "codex" ? baseArgs : [codexEntrypoint, ...baseArgs],
+      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;
+    types.logger.debug("[CodexMCP] Connected to Codex");
+  }
+  registerPermissionHandlers() {
+    this.client.setRequestHandler(
+      types_js.ElicitRequestSchema,
+      async (request) => {
+        console.log("[CodexMCP] Received elicitation request:", request.params);
+        const params = request.params;
+        const toolName = "CodexBash";
+        if (!this.permissionHandler) {
+          types.logger.debug("[CodexMCP] No permission handler set, denying by default");
+          return {
+            decision: "denied"
+          };
+        }
+        try {
+          const result = await this.permissionHandler.handleToolCall(
+            params.codex_call_id,
+            toolName,
+            {
+              command: params.codex_command,
+              cwd: params.codex_cwd
+            }
+          );
+          types.logger.debug("[CodexMCP] Permission result:", result);
+          return {
+            decision: result.decision
+          };
+        } catch (error) {
+          types.logger.debug("[CodexMCP] Error handling permission request:", error);
+          return {
+            decision: "denied",
+            reason: error instanceof Error ? error.message : "Permission request failed"
+          };
+        }
+      }
+    );
+    types.logger.debug("[CodexMCP] Permission handlers registered");
+  }
+  async startSession(config, options) {
+    if (!this.connected) await this.connect();
+    types.logger.debug("[CodexMCP] Starting Codex session:", config);
+    const response = await this.client.callTool({
+      name: "codex",
+      arguments: config
+    }, void 0, {
+      signal: options?.signal,
+      timeout: DEFAULT_TIMEOUT
+      // maxTotalTimeout: 10000000000
+    });
+    types.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;
+      types.logger.debug("[CodexMCP] conversationId missing, defaulting to sessionId:", this.conversationId);
+    }
+    const args = { sessionId: this.sessionId, conversationId: this.conversationId, prompt };
+    types.logger.debug("[CodexMCP] Continuing Codex session:", args);
+    const response = await this.client.callTool({
+      name: "codex-reply",
+      arguments: args
+    }, void 0, {
+      signal: options?.signal,
+      timeout: DEFAULT_TIMEOUT
+    });
+    types.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;
+      if (sessionId) {
+        this.sessionId = sessionId;
+        types.logger.debug("[CodexMCP] Session ID extracted from event:", this.sessionId);
+      }
+      const conversationId = candidate.conversation_id ?? candidate.conversationId;
+      if (conversationId) {
+        this.conversationId = conversationId;
+        types.logger.debug("[CodexMCP] Conversation ID extracted from event:", this.conversationId);
+      }
+    }
+  }
+  extractIdentifiers(response) {
+    const meta = response?.meta || {};
+    if (meta.sessionId) {
+      this.sessionId = meta.sessionId;
+      types.logger.debug("[CodexMCP] Session ID extracted:", this.sessionId);
+    } else if (response?.sessionId) {
+      this.sessionId = response.sessionId;
+      types.logger.debug("[CodexMCP] Session ID extracted:", this.sessionId);
+    }
+    if (meta.conversationId) {
+      this.conversationId = meta.conversationId;
+      types.logger.debug("[CodexMCP] Conversation ID extracted:", this.conversationId);
+    } else if (response?.conversationId) {
+      this.conversationId = response.conversationId;
+      types.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;
+          types.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;
+          types.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;
+    types.logger.debug("[CodexMCP] Session cleared, previous sessionId:", previousSessionId);
+  }
+  /**
+   * Store the current session ID without clearing it, useful for abort handling
+   */
+  storeSessionForResume() {
+    types.logger.debug("[CodexMCP] Storing session for potential resume:", this.sessionId);
+    return this.sessionId;
+  }
+  async disconnect() {
+    if (!this.connected) return;
+    const pid = this.transport?.pid ?? null;
+    types.logger.debug(`[CodexMCP] Disconnecting; child pid=${pid ?? "none"}`);
+    try {
+      types.logger.debug("[CodexMCP] client.close begin");
+      await this.client.close();
+      types.logger.debug("[CodexMCP] client.close done");
+    } catch (e) {
+      types.logger.debug("[CodexMCP] Error closing client, attempting transport close directly", e);
+      try {
+        types.logger.debug("[CodexMCP] transport.close begin");
+        await this.transport?.close?.();
+        types.logger.debug("[CodexMCP] transport.close done");
+      } catch {
+      }
+    }
+    if (pid) {
+      try {
+        process.kill(pid, 0);
+        types.logger.debug("[CodexMCP] Child still alive, sending SIGKILL");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      } catch {
+      }
+    }
+    this.transport = null;
+    this.connected = false;
+    this.sessionId = null;
+    this.conversationId = null;
+    types.logger.debug("[CodexMCP] Disconnected");
+  }
+}
+
+async function codexRemote(opts) {
+  const mcp = new CodexMcpClient();
+  mcp.setPermissionHandler(opts.permissionHandler);
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      types.logger.debug(`[codexRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
+  mcp.setHandler((event) => {
+    try {
+      const t = event && typeof event === "object" ? event.type : void 0;
+      const isDelta = t === "agent_message_delta" || t === "agent_reasoning_delta" || t === "agent_reasoning_section_break";
+      if (!isDelta) {
+        types.logger.debugLargeJson("[codexRemote] MCP Event:", event);
+      }
+    } catch {
+      types.logger.debugLargeJson("[codexRemote] MCP Event:", event);
+    }
+    opts.onMessage(event);
+    if (event.type === "task_started" || event.type === "task_progress") {
+      updateThinking(true);
+    } else if (event.type === "task_complete" || event.type === "turn_aborted") {
+      updateThinking(false);
+    }
+  });
+  try {
+    try {
+      const launchConfig = {};
+      const resumeHint = (opts.conversationId || opts.sessionId) ?? null;
+      if (resumeHint) {
+        launchConfig["resume"] = resumeHint;
+        launchConfig["experimental_resume"] = resumeHint;
+        launchConfig["session_id"] = resumeHint;
+        launchConfig["conversationId"] = resumeHint;
+        launchConfig["conversation_id"] = resumeHint;
+        launchConfig["thread_id"] = resumeHint;
+        launchConfig["thread"] = resumeHint;
+        launchConfig["resume_session"] = resumeHint;
+        launchConfig["resume_session_id"] = resumeHint;
+        launchConfig["resume_conversation"] = resumeHint;
+        launchConfig["resume_thread"] = resumeHint;
+        launchConfig["resume_thread_id"] = resumeHint;
+      }
+      if (Object.keys(launchConfig).length > 0) {
+        types.logger.debug("[codexRemote] Launch config for MCP (-c flags):", launchConfig);
+        mcp.setLaunchConfig(launchConfig);
+      }
+    } catch {
+    }
+    await mcp.connect();
+    const initial = await opts.nextMessage();
+    if (!initial) {
+      types.logger.debug("[codexRemote] No initial message, exiting");
+      return;
+    }
+    const specialCommand = index.parseSpecialCommand(initial.message);
+    if (specialCommand.type === "clear") {
+      types.logger.debug("[codexRemote] /clear command detected");
+      mcp.clearSession();
+      if (opts.onCompletionEvent) {
+        opts.onCompletionEvent("Context was reset");
+      }
+      if (opts.onSessionReset) {
+        opts.onSessionReset();
+      }
+      return;
+    }
+    let isCompactCommand = false;
+    if (specialCommand.type === "compact") {
+      types.logger.debug("[codexRemote] /compact command detected");
+      isCompactCommand = true;
+      if (opts.onCompletionEvent) {
+        opts.onCompletionEvent("Compaction started");
+      }
+    }
+    const config = {
+      prompt: initial.message,
+      cwd: opts.path
+    };
+    if (initial.mode.permissionMode === "read-only") {
+      config.sandbox = "read-only";
+    } else if (initial.mode.permissionMode === "safe-yolo") {
+      config.sandbox = "workspace-write";
+    } else if (initial.mode.permissionMode === "yolo") {
+      config.sandbox = "danger-full-access";
+    } else {
+      config.sandbox = "workspace-write";
+    }
+    if (initial.mode.model) {
+      config.model = initial.mode.model;
+    }
+    if (opts.sessionId || opts.conversationId || opts.mcpServers) {
+      config.config = {};
+      const resumeHint = (opts.conversationId || opts.sessionId) ?? null;
+      if (resumeHint) {
+        config.resume = resumeHint;
+        config.experimental_resume = resumeHint;
+        config.session_id = resumeHint;
+        config.conversationId = resumeHint;
+        config.conversation_id = resumeHint;
+        config.config.resume = resumeHint;
+        config.config.experimental_resume = resumeHint;
+        config.config.conversationId = resumeHint;
+        config.config.conversation_id = resumeHint;
+        config.thread_id = resumeHint;
+        config.threadId = resumeHint;
+        config.config.thread_id = resumeHint;
+        config.config.threadId = resumeHint;
+        types.logger.debug("[codexRemote] Attempting resume with hint:", resumeHint);
+      }
+      if (opts.mcpServers) {
+        config.config.mcp_servers = opts.mcpServers;
+      }
+    }
+    updateThinking(true);
+    types.logger.debug("[codexRemote] Starting MCP session");
+    await mcp.startSession(config, { signal: opts.signal });
+    const sessionId = mcp.getSessionId();
+    if (sessionId) {
+      types.logger.debug("[codexRemote] Session ID extracted:", sessionId);
+      opts.onSessionFound(sessionId);
+    }
+    if (isCompactCommand) {
+      types.logger.debug("[codexRemote] Compaction completed");
+      if (opts.onCompletionEvent) {
+        opts.onCompletionEvent("Compaction completed");
+      }
+    }
+    updateThinking(false);
+    opts.onReady();
+    while (true) {
+      const next = await opts.nextMessage();
+      if (!next) {
+        types.logger.debug("[codexRemote] No next message, exiting");
+        break;
+      }
+      const nextSpecialCommand = index.parseSpecialCommand(next.message);
+      if (nextSpecialCommand.type === "clear") {
+        types.logger.debug("[codexRemote] /clear command in continuation");
+        mcp.clearSession();
+        if (opts.onCompletionEvent) {
+          opts.onCompletionEvent("Context was reset");
+        }
+        if (opts.onSessionReset) {
+          opts.onSessionReset();
+        }
+        break;
+      }
+      updateThinking(true);
+      types.logger.debug("[codexRemote] Continuing MCP session");
+      await mcp.continueSession(next.message, { signal: opts.signal });
+      updateThinking(false);
+      opts.onReady();
+    }
+  } catch (error) {
+    if (error?.name === "AbortError" || opts.signal?.aborted) {
+      types.logger.debug("[codexRemote] Aborted");
+    } else {
+      types.logger.debug("[codexRemote] Error in codexRemote:", error);
+      throw error;
+    }
+  } finally {
+    updateThinking(false);
+    try {
+      await mcp.disconnect();
+    } catch (error) {
+      types.logger.debug("[codexRemote] Error disconnecting from MCP:", error);
+    }
+  }
+}
+
+class CodexPermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  /**
+   * 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.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [toolCallId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now()
+          }
+        }
+      }));
+      types.logger.debug(`[Codex] Permission request sent for tool: ${toolName} (${toolCallId})`);
+    });
+  }
+  /**
+   * Setup RPC handler for permission responses
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          types.logger.debug("[Codex] Permission request not found or already resolved");
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+          return res;
+        });
+        types.logger.debug(`[Codex] Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
+      }
+    );
+  }
+  /**
+   * Reset state for new sessions
+   */
+  reset() {
+    for (const [id, pending] of this.pendingRequests.entries()) {
+      pending.reject(new Error("Session reset"));
+    }
+    this.pendingRequests.clear();
+    this.session.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason: "Session reset"
+        };
+      }
+      return {
+        ...currentState,
+        requests: {},
+        completedRequests
+      };
+    });
+    types.logger.debug("[Codex] Permission handler reset");
+  }
+}
+
+function formatCodexEventForInk(event, messageBuffer) {
+  try {
+    if (!event || typeof event !== "object") return;
+    switch (event.type) {
+      case "session_configured": {
+        messageBuffer.addMessage("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500", "status");
+        if (event.session_id) messageBuffer.addMessage(`Session: ${event.session_id}`, "system");
+        if (event.model) messageBuffer.addMessage(`Model: ${event.model}`, "status");
+        if (event.rollout_path) messageBuffer.addMessage(`Session log: ${event.rollout_path}`, "status");
+        messageBuffer.addMessage("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500", "status");
+        break;
+      }
+      case "task_started": {
+        messageBuffer.addMessage("Thinking\u2026", "status");
+        break;
+      }
+      case "task_complete": {
+        messageBuffer.addMessage("Done", "status");
+        break;
+      }
+      case "message": {
+        const role = event.role || "system";
+        const blocks = Array.isArray(event.content) ? event.content : [];
+        for (const b of blocks) {
+          if (b && typeof b === "object") {
+            if (b.type === "input_text" || b.type === "text") {
+              const text = b.text ?? "";
+              if (role === "user") {
+                messageBuffer.addMessage(`User: ${text}`, "user");
+              } else if (role === "assistant") {
+                messageBuffer.addMessage(text, "assistant");
+              }
+            } else if (b.type === "output_text") {
+              const text = b.text ?? "";
+              const last = messageBuffer.peekLast();
+              if (!(last && last.type === "assistant" && last.content === text)) {
+                messageBuffer.addMessage(text, "assistant");
+              }
+            }
+          }
+        }
+        break;
+      }
+      case "agent_message_delta": {
+        const delta = event.delta ?? "";
+        if (typeof delta === "string" && delta) {
+          messageBuffer.appendToLast(delta, "assistant");
+        }
+        break;
+      }
+      case "agent_message": {
+        break;
+      }
+      case "agent_reasoning_delta": {
+        if (event.delta) {
+          const text = String(event.delta);
+          const last = messageBuffer.peekLast();
+          if (last && last.type === "status" && /^Tokens\s+—/.test(last.content)) {
+            messageBuffer.addMessage(text, "status");
+          } else {
+            messageBuffer.appendToLast(text, "status");
+          }
+        }
+        break;
+      }
+      case "agent_reasoning": {
+        if (event.text) messageBuffer.addMessage(String(event.text), "status");
+        break;
+      }
+      case "token_count": {
+        try {
+          const input = event.info?.last_token_usage?.input_tokens ?? event.info?.total_token_usage?.input_tokens;
+          const output = event.info?.last_token_usage?.output_tokens ?? event.info?.total_token_usage?.output_tokens;
+          if (typeof input === "number" || typeof output === "number") {
+            messageBuffer.addMessage(`Tokens \u2014 in: ${input ?? 0}, out: ${output ?? 0}`, "status");
+          }
+        } catch {
+        }
+        break;
+      }
+      default: {
+        if (process.env.DEBUG) {
+          messageBuffer.addMessage(`[${event.type}]`, "status");
+        }
+      }
+    }
+  } catch (e) {
+    types.logger.debug("[CODEX INK] Failed to format event:", e);
+  }
+}
+
+async function codexRemoteLauncher(session) {
+  let exitReason = null;
+  const abortController = new AbortController();
+  let uiStreaming = true;
+  const permissionHandler = new CodexPermissionHandler(session.client);
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  let inkInstance = null;
+  let messageBuffer = null;
+  if (hasTTY) {
+    try {
+      console.clear();
+    } catch {
+    }
+    messageBuffer = new index.MessageBuffer();
+    inkInstance = ink.render(React.createElement(index.RemoteModeDisplay, {
+      messageBuffer,
+      title: "Codex Messages",
+      logPath: process.env.DEBUG ? session.logPath : void 0,
+      onExit: async () => {
+        types.logger.debug("[CodexRemote]: Exit requested via UI");
+        if (!exitReason) exitReason = "exit";
+        try {
+          messageBuffer?.addMessage("Exiting\u2026", "status");
+        } catch {
+        }
+        uiStreaming = false;
+        abortController.abort();
+      },
+      onSwitchToLocal: async () => {
+        types.logger.debug("[CodexRemote]: Switch to local requested via UI");
+        if (!exitReason) exitReason = "switch";
+        try {
+          messageBuffer?.addMessage("Switching to local mode\u2026", "status");
+        } catch {
+        }
+        uiStreaming = false;
+        abortController.abort();
+      }
+    }), { exitOnCtrlC: false, patchConsole: false });
+    process.stdin.resume();
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
+  }
+  try {
+    async function doSwitch() {
+      types.logger.debug("[CodexRemote]: doSwitch - switching to local");
+      if (!exitReason) {
+        exitReason = "switch";
+      }
+      abortController.abort();
+    }
+    async function doExit() {
+      types.logger.debug("[CodexRemote]: doExit");
+      if (!exitReason) {
+        exitReason = "exit";
+      }
+      abortController.abort();
+    }
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
+    types.logger.debug("[CodexRemote]: Starting remote Codex control via MCP");
+    const remoteOptions = {
+      path: session.path,
+      sessionId: session.sessionId,
+      conversationId: session.conversationId ?? null,
+      mcpServers: session.mcpServers,
+      signal: abortController.signal,
+      permissionHandler,
+      nextMessage: async () => {
+        const batch = await session.queue.waitForMessagesAndGetAsString(abortController.signal);
+        if (!batch) return null;
+        return {
+          message: batch.message,
+          mode: batch.mode
+        };
+      },
+      onSessionFound: (sessionId) => {
+        session.onSessionFound(sessionId);
+      },
+      onReady: () => {
+        session.client.sendSessionEvent({ type: "ready" });
+      },
+      onThinkingChange: (isThinking) => {
+        session.onThinkingChange(isThinking);
+      },
+      onMessage: (message) => {
+        if (messageBuffer && uiStreaming) {
+          formatCodexEventForInk(message, messageBuffer);
+        }
+        let shouldForwardRaw = true;
+        try {
+          const t = message?.type;
+          if (t === "agent_message_delta" || t === "agent_reasoning_delta" || t === "agent_reasoning_section_break") {
+            shouldForwardRaw = false;
+          }
+          if (t === "message" && message?.role === "assistant" && Array.isArray(message?.content) && message.content.some((b) => b && typeof b === "object" && b.type === "output_text" && typeof b.text === "string")) {
+            shouldForwardRaw = false;
+          }
+        } catch {
+        }
+        if (shouldForwardRaw) {
+          session.client.sendCodexMessage(message);
+        }
+        try {
+          const candidates = [];
+          if (message && typeof message === "object") candidates.push(message);
+          if (message?.data && typeof message.data === "object") candidates.push(message.data);
+          for (const c of candidates) {
+            const conv = c.conversation_id || c.conversationId;
+            if (typeof conv === "string" && conv) {
+              session.onConversationFound(conv);
+              break;
+            }
+          }
+        } catch {
+        }
+        try {
+          if (message && typeof message === "object" && message.type === "message" && message.role === "assistant" && Array.isArray(message.content)) {
+            for (const block of message.content) {
+              if (block && typeof block === "object" && block.type === "output_text" && typeof block.text === "string") {
+                const text = block.text;
+                session.client.sendCodexMessage({
+                  type: "message",
+                  message: text,
+                  id: node_crypto.randomUUID()
+                });
+                try {
+                  session.client.sendClaudeSessionMessage({
+                    type: "assistant",
+                    uuid: node_crypto.randomUUID(),
+                    message: { content: [{ type: "text", text }] }
+                  });
+                } catch {
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      },
+      onCompletionEvent: (message) => {
+        types.logger.debug(`[CodexRemote]: ${message}`);
+      },
+      onSessionReset: () => {
+        permissionHandler.reset();
+      }
+    };
+    await codexRemote(remoteOptions);
+  } catch (error) {
+    if (error?.name === "AbortError" || abortController.signal.aborted) {
+      types.logger.debug("[CodexRemote]: Aborted");
+    } else {
+      types.logger.debug("[CodexRemote]: Error:", error);
+      throw error;
+    }
+  } finally {
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
+    });
+    permissionHandler.reset();
+    try {
+      inkInstance?.unmount?.();
+    } catch {
+    }
+    try {
+      inkInstance?.clear?.();
+    } catch {
+    }
+    try {
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    } catch {
+    }
+  }
+  return exitReason || "exit";
+}
+
+async function codexLoop(opts) {
+  const logPath = types.logger.logFilePath;
+  let session = new CodexSession({
+    api: opts.api,
+    client: opts.session,
+    path: opts.path,
+    sessionId: null,
+    mcpServers: opts.mcpServers,
+    logPath,
+    messageQueue: opts.messageQueue,
+    onModeChange: opts.onModeChange
+  });
+  if (opts.onSessionReady) {
+    opts.onSessionReady(session);
+  }
+  let mode = opts.startingMode ?? "local";
+  while (true) {
+    types.logger.debug(`[CodexLoop] Iteration with mode: ${mode}`);
+    if (mode === "local") {
+      let reason = await codexLocalLauncher(session);
+      if (reason === "exit") {
+        return;
+      }
+      mode = "remote";
+      if (opts.onModeChange) {
+        opts.onModeChange(mode);
+      }
+      continue;
+    }
+    if (mode === "remote") {
+      let reason = await codexRemoteLauncher(session);
+      if (reason === "exit") {
+        return;
+      }
+      mode = "local";
+      if (opts.onModeChange) {
+        opts.onModeChange(mode);
+      }
+      continue;
+    }
+  }
+}
+
+async function runCodex(credentials, options = {}) {
+  const workingDirectory = process.cwd();
+  const sessionTag = node_crypto.randomUUID();
+  types.logger.debug("[START] Starting Codex process");
+  types.logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
+  if (options.startedBy === "daemon" && options.startingMode === "local") {
+    types.logger.debug("Daemon spawn requested with local mode - forcing remote mode");
+    options.startingMode = "remote";
+  }
+  const api = new types.ApiClient(credentials.token, credentials.secret);
+  let state = {};
+  const settings = await types.readSettings();
+  let machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings. Please report this issue.`);
+    process.exit(1);
+  }
+  types.logger.debug(`Using machineId: ${machineId}`);
+  const machine = await api.getOrCreateMachine({
+    machineId,
+    metadata: index.initialMachineMetadata
+  });
+  const foregroundMachineClient = api.machineSyncClient(machine);
+  foregroundMachineClient.connect();
+  let metadata = {
+    path: workingDirectory,
+    host: os.hostname(),
+    version: types.packageJson.version,
+    os: os.platform(),
+    machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: types.configuration.happyHomeDir,
+    happyLibDir: types.projectPath(),
+    happyToolsDir: node_path.resolve(types.projectPath(), "tools", "unpacked"),
+    startedFromDaemon: options.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: options.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: "codex"
+  };
+  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  types.logger.debug(`Session created: ${response.id}`);
+  try {
+    types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+    const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+    if (result.error) {
+      types.logger.debug(`[START] Failed to report to daemon:`, result.error);
+    } else {
+      types.logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    types.logger.debug("[START] Failed to report to daemon:", error);
+  }
+  const session = api.sessionSyncClient(response);
+  const chellServer = await index.startChellServer(session);
+  types.logger.debug(`[START] Chell MCP server started at ${chellServer.url}`);
+  const logPath = types.logger.logFilePath;
+  types.logger.infoDeveloper(`Session: ${response.id}`);
+  types.logger.infoDeveloper(`Logs: ${logPath}`);
+  session.updateAgentState((currentState) => ({
+    ...currentState,
+    controlledByUser: options.startingMode !== "remote"
+  }));
+  const caffeinateStarted = index.startCaffeinate();
+  if (caffeinateStarted) {
+    types.logger.infoDeveloper("Sleep prevention enabled (macOS)");
+  }
+  const messageQueue = new index.MessageQueue2((mode) => index.hashObject({
+    permissionMode: mode.permissionMode,
+    model: mode.model
+  }));
+  let currentPermissionMode = void 0;
+  let currentModel = void 0;
+  session.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "read-only", "safe-yolo", "yolo"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        types.logger.debug(`[Codex] Permission mode updated: ${currentPermissionMode}`);
+      }
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+      types.logger.debug(`[Codex] Model updated: ${messageModel || "default"}`);
+    }
+    const enhancedMode = {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel
+    };
+    messageQueue.push(message.content.text, enhancedMode);
+    types.logger.debugLargeJson("User message pushed to queue:", message);
+  });
+  const cleanup = async () => {
+    types.logger.debug("[START] Received termination signal, cleaning up...");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      index.stopCaffeinate();
+      chellServer.stop();
+      try {
+        foregroundMachineClient.shutdown();
+      } catch {
+      }
+      types.logger.debug("[START] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      types.logger.debug("[START] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("uncaughtException", (error) => {
+    types.logger.debug("[START] Uncaught exception:", error);
+    cleanup();
+  });
+  process.on("unhandledRejection", (reason) => {
+    types.logger.debug("[START] Unhandled rejection:", reason);
+    cleanup();
+  });
+  index.registerKillSessionHandler(session.rpcHandlerManager, cleanup);
+  const mcpServers = {
+    chell: {
+      command: "node",
+      args: [node_path.resolve(types.projectPath(), "bin", "chell-mcp.mjs"), "--url", chellServer.url]
+    }
+  };
+  await codexLoop({
+    path: workingDirectory,
+    startingMode: options.startingMode,
+    messageQueue,
+    api,
+    onModeChange: (newMode) => {
+      session.sendSessionEvent({ type: "switch", mode: newMode });
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: newMode === "local"
+      }));
+    },
+    onSessionReady: (_sessionInstance) => {
+    },
+    mcpServers,
+    session
+  });
+  session.sendSessionDeath();
+  types.logger.debug("Waiting for socket to flush...");
+  await session.flush();
+  types.logger.debug("Closing session...");
+  await session.close();
+  index.stopCaffeinate();
+  types.logger.debug("Stopped sleep prevention");
+  chellServer.stop();
+  types.logger.debug("Stopped Chell MCP server");
+  process.exit(0);
+}
+
+exports.runCodex = runCodex;