@codex-native/sdk 0.0.1 → 0.0.3

package/dist/cli.cjs

@@ -0,0 +1,3510 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/cli/index.ts
+var import_node_process3 = __toESM(require("process"));
+var import_node_util2 = require("util");
+var import_node_url4 = require("url");
+
+// package.json
+var package_default = {
+  name: "@codex-native/sdk",
+  version: "0.0.3",
+  description: "Native NAPI-based Codex SDK - complete standalone implementation.",
+  main: "dist/index.cjs",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.cjs"
+    }
+  },
+  bin: {
+    "codex-native": "dist/cli.cjs"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "npm",
+    "*.node",
+    "index.js",
+    "index.d.ts"
+  ],
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@opencode-ai/sdk": "^1.0.68",
+    "@toon-format/toon": "^1.0.0",
+    pyright: "^1.1.386",
+    "typescript-language-server": "^4.3.3",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-types": "^3.17.5"
+  },
+  scripts: {
+    clean: "rm -rf dist *.node npm target/release/*.node && cargo clean --release",
+    "clean:all": "rm -rf dist *.node npm target node_modules && cargo clean",
+    build: "npm run build:rust && npm run build:napi && npm run build:ts && npm run verify:build",
+    "build:ci": "npm run build:napi && npm run build:ts && npm run verify:build",
+    "build:rust": "cargo fmt && cargo clippy --release --features napi-bindings -- -D warnings",
+    "build:napi": "napi build --platform --release --features napi-bindings",
+    "build:napi:debug": "napi build --platform --features napi-bindings",
+    "build:ts": "tsup",
+    "verify:build": `node -e "const fs=require('fs');const hasNode=fs.readdirSync('.').some(f=>f.endsWith('.node'));const hasDist=fs.existsSync('dist/index.mjs')&&fs.existsSync('dist/index.d.ts');const hasLoader=fs.existsSync('index.js');if(!hasNode||!hasDist||!hasLoader){console.error('Build incomplete: missing .node, dist, or loader index.js');process.exit(1)}require('./index.js');console.log('\u2713 Build verification passed')"`,
+    "verify:pack": "node ./scripts/verify-pack.mjs",
+    "create-npm-dirs": "napi create-npm-dirs",
+    artifacts: "napi artifacts",
+    prepublishOnly: "napi prepublish -t npm",
+    pretest: `node -e "const fs=require('fs');const hasNode=fs.readdirSync('.').some(f=>f.endsWith('.node'));if(!hasNode){process.exitCode=1;console.error('missing .node binary; run npm run build:ci');} else {console.log('\u2713 native binary present; skipping rebuild');}"`,
+    test: "node ./scripts/run-jest.mjs --runInBand",
+    "test:watch": "node ./scripts/run-jest.mjs --watch",
+    coverage: "node ./scripts/run-jest.mjs --coverage",
+    typecheck: "tsc --noEmit",
+    lint: "cargo fmt --check && cargo clippy --release --features napi-bindings -- -D warnings && npm run typecheck",
+    version: "napi version",
+    "release:patch": "npm version patch && npm run release",
+    "release:minor": "npm version minor && npm run release",
+    "release:major": "npm version major && npm run release",
+    "publish:platforms": "npm run create-npm-dirs && node scripts/publish-platform-packages.mjs",
+    release: "npm run build && npm run test && npm run verify:pack && npm run publish:platforms && node scripts/publish-sdk.mjs",
+    "release:dry": "npm run build && npm run test && npm run verify:pack && npm publish --dry-run"
+  },
+  napi: {
+    binaryName: "codex_native",
+    targets: [
+      "aarch64-apple-darwin",
+      "x86_64-apple-darwin",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "x86_64-unknown-linux-musl",
+      "aarch64-pc-windows-msvc",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  optionalDependencies: {
+    "@codex-native/sdk-darwin-arm64": "0.0.3",
+    "@codex-native/sdk-darwin-x64": "0.0.3",
+    "@codex-native/sdk-linux-arm64-gnu": "0.0.3",
+    "@codex-native/sdk-linux-x64-gnu": "0.0.3",
+    "@codex-native/sdk-linux-arm64-musl": "0.0.3",
+    "@codex-native/sdk-linux-x64-musl": "0.0.3",
+    "@codex-native/sdk-win32-arm64-msvc": "0.0.3",
+    "@codex-native/sdk-win32-x64-msvc": "0.0.3"
+  },
+  engines: {
+    node: ">=18"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  devDependencies: {
+    "@babel/core": "7.25.2",
+    "@babel/preset-env": "7.25.4",
+    "@babel/preset-typescript": "7.28.5",
+    "@jest/globals": "^29.7.0",
+    "@napi-rs/cli": "^3.4.1",
+    "@openai/agents": "^0.3.0",
+    "@types/jest": "29.5.11",
+    "@types/node": "^22.0.0",
+    "babel-jest": "29.7.0",
+    jest: "^29.7.0",
+    "ts-jest": "^29.1.1",
+    tsup: "^8.5.0",
+    tsx: "^4.20.6",
+    typescript: "^5.7.2",
+    zod: "^3.25.76"
+  }
+};
+
+// src/cli/config.ts
+var import_node_fs = __toESM(require("fs"));
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_node_module = require("module");
+var import_node_url = require("url");
+var requireFromThisModule = (0, import_node_module.createRequire)(importMetaUrl);
+var CONFIG_CANDIDATES = [
+  "codex.config.js",
+  "codex.config.cjs",
+  "codex.config.mjs",
+  "codex.config.ts",
+  "codex.js",
+  ".codexrc.js",
+  ".codexrc.cjs",
+  ".codexrc.mjs",
+  ".codexrc.json"
+];
+async function loadCliConfig(options) {
+  const warnings = [];
+  const discovery = await resolveConfigPath(options);
+  const configPath = discovery?.path ?? null;
+  let config = null;
+  if (discovery) {
+    const loadResult = await loadConfig(discovery, warnings);
+    config = loadResult ?? null;
+    if (config && typeof config !== "object") {
+      warnings.push(
+        `Config at ${discovery.path} must export an object. Received ${typeof config}.`
+      );
+      config = null;
+    }
+  }
+  const plugins = await resolvePlugins({
+    config,
+    configPath,
+    cliPluginPaths: options.pluginPaths ?? [],
+    cwd: options.cwd,
+    warnings
+  });
+  return {
+    configPath,
+    config,
+    plugins,
+    warnings
+  };
+}
+async function resolveConfigPath(options) {
+  if (options.explicitConfigPath) {
+    const explicitPath = import_node_path.default.resolve(options.cwd, options.explicitConfigPath);
+    if (!import_node_fs.default.existsSync(explicitPath)) {
+      throw new Error(`Config file not found at ${explicitPath}`);
+    }
+    return classifyPath(explicitPath);
+  }
+  if (options.noConfig) {
+    return null;
+  }
+  let currentDir = import_node_path.default.resolve(options.cwd);
+  const visited = /* @__PURE__ */ new Set();
+  while (!visited.has(currentDir)) {
+    visited.add(currentDir);
+    for (const candidate of CONFIG_CANDIDATES) {
+      const candidatePath = import_node_path.default.join(currentDir, candidate);
+      if (import_node_fs.default.existsSync(candidatePath) && import_node_fs.default.statSync(candidatePath).isFile()) {
+        return classifyPath(candidatePath);
+      }
+    }
+    const packageJsonPath = import_node_path.default.join(currentDir, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath) && import_node_fs.default.statSync(packageJsonPath).isFile()) {
+      const manifest = await readJson(packageJsonPath);
+      if (manifest && manifest.codexNative != null) {
+        return { path: packageJsonPath, type: "package-json", field: "codexNative" };
+      }
+    }
+    const parentDir = import_node_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function loadConfig(discovery, warnings) {
+  if (discovery.type === "package-json") {
+    const manifest = await readJson(discovery.path);
+    if (!manifest) {
+      warnings.push(`Failed to parse ${discovery.path}; ignoring config.`);
+      return null;
+    }
+    const raw = manifest[discovery.field];
+    if (typeof raw === "string") {
+      const baseDir = import_node_path.default.dirname(discovery.path);
+      const nestedPath = import_node_path.default.resolve(baseDir, raw);
+      if (!import_node_fs.default.existsSync(nestedPath)) {
+        throw new Error(
+          `Config path "${raw}" referenced by ${discovery.field} in ${discovery.path} was not found.`
+        );
+      }
+      return loadConfig({ path: nestedPath, type: "file" }, warnings);
+    }
+    if (typeof raw === "object" && raw !== null) {
+      return raw;
+    }
+    warnings.push(
+      `The ${discovery.field} field in ${discovery.path} must be an object or path string.`
+    );
+    return null;
+  }
+  const ext = import_node_path.default.extname(discovery.path).toLowerCase();
+  if (ext === ".json") {
+    const json = await readJson(discovery.path);
+    if (json === null) {
+      warnings.push(`Failed to parse JSON config at ${discovery.path}`);
+    }
+    return json;
+  }
+  if (ext === ".js" || ext === ".cjs") {
+    return extractModuleDefault(await loadCommonJsModule(discovery.path));
+  }
+  if (ext === ".mjs") {
+    return extractModuleDefault(await importModule(discovery.path));
+  }
+  if (ext === ".ts") {
+    return extractModuleDefault(await loadTypeScriptModule(discovery.path, warnings));
+  }
+  throw new Error(`Unsupported config extension "${ext}" at ${discovery.path}`);
+}
+async function resolvePlugins(params) {
+  const plugins = [];
+  const { config, configPath, cliPluginPaths, cwd, warnings } = params;
+  const configDir = configPath ? import_node_path.default.dirname(configPath) : cwd;
+  const rawConfigPlugins = config?.plugins;
+  const configPlugins = Array.isArray(rawConfigPlugins) ? rawConfigPlugins : [];
+  for (const spec of configPlugins) {
+    if (typeof spec === "string") {
+      const loaded = await loadPlugin(spec, configDir, "config", warnings);
+      if (loaded) {
+        plugins.push(loaded);
+      }
+    } else if (spec != null) {
+      plugins.push({
+        source: "config",
+        spec: "<inline>",
+        plugin: spec
+      });
+    }
+  }
+  for (const spec of cliPluginPaths) {
+    const loaded = await loadPlugin(spec, cwd, "cli", warnings);
+    if (loaded) {
+      plugins.push(loaded);
+    }
+  }
+  return plugins;
+}
+async function loadPlugin(spec, baseDir, source, warnings) {
+  try {
+    const resolved = resolveModule(spec, baseDir);
+    const moduleExports = await loadModuleForPath(resolved);
+    return {
+      source,
+      spec,
+      resolvedPath: resolved,
+      plugin: extractModuleDefault(moduleExports)
+    };
+  } catch (err) {
+    warnings.push(`Failed to load plugin "${spec}": ${err.message}`);
+    return null;
+  }
+}
+async function loadModuleForPath(modulePath) {
+  const ext = import_node_path.default.extname(modulePath).toLowerCase();
+  if (ext === ".cjs") {
+    return loadCommonJsModule(modulePath);
+  }
+  if (ext === ".mjs") {
+    return importModule(modulePath);
+  }
+  if (ext === ".ts") {
+    return loadTypeScriptModule(modulePath);
+  }
+  if (ext === ".json") {
+    return readJson(modulePath);
+  }
+  if (ext === ".js") {
+    try {
+      return loadCommonJsModule(modulePath);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("ERR_REQUIRE_ESM")) {
+        return importModule(modulePath);
+      }
+      throw err;
+    }
+  }
+  return loadCommonJsModule(modulePath);
+}
+async function loadCommonJsModule(modulePath) {
+  return requireFromThisModule(modulePath);
+}
+async function importModule(modulePath) {
+  const href = (0, import_node_url.pathToFileURL)(modulePath).href;
+  return import(href);
+}
+async function loadTypeScriptModule(modulePath, warnings) {
+  try {
+    const { register } = requireFromThisModule("tsx/cjs/api");
+    const unregister = register({ transpileOnly: true });
+    try {
+      return requireFromThisModule(modulePath);
+    } finally {
+      await maybeCall(unregister);
+    }
+  } catch (cjsError) {
+    try {
+      const tsxEsmSpecifier = "tsx/esm/api";
+      const apiModule = await import(tsxEsmSpecifier);
+      const unregister = typeof apiModule.register === "function" ? apiModule.register({ transpileOnly: true }) : apiModule.default({ transpileOnly: true });
+      try {
+        return importModule(modulePath);
+      } finally {
+        await maybeCall(unregister);
+      }
+    } catch (esmError) {
+      const message = [
+        `Failed to load TypeScript module ${modulePath}.`,
+        'Install the "tsx" package or convert the config to JavaScript.'
+      ].join(" ");
+      if (warnings) {
+        warnings.push(message);
+        return null;
+      }
+      throw new Error(message);
+    }
+  }
+}
+async function readJson(filePath) {
+  try {
+    const raw = await import_promises.default.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractModuleDefault(module2) {
+  if (module2 && typeof module2 === "object" && "default" in module2) {
+    const value = module2.default;
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return module2;
+}
+function resolveModule(specifier, baseDir) {
+  if (import_node_path.default.isAbsolute(specifier)) {
+    return specifier;
+  }
+  return requireFromThisModule.resolve(specifier, { paths: [baseDir] });
+}
+function classifyPath(filePath) {
+  if (import_node_path.default.basename(filePath) === "package.json") {
+    return { path: filePath, type: "package-json", field: "codexNative" };
+  }
+  return { path: filePath, type: "file" };
+}
+async function maybeCall(candidate) {
+  if (typeof candidate === "function") {
+    await Promise.resolve(candidate());
+  }
+}
+
+// src/cli/run.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path4 = __toESM(require("path"));
+var import_node_process = __toESM(require("process"));
+
+// src/nativeBinding.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_module2 = require("module");
+var import_node_path2 = __toESM(require("path"));
+var import_node_url2 = require("url");
+var CLI_ENTRYPOINT_ENV = "CODEX_NODE_CLI_ENTRYPOINT";
+function ensureCliEntrypointEnv() {
+  if (process.env[CLI_ENTRYPOINT_ENV]) {
+    return;
+  }
+  const filename = (0, import_node_url2.fileURLToPath)(importMetaUrl);
+  const dirname3 = import_node_path2.default.dirname(filename);
+  const candidates = [
+    import_node_path2.default.resolve(dirname3, "cli.cjs"),
+    import_node_path2.default.resolve(dirname3, "../cli.cjs"),
+    import_node_path2.default.resolve(dirname3, "../dist/cli.cjs")
+  ];
+  for (const candidate of candidates) {
+    if (import_node_fs2.default.existsSync(candidate)) {
+      process.env[CLI_ENTRYPOINT_ENV] = candidate;
+      break;
+    }
+  }
+}
+ensureCliEntrypointEnv();
+var cachedBinding;
+function getImportMetaUrl2() {
+  try {
+    return Function(
+      "return typeof import.meta !== 'undefined' && import.meta.url ? import.meta.url : undefined;"
+    )();
+  } catch {
+    return void 0;
+  }
+}
+function resolveBindingEntryPath() {
+  if (typeof __dirname === "string") {
+    return import_node_path2.default.resolve(__dirname, "..", "index.js");
+  }
+  const importMetaUrl2 = getImportMetaUrl2();
+  if (importMetaUrl2) {
+    try {
+      const filePath = (0, import_node_url2.fileURLToPath)(importMetaUrl2);
+      return import_node_path2.default.resolve(import_node_path2.default.dirname(filePath), "..", "index.js");
+    } catch {
+    }
+  }
+  return import_node_path2.default.resolve(process.cwd(), "index.js");
+}
+function resolveRequire() {
+  const globalRequire = globalThis.require;
+  if (typeof globalRequire === "function") {
+    return globalRequire;
+  }
+  if (typeof __filename === "string") {
+    try {
+      return (0, import_node_module2.createRequire)(__filename);
+    } catch {
+    }
+  }
+  const importMetaUrl2 = getImportMetaUrl2();
+  if (importMetaUrl2) {
+    try {
+      return (0, import_node_module2.createRequire)(importMetaUrl2);
+    } catch {
+    }
+  }
+  const fallbackBase = typeof __dirname === "string" ? __dirname : process.cwd();
+  const fallbackPath = import_node_path2.default.join(fallbackBase, "noop.js");
+  return (0, import_node_module2.createRequire)(fallbackPath);
+}
+function getNativeBinding() {
+  if (cachedBinding !== void 0) {
+    return cachedBinding;
+  }
+  const requireFn = resolveRequire();
+  const envPath = process.env.CODEX_NATIVE_BINDING;
+  if (envPath && envPath.length > 0) {
+    process.env.NAPI_RS_NATIVE_LIBRARY_PATH = envPath;
+  }
+  const bindingEntryPath = resolveBindingEntryPath();
+  try {
+    const binding = requireFn(bindingEntryPath);
+    binding.ensureTokioRuntime?.();
+    cachedBinding = binding;
+    return cachedBinding;
+  } catch (error) {
+    console.warn("Failed to load native NAPI binding:", error);
+    cachedBinding = null;
+    return cachedBinding;
+  }
+}
+function runApplyPatch(patch) {
+  if (!patch) {
+    throw new Error("apply_patch requires patch contents");
+  }
+  const binding = getNativeBinding();
+  if (!binding) throw new Error("Native binding not available");
+  binding.runApplyPatch(patch);
+}
+async function reverieIndexSemantic(codexHomePath, options) {
+  const binding = getNativeBinding();
+  if (!binding?.reverieIndexSemantic) throw new Error("Native binding not available or reverie functions not supported");
+  return binding.reverieIndexSemantic(codexHomePath, options);
+}
+async function fastEmbedInit(options) {
+  const binding = getNativeBinding();
+  if (!binding?.fastEmbedInit) throw new Error("Native binding not available or FastEmbed functions not supported");
+  await binding.fastEmbedInit(options);
+}
+
+// src/events/convert.ts
+function convertRustEventToThreadEvent(rustEvent) {
+  if (rustEvent?.ThreadStarted) {
+    return {
+      type: "thread.started",
+      thread_id: rustEvent.ThreadStarted.thread_id
+    };
+  }
+  if (rustEvent?.TurnStarted) {
+    return { type: "turn.started" };
+  }
+  if (rustEvent?.TurnCompleted) {
+    return {
+      type: "turn.completed",
+      usage: rustEvent.TurnCompleted.usage
+    };
+  }
+  if (rustEvent?.TurnFailed) {
+    return {
+      type: "turn.failed",
+      error: rustEvent.TurnFailed.error
+    };
+  }
+  if (rustEvent?.ItemStarted) {
+    return {
+      type: "item.started",
+      item: rustEvent.ItemStarted.item
+    };
+  }
+  if (rustEvent?.ItemUpdated) {
+    return {
+      type: "item.updated",
+      item: rustEvent.ItemUpdated.item
+    };
+  }
+  if (rustEvent?.ItemCompleted) {
+    return {
+      type: "item.completed",
+      item: rustEvent.ItemCompleted.item
+    };
+  }
+  if (rustEvent?.Error) {
+    return {
+      type: "error",
+      message: rustEvent.Error.message
+    };
+  }
+  if (rustEvent?.BackgroundEvent) {
+    return {
+      type: "background_event",
+      message: rustEvent.BackgroundEvent.message
+    };
+  }
+  if (rustEvent?.type === "background_event" && typeof rustEvent.message === "string") {
+    return {
+      type: "background_event",
+      message: rustEvent.message
+    };
+  }
+  if (rustEvent?.type === "plan_update_scheduled" && rustEvent.plan) {
+    const planData = rustEvent.plan;
+    const planItems = planData.plan || [];
+    return {
+      type: "item.completed",
+      item: {
+        id: `plan-${Date.now()}`,
+        type: "todo_list",
+        items: planItems.map((item) => ({
+          text: item.step,
+          completed: item.status === "completed"
+        }))
+      }
+    };
+  }
+  if (rustEvent?.type) {
+    return rustEvent;
+  }
+  return rustEvent;
+}
+
+// src/cli/optionParsers.ts
+var SANDBOX_MODE_VALUES = ["read-only", "workspace-write", "danger-full-access"];
+var APPROVAL_MODE_VALUES = ["never", "on-request", "on-failure", "untrusted"];
+function isSandboxMode(value) {
+  return SANDBOX_MODE_VALUES.includes(value);
+}
+function isApprovalMode(value) {
+  return APPROVAL_MODE_VALUES.includes(value);
+}
+function parseSandboxModeFlag(value, origin) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (isSandboxMode(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid sandbox mode "${value}" from ${origin}. Valid values: ${SANDBOX_MODE_VALUES.join(
+      ", "
+    )}.`
+  );
+}
+function parseApprovalModeFlag(value, origin) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (isApprovalMode(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid approval mode "${value}" from ${origin}. Valid values: ${APPROVAL_MODE_VALUES.join(
+      ", "
+    )}.`
+  );
+}
+
+// src/cli/hooks.ts
+function emitWarnings(warnings, fromIndex = 0) {
+  for (let i = fromIndex; i < warnings.length; i += 1) {
+    const message = warnings[i];
+    process.stderr.write(`[codex-native] Warning: ${message}
+`);
+  }
+}
+async function runBeforeStartHooks(hooks, context, warnings) {
+  for (const hook of hooks) {
+    try {
+      await hook.callback(context);
+    } catch (error) {
+      warnings.push(
+        `beforeStart hook "${hook.source}" threw: ${error.message ?? String(error)}`
+      );
+    }
+  }
+}
+async function runEventHooks(hooks, event, context, warnings) {
+  for (const hook of hooks) {
+    try {
+      await hook.callback(event, context);
+    } catch (error) {
+      warnings.push(`onEvent hook "${hook.source}" threw: ${error.message ?? String(error)}`);
+    }
+  }
+}
+
+// src/cli/elevatedDefaults.ts
+var import_node_path3 = __toESM(require("path"));
+var FULL_ACCESS_SANDBOX = "workspace-write";
+var FULL_ACCESS_APPROVAL = "never";
+function applyElevatedRunDefaults(request, cwd) {
+  const workingDirectory = resolveWorkingDirectory(request.workingDirectory, cwd);
+  request.workingDirectory = workingDirectory;
+  ensureSandboxModes(request);
+  request.workspaceWriteOptions = ensureWorkspaceWriteOptions(
+    request.workspaceWriteOptions,
+    workingDirectory
+  );
+}
+function applyElevatedTuiDefaults(params) {
+  const { request, thread, cwd } = params;
+  const workingDirectory = resolveWorkingDirectory(
+    request.workingDirectory ?? thread.workingDirectory,
+    cwd
+  );
+  request.workingDirectory = workingDirectory;
+  thread.workingDirectory = workingDirectory;
+  ensureSandboxModes(request);
+  thread.sandboxMode = request.sandboxMode ?? thread.sandboxMode ?? FULL_ACCESS_SANDBOX;
+  thread.approvalMode = request.approvalMode ?? thread.approvalMode ?? FULL_ACCESS_APPROVAL;
+  thread.workspaceWriteOptions = ensureWorkspaceWriteOptions(
+    thread.workspaceWriteOptions,
+    workingDirectory
+  );
+}
+function ensureSandboxModes(target) {
+  if (!target.sandboxMode) {
+    target.sandboxMode = FULL_ACCESS_SANDBOX;
+  }
+  if (!target.approvalMode) {
+    target.approvalMode = FULL_ACCESS_APPROVAL;
+  }
+}
+function ensureWorkspaceWriteOptions(options, workingDirectory) {
+  const resolved = import_node_path3.default.resolve(workingDirectory);
+  const writableRoots = new Set(options?.writableRoots ?? []);
+  writableRoots.add(resolved);
+  return {
+    ...options,
+    networkAccess: options?.networkAccess ?? true,
+    writableRoots: Array.from(writableRoots)
+  };
+}
+function resolveWorkingDirectory(candidate, cwd) {
+  if (!candidate || candidate.trim().length === 0) {
+    return import_node_path3.default.resolve(cwd);
+  }
+  return import_node_path3.default.isAbsolute(candidate) ? candidate : import_node_path3.default.resolve(cwd, candidate);
+}
+
+// src/lsp/bridge.ts
+var path8 = __toESM(require("path"));
+
+// src/lsp/manager.ts
+var path6 = __toESM(require("path"));
+
+// src/lsp/servers.ts
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var MARKERS_NODE = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"];
+var MARKERS_PY = ["pyproject.toml", "requirements.txt", "Pipfile", "setup.py", "setup.cfg", "poetry.lock"];
+var MARKERS_RUST = ["Cargo.toml"];
+var DEFAULT_SERVERS = [
+  {
+    id: "typescript",
+    displayName: "TypeScript Language Server",
+    command: ["typescript-language-server", "--stdio"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    workspace: { type: "markers", include: MARKERS_NODE }
+  },
+  {
+    id: "pyright",
+    displayName: "Pyright",
+    command: ["pyright-langserver", "--stdio"],
+    extensions: [".py", ".pyi"],
+    workspace: { type: "markers", include: MARKERS_PY }
+  },
+  {
+    id: "rust-analyzer",
+    displayName: "rust-analyzer",
+    command: ["rust-analyzer"],
+    extensions: [".rs"],
+    workspace: { type: "markers", include: MARKERS_RUST }
+  }
+];
+function findServerForFile(filePath) {
+  const lower = filePath.toLowerCase();
+  return DEFAULT_SERVERS.find((server) => server.extensions.some((ext) => lower.endsWith(ext)));
+}
+function resolveWorkspaceRoot(filePath, locator, fallbackDir) {
+  if (!locator) {
+    return fallbackDir;
+  }
+  if (locator.type === "fixed") {
+    return locator.path;
+  }
+  const include = locator.include ?? [];
+  const exclude = locator.exclude ?? [];
+  let current = fs3.statSync(filePath, { throwIfNoEntry: false })?.isDirectory() ? filePath : path4.dirname(filePath);
+  const root = path4.parse(current).root;
+  while (true) {
+    if (exclude.some((pattern) => fs3.existsSync(path4.join(current, pattern)))) {
+      break;
+    }
+    if (include.some((pattern) => fs3.existsSync(path4.join(current, pattern)))) {
+      return current;
+    }
+    if (current === root) {
+      break;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return fallbackDir;
+}
+
+// src/lsp/client.ts
+var import_node_child_process = require("child_process");
+var fs4 = __toESM(require("fs/promises"));
+var path5 = __toESM(require("path"));
+var import_node_url3 = require("url");
+var import_node_events = require("events");
+var import_vscode_jsonrpc = require("vscode-jsonrpc");
+var import_main = require("vscode-jsonrpc/lib/node/main.js");
+var import_vscode_languageserver_types = require("vscode-languageserver-types");
+var DEFAULT_TIMEOUT_MS = 3e3;
+var LspClient = class _LspClient {
+  constructor(config, root) {
+    this.config = config;
+    this.root = root;
+  }
+  connection = null;
+  process = null;
+  diagnostics = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  emitter = new import_node_events.EventEmitter();
+  static async start(server, root) {
+    const client = new _LspClient(server, root);
+    await client.initialize();
+    return client;
+  }
+  async initialize() {
+    const [command, ...args] = this.config.command;
+    if (!command) {
+      throw new Error(`LSP server ${this.config.id} is missing a command executable`);
+    }
+    try {
+      this.process = (0, import_node_child_process.spawn)(command, args, {
+        cwd: this.root,
+        env: { ...process.env, ...this.config.env },
+        stdio: "pipe"
+      });
+    } catch (error) {
+      throw new Error(`Failed to spawn ${this.config.displayName} (${command}): ${String(error)}`);
+    }
+    const child = this.process;
+    child.stderr.on("data", (_chunk) => {
+    });
+    const reader = new import_main.StreamMessageReader(child.stdout);
+    const writer = new import_main.StreamMessageWriter(child.stdin);
+    this.connection = (0, import_vscode_jsonrpc.createMessageConnection)(reader, writer);
+    this.connection.onNotification("textDocument/publishDiagnostics", (payload) => {
+      const fsPath = (0, import_node_url3.fileURLToPath)(payload.uri);
+      this.diagnostics.set(fsPath, payload.diagnostics);
+      this.emitter.emit(`diagnostics:${fsPath}`);
+    });
+    this.connection.onError((err) => {
+      console.warn(`[lsp:${this.config.id}] connection error`, err);
+    });
+    this.connection.listen();
+    await this.connection.sendRequest("initialize", {
+      rootUri: (0, import_node_url3.pathToFileURL)(this.root).href,
+      processId: process.pid,
+      initializationOptions: this.config.initializationOptions ?? {},
+      capabilities: {
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true
+          },
+          publishDiagnostics: {
+            versionSupport: true
+          }
+        },
+        workspace: {
+          workspaceFolders: true
+        }
+      },
+      workspaceFolders: [
+        {
+          name: path5.basename(this.root),
+          uri: (0, import_node_url3.pathToFileURL)(this.root).href
+        }
+      ]
+    });
+    await this.connection.sendNotification("initialized", {});
+  }
+  async openFile(filePath, waitForDiagnostics) {
+    if (!this.connection) return;
+    const absolute = path5.resolve(filePath);
+    const text = await fs4.readFile(absolute, "utf8");
+    const uri = (0, import_node_url3.pathToFileURL)(absolute).href;
+    const languageId = detectLanguageId(absolute);
+    const existingVersion = this.versions.get(absolute);
+    if (existingVersion === void 0) {
+      this.versions.set(absolute, 0);
+      await this.connection.sendNotification("textDocument/didOpen", {
+        textDocument: {
+          uri,
+          languageId,
+          version: 0,
+          text
+        }
+      });
+    } else {
+      const next = existingVersion + 1;
+      this.versions.set(absolute, next);
+      await this.connection.sendNotification("textDocument/didChange", {
+        textDocument: {
+          uri,
+          version: next
+        },
+        contentChanges: [{ text }]
+      });
+    }
+    if (waitForDiagnostics) {
+      await this.waitForDiagnostics(absolute);
+    }
+  }
+  getDiagnostics(filePath) {
+    const absolute = path5.resolve(filePath);
+    return this.diagnostics.get(absolute) ?? [];
+  }
+  waitForDiagnostics(filePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const absolute = path5.resolve(filePath);
+    return new Promise((resolve5) => {
+      const timer = setTimeout(resolve5, timeoutMs).unref();
+      this.emitter.once(`diagnostics:${absolute}`, () => {
+        clearTimeout(timer);
+        resolve5();
+      });
+    });
+  }
+  async shutdown() {
+    try {
+      await this.connection?.dispose();
+    } catch {
+    }
+    if (this.process && !this.process.killed) {
+      this.process.kill();
+    }
+  }
+};
+function detectLanguageId(filePath) {
+  const ext = path5.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "typescript";
+    case ".tsx":
+      return "typescriptreact";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    case ".jsx":
+      return "javascriptreact";
+    case ".py":
+    case ".pyi":
+      return "python";
+    case ".rs":
+      return "rust";
+    default:
+      return "plaintext";
+  }
+}
+function normalizeSeverity(severity) {
+  switch (severity) {
+    case import_vscode_languageserver_types.DiagnosticSeverity.Error:
+      return "error";
+    case import_vscode_languageserver_types.DiagnosticSeverity.Warning:
+      return "warning";
+    case import_vscode_languageserver_types.DiagnosticSeverity.Information:
+      return "info";
+    case import_vscode_languageserver_types.DiagnosticSeverity.Hint:
+      return "hint";
+    default:
+      return "error";
+  }
+}
+
+// src/lsp/manager.ts
+var LspManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  clients = /* @__PURE__ */ new Map();
+  async collectDiagnostics(files) {
+    const unique = Array.from(new Set(files.map((file) => path6.resolve(file))));
+    const results = [];
+    for (const filePath of unique) {
+      const server = findServerForFile(filePath);
+      if (!server) {
+        continue;
+      }
+      const root = resolveWorkspaceRoot(filePath, server.workspace, this.options.workingDirectory);
+      const client = await this.getClient(server, root);
+      if (!client) {
+        continue;
+      }
+      try {
+        await client.openFile(filePath, this.options.waitForDiagnostics !== false);
+      } catch (error) {
+        console.warn(`[lsp] failed to open ${filePath}:`, error);
+        continue;
+      }
+      const normalized = client.getDiagnostics(filePath).map((diag) => normalizeDiagnostic(diag)).filter((diag) => diag.message.trim().length > 0);
+      if (normalized.length > 0) {
+        results.push({ path: filePath, diagnostics: normalized });
+      }
+    }
+    return results;
+  }
+  async dispose() {
+    await Promise.all(
+      Array.from(this.clients.values()).map(async (promise) => {
+        const client = await promise;
+        await client?.shutdown();
+      })
+    );
+    this.clients.clear();
+  }
+  async getClient(server, root) {
+    const key = `${server.id}:${root}`;
+    let existing = this.clients.get(key);
+    if (!existing) {
+      existing = this.createClient(server, root);
+      this.clients.set(key, existing);
+    }
+    const client = await existing;
+    if (!client) {
+      this.clients.delete(key);
+    }
+    return client;
+  }
+  async createClient(server, root) {
+    try {
+      return await LspClient.start(server, root);
+    } catch (error) {
+      console.warn(`[lsp] unable to start ${server.displayName}:`, error);
+      return null;
+    }
+  }
+};
+function normalizeDiagnostic(diag) {
+  return {
+    message: diag.message ?? "",
+    severity: normalizeSeverity(diag.severity),
+    source: diag.source,
+    code: diag.code,
+    range: diag.range
+  };
+}
+
+// src/lsp/format.ts
+var path7 = __toESM(require("path"));
+var MAX_DIAGNOSTICS_PER_FILE = 5;
+function formatDiagnosticsForTool(diagnostics) {
+  return diagnostics.map(({ path: filePath, diagnostics: entries }) => {
+    const rel = filePath;
+    const lines = entries.slice(0, MAX_DIAGNOSTICS_PER_FILE).map((diag) => {
+      const { line, character } = diag.range.start;
+      const location = `${line + 1}:${character + 1}`;
+      const source = diag.source ? ` \xB7 ${diag.source}` : "";
+      return `  - [${diag.severity.toUpperCase()}] ${diag.message} (${location}${source})`;
+    });
+    const trimmed = entries.length > MAX_DIAGNOSTICS_PER_FILE ? "  - \u2026" : "";
+    return [`\u2022 ${rel}`, ...lines, trimmed].filter(Boolean).join("\n");
+  }).join("\n");
+}
+function formatDiagnosticsForBackgroundEvent(diagnostics, cwd) {
+  return diagnostics.map(({ path: filePath, diagnostics: entries }) => {
+    const rel = path7.relative(cwd, filePath) || filePath;
+    const lines = entries.slice(0, MAX_DIAGNOSTICS_PER_FILE).map((diag) => {
+      const { line, character } = diag.range.start;
+      const location = `${line + 1}:${character + 1}`;
+      const source = diag.source ? ` \xB7 ${diag.source}` : "";
+      return `  - [${diag.severity.toUpperCase()}] ${diag.message} (${location}${source})`;
+    });
+    const trimmed = entries.length > MAX_DIAGNOSTICS_PER_FILE ? "  - \u2026" : "";
+    return [`\u2022 ${rel}`, ...lines, trimmed].filter(Boolean).join("\n");
+  }).join("\n");
+}
+
+// src/lsp/bridge.ts
+var LspDiagnosticsBridge = class {
+  constructor(options) {
+    this.options = options;
+    this.manager = new LspManager(options);
+  }
+  manager;
+  attached = /* @__PURE__ */ new WeakSet();
+  attach(thread) {
+    if (this.attached.has(thread)) {
+      return () => {
+      };
+    }
+    this.attached.add(thread);
+    const unsubscribe = thread.onEvent((event) => {
+      if (event.type !== "item.completed") {
+        return;
+      }
+      if (event.item.type === "file_change") {
+        const targets = event.item.changes.filter((change) => change.kind !== "delete").map((change) => path8.resolve(this.options.workingDirectory, change.path));
+        if (targets.length === 0) {
+          return;
+        }
+        void this.processDiagnostics(thread, targets);
+        return;
+      }
+      if (event.item.type === "mcp_tool_call") {
+        const targets = extractReadFileTargets(event.item, this.options.workingDirectory);
+        if (targets.length === 0) {
+          return;
+        }
+        void this.processDiagnostics(thread, targets);
+      }
+    });
+    return () => {
+      this.attached.delete(thread);
+      unsubscribe();
+    };
+  }
+  async dispose() {
+    await this.manager.dispose();
+  }
+  async processDiagnostics(thread, files) {
+    try {
+      const diagnostics = await this.manager.collectDiagnostics(files);
+      if (diagnostics.length === 0) {
+        return;
+      }
+      const summary = formatDiagnosticsForBackgroundEvent(
+        diagnostics,
+        this.options.workingDirectory
+      );
+      console.log(`
+\u{1F4DF} LSP diagnostics detected:
+${summary}
+`);
+      try {
+        await thread.sendBackgroundEvent(`LSP diagnostics detected:
+${summary}`);
+      } catch {
+      }
+    } catch (error) {
+      console.warn("[lsp] failed to collect diagnostics", error);
+    }
+  }
+};
+function extractReadFileTargets(item, cwd) {
+  if (item.type !== "mcp_tool_call") {
+    return [];
+  }
+  const toolName = item.tool?.toLowerCase?.();
+  if (toolName !== "read_file" && toolName !== "read_file_v2") {
+    return [];
+  }
+  let args = item.arguments;
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return [];
+    }
+  }
+  if (!args || typeof args !== "object") {
+    return [];
+  }
+  const filePath = args.file_path ?? args.path;
+  if (typeof filePath !== "string" || filePath.trim().length === 0) {
+    return [];
+  }
+  const resolved = path8.isAbsolute(filePath) ? filePath : path8.resolve(cwd, filePath);
+  return [resolved];
+}
+
+// src/lsp/hooks.ts
+function attachLspDiagnostics(thread, options) {
+  const bridge = new LspDiagnosticsBridge(options);
+  const detach = bridge.attach(thread);
+  return () => {
+    detach();
+    void bridge.dispose().catch((error) => {
+      console.warn("Failed to dispose LSP bridge", error);
+    });
+  };
+}
+
+// src/cli/lspBridge.ts
+var RunCommandThreadRelay = class {
+  constructor(binding, initialThreadId) {
+    this.binding = binding;
+    this.threadId = initialThreadId ?? null;
+  }
+  listeners = /* @__PURE__ */ new Set();
+  threadId;
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async sendBackgroundEvent(message) {
+    const trimmed = typeof message === "string" ? message.trim() : "";
+    if (!trimmed) {
+      throw new Error("Background event message must be a non-empty string");
+    }
+    if (!this.threadId) {
+      throw new Error("Cannot emit a background event before the thread has started");
+    }
+    if (typeof this.binding.emitBackgroundEvent !== "function") {
+      throw new Error("emitBackgroundEvent is not available in this build");
+    }
+    await this.binding.emitBackgroundEvent({ threadId: this.threadId, message: trimmed });
+  }
+  handleEvent(event) {
+    if (event.type === "thread.started" && typeof event.thread_id === "string") {
+      this.threadId = event.thread_id;
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.warn("[codex-native] LSP listener failed", error);
+      }
+    }
+  }
+  setThreadId(id) {
+    if (id) {
+      this.threadId = id;
+    }
+  }
+};
+function createRunCommandLspBridge(params) {
+  try {
+    const relay = new RunCommandThreadRelay(params.binding, params.initialThreadId);
+    const detach = attachLspDiagnostics(relay, {
+      workingDirectory: params.workingDirectory,
+      waitForDiagnostics: true
+    });
+    relay.setThreadId(params.initialThreadId);
+    return {
+      handleEvent: (event) => relay.handleEvent(event),
+      dispose: () => detach()
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[codex-native] Failed to initialize LSP diagnostics bridge: ${message}`);
+    return null;
+  }
+}
+
+// src/cli/run.ts
+async function executeRunCommand(argv, context) {
+  const { combinedConfig } = context;
+  emitWarnings(combinedConfig.warnings);
+  const warningCount = combinedConfig.warnings.length;
+  const prompt = await resolvePrompt(argv, combinedConfig.runDefaults.prompt, context.cwd);
+  const request = await buildRunRequest({
+    prompt,
+    argv,
+    combinedDefaults: combinedConfig.runDefaults,
+    cwd: context.cwd
+  });
+  if (!request.skipGitRepoCheck) {
+    await assertTrustedDirectory(request.workingDirectory);
+  }
+  validateModel(request.model, request.oss === true);
+  const hookContext = {
+    command: "run",
+    cwd: context.cwd,
+    options: argv
+  };
+  await runBeforeStartHooks(combinedConfig.beforeStartHooks, hookContext, combinedConfig.warnings);
+  const binding = getNativeBinding();
+  if (!binding) {
+    throw new Error("Native N-API binding is not available.");
+  }
+  const queue = new AsyncQueue();
+  let conversationId = null;
+  const lspBridge = createRunCommandLspBridge({
+    binding,
+    workingDirectory: request.workingDirectory ?? context.cwd,
+    initialThreadId: request.threadId
+  });
+  const handleEvent = async (eventJson) => {
+    if (!eventJson) {
+      return;
+    }
+    import_node_process.default.stdout.write(eventJson);
+    import_node_process.default.stdout.write("\n");
+    let eventPayload = eventJson;
+    try {
+      eventPayload = JSON.parse(eventJson);
+    } catch {
+    }
+    conversationId ??= extractConversationId(eventPayload);
+    const threadEvent = toThreadEvent(eventPayload);
+    if (threadEvent && lspBridge) {
+      lspBridge.handleEvent(threadEvent);
+    }
+    await runEventHooks(
+      combinedConfig.onEventHooks,
+      eventPayload,
+      hookContext,
+      combinedConfig.warnings
+    );
+  };
+  let runPromise = Promise.resolve();
+  runPromise = binding.runThreadStream(request, (err, eventJson) => {
+    if (err) {
+      queue.fail(err);
+      return;
+    }
+    queue.push(eventJson ?? null);
+  }).then(
+    () => queue.end(),
+    (error) => {
+      queue.fail(error);
+    }
+  );
+  let loopError;
+  try {
+    for await (const eventJson of queue) {
+      try {
+        await handleEvent(eventJson);
+      } catch (error) {
+        combinedConfig.warnings.push(
+          `Event handler failed: ${error.message ?? String(error)}`
+        );
+      }
+    }
+    await runPromise;
+  } catch (error) {
+    loopError = error;
+    throw error;
+  } finally {
+    queue.end();
+    if (loopError) {
+      await runPromise.catch(() => {
+      });
+    }
+    if (lspBridge) {
+      lspBridge.dispose();
+    }
+  }
+  if (conversationId) {
+    import_node_process.default.stdout.write(`
+To resume, run: codex-native tui --resume ${conversationId}
+`);
+  }
+  emitWarnings(combinedConfig.warnings, warningCount);
+}
+function toThreadEvent(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  try {
+    return convertRustEventToThreadEvent(payload);
+  } catch {
+    return null;
+  }
+}
+async function resolvePrompt(argv, defaultPrompt, cwd) {
+  if (argv.prompt && argv.prompt.trim().length > 0) {
+    return argv.prompt;
+  }
+  if (defaultPrompt && defaultPrompt.trim().length > 0) {
+    return defaultPrompt;
+  }
+  const stdinPrompt = await readPromptFromStdin();
+  if (stdinPrompt && stdinPrompt.trim().length > 0) {
+    return stdinPrompt;
+  }
+  if (argv.threadId) {
+    return "";
+  }
+  const baseMessage = "No prompt provided. Supply a prompt or pipe one via stdin.";
+  if (import_node_process.default.stdin.isTTY) {
+    throw new Error(baseMessage);
+  }
+  throw new Error(baseMessage);
+}
+async function buildRunRequest(params) {
+  const { prompt, argv, combinedDefaults, cwd } = params;
+  const request = {
+    ...combinedDefaults,
+    prompt
+  };
+  if (combinedDefaults.images) {
+    request.images = [...combinedDefaults.images];
+  }
+  if (combinedDefaults.workspaceWriteOptions) {
+    request.workspaceWriteOptions = { ...combinedDefaults.workspaceWriteOptions };
+  }
+  if (argv.model !== void 0) request.model = argv.model;
+  if (argv.oss !== void 0) request.oss = argv.oss;
+  const sandboxMode = parseSandboxModeFlag(argv.sandbox, "--sandbox");
+  if (sandboxMode !== void 0) {
+    request.sandboxMode = sandboxMode;
+  }
+  const approvalMode = parseApprovalModeFlag(argv.approval, "--approval");
+  if (approvalMode !== void 0) {
+    request.approvalMode = approvalMode;
+  }
+  if (argv.threadId !== void 0) request.threadId = argv.threadId;
+  if (argv.baseUrl !== void 0) request.baseUrl = argv.baseUrl;
+  if (argv.apiKey !== void 0) request.apiKey = argv.apiKey;
+  if (argv.linuxSandboxPath !== void 0) request.linuxSandboxPath = argv.linuxSandboxPath;
+  if (argv.fullAuto !== void 0) request.fullAuto = argv.fullAuto;
+  if (argv.skipGitRepoCheck !== void 0) request.skipGitRepoCheck = argv.skipGitRepoCheck;
+  if (argv.cd !== void 0) request.workingDirectory = argv.cd;
+  if (argv.reviewMode !== void 0) request.reviewMode = argv.reviewMode;
+  if (argv.reviewHint !== void 0) request.reviewHint = argv.reviewHint;
+  const images = [
+    ...Array.isArray(request.images) ? request.images : [],
+    ...argv.image ?? []
+  ];
+  request.images = images.length > 0 ? images : void 0;
+  if (argv.schema) {
+    request.outputSchema = await readJsonFile(argv.schema);
+  }
+  applyElevatedRunDefaults(request, cwd);
+  return request;
+}
+async function readJsonFile(filePath) {
+  const absolute = import_node_path4.default.resolve(import_node_process.default.cwd(), filePath);
+  const data = await import_promises2.default.readFile(absolute, "utf8");
+  try {
+    return JSON.parse(data);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON schema from ${absolute}: ${error.message ?? error}`
+    );
+  }
+}
+async function readPromptFromStdin() {
+  if (import_node_process.default.stdin.isTTY) {
+    return null;
+  }
+  const chunks = [];
+  for await (const chunk of import_node_process.default.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  return Buffer.concat(chunks).toString("utf8").trimEnd();
+}
+function extractConversationId(eventPayload) {
+  if (!eventPayload || typeof eventPayload !== "object") {
+    return null;
+  }
+  const record = eventPayload;
+  if (typeof record.session_id === "string") {
+    return record.session_id;
+  }
+  const sessionConfigured = record.SessionConfigured ?? record.sessionConfigured;
+  if (sessionConfigured && typeof sessionConfigured === "object") {
+    const configuredSessionId = sessionConfigured.session_id;
+    if (typeof configuredSessionId === "string") {
+      return configuredSessionId;
+    }
+  }
+  const nestedSession = typeof record.session === "object" && record.session ? record.session.id : void 0;
+  if (typeof nestedSession === "string") {
+    return nestedSession;
+  }
+  return null;
+}
+function validateModel(model, oss) {
+  if (!model) return;
+  const trimmed = String(model).trim();
+  if (oss) {
+    if (!trimmed.startsWith("gpt-oss:")) {
+      throw new Error(
+        `Invalid model "${trimmed}" for OSS mode. Use models prefixed with "gpt-oss:", e.g. "gpt-oss:20b".`
+      );
+    }
+    return;
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    // GPT models
+    "gpt-5",
+    "gpt-5-codex",
+    "gpt-5-codex-mini",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-mini",
+    // Claude models
+    "claude-sonnet-4-5-20250929",
+    "claude-sonnet-4-20250514",
+    "claude-opus-4-20250514"
+  ]);
+  if (!allowed.has(trimmed) && !trimmed.startsWith("claude-") && !trimmed.startsWith("gpt-")) {
+    throw new Error(
+      `Invalid model "${trimmed}". Supported models: ${Array.from(allowed).map((m) => `"${m}"`).join(", ")}, or any model starting with "claude-" or "gpt-".`
+    );
+  }
+}
+async function assertTrustedDirectory(workingDirectory) {
+  const directory = workingDirectory ? import_node_path4.default.resolve(workingDirectory) : import_node_process.default.cwd();
+  if (await findGitRoot(directory)) {
+    return;
+  }
+  throw new Error(
+    "Not inside a trusted directory and --skip-git-repo-check was not specified."
+  );
+}
+async function findGitRoot(startDir) {
+  let current = import_node_path4.default.resolve(startDir);
+  while (true) {
+    const gitPath = import_node_path4.default.join(current, ".git");
+    if (import_node_fs3.default.existsSync(gitPath)) {
+      try {
+        const stats = await import_promises2.default.stat(gitPath);
+        if (stats.isDirectory() || stats.isFile()) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = import_node_path4.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var AsyncQueue = class {
+  buffer = [];
+  waiters = [];
+  ended = false;
+  error;
+  push(value) {
+    if (this.ended) return;
+    if (value === null) {
+      return;
+    }
+    if (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter.resolve({ value, done: false });
+      return;
+    }
+    this.buffer.push(value);
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(error) {
+    if (this.ended) return;
+    this.error = error;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.reject(error);
+    }
+  }
+  async next() {
+    if (this.buffer.length > 0) {
+      const value = this.buffer.shift();
+      return { value, done: false };
+    }
+    if (this.error) {
+      return Promise.reject(this.error);
+    }
+    if (this.ended) {
+      return { value: void 0, done: true };
+    }
+    return new Promise((resolve5, reject) => {
+      this.waiters.push({ resolve: resolve5, reject });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+
+// src/cli/tui.ts
+var import_node_process2 = __toESM(require("process"));
+
+// src/exec.ts
+var CodexExec = class {
+  native;
+  constructor() {
+    const nativeBinding = getNativeBinding();
+    if (!nativeBinding) {
+      throw new Error(
+        "Native NAPI binding not available. Make sure @openai/codex-native is properly installed and built."
+      );
+    }
+    this.native = nativeBinding;
+  }
+  requiresOutputSchemaFile() {
+    return false;
+  }
+  async *run(args) {
+    const binding = this.native;
+    const queue = new AsyncQueue2();
+    validateModel2(args.model, args.oss === true);
+    const request = {
+      prompt: args.input,
+      threadId: args.threadId ?? void 0,
+      images: args.images && args.images.length > 0 ? args.images : void 0,
+      model: args.model,
+      oss: args.oss,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      sandboxMode: args.sandboxMode,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      outputSchema: args.outputSchema,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      modelProvider: args.modelProvider,
+      fullAuto: args.fullAuto,
+      reviewMode: args.review ? true : void 0,
+      reviewHint: args.review?.userFacingHint
+    };
+    let runPromise = Promise.resolve();
+    try {
+      runPromise = binding.runThreadStream(request, (err, eventJson) => {
+        if (err) {
+          queue.fail(err);
+          return;
+        }
+        try {
+          queue.push(eventJson ?? "null");
+        } catch (error) {
+          queue.fail(error);
+        }
+      }).then(
+        () => {
+          queue.end();
+        },
+        (error) => {
+          queue.fail(error);
+        }
+      );
+    } catch (error) {
+      queue.fail(error);
+      throw error;
+    }
+    let loopError;
+    try {
+      for await (const value of queue) {
+        yield value;
+      }
+      await runPromise;
+    } catch (error) {
+      loopError = error;
+      throw error;
+    } finally {
+      queue.end();
+      if (loopError) {
+        await runPromise.catch(() => {
+        });
+      }
+    }
+  }
+  async compact(args) {
+    validateModel2(args.model, args.oss === true);
+    const request = {
+      prompt: args.input,
+      threadId: args.threadId ?? void 0,
+      images: args.images && args.images.length > 0 ? args.images : void 0,
+      model: args.model,
+      modelProvider: args.modelProvider,
+      oss: args.oss,
+      sandboxMode: args.sandboxMode,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      outputSchema: args.outputSchema,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      fullAuto: args.fullAuto,
+      reviewMode: args.review ? true : void 0,
+      reviewHint: args.review?.userFacingHint
+    };
+    return this.native.compactThread(request);
+  }
+  async fork(args) {
+    if (!args.threadId) {
+      throw new Error("threadId is required to fork a conversation");
+    }
+    const request = {
+      threadId: args.threadId,
+      nthUserMessage: args.nthUserMessage,
+      model: args.model,
+      oss: args.oss,
+      sandboxMode: args.sandboxMode,
+      approvalMode: args.approvalMode,
+      workspaceWriteOptions: args.workspaceWriteOptions,
+      workingDirectory: args.workingDirectory,
+      skipGitRepoCheck: args.skipGitRepoCheck,
+      baseUrl: args.baseUrl,
+      apiKey: args.apiKey,
+      modelProvider: args.modelProvider,
+      linuxSandboxPath: args.linuxSandboxPath,
+      fullAuto: args.fullAuto
+    };
+    return this.native.forkThread(request);
+  }
+  async listConversations(request) {
+    return this.native.listConversations(request);
+  }
+  async deleteConversation(request) {
+    return this.native.deleteConversation(request);
+  }
+  async resumeConversationFromRollout(request) {
+    return this.native.resumeConversationFromRollout(request);
+  }
+};
+var AsyncQueue2 = class {
+  buffer = [];
+  waiters = [];
+  ended = false;
+  error;
+  push(value) {
+    if (this.ended) return;
+    if (this.waiters.length > 0) {
+      const waiter = this.waiters.shift();
+      waiter.resolve({ value, done: false });
+      return;
+    }
+    this.buffer.push(value);
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  fail(error) {
+    if (this.ended) return;
+    this.error = error;
+    this.ended = true;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters) {
+      waiter.reject(error);
+    }
+  }
+  async next() {
+    if (this.buffer.length > 0) {
+      const value = this.buffer.shift();
+      return { value, done: false };
+    }
+    if (this.error) {
+      return Promise.reject(this.error);
+    }
+    if (this.ended) {
+      return { value: void 0, done: true };
+    }
+    return new Promise((resolve5, reject) => {
+      this.waiters.push({ resolve: resolve5, reject });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+function validateModel2(model, oss) {
+  if (!model) return;
+  const trimmed = String(model).trim();
+  if (oss) {
+    if (!trimmed.startsWith("gpt-oss:")) {
+      throw new Error(
+        `Invalid model "${trimmed}" for OSS mode. Use models prefixed with "gpt-oss:", e.g. "gpt-oss:20b".`
+      );
+    }
+    return;
+  }
+  const allowed = /* @__PURE__ */ new Set([
+    // GPT models
+    "gpt-5",
+    "gpt-5-codex",
+    "gpt-5-codex-mini",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-mini",
+    // Claude models
+    "claude-sonnet-4-5-20250929",
+    "claude-sonnet-4-20250514",
+    "claude-opus-4-20250514"
+  ]);
+  if (!allowed.has(trimmed) && !trimmed.startsWith("claude-") && !trimmed.startsWith("gpt-")) {
+    throw new Error(
+      `Invalid model "${trimmed}". Supported models: ${Array.from(allowed).map((m) => `"${m}"`).join(", ")}, or any model starting with "claude-" or "gpt-".`
+    );
+  }
+}
+
+// src/thread.ts
+var fs7 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+
+// src/outputSchemaFile.ts
+var import_node_fs4 = require("fs");
+var import_node_os = __toESM(require("os"));
+var import_node_path5 = __toESM(require("path"));
+function normalizeOutputSchema(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  if (isJsonObject(schema) && (schema.type === "json_schema" || schema.type === "json-schema") && isJsonObject(schema.json_schema) && isJsonObject(schema.json_schema.schema)) {
+    const strict = typeof schema.json_schema.strict === "boolean" ? schema.json_schema.strict : true;
+    return normalizeJsonSchemaObject(schema.json_schema.schema, strict);
+  }
+  if (isJsonObject(schema) && isJsonObject(schema.schema)) {
+    const strict = typeof schema.strict === "boolean" ? schema.strict : true;
+    return normalizeJsonSchemaObject(schema.schema, strict);
+  }
+  if (!isJsonObject(schema)) {
+    throw new Error(
+      "outputSchema must be a plain JSON object or an OpenAI-style json_schema wrapper"
+    );
+  }
+  return normalizeJsonSchemaObject(schema, true);
+}
+async function createOutputSchemaFile(schema) {
+  const normalizedSchema = normalizeOutputSchema(schema);
+  if (!normalizedSchema) {
+    return { cleanup: async () => {
+    } };
+  }
+  const schemaDir = await import_node_fs4.promises.mkdtemp(import_node_path5.default.join(import_node_os.default.tmpdir(), "codex-output-schema-"));
+  const schemaPath = import_node_path5.default.join(schemaDir, "schema.json");
+  const cleanup = async () => {
+    try {
+      await import_node_fs4.promises.rm(schemaDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    await import_node_fs4.promises.writeFile(schemaPath, JSON.stringify(normalizedSchema), "utf8");
+    return { schemaPath, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeJsonSchemaObject(schema, strict) {
+  const record = { ...schema };
+  const hasExplicitAdditional = typeof record.additionalProperties === "boolean" || typeof record.additionalProperties === "object";
+  const additionalProperties = hasExplicitAdditional ? record.additionalProperties : strict ? false : record.additionalProperties;
+  return {
+    ...record,
+    ...hasExplicitAdditional || strict ? { additionalProperties } : {}
+  };
+}
+
+// src/tui.ts
+function startTui(request) {
+  const binding = getNativeBinding();
+  if (!binding) {
+    throw new Error("Native binding is not available");
+  }
+  if (typeof binding.startTui === "function") {
+    const nativeSession = binding.startTui(request);
+    return wrapNativeSession(nativeSession);
+  }
+  if (typeof binding.runTui === "function") {
+    return createLegacySession(binding, request);
+  }
+  throw new Error("Native binding does not expose startTui or runTui");
+}
+async function runTui(request, options = {}) {
+  const session = startTui(request);
+  const { signal } = options;
+  let abortListener;
+  try {
+    if (signal) {
+      if (signal.aborted) {
+        session.shutdown();
+      } else {
+        abortListener = () => session.shutdown();
+        signal.addEventListener("abort", abortListener, { once: true });
+      }
+    }
+    return await session.wait();
+  } finally {
+    if (abortListener && signal) {
+      signal.removeEventListener("abort", abortListener);
+    }
+  }
+}
+function wrapNativeSession(nativeSession) {
+  return {
+    wait: () => nativeSession.wait(),
+    shutdown: () => nativeSession.shutdown(),
+    get closed() {
+      return nativeSession.closed;
+    }
+  };
+}
+function createLegacySession(binding, request) {
+  if (typeof binding.runTui !== "function") {
+    throw new Error("Native binding does not expose runTui");
+  }
+  let closed = false;
+  const promise = binding.runTui(request).then(
+    (result) => {
+      closed = true;
+      return result;
+    },
+    (error) => {
+      closed = true;
+      throw error;
+    }
+  );
+  return {
+    wait: () => promise,
+    shutdown() {
+      throw new Error(
+        "Programmatic shutdown is not supported by this native binding build. Rebuild the SDK to enable startTui()."
+      );
+    },
+    get closed() {
+      return closed;
+    }
+  };
+}
+
+// src/thread.ts
+var UNTRUSTED_DIRECTORY_ERROR = "Not inside a trusted directory and --skip-git-repo-check was not specified.";
+function findGitRoot2(startDir) {
+  let current = path11.resolve(startDir);
+  while (true) {
+    const gitPath = path11.join(current, ".git");
+    if (fs7.existsSync(gitPath)) {
+      try {
+        const stats = fs7.statSync(gitPath);
+        if (stats.isDirectory() || stats.isFile()) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path11.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+function assertTrustedDirectory2(workingDirectory) {
+  const directory = workingDirectory ? path11.resolve(workingDirectory) : process.cwd();
+  if (!findGitRoot2(directory)) {
+    throw new Error(UNTRUSTED_DIRECTORY_ERROR);
+  }
+}
+var Thread = class _Thread {
+  _exec;
+  _options;
+  _id;
+  _threadOptions;
+  _eventListeners = [];
+  _approvalHandler = null;
+  /** Returns the ID of the thread. Populated after the first turn starts. */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Register an event listener for thread events.
+   * @param listener Callback function that receives ThreadEvent objects
+   * @returns Unsubscribe function to remove the listener
+   */
+  onEvent(listener) {
+    this._eventListeners.push(listener);
+    return () => {
+      const index = this._eventListeners.indexOf(listener);
+      if (index !== -1) {
+        this._eventListeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Remove an event listener.
+   * @param listener The listener function to remove
+   */
+  offEvent(listener) {
+    const index = this._eventListeners.indexOf(listener);
+    if (index !== -1) {
+      this._eventListeners.splice(index, 1);
+    }
+  }
+  /**
+   * Register a callback to handle approval requests from the agent.
+   * The handler should return true to approve the action, false to deny it.
+   *
+   * @param handler Callback function that receives ApprovalRequest and returns approval decision
+   * @example
+   * ```typescript
+   * thread.onApprovalRequest(async (request) => {
+   *   console.log(`Approval requested for ${request.type}`);
+   *   return true; // Auto-approve
+   * });
+   * ```
+   */
+  onApprovalRequest(handler) {
+    this._approvalHandler = handler;
+    const binding = getNativeBinding();
+    if (binding && typeof binding.registerApprovalCallback === "function") {
+      binding.registerApprovalCallback(handler);
+    }
+  }
+  /**
+   * Emit a background notification while the agent is running the current turn.
+   * The message is surfaced to event subscribers but does not modify the user input queue.
+   *
+   * @throws Error if the thread has not been started yet.
+   */
+  async sendBackgroundEvent(message) {
+    const trimmed = message?.toString();
+    if (!trimmed || trimmed.trim().length === 0) {
+      throw new Error("Background event message must be a non-empty string");
+    }
+    if (!this._id) {
+      throw new Error("Cannot emit a background event before the thread has started");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.emitBackgroundEvent !== "function") {
+      throw new Error("emitBackgroundEvent is not available in this build");
+    }
+    await binding.emitBackgroundEvent({ threadId: this._id, message: trimmed });
+  }
+  /**
+   * Programmatically update the agent's plan/todo list.
+   * The plan will be applied at the start of the next turn.
+   *
+   * @param args The plan update arguments
+   * @throws Error if no thread ID is available
+   */
+  updatePlan(args) {
+    if (!this._id) {
+      throw new Error("Cannot update plan: no active thread");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.emitPlanUpdate !== "function") {
+      throw new Error("emitPlanUpdate is not available in this build");
+    }
+    binding.emitPlanUpdate({
+      threadId: this._id,
+      explanation: args.explanation,
+      plan: args.plan
+    });
+  }
+  /**
+   * Modify the agent's plan/todo list with granular operations.
+   * Changes will be applied at the start of the next turn.
+   *
+   * @param operations Array of operations to perform on the plan
+   * @throws Error if no thread ID is available
+   */
+  modifyPlan(operations) {
+    if (!this._id) {
+      throw new Error("Cannot modify plan: no active thread");
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.modifyPlan !== "function") {
+      throw new Error("modifyPlan is not available in this build");
+    }
+    binding.modifyPlan({
+      threadId: this._id,
+      operations
+    });
+  }
+  /**
+   * Add a new todo item to the agent's plan.
+   *
+   * @param step The todo step description
+   * @param status The initial status (defaults to "pending")
+   */
+  addTodo(step, status = "pending") {
+    this.modifyPlan([{ type: "add", item: { step, status } }]);
+  }
+  /**
+   * Update an existing todo item.
+   *
+   * @param index The index of the todo item to update
+   * @param updates The updates to apply
+   */
+  updateTodo(index, updates) {
+    this.modifyPlan([{ type: "update", index, updates }]);
+  }
+  /**
+   * Remove a todo item from the plan.
+   *
+   * @param index The index of the todo item to remove
+   */
+  removeTodo(index) {
+    this.modifyPlan([{ type: "remove", index }]);
+  }
+  /**
+   * Reorder the todo items in the plan.
+   *
+   * @param newOrder Array of indices representing the new order
+   */
+  reorderTodos(newOrder) {
+    this.modifyPlan([{ type: "reorder", newOrder }]);
+  }
+  /** Compacts the conversation history for this thread using Codex's builtin compaction. */
+  async compact() {
+    const skipGitRepoCheck = this._threadOptions?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory2(this._threadOptions?.workingDirectory);
+    }
+    const events = await this._exec.compact({
+      input: "compact",
+      threadId: this._id,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      model: this._threadOptions?.model ?? this._options.defaultModel,
+      sandboxMode: this._threadOptions?.sandboxMode,
+      approvalMode: this._threadOptions?.approvalMode,
+      workspaceWriteOptions: this._threadOptions?.workspaceWriteOptions,
+      workingDirectory: this._threadOptions?.workingDirectory,
+      skipGitRepoCheck,
+      modelProvider: this._options.modelProvider
+    });
+    if (!Array.isArray(events)) {
+      throw new Error("Compact did not return event list");
+    }
+  }
+  /**
+   * Fork this thread at the specified user message, returning a new thread that starts
+   * from the conversation history prior to that message.
+   *
+   * @param options Fork configuration including which user message to branch before and optional thread overrides.
+   */
+  async fork(options) {
+    if (!this._id) {
+      throw new Error("Cannot fork: no active thread");
+    }
+    const nthUserMessage = options?.nthUserMessage;
+    if (typeof nthUserMessage !== "number" || !Number.isInteger(nthUserMessage) || nthUserMessage < 0) {
+      throw new Error("nthUserMessage must be a non-negative integer");
+    }
+    const overrides = options.threadOptions ?? {};
+    const nextThreadOptions = {
+      ...this._threadOptions,
+      ...overrides
+    };
+    const skipGitRepoCheck = nextThreadOptions.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    nextThreadOptions.skipGitRepoCheck = skipGitRepoCheck;
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory2(nextThreadOptions.workingDirectory);
+    }
+    const forkArgs = {
+      threadId: this._id,
+      nthUserMessage,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      model: nextThreadOptions.model ?? this._options.defaultModel,
+      oss: nextThreadOptions.oss,
+      sandboxMode: nextThreadOptions.sandboxMode,
+      approvalMode: nextThreadOptions.approvalMode,
+      workspaceWriteOptions: nextThreadOptions.workspaceWriteOptions,
+      workingDirectory: nextThreadOptions.workingDirectory,
+      skipGitRepoCheck,
+      fullAuto: nextThreadOptions.fullAuto,
+      modelProvider: this._options.modelProvider
+    };
+    const result = await this._exec.fork(forkArgs);
+    return new _Thread(
+      this._exec,
+      this._options,
+      nextThreadOptions,
+      result.threadId
+    );
+  }
+  /* @internal */
+  constructor(exec, options, threadOptions, id = null) {
+    this._exec = exec;
+    this._options = options;
+    this._id = id;
+    this._threadOptions = threadOptions;
+  }
+  /** Provides the input to the agent and streams events as they are produced during the turn. */
+  async runStreamed(input, turnOptions = {}) {
+    return { events: this.runStreamedInternal(input, turnOptions, false) };
+  }
+  async *runStreamedInternal(input, turnOptions = {}, emitRawEvents = true) {
+    const normalizedSchema = normalizeOutputSchema(turnOptions.outputSchema);
+    const needsSchemaFile = this._exec.requiresOutputSchemaFile();
+    const schemaFile = needsSchemaFile ? await createOutputSchemaFile(normalizedSchema) : { schemaPath: void 0, cleanup: async () => {
+    } };
+    const options = this._threadOptions;
+    const { prompt, images } = normalizeInput(input);
+    const skipGitRepoCheck = options?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory2(options?.workingDirectory);
+    }
+    const generator = this._exec.run({
+      input: prompt,
+      baseUrl: this._options.baseUrl,
+      apiKey: this._options.apiKey,
+      threadId: this._id,
+      images,
+      model: options?.model,
+      oss: turnOptions?.oss ?? options?.oss,
+      sandboxMode: options?.sandboxMode,
+      approvalMode: options?.approvalMode,
+      workspaceWriteOptions: options?.workspaceWriteOptions,
+      workingDirectory: options?.workingDirectory,
+      skipGitRepoCheck,
+      outputSchemaFile: schemaFile.schemaPath,
+      outputSchema: normalizedSchema,
+      fullAuto: options?.fullAuto
+    });
+    try {
+      for await (const item of generator) {
+        let parsed;
+        try {
+          parsed = JSON.parse(item);
+        } catch (error) {
+          throw new Error(`Failed to parse item: ${item}. Parse error: ${error}`);
+        }
+        if (parsed === null) {
+          continue;
+        }
+        if (emitRawEvents) {
+          yield { type: "raw_event", raw: parsed };
+        }
+        const threadEvent = convertRustEventToThreadEvent(parsed);
+        if (threadEvent.type === "thread.started") {
+          this._id = threadEvent.thread_id;
+        }
+        for (const listener of this._eventListeners) {
+          try {
+            listener(threadEvent);
+          } catch (error) {
+            console.warn("Thread event listener threw error:", error);
+          }
+        }
+        yield threadEvent;
+      }
+    } finally {
+      await schemaFile.cleanup();
+    }
+  }
+  /** Provides the input to the agent and returns the completed turn. */
+  async run(input, turnOptions = {}) {
+    const generator = this.runStreamedInternal(input, turnOptions, true);
+    const items = [];
+    let finalResponse = "";
+    let usage = null;
+    let turnFailure = null;
+    for await (const event of generator) {
+      if (event.type === "item.completed") {
+        if (event.item.type === "agent_message") {
+          finalResponse = event.item.text;
+        }
+        items.push(event.item);
+      } else if (event.type === "turn.completed") {
+        usage = event.usage;
+      } else if (event.type === "turn.failed") {
+        turnFailure = event.error;
+        break;
+      }
+    }
+    if (turnFailure) {
+      throw new Error(turnFailure.message);
+    }
+    return { items, finalResponse, usage };
+  }
+  buildTuiRequest(overrides = {}) {
+    const skipGitRepoCheck = this._threadOptions?.skipGitRepoCheck ?? (typeof process !== "undefined" && process.env && process.env.CODEX_TEST_SKIP_GIT_REPO_CHECK === "1");
+    if (!skipGitRepoCheck) {
+      assertTrustedDirectory2(this._threadOptions?.workingDirectory);
+    }
+    const request = { ...overrides };
+    const assignIfUndefined = (key, value) => {
+      if (request[key] === void 0 && value !== void 0) {
+        request[key] = value;
+      }
+    };
+    assignIfUndefined("model", this._threadOptions?.model ?? this._options.defaultModel);
+    assignIfUndefined("oss", this._threadOptions?.oss);
+    assignIfUndefined("sandboxMode", this._threadOptions?.sandboxMode);
+    assignIfUndefined("approvalMode", this._threadOptions?.approvalMode);
+    assignIfUndefined("fullAuto", this._threadOptions?.fullAuto);
+    assignIfUndefined("workingDirectory", this._threadOptions?.workingDirectory);
+    assignIfUndefined("baseUrl", this._options.baseUrl);
+    assignIfUndefined("apiKey", this._options.apiKey);
+    if (request.resumeSessionId === void 0 && request.resumePicker !== true && request.resumeLast !== true && this._id) {
+      request.resumeSessionId = this._id;
+    }
+    return request;
+  }
+  /**
+   * Launches the interactive Codex TUI (Terminal User Interface) for this thread and returns a session handle.
+   *
+   * The handle allows advanced workflows where the TUI can be started and stopped programmatically,
+   * while preserving the underlying conversation state.
+   */
+  launchTui(overrides = {}) {
+    const request = this.buildTuiRequest(overrides);
+    const detachLsp = this.attachDefaultLspBridge(request);
+    const session = startTui(request);
+    return this.wrapTuiSession(session, detachLsp);
+  }
+  /**
+   * Launches the interactive Codex TUI (Terminal User Interface) for this thread.
+   *
+   * This method enables seamless transition from programmatic agent interaction to
+   * interactive terminal chat within the same session. The TUI takes over the terminal
+   * and allows you to continue the conversation interactively.
+   *
+   * @param overrides - Optional configuration to override thread defaults. Supports all TUI options
+   *                    including prompt, sandbox mode, approval mode, and resume options.
+   * @param options - Optional run options including an AbortSignal to request shutdown.
+   * @returns A Promise that resolves to TUI exit information including:
+   *          - tokenUsage: Token consumption statistics
+   *          - conversationId: Session ID for resuming later
+   *          - updateAction: Optional suggested update command
+   * @throws {Error} If not in a trusted git repository (unless skipGitRepoCheck is set)
+   * @throws {Error} If the terminal is not interactive (TTY required)
+   */
+  async tui(overrides = {}, options = {}) {
+    const request = this.buildTuiRequest(overrides);
+    const detachLsp = this.attachDefaultLspBridge(request);
+    try {
+      return await runTui(request, options);
+    } finally {
+      detachLsp();
+    }
+  }
+  wrapTuiSession(session, cleanup) {
+    let released = false;
+    const release = () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      cleanup();
+    };
+    return {
+      wait: async () => {
+        try {
+          return await session.wait();
+        } finally {
+          release();
+        }
+      },
+      shutdown: () => {
+        release();
+        session.shutdown();
+      },
+      get closed() {
+        return session.closed;
+      }
+    };
+  }
+  attachDefaultLspBridge(request) {
+    const workingDirectory = request.workingDirectory ?? this._threadOptions?.workingDirectory ?? (typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".");
+    return attachLspDiagnostics(this, {
+      workingDirectory,
+      waitForDiagnostics: true
+    });
+  }
+};
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { prompt: input, images: [] };
+  }
+  const promptParts = [];
+  const images = [];
+  for (const item of input) {
+    if (item.type === "text") {
+      promptParts.push(item.text);
+    } else if (item.type === "local_image") {
+      images.push(item.path);
+    }
+  }
+  return { prompt: promptParts.join("\n\n"), images };
+}
+
+// src/reviewOptions.ts
+function buildReviewPrompt(target) {
+  switch (target.type) {
+    case "current_changes":
+      return {
+        prompt: "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.",
+        hint: "current changes"
+      };
+    case "branch": {
+      const branch = target.baseBranch;
+      const prompt = `Review the code changes against the base branch '${branch}'. Start by finding the merge diff between the current branch and ${branch}'s upstream e.g. (\`git merge-base HEAD "$(git rev-parse --abbrev-ref "${branch}@{upstream}")"\`), then run \`git diff\` against that SHA to see what changes we would merge into the ${branch} branch. Provide prioritized, actionable findings.`;
+      return {
+        prompt,
+        hint: `changes against '${branch}'`
+      };
+    }
+    case "commit": {
+      const shortSha = target.sha.slice(0, 7);
+      const subject = target.subject ?? target.sha;
+      return {
+        prompt: `Review the code changes introduced by commit ${target.sha} ("${subject}"). Provide prioritized, actionable findings.`,
+        hint: `commit ${shortSha}`
+      };
+    }
+    case "custom": {
+      const hint = target.hint ?? "custom review";
+      return {
+        prompt: target.prompt,
+        hint
+      };
+    }
+    default: {
+      const exhaustive = target;
+      throw new Error(`Unsupported review target: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/codex.ts
+var Codex = class {
+  exec;
+  options;
+  nativeBinding;
+  lspForTools;
+  constructor(options = {}) {
+    const predefinedTools = options.tools ? [...options.tools] : [];
+    const preserveRegisteredTools = options.preserveRegisteredTools === true;
+    this.nativeBinding = getNativeBinding();
+    this.options = { ...options, tools: [] };
+    if (this.nativeBinding) {
+      if (!preserveRegisteredTools && typeof this.nativeBinding.clearRegisteredTools === "function") {
+        this.nativeBinding.clearRegisteredTools();
+      }
+      for (const tool of predefinedTools) {
+        this.registerTool(tool);
+      }
+    }
+    this.lspForTools = this.createLspManagerForTools();
+    if (this.lspForTools && this.nativeBinding) {
+      this.registerDefaultReadFileInterceptor();
+    }
+    this.exec = new CodexExec();
+  }
+  /**
+   * Register a tool for Codex. When `tool.name` matches a built-in Codex tool,
+   * the native implementation is replaced for this Codex instance.
+   */
+  registerTool(tool) {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool registration requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.registerTool !== "function") {
+      console.warn("registerTool is not available in this build - tools feature may be incomplete");
+      return;
+    }
+    const { handler, ...info } = tool;
+    this.nativeBinding.registerTool(info, handler);
+    if (!this.options.tools) {
+      this.options.tools = [];
+    }
+    this.options.tools.push(tool);
+  }
+  /**
+   * Register a tool interceptor for Codex. Interceptors can modify tool invocations
+   * and results, and can call the built-in implementation.
+   */
+  registerToolInterceptor(toolName, handler) {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool interceptor registration requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.registerToolInterceptor !== "function" || typeof this.nativeBinding.callToolBuiltin !== "function") {
+      console.warn("registerToolInterceptor is not available in this build - interceptor feature may be incomplete");
+      return;
+    }
+    this.nativeBinding.registerToolInterceptor(toolName, async (...args) => {
+      const context = args.length === 1 ? args[0] : args[1];
+      if (!context || typeof context !== "object") {
+        throw new Error("Native interceptor callback did not receive a context object");
+      }
+      const { invocation, token } = context;
+      const callBuiltin = (override) => this.nativeBinding.callToolBuiltin(token, override ?? invocation);
+      return handler({ invocation, callBuiltin });
+    });
+  }
+  /**
+   * Clear all registered tools, restoring built-in defaults.
+   */
+  clearTools() {
+    if (!this.nativeBinding) {
+      throw new Error("Native tool management requires the NAPI binding");
+    }
+    if (typeof this.nativeBinding.clearRegisteredTools === "function") {
+      this.nativeBinding.clearRegisteredTools();
+    }
+    if (this.options.tools) {
+      this.options.tools = [];
+    }
+  }
+  buildConversationConfig(options = {}) {
+    return {
+      model: options.model ?? this.options.defaultModel,
+      modelProvider: options.modelProvider ?? this.options.modelProvider,
+      oss: options.oss,
+      sandboxMode: options.sandboxMode,
+      approvalMode: options.approvalMode,
+      workspaceWriteOptions: options.workspaceWriteOptions,
+      workingDirectory: options.workingDirectory,
+      skipGitRepoCheck: options.skipGitRepoCheck,
+      reasoningEffort: options.reasoningEffort,
+      reasoningSummary: options.reasoningSummary,
+      fullAuto: options.fullAuto,
+      baseUrl: this.options.baseUrl,
+      apiKey: this.options.apiKey
+    };
+  }
+  createLspManagerForTools() {
+    const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+    const options = {
+      workingDirectory: cwd,
+      waitForDiagnostics: true
+    };
+    try {
+      return new LspManager(options);
+    } catch {
+      return null;
+    }
+  }
+  registerDefaultReadFileInterceptor() {
+    if (!this.lspForTools) {
+      return;
+    }
+    try {
+      this.registerToolInterceptor("read_file", async ({ invocation, callBuiltin }) => {
+        let base;
+        try {
+          base = await callBuiltin();
+        } catch (err) {
+          return {
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+            output: void 0
+          };
+        }
+        if (!base.output || base.success === false) {
+          return base;
+        }
+        let filePath;
+        if (invocation.arguments) {
+          try {
+            const args = JSON.parse(invocation.arguments);
+            const candidate = typeof args.file_path === "string" && args.file_path || typeof args.path === "string" && args.path || void 0;
+            if (candidate && candidate.trim().length > 0) {
+              filePath = candidate;
+            }
+          } catch {
+          }
+        }
+        if (!filePath) {
+          return base;
+        }
+        let diagnosticsText = "";
+        try {
+          const results = await this.lspForTools.collectDiagnostics([filePath]);
+          if (!results.length) {
+            return base;
+          }
+          diagnosticsText = formatDiagnosticsForTool(results);
+        } catch {
+          return base;
+        }
+        if (!diagnosticsText) {
+          return base;
+        }
+        const header = `LSP diagnostics for ${filePath}:
+${diagnosticsText}`;
+        return prependSystemHintToToolResult(base, header);
+      });
+    } catch {
+    }
+  }
+  /**
+   * Register a programmatic approval callback that Codex will call before executing
+   * sensitive operations (e.g., shell commands, file writes).
+   */
+  setApprovalCallback(handler) {
+    if (!this.nativeBinding || typeof this.nativeBinding.registerApprovalCallback !== "function") {
+      console.warn("Approval callback is not available in this build");
+      return;
+    }
+    this.nativeBinding.registerApprovalCallback(handler);
+  }
+  /**
+   * Starts a new conversation with an agent.
+   * @returns A new thread instance.
+   */
+  startThread(options = {}) {
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions);
+  }
+  /**
+   * Resumes a conversation with an agent based on the thread id.
+   * Threads are persisted in ~/.codex/sessions.
+   *
+   * @param id The id of the thread to resume.
+   * @returns A new thread instance.
+   */
+  resumeThread(id, options = {}) {
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions, id);
+  }
+  async listConversations(options = {}) {
+    const request = {
+      config: this.buildConversationConfig(options),
+      pageSize: options.pageSize,
+      cursor: options.cursor,
+      modelProviders: options.modelProviders
+    };
+    return this.exec.listConversations(request);
+  }
+  async deleteConversation(id, options = {}) {
+    const result = await this.exec.deleteConversation({
+      id,
+      config: this.buildConversationConfig(options)
+    });
+    return result.deleted;
+  }
+  async resumeConversationFromRollout(rolloutPath, options = {}) {
+    const result = await this.exec.resumeConversationFromRollout({
+      rolloutPath,
+      config: this.buildConversationConfig(options)
+    });
+    const threadOptions = {
+      ...options,
+      model: options.model ?? this.options.defaultModel
+    };
+    return new Thread(this.exec, this.options, threadOptions, result.threadId);
+  }
+  /**
+   * Starts a review task using the built-in Codex review flow.
+   */
+  async review(options) {
+    const generator = this.reviewStreamedInternal(options);
+    const items = [];
+    let finalResponse = "";
+    let usage = null;
+    let turnFailure = null;
+    for await (const event of generator) {
+      if (event === null) continue;
+      if (event.type === "item.completed") {
+        if (event.item.type === "agent_message") {
+          finalResponse = event.item.text;
+        }
+        items.push(event.item);
+      } else if (event.type === "exited_review_mode") {
+        if (event.review_output) {
+          const reviewOutput = event.review_output;
+          let reviewText = "";
+          if (reviewOutput.overall_explanation) {
+            reviewText += reviewOutput.overall_explanation;
+          }
+          if (reviewOutput.findings && reviewOutput.findings.length > 0) {
+            if (reviewText) reviewText += "\n\n";
+            reviewText += "## Review Findings\n\n";
+            reviewOutput.findings.forEach((finding, index) => {
+              reviewText += `### ${index + 1}. ${finding.title}
+`;
+              reviewText += `${finding.body}
+`;
+              reviewText += `**Priority:** ${finding.priority} | **Confidence:** ${finding.confidence_score}
+`;
+              reviewText += `**Location:** ${finding.code_location.absolute_file_path}:${finding.code_location.line_range.start}-${finding.code_location.line_range.end}
+
+`;
+            });
+          }
+          finalResponse = reviewText;
+        }
+      } else if (event.type === "turn.completed") {
+        usage = event.usage;
+      } else if (event.type === "turn.failed") {
+        turnFailure = event.error;
+        break;
+      }
+    }
+    if (turnFailure) {
+      throw new Error(turnFailure.message);
+    }
+    return { items, finalResponse, usage };
+  }
+  /**
+   * Starts a review task and returns the event stream.
+   */
+  async reviewStreamed(options) {
+    return { events: this.reviewStreamedInternal(options) };
+  }
+  async *reviewStreamedInternal(options) {
+    const { target, threadOptions = {}, turnOptions = {} } = options;
+    const { prompt, hint } = buildReviewPrompt(target);
+    const normalizedSchema = normalizeOutputSchema(turnOptions.outputSchema);
+    const needsSchemaFile = this.exec.requiresOutputSchemaFile();
+    const schemaFile = needsSchemaFile ? await createOutputSchemaFile(normalizedSchema) : { schemaPath: void 0, cleanup: async () => {
+    } };
+    const generator = this.exec.run({
+      input: prompt,
+      baseUrl: this.options.baseUrl,
+      apiKey: this.options.apiKey,
+      model: threadOptions.model,
+      modelProvider: threadOptions.modelProvider ?? this.options.modelProvider,
+      oss: threadOptions.oss,
+      sandboxMode: threadOptions.sandboxMode,
+      approvalMode: threadOptions.approvalMode,
+      workspaceWriteOptions: threadOptions.workspaceWriteOptions,
+      workingDirectory: threadOptions.workingDirectory,
+      skipGitRepoCheck: threadOptions.skipGitRepoCheck,
+      outputSchemaFile: schemaFile.schemaPath,
+      outputSchema: normalizedSchema,
+      fullAuto: threadOptions.fullAuto,
+      review: {
+        userFacingHint: hint
+      }
+    });
+    try {
+      for await (const item of generator) {
+        let parsed;
+        try {
+          parsed = JSON.parse(item);
+        } catch (error) {
+          throw new Error(`Failed to parse item: ${item}`, { cause: error });
+        }
+        yield parsed;
+      }
+    } finally {
+      await schemaFile.cleanup();
+    }
+  }
+};
+function prependSystemHintToToolResult(base, hint) {
+  const trimmedHint = hint.trim();
+  if (!trimmedHint) {
+    return base;
+  }
+  const existing = base.output ?? "";
+  const separator = existing.length === 0 || existing.startsWith("\n") ? "\n\n" : "\n\n";
+  const output = existing.length === 0 ? `[SYSTEM_HINT]
+${trimmedHint}` : `[SYSTEM_HINT]
+${trimmedHint}${separator}${existing}`;
+  return {
+    ...base,
+    output
+  };
+}
+
+// src/cli/tui.ts
+async function executeTuiCommand(argv, context) {
+  if (!import_node_process2.default.stdout.isTTY || !import_node_process2.default.stdin.isTTY) {
+    throw new Error("The interactive TUI requires an interactive terminal (TTY).");
+  }
+  const { combinedConfig } = context;
+  emitWarnings(combinedConfig.warnings);
+  const warningCount = combinedConfig.warnings.length;
+  const { request, thread: threadOptions } = buildTuiConfig({
+    argv,
+    defaults: combinedConfig.tuiDefaults,
+    cwd: context.cwd
+  });
+  applyElevatedTuiDefaults({ request, thread: threadOptions, cwd: context.cwd });
+  const hookContext = {
+    command: "tui",
+    cwd: context.cwd,
+    options: argv
+  };
+  await runBeforeStartHooks(combinedConfig.beforeStartHooks, hookContext, combinedConfig.warnings);
+  const codex = new Codex({
+    baseUrl: request.baseUrl,
+    apiKey: request.apiKey,
+    preserveRegisteredTools: true
+  });
+  const thread = codex.startThread(threadOptions);
+  const exitInfo = await thread.tui(request);
+  if (exitInfo.conversationId) {
+    import_node_process2.default.stdout.write(`
+Conversation ID: ${exitInfo.conversationId}
+`);
+  }
+  if (exitInfo.updateAction) {
+    import_node_process2.default.stdout.write(
+      `Update available (${exitInfo.updateAction.kind}): ${exitInfo.updateAction.command}
+`
+    );
+  }
+  emitWarnings(combinedConfig.warnings, warningCount);
+}
+function buildTuiConfig(params) {
+  const { argv, defaults, cwd } = params;
+  const request = {
+    ...defaults
+  };
+  if (argv.prompt !== void 0) request.prompt = argv.prompt;
+  if (argv.model !== void 0) request.model = argv.model;
+  if (argv.oss !== void 0) request.oss = argv.oss;
+  const sandboxMode = parseSandboxModeFlag(argv.sandbox, "--sandbox");
+  if (sandboxMode !== void 0) {
+    request.sandboxMode = sandboxMode;
+  }
+  const approvalMode = parseApprovalModeFlag(argv.approval, "--approval");
+  if (approvalMode !== void 0) {
+    request.approvalMode = approvalMode;
+  }
+  if (argv.resume !== void 0) request.resumeSessionId = argv.resume;
+  if (argv.resumeLast !== void 0) request.resumeLast = argv.resumeLast;
+  if (argv.resumePicker !== void 0) request.resumePicker = argv.resumePicker;
+  if (argv.fullAuto !== void 0) request.fullAuto = argv.fullAuto;
+  if (argv.dangerouslyBypassApprovalsAndSandbox !== void 0) {
+    request.dangerouslyBypassApprovalsAndSandbox = argv.dangerouslyBypassApprovalsAndSandbox;
+  }
+  if (argv.cd !== void 0) request.workingDirectory = argv.cd;
+  if (argv.configProfile !== void 0) request.configProfile = argv.configProfile;
+  if (argv.webSearch !== void 0) request.webSearch = argv.webSearch;
+  if (argv.linuxSandboxPath !== void 0) request.linuxSandboxPath = argv.linuxSandboxPath;
+  if (argv.baseUrl !== void 0) request.baseUrl = argv.baseUrl;
+  if (argv.apiKey !== void 0) request.apiKey = argv.apiKey;
+  if (argv.configOverrides) {
+    const defaultsOverrides = Array.isArray(request.configOverrides) ? [...request.configOverrides] : [];
+    request.configOverrides = [...defaultsOverrides, ...argv.configOverrides];
+  }
+  if (argv.addDir) {
+    const defaultsAddDir = Array.isArray(request.addDir) ? [...request.addDir] : [];
+    request.addDir = [...defaultsAddDir, ...argv.addDir];
+  }
+  if (argv.image) {
+    const defaultsImages = Array.isArray(request.images) ? [...request.images] : [];
+    request.images = [...defaultsImages, ...argv.image];
+  }
+  const thread = {
+    model: request.model,
+    oss: request.oss,
+    sandboxMode: request.sandboxMode,
+    approvalMode: request.approvalMode,
+    workingDirectory: request.workingDirectory ?? cwd,
+    skipGitRepoCheck: false
+  };
+  return { request, thread };
+}
+
+// src/cli/reverie.ts
+var import_node_path6 = __toESM(require("path"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_util = require("util");
+var DEFAULT_MODEL = "mixedbread-ai/mxbai-embed-large-v1";
+var INDEX_OPTION_DEFS = {
+  "codex-home": { type: "string" },
+  "project-root": { type: "string" },
+  limit: { type: "string" },
+  "max-candidates": { type: "string" },
+  "batch-size": { type: "string" },
+  normalize: { type: "boolean" },
+  cache: { type: "boolean" },
+  "embed-model": { type: "string" },
+  "embed-cache-dir": { type: "string" },
+  "embed-max-length": { type: "string" },
+  "no-progress": { type: "boolean" },
+  "skip-embed-init": { type: "boolean" }
+};
+async function executeReverieCommand(args) {
+  const [first, ...rest] = args;
+  const isFlag = first?.startsWith("-");
+  const command = !first || isFlag ? "index" : first;
+  const tail = !first || isFlag ? args : rest;
+  if (command !== "index") {
+    throw new Error(`Unknown reverie command '${command}'. Supported subcommands: index`);
+  }
+  await runReverieIndex(tail);
+}
+async function runReverieIndex(args) {
+  const { values } = (0, import_node_util.parseArgs)({ args, options: INDEX_OPTION_DEFS, allowPositionals: false, strict: true });
+  const codexHome = resolveCodexHome(values["codex-home"]);
+  const projectRoot = resolveProjectRoot(values["project-root"]);
+  const limit = parseOptionalInt(values.limit);
+  const maxCandidates = parseOptionalInt(values["max-candidates"]);
+  const batchSize = parseOptionalInt(values["batch-size"]);
+  const embedMaxLength = parseOptionalInt(values["embed-max-length"]);
+  const normalize = typeof values.normalize === "boolean" ? values.normalize : void 0;
+  const cache = typeof values.cache === "boolean" ? values.cache : void 0;
+  const embedModel = typeof values["embed-model"] === "string" ? values["embed-model"] : DEFAULT_MODEL;
+  const embedCacheDir = typeof values["embed-cache-dir"] === "string" ? values["embed-cache-dir"] : void 0;
+  const showDownloadProgress = values["no-progress"] ? false : true;
+  const skipEmbedInit = values["skip-embed-init"] === true;
+  if (!skipEmbedInit) {
+    await fastEmbedInit({
+      model: embedModel,
+      cacheDir: embedCacheDir ? import_node_path6.default.resolve(embedCacheDir) : defaultCacheDir(),
+      maxLength: embedMaxLength ?? void 0,
+      showDownloadProgress
+    });
+  }
+  const options = {
+    limit,
+    maxCandidates,
+    projectRoot,
+    batchSize,
+    normalize,
+    cache
+  };
+  console.log(`\u{1F4C2} Codex home: ${codexHome}`);
+  console.log(`\u{1F4C1} Project root: ${projectRoot}`);
+  const stats = await reverieIndexSemantic(codexHome, options);
+  console.log(
+    `\u2705 Indexed ${stats.documentsEmbedded} conversation(s) across ${stats.batches} batch(es); cache warmed at ${projectRoot}`
+  );
+}
+function resolveCodexHome(explicit) {
+  if (explicit) {
+    return import_node_path6.default.resolve(explicit);
+  }
+  if (process.env.CODEX_HOME) {
+    return process.env.CODEX_HOME;
+  }
+  const home = import_node_os2.default.homedir() || process.cwd();
+  return import_node_path6.default.join(home, ".codex");
+}
+function resolveProjectRoot(explicit) {
+  if (explicit) {
+    return import_node_path6.default.resolve(explicit);
+  }
+  return process.cwd();
+}
+function parseOptionalInt(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function defaultCacheDir() {
+  if (process.env.CODEX_EMBED_CACHE) {
+    return import_node_path6.default.resolve(process.env.CODEX_EMBED_CACHE);
+  }
+  return import_node_path6.default.join(import_node_os2.default.tmpdir(), "codex-embed-cache");
+}
+
+// src/cli/runtime.ts
+async function buildCombinedConfig(params) {
+  const { cwd, config } = params;
+  const warnings = [...config.warnings];
+  const combined = {
+    runDefaults: {},
+    tuiDefaults: {},
+    tools: [],
+    interceptors: [],
+    approval: void 0,
+    beforeStartHooks: [],
+    onEventHooks: [],
+    warnings,
+    allowReservedInterceptors: false
+  };
+  const pluginContext = { cwd, configPath: config.configPath };
+  if (config.config) {
+    accumulateConfig({
+      combined,
+      config: config.config,
+      source: config.configPath ?? "config",
+      warnings
+    });
+  }
+  for (const loaded of config.plugins) {
+    const pluginConfig = await evaluatePlugin(loaded, pluginContext, warnings);
+    if (pluginConfig) {
+      accumulateConfig({
+        combined,
+        config: pluginConfig,
+        source: loaded.spec,
+        warnings
+      });
+    }
+  }
+  combined.warnings = warnings;
+  return combined;
+}
+function applyNativeRegistrations(combined) {
+  const binding = getNativeBinding();
+  if (!binding) {
+    throw new Error("Native binding is not available.");
+  }
+  binding.clearRegisteredTools();
+  const seenTools = /* @__PURE__ */ new Set();
+  for (const tool of combined.tools) {
+    const { handler, ...info } = tool;
+    const name = String(info.name);
+    if (seenTools.has(name)) {
+      combined.warnings.push(`Duplicate tool "${name}" ignored (first definition wins).`);
+      continue;
+    }
+    seenTools.add(name);
+    binding.registerTool(info, handler);
+  }
+  if (combined.approval && typeof binding.registerApprovalCallback === "function") {
+    binding.registerApprovalCallback(combined.approval.handler);
+  }
+  const RESERVED = /* @__PURE__ */ new Set(["local_shell", "exec_command", "apply_patch", "web_search"]);
+  const seenInterceptors = /* @__PURE__ */ new Set();
+  for (const interceptor of combined.interceptors) {
+    const name = interceptor.toolName;
+    if (RESERVED.has(name) && !combined.allowReservedInterceptors) {
+      combined.warnings.push(
+        `Interceptor for "${name}" ignored: reserved for approval gating. Use approvals() hook instead.`
+      );
+      continue;
+    }
+    if (seenInterceptors.has(name)) {
+      combined.warnings.push(
+        `Multiple interceptors for "${name}" detected; only the first will be used.`
+      );
+      continue;
+    }
+    seenInterceptors.add(name);
+    binding.registerToolInterceptor(interceptor.toolName, interceptor.handler);
+  }
+}
+async function evaluatePlugin(loaded, context, warnings) {
+  const { plugin, spec } = loaded;
+  try {
+    if (typeof plugin === "function") {
+      const result = await plugin(context);
+      return coerceConfig(result, spec, warnings);
+    }
+    if (plugin && typeof plugin === "object") {
+      const candidate = plugin;
+      if (typeof candidate.setup === "function") {
+        await candidate.setup(context);
+      }
+      if (typeof candidate.config === "function") {
+        return coerceConfig(await candidate.config(context), spec, warnings);
+      }
+      if (candidate.config) {
+        return coerceConfig(candidate.config, spec, warnings);
+      }
+      return coerceConfig(candidate, spec, warnings);
+    }
+    return coerceConfig(plugin, spec, warnings);
+  } catch (error) {
+    warnings.push(`Plugin "${spec}" threw an error: ${error.message}`);
+    return null;
+  }
+}
+function coerceConfig(value, source, warnings) {
+  if (!value) {
+    return null;
+  }
+  if (typeof value === "object") {
+    return value;
+  }
+  warnings.push(`Plugin "${source}" did not return a config object.`);
+  return null;
+}
+function accumulateConfig(params) {
+  const { combined, config, source, warnings } = params;
+  if (config.defaults?.run) {
+    combined.runDefaults = { ...combined.runDefaults, ...config.defaults.run };
+  }
+  if (config.defaults?.tui) {
+    combined.tuiDefaults = { ...combined.tuiDefaults, ...config.defaults.tui };
+  }
+  if (Array.isArray(config.tools)) {
+    for (const tool of config.tools) {
+      if (!tool || typeof tool !== "object" || typeof tool.handler !== "function") {
+        warnings.push(`Invalid tool definition supplied by "${source}".`);
+        continue;
+      }
+      combined.tools.push(tool);
+    }
+  }
+  if (Array.isArray(config.interceptors)) {
+    for (const interceptor of config.interceptors) {
+      if (!interceptor || typeof interceptor !== "object" || typeof interceptor.toolName !== "string" || typeof interceptor.handler !== "function") {
+        warnings.push(`Invalid interceptor definition supplied by "${source}".`);
+        continue;
+      }
+      combined.interceptors.push(interceptor);
+    }
+  }
+  if (config.approvals) {
+    if (typeof config.approvals !== "function") {
+      warnings.push(`Approval callback from "${source}" must be a function.`);
+    } else {
+      if (combined.approval) {
+        warnings.push(
+          `Approval callback from "${source}" overrides handler from "${combined.approval.source}".`
+        );
+      }
+      combined.approval = { source, handler: config.approvals };
+    }
+  }
+  if (config.hooks) {
+    addHooks(combined, config.hooks, source, warnings);
+  }
+  if (config.allowReservedInterceptors === true) {
+    combined.allowReservedInterceptors = true;
+  }
+}
+function addHooks(combined, hooks, source, warnings) {
+  if (hooks.beforeStart) {
+    const beforeStartCallbacks = Array.isArray(hooks.beforeStart) ? hooks.beforeStart : [hooks.beforeStart];
+    for (const callback of beforeStartCallbacks) {
+      if (typeof callback !== "function") {
+        warnings.push(`beforeStart hook from "${source}" must be a function.`);
+        continue;
+      }
+      combined.beforeStartHooks.push({ source, callback });
+    }
+  }
+  if (hooks.onEvent) {
+    const eventCallbacks = Array.isArray(hooks.onEvent) ? hooks.onEvent : [hooks.onEvent];
+    for (const callback of eventCallbacks) {
+      if (typeof callback !== "function") {
+        warnings.push(`onEvent hook from "${source}" must be a function.`);
+        continue;
+      }
+      combined.onEventHooks.push({ source, callback });
+    }
+  }
+}
+
+// src/cli/index.ts
+var VERSION = package_default.version;
+var SANDBOX_CHOICES = ["read-only", "workspace-write", "danger-full-access"];
+var APPROVAL_CHOICES = ["never", "on-request", "on-failure", "untrusted"];
+var APPLY_PATCH_FLAG = "--codex-run-as-apply-patch";
+var CLI_ENTRYPOINT_ENV2 = "CODEX_NODE_CLI_ENTRYPOINT";
+try {
+  const entrypoint = (0, import_node_url4.fileURLToPath)(importMetaUrl);
+  import_node_process3.default.env[CLI_ENTRYPOINT_ENV2] = entrypoint;
+} catch {
+  if (import_node_process3.default.argv[1]) {
+    import_node_process3.default.env[CLI_ENTRYPOINT_ENV2] = import_node_process3.default.argv[1];
+  }
+}
+var GLOBAL_OPTION_DEFS = {
+  config: { type: "string" },
+  "no-config": { type: "boolean" },
+  plugin: { type: "string", multiple: true }
+};
+var RUN_OPTION_DEFS = {
+  model: { type: "string" },
+  oss: { type: "boolean" },
+  sandbox: { type: "string" },
+  approval: { type: "string" },
+  schema: { type: "string" },
+  "thread-id": { type: "string" },
+  "base-url": { type: "string" },
+  "api-key": { type: "string" },
+  "linux-sandbox-path": { type: "string" },
+  "full-auto": { type: "boolean" },
+  "skip-git-repo-check": { type: "boolean" },
+  cd: { type: "string" },
+  image: { type: "string", multiple: true },
+  "review-mode": { type: "boolean" },
+  "review-hint": { type: "string" }
+};
+var TUI_OPTION_DEFS = {
+  model: { type: "string" },
+  oss: { type: "boolean" },
+  sandbox: { type: "string" },
+  approval: { type: "string" },
+  resume: { type: "string" },
+  "resume-last": { type: "boolean" },
+  "resume-picker": { type: "boolean" },
+  "full-auto": { type: "boolean" },
+  "dangerously-bypass-approvals-and-sandbox": { type: "boolean" },
+  cd: { type: "string" },
+  "config-profile": { type: "string" },
+  "config-overrides": { type: "string", multiple: true },
+  "add-dir": { type: "string", multiple: true },
+  image: { type: "string", multiple: true },
+  "web-search": { type: "boolean" },
+  "linux-sandbox-path": { type: "string" },
+  "base-url": { type: "string" },
+  "api-key": { type: "string" }
+};
+async function main() {
+  const rawArgs = import_node_process3.default.argv.slice(2);
+  if (maybeHandleApplyPatch(rawArgs)) {
+    return;
+  }
+  if (hasFlag(rawArgs, "--version") || hasFlag(rawArgs, "-v")) {
+    printVersion();
+    return;
+  }
+  const generalHelpRequested = hasFlag(rawArgs, "--help") || hasFlag(rawArgs, "-h");
+  if (generalHelpRequested && !hasExplicitCommand(rawArgs)) {
+    printGeneralHelp();
+    return;
+  }
+  const { command, args } = selectCommand(rawArgs);
+  if (hasCommandHelpFlag(args)) {
+    printCommandHelp(command);
+    return;
+  }
+  if (command === "reverie-index") {
+    await executeReverieCommand(args);
+    return;
+  }
+  const options = command === "tui" ? parseTuiCommand(args) : parseRunCommand(args);
+  validateOptionChoices(command, options);
+  const context = await createContext(options);
+  if (command === "tui") {
+    await executeTuiCommand(options, context);
+  } else {
+    await executeRunCommand(options, context);
+  }
+}
+function maybeHandleApplyPatch(args) {
+  if (args.length === 0 || args[0] !== APPLY_PATCH_FLAG) {
+    return false;
+  }
+  const patch = args[1];
+  if (!patch) {
+    console.error(`${APPLY_PATCH_FLAG} requires a patch argument.`);
+    import_node_process3.default.exitCode = 1;
+    return true;
+  }
+  try {
+    runApplyPatch(patch);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`apply_patch failed: ${message}`);
+    import_node_process3.default.exitCode = 1;
+  }
+  return true;
+}
+function selectCommand(argv) {
+  if (argv.length > 0) {
+    const [first, ...rest] = argv;
+    if (first === "tui") {
+      return { command: "tui", args: rest };
+    }
+    if (first === "run") {
+      return { command: "run", args: rest };
+    }
+    if (first === "reverie") {
+      if (rest.length === 0) {
+        return { command: "reverie-index", args: [] };
+      }
+      return { command: "reverie-index", args: rest };
+    }
+  }
+  if (argv.length === 0) {
+    const isInteractive2 = import_node_process3.default.stdout.isTTY && import_node_process3.default.stdin.isTTY;
+    return { command: isInteractive2 ? "tui" : "run", args: [] };
+  }
+  const isInteractive = import_node_process3.default.stdout.isTTY && import_node_process3.default.stdin.isTTY;
+  return { command: isInteractive ? "tui" : "run", args: argv };
+}
+function hasExplicitCommand(argv) {
+  if (argv.length === 0) {
+    return false;
+  }
+  const first = argv[0];
+  return first === "tui" || first === "run" || first === "reverie";
+}
+function parseRunCommand(args) {
+  const { values, positionals } = (0, import_node_util2.parseArgs)({
+    args,
+    options: { ...GLOBAL_OPTION_DEFS, ...RUN_OPTION_DEFS },
+    allowPositionals: true,
+    strict: true
+  });
+  const options = camelCaseKeys(values);
+  const runOptions = {
+    ...options
+  };
+  if (!runOptions.prompt && positionals.length > 0) {
+    runOptions.prompt = positionals[0];
+  }
+  return runOptions;
+}
+function parseTuiCommand(args) {
+  const { values, positionals } = (0, import_node_util2.parseArgs)({
+    args,
+    options: { ...GLOBAL_OPTION_DEFS, ...TUI_OPTION_DEFS },
+    allowPositionals: true,
+    strict: true
+  });
+  const options = camelCaseKeys(values);
+  const tuiOptions = {
+    ...options
+  };
+  if (!tuiOptions.prompt && positionals.length > 0) {
+    tuiOptions.prompt = positionals[0];
+  }
+  return tuiOptions;
+}
+async function createContext(options) {
+  const cwd = import_node_process3.default.cwd();
+  const configOptions = {
+    cwd,
+    explicitConfigPath: options.config,
+    noConfig: options.noConfig,
+    pluginPaths: normalizeStringArray(options.plugin)
+  };
+  const config = await loadCliConfig(configOptions);
+  const combinedConfig = await buildCombinedConfig({ cwd, config });
+  applyNativeRegistrations(combinedConfig);
+  return { cwd, config, combinedConfig };
+}
+function normalizeStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item));
+  }
+  if (typeof value === "string") {
+    return [value];
+  }
+  return [];
+}
+function camelCaseKeys(record) {
+  return Object.entries(record).reduce((acc, [key, value]) => {
+    acc[toCamelCase(key)] = value;
+    return acc;
+  }, {});
+}
+function toCamelCase(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function hasCommandHelpFlag(args) {
+  return hasFlag(args, "--help") || hasFlag(args, "-h");
+}
+function printVersion() {
+  console.log(VERSION);
+}
+function printGeneralHelp() {
+  console.log(`codex-native v${VERSION}
+
+Usage:
+  codex-native [options] [prompt]
+  codex-native run [options] [prompt]
+  codex-native tui [options] [prompt]
+
+Default behavior:
+  Running 'codex-native' without arguments launches the interactive TUI.
+  Use 'codex-native run <prompt>' for non-interactive exec mode.
+
+Commands:
+  (default)   Launch the interactive TUI (with optional initial prompt)
+  run         Run Codex in non-interactive exec mode
+  tui         Explicitly launch the interactive TUI
+  reverie index  Pre-compute reverie embeddings for the current repo
+
+Global options:
+  --config <path>        Path to codex.config.js (or similar)
+  --no-config            Skip automatic config discovery
+  --plugin <path>        Additional plugin module (repeatable)
+
+Run options:
+  --model <slug>         Model slug to use
+  --oss                  Use the built-in OSS provider
+  --sandbox <mode>       ${SANDBOX_CHOICES.join(" | ")}
+  --approval <policy>    ${APPROVAL_CHOICES.join(" | ")}
+  --schema <file>        Path to final-output JSON schema
+  --thread-id <id>       Resume an existing thread
+  --base-url <url>       Override the Codex API base URL
+  --api-key <key>        API key for Codex requests
+  --linux-sandbox-path   Path to codex-linux-sandbox binary
+  --full-auto            Enable workspace-write auto approvals
+  --skip-git-repo-check  Skip git repository validation
+  --cd <path>            Working directory for the run
+  --image <path>         Attach an image (repeatable)
+  --review-mode          Enable review mode
+  --review-hint <text>   Hint text for review mode
+
+TUI options:
+  --model <slug>         Model slug to use
+  --oss                  Use the built-in OSS provider
+  --sandbox <mode>       ${SANDBOX_CHOICES.join(" | ")}
+  --approval <policy>    ${APPROVAL_CHOICES.join(" | ")}
+  --resume <id>          Resume a saved session by id
+  --resume-last          Resume the most recent saved session
+  --resume-picker        Show the resume picker on startup
+  --full-auto            Enable workspace-write auto approvals
+  --dangerously-bypass-approvals-and-sandbox
+                        Disable approvals and sandboxing (unsafe)
+  --cd <path>            Working directory for the session
+  --config-profile <name> Config profile to activate
+  --config-overrides <kv> Config overrides (key=value, repeatable)
+  --add-dir <path>       Additional writable directory (repeatable)
+  --image <path>         Attach an image (repeatable)
+  --web-search           Enable web search tool
+  --linux-sandbox-path   Path to codex-linux-sandbox binary
+  --base-url <url>       Override the Codex API base URL
+  --api-key <key>        API key for Codex requests
+`);
+}
+function printCommandHelp(command) {
+  if (command === "reverie-index") {
+    console.log(`codex-native reverie index [options]
+
+Options:
+  --codex-home <path>     Override CODEX_HOME (defaults to ~/.codex)
+  --project-root <path>   Project root for scoping + embedding cache (default: cwd)
+  --limit <n>             Maximum conversations to index (default: 10)
+  --max-candidates <n>    Scan window before filtering (default: 80)
+  --batch-size <n>        Batch size forwarded to FastEmbed
+  --normalize             Force vector normalization (default: embed config)
+  --no-normalize          Disable normalization
+  --cache / --no-cache    Override embedding cache behavior
+  --embed-model <name>    FastEmbed model (default: BAAI/bge-large-en-v1.5)
+  --embed-cache-dir <dir> Cache directory (defaults to $CODEX_EMBED_CACHE or system tmp)
+  --embed-max-length <n>  Override FastEmbed max token length
+  --no-progress           Hide FastEmbed download progress
+  --skip-embed-init       Assume fastEmbedInit was already called in this process
+`);
+    return;
+  }
+  if (command === "tui") {
+    console.log(`codex-native tui [options] [prompt]
+
+Options:
+  --model <slug>         Model slug to use
+  --oss                  Use the built-in OSS provider
+  --sandbox <mode>       ${SANDBOX_CHOICES.join(" | ")}
+  --approval <policy>    ${APPROVAL_CHOICES.join(" | ")}
+  --resume <id>          Resume a saved session by id
+  --resume-last          Resume the most recent saved session
+  --resume-picker        Show the resume picker on startup
+  --full-auto            Enable workspace-write auto approvals
+  --dangerously-bypass-approvals-and-sandbox
+                        Disable approvals and sandboxing (unsafe)
+  --cd <path>            Working directory for the session
+  --config-profile <name> Config profile to activate
+  --config-overrides <kv> Config overrides (key=value, repeatable)
+  --add-dir <path>       Additional writable directory (repeatable)
+  --image <path>         Attach an image (repeatable)
+  --web-search           Enable web search tool
+  --linux-sandbox-path   Path to codex-linux-sandbox binary
+  --base-url <url>       Override the Codex API base URL
+  --api-key <key>        API key for Codex requests
+`);
+  } else {
+    console.log(`codex-native run [options] [prompt]
+
+Options:
+  --model <slug>         Model slug to use
+  --oss                  Use the built-in OSS provider
+  --sandbox <mode>       ${SANDBOX_CHOICES.join(" | ")}
+  --approval <policy>    ${APPROVAL_CHOICES.join(" | ")}
+  --schema <file>        Path to final-output JSON schema
+  --thread-id <id>       Resume an existing thread
+  --base-url <url>       Override the Codex API base URL
+  --api-key <key>        API key for Codex requests
+  --linux-sandbox-path   Path to codex-linux-sandbox binary
+  --full-auto            Enable workspace-write auto approvals
+  --skip-git-repo-check  Skip git repository validation
+  --cd <path>            Working directory for the run
+  --image <path>         Attach an image (repeatable)
+  --review-mode          Enable review mode
+  --review-hint <text>   Hint text for review mode
+`);
+  }
+}
+function validateOptionChoices(command, options) {
+  const sandbox = options.sandbox;
+  if (sandbox && !SANDBOX_CHOICES.includes(sandbox)) {
+    throw new Error(
+      `Invalid sandbox mode "${sandbox}". Valid modes: ${SANDBOX_CHOICES.join(", ")}.`
+    );
+  }
+  const approval = options.approval;
+  if (approval && !APPROVAL_CHOICES.includes(approval)) {
+    throw new Error(
+      `Invalid approval policy "${approval}". Valid policies: ${APPROVAL_CHOICES.join(", ")}.`
+    );
+  }
+}
+function logError(error) {
+  if (error instanceof Error) {
+    console.error(error.message);
+    if (import_node_process3.default.env.CODEX_NATIVE_DEBUG) {
+      console.error(error.stack);
+    }
+  } else {
+    console.error(String(error));
+  }
+}
+main().catch((error) => {
+  logError(error);
+  import_node_process3.default.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map