@koreanhole/opencodex 2.98.0 → 3.0.0

package/src/adapter-runtime/config.ts

@@ -0,0 +1,381 @@
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getConfigDir, getConfigPath } from "../config";
+import { discoverClineLiveModels } from "../adapters/cli-agent/cline/live-models";
+import { discoverGeminiLiveModels } from "../adapters/cli-agent/gemini/live-models";
+import type { OcxProviderModel } from "../types";
+
+export const ADAPTER_PROVIDER_IDS = ["gemini-cli", "cline-cli"] as const;
+export type AdapterProviderId = typeof ADAPTER_PROVIDER_IDS[number];
+export const ADAPTER_TOKEN_ENV = "OPENCODEX_CLI_ADAPTER_TOKEN";
+export const ADAPTER_DEFAULT_PORT = 19_100;
+
+export interface AdapterModelMetadata {
+  models: string[];
+  modelDisplayNames?: Record<string, string>;
+  modelContextWindows?: Record<string, number>;
+  modelInputModalities?: Record<string, string[]>;
+  modelReasoningEfforts?: Record<string, string[]>;
+  modelDefaultReasoningEfforts?: Record<string, string>;
+}
+
+export type AdapterProviderMetadata = Partial<Record<AdapterProviderId, AdapterModelMetadata>>;
+
+export interface AdapterRuntimeState {
+  version: 1;
+  pid: number;
+  host: "127.0.0.1";
+  port: number;
+  tokenEnv: typeof ADAPTER_TOKEN_ENV;
+  providers: AdapterProviderId[];
+  startedAt: string;
+}
+
+interface AdapterConfigJournal {
+  version: 1;
+  priorRows: Record<AdapterProviderId, unknown | "absent">;
+  priorHostname?: string;
+  appliedHostname?: string;
+  priorDefaultProvider?: string;
+  appliedDefaultProvider?: string;
+}
+
+export class AdapterConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AdapterConfigError";
+  }
+}
+
+const CLINE_FALLBACK_CONTEXT = 128_000;
+
+function unionModalities(models: readonly OcxProviderModel[]): string[] {
+  const values = models.flatMap(model => model.inputModalities ?? []);
+  return [...new Set(values.length > 0 ? values : ["text"])];
+}
+
+function modelMetadata(models: readonly OcxProviderModel[], cline: boolean): AdapterModelMetadata {
+  const metadata: AdapterModelMetadata = { models: models.map(model => model.id) };
+  const displayNames: Record<string, string> = {};
+  const contexts: Record<string, number> = {};
+  const modalities: Record<string, string[]> = {};
+  const efforts: Record<string, string[]> = {};
+  const defaults: Record<string, string> = {};
+  for (const model of models) {
+    if (model.name) displayNames[model.id] = model.name;
+    const context = model.contextWindowTokens ?? (cline ? CLINE_FALLBACK_CONTEXT : undefined);
+    if (context !== undefined) contexts[model.id] = context;
+    modalities[model.id] = [...(model.inputModalities ?? ["text"])];
+    const levels = (model.supportedReasoningLevels ?? []).map(level => level.effort);
+    if (levels.length > 0) {
+      efforts[model.id] = levels;
+      defaults[model.id] = model.defaultReasoningLevel ?? levels[0]!;
+    }
+  }
+  if (cline) {
+    contexts.default = CLINE_FALLBACK_CONTEXT;
+    modalities.default = ["text"];
+  } else if (models.length > 0) {
+    const discoveredContexts = models.flatMap(model => model.contextWindowTokens ?? []);
+    if (discoveredContexts.length > 0) contexts.default = Math.min(...discoveredContexts);
+    modalities.default = unionModalities(models);
+  }
+  if (Object.keys(displayNames).length > 0) metadata.modelDisplayNames = displayNames;
+  if (Object.keys(contexts).length > 0) metadata.modelContextWindows = contexts;
+  if (Object.keys(modalities).length > 0) metadata.modelInputModalities = modalities;
+  if (Object.keys(efforts).length > 0) metadata.modelReasoningEfforts = efforts;
+  if (Object.keys(defaults).length > 0) metadata.modelDefaultReasoningEfforts = defaults;
+  return metadata;
+}
+
+export async function discoverManagedProviderMetadata(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<AdapterProviderMetadata> {
+  const [cline, gemini] = await Promise.all([
+    discoverClineLiveModels({ env }),
+    discoverGeminiLiveModels({ env }),
+  ]);
+  return {
+    "cline-cli": modelMetadata(
+      cline.ok ? cline.models.map(id => ({ id })) : [],
+      true,
+    ),
+    "gemini-cli": modelMetadata(
+      gemini.ok ? gemini.modelInfo : [],
+      false,
+    ),
+  };
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function isLoopback(hostname: string): boolean {
+  return hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]" || hostname === "localhost";
+}
+
+export function adapterStateDir(env: NodeJS.ProcessEnv = process.env): string {
+  return join(getConfigDir(env), "cli-adapters");
+}
+
+export function adapterRuntimePath(env: NodeJS.ProcessEnv = process.env): string {
+  return join(adapterStateDir(env), "runtime.json");
+}
+
+export function adapterJournalPath(env: NodeJS.ProcessEnv = process.env): string {
+  return join(adapterStateDir(env), "config-journal.json");
+}
+
+async function readJson(path: string): Promise<unknown | undefined> {
+  try {
+    return JSON.parse(await readFile(path, "utf8")) as unknown;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+    throw new AdapterConfigError(path + " is not valid JSON.");
+  }
+}
+
+async function writePrivateJson(path: string, value: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = path + "." + process.pid + "." + crypto.randomUUID() + ".tmp";
+  try {
+    await writeFile(temporary, JSON.stringify(value, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    await chmod(temporary, 0o600);
+    await rename(temporary, path);
+    await chmod(path, 0o600).catch(() => undefined);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => undefined);
+  }
+}
+
+export async function readUpstreamConfig(env: NodeJS.ProcessEnv = process.env): Promise<Record<string, unknown>> {
+  const parsed = await readJson(getConfigPath(env));
+  if (parsed === undefined) return {};
+  const config = record(parsed);
+  if (!config) throw new AdapterConfigError("config.json must contain a JSON object.");
+  return config;
+}
+
+function providers(config: Record<string, unknown>): Record<string, unknown> {
+  const current = record(config.providers);
+  if (current) return current;
+  const next: Record<string, unknown> = {};
+  config.providers = next;
+  return next;
+}
+
+export function isManagedProviderRow(name: AdapterProviderId, value: unknown): boolean {
+  const row = record(value);
+  if (!row || row.adapter !== "openai-responses" || typeof row.baseUrl !== "string") return false;
+  if (row.apiKey !== undefined && row.apiKey !== "${" + ADAPTER_TOKEN_ENV + "}") return false;
+  try {
+    const url = new URL(row.baseUrl);
+    return url.protocol === "http:"
+      && isLoopback(url.hostname)
+      && url.pathname === "/" + name + "/v1"
+      && url.search === ""
+      && url.hash === "";
+  } catch {
+    return false;
+  }
+}
+
+function isLegacyProviderRow(name: AdapterProviderId, value: unknown): boolean {
+  const row = record(value);
+  return row?.adapter === name;
+}
+
+function uniqueModels(metadata: AdapterModelMetadata | undefined): string[] {
+  return [...new Set(["default", ...(metadata?.models ?? [])].filter(Boolean))];
+}
+
+export function buildManagedProviderRow(
+  name: AdapterProviderId,
+  gatewayPort: number,
+  metadata: AdapterModelMetadata = { models: ["default"] },
+): Record<string, unknown> {
+  if (!Number.isInteger(gatewayPort) || gatewayPort < 1 || gatewayPort > 65_535) {
+    throw new AdapterConfigError("A loopback gateway port is required.");
+  }
+  return {
+    adapter: "openai-responses",
+    baseUrl: "http://127.0.0.1:" + gatewayPort + "/" + name + "/v1",
+    authMode: "key",
+    apiKey: "${" + ADAPTER_TOKEN_ENV + "}",
+    allowPrivateNetwork: true,
+    liveModels: true,
+    defaultModel: "default",
+    models: uniqueModels(metadata),
+    ...(metadata.modelDisplayNames ? { modelDisplayNames: metadata.modelDisplayNames } : {}),
+    ...(metadata.modelContextWindows ? { modelContextWindows: metadata.modelContextWindows } : {}),
+    ...(metadata.modelInputModalities ? { modelInputModalities: metadata.modelInputModalities } : {}),
+    ...(metadata.modelReasoningEfforts ? { modelReasoningEfforts: metadata.modelReasoningEfforts } : {}),
+    ...(metadata.modelDefaultReasoningEfforts
+      ? { modelDefaultReasoningEfforts: metadata.modelDefaultReasoningEfforts }
+      : {}),
+  };
+}
+
+async function readJournal(env: NodeJS.ProcessEnv): Promise<AdapterConfigJournal | undefined> {
+  const parsed = await readJson(adapterJournalPath(env));
+  if (parsed === undefined) return undefined;
+  const journal = record(parsed);
+  if (journal?.version !== 1 || !record(journal.priorRows)) {
+    throw new AdapterConfigError("The adapter configuration journal is malformed.");
+  }
+  return journal as unknown as AdapterConfigJournal;
+}
+
+export interface SyncManagedProviderRowsOptions {
+  env?: NodeJS.ProcessEnv;
+  gatewayPort: number;
+  metadata?: AdapterProviderMetadata;
+  defaultProvider?: AdapterProviderId;
+}
+
+/** Merge only the two managed provider rows and their reversible top-level markers. */
+export async function syncManagedProviderRows(
+  options: SyncManagedProviderRowsOptions,
+): Promise<{ configPath: string; providerEnvToken?: string }> {
+  const env = options.env ?? process.env;
+  const config = await readUpstreamConfig(env);
+  const rows = providers(config);
+  const existingJournal = await readJournal(env);
+  const journal: AdapterConfigJournal = existingJournal ?? {
+    version: 1,
+    priorRows: {
+      "gemini-cli": Object.hasOwn(rows, "gemini-cli") ? structuredClone(rows["gemini-cli"]) : "absent",
+      "cline-cli": Object.hasOwn(rows, "cline-cli") ? structuredClone(rows["cline-cli"]) : "absent",
+    },
+    ...(typeof config.hostname === "string" ? { priorHostname: config.hostname } : {}),
+    ...(typeof config.defaultProvider === "string" ? { priorDefaultProvider: config.defaultProvider } : {}),
+  };
+
+  for (const name of ADAPTER_PROVIDER_IDS) {
+    const prior = journal.priorRows[name];
+    if (prior !== "absent" && !isManagedProviderRow(name, prior) && !isLegacyProviderRow(name, prior)) {
+      throw new AdapterConfigError(
+        "Provider " + name + " is user-owned and cannot be replaced by the CLI adapter.",
+      );
+    }
+    const current = rows[name];
+    if (existingJournal && current !== undefined && !isManagedProviderRow(name, current)) {
+      throw new AdapterConfigError(
+        "Provider " + name + " changed while the CLI adapter was attached; refusing to overwrite it.",
+      );
+    }
+  }
+
+  if (config.hostname === undefined && typeof config.host === "string" && config.host.trim()) {
+    journal.appliedHostname = config.host.trim();
+    config.hostname = config.host.trim();
+  }
+  if (options.defaultProvider) {
+    journal.appliedDefaultProvider = options.defaultProvider;
+    config.defaultProvider = options.defaultProvider;
+  }
+  for (const name of ADAPTER_PROVIDER_IDS) {
+    const nextRow = buildManagedProviderRow(
+      name,
+      options.gatewayPort,
+      options.metadata?.[name] ?? { models: ["default"] },
+    );
+    const current = record(rows[name]);
+    const preserved = current
+      ? Object.fromEntries(Object.entries(current).filter(([key]) => !Object.hasOwn(nextRow, key)))
+      : {};
+    rows[name] = { ...preserved, ...nextRow };
+  }
+  config.providers = rows;
+  await writePrivateJson(adapterJournalPath(env), journal);
+  await writePrivateJson(getConfigPath(env), config);
+  return {
+    configPath: getConfigPath(env),
+    ...(typeof config.apiAuthToken === "string" && config.apiAuthToken.trim()
+      ? { providerEnvToken: config.apiAuthToken.trim() }
+      : {}),
+  };
+}
+
+export async function restoreManagedProviderRows(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<{ restored: boolean; preservedUserRows: AdapterProviderId[] }> {
+  const journal = await readJournal(env);
+  if (!journal) return { restored: false, preservedUserRows: [] };
+  const config = await readUpstreamConfig(env);
+  const rows = providers(config);
+  const preservedUserRows: AdapterProviderId[] = [];
+  for (const name of ADAPTER_PROVIDER_IDS) {
+    const current = rows[name];
+    if (current !== undefined && !isManagedProviderRow(name, current)) {
+      preservedUserRows.push(name);
+      continue;
+    }
+    const prior = journal.priorRows[name];
+    if (prior === "absent") delete rows[name];
+    else rows[name] = structuredClone(prior);
+  }
+  if (journal.appliedHostname !== undefined && config.hostname === journal.appliedHostname) {
+    if (journal.priorHostname === undefined) delete config.hostname;
+    else config.hostname = journal.priorHostname;
+  }
+  if (journal.appliedDefaultProvider !== undefined && config.defaultProvider === journal.appliedDefaultProvider) {
+    if (journal.priorDefaultProvider === undefined) delete config.defaultProvider;
+    else config.defaultProvider = journal.priorDefaultProvider;
+  }
+  await writePrivateJson(getConfigPath(env), config);
+  await rm(adapterJournalPath(env), { force: true });
+  return { restored: true, preservedUserRows };
+}
+
+export async function setAdapterDefaultProvider(
+  provider: AdapterProviderId,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  const config = await readUpstreamConfig(env);
+  const journal = await readJournal(env);
+  if (journal) {
+    if (journal.appliedDefaultProvider === undefined) {
+      if (typeof config.defaultProvider === "string") journal.priorDefaultProvider = config.defaultProvider;
+      else delete journal.priorDefaultProvider;
+    }
+    journal.appliedDefaultProvider = provider;
+    await writePrivateJson(adapterJournalPath(env), journal);
+  }
+  config.defaultProvider = provider;
+  await writePrivateJson(getConfigPath(env), config);
+}
+
+export async function readAdapterRuntime(
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<AdapterRuntimeState | undefined> {
+  const parsed = await readJson(adapterRuntimePath(env));
+  if (parsed === undefined) return undefined;
+  const state = record(parsed);
+  if (state?.version !== 1
+    || !Number.isInteger(state.pid)
+    || !Number.isInteger(state.port)
+    || state.host !== "127.0.0.1"
+    || state.tokenEnv !== ADAPTER_TOKEN_ENV) {
+    return undefined;
+  }
+  return state as unknown as AdapterRuntimeState;
+}
+
+export async function writeAdapterRuntime(
+  state: AdapterRuntimeState,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  await writePrivateJson(adapterRuntimePath(env), state);
+}
+
+export async function removeAdapterRuntimeIfPid(
+  pid: number,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<void> {
+  const state = await readAdapterRuntime(env);
+  if (state?.pid === pid) await rm(adapterRuntimePath(env), { force: true });
+}

package/src/adapter-runtime/gateway.ts

@@ -0,0 +1,121 @@
+import { timingSafeEqual } from "node:crypto";
+import type { RunningServer, ServerOptions } from "../server";
+import {
+  startScopedProviderServer,
+  type ScopedServerOptions,
+} from "./scoped-server";
+import type { AdapterProviderId } from "./config";
+
+const PROVIDER_PATHS: ReadonlyArray<[AdapterProviderId, string]> = [
+  ["gemini-cli", "/gemini-cli/v1"],
+  ["cline-cli", "/cline-cli/v1"],
+];
+
+export interface AdapterGatewayOptions extends Omit<ScopedServerOptions, "config"> {
+  token: string;
+  startBackend?: typeof startScopedProviderServer;
+}
+
+export interface AdapterGateway {
+  readonly host: "127.0.0.1";
+  readonly port: number;
+  readonly unavailable: Partial<Record<AdapterProviderId, boolean>>;
+  stop(): Promise<void>;
+}
+
+function equalSecret(candidate: string | undefined, expected: string): boolean {
+  if (candidate === undefined) return false;
+  const left = Buffer.from(candidate);
+  const right = Buffer.from(expected);
+  return left.length === right.length && timingSafeEqual(left, right);
+}
+
+function requestToken(req: Request): string | undefined {
+  const authorization = req.headers.get("authorization");
+  if (authorization?.startsWith("Bearer ")) return authorization.slice(7);
+  return req.headers.get("x-api-key") ?? undefined;
+}
+
+function matchProvider(pathname: string): { provider: AdapterProviderId; path: string } | undefined {
+  for (const [provider, prefix] of PROVIDER_PATHS) {
+    if (pathname === prefix || pathname.startsWith(prefix + "/")) {
+      const suffix = pathname.slice(prefix.length);
+      return { provider, path: "/v1" + (suffix || "") };
+    }
+  }
+  return undefined;
+}
+
+export function startAdapterGateway(options: AdapterGatewayOptions): AdapterGateway {
+  const backends: Partial<Record<AdapterProviderId, RunningServer>> = {};
+  const unavailable: Partial<Record<AdapterProviderId, boolean>> = {};
+  const startBackend = options.startBackend ?? startScopedProviderServer;
+  for (const [provider] of PROVIDER_PATHS) {
+    try {
+      backends[provider] = startBackend(provider, options);
+    } catch {
+      unavailable[provider] = true;
+    }
+  }
+  let server: ReturnType<typeof Bun.serve>;
+  const handleRequest = async (req: Request): Promise<Response> => {
+    const url = new URL(req.url);
+    if (url.pathname === "/healthz") {
+      return Response.json({
+        ok: true,
+        service: "opencodex-cli-adapters",
+        pid: process.pid,
+        unavailable: Object.keys(unavailable),
+      });
+    }
+    const match = matchProvider(url.pathname);
+    if (!match) {
+      return Response.json({ error: { message: "Not found", type: "invalid_request_error" } }, { status: 404 });
+    }
+    if (!equalSecret(requestToken(req), options.token)) {
+      return Response.json({ error: { message: "Unauthorized", type: "authentication_error" } }, {
+        status: 401,
+        headers: { "www-authenticate": "Bearer" },
+      });
+    }
+    const backend = backends[match.provider];
+    if (!backend) {
+      return Response.json({
+        error: { message: "CLI adapter is unavailable.", type: "provider_unavailable" },
+      }, { status: 502 });
+    }
+    const headers = new Headers(req.headers);
+    headers.delete("authorization");
+    headers.delete("x-api-key");
+    headers.delete("host");
+    const target = "http://127.0.0.1:" + backend.port + match.path + url.search;
+    try {
+      const forwarded = new Request(target, {
+        method: req.method,
+        headers,
+        body: req.method === "GET" || req.method === "HEAD" ? undefined : req.body,
+        signal: req.signal,
+        redirect: "manual",
+      });
+      return await globalThis.fetch(forwarded);
+    } catch {
+      return Response.json({
+        error: { message: "CLI adapter request failed.", type: "provider_unavailable" },
+      }, { status: 502 });
+    }
+  };
+  server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch: handleRequest,
+  });
+  return {
+    host: "127.0.0.1",
+    port: server.port ?? 0,
+    unavailable,
+    async stop() {
+      await server.stop(true).catch(() => undefined);
+      await Promise.all(Object.values(backends).map(backend => backend?.stop(true).catch(() => undefined)));
+    },
+  };
+}

package/src/adapter-runtime/scoped-server.ts

@@ -0,0 +1,20 @@
+import { defaultConfig, type ProviderId, type RuntimeConfig } from "../config";
+import { startServer, type RunningServer, type ServerOptions } from "../server";
+
+export interface ScopedServerOptions extends Omit<ServerOptions, "providerScope"> {
+  config?: RuntimeConfig;
+}
+
+export function startScopedProviderServer(
+  provider: ProviderId,
+  options: ScopedServerOptions = {},
+): RunningServer {
+  const base = options.config ?? defaultConfig();
+  const config: RuntimeConfig = {
+    ...base,
+    port: 0,
+    host: "127.0.0.1",
+    defaultProvider: provider,
+  };
+  return startServer(config, { ...options, providerScope: provider });
+}