dsh-armory 2.3.0 → 2.3.1

package/lib/community-meta.js

@@ -0,0 +1,222 @@
+// 社区元信息（只读）：仓库的「人味」信号——维护者、最近提交、issue 数、Star。
+//
+// 为什么单独一层：
+//   - 市场目录里的条目只带「上次核验」「发布方」这类静态字段，看不出这个项目
+//     **现在还活着吗**。GitHub 的 pushed_at / open_issues / archived 是最直接的证据。
+//   - 这些请求只应在用户真正打开某条详情时按需发生（每页 12 张卡片全量拉取会迅速
+//     耗尽未认证 GitHub 的 60 次/小时配额），所以缓存与限流处理必须在这里收口。
+//
+// 边界：
+//   - 只读公开接口，不接受 token，不写任何用户数据。
+//   - 单次最多 8 个仓库；命中 6 小时缓存不联网；有旧缓存时网络失败回落旧数据并标记 stale。
+//   - 缓存落在 ~/.dsh/armory/github-meta.json，staging + rename 原子写；测试可注入 rootDir/fetch。
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const COMMUNITY_META_VERSION = 1;
+export const COMMUNITY_META_TTL_MS = 6 * 60 * 60 * 1000;
+export const COMMUNITY_META_MAX_REPOS = 8;
+
+const GITHUB_API = "https://api.github.com/repos/";
+const USER_AGENT = "@2026heshao/dsh-armory (+https://github.com/2026heshao/dsh-armory)";
+
+/** 存储根目录：显式 rootDir > 环境变量 > 真实 ~/.dsh/armory（与 install-state 同一解析序）。 */
+function armoryRoot(options = {}) {
+  return options.rootDir || process.env.DSH_ARMORY_HOME || join(homedir(), ".dsh", "armory");
+}
+
+export function repoMetaPath(options = {}) {
+  return join(armoryRoot(options), "github-meta.json");
+}
+
+/**
+ * 从各种仓库写法里提取 `owner/repo`：
+ *   owner/repo、https://github.com/o/r、git+https://github.com/o/r.git、
+ *   git@github.com:o/r.git、带 #readme / /tree/main 尾巴的。
+ * 不是 GitHub 或提取不到返回 ""。
+ */
+export function parseGithubRepo(raw) {
+  const text = String(raw || "").trim();
+  if (!text) return "";
+  const ssh = /^git@github\.com:([^/\s]+)\/([^/\s#]+?)(?:\.git)?$/i.exec(text);
+  if (ssh) return `${ssh[1]}/${ssh[2]}`;
+  const http = /^(?:git\+)?https?:\/\/(?:www\.)?github\.com\/([^/\s#?]+)\/([^/\s#?]+)/i.exec(text);
+  if (http) return `${http[1]}/${http[2].replace(/\.git$/i, "")}`;
+  const bare = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(text);
+  if (bare) return `${bare[1]}/${bare[2].replace(/\.git$/i, "")}`;
+  return "";
+}
+
+/** 入参归一：字符串 / 数组 / {repo} 对象都收，去重、去空、最多 8 条。 */
+export function normalizeRepoList(value) {
+  const rows = Array.isArray(value) ? value : [value];
+  const seen = new Set();
+  const out = [];
+  for (const row of rows) {
+    const raw = row && typeof row === "object" ? row.repo || row.repository || "" : row;
+    const repo = parseGithubRepo(raw);
+    if (!repo) continue;
+    const key = repo.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(repo);
+    if (out.length >= COMMUNITY_META_MAX_REPOS) break;
+  }
+  return out;
+}
+
+function stringOf(value) {
+  return typeof value === "string" ? value : "";
+}
+
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+/** GitHub 原始响应 → 面板需要的窄投影（不落全量 JSON，缓存小且字段稳定）。 */
+export function projectRepoMeta(repo, data) {
+  const owner = stringOf(data?.owner?.login) || String(repo).split("/")[0] || "";
+  const full = stringOf(data?.full_name) || repo;
+  const license = data?.license && typeof data.license === "object" ? stringOf(data.license.spdx_id) : "";
+  return {
+    repo: full,
+    owner,
+    ownerAvatar: stringOf(data?.owner?.avatar_url) || (owner ? `https://github.com/${owner}.png?size=64` : ""),
+    ownerUrl: stringOf(data?.owner?.html_url) || (owner ? `https://github.com/${owner}` : ""),
+    htmlUrl: stringOf(data?.html_url) || `https://github.com/${full}`,
+    description: stringOf(data?.description),
+    stars: numberOrZero(data?.stargazers_count),
+    forks: numberOrZero(data?.forks_count),
+    openIssues: numberOrZero(data?.open_issues_count),
+    watchers: numberOrZero(data?.subscribers_count),
+    pushedAt: stringOf(data?.pushed_at),
+    updatedAt: stringOf(data?.updated_at),
+    archived: data?.archived === true,
+    disabled: data?.disabled === true,
+    license,
+    language: stringOf(data?.language),
+    homepage: stringOf(data?.homepage),
+    defaultBranch: stringOf(data?.default_branch),
+  };
+}
+
+async function readCache(options = {}) {
+  try {
+    const raw = JSON.parse(await readFile(repoMetaPath(options), "utf8"));
+    const repos = raw && typeof raw.repos === "object" && raw.repos !== null && !Array.isArray(raw.repos) ? raw.repos : {};
+    return {
+      version: raw && typeof raw.version === "number" ? raw.version : COMMUNITY_META_VERSION,
+      repos,
+      rateLimitedUntil: typeof raw?.rateLimitedUntil === "number" ? raw.rateLimitedUntil : 0,
+    };
+  } catch {
+    return { version: COMMUNITY_META_VERSION, repos: {}, rateLimitedUntil: 0 };
+  }
+}
+
+function dirnameOf(path) {
+  const cut = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return cut > 0 ? path.slice(0, cut) : path;
+}
+
+async function writeCache(cache, options = {}) {
+  const path = repoMetaPath(options);
+  await mkdir(dirnameOf(path), { recursive: true });
+  // 唯一临时名 + rename：详情卡是逐张 fire-and-forget 调进来的，固定 `.staging` 会让
+  // 两个并发写互相踩踏（交错 fd 写出撕坏的文件再被 rename 进正位）。
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tmp, JSON.stringify(cache, null, 2));
+    await rename(tmp, path);
+  } catch (error) {
+    await rm(tmp, { force: true }).catch(() => {});
+    throw error;
+  }
+}
+
+function errorText(error) {
+  return String(error?.message || error || "读取失败").slice(0, 200);
+}
+
+function rateLimitError(resetSeconds) {
+  const minutes = Math.max(1, Math.ceil((Number(resetSeconds) * 1000 - Date.now()) / 60_000));
+  return new Error(`GitHub 接口已限流，约 ${minutes} 分钟后恢复`);
+}
+
+/**
+ * 批量读取仓库元信息。
+ *
+ * 入参：`{ repos: string[] | {repo}[] | string, refresh?: boolean }`
+ * 返回：`{ repos: { "owner/repo": { ok, ...projectRepoMeta, cached?, stale?, error? } }, fetchedAt }`
+ *
+ * 单条失败不抛整体错误：UI 需要把「这一条查不到」与「整个接口挂了」分开显示。
+ * 有旧缓存时网络失败回落到旧数据（`stale: true`），永不因为刷新失败把界面打空。
+ */
+export async function wbRepoMeta(payload = {}, options = {}) {
+  const repos = normalizeRepoList(payload?.repos ?? payload?.repo);
+  const now = Date.now();
+  if (!repos.length) return { repos: {}, fetchedAt: now };
+  const cache = await readCache(options);
+  const fetchImpl = typeof options.fetchImpl === "function" ? options.fetchImpl : fetch;
+  const results = {};
+
+  for (const repo of repos) {
+    const key = repo.toLowerCase();
+    const entry = cache.repos[key];
+    const fresh = entry && entry.data && now - Number(entry.fetchedAt || 0) < COMMUNITY_META_TTL_MS;
+    if (fresh && payload?.refresh !== true) {
+      results[repo] = { ok: true, cached: true, ...entry.data };
+      continue;
+    }
+    if (cache.rateLimitedUntil && now < cache.rateLimitedUntil) {
+      results[repo] = entry?.data
+        ? { ok: true, cached: true, stale: true, ...entry.data, error: "GitHub 接口已限流，显示的是缓存" }
+        : { ok: false, error: "GitHub 接口已限流，稍后再试" };
+      continue;
+    }
+    const headers = { "user-agent": USER_AGENT, accept: "application/vnd.github+json" };
+    if (entry?.etag) headers["if-none-match"] = entry.etag;
+    try {
+      const response = await fetchImpl(`${GITHUB_API}${repo}`, {
+        headers,
+        signal: AbortSignal.timeout(12_000),
+      });
+      const remaining = response.headers?.get?.("x-ratelimit-remaining");
+      if (response.status === 304 && entry?.data) {
+        cache.repos[key] = { ...entry, fetchedAt: now };
+        results[repo] = { ok: true, cached: true, ...entry.data };
+        continue;
+      }
+      if (response.status === 403 && remaining === "0") {
+        const reset = Number(response.headers?.get?.("x-ratelimit-reset") || 0);
+        cache.rateLimitedUntil = reset ? reset * 1000 : now + 10 * 60_000;
+        throw rateLimitError(reset);
+      }
+      if (response.status === 404) {
+        results[repo] = { ok: false, error: "仓库不存在或已删除" };
+        continue;
+      }
+      if (!response.ok) throw new Error(`GitHub 返回 HTTP ${response.status}`);
+      const data = projectRepoMeta(repo, await response.json());
+      cache.repos[key] = {
+        fetchedAt: now,
+        etag: response.headers?.get?.("etag") || "",
+        data,
+      };
+      results[repo] = { ok: true, cached: false, ...data };
+    } catch (error) {
+      const message = errorText(error);
+      results[repo] = entry?.data
+        ? { ok: true, cached: true, stale: true, ...entry.data, error: message }
+        : { ok: false, error: message };
+    }
+  }
+
+  try {
+    await writeCache(cache, options);
+  } catch {
+    // 缓存写失败不影响本次结果；下次只是多打一次网络。
+  }
+  return { repos: results, fetchedAt: now };
+}

package/lib/expert-market.js

@@ -44,9 +44,17 @@ const EXPERT_ROW_PREFIX = "preset-wbexpert-";
 const EXPERT_PRESET_PREFIX = "wbexpert-";
 const EXPERT_SKILL_PREFIX = "wbexpert__";
 const JS_TAG = "tag:yaml.org,2002:js";
+// 召唤预设行 config.name 的固定前缀：宿主的会话头预设标签显示的就是整串
+// 「WorkBuddy 专家 · 吴八哥」。写侧用它拼，读侧（readExpertPresets）剥它取名，
+// 两处共用一个常量才不会拼/剥漂移。与 client.js 的 EXPERT_PRESET_LABEL_PREFIX
+// 必须逐字相同（那份是匹配宿主标签用的，同样不参与翻译）。
+const EXPERT_PRESET_NAME_PREFIX = "WorkBuddy 专家 · ";
 
 function cacheDir() {
-  return join(homedir(), ".dsh", "wb-market", "experts");
+  // 测试隔离口（惯例同 wb-registry 的 DSH_ARMORY_HOME）：设置时整个 wb-market 缓存根
+  // 指到临时目录，本目录 = <根>/experts；不设置走真实 ~/.dsh。
+  const root = process.env.DSH_ARMORY_MARKET_HOME || join(homedir(), ".dsh", "wb-market");
+  return join(root, "experts");
 }
 function manifestPath() {
   return join(cacheDir(), "expert_center.json");
@@ -103,6 +111,17 @@ async function fetchText(url) {
 // ── 专家目录：下载 + ETag 缓存 ─────────────────────────────────────────
 // 与连接器 ZIP 同一模式：meta.json 记 ETag，命中即用磁盘缓存；网络挂了继续用旧的。
 let cachedManifest = null; // { manifest, loadedFrom: "memory" | "disk" | "network" }
+/** 缓存正文用临时文件 + rename 落盘：写一半被杀只会留下无人读的 .tmp，不会留下截断的清单。 */
+async function writeCacheFile(path, data) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tmp, data);
+    await rename(tmp, path);
+  } catch (error) {
+    await rm(tmp, { force: true }).catch(() => {});
+    throw error;
+  }
+}
 async function loadManifest() {
   if (cachedManifest) return cachedManifest;
   await mkdir(cacheDir(), { recursive: true });
@@ -122,35 +141,51 @@ async function loadManifest() {
     const raw = await readFile(manifestPath(), "utf8");
     const manifest = JSON.parse(raw);
     if (!manifest || !Array.isArray(manifest.experts)) throw new Error("磁盘缓存的专家清单结构无效");
-    cachedManifest = { manifest, loadedFrom: "disk" };
+    return manifest;
+  };
+  const persistNetwork = async (fresh) => {
+    // 结构校验先于一切赋值/写盘：CDN 或中间代理返回"可解析但不是清单"的 JSON 时，
+    // 不能让它覆盖掉磁盘上那份好的（校验失败按下载失败处理，走下面的回落）。
+    const manifest = JSON.parse(fresh.buffer.toString("utf8"));
+    if (!manifest || !Array.isArray(manifest.experts)) throw new Error("专家清单结构无效（缺 experts 数组）");
+    await writeCacheFile(manifestPath(), fresh.buffer);
+    await writeCacheFile(manifestMetaPath(), JSON.stringify({ etag: fresh.etag, fetchedAt: Date.now() }));
+    cachedManifest = { manifest, loadedFrom: "network" };
     return cachedManifest;
   };
-  if (meta.etag) {
-    try {
-      const manifest = await useDisk();
-      const fresh = await download(meta.etag);
-      if (fresh === null) return manifest;
-      cachedManifest = { manifest: JSON.parse(fresh.buffer.toString("utf8")), loadedFrom: "network" };
-      await writeFile(manifestPath(), fresh.buffer);
-      await writeFile(manifestMetaPath(), JSON.stringify({ etag: fresh.etag, fetchedAt: Date.now() }));
-      return cachedManifest;
-    } catch {
-      // 磁盘缓存损坏或探测失败：落到下面的全量下载；再失败就把错误抛给面板。
-    }
+  // 磁盘缓存先读好备用：它是 304（内容未变）与断网两条路的共同回落——头注承诺的
+  // 「网络挂了继续用旧的」靠它兑现。读失败（损坏/缺失）只回落到全量下载，不抛出去。
+  let diskManifest = null;
+  try {
+    diskManifest = await useDisk();
+  } catch {
+    diskManifest = null;
+  }
+  try {
+    // 只在磁盘缓存有效时才带上 etag：磁盘副本损坏/缺失而 etag 命中 304 的话，
+    // 我们手上没有任何正文可用（旧实现此时会拿着 null 去取 buffer，崩成 TypeError）。
+    const fresh = await download(diskManifest && meta.etag ? meta.etag : "");
+    if (fresh) return await persistNetwork(fresh);
+    // 304 = 服务器内容与 etag 一致 = 磁盘缓存就是权威副本。
+    cachedManifest = { manifest: diskManifest, loadedFrom: "disk" };
+    return cachedManifest;
+  } catch {
+    // 网络失败 / 响应结构无效：有磁盘缓存就回落到它，绝不因为刷新失败把面板打空。
+  }
+  if (diskManifest) {
+    cachedManifest = { manifest: diskManifest, loadedFrom: "disk" };
+    return cachedManifest;
   }
-  const fresh = await download(meta.etag || "");
-  const manifest = JSON.parse(fresh.buffer.toString("utf8"));
-  if (!manifest || !Array.isArray(manifest.experts)) throw new Error("专家清单结构无效（缺 experts 数组）");
-  cachedManifest = { manifest, loadedFrom: "network" };
-  await writeFile(manifestPath(), fresh.buffer);
-  await writeFile(manifestMetaPath(), JSON.stringify({ etag: fresh.etag, fetchedAt: Date.now() }));
-  return cachedManifest;
+  throw new Error("专家目录不可用：下载失败且本地没有有效的缓存副本");
 }
 
 // ── 目录投影 ───────────────────────────────────────────────────────────
 function bi(value) {
   return value && typeof value === "object" ? String(value.zh || value.en || "") : String(value || "");
 }
+function biEn(value) {
+  return value && typeof value === "object" ? String(value.en || value.zh || "") : String(value || "");
+}
 function biMember(value) {
   return value && typeof value === "object" ? String(value.zh || value.en || "") : String(value || "");
 }
@@ -181,17 +216,58 @@ function projectExpert(entry, categoryById) {
     name: bi(entry.displayName) || plugin,
     profession: bi(entry.profession),
     description: bi(entry.description),
+    // 清单给的人设路径是权威来源：wbExpertDetail 拿它当首选（plugin.json 拉不到时是唯一来源）。
+    promptFile: String(entry.promptFile || ""),
     categoryId: String(entry.categoryId || ""),
     categoryName: category ? bi(category.name) : String(entry.categoryId || ""),
     tags: Array.isArray(entry.tags) ? entry.tags.slice(0, 3).map(bi).filter(Boolean) : [],
     quickPrompts: Array.isArray(entry.quickPrompts) ? entry.quickPrompts.slice(0, 3).map(bi).filter(Boolean) : [],
     defaultInitPrompt: bi(entry.defaultInitPrompt),
+    createdAt: String(entry.createdAt || ""),
     updatedAt: String(entry.updatedAt || ""),
     isOPC: !!entry.isOPC,
     avatarUrl: entry.avatar ? EXPERT_ORIGIN + String(entry.avatar) : "",
   };
 }
 
+/**
+ * plugin → 专家显示名（中英两套）+ 头像地址。只读本机目录缓存，不发网络请求：
+ * 输入框快捷菜单每次打开都要用，不能为了一次取名去拉 1.1MB 目录；而能召唤专家
+ * 的前提就是目录已经落过盘，缓存缺失只可能是手工清目录，返回空表由前端回落 plugin。
+ * avatarUrl 与 projectExpert 同一拼法（EXPERT_ORIGIN + entry.avatar），已召唤页的
+ * 卡片头像不用再等整份目录——只有名字缓存在场也能出图。
+ * 按 mtime+size 记忆：同一份目录只解析一次（wbExpertInstalled 会被面板多处并发调用）；
+ * 目录刷新写盘后戳变化，下一次调用自动重读。
+ */
+let displayNamesCache = null; // { stamp, names }
+export async function readExpertDisplayNames() {
+  const path = manifestPath();
+  let stamp = "";
+  try {
+    const info = await stat(path);
+    stamp = `${info.mtimeMs}:${info.size}`;
+  } catch {
+    return new Map();
+  }
+  if (displayNamesCache && displayNamesCache.stamp === stamp) return displayNamesCache.names;
+  const manifest = await readJson(path);
+  const names = new Map();
+  if (!manifest || !Array.isArray(manifest.experts)) return names;
+  for (const entry of manifest.experts) {
+    const plugin = String(entry?.plugin || "").trim();
+    if (!plugin) continue;
+    names.set(plugin, {
+      nameZh: bi(entry.displayName),
+      nameEn: biEn(entry.displayName),
+      professionZh: bi(entry.profession),
+      professionEn: biEn(entry.profession),
+      avatarUrl: entry.avatar ? EXPERT_ORIGIN + String(entry.avatar) : "",
+    });
+  }
+  displayNamesCache = { stamp, names };
+  return names;
+}
+
 /** 专家目录 + 15 个行业分类。UI 列表唯一数据源。 */
 export async function wbExpertCatalog() {
   const { manifest, loadedFrom } = await loadManifest();
@@ -204,7 +280,17 @@ export async function wbExpertCatalog() {
     name: bi(category.name),
     description: bi(category.description),
   })).filter((category) => category.id);
-  return { loadedFrom, total: experts.length, experts, categories };
+  // 目录本身的来源信息：面板上用来说明「这些专家是谁维护的、多久更新一次」。
+  // 缺字段就给空串，不编造。
+  const author = manifest.author && typeof manifest.author === "object" ? manifest.author : {};
+  const meta = {
+    authorName: String(author.name || ""),
+    authorSource: String(author.source || ""),
+    license: String(author.license || ""),
+    version: String(manifest.version || ""),
+    lastUpdated: String(manifest.lastUpdated || ""),
+  };
+  return { loadedFrom, total: experts.length, experts, categories, meta };
 }
 
 // ── 本机 WorkBuddy 缓存：完整技能树的优先来源 ───────────────────────────
@@ -539,9 +625,19 @@ export function readExpertPresets(content) {
       const prefix = personaConfig ? personaConfig.get("prefix", true) : null;
       if (prefix && typeof prefix.value === "string") personaText = prefix.value;
     }
+    // 召唤那一刻就随预设行落盘的专家显示名：剥掉 `WorkBuddy 专家 · ` 前缀即得。
+    // 目录缓存（readExpertDisplayNames）是首选来源——它有中英两套、且随目录刷新；
+    // 但缓存没落盘、或该专家已从市场下架时只剩这一份可用。没有它，输入框召唤菜单
+    // 只能回落到英文标识名（senior-developer 这种），对中文界面就是「没翻译」。
+    // 用户在宿主里手改过预设名的，原样尊重（剥不到前缀就不剥）。
+    const presetName = String(mapValue(config, "name") || "").trim();
+    const displayName = presetName.startsWith(EXPERT_PRESET_NAME_PREFIX)
+      ? presetName.slice(EXPERT_PRESET_NAME_PREFIX.length).trim()
+      : presetName;
     rows.push({
       presetId: String(mapValue(entry, "id")),
       plugin: presetId.slice(EXPERT_PRESET_PREFIX.length),
+      displayName,
       personaText,
     });
   }
@@ -660,7 +756,7 @@ function buildExpertPresetRow(doc, spec, presetId, presetConfigId) {
   entry.set("name", PRESET_PLUGIN);
   const config = new YAMLMap();
   config.set("id", presetConfigId);
-  config.set("name", `WorkBuddy 专家 · ${spec.displayName}`);
+  config.set("name", `${EXPERT_PRESET_NAME_PREFIX}${spec.displayName}`);
   config.set("description", `${spec.displayName} · ${spec.profession} —— 来自 WorkBuddy 专家市场${spec.description ? `：${spec.description}` : ""}`);
   config.set("order", 30);
   config.set("plugins", toNode(expertPresetPlugins(spec)));