dsh-commandcode-quota 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-commandcode-quota",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Command Code balance and quota panel for DeepSeek Harness: a status row under the composer showing balance and the 5-hour, weekly and monthly windows.",
   "type": "module",
   "license": "MIT",
@@ -19,6 +19,7 @@
     "src/",
     "locale/",
     "test/",
+    "scripts/",
     "cordis.patch.yml",
     "README.md",
     "README.zh.md",
@@ -35,7 +36,8 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "test": "node test/host.test.cjs && node test/client.test.cjs"
+    "test": "node test/host.test.cjs && node test/client.test.cjs",
+    "version": "node scripts/sync-version.cjs && git add src/index.js"
   },
   "repository": {
     "type": "git",
@@ -49,7 +51,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-credentials": "*"
+    "@deepseek-ai/dsh-credentials": ">=0.1.0-0 <0.2.0-0 || >=0.2.0-0 <0.3.0-0 || >=0.3.0-0 <0.4.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-credentials": {
@@ -57,6 +59,9 @@
     }
   },
   "dsh": {
+    "engines": {
+      "dsh": ">=0.2.0-rc.2"
+    },
     "bundle": {
       "patch": "./cordis.patch.yml"
     },

package/scripts/sync-version.cjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// 把 package.json 的版本同步进 src/index.js 的 user-agent 行。
+//
+// 由 npm 的 "version" 生命周期脚本调用。该钩子的执行时机是：
+// package.json 的 version 已更新，但改动尚未 commit —— 所以这里改完文件后
+// 再 git add，就能和版本号进入同一个 commit。
+//
+// 手动执行也可以：node scripts/sync-version.cjs
+const fs = require("node:fs");
+const path = require("node:path");
+
+const root = path.resolve(__dirname, "..");
+const manifest = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+const target = path.join(root, "src", "index.js");
+const source = fs.readFileSync(target, "utf8");
+
+const USER_AGENT = /("user-agent":\s*")[^"]*(")/;
+const wanted = `${manifest.name}/${manifest.version}`;
+
+if (!USER_AGENT.test(source)) {
+  console.error(`[sync-version] src/index.js 里找不到 user-agent 行，无法同步到 ${wanted}`);
+  process.exit(1);
+}
+
+const next = source.replace(USER_AGENT, `$1${wanted}$2`);
+
+if (next === source) {
+  console.log(`[sync-version] user-agent 已是 ${wanted}，无需修改`);
+  process.exit(0);
+}
+
+fs.writeFileSync(target, next);
+console.log(`[sync-version] user-agent 已更新为 ${wanted}`);

package/src/client.js

@@ -17,6 +17,7 @@ window.__ModuleLoader__.load({
     const { useCallback, useEffect, useState, useRef } = React;
 
     const FETCH_URL = "/__dsh-commandcode-quota/dashboard";
+    const CREDENTIALS_URL = "/__dsh-commandcode-quota/credentials";
     // 每 3 分钟后台自动刷新一次余额(面板开/关都刷新, 打开时看到的就是最新数据)
     const REFRESH_MS = 3 * 60 * 1000;
 
@@ -306,6 +307,63 @@ window.__ModuleLoader__.load({
           `剩余 ${fmtCurrency(remaining)} · 重置 ${fmtDuration(resetAt)}${fmtResetDay(resetAt)}`));
     }
 
+    // ---- 凭据条目选择 ------------------------------------------------------------
+    //
+    // 这个选择器在整个面板里【恒定渲染】—— 加载中、报错、甚至完全没数据时都在。
+    // 因为「一个 key 都没配」正是最需要它的时刻：用户在这里选一个已有条目即可，
+    // 不必去手改 profile patch。
+
+    function CredentialPicker({ state, onPick }) {
+      const safe = state || {};
+      const raw = Array.isArray(safe.entries) ? safe.entries : [];
+      // entries 是 [{ ref, provider }]；同时容忍纯字符串（宿主端读不到供应商时）
+      const entries = raw
+        .map((e) => (typeof e === "string" ? { ref: e, provider: null } : e))
+        .filter((e) => e && typeof e.ref === "string" && e.ref.length > 0);
+      const current = safe.apiKeyEnv ?? null;
+      // 当前值可能不在候选里（配置指向了尚未添加的条目），补一项，避免下拉显示空白
+      const options = current && !entries.some((e) => e.ref === current)
+        ? [{ ref: current, provider: null }, ...entries]
+        : entries;
+      // 能对上模型供应商时显示「供应商（条目名）」，否则只显示条目名
+      const labelOf = (e) => (e.provider ? `${e.provider}（${e.ref}）` : e.ref);
+
+      return React.createElement("div", {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          padding: "9px 16px",
+          borderBottom: `1px solid ${T.borderL}`,
+          fontSize: 11.5,
+          color: T.label3,
+        },
+      },
+        React.createElement("span", { style: { whiteSpace: "nowrap" } }, "凭据条目"),
+        React.createElement("select", {
+          value: current ?? "",
+          disabled: Boolean(safe.saving),
+          title: "选择用哪条凭据查询额度",
+          onChange: (event) => onPick(event.target.value),
+          style: {
+            flex: 1,
+            minWidth: 0,
+            padding: "4px 6px",
+            fontSize: 11.5,
+            fontFamily: "inherit",
+            color: T.label2,
+            background: T.bg2,
+            border: `1px solid ${T.border}`,
+            borderRadius: 8,
+            cursor: safe.saving ? "default" : "pointer",
+          },
+        },
+          React.createElement("option", { value: "" }, "（未设置）"),
+          options.map((e) => React.createElement("option", { key: e.ref, value: e.ref }, labelOf(e)))),
+        safe.saving ? React.createElement("span", null, "…") : null,
+        safe.error ? React.createElement("span", { style: { color: T.error } }, safe.error) : null);
+    }
+
     // ---- 面板内容 ----------------------------------------------------------------
 
     function DashboardBody({ data, loading, error }) {
@@ -496,6 +554,8 @@ window.__ModuleLoader__.load({
       const [loading, setLoading] = useState(false);
       const [error, setError] = useState(null);
       const timerRef = useRef(null);
+      // 凭据条目：与 data / error 完全解耦 —— 这样面板报「没配 key」时依然能切换
+      const [creds, setCreds] = useState({ entries: [], apiKeyEnv: null, saving: false, error: null });
 
       const refresh = useCallback(async () => {
         const fullUrl = FETCH_URL;
@@ -526,12 +586,46 @@ window.__ModuleLoader__.load({
         }
       }, []);
 
+      const loadCredentials = useCallback(async () => {
+        try {
+          const res = await fetch(CREDENTIALS_URL, { cache: "no-store" });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          const body = await res.json();
+          setCreds((prev) => ({
+            ...prev,
+            entries: Array.isArray(body.entries) ? body.entries : [],
+            apiKeyEnv: body.apiKeyEnv ?? null,
+            error: null,
+          }));
+        } catch (reason) {
+          setCreds((prev) => ({ ...prev, error: String(reason) }));
+        }
+      }, []);
+
+      const pickCredential = useCallback(async (name) => {
+        setCreds((prev) => ({ ...prev, saving: true, error: null }));
+        try {
+          const res = await fetch(CREDENTIALS_URL, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ apiKeyEnv: name || null }),
+          });
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+          const body = await res.json();
+          setCreds((prev) => ({ ...prev, apiKeyEnv: body.apiKeyEnv ?? null, saving: false }));
+          await refresh(); // 换完立刻按新条目重新查一次
+        } catch (reason) {
+          setCreds((prev) => ({ ...prev, saving: false, error: String(reason) }));
+        }
+      }, [refresh]);
+
       useEffect(() => {
+        loadCredentials();
         refresh();
         // 每 3 分钟自动查询一次余额(面板打开时也刷新)
         timerRef.current = setInterval(() => refresh(), REFRESH_MS);
         return () => { if (timerRef.current) clearInterval(timerRef.current); };
-      }, [refresh]);
+      }, [loadCredentials, refresh]);
 
       function pctOf(win) {
         if (!win || typeof win.used !== "number" || typeof win.cap !== "number" || win.cap <= 0) return null;
@@ -642,6 +736,7 @@ window.__ModuleLoader__.load({
                 onMouseEnter: (e) => Object.assign(e.currentTarget.style, iconBtnHover),
                 onMouseLeave: (e) => { e.currentTarget.style.background = "transparent"; e.currentTarget.style.color = T.label3; },
               }, React.createElement(IconClose)))),
+          React.createElement(CredentialPicker, { state: creds, onPick: pickCredential }),
           React.createElement(DashboardBody, { data, loading, error })) : null);
     }
 

package/src/index.js

@@ -4,8 +4,10 @@
  * 通过 Command Code 官方 API 读取余额与限额数据, 在 DSH Web 界面提供
  * 一个与 OpenCode 余额查询类似的单账号仪表盘。
  *
- *   GET /__dsh-commandcode-quota/dashboard              → 余额 + 限额 + 用量
- *   GET /__dsh-commandcode-quota/dashboard?scope=quick  → 余额优先，其余字段用缓存回填
+ *   GET  /__dsh-commandcode-quota/dashboard              → 余额 + 限额 + 用量
+ *   GET  /__dsh-commandcode-quota/dashboard?scope=quick  → 余额优先，其余字段用缓存回填
+ *   GET  /__dsh-commandcode-quota/credentials            → 候选凭据条目名 + 当前选择
+ *   POST /__dsh-commandcode-quota/credentials            → 保存选择的凭据条目名
  *
  * 数据源 (均为 Authorization: Bearer <key> 的 GET 请求):
  *   GET {base}/alpha/billing/credits        余额 & 窗口限额
@@ -23,6 +25,9 @@
  * ESM module format (cordis bundle rule): named exports apply/inject/name.
  */
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 
 const name = "dsh-commandcode-quota";
 const inject = ["credentials"];
@@ -67,7 +72,7 @@ async function ccFetch(baseURL, path, apiKey, timeoutMs) {
       headers: {
         authorization: `Bearer ${apiKey}`,
         accept: "application/json",
-        "user-agent": "dsh-commandcode-quota/0.2.0"
+        "user-agent": "dsh-commandcode-quota/0.2.2"
       },
       signal: controller.signal
     });
@@ -249,14 +254,159 @@ async function resolveAccountOptions(ctx, account) {
   };
 }
 
+// --- 凭据条目选择（面板里可切换）----------------------------------------------
+//
+// 两个约束决定了这里的写法：
+//   1. ctx.credentials 只有 resolve/describe/set/unset，没有「列出条目」的能力，
+//      所以候选列表只能自己从 .credentials.yaml 里取 —— 且【只取键名，绝不读值】。
+//   2. 选择要持久化才能跨重启生效；写进 $DSH_HOME 下的一个小 JSON，优先级高于
+//      profile patch 里的 apiKeyEnv（面板里的选择是最新意图）。
+
+/** 合法凭据条目名：POSIX shell 标识符，与 dsh-credentials 的 REF_PATTERN 一致。 */
+const REF_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function dshHome() {
+  const fromEnv = process.env.DSH_HOME;
+  return typeof fromEnv === "string" && fromEnv.length > 0 ? fromEnv : join(homedir(), ".dsh");
+}
+
+function choiceFile() {
+  return join(dshHome(), "dsh-commandcode-quota.json");
+}
+
+/** 面板里保存过的选择；没有或损坏时返回全 null（回落到 patch 配置）。 */
+function readChoice() {
+  try {
+    const parsed = JSON.parse(readFileSync(choiceFile(), "utf8"));
+    const pick = (v) => (typeof v === "string" && REF_PATTERN.test(v) ? v : null);
+    return { apiKeyEnv: pick(parsed?.apiKeyEnv), fallbackEnv: pick(parsed?.fallbackEnv) };
+  } catch {
+    return { apiKeyEnv: null, fallbackEnv: null };
+  }
+}
+
+function writeChoice(choice) {
+  const file = choiceFile();
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(choice, null, 2) + "\n", "utf8");
+}
+
+/**
+ * 列出 .credentials.yaml 里 refs: 段下的条目名。
+ * 只解析键、跳过一切值 —— 返回的是名字，不是密钥。
+ */
+function readCredentialEntries() {
+  let text;
+  try {
+    text = readFileSync(join(dshHome(), ".credentials.yaml"), "utf8");
+  } catch {
+    return [];
+  }
+  const names = [];
+  let inRefs = false;
+  let indent = -1;
+  for (const line of text.split(/\r?\n/)) {
+    if (/^refs:\s*$/.test(line)) { inRefs = true; continue; }
+    if (!inRefs) continue;
+    if (line.trim().length === 0) continue;
+    const m = line.match(/^(\s+)([A-Za-z_][A-Za-z0-9_]*):/);
+    if (!m) {
+      if (/^\S/.test(line)) break; // 回到顶层键，refs 段结束
+      continue;
+    }
+    if (indent < 0) indent = m[1].length;
+    if (m[1].length === indent) names.push(m[2]);
+  }
+  return names;
+}
+
+/** 读取请求体（上限 8KB，够放两个条目名）。 */
+function readBody(req, limit = 8192) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+      if (body.length > limit) {
+        reject(new Error("请求体过大"));
+        req.destroy?.();
+      }
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+
 // --- plugin ------------------------------------------------------------------
 
+/**
+ * 挑出要展示的凭据条目。
+ *
+ * 口径：对不上模型供应商的条目说明没在用它，不必占位置。
+ * 但如果一个都对不上（凭据库还没和任何 provider 关联），就退回全部 ——
+ * 否则下拉是空的，反而没法选。
+ */
+function pickEntries(refs, labels) {
+  const all = refs.map((ref) => ({ ref, provider: labels[ref] ?? null }));
+  const matched = all.filter((entry) => entry.provider);
+  return matched.length > 0 ? matched : all;
+}
+
+/**
+ * 凭据条目名 → 模型供应商显示名。
+ *
+ * 这层对应本来就存在于模型配置里（provider.apiKeyEnv 指向条目名），所以读
+ * llm-pi-ai 的 providers 就能把 "COMMANDCODE2_API_KEY" 翻译成用户在模型设置页
+ * 看到的 "commandcode2"。读不到就返回空表，调用方回落到只显示条目名。
+ *
+ * 用 ctx.get("settings") 而不是 inject —— 读不到时降级即可，
+ * 不必因为缺少这个服务就让整个插件不激活。
+ */
+function readProviderLabels(ctx) {
+  // 只能用 ctx.get：cordis 里访问未注入的服务属性（ctx.settings）会直接抛异常，
+  // 而这里的原则是「读不到就降级」，不该让整个端点跟着失败。
+  if (typeof ctx.get !== "function") return {};
+  let service;
+  try {
+    service = ctx.get("settings");
+  } catch {
+    return {};
+  }
+  if (typeof service?.describe !== "function") return {};
+  let rows;
+  try {
+    rows = service.describe();
+  } catch {
+    return {};
+  }
+  const row = (Array.isArray(rows) ? rows : []).find((r) => r?.ns === "llm-pi-ai");
+  const providers = row?.user?.providers;
+  if (!providers || typeof providers !== "object") return {};
+  const labels = {};
+  for (const [id, cfg] of Object.entries(providers)) {
+    const ref = cfg?.apiKeyEnv;
+    if (typeof ref !== "string" || ref.length === 0) continue;
+    const label = typeof cfg?.displayName === "string" && cfg.displayName.length > 0 ? cfg.displayName : id;
+    if (!(ref in labels)) labels[ref] = label;
+  }
+  return labels;
+}
+
 function apply(ctx, config) {
-  const account = normalizeAccount(config);
+  const base = normalizeAccount(config);
   const timeoutMs = Number.isFinite(config?.timeoutMs) && config.timeoutMs > 0
     ? config.timeoutMs
     : DEFAULT_TIMEOUT_MS;
 
+  // 每次请求重新算：面板里刚改过选择就立刻生效，不必重载插件。
+  function currentAccount() {
+    const saved = readChoice();
+    return {
+      ...base,
+      apiKeyEnv: saved.apiKeyEnv ?? base.apiKeyEnv,
+      fallbackEnv: saved.fallbackEnv ?? base.fallbackEnv
+    };
+  }
+
   function registerHttp(host, targetCtx) {
     targetCtx.effect(() => host.register({
       kind: "exact",
@@ -271,13 +421,13 @@ function apply(ctx, config) {
           // scope=quick: 只查响应快的 credits, 用量/订阅用缓存回填 (客户端先渲染再补全)
           const scope = readQuery(req, "scope");
 
-          const options = await resolveAccountOptions(ctx, account);
+          const options = await resolveAccountOptions(ctx, currentAccount());
           const meta = { ok: true };
           if (options.apiKey.length === 0) {
             sendJson(res, 200, {
               ...meta,
               ok: false,
-              error: `未配置 API key (尝试过: ${options.triedEnvs.join(", ") || "无"}); 请在 ~/.dsh/.credentials.yaml 中配置`,
+              error: `未配置 API key (尝试过: ${options.triedEnvs.join(", ") || "无"})。用面板上方的「凭据条目」选一个已有条目，或在 DSH 设置 → 凭据里添加`,
               keyConfigured: false
             });
             return;
@@ -293,6 +443,49 @@ function apply(ctx, config) {
         }
       }
     }));
+
+    // 凭据条目：GET 列出候选 + 当前选择；POST 保存选择。
+    // 无论如何都可用 —— 面板没配 key 时正是最需要它的时候。
+    targetCtx.effect(() => host.register({
+      kind: "exact",
+      path: "/__dsh-commandcode-quota/credentials",
+      handler: async (req, res) => {
+        if (req.method === "GET") {
+          const account = currentAccount();
+          const labels = readProviderLabels(ctx);
+          sendJson(res, 200, {
+            ok: true,
+            // 只列能对上模型供应商的条目（口径见 pickEntries）
+            entries: pickEntries(readCredentialEntries(), labels),
+            apiKeyEnv: account.apiKeyEnv,
+            fallbackEnv: account.fallbackEnv,
+            chosen: readChoice()
+          });
+          return;
+        }
+        if (req.method === "POST") {
+          try {
+            const parsed = JSON.parse((await readBody(req)) || "{}");
+            const next = { apiKeyEnv: null, fallbackEnv: null };
+            for (const key of ["apiKeyEnv", "fallbackEnv"]) {
+              const value = parsed?.[key];
+              if (value === null || value === undefined || value === "") continue;
+              if (typeof value !== "string" || !REF_PATTERN.test(value)) {
+                sendJson(res, 400, { ok: false, error: `凭据条目名不合法: ${JSON.stringify(value)}` });
+                return;
+              }
+              next[key] = value;
+            }
+            writeChoice(next);
+            sendJson(res, 200, { ok: true, ...next });
+          } catch (error) {
+            sendJson(res, 400, { ok: false, error: `保存失败: ${String(error)}` });
+          }
+          return;
+        }
+        sendJson(res, 405, { error: "method not allowed" });
+      }
+    }));
   }
 
   const ws = ctx.get("webServer");

package/test/client.test.cjs

@@ -13,9 +13,9 @@ const fixture = {
   // 月度窗口的重置时间取自订阅周期末，是 ISO 字符串而非毫秒数
   subscription: { status: "active", currentPeriodEnd: new Date(Date.now() + 20 * 86400000).toISOString() },
 };
-function mount({ open = true, data = fixture, failed = false } = {}) {
+function mount({ open = true, data = fixture, failed = false, creds = null } = {}) {
   let registration, component, slot, stateIndex = 0;
-  const values = [open, data, false, null];
+  const values = [open, data, false, null, creds || { entries: [], apiKeyEnv: null, saving: false, error: null }];
   const updates = [], callbacks = [], effects = [], requests = [], timers = [];
   const React = {
     Fragment: "fragment",
@@ -62,7 +62,7 @@ async function main() {
   const view = mount();
   const buttons = view.nodes.filter(node => node.type === "button");
   assert.equal(buttons.length, 3, "只保留状态栏、刷新和关闭按钮，不应存在账号切换按钮");
-  assert.equal(view.stateIndex, 4, "不再维护选中账号状态");
+  assert.equal(view.stateIndex, 5, "状态：面板开合 / 数据 / 加载 / 错误 / 凭据条目");
   assert.equal(view.callbacks[0].deps.length, 0);
   for (const label of ["5h 10%", "周 20%", "月 30%", "$70.00", "5 小时窗口", "每周窗口", "每月窗口"]) {
     assert.ok(view.texts.includes(label), `保留额度展示：${label}`);
@@ -76,9 +76,67 @@ async function main() {
     `月度应显示天级倒计时与到期日，实际：${resetTexts.join(" | ")}`,
   );
   await buttons.find(node => node.props.title === "刷新").props.onClick();
-  assert.deepEqual(view.requests.map(req => req.url), ["/__dsh-commandcode-quota/dashboard?scope=quick", "/__dsh-commandcode-quota/dashboard"]);
+  assert.deepEqual(view.requests.filter((r) => r.url.includes("/dashboard")).map((r) => r.url), [
+    "/__dsh-commandcode-quota/dashboard?scope=quick",
+    "/__dsh-commandcode-quota/dashboard",
+  ]);
   assert.ok(view.requests.every(req => req.options.cache === "no-store"));
   assert.ok(!view.updates.some(update => update.index > 3));
+
+  // 这个 mock 的 useEffect 只记录不执行，所以在这里手动触发挂载逻辑：
+  // 挂载时必须顺带拉一次凭据条目，下拉才会有候选
+  view.effects[0]();
+  assert.ok(
+    view.requests.some((r) => r.url === "/__dsh-commandcode-quota/credentials"),
+    "挂载时应拉取凭据条目列表",
+  );
+
+  // 凭据条目下拉存在的意义就是「没配 key 时也能选」，所以每种面板状态都必须能看到它
+  const pickerState = {
+    entries: [
+      { ref: "BAILIAN_API_KEY", provider: "bailian" },
+      { ref: "COMMANDCODE2_API_KEY", provider: "commandcode2" },
+      { ref: "CC_ACCOUNT2_API_KEY", provider: null },
+    ],
+    apiKeyEnv: "COMMANDCODE2_API_KEY",
+    saving: false,
+    error: null,
+  };
+  for (const [label, options] of [
+    ["正常态", {}],
+    ["报错态", { failed: true }],
+    ["无数据态", { data: null }],
+  ]) {
+    const view2 = mount({ ...options, creds: pickerState });
+    const selects = view2.nodes.filter((n) => n.type === "select");
+    assert.equal(selects.length, 1, `${label}下应能看到凭据条目下拉`);
+    const opts = view2.nodes.filter((n) => n.type === "option");
+    assert.deepEqual(
+      opts.map((o) => o.props.value),
+      ["", "BAILIAN_API_KEY", "COMMANDCODE2_API_KEY", "CC_ACCOUNT2_API_KEY"],
+      `${label}下的候选项不正确`,
+    );
+    // 能对上模型供应商的显示「供应商（条目名）」，对不上的只显示条目名
+    assert.deepEqual(opts.map((o) => o.children[0]), [
+      "（未设置）",
+      "bailian（BAILIAN_API_KEY）",
+      "commandcode2（COMMANDCODE2_API_KEY）",
+      "CC_ACCOUNT2_API_KEY",
+    ], `${label}下的显示文案不正确`);
+    assert.equal(selects[0].props.value, "COMMANDCODE2_API_KEY", `${label}下应选中当前条目`);
+  }
+  // 宿主端读不到供应商时会退化成纯字符串数组，也必须照常工作
+  const plain = mount({ creds: { entries: ["BAILIAN_API_KEY"], apiKeyEnv: null, saving: false, error: null } });
+  assert.deepEqual(
+    plain.nodes.filter((n) => n.type === "option").map((o) => o.children[0]),
+    ["（未设置）", "BAILIAN_API_KEY"],
+  );
+  // 配置指向一个尚未添加的条目时也要出现在候选里，否则下拉会显示成空白
+  const orphan = mount({ creds: { entries: [{ ref: "OTHER_KEY", provider: null }], apiKeyEnv: "MISSING_KEY", saving: false, error: null } });
+  assert.deepEqual(
+    orphan.nodes.filter((n) => n.type === "option").map((o) => o.props.value),
+    ["", "MISSING_KEY", "OTHER_KEY"],
+  );
   const timerView = mount({ open: false, data: null });
   assert.equal(timerView.nodes.filter(node => node.type === "button").length, 1);
   const cleanup = timerView.effects[0]();

package/test/host.test.cjs

@@ -3,9 +3,23 @@ const fs = require("node:fs");
 const vm = require("node:vm");
 const assert = require("node:assert/strict");
 const { createHash } = require("node:crypto");
-const { join } = require("node:path");
+const { join, dirname } = require("node:path");
+const { tmpdir } = require("node:os");
 const plugin = join(__dirname, "..");
 const source = fs.readFileSync(join(plugin, "src/index.js"), "utf8");
+
+// 完全隔离的 DSH_HOME：保存凭据选择会写配置，绝不能落到真实的 ~/.dsh。
+const fakeHome = fs.mkdtempSync(join(tmpdir(), "dsh-quota-test-"));
+fs.writeFileSync(join(fakeHome, ".credentials.yaml"), [
+  "version: 1",
+  "refs:",
+  "  PRIMARY_TEST_KEY: fixture-primary-value",
+  "  FALLBACK_TEST_KEY: fixture-fallback-value",
+  "records: {}",
+  "",
+].join("\n"));
+process.on("exit", () => { try { fs.rmSync(fakeHome, { recursive: true, force: true }); } catch { /* 清理失败不影响测试结论 */ } });
+
 const responses = {
   "/alpha/billing/credits": { credits: { monthlyCredits: 70 }, windowLimits: { fiveHour: { used: 10, cap: 100 } } },
   "/alpha/usage/summary": { totalMonthlyCredits: 30, totalTokens: 100, totalCost: 5, successRate: 98 },
@@ -17,6 +31,13 @@ function load() {
   let reply = async (url) => ({ ok: true, status: 200, json: async () => responses[new URL(url).pathname] });
   const context = vm.createContext({
     Buffer, URL, AbortController, setTimeout, clearTimeout, createHash,
+    // 源码的 import 会被剥掉，所以这里用到的 node 内置必须显式注入
+    readFileSync: fs.readFileSync,
+    writeFileSync: fs.writeFileSync,
+    mkdirSync: fs.mkdirSync,
+    join, dirname,
+    homedir: () => fakeHome,
+    process: { env: { DSH_HOME: fakeHome } },
     credentialRef: (ref) => ref,
     fetch: async (url, options) => { requests.push({ url, options }); return reply(url, options); },
   });
@@ -24,13 +45,27 @@ function load() {
     "\nglobalThis.host = { apply, fetchDashboard, inject, name };", context);
   return { host: context.host, requests, respond(fn) { reply = fn; } };
 }
-function mount(runtime, config = {}, keys = {}, lazy = false) {
-  let route;
+const DASHBOARD = "/__dsh-commandcode-quota/dashboard";
+const CREDS = "/__dsh-commandcode-quota/credentials";
+
+function mount(runtime, config = {}, keys = {}, lazy = false, settings = undefined) {
+  const routes = new Map();
   const refs = [];
-  const web = { register(row) { route = row; return () => {}; } };
+  const web = { register(row) { routes.set(row.path, row); return () => {}; } };
   const credentials = { async resolve(ref) { refs.push(ref); return { value: keys[ref] ?? "" }; } };
   const ctx = {
-    get(name) { return name === "credentials" ? credentials : name === "webServer" && !lazy ? web : undefined; },
+    get(name) {
+      if (name === "credentials") return credentials;
+      if (name === "settings") return settings;
+      if (name === "webServer") return lazy ? undefined : web;
+      return undefined;
+    },
+    // 真实 cordis 里访问未注入的服务属性会【抛异常】而不是返回 undefined。
+    // 这条 getter 守住它：代码必须走 ctx.get 并降级，
+    // 否则凭据端点会整个 400（曾经真的这么挂过一次）。
+    get settings() {
+      throw new Error("service settings is not injected");
+    },
     effect(fn) { return fn(); },
     inject(names, fn) { assert.deepEqual(Array.from(names), ["webServer"]); fn({ webServer: web, effect: ctx.effect }); },
     logger: { info() {} },
@@ -38,19 +73,41 @@ function mount(runtime, config = {}, keys = {}, lazy = false) {
   runtime.host.apply(ctx, config);
   assert.equal(runtime.host.name, "dsh-commandcode-quota");
   assert.deepEqual(Array.from(runtime.host.inject), ["credentials"]);
-  assert.equal(route.kind, "exact");
-  assert.equal(route.path, "/__dsh-commandcode-quota/dashboard");
+
+  const dashboard = routes.get(DASHBOARD);
+  assert.ok(dashboard, "必须注册 dashboard 端点");
+  assert.equal(dashboard.kind, "exact");
+  const creds = routes.get(CREDS);
+  assert.ok(creds, "必须注册 credentials 端点");
+  assert.equal(creds.kind, "exact");
+
+  async function invoke(handler, method, url, payload) {
+    let status, headers, raw;
+    const listeners = {};
+    const req = {
+      method,
+      url,
+      on(event, fn) { (listeners[event] = listeners[event] || []).push(fn); return req; },
+      destroy() {},
+    };
+    const pending = handler(req, {
+      writeHead(code, values) { status = code; headers = values; },
+      end(body) { raw = body; },
+    });
+    if (payload !== undefined) {
+      for (const fn of listeners.data || []) fn(JSON.stringify(payload));
+      for (const fn of listeners.end || []) fn();
+    }
+    await pending;
+    assert.equal(headers["cache-control"], "no-store");
+    assert.equal(headers["content-length"], Buffer.byteLength(raw));
+    return { status, body: JSON.parse(raw), raw };
+  }
+
   return {
     refs,
-    async request(url = route.path, method = "GET") {
-      let status, headers, raw;
-      await route.handler({ method, url }, {
-        writeHead(code, values) { status = code; headers = values; },
-        end(body) { raw = body; },
-      });
-      assert.equal(headers["cache-control"], "no-store");
-      assert.equal(headers["content-length"], Buffer.byteLength(raw));
-      return { status, body: JSON.parse(raw), raw };
+    request(url = DASHBOARD, method = "GET", payload) {
+      return invoke(url.includes("/credentials") ? creds.handler : dashboard.handler, method, url, payload);
     },
   };
 }
@@ -73,7 +130,7 @@ async function main() {
   assert.ok(runtime.requests.every(req => req.options.headers.authorization === "Bearer fixture-primary"));
   assert.deepEqual(app.refs, ["PRIMARY_TEST_KEY"]);
   runtime.requests.length = 0;
-  const quick = await app.request("/__dsh-commandcode-quota/dashboard?scope=quick");
+  const quick = await app.request(DASHBOARD + "?scope=quick");
   assert.equal(runtime.requests.length, 1);
   assert.equal(new URL(runtime.requests[0].url).pathname, "/alpha/billing/credits");
   assert.equal(quick.body.usage.totalMonthlyCredits, 30);
@@ -92,7 +149,7 @@ async function main() {
   assert.equal(runtime.requests.length, 0);
   const fallbackRuntime = load();
   const fallback = mount(fallbackRuntime, config, { FALLBACK_TEST_KEY: "fixture-fallback" }, true);
-  assert.equal((await fallback.request("/__dsh-commandcode-quota/dashboard?scope=quick")).body.keyConfigured, true);
+  assert.equal((await fallback.request(DASHBOARD + "?scope=quick")).body.keyConfigured, true);
   assert.deepEqual(fallback.refs, ["PRIMARY_TEST_KEY", "FALLBACK_TEST_KEY"]);
   assert.equal(fallbackRuntime.requests[0].options.headers.authorization, "Bearer fixture-fallback");
   const emptyRuntime = load();
@@ -100,6 +157,12 @@ async function main() {
   assert.equal(missing.body.keyConfigured, false);
   assert.equal(missing.body.ok, false);
   assert.equal(emptyRuntime.requests.length, 0);
+  assert.ok(missing.body.error.includes("凭据条目"), "缺 key 的提示应指向面板里的选择器");
+  // 缺 key 时，凭据端点必须照常可用 —— 这正是用户最需要它的时候
+  const missingApp = mount(load(), config);
+  const listedWhenEmpty = await missingApp.request(CREDS);
+  assert.equal(listedWhenEmpty.status, 200, "没配 key 时凭据端点也必须可用");
+  assert.equal(listedWhenEmpty.body.apiKeyEnv, "PRIMARY_TEST_KEY");
   const defaultRuntime = load();
   assert.equal((await mount(defaultRuntime, {}, { COMMANDCODE_API_KEY: "fixture-default" }).request()).body.ok, true);
   let attempts = 0;
@@ -108,14 +171,75 @@ async function main() {
     if (++attempts === 1) throw new TypeError("模拟连接失败");
     return { status: 200, json: async () => responses[new URL(url).pathname] };
   });
-  assert.equal((await mount(retryRuntime, config, { PRIMARY_TEST_KEY: "fixture-primary" }).request("/__dsh-commandcode-quota/dashboard?scope=quick")).body.ok, true);
+  assert.equal((await mount(retryRuntime, config, { PRIMARY_TEST_KEY: "fixture-primary" }).request(DASHBOARD + "?scope=quick")).body.ok, true);
   assert.equal(attempts, 2);
   const timeoutRuntime = load();
   timeoutRuntime.respond((url, options) => new Promise((resolve, reject) => {
     options.signal.addEventListener("abort", () => reject(new Error("模拟超时")), { once: true });
   }));
-  assert.equal((await mount(timeoutRuntime, { ...config, timeoutMs: 5 }, { PRIMARY_TEST_KEY: "fixture-primary" }).request("/__dsh-commandcode-quota/dashboard?scope=quick")).body.ok, false);
+  assert.equal((await mount(timeoutRuntime, { ...config, timeoutMs: 5 }, { PRIMARY_TEST_KEY: "fixture-primary" }).request(DASHBOARD + "?scope=quick")).body.ok, false);
   assert.equal(timeoutRuntime.requests.length, 1, "主动超时不重试");
+
+  // 凭据条目端点：GET 只回条目名 + 当前选择，POST 保存选择。放在最后跑，因为保存会改变后续读取。
+  const credsApp = mount(load(), config, { PRIMARY_TEST_KEY: "fixture-primary" });
+  const listed = await credsApp.request(CREDS);
+  assert.equal(listed.status, 200);
+  assert.deepEqual(listed.body.entries, [
+    { ref: "PRIMARY_TEST_KEY", provider: null },
+    { ref: "FALLBACK_TEST_KEY", provider: null },
+  ], "一个都对不上供应商时回退显示全部，免得多拉是空的");
+  assert.equal(listed.body.apiKeyEnv, "PRIMARY_TEST_KEY");
+  for (const secret of ["fixture-primary-value", "fixture-fallback-value"]) {
+    assert.ok(!listed.raw.includes(secret), `凭据端点绝不能回值：${secret}`);
+  }
+  const saved = await credsApp.request(CREDS, "POST", { apiKeyEnv: "FALLBACK_TEST_KEY" });
+  assert.equal(saved.status, 200);
+  assert.equal(saved.body.apiKeyEnv, "FALLBACK_TEST_KEY");
+  assert.equal(
+    (await credsApp.request(CREDS, "POST", { apiKeyEnv: "not a valid ref" })).status,
+    400,
+    "非法条目名必须被拒",
+  );
+  assert.equal((await credsApp.request(CREDS, "DELETE")).status, 405);
+  // 保存过的选择要覆盖 profile patch 里的 apiKeyEnv
+  const chosenRuntime = load();
+  const chosen = mount(chosenRuntime, config, { FALLBACK_TEST_KEY: "fixture-fallback" });
+  assert.equal((await chosen.request(DASHBOARD + "?scope=quick")).body.keyConfigured, true);
+  assert.deepEqual(chosen.refs, ["FALLBACK_TEST_KEY"], "保存的选择应优先于 patch 配置");
+
+  // 供应商映射：provider.apiKeyEnv 指向条目名时，下拉显示供应商名而不是裸条目名
+  const settingsStub = {
+    describe: () => ([{
+      ns: "llm-pi-ai",
+      user: {
+        providers: {
+          commandcode2: { apiKeyEnv: "PRIMARY_TEST_KEY" },
+          cerebras: { displayName: "bailian", apiKeyEnv: "FALLBACK_TEST_KEY" },
+          noKey: { baseURL: "https://example.invalid" },
+        },
+      },
+    }]),
+  };
+  const labeled = await mount(load(), config, { PRIMARY_TEST_KEY: "x" }, false, settingsStub).request(CREDS);
+  assert.deepEqual(labeled.body.entries, [
+    { ref: "PRIMARY_TEST_KEY", provider: "commandcode2" },
+    { ref: "FALLBACK_TEST_KEY", provider: "bailian" },
+  ], "应把条目名翻译成模型设置里显示的供应商名");
+  // describe() 抛错时必须降级，而不是让整个端点失败
+  const broken = await mount(load(), config, {}, false, { describe() { throw new Error("boom"); } }).request(CREDS);
+  assert.equal(broken.status, 200, "settings 读不到时应降级而不是报错");
+  assert.deepEqual(broken.body.entries.map((e) => e.provider), [null, null]);
+  // 只有部分条目对得上时，只列出对得上的 —— 对不上的说明用户没在用它
+  const partial = await mount(load(), config, {}, false, {
+    describe: () => ([{
+      ns: "llm-pi-ai",
+      user: { providers: { cerebras: { displayName: "bailian", apiKeyEnv: "FALLBACK_TEST_KEY" } } },
+    }]),
+  }).request(CREDS);
+  assert.deepEqual(partial.body.entries, [
+    { ref: "FALLBACK_TEST_KEY", provider: "bailian" },
+  ], "只应列出对得上模型供应商的条目");
+
   // 包自检：声明、注册 id 与 bundle 补丁层三者必须一致。
   const manifest = JSON.parse(fs.readFileSync(join(plugin, "package.json"), "utf8"));
   assert.equal(manifest.name, "dsh-commandcode-quota", "package.json 的 name 必须等于宿主端导出 name");
@@ -128,7 +252,16 @@ async function main() {
   // 发版时最容易漏的一处：user-agent 里的版本号要与 package.json 同步。
   const uaVersion = source.match(/"user-agent":\s*"[^"]*\/([^"]+)"/)?.[1];
   assert.equal(uaVersion, manifest.version, "user-agent 版本必须与 package.json 的 version 一致");
+  // 官方包的 peer 范围必须带显式预发布分支。node-semver 只让「相同 major.minor.patch
+  // 元组、且自身带预发布标签」的比较符放行预发布版本，所以 '*' 和 '>=0.0.0-0' 都匹配
+  // 不到任何 0.x.0-rc.y —— 而那正是 harness 官方包的版本形态。
+  const peerRange = manifest.peerDependencies["@deepseek-ai/dsh-credentials"];
+  assert.ok(
+    typeof peerRange === "string" && /-0/.test(peerRange),
+    `官方包 peer 范围必须含显式预发布分支（当前: ${peerRange}）`,
+  );
   console.log("通过：单账号响应、主/回退凭据、完整/快速查询、缓存、401、405、重试和超时。");
+  console.log("通过：凭据端点只回条目名、翻译供应商名、保存后覆盖 patch 配置、非法名被拒、无 key 时依然可用。");
   console.log("通过：宿主端导出、路由、包名与 bundle 补丁层一致。");
 }
 main().catch(error => { console.error(error.message); process.exitCode = 1; });