@yhong91/cpac 0.1.25 → 0.1.27

package/README.md

@@ -41,15 +41,15 @@ cpac install --all                     # 注入所有检测到的目标（codex/
 cpac install --target codex            # 只注入 Codex（默认开启 multi-agent v2）
 cpac install --target codex --v2_models  # 先多选 spawn_agent 模型再注入
 cpac install --target codex --max_context  # 注入时把模型上下文提升到实测上限（opt-in，仅限 codex）
-cpac uninstall --target codex          # 字节级恢复原配置
+cpac restore --target codex            # 字节级恢复原配置
 
 # 4b. 临时接管（退出无痕，不写任何配置文件）
 cpac claude                            # Claude Code 走 CPA
 cpac opencode                          # opencode 走 CPA（模型选 cpac/<模型名>）
 
 # 5. 可选：Agent 配置向导与模型选择
-cpac codex setup                       # 进入 Codex 配置向导（Subagent 模型多选、最大上下文、Multi-Agent V2）
-cpac claude setup                      # 进入 Claude Code 模型向导（Sonnet、Haiku、Opus 槽位选择）
+cpac codex --setup                     # Codex 配置向导 → 注入 → 启动
+cpac claude --setup                    # Claude 模型向导 → 启动
 
 # 6. 升级（装上新版本后自动 sync 已接入的 agent）
 cpac upgrade
@@ -80,7 +80,7 @@ cpac status   # 验证：CPA_API_KEY 应显示 configured
 }
 ```
 
-   Claude 槽位（opus/sonnet/haiku）通常不用配：cpac 启动时自动选择——同家族 claude 模型优先，否则 gemini → grok → luna → 目录第一个；opus 无匹配则不设。这个链条在常见目录上正好给出理想结果：sonnet 落在 claude-sonnet-*（它同时充当 Auto mode 分类器的替身，避免分类请求失败后回退到昂贵的会话主模型），haiku 落在快的 gemini flash。只有目录奇怪时才用 `cpac claude setup` 交互式配置。codex spawn subagent 取三个 GPT + gemini + grok 五席（顺序即优先级，Codex 只广告 catalog 前 5），可通过 `cpac codex setup` 交互式配置。候选替换：`mimo-v2.5`（haiku）、`grok-4.5`（haiku）。若上述 slug 不在目录中（`curl -s -H "Authorization: Bearer $CPA_API_KEY" "$CPA_BASE_URL/v1/models"` 可查），按家族就近替换。分类器机制细节见 [docs/claude-auto-mode-classifier.md](docs/claude-auto-mode-classifier.md)。
+   Claude 槽位（opus/sonnet/haiku）通常不用配：cpac 启动时自动选择——同家族 claude 模型优先，否则 gemini → grok → luna → 目录第一个；opus 无匹配则不设。这个链条在常见目录上正好给出理想结果：sonnet 落在 claude-sonnet-*（它同时充当 Auto mode 分类器的替身，避免分类请求失败后回退到昂贵的会话主模型），haiku 落在快的 gemini flash。只有目录奇怪时才用 `cpac claude --setup` 交互式配置。codex spawn subagent 取三个 GPT + gemini + grok 五席（顺序即优先级，Codex 只广告 catalog 前 5），可通过 `cpac codex --setup` 交互式配置。候选替换：`mimo-v2.5`（haiku）、`grok-4.5`（haiku）。若上述 slug 不在目录中（`curl -s -H "Authorization: Bearer $CPA_API_KEY" "$CPA_BASE_URL/v1/models"` 可查），按家族就近替换。分类器机制细节见 [docs/claude-auto-mode-classifier.md](docs/claude-auto-mode-classifier.md)。
 
 1. **持久注入**（只对检测到的目标；codex 会应用步骤 3 的 spawn_models）：
 
@@ -91,7 +91,7 @@ cpac status   # 验证：各 target 显示 ready/injected
 
 1. **统一启动与配置**：
    - 启动：`cpac <codex|claude|kimi|grok|pi|opencode> [args...]`（所有原生参数如 `-c` 等原样透明传递）
-   - 配置：`cpac <codex|claude> setup`（交互式配置模型与特性）
+   - 配置并启动：`cpac <codex|claude> --setup`（向导结束后注入并拉起）
    - 还原：`cpac <agent> clear`（还原或重置配置）
 
 2. **已安装后升级**：npm 发布新版本后，等 publish 成功再执行 `cpac upgrade`。它会按需 `npm install -g`，再对已接入的 Codex / Pi / Kimi / Grok 做 `sync`。不要拆成 `npm install -g @yhong91/cpac` 再手动 `cpac sync`。只刷新配置、不升 CLI 时才用 `cpac sync`。
@@ -112,7 +112,7 @@ Commands:
   cpac claude [args...]  Launch Claude Code through CPA
   cpac inject            Inject CPA into Codex
   cpac status            Show Codex injection status
-  cpac restore           Restore the original Codex config
+  cpac restore --target <id> | --all  Detach injected agents
   cpac --help            Show command usage
 ```
 
@@ -158,7 +158,7 @@ cpac
 cpac --help
 ```
 
-### 统一管理（detect / install / sync / uninstall / upgrade）
+### 统一管理（detect / install / sync / restore / uninstall / upgrade）
 
 参考 vibetime 的目标式命令，对 `codex`、`pi`、`kimi` 三个持久注入目标统一管理（claude/opencode 是临时接管，用 `cpac claude` / `cpac opencode` 启动，不属于 install 目标）：
 
@@ -166,9 +166,10 @@ cpac --help
 cpac detect [--json] [--home PATH]
 cpac install [--target codex,pi,kimi] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]
 cpac sync [--target codex,pi,kimi] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]
-cpac uninstall [--target codex,pi,kimi] [--all] [--dry-run] [--home PATH]
+cpac restore --target <id> | --all [--dry-run] [--home PATH]
+cpac uninstall [--dry-run]
 cpac upgrade [--check]
-cpac version
+cpac -v | --version
 ```
 
 - `detect` 列出每个目标是否被检测到、是否已接入 CPAC；`--json` 输出机器可读结果。
@@ -176,7 +177,8 @@ cpac version
 - `sync` 按当前 `cpa_url` 和 CPA 目录强制刷新**已经接入**的目标（Codex 重新注入、Pi 扩展重写、Kimi 配置重写），用来在 CPA 地址或模型目录变化后一次对齐本地配置。不带参数只动已安装目标；`--all` 会对检测到的目标做同样的强制刷新（尚未安装的会装上）。`--max_context` 仍只对 `--target codex` 有效。
 - Codex 注入默认开启 multi-agent v2（写入 `[features.multi_agent_v2] enabled = true`）；`install --target codex --v2_off` 写入 `enabled = false`。服务端还需在 CPA 配置中开启 `codex.optimize-multi-agent-v2`。
 - `--v2_models` 进入 arrow-key 复选框选择最多 5 个 spawn_agent 模型（勾选顺序即推荐顺序），选择结果存入配置文件的 `spawn_models`，注入时把这些模型排到 `codex-models.json` 最前——Codex 客户端只把 catalog 前 5 个可见模型广告为 spawn 覆盖项。
-- `uninstall` 默认作用于已安装目标，映射到 `cpac restore` / `cpac pi uninstall` / `cpac kimi uninstall`。
+- `restore` 必须带 `--target` 或 `--all`，卸掉指定（或全部）已注入目标。`--all` 时未安装的目标静默跳过。
+- `uninstall` 先用和 `cpac codex --setup` 相同的方向键选择器确认（默认 Cancel），再 `restore --all`，最后 `npm uninstall -g @yhong91/cpac`。不要用 `--target`。非终端取消。`--dry-run` 跳过确认。
 - `--home PATH` 临时把 `HOME` 指向给定目录，便于在隔离环境中试验。
 - `upgrade` 是发布后更新本机的一次性入口：查 npm → 需要时 `npm install -g` → 对**已接入**的 Codex / Pi / Kimi 执行 `sync`。已是最新也会 sync。不要先手动 `npm install -g` 再 `cpac sync`。`--check` 只报告版本，不安装也不 sync。没有已安装目标时跳过 sync，不报错。只刷新配置、不升 CLI 时用 `cpac sync`。
 
@@ -194,7 +196,7 @@ cpac claude -- -p "检查当前项目"
 #### 配置与清除
 
 ```bash
-cpac claude setup                      # 交互式依次配置 Sonnet / Haiku / Opus
+cpac claude --setup                    # 交互式依次配置 Sonnet / Haiku / Opus，然后启动
 cpac claude clear                      # 重置所有覆盖，恢复自动选择
 ```
 
@@ -223,7 +225,7 @@ cpac codex exec "帮我写一个测试"
 #### 配置与清除
 
 ```bash
-cpac codex setup                       # 交互式配置 Subagent 候选模型、最大上下文和 Multi-Agent V2
+cpac codex --setup                     # 交互式配置后注入并启动 Codex
 cpac codex clear                       # 还原 Codex 原生配置并关闭代理
 ```
 
@@ -231,7 +233,7 @@ cpac codex clear                       # 还原 Codex 原生配置并关闭代
 
 ```bash
 cpac inject [--v2_off] [--v2_models] [--max_context] [--config PATH]
-cpac restore
+cpac restore --target codex
 ```
 
 `inject` 从远端 `/v1/models?client_version=1` 获取 Codex rich catalog，并启动只监听 `127.0.0.1` 的轻量转发代理。Codex 配置保留内置 `openai` provider，只写入根级 `model_catalog_json` 和：
@@ -286,8 +288,7 @@ cpac pi install
 它将生成 `cpac.ts` 写入 `~/.pi/agent/extensions/`，Pi 启动时自动加载并从 CPA 动态注册模型目录。卸载：
 
 ```bash
-cpac pi uninstall
-cpac pi status
+cpac restore --target pi
 ```
 
 Pi 扩展尊重 `PI_CODING_AGENT_DIR` 环境变量。
@@ -303,8 +304,7 @@ cpac kimi install
 它在 `~/.kimi-code/config.toml` 追加一个由 CPAC 管理的块，注册 `cpac` OpenAI 兼容 provider，并把 CPA 目录里的每个模型映射为一个 `cpac/<模型名>` 条目。带 `supported_reasoning_levels` 的模型会写入 `capabilities`、`support_efforts` 和 `default_effort`，否则 Kimi 只给 Claude 名套内置 thinking profile，其它模型会停在 thinking off 且无法改 effort。`base_url` 指向 Codex 注入使用的 loopback 代理，因此密钥不落盘；代理未运行时 install 会提示先执行 `cpac inject`。卸载与状态：
 
 ```bash
-cpac kimi uninstall
-cpac kimi status
+cpac restore --target kimi
 ```
 
 Kimi Code 配置目录尊重 `KIMI_CODE_HOME` 环境变量。首次写入前若 `config.toml` 已存在，会在同目录保留一份原始快照 `config.toml.cpac-backup`（只存最早版本），万一文件损坏可手动复制回去。

package/dist/agents.js

@@ -0,0 +1,445 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fetchCatalog, pickSpawnModels, proxyFingerprint, readState, saveSpawnModels, stateBytes, stateProxy, } from "./config.js";
+import { proxyIsHealthy, startProxyProcess, stopProxyProcess, } from "./proxy.js";
+import { MANAGED_MARKER, inject, restore } from "./targets/codex.js";
+import { grokConfigPath, grokHome, installGrokConfig, isGrokConfigInstalled, uninstallGrokConfig, } from "./targets/grok.js";
+import { installKimiConfig, isKimiConfigInstalled, kimiConfigPath, uninstallKimiConfig, } from "./targets/kimi.js";
+import { installPiExtension, isPiExtensionInstalled, piExtensionsDir, uninstallPiExtension, } from "./targets/pi.js";
+import { CPACError, atomicWrite, checkboxPicker, expandUserPath, objectValue, resolveApiKey, } from "./util.js";
+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 (!options.skipSync) {
+        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 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 runRestore(config, requested, options) {
+    if (requested.length === 0 && !options.all) {
+        throw new CPACError("restore requires --target <id> or --all");
+    }
+    const eligible = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
+    const selected = selectTargets(requested, options.all, eligible);
+    for (const target of selected) {
+        if (!target.installed(config)) {
+            if (requested.length > 0)
+                console.log(`${target.id}: not installed`);
+            continue;
+        }
+        await target.uninstall(config, options.dryRun);
+    }
+    return 0;
+}
+async function confirmUninstall() {
+    let choice;
+    try {
+        [choice] = await checkboxPicker("This will restore all agents and run npm uninstall -g @yhong91/cpac.", ["Cancel", "Uninstall"], 1);
+    }
+    catch (error) {
+        if (error instanceof CPACError)
+            throw new CPACError("uninstall cancelled");
+        throw error;
+    }
+    if (choice !== "Uninstall")
+        throw new CPACError("uninstall cancelled");
+}
+export async function runUninstall(config, options) {
+    if (!options.dryRun)
+        await confirmUninstall();
+    await runRestore(config, [], { all: true, dryRun: options.dryRun });
+    if (options.dryRun) {
+        console.log("would uninstall @yhong91/cpac");
+        return 0;
+    }
+    console.log("Uninstalling @yhong91/cpac");
+    const result = spawnSync("npm", ["uninstall", "-g", "@yhong91/cpac"], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        console.error("npm uninstall failed");
+        return result.status ?? 1;
+    }
+    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 });
+}