@luchenglong/cli-bridge 0.2.9 → 0.2.11

package/dynamic/claude.host.js

@@ -585,7 +585,8 @@ function createRunner(o) {
 //  - 模型清单只认服务端权威探测；拿不到 = ok:false + 可操作错误（绝不静默空数组/配置冒充）。
 // import { createStatusEngine, createRunner, clampInt, isLimited } from '../core/bridge-kit.mjs'
 // import { claudeExeCandidates, claudePathHint, resolveExePrefix, splitExeSpec, CLAUDE_BIN_ENV_VARS } from './claude-exe.mjs'
-// import { PROBE_MODEL, parseSupportedModels, probeSupportedModels, probeSupportedModelsSyncCached, readConfiguredModels, listAccountModels, resetModelsCache } from './claude-models.mjs'
+// import { PROBE_MODEL, parseSupportedModels, probeSupportedModels, readCachedModels, readConfiguredModels, listAccountModels, resetModelsCache, claudeConfigDir } from './claude-models.mjs'
+// import { ENDPOINT_MODES, DEFAULT_PROXY_URL, resolveEndpoint, overlaySettingsJson, readConfiguredBaseUrl } from './claude-endpoint.mjs'
 // 单行 re-export（build 内联时整行剥离；多行形态风险见 build.mjs 的 stripModuleSyntax 注释）。
 
 function nowIso() { return new Date().toISOString() }
@@ -593,6 +594,19 @@ function nowIso() { return new Date().toISOString() }
 // 权限模式的用户可见取值（auto 由 DSH plan 状态决定；其余直通 CLI）。
 const MODE_ENUM = ['auto', 'plan', 'accept-edits', 'bypass']
 
+// 手动拉取（契约 §3.2）的探测时限与失败指引。
+// 失败文案必须「可操作」：面板只会把 error 原样显示给用户，没写下一步等于没帮上忙。
+const REFRESH_TIMEOUT_MS = 30000
+const REFRESH_HINT = '排查顺序：① 确认设置面板的「claude 可执行文件路径」或 CLAUDE_BIN 指向真实 claude（原生 .exe 优先）；② 确认 ~/.claude/settings.json 的 env 里 ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN 指向可用端点（该面若未登录，先在终端跑一次 claude 完成登录）；③ 再点一次「拉取可用模型」。'
+
+/** 缓存年龄的短文案（面板 note 用；只描述事实，不假装新鲜）。 */
+function ageText(ms) {
+  const min = Math.floor(Math.max(0, Number(ms) || 0) / 60000)
+  if (min < 1) return '刚刚拉取'
+  if (min < 60) return min + ' 分钟前拉取'
+  return Math.floor(min / 60) + ' 小时前拉取'
+}
+
 // ── 三工具 schema ─────────────────────────────────────────────────────────────
 const RUN_PARAMS = {
   type: 'object',
@@ -742,6 +756,12 @@ function defineProvider (deps = {}) {
       else argv.push('--output-format', 'json')
       if (stream && args.includePartialMessages) argv.push('--include-partial-messages')
       const timeoutSec = clampInt(args.timeoutSec, 600, 10, 3600)
+      // 端点：cc-switch 的 proxy 模式把 Claude 指向第三方网关，而该网关要求自家 session 头
+      // （claude CLI 不会发）——**直连必然 400**，必须经 cc-switch 本地代理转发。
+      // 这里用 --settings 只覆盖 ANTHROPIC_BASE_URL，绝不改写用户的 ~/.claude/settings.json。
+      const ep = resolveEndpoint(currentSettings(), deps.env || {}, { probe: o.probeProxy, configDir: claudeConfigDir(deps.env || {}) })
+      if (ep.error) { const e = new Error(ep.error); e.code = 'ENDPOINT_UNAVAILABLE'; throw e }
+      if (ep.mode === 'proxy' && ep.baseUrl) argv.push('--settings', overlaySettingsJson(ep.baseUrl))
 
       // 权限：auto → 跟随 DSH plan 状态；plan 用 CLI 的 plan 模式，其余走 bypass
       //（-p 没有 TTY，任何交互批准都会挂到超时 —— 与 agy/codebuddy/opencode 同语义）。
@@ -967,12 +987,20 @@ function defineProvider (deps = {}) {
         }
         return out
       },
+      /**
+       * 设置面板元数据（契约 §3.2）：**只读缓存、绝不探测**。
+       * 面板是同步回调，而探测要起子进程打网络（3-5s）——放在这里会把首屏拖慢，且探不到时
+       * 用户无法区分「没模型」与「没拉到」。故探测改为用户点「拉取可用模型」→
+       * settings.refreshModels() 显式触发；成功后写回同一份缓存，这里下次渲染直接命中。
+       */
       meta: (env2) => {
         const e = env2 && typeof env2 === 'object' ? env2 : {}
         const s = currentSettings()
-        const probe = (function () { try { return probeSupportedModelsSyncCached(e, { binPath: s.binPath }) } catch (err) { return { ok: false, ids: [], error: String(err && err.message || err) } } })()
-        const options = (probe.ok ? probe.ids : []).map((id) => ({ value: id, label: id }))
+        const cached = readCachedModels(e, { binPath: s.binPath })
+        const options = (cached ? cached.ids : []).map((id) => ({ value: id, label: id }))
         const exeCandidates = claudeExeCandidates(e, '')
+        // 端点实际走向（proxy / direct）——面板上如实显示，用户不用猜为什么请求失败。
+        const epInfo = resolveEndpoint(s, e, { configDir: claudeConfigDir(e) })
         return {
           titleSuffix: 'Claude Code',
           fields: [
@@ -985,19 +1013,73 @@ function defineProvider (deps = {}) {
             {
               key: 'defaultModel', label: '默认模型', type: 'select', allowCustom: true,
               options,
+              // 面板据此渲染「手动拉取」按钮（契约 §3.2）；meta() 自身永不探测。
+              refresh: { label: '拉取可用模型' },
               placeholder: '留空 = 由 claude 自身配置（~/.claude/settings.json）决定',
               note: options.length
-                ? '共 ' + options.length + ' 个服务端权威可用模型（探测所得）。调用时传 model 可覆盖本项。'
-                : '未能获取服务端权威模型清单（探测失败：' + String(probe.error || 'unknown').slice(0, 140) + '）—— 下拉为空，但可手动输入模型名。配置里的 ANTHROPIC_*_MODEL 只是别名映射，不作为候选展示。'
+                ? '共 ' + options.length + ' 个服务端权威可用模型（' + ageText(cached.ageMs) + '，源：' + cached.mode + '）。点「拉取可用模型」重新获取；调用时传 model 可覆盖本项。'
+                : '还没拉取过（或上次没拉到）：点「拉取可用模型」向端点取权威清单；空表示尚未拉取 / 该面未登录。可直接手动输入模型名 —— 配置里的 ANTHROPIC_*_MODEL 只是别名映射，不作为候选展示。'
             },
             {
               key: 'maxBudgetUsd', label: '单次最大花费（美元）', type: 'text',
               placeholder: '留空 = 不限制',
               note: '非空时自动附加 --max-budget-usd；调用参数 maxBudgetUsd 可覆盖。'
+            },
+            {
+              key: 'endpointMode', label: '端点模式', type: 'select',
+              options: [
+                { value: 'auto', label: 'auto —— 代理活着就走代理，否则直连' },
+                { value: 'proxy', label: 'proxy —— 强制走本地代理' },
+                { value: 'direct', label: 'direct —— 强制直连配置的端点' }
+              ],
+              note: epInfo.note + '。cc-switch 的 proxy 模式把 Claude 指向第三方网关，该网关要求自家 session 头而 claude CLI 不会发：直连必然 400，必须经 cc-switch 本地代理转发。'
+            },
+            {
+              key: 'proxyUrl', label: '本地代理地址', type: 'text',
+              placeholder: DEFAULT_PROXY_URL,
+              note: 'cc-switch 的本地代理默认监听 127.0.0.1:15721。若你改过端口，填这里。桥接用 --settings 只覆盖 ANTHROPIC_BASE_URL，**不会改写** ~/.claude/settings.json。'
             }
           ]
         }
       },
+
+      /**
+       * 手动拉取（契约 §3.2）：面板「拉取可用模型」按钮 → keystone
+       * POST /cli-bridge/settings/models → 这里。这是本 provider 唯一的面板探测入口。
+       *
+       * 复用 listAccountModels（异步 probeSupportedModels + 配置诊断），不写第二套探测；
+       * 其成功路径已把权威清单写回 modelsCache，随后 meta() 直接命中（无需再探测）。
+       * 铁律：失败 = ok:false + 可操作错误 + 空 ids，绝不返回 {ok:true, ids:[]}；
+       * 也绝不把 settings.json 里的别名映射冒充成服务端可用全集。
+       */
+      async refreshModels(settings, env2) {
+        const e = (env2 && typeof env2 === 'object') ? env2 : env
+        const s = descriptor.settings.normalize(settings)
+        // 探测必须走**同一个端点**：cc-switch proxy 模式下直连第三方网关会 400，那样探测
+        // 永远拿不到东西（但配置清单仍应给出，见 listAccountModels 的合并逻辑）。
+        const ep = resolveEndpoint(s, e, { configDir: claudeConfigDir(e) })
+        const got = await listAccountModels(e, {
+          binPath: s.binPath,
+          baseUrl: ep.mode === 'proxy' ? ep.baseUrl : '',
+          timeoutMs: REFRESH_TIMEOUT_MS,
+          refresh: true
+        })
+        if (!got.ok) {
+          return { ok: false, ids: [], source: got.source || 'none', error: String(got.error || 'probe failed') + ' ' + REFRESH_HINT + ' 端点：' + ep.note }
+        }
+        const ids = (got.models || []).map((m) => m.id).filter(Boolean)
+        if (!ids.length) {
+          return { ok: false, ids: [], source: got.source || 'none', error: '探测声称成功但未返回任何模型 id（内部不一致）。' + REFRESH_HINT }
+        }
+        // labels 标出「来自配置」还是「服务端报文补充」，面板可据此区分来源。
+        const labels = {}
+        for (const m of got.models) {
+          labels[m.id] = m.id + (m.source === 'configured'
+            ? '  [' + String(m.configuredAs || 'settings.json') + ']'
+            : '  [服务端清单]')
+        }
+        return { ok: true, ids, labels, source: got.source || 'configured', endpoint: ep.note }
+      },
       diagnose: (settings, env2) => {
         const s = settings && typeof settings === 'object' ? settings : {}
         const e = env2 && typeof env2 === 'object' ? env2 : {}
@@ -1070,6 +1152,140 @@ function defineProvider (deps = {}) {
   return descriptor
 }
 
+// ── inlined from providers/claude-endpoint.mjs ──
+// providers/claude-endpoint.mjs — claude 的端点解析（第三片）。
+//
+// 为什么需要这一层（真实事故，2026-10-20）：
+// 用户用 cc-switch 管理 Claude 配置，其「proxy 模式」把 Claude 指向第三方网关
+// （例：ANTHROPIC_BASE_URL=https://opencode.ai/zen/go）。该网关要求自家 session 头
+// （`x-opencode-session` / MissingSessionID），claude CLI 不会发 → **直连必然 400**。
+// 能用是因为 cc-switch 在本机起了一个转发代理，由它补头/认证：
+//   实测 POST http://127.0.0.1:15721/v1/messages → 200；同一配置直连 → 400 MissingSessionID。
+// 所以「把 base_url 换成 cc-switch 代理」不是降级，而是这套配置**唯一可行**的访问方式。
+//
+// 注入方式：`--settings <json>` 覆盖 env.ANTHROPIC_BASE_URL，**不改用户的
+// ~/.claude/settings.json**（那是 cc-switch 的领地，改它会在下次切换时被覆盖，也可能
+// 破坏用户的 GUI 会话）。
+//
+// 探活采用「起一次 node 子进程做 HTTP GET」：buildArgv/meta 都是同步回调，Node 无同步
+// HTTP。结果按 URL 缓存 30s，避免每次调用都起进程。探不到就如实回落直连（并在诊断里
+// 说明"代理未响应"），绝不再假装已接管。
+
+/** 默认的 cc-switch 本地代理地址（其 proxy_config.listen_port 实测为 15721）。 */
+const DEFAULT_PROXY_URL = 'http://127.0.0.1:15721'
+
+/** 端点模式：auto = 代理活着就用它；proxy = 强制；direct = 强制直连。 */
+const ENDPOINT_MODES = ['auto', 'proxy', 'direct']
+
+const PROXY_TTL_MS = 30 * 1000
+let proxyCache = { url: '', at: 0, alive: false, detail: '' }
+
+/** 允许测试注入探测结果，避免每个用例都起子进程。 */
+function resetProxyCache() { proxyCache = { url: '', at: 0, alive: false, detail: '' } }
+
+function builtin(name) {
+  const p = globalThis.process
+  try { return (p && typeof p.getBuiltinModule === 'function') ? p.getBuiltinModule(name) : null } catch (e) { return null }
+}
+
+/** 探活子脚本：对 url 发 GET，任何 HTTP 响应都算活着（404 也算 —— cc-switch 根路径就是 404）。 */
+const PROBE_SCRIPT = [
+  "const http=require('http'),https=require('https');",
+  "const u=process.argv[1];",
+  "const m=/^https:/i.test(u)?https:http;",
+  "const r=m.get(u,{timeout:1500},(res)=>{res.resume();console.log('ALIVE '+res.statusCode);process.exit(0)});",
+  "r.on('error',(e)=>{console.log('DEAD '+(e.code||e.message));process.exit(0)});",
+  "r.on('timeout',()=>{console.log('DEAD timeout');try{r.destroy()}catch(e){};process.exit(0)});"
+].join('')
+
+/**
+ * 同步探活（带 30s 缓存）。返回 { alive, detail }。
+ * 起 `node -e` 子进程是唯一能在同步回调里做真实 HTTP 的办法；代价约 100-250ms，
+ * 且被 URL 维度缓存 —— 只在「首次」或「缓存过期」时付。
+ */
+function detectProxySync(url, nowMs) {
+  const target = String(url || '').trim()
+  if (!target) return { alive: false, detail: 'no url' }
+  const at = Number(nowMs) || Date.now()
+  if (proxyCache.url === target && at - proxyCache.at < PROXY_TTL_MS) {
+    return { alive: proxyCache.alive, detail: proxyCache.detail }
+  }
+  const child = builtin('node:child_process')
+  const proc = globalThis.process
+  let alive = false
+  let detail = 'no child_process'
+  if (child && typeof child.spawnSync === 'function' && proc && proc.execPath) {
+    try {
+      const r = child.spawnSync(proc.execPath, ['-e', PROBE_SCRIPT, target], {
+        encoding: 'utf8', timeout: 4000, windowsHide: true,
+        env: Object.assign({}, proc.env)
+      })
+      const out = String((r && r.stdout) || '')
+      alive = /^ALIVE\b/m.test(out)
+      detail = out.trim().split(/\r?\n/).pop() || (r && r.error && (r.error.code || r.error.message)) || 'unknown'
+    } catch (e) { detail = 'probe threw: ' + String(e && e.message || e) }
+  }
+  proxyCache = { url: target, at, alive, detail }
+  return { alive, detail }
+}
+
+/** 读 ~/.claude/settings.json 里配置的 ANTHROPIC_BASE_URL（只读，不写）。 */
+function readConfiguredBaseUrl(env, configDir) {
+  const fs = builtin('node:fs')
+  const path = builtin('node:path')
+  if (!fs || !path) return ''
+  const dir = configDir || ((env && (env.CLAUDE_CONFIG_DIR || env.CLAUDE_HOME)) || '')
+  if (!dir) return ''
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(dir, 'settings.json'), 'utf8'))
+    const block = raw && raw.env && typeof raw.env === 'object' ? raw.env : {}
+    return typeof block.ANTHROPIC_BASE_URL === 'string' ? block.ANTHROPIC_BASE_URL.trim() : ''
+  } catch (e) { return '' }
+}
+
+/**
+ * 解析最终端点。
+ * @returns {{ mode: 'proxy'|'direct', baseUrl: string, proxyUrl: string, proxyAlive: boolean,
+ *             configuredBaseUrl: string, note: string, error?: string }}
+ */
+function resolveEndpoint(settings, env, opts) {
+  const o = opts || {}
+  const s = settings && typeof settings === 'object' ? settings : {}
+  const mode = ENDPOINT_MODES.indexOf(String(s.endpointMode || '')) >= 0 ? String(s.endpointMode) : 'auto'
+  const proxyUrl = String(s.proxyUrl || DEFAULT_PROXY_URL).trim() || DEFAULT_PROXY_URL
+  const configuredBaseUrl = readConfiguredBaseUrl(env, o.configDir)
+
+  if (mode === 'direct') {
+    return { mode: 'direct', baseUrl: configuredBaseUrl, proxyUrl, proxyAlive: false, configuredBaseUrl, note: '强制直连（endpointMode=direct）' }
+  }
+  const det = o.probe ? o.probe(proxyUrl) : detectProxySync(proxyUrl)
+  if (det.alive) {
+    return {
+      mode: 'proxy', baseUrl: proxyUrl, proxyUrl, proxyAlive: true, configuredBaseUrl,
+      note: '经 cc-switch 本地代理 ' + proxyUrl + '（配置的端点 ' + (configuredBaseUrl || '(未读到)') + ' 需要代理补头）'
+    }
+  }
+  if (mode === 'proxy') {
+    return {
+      mode: 'proxy', baseUrl: proxyUrl, proxyUrl, proxyAlive: false, configuredBaseUrl,
+      note: '强制走代理但探测失败：' + det.detail,
+      error: 'cc-switch 本地代理 ' + proxyUrl + ' 无响应（' + det.detail + '）。请启动 cc-switch（含其本地代理），' +
+        '或把「端点模式」改为 direct 直连，或在「代理地址」里填实际端口。'
+    }
+  }
+  return {
+    mode: 'direct', baseUrl: configuredBaseUrl, proxyUrl, proxyAlive: false, configuredBaseUrl,
+    note: '直连配置的端点 ' + (configuredBaseUrl || '(未读到)') + '（本地代理 ' + proxyUrl + ' 未响应：' + det.detail + '）。' +
+      '若该端点来自 cc-switch 的 proxy 模式，请启动 cc-switch —— 否则会被网关以缺 session 头拒绝。'
+  }
+}
+
+/** 把端点覆盖编成 claude 的 `--settings` JSON（只覆盖 base_url，不动其它键）。 */
+function overlaySettingsJson(baseUrl) {
+  if (!baseUrl) return ''
+  return JSON.stringify({ env: { ANTHROPIC_BASE_URL: String(baseUrl) } })
+}
+
 // ── inlined from providers/claude-exe.mjs ──
 // providers/claude-exe.mjs — claude 可执行文件探测/包装（无宿主依赖的纯逻辑片）。
 //
@@ -1200,18 +1416,23 @@ function claudePathHint(env) {
 //   ~/.claude/settings.json 的 env.ANTHROPIC_DEFAULT_*_MODEL 只是「别名映射」，
 //   不是服务端可用全集 —— 红线：绝不把它冒充成可用清单，也绝不静默返回空数组。
 //
-// 落盘/缓存：面板（settings.meta）是同步回调，必须 spawnSync；探测一次约 3-5s，
-// 故结果进 5 分钟缓存（与 codebuddy catalog 同策略），避免每次渲染都打网络。
+// 缓存与「谁探测」（契约 §3.2 手动拉取）：
+//   • settings.meta() 是同步回调，且**不再自动探测** —— 它只调 readCachedModels() 读这里的
+//     缓存（纯读、不 spawn、不联网）；没命中就留空，由 note 提示用户点「拉取可用模型」。
+//   • 探测只有一条路：settings.refreshModels() → 异步 probeSupportedModels()（用户显式触发）。
+//     成功后经 cachedModels() 写回同一个缓存，下次 meta() 直接命中 —— 面板首屏不再被拖慢。
+//   • 5 分钟 TTL 只约束**工具调用**（claude_models 的重复调用）；面板展示的是「上次拉取到的
+//     权威清单」，过期也照旧展示，但 note 会标注拉取时间（宁可显式标旧，也不让下拉莫名清空）。
 // import { claudeExeCandidates, claudeProbeCandidates, splitExeSpec, quoteShellArg } from './claude-exe.mjs'
 // 故意无效的探测模型名（服务端必然拒绝；保持带前缀，便于日志辨认来源）。
 const PROBE_MODEL = '__clb_probe_invalid__'
 const MODELS_TTL_MS = 5 * 60 * 1000
 
-// 探测结果缓存：key（后端/端点标识） → { at, ids }
+// 探测结果缓存：key（后端/端点标识） → { at, value }
 const modelsCache = new Map()
 
 /** 清空探测缓存（测试与「模型变更后刷新」用）。 */
-function resetModelsCache() { modelsCache.clear(); syncModelsCache.clear() }
+function resetModelsCache() { modelsCache.clear() }
 
 // 缓存键 = 候选可执行文件集合（同一台机器可能切换 CLAUDE_BIN / 面板路径，键必须跟着变，
 // 否则会把「上一个 exe 的探测结果」错配给新 exe）。
@@ -1220,8 +1441,18 @@ function candidateKey(env, binPath) {
   return list.length ? list.join('|') : 'claude'
 }
 
+/** 缓存的键（面板读缓存与工具探测必须用同一把键，否则写进去读不出来）。 */
+function modelsCacheKey(env, binPath) {
+  return 'claude:' + candidateKey(env, binPath)
+}
+
+/** 缓存里只可能存「成功的权威清单」；失败绝不入缓存（否则会把坏状态固化）。 */
+function isUsableProbe(v) {
+  return !!(v && v.ok === true && Array.isArray(v.ids) && v.ids.length)
+}
+
 /**
- * 缓存包装：TTL 内直接返回上次成功结果；失败不写缓存（下次仍然重试，绝不把失败固化）。
+ * 缓存包装（异步工具路径）：TTL 内直接返回上次成功结果；失败不写缓存。
  * @param {string} key
  * @param {() => Promise<object>|object} load
  * @param {number} [nowMs]
@@ -1231,11 +1462,47 @@ function cachedModels(key, load, nowMs) {
   const hit = modelsCache.get(key)
   if (hit && at - hit.at < MODELS_TTL_MS) return hit.value
   return Promise.resolve().then(load).then((v) => {
-    if (v && v.ok && Array.isArray(v.ids) && v.ids.length) modelsCache.set(key, { at, value: v })
+    if (isUsableProbe(v)) modelsCache.set(key, { at, value: v })
     return v
   })
 }
 
+/**
+ * 只读缓存（settings.meta 专用）：纯读、不 spawn、不联网。
+ * 与 cachedModels 的区别：这里**不受 TTL 限制** —— 面板展示的是「上次真正拉取到的那份
+ * 服务端清单」，附 ageMs 让 note 如实标注新旧；空/过期与否都不该凭空清空用户看到的下拉。
+ *
+ * 为什么要「精确键未命中 → 取最近一次成功结果」：keystone 渲染面板时只把 env 传给
+ * meta()，**拿不到面板里保存的 binPath**（settingsView 里 createProvider 只带 env），
+ * 而缓存键含候选 exe 集合 → 用户一旦填过 binPath，精确键必然错开，下拉会在拉取成功后
+ * 仍然空着（看起来像按钮没起作用）。这不算降级：清单是 claude 自己 settings.json 里
+ * 端点+凭据裁决的，与走哪个候选 exe 无关（exe 只决定探测能否跑起来），且 note 会带上
+ * 「N 分钟前拉取 / 源 account-live」，用户看到的是真实的探测结果与真实的年龄。
+ * @param {object} env
+ * @param {{binPath?: string, nowMs?: number}} [opts]
+ * @returns {{ids: string[], mode: string, exe: (string|null), at: number, ageMs: number}|null}
+ */
+function readCachedModels(env, opts) {
+  const o = opts || {}
+  const at = Number(o.nowMs) || Date.now()
+  const exact = modelsCache.get(modelsCacheKey(env, o.binPath))
+  let hit = isUsableProbe(exact && exact.value) ? exact : null
+  if (!hit) {
+    for (const entry of modelsCache.values()) {
+      if (!isUsableProbe(entry.value)) continue
+      if (!hit || entry.at > hit.at) hit = entry
+    }
+  }
+  if (!hit) return null
+  return {
+    ids: hit.value.ids.slice(),
+    mode: hit.value.mode || 'account-live',
+    exe: hit.value.exe || null,
+    at: hit.at,
+    ageMs: Math.max(0, at - hit.at)
+  }
+}
+
 /**
  * 从 400 报文里解析「服务端支持的模型名」。
  * 主格式（实测）：`The supported API model names are A, B, but you passed Z.`
@@ -1343,8 +1610,15 @@ function readConfiguredModels(env) {
 }
 
 /** 探测 argv（不含 exe 前缀）：固定参数集，绝不拼装用户 prompt。 */
-function probeArgv() {
-  return ['-p', 'hi', '--model', PROBE_MODEL, '--output-format', 'json', '--no-session-persistence']
+/**
+ * 探测用的 argv。`baseUrl` 非空时用 `--settings` 覆盖 ANTHROPIC_BASE_URL ——
+ * 这是 cc-switch proxy 模式唯一可行的访问方式（直连第三方网关缺 session 头必 400）。
+ * 只覆盖 base_url，不碰用户的 ~/.claude/settings.json。
+ */
+function probeArgv(baseUrl) {
+  const argv = ['-p', 'hi', '--model', PROBE_MODEL, '--output-format', 'json', '--no-session-persistence']
+  if (baseUrl) argv.push('--settings', JSON.stringify({ env: { ANTHROPIC_BASE_URL: String(baseUrl) } }))
+  return argv
 }
 
 /** 探测失败时的可操作文案（区分「没找到 CLI」与「CLI 跑了但服务端没报清单」）。 */
@@ -1356,68 +1630,8 @@ function probeFailureText(reasons, tried) {
 }
 
 /**
- * 同步探测（供 settings.meta 面板下拉；无 spawnSync 能力 → 明确 ok:false）。
- * @param {object} env
- * @param {{binPath?: string, timeoutMs?: number}} [opts]
- * @returns {{ok: boolean, ids: string[], mode: string, exe?: string, error?: string}}
- */
-function probeSupportedModelsSync(env, opts) {
-  const o = opts || {}
-  const child = (function () { try { const p = globalThis.process; return (p && typeof p.getBuiltinModule === 'function') ? p.getBuiltinModule('node:child_process') : null } catch (x) { return null } })()
-  if (!child || typeof child.spawnSync !== 'function') {
-    return { ok: false, ids: [], mode: 'account-live', error: 'no spawnSync capability in this host form' }
-  }
-  const cands = claudeProbeCandidates(env, o.binPath)
-  const probeList = cands.length ? cands : ['claude']
-  const timeout = Math.max(3000, Math.min(Number(o.timeoutMs) || 12000, 30000))
-  const reasons = []
-  const proc = globalThis.process
-  for (const exe of probeList) {
-    const spec = splitExeSpec(exe)
-    const argv = spec.prefixArgs.concat(probeArgv())
-    const cmd = spec.shell ? [spec.cmd].concat(argv).map(quoteShellArg).join(' ') : spec.cmd
-    const r = child.spawnSync(cmd, spec.shell ? [] : argv, {
-      encoding: 'utf8', timeout, windowsHide: true, shell: !!spec.shell,
-      env: Object.assign({}, (proc && proc.env) || {}, {})
-    })
-    if (!r || r.error) { reasons.push(exe + ': ' + String((r && r.error && (r.error.code || r.error.message)) || 'spawn failed')); continue }
-    const got = extractProbeIds(r.stdout, r.stderr)
-    if (got.ids && got.ids.length) return { ok: true, ids: got.ids, mode: 'account-live', exe }
-    const head = String(got.errorText || '').replace(/\s+/g, ' ').trim().slice(0, 160)
-    reasons.push(exe + ': exit ' + r.status + '，未解析出可用模型清单' + (head ? ' — ' + head : ''))
-  }
-  return { ok: false, ids: [], mode: 'account-live', error: probeFailureText(reasons, probeList.length) }
-}
-
-// 同步探测缓存（面板每次渲染都会取，避免反复 spawnSync 打网络）。
-const syncModelsCache = new Map()
-// 失败结果的反向缓存 TTL：成功缓存 5 分钟；失败只缓存 60 秒。
-// 为什么必须有反向缓存：面板是同步回调，CLI 缺失/未登录时一次 spawnSync 可能阻塞数秒，
-// 每次渲染都重探会让设置面板卡顿。60 秒足够让用户装好 CLI/登录后立刻看到新结果，
-// 又不会把「当时读不到」长期固化成假象（状态照旧 ok:false + 可操作错误，语义不变）。
-const NEGATIVE_TTL_MS = 60 * 1000
-
-/**
- * 带缓存的同步探测（settings.meta 专用；面板是同步回调，只能 spawnSync）。
- * 成功/失败都进缓存（TTL 不同），失败语义保持不变：ok:false + 可操作错误。
- * @returns {{ok: boolean, ids: string[], mode: string, exe?: string, error?: string}}
- */
-function probeSupportedModelsSyncCached(env, opts) {
-  const o = opts || {}
-  const key = 'sync:claude:' + candidateKey(env, o.binPath)
-  const at = Date.now()
-  const hit = syncModelsCache.get(key)
-  if (hit) {
-    const ttl = hit.value && hit.value.ok ? MODELS_TTL_MS : NEGATIVE_TTL_MS
-    if (at - hit.at < ttl) return hit.value
-  }
-  const v = probeSupportedModelsSync(env, o)
-  syncModelsCache.set(key, { at, value: v })
-  return v
-}
-
-/**
- * 异步探测（MCP / preset / dynamic 三形态共用）：起一次真实 CLI 调用，解析 400 报文。
+ * 异步探测（唯一探测实现：MCP / preset / dynamic 三形态 + 面板「拉取可用模型」共用）：
+ * 起一次真实 CLI 调用，解析 400 报文。
  * 铁律：只认探测结果；失败 = ok:false + 可操作错误，绝不回落到配置文件/静态表。
  * @param {object} env
  * @param {{binPath?: string, timeoutMs?: number}} [opts]
@@ -1443,7 +1657,7 @@ function probeSupportedModels(env, opts) {
       }
       const exe = probeList[idx++]
       const spec = splitExeSpec(exe)
-      const argv = spec.prefixArgs.concat(probeArgv())
+      const argv = spec.prefixArgs.concat(probeArgv(o.baseUrl))
       let c
       try {
         const spawnCmd = spec.shell ? [spec.cmd].concat(argv).map(quoteShellArg).join(' ') : spec.cmd
@@ -1454,20 +1668,33 @@ function probeSupportedModels(env, opts) {
       let out = ''
       let err = ''
       const timer = setTimeout(() => { try { c.kill() } catch (e) { } }, Math.max(5000, Math.min(Number(o.timeoutMs) || 30000, 90000)))
+      // 一个候选只允许结算一次：spawn 失败时 'error' 与 'close' 会先后都触发，
+      // 两个回调各调一次 attempt() 会把后面的候选整个跳过（idx 多走一格）——
+      // 实测后果是「binPath 填错 → 明明 CLAUDE_BIN 里那个能跑，探测却直接失败」。
+      let settled = false
+      const nextCandidate = (reason) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        if (reason) reasons.push(reason)
+        attempt()
+      }
       c.stdout.on('data', (d) => { out += d; if (out.length > 400000) out = out.slice(-200000) })
       c.stderr.on('data', (d) => { err += d; if (err.length > 200000) err = err.slice(-100000) })
       c.on('error', (e) => {
-        clearTimeout(timer)
-        reasons.push(exe + ': ' + String((e && e.code) || (e && e.message) || 'spawn error'))
-        attempt()
+        nextCandidate(exe + ': ' + String((e && e.code) || (e && e.message) || 'spawn error'))
       })
       c.on('close', (code) => {
-        clearTimeout(timer)
+        if (settled) return
         const got = extractProbeIds(out, err)
-        if (got.ids && got.ids.length) { resolve({ ok: true, ids: got.ids, mode: 'account-live', exe }); return }
+        if (got.ids && got.ids.length) {
+          settled = true
+          clearTimeout(timer)
+          resolve({ ok: true, ids: got.ids, mode: 'account-live', exe })
+          return
+        }
         const head = String(got.errorText || '').replace(/\s+/g, ' ').trim().slice(0, 160)
-        reasons.push(exe + ': exit ' + code + '，未解析出可用模型清单' + (head ? ' — ' + head : ''))
-        attempt()
+        nextCandidate(exe + ': exit ' + code + '，未解析出可用模型清单' + (head ? ' — ' + head : ''))
       })
     }
     attempt()
@@ -1481,40 +1708,69 @@ function probeSupportedModels(env, opts) {
  * @param {object} env
  * @param {{binPath?: string, timeoutMs?: number, refresh?: boolean}} [opts]
  */
+/**
+ * 列出可用模型 —— **合并两个来源**，而不是只认服务端报文。
+ *
+ * 为什么必须合并（真实事故）：服务端「无效模型触发 400」只回吐**基础模型名**。
+ * 实测 DeepSeek 的 Anthropic 兼容端点报 `deepseek-flash, deepseek-v4-pro`，
+ * 但用户实际配置在用的 `deepseek-v4-pro[1M]` / `deepseek-v4-flash` 逐个实测都是 200 ——
+ * 它们只是带上下文窗口后缀/命名变体，服务端报文不列。若只信报文，用户会看到一份
+ * 「比我配的还少」的清单，等于给错答案。
+ *
+ * 因此：configured（`~/.claude/settings.json` 的 env，cc-switch 等工具写入的**最终生效**
+ * 配置）+ account-live（服务端报文）取并集，逐项标注来源；configured 排在前面。
+ *
+ * 且 configured **不依赖探测成功** —— 端点若根本不支持 400 技巧（如某些代理对任何
+ * 模型都先校验 session），我们仍能把用户配置的模型给出来，而不是返回空。
+ */
 async function listAccountModels(env, opts) {
   const o = opts || {}
-  const key = 'claude:' + candidateKey(env, o.binPath)
+  const key = modelsCacheKey(env, o.binPath)
   if (o.refresh) modelsCache.delete(key)
   const probe = await cachedModels(key, () => probeSupportedModels(env, o))
   const cfg = readConfiguredModels(env)
   const configured = cfg.models || []
-  if (!probe.ok) {
+
+  // 大小写不敏感 + 忽略 [1m]/[1M] 这类后缀后做去重键，避免同一模型重复占两行。
+  const dk = (id) => String(id).trim().toLowerCase().replace(/\[[^\]]*\]$/, '')
+  const seen = new Set()
+  const models = []
+  for (const m of configured) {
+    const k = dk(m.id)
+    if (seen.has(k)) continue
+    seen.add(k)
+    models.push({ id: m.id, source: 'configured', configuredAs: m.key })
+  }
+  const probeIds = probe && probe.ok ? (probe.ids || []) : []
+  for (const id of probeIds) {
+    const k = dk(id)
+    if (seen.has(k)) continue
+    seen.add(k)
+    models.push({ id, source: 'account-live', configuredAs: null })
+  }
+
+  if (!models.length) {
     return {
-      ok: false,
-      source: 'account-live',
-      models: [],
-      count: 0,
-      error: String(probe.error || 'probe failed'),
-      diagnostic: {
-        configured: configured,
-        settingsPath: cfg.path,
-        note: 'ANTHROPIC_*_MODEL 只是用户配置的别名映射，不是服务端可用全集；因此不作为 models 返回。'
-      }
+      ok: false, source: 'none', models: [], count: 0,
+      error: String((probe && probe.error) || 'no configured models and probe returned nothing') +
+        (cfg.error ? '；settings.json: ' + cfg.error : ''),
+      diagnostic: { configured, settingsPath: cfg.path, probeError: (probe && probe.error) || null }
     }
   }
-  const ids = probe.ids.slice()
-  const byId = new Map(configured.map((m) => [m.id, m]))
-  const byIdLoose = new Map(configured.map((m) => [String(m.id).toLowerCase().replace(/\[.*\]$/, ''), m]))
+  // source 汇总：两个来源都有效时标注合并，便于面板/工具如实显示。
+  const source = (configured.length && probeIds.length) ? 'configured+account-live'
+    : (configured.length ? 'configured' : 'account-live')
   return {
     ok: true,
-    source: 'account-live',
-    models: ids.map((id) => {
-      const hit = byId.get(id) || byIdLoose.get(String(id).toLowerCase())
-      return { id, source: 'account-live', configuredAs: hit ? hit.key : null }
-    }),
-    count: ids.length,
-    ext: { exe: probe.exe || null, mode: probe.mode },
-    diagnostic: { settingsPath: cfg.path, configured: configured }
+    source,
+    models,
+    count: models.length,
+    ext: { exe: (probe && probe.exe) || null, mode: (probe && probe.mode) || null },
+    diagnostic: {
+      settingsPath: cfg.path,
+      configured,
+      probeError: (probe && !probe.ok) ? String(probe.error || 'probe failed') : null
+    }
   }
 }