@koreanhole/opencodex 2.97.0 → 2.99.0

package/src/cli/index.ts

@@ -20,6 +20,7 @@ import { startServer } from "../server";
 import { loginClineAcp } from "../adapters/cli-agent/cline/acp";
 import { runCodingAgentMcpServer } from "../adapters/cli-agent/mcp-server";
 import { syncCodexCatalog } from "../lib/codex-catalog";
+import { injectCodexConfig, recordCodexCatalogState, restoreCodexConfig } from "../lib/codex-inject";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -61,7 +62,10 @@ function help(): string {
     "  provider list [--json]                 Show supported providers",
     "  start [--port <port>] [--host <host>] Start the proxy",
     "  status [--json]                        Check the running proxy",
-    "  stop [--json]                          Stop the running proxy",
+    "  stop [--json]                          Stop the proxy and restore native Codex",
+    "  restore [--json]                       Restore native Codex without stopping",
+    "  restore back [--json]                  Re-point Codex at the running proxy",
+    "  eject                                  Alias of restore",
     "  codex sync [--json]                    Refresh the Codex model catalog",
     "  version                                Print the package version",
     "  help                                   Show this help",
@@ -179,21 +183,27 @@ async function startCommand(args: string[]): Promise<number> {
     config.port = parsed;
   }
   if (host !== undefined) config.host = host;
+  const running = startServer(config, { env });
+  try {
+    await injectCodexConfig({ env, endpoint: { host: running.host, port: running.port }, config });
+  } catch (error) {
+    await running.stop(true).catch(() => undefined);
+    throw error;
+  }
   try {
     const catalog = await syncCodexCatalog({ env });
     if (catalog.ok && catalog.written) {
+      await recordCodexCatalogState(env).catch(error => {
+        console.warn(`[opencodex] Codex catalog state was not journaled: ${error instanceof Error ? error.message : String(error)}`);
+      });
       console.log(`Codex catalog refreshed: ${catalog.path}`);
       console.log("Restart the Codex app/app-server to reload the model picker.");
-      if (!catalog.configured) {
-        console.log(`Activate it with: model_catalog_json = "${catalog.path}"`);
-      }
     } else if (!catalog.ok) {
       console.warn(`[opencodex] Codex catalog was not refreshed: ${catalog.message}`);
     }
   } catch (error) {
     console.warn(`[opencodex] Codex catalog refresh failed: ${error instanceof Error ? error.message : String(error)}`);
   }
-  const running = startServer(config, { env });
   await writeRuntimeState({ pid: process.pid, port: running.port, host: running.host, startedAt: new Date().toISOString() }, env);
   console.log(`opencodex listening on http://${running.host}:${running.port}/v1 (default provider: ${config.defaultProvider})`);
   console.log(`Health: http://${running.host}:${running.port}/healthz`);
@@ -202,10 +212,22 @@ async function startCommand(args: string[]): Promise<number> {
     console.log(`\nStopping proxy (${signal})...`);
     await running.stop(true);
     await removeRuntimeStateIfPid(process.pid, env);
-    process.exit(0);
+    let exitCode = 0;
+    try {
+      const restored = await restoreCodexConfig({ env });
+      if (!restored.success) {
+        exitCode = 1;
+        console.error(`ocx: Codex restore did not complete: ${restored.catalog.message}`);
+      }
+    } catch (error) {
+      exitCode = 1;
+      console.error(`ocx: Codex restore failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    process.exit(exitCode);
   };
   process.once("SIGINT", () => void shutdown("SIGINT"));
   process.once("SIGTERM", () => void shutdown("SIGTERM"));
+  process.once("SIGHUP", () => void shutdown("SIGHUP"));
   await new Promise<never>(() => undefined);
   return 0;
 }
@@ -232,9 +254,42 @@ async function codexCommand(args: string[]): Promise<number> {
     }
     console.log("Codex reload required: restart the Codex app or app-server model picker.");
   }
+  if (result.ok) await recordCodexCatalogState(process.env).catch(() => undefined);
   return 0;
 }
 
+async function restoreCommand(args: string[]): Promise<number> {
+  const env = process.env;
+  const back = args[0] === "back";
+  if (back) args.shift();
+  const json = takeFlag(args, "--json");
+  const removeProviderTable = takeFlag(args, "--remove-codex-provider-table");
+  if (args.length > 0) throw new ConfigError(`Unknown restore option: ${args[0]}`);
+  let result;
+  if (back) {
+    const state = await readRuntimeState(env);
+    if (!state) throw new ConfigError("Proxy is not running; start it before `ocx restore back`.");
+    const config = await loadConfig(env);
+    if (!isAlive(state.pid) || !await health(state.host, state.port, config, env)) {
+      throw new ConfigError("The recorded proxy is not healthy; refusing to restore Codex routing.");
+    }
+    result = await injectCodexConfig({
+      env,
+      endpoint: { host: state.host, port: state.port },
+      config,
+    });
+    result = { ...result, action: "restore-back" as const };
+  } else {
+    result = await restoreCodexConfig({ env, removeProviderTable });
+  }
+  if (json) console.log(JSON.stringify(result));
+  else {
+    console.log(result.config.message);
+    console.log(result.catalog.message);
+  }
+  return result.success ? 0 : 1;
+}
+
 async function statusCommand(args: string[]): Promise<number> {
   const json = takeFlag(args, "--json");
   if (args.length > 0) throw new ConfigError(`Unknown status option: ${args[0]}`);
@@ -257,16 +312,24 @@ async function stopCommand(args: string[]): Promise<number> {
   if (args.length > 0) throw new ConfigError(`Unknown stop option: ${args[0]}`);
   const state = await readRuntimeState();
   if (!state) {
-    if (json) console.log(JSON.stringify({ stopped: false, reason: "not-running" }));
-    else console.log("Proxy is not running.");
+    const restored = await restoreCodexConfig({ env: process.env });
+    if (json) console.log(JSON.stringify({ stopped: false, reason: "not-running", restore: restored }));
+    else {
+      console.log("Proxy is not running.");
+      console.log(restored.config.message);
+    }
     return 1;
   }
   const config = await loadConfig();
   if (!isAlive(state.pid)) {
     await removeRuntimeStateIfPid(state.pid);
-    if (json) console.log(JSON.stringify({ stopped: true, stale: true }));
-    else console.log("Removed stale proxy state.");
-    return 0;
+    const restored = await restoreCodexConfig({ env: process.env });
+    if (json) console.log(JSON.stringify({ stopped: true, stale: true, restore: restored }));
+    else {
+      console.log("Removed stale proxy state.");
+      console.log(restored.config.message);
+    }
+    return restored.success ? 0 : 1;
   }
   if (!await health(state.host, state.port, config, process.env)) {
     throw new ConfigError(`Refusing to stop pid ${state.pid}: it is not the opencodex proxy recorded by this home.`);
@@ -276,9 +339,13 @@ async function stopCommand(args: string[]): Promise<number> {
   while (isAlive(state.pid) && Date.now() < deadline) await Bun.sleep(50);
   if (isAlive(state.pid)) process.kill(state.pid, "SIGKILL");
   await removeRuntimeStateIfPid(state.pid);
-  if (json) console.log(JSON.stringify({ stopped: true, pid: state.pid }));
-  else console.log(`Stopped proxy (pid ${state.pid}).`);
-  return 0;
+  const restored = await restoreCodexConfig({ env: process.env });
+  if (json) console.log(JSON.stringify({ stopped: true, pid: state.pid, restore: restored }));
+  else {
+    console.log(`Stopped proxy (pid ${state.pid}).`);
+    console.log(restored.config.message);
+  }
+  return restored.success ? 0 : 1;
 }
 
 async function main(argv: string[]): Promise<number> {
@@ -301,7 +368,8 @@ async function main(argv: string[]): Promise<number> {
   if (command === "start") return await startCommand(argv);
   if (command === "status") return await statusCommand(argv);
   if (command === "stop") return await stopCommand(argv);
-  throw new ConfigError(`Unknown command: ${command}. Expected login, provider, codex, start, status, stop, version, or help.`);
+  if (command === "restore" || command === "eject") return await restoreCommand(argv);
+  throw new ConfigError(`Unknown command: ${command}. Expected login, provider, codex, start, status, stop, restore, eject, version, or help.`);
 }
 
 try {

package/src/lib/codex-catalog.ts

@@ -7,6 +7,7 @@ import { discoverGeminiLiveModels } from "../adapters/cli-agent/gemini/live-mode
 import type { ClineTurnDeps } from "../adapters/cli-agent/cline/adapter";
 import type { GeminiTurnDeps } from "../adapters/cli-agent/gemini/adapter";
 
+// Cline ACP descriptors expose no context source; this fallback is Cline-only.
 const CATALOG_FALLBACK_CONTEXT = 128_000;
 const BASE_INSTRUCTIONS = "You are a helpful coding assistant.";
 const MANAGED_PREFIXES = ["cline-cli/", "gemini-cli/"] as const;
@@ -28,7 +29,7 @@ export interface CodexCatalogModel {
   context_window: number;
   max_context_window: number;
   auto_compact_token_limit: number;
-  input_modalities: ["text"];
+  input_modalities: Array<"text" | "image" | "audio">;
   node_repl_disabled: false;
   node_repl_auto_review_required: false;
   include_plugin_usage_instructions: false;
@@ -36,14 +37,14 @@ export interface CodexCatalogModel {
   include_skills_usage_instructions: false;
   supports_reasoning_summaries: boolean;
   default_reasoning_summary: string;
-  support_verbosity: true;
+  support_verbosity: boolean;
   default_verbosity: "low";
   apply_patch_tool_type: "freeform";
   truncation_policy: { mode: "tokens"; limit: number };
   supports_parallel_tool_calls: true;
   supports_image_detail_original: false;
   experimental_supported_tools: [];
-  effective_context_window_percent: 95;
+  effective_context_window_percent: number;
   comp_hash: null;
   multi_agent_version: "v1";
   auto_review_model_override: null;
@@ -115,6 +116,19 @@ export function buildCodexCatalogModel(providerId: "cline-cli" | "gemini-cli", m
   const defaultLevel = model.defaultReasoningLevel ?? levels[0]?.effort ?? "low";
   const isDefault = model.id === "default";
   const providerLabel = providerId === "gemini-cli" ? "Gemini CLI" : "Cline CLI";
+  const contextWindow = model.contextWindowTokens ?? (providerId === "cline-cli" ? CATALOG_FALLBACK_CONTEXT : undefined);
+  if (contextWindow === undefined) {
+    throw new Error(`Gemini model "${model.id}" has no runtime context window.`);
+  }
+  const deterministicThreshold = providerId === "gemini-cli"
+    ? model.compressionThreshold
+    : model.compressionThreshold ?? 0.9;
+  const compactLimit = deterministicThreshold !== undefined
+    ? Math.max(1, Math.floor(contextWindow * deterministicThreshold))
+    : contextWindow;
+  const effectivePercent = deterministicThreshold !== undefined
+    ? Math.max(1, Math.min(100, Math.round(deterministicThreshold * 100)))
+    : 100;
   return {
     slug: `${providerId}/${encodeRoutedId(model.id)}`,
     display_name: model.name ?? (isDefault ? `${providerLabel} default` : model.id),
@@ -129,10 +143,10 @@ export function buildCodexCatalogModel(providerId: "cline-cli" | "gemini-cli", m
     web_search_tool_type: "text_and_image",
     supports_search_tool: false,
     tool_mode: "code_mode_only",
-    context_window: CATALOG_FALLBACK_CONTEXT,
-    max_context_window: CATALOG_FALLBACK_CONTEXT,
-    auto_compact_token_limit: Math.floor(CATALOG_FALLBACK_CONTEXT * 0.9),
-    input_modalities: ["text"],
+    context_window: contextWindow,
+    max_context_window: model.maxContextWindowTokens ?? contextWindow,
+    auto_compact_token_limit: compactLimit,
+    input_modalities: [...(model.inputModalities ?? ["text"])],
     node_repl_disabled: false,
     node_repl_auto_review_required: false,
     include_plugin_usage_instructions: false,
@@ -140,14 +154,14 @@ export function buildCodexCatalogModel(providerId: "cline-cli" | "gemini-cli", m
     include_skills_usage_instructions: false,
     supports_reasoning_summaries: levels.length > 0,
     default_reasoning_summary: levels.length > 0 ? "auto" : "none",
-    support_verbosity: true,
+    support_verbosity: false,
     default_verbosity: "low",
     apply_patch_tool_type: "freeform",
     truncation_policy: { mode: "tokens", limit: 10_000 },
     supports_parallel_tool_calls: true,
     supports_image_detail_original: false,
     experimental_supported_tools: [],
-    effective_context_window_percent: 95,
+    effective_context_window_percent: effectivePercent,
     comp_hash: null,
     multi_agent_version: "v1",
     auto_review_model_override: null,
@@ -194,11 +208,30 @@ export async function discoverCodexCatalogModels(options: CodexCatalogDiscoveryO
   if (gemini.ok && gemini.metadataWarning) warnings.push(`Gemini metadata: ${gemini.metadataWarning}`);
   const clineModels = normalizedModels(cline.ok ? cline.models.map(id => ({ id })) : []);
   const geminiModels = normalizedModels(gemini.ok ? gemini.modelInfo : []);
+  const geminiDefault = geminiModels.find(model => model.id === "default");
+  const geminiContexts = geminiModels.flatMap(model => model.contextWindowTokens !== undefined ? [model.contextWindowTokens] : []);
+  if (geminiDefault && geminiContexts.length > 0) {
+    const conservative = Math.min(...geminiContexts);
+    geminiDefault.contextWindowTokens = conservative;
+    geminiDefault.maxContextWindowTokens = conservative;
+    geminiDefault.compressionThreshold = geminiModels.find(model => model.compressionThreshold !== undefined)?.compressionThreshold;
+    const modalities = geminiModels.flatMap(model => model.inputModalities ?? []);
+    geminiDefault.inputModalities = [...new Set(modalities.length > 0 ? modalities : ["text" as const])]
+      .filter((value): value is "text" | "image" | "audio" => value === "text" || value === "image" || value === "audio");
+  }
+  const models: CodexCatalogModel[] = [];
+  for (const model of clineModels) {
+    models.push(buildCodexCatalogModel("cline-cli", model, models.length));
+  }
+  for (const model of geminiModels) {
+    if (model.contextWindowTokens === undefined) {
+      warnings.push(`Gemini model "${model.id}" has no runtime context window; omitted from the Codex catalog.`);
+      continue;
+    }
+    models.push(buildCodexCatalogModel("gemini-cli", model, models.length));
+  }
   return {
-    models: [
-      ...clineModels.map((model, index) => buildCodexCatalogModel("cline-cli", model, index)),
-      ...geminiModels.map((model, index) => buildCodexCatalogModel("gemini-cli", model, clineModels.length + index)),
-    ],
+    models,
     warnings,
   };
 }
@@ -224,6 +257,67 @@ function readRootTomlString(text: string, key: string): string | undefined {
   return match?.[1]?.trim() || undefined;
 }
 
+export function codexHome(env: NodeJS.ProcessEnv = process.env): string {
+  return env.CODEX_HOME?.trim() || join(env.HOME?.trim() || homedir(), ".codex");
+}
+
+/** Resolve the catalog only when opencodex is allowed to manage that file. */
+export async function resolveCodexCatalogPath(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<string | undefined> {
+  const home = codexHome(env);
+  let configured: string | undefined;
+  try {
+    configured = readRootTomlString(await readFile(join(home, "config.toml"), "utf8"), "model_catalog_json");
+  } catch {
+    configured = undefined;
+  }
+  if (configured && basename(configured) !== "opencodex-catalog.json") return undefined;
+  return configured ? resolve(home, configured) : join(home, "opencodex-catalog.json");
+}
+
+export function isManagedCodexCatalogSlug(slug: unknown): boolean {
+  return managedSlug(slug);
+}
+
+/** Remove only opencodex-routed rows; preserve native/user rows. */
+export async function removeManagedCodexCatalogRows(path: string): Promise<{
+  changed: boolean;
+  removed: number;
+  message: string;
+}> {
+  let raw: string;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return { changed: false, removed: 0, message: "No opencodex catalog file was present." };
+    }
+    throw error;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    const value = asRecord(JSON.parse(raw));
+    if (!value) throw new Error("catalog is not an object");
+    parsed = value;
+  } catch {
+    throw new Error("The opencodex catalog is malformed; it was preserved.");
+  }
+  const models = Array.isArray(parsed.models) ? parsed.models : undefined;
+  if (!models || models.some(model => !asRecord(model))) {
+    throw new Error("The opencodex catalog has an invalid models field; it was preserved.");
+  }
+  const kept = models.filter(model => !managedSlug(asRecord(model)?.slug));
+  const removed = models.length - kept.length;
+  if (removed === 0) return { changed: false, removed: 0, message: "No managed catalog rows were present." };
+  if (kept.length === 0 && basename(path) === "opencodex-catalog.json") {
+    await rm(path, { force: true });
+    return { changed: true, removed, message: `Removed ${removed} managed catalog row(s) and the empty opencodex catalog.` };
+  }
+  await writeCodexCatalog(path, { ...parsed, models: kept } as CodexCatalogDocument);
+  return { changed: true, removed, message: `Removed ${removed} managed catalog row(s) from ${path}.` };
+}
+
 export async function writeCodexCatalog(
   path: string,
   document: CodexCatalogDocument,