dsh-armory 2.3.1 → 2.4.0

package/lib/index.js

@@ -14,6 +14,8 @@ import { deriveMcpPhase, formatMcpLog, sanitizeMcpLog } from "./mcp-observabilit
 import { allMcpEntries, entriesForName, projectToolSchema, revisionOf, toolInventory } from "./mcp-registry.js";
 // Skill 看板的卸载落盘点：来源白名单 + 根目录包含性 + 符号链接/根目录校验（lib/skill-remove.js）。
 import { removeSkillFromDisk } from "./skill-remove.js";
+// Skill 看板的安装时间 + 市场原名投影（名字自建映射，lib/skill-dir-times.js）。
+import { skillInstallInfo } from "./skill-dir-times.js";
 import { WHATS_NEW } from "./whats-new.js";
 import { attachWhatsNewEnglish } from "./whats-new-en.js";
 import { probeMcpServersAuthorization, wbConnectorCatalog, wbConnectorCachedCount, wbConnectorIcon, wbConnectorPreview, wbSkillCatalog, wbSkillDetail, wbSkillInstall, wbSkillInstalled, wbSkillUninstall } from "./wb-market.js";
@@ -38,6 +40,8 @@ import {
 	cancelAuthorization as oauthCancel,
 	clearTokenRecord as oauthClearToken,
 	ensureAccessToken as oauthEnsureToken,
+	isSerializedGarbageCredential as oauthIsGarbageCredential,
+	isUsableBearerToken as oauthIsUsableToken,
 	saveManualToken as oauthSaveManualToken,
 	submitCallback as oauthSubmitCallback,
 } from "./mcp-oauth.js";
@@ -121,6 +125,24 @@ function withBearerHeader(rawServer, token) {
 	return { ...rawServer, headers };
 }
 
+/**
+ * 摘掉一个已经坏掉的 authorization 头（保留其它头、保留原键名大小写）。
+ * 只给「确认是序列化残骸」的配置用：历史版本把 `Bearer [object Object]` 写进了
+ * 用户的 patch，那条头不删掉，服务器就从「你没带凭据」(401) 变成「你凭据是坏的」(400)，
+ * 装前探测因此再也认不出这是鉴权问题，用户既装不上也看不到授权入口。
+ */
+function stripBearerHeader(rawServer) {
+	const container = rawServer && typeof rawServer.transport === "object" ? rawServer.transport : rawServer;
+	const headers = container?.headers;
+	if (!headers || typeof headers !== "object" || Array.isArray(headers)) return rawServer;
+	const next = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (String(key).toLowerCase() !== "authorization") next[key] = value;
+	}
+	const patched = { ...container, headers: next };
+	return rawServer && typeof rawServer.transport === "object" ? { ...rawServer, transport: patched } : patched;
+}
+
 /**
  * 安装前把已落盘的 access_token 注进对应 server 的 headers。
  * 读不到 / 过期且刷不动就原样返回，交给 probe 去判定「需要授权」——
@@ -131,17 +153,27 @@ async function injectStoredOAuthTokens(mcpServers) {
 	const out = {};
 	for (const [serverName, rawServer] of Object.entries(mcpServers)) {
 		const spec = nestedServerSpec(rawServer);
-		if (!isOAuthCandidate(spec) || spec.headers.authorization) {
+		// 配置里已有的 authorization 一律优先：可能是用户手填的真令牌，也可能是 R7
+		// 的 ${...} 占位符（那种要原样保留、由 missingSlots 回报面板补填）。
+		const declared = spec.headers.authorization;
+		const poisoned = Boolean(declared) && oauthIsGarbageCredential(declared);
+		if (!isOAuthCandidate(spec) || (declared && !poisoned)) {
 			out[serverName] = rawServer;
 			continue;
 		}
 		let token = "";
 		try {
-			token = String((await oauthEnsureToken(spec.url)) || "");
+			// ensureAccessToken 回的是 {ok, accessToken, refreshed, error} 对象，不是字符串。
+			// 这里曾经直接对那个对象取字符串：得到 "[object Object]"，真值、非空，
+			// 于是每个 HTTP 连接器都被注进 `authorization: Bearer [object Object]`
+			// —— 装上必挂，还把服务器的 401 伪装成 400（见 test/auth-gate-regression.mjs 第 7 节）。
+			const result = await oauthEnsureToken(spec.url);
+			if (result?.ok && oauthIsUsableToken(result.accessToken)) token = String(result.accessToken).replace(/^Bearer\s+/i, "").trim();
 		} catch {
 			token = "";
 		}
-		out[serverName] = token ? withBearerHeader(rawServer, token) : rawServer;
+		if (token) out[serverName] = withBearerHeader(rawServer, token);
+		else out[serverName] = poisoned ? stripBearerHeader(rawServer) : rawServer;
 	}
 	return out;
 }
@@ -155,7 +187,12 @@ async function resolveOAuthTarget(connectorId, serverName) {
 	if (!rawServer) throw new Error(`连接器 ${connectorId} 里没有 server「${name || "（空）"}」`);
 	const spec = nestedServerSpec(rawServer);
 	if (!spec.url) throw new Error(`server「${name}」没有可授权的 URL（stdio 型不需要 OAuth 授权）`);
-	return { serverName: name, url: spec.url, headers: spec.headers, transport: spec.transport };
+	// 坏掉的 authorization 不能跟着去探测：带着 `Bearer [object Object]` 打过去，服务器
+	// 回的是 400「token parse failed」而不是 401「empty access token」，授权发现
+	// 那条路就在第一步被判定成「非鉴权错误」而中止。
+	const headers = { ...spec.headers };
+	if (headers.authorization && oauthIsGarbageCredential(headers.authorization)) delete headers.authorization;
+	return { serverName: name, url: spec.url, headers, transport: spec.transport };
 }
 
 /** 宿主 shell 服务的几种可能落点，逐个试；拿不到就返回 undefined 走系统兜底。 */
@@ -1780,6 +1817,12 @@ let McpManagerGateway = (() => {
 		if (result === undefined) throw new Error("宿主没有挂载 skill 注册表（@deepseek-ai/dsh-skill），无法卸载");
 		return { note: `已卸载 ${name}（${result.kind === "symlink" ? "符号链接" : "目录"}：${result.path}）` };
 	}
+	// 安装时间 + 市场原名（按 skill 名字索引）：宿主自扫标准技能根目录、读 SKILL.md
+	// 头部 name 建立映射——不依赖 listSkills 行里的 path（注册表可能整列不给）。
+	// 永不抛错——时间与原名是辅助信息，单个目录读失败只是没有该条目，不该拖垮看板。
+	async skillInstallInfo(payload) {
+		return skillInstallInfo(payload || {});
+	}
 	// ── 自定义套件（Skill 看板）─────────────────────────────────────────
 	// 数据层在 lib/suites-registry.js（~/.dsh/armory/suites.json）；这里只做 RPC 转发。
 	//   listSkillSuites —— 永不抛错：文件缺失 / JSON 损坏 / 结构不对都回落空集合，
@@ -1884,6 +1927,10 @@ let McpManagerGateway = (() => {
 				error: started?.error || "授权流程启动失败",
 				mode: started?.mode || "",
 				redirectUri: started?.redirectUri || "",
+				// 授权页这条路走不通（服务器不提供 OAuth 发现、动态注册被拒…）时，
+				// 手填令牌仍然是可用通道：把它交给面板，别只留一行红字。
+				manualTokenOnly: started?.manualTokenOnly === true,
+				serverUrl: started?.serverUrl || target.url,
 			};
 		}
 		// 默认由宿主直接把授权页推给系统浏览器；open:false 留给面板自己渲染链接。

package/lib/mcp-oauth.js

@@ -29,7 +29,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 /** 插件版本：DCR 的 clientInfo 与 UA 共用一处，避免两边各自漂移。 */
-const PLUGIN_VERSION = "2.3.1";
+const PLUGIN_VERSION = "2.3.2";
 const USER_AGENT = `dsh-armory/${PLUGIN_VERSION} (+mcp-oauth)`;
 const NET_TIMEOUT_MS = 15_000;
 /** 授权流程整体存活时间：超过就判过期，避免会话表无限增长。 */
@@ -59,6 +59,69 @@ function sha256hex(text) {
   return createHash("sha256").update(String(text)).digest("hex");
 }
 
+// ── 凭据形状 ────────────────────────────────────────────────────────────
+// 这一层存在的理由是一条真实事故：`ensureAccessToken()` 返回的是对象
+// `{ok, accessToken, ...}`，调用方写成 `String(await ensureAccessToken(url))` 就得到
+// `"[object Object]"` —— 真值、非空、于是被当成正经令牌注进 `authorization` 头并落盘。
+// 服务器收到后回的不是 401「empty access token」而是 400「token parse failed」，
+// 装前探测只认 401/403，于是「需要授权」被彻底漏判：配置写进去了、授权页永远不弹、
+// 连接永远失败。所以「什么才算一个能用的令牌」必须只写一次、放在这里。
+
+/** Bearer 令牌长度上限：正常签发物不会这么长，超长基本是把整坨响应粘回来了。 */
+const BEARER_TOKEN_MAX = 8192;
+
+/** 去掉可选的 `Bearer ` 前缀与首尾空白（光杆一个 "Bearer" 等于没有令牌）。 */
+function stripBearerPrefix(value) {
+  return String(value ?? "").replace(/^\s*Bearer\b[ \t]*/i, "").trim();
+}
+
+/**
+ * 一眼假：序列化残骸（`[object Object]` / `undefined` / `NaN`）、空值、光杆 `Bearer`。
+ * 未替换的 `${TOKEN}` 占位符**不算**残骸——那是 R7 令牌引导的合法中间态，
+ * 由 `missingSlots` 单独回报面板，不能被这里悄悄抹掉。
+ */
+export function isSerializedGarbageCredential(value) {
+  if (value === null || value === undefined) return true;
+  if (typeof value !== "string") return true;
+  const text = value.trim();
+  if (!text) return true;
+  if (/^\[object\s+\w+\]$/i.test(text) || /\[object\s+\w+\]/i.test(text)) return true;
+  if (/^(?:undefined|null|NaN)$/i.test(stripBearerPrefix(text))) return true;
+  return !stripBearerPrefix(text);
+}
+
+/** 是不是一个可以原样发给服务器的 access token。 */
+export function isUsableBearerToken(value) {
+  if (isSerializedGarbageCredential(value)) return false;
+  const token = stripBearerPrefix(value);
+  if (token.length > BEARER_TOKEN_MAX) return false;
+  if (/\$\{[^}]*\}/.test(token)) return false;
+  // 控制符/换行：HTTP 头里出现就是注入面（fetch 也会拒），一律视为不可用。
+  return !/[\u0000-\u001f\u007f\u0080-\u009f]/.test(token);
+}
+
+// ── 「这是鉴权失败吗」判定 ───────────────────────────────────────────────
+
+/**
+ * 各家网关的鉴权失败措辞（JSON-RPC error.message 里常见）。刻意只列鉴权语义，
+ * 不收 "not found" / "invalid params" 这类——把服务器故障判成「要授权」会把用户
+ * 引到一条根本走不通的授权路上。
+ */
+const AUTH_BODY_RE =
+  /(empty access token|access token (?:empty|missing|invalid)|token parse|invalid[ _-]?token|missing[ _-]?token|no (?:access )?token|token (?:expired|invalid)|unauthorized|unauthenticated|(?:authentication|authorization) (?:failed|error|required)|(?:需要|请)(?:登录|授权|鉴权))/i;
+
+/**
+ * 一次 MCP 握手失败是不是「缺凭据」。
+ * 401/403 无条件算；其它 4xx 只有在响应体明确说鉴权时才算（腾讯 ima 就是 400 +
+ * `msg:token parse failed`，且不带 `WWW-Authenticate`）；2xx/3xx/5xx 一律不算。
+ */
+export function mcpAuthFailure(status, bodyText = "") {
+  const code = Number(status) || 0;
+  if (code === 401 || code === 403) return true;
+  if (code < 400 || code >= 500) return false;
+  return AUTH_BODY_RE.test(String(bodyText || ""));
+}
+
 /** PKCE 授权码流程的 verifier/challenge（S256）。 */
 export function createPkce() {
   const verifier = b64url(randomBytes(48));
@@ -114,8 +177,8 @@ async function fetchJson(url, init = {}) {
 // ── 探测 ────────────────────────────────────────────────────────────────
 
 /**
- * 打一次 MCP initialize，拿回状态码与 `WWW-Authenticate`。
- * 只用于确认「这颗 server 是不是 401 且声明了 OAuth」，不做其它判断。
+ * 打一次 MCP initialize，拿回状态码、`WWW-Authenticate` 与响应体摘要。
+ * 只用于确认「这颗 server 是不是要凭据」，不做其它判断。
  */
 export async function probeServer(serverUrl, headers = {}) {
   const body = JSON.stringify({
@@ -142,16 +205,18 @@ export async function probeServer(serverUrl, headers = {}) {
       },
       body
     });
-    // 读掉 body，避免 socket 悬挂
-    await response.text().catch(() => "");
+    // 读掉 body，避免 socket 悬挂；正文还要留给鉴权判定（不少网关 400 也带鉴权语义）。
+    const text = await response.text().catch(() => "");
     return {
       ok: true,
       status: response.status,
       wwwAuthenticate: response.headers.get("www-authenticate") || "",
+      body: trimText(text, 400),
+      authRequired: mcpAuthFailure(response.status, text),
       error: ""
     };
   } catch (error) {
-    return { ok: false, status: 0, wwwAuthenticate: "", error: String(error?.message || error) };
+    return { ok: false, status: 0, wwwAuthenticate: "", body: "", authRequired: false, error: String(error?.message || error) };
   }
 }
 
@@ -439,7 +504,8 @@ export async function clearTokenRecord(serverUrl) {
 
 /** 记录里是否有一个「还没过期」的 access token（留 60s 余量）。 */
 export function tokenIsFresh(record) {
-  if (!record || !str(record.accessToken)) return false;
+  // 形状先于时效：`[object Object]` 这种残骸哪怕带着未来的 expiresAt 也不是令牌。
+  if (!record || !isUsableBearerToken(record.accessToken)) return false;
   if (!record.expiresAt) return true; // 服务器没给 expires_in：视为长期有效，等 401 再说
   // 落盘时写的是 ISO 串（见 exchangeCode），但令牌库是纯 JSON、可能被人手改或由
   // 旧版本写成数字毫秒，两种都认：数字直接当时间戳，字符串才走 Date.parse。
@@ -478,7 +544,7 @@ async function refreshAccessToken(record) {
     headers: { "content-type": "application/x-www-form-urlencoded" },
     body: body.toString()
   });
-  if (!result.ok || !str(result.json?.access_token)) {
+  if (!result.ok || !isUsableBearerToken(result.json?.access_token)) {
     return { ok: false, accessToken: "", error: `刷新 token 失败（HTTP ${result.status || "网络错误"}）：${trimText(result.text)}` };
   }
   await writeTokenRecord(record.serverUrl, tokenRecordPatch(result.json));
@@ -512,20 +578,35 @@ function tokenRecordPatch(tokenResponse) {
 export async function beginAuthorization({ serverName, serverUrl, headers = {}, clientName = "DeepSeek Harness" } = {}) {
   if (!serverUrl) return fail("", "", "", "缺少 server url");
   const probe = await probeServer(serverUrl, headers);
-  if (!probe.ok) return fail("", "", "", `无法连接 ${serverUrl}：${probe.error}`);
-  if (probe.status !== 401 && probe.status !== 403) {
-    // 有些服务器首次 initialize 回 200，鉴权在 tools/call 才触发；这里仍允许继续试一次。
-    if (probe.status >= 400 && probe.status !== 401 && probe.status !== 403) {
-      return fail("", "", "", `服务器返回 HTTP ${probe.status}，不是预期的 401/403，无法确认其 OAuth 要求`);
-    }
+  if (!probe.ok) return fail("", "", "", `无法连接 ${serverUrl}：${probe.error}`, { serverUrl });
+  if (probe.status >= 400 && !probe.authRequired) {
+    // 明确的非鉴权失败（404 路径错、500 服务器挂了…）：继续往下走只会把用户
+    // 引到一条根本不存在的授权路上，直接说清楚更省时间。
+    return fail("", "", "", `服务器返回 HTTP ${probe.status}，不是预期的鉴权错误：${probe.body || "（无响应体）"}`, { serverUrl });
   }
+  // 到这里要么服务器点名要凭据（401/403/4xx 鉴权体），要么匿名握手就过了
+  // （有些实现把鉴权推迟到 tools/call）——两种都继续试一次发现流程。
 
   const resource = await resolveProtectedResource({ serverUrl, wwwAuthenticate: probe.wwwAuthenticate });
-  if (!resource.ok) return fail("", "", "", resource.error);
+  if (!resource.ok) return fail("", "", "", resource.error, { serverUrl, manualTokenOnly: true });
   const as = await resolveAuthorizationServer(resource.authorizationServers[0]);
-  if (!as.ok) return fail("", "", "", as.error);
+  if (!as.ok) {
+    // 现实里很常见：服务器要 Bearer token，但压根不实现 RFC 9728/8414 的 well-known
+    // 发现（腾讯 ima 就是这样）。这时没有任何 authorizeUrl 可开，硬报错等于把用户
+    // 关在门外——回 manualTokenOnly，让面板把手填令牌那条兜底路摊开给他。
+    return fail("", "", "", `${as.error}\n该服务器没有提供标准 OAuth 授权发现，无法自动打开授权页；如果你已有访问令牌，可以直接粘贴安装。`, {
+      serverUrl,
+      manualTokenOnly: true
+    });
+  }
   if (!as.tokenEndpointAuthMethods.includes("none")) {
-    return fail("", "", "", `该授权服务器要求客户端认证（${as.tokenEndpointAuthMethods.join("/")}），本插件只支持公共客户端（none）`);
+    return fail(
+      "",
+      "",
+      "",
+      `该授权服务器要求客户端认证（${as.tokenEndpointAuthMethods.join("/")}），本插件只支持公共客户端（none）；如果你已有访问令牌，可以直接粘贴安装。`,
+      { serverUrl, manualTokenOnly: true }
+    );
   }
 
   const scope = as.scopesSupported.length ? as.scopesSupported.join(" ") : "";
@@ -543,13 +624,22 @@ export async function beginAuthorization({ serverName, serverUrl, headers = {},
     const template = extractExpectedRedirectUri(registration.raw || registration.error);
     if (!template) {
       loopback.close();
-      return fail("", "", "", registration.error);
+      return fail("", "", "", `${registration.error}\n动态注册走不通，无法生成授权页；如果你已有访问令牌，可以直接粘贴安装。`, {
+        serverUrl,
+        manualTokenOnly: true
+      });
     }
     const expected = substituteRedirectPlaceholder(template, serverName || clientName);
     const retry = await registerClient(as, { redirectUri: expected, clientName, scope });
     if (!retry.ok) {
       loopback.close();
-      return fail("", "", "", `${registration.error}\n改用服务器指定的回调地址 ${expected} 重试仍失败：${retry.error}`);
+      return fail(
+        "",
+        "",
+        "",
+        `${registration.error}\n改用服务器指定的回调地址 ${expected} 重试仍失败：${retry.error}\n如果你已有访问令牌，可以直接粘贴安装。`,
+        { serverUrl, manualTokenOnly: true }
+      );
     }
     registration = retry;
     redirectUri = expected;
@@ -619,8 +709,21 @@ function buildAuthorizeUrl({ authorizationEndpoint, clientId, redirectUri, scope
   return url.href;
 }
 
-function fail(sessionId, authorizeUrl, mode, error) {
-  return { ok: false, sessionId, authorizeUrl, mode, redirectUri: "", hint: "", error };
+function fail(sessionId, authorizeUrl, mode, error, extra = {}) {
+  return {
+    ok: false,
+    sessionId,
+    authorizeUrl,
+    mode,
+    redirectUri: "",
+    hint: "",
+    // manualTokenOnly：授权页这条路走不通，但「手填访问令牌」仍然可用。面板据此
+    // 也要把弹层开出来（而不是只甩一行红字），否则用户看到的是死路。
+    manualTokenOnly: false,
+    serverUrl: "",
+    error,
+    ...extra
+  };
 }
 
 function pruneSessions() {
@@ -667,7 +770,7 @@ async function exchangeCode(session, code) {
     headers: { "content-type": "application/x-www-form-urlencoded" },
     body: body.toString()
   });
-  if (!result.ok || !str(result.json?.access_token)) {
+  if (!result.ok || !isUsableBearerToken(result.json?.access_token)) {
     session.status = "failed";
     session.error = `换取 token 失败（HTTP ${result.status || "网络错误"}）：${trimText(result.text)}`;
     return;
@@ -775,8 +878,12 @@ export async function saveManualToken({ serverUrl, serverName = "", token, token
   const raw = String(token || "").trim();
   if (!serverUrl) return { ok: false, error: "缺少 server url" };
   if (!raw) return { ok: false, error: "token 不能为空" };
-  const accessToken = raw.replace(/^Bearer\s+/i, "").trim();
+  const accessToken = stripBearerPrefix(raw);
   if (!accessToken) return { ok: false, error: "token 不能为空" };
+  // 手填这条路最容易粘进残骸（`[object Object]`、没替换的 ${TOKEN}、带换行的整段 curl）。
+  if (!isUsableBearerToken(accessToken)) {
+    return { ok: false, error: "这不像是个可用的访问令牌（空值、未替换的 ${...} 占位符或序列化残骸），请重新从服务方复制。" };
+  }
   await writeTokenRecord(serverUrl, {
     accessToken,
     tokenType: "Bearer",

package/lib/skill-dir-times.js

@@ -0,0 +1,111 @@
+// Skill 看板的「安装时间 + 市场原名」投影（按 skill 名字索引）。
+//
+// 为什么不按 listSkills 行里的 path 查：宿主注册表的行**不一定**带 path（字段是条件
+// 展开，lib/index.js 只透传注册表给的），实测有的版本整列都缺——按 path 查会整表静默
+// 落空。这里改为宿主自建映射：扫描标准技能根目录，读每个目录 SKILL.md 头部的
+// `name:` 字段得到「看板显示名」，建立 名字 → 目录 → 时间/原名 的映射，按名字返回。
+// 面板的每一行必有 name（看板主键），join 永不落空。
+//
+// installedAt 取值优先级（与 wb-market.wbSkillInstalled 同一口径）：
+//   ① 安装状态账本（kind=skill，按 installPath 归一对齐）登记的首次安装时间；
+//   ② 目录创建时间——重装 = rm 后 rename 换入新目录，创建时间即最近一次落盘；
+//   ③ 目录修改时间兜底（个别文件系统不吐 birthtime）。
+// 没有 SKILL.md 的目录不会被注册表发现，直接跳过；同名目录按扫描序首个优先
+// （agents 根在 dsh 根之前，与注册表的来源优先级同向）。
+// 账本命中的条目附带 marketName / marketplace / marketVersion：账本登记的是市场里的
+// 名字，看板显示的是 SKILL.md 的 name 字段——两者可以不同，投影出去供面板对应。
+//
+// 纯只读（readdir / stat / 只读 SKILL.md 头部 4KB）；账本读失败只降级到 ②③。
+// 存储根目录可注入（options.rootDir / DSH_ARMORY_HOME），home 可注入（options.home，测试用）。
+import { open, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { listInstalled } from "./wb-install-state.js";
+
+/** join 键归一：分隔符统一 /、去尾斜杠。账本 installPath 与实际扫描目录是两套来源，
+ *  Windows 下分隔符与结尾斜杠可能有差异，对齐前先拉齐形态。 */
+const normPath = (value) => String(value || "").trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "");
+
+/** 只读文件头部 4KB——frontmatter 永远在最前面，整读大 SKILL.md 不值得。 */
+async function head(path, bytes = 4096) {
+  const handle = await open(path, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
+/** SKILL.md 头部 frontmatter 的 name 字段；没有 frontmatter / 没写 name 返回空串。 */
+export function frontmatterName(text) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---/.exec(String(text || ""));
+  if (!block) return "";
+  const line = /^name:[ \t]*(.+?)[ \t]*$/m.exec(block[1]);
+  return line ? line[1].replace(/^["']|["']$/g, "") : "";
+}
+
+/**
+ * 扫描技能根目录，返回「看板名字 → 安装信息」映射。
+ * @param {object} payload 客户端信封：{ cwd? }（项目作用域时带项目根）
+ * @returns {Promise<{info: Record<string, {installedAt: number, dir: string,
+ *   marketName?: string, marketplace?: string, marketVersion?: string}>}>}
+ */
+export async function skillInstallInfo(payload = {}, options = {}) {
+  const home = options.home || homedir();
+  const roots = [
+    join(home, ".agents", "skills"),
+    join(home, ".dsh", "skills"),
+  ];
+  const cwd = String(payload?.cwd || "").trim();
+  if (cwd) {
+    roots.push(join(cwd, ".agents", "skills"));
+    roots.push(join(cwd, ".dsh", "skills"));
+  }
+  const ledger = await listInstalled("skill", options).catch(() => []);
+  const byPath = new Map(
+    ledger.filter((row) => row && row.installPath).map((row) => [normPath(row.installPath), row]),
+  );
+  const info = {};
+  for (const root of roots) {
+    let entries = [];
+    try {
+      entries = await readdir(root);
+    } catch {
+      continue; // 根目录不存在（没装过任何市场技能 / 没有 ~/.dsh/skills）：跳过
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const dir = join(root, entry);
+      let dirStat;
+      try {
+        dirStat = await stat(dir);
+      } catch {
+        continue; // 竞态删除等：跳过
+      }
+      if (!dirStat.isDirectory()) continue;
+      let name = "";
+      try {
+        name = frontmatterName(await head(join(dir, "SKILL.md")));
+      } catch {
+        continue; // 没有 SKILL.md：注册表发现不了，不进映射
+      }
+      if (!name) name = entry;
+      if (info[name]) continue; // 同名：首个根/首个目录优先
+      const hit = byPath.get(normPath(dir));
+      const bornAt = Math.round(Number(dirStat.birthtimeMs) || 0);
+      const row = {
+        installedAt: (hit?.installedAt || 0) || bornAt || Math.round(Number(dirStat.mtimeMs) || 0),
+        dir,
+      };
+      if (hit?.name) {
+        row.marketName = hit.name;
+        row.marketplace = hit.source?.marketplace || "";
+        row.marketVersion = hit.version || "";
+      }
+      info[name] = row;
+    }
+  }
+  return { info };
+}

package/lib/typert.js

@@ -77,6 +77,11 @@ export const TYPERT = {
     // 卸载已安装 skill：永久删除用户级/项目级 skills 根目录内的条目。三处契约缺一即 404，
     // 删除规则全在 lib/skill-remove.js（来源白名单 / 根目录包含性 / 符号链接只删链接）。
     mv('removeSkill', [payloadParam], 'NoteResult'),
+    // 安装时间 + 市场原名（Skill 看板卡片徽标 /「最近安装」排序的数据源）：宿主自扫
+    // 标准根目录按 SKILL.md name 建映射，出 { ok, info: { [name]: { installedAt, ... } } }。
+    // 不按 listSkills 行的 path 查——注册表行可能整列缺 path（实测）。形状由
+    // lib/skill-dir-times.js 校验，与 wb* 系列同一宽容度（payload $any）。
+    mv('skillInstallInfo', [payloadParam], 'SkillInstallInfoResult'),
     // 自定义套件（Skill 看板的「一组相关 skill 打包引用」）：读 = 全量集合，
     // 存 = 整集合覆盖（UI 一次提交右侧全部套件，不做增量 upsert）。数据层在
     // lib/suites-registry.js，id 分配 / 成员去重保序 / 脏数据拒绝都在那边，