@noob-stupid/dsh-plugin-console 0.5.34 → 0.5.36

package/lib/server/domain/market-search.js

@@ -0,0 +1,242 @@
+// L1 · domain —— market-search.js（0.5.35：市场页搜索的**唯一一份排序判据** + 分页/截断语义）
+//
+// 真机缺陷（2026-10-03 用户实测，市场页输入他刚发布的仓库确切名字 `dsh-connection-card-host`）：
+//   ① 结果里只有三条**无关的高星**条目（dsh-desktop ★29812 / awesome-dsh-plugin ★17621 /
+//      dsh-desktop ★11682，都带「聚合」角标），**他要的仓库既不在前排、往下也没有**；
+//   ② 下面**没有「加载更多」**，也就无从"往下看"。
+// 定位结论（离线复现，见 tests/test-market-search.mjs）：
+//   · 那三条来自 `lib/client.js` 的**本地索引模糊匹配**（500 条封顶的静态索引里没有这个新仓库；
+//     索引匹配只按"子串 / 编辑距离 ≤2"打分，结果里全是恰好带 `dsh`、`host` 这类 token 的无关仓库），
+//     且它选出来的 12 条**按"星数"排的结果**被当作最终顺序**直接 return** —— 活搜 GitHub
+//     （本来会把逐字同名的仓库排第一）根本没被执行；
+//   · 「加载更多」按钮的渲染条件是 `market.data.length >= 20`：三条命中 ⇒ 按钮不渲染；
+//   · 服务端 /search 还把 `page` **夹到 1..5**，翻到第 6 次开始原地返回第 5 页。
+//
+// ★ 用户定案（原话）：「所有的搜索链，都应该以**名字相似为主排序**，然后才往下按 star 走」★
+//   即**不是**"只把精确命中置顶"，而是**名字相似度分层** —— 同一层内才比 star：
+//
+//     Tier 0  full_name 逐字相等（owner/repo 或裸 repo）
+//     Tier 1  name 逐字相等（大小写不敏感）
+//     Tier 2  name 前缀命中（以查询词开头）
+//     Tier 3  name 含查询子串
+//     Tier 4  name 的 token **全部**命中（可乱序）
+//     Tier 5  description / topics 命中
+//     Tier 6  README 命中
+//     其余    不匹配（排在最后，不参与前七层）
+//     同 Tier 内：stars 降序 → 再同分：最近更新优先 → 最后 full_name 字典序（确定性兜底）
+//
+// 本模块只做**纯函数**（无网络、无落盘、无 ctx）：查询词归一、分层判据、排序、分页/截断/合计。
+// 「一处定义、处处复用」的落地方式（**双份实现必须逐字一致，由架构守卫钉死**）：
+//   · 服务端：`lib/server/routes/market.js` 直接 import 本模块；
+//   · 浏览器：`lib/client.js` 是**单文件打包产物**（`window.__ModuleLoader__.load`），不能用 import，
+//     所以那里的排序块是**逐字移植**的同一份代码，两端都用下面的提取标记圈住：
+//         // <<<market-rank:begin>>>  …  // <<<market-rank:end>>>
+//     `tests/test-market-rank-canonical.mjs` 断言两份**去缩进后逐字相等**（改一边必须改另一边），
+//     架构守卫里同一断言也跑一遍。这样"唯一排序函数"是可验证的事实，而不是口头约定。
+//
+// 铁律：① 只调整**展示顺序**与**分页口径**，绝不改变"谁被搜出来"（过滤条件一处不动）；
+//       ② 分页**幂等可重复**：同一查询同一页永远同一批条目（排序里必须有确定性 tiebreaker）。
+
+// <<<market-rank:begin>>>
+/** 排序层级（越小越靠前）。Tier 0-6 与用户定案逐条对应；NOT_MATCHED 只是"没有名字/描述命中"。 */
+const RANK_TIER = Object.freeze({
+  FULL_NAME_EXACT: 0,
+  NAME_EXACT: 1,
+  NAME_PREFIX: 2,
+  NAME_SUBSTRING: 3,
+  NAME_TOKENS: 4,
+  DESCRIPTION_OR_TOPICS: 5,
+  README: 6,
+  NOT_MATCHED: 7,
+})
+
+/** 归一化：小写 + 去掉尾部 `.git` / 首尾空白。所有判据都用它，避免大小写与 `.git` 差异漏判。 */
+function normalizeSearchName(value) {
+  return String(value ?? '').trim().replace(/\.git$/iu, '').toLowerCase()
+}
+
+/** 查询词按分隔符切出的 token（≥2 字符，去重保序）——用于 Tier 4「token 全命中」判据。 */
+function queryTokens(query) {
+  const q = normalizeSearchName(query)
+  if (q === '') return []
+  const out = []
+  for (const tk of q.split(/[\s\-_/.]+/u)) {
+    if (tk.length >= 2 && !out.includes(tk)) out.push(tk)
+  }
+  return out
+}
+
+/** 条目的两个名字形态（都归一化）：`full` = owner/repo，`short` = 裸名（缺 name 时从 full 取尾段）。 */
+function itemNameForms(item) {
+  const full = normalizeSearchName(item?.fullName ?? item?.full_name)
+  const short = normalizeSearchName(item?.name) || (full === '' ? '' : (full.split('/').pop() ?? ''))
+  return { full, short }
+}
+
+/** 名字里按分隔符切出的 token（小写）。`dsh-connection-card-host` → [dsh, connection, card, host]。 */
+function nameTokens(name) {
+  return String(name ?? '').toLowerCase().split(/[\s\-_/.]+/u).filter(Boolean)
+}
+
+/** description / topics 是不是命中查询词（整词子串，大小写不敏感）。 */
+function textHitsQuery(query, item) {
+  const q = normalizeSearchName(query)
+  if (q === '') return false
+  const desc = normalizeSearchName(item?.description)
+  if (desc !== '' && desc.includes(q)) return true
+  const topics = Array.isArray(item?.topics) ? item.topics : []
+  return topics.some((topic) => normalizeSearchName(topic).includes(q))
+}
+
+/** README 命中：优先看条目**自带**的 readme 文本；没有就认标记位（服务端 in:readme 重查补进来的条目）。
+ *  标记位是"这条是从 README 检索面捞到的"的既成事实，不编造内容。 */
+function readmeHitsQuery(query, item) {
+  const q = normalizeSearchName(query)
+  if (q === '') return false
+  const readme = normalizeSearchName(item?.readme)
+  if (readme !== '' && readme.includes(q)) return true
+  return item?.viaReadme === true
+}
+
+/** 名字相似度分层（唯一判据；越小越靠前）。owner/repo 查询只按 full_name 判 Tier 0，
+ *  避免"同名不同 owner"被当成逐字命中（与用户"输入确切名字要排第一"的预期一致）。 */
+function rankTier(query, item) {
+  const q = normalizeSearchName(query)
+  if (q === '') return RANK_TIER.NOT_MATCHED
+  const { full, short } = itemNameForms(item)
+  const tokens = queryTokens(query)
+  const hasOwner = q.includes('/')
+  const target = short !== '' ? short : full
+  if (full !== '' && full === q) return RANK_TIER.FULL_NAME_EXACT
+  if (!hasOwner && short !== '' && short === q) return RANK_TIER.NAME_EXACT
+  if (target !== '' && target.startsWith(q)) return RANK_TIER.NAME_PREFIX
+  if (target !== '' && target.includes(q)) return RANK_TIER.NAME_SUBSTRING
+  if (tokens.length > 0) {
+    const owned = nameTokens(full !== '' ? full : short)
+    if (tokens.every((tk) => owned.includes(tk))) return RANK_TIER.NAME_TOKENS
+  }
+  if (textHitsQuery(query, item)) return RANK_TIER.DESCRIPTION_OR_TOPICS
+  if (readmeHitsQuery(query, item)) return RANK_TIER.README
+  return RANK_TIER.NOT_MATCHED
+}
+
+/** 星数（缺省 0；非数字按 0 处理——索引/GitHub 都是外部数据，不能拿它当数字用）。 */
+function starsOf(item) {
+  const n = item?.stars ?? item?.stargazers_count
+  return typeof n === 'number' && Number.isFinite(n) ? n : 0
+}
+
+/** 更新时间戳（毫秒）。缺省/非法一律 0（"没给时间"排最后；绝不编造"刚更新"）。 */
+function updatedAtOf(item) {
+  const raw = item?.updatedAt ?? item?.updated_at
+  if (typeof raw === 'number' && Number.isFinite(raw)) return raw
+  if (typeof raw === 'string' && raw !== '') {
+    const parsed = Date.parse(raw)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return 0
+}
+
+/** 确定性兜底 tiebreaker：同层同星同时间时按 full_name 字典序（分页不抖动）。 */
+function nameOf(item) {
+  return normalizeSearchName(item?.fullName ?? item?.full_name ?? item?.name)
+}
+
+/** 统一比较器：Tier 0-6 升序 → stars 降序 → updatedAt 降序 → full_name 升序。
+ *  「名字相似为主、同层才比 star」的全部语义都在这一个函数里；所有搜索链只许调它。 */
+function compareByRank(query) {
+  return (a, b) => {
+    const ta = rankTier(query, a)
+    const tb = rankTier(query, b)
+    if (ta !== tb) return ta - tb
+    const sa = starsOf(a)
+    const sb = starsOf(b)
+    if (sa !== sb) return sb - sa
+    const ua = updatedAtOf(a)
+    const ub = updatedAtOf(b)
+    if (ua !== ub) return ub - ua
+    const na = nameOf(a)
+    const nb = nameOf(b)
+    return na < nb ? -1 : (na > nb ? 1 : 0)
+  }
+}
+
+/** **唯一入口**：按用户定案排序（返回**新数组**；条目对象一个字段都不动 —— 只改顺序不改内容）。
+ *  分页幂等的根本保证：同一数组同一 query 的排序结果逐位相同（比较器无随机、无时间依赖）。 */
+function rankSearchResults(items, query) {
+  const list = Array.isArray(items) ? items.slice() : []
+  if (list.length < 2) return list
+  return list.sort(compareByRank(query))
+}
+
+/** 分层结果（UI 角标/说明与测试用）：[{ tier, items }] 只含**真的命中**（Tier 0-6）的层，层序固定。 */
+function rankTiers(items, query) {
+  const buckets = new Map()
+  for (const item of Array.isArray(items) ? items : []) {
+    const tier = rankTier(query, item)
+    if (tier > RANK_TIER.README) continue
+    if (!buckets.has(tier)) buckets.set(tier, [])
+    buckets.get(tier).push(item)
+  }
+  return [...buckets.keys()].sort((a, b) => a - b).map((tier) => ({ tier, items: buckets.get(tier) }))
+}
+
+/**
+ * 分页 + 截断口径（纯函数；GitHub search 的 `total_count` 与 `per_page` 都进这里）：
+ *   · shown   本次实际显示的条目数
+ *   · total   数据源报的**总命中数**（未知传 null → UI 只说"已显示 M 条"，绝不编造总数）
+ *   · hasMore 还能不能往下翻（`page*perPage < total` **且没有翻过数据源硬上限**；总数为 null 时退化为"本页满页"）
+ *   · truncated 结果被截断了（总数 > 本次已取到的范围）——UI 必须**明说**，不许让用户以为"就是没有"
+ *   · reason  截断的**可读原因**（GitHub API 最多 1000 条 / 索引封顶 / 无 total 但满页）
+ * 幂等：同一 (page, perPage, total) 永远同一结论。
+ *
+ * ★ 0.5.35 实测（真机 GitHub，2026-10-03）：`per_page=20&page=51`（第 1001 条起）不是"返回空"而是
+ *   **HTTP 422 `Only the first 1000 search results are available`** —— 也就是说越过上限再翻页必然报错。
+ *   所以 hasMore 在 `page*perPage >= min(total, cap)` 时必须为 false：按钮不给，用户就不会点出一个错误。
+ *   它也在标记块**之内**：浏览器那一半用同一份口径算「加载更多」与「共 N 条」。
+ */
+function buildPageEnvelope({ shown = 0, total = null, page = 1, perPage = 20, cap = 1000, capReason = null } = {}) {
+  const n = Number.isFinite(shown) && shown > 0 ? shown : 0
+  const p = Number.isFinite(page) && page > 0 ? Math.floor(page) : 1
+  const size = Number.isFinite(perPage) && perPage > 0 ? Math.floor(perPage) : 20
+  const known = typeof total === 'number' && Number.isFinite(total) && total >= 0 ? Math.floor(total) : null
+  const capValue = Number.isFinite(cap) && cap > 0 ? Math.floor(cap) : Infinity
+  const fetched = p * size
+  // 数据源硬上限之内还能取到条数（GitHub search 只有前 1000 条；越过就是 422，不是空页）
+  const reachable = known === null ? Infinity : Math.min(known, capValue)
+  // hasMore 只由**总数与上限**决定（`shown > 0`）：本页返回 0 条就是到底了，不许再让用户点空按钮，
+  // 也不许让用户点到必然 422 的那一页。
+  const hasMore = known === null ? n >= size : (n > 0 && fetched < reachable)
+  // 截断分两种，都必须让用户看见（而不是以为"就是没有"）：
+  //   ① 数据源硬上限（GitHub search 只给前 1000 条）→ 这是**始终**成立的事实，与翻到第几页无关；
+  //   ② 本次只取到前 fetched 条（还有更多没取）→ 翻页可解。
+  const overCap = known !== null && known > cap
+  const truncated = overCap || (known === null ? n >= size : known > fetched)
+  let reason = null
+  if (overCap) reason = capReason !== null ? capReason : `数据源最多只返回前 ${cap} 条（命中 ${known} 条）`
+  else if (known === null && n >= size) reason = '数据源未返回总数（只能按每页满页判断还有更多）'
+  else if (known !== null && known > fetched) reason = `共 ${known} 条，本次只取到前 ${Math.min(fetched, known)} 条`
+  // 已经翻到/翻过硬上限：再说"可继续加载"就是骗人（GitHub 第 1001 条起是 422）
+  if (overCap && fetched >= cap) {
+    reason = capReason !== null ? capReason : `数据源最多只返回前 ${cap} 条（命中 ${known} 条）：已翻到第 ${fetched} 条，无法再往下`
+  }
+  return { shown: n, total: known, page: p, perPage: size, hasMore, truncated, reason }
+}
+// <<<market-rank:end>>>
+
+export {
+  RANK_TIER,
+  normalizeSearchName,
+  queryTokens,
+  itemNameForms,
+  nameTokens,
+  textHitsQuery,
+  readmeHitsQuery,
+  rankTier,
+  starsOf,
+  updatedAtOf,
+  compareByRank,
+  rankSearchResults,
+  rankTiers,
+  buildPageEnvelope,
+}

package/lib/server/domain/patch.js

@@ -2,7 +2,7 @@
 // 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
 
 import { readFile, writeFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
+import { dirname, join } from 'node:path'
 import { frameworkBases, isFrameworkModuleName } from '../infra/framework-root.js'
 import { queuedWrite } from '../infra/fsx.js'
 import { escapeRegExp } from '../infra/mask.js'
@@ -71,11 +71,42 @@ async function enableEntry(patchPath, id) {
   })
 }
 
-/** 追加一条 insert 启用行（插件包需已安装到 profile）。 */
+/** 读 profile 清单里的 `dsh.profile.bundles`（包名数组）。
+ *  读不到就返回空数组 —— 绝不因为读清单失败而阻断既有写入行为。 */
+async function readProfileBundles(patchPath) {
+  try {
+    const manifest = JSON.parse(await readFile(join(dirname(patchPath), 'package.json'), 'utf8'))
+    const list = manifest?.dsh?.profile?.bundles
+    return Array.isArray(list) ? list.filter((x) => typeof x === 'string' && x.trim() !== '') : []
+  } catch {
+    return []
+  }
+}
+
+/** 追加一条 insert 启用行（插件包需已安装到 profile）。
+ *
+ *  幂等护栏（2026-10-03 用户实测事故后加）：以下三种情况都**不写**，只回报 `changed:false` + `reason`：
+ *    ① `same-id`        同 id 已经在 insert 里（原有行为）；
+ *    ② `same-package`   **同一个包名**已由别的 insert 行声明 —— 再写一行 = 重复装配，
+ *                       第二行会因重复注册而挂载失败；
+ *    ③ `bundle`         **同一个包名**已由 `dsh.profile.bundles` 声明 —— bundle 自带的
+ *                       patch 会在启动时自动装配它自己的行，我们再插一行同样是重复装配。
+ *
+ *  事故复现：用户先用**官方插件管理**启用插件（= 走 bundle 声明），再在我们面板点「启用」
+ *  → 我们多写了一条 insert 行 → 同一插件被装配两次 → 第二行抛 `already registered`
+ *  → 面板显示「已启用 + 挂载失败」。 */
 async function appendInsert(patchPath, entryId, packageName) {
   return queuedWrite(async () => {
     const { inserts, text } = await readPatchState(patchPath)
-    if (inserts.includes(entryId)) return { changed: false }
+    if (inserts.includes(entryId)) return { changed: false, reason: 'same-id' }
+    const name = String(packageName ?? '').trim()
+    if (name !== '') {
+      for (const declared of parseInsertNames(text).values()) {
+        if (String(declared ?? '').trim() === name) return { changed: false, reason: 'same-package' }
+      }
+      const bundles = await readProfileBundles(patchPath)
+      if (bundles.includes(name)) return { changed: false, reason: 'bundle' }
+    }
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
     const block = `- insert:\n    - id: ${entryId}\n      name: '${packageName}'\n`

package/lib/server/routes/market.js

@@ -6,6 +6,7 @@ import { writeFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { readGithubAuth } from '../domain/install.js'
 import { enrichItems, fetchRepoPackage, fetchSubpackageNames, githubRepoInfo, hasDirectNameHit, normalizePlatformItems, searchNpmPackages, searchSubpackageItems } from '../domain/market.js'
+import { buildPageEnvelope, rankSearchResults } from '../domain/market-search.js'
 import { SKILL_TOPICS, detectSkillRepo, fetchSkillMeta } from '../domain/skills.js'
 import { DEFAULT_SEARCH, gitCloneUrls, orderedRegistries, readGiteeConfig, readSources } from '../domain/sources.js'
 import { GITHUB_API, META_BUDGET_MS, curlJson, fetchJsonUrl, githubJson, looksLikeGitmodules, rawTextWithFallback } from '../infra/http.js'
@@ -13,19 +14,48 @@ import { sendError, sendJson } from '../infra/httpd.js'
 import { marketIndexCacheFile } from '../infra/paths.js'
 import { marketIndexCache, setMarketIndexCache } from '../state.js'
 
+/** 技能检索的 per_page：三 topic 合并去重后不一定还有 20 条，取少了下拉就白丢条目
+ *  （旧行为每 topic 20 条再截前 20 ⇒ 点「加载更多」也翻不出新东西）。 */
+const SKILL_TOPIC_PER_PAGE = 50
+/** 技能池缓存：同一个查询的**同一份合并池**重复切片 ⇒ 翻页幂等（不重不漏）。
+ *  不进 state.js：这是路由层的短命缓存（与静态索引缓存不是一回事）。 */
+const SKILL_POOL_TTL_MS = 300000
+const skillPoolCache = new Map()
+function skillPoolCacheGet(key) {
+  const hit = skillPoolCache.get(key)
+  if (hit === undefined) return null
+  if (Date.now() - hit.at > SKILL_POOL_TTL_MS) { skillPoolCache.delete(key); return null }
+  return hit.items
+}
+function skillPoolCacheSet(key, items) {
+  if (skillPoolCache.size >= 8) skillPoolCache.delete(skillPoolCache.keys().next().value)
+  skillPoolCache.set(key, { at: Date.now(), items })
+}
+
 async function routeSearch(req, res, rc) {
   const DEFAULT_SEARCH = rc.deps.DEFAULT_SEARCH
+  // 网络取数的注入缝（默认就是真通道）：测试要断言"排序/分页/失败路径"时喂固定数据，
+  // 免得把判据与 CI 稳定性绑在网络可用性上（与 routes/index.js 的 deps 同一种风格）。
+  const fetchJson = typeof rc.deps?.fetchJson === 'function' ? rc.deps.fetchJson : fetchJsonUrl
+  const searchRepos = typeof rc.deps?.githubJson === 'function' ? rc.deps.githubJson : githubJson
   const ctx = rc.ctx
   const pathname = rc.pathname
   const method = rc.method
   const body = rc.body
     const raw = typeof body.q === 'string' ? body.q.trim() : ''
     const query = raw === '' ? DEFAULT_SEARCH : raw
-    const page = Math.max(Math.min(Number.parseInt(String(body.page), 10) || 1, 5), 1)
+    // 0.5.35 改错：旧代码把 page **夹到 1..5** —— 第 6 次「加载更多」起原地返回第 5 页，
+    // 用户看到的是"怎么点都不出新条目"（与本次"没有加载更多"同族的第二个截断层）。
+    // 现在只做合法性下限（≥1），真实可翻页性由 buildPageEnvelope 依据数据源的 total 如实回报。
+    const page = Math.max(Number.parseInt(String(body.page), 10) || 1, 1)
     const source = typeof body.source === 'string' && body.source !== '' ? body.source : 'github'
     const all = body.all === true
     const auth = readGithubAuth()
     let items = []
+    // 数据源报的**总命中数**（GitHub search 的 total_count；自定义源没有就留 null —— 绝不编造）
+    let total = null
+    // in:readme 重查那一层有没有被自己的 40 条上限截断（说清楚，别让用户以为"就是没有"）
+    let readmeTruncated = false
     // 给前端的补充说明（如"代码搜索需登录"）——放响应里，前端据此给提示，不改 items 结构
     const extraNotes = {}
     // 增量检索（前端浏览器直连成功时**并行**调用）：只补「npm 包名映射 + in:readme 重查 + 代码搜索子包」，
@@ -36,7 +66,7 @@ async function routeSearch(req, res, rc) {
       if (raw !== '') {
         try { extra.push(...await searchNpmPackages(raw, orderedRegistries(readSources()), 3, auth.token)) } catch {}
         try {
-          const again = await githubJson(
+          const again = await searchRepos(
             `${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,
@@ -48,7 +78,8 @@ async function routeSearch(req, res, rc) {
       sendJson(res, 200, {
         ok: true,
         query: raw,
-        items: extra,
+        // 增量结果同样过**唯一**排序函数：客户端拿到后只需合并，不需要（也不许）自己另排一份
+        items: rankSearchResults(extra, raw),
         extras: true,
         authenticated: auth.loggedIn,
         source: 'github',
@@ -63,11 +94,12 @@ async function routeSearch(req, res, rc) {
       const tasks = [
         (async () => {
           try {
-            const data = await githubJson(
+            const data = await searchRepos(
               `${GITHUB_API}/search/repositories?q=${encodeURIComponent(all ? query : `${query} topic:dsh-plugin`)}&sort=stars&order=desc&per_page=20&page=${page}`,
               req.signal,
               auth.token,
             )
+            if (typeof data?.total_count === 'number') total = data.total_count
             return normalizePlatformItems(data.items ?? [], 'main').map((item) => ({ ...item, source: 'github', sourceName: 'GitHub' }))
           } catch {
             return []
@@ -76,7 +108,7 @@ async function routeSearch(req, res, rc) {
         ...sources.searchSources.filter((s) => s.type === 'custom').map((s) => (async () => {
           try {
             const url = s.url.replace('{q}', encodeURIComponent(query)).replace('{page}', String(page))
-            const data = await fetchJsonUrl(url, 15000, s.headers ?? {})
+            const data = await fetchJson(url, 15000, s.headers ?? {})
             return normalizePlatformItems(data, 'main').map((item) => ({ ...item, source: s.id, sourceName: s.name }))
           } catch {
             return []
@@ -86,40 +118,63 @@ async function routeSearch(req, res, rc) {
       const results = await Promise.all(tasks)
       items = results.flat()
       items = await enrichItems(items)
-      sendJson(res, 200, { ok: true, query, items, authenticated: auth.loggedIn, source: 'all', multi: true })
+      // 多源合并后**只排一次**（唯一排序函数）：跨源条目按同一套名字分层，同层才比 star
+      items = rankSearchResults(items, raw)
+      sendJson(res, 200, {
+        ok: true, query, items, authenticated: auth.loggedIn, source: 'all', multi: true,
+        ...buildPageEnvelope({ shown: items.length, total, page }),
+      })
       return
     }
     if (body.skills === true) {
-      // 技能模式搜索：agent-skills / claude-skills / dsh-skill 三 topic 并行检索后合并去重
-      // （GitHub search 的 OR 语法优先级不可靠，分开查最稳），按 star 排序取前 20。
+      // 技能模式搜索：agent-skills / claude-skills / dsh-skill 三 topic 并行检索后合并去重。
+      // （GitHub search 的 OR 语法优先级不可靠，分开查最稳。）
+      // 0.5.35 改错：旧行为「取前 20 条」把合并池**截断**在 20 —— 客户端点「加载更多」请求下一页，
+      // 服务端仍从**每个 topic 的第 N 页**取 20 条再截前 20，去重后经常一条新的都没有（按钮白点）。
+      // 现在：合并池按唯一排序函数排序 + 去重，然后**照分页口径切片**；并集池按查询缓存，
+      // 同一查询的任何一页都从同一份池里切 ⇒ 翻页幂等（不重不漏）。
       if (source !== 'github') {
         sendError(res, 400, '技能搜索仅支持 GitHub 源')
         return
       }
       const keyword = raw === '' ? '' : `${raw} in:name,description,topics `
-      const tasks = SKILL_TOPICS.map((topic) => (async () => {
-        try {
-          const data = await githubJson(
-            `${GITHUB_API}/search/repositories?q=${encodeURIComponent(`${keyword}topic:${topic}`)}&sort=stars&order=desc&per_page=20&page=${page}`,
-            req.signal,
-            auth.token,
-          )
-          return normalizePlatformItems(data.items ?? [], 'main').map((item) => ({ ...item, source: 'github', skillTopics: [topic] }))
-        } catch {
-          return []
+      const poolKey = `${raw}\u0000${all ? '1' : '0'}`
+      let pool = skillPoolCacheGet(poolKey)
+      if (pool === null) {
+        const tasks = SKILL_TOPICS.map((topic) => (async () => {
+          try {
+            const data = await searchRepos(
+              `${GITHUB_API}/search/repositories?q=${encodeURIComponent(`${keyword}topic:${topic}`)}&sort=stars&order=desc&per_page=${SKILL_TOPIC_PER_PAGE}&page=1`,
+              req.signal,
+              auth.token,
+            )
+            if (typeof data?.total_count === 'number') total = (total ?? 0) + data.total_count
+            return normalizePlatformItems(data.items ?? [], 'main').map((item) => ({ ...item, source: 'github', skillTopics: [topic] }))
+          } catch {
+            return []
+          }
+        })())
+        const merged = (await Promise.all(tasks)).flat()
+        const seen = new Set()
+        const deduped = []
+        for (const item of rankSearchResults(merged, raw)) {
+          if (seen.has(item.fullName)) continue
+          seen.add(item.fullName)
+          deduped.push(item)
         }
-      })())
-      const merged = (await Promise.all(tasks)).flat()
-      const seen = new Set()
-      items = []
-      for (const item of merged.sort((a, b) => b.stars - a.stars)) {
-        if (seen.has(item.fullName)) continue
-        seen.add(item.fullName)
-        items.push(item)
-        if (items.length >= 20) break
+        pool = deduped
+        skillPoolCacheSet(poolKey, pool)
       }
+      const perPage = 20
+      const start = (page - 1) * perPage
+      items = pool.slice(start, start + perPage)
       items = await enrichItems(items)
-      sendJson(res, 200, { ok: true, query, items, authenticated: auth.loggedIn, source: 'github', skills: true })
+      sendJson(res, 200, {
+        ok: true, query, items, authenticated: auth.loggedIn, source: 'github', skills: true,
+        // 技能池的真实总量（三 topic 并集去重后的条数），不是 GitHub 的 total_count 之和
+        // （三个 topic 之间有重叠，直接相加会把"共 N 条"报大）
+        ...buildPageEnvelope({ shown: items.length, total: pool.length, page, perPage }),
+      })
       return
     }
     if (source === 'gitee') {
@@ -140,13 +195,16 @@ async function routeSearch(req, res, rc) {
           // repo 已由 githubRepoInfo 校验；分段编码（只编码中文等非 ASCII，斜杠保留原样——
           // Gitee 服务器不认 %2F 编码的路径分隔，返回 404）
           const [owner, name] = repo.split('/')
-          const data = await fetchJsonUrl(`https://gitee.com/api/v5/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}${tokenQ}`)
+          const data = await fetchJson(`https://gitee.com/api/v5/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}${tokenQ}`)
           items = normalizePlatformItems([data], 'master').map((item) => ({ ...item, source: 'gitee' }))
         } catch (error) {
           giteeError = error instanceof Error ? error.message : String(error)
         }
       }
-      sendJson(res, 200, { ok: true, query, items, authenticated: auth.loggedIn, source, giteeNeedsLogin: false, directOnly: true, giteeError })
+      sendJson(res, 200, {
+        ok: true, query, items, authenticated: auth.loggedIn, source, giteeNeedsLogin: false, directOnly: true, giteeError,
+        ...buildPageEnvelope({ shown: items.length, total, page }),
+      })
       return
     } else if (source !== 'github') {
       // 自定义搜索源：URL 模板（{q}/{page} 占位符），返回数组或 {items} 结构；支持配置的请求头
@@ -159,7 +217,7 @@ async function routeSearch(req, res, rc) {
       const url = custom.url
         .replace('{q}', encodeURIComponent(query))
         .replace('{page}', String(page))
-      const data = await fetchJsonUrl(url, 15000, custom.headers ?? {})
+      const data = await fetchJson(url, 15000, custom.headers ?? {})
       items = normalizePlatformItems(data, 'main').map((item) => ({ ...item, source, sourceName: custom.name }))
     } else {
       // npm 包名搜索与 GitHub 仓库搜索**并行**：npm 侧要查 registry 搜索 + packument + 仓库元数据
@@ -167,12 +225,13 @@ async function routeSearch(req, res, rc) {
       const npmPromise = raw !== '' && !body.skills
         ? searchNpmPackages(raw, orderedRegistries(readSources()), 3, auth.token).catch(() => [])
         : Promise.resolve([])
-      const data = await githubJson(
+      const data = await searchRepos(
         `${GITHUB_API}/search/repositories?q=${encodeURIComponent(all ? query : `${query} topic:dsh-plugin`)}&sort=stars&order=desc&per_page=20&page=${page}`,
         req.signal,
         auth.token,
       )
       items = normalizePlatformItems(data.items ?? [], 'main').map((item) => ({ ...item, source: 'github' }))
+      if (typeof data?.total_count === 'number') total = data.total_count
       items = await enrichItems(items)
       // monorepo 子包增强（OpenViking/examples/dsh-memory-plugin 等可按子包名搜到；
       // 代码搜索需登录，未登录时该函数返回空数组，见 domain/market.js 说明）
@@ -188,7 +247,7 @@ async function routeSearch(req, res, rc) {
       // 首屏没有"名字逐词命中"的条目时，用 in:name,description,readme 再查一次（未登录也能用）。
       if (raw !== '' && !body.skills && page === 1 && !hasDirectNameHit(items, raw)) {
         try {
-          const again = await githubJson(
+          const again = await searchRepos(
             `${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,
@@ -196,7 +255,9 @@ async function routeSearch(req, res, rc) {
           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
+            // 截断上限 40 是**既有**的检索面口径（不改"谁被搜出来"）：只影响 in:readme 重查这一路，
+            // 且被截断这件事由下面的 envelope 如实告知（truncated/reason），不再静默。
+            if (items.length >= 40) { readmeTruncated = true; break }
           }
         } catch {}
       }
@@ -217,7 +278,19 @@ async function routeSearch(req, res, rc) {
       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, ...(extraNotes) })
+    // ★ 唯一一处排序 ★：所有搜索链（github 多路合并 / multi 多源 / custom / gitee）在**这里**统一
+    // 过同一个名字分层函数。上一版各分支自己排/自己截（skills 还截前 20），才会有"点两次结果不同"
+    // 与"高星无关仓库压过逐字命中"。
+    items = rankSearchResults(items, raw)
+    // 分页/截断如实回报：客户端据此决定「加载更多」是否可点、要不要明说"已截断"。
+    const envelope = buildPageEnvelope({ shown: items.length, total, page })
+    sendJson(res, 200, {
+      ok: true, query, items, authenticated: auth.loggedIn, source,
+      ...envelope,
+      // 自己那一层 40 条上限截断了 → 明说（否则用户以为"就是没有"；翻页也解不了这一层）
+      ...(readmeTruncated ? { truncated: true, reason: envelope.reason !== null ? `${envelope.reason}；另：README 重查层已取满 40 条` : 'README 重查层已取满 40 条（可换更精确的关键词缩小范围）' } : {}),
+      ...(extraNotes),
+    })
     return
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.34",
+  "version": "0.5.36",
   "description": "DSH 框架升级安全与插件升级门控：一键升级、失败自动回滚、升级后回滚上版、旧插件不适配自动禁用；内置多源插件市场为发现层，插件源全部可自定义，可指向公司内网私有源 / 私有索引 / 本地 Git 仓库，纯内网离线可用 | Framework upgrade safety & plugin version gating for DSH, with a customizable multi-source plugin market: point every source at internal mirrors or a local file:// repo for intranet-only, offline installs.",
   "repository": {
     "type": "git",