@yhong91/cpac 0.1.3 → 0.1.5

package/README.md

@@ -91,6 +91,24 @@ cpac
 cpac --help
 ```
 
+### 统一管理（detect / install / uninstall / upgrade）
+
+参考 vibetime 的目标式命令，对 `codex`、`claude`、`pi`、`kimi` 四个目标统一管理：
+
+```bash
+cpac detect [--json] [--home PATH]
+cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--home PATH]
+cpac uninstall [--target codex,claude,pi,kimi] [--all] [--dry-run] [--home PATH]
+cpac upgrade [--check]
+cpac version
+```
+
+- `detect` 列出每个目标是否被检测到、是否已接入 CPAC；`--json` 输出机器可读结果。
+- `install` 默认作用于检测到的目标；`--target` 指定目标、`--all` 全部。各目标映射到既有逻辑：`codex` → `cpac inject`，`pi` → `cpac pi install`，`kimi` → `cpac kimi install`；`claude` 无持久化安装（用 `cpac claude` 启动）。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
+- `uninstall` 默认作用于已安装目标，映射到 `cpac restore` / `cpac pi uninstall` / `cpac kimi uninstall`。
+- `--home PATH` 临时把 `HOME` 指向给定目录，便于在隔离环境中试验。
+- `upgrade` 检查 npm 上是否有新版本，`--check` 只报告不提示安装命令。
+
 ### Claude Code
 
 通过 CPA 启动 Claude Code，后续参数原样传递：
@@ -101,16 +119,20 @@ cpac claude --model claude-sonnet-4-5
 cpac claude -- -p "检查当前项目"
 ```
 
-`cpac claude` 会为 Claude Code 子进程设置：
+`cpac claude` 会在本地起一个临时 loopback 代理，并为 Claude Code 子进程设置：
 
 ```text
-ANTHROPIC_BASE_URL=<CPA 地址>
+ANTHROPIC_BASE_URL=http://127.0.0.1:<临时端口>
 ANTHROPIC_AUTH_TOKEN=<CPA_API_KEY>
+CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
+CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST=1
 ```
 
 同时清除可能覆盖网关选择的 `ANTHROPIC_API_KEY` 和 Claude Code 云 provider 环境变量。它不会修改 `~/.claude/`，并原样返回 Claude Code 的退出码。
 
-> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。Claude 路径直接连接远端 CPA；CPAC 不负责协议转换。
+代理开启 Claude Code 的 gateway model discovery：`/model` 选择器会列出 CPA 目录里的全部模型。claude 系模型直接使用原 id；其它模型以 `claude-cpac--<模型名>` 别名出现（例如 `claude-cpac--gpt-5.6-sol`），请求发出时由代理还原为真实模型名。
+
+> CPA 服务端必须支持 Claude Code 使用的 Anthropic Messages API（`/v1/messages`）。
 
 ### Codex
 
@@ -192,6 +214,23 @@ cpac pi status
 
 Pi 扩展尊重 `PI_CODING_AGENT_DIR` 环境变量。
 
+### Kimi Code
+
+写入 CPA provider 配置到 Kimi Code：
+
+```bash
+cpac kimi install
+```
+
+它在 `~/.kimi-code/config.toml` 追加一个由 CPAC 管理的块，注册 `cpac` OpenAI 兼容 provider，并把 CPA 目录里的每个模型映射为一个 `cpac/<模型名>` 条目。`base_url` 指向 Codex 注入使用的 loopback 代理，因此密钥不落盘；代理未运行时 install 会提示先执行 `cpac inject`。卸载与状态：
+
+```bash
+cpac kimi uninstall
+cpac kimi status
+```
+
+Kimi Code 配置目录尊重 `KIMI_CODE_HOME` 环境变量。首次写入前若 `config.toml` 已存在，会在同目录保留一份原始快照 `config.toml.cpac-backup`（只存最早版本），万一文件损坏可手动复制回去。
+
 ## 环境变量
 
 | 变量 | 默认值 | 作用 |
@@ -199,6 +238,7 @@ Pi 扩展尊重 `PI_CODING_AGENT_DIR` 环境变量。
 | `CPA_API_KEY` | 无 | CPA Bearer key；可由 `cpac` 首次引导写入 shell 启动文件 |
 | `CPA_BASE_URL` | `https://cpa.vibetime.cc` | 覆盖内置 CPA 地址 |
 | `PI_CODING_AGENT_DIR` | `~/.pi/agent` | 覆盖 Pi agent 目录（影响 `cpac pi install` 写入位置） |
+| `KIMI_CODE_HOME` | `~/.kimi-code` | 覆盖 Kimi Code 目录（影响 `cpac kimi install` 写入位置） |
 | `CPAC_CONFIG` | `~/.config/cpac/config.json` | 指定可选 JSON 配置路径 |
 | `CODEX_HOME` | `~/.codex` | Codex home 目录 |
 

package/dist/cpac.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
-import { spawn } from "node:child_process";
+import { chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer, request as httpRequest, } from "node:http";
 import { request as httpsRequest } from "node:https";
@@ -507,6 +507,134 @@ export async function createLoopbackProxy(cpaUrl, apiKey, proxyId, port) {
     }
     return { server, port: address.port };
 }
+const CLAUDE_ALIAS_PREFIX = "claude-cpac--";
+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);
+}
+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;
+}
+async function claudeModelList(cpaUrl, apiKey, response) {
+    let rows;
+    try {
+        const catalog = await fetch(`${apiBase(cpaUrl)}/models?client_version=1`, {
+            headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(20_000),
+        });
+        if (catalog.ok)
+            rows = catalogModelRows(await catalog.json());
+    }
+    catch {
+        rows = undefined;
+    }
+    if (!rows) {
+        response.writeHead(502, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "CPA catalog request failed" }));
+        return;
+    }
+    // Claude Code's /model picker only lists ids starting with claude/anthropic;
+    // expose every other catalog model as claude-cpac--<id>.
+    const data = [];
+    for (const model of rows) {
+        const id = catalogModelId(model);
+        if (!id)
+            continue;
+        const alias = id.startsWith("claude") ? id : `${CLAUDE_ALIAS_PREFIX}${id}`;
+        data.push({
+            type: "model",
+            id: alias,
+            display_name: typeof model.display_name === "string" && model.display_name.trim()
+                ? model.display_name
+                : id,
+        });
+    }
+    response.writeHead(200, { "content-type": "application/json" });
+    response.end(JSON.stringify({
+        data,
+        has_more: false,
+        first_id: data.length > 0 ? data[0].id : null,
+        last_id: data.length > 0 ? data[data.length - 1].id : null,
+    }));
+}
+export async function createClaudeProxy(cpaUrl, apiKey) {
+    const server = createServer((request, response) => {
+        const requestUrl = request.url ?? "/";
+        if (request.method === "GET" && requestUrl.startsWith("/v1/models")) {
+            void claudeModelList(cpaUrl, apiKey, response);
+            return;
+        }
+        let target;
+        try {
+            target = upstreamUrl(cpaUrl, requestUrl);
+        }
+        catch {
+            response.writeHead(400).end("invalid request URL");
+            return;
+        }
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.once("error", () => response.destroy());
+        request.once("end", () => {
+            let body = Buffer.concat(chunks);
+            if (body.length > 0) {
+                try {
+                    const parsed = JSON.parse(body.toString("utf8"));
+                    if (objectValue(parsed) &&
+                        typeof parsed.model === "string" &&
+                        parsed.model.startsWith(CLAUDE_ALIAS_PREFIX)) {
+                        parsed.model = parsed.model.slice(CLAUDE_ALIAS_PREFIX.length);
+                        body = Buffer.from(JSON.stringify(parsed));
+                    }
+                }
+                catch {
+                    // not JSON; forward unchanged
+                }
+            }
+            const headers = proxyHeaders(request.headers, apiKey);
+            headers["content-length"] = String(body.length);
+            const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+            const upstream = send(target, { method: request.method, headers }, (upstreamResponse) => {
+                response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders(upstreamResponse.headers));
+                upstreamResponse.pipe(response);
+            });
+            upstream.once("error", () => {
+                if (!response.headersSent) {
+                    response.writeHead(502, { "content-type": "application/json" });
+                }
+                if (!response.writableEnded)
+                    response.end(JSON.stringify({ error: "CPA upstream request failed" }));
+            });
+            upstream.end(body);
+        });
+    });
+    server.on("clientError", (_error, socket) => socket.destroy());
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new CPACError("cannot determine Claude proxy port");
+    }
+    return { server, port: address.port };
+}
 async function runProxyChild(port) {
     const cpaUrl = process.env.CPAC_PROXY_UPSTREAM;
     const apiKey = process.env.CPAC_PROXY_API_KEY;
@@ -888,6 +1016,8 @@ export async function status(config) {
     console.log(`claude: ${keyConfigured ? "ready" : "not configured"}`);
     const piInstalled = isPiExtensionInstalled();
     console.log(`pi: ${keyConfigured ? (piInstalled ? "ready" : "extension not installed; run: cpac pi install") : "not configured"}`);
+    const kimiInstalled = isKimiConfigInstalled();
+    console.log(`kimi: ${keyConfigured ? (kimiInstalled ? "ready" : "config not installed; run: cpac kimi install") : "not configured"}`);
     if (!state)
         return 1;
     const proxy = stateProxy(state);
@@ -895,9 +1025,6 @@ export async function status(config) {
         return 2;
     return 0;
 }
-function claudeBaseUrl(cpaUrl) {
-    return cpaUrl.replace(/\/v1$/, "");
-}
 async function promptSecret(name) {
     if (!process.stdin.isTTY || !process.stderr.isTTY) {
         throw new CPACError(`environment variable ${name} is not set; run: export ${name}="..."`);
@@ -953,7 +1080,7 @@ export function saveApiKeyExport(profile, name, apiKey) {
     atomicWrite(profile, Buffer.from(content), mode);
 }
 async function guide(config) {
-    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac claude [args...]  Launch Claude Code through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi)\n  cpac restore           Restore the original Codex config\n  cpac pi install        Install CPA provider extension for Pi\n  cpac pi uninstall      Remove the Pi CPA provider extension\n  cpac pi status         Show Pi extension install status\n  cpac --help            Show command usage`);
+    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac claude [args...]  Launch Claude Code through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi)\n  cpac restore           Restore the original Codex config\n  cpac pi install        Install CPA provider extension for Pi\n  cpac pi uninstall      Remove the Pi CPA provider extension\n  cpac pi status         Show Pi extension install status\n  cpac kimi install      Write CPA provider config for Kimi Code\n  cpac kimi uninstall    Remove the Kimi Code CPA provider config\n  cpac kimi status       Show Kimi Code config install status\n  cpac detect            Show supported targets and install status\n  cpac install           Install CPA integration into detected targets\n  cpac uninstall         Remove CPA integration from installed targets\n  cpac upgrade           Check for cpac updates on npm\n  cpac --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
         return 0;
     const apiKey = await promptSecret(config.api_key_env);
@@ -965,10 +1092,17 @@ async function guide(config) {
 }
 export async function runClaude(config, args, executable = "claude") {
     const apiKey = await resolveApiKey(config.api_key_env);
+    const proxy = await createClaudeProxy(config.cpa_url, apiKey);
+    const stopProxy = () => {
+        proxy.server.closeAllConnections?.();
+        proxy.server.close();
+    };
     const env = {
         ...process.env,
-        ANTHROPIC_BASE_URL: claudeBaseUrl(config.cpa_url),
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${proxy.port}`,
         ANTHROPIC_AUTH_TOKEN: apiKey,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+        CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1",
     };
     delete env.ANTHROPIC_API_KEY;
     delete env.CLAUDE_CODE_USE_ANTHROPIC_AWS;
@@ -978,11 +1112,15 @@ export async function runClaude(config, args, executable = "claude") {
     return await new Promise((resolve, reject) => {
         const child = spawn(executable, args, { env, stdio: "inherit" });
         child.once("error", (error) => {
+            stopProxy();
             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));
+        child.once("close", (code) => {
+            stopProxy();
+            resolve(code ?? 1);
+        });
     });
 }
 export async function runProxy(config) {
@@ -1033,6 +1171,7 @@ 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}`);
 }
@@ -1059,6 +1198,314 @@ export async function runPi(config, action) {
     }
     throw new CPACError(`unknown pi action: ${action}; use install, uninstall, or status`);
 }
+// Pre-write snapshot kept at <target>.cpac-backup (first version only) so a
+// damaged config can be restored by hand even if uninstall cannot parse it.
+function ensureCpacBackup(target) {
+    if (!existsSync(target))
+        return;
+    const backup = `${target}.cpac-backup`;
+    if (existsSync(backup))
+        return;
+    copyFileSync(target, backup);
+}
+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 {
+        return kimiBlockRegex.test(readFileSync(kimiConfigPath(), "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+function writeKimiBlock(path, block) {
+    let content = existsSync(path) ? readFileSync(path, "utf8") : "";
+    content = content.replace(kimiBlockRegex, "");
+    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 installKimiConfig(config) {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    const document = JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes));
+    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;
+        lines.push("", `[models."cpac/${slug}"]`, 'provider = "cpac"', `model = ${tomlString(slug)}`, `max_context_size = ${context}`);
+        if (typeof row.display_name === "string" && row.display_name.trim()) {
+            lines.push(`display_name = ${tomlString(row.display_name)}`);
+        }
+    }
+    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}`);
+}
+export async function runKimi(config, action) {
+    if (action === "install") {
+        await installKimiConfig(config);
+        return 0;
+    }
+    if (action === "uninstall") {
+        await uninstallKimiConfig();
+        return 0;
+    }
+    if (action === "status") {
+        const installed = isKimiConfigInstalled();
+        console.log(`Kimi Code config: ${installed ? "installed" : "not installed"}`);
+        return installed ? 0 : 1;
+    }
+    throw new CPACError(`unknown kimi action: ${action}; use install, uninstall, or status`);
+}
+function readPackageVersion() {
+    try {
+        const raw = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8");
+        const version = JSON.parse(raw).version;
+        return typeof version === "string" ? version : "0.0.0-dev";
+    }
+    catch {
+        return "0.0.0-dev";
+    }
+}
+const CPAC_VERSION = readPackageVersion();
+function binaryOnPath(name) {
+    if (!/^[\w.-]+$/.test(name))
+        return false;
+    try {
+        return spawnSync(`command -v ${name}`, { stdio: "ignore", shell: true }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+const TARGETS = [
+    {
+        id: "codex",
+        home: () => expandUserPath(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex")),
+        detected: function () {
+            return existsSync(this.home());
+        },
+        installed: (config) => {
+            try {
+                return hasProviderTable(readFileSync(config.codex_config, "utf8"));
+            }
+            catch {
+                return false;
+            }
+        },
+        install: async (config, dryRun) => {
+            if (dryRun) {
+                console.log("would inject CPA catalog and loopback proxy into Codex");
+                return;
+            }
+            await inject(config);
+        },
+        uninstall: async (config, dryRun) => {
+            if (dryRun) {
+                console.log("would restore the original Codex config");
+                return;
+            }
+            await restore(config);
+        },
+    },
+    {
+        id: "claude",
+        home: () => expandUserPath(process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude")),
+        detected: () => binaryOnPath("claude") || existsSync(join(homedir(), ".claude")),
+        installed: () => false,
+        install: async (_config, dryRun) => {
+            const message = "claude needs no install; launch it through CPA with: cpac claude";
+            console.log(dryRun ? `would do nothing: ${message}` : message);
+        },
+        uninstall: async (_config, dryRun) => {
+            const message = "claude keeps no persistent CPAC state; nothing to remove";
+            console.log(dryRun ? `would do nothing: ${message}` : message);
+        },
+    },
+    {
+        id: "pi",
+        home: () => piExtensionsDir(),
+        detected: () => binaryOnPath("pi") || existsSync(piExtensionsDir()),
+        installed: () => isPiExtensionInstalled(),
+        install: async (config, dryRun) => {
+            if (dryRun) {
+                console.log(`would write Pi extension: ${join(piExtensionsDir(), "cpac.ts")}`);
+                return;
+            }
+            await installPiExtension(config);
+        },
+        uninstall: async (_config, dryRun) => {
+            if (dryRun) {
+                console.log(`would remove Pi extension: ${join(piExtensionsDir(), "cpac.ts")}`);
+                return;
+            }
+            await uninstallPiExtension();
+        },
+    },
+    {
+        id: "kimi",
+        home: () => dirname(kimiConfigPath()),
+        detected: () => binaryOnPath("kimi") || existsSync(dirname(kimiConfigPath())),
+        installed: () => isKimiConfigInstalled(),
+        install: async (config, dryRun) => {
+            if (dryRun) {
+                console.log(`would write CPA provider block: ${kimiConfigPath()}`);
+                return;
+            }
+            await installKimiConfig(config);
+        },
+        uninstall: async (_config, dryRun) => {
+            if (dryRun) {
+                console.log(`would remove CPA provider block: ${kimiConfigPath()}`);
+                return;
+            }
+            await uninstallKimiConfig();
+        },
+    },
+];
+export async function detectTargets(config) {
+    return TARGETS.map((target) => ({
+        id: target.id,
+        detected: target.detected(),
+        installed: target.installed(config),
+        path: target.home(),
+    }));
+}
+export async function runDetect(config, asJson) {
+    const targets = await detectTargets(config);
+    if (asJson) {
+        console.log(JSON.stringify({ version: CPAC_VERSION, targets }, null, 2));
+        return 0;
+    }
+    for (const target of targets) {
+        console.log(`${target.id.padEnd(8)} ${(target.detected ? "detected" : "missing").padEnd(9)} ${(target.installed ? "installed" : "not installed").padEnd(14)} ${target.path}`);
+    }
+    return 0;
+}
+function selectTargets(requested, all, eligible) {
+    const unknown = requested.filter((id) => !TARGETS.some((target) => target.id === id));
+    if (unknown.length > 0) {
+        throw new CPACError(`unknown target(s): ${unknown.join(", ")}; use ${TARGETS.map((target) => target.id).join(",")}`);
+    }
+    const ids = requested.length > 0 ? requested : all ? TARGETS.map((target) => target.id) : eligible;
+    return TARGETS.filter((target) => ids.includes(target.id));
+}
+export async function runInstall(config, requested, options) {
+    const eligible = TARGETS.filter((target) => target.detected()).map((target) => target.id);
+    const selected = selectTargets(requested, options.all, eligible);
+    if (selected.length === 0) {
+        throw new CPACError(`no supported targets detected; use --target ${TARGETS.map((target) => target.id).join(",")} or --all`);
+    }
+    for (const target of selected) {
+        if (target.installed(config) && !options.force) {
+            console.log(`${target.id}: already installed; use --force to reinstall`);
+            continue;
+        }
+        await target.install(config, options.dryRun);
+    }
+    return 0;
+}
+export async function runUninstall(config, requested, options) {
+    const eligible = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
+    const selected = selectTargets(requested, options.all, eligible);
+    if (selected.length === 0) {
+        throw new CPACError("no installed CPAC integrations found; use --target <id> or --all");
+    }
+    for (const target of selected) {
+        if (!target.installed(config)) {
+            console.log(`${target.id}: not installed`);
+            continue;
+        }
+        await target.uninstall(config, options.dryRun);
+    }
+    return 0;
+}
+function compareVersions(a, b) {
+    const left = a.split(".").map(Number);
+    const right = b.split(".").map(Number);
+    for (let index = 0; index < Math.max(left.length, right.length); index++) {
+        const l = left[index] ?? 0;
+        const r = right[index] ?? 0;
+        if (l !== r)
+            return l > r ? 1 : -1;
+    }
+    return 0;
+}
+export async function runUpgrade(checkOnly) {
+    console.log(`Current version: ${CPAC_VERSION}`);
+    let latest;
+    try {
+        const response = await fetch("https://registry.npmjs.org/@yhong91/cpac/latest", {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            if (typeof data.version === "string")
+                latest = data.version;
+        }
+    }
+    catch {
+        latest = undefined;
+    }
+    if (!latest) {
+        console.error("Could not fetch latest version from npm. Check your network connection.");
+        return 1;
+    }
+    console.log(`Latest version: ${latest}`);
+    if (compareVersions(CPAC_VERSION, latest) >= 0) {
+        console.log("Already up to date.");
+        return 0;
+    }
+    if (checkOnly) {
+        console.log(`Update available. Run: npm install -g @yhong91/cpac@latest`);
+        return 0;
+    }
+    console.log(`Update available. Run: npm install -g @yhong91/cpac@latest`);
+    return 0;
+}
 function usage() {
     return [
         "Usage: cpac",
@@ -1066,13 +1513,73 @@ function usage() {
         "       cpac proxy [--config PATH]",
         "       cpac claude [--config PATH] [--] [claude args...]",
         "       cpac pi <install|uninstall|status> [--config PATH]",
+        "       cpac kimi <install|uninstall|status> [--config PATH]",
+        "       cpac detect [--json] [--home PATH]",
+        "       cpac install [--target codex,claude,pi,kimi] [--all] [--dry-run] [--force] [--home PATH]",
+        "       cpac uninstall [--target codex,claude,pi,kimi] [--all] [--dry-run] [--home PATH]",
+        "       cpac upgrade [--check]",
+        "       cpac version",
     ].join("\n");
 }
 function parseArgs(args) {
     if (args.length === 0) {
         return { command: "guide", configPath: defaultConfigPath() };
     }
-    if (args[0] === "pi") {
+    if (args[0] === "detect" ||
+        args[0] === "install" ||
+        args[0] === "uninstall" ||
+        args[0] === "upgrade" ||
+        args[0] === "version") {
+        const parsed = {
+            command: args[0],
+            configPath: defaultConfigPath(),
+            json: false,
+            targets: [],
+            all: false,
+            dryRun: false,
+            force: false,
+            check: false,
+        };
+        for (let index = 1; index < args.length; index++) {
+            const arg = args[index];
+            if (arg === "--json")
+                parsed.json = true;
+            else if (arg === "--all")
+                parsed.all = true;
+            else if (arg === "--dry-run")
+                parsed.dryRun = true;
+            else if (arg === "--force")
+                parsed.force = true;
+            else if (arg === "--check")
+                parsed.check = true;
+            else if (arg === "--target" || arg === "--targets") {
+                const value = args[++index];
+                if (!value)
+                    throw new CPACError(`${arg} requires a comma-separated list`);
+                parsed.targets.push(...value
+                    .split(",")
+                    .map((entry) => entry.trim())
+                    .filter(Boolean));
+            }
+            else if (arg === "--home") {
+                const value = args[++index];
+                if (!value)
+                    throw new CPACError("--home requires a path");
+                parsed.home = resolve(expandUserPath(value));
+            }
+            else if (arg === "--config") {
+                const value = args[++index];
+                if (!value)
+                    throw new CPACError("--config requires a path");
+                parsed.configPath = resolve(expandUserPath(value));
+            }
+            else {
+                throw new CPACError(`unknown option: ${arg}`);
+            }
+        }
+        return parsed;
+    }
+    if (args[0] === "pi" || args[0] === "kimi") {
         let configPath = defaultConfigPath();
         let index = 1;
         if (args[index] === "--config") {
@@ -1083,7 +1590,7 @@ function parseArgs(args) {
             index += 1;
         }
         const action = args[index] || "status";
-        return { command: "pi", configPath, action };
+        return { command: args[0], configPath, action };
     }
     if (args[0] === "claude") {
         let configPath = defaultConfigPath();
@@ -1138,15 +1645,38 @@ export async function main(args = process.argv.slice(2)) {
         const parsed = parseArgs(args);
         if (!parsed)
             return 0;
+        if ("home" in parsed && parsed.home)
+            process.env.HOME = parsed.home;
         const config = loadConfig(parsed.configPath, true);
         if (parsed.command === "guide")
             return await guide(config);
+        if (parsed.command === "detect")
+            return await runDetect(config, parsed.json);
+        if (parsed.command === "install")
+            return await runInstall(config, parsed.targets, {
+                all: parsed.all,
+                dryRun: parsed.dryRun,
+                force: parsed.force,
+            });
+        if (parsed.command === "uninstall")
+            return await runUninstall(config, parsed.targets, {
+                all: parsed.all,
+                dryRun: parsed.dryRun,
+            });
+        if (parsed.command === "upgrade")
+            return await runUpgrade(parsed.check);
+        if (parsed.command === "version") {
+            console.log(CPAC_VERSION);
+            return 0;
+        }
         if (parsed.command === "claude")
             return await runClaude(config, parsed.args);
         if (parsed.command === "proxy")
             return await runProxy(config);
         if (parsed.command === "pi")
             return await runPi(config, parsed.action);
+        if (parsed.command === "kimi")
+            return await runKimi(config, parsed.action);
         if (parsed.command === "inject")
             await inject(config);
         else if (parsed.command === "restore")

package/dist/pi-extension.template

@@ -16,7 +16,7 @@ const MAX_TOKENS = {
   "claude-opus-4-6-thinking": 128000, "claude-sonnet-4-6": 64000,
   "gemini-3.6-flash": 65536, "gemini-3.6-flash-high": 65536,
   "deepseek-v4-pro": 128000, "deepseek-v4-flash": 128000,
-  "glm-5.2": 128000, "kimi-k2.7-code": 128000, "minimax-m3": 128000,
+  "glm-5.3": 128000, "kimi-k2.7-code": 128000, "minimax-m3": 128000,
   "mimo-v2.5": 131072, "mimo-v2.5-pro": 131072, "grok-4.5": 128000,
   "doubao-seed-2.0-lite": 128000, "doubao-seed-2.1-turbo": 128000,
 };
@@ -40,20 +40,44 @@ function intField(value) {
 
 export default async function (pi) {
   const apiKey = (process.env.CPA_API_KEY || "").trim();
-  if (!apiKey) return;
+  if (!apiKey) {
+    console.error("[cpac] CPA_API_KEY not set; skipping CPA providers");
+    return;
+  }
   let payload;
   try {
     const res = await fetch(CPA + "/v1/models?client_version=1", {
       headers: { Authorization: "Bearer " + apiKey },
       signal: AbortSignal.timeout(10000),
     });
-    if (!res.ok) return;
+    if (!res.ok) {
+      console.error("[cpac] CPA models request failed: HTTP " + res.status);
+      return;
+    }
     payload = await res.json();
-  } catch { return; }
-  if (!payload || typeof payload !== "object" || !Array.isArray(payload.models)) return;
-  const rows = payload.models.filter(function (m) {
-    return m && typeof m === "object" && typeof m.slug === "string";
-  });
+  } catch (error) {
+    console.error("[cpac] CPA models request failed: " + (error && error.message || error));
+    return;
+  }
+  const source = payload && Array.isArray(payload.models)
+    ? payload.models
+    : payload && Array.isArray(payload.data) ? payload.data : null;
+  if (!source) {
+    console.error("[cpac] CPA models response has no models list");
+    return;
+  }
+  const rows = [];
+  for (const m of source) {
+    if (!m || typeof m !== "object") continue;
+    const slug = typeof m.slug === "string" && m.slug.trim()
+      ? m.slug.trim()
+      : typeof m.id === "string" && m.id.trim() ? m.id.trim() : null;
+    if (slug) rows.push({ slug: slug, display_name: m.display_name, supported_reasoning_levels: m.supported_reasoning_levels, context_window: m.context_window });
+  }
+  if (rows.length === 0) {
+    console.error("[cpac] CPA models response has no usable models");
+    return;
+  }
   const groups = new Map();
   for (const m of rows) {
     const name = groupName(vendorFor(m.slug));

package/package.json

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