@yhong91/cpac 0.1.25 → 0.1.26

package/dist/agents.js

@@ -0,0 +1,784 @@
+import { spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { apiBase, catalogModelId, catalogModelRows, fetchCatalog, pickSpawnModels, proxyFingerprint, readState, saveSpawnModels, stateBytes, stateProxy, } from "./config.js";
+import { MANAGED_MARKER, inject, restore } from "./codex.js";
+import { proxyIsHealthy, startProxyProcess, stopProxyProcess, } from "./proxy.js";
+import { CPACError, atomicWrite, checkboxPicker, expandUserPath, objectValue, resolveApiKey, tomlString, tomlStringArray, } 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));
+    });
+}
+export async function runCodexConfig(config, configPath, options = {}) {
+    if (options.reset) {
+        let raw = {};
+        try {
+            const file = JSON.parse(readFileSync(configPath, "utf8"));
+            if (!objectValue(file))
+                throw new CPACError("config must be a JSON object");
+            raw = file;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                if (error instanceof CPACError)
+                    throw error;
+                throw new CPACError(`cannot read config: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        delete raw.spawn_models;
+        atomicWrite(configPath, Buffer.from(`${JSON.stringify(raw, null, 2)}\n`));
+        await runRestore(config, ["codex"], { all: false, dryRun: false });
+        console.log("Codex configuration reset to default");
+        return 0;
+    }
+    if (options.interactive && (!process.stdin.isTTY || !process.stderr.isTTY)) {
+        console.log(config.spawn_models
+            ? JSON.stringify(config.spawn_models, null, 2)
+            : "spawn_models not set");
+        return 0;
+    }
+    let spawnModels = config.spawn_models;
+    let v2Off = options.v2Off ?? false;
+    let maxContext = options.maxContext ?? false;
+    if (options.interactive || options.v2Models) {
+        const picked = await pickSpawnModels(config);
+        if (picked.length > 0) {
+            spawnModels = picked;
+            saveSpawnModels(configPath, picked);
+            console.log(`spawn_models saved to ${configPath}: ${picked.join(", ")}`);
+        }
+        if (options.interactive) {
+            const [maxCtxChoice] = await checkboxPicker("Codex Context Window Size:", [
+                "Standard (default input budget, e.g. 200K~272K)",
+                "Max Context Window (lift to full upper bound, e.g. 921K~1M, 90% auto-compact limit)",
+            ], 1);
+            maxContext = maxCtxChoice?.startsWith("Max Context") ?? false;
+            const [v2Choice] = await checkboxPicker("Codex Multi-Agent V2 mode:", ["Enabled (Default)", "Disabled (--v2_off)"], 1);
+            v2Off = v2Choice === "Disabled (--v2_off)";
+        }
+    }
+    const updatedConfig = { ...config, spawn_models: spawnModels };
+    await runInstall(updatedConfig, ["codex"], {
+        all: false,
+        dryRun: false,
+        force: true,
+        v2Off,
+        maxContext,
+    });
+    console.log("Codex configuration updated and synced.");
+    return 0;
+}
+export async function runTargetLauncher(config, targetId, args, executable = targetId, options = {}) {
+    const target = TARGETS.find((t) => t.id === targetId);
+    if (!target)
+        throw new CPACError(`unknown target: ${targetId}`);
+    if (["kimi", "grok"].includes(targetId)) {
+        const state = readState(config.state_dir);
+        const proxy = state ? stateProxy(state) : null;
+        if (!proxy || !(await proxyIsHealthy(proxy))) {
+            if (proxy)
+                await stopProxyProcess(proxy);
+            const apiKey = await resolveApiKey(config.api_key_env);
+            const started = await startProxyProcess(config, apiKey);
+            try {
+                const fingerprint = proxyFingerprint(config, apiKey);
+                const catalog = await fetchCatalog(config.cpa_url, apiKey);
+                const catalogPath = join(config.state_dir, "codex-models.json");
+                mkdirSync(config.state_dir, { recursive: true, mode: 0o700 });
+                atomicWrite(catalogPath, catalog.bytes);
+                const originalMode = existsSync(config.codex_config)
+                    ? statSync(config.codex_config).mode & 0o7777
+                    : 0o600;
+                atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, state ? state.config_existed : false, state ? state.config_mode : originalMode, started, fingerprint));
+            }
+            catch (error) {
+                await stopProxyProcess(started);
+                throw error;
+            }
+        }
+    }
+    if (target.installed(config)) {
+        try {
+            await runSync(config, [targetId], {
+                all: false,
+                dryRun: false,
+                v2Off: options.v2Off,
+                maxContext: options.maxContext,
+            });
+        }
+        catch (error) {
+            console.warn(`warning: auto-sync failed (${error instanceof Error ? error.message : String(error)}); launching with existing config`);
+        }
+    }
+    else {
+        await target.install(config, false, options.v2Off, options.maxContext);
+    }
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(executable, args, { stdio: "inherit" });
+        child.once("error", (error) => {
+            rejectPromise(new CPACError(error instanceof Error && "code" in error && error.code === "ENOENT"
+                ? `${executable} not found`
+                : `cannot start ${executable}: ${error.message}`));
+        });
+        child.once("close", (code) => resolvePromise(code ?? 1));
+    });
+}
+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}`);
+}
+// 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 {
+        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}`);
+}
+function grokHome() {
+    const home = process.env.GROK_HOME?.trim() || join(homedir(), ".grok");
+    return expandUserPath(home);
+}
+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}`);
+}
+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";
+    }
+}
+export const CPAC_VERSION = readPackageVersion();
+export function detectClientVersion(binary) {
+    if (!/^[\w.-]+$/.test(binary))
+        return undefined;
+    try {
+        const res = spawnSync(binary, ["--version"], {
+            encoding: "utf8",
+            timeout: 2000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        if (res.status === 0 && typeof res.stdout === "string") {
+            const match = res.stdout.match(/v?(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+            return match ? match[1] : res.stdout.trim().split(/\s+/)[0] || undefined;
+        }
+    }
+    catch {
+        // ignored
+    }
+    return undefined;
+}
+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 readFileSync(config.codex_config, "utf8").includes(MANAGED_MARKER);
+            }
+            catch {
+                return false;
+            }
+        },
+        version: () => detectClientVersion("codex"),
+        install: async (config, dryRun, v2Off, maxContext) => {
+            if (dryRun) {
+                console.log("would inject CPA catalog and loopback proxy into Codex");
+                return;
+            }
+            await inject(config, v2Off, maxContext);
+        },
+        uninstall: async (config, dryRun) => {
+            if (dryRun) {
+                console.log("would restore the original Codex config");
+                return;
+            }
+            await restore(config);
+        },
+    },
+    {
+        id: "pi",
+        home: () => piExtensionsDir(),
+        detected: () => binaryOnPath("pi") || existsSync(piExtensionsDir()),
+        installed: () => isPiExtensionInstalled(),
+        version: () => detectClientVersion("pi"),
+        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(),
+        version: () => detectClientVersion("kimi"),
+        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();
+        },
+    },
+    {
+        id: "grok",
+        home: () => grokHome(),
+        detected: () => binaryOnPath("grok") || existsSync(grokHome()),
+        installed: () => isGrokConfigInstalled(),
+        version: () => detectClientVersion("grok"),
+        install: async (config, dryRun) => {
+            if (dryRun) {
+                console.log(`would write CPA provider block: ${grokConfigPath()}`);
+                return;
+            }
+            await installGrokConfig(config);
+        },
+        uninstall: async (_config, dryRun) => {
+            if (dryRun) {
+                console.log(`would remove CPA provider block: ${grokConfigPath()}`);
+                return;
+            }
+            await uninstallGrokConfig();
+        },
+    },
+];
+export async function detectTargets(config) {
+    return TARGETS.map((target) => ({
+        id: target.id,
+        detected: target.detected(),
+        installed: target.installed(config),
+        path: target.home(),
+        version: target.version?.(),
+    }));
+}
+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`);
+    }
+    // Catalog context lifting is Codex-specific; refuse to silently skip it on
+    // other targets so the flag never gains cross-agent meaning.
+    if (options.maxContext && selected.some((target) => target.id !== "codex")) {
+        throw new CPACError("--max_context is only valid with --target codex");
+    }
+    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, options.v2Off, options.maxContext);
+    }
+    return 0;
+}
+export async function runSync(config, requested, options) {
+    const installed = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
+    if (requested.length === 0 && !options.all) {
+        if (installed.length === 0) {
+            throw new CPACError("no installed CPAC integrations found; run cpac install first");
+        }
+        return runInstall(config, installed, {
+            all: false,
+            dryRun: options.dryRun,
+            force: true,
+            v2Off: options.v2Off,
+            maxContext: options.maxContext,
+        });
+    }
+    return runInstall(config, requested, {
+        all: options.all,
+        dryRun: options.dryRun,
+        force: true,
+        v2Off: options.v2Off,
+        maxContext: options.maxContext,
+    });
+}
+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;
+}
+export async function runRestore(config, requested, options) {
+    if (requested.length > 0 || options.all) {
+        return runUninstall(config, requested, options);
+    }
+    if (options.dryRun) {
+        console.log("would restore the original Codex config");
+        return 0;
+    }
+    await restore(config);
+    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(config, 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}`);
+    const upToDate = compareVersions(CPAC_VERSION, latest) >= 0;
+    if (checkOnly) {
+        if (upToDate)
+            console.log("Already up to date.");
+        else
+            console.log("Update available. Run: cpac upgrade");
+        return 0;
+    }
+    if (upToDate) {
+        console.log("Already up to date.");
+    }
+    else {
+        console.log(`Installing @yhong91/cpac@${latest}`);
+        const result = spawnSync("npm", ["install", "-g", `@yhong91/cpac@${latest}`], { stdio: "inherit" });
+        if (result.status !== 0) {
+            console.error("npm install failed");
+            return result.status ?? 1;
+        }
+    }
+    const installed = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
+    if (installed.length === 0) {
+        console.log("No installed agents to sync.");
+        return 0;
+    }
+    console.log(`Syncing ${installed.join(", ")}`);
+    return runSync(config, [], { all: false, dryRun: false });
+}