dsh-armory 1.10.0 → 2.0.0

package/lib/wb-plugin-market.js

@@ -0,0 +1,291 @@
+// CodeBuddy 插件市场（T03/R5）—— sourceFor("plugins") 的 ZIP 数据源与目录投影。
+//
+// 数据链路（与连接器市场同一套形状，缓存目录不同）：
+//   1. 源：lib/wb-registry.js sourceFor("plugins") —— 内置默认
+//      codebuddy-plugins-official（https://download.codebuddy.cn/...zip），
+//      用户注册表条目可覆盖；读不到源时抛错（不发明第二处硬编码）。
+//   2. 缓存：~/.dsh/armory/plugin-market/ 下 plugin.zip + meta.json{etag,fetchedAt}，
+//      ETag 命中就不重复下载（与 wb-market.js 的连接器缓存同构；目录挂在 armory
+//      根下而不是 ~/.dsh/wb-market/，因为这是 armory 自己引入的市场）。
+//   3. 解析（zip 内嵌套清单，实测形状）：
+//      .codebuddy-plugin/marketplace.json —— 市场索引（plugins 数组，取插件目录名）
+//      external_plugins/<name>/.codebuddy-plugin/plugin.json —— 每个插件的清单，
+//      投影 {name,description,author,repository,homepage,license,version,dependencies,lspServers}。
+//
+// 纪律：安装动作不在这里（客户端直接走官方 pluginManager.installBundle，T04 的 R8
+// 才接 wb-install-state 记账）；本文件只做「取数 + 投影」，零副作用除缓存写盘。
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ZipReader } from "./wb-zip.js";
+import { sourceFor } from "./wb-registry.js";
+
+const USER_AGENT = "@2026heshao/dsh-armory (+https://github.com/2026heshao/dsh-armory)";
+const MAX_ZIP_BYTES = 64 * 1024 * 1024;
+
+/** 缓存根目录：~/.dsh/armory/plugin-market（测试可用 options.rootDir 覆盖）。 */
+function pluginMarketDir(options = {}) {
+  return join(options.rootDir || process.env.DSH_ARMORY_HOME || join(homedir(), ".dsh", "armory"), "plugin-market");
+}
+function zipPathOf(options) {
+  return join(pluginMarketDir(options), "plugin.zip");
+}
+function metaPathOf(options) {
+  return join(pluginMarketDir(options), "meta.json");
+}
+
+async function readJsonAt(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 模块级缓存：一次进程内只解析一次 zip（与 wb-market cachedZip 同构）。 */
+let cachedPluginZip = null;
+
+async function downloadPluginZip(sourceUrl, etag) {
+  const response = await fetch(sourceUrl, {
+    headers: { "user-agent": USER_AGENT, ...(etag ? { "if-none-match": etag } : {}) },
+    signal: AbortSignal.timeout(120_000),
+  });
+  if (response.status === 304 && etag) return null;
+  if (!response.ok) throw new Error(`插件市场下载失败：HTTP ${response.status}`);
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (buffer.length > MAX_ZIP_BYTES) throw new Error(`插件市场包超过 ${Math.round(MAX_ZIP_BYTES / 1024 / 1024)}MB 上限，疑似异常响应`);
+  return { buffer, etag: response.headers.get("etag") || "" };
+}
+
+/** 下载（或复用磁盘缓存）并解析插件市场 zip。返回 { zip, loadedFrom }。 */
+async function loadPluginZip(options = {}) {
+  if (cachedPluginZip) return cachedPluginZip;
+  const source = await sourceFor("plugins", options);
+  const sourceUrl = source?.source?.url;
+  if (typeof sourceUrl !== "string" || !sourceUrl) throw new Error("注册表里没有可用的 plugins 市场源");
+  const dir = pluginMarketDir(options);
+  await mkdir(dir, { recursive: true });
+  const meta = (await readJsonAt(metaPathOf(options))) || {};
+  const writeThrough = async (fresh) => {
+    await writeFile(zipPathOf(options), fresh.buffer);
+    await writeFile(metaPathOf(options), JSON.stringify({ etag: fresh.etag, fetchedAt: Date.now() }));
+  };
+  let zip = null;
+  if (meta.etag) {
+    try {
+      const local = await readFile(zipPathOf(options));
+      zip = new ZipReader(local);
+      const fresh = await downloadPluginZip(sourceUrl, meta.etag);
+      if (fresh === null) {
+        cachedPluginZip = { zip, loadedFrom: "disk" };
+        return cachedPluginZip;
+      }
+      zip = new ZipReader(fresh.buffer);
+      await writeThrough(fresh);
+      cachedPluginZip = { zip, loadedFrom: "network" };
+      return cachedPluginZip;
+    } catch {
+      zip = null; // 磁盘缓存损坏 → 走完整重下
+    }
+  }
+  const fresh = await downloadPluginZip(sourceUrl, "");
+  zip = new ZipReader(fresh.buffer);
+  await writeThrough(fresh);
+  cachedPluginZip = { zip, loadedFrom: "network" };
+  return cachedPluginZip;
+}
+
+// ── 清单解析（嵌套投影）──────────────────────────────────────────────────
+
+/** 字符串字段防御读取。 */
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value.trim() : fallback;
+}
+
+/**
+ * marketplace.json → 插件目录名列表。实测形状 { plugins: ["name-a", ...] }；
+ * 兼容 { plugins: [{ name }] } 与 { plugins: { ... } }（对象键即目录名）两种变体。
+ * 畸形一律返回 []，不抛错。
+ */
+export function pluginNamesFromMarketplace(indexJson) {
+  const raw = indexJson?.plugins;
+  if (Array.isArray(raw)) {
+    return raw
+      .map((item) => (typeof item === "string" ? item : asString(item?.name)))
+      .filter(Boolean);
+  }
+  if (raw && typeof raw === "object") return Object.keys(raw).filter(Boolean);
+  return [];
+}
+
+/** 去掉末尾斜杠并统一为 / 分隔（listByPrefix 是小写前缀匹配，路径形态无关紧要）。 */
+/** zip 内插件清单的标准嵌套路径（导出给测试对形状做锚定）。 */
+export function pluginJsonPath(name) {
+  return `external_plugins/${name}/.codebuddy-plugin/plugin.json`;
+}
+
+/**
+ * plugin.json → 面板投影。防御性提取：全部字段缺失不炸；dependencies 缺失 = []
+ * （R6：实测清单无该字段，出现时展示、绝不自动安装）；lspServers 仅透传展示（X7）。
+ */
+export function projectPlugin(name, pluginJson) {
+  const raw = pluginJson && typeof pluginJson === "object" ? pluginJson : {};
+  const deps = Array.isArray(raw.dependencies)
+    ? raw.dependencies
+        .map((dep) => (typeof dep === "string"
+          ? { name: dep.trim(), version: "" }
+          : { name: asString(dep?.name), version: asString(dep?.version || dep?.spec || "") }))
+        .filter((dep) => dep.name)
+    : [];
+  return {
+    name: asString(raw.name) || asString(name),
+    description: asString(raw.description),
+    author: asString(raw.author),
+    repository: asString(raw.repository),
+    homepage: asString(raw.homepage),
+    license: asString(raw.license),
+    version: asString(raw.version),
+    dependencies: deps,
+    lspServers: raw.lspServers && typeof raw.lspServers === "object" ? raw.lspServers : null,
+  };
+}
+
+/**
+ * 从已解析的 ZipReader 枚举全部插件投影。先读市场索引拿目录名，再逐条读
+ * external_plugins/<name>/.codebuddy-plugin/plugin.json（缺清单的目录跳过并计数）。
+ */
+export function readPluginCatalog(zip) {
+  const marketManifestName = ".codebuddy-plugin/marketplace.json";
+  if (!zip.has(marketManifestName)) {
+    return { plugins: [], skipped: 0 };
+  }
+  let indexJson = null;
+  try {
+    indexJson = JSON.parse(zip.extract(marketManifestName).toString("utf8"));
+  } catch {
+    return { plugins: [], skipped: 0 };
+  }
+  const names = pluginNamesFromMarketplace(indexJson);
+  const plugins = [];
+  let skipped = 0;
+  for (const name of names) {
+    const manifestPath = pluginJsonPath(name);
+    if (!zip.has(manifestPath)) {
+      skipped += 1;
+      continue;
+    }
+    try {
+      const pluginJson = JSON.parse(zip.extract(manifestPath).toString("utf8"));
+      plugins.push(projectPlugin(name, pluginJson));
+    } catch {
+      skipped += 1; // 单个插件清单损坏不拖垮整个目录
+    }
+  }
+  return { plugins, skipped };
+}
+
+/**
+ * 目录投影：catalog 返回 {ok, total, loadedFrom, plugins, skipped}。
+ * 投影只保留列表需要的字段（详情从 detail 再取全量），保持响应轻。
+ */
+export async function wbPluginCatalog(options = {}) {
+  const { zip, loadedFrom } = await loadPluginZip(options);
+  const { plugins, skipped } = readPluginCatalog(zip);
+  return {
+    ok: true,
+    loadedFrom,
+    total: plugins.length,
+    skipped,
+    plugins: plugins.map((plugin) => ({
+      name: plugin.name,
+      description: plugin.description,
+      author: plugin.author,
+      repository: plugin.repository,
+      version: plugin.version,
+      license: plugin.license,
+      dependencies: plugin.dependencies,
+    })),
+  };
+}
+
+/**
+ * 单插件详情：全量投影（repository/homepage/lspServers 只在详情透出）。
+ * name 未给或 zip 里没有 → ok:false（不抛错，客户端按「不可用」渲染）。
+ */
+export async function wbPluginDetail(name, options = {}) {
+  const wanted = String(name ?? "").trim();
+  if (!wanted) return { ok: false, error: "缺少插件名" };
+  const { zip, loadedFrom } = await loadPluginZip(options);
+  const manifestPath = pluginJsonPath(wanted);
+  if (!zip.has(manifestPath)) return { ok: false, error: `zip 里没有插件 ${wanted}` };
+  try {
+    const pluginJson = JSON.parse(zip.extract(manifestPath).toString("utf8"));
+    return { ok: true, loadedFrom, plugin: projectPlugin(wanted, pluginJson) };
+  } catch (error) {
+    return { ok: false, error: `插件清单解析失败：${error.message}` };
+  }
+}
+
+/** 供测试与未来 R8（T04）检查缓存是否在场；只读，不联网。 */
+export async function wbPluginCachedInfo(options = {}) {
+  const meta = (await readJsonAt(metaPathOf(options))) || {};
+  return { hasCache: Boolean(meta.etag), etag: meta.etag || "", fetchedAt: meta.fetchedAt || 0 };
+}
+
+// writeAtomic 同款 staging+rename（本文件缓存写用直写即可，这里导出给测试复用形态）。
+export async function writeCacheStaging(path, data) {
+  await mkdir(join(path, ".."), { recursive: true });
+  await writeFile(`${path}.staging`, data);
+  await rm(path, { force: true });
+  await rename(`${path}.staging`, path);
+}
+
+/**
+ * R9（T05）：插件市场更新探测 —— 只做条件请求，**绝不落盘**。
+ *
+ * 判定口径（设计文档）：ETag 与上次落盘的 meta.json 不一致即有更新；
+ * HTTP 304 = 无更新，HTTP 200 = 有更新。HEAD 不传包体做轻量探测；
+ * 服务端对 HEAD 返回 405/501 时降级为 GET，并立即 cancel() 丢弃响应体，
+ * 不把 zip 读进内存。纯探测：不写 zip、不写 meta.json、不更新内存缓存。
+ */
+export async function wbPluginUpdateCheck(options = {}) {
+  try {
+    const source = await sourceFor("plugins", options);
+    const sourceUrl = source?.source?.url;
+    const meta = (await readJsonAt(metaPathOf(options))) || {};
+    const localEtag = meta.etag || "";
+    if (typeof sourceUrl !== "string" || !sourceUrl) {
+      // 市场源检查必须先于 no-cache 分支：市场没配置时绝不能提示「有新版本」。
+      return { ok: false, hasUpdate: false, reason: "no-source", localEtag, remoteEtag: "", checkedAt: Date.now(), error: "注册表里没有可用的 plugins 市场源" };
+    }
+    if (!localEtag) {
+      // 本地没缓存过 → 无法比较，视为有更新，引导用户首次加载（纯探测仍不下载）。
+      return { ok: true, hasUpdate: true, reason: "no-cache", localEtag: "", remoteEtag: "", checkedAt: Date.now() };
+    }
+    const headers = { "user-agent": USER_AGENT, "if-none-match": localEtag };
+    let response;
+    try {
+      response = await fetch(sourceUrl, { method: "HEAD", headers, signal: AbortSignal.timeout(30_000) });
+      if (response.status === 405 || response.status === 501) {
+        // HEAD 不被支持 → 降级 GET，立刻 cancel() 丢弃响应体，不读进内存。
+        response.body?.cancel?.();
+        response = await fetch(sourceUrl, { method: "GET", headers, signal: AbortSignal.timeout(30_000) });
+        response.body?.cancel?.();
+      }
+    } catch (error) {
+      return { ok: false, hasUpdate: false, reason: "probe-failed", localEtag, remoteEtag: "", checkedAt: Date.now(), error: `更新探测失败：${error.message}` };
+    }
+    if (response.status === 304) {
+      // 304：ETag 命中，服务端不回显 ETag；回显 localEtag 便于客户端展示。
+      return { ok: true, hasUpdate: false, reason: "up-to-date", localEtag, remoteEtag: localEtag, checkedAt: Date.now() };
+    }
+    if (response.ok) {
+      const remoteEtag = response.headers.get("etag") || "";
+      const hasUpdate = remoteEtag !== localEtag;
+      return { ok: true, hasUpdate, reason: hasUpdate ? "update-available" : "up-to-date", localEtag, remoteEtag, checkedAt: Date.now() };
+    }
+    return { ok: false, hasUpdate: false, reason: "probe-failed", localEtag, remoteEtag: "", checkedAt: Date.now(), error: `插件市场更新探测失败：HTTP ${response.status}` };
+  } catch (error) {
+    return { ok: false, hasUpdate: false, reason: "probe-failed", localEtag: "", remoteEtag: "", checkedAt: Date.now(), error: `更新探测异常：${error.message}` };
+  }
+}

package/lib/wb-registry.js

@@ -0,0 +1,224 @@
+// 多市场注册表（R4）—— ~/.dsh/armory/marketplaces.json 的读写层。
+//
+// 职责（设计文档 docs/system_design.md 8.3 / 类图 MarketRegistry）：
+//   - 注册表文件不存在或损坏时，回落到**内置默认两条**：连接器源（与 lib/wb-market.js:27
+//     的 CONNECTOR_ZIP_URL 保持同一现值，禁止在此发明第二处硬编码真相）与
+//     codebuddy-plugins-official 插件源；首读时把默认项落盘。
+//   - 合并投影：内置默认永远在场（文件内同 id 条目可覆盖其字段），用户自定义条目追加其后。
+//   - 增删改一律 staging + rename 原子替换（沿用 wbSkillInstall 的 staging 模式）。
+//
+// 纯数据层：不做任何网络请求，不依赖 Remote/UI。测试可通过 options.rootDir 或
+// 环境变量 DSH_ARMORY_HOME 把存储根目录指到临时目录，绝不碰真实 ~/.dsh。
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// 与 lib/wb-market.js:27 现值一致（改动连接器源时两处必须同步，注册表化接入后此值
+// 仅作为「内置默认项」的数据来源，不再被 wb-market 直接消费）。
+const CONNECTOR_ZIP_URL = "https://static.workbuddy.cn/connectors-config-v2/connectors-config.zip";
+
+export const REGISTRY_VERSION = 1;
+
+/** 存储根目录：显式 rootDir > 环境变量 > 真实 ~/.dsh/armory。 */
+function armoryRoot(options = {}) {
+  return options.rootDir || process.env.DSH_ARMORY_HOME || join(homedir(), ".dsh", "armory");
+}
+
+/** 注册表文件绝对路径。 */
+export function registryPath(options = {}) {
+  return join(armoryRoot(options), "marketplaces.json");
+}
+
+/**
+ * 内置默认市场条目（代码内声明，首读落盘）。顺序即 sourceFor 的优先序：
+ *   1. connectors → 现有 connectors-config.zip（WorkBuddy 连接器市场分发地址）
+ *   2. plugins    → codebuddy-plugins-official（清单实测在 .codebuddy-plugin/marketplace.json）
+ */
+export function builtinMarketplaces() {
+  return [
+    {
+      id: "workbuddy-connectors",
+      kind: "connectors",
+      manifestName: "workbuddy-connectors",
+      type: "zip",
+      source: { url: CONNECTOR_ZIP_URL, path: "" },
+      manifestPath: ".codebuddy-connector/connectors.json",
+      autoUpdate: false,
+      isBuiltIn: true,
+      description: "WorkBuddy 官方连接器市场（connectors-config.zip）",
+      addedAt: 0,
+      lastUpdated: 0,
+    },
+    {
+      id: "codebuddy-plugins-official",
+      kind: "plugins",
+      manifestName: "codebuddy-plugins-official",
+      type: "zip",
+      source: {
+        url: "https://download.codebuddy.cn/plugin-marketplace/codebuddy-plugins-official-4b9366ac-f7e5-4cef-b60a-99a5229ce2b2.zip",
+        path: "",
+      },
+      manifestPath: ".codebuddy-plugin/marketplace.json",
+      autoUpdate: false,
+      isBuiltIn: true,
+      description: "CodeBuddy 官方插件市场",
+      addedAt: 0,
+      lastUpdated: 0,
+    },
+  ];
+}
+
+const KINDS = new Set(["connectors", "plugins"]);
+
+/** 字符串字段防御读取：非字符串一律回落默认值。 */
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+
+/** 布尔字段防御读取。 */
+function asBool(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+/** 数字时间戳防御读取：非有限非负数一律回落 fallback。 */
+function asTimestamp(value, fallback = 0) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+/**
+ * 把任意原始对象规范成一条完整的 MarketplaceEntry：缺失字段防御性补全
+ * （缺 addedAt/lastUpdated 补 0、缺 description 补空串等），畸形条目不炸调用方。
+ */
+export function normalizeEntry(raw, { isBuiltIn = false } = {}) {
+  const source = raw && typeof raw.source === "object" && raw.source !== null ? raw.source : {};
+  return {
+    id: asString(raw?.id).trim(),
+    kind: KINDS.has(raw?.kind) ? raw.kind : "connectors",
+    manifestName: asString(raw?.manifestName, asString(raw?.id).trim()),
+    type: raw?.type === "directory" ? "directory" : "zip",
+    source: { url: asString(source.url), path: asString(source.path) },
+    manifestPath: asString(raw?.manifestPath),
+    autoUpdate: asBool(raw?.autoUpdate, false),
+    isBuiltIn: asBool(raw?.isBuiltIn, isBuiltIn),
+    description: asString(raw?.description),
+    addedAt: asTimestamp(raw?.addedAt, 0),
+    lastUpdated: asTimestamp(raw?.lastUpdated, 0),
+  };
+}
+
+/** 从磁盘读原始文档；不存在/损坏一律返回 null（由调用方决定回落语义）。 */
+async function readRawDoc(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null; // ENOENT / ENOTDIR / JSON 解析失败同途处理
+  }
+}
+
+/** staging + rename 原子写：先写 `<file>.staging`，再删旧文件换入（Windows rename 不覆盖）。 */
+async function writeAtomic(path, doc) {
+  await mkdir(armoryPathDirname(path), { recursive: true });
+  await writeFile(`${path}.staging`, JSON.stringify(doc, null, 2));
+  await rm(path, { force: true });
+  await rename(`${path}.staging`, path);
+}
+
+/** 拆出目录部分（避免为 dirname 多引一个依赖，路径既有 / 也有 \ 的 Windows 形态）。 */
+function armoryPathDirname(path) {
+  const cut = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return cut > 0 ? path.slice(0, cut) : path;
+}
+
+/**
+ * 读注册表并返回合并投影：
+ *   - 文件不存在 / 解析失败 / marketplaces 非数组 → 内置默认两条（并尽力落盘）；
+ *   - 文件内与内置默认同 id 的条目**覆盖**默认项字段；
+ *   - 其余文件条目按原顺序追加在默认项之后。
+ * 返回 { version, marketplaces }，永不抛错。
+ */
+export async function readRegistry(options = {}) {
+  const path = registryPath(options);
+  const raw = await readRawDoc(path);
+  const fileEntries = Array.isArray(raw?.marketplaces)
+    ? raw.marketplaces.filter((entry) => entry && typeof entry === "object" && !Array.isArray(entry))
+    : null;
+
+  if (fileEntries === null) {
+    // 首读落盘：把内置默认写进文件，失败（只读盘等）不影响返回值。
+    const defaults = builtinMarketplaces();
+    try {
+      await writeAtomic(path, { version: REGISTRY_VERSION, marketplaces: defaults });
+    } catch {
+      /* 落盘失败不致命：下次读仍回落内置默认 */
+    }
+    return { version: REGISTRY_VERSION, marketplaces: defaults };
+  }
+
+  const normalized = fileEntries.map((entry) => normalizeEntry(entry));
+  const byId = new Map(normalized.map((entry) => [entry.id, entry]));
+  const merged = builtinMarketplaces().map(
+    (builtin) => (byId.has(builtin.id) ? byId.get(builtin.id) : builtin),
+  );
+  const builtinIds = new Set(builtinMarketplaces().map((entry) => entry.id));
+  for (const entry of normalized) {
+    if (!builtinIds.has(entry.id)) merged.push(entry);
+  }
+  const version = raw && typeof raw.version === "number" ? raw.version : REGISTRY_VERSION;
+  return { version, marketplaces: merged };
+}
+
+/**
+ * 新增或更新一条市场条目（按 id 定位）。新条目补 addedAt，任何写入都刷新 lastUpdated。
+ * 用户 upsert 内置同 id 条目即形成覆盖记录（删掉后内置默认回归）。
+ * 返回写入后的合并投影。
+ */
+export async function upsertMarketplace(entry, options = {}) {
+  const normalized = normalizeEntry(entry);
+  if (!normalized.id) throw new Error("市场条目缺少 id，无法登记");
+  const path = registryPath(options);
+  const raw = await readRawDoc(path);
+  const list = Array.isArray(raw?.marketplaces)
+    ? raw.marketplaces.filter((item) => item && typeof item === "object" && !Array.isArray(item))
+    : [];
+  const now = Date.now();
+  const existingIndex = list.findIndex((item) => normalizeEntry(item).id === normalized.id);
+  if (existingIndex >= 0) {
+    const existing = normalizeEntry(list[existingIndex]);
+    list[existingIndex] = {
+      ...normalized,
+      addedAt: existing.addedAt || now,
+      lastUpdated: now,
+    };
+  } else {
+    list.push({ ...normalized, addedAt: normalized.addedAt || now, lastUpdated: now });
+  }
+  await writeAtomic(path, { version: REGISTRY_VERSION, marketplaces: list });
+  return readRegistry(options);
+}
+
+/**
+ * 按 id 删除一条**文件内**条目。内置默认不受影响：删除同 id 的覆盖记录后，
+ * 合并投影里内置默认回归。id 不存在时为无害空操作。
+ * 返回写入后的合并投影。
+ */
+export async function removeMarketplace(id, options = {}) {
+  const target = String(id ?? "").trim();
+  if (!target) throw new Error("缺少要删除的市场 id");
+  const path = registryPath(options);
+  const raw = await readRawDoc(path);
+  if (!Array.isArray(raw?.marketplaces)) {
+    return readRegistry(options); // 文件本就没有用户条目，直接回落投影
+  }
+  const list = raw.marketplaces.filter(
+    (item) => !(item && typeof item === "object" && normalizeEntry(item).id === target),
+  );
+  await writeAtomic(path, { version: REGISTRY_VERSION, marketplaces: list });
+  return readRegistry(options);
+}
+
+/** 取某个 kind 的第一条市场源（合并投影序 = 内置默认优先）；没有则返回 null。 */
+export async function sourceFor(kind, options = {}) {
+  const wanted = String(kind ?? "").trim();
+  const { marketplaces } = await readRegistry(options);
+  return marketplaces.find((entry) => entry.kind === wanted) ?? null;
+}

package/lib/whats-new.js

@@ -333,4 +333,41 @@ export const WHATS_NEW = [
       },
     ],
   },
+  {
+    version: '2.0.0',
+    items: [
+      {
+        text: '**来了第三个市场源：插件页**：新开「插件」页，把三类来源并进一个可搜索、可筛选的目录——**官方**（DSH 宿主自带组件，随宿主分发、不可单独安装）、**CodeBuddy 官方**（ZIP 分发）、**DSH 社区**（`awesome-dsh-plugins` 社区清单，jsdelivr 走 CDN）。安装统一走宿主 `pluginManager` 拉取落盘，**装完需重启宿主才生效**；宿主没提供 `pluginManager` 时会明确报错而不是装作成功。条目没给 npm 包名 / 没有 repository 的，文案直说「暂不支持安装」「仅展示」，不做猜的安装',
+        where: '面板「插件」页',
+      },
+      {
+        text: '**需要 token 的连接器，现在安装时就让你填**：安装前自动扫出 `mcpServers` 里的 `${...}` 占位符，弹「填写 {连接器} 的凭据」逐槽填写后再装；留空表示稍后自行补全，装完还会提示「另有 N 个占位符未填写，配置里保留原样」。没有占位符的连接器直接放行，不多弹一层',
+        where: 'MCP 市场 → 任一带占位符的连接器 → 安装',
+      },
+      {
+        text: '**MCP OAuth 一键授权**：以前远端 MCP 只认 `requestInit.headers`、没有 authProvider，OAuth 根本装不上，只能手搓 token。现在按 RFC 9728 / 8414 / 7591 / 7636 / 8707 走完整流程：发现受保护资源与授权服务器 → 动态客户端注册 → PKCE(S256) → 开浏览器授权 → 拿 code 换 token → 写进 patch 的 headers，到期自动刷新。回调通道**三级降级**：本地 loopback 自动收（主流实现）→ 服务器只接受自定义 scheme 时粘贴整条回调地址 → 都不通就直接贴 Bearer token',
+        where: 'MCP 市场 → 返回 401 的连接器 → 授权',
+      },
+      {
+        text: '**安装状态账本 + 跨页「已安装」筛选**：新增 `~/.dsh/armory/install-state.json` 记录每个连接器 / 技能 / 插件是谁装的、来自哪个市场，市场页据此把「本插件装的」和「别处来的」分开，并支持**跨页**筛出已安装项（技能侧仍只筛当前页，两处文案已分别说明）。登记失败不会让安装失败，只补一句「已安装，但状态登记失败」',
+        where: '市场各页顶部筛选 / 已安装计数',
+      },
+      {
+        text: '**技能看板会分类了**：技能按 **编程开发 / 设计与创作 / 文档办公 / 效率与自动化 / 开发运维 / 未分类** 六类归置，网格与列表双视图可切，可按分类过滤；详情新增所属分类、来源目录、文件位置，并能一键「复制 SKILL.md 路径」「复制 @会话引用」',
+        where: '技能标签页',
+      },
+      {
+        text: '**社区目录秒开**：上次成功的社区清单镜像进浏览器 `localStorage`（7 天 / 4MB 上限，超配额就保留旧快照），首屏先渲染快照、再被真实结果静默替换，**0 网络 0 IPC**；源不可达时明确写「目录缓存已过期，显示的是本地缓存」，而不是给一个空列表',
+        where: '插件 → DSH 社区',
+      },
+      {
+        text: '**安装轻提示 + 注入规则只读展示**：安装过程挂一个不随面板卸载而消失的浮层（纯 DOM、只写 `textContent`，不走 `createPortal`，top 64px）；连接器详情里解析 `connectors.json` 的 `auth_injection_rules`，标出哪些连接器依赖 WB 账号体系「代注入」——**DSH 不代注入，只解析展示**，两者边界在代码注释与 UI 上都写明',
+        where: '任意安装动作 / MCP → 连接器详情',
+      },
+      {
+        text: '**多市场注册表**：市场源不再硬编码，落到 `~/.dsh/armory/marketplaces.json`（缺失或损坏回落内置默认项，首读即落盘），支持增删改；写盘一律 staging + rename 原子替换，避免半截文件',
+        where: '—（`~/.dsh/armory/marketplaces.json`）',
+      },
+    ],
+  },
 ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-armory",
-  "version": "1.10.0",
-  "description": "Unified Skill + MCP + Expert board for DeepSeek Harness (desktop app and Web GUI) — global panel page, JSON import, WorkBuddy connector & SkillHub & Expert market installs, tool-usage tailor, and profile-backed Host Remote management.",
+  "version": "2.0.0",
+  "description": "Unified Skill + MCP + Expert + Plugin board for DeepSeek Harness (desktop app and Web GUI) — global panel page, JSON import, WorkBuddy connector & SkillHub & Expert & CodeBuddy plugin & awesome-dsh-plugins market installs, MCP OAuth authorization, tool-usage tailor, and profile-backed Host Remote management.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/2026heshao/dsh-armory.git"