@yhong91/cpac 0.1.26 → 0.1.28

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}`);
+}

package/dist/targets/opencode.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { apiBase, catalogModelId, fetchCatalog, } from "../config.js";
+import { CPACError } from "../util.js";
+const OPENCODE_OUTPUT_BUDGET = 32_000;
+// Ephemeral takeover: inline a CPA provider via OPENCODE_CONFIG_CONTENT so no
+// opencode config file is touched; the session ends with zero residue.
+export async function runOpencode(config, args, executable = "opencode") {
+    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 models = {};
+    for (const row of document.models) {
+        const id = catalogModelId(row);
+        if (!id)
+            continue;
+        const window = typeof row.context_window === "number" && row.context_window > 0
+            ? Math.floor(row.context_window)
+            : 0;
+        models[id] =
+            window > 0
+                ? {
+                    limit: {
+                        context: window,
+                        output: Math.min(OPENCODE_OUTPUT_BUDGET, window),
+                    },
+                }
+                : {};
+    }
+    const content = JSON.stringify({
+        provider: {
+            cpac: {
+                npm: "@ai-sdk/openai-compatible",
+                options: { baseURL: apiBase(config.cpa_url), apiKey },
+                models,
+            },
+        },
+    });
+    const env = {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: content,
+    };
+    return await new Promise((resolve, reject) => {
+        const child = spawn(executable, args, { env, stdio: "inherit" });
+        child.once("error", (error) => {
+            reject(new CPACError(error instanceof Error && "code" in error && error.code === "ENOENT"
+                ? `${executable} not found`
+                : `cannot start ${executable}: ${error.message}`));
+        });
+        child.once("close", (code) => resolve(code ?? 1));
+    });
+}

package/dist/targets/pi.js

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, } from "../util.js";
+export function piExtensionsDir() {
+    return join(expandUserPath(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent")), "extensions");
+}
+export function isPiExtensionInstalled() {
+    return existsSync(join(piExtensionsDir(), "cpac.ts"));
+}
+function piTemplatePath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "pi-extension.template");
+}
+function piExtensionContent(cpaUrl) {
+    return readFileSync(piTemplatePath(), "utf8").replace("__CPA_URL__", cpaUrl);
+}
+export async function installPiExtension(config) {
+    const dir = piExtensionsDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const target = join(dir, "cpac.ts");
+    ensureCpacBackup(target);
+    atomicWrite(target, Buffer.from(piExtensionContent(config.cpa_url)), 0o644);
+    console.log(`Installed Pi extension: ${target}`);
+}
+export async function uninstallPiExtension() {
+    const target = join(piExtensionsDir(), "cpac.ts");
+    if (!existsSync(target))
+        throw new CPACError("Pi extension is not installed");
+    unlinkSync(target);
+    console.log(`Removed Pi extension: ${target}`);
+}

package/dist/util.js

@@ -1,4 +1,4 @@
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, parse } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -9,6 +9,14 @@ export class CPACError extends Error {
 export function objectValue(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+export function ensureCpacBackup(target) {
+    if (!existsSync(target))
+        return;
+    const backup = `${target}.cpac-backup`;
+    if (existsSync(backup))
+        return;
+    copyFileSync(target, backup);
+}
 export function expandUserPath(value) {
     if (value === "~")
         return homedir();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {