dsh-armory 2.4.3 → 2.4.4

package/lib/system-open.js

@@ -0,0 +1,113 @@
+// 系统级「打开链接 / 定位文件」的唯一出口。
+//
+// 为什么单独成模块（issue #7）：headless 主机（NAS / 容器里的 `dsh web`）没有 xdg-open。
+// spawn 的 ENOENT 不是同步 throw，而是异步 'error' 事件；没人监听就升级成
+// uncaughtException，直接把宿主进程带走——用户看到的是「点一下安装，所有 API 502」。
+// 这里等到 spawn / error 任意一个落地再返回：调用方拿到可判定的结果，也不会再有
+// 「spawn 完立刻 unref、错误没人接」的写法漏进业务代码。
+import { spawn } from 'node:child_process';
+
+// 极少数平台既不回 spawn 也不回 error。不能为了一次「打开链接」卡住 RPC，按成功放行。
+const LAUNCH_TIMEOUT_MS = 5000;
+
+// 允许交给系统浏览器打开的 URL。rundll32 / open / xdg-open 收到本地路径时会直接用
+// 关联程序执行（.exe / .command / .app），所以这里必须先做协议白名单：只放 https，
+// http 仅限本机回环（本地开发服务）。javascript: / file: / data: 一律拒绝。
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
+
+/** 是否是允许交给系统浏览器的 URL（协议白名单）。 */
+export function isAllowedExternalUrl(value) {
+  const text = String(value ?? '').trim();
+  if (!text) return false;
+  let parsed;
+  try {
+    parsed = new URL(text);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol === 'https:') return true;
+  return parsed.protocol === 'http:' && LOOPBACK_HOSTS.has(parsed.hostname.toLowerCase());
+}
+
+/** 打开 URL 的平台命令。 */
+export function urlOpenCommand(target, platform = process.platform) {
+  if (platform === 'win32') {
+    // 绝不能用 `cmd /c start "$url"`：Node 只在参数含空格时才给参数加引号，而 URL 不含空格，
+    // cmd 于是把 URL 里的 & 当成命令分隔符，授权地址被截断成 `?response_type=code`，
+    // 服务器随后回 `invalid_request: client_id is required`。
+    // rundll32 走 ShellExecute 且参数直传，不经 cmd 解析。
+    return { command: 'rundll32', args: ['url.dll,FileProtocolHandler', target] };
+  }
+  return { command: platform === 'darwin' ? 'open' : 'xdg-open', args: [target] };
+}
+
+/** 在系统文件管理器中定位路径的平台命令。 */
+export function pathRevealCommand(target, platform = process.platform) {
+  if (platform === 'win32') return { command: 'explorer', args: ['/select,', target] };
+  return { command: platform === 'darwin' ? 'open' : 'xdg-open', args: [target] };
+}
+
+function failedOutcome(command, error, logger) {
+  const reason =
+    error?.code === 'ENOENT'
+      ? `找不到系统命令 ${command}（headless 主机通常没有桌面打开器）`
+      : String(error?.message || error);
+  try {
+    logger?.warn?.(`[dsh-armory] 系统打开器不可用：${reason}`);
+  } catch {
+    /* 日志本身不该再制造一次失败 */
+  }
+  return { ok: false, reason, code: error?.code || '' };
+}
+
+/**
+ * 启动一个分离进程，并等「确实起来了」或「确实失败了」再返回。永不 reject。
+ * 成功才 unref；失败时进程根本没起来，unref 无意义。
+ */
+export async function launchDetached(command, args, { logger } = {}) {
+  let child;
+  try {
+    child = spawn(command, args, { detached: true, stdio: 'ignore' });
+  } catch (error) {
+    return failedOutcome(command, error, logger);
+  }
+  const outcome = await new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+    // 监听器常驻：成功之后才冒出来的 error 同样必须被吃掉，不能再回到 uncaughtException。
+    child.on('error', (error) => finish(failedOutcome(command, error, logger)));
+    child.once('spawn', () => finish({ ok: true }));
+    timer = setTimeout(() => finish({ ok: true, timedOut: true }), LAUNCH_TIMEOUT_MS);
+    timer.unref?.();
+  });
+  if (outcome.ok) child.unref();
+  return outcome;
+}
+
+/** 用系统默认浏览器打开 URL。非白名单协议直接拒绝，不启动任何进程。 */
+export function openSystemUrl(url, { logger, platform = process.platform } = {}) {
+  if (!isAllowedExternalUrl(url)) {
+    const reason = '只允许用系统浏览器打开 https 链接（http 仅限本机回环）';
+    try {
+      logger?.warn?.('[dsh-armory] 已拦截非白名单协议的打开请求');
+    } catch {
+      /* 日志本身不该再制造一次失败 */
+    }
+    return Promise.resolve({ ok: false, reason, code: 'EBADURL' });
+  }
+  const target = String(url).trim();
+  const { command, args } = urlOpenCommand(target, platform);
+  return launchDetached(command, args, { logger });
+}
+
+/** 用系统文件管理器定位路径。 */
+export function revealSystemPath(path, { logger, platform = process.platform } = {}) {
+  const { command, args } = pathRevealCommand(path, platform);
+  return launchDetached(command, args, { logger });
+}

package/lib/typert.js

@@ -77,6 +77,10 @@ export const TYPERT = {
     // 卸载已安装 skill：永久删除用户级/项目级 skills 根目录内的条目。三处契约缺一即 404，
     // 删除规则全在 lib/skill-remove.js（来源白名单 / 根目录包含性 / 符号链接只删链接）。
     mv('removeSkill', [payloadParam], 'NoteResult'),
+    // 禁用 / 释放 skill（工具裁缝技能账本行内按钮）：写 SKILL.md frontmatter 的
+    // disable-model-invocation 标志（宿主官方键），写盘规则全在 lib/skill-disable.js。
+    mv('disableSkill', [payloadParam], 'NoteResult'),
+    mv('enableSkill', [payloadParam], 'NoteResult'),
     // 安装时间 + 市场原名（Skill 看板卡片徽标 /「最近安装」排序的数据源）：宿主自扫
     // 标准根目录按 SKILL.md name 建映射，出 { ok, info: { [name]: { installedAt, ... } } }。
     // 不按 listSkills 行的 path 查——注册表行可能整列缺 path（实测）。形状由
@@ -115,6 +119,9 @@ export const TYPERT = {
     mv('wbInstallStateForget', [payloadParam], 'NoteResult'),
     // T06/Awesome：DSH 社区插件市场（awesome-dsh-plugins，数据层 lib/wb-awesome-market.js）。
     mv('wbAwesomeCatalog', [payloadParam], 'AwesomeCatalogResult'),
+    // 社区 MCP：官方 MCP Registry v0 只读列表（数据层 lib/mcp-community.js）。
+    // 与上面 wb* 系列同一宽容度：payload 形状由数据层校验，契约层 $any。
+    mv('wbMcpCommunityList', [payloadParam], 'WbMcpCommunityResult'),
     mv('wbAwesomeDetail', [payloadParam], 'AwesomeDetailResult'),
     // README 预览：点击卡片按需取一次（npm registry / GitHub raw），落盘缓存 7 天。
     mv('wbAwesomeReadme', [payloadParam], 'AwesomeReadmeResult'),
@@ -150,6 +157,9 @@ export const TYPERT = {
     mv('wbOAuthCancel', [payloadParam], 'NoteResult'),
     mv('wbOAuthToken', [payloadParam], 'NoteResult'),
     mv('wbOAuthOverview', [payloadParam], 'NoteResult'),
+    // 强制刷新已存的 OAuth token（refresh_token 换新）。面板「刷新授权」用它，
+    // 刷新后再走一次 wbConnectorInstall 把新凭据写回 headers。
+    mv('wbOAuthRefresh', [payloadParam], 'NoteResult'),
     mv('wbOAuthOpen', [payloadParam], 'NoteResult'),
   ],
   model: { services: [], events: [], objects: [] },

package/lib/wb-auth-rules.js

@@ -37,20 +37,24 @@ export function rulesFor(rules, connectorId) {
 }
 
 /** 一个待填 token 槽位：占位符在哪个 server 的哪个容器字段里。 */
-// 形状：{ server, container: "env"|"header", key, template, placeholder, value }
+// 形状：{ server, container: "env"|"header"|"url", key, template, placeholder, value }
+// url 槽位是「凭据写在连接地址里」的形态：`https://api.x/mcp/?token=${TOKEN}`。实测
+// 连接器市场里有 12 条 auth_mode=token 只把占位符写在 url（tushare / 百度地图 / 快递100…），
+// 只扫 env/headers 会让它们既没有可填槽位、又被判「未声明可替换」，安装入口整个消失。
 
 const PLACEHOLDER_PATTERN = /\$\{([^}]+)\}/g;
 // 非全局版：.test() 不会推进 lastIndex（全局正则连续 test 会漏判残留占位符）。
 const HAS_PLACEHOLDER = /\$\{[^}]+\}/;
 
 /**
- * 扫描 mcpServers 的 env 与 headers 值里的 `${...}` 模板占位符。
- * 返回槽位清单：[{ server, container: "env"|"header", key, template, placeholder, value }]
- *   - container   字段容器：env → env 对象；header → headers 对象（对外统一命名）
- *   - template    原始模板串（如 "Bearer ${token}"）
+ * 扫描 mcpServers 的 env / headers / url 里的 `${...}` 模板占位符。
+ * 返回槽位清单：[{ server, container: "env"|"header"|"url", key, template, placeholder, value }]
+ *   - container   字段容器：env → env 对象；header → headers 对象（对外统一命名）；
+ *                 url → server 的连接地址（key 固定为 "url"）
+ *   - template    原始模板串（如 "Bearer ${token}"、"?token=${TOKEN}"）
  *   - placeholder 第一个占位符（如 "token"）；模板无占位符的条目不进清单
  *   - value       原值（供 applyTokens 做精确字符串替换与回显）
- * mcpServers / env / headers 畸形（null、数组、值非字符串）一律跳过，不抛错。
+ * mcpServers / env / headers / url 畸形（null、数组、值非字符串）一律跳过，不抛错。
  */
 export function scanTokenSlots(mcpServers) {
   if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) return [];
@@ -79,10 +83,36 @@ export function scanTokenSlots(mcpServers) {
         });
       }
     }
+    // url 槽位：凭据写在连接地址里（?token=${X} / /mcp/${X}）。与 env/headers 分开处理，
+    // 因为它在 server 本体的字符串字段上，applyTokens 也要按字符串整体替换。
+    const urlValue = typeof nested.url === "string" ? nested.url : "";
+    const urlMatches = urlValue ? [...urlValue.matchAll(PLACEHOLDER_PATTERN)] : [];
+    if (urlMatches.length) {
+      slots.push({
+        server,
+        container: "url",
+        key: "url",
+        template: urlValue,
+        placeholder: urlMatches[0][1].trim(),
+        value: urlValue,
+      });
+    }
   }
   return slots;
 }
 
+/** 把模板串里所有有值 token 的占位符替换掉；无值占位符原样保留。 */
+function fillPlaceholders(template, tokenMap) {
+  let filled = String(template);
+  for (const match of filled.matchAll(PLACEHOLDER_PATTERN)) {
+    const token = tokenMap[match[1].trim()];
+    if (typeof token === "string" && token.length) {
+      filled = filled.split(match[0]).join(token);
+    }
+  }
+  return filled;
+}
+
 /**
  * 按槽位把占位符替换为用户 token，产出「可安全写盘」的 mcpServers 副本。
  *   - tokens: Record<placeholder, value>，键为占位符名（如 { access_token: "xxx" }）。
@@ -92,6 +122,7 @@ export function scanTokenSlots(mcpServers) {
  *   missingSlots  [{ server, container, key, placeholder, template }] 未填槽位清单
  * 输入畸形时返回 { mcpServers: {}, missingSlots: [] }；对每个槽位同时应用模板内**所有**
  * 占位符（"Bearer ${a}/${b}" 两处都能换），全替换后仍含 `${` 的值按未填槽位上报。
+ * url 槽位整串替换（`?token=${TOKEN}` → `?token=xxx`），写回 server.url / transport.url。
  */
 export function applyTokens(mcpServers, tokens) {
   const source = mcpServers && typeof mcpServers === "object" && !Array.isArray(mcpServers) ? mcpServers : {};
@@ -100,17 +131,17 @@ export function applyTokens(mcpServers, tokens) {
   const result = structuredClone(source);
   const slots = scanTokenSlots(result);
   for (const slot of slots) {
-    const target = slot.container === "header"
-      ? result[slot.server]?.transport?.headers ?? result[slot.server]?.headers
-      : result[slot.server]?.transport?.env ?? result[slot.server]?.env;
+    // url 槽位落在 server 本体的字符串字段上；transport 嵌套形态则落在 transport.url。
+    const urlHolder = result[slot.server]?.transport && typeof result[slot.server].transport === "object"
+      ? result[slot.server].transport
+      : result[slot.server];
+    const target = slot.container === "url"
+      ? (urlHolder && typeof urlHolder.url === "string" ? urlHolder : null)
+      : slot.container === "header"
+        ? result[slot.server]?.transport?.headers ?? result[slot.server]?.headers
+        : result[slot.server]?.transport?.env ?? result[slot.server]?.env;
     if (!target || typeof target !== "object") continue;
-    let filled = String(target[slot.key]);
-    for (const match of filled.matchAll(PLACEHOLDER_PATTERN)) {
-      const token = tokenMap[match[1].trim()];
-      if (typeof token === "string" && token.length) {
-        filled = filled.split(match[0]).join(token);
-      }
-    }
+    const filled = fillPlaceholders(slot.container === "url" ? target.url : target[slot.key], tokenMap);
     if (HAS_PLACEHOLDER.test(filled)) {
       // 仍有残留占位符 → 该槽位缺 token：保留原样并上报。
       missingSlots.push({

package/lib/wb-market.js

@@ -277,6 +277,79 @@ export function serverInstallability(serverName, rawServer, authMode = "") {
   return { ok: reasons.length === 0, transport: transport || "stdio", reasons, tokenSlots, needsTokens, needsOAuth };
 }
 
+// ── 本机固定依赖（本地 stdio 连接器）────────────────────────────────────
+// 少数连接器不是「远程 URL + 凭据」，而是**驱动本机已安装的客户端**：mcp.json 把固定绝对
+// 路径（或 `cmd /d /c <path>` 包装）写死，能不能连上取决于用户机器上有没有那个程序、有没有
+// 开启它的 MCP/集成开关。不做检查时安装会「成功」，随后宿主按 mcp-client 的重连策略失败 10
+// 次才注销工具（issue #3：NVIDIA App 本地助手）。这里只做**静态**检查：认显式绝对路径、在
+// 对应平台 stat 一次；本插件不 spawn 任何 MCP 子进程，也不读取目标程序的配置或凭据。
+const WINDOWS_ABS_PATH = /^[A-Za-z]:[\\/]/;
+const WINDOWS_UNC_PATH = /^\\\\[^\\]/;
+const SHELL_COMMANDS = new Set(["cmd", "cmd.exe", "sh", "bash", "zsh", "powershell", "powershell.exe", "pwsh", "pwsh.exe"]);
+
+function unquotePath(value) {
+  const text = String(value ?? "").trim();
+  if (text.length >= 2 && ((text[0] === '"' && text.at(-1) === '"') || (text[0] === "'" && text.at(-1) === "'"))) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function isFixedAbsolutePath(value) {
+  const text = unquotePath(value);
+  // `${...}` / `!!js` 是运行时才求值的表达式，静态检查无法判断，交给宿主连接时的真实报错。
+  if (!text || text.includes("${") || text.startsWith("!!js ")) return false;
+  return WINDOWS_ABS_PATH.test(text) || WINDOWS_UNC_PATH.test(text) || (text.startsWith("/") && !text.startsWith("//"));
+}
+
+/** 一条 stdio server 固定依赖的本机可执行文件（只认显式绝对路径，不解析 PATH）。 */
+export function localExecutablePathsOf(rawServer) {
+  const nested = rawServer && typeof rawServer.transport === "object" ? rawServer.transport : rawServer;
+  const transport =
+    String(nested?.type ?? "").toLowerCase() ||
+    (typeof nested?.command === "string" && nested.command.trim() ? "stdio" : "");
+  if (transport !== "stdio") return [];
+  const command = unquotePath(nested?.command);
+  if (!command) return [];
+  const base = command.split(/[\\/]/).pop().toLowerCase();
+  if (SHELL_COMMANDS.has(base)) {
+    // cmd /d /c <path>、sh -c <path>：只取执行开关后面的第一个绝对路径参数；
+    // `-y`、包名、数据文件之类的一律不当成依赖。
+    const args = Array.isArray(nested?.args) ? nested.args.map(unquotePath) : [];
+    const flagIndex = args.findIndex((arg) => /^(\/c|-c)$/i.test(arg));
+    const target = flagIndex >= 0 ? args[flagIndex + 1] : "";
+    return isFixedAbsolutePath(target) ? [target] : [];
+  }
+  return isFixedAbsolutePath(command) ? [command] : [];
+}
+
+/** 固定依赖的静态可用性：found / missing / platform（Windows 路径在别的系统上无意义）。 */
+async function localDependencyStatus(path) {
+  const windowsPath = WINDOWS_ABS_PATH.test(path) || WINDOWS_UNC_PATH.test(path);
+  const posixPath = path.startsWith("/") && !path.startsWith("//");
+  if ((windowsPath && process.platform !== "win32") || (posixPath && process.platform === "win32")) return "platform";
+  try {
+    return (await stat(path)).isFile() ? "found" : "missing";
+  } catch {
+    return "missing";
+  }
+}
+
+/** 整份 mcpServers 的本机固定依赖（按路径去重；没有固定依赖时返回空数组）。 */
+export async function connectorLocalDeps(mcpServers) {
+  const paths = new Set();
+  const servers = mcpServers && typeof mcpServers === "object" ? Object.values(mcpServers) : [];
+  for (const rawServer of servers) for (const path of localExecutablePathsOf(rawServer)) paths.add(path);
+  const deps = [];
+  for (const path of paths) deps.push({ path, status: await localDependencyStatus(path) });
+  return deps;
+}
+
+// P1-6：10 分钟模块级缓存。顶栏 chip 与看板都会在每次挂载时问一次，解 24MB ZIP 只为
+// 数一个数字；wbConnectorCatalog 成功后回写，保证刚开过市场时两边同源。
+// 解不出（没有 ZIP）时不缓存 null，下次挂载还会再试——缓存文件可能刚被下载落盘。
+const COUNT_CACHE_TTL = 10 * 60 * 1000;
+let countCache = null;
 /** connectors.json 索引 + 每条的可装性标注。UI 列表唯一数据源。 */
 export async function wbConnectorCatalog() {
   const { zip, loadedFrom } = await loadConnectorZip();
@@ -302,6 +375,9 @@ export async function wbConnectorCatalog() {
     const servers = mcpJson?.mcpServers && typeof mcpJson.mcpServers === "object" ? Object.entries(mcpJson.mcpServers) : [];
     const checks = servers.map(([serverName, rawServer]) => ({ serverName, rawServer, ...serverInstallability(serverName, rawServer, entry.auth_mode) }));
     const blocked = checks.filter((check) => !check.ok);
+    // 本机固定依赖：绝大多数连接器是远程 URL / npx 型，这里为空；本地客户端型（如
+    // nvapp-windows-local）会带上路径与 found/missing/platform，供详情页与安装闸使用。
+    const localDeps = await connectorLocalDeps(mcpJson?.mcpServers);
     // R3：examples 优先（zh → en 回落），description 只作兜底正文。
     const copy = displayCopyOf(entry);
     rows.push({
@@ -323,6 +399,8 @@ export async function wbConnectorCatalog() {
       // R8：needsOAuth 为 true 时 UI 应走「浏览器授权」引导（而不是拒装/令牌框）。
       needsOAuth: checks.some((check) => check.needsOAuth),
       tokenSlots: checks.flatMap((check) => check.tokenSlots || []),
+      // 本机固定依赖（没有固定依赖时为空数组）。缺失时安装会被拦住，详情页也会明示路径。
+      localDeps,
       authMode: entry.auth_mode || "",
       version: entry.version || "",
       type: entry.type || "",
@@ -337,6 +415,8 @@ export async function wbConnectorCatalog() {
           : blocked[0]?.reasons.join("；") || "",
     });
   }
+  // P1-6：列表刚解过的 ZIP 顺便把条目数记下来，顶栏 chip 的计数查询不必再解一次。
+  countCache = { at: Date.now(), total: rows.length };
   return { loadedFrom, total: rows.length, connectors: rows };
 }
 
@@ -488,13 +568,17 @@ export async function probeMcpServersAuthorization(mcpServers) {
  * 单独存在的意义：wbConnectorCatalog 即使热缓存也会做一次 304 网络探测，
  * 冷缓存更是 24MB 下载——为顶栏一个数字触发这两者都不值得。
  */
+// P1-6：10 分钟模块级缓存（见上方 countCache 声明）。
 export async function wbConnectorCachedCount() {
+  if (countCache && Date.now() - countCache.at < COUNT_CACHE_TTL) return { total: countCache.total };
   try {
     const local = await readFile(zipPath());
     const zip = new ZipReader(local);
     const index = JSON.parse(zip.extract(".codebuddy-connector/connectors.json").toString("utf8"));
     const connectors = Array.isArray(index.connectors) ? index.connectors : [];
-    return { total: connectors.filter((entry) => String(entry.id || entry.source || "").trim()).length };
+    const total = connectors.filter((entry) => String(entry.id || entry.source || "").trim()).length;
+    countCache = { at: Date.now(), total };
+    return { total };
   } catch {
     return { total: null };
   }

package/lib/whats-new-en.js

@@ -476,6 +476,32 @@ export const WHATS_NEW_EN = {
       where: 'README -> Experts / FAQ',
     },
   ],
+  '2.4.4': [
+    {
+      text: '**A new Community MCP source on the Connectors tab**: reads the official MCP Registry directly and needs no WorkBuddy account; search by name or description, cursor pagination, an "only directly runnable (npx / uvx)" filter, details with the exact command, args and environment variables, and "Add MCP" only prefills the form — nothing is written until you confirm. Community entries are not reviewed by the Armory, and a permanent notice asks you to verify the command and environment variables yourself',
+      where: 'Market -> Connectors -> Source switch',
+    },
+    {
+      text: '**Disable or release a skill from the Tool Tailor skill ledger**: the inline Disable button writes the official `disable-model-invocation` flag into SKILL.md, so the model no longer loads that skill or pays its context tax, while manual `/` references keep working; Release removes the flag. Only user-level and project-level `.agents/skills` and `.dsh/skills` are accepted, after a source allowlist, strict root containment and a realpath check',
+      where: 'Tool Tailor -> Skills (skill tool)',
+    },
+    {
+      text: '**Connector cards now say whether the connector is actually connected**: an installed connector with zero tools is labelled "not connected" or "needs authorization" (401/403 failures that reconnecting cannot fix), with Reconnect or Re-authorize offered right there. Details show the authorization expiry; when the server issued a refresh_token, Refresh authorization renews it and writes the new credential back to the config, falling back to browser authorization if that fails. CLI-based connectors also get a local-dependency check',
+      where: 'Market -> Connectors',
+    },
+    {
+      text: '**Your expert choice is remembered per session**: an attached expert is recorded in `~/.dsh/wb-market/experts/session-persona.json` (only which session has which expert), so switching sessions, restarting the host, or an agent rebuild after context compaction brings it back automatically; only the × button cancels it for good. Stand-in personas are never persisted, so generated text is not remembered as the original',
+      where: 'Summon menu -> Experts / session header badge',
+    },
+    {
+      text: '**Two lifecycle fixes**: a project `.dsh/mcp.json` added while a session is already open is registered and reconciled immediately, with no need to start a new session (issue #6); on a headless host with no `xdg-open`, clicking Authorize no longer takes the host process down with it (issue #7)',
+      where: 'Project MCP / Connector authorization',
+    },
+    {
+      text: '**Security hardening and a faster market**: external links are https-only (http only for loopback), skill paths are trusted only from the host registry, community repository links filter out pseudo-protocols, and skill-disable writes are pinned to the four skills roots; the host market modules load on demand, the first paint prefetches only the current tab, snapshots are written on an idle frame after a signature comparison, the skill list uses stale-while-revalidate, and hovering a card prefetches its details — switching tabs no longer reparses and rewrites the whole directory',
+      where: 'Market / Security',
+    },
+  ],
 };
 
 /**

package/lib/whats-new.js

@@ -550,4 +550,33 @@ export const WHATS_NEW = [
       },
     ],
   },
+  {
+    version: '2.4.4',
+    items: [
+      {
+        text: '**连接器页新增「社区 MCP」来源**：直读官方 MCP Registry，不依赖 WorkBuddy 账号；支持关键词搜索、游标翻页、只看 npx / uvx 可直接运行，详情给出启动命令、参数与环境变量，点「加入 MCP」只预填表单，确认后才写配置。社区条目未经军械库审核，面板常驻声明提醒自行确认命令与环境变量',
+        where: '市场 → 连接器 → 来源切换',
+      },
+      {
+        text: '**工具裁缝的技能账本可禁用 / 释放技能**：行内「禁用」写 SKILL.md 的官方键 `disable-model-invocation`，模型不再加载该技能、不再缴它的上下文税，手动 `/` 引用不受影响；点「释放」恢复。只对用户级 / 项目级的 `.agents/skills` 与 `.dsh/skills` 开放，写入前过来源白名单、根目录包含性与 realpath 校验',
+        where: '工具裁缝 → 技能（skill 工具）',
+      },
+      {
+        text: '**连接器卡片先说清「到底连没连上」**：已安装但工具数为 0 时区分「未连接」与「需授权」（401/403 类失败，重连不会恢复），并就地给出「重连」或「重新授权」；详情显示授权有效期，有 refresh_token 的可直接「刷新授权」把新凭据写回配置，刷不动自动回到浏览器授权；CLI 型连接器另给「本机依赖」检查',
+        where: '市场 → 连接器',
+      },
+      {
+        text: '**专家选择随会话记住**：挂上的专家写进 `~/.dsh/wb-market/experts/session-persona.json`（只记哪个会话挂了谁），切会话、宿主重启、上下文压缩后 agent 重建都会自动补回；点 × 才是永久取消。替身人设不落盘，避免把生成的正文当成原文记住',
+        where: '召唤菜单 → 专家 / 会话标题栏徽章',
+      },
+      {
+        text: '**项目 MCP 与会话生命周期的两处修正**：项目还没有 `.dsh/mcp.json` 时会话也会先登记，之后新加的配置立刻对齐到已开着的会话，不必等新会话（issue #6）；headless 主机没有 `xdg-open` 时，点「安装」触发授权不再把宿主进程一起带走（issue #7）',
+        where: '项目 MCP / 连接器授权',
+      },
+      {
+        text: '**安全加固与市场加载提速**：外链只允许 https（http 仅本机回环），技能路径只信宿主注册表，社区仓库链接过滤伪协议，技能禁用的写入面钉死在四类 skills 根；宿主市场数据层改为按需加载，首屏只预取当前页签，快照先比签名再在空闲帧写盘，技能列表走 SWR、卡片 hover 预取详情，切页不再重付整份目录的解析与写盘',
+        where: '市场 / 安全',
+      },
+    ],
+  },
 ]

package/lib/workspace-runtime.js

@@ -508,6 +508,25 @@ function repointConnectionSlots(ctx, previous, entry) {
 	}
 	return repointed;
 }
+// 宿主 agents 服务里的存活会话，作为 agent/created 之外的兜底来源。
+// 为什么需要兜底：本代挂载只覆盖「本代上线之后创建的会话」。插件被宿主热加载
+// （改 profile patch 触发重载）时，旧代登记过的会话仍在跑，却不在新代的
+// agentWorkspaceStates 里；只靠事件的话，它们要等下一次创建才重新进入管理，
+// 期间新增的项目 MCP 对它们无效。写盘对齐时扫一遍活会话把它们并进来，
+// 代价只是一次 list()；拿不到服务（旧宿主/作用域外调用）时退化为空表。
+function liveAgentsOf(ctx) {
+	const get = typeof ctx.get === "function" ? ctx.get.bind(ctx) : null;
+	const agents = get && get("agents");
+	if (!agents || typeof agents.list !== "function") return [];
+	try {
+		return agents.list() || [];
+	} catch (error) {
+		// 不能静默吞：兜底来源失效时用户只会看到「写盘后历史会话没吃到新配置」。
+		// 同一条故障只打一次（reconcile 每 5s 会走到这里）。
+		warnDiagnosticOnce(ctx?.logger, "live-agents", `armory: 读取存活会话失败（项目 MCP 兜底同步暂停）：${error?.message || error}`);
+		return [];
+	}
+}
 // 配置 → 连接集的唯一同步点：**写盘之后**调用，把该项目对齐到新配置。
 //   1. 配置里已不存在、或配置已变化的连接立刻 retire（不做空闲等待：它已经"不再有效"）；
 //   2. 对每个存活会话重跑一次挂载（幂等）：缺的连上、换掉的重新投射、已有的当场归还多余引用。
@@ -548,6 +567,16 @@ async function reconcileWorkspaceConnections(ctx, wsPath) {
 		await mountProjectMcpForAgent(ctx, agent, generation, { awaitReady: false });
 		remounted += 1;
 	}
+	// 兜底：并入本代尚未登记、但确实活在这个项目里的会话（见 liveAgentsOf）。
+	// 正常情况下这一步是空转；热加载换代后它负责让「历史会话」也吃到本次写盘。
+	for (const agent of liveAgentsOf(ctx)) {
+		if (!agent || agentWorkspaceStates.has(agent)) continue;
+		const cwd = agent.session?.header?.cwd;
+		if (typeof cwd !== "string" || cwd.length === 0) continue;
+		if (canonicalWorkspacePath(cwd) !== wsPath) continue;
+		await mountProjectMcpForAgent(ctx, agent, generation, { awaitReady: false });
+		remounted += 1;
+	}
 	return { retired, remounted };
 }
 function agentSlotIndex(ctx, agent) {
@@ -1155,11 +1184,16 @@ async function mountProjectMcpForAgent(ctx, agent, generation, options = {}) {
 	if (typeof cwd === "string" && cwd.length > 0) {
 		const wsPath = canonicalWorkspacePath(cwd);
 		try {
+			// **先登记、再读配置**：项目 MCP 最常见的添加时机，正是这个项目已经开着会话、
+			// 但还没有 `.dsh/mcp.json` 的时候（第一次加）。若这里因为 config.missing 跳过登记，
+			// 之后面板写盘时的 reconcileWorkspaceConnections 就遍历不到这个会话（它只认
+			// agentWorkspaceStates），新增的 server 只能等用户新开会话——正是 issue #6 的现象。
+			// 登记只是记账，不建连、不注册工具；没有配置时它没有任何可观察副作用。
+			// 会话记录只承载「本会话属于哪个项目 + restrict 展开到哪一步」。它不再是任何
+			// 存活性凭据：共享连接的引用由 commitSharedConnection 交给 cordis 的 effect 持有。
+			ensureAgentWorkspaceState(ctx, agentCtx, agent, wsPath);
 			const config = await readWorkspaceConfigCached(ctx, wsPath);
 			if (!config.error && !config.missing) {
-				// 会话记录只承载「本会话属于哪个项目 + restrict 展开到哪一步」。它不再是任何
-				// 存活性凭据：共享连接的引用由 commitSharedConnection 交给 cordis 的 effect 持有。
-				ensureAgentWorkspaceState(ctx, agentCtx, agent, wsPath);
 				// 本次挂载的共享就绪预算（见 waitForConnectionReady）：取各 server 上限里的最大值，
 				// 而不是逐个相加 —— 预算是给「这次会话创建」的，不是给每个 server 各发一份。
 				let readyDeadline = Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-armory",
-  "version": "2.4.3",
+  "version": "2.4.4",
   "description": "Unified Skill + MCP + Expert + Plugin board for DeepSeek Harness (desktop app and Web GUI) — custom skill suites, skill install/uninstall with live refresh, global panel page, JSON import, WorkBuddy connector & SkillHub & Expert & DSH community plugin market installs, MCP OAuth authorization, tool-usage tailor with wire-tax trends, and profile-backed Host Remote management.",
   "repository": {
     "type": "git",