pi-cliproxyapi 0.1.0

package/src/compat.ts

@@ -0,0 +1,128 @@
+// Local fallback heuristics + helpers for when /.well-known/pi is not available.
+// When /.well-known/pi succeeds, we trust the server. This module is the
+// secondary classifier (/v1/models path) and a couple of small utilities.
+
+import type { Api } from "@earendil-works/pi-ai";
+
+import type { CustomProviderModelConfig } from "./config.ts";
+
+/** API families we know how to route through CliProxyAPI. */
+export const ALLOWED_APIS: ReadonlySet<Api> = new Set<Api>([
+	"openai-completions",
+	"openai-responses",
+	"anthropic-messages",
+]);
+
+/**
+ * For openai-* APIs the proxy endpoint is "https://.../v1" — pass it through.
+ * For anthropic-messages the SDK expects the host root, so strip the trailing /v1.
+ */
+export function baseUrlFor(api: Api, endpoint: string): string {
+	const trimmed = endpoint.replace(/\/+$/, "");
+	if (api === "anthropic-messages") {
+		return trimmed.replace(/\/v1$/, "");
+	}
+	return trimmed;
+}
+
+/** Match the well-known glob-ish excludes (server-defined patterns like "*:*"). */
+export function isExcluded(id: string, patterns: string[]): boolean {
+	if (!id) return true;
+	for (const pat of patterns) {
+		const rx = new RegExp(
+			"^" + pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
+		);
+		if (rx.test(id)) return true;
+	}
+	return false;
+}
+
+/** Defaults used when the catalog has nothing on a model id. */
+export const DEFAULT_CONTEXT_WINDOW = 128_000;
+export const DEFAULT_MAX_TOKENS = 16_000;
+export const DEFAULT_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+};
+
+const REASONING_RX: RegExp[] = [
+	/.*-thinking$/,
+	/^gpt-5(\.\d+)?(-.*)?$/,
+	/^gemini-3(\.\d+)?(-.*)?$/,
+];
+
+export function reasoningFromId(id: string): boolean {
+	return REASONING_RX.some((rx) => rx.test(id));
+}
+
+/** owned_by → (suggested provider slug, default api). */
+const SUGGESTED_GROUPS: Array<[Set<string>, string, Api]> = [
+	[new Set(["zai"]), "glm", "openai-completions"],
+	[new Set(["Mistral"]), "mistral", "openai-completions"],
+	[new Set(["google", "antigravity"]), "gemini", "openai-completions"],
+	[new Set(["Ollama", "Ollama pay"]), "ollama", "openai-completions"],
+	[new Set(["Xiaomi"]), "mimo", "openai-completions"],
+	[new Set(["OpenRouter"]), "openrouter", "openai-completions"],
+	[new Set(["cerebras"]), "cerebras", "openai-completions"],
+];
+
+export function withProviderPrefix(
+	prefix: string | undefined,
+	suffix: string,
+): string {
+	const p = (prefix ?? "").trim();
+	return p ? `${p}-${suffix}` : suffix;
+}
+
+/**
+ * Server may suggest names with a legacy prefix.
+ * Re-map them to the user's chosen prefix; if the user hasn't set one, drop
+ * the legacy prefix entirely so we never surface our private namespace.
+ */
+export function normalizeSuggestedProvider(
+	suggestedProvider: string,
+	prefix: string | undefined,
+): string {
+	const p = (prefix ?? "").trim();
+	const m = suggestedProvider.match(/^([a-z0-9]+-)(.*)$/);
+	if (m) return p ? `${p}-${m[1]}` : m[1]!;
+	return suggestedProvider;
+}
+
+export function classifyCustom(
+	ownedBy: string,
+	prefix?: string,
+): { slug: string; api: Api } {
+	for (const [owners, suffix, api] of SUGGESTED_GROUPS) {
+		if (owners.has(ownedBy))
+			return { slug: withProviderPrefix(prefix, suffix), api };
+	}
+	return {
+		slug: withProviderPrefix(prefix, "misc"),
+		api: "openai-completions",
+	};
+}
+
+/** Make a friendly display name from an id like "glm-4.7" → "Glm 4.7". */
+export function prettifyName(id: string): string {
+	return id
+		.replace(/[/:]/g, " ")
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((p) => p[0]!.toUpperCase() + p.slice(1))
+		.join(" ");
+}
+
+/** Build a CustomProviderModelConfig from a raw upstream model id + metadata. */
+export function modelDefaults(id: string): CustomProviderModelConfig {
+	return {
+		id,
+		name: prettifyName(id),
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS,
+		reasoning: reasoningFromId(id),
+		cost: { ...DEFAULT_COST },
+	};
+}

package/src/config.ts

@@ -0,0 +1,199 @@
+// ~/.config/pi-cliproxyapi/config.json — load, validate, persist.
+//
+// Schema:
+//
+//   {
+//     "proxy": {
+//       "endpoint": "https://your-proxy.example.com/v1",
+//       "apiKey":   "!cat ~/.config/pi-cliproxyapi/key",
+//       "providerPrefix": "myproxy",
+//       "usageKey": "!cat ~/.config/pi-cliproxyapi/usage-key"
+//     },
+//     "builtinProviders": {
+//       "openai":    { "enabled": true,  "apiOverride": null, "models": ["gpt-5.2"] },
+//       "anthropic": { "enabled": true,                       "models": ["claude-opus-4-7"] }
+//     },
+//     "customProviders": {
+//       "myproxy-glm": {
+//         "api": "openai-completions",
+//         "models": [{ "id": "glm-4.7", "name": "GLM 4.7", "contextWindow": 128000, "maxTokens": 16000, "reasoning": true }]
+//       }
+//     },
+//     "discoveryExcludes": ["*:*"],
+//     "overrides": {},
+//     "refreshIntervalMinutes": 0,
+//     "usageCacheTtlMs": 30000
+//   }
+
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import type { Api } from "@earendil-works/pi-ai";
+
+import { log } from "./log.ts";
+
+export const CONFIG_DIR = join(homedir(), ".config", "pi-cliproxyapi");
+export const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export interface BuiltinProviderConfig {
+	enabled: boolean;
+	apiOverride?: Api | null;
+	models: string[];
+}
+
+export interface CustomProviderModelConfig {
+	id: string;
+	name?: string;
+	contextWindow?: number;
+	maxTokens?: number;
+	reasoning?: boolean;
+	cost?: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+	};
+}
+
+export interface CustomProviderConfig {
+	api: Api;
+	models: CustomProviderModelConfig[];
+}
+
+export interface ProxyConfig {
+	proxy: {
+		endpoint: string;
+		apiKey: string;
+		usageKey?: string;
+		/** Prefix used for default custom-provider slugs, e.g. `myproxy` -> `myproxy-glm`. */
+		providerPrefix?: string;
+	};
+	builtinProviders: Record<string, BuiltinProviderConfig>;
+	customProviders: Record<string, CustomProviderConfig>;
+	discoveryExcludes: string[];
+	overrides: Record<string, Partial<CustomProviderModelConfig>>;
+	refreshIntervalMinutes: number;
+	usageCacheTtlMs: number;
+}
+
+const DEFAULT_CONFIG: ProxyConfig = {
+	proxy: {
+		endpoint: "",
+		apiKey: "",
+	},
+	builtinProviders: {},
+	customProviders: {},
+	discoveryExcludes: ["*:*"],
+	overrides: {},
+	refreshIntervalMinutes: 0,
+	usageCacheTtlMs: 30_000,
+};
+
+export function loadConfig(): ProxyConfig {
+	if (!existsSync(CONFIG_PATH)) {
+		log.info("config not found, using defaults at", CONFIG_PATH);
+		return structuredClone(DEFAULT_CONFIG);
+	}
+	try {
+		const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+		return normalizeConfig(raw);
+	} catch (err) {
+		log.error("failed to read config:", err, "— using defaults");
+		return structuredClone(DEFAULT_CONFIG);
+	}
+}
+
+export function saveConfig(cfg: ProxyConfig): void {
+	mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+	writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+	log.info("config saved to", CONFIG_PATH);
+}
+
+function normalizeConfig(raw: unknown): ProxyConfig {
+	if (!raw || typeof raw !== "object") return structuredClone(DEFAULT_CONFIG);
+	const r = raw as Record<string, unknown>;
+	const merged = structuredClone(DEFAULT_CONFIG);
+	const proxyBlock =
+		(r.proxy as Record<string, unknown> | undefined) ??
+		{};
+	merged.proxy.endpoint =
+		typeof proxyBlock.endpoint === "string"
+			? proxyBlock.endpoint
+			: merged.proxy.endpoint;
+	merged.proxy.apiKey =
+		typeof proxyBlock.apiKey === "string" ? proxyBlock.apiKey : "";
+	if (typeof proxyBlock.usageKey === "string")
+		merged.proxy.usageKey = proxyBlock.usageKey;
+	if (
+		typeof proxyBlock.providerPrefix === "string" &&
+		proxyBlock.providerPrefix.trim()
+	) {
+		merged.proxy.providerPrefix = proxyBlock.providerPrefix.trim();
+	}
+
+	if (r.builtinProviders && typeof r.builtinProviders === "object") {
+		merged.builtinProviders = r.builtinProviders as Record<
+			string,
+			BuiltinProviderConfig
+		>;
+	}
+	if (r.customProviders && typeof r.customProviders === "object") {
+		merged.customProviders = r.customProviders as Record<
+			string,
+			CustomProviderConfig
+		>;
+	}
+	if (Array.isArray(r.discoveryExcludes)) {
+		merged.discoveryExcludes = r.discoveryExcludes.filter(
+			(x): x is string => typeof x === "string",
+		);
+	}
+	if (r.overrides && typeof r.overrides === "object") {
+		merged.overrides = r.overrides as Record<
+			string,
+			Partial<CustomProviderModelConfig>
+		>;
+	}
+	if (typeof r.refreshIntervalMinutes === "number")
+		merged.refreshIntervalMinutes = r.refreshIntervalMinutes;
+	if (typeof r.usageCacheTtlMs === "number")
+		merged.usageCacheTtlMs = r.usageCacheTtlMs;
+	return merged;
+}
+
+/**
+ * resolveConfigValue — same semantics Pi uses for apiKey:
+ *   "!cmd ..."     → run command, take stdout, trim
+ *   "$ENV_VAR"     → read process.env[ENV_VAR]
+ *   any other str  → return as-is
+ * Empty / undefined → "".
+ *
+ * We re-implement it locally rather than reach into pi internals; resolution
+ * happens once at apply time so the resolved key can be passed to
+ * pi.registerProvider verbatim.
+ */
+export function resolveConfigValue(raw: string | undefined | null): string {
+	if (!raw) return "";
+	const v = raw.trim();
+	if (v.startsWith("!")) {
+		try {
+			return execSync(v.slice(1), {
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "pipe"],
+			}).trim();
+		} catch (err) {
+			// Don't dump stack traces for the common "file not found" case — just say what didn't resolve.
+			const msg =
+				(err as { stderr?: Buffer | string })?.stderr?.toString?.()?.trim() ??
+				(err as Error).message;
+			log.warn(`failed to resolve "!" config value (${v}): ${msg}`);
+			return "";
+		}
+	}
+	if (v.startsWith("$")) {
+		return process.env[v.slice(1)] ?? "";
+	}
+	return v;
+}

package/src/conflicts.ts

@@ -0,0 +1,66 @@
+// Conflicts: read-only scan of Pi's own ~/.pi/models.json and ~/.pi/auth.json
+// to warn when an extension-registered provider collides with a user-edited
+// entry that Pi merges on top. We never write to these files.
+//
+// Both files are entirely optional (users might never touch them). Missing or
+// malformed → no warnings.
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import type { ProxyConfig } from "./config.ts";
+
+export interface ConflictWarning {
+	kind: "models.json" | "auth.json";
+	provider: string;
+	detail: string;
+}
+
+const MODELS_JSON = join(homedir(), ".pi", "models.json");
+const AUTH_JSON = join(homedir(), ".pi", "auth.json");
+
+function safeRead(path: string): unknown {
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+export function detectConflicts(cfg: ProxyConfig): ConflictWarning[] {
+	const out: ConflictWarning[] = [];
+	const providersInCfg = new Set<string>([
+		...Object.keys(cfg.builtinProviders),
+		...Object.keys(cfg.customProviders),
+	]);
+
+	const models = safeRead(MODELS_JSON);
+	if (models && typeof models === "object") {
+		for (const name of Object.keys(models as Record<string, unknown>)) {
+			if (providersInCfg.has(name)) {
+				out.push({
+					kind: "models.json",
+					provider: name,
+					detail: `provider "${name}" has user overrides in ~/.pi/models.json which Pi merges on top of our registration`,
+				});
+			}
+		}
+	}
+
+	const auth = safeRead(AUTH_JSON);
+	if (auth && typeof auth === "object") {
+		for (const name of Object.keys(auth as Record<string, unknown>)) {
+			if (providersInCfg.has(name)) {
+				out.push({
+					kind: "auth.json",
+					provider: name,
+					detail: `provider "${name}" has user-set credentials in ~/.pi/auth.json which take priority over our apiKey`,
+				});
+			}
+		}
+	}
+
+	return out;
+}