@yhong91/cpac 0.1.25 → 0.1.27

package/dist/config.js

@@ -0,0 +1,440 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, rmdirSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { isAbsolute, join, parse, relative, resolve } from "node:path";
+import { CPACError, atomicWrite, checkboxPicker, expandUserPath, objectValue, } from "./util.js";
+export const PROVIDER = "cpac_cpa";
+export const DEFAULT_CPA_URL = "http://124.223.178.52:8317";
+export const DEFAULT_CODEX_PROXY_PORT = 10101;
+const MAX_CATALOG_BYTES = 16 * 1024 * 1024;
+const CONFIG_KEYS = new Set([
+    "cpa_url",
+    "api_key_env",
+    "codex_config",
+    "codex_proxy_port",
+    "state_dir",
+    "claude_models",
+    "spawn_models",
+]);
+// Codex advertises only the first 5 picker-visible catalog models as
+// spawn_agent overrides (codex-rs MAX_SPAWN_AGENT_MODEL_OVERRIDES).
+const MAX_SPAWN_MODELS = 5;
+export const CLAUDE_SLOT_KEYS = ["opus", "sonnet", "haiku"];
+const REQUIRED_STATE_KEYS = new Set([
+    "config_path",
+    "config_existed",
+    "config_mode",
+]);
+const STATE_KEYS = new Set([
+    ...REQUIRED_STATE_KEYS,
+    "proxy_id",
+    "proxy_fingerprint",
+    "proxy_pid",
+    "proxy_port",
+]);
+export const STATE_FILES = [
+    "state.json",
+    "config.toml.backup",
+    "codex-models.json",
+];
+export function defaultConfigPath() {
+    return resolve(expandUserPath(process.env.CPAC_CONFIG || "~/.config/cpac/config.json"));
+}
+function normalizeCpaUrl(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new CPACError("cpa_url must be a non-empty string");
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new CPACError("cpa_url must be an absolute http(s) URL");
+    }
+    if (!["http:", "https:"].includes(parsed.protocol) ||
+        !parsed.hostname ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash) {
+        throw new CPACError("cpa_url must be an absolute http(s) URL without credentials, query, or fragment");
+    }
+    return value.trim().replace(/\/+$/, "");
+}
+export function loadConfig(path, useDefaultsIfMissing = false) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT" &&
+            useDefaultsIfMissing) {
+            value = {};
+        }
+        else if (error.code === "ENOENT") {
+            throw new CPACError(`config not found: ${path}`);
+        }
+        else {
+            throw new CPACError(`cannot read config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!objectValue(value))
+        throw new CPACError("config must be a JSON object");
+    const unknown = Object.keys(value)
+        .filter((key) => !CONFIG_KEYS.has(key))
+        .sort();
+    if (unknown.length)
+        throw new CPACError(`unknown config keys: ${unknown.join(", ")}`);
+    const cpaUrl = normalizeCpaUrl(value.cpa_url ?? process.env.CPA_BASE_URL?.trim() ?? DEFAULT_CPA_URL);
+    const apiKeyEnv = value.api_key_env ?? "CPA_API_KEY";
+    if (typeof apiKeyEnv !== "string" ||
+        !/^[A-Za-z_][A-Za-z0-9_]*$/.test(apiKeyEnv)) {
+        throw new CPACError("api_key_env must be an environment variable name");
+    }
+    if (value.codex_config !== undefined &&
+        (typeof value.codex_config !== "string" || !value.codex_config.trim())) {
+        throw new CPACError("codex_config must be a non-empty string");
+    }
+    if (value.state_dir !== undefined &&
+        (typeof value.state_dir !== "string" || !value.state_dir.trim())) {
+        throw new CPACError("state_dir must be a non-empty string");
+    }
+    const codexProxyPort = value.codex_proxy_port ?? DEFAULT_CODEX_PROXY_PORT;
+    if (!Number.isInteger(codexProxyPort) ||
+        codexProxyPort < 0 ||
+        codexProxyPort > 65535) {
+        throw new CPACError("codex_proxy_port must be an integer from 0 to 65535");
+    }
+    const claudeModelsRaw = value.claude_models;
+    let claudeModels;
+    if (claudeModelsRaw !== undefined) {
+        if (!objectValue(claudeModelsRaw))
+            throw new CPACError("claude_models must be an object");
+        const unknownSlots = Object.keys(claudeModelsRaw)
+            // "classifier" was a shipped slot; its env var turned out unread by
+            // Claude Code, so the key is dropped on load instead of erroring.
+            .filter((key) => key !== "classifier" && !CLAUDE_SLOT_KEYS.includes(key))
+            .sort();
+        if (unknownSlots.length)
+            throw new CPACError(`unknown claude_models slots: ${unknownSlots.join(", ")}`);
+        claudeModels = {};
+        for (const slot of CLAUDE_SLOT_KEYS) {
+            const model = claudeModelsRaw[slot];
+            if (model === undefined)
+                continue;
+            if (typeof model !== "string" || !model.trim())
+                throw new CPACError(`claude_models.${slot} must be a non-empty string`);
+            claudeModels[slot] = model.trim();
+        }
+    }
+    const spawnModelsRaw = value.spawn_models;
+    let spawnModels;
+    if (spawnModelsRaw !== undefined) {
+        if (!Array.isArray(spawnModelsRaw))
+            throw new CPACError("spawn_models must be an array of model slugs");
+        if (spawnModelsRaw.length > MAX_SPAWN_MODELS)
+            throw new CPACError(`spawn_models accepts at most ${MAX_SPAWN_MODELS} models`);
+        spawnModels = spawnModelsRaw.map((model, index) => {
+            if (typeof model !== "string" || !model.trim())
+                throw new CPACError(`spawn_models[${index}] must be a non-empty string`);
+            return model.trim();
+        });
+    }
+    const codexHome = expandUserPath(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
+    const codexConfig = resolve(expandUserPath(value.codex_config || join(codexHome, "config.toml")));
+    const stateDir = resolve(expandUserPath(value.state_dir || join(homedir(), ".cpac")));
+    const stateToConfig = relative(stateDir, codexConfig);
+    if ([parse(stateDir).root, resolve(homedir()), resolve(tmpdir())].includes(stateDir) ||
+        stateToConfig === "" ||
+        (!stateToConfig.startsWith("..") && !isAbsolute(stateToConfig))) {
+        throw new CPACError("state_dir must not be a filesystem root, home/temp directory, or contain codex_config");
+    }
+    return {
+        cpa_url: cpaUrl,
+        api_key_env: apiKeyEnv,
+        codex_config: codexConfig,
+        codex_proxy_port: codexProxyPort,
+        state_dir: stateDir,
+        claude_models: claudeModels,
+        spawn_models: spawnModels,
+    };
+}
+export function apiBase(cpaUrl) {
+    try {
+        const url = new URL(cpaUrl);
+        return url.pathname.replace(/\/+$/, "").endsWith("/v1")
+            ? cpaUrl
+            : `${cpaUrl}/v1`;
+    }
+    catch {
+        throw new CPACError("cpa_url must be an absolute http(s) URL");
+    }
+}
+export async function fetchCatalog(cpaUrl, apiKey) {
+    let response;
+    try {
+        response = await fetch(`${apiBase(cpaUrl)}/models?client_version=1`, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                Accept: "application/json",
+            },
+            signal: AbortSignal.timeout(20_000),
+        });
+    }
+    catch {
+        throw new CPACError("CPA catalog request failed");
+    }
+    if (!response.ok)
+        throw new CPACError(`CPA catalog request failed: HTTP ${response.status}`);
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength &&
+        /^\d+$/.test(declaredLength) &&
+        Number(declaredLength) > MAX_CATALOG_BYTES) {
+        await response.body?.cancel();
+        throw new CPACError("CPA catalog exceeds 16 MiB");
+    }
+    const chunks = [];
+    let length = 0;
+    const reader = response.body?.getReader();
+    if (reader) {
+        while (true) {
+            let result;
+            try {
+                result = await reader.read();
+            }
+            catch {
+                throw new CPACError("CPA catalog request failed");
+            }
+            if (result.done)
+                break;
+            length += result.value.byteLength;
+            if (length > MAX_CATALOG_BYTES) {
+                await reader.cancel();
+                throw new CPACError("CPA catalog exceeds 16 MiB");
+            }
+            chunks.push(result.value);
+        }
+    }
+    const body = Buffer.concat(chunks, length);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body));
+    }
+    catch {
+        throw new CPACError("CPA catalog is not valid JSON");
+    }
+    const models = objectValue(document) ? document.models : undefined;
+    if (!Array.isArray(models) || models.length === 0) {
+        throw new CPACError("CPA rich catalog must contain a non-empty models array");
+    }
+    if (models.some((model) => !objectValue(model) || typeof model.slug !== "string" || !model.slug.trim())) {
+        throw new CPACError("CPA catalog contains a model without a slug");
+    }
+    return {
+        bytes: Buffer.from(`${JSON.stringify(document, null, 2)}\n`),
+        modelCount: models.length,
+    };
+}
+// Codex treats a catalog model's context_window as its input budget, not a
+// display label; upstream keeps it a conservative operating cap while
+// max_context_window holds the real ceiling (gpt-5.6: 272k vs ~921k, measured
+// by opencodex). Opt-in lift: raise context_window to max_context_window and
+// set auto_compact_token_limit at 90% (Codex's own convention), keeping
+// compaction ahead of the hard ceiling.
+export function liftContextWindows(bytes) {
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    for (const model of document.models) {
+        const maxWindow = typeof model.max_context_window === "number" && model.max_context_window > 0
+            ? Math.floor(model.max_context_window)
+            : 0;
+        const window = typeof model.context_window === "number"
+            ? Math.floor(model.context_window)
+            : 0;
+        if (maxWindow <= window)
+            continue;
+        model.context_window = maxWindow;
+        model.auto_compact_token_limit = Math.floor(maxWindow * 0.9);
+    }
+    return Buffer.from(`${JSON.stringify(document, null, 2)}\n`);
+}
+// Move `order` slugs to the front of the rich catalog (stable for the rest),
+// so the Codex client's first-5 spawn_agent advertisement picks them.
+export function reorderCatalog(bytes, order) {
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const rank = new Map(order.map((slug, index) => [slug, index]));
+    const models = document.models.map((model, index) => ({ model, index }));
+    models.sort((left, right) => {
+        const leftRank = rank.get(String(left.model.slug));
+        const rightRank = rank.get(String(right.model.slug));
+        if (leftRank === undefined && rightRank === undefined)
+            return left.index - right.index;
+        if (leftRank === undefined)
+            return 1;
+        if (rightRank === undefined)
+            return -1;
+        return leftRank - rightRank;
+    });
+    document.models = models.map((entry) => entry.model);
+    return Buffer.from(`${JSON.stringify(document, null, 2)}\n`);
+}
+export function saveSpawnModels(configPath, models) {
+    let document = {};
+    if (existsSync(configPath)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(configPath, "utf8"));
+        }
+        catch {
+            throw new CPACError("config must be a valid JSON object");
+        }
+        if (!objectValue(parsed))
+            throw new CPACError("config must be a JSON object");
+        document = parsed;
+    }
+    document.spawn_models = models;
+    atomicWrite(configPath, Buffer.from(`${JSON.stringify(document, null, 2)}\n`));
+}
+// Arrow-key checkbox picker on raw stdin; resolves with the checked labels in
+export async function pickSpawnModels(config) {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    if (!apiKey)
+        throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder().decode(catalog.bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const slugs = document.models.map((model) => model.slug);
+    const picked = await checkboxPicker("Select spawn_agent models", slugs, MAX_SPAWN_MODELS);
+    if (picked.length === 0)
+        throw new CPACError("no models selected");
+    return picked;
+}
+export function catalogModelRows(document) {
+    if (!objectValue(document))
+        return undefined;
+    const source = Array.isArray(document.models)
+        ? document.models
+        : Array.isArray(document.data)
+            ? document.data
+            : undefined;
+    if (!source)
+        return undefined;
+    return source.filter(objectValue);
+}
+export function catalogModelId(model) {
+    if (typeof model.slug === "string" && model.slug.trim())
+        return model.slug.trim();
+    if (typeof model.id === "string" && model.id.trim())
+        return model.id.trim();
+    return undefined;
+}
+export function readState(stateDir) {
+    const path = join(stateDir, "state.json");
+    if (!existsSync(path))
+        return null;
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new CPACError(`cannot read state: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!objectValue(value) ||
+        Object.keys(value).some((key) => !STATE_KEYS.has(key)) ||
+        [...REQUIRED_STATE_KEYS].some((key) => !(key in value))) {
+        throw new CPACError("invalid state file");
+    }
+    if (typeof value.config_path !== "string" || !isAbsolute(value.config_path)) {
+        throw new CPACError("invalid config path in state");
+    }
+    if (typeof value.config_existed !== "boolean")
+        throw new CPACError("invalid config_existed value in state");
+    if (!Number.isInteger(value.config_mode) ||
+        value.config_mode < 0 ||
+        value.config_mode > 0o7777) {
+        throw new CPACError("invalid config_mode value in state");
+    }
+    const proxyKeys = ["proxy_id", "proxy_pid", "proxy_port"];
+    const proxyKeyCount = proxyKeys.filter((key) => key in value).length;
+    if (proxyKeyCount !== 0 &&
+        (proxyKeyCount !== proxyKeys.length ||
+            typeof value.proxy_id !== "string" ||
+            !/^[a-f0-9]{48}$/.test(value.proxy_id) ||
+            !Number.isInteger(value.proxy_pid) ||
+            value.proxy_pid <= 0 ||
+            !Number.isInteger(value.proxy_port) ||
+            value.proxy_port <= 0 ||
+            value.proxy_port > 65535)) {
+        throw new CPACError("invalid loopback proxy state");
+    }
+    if (value.proxy_fingerprint !== undefined &&
+        (typeof value.proxy_fingerprint !== "string" ||
+            !/^[a-f0-9]{64}$/.test(value.proxy_fingerprint))) {
+        throw new CPACError("invalid loopback proxy fingerprint");
+    }
+    return value;
+}
+export function stateProxy(state) {
+    return state.proxy_id && state.proxy_pid && state.proxy_port
+        ? { id: state.proxy_id, pid: state.proxy_pid, port: state.proxy_port }
+        : null;
+}
+export function stateBytes(config, existed, mode, proxy, proxyFingerprint) {
+    return Buffer.from(`${JSON.stringify({
+        config_path: config.codex_config,
+        config_existed: existed,
+        config_mode: mode,
+        proxy_id: proxy.id,
+        proxy_fingerprint: proxyFingerprint,
+        proxy_pid: proxy.pid,
+        proxy_port: proxy.port,
+    }, null, 2)}\n`);
+}
+export function originalBytes(stateDir, state, expectedPath) {
+    if (state.config_path !== expectedPath) {
+        throw new CPACError(`active injection belongs to ${state.config_path}; restore it first`);
+    }
+    if (!state.config_existed)
+        return new Uint8Array();
+    try {
+        return readFileSync(join(stateDir, "config.toml.backup"));
+    }
+    catch (error) {
+        throw new CPACError(`cannot read original config backup: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function cleanupStateFiles(stateDir) {
+    for (const name of STATE_FILES)
+        rmSync(join(stateDir, name), { force: true });
+    try {
+        rmdirSync(stateDir);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST")
+            throw error;
+    }
+}
+export function proxyFingerprint(config, apiKey) {
+    return createHash("sha256")
+        .update(config.cpa_url)
+        .update("\0")
+        .update(apiKey)
+        .digest("hex");
+}