@iislee/opencodex 2.11.0

package/src/clients/probes/codex.ts

@@ -0,0 +1,125 @@
+/**
+ * Codex `config.toml` effective-routing probe.
+ *
+ * Uses the same marker semantics as inject (`hasInjectedOpenaiBaseUrl` /
+ * `rootTomlString`) so the Clients page agrees with `ocx status` / journal.
+ * Never returns bearer tokens from model_providers tables.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  hasInjectedCodexRouting,
+  hasInjectedOpenaiBaseUrl,
+  providerTableString,
+  rootTomlString,
+} from "../../codex/injected-marker";
+
+export interface CodexProbeResult {
+  present: boolean;
+  baseUrl: string | null;
+  model: string | null;
+  configPaths: string[];
+  notes: string[];
+  /** True when root is ocx but extra non-ocx model_providers remain. */
+  mixed: boolean;
+  injected: boolean;
+}
+
+export function codexConfigPath(home: string, codexHome?: string): string {
+  if (codexHome) return join(codexHome, "config.toml");
+  return join(home, ".codex", "config.toml");
+}
+
+/** List bare `[model_providers.X]` table names in a TOML document. */
+export function listModelProviderNames(content: string): string[] {
+  const names: string[] = [];
+  const re = /^\s*\[\s*(?:model_providers|"model_providers"|'model_providers')\s*\.\s*(?:([A-Za-z0-9_-]+)|"([^"]+)"|'([^']+)')\s*\]\s*(?:#.*)?$/gm;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(content)) !== null) {
+    const name = match[1] ?? match[2] ?? match[3];
+    if (name) names.push(name);
+  }
+  return names;
+}
+
+export function probeCodex(opts: {
+  home: string;
+  codexHome?: string;
+  configPath?: string;
+} = { home: "" }): CodexProbeResult {
+  const path = opts.configPath ?? codexConfigPath(opts.home, opts.codexHome);
+  const notes: string[] = [];
+  if (!existsSync(path)) {
+    return {
+      present: false,
+      baseUrl: null,
+      model: null,
+      configPaths: [path],
+      notes,
+      mixed: false,
+      injected: false,
+    };
+  }
+
+  let content: string;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch (error) {
+    return {
+      present: true,
+      baseUrl: null,
+      model: null,
+      configPaths: [path],
+      notes: [`Could not read config.toml: ${error instanceof Error ? error.message : String(error)}`],
+      mixed: false,
+      injected: false,
+    };
+  }
+
+  const injected = hasInjectedCodexRouting(content);
+  // Effective base URL priority:
+  // 1. Marker-owned root openai_base_url (Design B)
+  // 2. model_providers.opencodex.base_url when model_provider=opencodex
+  // 3. Any root openai_base_url (user-owned)
+  // 4. Selected model_provider's base_url
+  let baseUrl: string | null = null;
+  if (hasInjectedOpenaiBaseUrl(content)) {
+    baseUrl = rootTomlString(content, "openai_base_url");
+  } else {
+    const provider = rootTomlString(content, "model_provider");
+    if (provider === "opencodex") {
+      baseUrl = providerTableString(content, "opencodex", "base_url");
+    }
+    if (!baseUrl) {
+      baseUrl = rootTomlString(content, "openai_base_url");
+    }
+    if (!baseUrl && provider) {
+      baseUrl = providerTableString(content, provider, "base_url");
+    }
+  }
+
+  const model = rootTomlString(content, "model");
+  const providers = listModelProviderNames(content);
+  const foreignProviders = providers.filter(name => name !== "opencodex" && name !== "openai");
+  // mixed: root routes via ocx inject, but leftover third-party provider tables exist
+  // (e.g. CC Switch / custom entries that can still be selected).
+  const mixed = injected && foreignProviders.length > 0;
+  if (mixed) {
+    notes.push(`Extra model_providers on disk: ${foreignProviders.join(", ")}`);
+  }
+  if (!baseUrl) notes.push("No openai_base_url / model_provider base_url found.");
+
+  const catalog = rootTomlString(content, "model_catalog_json");
+  const configPaths = [path];
+  if (catalog) configPaths.push(catalog);
+
+  return {
+    present: true,
+    baseUrl,
+    model,
+    configPaths,
+    notes,
+    mixed,
+    injected,
+  };
+}

package/src/clients/probes/grok.ts

@@ -0,0 +1,29 @@
+/**
+ * Grok Build fence probe — wraps readGrokStatus (managed block only).
+ */
+import { readGrokStatus } from "../../grok/status";
+
+export interface GrokProbeResult {
+  present: boolean;
+  baseUrl: string | null;
+  model: string | null;
+  configPaths: string[];
+  notes: string[];
+}
+
+export function probeGrok(opts: { home?: string; grokHome?: string } = {}): GrokProbeResult {
+  const grokHome = opts.grokHome ?? (opts.home ? `${opts.home}/.grok` : undefined);
+  const status = readGrokStatus(grokHome !== undefined ? { grokHome } : {});
+  const notes: string[] = [];
+  if (!status.present) {
+    notes.push("No opencodex managed block in config.toml.");
+  }
+  const model = status.models[0]?.id ?? status.models[0]?.alias ?? null;
+  return {
+    present: status.present,
+    baseUrl: status.baseUrl,
+    model,
+    configPaths: [status.configPath],
+    notes: status.present ? [] : notes,
+  };
+}

package/src/clients/probes/opencode.ts

@@ -0,0 +1,109 @@
+/**
+ * OpenCode global config probe.
+ *
+ * Reads `options.baseURL` only — apiKey is never returned (privacy red line).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { opencodeGlobalConfigPath } from "../config-export";
+
+export interface OpencodeProbeResult {
+  present: boolean;
+  baseUrl: string | null;
+  model: string | null;
+  configPaths: string[];
+  notes: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function probeOpencode(opts: {
+  home?: string;
+  env?: NodeJS.ProcessEnv;
+  configPath?: string;
+} = {}): OpencodeProbeResult {
+  const path = opts.configPath
+    ?? opencodeGlobalConfigPath(opts.env ?? process.env, opts.home);
+  const notes: string[] = [];
+  if (!existsSync(path)) {
+    return { present: false, baseUrl: null, model: null, configPaths: [path], notes };
+  }
+
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    return {
+      present: true,
+      baseUrl: null,
+      model: null,
+      configPaths: [path],
+      notes: [`Could not read opencode.json: ${error instanceof Error ? error.message : String(error)}`],
+    };
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {
+      present: true,
+      baseUrl: null,
+      model: null,
+      configPaths: [path],
+      notes: ["opencode.json is not valid JSON"],
+    };
+  }
+
+  if (!isRecord(parsed)) {
+    return {
+      present: true,
+      baseUrl: null,
+      model: null,
+      configPaths: [path],
+      notes: ["opencode.json root is not an object"],
+    };
+  }
+
+  const provider = isRecord(parsed.provider) ? parsed.provider : {};
+  // Prefer an explicit opencodex provider block; otherwise take the first baseURL found.
+  let baseUrl: string | null = null;
+  let model: string | null = null;
+  const providerIds = Object.keys(provider);
+
+  const prefer = providerIds.includes("opencodex")
+    ? ["opencodex", ...providerIds.filter(id => id !== "opencodex")]
+    : providerIds;
+
+  for (const id of prefer) {
+    const block = provider[id];
+    if (!isRecord(block)) continue;
+    const options = isRecord(block.options) ? block.options : {};
+    // NEVER read options.apiKey.
+    const url = typeof options.baseURL === "string" ? options.baseURL.trim()
+      : typeof options.baseUrl === "string" ? options.baseUrl.trim()
+        : "";
+    if (!url) continue;
+    if (!baseUrl) {
+      baseUrl = url;
+      if (id !== "opencodex") notes.push(`Using provider "${id}" baseURL (no opencodex provider block).`);
+    }
+    const models = isRecord(block.models) ? block.models : null;
+    if (models && !model) {
+      const first = Object.keys(models)[0];
+      if (first) model = first;
+    }
+    if (baseUrl && id === "opencodex") break;
+  }
+
+  if (!baseUrl) notes.push("No provider options.baseURL found.");
+
+  return {
+    present: true,
+    baseUrl,
+    model,
+    configPaths: [path],
+    notes,
+  };
+}

package/src/clients/probes/paseo.ts

@@ -0,0 +1,55 @@
+/**
+ * Paseo launcher command probe (optional).
+ *
+ * Reads `~/.paseo/config.json` → `agents.providers.*.command` only.
+ * Env maps are ignored (may hold secrets).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface PaseoProviderCommand {
+  provider: string;
+  command: string[];
+}
+
+export function paseoConfigPath(home: string): string {
+  return join(home, ".paseo", "config.json");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function readPaseoProviderCommands(opts: {
+  home: string;
+  configPath?: string;
+} = { home: "" }): PaseoProviderCommand[] {
+  const path = opts.configPath ?? paseoConfigPath(opts.home);
+  if (!existsSync(path)) return [];
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!isRecord(parsed)) return [];
+
+  // Support both top-level `providers` and nested `agents.providers`.
+  const providersRoot = isRecord(parsed.agents) && isRecord(parsed.agents.providers)
+    ? parsed.agents.providers
+    : isRecord(parsed.providers)
+      ? parsed.providers
+      : null;
+  if (!providersRoot) return [];
+
+  const out: PaseoProviderCommand[] = [];
+  for (const [provider, value] of Object.entries(providersRoot)) {
+    if (!isRecord(value)) continue;
+    const command = value.command;
+    if (!Array.isArray(command) || !command.every(c => typeof c === "string")) continue;
+    if (command.length === 0) continue;
+    out.push({ provider, command: command as string[] });
+  }
+  return out;
+}

package/src/clients/probes/pi.ts

@@ -0,0 +1,55 @@
+/**
+ * Pi effective-status probe — wraps readPiModelsStatus + curated settings.
+ * Never reads auth.json.
+ */
+import { readPiModelsStatus } from "../../pi/models";
+import { readPiSettings } from "../../pi/settings";
+import { piAgentDirExists, piModelsPath, piSettingsPath, resolvePiAgentDir } from "../../pi/home";
+import { resolvePiBinary } from "../../pi/packages";
+
+export interface PiProbeResult {
+  present: boolean;
+  baseUrl: string | null;
+  model: string | null;
+  configPaths: string[];
+  notes: string[];
+  binary: string | null;
+}
+
+export function probePi(opts: { home?: string; piHome?: string } = {}): PiProbeResult {
+  // When a test home is supplied without piHome, treat home as the Pi root parent
+  // so fixtures can use `<tmp>/.pi/...` layout.
+  const piHome = opts.piHome ?? (opts.home ? `${opts.home}/.pi` : undefined);
+  const notes: string[] = [];
+  const models = readPiModelsStatus(piHome !== undefined ? { piHome } : {});
+  const settings = readPiSettings(piHome !== undefined ? { piHome } : {});
+  let binary: string | null = null;
+  try {
+    binary = resolvePiBinary();
+  } catch {
+    binary = null;
+  }
+
+  const agentDir = resolvePiAgentDir(piHome);
+  const present = models.present || piAgentDirExists(piHome) || settings.present;
+  const configPaths = [piModelsPath(piHome), piSettingsPath(piHome)];
+  if (piAgentDirExists(piHome)) configPaths.unshift(agentDir);
+
+  const model = settings.settings.defaultModel
+    ?? (models.models[0]?.id ?? null);
+  if (settings.settings.defaultProvider && settings.settings.defaultProvider !== "opencodex") {
+    notes.push(`defaultProvider is "${settings.settings.defaultProvider}" (not opencodex).`);
+  }
+  if (!models.present && present) {
+    notes.push("providers.opencodex block not present in models.json.");
+  }
+
+  return {
+    present,
+    baseUrl: models.baseUrl,
+    model,
+    configPaths: [...new Set(configPaths)],
+    notes,
+    binary,
+  };
+}