@yhong91/cpac 0.1.48 → 0.2.0

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`
+- 已安装需要使用的 agent：`codex`、`claude`、`pi`、`kimi`、`grok`、`zed`、`hermes` 或 `cline`
 - 有权访问的 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）
+cpac install --all                     # 注入所有检测到的目标（codex/pi/kimi/grok/zed/hermes/cline）
 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` 在 PATH 上）。向用户索取 CPA API key。
+1. **检查前置**：`node --version` ≥ 20；确认用户需要哪些 agent（`codex`/`claude`/`pi`/`kimi`/`grok`/`zed`/`hermes`/`cline` 在 PATH 上）。向用户索取 CPA API key。
 
 2. **安装与密钥**：
 
@@ -90,14 +90,14 @@ cpac status   # 验证：各 target 显示 ready/injected
 ```
 
 1. **统一启动与配置**：
-   - 启动：`cpac <codex|claude|kimi|grok|pi|zed|hermes> [args...]`（所有原生参数如 `-c` 等原样透明传递）
+   - 启动：`cpac <codex|claude|kimi|grok|pi|zed|hermes|cline> [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>` 恢复原配置。
+失败处理：任何一步报错时先跑 `cpac status`；密钥未配置回到步骤 2；注入后异常用 `cpac <agent> clear` 或 `cpac restore <codex|pi|kimi|grok|zed|hermes|cline>` 恢复原配置。
 
 ## 首次引导
 
@@ -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> | --all  Detach injected agents
+  cpac restore <codex|pi|kimi|grok|zed|hermes|cline> | --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` 六个持久注入目标统一管理（claude 是临时接管，用 `cpac claude` 启动，不属于 install 目标）：
+参考 vibetime 的目标式命令，对 `codex`、`pi`、`kimi`、`grok`、`zed`、`hermes`、`cline` 七个持久注入目标统一管理（claude 是临时接管，用 `cpac claude` 启动，不属于 install 目标）：
 
 ```bash
 cpac detect [--json]
 cpac models [--json]
-cpac install [codex|pi|kimi|grok|zed|hermes...] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context]
-cpac sync [codex|pi|kimi|grok|zed|hermes...] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context]
-cpac restore <codex|pi|kimi|grok|zed|hermes...> | --all [--dry-run]
+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 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` 写入各自配置。`--dry-run` 只打印将要做的事，`--force` 允许重装已安装目标。
-- `sync` 按当前 `cpa_url` 和 CPA 目录强制刷新**已经接入**的目标（Codex 重新注入、Pi / Kimi / Grok / Zed / Hermes 配置重写），用来在 CPA 地址或模型目录变化后一次对齐本地配置。不带参数只动已安装目标；`--all` 会对检测到的目标做同样的强制刷新（尚未安装的会装上）。`--max_context` 仍只对 `cpac install codex` 有效。
+- `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` 有效。
 - 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 执行 `sync`。已是最新也会 sync。不要先手动 `npm install -g` 再 `cpac sync`。`--check` 只报告版本，不安装也不 sync。没有已安装目标时跳过 sync，不报错。只刷新配置、不升 CLI 时用 `cpac sync`。
+- `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`。
 
 ### 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 同样：没有旧配置不写空备份，native 覆盖旧快照，已接入则保留。所有 target 的 restore 都按 Codex 规则：注入后记下文件 hash；相对注入未改则逐字节还原备份（没有备份则删除我们创建的文件）；注入后改过则只剥 CPAC 字段，用户改动留下。没有其它需要代理的 agent 时才关闭代理。
+`config.toml` 不存在时拒绝注入。当前是 native 时把原文件备份到 `state_dir/codex/config.toml`（覆盖更旧的 native 快照）；已注入后再装不覆盖备份。kimi/grok/zed/hermes/pi/cline 同样：没有旧配置不写空备份，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` 即可恢复。
+loopback 代理是 detached 用户进程，不安装系统服务。机器重启或进程意外退出后，`cpac status` 会报告 `loopback proxy stopped`；重新执行 `cpac install codex` 或 `cpac pi` / `cpac kimi` / `cpac grok` / `cpac zed` / `cpac hermes` / `cpac cline` 即可恢复。
 
 默认路径：
 
@@ -268,6 +268,7 @@ 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
 restore / `<agent> clear` 会删掉该 agent 的备份目录和 state.json 里的对应记录
 ```
@@ -281,7 +282,7 @@ cpac install pi
 cpac pi
 ```
 
-它在 `~/.pi/agent/models.json` 的 `providers.cpac` 写入 loopback `baseUrl`、占位 `apiKey`、`api: openai-responses`，以及 CPA catalog 的模型列表。每个模型的 `cost` 是 USD / 百万 token（input / output / cacheRead / cacheWrite），来自打包的 [models.dev](https://models.dev) 快照（官方价优先，否则 OpenRouter）；未知模型为 0。不改当前默认模型；切换用 `/model`。密钥由 loopback 注入。旧的 `npm:@yhong91/cpac` package 和 `extensions/pi-cpac.ts` 会在 install / restore 时删掉。
+它在 `~/.pi/agent/models.json` 的 `providers.cpac` 写入 loopback `baseUrl`、占位 `apiKey`、`api: openai-responses`，以及 CPA catalog 的模型列表。每个模型的 `cost` 是 USD / 百万 token（input / output / cacheRead / cacheWrite）。注入时若 `~/.cpac/model-prices.json` 超过 24 小时会从 [models.dev](https://models.dev) 刷新（官方价优先，否则 OpenRouter；失败则用打包快照）；未知模型为 0。不改当前默认模型；切换用 `/model`。密钥由 loopback 注入。旧的 `npm:@yhong91/cpac` package 和 `extensions/pi-cpac.ts` 会在 install / restore 时删掉。
 
 卸载：`cpac restore pi` 或 `cpac pi clear`。尊重 `PI_CODING_AGENT_DIR`。
 
@@ -335,6 +336,33 @@ cpac restore hermes
 
 配置目录尊重 `HERMES_HOME`（Windows 默认 `%LOCALAPPDATA%\hermes`）。首次写入前若 default `config.yaml` 已存在，会在 `state_dir/hermes/config.yaml` 保留原始快照。profile 文件不单独备份，restore 只剥 `providers.cpac`。
 
+### Cline（CLI 与 Desktop）
+
+写入 CPA 的 OpenAI-compatible provider 到 Cline：
+
+```bash
+cpac install cline
+cpac cline                          # 未显式传 -P/--provider 时自动注入 -P openai-compatible
+cpac cline "帮我写一个测试"           # 原生参数原样直通
+cpac cline -P cline "..."           # 显式指定 provider 时不注入
+```
+
+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`。
+
+- 模型：首次写入 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；两侧使用默认路径时注入对两边同时生效。
+
+卸载：
+
+```bash
+cpac restore cline
+```
+
+配置目录尊重 `CLINE_DATA_DIR`（否则 `~/.cline/data`，CLI 与 Desktop 共享）。首次写入前若 `providers.json` 已存在，会在 `state_dir/cline/providers.json` 保留原始快照。
+
 ## 环境变量
 
 | 变量 | 默认值 | 作用 |
@@ -345,6 +373,7 @@ cpac restore hermes
 | `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 读默认路径） |
 | `CPAC_CONFIG` | `~/.config/cpac/config.json` | 指定可选 JSON 配置路径 |
 | `CODEX_HOME` | `~/.codex` | Codex home 目录 |
 

package/dist/agents.js

@@ -10,6 +10,7 @@ import { installKimiConfig, isKimiConfigInstalled, kimiConfigPath, uninstallKimi
 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";
 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)";
@@ -325,6 +326,30 @@ const TARGETS = [
             await uninstallHermesConfig(config);
         },
     },
+    {
+        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) => {
+            if (dryRun) {
+                console.log(`would write Cline ${CLINE_PROVIDER_ID} provider: ${clineProvidersPath()}`);
+                return;
+            }
+            await installClineConfig(config, force);
+        },
+        uninstall: async (config, dryRun) => {
+            if (dryRun) {
+                console.log(`would remove Cline ${CLINE_PROVIDER_ID} provider: ${clineProvidersPath()}`);
+                return;
+            }
+            await uninstallClineConfig(config);
+        },
+    },
 ];
 export async function detectTargets(config) {
     return TARGETS.map((target) => ({
@@ -377,7 +402,7 @@ export async function runInstall(config, requested, options) {
             console.log(`${target.id}: already installed; use --force to reinstall`);
             continue;
         }
-        await target.install(config, options.dryRun, options.v2Off, options.maxContext);
+        await target.install(config, options.dryRun, options.v2Off, options.maxContext, options.force);
     }
     return 0;
 }

package/dist/config.js

@@ -22,7 +22,15 @@ const CONFIG_KEYS = new Set([
 // spawn_agent overrides (codex-rs MAX_SPAWN_AGENT_MODEL_OVERRIDES).
 export const MAX_SPAWN_MODELS = 5;
 export const CLAUDE_SLOT_KEYS = ["opus", "sonnet", "haiku"];
-export const AGENT_IDS = ["codex", "pi", "kimi", "grok", "zed", "hermes"];
+export const AGENT_IDS = [
+    "codex",
+    "pi",
+    "kimi",
+    "grok",
+    "zed",
+    "hermes",
+    "cline",
+];
 const AGENT_ID_SET = new Set(AGENT_IDS);
 const STATE_KEYS = new Set([
     "config_path",
@@ -742,5 +750,7 @@ export function proxyFingerprint(config, apiKey) {
         .update(config.cpa_url)
         .update("\0")
         .update(apiKey)
+        .update("\0")
+        .update("agent:false")
         .digest("hex");
 }

package/dist/cpac.js

@@ -11,6 +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 { defaultConfigPath, loadConfig, originalBytes, pickSpawnModels, readState, saveSpawnModels, stateProxy, catalogMaxContextLive, catalogModelId, catalogModelRows, catalogSlugs, fetchCatalog, } from "./config.js";
 import { proxyIsHealthy, runProxyChild } from "./proxy.js";
 import { CPACError, expandUserPath, promptSecret, saveApiKeyExport, shellProfile, } from "./util.js";
@@ -23,9 +24,10 @@ export { detectClientVersion, detectTargets, runInstall, runRestore, runSync, ru
 export { installGrokConfig, isGrokConfigInstalled, uninstallGrokConfig, } from "./targets/grok.js";
 export { installKimiConfig, isKimiConfigInstalled, uninstallKimiConfig, } from "./targets/kimi.js";
 export { installPiConfig, isPiConfigInstalled, uninstallPiConfig, PI_PROVIDER_ID, } from "./targets/pi.js";
-export { lookupModelCost } from "./pricing.js";
+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 async function status(config) {
     const apiKey = process.env[config.api_key_env]?.trim();
     const keyConfigured = !!apiKey;
@@ -81,6 +83,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"}`);
     if (!state)
         return 1;
     const proxy = stateProxy(state);
@@ -119,10 +123,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, 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)\n  cpac restore <codex|pi|kimi|grok|zed|hermes> | --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, 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
   cpac detect            Show supported targets and install status
-  cpac install [codex|pi|kimi|grok|zed|hermes...]  Install CPA into detected targets, or named agents
-  cpac sync              Refresh installed Codex/Pi/Kimi/Grok/Zed/Hermes injections from CPA
+  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 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 --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
         return 0;
@@ -162,7 +166,7 @@ function usage() {
         cmd("cpac upgrade", "update cpac from npm and sync installed agents"),
         "",
         "Positionals:",
-        helpRow("agent", "codex, kimi, grok, pi, zed, hermes, or claude (claude is launch-only)", "", 18),
+        helpRow("agent", "codex, kimi, grok, pi, zed, hermes, cline, or claude (claude is launch-only)", "", 18),
         "",
         "Options:",
         opt("-h, --help", "show help", "[boolean]"),
@@ -301,7 +305,7 @@ function parseArgs(args) {
         }
         return parsed;
     }
-    if (["codex", "kimi", "grok", "pi", "zed", "hermes", "claude"].includes(args[0])) {
+    if (["codex", "kimi", "grok", "pi", "zed", "hermes", "cline", "claude"].includes(args[0])) {
         const targetId = args[0];
         let configPath = defaultConfigPath();
         const raw = args.slice(1);
@@ -649,7 +653,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> | --all");
+                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore <codex|pi|kimi|grok|zed|hermes|cline> | --all");
             }
             return await runUninstall(config, { dryRun: parsed.dryRun });
         }
@@ -698,6 +702,14 @@ 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" ||

package/dist/pricing.js

@@ -1,7 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
+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 { objectValue } from "./util.js";
+import { atomicWrite, objectValue } from "./util.js";
 const ZERO_COST = {
     input: 0,
     output: 0,
@@ -9,29 +10,29 @@ const ZERO_COST = {
     cacheWrite: 0,
 };
 const VARIANT_SUFFIX = /[-_\s]+(?:minimal|low|medium|high|xhigh|max|ultra|thinking|preview|build|fast|free)$/i;
+const REFRESH_MS = 24 * 60 * 60 * 1000;
+const FETCH_MS = 10_000;
+const MODELS_DEV_API = "https://models.dev/api.json";
+const MODELS_DEV_MODELS = "https://models.dev/models.json";
+const MODELS_DEV_PROXY_API = "https://models-proxy.vibetime.cc/api.json";
+const MODELS_DEV_PROXY_MODELS = "https://models-proxy.vibetime.cc/models.json";
 let table;
 function foldToken(value) {
     return value.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function pricesPath() {
+function bundledPath() {
     return join(dirname(fileURLToPath(import.meta.url)), "data", "model-prices.json");
 }
-function loadTable() {
-    if (table)
-        return table;
-    table = new Map();
-    const path = pricesPath();
-    if (!existsSync(path))
-        return table;
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return table;
-    }
+function cachePath() {
+    const override = process.env.CPAC_PRICES_CACHE?.trim();
+    if (override)
+        return override;
+    return join(homedir(), ".cpac", "model-prices.json");
+}
+function parseTable(raw) {
+    const next = new Map();
     if (!objectValue(raw))
-        return table;
+        return next;
     for (const [key, value] of Object.entries(raw)) {
         if (!Array.isArray(value) || value.length < 4)
             continue;
@@ -42,8 +43,186 @@ function loadTable() {
         if (![input, output, cacheRead, cacheWrite].every((n) => Number.isFinite(n) && n >= 0)) {
             continue;
         }
-        table.set(key, { input, output, cacheRead, cacheWrite });
+        next.set(key, { input, output, cacheRead, cacheWrite });
+    }
+    return next;
+}
+function readTableFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return parseTable(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+function loadBundled() {
+    return readTableFile(bundledPath()) ?? new Map();
+}
+function tokens(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    const lower = trimmed.toLowerCase();
+    const slash = lower.lastIndexOf("/");
+    const tail = slash === -1 ? lower : lower.slice(slash + 1);
+    const hyphenated = tail.replace(/\s+/g, "-");
+    const dotted = hyphenated.replace(/(\d+)-(\d+)/g, "$1.$2");
+    const dashed = hyphenated.replace(/(\d+)\.(\d+)/g, "$1-$2");
+    const out = [];
+    for (const t of [lower, tail, hyphenated, dotted, dashed, foldToken(tail)]) {
+        if (t && !out.includes(t))
+            out.push(t);
+    }
+    return out;
+}
+function toCost(cost) {
+    if (!objectValue(cost))
+        return undefined;
+    const input = Number(cost.input);
+    const output = Number(cost.output);
+    if (!Number.isFinite(input) || !Number.isFinite(output))
+        return undefined;
+    if (input < 0 || output < 0 || (input === 0 && output === 0))
+        return undefined;
+    const cacheRead = Number.isFinite(Number(cost.cache_read))
+        ? Number(cost.cache_read)
+        : input;
+    const cacheWrite = Number.isFinite(Number(cost.cache_write))
+        ? Number(cost.cache_write)
+        : cacheRead;
+    return [input, output, cacheRead, cacheWrite];
+}
+function officialFor(lab, modelId) {
+    return foldToken(modelId.split("/").pop() ?? "").startsWith("glm") ? "zai" : lab;
+}
+function pick(index, modelId, lab) {
+    const official = lab ? officialFor(lab, modelId) : undefined;
+    const cands = tokens(modelId);
+    if (official) {
+        for (const cand of cands) {
+            for (const [p, c] of index.get(cand) ?? []) {
+                if (p === official)
+                    return c;
+            }
+        }
+    }
+    for (const cand of cands) {
+        for (const [p, c] of index.get(cand) ?? []) {
+            if (p === "openrouter")
+                return c;
+        }
+    }
+    return undefined;
+}
+export function compactModelPrices(api, models) {
+    const index = new Map();
+    if (objectValue(api)) {
+        for (const [pid, prov] of Object.entries(api)) {
+            if (!objectValue(prov) || !objectValue(prov.models))
+                continue;
+            const p = pid.toLowerCase();
+            for (const [mid, model] of Object.entries(prov.models)) {
+                const c = objectValue(model) ? toCost(model.cost) : undefined;
+                if (!c)
+                    continue;
+                for (const tok of tokens(mid)) {
+                    const bucket = index.get(tok);
+                    if (bucket)
+                        bucket.push([p, c]);
+                    else
+                        index.set(tok, [[p, c]]);
+                }
+            }
+        }
+    }
+    const tableJson = {};
+    if (objectValue(models)) {
+        for (const key of Object.keys(models)) {
+            if (!key.includes("/"))
+                continue;
+            const lab = key.slice(0, key.indexOf("/")).toLowerCase();
+            const tail = key.slice(key.indexOf("/") + 1);
+            const cost = pick(index, key, lab);
+            const f = foldToken(tail);
+            if (cost && f && tableJson[f] === undefined)
+                tableJson[f] = cost;
+        }
+    }
+    for (const [tok, bucket] of index) {
+        const f = foldToken(tok.includes("/") ? tok.slice(tok.lastIndexOf("/") + 1) : tok);
+        if (!f || tableJson[f] !== undefined)
+            continue;
+        tableJson[f] = bucket.find(([p]) => p === "openrouter")?.[1] ?? bucket[0][1];
+    }
+    return Object.fromEntries(Object.entries(tableJson).sort(([a], [b]) => a.localeCompare(b)));
+}
+async function fetchJson(url) {
+    const response = await fetch(url, {
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout(FETCH_MS),
+    });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    return response.json();
+}
+export async function fetchModelPriceTable() {
+    let api;
+    let models;
+    try {
+        [api, models] = await Promise.all([
+            fetchJson(MODELS_DEV_API),
+            fetchJson(MODELS_DEV_MODELS),
+        ]);
+    }
+    catch {
+        [api, models] = await Promise.all([
+            fetchJson(MODELS_DEV_PROXY_API),
+            fetchJson(MODELS_DEV_PROXY_MODELS),
+        ]);
+    }
+    return compactModelPrices(api, models);
+}
+function cacheIsFresh(path) {
+    try {
+        return Date.now() - statSync(path).mtimeMs < REFRESH_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function applyTable(next) {
+    table = next;
+}
+function writeCache(path, prices) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    atomicWrite(path, Buffer.from(`${JSON.stringify(prices)}\n`), 0o600);
+}
+/** Refresh from models.dev when the local cache is older than 24h; fall back to bundled snapshot. */
+export async function ensureModelPrices() {
+    const cache = cachePath();
+    if (cacheIsFresh(cache)) {
+        applyTable(readTableFile(cache) ?? loadBundled());
+        return;
+    }
+    try {
+        const prices = await fetchModelPriceTable();
+        if (Object.keys(prices).length > 0) {
+            writeCache(cache, prices);
+            applyTable(parseTable(prices));
+            return;
+        }
     }
+    catch {
+        // Keep cache or bundled snapshot.
+    }
+    applyTable(readTableFile(cache) ?? loadBundled());
+}
+function loadTable() {
+    if (table)
+        return table;
+    table = loadBundled();
     return table;
 }
 function lookupKeys(slug) {
@@ -55,7 +234,7 @@ function lookupKeys(slug) {
         keys.push(stripped);
     return keys;
 }
-/** USD per million tokens from the bundled models.dev snapshot; zeros if unknown. */
+/** USD per million tokens; zeros if unknown. */
 export function lookupModelCost(slug) {
     const prices = loadTable();
     for (const key of lookupKeys(slug)) {
@@ -65,3 +244,6 @@ export function lookupModelCost(slug) {
     }
     return ZERO_COST;
 }
+export function resetModelPrices() {
+    table = undefined;
+}

package/dist/proxy.js

@@ -112,6 +112,7 @@ export async function createLoopbackProxy(cpaUrl, apiKey, proxyId, port) {
         }
         const send = target.protocol === "https:" ? httpsRequest : httpRequest;
         const upstream = send(target, {
+            agent: false,
             method: request.method,
             headers: proxyHeaders(request.headers, apiKey),
         }, (upstreamResponse) => {

package/dist/targets/claude.js

@@ -169,7 +169,7 @@ export async function createClaudeProxy(cpaUrl, apiKey) {
             const headers = proxyHeaders(request.headers, apiKey);
             headers["content-length"] = String(body.length);
             const send = target.protocol === "https:" ? httpsRequest : httpRequest;
-            const upstream = send(target, { method: request.method, headers }, (upstreamResponse) => {
+            const upstream = send(target, { method: request.method, headers, agent: false }, (upstreamResponse) => {
                 response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders(upstreamResponse.headers));
                 upstreamResponse.pipe(response);
             });

package/dist/targets/cline.js

@@ -0,0 +1,197 @@
+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}`);
+}

package/dist/targets/pi.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync } from "node:
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { catalogModelId, catalogModelRows, dropAgent, fetchCatalog, recordWrittenConfig, restoreOwnedConfig, } from "../config.js";
-import { lookupModelCost } from "../pricing.js";
+import { ensureModelPrices, lookupModelCost } from "../pricing.js";
 import { ensureLoopbackProxy, stopProxyProcess } from "../proxy.js";
 import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, objectValue, resolveApiKey, } from "../util.js";
 export const PI_PROVIDER_ID = "cpac";
@@ -234,6 +234,7 @@ export async function installPiConfig(config) {
     const rows = catalogModelRows(document) ?? [];
     if (rows.length === 0)
         throw new CPACError("CPA catalog contains no models");
+    await ensureModelPrices();
     const { proxy, fingerprint, started } = await ensureLoopbackProxy(config, apiKey);
     const provider = buildCpacProvider(proxy.port, rows);
     const target = piModelsPath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.48",
+  "version": "0.2.0",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {
@@ -33,7 +33,7 @@
     "test": "npm run clean && tsc -p tsconfig.test.json && npm run copy-data && node --test --test-reporter=spec dist-test/cpac.test.js",
     "pack:check": "npm pack --dry-run",
     "copy-data": "node -e \"const fs=require('fs');const path=require('path');for (const d of ['dist/data','dist-test/src/data']) {fs.mkdirSync(d,{recursive:true});fs.copyFileSync('src/data/model-prices.json', path.join(d,'model-prices.json'))}\"",
-    "refresh-prices": "node scripts/refresh-model-prices.mjs"
+    "refresh-prices": "npm run build && node scripts/refresh-model-prices.mjs"
   },
   "devDependencies": {
     "@types/node": "^22.13.10",