@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
173 lines (167 loc) • 10.2 kB
text/typescript
/** Explicit live lifecycle writes; the server remains the persistence authority. */
import { isValidProviderName } from "../config/provider-name";
import { providerRelativeSendPathConfigError } from "../config/provider-relative-send-path";
import { modelCapabilitiesConfigError, providerBaseUrlConfigError } from "../config/provider-validation";
import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers-destination";
import { parseProviderEditorConfigDTO, providerManagementConfigError } from "../server/auth-cors";
import type { OcxProviderConfig } from "../types";
import { printProviderReceipt, runProviderAction } from "./provider-result";
import { serializeManagementJson } from "./json-input";
import {
CliUsageError, runtimeBaseUrl, runtimeRequest, takeFlag, takeOptionWithSyntax,
type RuntimeApiDeps,
} from "./runtime-api";
const USAGE = `Usage:
ocx provider add <name> --live [--adapter <id>] [--base-url <url>]
[--api-key <key>] [--api-key-transport <x-api-key|bearer>]
[--auth-mode <key|forward|oauth|local>] [--responses-path <path>]
[--default-model <id>] [--model <id> --text-only]
[--google-tool-schema-policy <compatible|reject-lossy>]
[--allow-private-network] [--set-default] [--force] [--json]
ocx provider set-default <name> --live [--json]
ocx provider remove <name> --live --yes [--json]
Add checks the target roster before writing; a concurrent change can still win the upsert race.
--force permits overwriting an observed provider. --sync is not supported with --live.
Remove uses server default reassignment, dependency checks and account/custom-model cleanup.`;
const AUTH_MODES = new Set(["key", "forward", "oauth", "local"]);
const OPTION_FIELDS = {
"--adapter": "adapter", "--base-url": "baseUrl", "--api-key": "apiKey",
"--api-key-transport": "apiKeyTransport", "--auth-mode": "authMode",
"--responses-path": "responsesPath", "--default-model": "defaultModel",
"--google-tool-schema-policy": "googleToolSchemaPolicy",
} as const;
function record(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function invalid(message: string): never { throw new CliUsageError(message, USAGE); }
function flag(args: string[], name: string): boolean {
if (args.filter(arg => arg === name).length > 1) invalid("An option was given more than once.");
return takeFlag(args, name);
}
function checkExplicitFields(fields: Record<string, unknown>): void {
if (typeof fields.baseUrl === "string" && providerBaseUrlConfigError(fields.baseUrl)) invalid("Invalid provider base URL.");
if (providerRelativeSendPathConfigError("responsesPath", fields.responsesPath)) invalid("Invalid responses path.");
if (fields.authMode !== undefined && !AUTH_MODES.has(String(fields.authMode))) invalid("Invalid auth mode.");
if (fields.apiKeyTransport !== undefined && !["x-api-key", "bearer"].includes(String(fields.apiKeyTransport))) invalid("Invalid API key transport.");
if (fields.googleToolSchemaPolicy !== undefined && !["compatible", "reject-lossy"].includes(String(fields.googleToolSchemaPolicy))) invalid("Invalid Google tool schema policy.");
}
function parseAdd(args: string[]) {
const force = flag(args, "--force");
const setDefault = flag(args, "--set-default");
const allowPrivateNetwork = flag(args, "--allow-private-network");
const textOnly = flag(args, "--text-only");
const model = takeOptionWithSyntax(args, "--model")?.value;
const fields: Record<string, unknown> = {};
for (const [option, field] of Object.entries(OPTION_FIELDS)) {
const value = takeOptionWithSyntax(args, option)?.value;
if (value !== undefined) {
if (!value.trim()) invalid("Provider options require nonempty values.");
fields[field] = value;
}
}
if (allowPrivateNetwork) fields.allowPrivateNetwork = true;
if (args.length) invalid("Unexpected provider argument or option.");
if (model !== undefined && !textOnly) invalid("--model requires --text-only.");
if (model !== undefined && modelCapabilitiesConfigError({ [model]: { inputModalities: ["text"] } })) invalid("Invalid model capability selection.");
checkExplicitFields(fields);
return { force, setDefault, fields, textOnly, model };
}
function presetSeed(name: string, payload: unknown): Record<string, unknown> | undefined {
if (!record(payload) || !Array.isArray(payload.providers)
|| payload.providers.some(row => !record(row) || typeof row.id !== "string")) {
throw new Error("Invalid provider preset response.");
}
const matches = payload.providers.filter(row => row.id === name);
if (matches.length > 1) throw new Error("Ambiguous provider preset response.");
const preset = matches[0] as Record<string, unknown> | undefined;
if (!preset) return undefined;
// The target catalog's custom row is a form placeholder, not a provider seed.
if (name === "custom" && preset.baseUrl === "") return undefined;
if (name === "openai") {
const seed = preset.provider;
if (!record(seed) || typeof seed.baseUrl !== "string"
|| !isCanonicalOpenAiForwardProvider(seed as unknown as OcxProviderConfig)
|| !["pool", "direct"].includes(String(seed.codexAccountMode))
|| Object.hasOwn(seed, "allowPrivateNetwork")
|| !parseProviderEditorConfigDTO({ defaultProvider: name, providers: { [name]: seed } }).ok
|| providerRelativeSendPathConfigError("responsesPath", seed.responsesPath)) {
throw new Error("Invalid canonical provider preset.");
}
// Use the selected target's seed verbatim, never a local registry fallback.
return structuredClone(seed);
}
if (typeof preset.adapter !== "string" || !preset.adapter.trim()
|| typeof preset.baseUrl !== "string" || providerBaseUrlConfigError(preset.baseUrl)
|| typeof preset.auth !== "string" || !AUTH_MODES.has(preset.auth)) {
throw new Error("Invalid provider preset.");
}
const seed: Record<string, unknown> = { adapter: preset.adapter, baseUrl: preset.baseUrl, authMode: preset.auth };
for (const field of ["responsesPath", "chatCompletionsPath", "defaultModel"] as const) {
if (preset[field] !== undefined) {
if (typeof preset[field] !== "string" || !preset[field].trim()) throw new Error("Invalid provider preset.");
seed[field] = preset[field];
}
}
return seed;
}
/** Live add: an unoffered preset without --adapter/--base-url is a usage error (exit 2) before any write. */
async function add(name: string, options: ReturnType<typeof parseAdd>, wantsJson: boolean, deps: RuntimeApiDeps): Promise<number> {
const roster = await runtimeRequest<unknown>("/api/providers", { redirect: "error" }, deps);
if (!Array.isArray(roster) || roster.some(row => !record(row) || typeof row.name !== "string" || !isValidProviderName(row.name))) {
throw new Error("Invalid provider roster response.");
}
if (!options.force && roster.some(row => row.name === name)) {
console.error("Provider already exists on this target. Use --force to permit overwrite.");
return 5;
}
const presets = await runtimeRequest("/api/provider-presets", { redirect: "error" }, deps);
const seed = presetSeed(name, presets);
if (!seed && name === "openai") invalid("The selected target does not offer the canonical openai preset.");
if (!seed && (!options.fields.adapter || !options.fields.baseUrl)) {
invalid(`The selected target does not offer a "${name}" preset. Custom providers require --adapter and --base-url.`);
}
const provider = { ...seed, ...options.fields };
if (provider.googleToolSchemaPolicy !== undefined && provider.adapter !== "google") {
invalid("--google-tool-schema-policy requires the google adapter.");
}
if (provider.apiKey !== undefined && provider.authMode !== undefined && provider.authMode !== "key") {
invalid("--api-key requires key authentication; use the provider login workflow for account authentication.");
}
if (options.textOnly) {
const model = options.model ?? provider.defaultModel;
if (typeof model !== "string") invalid("--text-only requires --model or a default model.");
const capabilities = { [model]: { inputModalities: ["text"] } };
if (modelCapabilitiesConfigError(capabilities)) invalid("Invalid model capability selection.");
provider.modelCapabilities = capabilities;
}
if (name !== "openai" && providerManagementConfigError(name, provider)) invalid("Invalid provider configuration.");
const result = await runtimeRequest("/api/providers", {
method: "POST", redirect: "error",
body: serializeManagementJson({ name, provider, ...(options.setDefault ? { setDefault: true } : {}) }),
}, deps);
return printProviderReceipt(result, wantsJson, "added");
}
export async function handleProviderLifecycleRuntimeCommand(
sub: "add" | "remove" | "set-default", argv: string[], deps: RuntimeApiDeps = {},
): Promise<number> {
return runProviderAction(async () => {
const args = [...argv];
const wantsJson = flag(args, "--json");
const name = args.shift();
if (!name || !isValidProviderName(name)) invalid("A valid provider name is required.");
const options = sub === "add" ? parseAdd(args) : undefined;
const yes = sub === "remove" ? flag(args, "--yes") : false;
if (args.length) invalid("Unexpected provider argument or option.");
if (sub === "remove" && !yes) invalid("Live removal requires --yes.");
if (name === "openai" && options && (Object.keys(options.fields).length || options.textOnly)) {
invalid("Canonical OpenAI uses the target preset unchanged; add flags cannot override its seed.");
}
const pinned = { ...deps, baseUrl: await runtimeBaseUrl(deps) };
if (options) return add(name, options, wantsJson, pinned);
const result = await runtimeRequest(`/api/providers?name=${encodeURIComponent(name)}`, {
method: sub === "remove" ? "DELETE" : "PATCH", redirect: "error",
...(sub === "set-default" ? { body: JSON.stringify({ setDefault: true }) } : {}),
}, pinned);
return printProviderReceipt(result, wantsJson, sub === "remove" ? "removed" : "set-default");
});
}