@noob-stupid/dsh-plugin-console 0.3.47 → 0.3.49

package/lib/index.js

@@ -594,7 +594,7 @@ async function removeBundleFromManifest(profileDir, bundlePkg) {
 /** 用 corepack pnpm 移除包（与安装同一管理器与凭据抑制环境）。
  * 注意：pnpm remove 不支持 --registry 选项，去掉避免静默失败。 */
 async function pnpmRemove(profileDir, packageName) {
-  const args = ['pnpm', 'remove', packageName]
+  const args = ['remove', packageName]
   const opts = {
     cwd: profileDir,
     timeout: 120000,
@@ -602,17 +602,8 @@ async function pnpmRemove(profileDir, packageName) {
     maxBuffer: 4 * 1024 * 1024,
     env: { ...process.env, COREPACK_NPM_REGISTRY: 'https://registry.npmmirror.com', GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' },
   }
-  if (process.platform === 'win32') {
-    const corepackJs = join(dirname(process.execPath), 'node_modules', 'corepack', 'dist', 'corepack.js')
-    if (existsSync(corepackJs)) {
-      await execFileAsync(process.execPath, [corepackJs, ...args], opts)
-      return
-    }
-    const cmd = `${JSON.stringify('corepack')} ${args.map((arg) => JSON.stringify(arg)).join(' ')}`
-    await execFileAsync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/s', '/c', cmd], opts)
-    return
-  }
-  await execFileAsync('corepack', args, opts)
+  // 跨平台定位 corepack/pnpm（Linux 的 corepack 不在 <node bin>/node_modules 下，2026-09-20 事故）
+  await runPnpmWithFallback(args, { execOpts: opts })
 }
 
 /** 清理陈旧包目录与 pnpm _tmp_ 残留（Windows 原子替换 EPERM 的根因），返回清理数量。 */
@@ -645,7 +636,7 @@ function cleanupStalePackageDir(profileDir, packageName) {
 const SOURCES_FILE = join(dshHome(), 'plugin-console-sources.json')
 /** 敏感凭据单独落盘（避免与可分享配置混存）：自定义搜索源 headers + Gitee secret/token。 */
 const SOURCES_SECRETS_FILE = join(dshHome(), 'plugin-console-sources.secrets.json')
-const DEFAULT_SOURCES = {
+export const DEFAULT_SOURCES = {
   registries: [
     { id: 'npmmirror', name: 'npmmirror（国内镜像）', url: 'https://registry.npmmirror.com', primary: true },
     { id: 'npmjs', name: 'npmjs（官方源）', url: 'https://registry.npmjs.org', primary: false },
@@ -655,9 +646,16 @@ const DEFAULT_SOURCES = {
     { id: 'gitee', name: 'Gitee', type: 'builtin' },
   ],
   // 市场静态索引源（按主→备依次尝试；内网可整体替换为自建镜像，实现完全离线的市场浏览）
+  // 2026-09-20 扩容 2 → 5：只有 jsDelivr + ghproxy 两个源时，两者同时不可达就会让整个市场退化成
+  // 「只能搜 GitHub 实时结果」——收录清单（含 ★7800 全家桶）与本地索引模糊匹配一起失效
+  // （另一位用户实测报「市场索引加载失败：网络不可达（2 个索引源全部失败）：GitHub 请求超时」）。
+  // jsDelivr 官方多入口互为主备：cdn（主）/ gcore / fastly；再加 ghproxy 与 raw 直连兜底。
   indexSources: [
     { id: 'jsdelivr', name: 'jsDelivr CDN', url: 'https://cdn.jsdelivr.net/gh/Noob-stupid/dsh-plugin-hub@main/marketplace/index.json', primary: true },
+    { id: 'jsdelivr-gcore', name: 'jsDelivr (gcore)', url: 'https://gcore.jsdelivr.net/gh/Noob-stupid/dsh-plugin-hub@main/marketplace/index.json', primary: false },
+    { id: 'jsdelivr-fastly', name: 'jsDelivr (fastly)', url: 'https://fastly.jsdelivr.net/gh/Noob-stupid/dsh-plugin-hub@main/marketplace/index.json', primary: false },
     { id: 'ghproxy', name: 'ghproxy 镜像', url: 'https://ghproxy.net/https://raw.githubusercontent.com/Noob-stupid/dsh-plugin-hub/main/marketplace/index.json', primary: false },
+    { id: 'raw', name: 'GitHub raw 直连', url: 'https://raw.githubusercontent.com/Noob-stupid/dsh-plugin-hub/main/marketplace/index.json', primary: false },
   ],
   // Git 克隆源（{owner}/{repo} 占位符；按主→备依次尝试）。
   // 可替换为 Gitee / GitLab / 自建 Gitea / 任意镜像代理，实现「换一个网站下载仓库内容」。
@@ -1705,11 +1703,12 @@ const API_MIRROR_PREFIXES = [
   'https://ghfast.top/https://api.github.com',
 ]
 
-/** raw.githubusercontent.com 的镜像竞速前缀（与浏览器端四通道一致）。 */
+/** raw.githubusercontent.com 的镜像竞速前缀（与浏览器端四通道一致）。
+ * 2026-09-19 移除 mirror.ghproxy.com：该域名早已失效（实测连接超时；失效域名被停放页接管时
+ * 会回 2xx HTML —— 正是"普通插件被误判成 submodule 套装"的假阳性来源之一）。 */
 const RAW_MIRROR_PREFIXES = [
   'https://ghproxy.net/https://raw.githubusercontent.com',
   'https://ghfast.top/https://raw.githubusercontent.com',
-  'https://mirror.ghproxy.com/https://raw.githubusercontent.com',
 ]
 
 /** 并行竞速：任一分支拿到 2xx 即胜出；非 2xx 与错误都视为失败，全部失败则拒绝。 */
@@ -1868,9 +1867,12 @@ async function githubText(url, signal, token = null) {
 }
 
 /** 用 curl 子进程请求 JSON（绕过本机中间设备对 node:https TLS 指纹的拦截；curl 走系统网络栈）。 */
-async function curlJson(url, timeout = 15000, headers = {}) {
+async function curlJson(url, timeout = 15000, headers = {}, { ipv4 = false } = {}) {
   const bin = process.platform === 'win32' ? 'curl.exe' : 'curl'
   const args = ['-s', '-m', String(Math.max(5, Math.ceil(timeout / 1000))), '-H', 'accept: application/json', '-w', '\n__HTTP__%{http_code}']
+  // ipv4：只给 GitHub 域名用——「解析出 IPv6 但没有 IPv6 路由」的环境里 curl 默认要先空等 ~5.2s 才回退
+  // IPv4（2026-09-20 另一位用户实测：默认 5473ms vs `-4` 的 461ms）；双栈正常的环境无副作用。
+  if (ipv4) args.push('-4')
   for (const [key, value] of Object.entries(headers)) args.push('-H', `${key}: ${value}`)
   args.push(url)
   const { stdout } = await execFileAsync(bin, args, { timeout: timeout + 3000, windowsHide: true, maxBuffer: 8 * 1024 * 1024 })
@@ -1881,12 +1883,17 @@ async function curlJson(url, timeout = 15000, headers = {}) {
   return JSON.parse(body)
 }
 
-/** 用 curl 拉取文本（raw 文件用：本机 curl 直连 raw.githubusercontent.com 秒回，绕开 node:https 黑洞）。 */
-async function curlText(url, timeout = 10000) {
+/** 用 curl 拉取文本（raw 文件用：本机 curl 直连 raw.githubusercontent.com 秒回，绕开 node:https 黑洞）。
+ * 导出供 test-suite-detect.mjs 断言传输层口径（200 空 body → 空串，404 → 抛 HTTP 404）。 */
+export async function curlText(url, timeout = 10000, { ipv4 = false } = {}) {
   const bin = process.platform === 'win32' ? 'curl.exe' : 'curl'
+  const args = ['-s', '-m', String(Math.max(3, Math.ceil(timeout / 1000))), '-H', 'accept: text/plain', '-w', '\n__HTTP__%{http_code}']
+  // 见 curlJson 注释：GitHub 域名走 IPv4 快通道（IPv6 无路由的环境下默认要白等 ~5.2s）
+  if (ipv4) args.push('-4')
+  args.push(url)
   const { stdout } = await execFileAsync(
     bin,
-    ['-s', '-m', String(Math.max(3, Math.ceil(timeout / 1000))), '-H', 'accept: text/plain', '-w', '\n__HTTP__%{http_code}', url],
+    args,
     { timeout: timeout + 3000, windowsHide: true, maxBuffer: 8 * 1024 * 1024 },
   )
   const m = String(stdout).match(/\n__HTTP__(\d+)\s*$/u)
@@ -2049,7 +2056,9 @@ async function enrichItemOne(item) {
       detectSkillRepo(item.fullName, branch),
       rawTextWithFallback(item.fullName, branch, '.gitmodules'),
     ])
-    if (suiteResult.status === 'fulfilled' && suiteResult.value !== null) {
+    // 套装判定必须过内容校验：代理/CDN 对不存在的 .gitmodules 也可能回 2xx 空 body，
+    // 只判"探测非 null"会把普通插件标成套装置仓库（2026-09-19 事故）。
+    if (suiteResult.status === 'fulfilled' && looksLikeGitmodules(suiteResult.value)) {
       hasSuite = true
     }
     if (pkgResult.status === 'fulfilled') {
@@ -2149,11 +2158,53 @@ function githubRepoInfo(repo) {
   return `${match[1]}/${match[2]}`
 }
 
+/** 「真的读到了文件内容」判定：null / 空串 / 纯空白都不算。导出供 test-suite-detect.mjs 断言。
+ * 真实事故（2026-09-19，用户反馈装 dsh-whale-widget 报「未找到 .gitmodules」）：
+ * 本机加速器/代理（Watt Toolkit 之类，劫持 raw.githubusercontent.com 到 127.0.0.1）
+ * 会对**不存在的文件**回 2xx + 空 body；旧代码只判 `body === null`，
+ * 于是空串被当成"文件存在" → 普通插件被判定成 submodule 套装置仓库 → 安装必然失败。 */
+export function readBodyOrNull(body) {
+  return typeof body === 'string' && body.trim() !== '' ? body : null
+}
+
+/** .gitmodules 内容校验：必须是真 gitmodules（含 [submodule "x"] 段）才算套装仓库。导出供测试。
+ * 只判"探测非 null"会把代理/CDN 的垃圾响应也算成套装；判定权交给内容，不交给状态码。 */
+export function looksLikeGitmodules(text) {
+  return typeof text === 'string' && /^\s*\[submodule\s+"/mu.test(text)
+}
+
+/** raw 抓取外层预算（毫秒）。事件（2026-09-20，另一位用户：Android + proot Ubuntu 容器，域名解析出
+ * IPv6 但容器无 IPv6 路由）：4 条通道最快也要 5.4s（curl 直连被 -m 6 掐死、node:https 5435ms、
+ * jsDelivr 5564ms），旧的 5000ms 预算**必然先超时** → 抓取失败被当成"文件不存在"，
+ * 报成「仓库没有 package.json」。放宽到 10s：真 404 仍是毫秒级返回，只有全网慢时才多等。 */
+export const FETCH_BUDGET_MS = 10000
+/** 仓库元数据（默认分支）探测预算：旧值 3s 在同一环境下同样必输 → branch 恒为 'main'，
+ * 默认分支为 dev 的仓库会取错分支。 */
+export const META_BUDGET_MS = 8000
+export const FETCH_OK = 'ok'
+export const FETCH_NOT_FOUND = 'not-found'
+export const FETCH_UNREACHABLE = 'unreachable'
+
+/** 竞速组合（纯逻辑，导出供单测）：通道结果 + 预算 → { state, body }。
+ * · anyPromise 以 null 成功 = 某通道确定性 404 → not-found
+ * · anyPromise 以字符串成功 = 读到内容 → ok
+ * · anyPromise 全部失败（AggregateError）或超出预算 → unreachable（**不再与 404 混为一谈**） */
+export function raceFetchOutcome(anyPromise, budgetMs) {
+  const settled = Promise.resolve(anyPromise)
+    .then((body) => (body === null ? { state: FETCH_NOT_FOUND, body: null } : { state: FETCH_OK, body }))
+    .catch(() => ({ state: FETCH_UNREACHABLE, body: null }))
+  return Promise.race([
+    settled,
+    new Promise((resolve) => setTimeout(() => resolve({ state: FETCH_UNREACHABLE, body: null }), budgetMs)),
+  ])
+}
+
 /** raw 文件读取：https 主通道（含镜像）、gh CLI、curl 直连、curl jsDelivr CDN **四通道并行竞速**。
  * 黑洞期 https/ghproxy 全挂、gh 可能不在服务进程 PATH——jsDelivr CDN 走系统网络且国内可达，是最后兜底。
  * 关键语义：**404 是确定性结果**（文件不存在，探测 .gitmodules/SKILL.md 等时的正常答案），
- * 必须立即返回 null，不能等其它分支（黑洞期 https 通道 20s+ 才失败会拖死整个请求）。 */
-async function rawTextWithFallback(repo, branch, path) {
+ * 必须立即返回 null，不能等其它分支（黑洞期 https 通道 20s+ 才失败会拖死整个请求）。
+ * 返回值区分「确定性 404」与「超时/通道全灭」——二者都以"没内容"结束，但用户文案必须不同。 */
+async function rawTextFetch(repo, branch, path, budgetMs = FETCH_BUDGET_MS) {
   const url = `${GITHUB_RAW}/${repo}/${encodeURIComponent(branch)}/${path}`
   // 404/4xx：确定性"不存在"，立即以 null 胜出（不等慢分支）
   const notFound = (promise) => promise
@@ -2161,48 +2212,184 @@ async function rawTextWithFallback(repo, branch, path) {
       if (error instanceof Error && /HTTP 404|HTTP 400|Not Found|not found|非 2xx|HTTP 非 2xx/u.test(error.message)) return null
       throw error
     })
-  const https = notFound(githubText(url)
-    .then((body) => {
-      if (body === null) throw new Error('HTTP 非 2xx')
-      return body
-    }))
+  // 各通道统一口径：状态 2xx **且** body 非空白，才算读到文件（否则抛"非 2xx" → 归一为 null）
+  const real = (promise) => promise.then((body) => {
+    const text = readBodyOrNull(body)
+    if (text === null) throw new Error('HTTP 非 2xx')
+    return text
+  })
+  const https = notFound(real(githubText(url)))
   const gh = notFound(githubViaGh(`repos/${repo}/contents/${path}?ref=${encodeURIComponent(branch)}`)
     .then((data) => {
       if (data && typeof data.content === 'string') return Buffer.from(data.content, 'base64').toString('utf8')
       throw new Error('contents 无内容')
-    }))
-  const curl = notFound(curlText(url, 6000)
-    .then((body) => {
-      if (body === null) throw new Error('HTTP 非 2xx')
-      return body
-    }))
-  const cdn = notFound(curlText(`https://cdn.jsdelivr.net/gh/${repo}@${encodeURIComponent(branch)}/${path}`, 6000)
-    .then((body) => {
-      if (body === null) throw new Error('HTTP 非 2xx')
+    })
+    .then((text) => {
+      const body = readBodyOrNull(text)
+      if (body === null) throw new Error('contents 无内容')
       return body
     }))
+  const curl = notFound(real(curlText(url, 9000, { ipv4: true })))
+  const cdn = notFound(real(curlText(`https://cdn.jsdelivr.net/gh/${repo}@${encodeURIComponent(branch)}/${path}`, 9000, { ipv4: true })))
+  return await raceFetchOutcome(Promise.any([https, gh, curl, cdn]), budgetMs)
+}
+
+/** 兼容入口：调用方只关心"有没有内容"（null = 没有）。需要区分超时/404 的场景用 rawTextFetch。 */
+async function rawTextWithFallback(repo, branch, path) {
+  const { state, body } = await rawTextFetch(repo, branch, path)
+  return state === FETCH_OK ? body : null
+}
+
+/** 包探测（带失败原因）：reason ∈ ok / not-found / unreachable / invalid。导出供测试。
+ * 事故（2026-09-20，另一位用户：Android + proot Ubuntu，容器无 IPv6 路由）：
+ * 抓取超时与真 404 都让上层拿到同一个 null，于是「网络太慢」被报成「仓库没有 package.json」。 */
+async function fetchRepoPackageEx(repo, branch) {
+  const { state, body } = await rawTextFetch(repo, branch, 'package.json')
+  if (state !== FETCH_OK) return { pkg: null, reason: state }
   try {
-    // 任一通道成功（含 404→null）立即返回；整体 5s 封顶（jsDelivr 正常 0.7s，
-    // 黑洞期快速失败优于等 12s），超时视为不可达（null）。
-    return await Promise.race([
-      Promise.any([https, gh, curl, cdn]),
-      new Promise((resolve) => setTimeout(() => resolve(null), 5000)),
-    ])
-  } catch {
-    return null
-  }
+    const pkg = JSON.parse(body)
+    if (pkg !== null && typeof pkg === 'object' && typeof pkg.name === 'string') return { pkg, reason: 'ok' }
+  } catch {}
+  return { pkg: null, reason: 'invalid' }
 }
 
 async function fetchRepoPackage(repo, branch) {
+  return (await fetchRepoPackageEx(repo, branch)).pkg
+}
+
+/** 从 npm 的 repository 字段解析出 GitHub/Gitee 仓库标识（纯函数，单测覆盖）。
+ * 支持 `https://github.com/o/r.git`、`git+https://…`、`git://…`、带 `#path` 的 monorepo 写法。 */
+export function parseRepoFromUrl(url) {
+  const raw = String(url ?? '').trim()
+  // npm 老式简写：`github:owner/repo` / `gitee:owner/repo`
+  const shorthand = raw.match(/^(?:github|gitee):([^/\s]+)\/([^/\s#?]+?)(?:\.git)?(?:[#?].*)?$/u)
+  if (shorthand !== null) return `${shorthand[1]}/${shorthand[2]}`
+  const m = raw.match(/(?:github\.com|gitee\.com)[/:]([^/\s]+)\/([^/\s#?]+?)(?:\.git)?(?:[#?].*)?$/u)
+  if (m === null) return null
+  return `${m[1]}/${m[2]}`
+}
+
+/** 结果里是否已有"名字逐词命中查询词"的条目——决定要不要再加 `in:readme` 重查一次。
+ * （仓库搜索的检索面只有 名字/描述/topics；README 里的词必须显式 in:readme 才查得到） */
+export function hasDirectNameHit(items, query) {
+  const tokens = String(query ?? '').toLowerCase().split(/[\s\-_/.]+/u).filter((tk) => tk.length >= 3)
+  if (tokens.length === 0) return true // 查询太短/太泛：不做二次查询，避免把结果冲稀
+  return items.some((it) => {
+    const name = String(it?.fullName ?? '').toLowerCase()
+    return tokens.every((tk) => name.includes(tk))
+  })
+}
+
+/** npm 包名搜索：registry 搜索接口 → 候选包 → 读 packument 的 repository.url → 映射回 GitHub 仓库。
+ * 背景（2026-09-20）：用户搜 `web-all`（= npm 包 `@linxin666/dsh-web-all`）搜不到，因为 `web-all`
+ * 只存在于 npm 包名、仓库文件与 README 里，而 GitHub 仓库搜索的检索面只有 名字/描述/topics。
+ * 这条通道不依赖静态索引、也不依赖 GitHub 登录，且命中后可按包名直接安装。 */
+export async function searchNpmPackages(query, registries, limit = 3, token = null) {
+  const q = String(query ?? '').trim().toLowerCase()
+  if (q.length < 2) return []
+  let hits = null
+  let registry = null
+  for (const reg of (registries ?? []).slice(0, 3)) {
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const data = await fetchJsonUrl(`${reg}/-/v1/search?text=${encodeURIComponent(q)}&size=10`, 8000)
+      if (data && Array.isArray(data.objects)) { hits = data.objects; registry = reg; break }
+    } catch {}
+  }
+  if (hits === null) return []
+  const candidates = hits
+    .map((o) => o?.package)
+    .filter((p) => p && typeof p.name === 'string' && p.name.toLowerCase().includes(q))
+    .slice(0, limit)
+  const out = []
+  for (const cand of candidates) {
+    try {
+      const encoded = cand.name.startsWith('@')
+        ? `@${encodeURIComponent(cand.name.slice(1).split('/')[0])}%2f${encodeURIComponent(cand.name.split('/').slice(1).join('/'))}`
+        : encodeURIComponent(cand.name)
+      // eslint-disable-next-line no-await-in-loop
+      const meta = await fetchJsonUrl(`${registry}/${encoded}`, 8000)
+      const repo = parseRepoFromUrl(meta?.repository?.url ?? meta?.repository ?? cand.links?.repository ?? '')
+      if (repo === null) continue
+      // 顺带补仓库真实元数据（星数/描述/默认分支）——npm 里的信息不足，且默认分支可能是 dev
+      let info = null
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        info = await githubJson(`${GITHUB_API}/repos/${repo}`, null, token)
+      } catch {}
+      out.push({
+        fullName: repo,
+        description: `${info?.description ?? cand.description ?? ''}（npm 包：${cand.name}@${cand.version ?? '?'}）`.trim(),
+        htmlUrl: info?.html_url ?? `https://github.com/${repo}`,
+        stars: typeof info?.stargazers_count === 'number' ? info.stargazers_count : 0,
+        updatedAt: info?.updated_at ?? '',
+        defaultBranch: info?.default_branch ?? null,
+        topics: Array.isArray(info?.topics) ? info.topics : [],
+        source: 'npm',
+        sourceName: 'npm',
+        packageName: cand.name,
+        npmVersion: cand.version ?? null,
+        npmPackage: true,
+      })
+    } catch {}
+  }
+  return out
+}
+
+/** monorepo 子包增强：GitHub 代码搜索（`<词> filename:package.json`）→ 命中 `packages/<包>/package.json`
+ * → 读该 package.json 取真实包名 → 作为子包条目返回（这样 `dsh-web-all`、OpenViking 这类
+ * 「只存在于仓库文件里的包名」也能被搜到，且带 packageName 可直接按包名安装）。
+ * ⚠️ GitHub **代码搜索 API 强制要求登录**（未登录实测 401 Requires authentication），未登录时返回空。 */
+export async function searchSubpackageItems(query, token = null, signal = null) {
+  const subItems = []
   try {
-    const body = await rawTextWithFallback(repo, branch, 'package.json')
-    if (body === null) return null
-    const pkg = JSON.parse(body)
-    if (pkg == null || typeof pkg !== 'object' || typeof pkg.name !== 'string') return null
-    return pkg
-  } catch {
-    return null
+    const codeData = await githubJson(
+      `${GITHUB_API}/search/code?q=${encodeURIComponent(`${query} filename:package.json`)}`,
+      signal,
+      token,
+    )
+    for (const hit of (codeData.items ?? []).slice(0, 10)) {
+      const hitPath = typeof hit.path === 'string' ? hit.path : ''
+      if (!/^(?:packages|examples|plugins|skills|apps|extensions|src|lib)\/[^/]+\/package\.json$/u.test(hitPath)) continue
+      const repoName = hit.repository?.full_name ?? ''
+      if (!repoName) continue
+      const dir = hitPath.split('/').slice(0, -1).join('/')
+      let packageName = dir.split('/').slice(-1)[0]
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const pkgText = await rawTextWithFallback(repoName, 'main', hitPath)
+        if (pkgText !== null) {
+          const pkg = JSON.parse(pkgText)
+          if (pkg && typeof pkg.name === 'string') packageName = pkg.name
+        }
+      } catch {}
+      subItems.push({
+        fullName: repoName,
+        description: `子包：${dir}`,
+        htmlUrl: `https://github.com/${repoName}/tree/main/${dir}`,
+        stars: 0,
+        updatedAt: '',
+        defaultBranch: 'main',
+        topics: [],
+        source: 'github',
+        subpackagePath: dir,
+        packageName,
+      })
+      if (subItems.length >= 5) break
+    }
+  } catch {}
+  return subItems
+}
+
+/** 探测失败时的用户可读文案：「抓取超时/不可达」与「真的没有」必须区分开。导出供测试。 */
+export function packageProbeErrorText(repo, branch, reason) {
+  if (reason === FETCH_UNREACHABLE) {
+    return `抓取超时/网络不可达：没能读到 ${repo}（${branch} 分支）的 package.json —— 通常是网络到 GitHub 太慢（例如解析出 IPv6 却无 IPv6 路由）。请重试；若持续失败，可先用「仓库落地」克隆到本地目录。`
+  }
+  if (reason === 'invalid') {
+    return `仓库 ${repo} 的 package.json 不是合法的包描述（缺少 name 字段），无法作为插件安装——可改用「仓库落地」克隆到本地目录。`
   }
+  return `仓库 ${repo} 没有 package.json（也不是技能仓库），无法作为插件安装——可改用「仓库落地」克隆到本地目录。`
 }
 
 /**
@@ -2211,7 +2398,7 @@ async function fetchRepoPackage(repo, branch) {
  * （曾导致入口链接丢失、DSH 启动崩溃）。registry 走国内镜像。
  */
 async function pnpmInstall(profileDir, spec, registry = 'https://registry.npmmirror.com', timeout = 90000, signal = null) {
-  const args = ['pnpm', 'add', spec, '--registry', registry]
+  const args = ['add', spec, '--registry', registry]
   const opts = {
     cwd: profileDir,
     timeout,
@@ -2225,19 +2412,9 @@ async function pnpmInstall(profileDir, spec, registry = 'https://registry.npmmir
       GCM_INTERACTIVE: 'never',
     },
   }
-  if (process.platform === 'win32') {
-    // .cmd 批处理不能直接 execFile（EINVAL）：优先 node 直跑 corepack.js
-    const corepackJs = join(dirname(process.execPath), 'node_modules', 'corepack', 'dist', 'corepack.js')
-    if (existsSync(corepackJs)) {
-      await execFileAsync(process.execPath, [corepackJs, ...args], opts)
-      return
-    }
-    // 兜底：经 cmd.exe 运行 corepack
-    const cmd = `${JSON.stringify('corepack')} ${args.map((arg) => JSON.stringify(arg)).join(' ')}`
-    await execFileAsync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/s', '/c', cmd], opts)
-    return
-  }
-  await execFileAsync('corepack', args, opts)
+  // 跨平台定位 corepack/pnpm（Windows 布局 / Linux npm 全局布局 / PATH 兜底）；
+  // 旧代码只认 Windows 布局，Linux 上会生成 MODULE_NOT_FOUND 的命令（2026-09-20 事故）
+  await runPnpmWithFallback(args, { execOpts: opts })
 }
 
 /**
@@ -2783,6 +2960,64 @@ function packageEntryExists(dir, pkg) {
   return candidates.some((c) => existsSync(join(dir, c)))
 }
 
+/** git 可执行名（跨平台）。事故（2026-09-20，另一位用户：Android + proot Ubuntu）：
+ * 「仓库落地」硬编码 `git.exe` → 非 Windows 环境 spawn git.exe ENOENT，克隆必然失败。导出供测试。 */
+export function gitBin() {
+  return process.platform === 'win32' ? 'git.exe' : 'git'
+}
+
+/** pnpm 执行方式定位（跨平台，纯函数便于单测 → 按优先级返回列表，逐个尝试）。导出供测试。
+ * 事故（2026-09-20，同一位用户，node v24 + Linux）：只按 Windows 布局找 corepack.js
+ * （`<node bin>/node_modules/corepack/dist/corepack.js`），而 Linux 的 npm 全局布局在
+ * `<prefix>/lib/node_modules/corepack/...` → AI 赋能的 install-npm 生成
+ * `node /usr/local/bin/node_modules/corepack/dist/corepack.js pnpm add …` → MODULE_NOT_FOUND。 */
+export function resolvePnpmRunners({ platform = process.platform, execPath = process.execPath, comspec = process.env.ComSpec ?? 'cmd.exe', exists = existsSync } = {}) {
+  const binDir = dirname(execPath)
+  const corepackCandidates = [
+    join(binDir, 'node_modules', 'corepack', 'dist', 'corepack.js'), // Windows 官方安装器 / nvm-windows
+    join(binDir, '..', 'lib', 'node_modules', 'corepack', 'dist', 'corepack.js'), // Linux/macOS npm 全局
+    join(binDir, '..', 'libexec', 'lib', 'node_modules', 'corepack', 'dist', 'corepack.js'), // brew / 自编译布局
+  ]
+  const runners = []
+  for (const js of corepackCandidates) {
+    if (exists(js)) {
+      runners.push({ kind: 'node-corepack', note: `node ${js} pnpm`, run: (args) => ({ bin: execPath, argv: [js, 'pnpm', ...args] }) })
+    }
+  }
+  if (platform === 'win32') {
+    // .cmd 批处理不能直接 execFile（EINVAL）→ 经 cmd.exe 调用（整条命令作为一个参数）
+    runners.push({
+      kind: 'cmd-corepack',
+      note: 'cmd /c corepack pnpm',
+      run: (args) => ({ bin: comspec, argv: ['/d', '/s', '/c', ['corepack', 'pnpm', ...args].map((a) => JSON.stringify(a)).join(' ')] }),
+    })
+  } else {
+    runners.push({ kind: 'corepack', note: 'corepack pnpm', run: (args) => ({ bin: 'corepack', argv: ['pnpm', ...args] }) })
+    runners.push({ kind: 'pnpm', note: 'pnpm', run: (args) => ({ bin: 'pnpm', argv: args }) })
+  }
+  return runners
+}
+
+/** 依次尝试各执行方式；只有"执行方式本身不可用"（ENOENT / MODULE_NOT_FOUND）才换下一个，
+ * 真正的安装失败（网络、依赖冲突等）立即抛出，并附上已尝试的清单便于排查。 */
+async function runPnpmWithFallback(args, { execOpts = {}, runners = resolvePnpmRunners() } = {}) {
+  let lastError = null
+  for (const runner of runners) {
+    const { bin, argv } = runner.run(args)
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await execFileAsync(bin, argv, execOpts)
+      return { runner }
+    } catch (error) {
+      lastError = error
+      const message = String(error?.message ?? '')
+      if (!/ENOENT|Cannot find module/u.test(message)) throw error
+    }
+  }
+  const tried = runners.map((r) => r.note).join(' → ')
+  throw new Error(`${lastError?.message ?? 'pnpm 执行失败'}（已尝试：${tried}）`)
+}
+
 /** git 非交互环境：禁止任何登录/凭据窗口弹出（私有仓库或不可达源直接失败，不做交互式重试）。 */
 function gitEnv() {
   return {
@@ -2812,23 +3047,38 @@ function gitCloneUrls(repoFullName, source = 'github') {
   return urls.length > 0 ? urls : [`https://github.com/${repoFullName}.git`]
 }
 
-/** git clone（镜像→直连；gitee 直连），返回或抛错。 */
+/** 逐条尝试的错误汇总（纯函数，单测覆盖）：报**第一个**错误（真实原因）+ 尝试清单。
+ * 为什么要这样：多源重试时若第一次失败留下半成品目录，第二次会以
+ * `fatal: destination path '…' already exists and is not an empty directory` 失败，
+ * 旧代码把它当 lastError 抛出去 → 用户只看到"目录非空"，真实原因（镜像/网络不可达）被完全掩盖。
+ * 2026-09-20 另一位用户实测报的就是这句。 */
+export function summarizeCloneErrors(errors) {
+  const first = errors[0]
+  const tried = errors.map((e) => (/already exists and is not an empty directory/u.test(e.message) ? `${e.url}（目录非空）` : e.url)).join('；')
+  return `git clone 失败（首个错误：${first?.message ?? '未知'}）；已尝试 ${errors.length} 个源：${tried}`
+}
+
+/** git clone（镜像→直连；gitee 直连），返回 { url } 或抛错。 */
 async function gitCloneRepo(repo, dest, source = 'github', timeout = 180000) {
   const urls = gitCloneUrls(repo, source)
-  let lastError = null
-  for (const url of urls) {
+  const errors = []
+  for (const [attempt, url] of urls.entries()) {
+    // 每次尝试前都清掉目标目录：上一次可能留下半成品（git 会先建目录再传输），
+    // 不清就会让第二次以"目录非空"失败并掩盖真实原因（见 summarizeCloneErrors 注释）。
+    try { rmSync(dest, { recursive: true, force: true }) } catch {}
     try {
+      // eslint-disable-next-line no-await-in-loop
       await execFileAsync('git', ['clone', '--depth', '1', '--quiet', url, dest], {
         timeout,
         windowsHide: true,
         env: gitEnv(),
       })
-      return
+      return { url, attempt: attempt + 1 }
     } catch (error) {
-      lastError = error
+      errors.push({ url, message: error?.message ?? String(error) })
     }
   }
-  throw new Error(`git clone 失败：${lastError?.message ?? '未知'}`)
+  throw new Error(summarizeCloneErrors(errors))
 }
 
 /** 从 GitHub Release 下载预构建 tgz 装配到 node_modules/<pkgName>（gh CLI 通道，含绝对路径候选）。 */
@@ -2865,6 +3115,24 @@ async function installBundleFromRelease(subRepo, pkgName, target) {
   }
 }
 
+/** 套装探测（唯一入口）：main → master，且**必须内容像 .gitmodules**（含 [submodule "x"] 段）才算套装。
+ * 判据是内容、不是"探测非 null"：2026-09-19 用户反馈装 dsh-whale-widget 被判成 submodule 套装置仓库、
+ * clone 后报「未找到 .gitmodules」——根因就是代理/CDN 对**不存在的文件**回 2xx（空 body 也算"读到"）。 */
+async function probeGitmodules(repo) {
+  const main = await rawTextWithFallback(repo, 'main', '.gitmodules')
+  if (looksLikeGitmodules(main)) return main
+  const master = await rawTextWithFallback(repo, 'master', '.gitmodules')
+  return looksLikeGitmodules(master) ? master : null
+}
+
+/** 安装类型决策（纯函数，导出供 test-suite-detect.mjs 断言）：`.gitmodules` 的**内容**说了算——
+ * 显式 suite 请求若探测内容不像 .gitmodules 也回落普通插件安装（前端标记可能来自 24h 缓存的误判，
+ * 不能当判据）；技能请求不受影响。 */
+export function resolveInstallKind(requestKind, probeText) {
+  if (requestKind === 'skill') return 'skill'
+  return looksLikeGitmodules(probeText) ? 'suite' : 'plugin'
+}
+
 /** 套装安装（submodule 聚合仓库）：照仓库 install.ps1/README 语义——
  * clone 套装 → 手动镜像拉取子模块 → 按类型装配（bundle 插件含 Release tgz 兜底 / 普通插件 / 技能 / agent 预设）。
  * 不执行第三方脚本本体（安全护栏：脚本型只读语义不运行）。 */
@@ -2876,7 +3144,12 @@ async function runSuiteInstallJob(job, ctx) {
     mkdirSync(tmpDir, { recursive: true })
     await gitCloneRepo(job.repo, tmpDir, job.source)
     const subs = readGitmodules(tmpDir)
-    if (subs.length === 0) throw new Error('未找到 .gitmodules（不是 submodule 套装仓库）')
+    if (subs.length === 0) {
+      // 探测与仓库实际内容不符（假阳性 / 仓库已重构）：**不报失败**，把决定权交回调用方
+      // 回落普通插件安装（npm → Release → git 规格），用户不该因为一次误判装不上插件。
+      job.stage = 'detecting'
+      return { notASuite: true }
+    }
     job.stage = 'detecting'
     const patchPath = findPatchPath(ctx)
     const profileDir = dirname(patchPath)
@@ -3185,7 +3458,9 @@ async function aiRepair(job, ctx, profileDir, candidates, lastError) {
     job.error = `本地 AI 修复通道没有可用的子代理提供方：${String(error)}；请手动执行：dsh plugin --profile web add <包名>`
     return
   }
-  const corepackJs = join(dirname(process.execPath), 'node_modules', 'corepack', 'dist', 'corepack.js')
+  // 跨平台提示：corepack 的位置随安装方式/系统而异（Windows 官方安装器在 <node bin>/node_modules，
+  // Linux 的 npm 全局在 <prefix>/lib/node_modules），所以给子代理的提示不再写死路径
+  const corepackRunner = resolvePnpmRunners()[0]
   const prompt = [
     '你是 DeepSeek Harness 的插件安装专家。用户通过插件管理面板安装插件失败，现在由你主动接管安装（不是被动"修复"，而是像人工一样把它装好）。',
     `目标仓库：${job.repo}`,
@@ -3194,7 +3469,7 @@ async function aiRepair(job, ctx, profileDir, candidates, lastError) {
     `此前确定性通道的错误：${lastError ?? '未知'}`,
     '接管步骤：',
     `1) 先弄清楚装什么：若根包是 private 的聚合仓库（monorepo），用 gh api repos/${job.repo}/git/trees/main?recursive=1 或读 packages 目录下的 package.json 找出子包名；优先选聚合包（名字含 all，如 dsh-web-ui-all，一个包装全部）；`,
-    `2) 用 corepack pnpm 安装（Windows 执行 node ${JSON.stringify(corepackJs)} pnpm add <包名> --registry https://registry.npmmirror.com，工作目录 ${profileDir}）；镜像 404 时改 --registry https://registry.npmjs.org；都不行再用 git 通道；`,
+    `2) 用 corepack/pnpm 安装（本机可用的执行方式：${corepackRunner?.note ?? 'corepack pnpm 或 pnpm'}，即在该方式后接 add <包名> --registry https://registry.npmmirror.com，工作目录 ${profileDir}；Windows 上是 node <corepack.js> pnpm，Linux 上通常是 corepack pnpm 或直接 pnpm）；镜像 404 时改 --registry https://registry.npmjs.org；都不行再用 git 通道；`,
     '3) **node 网络黑洞判定**：pnpm 长时间无下载进度（Progress 停在 downloaded 0）、或报 socket hang up / EPERM / TIMEOUT、或 node 脚本连 127.0.0.1 都超时，说明本机拦截 node 进程网络——此时 curl 与系统 git 通常仍可用，立即改用 curl 手动安装：先 `curl -s https://registry.npmmirror.com/<包名>` 取最新版本号，再 `curl -sL -o <临时目录>/pkg.tgz https://registry.npmmirror.com/<包名>/-/<包名>-<版本>.tgz`，解压 tar -xzf 后把 package 内容放入 profile/node_modules/<包名>（先备份旧目录）；包有 dependencies 时用同样方式逐个 curl 拉取补齐到 node_modules；零依赖包（如 dsh-skin）一条龙即可完成；',
     `4) 安装成功后按官方 dsh plugin add 规则落配置：包声明 dsh.bundle 时把包名追加进 profile 目录 package.json 的 dsh.profile.bundles 数组；普通插件在 cordis.patch.yml 追加 insert 行（id 由包名去 scope、非字母数字转连字符生成，name 填包名）；`,
     '5) 装完自查：确认包已出现在 node_modules、配置已写入；必要时用 gh api 核对仓库信息；',
@@ -3773,10 +4048,13 @@ async function runAiStep(job, step, ctx, profileDir, signal) {
       const pkg = String(step.package ?? '')
       if (!/^(@[A-Za-z0-9_\-\.]+\/)?[A-Za-z0-9_\-\.]+(@[A-Za-z0-9_\-\.]+)?$/u.test(pkg)) throw new Error(`包名不合法：${pkg}`)
       const dir = resolvePlaceholders(String(step.directory ?? profile), { profileDir: profile })
-      const corepackJs = join(dirname(process.execPath), 'node_modules', 'corepack', 'dist', 'corepack.js')
-      const params = [corepackJs, 'pnpm', 'add', pkg, '--dir', dir, '--registry', 'https://registry.npmmirror.com']
-      jobLog(job, `  运行: node ${params.join(' ')}`)
-      await execFileAsync(process.execPath, params, { timeout: 900000, windowsHide: true, maxBuffer: 4 * 1024 * 1024, signal })
+      // 跨平台：不再拼 `node <node bin>/node_modules/corepack/dist/corepack.js`（Linux 上必 MODULE_NOT_FOUND，
+      // 2026-09-20 另一位用户的 install-npm 失败现场就是这一行），改为按优先级尝试可用的执行方式
+      const args = ['add', pkg, '--dir', dir, '--registry', 'https://registry.npmmirror.com']
+      const { runner } = await runPnpmWithFallback(args, {
+        execOpts: { timeout: 900000, windowsHide: true, maxBuffer: 4 * 1024 * 1024, signal },
+      })
+      jobLog(job, `  运行: ${runner.note} ${args.join(' ')}`)
       return
     }
     case 'write-file': {
@@ -4499,25 +4777,30 @@ async function runInstallJob(job, ctx) {
     let candidates = [job.packageName].filter((name) => typeof name === 'string' && name !== '')
     let subpackageMode = false
     if (candidates.length === 0) {
-      // 套装兜底：submodule 聚合仓库（根 .gitmodules 存在）→ 自动转套装安装，
-      // 不依赖前端标记（搜索结果 enrich 是异步的、索引浏览条目无 enrich）
-      let suiteProbe = await rawTextWithFallback(job.repo, 'main', '.gitmodules')
-      if (suiteProbe === null) suiteProbe = await rawTextWithFallback(job.repo, 'master', '.gitmodules')
-      if (suiteProbe !== null) {
+      // 套装兜底：submodule 聚合仓库（根 .gitmodules 内容校验通过）→ 自动转套装安装，
+      // 不依赖前端标记（搜索结果 enrich 是异步的、索引浏览条目无 enrich）。
+      // 判据是**内容**（resolveInstallKind），不是"探测非 null"：后者会把代理/CDN 对不存在文件回的
+      // 2xx 空 body、垃圾页当成套装（2026-09-19 用户反馈的「未找到 .gitmodules」事故根因）。
+      if (resolveInstallKind(job.kind, await probeGitmodules(job.repo)) === 'suite') {
         job.kind = 'suite'
-        await runSuiteInstallJob(job, ctx)
-        return
-      }
-      // 兜底：宿主端自行拉取仓库元数据（githubJson 与 curl 竞速 + 3s 超时降级，黑洞期不卡 40s）
+        const suiteResult = await runSuiteInstallJob(job, ctx)
+        // clone 后才发现没有 .gitmodules（探测假阳性 / 仓库已重构）→ 回落普通安装，不给用户一个失败
+        if (suiteResult?.notASuite !== true) return
+        job.kind = 'plugin'
+        job.suiteNote = '探测到的 .gitmodules 与仓库实际内容不符（不是 submodule 套装仓库），已自动回落普通插件安装'
+      }
+      // 兜底：宿主端自行拉取仓库元数据（githubJson 与 curl 竞速 + 8s 超时降级，黑洞期不卡 40s）。
+      // 8s 而非旧值 3s：IPv6 无路由的环境里单条通道就要 5.4s，3s 预算必输 → branch 恒为 main，
+      // 默认分支为 dev 的仓库会取错分支（2026-09-20 另一位用户实测）。
       const meta = await Promise.race([
         Promise.any([
           githubJson(`${GITHUB_API}/repos/${job.repo}`),
-          curlJson(`${GITHUB_API}/repos/${job.repo}`, 12000),
+          curlJson(`${GITHUB_API}/repos/${job.repo}`, 12000, {}, { ipv4: true }),
         ]),
-        new Promise((resolve) => setTimeout(() => resolve(null), 3000)),
+        new Promise((resolve) => setTimeout(() => resolve(null), META_BUDGET_MS)),
       ]).catch(() => null)
       const branch = meta?.default_branch ?? 'main'
-      const pkg = await fetchRepoPackage(job.repo, branch)
+      const { pkg, reason } = await fetchRepoPackageEx(job.repo, branch)
       if (pkg === null) {
         // 无 package.json：先探测是否技能仓库（含 SKILL.md）→ 自动转技能安装；
         // 否则标记 hint=repo-land，前端给出「仓库落地」一键入口（克隆到本地目录）。
@@ -4529,7 +4812,9 @@ async function runInstallJob(job, ctx) {
         }
         job.status = 'failed'
         job.hint = 'repo-land'
-        job.error = `仓库 ${job.repo} 没有 package.json（也不是技能仓库），无法作为插件安装——可改用「仓库落地」克隆到本地目录。`
+        // 文案区分「抓取超时/不可达」与「真的没有」——旧代码两者共用一个出口，报错永远说"文件不存在"
+        job.error = packageProbeErrorText(job.repo, branch, reason)
+        job.probeReason = reason
         return
       }
       if (pkg.private === true) {
@@ -5320,6 +5605,36 @@ async function handle(ctx, req, res) {
     const all = body.all === true
     const auth = readGithubAuth()
     let items = []
+    // 给前端的补充说明（如"代码搜索需登录"）——放响应里，前端据此给提示，不改 items 结构
+    const extraNotes = {}
+    // 增量检索（前端浏览器直连成功时**并行**调用）：只补「npm 包名映射 + in:readme 重查 + 代码搜索子包」，
+    // 不重复仓库搜索。为什么需要它：直连成功就不会走本路由，而未登录用户恰恰只能走直连
+    // （2026-09-20 事故：未登录 + 索引加载失败 → 三条检索路全断，搜 web-all 搜不到 dsh-web）。
+    if (body.extras === true) {
+      const extra = []
+      if (raw !== '') {
+        try { extra.push(...await searchNpmPackages(raw, orderedRegistries(readSources()), 3, auth.token)) } catch {}
+        try {
+          const again = await githubJson(
+            `${GITHUB_API}/search/repositories?q=${encodeURIComponent(`${raw} in:name,description,readme${all ? '' : ' topic:dsh-plugin'}`)}&sort=stars&order=desc&per_page=20&page=1`,
+            req.signal,
+            auth.token,
+          )
+          extra.push(...normalizePlatformItems(again.items ?? [], 'main').map((it) => ({ ...it, source: 'github', viaReadme: true })))
+        } catch {}
+        try { extra.push(...await searchSubpackageItems(raw, auth.token, req.signal)) } catch {}
+      }
+      sendJson(res, 200, {
+        ok: true,
+        query: raw,
+        items: extra,
+        extras: true,
+        authenticated: auth.loggedIn,
+        source: 'github',
+        ...(raw !== '' && !auth.loggedIn ? { codeSearchSkipped: true } : {}),
+      })
+      return
+    }
     if (body.multi === true) {
       // 多源汇总：GitHub + 全部自定义搜索源并行检索，结果合并（每项带 source 标记）。
       // Gitee 为直装模式（关键词搜索无意义），不参与多源汇总。
@@ -5426,6 +5741,11 @@ async function handle(ctx, req, res) {
       const data = await fetchJsonUrl(url, 15000, custom.headers ?? {})
       items = normalizePlatformItems(data, 'main').map((item) => ({ ...item, source, sourceName: custom.name }))
     } else {
+      // npm 包名搜索与 GitHub 仓库搜索**并行**：npm 侧要查 registry 搜索 + packument + 仓库元数据
+      // （实测 4.5~9s），串行会把两段等待叠加到用户身上。
+      const npmPromise = raw !== '' && !body.skills
+        ? searchNpmPackages(raw, orderedRegistries(readSources()), 3, auth.token).catch(() => [])
+        : Promise.resolve([])
       const data = await githubJson(
         `${GITHUB_API}/search/repositories?q=${encodeURIComponent(all ? query : `${query} topic:dsh-plugin`)}&sort=stars&order=desc&per_page=20&page=${page}`,
         req.signal,
@@ -5433,51 +5753,50 @@ async function handle(ctx, req, res) {
       )
       items = normalizePlatformItems(data.items ?? [], 'main').map((item) => ({ ...item, source: 'github' }))
       items = await enrichItems(items)
-      // monorepo 子包增强（OpenViking/examples/dsh-memory-plugin 等可按子包名搜到）
+      // monorepo 子包增强（OpenViking/examples/dsh-memory-plugin 等可按子包名搜到；
+      // 代码搜索需登录，未登录时该函数返回空数组，见 searchSubpackageItems 的说明）
       if (raw !== '' && !body.skills) {
+        for (const sub of await searchSubpackageItems(raw, auth.token, req.signal)) {
+          if (!items.some((x) => x.fullName === sub.fullName)) items.push(sub)
+        }
+      }
+      // ── B′：README 重查（2026-09-20）────────────────────────────────────────
+      // 仓库搜索只在「仓库名 + 描述 + topics」里找词，所以只写在 README 或仓库文件里的名字搜不到。
+      // 典型：`web-all` 只是 npm 包名 + `packages/dsh-web-all/package.json` 的内容，
+      // `q=web-all topic:dsh-plugin` 32 条里没有 dsh-web；而 `web-all in:readme` 第 9 条就是它。
+      // 首屏没有"名字逐词命中"的条目时，用 in:name,description,readme 再查一次（未登录也能用）。
+      if (raw !== '' && !body.skills && page === 1 && !hasDirectNameHit(items, raw)) {
         try {
-          const codeData = await githubJson(
-            `${GITHUB_API}/search/code?q=${encodeURIComponent(`${raw} filename:package.json`)}`,
+          const again = await githubJson(
+            `${GITHUB_API}/search/repositories?q=${encodeURIComponent(`${raw} in:name,description,readme${all ? '' : ' topic:dsh-plugin'}`)}&sort=stars&order=desc&per_page=20&page=1`,
             req.signal,
             auth.token,
           )
-          const subItems = []
-          for (const hit of (codeData.items ?? []).slice(0, 10)) {
-            const hitPath = typeof hit.path === 'string' ? hit.path : ''
-            if (!/^(?:packages|examples|plugins|skills|apps|extensions|src|lib)\/[^/]+\/package\.json$/u.test(hitPath)) continue
-            const repoName = hit.repository?.full_name ?? ''
-            if (!repoName) continue
-            const dir = hitPath.split('/').slice(0, -1).join('/')
-            let packageName = dir.split('/').slice(-1)[0]
-            try {
-              const pkgText = await rawTextWithFallback(repoName, 'main', hitPath)
-              if (pkgText !== null) {
-                const pkg = JSON.parse(pkgText)
-                if (pkg && typeof pkg.name === 'string') packageName = pkg.name
-              }
-            } catch {}
-            subItems.push({
-              fullName: repoName,
-              description: `子包：${dir}`,
-              htmlUrl: `https://github.com/${repoName}/tree/main/${dir}`,
-              stars: 0,
-              updatedAt: '',
-              defaultBranch: 'main',
-              topics: [],
-              source: 'github',
-              subpackagePath: dir,
-              packageName,
-            })
-            if (subItems.length >= 5) break
-          }
-          for (const sub of subItems) {
-            if (!items.some((x) => x.fullName === sub.fullName)) items.push(sub)
+          for (const it of normalizePlatformItems(again.items ?? [], 'main')) {
+            if (items.some((x) => x.fullName === it.fullName)) continue
+            items.push({ ...it, source: 'github', viaReadme: true })
+            if (items.length >= 40) break
           }
         } catch {}
       }
+      // ── A：npm 包名搜索（2026-09-20）────────────────────────────────────────
+      // 用户输入常常是 npm 包名（`web-all`），而 GitHub 元数据里没有它 → 走 registry 搜索接口反查
+      // 包 → repository.url → 仓库，命中**置顶**并带 npmPackage 标记（前端按包名安装）。
+      // 不依赖静态索引、不依赖 GitHub 登录；registry 走配置的软件源（默认国内镜像）。
+      // 已在列表里的同仓库条目（例如代码搜索加进来的"子包"）合并 npm 信息后上移——精确命中不该排在第 21 位。
+      if (raw !== '' && !body.skills) {
+        for (const it of (await npmPromise).reverse()) {
+          const existingIdx = items.findIndex((x) => x.fullName === it.fullName)
+          const existing = existingIdx >= 0 ? items.splice(existingIdx, 1)[0] : null
+          items.unshift({ ...(existing ?? {}), ...it })
+        }
+      }
+      // 代码搜索（monorepo 子包）需要 GitHub 登录：未登录时它拿不到结果，
+      // 前端据此提示"登录后可按子包名搜索"（2026-09-20 事故复盘：未登录用户三条检索路径全断）
+      if (raw !== '' && !body.skills && !auth.loggedIn) extraNotes.codeSearchSkipped = true
     }
     items = items.filter((item) => item.fullName !== '')
-    sendJson(res, 200, { ok: true, query, items, authenticated: auth.loggedIn, source })
+    sendJson(res, 200, { ok: true, query, items, authenticated: auth.loggedIn, source, ...(extraNotes) })
     return
   }
 
@@ -5492,24 +5811,26 @@ async function handle(ctx, req, res) {
   if (pathname === `${ROUTE_PREFIX}/repo`) {
     const repo = githubRepoInfo(typeof body.repo === 'string' ? body.repo : '')
     const auth = readGithubAuth()
-    // meta 降级策略：githubJson（https+镜像+gh）与 curl 竞速，3 秒超时即降级——
+    // meta 降级策略：githubJson（https+镜像+gh）与 curl 竞速，8 秒超时即降级——
     // Promise.any 全失败时要等最慢分支（黑洞期 https 41.5s），加 race 超时避免拖累整体。
+    // 8s 而非旧值 3s：IPv6 无路由的环境里单条通道就要 5.4s（2026-09-20 实测），3s 必输 → branch 取错。
     let meta = null
     try {
       meta = await Promise.race([
         Promise.any([
           githubJson(`${GITHUB_API}/repos/${repo}`, req.signal, auth.token),
-          curlJson(`${GITHUB_API}/repos/${repo}`, 12000),
+          curlJson(`${GITHUB_API}/repos/${repo}`, 12000, {}, { ipv4: true }),
         ]),
-        new Promise((resolve) => setTimeout(() => resolve(null), 3000)),
+        new Promise((resolve) => setTimeout(() => resolve(null), META_BUDGET_MS)),
       ])
     } catch {}
     const branch = meta?.default_branch ?? 'main'
     const pkg = await fetchRepoPackage(repo, branch)
     const skill = await detectSkillRepo(repo, branch)
     const skillMeta = skill.hasSkill ? await fetchSkillMeta(repo, branch, skill.skillDir) : null
-    // 套装识别：根 .gitmodules 存在（submodule 聚合仓库）
-    const hasSuite = (await rawTextWithFallback(repo, branch, '.gitmodules')) !== null
+    // 套装识别：根 .gitmodules 存在**且内容真的是 gitmodules**（只判非 null 会被代理/CDN 对不存在
+    // 文件回的 2xx 空 body 骗到，把普通插件标成套装——2026-09-19 用户反馈事故）
+    const hasSuite = looksLikeGitmodules(await rawTextWithFallback(repo, branch, '.gitmodules'))
     // 官方安装方式（详情面板展示 + 一键复制，供用户手动安装）：
     // 套装 → 仓库 install.ps1/README 的官方步骤；普通/聚合 → dsh plugin add 官方命令
     let installCommand = null
@@ -5949,9 +6270,13 @@ async function handle(ctx, req, res) {
     }
     let lastError = null
     let formatError = null
+    // 总预算：索引源扩容到 5 个后，逐个 15s 最坏要等 75s（用户只会看到"市场一直转圈"）。
+    // 单源 8s + 整体 20s 封顶，超预算立刻进入落盘缓存兜底。
+    const deadline = Date.now() + 20000
     for (const src of indexList) {
+      if (Date.now() > deadline) break
       try {
-        const data = await fetchJsonUrl(src.url, 15000)
+        const data = await fetchJsonUrl(src.url, 8000)
         if (data && Array.isArray(data.items)) {
           marketIndexCache = { at: Date.now(), data, sourceName: src.name }
           try { await writeFile(MARKET_INDEX_CACHE_FILE, JSON.stringify({ at: Date.now(), data, sourceName: src.name }), 'utf8') } catch {}
@@ -5974,7 +6299,9 @@ async function handle(ctx, req, res) {
     const reason = formatError !== null
       ? formatError
       : `网络不可达（${indexList.length} 个索引源全部失败）：${lastError?.message ?? '未知错误'}`
-    sendError(res, 500, `索引加载失败：${reason}`)
+    // 说清后果（2026-09-20 另一位用户实测的困惑）：索引不在时市场只剩 GitHub 实时结果，
+    // 收录条目与本地索引模糊匹配一起失效（他搜 web-all 搜不到 dsh-web 全家桶就是这个原因）
+    sendError(res, 500, `索引加载失败：${reason}（此时市场只能搜 GitHub 实时结果，收录条目可能看不到；可在「软件源 → 索引源」增删/更换索引源后重试）`)
     return
   }
 
@@ -7094,9 +7421,9 @@ async function handle(ctx, req, res) {
       sendError(res, 400, 'deepseek-harness 是 DSH 框架本体，不是插件——无需安装（升级请用官方 dsh 升级方式）')
       return
     }
-    const kind = body.kind === 'skill' ? 'skill' : body.kind === 'suite' ? 'suite' : 'plugin'
-    if ((kind === 'skill' || kind === 'suite') && repo === '') {
-      sendError(res, 400, `${kind === 'skill' ? '技能' : '套装'}安装必须提供仓库（owner/name）`)
+    const requestedKind = body.kind === 'skill' ? 'skill' : body.kind === 'suite' ? 'suite' : 'plugin'
+    if ((requestedKind === 'skill' || requestedKind === 'suite') && repo === '') {
+      sendError(res, 400, `${requestedKind === 'skill' ? '技能' : '套装'}安装必须提供仓库（owner/name）`)
       return
     }
     const source = body.source === 'gitee' ? body.source : 'github'
@@ -7113,6 +7440,14 @@ async function handle(ctx, req, res) {
       sendError(res, 409, '该插件正在安装/更新中，请等待当前任务完成后再试')
       return
     }
+    // 套装请求必须复检内容（2026-09-19 事故）：前端标记可能来自 24h enrich 缓存的误判，
+    // 探测内容不像 .gitmodules 就按普通插件安装——别把用户送进注定失败的套装通道。
+    let kind = requestedKind
+    let suiteNote = null
+    if (requestedKind === 'suite') {
+      kind = resolveInstallKind('suite', await probeGitmodules(repo))
+      if (kind !== 'suite') suiteNote = '探测未发现有效的 .gitmodules（不是 submodule 套装仓库），已按普通插件安装'
+    }
     const job = {
       id: `job-${installJobSeq += 1}`,
       repo,
@@ -7132,10 +7467,20 @@ async function handle(ctx, req, res) {
         update: body.update === true,
       kind,
     }
+    if (suiteNote !== null) job.suiteNote = suiteNote
     installJobs.set(job.id, job)
+    // 套装通道兜底：探测说有、clone 下来却没有 .gitmodules（假阳性 / 仓库已重构）时
+    // 回落普通插件安装，而不是给用户一个「未找到 .gitmodules」的失败。
+    const runSuiteThenFallback = async () => {
+      const result = await runSuiteInstallJob(job, ctx)
+      if (result?.notASuite !== true) return
+      job.kind = 'plugin'
+      job.suiteNote = '仓库实际内容与探测不符（没有 .gitmodules），已自动回落普通插件安装'
+      await runInstallJob(job, ctx)
+    }
     // 后台执行：请求立即返回，安装不受客户端断开/离开面板影响
-    void (kind === 'skill' ? runSkillInstallJob(job) : kind === 'suite' ? runSuiteInstallJob(job, ctx) : runInstallJob(job, ctx))
-    sendJson(res, 200, { ok: true, jobId: job.id, status: 'installing', kind })
+    void (kind === 'skill' ? runSkillInstallJob(job) : kind === 'suite' ? runSuiteThenFallback() : runInstallJob(job, ctx))
+    sendJson(res, 200, { ok: true, jobId: job.id, status: 'installing', kind, ...(suiteNote !== null ? { suiteNote } : {}) })
     return
   }
 
@@ -7383,7 +7728,7 @@ async function handle(ctx, req, res) {
       let usedUrl = ''
       for (const url of urls) {
         try {
-          await execFileAsync('git.exe', ['clone', '--depth', '1', url, target], { cwd: root, timeout: 600000, windowsHide: true, maxBuffer: 4 * 1024 * 1024, env: gitEnv() })
+          await execFileAsync(gitBin(), ['clone', '--depth', '1', url, target], { cwd: root, timeout: 600000, windowsHide: true, maxBuffer: 4 * 1024 * 1024, env: gitEnv() })
           cloned = true
           usedUrl = url
           break