@koreanhole/opencodex 2.95.10 → 2.97.0

package/src/adapters/cli-agent/gemini/model-metadata.ts

@@ -0,0 +1,291 @@
+import { readFile, readdir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import type { OcxProviderModel, OcxReasoningLevel } from "../../../types";
+
+const DEFAULT_METADATA_TTL_MS = 5 * 60_000;
+
+export interface GeminiThinkingConfig {
+  thinkingLevel?: string;
+  thinkingBudget?: number;
+  includeThoughts?: boolean;
+}
+
+export interface GeminiReasoningLevel extends OcxReasoningLevel {
+  thinkingConfig: GeminiThinkingConfig;
+  originalEffort: string;
+}
+
+export interface GeminiModelCapability {
+  thinkingSupported: boolean;
+  reasoningLevels: GeminiReasoningLevel[];
+  defaultReasoningLevel?: string;
+}
+
+export interface GeminiMetadataResult {
+  packageRoot?: string;
+  settingsPath?: string;
+  capabilities: Record<string, GeminiModelCapability>;
+  warning?: string;
+}
+
+export interface GeminiMetadataOptions {
+  binary: string;
+  env?: NodeJS.ProcessEnv;
+  packageRoot?: string;
+  ttlMs?: number;
+  now?: () => number;
+}
+
+interface CachedMetadata extends GeminiMetadataResult {
+  fetchedAt: number;
+}
+
+const metadataCache = new Map<string, CachedMetadata>();
+
+export function resetGeminiMetadataCacheForTests(): void {
+  metadataCache.clear();
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function extractDefaultJsonValue(markdown: string, property: string): unknown {
+  const marker = `- **\`modelConfigs.${property}\`**`;
+  const start = markdown.indexOf(marker);
+  if (start < 0) return undefined;
+  const fenceStart = markdown.indexOf("```json", start);
+  if (fenceStart < 0) return undefined;
+  const bodyStart = markdown.indexOf("\n", fenceStart) + 1;
+  const fenceEnd = markdown.indexOf("```", bodyStart);
+  if (bodyStart <= 0 || fenceEnd < 0) return undefined;
+  try {
+    return JSON.parse(markdown.slice(bodyStart, fenceEnd).trim()) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function extractDefaultJson(markdown: string, property: string): Record<string, unknown> | undefined {
+  return asRecord(extractDefaultJsonValue(markdown, property));
+}
+
+async function findPackageRoot(binary: string): Promise<string | undefined> {
+  let current: string;
+  try {
+    current = dirname(await realpath(binary));
+  } catch {
+    current = dirname(resolve(binary));
+  }
+  for (let depth = 0; depth < 10; depth++) {
+    try {
+      const manifest = JSON.parse(await readFile(join(current, "package.json"), "utf8")) as { name?: unknown };
+      if (manifest.name === "@google/gemini-cli") return current;
+    } catch {
+      // Keep walking toward the package root.
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return undefined;
+}
+
+async function readThinkingLevels(packageRoot: string): Promise<Array<{ effort: string; original: string }>> {
+  let files: string[];
+  try {
+    files = (await readdir(join(packageRoot, "bundle"))).filter(name => name.endsWith(".js"));
+  } catch {
+    return [];
+  }
+  const candidates = await Promise.all(files.map(async name => {
+    const path = join(packageRoot, "bundle", name);
+    const info = await stat(path).catch(() => undefined);
+    return info ? { path, size: info.size } : undefined;
+  }));
+  candidates.sort((left, right) => (left?.size ?? Infinity) - (right?.size ?? Infinity));
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const text = await readFile(candidate.path, "utf8").catch(() => "");
+    if (!text.includes("ThinkingLevel2[\"LOW\"]")) continue;
+    const levels = [...text.matchAll(/ThinkingLevel2\["([A-Z0-9_]+)"\]/g)]
+      .map(match => match[1]!)
+      .filter(level => level !== "THINKING_LEVEL_UNSPECIFIED");
+    return [...new Set(levels)].map(level => ({ effort: level.toLowerCase(), original: level }));
+  }
+  return [];
+}
+
+function mergeConfig(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown> {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    const targetRecord = asRecord(out[key]);
+    const sourceRecord = asRecord(value);
+    out[key] = targetRecord && sourceRecord ? mergeConfig(targetRecord, sourceRecord) : value;
+  }
+  return out;
+}
+
+function resolveAlias(
+  id: string,
+  aliases: Record<string, unknown>,
+  seen = new Set<string>(),
+): Record<string, unknown> {
+  if (seen.has(id)) return {};
+  seen.add(id);
+  const alias = asRecord(aliases[id]);
+  if (!alias) return {};
+  const parent = stringValue(alias.extends);
+  const inherited = parent ? resolveAlias(parent, aliases, seen) : {};
+  return mergeConfig(inherited, asRecord(alias.modelConfig) ?? {});
+}
+
+function capabilitiesFromMetadata(
+  definitions: Record<string, unknown>,
+  aliases: Record<string, unknown>,
+  levels: Array<{ effort: string; original: string }>,
+  overrides: readonly unknown[],
+): Record<string, GeminiModelCapability> {
+  const capabilities: Record<string, GeminiModelCapability> = {};
+  for (const [modelId, rawDefinition] of Object.entries(definitions)) {
+    const definition = asRecord(rawDefinition);
+    const features = asRecord(definition?.features);
+    const thinkingSupported = features?.thinking === true;
+    if (!thinkingSupported) {
+      capabilities[modelId] = { thinkingSupported: false, reasoningLevels: [] };
+      continue;
+    }
+    let generateContentConfig = asRecord(resolveAlias(modelId, aliases).generateContentConfig) ?? {};
+    for (const rawOverride of overrides) {
+      const override = asRecord(rawOverride);
+      if (stringValue(asRecord(override?.match)?.model) !== modelId) continue;
+      generateContentConfig = mergeConfig(generateContentConfig, asRecord(asRecord(override?.modelConfig)?.generateContentConfig) ?? {});
+    }
+    const config = asRecord(generateContentConfig.thinkingConfig);
+    const configuredLevel = stringValue(config?.thinkingLevel)?.toLowerCase();
+    const includeThoughts = config?.includeThoughts === true;
+    const reasoningLevels = levels.map(level => ({
+      effort: level.effort,
+      originalEffort: level.original,
+      description: `Gemini CLI ${level.original} thinking level`,
+      thinkingConfig: {
+        thinkingLevel: level.original,
+        ...(includeThoughts ? { includeThoughts: true } : {}),
+      },
+    }));
+    const defaultReasoningLevel = reasoningLevels.some(level => level.effort === configuredLevel)
+      ? configuredLevel
+      : reasoningLevels.find(level => level.effort === "high")?.effort ?? reasoningLevels[0]?.effort;
+    capabilities[modelId] = {
+      thinkingSupported: true,
+      reasoningLevels,
+      ...(defaultReasoningLevel ? { defaultReasoningLevel } : {}),
+    };
+  }
+  return capabilities;
+}
+
+async function loadMetadata(options: GeminiMetadataOptions): Promise<GeminiMetadataResult> {
+  const env = options.env ?? process.env;
+  const packageRoot = options.packageRoot ?? await findPackageRoot(options.binary);
+  if (!packageRoot) return { capabilities: {}, warning: "Gemini CLI package metadata was not found." };
+  const docsPath = join(packageRoot, "bundle", "docs", "reference", "configuration.md");
+  let markdown: string;
+  try {
+    markdown = await readFile(docsPath, "utf8");
+  } catch {
+    return { packageRoot, capabilities: {}, warning: "Gemini CLI model configuration documentation was not found." };
+  }
+  const defaultAliases = extractDefaultJson(markdown, "aliases");
+  const defaultDefinitions = extractDefaultJson(markdown, "modelDefinitions");
+  const defaultOverrides = extractDefaultJsonValue(markdown, "overrides");
+  if (!defaultAliases || !defaultDefinitions) {
+    return { packageRoot, capabilities: {}, warning: "Gemini CLI model configuration metadata could not be parsed." };
+  }
+
+  const home = stringValue(env.GEMINI_CLI_HOME) ?? stringValue(env.HOME) ?? stringValue(env.USERPROFILE) ?? homedir();
+  const settingsPath = join(home, ".gemini", "settings.json");
+  let userSettings: Record<string, unknown> = {};
+  try {
+    userSettings = asRecord(JSON.parse(await readFile(settingsPath, "utf8"))) ?? {};
+  } catch {
+    // User settings are optional; absence is not a metadata failure.
+  }
+  const modelConfigs = asRecord(userSettings.modelConfigs) ?? {};
+  const aliases = mergeConfig(
+    mergeConfig(defaultAliases, asRecord(modelConfigs.customAliases) ?? {}),
+    asRecord(modelConfigs.aliases) ?? {},
+  );
+  const definitions = mergeConfig(defaultDefinitions, asRecord(modelConfigs.modelDefinitions) ?? {});
+  const overrides = [
+    ...(Array.isArray(defaultOverrides) ? defaultOverrides : []),
+    ...(Array.isArray(modelConfigs.overrides) ? modelConfigs.overrides : []),
+    ...(Array.isArray(modelConfigs.customOverrides) ? modelConfigs.customOverrides : []),
+  ];
+  const levels = await readThinkingLevels(packageRoot);
+  if (levels.length === 0) {
+    return { packageRoot, settingsPath, capabilities: {}, warning: "Gemini CLI thinking-level metadata was not found." };
+  }
+  return {
+    packageRoot,
+    settingsPath,
+    capabilities: capabilitiesFromMetadata(definitions, aliases, levels, overrides),
+  };
+}
+
+export async function discoverGeminiModelMetadata(options: GeminiMetadataOptions): Promise<GeminiMetadataResult> {
+  const env = options.env ?? process.env;
+  const key = [
+    options.packageRoot ?? "auto",
+    resolve(options.binary),
+    stringValue(env.GEMINI_CLI_HOME) ?? stringValue(env.HOME) ?? stringValue(env.USERPROFILE) ?? homedir(),
+  ].join("\n");
+  const now = options.now ?? Date.now;
+  const ttlMs = options.ttlMs ?? DEFAULT_METADATA_TTL_MS;
+  const cached = metadataCache.get(key);
+  if (cached && now() - cached.fetchedAt < ttlMs) return cached;
+  const result = await loadMetadata(options);
+  const entry: CachedMetadata = { ...result, fetchedAt: now() };
+  metadataCache.set(key, entry);
+  return entry;
+}
+
+export function mergeGeminiModelDescriptors(
+  advertised: readonly { modelId: string; name?: string; description?: string }[],
+  metadata: GeminiMetadataResult,
+): OcxProviderModel[] {
+  return advertised.map(model => {
+    const capability = metadata.capabilities[model.modelId];
+    const reasoningLevels = capability?.reasoningLevels.map(level => ({
+      effort: level.effort,
+      description: level.description,
+    })) ?? [];
+    return {
+      id: model.modelId,
+      ...(model.name ? { name: model.name } : {}),
+      ...(model.description ? { description: model.description } : {}),
+      supportedReasoningLevels: reasoningLevels,
+      ...(capability?.defaultReasoningLevel ? { defaultReasoningLevel: capability.defaultReasoningLevel } : {}),
+    };
+  });
+}
+
+export function reasoningLevelForEffort(
+  capability: GeminiModelCapability | undefined,
+  effort: string | undefined,
+): GeminiReasoningLevel | undefined {
+  if (!capability?.thinkingSupported || capability.reasoningLevels.length === 0) return undefined;
+  const wanted = effort?.trim().toLowerCase();
+  if (!wanted) {
+    return capability.reasoningLevels.find(level => level.effort === capability.defaultReasoningLevel)
+      ?? capability.reasoningLevels[0];
+  }
+  return capability.reasoningLevels.find(level => level.effort === wanted);
+}

package/src/adapters/cli-agent/mcp-server.ts

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { appendFile, readFile } from "node:fs/promises";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -9,21 +9,46 @@ export interface CodingAgentMcpTool {
   inputSchema: Record<string, unknown>;
 }
 
-export async function serveCodingAgentMcpTools(tools: CodingAgentMcpTool[], serverName: string): Promise<void> {
+const MAX_CAPTURE_CALLS = 16;
+const MAX_CAPTURE_ARGUMENT_BYTES = 2 * 1024 * 1024;
+
+export async function serveCodingAgentMcpTools(
+  tools: CodingAgentMcpTool[],
+  serverName: string,
+  capturePath?: string,
+): Promise<void> {
   const exitOnStdinClose = (): void => process.exit(0);
   process.stdin.on("end", exitOnStdinClose);
   process.stdin.on("close", exitOnStdinClose);
   const names = new Set(tools.map(tool => tool.name));
   const server = new Server({ name: serverName, version: "1.0.0" }, { capabilities: { tools: {} } });
+  let capturedCalls = 0;
   server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
   server.setRequestHandler(CallToolRequestSchema, async request => {
     if (!names.has(request.params.name)) throw new Error("unknown isolated tool");
+    if (capturePath) {
+      if (++capturedCalls > MAX_CAPTURE_CALLS) throw new Error("isolated tool capture limit exceeded");
+      const argumentsValue = request.params.arguments ?? {};
+      const serialized = JSON.stringify(argumentsValue);
+      if (Buffer.byteLength(serialized) > MAX_CAPTURE_ARGUMENT_BYTES) {
+        throw new Error("isolated tool arguments exceed the capture limit");
+      }
+      await appendFile(capturePath, `${JSON.stringify({
+        id: `gemini-tool-${crypto.randomUUID()}`,
+        name: request.params.name,
+        arguments: argumentsValue,
+      })}\n`, { encoding: "utf8", mode: 0o600 });
+    }
     return new Promise<never>(() => undefined);
   });
   await server.connect(new StdioServerTransport());
 }
 
-export async function runCodingAgentMcpServer(catalogPath: string): Promise<void> {
+export async function runCodingAgentMcpServer(catalogPath: string, capturePath?: string): Promise<void> {
   const tools = JSON.parse(await readFile(catalogPath, "utf8")) as CodingAgentMcpTool[];
-  await serveCodingAgentMcpTools(tools, "opencodex-coding-agent-tools");
+  await serveCodingAgentMcpTools(tools, "opencodex-coding-agent-tools", capturePath);
+}
+
+if (import.meta.main) {
+  await runCodingAgentMcpServer(process.argv[2] ?? "", process.argv[3]);
 }

package/src/adapters/cli-agent/tool-intent.ts

@@ -0,0 +1,71 @@
+import { Buffer } from "node:buffer";
+import type { AdapterEvent } from "../../types";
+import type { CliAgentStreamState } from "./types";
+
+const MAX_TOOL_ARGUMENT_BYTES = 2 * 1024 * 1024;
+
+export class ToolIntentError extends Error {
+  readonly code = "cli_protocol_error";
+  readonly status = 502;
+
+  constructor(message: string) {
+    super(message);
+    this.name = "ToolIntentError";
+  }
+}
+
+export interface ToolIntentOptions {
+  toolNames: ReadonlyMap<string, string>;
+  maxToolCalls?: number;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function toolArguments(input: unknown, label: string): string {
+  let value = input;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      throw new ToolIntentError(`${label} returned a tool call with invalid JSON arguments.`);
+    }
+  }
+  const record = asRecord(value ?? {});
+  if (!record) throw new ToolIntentError(`${label} returned non-object tool arguments.`);
+  const serialized = JSON.stringify(record);
+  if (Buffer.byteLength(serialized) > MAX_TOOL_ARGUMENT_BYTES) {
+    throw new ToolIntentError(`${label} returned tool arguments above the byte limit.`);
+  }
+  return serialized;
+}
+
+/** Convert one validated vendor tool request into events owned by Codex. */
+export function mapToolIntent(
+  label: string,
+  vendorName: string,
+  toolCallId: string | undefined,
+  input: unknown,
+  state: CliAgentStreamState,
+  options: ToolIntentOptions,
+): AdapterEvent[] {
+  if (!vendorName) throw new ToolIntentError(`${label} returned a tool call without a name.`);
+  const wireName = options.toolNames.get(vendorName);
+  if (!wireName) throw new ToolIntentError(`${label} returned an undeclared tool: ${vendorName.slice(0, 128)}`);
+  const maxToolCalls = options.maxToolCalls ?? 16;
+  if (state.toolCalls >= maxToolCalls) {
+    throw new ToolIntentError(`${label} exceeded the per-turn tool-call limit.`);
+  }
+  const ordinal = ++state.nextToolOrdinal;
+  const id = toolCallId?.trim() || `${label.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-")}-tool-${ordinal}`;
+  const argumentsJson = toolArguments(input, label);
+  state.toolCalls++;
+  return [
+    { type: "tool_call_start", id, name: wireName },
+    { type: "tool_call_delta", arguments: argumentsJson },
+    { type: "tool_call_end" },
+  ];
+}

package/src/cli/index.ts

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   CLINE_PROVIDER_ID,
+  GEMINI_PROVIDER_ID,
   ConfigError,
   apiToken,
   defaultConfig,
@@ -13,10 +14,12 @@ import {
   removeRuntimeStateIfPid,
   saveConfig,
   writeRuntimeState,
+  type ProviderId,
 } from "../config";
 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";
 
 const here = dirname(fileURLToPath(import.meta.url));
 
@@ -47,20 +50,24 @@ async function version(): Promise<string> {
 
 function help(): string {
   return [
-    "opencodex Cline-only proxy",
+    "opencodex local CLI proxy",
     "",
     "Usage: ocx <command>",
     "",
     "Commands:",
     "  login cline-cli [--json] [--no-wait]   Authenticate the local Cline CLI",
-    "  provider add cline-cli [--set-default] Configure the Cline CLI transport",
-    "  provider use cline-cli                 Select Cline CLI as the default provider",
-    "  provider list [--json]                 Show the supported provider",
+    "  provider add <provider> [--set-default] Configure a CLI transport",
+    "  provider use <provider>                Select the default provider",
+    "  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",
+    "  codex sync [--json]                    Refresh the Codex model catalog",
     "  version                                Print the package version",
     "  help                                   Show this help",
+    "",
+    "Providers: cline-cli, gemini-cli",
+    "Gemini authentication is managed by Gemini CLI (`gemini` or GEMINI_API_KEY).",
   ].join("\n");
 }
 
@@ -88,7 +95,7 @@ async function health(host: string, port: number, config: Awaited<ReturnType<typ
     });
     if (!response.ok) return false;
     const body = await response.json() as { service?: string; ok?: boolean };
-    return body.ok === true && body.service === "opencodex-cline";
+    return body.ok === true && body.service === "opencodex";
   } catch {
     return false;
   }
@@ -100,31 +107,46 @@ async function providerCommand(args: string[]): Promise<number> {
   if (sub === "list") {
     const json = takeFlag(args, "--json");
     if (args.length > 0) throw new ConfigError(`Unknown provider list option: ${args[0]}`);
-    if (json) console.log(JSON.stringify({ defaultProvider: CLINE_PROVIDER_ID, providers: config.providers }, null, 2));
-    else console.log(`${CLINE_PROVIDER_ID}${config.defaultProvider === CLINE_PROVIDER_ID ? " (default)" : ""}`);
+    if (json) console.log(JSON.stringify({ defaultProvider: config.defaultProvider, providers: config.providers }, null, 2));
+    else {
+      for (const id of [CLINE_PROVIDER_ID, GEMINI_PROVIDER_ID]) {
+        console.log(`${id}${config.defaultProvider === id ? " (default)" : ""}`);
+      }
+    }
     return 0;
   }
   if (sub === "add") {
-    if (args.shift() !== CLINE_PROVIDER_ID) throw new ConfigError("Only `provider add cline-cli` is supported.");
+    const requested = args.shift();
+    if (requested !== CLINE_PROVIDER_ID && requested !== GEMINI_PROVIDER_ID) {
+      throw new ConfigError("Only `provider add cline-cli` or `provider add gemini-cli` is supported.");
+    }
+    const id = requested as ProviderId;
     const setDefault = takeFlag(args, "--set-default");
     if (args.length > 0) throw new ConfigError(`Unknown provider add option: ${args[0]}`);
-    const next = { ...config, providers: { [CLINE_PROVIDER_ID]: defaultConfig().providers[CLINE_PROVIDER_ID] } };
-    if (setDefault) next.defaultProvider = CLINE_PROVIDER_ID;
+    const next = { ...config, providers: { ...config.providers, [id]: defaultConfig().providers[id] } };
+    if (setDefault) next.defaultProvider = id;
     await saveConfig(next);
-    console.log(`Configured ${CLINE_PROVIDER_ID} at ${getConfigPath()}`);
+    console.log(`Configured ${id} at ${getConfigPath()}`);
     return 0;
   }
   if (sub === "use") {
-    if (args.shift() !== CLINE_PROVIDER_ID) throw new ConfigError("Only `provider use cline-cli` is supported.");
-    await saveConfig({ ...config, defaultProvider: CLINE_PROVIDER_ID });
-    console.log(`Default provider: ${CLINE_PROVIDER_ID}`);
+    const requested = args.shift();
+    if (requested !== CLINE_PROVIDER_ID && requested !== GEMINI_PROVIDER_ID) {
+      throw new ConfigError("Only `provider use cline-cli` or `provider use gemini-cli` is supported.");
+    }
+    await saveConfig({ ...config, defaultProvider: requested });
+    console.log(`Default provider: ${requested}`);
     return 0;
   }
   throw new ConfigError(`Unknown provider command: ${sub ?? "(missing)"}`);
 }
 
 async function loginCommand(args: string[]): Promise<number> {
-  if (args.shift() !== CLINE_PROVIDER_ID) throw new ConfigError("Only `login cline-cli` is supported.");
+  const provider = args.shift();
+  if (provider === GEMINI_PROVIDER_ID) {
+    throw new ConfigError("Gemini authentication is managed by Gemini CLI. Run `gemini` to log in or set GEMINI_API_KEY for the CLI.");
+  }
+  if (provider !== CLINE_PROVIDER_ID) throw new ConfigError("Only `login cline-cli` is supported; authenticate Gemini through Gemini CLI.");
   const json = takeFlag(args, "--json");
   const noWait = takeFlag(args, "--no-wait");
   if (args.length > 0) throw new ConfigError(`Unknown login option: ${args[0]}`);
@@ -157,9 +179,23 @@ async function startCommand(args: string[]): Promise<number> {
     config.port = parsed;
   }
   if (host !== undefined) config.host = host;
+  try {
+    const catalog = await syncCodexCatalog({ env });
+    if (catalog.ok && catalog.written) {
+      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(`Cline-only proxy listening on http://${running.host}:${running.port}/v1`);
+  console.log(`opencodex listening on http://${running.host}:${running.port}/v1 (default provider: ${config.defaultProvider})`);
   console.log(`Health: http://${running.host}:${running.port}/healthz`);
 
   const shutdown = async (signal: string): Promise<void> => {
@@ -174,6 +210,31 @@ async function startCommand(args: string[]): Promise<number> {
   return 0;
 }
 
+async function codexCommand(args: string[]): Promise<number> {
+  const sub = args.shift();
+  if (sub !== "sync") throw new ConfigError(`Unknown codex command: ${sub ?? "(missing)"}. Expected sync.`);
+  const json = takeFlag(args, "--json");
+  if (args.length > 0) throw new ConfigError(`Unknown codex sync option: ${args[0]}`);
+  const result = await syncCodexCatalog({ env: process.env });
+  if (!result.ok) {
+    if (json) console.log(JSON.stringify({ ok: false, path: result.path, reason: result.reason, message: result.message }));
+    else console.error(`ocx: ${result.message}`);
+    return 1;
+  }
+  if (json) {
+    console.log(JSON.stringify(result));
+  } else {
+    console.log(`Catalog: ${result.path}`);
+    console.log(`Models: ${result.modelCount} (Gemini ${result.geminiModelCount}, reasoning-enabled ${result.reasoningModelCount})`);
+    for (const warning of result.warnings) console.warn(`[opencodex] ${warning}`);
+    if (!result.configured) {
+      console.log(`Activate it with: model_catalog_json = "${result.path}"`);
+    }
+    console.log("Codex reload required: restart the Codex app or app-server model picker.");
+  }
+  return 0;
+}
+
 async function statusCommand(args: string[]): Promise<number> {
   const json = takeFlag(args, "--json");
   if (args.length > 0) throw new ConfigError(`Unknown status option: ${args[0]}`);
@@ -208,7 +269,7 @@ async function stopCommand(args: string[]): Promise<number> {
     return 0;
   }
   if (!await health(state.host, state.port, config, process.env)) {
-    throw new ConfigError(`Refusing to stop pid ${state.pid}: it is not the Cline-only proxy recorded by this home.`);
+    throw new ConfigError(`Refusing to stop pid ${state.pid}: it is not the opencodex proxy recorded by this home.`);
   }
   process.kill(state.pid, "SIGTERM");
   const deadline = Date.now() + 5_000;
@@ -222,7 +283,7 @@ async function stopCommand(args: string[]): Promise<number> {
 
 async function main(argv: string[]): Promise<number> {
   if (argv[0] === "__cli-agent-mcp") {
-    await runCodingAgentMcpServer(argv[1] ?? "");
+    await runCodingAgentMcpServer(argv[1] ?? "", argv[2]);
     return 0;
   }
   const command = argv.shift();
@@ -236,10 +297,11 @@ async function main(argv: string[]): Promise<number> {
   }
   if (command === "login") return await loginCommand(argv);
   if (command === "provider") return await providerCommand(argv);
+  if (command === "codex") return await codexCommand(argv);
   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, start, status, stop, version, or help.`);
+  throw new ConfigError(`Unknown command: ${command}. Expected login, provider, codex, start, status, stop, version, or help.`);
 }
 
 try {