@yhong91/cpac 0.2.3 → 0.2.4

package/README.md

@@ -10,7 +10,7 @@ CPAC 将 Codex 和 Claude Code 接入远端 CLIProxyAPI（CPA）：
 ## 要求
 
 - [Node.js](https://nodejs.org/) 20 或更新版本（npm 随 Node 安装）
-- 已安装需要使用的 agent：`codex`、`claude`、`pi`、`kimi`、`grok`、`zed`、`hermes` 或 `cline`
+- 已安装需要使用的 agent：`codex`、`claude`、`pi`、`kimi`、`grok`、`zed`、`hermes` 或 `codebuddy`
 - 有权访问的 CPA API key
 
 ## 安装
@@ -37,7 +37,7 @@ echo 'export CPA_API_KEY="<你的key>"' >> ~/.zshrc && source ~/.zshrc
 cpac status
 
 # 4a. 持久注入（长期生效，写入 agent 配置，可完整恢复）
-cpac install --all                     # 注入所有检测到的目标（codex/pi/kimi/grok/zed/hermes/cline）
+cpac install --all                     # 注入所有检测到的目标（codex/pi/kimi/grok/zed/hermes/codebuddy）
 cpac install codex                     # 只注入 Codex（默认开启 multi-agent v2）
 cpac install codex --v2_models         # 先多选 spawn_agent 模型再注入
 cpac install codex --max_context       # 注入时把模型上下文提升到实测上限（opt-in，仅限 codex）
@@ -61,7 +61,7 @@ cpac upgrade
 
 本节面向 AI agent：按顺序执行即可完成安装与配置，**全程无交互**。注意：`cpac codex --config` 和 `cpac claude --config` 的交互向导是 TTY-only，agent 必须走下方直接写配置 JSON 的路径。
 
-1. **检查前置**：`node --version` ≥ 20；确认用户需要哪些 agent（`codex`/`claude`/`pi`/`kimi`/`grok`/`zed`/`hermes`/`cline` 在 PATH 上）。向用户索取 CPA API key。
+1. **检查前置**：`node --version` ≥ 20；确认用户需要哪些 agent（`codex`/`claude`/`pi`/`kimi`/`grok`/`zed`/`hermes`/`codebuddy` 在 PATH 上）。向用户索取 CPA API key。
 
 2. **安装与密钥**：
 
@@ -90,14 +90,14 @@ cpac status   # 验证：各 target 显示 ready/injected
 ```
 
 1. **统一启动与配置**：
-   - 启动：`cpac <codex|claude|kimi|grok|pi|zed|hermes|cline> [args...]`（所有原生参数如 `-c` 等原样透明传递）
+   - 启动：`cpac <codex|claude|kimi|grok|pi|zed|hermes|codebuddy> [args...]`（所有原生参数如 `-c` 等原样透明传递）
      - `setup` / `--setup`：配置 Codex/Claude，然后启动
      - `clear`：还原原生配置
    - 只写配置、不启动：`cpac setup [claude|codex]`；查看当前：`cpac setup`
 
 2. **已安装后升级**：npm 发布新版本后，等 publish 成功再执行 `cpac upgrade`。它会按需 `npm install -g`，再对已接入的 Codex / Pi / Kimi / Grok / Zed / Hermes 做 `sync`。不要拆成 `npm install -g @yhong91/cpac` 再手动 `cpac sync`。只刷新配置、不升 CLI 时才用 `cpac sync`。
 
-失败处理：任何一步报错时先跑 `cpac status`；密钥未配置回到步骤 2；注入后异常用 `cpac <agent> clear` 或 `cpac restore <codex|pi|kimi|grok|zed|hermes|cline>` 恢复原配置。
+失败处理：任何一步报错时先跑 `cpac status`；密钥未配置回到步骤 2；注入后异常用 `cpac <agent> clear` 或 `cpac restore <codex|pi|kimi|grok|zed|hermes|codebuddy>` 恢复原配置。
 
 ## 首次引导
 
@@ -114,7 +114,7 @@ Commands:
   cpac setup            Show current Codex/Claude setup
   cpac status            Show agent support status
   cpac models            List remote CPA catalog models
-  cpac restore <codex|pi|kimi|grok|zed|hermes|cline> | --all  Detach injected agents
+  cpac restore <codex|pi|kimi|grok|zed|hermes|codebuddy> | --all  Detach injected agents
   cpac --help            Show command usage
 ```
 
@@ -162,14 +162,14 @@ cpac --help
 
 ### 统一管理（detect / install / sync / restore / uninstall / upgrade）
 
-参考 vibetime 的目标式命令，对 `codex`、`pi`、`kimi`、`grok`、`zed`、`hermes`、`cline` 七个持久注入目标统一管理（claude 是临时接管，用 `cpac claude` 启动，不属于 install 目标）：
+参考 vibetime 的目标式命令，对 `codex`、`pi`、`kimi`、`grok`、`zed`、`hermes`、`codebuddy` 七个持久注入目标统一管理（claude 是临时接管，用 `cpac claude` 启动，不属于 install 目标）：
 
 ```bash
 cpac detect [--json]
 cpac models [--json]
-cpac install [codex|pi|kimi|grok|zed|hermes|cline...] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context]
-cpac sync [codex|pi|kimi|grok|zed|hermes|cline...] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context]
-cpac restore <codex|pi|kimi|grok|zed|hermes|cline...> | --all [--dry-run]
+cpac install [codex|pi|kimi|grok|zed|hermes|codebuddy...] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context]
+cpac sync [codex|pi|kimi|grok|zed|hermes|codebuddy...] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context]
+cpac restore <codex|pi|kimi|grok|zed|hermes|codebuddy...> | --all [--dry-run]
 cpac uninstall [--dry-run]
 cpac upgrade [--check]
 cpac -v | --version
@@ -177,13 +177,13 @@ cpac -v | --version
 
 - `models` 从远端 CPA 拉取 rich catalog，默认一行一个 slug；`--json` 输出 `cpa_url` 和模型字段（`slug` / `display_name` / `context_window`）。用来核对 catalog 里有没有某个模型（例如 `*-fast`），不写本地配置。
 - `detect` 列出每个目标是否被检测到、是否已接入 CPAC；`--json` 输出机器可读结果。
-- `install` 默认作用于检测到的目标；后面直接写 agent 名（`cpac install codex pi`），`--all` 全部。`codex` 写入 catalog 并拉起 loopback 代理；`pi`/`kimi`/`grok`/`zed`/`hermes`/`cline` 写入各自配置。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
-- `sync` 按当前 `cpa_url` 和 CPA 目录强制刷新**已经接入**的目标（Codex 重新注入、Pi / Kimi / Grok / Zed / Hermes / Cline 配置重写），用来在 CPA 地址或模型目录变化后一次对齐本地配置。不带参数只动已安装目标；`--all` 会对检测到的目标做同样的强制刷新（尚未安装的会装上）。`--max_context` 仍只对 `cpac install codex` 有效。
+- `install` 默认作用于检测到的目标；后面直接写 agent 名（`cpac install codex pi`），`--all` 全部。`codex` 写入 catalog 并拉起 loopback 代理；`pi`/`kimi`/`grok`/`zed`/`hermes`/`codebuddy` 写入各自配置。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
+- `sync` 把 CPA 模型列表和更新时间写到 `state_dir/models.json`（默认 `~/.cpac/models.json`）。这个时间戳就是模型版本：列表没变则时间戳不变，目标上次同步到的版本相同就跳过，不同才重写。不带参数只看已安装目标；`--all` 还会装上检测到但还没接入的目标。`install` 仍总是重写。`spawn_models`、`v2_off`、`max_context` 和代理端口不改这个版本，要马上生效用 `cpac install`。`--max_context` 仍只对 `cpac install codex` 有效。
 - Codex 注入默认开启 multi-agent v2（写入 `[features.multi_agent_v2] enabled = true`，catalog 行打 `multi_agent_version: "v2"`）；`install codex --v2_off` 关掉 toml 并去掉 catalog 戳。v2 开着时会剥掉 `[agents] max_threads`（Codex 否则拒启动）。`cpac status` 对照 config 里的 `v2_off` / `max_context` 和 live toml / catalog。服务端还需在 CPA 配置中开启 `codex.optimize-multi-agent-v2`。
 - `--v2_models` 进入 arrow-key 复选框选择最多 5 个 spawn_agent 模型（勾选顺序即推荐顺序），选择结果存入配置文件的 `spawn_models`，注入时把这些模型排到 `codex-models.json` 最前——Codex 客户端只把 catalog 前 5 个可见模型广告为 spawn 覆盖项。
 - `restore` 必须带 agent 名或 `--all`，卸掉指定（或全部）已注入目标。`--all` 时未安装的目标静默跳过。
 - `uninstall` 先用和 `cpac setup codex` 相同的方向键选择器确认（默认 Cancel），再 `restore --all`，最后 `npm uninstall -g @yhong91/cpac`。不要跟 agent 名；卸载的是 cpac 包本身。非终端取消。`--dry-run` 跳过确认。
-- `upgrade` 是发布后更新本机的一次性入口：查 npm → 需要时 `npm install -g` → 对**已接入**的 Codex / Pi / Kimi / Grok / Zed / Hermes / Cline 执行 `sync`。已是最新也会 sync。不要先手动 `npm install -g` 再 `cpac sync`。`--check` 只报告版本，不安装也不 sync。没有已安装目标时跳过 sync，不报错。只刷新配置、不升 CLI 时用 `cpac sync`。
+- `upgrade` 是发布后更新本机的一次性入口：查 npm → 需要时 `npm install -g` → 对**已接入**的 Codex / Pi / Kimi / Grok / Zed / Hermes / CodeBuddy 执行 `sync`。已是最新也会 sync。不要先手动 `npm install -g` 再 `cpac sync`。`--check` 只报告版本，不安装也不 sync。没有已安装目标时跳过 sync，不报错。只刷新配置、不升 CLI 时用 `cpac sync`。
 
 ### Claude Code
 
@@ -253,9 +253,9 @@ Codex App 的长驻 `app-server` 可能缓存旧目录。注入会删除 `models
 
 注入命令可选 `--max_context`（`cpac install codex --max_context`，默认不带）：把 catalog 中 `max_context_window` 高于 `context_window` 的模型提升到上限，并把 `auto_compact_token_limit` 设为上限的 90%。Codex 把 `context_window` 当输入预算而非展示标签，上游默认保留保守运营值（如 GPT-5.6 家族 272k），带上该参数后可用到实测上限（约 921k，opencodex 实测）；90% 压缩线确保在硬上限前触发 auto-compact。不带参数注入的仍是原本上下文的目录。该参数仅限 codex，与其他 target 组合使用会直接报错。
 
-`config.toml` 不存在时拒绝注入。当前是 native 时把原文件备份到 `state_dir/codex/config.toml`（覆盖更旧的 native 快照）；已注入后再装不覆盖备份。kimi/grok/zed/hermes/pi/cline 同样：没有旧配置不写空备份，native 覆盖旧快照，已接入则保留。所有 target 的 restore 都按 Codex 规则：注入后记下文件 hash；相对注入未改则逐字节还原备份（没有备份则删除我们创建的文件）；注入后改过则只剥 CPAC 字段，用户改动留下。没有其它需要代理的 agent 时才关闭代理。
+`config.toml` 不存在时拒绝注入。当前是 native 时把原文件备份到 `state_dir/codex/config.toml`（覆盖更旧的 native 快照）；已注入后再装不覆盖备份。kimi/grok/zed/hermes/pi/codebuddy 同样：没有旧配置不写空备份，native 覆盖旧快照，已接入则保留。所有 target 的 restore 都按 Codex 规则：注入后记下文件 hash；相对注入未改则逐字节还原备份（没有备份则删除我们创建的文件）；注入后改过则只剥 CPAC 字段，用户改动留下。没有其它需要代理的 agent 时才关闭代理。
 
-loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac install codex` 或 `cpac pi` / `cpac kimi` / `cpac grok` / `cpac zed` / `cpac hermes` / `cpac cline` 即可恢复。
+loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac install codex` 或 `cpac pi` / `cpac kimi` / `cpac grok` / `cpac zed` / `cpac hermes` / `cpac codebuddy` 即可恢复。
 
 默认路径：
 
@@ -268,8 +268,8 @@ CPAC state：~/.cpac/state.json（公用 proxy 字段 + 已接入 agent 记录
   Grok   ~/.cpac/grok/config.toml
   Zed    ~/.cpac/zed/settings.json
   Hermes ~/.cpac/hermes/config.yaml
-  Cline  ~/.cpac/cline/providers.json
   Pi     ~/.cpac/pi/models.json
+  CodeBuddy ~/.cpac/codebuddy/models.json
 restore / `<agent> clear` 会删掉该 agent 的备份目录和 state.json 里的对应记录
 ```
 
@@ -336,32 +336,26 @@ cpac restore hermes
 
 配置目录尊重 `HERMES_HOME`（Windows 默认 `%LOCALAPPDATA%\hermes`）。首次写入前若 default `config.yaml` 已存在，会在 `state_dir/hermes/config.yaml` 保留原始快照。profile 文件不单独备份，restore 只剥 `providers.cpac`。
 
-### Cline（CLI 与 Desktop）
+### CodeBuddy
 
-写入 CPA 的 OpenAI-compatible provider 到 Cline：
+把 CPA 目录写成 CodeBuddy 的自定义模型：
 
 ```bash
-cpac install cline
-cpac cline                          # 未显式传 -P/--provider 时自动注入 -P openai-compatible
-cpac cline "帮我写一个测试"           # 原生参数原样直通
-cpac cline -P cline "..."           # 显式指定 provider 时不注入
+cpac install codebuddy
+cpac codebuddy                       # 启动；原生参数原样直通
+cpac codebuddy -p "检查当前项目"       # 非交互模式
 ```
 
-Cline CLI 与 Cline Desktop 共享同一份 `~/.cline/data/settings/providers.json`（并共用同一本地 hub）。CPAC 在 `providers["openai-compatible"]` 槽位写入 loopback `baseUrl`、占位 `apiKey`（`cpac`）和默认模型——这是 Cline 唯一接受自定义 OpenAI 兼容端点的 provider 槽位（Cline 拒绝未知 provider id），因此一次注入对 CLI 和 Desktop 同时生效。两者的请求都是 `POST {baseUrl}/chat/completions`，loopback 代理会把入站 Authorization 换成真实 `CPA_API_KEY`。
+`~/.codebuddy/models.json` 是 CodeBuddy 官方放置第三方模型的地方，CPAC 只做**合并**：为每个 catalog slug 写一条 `models[]` 条目（`vendor: "CPAC"`、占位 `apiKey`（`cpac`）、`url` 指向 loopback `/v1/chat/completions`），你在同一文件里自己加的模型条目原样保留。loopback 代理把入站 Authorization 换成真实 `CPA_API_KEY`。
 
-- 模型：首次写入 catalog 第一个 slug；之后你在 Cline 里改过模型，`cpac sync cline` 会保留你的选择（只要该 slug 仍在目录里）。切换模型用 CLI 的 `-m <model>` 或 Desktop/IDE 的模型选择器。
-- provider 选择：`cpac cline` 默认注入 `-P openai-compatible`，避免走 Cline 官方托管 provider；Desktop 没有 CLI 参数，需要在 provider 列表里手动选 "OpenAI Compatible"。
-- 槽位冲突：如果该槽位已配置为其它端点，`cpac install cline` 会拒绝；用 `cpac install cline --force` 覆盖（原文件备份在 `state_dir/cline/providers.json`）。
-- 并发与恢复：Cline（尤其是常驻的 Desktop）会随时重写 `providers.json`。`restore` 按「注入后未改 → 逐字节还原备份；改过 → 只剥 CPAC 槽位、其余（包括你在 Cline 里改的 provider）留下」处理。Cline 侧改掉该槽位的 apiKey/baseUrl 后，注入即视为失效，重跑 `cpac install cline` / `cpac sync cline` 恢复。
-- Desktop 从 GUI 启动不继承 shell 环境变量，`CLINE_DATA_DIR` 覆盖只影响 CLI；两侧使用默认路径时注入对两边同时生效。
+- 字段映射：`maxInputTokens` 取 catalog 的 `context_window`（不是 `max_context_window`），`maxOutputTokens` 取 `max_output_tokens`，catalog 没给就不写这两个键；`supportsImages` / `supportsReasoning` 按 `input_modalities` / `supported_reasoning_levels` 推导，`supportsToolCall` 恒为 true。
+- 不写 `relatedModels`：CodeBuddy 的 lite / reasoning 场景因此回落到主模型，而不是借用内置默认值。
+- `availableModels` 只在你已经设置过时才改写（缺失即「显示全部」）；改写只并入 CPA slug，不会删掉你列出的 id。
+- 归属识别：`apiKey` 为 `cpac` 且 `url` 是 loopback `…/chat/completions` 的条目才算 CPAC 的，`cpac sync codebuddy` 只替换这些条目。
+- 恢复：注入后未改 → 逐字节还原原文件（原本没有该文件则删除它）；改过 → 只剥 CPAC 条目，你的模型和 `availableModels` 留下。
+- 模型选择仍由 CodeBuddy 决定：用 `/model` 选 CPA 模型或用 `CODEBUDDY_MODEL` 指定默认模型，CPAC 不改 `settings.json`。
 
-卸载：
-
-```bash
-cpac restore cline
-```
-
-配置目录尊重 `CLINE_DATA_DIR`（否则 `~/.cline/data`，CLI 与 Desktop 共享）。首次写入前若 `providers.json` 已存在，会在 `state_dir/cline/providers.json` 保留原始快照。
+配置目录尊重 `CODEBUDDY_CONFIG_DIR`（否则 `~/.codebuddy`）。首次写入前若 `models.json` 已存在，会在 `state_dir/codebuddy/models.json` 保留原始快照。
 
 ### 手动打开 5h 窗口
 
@@ -384,7 +378,7 @@ cpac ping agy      # 目录里匹配 gemini-*-flash* 的一条，以及 claude-s
 | `KIMI_CODE_HOME` | `~/.kimi-code` | 覆盖 Kimi Code 目录（影响 `cpac install kimi` 写入位置） |
 | `ZED_CONFIG_DIR` | `~/.config/zed` | 覆盖 Zed 配置目录（影响 `cpac install zed` 写入位置） |
 | `HERMES_HOME` | `~/.hermes` | 覆盖 Hermes 目录（影响 `cpac install hermes` 写入位置） |
-| `CLINE_DATA_DIR` | `~/.cline/data` | 覆盖 Cline 数据目录（影响 `cpac install cline` 写入位置；仅 CLI 生效，Desktop 读默认路径） |
+| `CODEBUDDY_CONFIG_DIR` | `~/.codebuddy` | 覆盖 CodeBuddy 配置目录（影响 `cpac install codebuddy` 写入的 `models.json` 位置） |
 | `CPAC_CONFIG` | `~/.config/cpac/config.json` | 指定可选 JSON 配置路径 |
 | `CODEX_HOME` | `~/.codex` | Codex home 目录 |
 

package/dist/agents.js

@@ -3,15 +3,16 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { MAX_SPAWN_MODELS, loadCatalogSlugs, pickSpawnModels, saveCodexSetup, saveSpawnModels, } from "./config.js";
+import { MAX_SPAWN_MODELS, fetchCatalog, loadCatalogSlugs, pickSpawnModels, saveCodexSetup, saveSpawnModels, } from "./config.js";
+import { markModelsApplied, refreshModelIndex } from "./models.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 { installPiConfig, isPiConfigInstalled, piAgentDir, piModelsPath, uninstallPiConfig, } from "./targets/pi.js";
 import { installZedConfig, isZedConfigInstalled, uninstallZedConfig, zedConfigPath, zedHome, } from "./targets/zed.js";
 import { hermesConfigPaths, hermesHome, installHermesConfig, isHermesConfigInstalled, uninstallHermesConfig, } from "./targets/hermes.js";
-import { CLINE_PROVIDER_ID, clineDataDir, clineProvidersPath, installClineConfig, isClineConfigInstalled, uninstallClineConfig, } from "./targets/cline.js";
-import { CPACError, atomicWrite, checkboxPicker, compareVersions, expandUserPath, objectValue, tabWizard, } from "./util.js";
+import { codebuddyHome, codebuddyModelsPath, installCodebuddyConfig, isCodebuddyConfigInstalled, uninstallCodebuddyConfig, } from "./targets/codebuddy.js";
+import { CPACError, atomicWrite, checkboxPicker, compareVersions, expandUserPath, objectValue, resolveApiKey, tabWizard, } from "./util.js";
 const CODEX_CTX_STD = "Standard (default input budget, e.g. 200K~272K)";
 const CODEX_CTX_MAX = "Max Context Window (lift to full upper bound, e.g. 921K~1M, 90% auto-compact limit)";
 const CODEX_V2_ON = "Enabled (Default)";
@@ -327,27 +328,24 @@ const TARGETS = [
         },
     },
     {
-        id: "cline",
-        home: () => clineDataDir(),
-        detected: () => binaryOnPath("cline") ||
-            existsSync(join(homedir(), ".cline")) ||
-            (process.platform === "darwin" &&
-                existsSync("/Applications/Cline.app")),
-        installed: () => isClineConfigInstalled(),
-        version: () => detectClientVersion("cline"),
-        install: async (config, dryRun, _v2Off, _maxContext, force) => {
+        id: "codebuddy",
+        home: () => codebuddyHome(),
+        detected: () => binaryOnPath("codebuddy") || existsSync(codebuddyHome()),
+        installed: () => isCodebuddyConfigInstalled(),
+        version: () => detectClientVersion("codebuddy"),
+        install: async (config, dryRun) => {
             if (dryRun) {
-                console.log(`would write Cline ${CLINE_PROVIDER_ID} provider: ${clineProvidersPath()}`);
+                console.log(`would write CPAC models into CodeBuddy: ${codebuddyModelsPath()}`);
                 return;
             }
-            await installClineConfig(config, force);
+            await installCodebuddyConfig(config);
         },
         uninstall: async (config, dryRun) => {
             if (dryRun) {
-                console.log(`would remove Cline ${CLINE_PROVIDER_ID} provider: ${clineProvidersPath()}`);
+                console.log(`would remove CPAC models from CodeBuddy: ${codebuddyModelsPath()}`);
                 return;
             }
-            await uninstallClineConfig(config);
+            await uninstallCodebuddyConfig(config);
         },
     },
 ];
@@ -406,27 +404,51 @@ export async function runInstall(config, requested, options) {
     }
     return 0;
 }
-export async function runSync(config, requested, options) {
+function syncTargetIds(config, requested, all) {
     const installed = TARGETS.filter((target) => target.installed(config)).map((target) => target.id);
-    if (requested.length === 0 && !options.all) {
+    if (requested.length === 0 && !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 installed;
     }
-    return runInstall(config, requested, {
-        all: options.all,
+    const eligible = TARGETS.filter((target) => target.detected()).map((target) => target.id);
+    const selected = selectTargets(requested, all, eligible);
+    if (selected.length === 0) {
+        throw new CPACError(`no supported targets detected; use: cpac install ${TARGETS.map((target) => target.id).join(" ")} or --all`);
+    }
+    return selected.map((target) => target.id);
+}
+export async function runSync(config, requested, options) {
+    const ids = syncTargetIds(config, requested, options.all);
+    if (options.maxContext && ids.some((id) => id !== "codex")) {
+        throw new CPACError("--max_context is only valid with codex");
+    }
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    const { index, changed } = refreshModelIndex(config.state_dir, catalog.bytes, new Date().toISOString(), !options.dryRun);
+    console.log(`models ${index.updated_at}${changed ? (options.dryRun ? " would update" : " updated") : " unchanged"}`);
+    const pending = ids.filter((id) => index.applied[id] !== index.updated_at);
+    for (const id of ids) {
+        if (index.applied[id] === index.updated_at) {
+            console.log(`${id}: model version ${index.updated_at} unchanged`);
+        }
+    }
+    if (pending.length === 0)
+        return 0;
+    // ponytail: version is the model-list timestamp only. spawn_models, v2_off,
+    // max_context, and the proxy port do not bump it; cpac install still rewrites.
+    const code = await runInstall(config, pending, {
+        all: false,
         dryRun: options.dryRun,
         force: true,
         v2Off: options.v2Off,
         maxContext: options.maxContext,
     });
+    if (!options.dryRun && code === 0) {
+        markModelsApplied(config.state_dir, pending, index.updated_at);
+    }
+    return code;
 }
 export async function runRestore(config, requested, options) {
     if (requested.length === 0 && !options.all) {

package/dist/config.js

@@ -29,7 +29,7 @@ export const AGENT_IDS = [
     "grok",
     "zed",
     "hermes",
-    "cline",
+    "codebuddy",
 ];
 const AGENT_ID_SET = new Set(AGENT_IDS);
 const STATE_KEYS = new Set([
@@ -472,9 +472,13 @@ export function readState(stateDir) {
     if (value.agents !== undefined) {
         if (!objectValue(value.agents))
             throw new CPACError("invalid agents in state");
+        // Records for targets that no longer exist (e.g. cline) are dropped on
+        // load instead of erroring, so a state file written by an older release
+        // keeps working after a target is removed.
+        const agents = {};
         for (const [id, rec] of Object.entries(value.agents)) {
             if (!AGENT_ID_SET.has(id))
-                throw new CPACError(`unknown agent in state: ${id}`);
+                continue;
             if (!objectValue(rec) ||
                 typeof rec.path !== "string" ||
                 !rec.path ||
@@ -489,7 +493,12 @@ export function readState(stateDir) {
                 Object.keys(rec).some((key) => !AGENT_RECORD_KEYS.has(key))) {
                 throw new CPACError(`invalid agent record: ${id}`);
             }
+            agents[id] = rec;
         }
+        if (Object.keys(agents).length > 0)
+            value.agents = agents;
+        else
+            delete value.agents;
     }
     const proxyKeys = ["proxy_id", "proxy_pid", "proxy_port"];
     const proxyKeyCount = proxyKeys.filter((key) => key in value).length;
@@ -535,7 +544,13 @@ export function needsProxy(state) {
     if (state.config_path)
         return true;
     const agents = state.agents ?? {};
-    return Boolean(agents.codex || agents.pi || agents.kimi || agents.grok || agents.zed || agents.hermes);
+    return Boolean(agents.codex ||
+        agents.pi ||
+        agents.kimi ||
+        agents.grok ||
+        agents.zed ||
+        agents.hermes ||
+        agents.codebuddy);
 }
 export function saveState(stateDir, state) {
     atomicWrite(join(stateDir, "state.json"), Buffer.from(`${JSON.stringify(state, null, 2)}\n`));

package/dist/cpac.js

@@ -11,7 +11,7 @@ import { isKimiConfigInstalled } from "./targets/kimi.js";
 import { isPiConfigInstalled } from "./targets/pi.js";
 import { isZedConfigInstalled } from "./targets/zed.js";
 import { isHermesConfigInstalled } from "./targets/hermes.js";
-import { CLINE_PROVIDER_ID, isClineConfigInstalled } from "./targets/cline.js";
+import { isCodebuddyConfigInstalled } from "./targets/codebuddy.js";
 import { defaultConfigPath, loadConfig, originalBytes, pickSpawnModels, readState, saveSpawnModels, stateProxy, catalogMaxContextLive, catalogModelId, catalogModelRows, catalogSlugs, fetchCatalog, } from "./config.js";
 import { runPing } from "./ping.js";
 import { proxyIsHealthy, runProxyChild } from "./proxy.js";
@@ -28,7 +28,7 @@ export { installPiConfig, isPiConfigInstalled, uninstallPiConfig, PI_PROVIDER_ID
 export { compactModelPrices, ensureModelPrices, lookupModelCost, resetModelPrices, } from "./pricing.js";
 export { installZedConfig, isZedConfigInstalled, uninstallZedConfig, ZED_PROVIDER_ID, } from "./targets/zed.js";
 export { installHermesConfig, isHermesConfigInstalled, uninstallHermesConfig, HERMES_PROVIDER_ID, } from "./targets/hermes.js";
-export { CLINE_PROVIDER_ID, installClineConfig, isClineConfigInstalled, uninstallClineConfig, } from "./targets/cline.js";
+export { CODEBUDDY_API_KEY_PLACEHOLDER, codebuddyModelsPath, installCodebuddyConfig, isCodebuddyConfigInstalled, uninstallCodebuddyConfig, } from "./targets/codebuddy.js";
 export async function status(config) {
     const apiKey = process.env[config.api_key_env]?.trim();
     const keyConfigured = !!apiKey;
@@ -84,8 +84,8 @@ export async function status(config) {
     console.log(`zed: ${keyConfigured ? (zedInstalled ? "ready" : "config not installed; run: cpac install zed") : "not configured"}`);
     const hermesInstalled = isHermesConfigInstalled();
     console.log(`hermes: ${keyConfigured ? (hermesInstalled ? "ready" : "config not installed; run: cpac install hermes") : "not configured"}`);
-    const clineInstalled = isClineConfigInstalled();
-    console.log(`cline: ${keyConfigured ? (clineInstalled ? "ready" : "config not installed; run: cpac install cline") : "not configured"}`);
+    const codebuddyInstalled = isCodebuddyConfigInstalled();
+    console.log(`codebuddy: ${keyConfigured ? (codebuddyInstalled ? "ready" : "config not installed; run: cpac install codebuddy") : "not configured"}`);
     if (!state)
         return 1;
     const proxy = stateProxy(state);
@@ -130,10 +130,10 @@ async function listModels(config, json) {
     return 0;
 }
 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 <agent> [args...] Launch an agent (codex, kimi, grok, pi, zed, hermes, cline, claude) through CPA\n  cpac setup            Show current Codex/Claude setup; cpac setup <codex|claude> to change\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok, Zed, Hermes, Cline)\n  cpac restore <codex|pi|kimi|grok|zed|hermes|cline> | --all  Detach injected agents
+    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 <agent> [args...] Launch an agent (codex, kimi, grok, pi, zed, hermes, codebuddy, claude) through CPA\n  cpac setup            Show current Codex/Claude setup; cpac setup <codex|claude> to change\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok, Zed, Hermes, CodeBuddy)\n  cpac restore <codex|pi|kimi|grok|zed|hermes|codebuddy> | --all  Detach injected agents
   cpac detect            Show supported targets and install status
-  cpac install [codex|pi|kimi|grok|zed|hermes|cline...]  Install CPA into detected targets, or named agents
-  cpac sync              Refresh installed Codex/Pi/Kimi/Grok/Zed/Hermes/Cline injections from CPA
+  cpac install [codex|pi|kimi|grok|zed|hermes|codebuddy...]  Install CPA into detected targets, or named agents
+  cpac sync              Refresh installed Codex/Pi/Kimi/Grok/Zed/Hermes/CodeBuddy injections from CPA
   cpac uninstall         Detach all agents, then remove the cpac package (confirms first)\n  cpac upgrade           Update cpac from npm and sync installed agents\n  cpac models            List remote CPA catalog models\n  cpac ping codex|agy    Send one request to open that 5h window\n  cpac --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
         return 0;
@@ -174,7 +174,7 @@ function usage() {
         cmd("cpac ping <codex|agy>", "send one request to open that 5h window"),
         "",
         "Positionals:",
-        helpRow("agent", "codex, kimi, grok, pi, zed, hermes, cline, or claude (claude is launch-only)", "", 18),
+        helpRow("agent", "codex, kimi, grok, pi, zed, hermes, codebuddy, or claude (claude is launch-only)", "", 18),
         "",
         "Options:",
         opt("-h, --help", "show help", "[boolean]"),
@@ -338,7 +338,16 @@ function parseArgs(args) {
         }
         return parsed;
     }
-    if (["codex", "kimi", "grok", "pi", "zed", "hermes", "cline", "claude"].includes(args[0])) {
+    if ([
+        "codex",
+        "kimi",
+        "grok",
+        "pi",
+        "zed",
+        "hermes",
+        "codebuddy",
+        "claude",
+    ].includes(args[0])) {
         const targetId = args[0];
         let configPath = defaultConfigPath();
         const raw = args.slice(1);
@@ -686,7 +695,7 @@ export async function main(args = process.argv.slice(2)) {
             });
         if (parsed.command === "uninstall") {
             if (parsed.targets.length || parsed.all) {
-                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore <codex|pi|kimi|grok|zed|hermes|cline> | --all");
+                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore <codex|pi|kimi|grok|zed|hermes|codebuddy> | --all");
             }
             return await runUninstall(config, { dryRun: parsed.dryRun });
         }
@@ -737,19 +746,12 @@ export async function main(args = process.argv.slice(2)) {
             }
             return await runTargetLauncher(launcherConfig, "codex", parsed.args, "codex", { v2Off: parsed.v2Off, maxContext: parsed.maxContext });
         }
-        if (parsed.command === "cline") {
-            // Cline's default provider is its own hosted service; default the
-            // launch to the injected CPAC slot unless the user picked one.
-            const args = parsed.args.some((arg) => arg === "-P" || arg === "--provider")
-                ? parsed.args
-                : ["-P", CLINE_PROVIDER_ID, ...parsed.args];
-            return await runTargetLauncher(config, "cline", args, "cline");
-        }
         if (parsed.command === "kimi" ||
             parsed.command === "grok" ||
             parsed.command === "pi" ||
             parsed.command === "zed" ||
-            parsed.command === "hermes") {
+            parsed.command === "hermes" ||
+            parsed.command === "codebuddy") {
             return await runTargetLauncher(config, parsed.command, parsed.args);
         }
         return await status(config);

package/dist/models.js

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { AGENT_IDS, catalogModelRows } from "./config.js";
+import { CPACError, atomicWrite, objectValue } from "./util.js";
+const INDEX_KEYS = new Set(["updated_at", "models", "applied"]);
+const AGENT_ID_SET = new Set(AGENT_IDS);
+const VERSION = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+export function modelIndexPath(stateDir) {
+    return join(stateDir, "models.json");
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isModelRecord(value) {
+    return isJsonObject(value) && typeof value.slug === "string" && value.slug.trim() !== "";
+}
+function isAgentId(id) {
+    return AGENT_ID_SET.has(id);
+}
+function stableValue(value) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!objectValue(value))
+        throw new CPACError("invalid CPA catalog");
+    const stable = {};
+    for (const key of Object.keys(value).sort())
+        stable[key] = stableValue(value[key]);
+    return stable;
+}
+export function canonicalModels(bytes) {
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const rows = catalogModelRows(document);
+    if (!rows || rows.length === 0)
+        throw new CPACError("invalid CPA catalog");
+    return rows.map((row) => {
+        const stable = stableValue(row);
+        if (!isModelRecord(stable))
+            throw new CPACError("invalid CPA catalog");
+        return stable;
+    });
+}
+function parseApplied(value) {
+    if (!objectValue(value))
+        return null;
+    const applied = {};
+    for (const [id, version] of Object.entries(value)) {
+        // Entries for targets that no longer exist (e.g. cline) are dropped
+        // instead of rejecting the whole index, matching how readState treats
+        // agent records left over from an older release.
+        if (!isAgentId(id))
+            continue;
+        if (typeof version !== "string" || !VERSION.test(version))
+            return null;
+        applied[id] = version;
+    }
+    return applied;
+}
+function parseModelIndex(value) {
+    if (!objectValue(value) ||
+        Object.keys(value).some((key) => !INDEX_KEYS.has(key)) ||
+        typeof value.updated_at !== "string" ||
+        !VERSION.test(value.updated_at) ||
+        !Array.isArray(value.models) ||
+        value.models.length === 0) {
+        return null;
+    }
+    const models = [];
+    for (const row of value.models) {
+        let stable;
+        try {
+            stable = stableValue(row);
+        }
+        catch {
+            return null;
+        }
+        if (!isModelRecord(stable))
+            return null;
+        models.push(stable);
+    }
+    const applied = parseApplied(value.applied);
+    if (!applied)
+        return null;
+    return { updated_at: value.updated_at, models, applied };
+}
+export function readModelIndex(stateDir) {
+    const path = modelIndexPath(stateDir);
+    if (!existsSync(path))
+        return null;
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new CPACError(`cannot read model index: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const index = parseModelIndex(value);
+    if (!index)
+        throw new CPACError("invalid model index");
+    return index;
+}
+function writeModelIndex(stateDir, index) {
+    atomicWrite(modelIndexPath(stateDir), Buffer.from(`${JSON.stringify(index, null, 2)}\n`));
+}
+export function refreshModelIndex(stateDir, catalogBytes, now = new Date().toISOString(), write = true) {
+    const models = canonicalModels(catalogBytes);
+    const current = readModelIndex(stateDir);
+    if (current && JSON.stringify(current.models) === JSON.stringify(models)) {
+        return { index: current, changed: false };
+    }
+    const index = {
+        updated_at: now,
+        models,
+        applied: current?.applied ?? {},
+    };
+    if (write)
+        writeModelIndex(stateDir, index);
+    return { index, changed: true };
+}
+export function markModelsApplied(stateDir, ids, updatedAt) {
+    const current = readModelIndex(stateDir);
+    if (!current)
+        throw new CPACError("model index missing");
+    let changed = false;
+    const applied = { ...current.applied };
+    for (const id of ids) {
+        if (applied[id] === updatedAt)
+            continue;
+        applied[id] = updatedAt;
+        changed = true;
+    }
+    if (changed)
+        writeModelIndex(stateDir, { ...current, applied });
+}

package/dist/targets/codebuddy.js

@@ -0,0 +1,204 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { catalogModelId, catalogModelRows, dropAgent, fetchCatalog, readState, recordWrittenConfig, restoreOwnedConfig, } from "../config.js";
+import { ensureLoopbackProxy, stopProxyProcess } from "../proxy.js";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, objectValue, resolveApiKey, } from "../util.js";
+/**
+ * ~/.codebuddy/models.json is CodeBuddy's documented place for third-party
+ * models, so CPAC merges rather than owns the file: it writes one entry per
+ * catalog slug and leaves every model the user added there untouched. Entries
+ * CPAC wrote are recognizable by the placeholder key plus a loopback
+ * /chat/completions URL, and only those are replaced on re-sync and dropped on
+ * restore.
+ */
+export const CODEBUDDY_API_KEY_PLACEHOLDER = "cpac";
+export const CODEBUDDY_VENDOR = "CPAC";
+export function codebuddyHome() {
+    return expandUserPath(process.env.CODEBUDDY_CONFIG_DIR?.trim() || join(homedir(), ".codebuddy"));
+}
+export function codebuddyModelsPath() {
+    return join(codebuddyHome(), "models.json");
+}
+function readModelsDoc(path) {
+    if (!existsSync(path))
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new CPACError(`invalid CodeBuddy models.json: ${path}`);
+    }
+    if (!objectValue(parsed))
+        throw new CPACError(`invalid CodeBuddy models.json: ${path}`);
+    return parsed;
+}
+function modelEntries(doc) {
+    return Array.isArray(doc.models) ? doc.models : [];
+}
+function loopbackChatCompletionsUrl(value) {
+    if (typeof value !== "string" || !value.trim())
+        return false;
+    try {
+        const url = new URL(value);
+        const host = url.hostname.toLowerCase();
+        return ((host === "127.0.0.1" || host === "localhost" || host === "::1") &&
+            url.pathname.endsWith("/chat/completions"));
+    }
+    catch {
+        return false;
+    }
+}
+/** True for entries CPAC wrote: placeholder key plus a loopback endpoint. */
+function isCpacModel(entry) {
+    if (!objectValue(entry))
+        return false;
+    return (entry.apiKey === CODEBUDDY_API_KEY_PLACEHOLDER &&
+        loopbackChatCompletionsUrl(entry.url));
+}
+export function isCodebuddyConfigInstalled() {
+    try {
+        return modelEntries(readModelsDoc(codebuddyModelsPath())).some(isCpacModel);
+    }
+    catch {
+        return false;
+    }
+}
+function inputHasImage(row) {
+    const modalities = row.input_modalities;
+    return Array.isArray(modalities) && modalities.some((value) => value === "image");
+}
+function supportsReasoning(row) {
+    const levels = row.supported_reasoning_levels;
+    return Array.isArray(levels) && levels.length > 0;
+}
+function positiveInt(value) {
+    return typeof value === "number" && value > 0 ? Math.floor(value) : undefined;
+}
+function buildModel(row, slug, port) {
+    const model = {
+        id: slug,
+        name: typeof row.display_name === "string" && row.display_name.trim()
+            ? row.display_name.trim()
+            : slug,
+        vendor: CODEBUDDY_VENDOR,
+        apiKey: CODEBUDDY_API_KEY_PLACEHOLDER,
+        url: `http://127.0.0.1:${port}/v1/chat/completions`,
+        supportsToolCall: true,
+        supportsImages: inputHasImage(row),
+        supportsReasoning: supportsReasoning(row),
+    };
+    const maxInput = positiveInt(row.context_window);
+    if (maxInput)
+        model.maxInputTokens = maxInput;
+    const maxOutput = positiveInt(row.max_output_tokens);
+    if (maxOutput)
+        model.maxOutputTokens = maxOutput;
+    // No relatedModels: CodeBuddy then falls back to the main model for the
+    // lite / reasoning slots instead of borrowing product built-in defaults.
+    return model;
+}
+/** Keep the user's models and the position CPAC's block already occupied. */
+function mergeModels(existing, cpaModels) {
+    const userModels = existing.filter((entry) => !isCpacModel(entry));
+    const firstCpac = existing.findIndex(isCpacModel);
+    const insertAt = firstCpac === -1
+        ? userModels.length
+        : existing.slice(0, firstCpac).filter((entry) => !isCpacModel(entry)).length;
+    return [
+        ...userModels.slice(0, insertAt),
+        ...cpaModels,
+        ...userModels.slice(insertAt),
+    ];
+}
+/**
+ * Only touch availableModels when the user already set it: an absent list means
+ * "show everything", but a present one would hide the CPA models. Slugs are
+ * added, never removed — the list cannot tell CPA ids from CodeBuddy built-ins.
+ */
+function mergedAvailableModels(doc, slugs) {
+    if (!Array.isArray(doc.availableModels))
+        return undefined;
+    const available = doc.availableModels.filter((id) => typeof id === "string");
+    for (const slug of slugs) {
+        if (!available.includes(slug))
+            available.push(slug);
+    }
+    return available;
+}
+export async function installCodebuddyConfig(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) ?? [];
+    const catalogRows = rows.flatMap((row) => {
+        const slug = catalogModelId(row);
+        return slug ? [{ row, slug }] : [];
+    });
+    if (catalogRows.length === 0)
+        throw new CPACError("CPA catalog contains no models");
+    const { proxy, fingerprint, started } = await ensureLoopbackProxy(config, apiKey);
+    const models = catalogRows.map(({ row, slug }) => buildModel(row, slug, proxy.port));
+    const target = codebuddyModelsPath();
+    const hadFile = existsSync(target);
+    try {
+        const doc = readModelsDoc(target);
+        const available = mergedAvailableModels(doc, models.map((model) => String(model.id)));
+        ensureCpacBackup(config.state_dir, "codebuddy", target, !isCodebuddyConfigInstalled());
+        doc.models = mergeModels(modelEntries(doc), models);
+        if (available)
+            doc.availableModels = available;
+        mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+        const mode = existsSync(target) ? statSync(target).mode & 0o7777 : 0o600;
+        atomicWrite(target, Buffer.from(`${JSON.stringify(doc, null, 2)}\n`), mode);
+        recordWrittenConfig(config.state_dir, "codebuddy", target, {
+            id: proxy.id,
+            pid: proxy.pid,
+            port: proxy.port,
+            fingerprint,
+        }, hadFile);
+    }
+    catch (error) {
+        if (started)
+            await stopProxyProcess(proxy);
+        throw error;
+    }
+    console.log(`Installed ${models.length} CPAC models into CodeBuddy: ${target}`);
+    console.log(`Models keep the placeholder key "${CODEBUDDY_API_KEY_PLACEHOLDER}"; the loopback proxy injects ${config.api_key_env}.`);
+}
+function stripCodebuddyManaged(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder("utf-8").decode(content));
+    }
+    catch {
+        return content;
+    }
+    if (!objectValue(parsed))
+        return content;
+    const doc = parsed;
+    const models = modelEntries(doc).filter((entry) => !isCpacModel(entry));
+    if (models.length > 0)
+        doc.models = models;
+    else
+        delete doc.models;
+    return Buffer.from(`${JSON.stringify(doc, null, 2)}\n`);
+}
+export async function uninstallCodebuddyConfig(config) {
+    const target = codebuddyModelsPath();
+    const recorded = readState(config.state_dir)?.agents?.codebuddy;
+    if (!recorded && !isCodebuddyConfigInstalled())
+        throw new CPACError("CodeBuddy CPAC models are not installed");
+    restoreOwnedConfig(config.state_dir, "codebuddy", target, stripCodebuddyManaged);
+    const { stopProxy } = dropAgent(config.state_dir, "codebuddy");
+    if (stopProxy)
+        await stopProxyProcess(stopProxy);
+    console.log(`Removed CPAC models from CodeBuddy: ${target}`);
+}

package/package.json

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

package/dist/targets/cline.js

@@ -1,197 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { catalogModelId, catalogModelRows, dropAgent, fetchCatalog, readState, recordWrittenConfig, restoreOwnedConfig, } from "../config.js";
-import { ensureLoopbackProxy, stopProxyProcess } from "../proxy.js";
-import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, objectValue, resolveApiKey, } from "../util.js";
-/**
- * Cline only accepts its built-in provider ids; `openai-compatible` is the one
- * slot meant for a user-defined OpenAI-compatible endpoint. The CLI (`cline`)
- * and Cline Desktop share that slot through ~/.cline/data/settings/providers.json
- * (both talk to the same local hub daemon on 127.0.0.1:25463), so one injection
- * covers both apps.
- */
-export const CLINE_PROVIDER_ID = "openai-compatible";
-/** Cline sends this placeholder key; the loopback proxy swaps in the CPA key. */
-export const CLINE_API_KEY_PLACEHOLDER = "cpac";
-export function clineDataDir() {
-    const override = process.env.CLINE_DATA_DIR?.trim();
-    if (override)
-        return expandUserPath(override);
-    return join(homedir(), ".cline", "data");
-}
-export function clineProvidersPath() {
-    return join(clineDataDir(), "settings", "providers.json");
-}
-function readProviders(path) {
-    if (!existsSync(path))
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        throw new CPACError(`invalid Cline providers.json: ${path}`);
-    }
-    if (!objectValue(parsed))
-        throw new CPACError(`invalid Cline providers.json: ${path}`);
-    return parsed;
-}
-function providerEntry(doc) {
-    if (!objectValue(doc.providers))
-        return null;
-    const entry = doc.providers[CLINE_PROVIDER_ID];
-    return objectValue(entry) ? entry : null;
-}
-function loopbackBaseUrl(value) {
-    if (typeof value !== "string" || !value.trim())
-        return false;
-    try {
-        const host = new URL(value).hostname.toLowerCase();
-        return host === "127.0.0.1" || host === "localhost" || host === "::1";
-    }
-    catch {
-        return false;
-    }
-}
-/** True while the slot still carries the CPAC placeholder key and loopback URL. */
-function isCpacEntry(entry) {
-    if (!objectValue(entry) || !objectValue(entry.settings))
-        return false;
-    const settings = entry.settings;
-    return (settings.apiKey === CLINE_API_KEY_PLACEHOLDER &&
-        loopbackBaseUrl(settings.baseUrl));
-}
-export function isClineConfigInstalled() {
-    try {
-        return isCpacEntry(providerEntry(readProviders(clineProvidersPath())));
-    }
-    catch {
-        return false;
-    }
-}
-function clineModelSlugs(rows) {
-    const slugs = [];
-    for (const row of rows) {
-        const slug = catalogModelId(row);
-        if (slug)
-            slugs.push(slug);
-    }
-    return slugs;
-}
-/**
- * Keep Cline's slot shape (settings/updatedAt/tokenSource) and merge over the
- * fields CPAC owns, so extra user tuning inside the slot survives re-injection.
- */
-function clineProviderEntry(port, model, previous) {
-    const previousSettings = previous && objectValue(previous.settings) ? previous.settings : {};
-    return {
-        ...(previous ?? {}),
-        settings: {
-            ...previousSettings,
-            provider: CLINE_PROVIDER_ID,
-            apiKey: CLINE_API_KEY_PLACEHOLDER,
-            model,
-            baseUrl: `http://127.0.0.1:${port}/v1`,
-        },
-        updatedAt: new Date().toISOString(),
-        tokenSource: "manual",
-    };
-}
-function writeClineProvider(path, port, model) {
-    const doc = readProviders(path);
-    const previous = providerEntry(doc);
-    const providers = objectValue(doc.providers) ? { ...doc.providers } : {};
-    providers[CLINE_PROVIDER_ID] = clineProviderEntry(port, model, previous);
-    doc.providers = providers;
-    if (typeof doc.version !== "number")
-        doc.version = 1;
-    if (!objectValue(doc.modes))
-        doc.modes = {};
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const mode = existsSync(path) ? statSync(path).mode & 0o7777 : 0o600;
-    atomicWrite(path, Buffer.from(`${JSON.stringify(doc, null, 2)}\n`), mode);
-}
-export async function installClineConfig(config, force = false) {
-    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) ?? [];
-    const slugs = clineModelSlugs(rows);
-    if (slugs.length === 0)
-        throw new CPACError("CPA catalog contains no models");
-    const target = clineProvidersPath();
-    const existing = providerEntry(readProviders(target));
-    if (existing && !isCpacEntry(existing) && !force) {
-        throw new CPACError(`Cline provider "${CLINE_PROVIDER_ID}" already holds a non-CPAC configuration (${target}); ` +
-            `re-run with --force to replace it (the original file is backed up in the cpac state dir)`);
-    }
-    // Keep the model the user picked in Cline when it still exists in the catalog.
-    const previousModel = existing && objectValue(existing.settings) ? existing.settings.model : undefined;
-    const model = typeof previousModel === "string" && slugs.includes(previousModel)
-        ? previousModel
-        : slugs[0];
-    const { proxy, fingerprint, started } = await ensureLoopbackProxy(config, apiKey);
-    const hadFile = existsSync(target);
-    try {
-        ensureCpacBackup(config.state_dir, "cline", target, !isClineConfigInstalled());
-        writeClineProvider(target, proxy.port, model);
-        recordWrittenConfig(config.state_dir, "cline", target, {
-            id: proxy.id,
-            pid: proxy.pid,
-            port: proxy.port,
-            fingerprint,
-        }, hadFile);
-    }
-    catch (error) {
-        if (started)
-            await stopProxyProcess(proxy);
-        throw error;
-    }
-    console.log(`Installed Cline provider "${CLINE_PROVIDER_ID}" (model ${model}): ${target}`);
-    console.log(`Cline CLI: cline -P ${CLINE_PROVIDER_ID} -m <model> (or cpac cline); Cline Desktop: pick "OpenAI Compatible" in the provider list.`);
-    console.log(`The stored key stays "${CLINE_API_KEY_PLACEHOLDER}"; the loopback proxy injects ${config.api_key_env}.`);
-}
-/** Drop the CPAC slot; keep the file untouched when Cline now owns the slot. */
-function stripClineProvider(current) {
-    let parsed;
-    try {
-        parsed = JSON.parse(new TextDecoder("utf-8").decode(current));
-    }
-    catch {
-        return current;
-    }
-    if (!objectValue(parsed))
-        return current;
-    const doc = parsed;
-    const providers = doc.providers;
-    if (!objectValue(providers))
-        return current;
-    const entry = providers[CLINE_PROVIDER_ID];
-    if (!isCpacEntry(entry))
-        return current;
-    const nextProviders = { ...providers };
-    delete nextProviders[CLINE_PROVIDER_ID];
-    if (Object.keys(nextProviders).length > 0)
-        doc.providers = nextProviders;
-    else
-        delete doc.providers;
-    return Buffer.from(`${JSON.stringify(doc, null, 2)}\n`);
-}
-export async function uninstallClineConfig(config) {
-    const target = clineProvidersPath();
-    const recorded = readState(config.state_dir)?.agents?.cline;
-    if (!recorded && !isClineConfigInstalled())
-        throw new CPACError("Cline CPAC provider is not installed");
-    restoreOwnedConfig(config.state_dir, "cline", target, stripClineProvider);
-    const { stopProxy } = dropAgent(config.state_dir, "cline");
-    if (stopProxy)
-        await stopProxyProcess(stopProxy);
-    console.log(`Removed Cline provider "${CLINE_PROVIDER_ID}": ${target}`);
-}