@codex-native/sdk 0.0.1 → 0.0.2

package/dist/cli.mjs

@@ -0,0 +1,1658 @@
+#!/usr/bin/env node
+import {
+  Codex,
+  attachLspDiagnostics,
+  convertRustEventToThreadEvent,
+  fastEmbedInit,
+  getNativeBinding,
+  reverieIndexSemantic,
+  runApplyPatch
+} from "./chunk-ZTUGAPWF.mjs";
+
+// src/cli/index.ts
+import process4 from "process";
+import { parseArgs as parseArgs2 } from "util";
+import { fileURLToPath } from "url";
+
+// package.json
+var package_default = {
+  name: "@codex-native/sdk",
+  version: "0.0.2",
+  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"
+  ],
+  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');if(!hasNode||!hasDist){console.error('Build incomplete: missing .node or dist files');process.exit(1)}console.log('\u2713 Build verification passed')"`,
+    "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 publish:platforms && node scripts/publish-sdk.mjs",
+    "release:dry": "npm run build && npm run test && 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.2",
+    "@codex-native/sdk-darwin-x64": "0.0.2",
+    "@codex-native/sdk-linux-arm64-gnu": "0.0.2",
+    "@codex-native/sdk-linux-arm64-musl": "0.0.2",
+    "@codex-native/sdk-linux-x64-gnu": "0.0.2",
+    "@codex-native/sdk-linux-x64-musl": "0.0.2",
+    "@codex-native/sdk-win32-arm64-msvc": "0.0.2",
+    "@codex-native/sdk-win32-x64-msvc": "0.0.2"
+  },
+  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
+import fs from "fs";
+import fsPromises from "fs/promises";
+import path from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+var requireFromThisModule = createRequire(import.meta.url);
+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 = path.resolve(options.cwd, options.explicitConfigPath);
+    if (!fs.existsSync(explicitPath)) {
+      throw new Error(`Config file not found at ${explicitPath}`);
+    }
+    return classifyPath(explicitPath);
+  }
+  if (options.noConfig) {
+    return null;
+  }
+  let currentDir = path.resolve(options.cwd);
+  const visited = /* @__PURE__ */ new Set();
+  while (!visited.has(currentDir)) {
+    visited.add(currentDir);
+    for (const candidate of CONFIG_CANDIDATES) {
+      const candidatePath = path.join(currentDir, candidate);
+      if (fs.existsSync(candidatePath) && fs.statSync(candidatePath).isFile()) {
+        return classifyPath(candidatePath);
+      }
+    }
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).isFile()) {
+      const manifest = await readJson(packageJsonPath);
+      if (manifest && manifest.codexNative != null) {
+        return { path: packageJsonPath, type: "package-json", field: "codexNative" };
+      }
+    }
+    const parentDir = path.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 = path.dirname(discovery.path);
+      const nestedPath = path.resolve(baseDir, raw);
+      if (!fs.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 = path.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 ? path.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 = path.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 = 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 fsPromises.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractModuleDefault(module) {
+  if (module && typeof module === "object" && "default" in module) {
+    const value = module.default;
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return module;
+}
+function resolveModule(specifier, baseDir) {
+  if (path.isAbsolute(specifier)) {
+    return specifier;
+  }
+  return requireFromThisModule.resolve(specifier, { paths: [baseDir] });
+}
+function classifyPath(filePath) {
+  if (path.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
+import fs2 from "fs";
+import fsPromises2 from "fs/promises";
+import path3 from "path";
+import process2 from "process";
+
+// 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
+import path2 from "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 = path2.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 path2.resolve(cwd);
+  }
+  return path2.isAbsolute(candidate) ? candidate : path2.resolve(cwd, candidate);
+}
+
+// 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;
+    }
+    process2.stdout.write(eventJson);
+    process2.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) {
+    process2.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 (process2.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 = path3.resolve(process2.cwd(), filePath);
+  const data = await fsPromises2.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 (process2.stdin.isTTY) {
+    return null;
+  }
+  const chunks = [];
+  for await (const chunk of process2.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 ? path3.resolve(workingDirectory) : process2.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 = path3.resolve(startDir);
+  while (true) {
+    const gitPath = path3.join(current, ".git");
+    if (fs2.existsSync(gitPath)) {
+      try {
+        const stats = await fsPromises2.stat(gitPath);
+        if (stats.isDirectory() || stats.isFile()) {
+          return current;
+        }
+      } catch {
+      }
+    }
+    const parent = path3.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((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+
+// src/cli/tui.ts
+import process3 from "process";
+async function executeTuiCommand(argv, context) {
+  if (!process3.stdout.isTTY || !process3.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) {
+    process3.stdout.write(`
+Conversation ID: ${exitInfo.conversationId}
+`);
+  }
+  if (exitInfo.updateAction) {
+    process3.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
+import path4 from "path";
+import os from "os";
+import { parseArgs } from "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 } = 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 ? path4.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 path4.resolve(explicit);
+  }
+  if (process.env.CODEX_HOME) {
+    return process.env.CODEX_HOME;
+  }
+  const home = os.homedir() || process.cwd();
+  return path4.join(home, ".codex");
+}
+function resolveProjectRoot(explicit) {
+  if (explicit) {
+    return path4.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 path4.resolve(process.env.CODEX_EMBED_CACHE);
+  }
+  return path4.join(os.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_ENV = "CODEX_NODE_CLI_ENTRYPOINT";
+try {
+  const entrypoint = fileURLToPath(import.meta.url);
+  process4.env[CLI_ENTRYPOINT_ENV] = entrypoint;
+} catch {
+  if (process4.argv[1]) {
+    process4.env[CLI_ENTRYPOINT_ENV] = process4.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 = process4.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.`);
+    process4.exitCode = 1;
+    return true;
+  }
+  try {
+    runApplyPatch(patch);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`apply_patch failed: ${message}`);
+    process4.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 = process4.stdout.isTTY && process4.stdin.isTTY;
+    return { command: isInteractive2 ? "tui" : "run", args: [] };
+  }
+  const isInteractive = process4.stdout.isTTY && process4.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 } = parseArgs2({
+    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 } = parseArgs2({
+    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 = process4.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 (process4.env.CODEX_NATIVE_DEBUG) {
+      console.error(error.stack);
+    }
+  } else {
+    console.error(String(error));
+  }
+}
+main().catch((error) => {
+  logError(error);
+  process4.exitCode = 1;
+});
+//# sourceMappingURL=cli.mjs.map