mslxdff 0.1.136 → 0.1.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.136",
+  "version": "0.1.138",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
     "docs:check": "node scripts/docs-check.js"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "files": [
     "bin/",

package/src/chat/gateway.js

@@ -138,7 +138,7 @@ export function createGatewayClient({
         }
         if (provider === "opencode" && rawModel.includes("/")) {
           const maybe = rawModel.split("/")[0];
-          if (["workbuddy", "clinebot", "sensenova", "openrouter", "generic"].includes(maybe)) provider = maybe;
+          if (["workbuddy", "cline", "sensenova", "openrouter", "generic"].includes(maybe)) provider = maybe;
         }
       } catch {}
       if (TRACE) {

package/src/chat/prompt.js

@@ -58,7 +58,7 @@ ${mini}
 - 需要执行命令时调用 run_command，需要看文件时调用 read_file，需要检查网络/服务可用性时调用 curl。
 - curl 简写：upstream(=上游 https://opencode.ai/zen/v1/models)、local/health(=本机 /health)、local/models(=本机 /v1/models)，也支持完整 http(s) URL；会自动补上游头、本机 token 与已配置供应商 key（直连 https://api.b.ai/v1/models 会自动带 bai 的 key，无需手动加头）。
 - 查“某供应商有哪些模型”**优先用 CLI 直查**：若上方“可用模型”已能回答，直接前缀过滤回答（如 workbuddy/ 即 workbuddy）；需实时拉取时调用 run_command: "-provider <id> models"（如 -provider workbuddy models）或 "-model list --provider <id>"，按 allowlist 过滤，--json 供脚本。**禁止**调 -provider <id> list（这是查配置，不是查模型！）。**错误示例**：workbuddy有哪些模型 → 调 -provider workbuddy list → 错。**正确**：-provider workbuddy models。禁止为此调用 -showtoken。
-- 严禁幻觉命令：mslxdff "hi" --model X / mslxdff --model X "hi" / mslxdff -chat --model X 都不存在，输出只会是 status 页。探活任意模型（含 clinebot/*、workbuddy/*、bai/*）必须用 curl POST http://localhost:8989/v1/chat/completions，body 为 {"model":"<前缀/模型>","messages":[{"role":"user","content":"hi"}],"stream":false}，成功 200 + x-mslxdff-via:local 即通；401 代表本机 token 陈旧需提示 mslxdff -stop && mslxdff；403 + x-mslxdff-allowlist:1 代表白名单未放行需 allowlist add。
+- 严禁幻觉命令：mslxdff "hi" --model X / mslxdff --model X "hi" / mslxdff -chat --model X 都不存在，输出只会是 status 页。探活任意模型（含 cline/*、workbuddy/*、bai/*）必须用 curl POST http://localhost:8989/v1/chat/completions，body 为 {"model":"<前缀/模型>","messages":[{"role":"user","content":"hi"}],"stream":false}，成功 200 + x-mslxdff-via:local 即通；401 代表本机 token 陈旧需提示 mslxdff -stop && mslxdff；403 + x-mslxdff-allowlist:1 代表白名单未放行需 allowlist add。
 - **禁止重复调用（最高优先级）**：同一 run_command/curl/read_file 在本轮只执行一次，重复会被工具侧 SKIPPED_DUP 拦截；查询类（-showtoken/-status/-provider list/-providers list/-model list/-group list/-log 等）**调用一次即答案**，拿到 OK 结果后必须**立即用中文直接回答用户**，禁止再发起任何工具调用。收到 SKIPPED_DUP 或“请直接回答/禁止再调用”提示时，必须 0 工具直接回答。
 - 禁止调用 -uninstall，包含即拒绝；-showtoken 仅在用户明确要求查看/调试本机 token 时才用，查模型/查供应商严禁调用。
 - 回复风格：简洁友好，执行前后用中文说明你在做什么。

package/src/chat/terminal.js

@@ -96,7 +96,7 @@ export function handleSlash(line, ctx) {
     const id = arg;
     if (id.includes("/")) {
       console.log(`\x1b[31m[拒绝] ${id} 带供应商前缀 — -chat 只支持 opencode 上游模型（裸 id，直连 opencode.ai 免费池）\x1b[0m`);
-      console.log(`\x1b[90m其他供应商（deepseek/ workbuddy/ clinebot/ 等）请走网关：mslxdff -model set <id> 或 curl 本机 /v1/chat/completions\x1b[0m`);
+      console.log(`\x1b[90m其他供应商（deepseek/ workbuddy/ cline/ 等）请走网关：mslxdff -model set <id> 或 curl 本机 /v1/chat/completions\x1b[0m`);
       return { handled: true };
     }
     if (!isFreeModel(id) || !freePoolNow().includes(id)) {

package/src/cli/commands/model/list-providers.js

@@ -8,7 +8,7 @@ export async function renderOtherProviders({ pickedIds, ids, fullAliases }) {
   try { _la2(); } catch {}
   const configs = loadProviderConfigs();
   const otherIds = Object.keys(configs).filter((k) => String(k).toLowerCase() !== "opencode");
-  const order2 = ["workbuddy", "clinebot", "openrouter", "bai"];
+  const order2 = ["workbuddy", "cline", "openrouter", "bai"];
   otherIds.sort((a, b) => {
     const ia = order2.indexOf(a), ib = order2.indexOf(b);
     if (ia !== -1 || ib !== -1) {

package/src/cli/commands/model/list-render.js

@@ -57,7 +57,7 @@ export function renderFreeList({ ids, at, pickedIds, sortedProvs, groups, aliasM
   }
 }
 
-/** 按供应商分组 + 排序（opencode/workbuddy/clinebot/openrouter 优先） */
+/** 按供应商分组 + 排序（opencode/workbuddy/cline/openrouter 优先） */
 export function groupByProvider(ids) {
   const groups = {};
   for (const id of ids) {
@@ -65,7 +65,7 @@ export function groupByProvider(ids) {
     if (!groups[prov]) groups[prov] = [];
     groups[prov].push(id);
   }
-  const order = ["opencode", "workbuddy", "clinebot", "openrouter"];
+  const order = ["opencode", "workbuddy", "cline", "openrouter"];
   const sortedProvs = Object.keys(groups).sort((a, b) => {
     const ia = order.indexOf(a), ib = order.indexOf(b);
     if (ia !== -1 || ib !== -1) {

package/src/cli/commands/provider/add.js

@@ -69,7 +69,8 @@ export async function handleProviderAdd(id, sub, rest) {
     try {
       const { writeFileSync, mkdirSync } = await import("node:fs");
       const { join } = await import("node:path");
-      const dir = process.env.WORKBUDDY_AUTH_DIR || join(process.cwd(), "auths");
+      const { resolveAuthDir } = await import("../../providers/workbuddy/account-store.js");
+      const dir = resolveAuthDir();
       mkdirSync(dir, { recursive: true });
       const fp = join(dir, `workbuddy-${uid}.json`);
       const doc = { account: { uid, enterpriseId: "", nickname: "" }, auth: { accessToken: token, refreshToken: "", expiresAt: Math.floor(Date.now()/1000)+3600, domain: "www.codebuddy.cn" } };

package/src/cli/commands/provider/bench-via.js

@@ -120,7 +120,7 @@ export async function handleVia({ providerId, opts, fetchImpl, loadConfigs, load
       for (const k of Object.keys(raw.providerConfigs || {})) if (!targetIds.includes(k) && (loadAllowed(k) || []).length) targetIds.push(k);
       for (const k of Object.keys(raw.providerKeys || {})) if (!targetIds.includes(k) && (loadAllowed(k) || []).length) targetIds.push(k);
     } catch {}
-    if (!targetIds.length) targetIds = ["openrouter", "workbuddy", "clinebot"].filter((p) => (loadAllowed(p) || []).length);
+    if (!targetIds.length) targetIds = ["openrouter", "workbuddy", "cline"].filter((p) => (loadAllowed(p) || []).length);
     // opencode 默认 allowAny 但 allowlist 常空：有裸 picks 且确认包含 opencode 时纳入
     if (includeOpencode && !targetIds.includes("opencode") && picks.some((p) => !String(p).includes("/") || String(p).toLowerCase().startsWith("opencode/"))) {
       targetIds.push("opencode");

package/src/cli/commands/provider/cline-free.js

@@ -0,0 +1,94 @@
+/**
+ * mslxdff -provider cline free [sync] [--yes] [--json] [--keep-extra]
+ * 只读：直查上游免费目录（公开接口，无凭据）并与当前 allowlist 求差；只有 `free sync --yes` 才写 allowlist。
+ * allowlist 存裸 id（不带 cline/ 前缀），与 normalizeAllowedModel 语义一致；落盘走 saveProviderAllowedModels 保留 keys/baseUrl。
+ */
+import { normalizeProviderId } from "../../../providers/model-id.js";
+import { fetchFreeCatalog, FALLBACK_FREE, FREE_CATALOG_PATH } from "../../../providers/cline/free-catalog.js";
+
+/** 上游不可达时退回内置兜底目录（标注 source=fallback，供人判断是否该落盘） */
+async function loadCatalog() {
+  const cat = await fetchFreeCatalog({});
+  if (cat.ok) return { ...cat, source: "upstream" };
+  return {
+    ...cat,
+    source: "fallback",
+    models: FALLBACK_FREE.map((m) => ({ ...m })),
+    ids: FALLBACK_FREE.map((m) => m.id),
+  };
+}
+
+function computeNext(current, freeIds, keepExtra) {
+  const next = keepExtra ? [...new Set([...current, ...freeIds])] : [...freeIds];
+  return {
+    next,
+    added: next.filter((m) => !current.includes(m)),
+    removed: current.filter((m) => !next.includes(m)),
+    kept: next.filter((m) => current.includes(m)),
+  };
+}
+
+function renderList(cat, current, next, plan) {
+  console.log(`cline free 目录（GET ${FREE_CATALOG_PATH} → free）：${cat.ids.length} 个${cat.source === "fallback" ? "（内置兜底，上游不可达）" : ""}`);
+  const w = Math.max(20, ...cat.ids.map((s) => s.length)) + 2;
+  for (const m of cat.models) console.log(`   + ${String(m.id).padEnd(w)}${m.name && m.name !== m.id ? m.name : ""}`);
+  console.log(`当前 allowlist：${current.length} 个`);
+  for (const id of current) console.log(`   ${next.includes(id) ? "✓" : "-"} ${id}${next.includes(id) ? "" : "          （不在 free 目录）"}`);
+  console.log(`结果：allowlist ${current.length} → ${next.length}（+${plan.added.length} 新增 / -${plan.removed.length} 移除 / ${plan.kept.length} 保留）`);
+}
+
+export async function handleClineFree(id, sub, rest = [], args = []) {
+  if (normalizeProviderId(id) !== "cline") return false;
+  if (String(sub || "").toLowerCase() !== "free") return false;
+  const isSync = String(rest[1] || "").toLowerCase() === "sync";
+  const wantsJson = args.includes("--json") || args.includes("-json");
+  const yes = args.includes("--yes") || args.includes("-y");
+  const keepExtra = args.includes("--keep-extra");
+
+  const { loadProviderAllowedModels, saveProviderAllowedModels } = await import("../../../state.js");
+  const cat = await loadCatalog();
+  const current = loadProviderAllowedModels("cline");
+  const plan = computeNext(current, cat.ids, keepExtra);
+  const dryRun = !(isSync && yes);
+  let written = [];
+  if (isSync && !dryRun) {
+    try {
+      written = saveProviderAllowedModels("cline", plan.next);
+    } catch (e) {
+      console.error(`❌ 写入 allowlist 失败: ${String(e?.message || e)}`);
+      process.exit(1);
+    }
+  }
+  const warning = cat.source === "fallback" ? `上游目录不可达（${cat.error || cat.status}），使用内置兜底目录，可能过期` : null;
+
+  if (wantsJson) {
+    console.log(JSON.stringify({
+      provider: "cline",
+      mode: isSync ? "sync" : "list",
+      source: cat.source,
+      url: cat.url,
+      free: cat.ids,
+      current,
+      next: plan.next,
+      added: plan.added,
+      removed: plan.removed,
+      kept: plan.kept,
+      dryRun,
+      written,
+      ...(warning ? { warning } : {}),
+    }, null, 2));
+    process.exit(0);
+  }
+
+  if (warning) console.error(`⚠️  ${warning}`);
+  renderList(cat, current, plan.next, plan);
+  if (!isSync) {
+    console.log(`\n预览（只读）。一键同步：mslxdff -provider cline free sync --yes   ·   只增不删：加 --keep-extra`);
+  } else if (dryRun) {
+    console.log(`\n预览模式，未写入。执行：mslxdff -provider cline free sync --yes${keepExtra ? " --keep-extra" : ""}`);
+  } else {
+    console.log(`\n✅ 已写入 allowlist：${written.length} 个（providerConfigs.cline.allowedModels）`);
+    console.log(`   生效：mslxdff -restart（daemon 的 /v1/models 聚合有 10 分钟缓存，重启即刷新）`);
+  }
+  process.exit(0);
+}

package/src/cli/commands/provider/cline-login.js

@@ -1,7 +1,8 @@
 import { compatFetch, getUndici, timeoutSignal } from "../../../compat.js";
+import { normalizeProviderId } from "../../../providers/model-id.js";
 export async function handleClineLogin(id, sub) {
   if (sub !== "login" && sub !== "auth" && sub !== "oauth") return false;
-  if (id !== "cline" && id !== "clinebot" && id !== "cline-bot") return false;
+  if (normalizeProviderId(id) !== "cline") return false;
 
   const CLIENT_ID = "client_01K3A541FN8TA3EPPHTD2325AR";
   const WORKOS_DEVICE = "https://api.workos.com/user_management/authorize/device";
@@ -97,7 +98,7 @@ export async function handleClineLogin(id, sub) {
     }
   }
   if (!workos) {
-    console.error("\n❌ 授权超时，请重新运行 mslxdff -provider clinebot login");
+    console.error("\n❌ 授权超时，请重新运行 mslxdff -provider cline login");
     process.exit(1);
   }
   console.log("\n✅ WorkOS 授权成功！\n🔗 用 WorkOS token 在 Cline 注册...");
@@ -117,28 +118,32 @@ export async function handleClineLogin(id, sub) {
   console.log("=".repeat(60));
   console.log(`✅ 登录成功! 账号: ${email}`);
   console.log(`🔑 refreshToken: ${rt.slice(0, 8)}…${rt.slice(-8)} (${rt.length} 字符)`);
-  // 落盘到 state（同时写 cline 与 clinebot 两个 id，兼容）
-  const { loadProviderKeys, saveProviderConfig, loadProviderConfig } = await import("../../../state.js");
-  for (const pid of ["cline", "clinebot"]) {
-    try {
-      const cur = loadProviderKeys(pid);
-      if (cur.includes(rt)) {
-        console.log(`   ℹ️ ${pid} 已存在相同 token，跳过`);
-        continue;
-      }
+  // 落盘到 state（供应商 id 恒为 cline；写盘前先跑一次性迁移，保证老用户不会再写出 clinebot）
+  const { defaultStateFile, loadProviderKeys, saveProviderConfig, loadProviderConfig } = await import("../../../state.js");
+  try {
+    const { runStateMigrations } = await import("../../../state/migrations.js");
+    const mig = await runStateMigrations({ file: defaultStateFile() });
+    if (mig.applied.length) console.log(`   ℹ️ 已合并遗留供应商配置: ${mig.applied.join(", ")}`);
+  } catch {}
+  try {
+    const pid = "cline";
+    const cur = loadProviderKeys(pid);
+    if (cur.includes(rt)) {
+      console.log(`   ℹ️ ${pid} 已存在相同 token，跳过`);
+    } else {
       const cfg = loadProviderConfig(pid) || { baseUrl: "", keys: [] };
       const nextKeys = [...new Set([...(cfg.keys || cur), rt].filter(Boolean))];
       saveProviderConfig(pid, { baseUrl: cfg.baseUrl || "https://api.cline.bot", keys: nextKeys });
       console.log(`   ✅ 已写入 ${pid}（现 ${nextKeys.length} 个账号）`);
-    } catch (e) {
-      console.log(`   ⚠️ 写入 ${pid} 失败: ${e.message}`);
     }
+  } catch (e) {
+    console.log(`   ⚠️ 写入 cline 失败: ${e.message}`);
   }
   console.log("=".repeat(60));
   console.log("\n下一步：");
   console.log("  mslxdff -restart                         重启网关使新账号生效");
-  console.log("  mslxdff -provider clinebot bench --json  测速 deepseek 是否 200");
+  console.log("  mslxdff -provider cline bench --json     测速 deepseek 是否 200");
   console.log("  mslxdff -chat                             直接对话，模型选 deepseek/deepseek-v4-flash");
-  console.log("\n多账号：重复 `mslxdff -provider clinebot login` 追加，二号自动做后备");
+  console.log("\n多账号：重复 `mslxdff -provider cline login` 追加，二号自动做后备");
   process.exit(0);
 }

package/src/cli/commands/provider/index.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { normalizeProviderId } from "../../../providers/model-id.js";
 import { defaultStateFile } from "../../../state.js";
 
 export async function handleProviders(args) {
@@ -74,6 +75,27 @@ export async function handleProvider(args) {
   if (await handleProviderModels(id, sub, args, rest)) return true;
   const { handleProviderBench } = await import("./bench.js");
   if (await handleProviderBench(id, sub, rest, args)) return true;
+  const { handleClineFree } = await import("./cline-free.js");
+  if (await handleClineFree(id, sub, rest, args)) return true;
+  if (normalizeProviderId(id) === "cline" && sub === "migrate") {
+    const { runStateMigrations } = await import("../../../state/migrations.js");
+    const dryRun = args.includes("--dry-run") || args.includes("--dryrun");
+    const r = await runStateMigrations({ dryRun });
+    const d = r.details["cline-unify"] || {};
+    if (r.errors.length) console.error(`❌ 迁移失败: ${r.errors.map((e) => `${e.id}: ${e.error}`).join("; ")}`);
+    if (dryRun) {
+      console.log(d.changed
+        ? `cline migrate 干跑：将合并遗留 cline id 配置（keys ${d.before.keys} → ${d.after.keys} / allowlist ${d.before.allowedModels} → ${d.after.allowedModels}），未写入`
+        : "cline migrate 干跑：无需迁移（未发现 providerConfigs.clinebot / cline-bot）");
+    } else if (d.applied) {
+      console.log(`✅ cline migrate 完成：keys ${d.before.keys} → ${d.after.keys} / allowlist ${d.before.allowedModels} → ${d.after.allowedModels}`);
+      if (d.backup) console.log(`   备份：${d.backup}`);
+      console.log("   生效：mslxdff -restart");
+    } else {
+      console.log("cline migrate：无需迁移（未发现 providerConfigs.clinebot / cline-bot）");
+    }
+    process.exit(r.errors.length ? 1 : 0);
+  }
   const { handleProviderKeys } = await import("./keys.js");
   await handleProviderKeys(id, sub, rest, args);
   return true;

package/src/cli/commands/provider/models.js

@@ -1,9 +1,12 @@
 import { join } from "node:path";
 import { defaultStateFile } from "../../../state.js";
 import { logDir } from "../../../logs.js";
+import { normalizeProviderId } from "../../../providers/model-id.js";
 
 export async function handleProviderModels(id, sub, args, rest) {
   if (!(sub === "models" || sub === "show-models" || sub === "list-models" || sub === "ls")) return false;
+  // 供应商 id 归一（clinebot/cline-bot → cline）：老脚本 `-provider clinebot models` 仍走 cline 直查
+  id = normalizeProviderId(id);
   const { loadProviderConfig, loadProviderKeys, isModelAllowed } = await import("../../../state.js");
   const wantsJson = args.includes("--json") || args.includes("-json");
   const cfg = loadProviderConfig(id);
@@ -34,7 +37,7 @@ export async function handleProviderModels(id, sub, args, rest) {
     let provider;
     if (id === "workbuddy") {
       provider = createWorkbuddyProvider({ baseUrl, apiKeys: keys, auths, file: defaultStateFile() });
-    } else if (id === "cline" || id === "clinebot") {
+    } else if (id === "cline") {
       // 与聚合目录同源：recommended-models 的 free（generic 的 /api/v1/models 是全量目录，含大量不可用条目）
       const { createClineProvider } = await import("../../../providers/cline.js");
       provider = createClineProvider({ id, baseUrl: baseUrl || undefined, apiKeys: keys, file: defaultStateFile() });

package/src/cli/commands/provider/workbuddy-login.js

@@ -1,5 +1,5 @@
 import { compatFetch, timeoutSignal } from "../../../compat.js";
-// mslxdff -provider workbuddy login — WorkBuddy 官方设备授权流（对标 clinebot login）。
+// mslxdff -provider workbuddy login — WorkBuddy 官方设备授权流（对标 cline login）。
 // 学自 Sliverkiss/workbuddy2api（cmd/login）：POST /v2/plugin/auth/state 拿 state+authUrl →
 // 浏览器登录 → GET /v2/plugin/auth/token?state= 轮询 → GET /v2/plugin/login/account?state= 拿 uid。
 // 不走 whistle/MITM，不依赖 codebuddy CLI，自然支持多账号追加。

package/src/cli/commands/workbuddy.js

@@ -126,12 +126,15 @@ export async function handleWorkbuddy(args) {
     auths.splice(rmIdx,1); keys.splice(rmIdx,1);
     saveProviderConfig("workbuddy", { baseUrl: cfg.baseUrl||"https://copilot.tencent.com", keys, auths });
     if (!keep) {
+      // 旧实现只删 cwd/auths 那一份，留下的旧副本会被读取兜底"复活"账号 → 扫所有候选目录
       try {
         const { existsSync, unlinkSync } = await import("node:fs");
         const { join } = await import("node:path");
-        const dir = process.env.WORKBUDDY_AUTH_DIR || join(process.cwd(), "auths");
-        const fp = join(dir, `workbuddy-${uid}.json`);
-        if (existsSync(fp)) { unlinkSync(fp); console.log(`removed file ${fp}`); }
+        const { resolveAuthDirs } = await import("../../providers/workbuddy/account-store.js");
+        for (const dir of resolveAuthDirs()) {
+          const fp = join(dir, `workbuddy-${uid}.json`);
+          if (existsSync(fp)) { unlinkSync(fp); console.log(`removed file ${fp}`); }
+        }
       } catch {}
     }
     try { const { getBalanceCache } = await import("../../providers/workbuddy-balance.js"); getBalanceCache().delete(uid); } catch {}
@@ -155,24 +158,14 @@ async function loadWorkbuddyAccounts() {
   })).filter((it) => it.uid && it.key);
   if (items.length) return items;
   try {
-    const { readdirSync, readFileSync, existsSync } = await import("node:fs");
-    const { join } = await import("node:path");
-    const { resolveAuthDir } = await import("../../providers/workbuddy/account-store.js");
-    const dir = resolveAuthDir();
-    if (existsSync(dir)) {
-      for (const f of readdirSync(dir).filter((x) => x.startsWith("workbuddy-") && x.endsWith(".json"))) {
-        try {
-          const j = JSON.parse(readFileSync(join(dir, f), "utf8"));
-          if (j?.account?.uid && j?.auth?.accessToken) {
-            const domain = j.auth.domain || "www.codebuddy.cn";
-            items.push({
-              uid: j.account.uid, domain, enterpriseId: j.account.enterpriseId || "",
-              key: j.auth.accessToken,
-              auth: { uid: j.account.uid, domain, enterpriseId: j.account.enterpriseId || "", refreshToken: j.auth.refreshToken || "" },
-            });
-          }
-        } catch {}
-      }
+    const { listAccountDocs } = await import("../../providers/workbuddy/account-store.js");
+    for (const { uid, doc } of listAccountDocs()) {
+      const domain = doc.auth.domain || "www.codebuddy.cn";
+      items.push({
+        uid, domain, enterpriseId: doc.account.enterpriseId || "",
+        key: doc.auth.accessToken,
+        auth: { uid, domain, enterpriseId: doc.account.enterpriseId || "", refreshToken: doc.auth.refreshToken || "" },
+      });
     }
   } catch {}
   return items;

package/src/cli/index.js

@@ -1,12 +1,15 @@
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { assertMinNode } from "../compat.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf8")).version;
 
 // deep CLI entry — single inlet: run(args) — hides all command branching inside
 export async function run(args = process.argv.slice(2)) {
+  // 运行环境门（强制）：项目要求 Node >=18（ADR-0024），不满足则人话退出
+  if (!assertMinNode()) process.exit(1);
   const { handleHelp, handleUpdate, handleRefreshToken, handleShowToken, handleUninstall, handleLog, handlePlugins, handleChat, handleStatus, handleFree, handleAutostart } = await import("./commands/system.js");
   if (await handleHelp(args, VERSION)) return;
   if (await handleUpdate(args, VERSION)) return;

package/src/compat.js

@@ -1,8 +1,8 @@
-// 老 Node 兼容层（engines >=16）：Node 16 缺 globalThis.fetch（18+）、
-// AbortSignal.timeout（17.3+）、structuredClone（17+）；裸全局 crypto 是
-// WebCrypto，其 randomUUID 要 19+，只有 node:crypto 的 14.17+ 可用。
-// undici 8 需 Node 22+，依赖已锁 5.x（老 Node 可跑，API 兼容我们用到的面）。
-// 统一从这里取，源码里勿直接用这些全局。
+// 运行时兼容层（项目要求 Node >=18，见 ADR-0024；源码里勿直接用裸 fetch/globalThis.fetch）。
+// 仍保留本层的原因：① undici 是显式依赖（Agent 连接池/keep-alive 要用），
+// 各家 fetch 实现统一从这里取，避免 globalThis.fetch 与 undici.fetch 混用；
+// ② AbortSignal.timeout/structuredClone 在 18+ 已原生，这里的兜底只为可读报错，
+// 不再承诺 <18 可用（<18 请走 assertMinNode 的人话提示）。
 import { randomUUID } from "node:crypto";
 
 let _undici = null;
@@ -33,3 +33,21 @@ export function clone(v) {
 }
 
 export const uuid = () => randomUUID();
+
+// ---- 运行环境门（强制）：项目要求 Node >=18（ADR-0024）----
+// Node <18 缺 Response/Headers/ReadableStream/TransformStream 等 Web 全局，
+// 上游适配层有 29 处裸用，跑起来必 ReferenceError；与其半途炸掉，不如入口给人话。
+export const MIN_NODE_MAJOR = 18;
+
+export function nodeMajor() {
+  return Number(String(process.versions?.node || "0").split(".")[0]) || 0;
+}
+
+export function assertMinNode({ min = MIN_NODE_MAJOR, label = "mslxdff" } = {}) {
+  const major = nodeMajor();
+  if (major >= min) return true;
+  console.error(`[运行环境不满足] ${label} 需要 Node ${min}+，当前 v${process.versions.node}。`);
+  console.error("原因：Node <18 没有 Response/Headers/ReadableStream 等全局对象，上游转发必然失败。");
+  console.error("升级方式：nvm install 20 && nvm use 20，或到 https://nodejs.org/ 装 LTS（推荐 20/22）。");
+  return false;
+}

package/src/model-capabilities/merge.js

@@ -4,7 +4,7 @@
 // 全程 best-effort：目录不可用 → 原样返回，绝不让 /models 因富化失败挂掉。
 import { globalCapabilities } from "./index.js";
 
-// "clinebot/deepseek/deepseek-v4-flash" → { provider: "clinebot", raw: "deepseek/deepseek-v4-flash" }；裸 id 归 opencode
+// "cline/deepseek/deepseek-v4-flash" → { provider: "cline", raw: "deepseek/deepseek-v4-flash" }；裸 id 归 opencode
 export function splitModelId(id) {
   const s = String(id || "").trim();
   const i = s.indexOf("/");
@@ -55,7 +55,7 @@ export function capsPayloadFor(caps, raw) {
   return payload;
 }
 
-// 单条 id 的目录匹配：精确裸 id → 剥 -free 后缀 → 二级厂商前缀（clinebot/deepseek/x → deepseek/x）
+// 单条 id 的目录匹配：精确裸 id → 剥 -free 后缀 → 二级厂商前缀（cline/deepseek/x → deepseek/x）
 function lookupCaps(svc, provider, raw) {
   return (
     svc.get(provider, raw) ||

package/src/providers/classify.js

@@ -4,7 +4,7 @@
 // latency-compare：key/token 类，direct vs link+remote 比延迟
 export function classifyProvider(id) {
   const s = String(id || "").trim().toLowerCase();
-  if (s === "workbuddy" || s === "cline" || s === "clinebot") return "local-only";
+  if (s === "workbuddy" || s === "cline") return "local-only";
   if (s === "opencode") return "quota-pool";
   return "latency-compare";
 }

package/src/providers/cline/auth.js

@@ -120,7 +120,7 @@ export function createAuthPool({
     if (account.dead) throw new Error("invalid_grant");
     if (account.cooldownUntil > now) throw new Error("account_cooldown");
     if (account.accessToken && now < account.expiry) return account.accessToken;
-    // base 可能已含 /api/v1（state 里 clinebot baseUrl 就是 …/api/v1），直接拼会 double 成
+    // base 可能已含 /api/v1（老 clinebot 配置就是 …/api/v1），直接拼会 double 成
     // …/api/v1/api/v1/auth/refresh → 上游回 401 Unauthorized（版本/重认证提示），绝不能当 token 死。
     const baseNoV1 = resolvedBase.replace(/\/api\/v1\/?$/, "");
     const url = joinUrl(baseNoV1, "/api/v1/auth/refresh");

package/src/providers/cline/chat.js

@@ -1,20 +1,20 @@
 import { joinUrl, sleep } from "../base.js";
 import { clineHeaders } from "./headers.js";
 import { createTransport } from "../../transport/index.js";
+import { normalizeProviderId } from "../model-id.js";
 import { createSdkDispatch } from "../../upstream-engine/sdk/dispatch.js";
 
 function genSessionId() { return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`; }
 
-// stripProviderPrefix 去掉本地供应商前缀，发上游用裸模型 id。
-// 上游（对标 cline2api-workers MODELS）只认裸 id："deepseek/deepseek-v4-flash"、
-// "poolside/laguna-s-2.1:free"；本地 "clinebot/deepseek/..." 需取后两段。
-// 两段及以内视为已是裸 id，原样透传。
-function stripProviderPrefix(id) {
-  const parts = String(id || "").split("/").filter(Boolean);
-  if (parts.length > 2) return parts.slice(1).join("/");
-  return String(id || "");
+// stripProviderPrefix 只剥「本供应商」前缀（cline/<裸 id> → 裸 id），非本前缀（含上游自带多段 id
+// 如 meta/vendor/x）原样透传，不误削首段（旧实现按段数剥曾是潜在 bug）。
+function stripProviderPrefix(model, providerId) {
+  const s = String(model || "");
+  const i = s.indexOf("/");
+  if (i <= 0) return s;
+  const low = (v) => normalizeProviderId(String(v || "").toLowerCase());
+  return low(s.slice(0, i)) === low(providerId) ? s.slice(i + 1) : s;
 }
-
 function unwrapData(obj) {
   if (obj && obj.data && typeof obj.data === "object") {
     const d = obj.data;
@@ -169,7 +169,7 @@ export function createChatService({
     const model = body?.model || "deepseek/deepseek-v4-flash";
     const sessionId = genSessionId();
     const isStream = body?.stream === true;
-    const upstreamModel = stripProviderPrefix(model);
+    const upstreamModel = stripProviderPrefix(model, id);
     // token 口径双写：对标官方 withMaxCompletionTokensForReasoningModels——
     // cline 上游默认 reasoning_effort high，推理模型认 max_completion_tokens，
     // 只发 max_tokens 会被部分通道拒；双写兼容最稳。
@@ -182,7 +182,10 @@ export function createChatService({
       reasoning_effort: body?.reasoning_effort || body?.reasoningEffort || "high",
       messages: body?.messages || [],
     };
-    const forceStream = !isStream && String(upstreamModel).startsWith("deepseek/");
+    // 部分免费通道（deepseek 家族，含 cline-free/deepseek-*）原生非流式不可靠
+    //（500 empty response）：这类模型在内部走 stream+聚合成 JSON，对外仍按请求方
+    // stream 标志返回（true 直透，false 聚合）。其它模型完全尊重请求方，不强制。
+    const forceStream = !isStream && String(upstreamModel).toLowerCase().includes("deepseek");
     if (isStream || forceStream) upstreamBody.stream = true;
     for (const k of ["temperature", "top_p", "tools", "tool_choice", "stop", "presence_penalty", "frequency_penalty", "response_format", "user", "n", "seed"]) {
       if (body[k] !== undefined) upstreamBody[k] = body[k];

package/src/providers/cline/free-catalog.js

@@ -0,0 +1,71 @@
+/**
+ * Cline 免费目录深模块：只认上游 `free` 数组（公开接口，无需鉴权、无凭据）。
+ * GET {bareHost}/api/v1/ai/cline/recommended-models → { recommended, free, clinePass, clineCloud }
+ * 供 cline/models.js（聚合目录 + 启动自检）与 `-provider cline free` CLI 共用；缓存由调用方持有。
+ */
+import { compatFetch } from "../../compat.js";
+import { joinUrl } from "../base.js";
+
+export const FREE_CATALOG_PATH = "/api/v1/ai/cline/recommended-models";
+export const DEFAULT_CLINE_BASE = "https://api.cline.bot";
+
+// 上游不可达时的内置兜底（2026-09-20 实测 5 个；只有 id 与短名，无凭据）
+export const FALLBACK_FREE = Object.freeze([
+  { id: "cline-free/deepseek-v4.1-flash", name: "deepseek-v4.1-flash" },
+  { id: "cline-free/muse-spark-1.3-contributor", name: "muse-spark-1.3-contributor" },
+  { id: "z-ai/glm-5.3-flash", name: "glm-5.3-flash" },
+  { id: "cline-free/solar-pro4", name: "solar-pro4" },
+  { id: "poolside/laguna-s-2.1:free", name: "laguna-s-2.1:free" },
+]);
+export const FALLBACK_FREE_IDS = FALLBACK_FREE.map((m) => m.id);
+
+/** 目录 URL 归一：baseUrl 可能是裸 host 或带 /api/v1 的老 clinebot 形态；customPath 尊重用户自定义端点 */
+export function catalogUrl(baseUrl, customPath) {
+  const raw = String(baseUrl || "").trim() || DEFAULT_CLINE_BASE;
+  const bare = raw.replace(/\/+$/, "").replace(/\/api\/v1\/?$/, "") || DEFAULT_CLINE_BASE;
+  const p = String(customPath || "").trim();
+  if (p && p !== "/models" && p !== FREE_CATALOG_PATH) return joinUrl(bare, p);
+  return joinUrl(bare, FREE_CATALOG_PATH);
+}
+
+/** 只取 json.free（对象 {id,name,...} 或裸字符串两种形态都容忍） */
+function pickFree(json) {
+  const arr = Array.isArray(json?.free) ? json.free : [];
+  const out = [];
+  for (const m of arr) {
+    if (typeof m === "string" && m.trim()) out.push({ id: m.trim() });
+    else if (m && typeof m.id === "string" && m.id.trim()) out.push({ ...m, id: m.id.trim(), name: String(m.name || "") });
+  }
+  return out;
+}
+
+/**
+ * 拉免费目录。
+ * @returns {Promise<{ok:boolean, status:number, url:string, models:object[], ids:string[], error?:string}>}
+ *   ok=false 时 models/ids 为空（兜底由调用方决定）；authorization 供私有/自定义目录可选透传。
+ */
+export async function fetchFreeCatalog({ baseUrl, customPath, fetchImpl, dispatcher, authorization, timeoutMs = 15_000 } = {}) {
+  const url = catalogUrl(baseUrl, customPath);
+  const impl = fetchImpl || compatFetch;
+  const headers = { Accept: "application/json" };
+  if (authorization) headers.Authorization = authorization;
+  const opts = { headers };
+  if (dispatcher) opts.dispatcher = dispatcher;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error("cline free catalog timed out")), timeoutMs);
+  timer.unref?.();
+  opts.signal = controller.signal;
+  try {
+    const res = await impl(url, opts);
+    const status = Number(res?.status) || 0;
+    if (!res?.ok) return { ok: false, status, url, models: [], ids: [], error: `HTTP ${status}` };
+    const json = await res.json().catch(() => null);
+    const models = pickFree(json);
+    if (!models.length) return { ok: false, status, url, models: [], ids: [], error: "empty free list" };
+    return { ok: true, status, url, models, ids: models.map((m) => m.id) };
+  } catch (err) {
+    return { ok: false, status: 0, url, models: [], ids: [], error: String(err?.message || err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}