@koreanhole/opencodex 2.99.0 → 3.0.0

package/src/cli/entry.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env bun
+import { randomBytes } from "node:crypto";
+import { rmSync } from "node:fs";
+import {
+  ADAPTER_DEFAULT_PORT,
+  ADAPTER_PROVIDER_IDS,
+  ADAPTER_TOKEN_ENV,
+  AdapterConfigError,
+  adapterRuntimePath,
+  discoverManagedProviderMetadata,
+  readAdapterRuntime,
+  readUpstreamConfig,
+  removeAdapterRuntimeIfPid,
+  restoreManagedProviderRows,
+  setAdapterDefaultProvider,
+  syncManagedProviderRows,
+  writeAdapterRuntime,
+  type AdapterProviderId,
+} from "../adapter-runtime/config";
+import { startAdapterGateway, type AdapterGateway } from "../adapter-runtime/gateway";
+import { ConfigError } from "../config";
+import { UpstreamPackageError, resolveUpstreamPackage } from "../upstream/package";
+import { loadUpstreamCli } from "../upstream/cli";
+import { runAdapterCli } from "./index";
+
+type AdapterCli = (argv: string[]) => Promise<number>;
+type UpstreamLoader = () => Promise<void>;
+type StartPreparer = (env: NodeJS.ProcessEnv) => Promise<unknown>;
+
+export interface EntryDeps {
+  adapterCli?: AdapterCli;
+  loadUpstream?: UpstreamLoader;
+  prepareStart?: StartPreparer;
+}
+
+const DISTRIBUTION_PACKAGE = "@koreanhole/opencodex";
+
+function isAdapterId(value: string | undefined): value is AdapterProviderId {
+  return value === "gemini-cli" || value === "cline-cli";
+}
+
+export function isAdapterOwnedCommand(argv: readonly string[]): boolean {
+  const command = argv[0];
+  if (command === "__cli-agent-mcp") return true;
+  if (command === "update") return true;
+  if (command === "system" && argv.slice(1).includes("update")) return true;
+  if (command === "login" && (argv[1] === "cline-cli" || argv[1] === "gemini-cli")) return true;
+  if (command === "adapter" && argv[1] === "detach") return true;
+  if (command !== "provider") return false;
+  if (argv[1] === "add" && isAdapterId(argv[2])) return true;
+  if (argv[1] === "use" && isAdapterId(argv[2])) return true;
+  return false;
+}
+
+function takeFlag(args: string[], flag: string): boolean {
+  const index = args.indexOf(flag);
+  if (index < 0) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+async function adapterProviderCommand(args: string[], env: NodeJS.ProcessEnv): Promise<number> {
+  const sub = args.shift();
+  if (sub !== "add" && sub !== "use") throw new ConfigError("Unknown provider command: " + String(sub ?? "(missing)"));
+  const provider = args.shift();
+  if (!isAdapterId(provider)) throw new ConfigError("Only gemini-cli and cline-cli are handled for provider " + sub + ".");
+  if (sub === "add") {
+    const setDefault = takeFlag(args, "--set-default");
+    if (args.length > 0) throw new ConfigError("Unknown provider add option: " + args[0]);
+    const runtime = await readAdapterRuntime(env);
+    await syncManagedProviderRows({
+      env,
+      gatewayPort: runtime?.port ?? ADAPTER_DEFAULT_PORT,
+      ...(setDefault ? { defaultProvider: provider } : {}),
+    });
+    console.log("Configured " + provider + ".");
+    return 0;
+  }
+  if (args.length > 0) throw new ConfigError("Unknown provider use option: " + args[0]);
+  await setAdapterDefaultProvider(provider, env);
+  console.log("Default provider: " + provider);
+  return 0;
+}
+
+async function detachAdapter(env: NodeJS.ProcessEnv): Promise<number> {
+  const result = await restoreManagedProviderRows(env);
+  if (!result.restored) {
+    console.log("CLI adapters are not attached.");
+    return 0;
+  }
+  if (result.preservedUserRows.length > 0) {
+    console.log("Preserved user-owned provider rows: " + result.preservedUserRows.join(", "));
+  }
+  console.log("CLI adapter provider rows detached.");
+  return 0;
+}
+
+function printDistributionUpdate(argv: readonly string[]): number {
+  const command = "npm install -g " + DISTRIBUTION_PACKAGE + "@latest";
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify({
+      ok: false,
+      reason: "distribution_managed",
+      package: DISTRIBUTION_PACKAGE,
+      command,
+    }));
+  } else {
+    console.error("ocx: updates are managed by " + DISTRIBUTION_PACKAGE + ".");
+    console.error("Run: " + command);
+  }
+  return 2;
+}
+
+async function runAdapterCommand(argv: string[], env: NodeJS.ProcessEnv, adapterCli: AdapterCli): Promise<number> {
+  if (argv[0] === "__cli-agent-mcp") return adapterCli(argv);
+  if (argv[0] === "login") return adapterCli(argv);
+  if (argv[0] === "update" || (argv[0] === "system" && argv.slice(1).includes("update"))) {
+    return printDistributionUpdate(argv);
+  }
+  if (argv[0] === "adapter" && argv[1] === "detach") return detachAdapter(env);
+  if (argv[0] === "provider") return adapterProviderCommand(argv.slice(1), env);
+  throw new ConfigError("Internal adapter dispatch error.");
+}
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Attach the two managed rows and keep the gateway in the serving process. */
+export async function prepareAdapterStart(
+  env: NodeJS.ProcessEnv = process.env,
+  deps: {
+    discoverMetadata?: typeof discoverManagedProviderMetadata;
+    startGateway?: typeof startAdapterGateway;
+    syncRows?: typeof syncManagedProviderRows;
+  } = {},
+): Promise<AdapterGateway | undefined> {
+  const existing = await readAdapterRuntime(env);
+  const inheritedToken = env[ADAPTER_TOKEN_ENV]?.trim();
+  if (existing && existing.pid !== process.pid && pidAlive(existing.pid) && !inheritedToken) {
+    throw new AdapterConfigError(
+      "The CLI adapter gateway is already running in another process; restart it from that process or stop it first.",
+    );
+  }
+  const token = inheritedToken || randomBytes(32).toString("base64url");
+  env[ADAPTER_TOKEN_ENV] = token;
+  let gateway: AdapterGateway | undefined;
+  let gatewayPort: number;
+  if (existing && existing.pid !== process.pid && pidAlive(existing.pid)) {
+    gatewayPort = existing.port;
+  } else {
+    if (existing) await removeAdapterRuntimeIfPid(existing.pid, env);
+    gateway = (deps.startGateway ?? startAdapterGateway)({ token, env });
+    gatewayPort = gateway.port;
+    await writeAdapterRuntime({
+      version: 1,
+      pid: process.pid,
+      host: "127.0.0.1",
+      port: gatewayPort,
+      tokenEnv: ADAPTER_TOKEN_ENV,
+      providers: [...ADAPTER_PROVIDER_IDS],
+      startedAt: new Date().toISOString(),
+    }, env);
+    process.once("exit", () => {
+      try {
+        rmSync(adapterRuntimePath(env), { force: true });
+      } catch {
+        // best effort
+      }
+    });
+  }
+
+  try {
+    const metadata = await (deps.discoverMetadata ?? discoverManagedProviderMetadata)(env).catch(() => undefined);
+    const synced = await (deps.syncRows ?? syncManagedProviderRows)({
+      env,
+      gatewayPort,
+      ...(metadata ? { metadata } : {}),
+    });
+    if (synced.providerEnvToken) env.OPENCODEX_API_AUTH_TOKEN ??= synced.providerEnvToken;
+    return gateway;
+  } catch (error) {
+    await gateway?.stop().catch(() => undefined);
+    await removeAdapterRuntimeIfPid(process.pid, env).catch(() => undefined);
+    throw error;
+  }
+}
+
+export async function runEntry(argv: string[], deps: EntryDeps = {}): Promise<void> {
+  const env = process.env;
+  env.OCX_DISABLE_UPDATE_CHECK ??= "1";
+  if (isAdapterOwnedCommand(argv)) {
+    process.exitCode = await runAdapterCommand(argv, env, deps.adapterCli ?? runAdapterCli);
+    return;
+  }
+  if (argv[0] === "start") {
+    await (deps.prepareStart ?? prepareAdapterStart)(env);
+  }
+  const entry = process.argv[1] ?? "ocx";
+  const executable = process.argv[0] ?? "bun";
+  process.argv = [executable, entry, ...argv];
+  await (deps.loadUpstream ?? (() => loadUpstreamCli()))();
+}
+
+function printError(error: unknown): number {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error("ocx: " + message);
+  return error instanceof ConfigError || error instanceof AdapterConfigError || error instanceof UpstreamPackageError ? 2 : 1;
+}
+
+if (import.meta.main) {
+  try {
+    await runEntry(process.argv.slice(2));
+  } catch (error) {
+    process.exitCode = printError(error);
+  }
+}

package/src/cli/index.ts

@@ -348,7 +348,7 @@ async function stopCommand(args: string[]): Promise<number> {
   return restored.success ? 0 : 1;
 }
 
-async function main(argv: string[]): Promise<number> {
+export async function runAdapterCli(argv: string[]): Promise<number> {
   if (argv[0] === "__cli-agent-mcp") {
     await runCodingAgentMcpServer(argv[1] ?? "", argv[2]);
     return 0;
@@ -372,8 +372,10 @@ async function main(argv: string[]): Promise<number> {
   throw new ConfigError(`Unknown command: ${command}. Expected login, provider, codex, start, status, stop, restore, eject, version, or help.`);
 }
 
-try {
-  process.exitCode = await main(process.argv.slice(2));
-} catch (error) {
-  process.exitCode = printError(error);
+if (import.meta.main) {
+  try {
+    process.exitCode = await runAdapterCli(process.argv.slice(2));
+  } catch (error) {
+    process.exitCode = printError(error);
+  }
 }

package/src/server/index.ts

@@ -5,6 +5,7 @@ import {
   assertSafeListener,
   defaultConfig,
   normalizeConfig,
+  type ProviderId,
   type RuntimeConfig,
 } from "../config";
 import type { IncomingMeta } from "../types";
@@ -29,6 +30,7 @@ export interface ServerOptions {
   clineDeps?: ClineTurnDeps;
   geminiDeps?: GeminiTurnDeps;
   geminiPackageRoot?: string;
+  providerScope?: ProviderId;
   onWebSocketRequest?: (observation: WebSocketRequestObservation) => void;
 }
 
@@ -92,23 +94,32 @@ async function discoverModels(
   clineDeps: ClineTurnDeps | undefined,
   geminiDeps: GeminiTurnDeps | undefined,
   geminiPackageRoot: string | undefined,
+  providerScope?: ProviderId,
 ): Promise<ProviderModels> {
   const [cline, gemini] = await Promise.all([
-    discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) }),
-    discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}), ...(geminiPackageRoot ? { packageRoot: geminiPackageRoot } : {}) }),
+    !providerScope || providerScope === "cline-cli"
+      ? discoverClineLiveModels({ env, ...(clineDeps ? { deps: clineDeps } : {}) })
+      : undefined,
+    !providerScope || providerScope === "gemini-cli"
+      ? discoverGeminiLiveModels({ env, ...(geminiDeps ? { deps: geminiDeps } : {}), ...(geminiPackageRoot ? { packageRoot: geminiPackageRoot } : {}) })
+      : undefined,
   ]);
-  if (!cline.ok && cline.reason !== "not_found" && env.OPENCODEX_CLINE_ACP?.trim() !== "0") {
+  if (cline && !cline.ok && cline.reason !== "not_found" && env.OPENCODEX_CLINE_ACP?.trim() !== "0") {
     console.warn(`[opencodex] Cline model discovery degraded [${cline.reason}]: ${cline.detail}`);
   }
-  if (!gemini.ok && gemini.reason !== "not_found" && env.OPENCODEX_GEMINI_ACP?.trim() !== "0") {
+  if (gemini && !gemini.ok && gemini.reason !== "not_found" && env.OPENCODEX_GEMINI_ACP?.trim() !== "0") {
     console.warn(`[opencodex] Gemini model discovery degraded [${gemini.reason}]: ${gemini.detail}`);
   }
-  return {
-    "cline-cli": cline.ok ? ["default", ...cline.models.filter(id => id !== "default")] : ["default"],
-    "gemini-cli": gemini.ok
+  const models: ProviderModels = {};
+  if (cline) {
+    models["cline-cli"] = cline.ok ? ["default", ...cline.models.filter(id => id !== "default")] : ["default"];
+  }
+  if (gemini) {
+    models["gemini-cli"] = gemini.ok
       ? ["default", ...gemini.modelInfo.filter(model => model.id !== "default")]
-      : ["default"],
-  };
+      : ["default"];
+  }
+  return models;
 }
 
 export function startServer(config: RuntimeConfig | number, options: ServerOptions = {}): RunningServer {
@@ -138,8 +149,8 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
     }
     try {
       if (req.method === "GET" && url.pathname === "/v1/models") {
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
-        return Response.json({ object: "list", data: modelList(known) });
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
+        return Response.json({ object: "list", data: modelList(known, options.providerScope) });
       }
       if (req.method === "GET" && url.pathname === "/v1/model-catalog") {
         const discovered = await discoverCodexCatalogModels({
@@ -152,16 +163,16 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
       }
       if (req.method === "POST" && url.pathname === "/v1/responses") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
         const signal = AbortSignal.any([req.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]);
         const incoming: IncomingMeta = { headers: req.headers, abortSignal: signal };
-        return await handleResponses(body, incoming, known, turnDeps, config.defaultProvider);
+        return await handleResponses(body, incoming, known, turnDeps, options.providerScope ?? config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages") {
         const body = await boundedJson(req);
-        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot);
+        const known = await discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope);
         const signal = AbortSignal.any([req.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]);
-        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, turnDeps, config.defaultProvider);
+        return await handleMessages(body, { headers: req.headers, abortSignal: signal }, known, turnDeps, options.providerScope ?? config.defaultProvider);
       }
       if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
         return handleCountTokens(await boundedJson(req));
@@ -173,9 +184,9 @@ export function startServer(config: RuntimeConfig | number, options: ServerOptio
   };
 
   const websocketContext = {
-    knownModels: () => discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot),
+    knownModels: () => discoverModels(env, options.clineDeps, options.geminiDeps, options.geminiPackageRoot, options.providerScope),
     deps: turnDeps,
-    defaultProvider: config.defaultProvider,
+    defaultProvider: options.providerScope ?? config.defaultProvider,
     timeoutMs: REQUEST_TIMEOUT_MS,
     ...(options.onWebSocketRequest ? { onRequest: options.onWebSocketRequest } : {}),
   };

package/src/server/responses.ts

@@ -379,7 +379,10 @@ const PROVIDER_LABELS: Record<ProviderId, string> = {
   [GEMINI_PROVIDER_ID]: "Gemini CLI",
 };
 
-export function modelList(known: string[] | ProviderModels): Array<Record<string, unknown>> {
+export function modelList(
+  known: string[] | ProviderModels,
+  scope?: ProviderId,
+): Array<Record<string, unknown>> {
   if (Array.isArray(known)) {
     const ids = ["default", ...known.filter(id => id !== "default")];
     return [...new Set(ids)].map(id => ({
@@ -390,6 +393,44 @@ export function modelList(known: string[] | ProviderModels): Array<Record<string
       display_name: id === "default" ? "Cline default" : id,
     }));
   }
+  if (scope) {
+    const entries = ["default", ...(known[scope] ?? []).filter(entry => modelIdOf(entry) !== "default")];
+    const rows: Array<Record<string, unknown>> = [];
+    const seen = new Set<string>();
+    for (const entry of entries) {
+      const id = modelIdOf(entry);
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const info = typeof entry === "string" ? { id: entry } as OcxProviderModel : entry;
+      const reasoning = info.supportedReasoningLevels ?? [];
+      rows.push({
+        id: encodeRoutedModelId(id),
+        object: "model",
+        created: 0,
+        owned_by: scope,
+        display_name: info.name ?? (id === "default" ? PROVIDER_LABELS[scope] + " default" : id),
+        ...(info.description ? { description: info.description } : {}),
+        ...(info.contextWindowTokens !== undefined
+          ? {
+              context_window: info.contextWindowTokens,
+              max_context_window: info.maxContextWindowTokens ?? info.contextWindowTokens,
+            }
+          : {}),
+        ...(info.inputModalities ? { input_modalities: [...info.inputModalities] } : {}),
+        ...(info.loadSession !== undefined ? { load_session: info.loadSession } : {}),
+        ...(reasoning.length > 0
+          ? {
+              supported_reasoning_levels: reasoning.map(level => ({
+                effort: level.effort,
+                description: level.description,
+              })),
+              default_reasoning_level: info.defaultReasoningLevel ?? reasoning[0]!.effort,
+            }
+          : { supported_reasoning_levels: [] }),
+      });
+    }
+    return rows;
+  }
   const rows: Array<Record<string, unknown>> = [{
     id: "default",
     object: "model",

package/src/upstream/cli.ts

@@ -0,0 +1,12 @@
+import { pathToFileURL } from "node:url";
+import { resolveUpstreamPackage, type UpstreamPackage } from "./package";
+
+export type UpstreamModuleImporter = (url: string) => Promise<unknown>;
+
+/** Load the immutable upstream CLI into this process so service ownership stays ours. */
+export async function loadUpstreamCli(
+  pkg: UpstreamPackage = resolveUpstreamPackage(),
+  importer: UpstreamModuleImporter = url => import(url),
+): Promise<void> {
+  await importer(pathToFileURL(pkg.cliEntry).href);
+}

package/src/upstream/package.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+export const UPSTREAM_PACKAGE_NAME = "@bitkyc08/opencodex";
+export const UPSTREAM_PACKAGE_VERSION = "2.94.0";
+export const UPSTREAM_CLI_RELATIVE_PATH = "src/cli/index.ts";
+
+export interface UpstreamPackage {
+  name: string;
+  version: string;
+  root: string;
+  cliEntry: string;
+}
+
+export class UpstreamPackageError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UpstreamPackageError";
+  }
+}
+
+export interface ResolveUpstreamPackageDeps {
+  resolvePackageJson?: () => string;
+  readJson?: (path: string) => unknown;
+  exists?: (path: string) => boolean;
+}
+
+/** Resolve the exact immutable upstream package without importing its runtime. */
+export function resolveUpstreamPackage(
+  deps: ResolveUpstreamPackageDeps = {},
+): UpstreamPackage {
+  const resolvePackageJson = deps.resolvePackageJson
+    ?? (() => createRequire(import.meta.url).resolve(UPSTREAM_PACKAGE_NAME + "/package.json"));
+  const readJson = deps.readJson
+    ?? (path => JSON.parse(readFileSync(path, "utf8")) as unknown);
+  const exists = deps.exists ?? existsSync;
+
+  let packageJsonPath: string;
+  try {
+    packageJsonPath = resolvePackageJson();
+  } catch {
+    throw new UpstreamPackageError(
+      UPSTREAM_PACKAGE_NAME + " is not installed. Reinstall this package with its dependencies.",
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = readJson(packageJsonPath);
+  } catch {
+    throw new UpstreamPackageError("The installed opencodex package metadata is unreadable.");
+  }
+  const packageJson = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+    ? parsed as Record<string, unknown>
+    : undefined;
+  if (packageJson?.name !== UPSTREAM_PACKAGE_NAME || packageJson.version !== UPSTREAM_PACKAGE_VERSION) {
+    throw new UpstreamPackageError(
+      "Expected " + UPSTREAM_PACKAGE_NAME + "@" + UPSTREAM_PACKAGE_VERSION
+        + ", found " + String(packageJson?.name ?? "unknown") + "@" + String(packageJson?.version ?? "unknown") + ".",
+    );
+  }
+  const root = dirname(packageJsonPath);
+  const cliEntry = join(root, UPSTREAM_CLI_RELATIVE_PATH);
+  if (!exists(cliEntry)) {
+    throw new UpstreamPackageError(
+      UPSTREAM_PACKAGE_NAME + "@" + UPSTREAM_PACKAGE_VERSION + " does not contain " + UPSTREAM_CLI_RELATIVE_PATH + ".",
+    );
+  }
+  return {
+    name: UPSTREAM_PACKAGE_NAME,
+    version: UPSTREAM_PACKAGE_VERSION,
+    root,
+    cliEntry,
+  };
+}