@yhong91/cpac 0.1.25 → 0.1.27

package/dist/targets/codex.js

@@ -0,0 +1,378 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { PROVIDER, STATE_FILES, cleanupStateFiles, fetchCatalog, liftContextWindows, originalBytes, proxyFingerprint, readState, reorderCatalog, stateBytes, stateProxy, } from "../config.js";
+import { proxyIsHealthy, startProxyProcess, stopProxyProcess, } from "../proxy.js";
+import { CPACError, atomicWrite, dominantEol, tomlString } from "../util.js";
+const MODEL_PROVIDER_KEY = /^\s*(?:model_provider|"model_provider"|'model_provider')\s*=/;
+const MODEL_CATALOG_KEY = /^\s*(?:model_catalog_json|"model_catalog_json"|'model_catalog_json')\s*=/;
+const OPENAI_BASE_URL_KEY = /^\s*(?:openai_base_url|"openai_base_url"|'openai_base_url')\s*=/;
+const ROOT_KEY = new RegExp(`(?:${MODEL_PROVIDER_KEY.source}|${MODEL_CATALOG_KEY.source}|${OPENAI_BASE_URL_KEY.source})`);
+export const MANAGED_MARKER = "# CPAC managed; run CPAC 'restore' to restore the original file.";
+function providerPatterns(provider = PROVIDER) {
+    const escaped = provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const modelProviders = `(?:model_providers|"model_providers"|'model_providers')`;
+    const providerToken = `(?:${escaped}|"${escaped}"|'${escaped}')`;
+    return {
+        header: new RegExp(`^\\s*\\[\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*\\]\\s*(?:#.*)?$`),
+        arrayHeader: new RegExp(`^\\s*\\[\\[\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*\\]\\]\\s*(?:#.*)?$`),
+        parentHeader: new RegExp(`^\\s*\\[\\s*${modelProviders}\\s*\\]\\s*(?:#.*)?$`),
+        inlineKey: new RegExp(`^\\s*${providerToken}\\s*=`),
+        dottedKey: new RegExp(`^\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*=`),
+    };
+}
+function providerHeader(provider = PROVIDER) {
+    return providerPatterns(provider).header;
+}
+export function hasProviderTable(content, provider = PROVIDER) {
+    const patterns = providerPatterns(provider);
+    let inRoot = true;
+    let inModelProviders = false;
+    for (const line of content.split(/\r?\n/)) {
+        if (patterns.header.test(line) || patterns.arrayHeader.test(line))
+            return true;
+        if (/^\s*\[/.test(line)) {
+            inRoot = false;
+            inModelProviders = patterns.parentHeader.test(line);
+            continue;
+        }
+        if ((inModelProviders && patterns.inlineKey.test(line)) ||
+            (inRoot && patterns.dottedKey.test(line)))
+            return true;
+    }
+    return false;
+}
+function stripManagedConfig(content) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(content);
+    }
+    catch {
+        throw new CPACError("Codex config must be UTF-8");
+    }
+    const eol = dominantEol(text);
+    const header = providerHeader();
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    let inRoot = true;
+    let inProvider = false;
+    let managedRootKeys = 0;
+    const kept = [];
+    for (const line of lines) {
+        if (inProvider && /^\s*\[/.test(line))
+            inProvider = false;
+        if (!inProvider && header.test(line)) {
+            inProvider = true;
+            continue;
+        }
+        if (inProvider)
+            continue;
+        if (/^\s*\[/.test(line))
+            inRoot = false;
+        if (inRoot && line === MANAGED_MARKER) {
+            managedRootKeys = 2;
+            continue;
+        }
+        if (inRoot && managedRootKeys > 0 && ROOT_KEY.test(line)) {
+            managedRootKeys -= 1;
+            continue;
+        }
+        kept.push(line);
+    }
+    const output = kept.join("\n");
+    return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
+}
+export function buildCodexConfig(original, proxyPort, catalogPath) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(original);
+    }
+    catch {
+        throw new CPACError("Codex config must be UTF-8");
+    }
+    if (hasProviderTable(text)) {
+        throw new CPACError(`Codex config already contains [model_providers.${PROVIDER}]`);
+    }
+    const normalizedLines = text.replace(/\r\n/g, "\n").split("\n");
+    const firstTable = normalizedLines.findIndex((line) => /^\s*\[/.test(line));
+    const rootLines = normalizedLines.slice(0, firstTable === -1 ? undefined : firstTable);
+    const providerLine = rootLines.find((line) => MODEL_PROVIDER_KEY.test(line));
+    if (providerLine) {
+        const match = /=\s*["']([^"']+)["']/.exec(providerLine);
+        if (!match || match[1] !== "openai") {
+            throw new CPACError("Codex config selects an external model_provider; restore it to openai before injecting CPAC");
+        }
+    }
+    if (rootLines.some((line) => OPENAI_BASE_URL_KEY.test(line))) {
+        throw new CPACError("Codex config already contains openai_base_url; remove that user-owned override before injecting CPAC");
+    }
+    const eol = dominantEol(text);
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    let inRoot = true;
+    const kept = lines.filter((line) => {
+        if (/^\s*\[/.test(line))
+            inRoot = false;
+        return !(inRoot && MODEL_CATALOG_KEY.test(line));
+    });
+    let body = kept.join("\n");
+    if (body && !body.endsWith("\n"))
+        body += "\n";
+    const root = [
+        MANAGED_MARKER,
+        `model_catalog_json = ${tomlString(catalogPath)}`,
+        `openai_base_url = ${tomlString(`http://127.0.0.1:${proxyPort}/v1`)}`,
+        "",
+    ].join("\n");
+    const output = root + body;
+    return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
+}
+// Codex multi-agent v2 (features.multi_agent_v2). Accepts the same TOML
+// shapes codex-rs does: a [features.multi_agent_v2] table, an inline
+// `multi_agent_v2 = ...` under [features], or dotted root keys.
+const V2_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*\]\s*(?:#.*)?$/;
+const FEATURES_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\]\s*(?:#.*)?$/;
+const V2_KEY = /^\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*=/;
+const V2_DOTTED_KEY = /^\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')(?:\s*\.\s*(?:enabled|"enabled"|'enabled'))?\s*=/;
+function v2LineValue(line) {
+    const inline = line.match(/\{[^}]*\benabled\s*=\s*(true|false)/);
+    if (inline)
+        return inline[1] === "true";
+    const plain = line.match(/=\s*(true|false)(?![A-Za-z0-9_])/);
+    if (plain)
+        return plain[1] === "true";
+    return undefined;
+}
+export function multiAgentV2Enabled(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (V2_TABLE_HEADER.test(line)) {
+            table = "v2";
+            continue;
+        }
+        if (FEATURES_TABLE_HEADER.test(line)) {
+            table = "features";
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            table = "other";
+            continue;
+        }
+        if (table === "v2" && /^\s*(?:enabled|"enabled"|'enabled')\s*=/.test(line)) {
+            return v2LineValue(line) ?? false;
+        }
+        if (table === "features" && V2_KEY.test(line))
+            return v2LineValue(line) ?? false;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            return v2LineValue(line) ?? false;
+    }
+    return false;
+}
+function stripMultiAgentV2(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const kept = [];
+    let skipTable = false;
+    let table = "root";
+    for (const line of lines) {
+        if (/^\s*\[/.test(line)) {
+            skipTable = V2_TABLE_HEADER.test(line);
+            if (skipTable) {
+                table = "other";
+                continue;
+            }
+            table = FEATURES_TABLE_HEADER.test(line) ? "features" : "other";
+        }
+        if (skipTable)
+            continue;
+        if (table === "features" && V2_KEY.test(line))
+            continue;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            continue;
+        kept.push(line);
+    }
+    return kept.join("\n");
+}
+function hasAgentsMaxThreads(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (/^\s*\[/.test(line)) {
+            table = /^\s*\[\s*(?:agents|"agents"|'agents')\s*\]\s*(?:#.*)?$/.test(line)
+                ? "agents"
+                : "other";
+            continue;
+        }
+        if (table === "agents" && /^\s*max_threads\s*=/.test(line))
+            return true;
+        if (table === "root" &&
+            /^\s*(?:agents|"agents"|'agents')\s*\.\s*max_threads\s*=/.test(line))
+            return true;
+    }
+    return false;
+}
+export function withMultiAgentV2(content, enabled, eol) {
+    let body = stripMultiAgentV2(content);
+    if (body && !body.endsWith("\n"))
+        body += "\n";
+    const output = body + `\n[features.multi_agent_v2]\nenabled = ${enabled}\n`;
+    return eol === "\n" ? output : output.replace(/\n/g, "\r\n");
+}
+export async function inject(config, v2Off = false, maxContext = false) {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    if (!apiKey)
+        throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+    const state = readState(config.state_dir);
+    let existed;
+    let original;
+    let originalMode;
+    if (state) {
+        const backup = originalBytes(config.state_dir, state, config.codex_config);
+        try {
+            original = existsSync(config.codex_config)
+                ? stripManagedConfig(readFileSync(config.codex_config))
+                : backup;
+        }
+        catch (error) {
+            if (error instanceof CPACError)
+                throw error;
+            throw new CPACError(`cannot read Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        existed = state.config_existed;
+        originalMode = state.config_mode;
+    }
+    else {
+        existed = existsSync(config.codex_config);
+        try {
+            original = existed ? readFileSync(config.codex_config) : new Uint8Array();
+            originalMode = existed ? statSync(config.codex_config).mode & 0o7777 : 0o600;
+        }
+        catch (error) {
+            throw new CPACError(`cannot read Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    if (config.spawn_models?.length)
+        catalog.bytes = reorderCatalog(catalog.bytes, config.spawn_models);
+    if (maxContext)
+        catalog.bytes = liftContextWindows(catalog.bytes);
+    const stateDirExisted = existsSync(config.state_dir);
+    if (!state &&
+        STATE_FILES.some((name) => existsSync(join(config.state_dir, name)))) {
+        throw new CPACError("state_dir contains CPAC files without a valid state; refusing to overwrite them");
+    }
+    const fingerprint = proxyFingerprint(config, apiKey);
+    const previousProxy = state ? stateProxy(state) : null;
+    let proxy;
+    let startedProxy = false;
+    if (previousProxy &&
+        state?.proxy_fingerprint === fingerprint &&
+        (config.codex_proxy_port === 0 ||
+            config.codex_proxy_port === previousProxy.port) &&
+        (await proxyIsHealthy(previousProxy))) {
+        proxy = previousProxy;
+    }
+    else {
+        if (previousProxy)
+            await stopProxyProcess(previousProxy);
+        try {
+            proxy = await startProxyProcess(config, apiKey);
+            startedProxy = true;
+        }
+        catch (error) {
+            throw new CPACError(`${error instanceof Error ? error.message : String(error)}; choose another codex_proxy_port if the port is occupied`);
+        }
+    }
+    const catalogPath = join(config.state_dir, "codex-models.json");
+    let injected;
+    try {
+        injected = buildCodexConfig(original, proxy.port, catalogPath);
+        const injectedText = new TextDecoder("utf-8").decode(injected);
+        injected = Buffer.from(withMultiAgentV2(injectedText, !v2Off, dominantEol(injectedText)));
+        if (!v2Off && hasAgentsMaxThreads(injectedText)) {
+            console.warn("warning: [agents] max_threads is set; codex refuses to start with multi_agent_v2 enabled, remove it");
+        }
+    }
+    catch (error) {
+        if (startedProxy)
+            await stopProxyProcess(proxy);
+        throw error;
+    }
+    mkdirSync(config.state_dir, { recursive: true, mode: 0o700 });
+    if (!stateDirExisted)
+        chmodSync(config.state_dir, 0o700);
+    if (state) {
+        try {
+            atomicWrite(catalogPath, catalog.bytes);
+            atomicWrite(config.codex_config, injected, originalMode);
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+        }
+        catch (error) {
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            throw error;
+        }
+    }
+    else {
+        let configWritten = false;
+        try {
+            if (existed)
+                atomicWrite(join(config.state_dir, "config.toml.backup"), original);
+            atomicWrite(catalogPath, catalog.bytes);
+            atomicWrite(config.codex_config, injected, originalMode);
+            configWritten = true;
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+        }
+        catch (error) {
+            if (configWritten) {
+                try {
+                    if (existed)
+                        atomicWrite(config.codex_config, original, originalMode);
+                    else
+                        rmSync(config.codex_config, { force: true });
+                }
+                catch (rollbackError) {
+                    throw new CPACError(`injection failed and config rollback failed; backup retained in ${config.state_dir}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                }
+            }
+            let cleanupError;
+            try {
+                cleanupStateFiles(config.state_dir);
+            }
+            catch (caught) {
+                cleanupError = caught;
+            }
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            if (cleanupError) {
+                throw new CPACError(`injection failed and state cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+            throw error;
+        }
+    }
+    try {
+        rmSync(join(dirname(config.codex_config), "models_cache.json"), {
+            force: true,
+        });
+    }
+    catch {
+        console.warn("CPAC could not invalidate Codex models_cache.json; restart Codex App if its model list is stale.");
+    }
+    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config} via http://127.0.0.1:${proxy.port}/v1 (multi-agent v2: ${v2Off ? "off" : "on"})`);
+    console.log("Restart Codex App if its running app-server still shows the old model list.");
+}
+export async function restore(config) {
+    const state = readState(config.state_dir);
+    if (!state)
+        throw new CPACError("no active CPAC injection");
+    const original = originalBytes(config.state_dir, state, config.codex_config);
+    if (state.config_existed)
+        atomicWrite(config.codex_config, original, state.config_mode);
+    else
+        rmSync(config.codex_config, { force: true });
+    const proxy = stateProxy(state);
+    if (proxy)
+        await stopProxyProcess(proxy);
+    try {
+        cleanupStateFiles(config.state_dir);
+    }
+    catch (error) {
+        throw new CPACError(`config restored, but state cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.log(`Restored ${config.codex_config}`);
+}

package/dist/targets/grok.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { catalogModelId, catalogModelRows, fetchCatalog, readState, stateProxy, } from "../config.js";
+import { proxyIsHealthy } from "../proxy.js";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, resolveApiKey, tomlString, } from "../util.js";
+export function grokHome() {
+    const home = process.env.GROK_HOME?.trim() || join(homedir(), ".grok");
+    return expandUserPath(home);
+}
+export function grokConfigPath() {
+    return join(grokHome(), "config.toml");
+}
+const GROK_BLOCK_START = "# >>> CPAC Grok >>>";
+const GROK_BLOCK_END = "# <<< CPAC Grok <<<";
+const grokBlockRegex = new RegExp(`${GROK_BLOCK_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${GROK_BLOCK_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`);
+export function isGrokConfigInstalled() {
+    try {
+        const content = readFileSync(grokConfigPath(), "utf8");
+        return (grokBlockRegex.test(content) ||
+            /^\s*\[model\.(?:"cpac\/|'cpac\/|cpac-)/m.test(content));
+    }
+    catch {
+        return false;
+    }
+}
+function isCpacGrokTableHeader(line) {
+    const header = line.match(/^\[([^\]]+)\]\s*$/);
+    if (!header)
+        return false;
+    const name = header[1];
+    return /^model\.(?:"cpac\/|'cpac\/|cpac-)/.test(name);
+}
+function stripOrphanCpacGrokTables(content) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const out = [];
+    let skipping = false;
+    for (const line of content.split(/\r?\n/)) {
+        if (/^\[[^\]]+\]\s*$/.test(line))
+            skipping = isCpacGrokTableHeader(line);
+        if (!skipping)
+            out.push(line);
+    }
+    return out.join(eol).replace(/(?:\r?\n){3,}/g, `${eol}${eol}`);
+}
+function writeGrokBlock(path, block) {
+    let content = existsSync(path) ? readFileSync(path, "utf8") : "";
+    content = content.replace(grokBlockRegex, "");
+    const orphan = content.indexOf(GROK_BLOCK_START);
+    if (orphan !== -1)
+        content = content.slice(0, orphan);
+    content = stripOrphanCpacGrokTables(content);
+    if (block) {
+        content = `${content}${content && !content.endsWith("\n") ? "\n" : ""}${block}\n`;
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const mode = existsSync(path) ? statSync(path).mode & 0o7777 : 0o600;
+    atomicWrite(path, Buffer.from(content), mode);
+}
+export async function installGrokConfig(config) {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const rows = catalogModelRows(document) ?? [];
+    if (rows.length === 0)
+        throw new CPACError("CPA catalog contains no models");
+    const state = readState(config.state_dir);
+    const recorded = state ? stateProxy(state) : null;
+    const port = recorded?.port ?? config.codex_proxy_port;
+    if (!port) {
+        throw new CPACError("loopback proxy port unknown; run cpac inject first");
+    }
+    const lines = [GROK_BLOCK_START];
+    for (const row of rows) {
+        const slug = catalogModelId(row);
+        if (!slug)
+            continue;
+        const context = typeof row.context_window === "number" && row.context_window > 0
+            ? Math.floor(row.context_window)
+            : 200000;
+        const name = typeof row.display_name === "string" && row.display_name.trim()
+            ? `${row.display_name.trim()} (CPAC)`
+            : `CPAC ${slug}`;
+        lines.push(`[model."cpac/${slug}"]`, `model = ${tomlString(slug)}`, `base_url = "http://127.0.0.1:${port}/v1"`, 'api_backend = "responses"', '# Placeholder: the CPAC loopback proxy replaces it with the CPA key; run "cpac inject" to start the proxy.', 'api_key = "cpac-loopback"', `name = ${tomlString(name)}`, `context_window = ${context}`, "");
+    }
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    lines.push(GROK_BLOCK_END);
+    const target = grokConfigPath();
+    ensureCpacBackup(target);
+    writeGrokBlock(target, lines.join("\n"));
+    console.log(`Installed Grok Build provider config: ${target}`);
+    if (!recorded || !(await proxyIsHealthy(recorded))) {
+        console.log("Loopback proxy is not running; run: cpac inject");
+    }
+}
+export async function uninstallGrokConfig() {
+    const target = grokConfigPath();
+    if (!isGrokConfigInstalled())
+        throw new CPACError("Grok Build config is not installed");
+    writeGrokBlock(target, null);
+    console.log(`Removed Grok Build provider config: ${target}`);
+}

package/dist/targets/kimi.js

@@ -0,0 +1,175 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { catalogModelId, catalogModelRows, fetchCatalog, readState, stateProxy, } from "../config.js";
+import { proxyIsHealthy } from "../proxy.js";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, objectValue, resolveApiKey, tomlString, tomlStringArray, } from "../util.js";
+export function kimiConfigPath() {
+    const home = process.env.KIMI_CODE_HOME?.trim() || join(homedir(), ".kimi-code");
+    return join(expandUserPath(home), "config.toml");
+}
+const KIMI_BLOCK_START = "# >>> CPAC Kimi >>>";
+const KIMI_BLOCK_END = "# <<< CPAC Kimi <<<";
+const kimiBlockRegex = new RegExp(`${KIMI_BLOCK_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${KIMI_BLOCK_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`);
+export function isKimiConfigInstalled() {
+    try {
+        const content = readFileSync(kimiConfigPath(), "utf8");
+        return (kimiBlockRegex.test(content) || /^\s*\[providers\.cpac\]\s*$/m.test(content));
+    }
+    catch {
+        return false;
+    }
+}
+function isCpacTableHeader(line) {
+    const header = line.match(/^\[([^\]]+)\]\s*$/);
+    if (!header)
+        return false;
+    const name = header[1];
+    return (name === "providers.cpac" ||
+        name.startsWith("providers.cpac.") ||
+        /^models\.(?:"cpac\/|'cpac\/)/.test(name));
+}
+// Kimi may rewrite config.toml and drop our comment markers, leaving the
+// [providers.cpac] / [models."cpac/..."] tables behind. A later install would
+// then append a second copy and make the file invalid TOML.
+function stripOrphanCpacTables(content) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const out = [];
+    let skipping = false;
+    for (const line of content.split(/\r?\n/)) {
+        if (/^\[[^\]]+\]\s*$/.test(line))
+            skipping = isCpacTableHeader(line);
+        if (!skipping)
+            out.push(line);
+    }
+    return out.join(eol).replace(/(?:\r?\n){3,}/g, `${eol}${eol}`);
+}
+function writeKimiBlock(path, block) {
+    let content = existsSync(path) ? readFileSync(path, "utf8") : "";
+    content = content.replace(kimiBlockRegex, "");
+    // A truncated managed block (start marker without the end marker) leaves its
+    // tables behind; appending again would duplicate [providers.cpac], make the
+    // file invalid TOML, and block `kimi login`. The block is always appended
+    // last, so dropping from an orphaned start marker to EOF is safe.
+    const orphan = content.indexOf(KIMI_BLOCK_START);
+    if (orphan !== -1)
+        content = content.slice(0, orphan);
+    content = stripOrphanCpacTables(content);
+    if (block) {
+        content = `${content}${content && !content.endsWith("\n") ? "\n" : ""}${block}\n`;
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const mode = existsSync(path) ? statSync(path).mode & 0o7777 : 0o600;
+    atomicWrite(path, Buffer.from(content), mode);
+}
+const KIMI_REASONING_EFFORTS = new Set([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+]);
+function kimiSupportEfforts(row) {
+    const levels = row.supported_reasoning_levels ??
+        row.reasoning_effort_levels ??
+        row.reasoning_levels;
+    if (!Array.isArray(levels))
+        return [];
+    const seen = new Set();
+    const efforts = [];
+    for (const level of levels) {
+        const effort = typeof level === "string"
+            ? level.toLowerCase()
+            : objectValue(level) && typeof level.effort === "string"
+                ? level.effort.toLowerCase()
+                : undefined;
+        if (!effort || !KIMI_REASONING_EFFORTS.has(effort) || seen.has(effort))
+            continue;
+        seen.add(effort);
+        efforts.push(effort);
+    }
+    return efforts;
+}
+function kimiInputHasImage(row) {
+    const modalities = row.input_modalities;
+    if (!Array.isArray(modalities))
+        return true;
+    return modalities.some((value) => value === "image");
+}
+export async function installKimiConfig(config) {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const rows = catalogModelRows(document) ?? [];
+    if (rows.length === 0)
+        throw new CPACError("CPA catalog contains no models");
+    const state = readState(config.state_dir);
+    const recorded = state ? stateProxy(state) : null;
+    const port = recorded?.port ?? config.codex_proxy_port;
+    if (!port) {
+        throw new CPACError("loopback proxy port unknown; run cpac inject first");
+    }
+    const lines = [
+        KIMI_BLOCK_START,
+        "[providers.cpac]",
+        'type = "openai"',
+        `base_url = "http://127.0.0.1:${port}/v1"`,
+        '# Placeholder: the CPAC loopback proxy replaces it with the CPA key; run "cpac inject" to start the proxy.',
+        'api_key = "cpac-loopback"',
+    ];
+    for (const row of rows) {
+        const slug = catalogModelId(row);
+        if (!slug)
+            continue;
+        // ponytail: Kimi requires max_context_size; default 200000 when the catalog omits it.
+        const context = typeof row.context_window === "number" && row.context_window > 0
+            ? Math.floor(row.context_window)
+            : 200000;
+        const efforts = kimiSupportEfforts(row);
+        const capabilities = [
+            ...(efforts.length > 0 ? ["thinking"] : []),
+            "tool_use",
+            ...(kimiInputHasImage(row) ? ["image_in"] : []),
+        ];
+        lines.push("", `[models."cpac/${slug}"]`, 'provider = "cpac"', `model = ${tomlString(slug)}`, `max_context_size = ${context}`, `capabilities = ${tomlStringArray(capabilities)}`);
+        if (typeof row.display_name === "string" && row.display_name.trim()) {
+            lines.push(`display_name = ${tomlString(row.display_name)}`);
+        }
+        if (efforts.length > 0) {
+            lines.push(`support_efforts = ${tomlStringArray(efforts)}`);
+            const rawDefaultEffort = (typeof row.default_reasoning_level === "string" &&
+                row.default_reasoning_level) ||
+                (typeof row.default_reasoning_effort === "string" &&
+                    row.default_reasoning_effort) ||
+                (typeof row.default_effort === "string" && row.default_effort);
+            const defaultEffort = rawDefaultEffort && efforts.includes(rawDefaultEffort.toLowerCase())
+                ? rawDefaultEffort.toLowerCase()
+                : undefined;
+            if (defaultEffort)
+                lines.push(`default_effort = ${tomlString(defaultEffort)}`);
+        }
+    }
+    lines.push(KIMI_BLOCK_END);
+    const target = kimiConfigPath();
+    ensureCpacBackup(target);
+    writeKimiBlock(target, lines.join("\n"));
+    console.log(`Installed Kimi Code provider config: ${target}`);
+    if (!recorded || !(await proxyIsHealthy(recorded))) {
+        console.log("Loopback proxy is not running; run: cpac inject");
+    }
+}
+export async function uninstallKimiConfig() {
+    const target = kimiConfigPath();
+    if (!isKimiConfigInstalled())
+        throw new CPACError("Kimi Code config is not installed");
+    writeKimiBlock(target, null);
+    console.log(`Removed Kimi Code provider config: ${target}`);
+}