@bitkyc08/opencodex 2.7.41 → 2.7.42

package/src/cli/integrations.ts

@@ -0,0 +1,142 @@
+import {
+  CliUsageError,
+  csv,
+  printData,
+  rejectArgs,
+  runCliAction,
+  runtimeRequest,
+  summaryLines,
+  takeBooleanOption,
+  takeFlag,
+  takeOption,
+  type RuntimeApiDeps,
+} from "./runtime-api";
+
+const CLAUDE_USAGE = `Usage:
+  ocx claude config [status] [--json]
+  ocx claude config set [--enabled <on|off>] [--auth-mode <auto|proxy|subscription>]
+      [--system-env <on|off>] [--fast-mode <on|off>] [--auto-context <on|off>]
+      [--compact-window <tokens|default>] [--inject-agents <on|off>]
+      [--small-fast-model <id|->] [--model-map <from=to,from=to|->]
+      [--blocked-skills <name,name|->] [--web-model <id|->] [--web-backend <openai|anthropic|->]
+      [--vision-model <id|->] [--vision-backend <openai|anthropic|->] [--json]`;
+
+const GROK_USAGE = `Usage:
+  ocx grok [status] [--json]
+  ocx grok <exclude|include|set> <model,model...> [--json]
+  ocx grok clear [--json]
+  ocx grok apply [--json]`;
+
+function parseMap(raw: string): Record<string, string> {
+  if (raw === "-") return {};
+  const map: Record<string, string> = {};
+  for (const pair of raw.split(",")) {
+    const index = pair.indexOf("=");
+    if (index <= 0 || index === pair.length - 1) throw new CliUsageError(`invalid model map entry "${pair}"; use from=to`, CLAUDE_USAGE);
+    map[pair.slice(0, index).trim()] = pair.slice(index + 1).trim();
+  }
+  return map;
+}
+
+export async function handleClaudeConfigCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const args = [...argv];
+    const action = (args.shift() ?? "status").toLowerCase();
+    const wantsJson = takeFlag(args, "--json");
+    if (action === "status" || action === "show") {
+      rejectArgs(args, CLAUDE_USAGE);
+      const result = await runtimeRequest("/api/claude-code", {}, deps);
+      printData(result, wantsJson, summaryLines(result));
+      return;
+    }
+    if (action !== "set") throw new CliUsageError(`unknown Claude config command ${action}`, CLAUDE_USAGE);
+    const body: Record<string, unknown> = {};
+    const enabled = takeBooleanOption(args, "--enabled");
+    const authMode = takeOption(args, "--auth-mode");
+    const systemEnv = takeBooleanOption(args, "--system-env");
+    const fastMode = takeBooleanOption(args, "--fast-mode");
+    const autoContext = takeBooleanOption(args, "--auto-context");
+    const compact = takeOption(args, "--compact-window");
+    const injectAgents = takeBooleanOption(args, "--inject-agents");
+    const smallFastModel = takeOption(args, "--small-fast-model");
+    const modelMap = takeOption(args, "--model-map");
+    const blockedSkills = takeOption(args, "--blocked-skills");
+    const webModel = takeOption(args, "--web-model");
+    const webBackend = takeOption(args, "--web-backend");
+    const visionModel = takeOption(args, "--vision-model");
+    const visionBackend = takeOption(args, "--vision-backend");
+    rejectArgs(args, CLAUDE_USAGE);
+    if (enabled !== undefined) body.enabled = enabled;
+    if (authMode !== undefined) body.authMode = authMode;
+    if (systemEnv !== undefined) body.systemEnv = systemEnv;
+    if (fastMode !== undefined) body.fastMode = fastMode;
+    if (autoContext !== undefined) body.autoContext = autoContext;
+    if (compact !== undefined) {
+      if (compact === "default" || compact === "-") body.autoCompactWindow = null;
+      else {
+        const value = Number(compact.replace(/[_,]/g, ""));
+        if (!Number.isInteger(value) || value <= 0) throw new CliUsageError("--compact-window must be a positive integer or default", CLAUDE_USAGE);
+        body.autoCompactWindow = value;
+      }
+    }
+    if (injectAgents !== undefined) body.injectAgents = injectAgents;
+    if (smallFastModel !== undefined) body.smallFastModel = smallFastModel === "-" ? "" : smallFastModel;
+    if (modelMap !== undefined) body.modelMap = parseMap(modelMap);
+    if (blockedSkills !== undefined) body.blockedSkills = blockedSkills === "-" ? null : csv(blockedSkills);
+    const sidecar = (model: string | undefined, backend: string | undefined): Record<string, unknown> | undefined => {
+      if (model === undefined && backend === undefined) return undefined;
+      const result: Record<string, unknown> = {};
+      if (model !== undefined) result.model = model === "-" ? "" : model;
+      if (backend !== undefined) result.backend = backend === "-" ? null : backend;
+      return result;
+    };
+    const web = sidecar(webModel, webBackend);
+    const vision = sidecar(visionModel, visionBackend);
+    if (web) body.webSearchSidecar = web;
+    if (vision) body.visionSidecar = vision;
+    if (Object.keys(body).length === 0) throw new CliUsageError("at least one Claude setting is required", CLAUDE_USAGE);
+    const result = await runtimeRequest("/api/claude-code", { method: "PUT", body: JSON.stringify(body) }, deps);
+    printData(result, wantsJson, ["Claude Code settings updated."]);
+  });
+}
+
+type GrokState = Record<string, unknown> & { excluded?: string[] };
+
+export async function handleGrokCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const args = [...argv];
+    const action = (args.shift() ?? "status").toLowerCase();
+    const wantsJson = takeFlag(args, "--json");
+    if (action === "status" || action === "show") {
+      rejectArgs(args, GROK_USAGE);
+      const result = await runtimeRequest("/api/grok", {}, deps);
+      printData(result, wantsJson, summaryLines(result));
+      return;
+    }
+    if (action === "apply") {
+      rejectArgs(args, GROK_USAGE);
+      const result = await runtimeRequest("/api/grok/apply", { method: "POST" }, deps);
+      printData(result, wantsJson, [String((result as Record<string, unknown>).message ?? "Grok configuration applied.")]);
+      return;
+    }
+    let excluded: string[];
+    if (action === "clear") excluded = [];
+    else if (["exclude", "include", "set"].includes(action)) {
+      const raw = args.shift();
+      if (!raw) throw new CliUsageError("comma-separated models are required", GROK_USAGE);
+      const requested = csv(raw) ?? [];
+      if (action === "set") excluded = requested;
+      else {
+        const state = await runtimeRequest<GrokState>("/api/grok", {}, deps);
+        const current = new Set(state.excluded ?? []);
+        for (const model of requested) action === "exclude" ? current.add(model) : current.delete(model);
+        excluded = [...current].sort();
+      }
+    } else throw new CliUsageError(`unknown Grok command ${action}`, GROK_USAGE);
+    rejectArgs(args, GROK_USAGE);
+    const result = await runtimeRequest("/api/grok/selection", { method: "PUT", body: JSON.stringify({ excluded }) }, deps);
+    printData(result, wantsJson, [`Grok exclusions: ${excluded.join(", ") || "none"}`]);
+  });
+}
+
+export const INTEGRATION_USAGE = { claude: CLAUDE_USAGE, grok: GROK_USAGE };

package/src/cli/models-runtime.ts

@@ -0,0 +1,212 @@
+import {
+  CliUsageError,
+  csv,
+  printData,
+  rejectArgs,
+  runCliAction,
+  runtimeRequest,
+  summaryLines,
+  takeBooleanOption,
+  takeFlag,
+  takeIntegerOption,
+  takeOption,
+  type RuntimeApiDeps,
+} from "./runtime-api";
+
+const USAGE = `Usage:
+  ocx models live [--provider <name>] [--json]
+  ocx models edit <custom-id> [--model-id <id>] [--display-name <name|->]
+      [--context-window <tokens|0>] [--modalities <text,image,audio|->] [--json]
+  ocx models <enable|disable> <provider/model|native-model> [--native] [--json]
+  ocx models provider <name> <on|off> [--json]
+  ocx models selected <provider> [--set <id,id...>|--clear] [--json]
+  ocx models context <status|value <tokens>|provider <name> <on|off>|all <on|off>> [--json]
+  ocx models shadow <status|set> [model|-] [--enabled <on|off>] [--json]`;
+
+type ModelRow = {
+  provider?: string;
+  id?: string;
+  namespaced?: string;
+  native?: boolean;
+  disabled?: boolean;
+  custom?: boolean;
+  customId?: string;
+  displayName?: string;
+};
+
+async function live(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const provider = takeOption(args, "--provider");
+  rejectArgs(args, USAGE);
+  const rows = await runtimeRequest<ModelRow[]>("/api/models", {}, deps);
+  const filtered = provider ? rows.filter(row => row.provider === provider) : rows;
+  printData(filtered, wantsJson, filtered.map(row => {
+    const flags = [row.native ? "native" : "routed", row.custom ? "custom" : "", row.disabled ? "disabled" : "enabled"].filter(Boolean);
+    return `${row.namespaced ?? `${row.provider}/${row.id}`}  [${flags.join(", ")}]`;
+  }));
+}
+
+async function edit(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const id = args.shift()?.trim();
+  const wantsJson = takeFlag(args, "--json");
+  if (!id) throw new CliUsageError("custom model id is required", USAGE);
+  const patch: Record<string, unknown> = {};
+  const modelId = takeOption(args, "--model-id");
+  const displayName = takeOption(args, "--display-name");
+  const contextRaw = takeOption(args, "--context-window");
+  const modalitiesRaw = takeOption(args, "--modalities");
+  rejectArgs(args, USAGE);
+  if (modelId !== undefined) patch.modelId = modelId;
+  if (displayName !== undefined) patch.displayName = displayName === "-" ? "" : displayName;
+  if (contextRaw !== undefined) {
+    const value = Number(contextRaw.replace(/[_,]/g, ""));
+    if (!Number.isInteger(value) || value < 0) throw new CliUsageError("--context-window must be an integer >= 0", USAGE);
+    patch.contextWindow = value === 0 ? null : value;
+  }
+  if (modalitiesRaw !== undefined) patch.inputModalities = modalitiesRaw === "-" ? [] : csv(modalitiesRaw);
+  if (Object.keys(patch).length === 0) throw new CliUsageError("at least one edit option is required", USAGE);
+  const result = await runtimeRequest(`/api/custom-models/${encodeURIComponent(id)}`, {
+    method: "PUT",
+    body: JSON.stringify(patch),
+  }, deps);
+  printData(result, wantsJson, [`Updated custom model ${id}.`]);
+}
+
+function parseSelector(selector: string, forceNative: boolean): { provider: string; id: string; native: boolean } {
+  if (forceNative || !selector.includes("/")) return { provider: "openai", id: selector, native: true };
+  const slash = selector.indexOf("/");
+  const provider = selector.slice(0, slash);
+  const id = selector.slice(slash + 1);
+  if (!provider || !id) throw new CliUsageError("model selector must be provider/model or a native model id", USAGE);
+  return { provider, id, native: false };
+}
+
+async function visibility(enabled: boolean, argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const selector = args.shift()?.trim();
+  const wantsJson = takeFlag(args, "--json");
+  const native = takeFlag(args, "--native");
+  if (!selector) throw new CliUsageError("model selector is required", USAGE);
+  rejectArgs(args, USAGE);
+  const target = parseSelector(selector, native);
+  const result = await runtimeRequest("/api/model-visibility", {
+    method: "PUT",
+    body: JSON.stringify({ scope: "models", provider: target.provider, enabled, targets: [{ id: target.id, native: target.native }] }),
+  }, deps);
+  printData(result, wantsJson, [`${enabled ? "Enabled" : "Disabled"} ${selector}.`]);
+}
+
+async function providerVisibility(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const provider = args.shift()?.trim();
+  const state = args.shift()?.toLowerCase();
+  const wantsJson = takeFlag(args, "--json");
+  if (!provider || (state !== "on" && state !== "off")) throw new CliUsageError("provider and on|off are required", USAGE);
+  rejectArgs(args, USAGE);
+  const rows = await runtimeRequest<ModelRow[]>("/api/models", {}, deps);
+  const targets = rows.filter(row => row.provider === provider && typeof row.id === "string")
+    .map(row => ({ id: row.id!, native: row.native === true }));
+  if (targets.length === 0) throw new CliUsageError(`no models are available for provider ${provider}`);
+  const result = await runtimeRequest("/api/model-visibility", {
+    method: "PUT",
+    body: JSON.stringify({ scope: "provider", provider, enabled: state === "on", targets }),
+  }, deps);
+  printData(result, wantsJson, [`${provider}: ${state}`]);
+}
+
+async function selected(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const provider = args.shift()?.trim();
+  const wantsJson = takeFlag(args, "--json");
+  const selectedModels = csv(takeOption(args, "--set"));
+  const clear = takeFlag(args, "--clear");
+  if (!provider) throw new CliUsageError("provider is required", USAGE);
+  if (selectedModels !== undefined && clear) throw new CliUsageError("--set and --clear cannot be combined", USAGE);
+  rejectArgs(args, USAGE);
+  if (selectedModels === undefined && !clear) {
+    const result = await runtimeRequest<Record<string, unknown>>("/api/selected-models", {}, deps);
+    const map = result.selected as Record<string, string[]> | undefined;
+    const available = result.available as Record<string, string[]> | undefined;
+    const view = { provider, selected: map?.[provider] ?? [], available: available?.[provider] ?? [] };
+    printData(view, wantsJson, [`${provider}: ${view.selected.join(", ") || "all models"}`]);
+    return;
+  }
+  const models = clear ? [] : selectedModels!;
+  const result = await runtimeRequest("/api/selected-models", {
+    method: "PUT",
+    body: JSON.stringify({ provider, models }),
+  }, deps);
+  printData(result, wantsJson, [`${provider}: ${models.length ? models.join(", ") : "all models"}`]);
+}
+
+async function context(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const action = (args.shift() ?? "status").toLowerCase();
+  const wantsJson = takeFlag(args, "--json");
+  if (action === "status") {
+    rejectArgs(args, USAGE);
+    const result = await runtimeRequest("/api/provider-context-caps", {}, deps);
+    printData(result, wantsJson, summaryLines(result));
+    return;
+  }
+  let body: Record<string, unknown>;
+  if (action === "value") {
+    const raw = args.shift();
+    if (!raw) throw new CliUsageError("context value is required", USAGE);
+    const value = Number(raw.replace(/[_,]/g, ""));
+    if (!Number.isInteger(value) || value <= 0) throw new CliUsageError("context value must be a positive integer", USAGE);
+    body = { value };
+  } else if (action === "provider") {
+    const provider = args.shift()?.trim();
+    const state = args.shift()?.toLowerCase();
+    if (!provider || (state !== "on" && state !== "off")) throw new CliUsageError("provider and on|off are required", USAGE);
+    body = { provider, enabled: state === "on" };
+  } else if (action === "all") {
+    const state = args.shift()?.toLowerCase();
+    if (state !== "on" && state !== "off") throw new CliUsageError("all requires on|off", USAGE);
+    body = { setAll: state === "on" };
+  } else throw new CliUsageError(`unknown context action ${action}`, USAGE);
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest("/api/provider-context-caps", { method: "PUT", body: JSON.stringify(body) }, deps);
+  printData(result, wantsJson, ["Context cap settings updated."]);
+}
+
+async function shadow(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const action = (args.shift() ?? "status").toLowerCase();
+  const wantsJson = takeFlag(args, "--json");
+  if (action === "status") {
+    rejectArgs(args, USAGE);
+    const result = await runtimeRequest("/api/shadow-call-settings", {}, deps);
+    printData(result, wantsJson);
+    return;
+  }
+  if (action !== "set") throw new CliUsageError(`unknown shadow action ${action}`, USAGE);
+  const modelRaw = args[0] && !args[0].startsWith("--") ? args.shift() : undefined;
+  const enabled = takeBooleanOption(args, "--enabled");
+  rejectArgs(args, USAGE);
+  const body: Record<string, unknown> = {};
+  if (modelRaw !== undefined) body.model = modelRaw === "-" ? "" : modelRaw;
+  if (enabled !== undefined) body.enabled = enabled;
+  if (Object.keys(body).length === 0) throw new CliUsageError("model and/or --enabled is required", USAGE);
+  const result = await runtimeRequest("/api/shadow-call-settings", { method: "PUT", body: JSON.stringify(body) }, deps);
+  printData(result, wantsJson, ["Shadow-call settings updated."]);
+}
+
+export async function handleModelsRuntimeCommand(sub: string, argv: string[], deps: RuntimeApiDeps = {}): Promise<number | null> {
+  let action: (() => Promise<void>) | undefined;
+  if (sub === "live") action = () => live(argv, deps);
+  else if (sub === "edit") action = () => edit(argv, deps);
+  else if (sub === "enable") action = () => visibility(true, argv, deps);
+  else if (sub === "disable") action = () => visibility(false, argv, deps);
+  else if (sub === "provider") action = () => providerVisibility(argv, deps);
+  else if (sub === "selected") action = () => selected(argv, deps);
+  else if (sub === "context") action = () => context(argv, deps);
+  else if (sub === "shadow") action = () => shadow(argv, deps);
+  if (!action) return null;
+  return runCliAction(action);
+}
+
+export const MODELS_RUNTIME_USAGE = USAGE;

package/src/cli/models.ts

@@ -312,26 +312,25 @@ function handleConfiguredModels(args: string[]): void {
   console.log("Note: providers with liveModels may have additional models at runtime.");
 }
 
-function runCustomCommand(command: Promise<void>): void {
-  command.catch(error => {
-    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-    process.exitCode = 1;
-  });
-}
-
-export function handleModels(args: string[]): void {
+export async function handleModels(args: string[]): Promise<void> {
   const [subcommand, ...rest] = args;
   if (subcommand === "add") {
-    runCustomCommand(handleCustomAdd(rest));
+    await handleCustomAdd(rest);
     return;
   }
   if (subcommand === "remove") {
-    runCustomCommand(handleCustomRemove(rest));
+    await handleCustomRemove(rest);
     return;
   }
   if (subcommand === "list-custom") {
     handleCustomList(rest);
     return;
   }
+  if (["live", "edit", "enable", "disable", "provider", "selected", "context", "shadow"].includes(subcommand ?? "")) {
+    const { handleModelsRuntimeCommand } = await import("./models-runtime");
+    const code = await handleModelsRuntimeCommand(subcommand!, rest);
+    if (code !== null) process.exitCode = code;
+    return;
+  }
   handleConfiguredModels(subcommand === "list" ? rest : args);
 }

package/src/cli/observe.ts

@@ -0,0 +1,117 @@
+import {
+  CliUsageError,
+  printData,
+  rejectArgs,
+  runCliAction,
+  runtimeRequest,
+  summaryLines,
+  takeFlag,
+  takeIntegerOption,
+  takeOption,
+  type RuntimeApiDeps,
+} from "./runtime-api";
+
+const USAGE = `Usage:
+  ocx observe logs [--provider <name>] [--model <id>] [--status <code>]
+      [--limit <n>] [--follow] [--json|--jsonl]
+  ocx observe usage [--range <7d|30d|all>] [--surface <all|codex|claude|grok>] [--json]
+  ocx observe storage [--json]
+  ocx observe memory [--json]
+  ocx observe debug [--json]
+  ocx observe claude-inbound [--limit <n>] [--json]
+  ocx observe injection [--limit <n>] [--json]`;
+
+type LogEntry = Record<string, unknown> & { id?: string | number; timestamp?: string; provider?: string; model?: string; status?: number };
+
+function query(params: Record<string, string | number | undefined>): string {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) if (value !== undefined) search.set(key, String(value));
+  const encoded = search.toString();
+  return encoded ? `?${encoded}` : "";
+}
+
+function logRows(data: unknown): LogEntry[] {
+  if (Array.isArray(data)) return data as LogEntry[];
+  if (data && typeof data === "object") {
+    const record = data as Record<string, unknown>;
+    for (const key of ["logs", "entries", "requests"]) if (Array.isArray(record[key])) return record[key] as LogEntry[];
+  }
+  return [];
+}
+
+function formatLog(row: LogEntry): string {
+  const time = String(row.timestamp ?? row.createdAt ?? "");
+  const route = [row.provider, row.model].filter(Boolean).join("/");
+  const status = row.status ?? row.statusCode ?? "?";
+  const duration = row.durationMs !== undefined ? `${String(row.durationMs)}ms` : "";
+  return [time, String(status), route, duration].filter(Boolean).join("  ");
+}
+
+async function logs(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const wantsJsonl = takeFlag(args, "--jsonl");
+  const follow = takeFlag(args, "--follow") || takeFlag(args, "-f");
+  const provider = takeOption(args, "--provider");
+  const model = takeOption(args, "--model");
+  const status = takeOption(args, "--status");
+  const limit = takeIntegerOption(args, "--limit", { min: 1 }) ?? 200;
+  rejectArgs(args, USAGE);
+  if (wantsJson && wantsJsonl) throw new CliUsageError("--json and --jsonl cannot be combined", USAGE);
+  if (follow && wantsJson) throw new CliUsageError("--follow uses --jsonl, not --json", USAGE);
+  let seen = new Set<string>();
+  do {
+    const data = await runtimeRequest(`/api/logs${query({ provider, model, status, limit })}`, {}, deps);
+    const rows = logRows(data);
+    if (!follow && wantsJson) printData(data, true);
+    else {
+      for (const row of rows) {
+        const key = String(row.id ?? `${row.timestamp}:${row.provider}:${row.model}:${row.status}`);
+        if (follow && seen.has(key)) continue;
+        if (wantsJsonl) console.log(JSON.stringify(row));
+        else console.log(formatLog(row));
+        seen.add(key);
+      }
+    }
+    if (!follow) return;
+    if (seen.size > 5_000) seen = new Set([...seen].slice(-2_500));
+    await Bun.sleep(1_000);
+  } while (true);
+}
+
+async function usage(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const range = takeOption(args, "--range") ?? "30d";
+  const surface = takeOption(args, "--surface") ?? "all";
+  if (!["7d", "30d", "all"].includes(range)) throw new CliUsageError("--range must be 7d, 30d, or all", USAGE);
+  if (!["all", "codex", "claude", "grok"].includes(surface)) throw new CliUsageError("--surface must be all, codex, claude, or grok", USAGE);
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest(`/api/usage${query({ range, surface })}`, {}, deps);
+  printData(result, wantsJson, summaryLines(result));
+}
+
+async function simple(path: string, argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const limit = takeIntegerOption(args, "--limit", { min: 1 });
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest(`${path}${query({ limit })}`, {}, deps);
+  printData(result, wantsJson, summaryLines(result));
+}
+
+export async function handleObserveCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const [sub = "logs", ...rest] = argv;
+    if (sub === "logs") await logs(rest, deps);
+    else if (sub === "usage") await usage(rest, deps);
+    else if (sub === "storage") await simple("/api/storage", rest, deps);
+    else if (sub === "memory") await simple("/api/system/memory", rest, deps);
+    else if (sub === "debug") await simple("/api/debug", rest, deps);
+    else if (sub === "claude-inbound") await simple("/api/claude/inbound-debug", rest, deps);
+    else if (sub === "injection") await simple("/api/debug/injection-logs", rest, deps);
+    else throw new CliUsageError(`unknown observe command ${sub}`, USAGE);
+  });
+}
+
+export const OBSERVE_USAGE = USAGE;

package/src/cli/provider-runtime.ts

@@ -0,0 +1,152 @@
+import {
+  CliUsageError,
+  csv,
+  printData,
+  rejectArgs,
+  runCliAction,
+  runtimeRequest,
+  summaryLines,
+  takeBooleanOption,
+  takeFlag,
+  takeOption,
+  type RuntimeApiDeps,
+} from "./runtime-api";
+
+const USAGE = `Usage:
+  ocx provider edit <name> [--adapter <id>] [--base-url <url>] [--default-model <id|->]
+      [--auth-mode <key|forward|oauth|local|->] [--note <text|->]
+      [--enabled <on|off>] [--live-models <on|off>] [--allow-private-network <on|off>] [--json]
+  ocx provider test <name> [--json]
+  ocx provider quota [--refresh] [--json]
+  ocx provider presets [--json]
+  ocx provider account-mode <pool|direct> [--json]
+  ocx provider selected <name> [--set <model,model...>] [--clear] [--json]`;
+
+function cleared(value: string | undefined): string | undefined {
+  return value === "-" ? "" : value;
+}
+
+async function edit(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const name = args.shift()?.trim();
+  if (!name) throw new CliUsageError("provider name is required", USAGE);
+  const wantsJson = takeFlag(args, "--json");
+  const patch: Record<string, unknown> = {};
+  const adapter = takeOption(args, "--adapter");
+  const baseUrl = takeOption(args, "--base-url");
+  const defaultModel = cleared(takeOption(args, "--default-model"));
+  const authMode = cleared(takeOption(args, "--auth-mode"));
+  const note = cleared(takeOption(args, "--note"));
+  const enabled = takeBooleanOption(args, "--enabled");
+  const liveModels = takeBooleanOption(args, "--live-models");
+  const allowPrivateNetwork = takeBooleanOption(args, "--allow-private-network");
+  rejectArgs(args, USAGE);
+  if (adapter !== undefined) patch.adapter = adapter;
+  if (baseUrl !== undefined) patch.baseUrl = baseUrl;
+  if (defaultModel !== undefined) patch.defaultModel = defaultModel;
+  if (authMode !== undefined) patch.authMode = authMode;
+  if (note !== undefined) patch.note = note;
+  if (enabled !== undefined) patch.disabled = !enabled;
+  if (liveModels !== undefined) patch.liveModels = liveModels;
+  if (allowPrivateNetwork !== undefined) patch.allowPrivateNetwork = allowPrivateNetwork;
+  if (Object.keys(patch).length === 0) throw new CliUsageError("at least one edit option is required", USAGE);
+  const result = await runtimeRequest(`/api/providers?name=${encodeURIComponent(name)}`, {
+    method: "PATCH",
+    body: JSON.stringify(patch),
+  }, deps);
+  printData(result, wantsJson, [`Updated provider ${name}.`]);
+}
+
+async function testProvider(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const name = args.shift()?.trim();
+  const wantsJson = takeFlag(args, "--json");
+  if (!name) throw new CliUsageError("provider name is required", USAGE);
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest<Record<string, unknown>>(`/api/providers/test?name=${encodeURIComponent(name)}`, {
+    method: "POST",
+  }, deps);
+  const ok = result.ok === true;
+  printData(result, wantsJson, [
+    `${name}: ${ok ? "connected" : "failed"}`,
+    String(result.message ?? result.error ?? "No detail"),
+    `Latency: ${String(result.latencyMs ?? "?")} ms`,
+  ]);
+  if (!ok) process.exitCode = 1;
+}
+
+async function quota(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  const refresh = takeFlag(args, "--refresh");
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest(`/api/provider-quotas${refresh ? "?refresh=1" : ""}`, {}, deps);
+  printData(result, wantsJson, summaryLines(result));
+}
+
+async function presets(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const wantsJson = takeFlag(args, "--json");
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest<{ providers?: unknown[] } | unknown[]>("/api/provider-presets", {}, deps);
+  const rows = Array.isArray(result) ? result : result.providers ?? [];
+  printData(result, wantsJson, rows.map(row => {
+    const record = row as Record<string, unknown>;
+    return `${String(record.id ?? record.name ?? "?")}  ${String(record.label ?? record.adapter ?? "")}`.trimEnd();
+  }));
+}
+
+async function accountMode(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const mode = args.shift();
+  const wantsJson = takeFlag(args, "--json");
+  if (mode !== "pool" && mode !== "direct") throw new CliUsageError("mode must be pool or direct", USAGE);
+  rejectArgs(args, USAGE);
+  const result = await runtimeRequest("/api/providers?name=openai", {
+    method: "PATCH",
+    body: JSON.stringify({ codexAccountMode: mode }),
+  }, deps);
+  printData(result, wantsJson, [`OpenAI Codex account mode: ${mode}`]);
+}
+
+async function selected(argv: string[], deps: RuntimeApiDeps): Promise<void> {
+  const args = [...argv];
+  const name = args.shift()?.trim();
+  const wantsJson = takeFlag(args, "--json");
+  const set = csv(takeOption(args, "--set"));
+  const clear = takeFlag(args, "--clear");
+  if (!name) throw new CliUsageError("provider name is required", USAGE);
+  if (set !== undefined && clear) throw new CliUsageError("--set and --clear cannot be combined", USAGE);
+  rejectArgs(args, USAGE);
+  if (set === undefined && !clear) {
+    const result = await runtimeRequest<Record<string, unknown>>("/api/selected-models", {}, deps);
+    const selectedMap = (result.selected ?? {}) as Record<string, string[]>;
+    const availableMap = (result.available ?? {}) as Record<string, string[]>;
+    printData({ provider: name, selected: selectedMap[name] ?? [], available: availableMap[name] ?? [] }, wantsJson,
+      [`Selected models for ${name}: ${(selectedMap[name] ?? []).join(", ") || "all"}`]);
+    return;
+  }
+  const models = clear ? [] : (set ?? []);
+  const result = await runtimeRequest("/api/selected-models", {
+    method: "PUT",
+    body: JSON.stringify({ provider: name, models }),
+  }, deps);
+  printData(result, wantsJson, [`${name}: ${models.length ? models.join(", ") : "all models"}`]);
+}
+
+export async function handleProviderRuntimeCommand(sub: string, argv: string[], deps: RuntimeApiDeps = {}): Promise<number | null> {
+  const handlers: Record<string, (args: string[], deps: RuntimeApiDeps) => Promise<void>> = {
+    edit,
+    update: edit,
+    test: testProvider,
+    quota,
+    presets,
+    "account-mode": accountMode,
+    selected,
+  };
+  const handler = handlers[sub];
+  if (!handler) return null;
+  return runCliAction(() => handler(argv, deps));
+}
+
+export const PROVIDER_RUNTIME_USAGE = USAGE;