@noob-stupid/dsh-plugin-console 0.5.49 → 0.5.51

package/lib/server/infra/fw-root-detect.js

@@ -0,0 +1,209 @@
+// L0 · infra —— fw-root-detect.js（框架树根的**多基准探测**；0.5.50 加法）
+//
+// 为什么要多基准（真机实证，2026-10-14）：
+//   这套代码会在**两种完全不同的位置**被运行，解析语义天然不同：
+//     ① 插件装在 profile 里（正常形态）—— 从插件自己的 `lib/index.js` 能解析到
+//        `@deepseek-ai/dsh`（本机实测：profile 的 node_modules 把它指向 npx 缓存的
+//        `D:\node_cache\_npx\<hash>\node_modules\@deepseek-ai\dsh`）；
+//     ② 在**开发仓库**里直接跑（`node scripts/fw-preflight.mjs`）—— 仓库根没有 node_modules，
+//        `require.resolve('@deepseek-ai/dsh/package.json')` 直接 `MODULE_NOT_FOUND`。
+//        **而"服务起不来"时最可能的调用方式恰恰是这一种**（用户手里只有一条命令）。
+//   ⇒ 只写一种基准等于在最需要它的场景里失效。本模块把候选收在一处，按"最准 → 最宽"排序。
+//
+// 与 domain/framework-root.js 的分工（**不是同一件事，别合并**）：
+//   · 那边：给**补丁自愈/只读体检**判断"某个 `@deepseek-ai/*` 包在不在"，产出**多个**解析基准；
+//   · 这边：给**预检治包**判断"框架树根本身在哪"，产出**一个**根目录（供走闭包与定 .pnpm 位置）。
+//
+// 分层：L0 · infra（不得 import domain/routes/index —— tests/test-architecture-guard.mjs 断言②）。
+
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { candidateCacheRoots } from './npm-cache.js'
+
+/** 该目录像不像一棵框架树：有 `@deepseek-ai/dsh/lib/bin.js`，或有 `.pnpm` 且其中有 dsh 实体。 */
+function looksLikeFwRoot(dir, { deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  if (typeof dir !== 'string' || dir === '') return false
+  if (exists(join(dir, '@deepseek-ai', 'dsh', 'lib', 'bin.js'))) return true
+  try {
+    for (const name of readdirSync(join(dir, '.pnpm'))) {
+      if (!name.startsWith('@deepseek-ai+dsh@')) continue
+      if (exists(join(dir, '.pnpm', name, 'node_modules', '@deepseek-ai', 'dsh', 'lib', 'bin.js'))) return true
+    }
+  } catch {}
+  return false
+}
+
+/** 从某个基准文件/目录解析 `@deepseek-ai/dsh`，成功则反推承载它的那层 `node_modules`。 */
+function fwRootFromBase(base, { deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  const realpath = deps.realpath ?? ((p) => realpathSync(p))
+  const makeReq = deps.createRequire ?? createRequire
+  let pkgPath = null
+  try { pkgPath = makeReq(base).resolve('@deepseek-ai/dsh/package.json') } catch { return null }
+  if (typeof pkgPath !== 'string') return null
+  // `<…>/node_modules/@deepseek-ai/dsh/package.json` → 退三层 = 那层 node_modules
+  let nm = dirname(dirname(dirname(pkgPath)))
+  // ★ 必须 resolve 成**真身**：profile 侧的 `node_modules/@deepseek-ai/dsh` 常是 junction 投影
+  //   （真机实测：`C:\Users\<u>\.dsh\profiles\node_modules\@deepseek-ai\dsh` → `D:\node_cache\_npx\<hash>\…`）。
+  //   拿投影当框架树根 ⇒ `--repair` 会按"投影的 node_modules / .pnpm"去算目标路径 ⇒ 写到不存在的
+  //   结构里，或者把包装进投影层而不是真身所在的那棵树。解析到真身才能与"服务实际加载的那棵树"对齐。
+  try { nm = dirname(dirname(dirname(realpath(pkgPath)))) } catch {}
+  if (looksLikeFwRoot(nm, { deps })) return nm
+  // rc.1 之后实体在 .pnpm 内层：再向上找最近的含 .pnpm 的 node_modules
+  let dir = nm
+  for (let i = 0; i < 8; i += 1) {
+    if (exists(join(dir, '.pnpm'))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return exists(nm) ? nm : null
+}
+
+/** 扫 npx 缓存（`<cacheBase>/_npx/<hash>/node_modules`），按 dsh 的 bin.js 修改时间取最新那个。 */
+function fwRootFromNpxCache({ env = process.env, home = homedir(), deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  const stat = deps.stat ?? ((p) => statSync(p))
+  const readdir = deps.readdir ?? ((p) => readdirSync(p))
+
+  const bases = []
+  const pushBase = (dir) => {
+    if (typeof dir !== 'string' || dir === '') return
+    if (!bases.includes(dir)) bases.push(dir)
+  }
+  pushBase(env.npm_config_cache)
+  pushBase(env.NPM_CONFIG_CACHE)
+  pushBase('D:\\node_cache')
+  pushBase(join(env.LOCALAPPDATA ?? '', 'npm-cache'))
+  pushBase(join(home, 'AppData', 'Local', 'npm-cache'))
+  // npm cacache 的根通常就是 `<cacheBase>/_cacache`，故从它的父目录取 `_npx`
+  for (const cacache of candidateCacheRoots({ env, home })) pushBase(dirname(cacache))
+
+  const hits = []
+  for (const base of bases) {
+    const npxRoot = join(base, '_npx')
+    if (!exists(npxRoot)) continue
+    let dirs = []
+    try { dirs = readdir(npxRoot) } catch { continue }
+    for (const d of dirs) {
+      const nm = join(npxRoot, d, 'node_modules')
+      const bin = join(nm, '@deepseek-ai', 'dsh', 'lib', 'bin.js')
+      if (!exists(bin)) continue
+      let mtime = 0
+      try { mtime = stat(bin).mtimeMs ?? 0 } catch { mtime = 0 }
+      hits.push({ fwRoot: nm, via: 'npx-cache', mtime })
+    }
+  }
+  if (hits.length === 0) return null
+  // 桌面端启动器就是按 mtime 取最新的那个 —— 这里沿用同一取舍，保证"预检的树"与"会被启动的树"一致
+  hits.sort((a, b) => b.mtime - a.mtime)
+  return hits[0]
+}
+
+/** 扫 `<dshHome>/profiles/**` 与各类 node_modules，找一棵像框架树的。 */
+function fwRootFromDshHome({ env = process.env, home = homedir(), deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  const readdir = deps.readdir ?? ((p) => readdirSync(p))
+  const dshHome = (typeof env.DSH_HOME === 'string' && env.DSH_HOME.trim() !== '') ? env.DSH_HOME.trim() : join(home, '.dsh')
+
+  const cands = []
+  // ① 显式 profile 目录（桌面端/CLI 都会设 DSH_PROFILE_DIR）
+  if (typeof env.DSH_PROFILE_DIR === 'string' && env.DSH_PROFILE_DIR.trim() !== '') cands.push(env.DSH_PROFILE_DIR.trim())
+  // ② 按 profile 名
+  if (typeof env.DSH_PROFILE === 'string' && env.DSH_PROFILE.trim() !== '') cands.push(join(dshHome, 'profiles', env.DSH_PROFILE.trim()))
+  // ③ 共享投影层与各 profile
+  cands.push(join(dshHome, 'profiles', 'node_modules'))
+  try {
+    for (const d of readdir(join(dshHome, 'profiles'))) {
+      if (d === 'node_modules') continue
+      cands.push(join(dshHome, 'profiles', d, 'node_modules'))
+    }
+  } catch {}
+
+  for (const dir of cands) {
+    if (!looksLikeFwRoot(dir, { deps })) continue
+    return { fwRoot: dir, via: 'dsh-home' }
+  }
+  return null
+}
+
+/**
+ * 把"看起来像框架树根"的目录**归一到真身**。
+ *
+ * 为什么必须单独做这一步（真机实测 2026-10-14）：
+ *   `C:\Users\<u>\.dsh\profiles\node_modules` **本身是真实目录**（不是链接），但它下面的
+ *   `@deepseek-ai\dsh` 是 **junction** → `D:\node_cache\_npx\<hash>\node_modules\@deepseek-ai\dsh`。
+ *   于是"这个目录像框架树"与"框架包的真身在哪"是两件事：只对根目录做 realpath 什么也变不了。
+ *   ⇒ 拿投影当根，`--repair` 会按"投影的 node_modules / .pnpm"去算目标路径，写到不存在的结构里；
+ *     而服务实际加载的是**真身那棵树**（启动器命令行 = `…\_npx\<hash>\node_modules\@deepseek-ai\dsh\lib\bin.js`）。
+ *   ⇒ 归一到真身，预检的那棵树才与"会被启动的那棵树"一致。
+ */
+function realRootOf(dir, { deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  const realpath = deps.realpath ?? ((p) => realpathSync(p))
+  if (typeof dir !== 'string' || dir === '') return dir
+  const pkg = join(dir, '@deepseek-ai', 'dsh', 'package.json')
+  if (exists(pkg)) {
+    try { return dirname(dirname(dirname(realpath(pkg)))) } catch { return dir }
+  }
+  // `.pnpm` 内层形态：解析 store 里那份 dsh 的清单，同样退三层
+  try {
+    for (const name of readdirSync(join(dir, '.pnpm'))) {
+      if (!name.startsWith('@deepseek-ai+dsh@')) continue
+      const inner = join(dir, '.pnpm', name, 'node_modules', '@deepseek-ai', 'dsh', 'package.json')
+      if (!exists(inner)) continue
+      return dirname(dirname(dirname(realpath(inner))))
+    }
+  } catch {}
+  return dir
+}
+
+/**
+ * 探测框架树根（**有序**，先准后宽）。返回 `{ fwRoot, via, tried }`；一个都拿不到时
+ * `fwRoot: null` 且 `tried` 列出试过的基准 —— 调用方据此如实报"探测不到"，而不是猜一个。
+ *
+ * 所有分支的返回值都过一道 `realRootOf` —— 保证调用方拿到的永远是**真身所在的那棵树**。
+ *
+ * @param {object} p
+ * @param {string} [p.pluginDir]   插件包根（调用方传 `<repo>/`，用于第 ① 基准）。
+ *                                 ★ 名字不叫 `pluginRoot`：那是 infra/paths.js 的导出名，
+ *                                   同名参数会被架构守卫断言⑧（导入绑定只读）判成"给导出绑定赋值"。
+ * @param {string} [p.entryHint]   已知的入口文件（如 `dsh/lib/bin.js`）—— 给了就优先用它反推。
+ */
+function detectFrameworkRoot({ pluginDir = null, entryHint = null, env = process.env, home = homedir(), deps = {} } = {}) {
+  const realpath = deps.realpath ?? ((p) => realpathSync(p))
+  const tried = []
+  const real = (p) => { try { return realpath(p) } catch { return p } }
+
+  // ⓪ 调用方直接给了入口文件：它所在的那层 node_modules 最准（同样要落到真身）
+  if (typeof entryHint === 'string' && entryHint !== '') {
+    const nm = real(dirname(dirname(dirname(resolve(entryHint)))))
+    tried.push({ via: 'entry-hint', base: nm })
+    if (looksLikeFwRoot(nm, { deps })) return { fwRoot: nm, via: 'entry-hint', tried }
+  }
+
+  // ① 从插件自己解析（插件装在 profile 里时最准）
+  if (typeof pluginDir === 'string' && pluginDir !== '') {
+    const base = join(pluginDir, 'lib', 'index.js')
+    tried.push({ via: 'plugin-root', base })
+    const hit = fwRootFromBase(base, { deps })
+    if (hit !== null) return { fwRoot: realRootOf(hit, { deps }), via: 'plugin-root', tried }
+  }
+
+  // ② DSH_HOME / profile 环境变量
+  tried.push({ via: 'dsh-home', base: '(DSH_HOME/profiles)' })
+  const fromHome = fwRootFromDshHome({ env, home, deps })
+  if (fromHome !== null) return { fwRoot: realRootOf(fromHome.fwRoot, { deps }), via: fromHome.via, tried }
+
+  // ③ npx 缓存（开发仓库里直接跑时的主要出路；与桌面端启动器同一取舍）
+  tried.push({ via: 'npx-cache', base: '(cacheBase/_npx/*)' })
+  const fromNpx = fwRootFromNpxCache({ env, home, deps })
+  if (fromNpx !== null) return { fwRoot: realRootOf(fromNpx.fwRoot, { deps }), via: fromNpx.via, tried }
+
+  return { fwRoot: null, via: null, tried }
+}
+
+export { detectFrameworkRoot, fwRootFromBase, fwRootFromDshHome, fwRootFromNpxCache, looksLikeFwRoot, realRootOf }

package/lib/server/infra/npm-cache.js

@@ -0,0 +1,173 @@
+// L0 · infra —— npm-cache.js（npm cacache **直读** + 零依赖解 tgz；0.5.50 加法）
+//
+// 为什么需要它（2026-10-14 真机停机事故的修复侧）：
+//   框架包被掏空后，`node_modules` 里只剩空壳，但**本地 npm 缓存里通常还留着原始 tarball**。
+//   实测本机：`cordis` / `dsh-llm` / `dsh-tools` / `dsh-web` 四个包的 tarball 全在
+//   `D:\node_cache\_cacache`，按 `package-lock.json` 的 `integrity` **逐字节命中**，110KB 的包
+//   从"发现"到"装回"在 1 秒内完成 —— 全程离线、不联网、不 spawn、不需要 pnpm。
+//
+// 两条硬约束（都是真机踩出来的）：
+//   ① **零依赖**：不 require npm 自带的 `cacache` / `tar`。
+//      实测在 `D:\dsh` 目录下 `require('npm/node_modules/cacache')` 会炸
+//      `ERR_INVALID_PACKAGE_CONFIG`（那儿有个 0 字节的 `package.json`）—— 靠 npm 内部模块
+//      就等于把"打不开时唯一的出路"押在另一个可能坏的东西上。
+//   ② **cacache 布局是确定性的**，直接按哈希路径取文件即可：
+//      `content-v2/sha512/<hex[0:2]>/<hex[2:4]>/<hex[4:]>`，其中 `hex = base64 解码 integrity 后的十六进制`。
+//      这条路不依赖 index-v5 的元数据，也不受 registry 地址（npmjs / npmmirror）影响。
+//
+// 解 tgz 自带一个最小 tar 解析器（ustar + GNU 长名 + pax 头跳过）——见 extractTgz。
+//
+// 分层：L0 · infra（不得 import domain/routes/index —— tests/test-architecture-guard.mjs 断言②）。
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve, sep } from 'node:path'
+import { homedir } from 'node:os'
+import { gunzipSync } from 'node:zlib'
+
+/**
+ * 候选 npm 缓存根（按"最可能先命中"排序）。
+ * 显式 env 优先（`npm_config_cache` / `NPM_CONFIG_CACHE`），再退到用户 .npmrc 的常见落点。
+ */
+function candidateCacheRoots({ env = process.env, home = homedir() } = {}) {
+  const out = []
+  const push = (dir) => {
+    if (typeof dir !== 'string' || dir === '') return
+    const withCache = dir.endsWith('_cacache') ? dir : join(dir, '_cacache')
+    if (!out.includes(withCache)) out.push(withCache)
+  }
+  push(env.npm_config_cache)
+  push(env.NPM_CONFIG_CACHE)
+  push('D:\\node_cache')
+  push(join(env.LOCALAPPDATA ?? '', 'npm-cache'))
+  push(join(home, 'AppData', 'Local', 'npm-cache'))
+  push(join(home, '.npm'))
+  // 只要真的存在 `content-v2` 才算数（光有目录名不算）
+  return out.filter((p) => existsSync(join(p, 'content-v2')))
+}
+
+/**
+ * `sha512-<base64>` → cacache 内容文件的绝对路径。
+ * 非法 integrity / 长度不对时返回 null（**不猜**：宁可报"取不到"，也不去读一个碰巧存在的路径）。
+ */
+function integrityToContentPath(cacheRoot, integrity) {
+  const m = /^sha512-(.+)$/u.exec(String(integrity ?? ''))
+  if (m === null) return null
+  let hex = ''
+  try { hex = Buffer.from(m[1], 'base64').toString('hex') } catch { return null }
+  if (hex.length !== 128 || !/^[0-9a-f]+$/u.test(hex)) return null
+  return join(cacheRoot, 'content-v2', 'sha512', hex.slice(0, 2), hex.slice(2, 4), hex.slice(4))
+}
+
+/** 按 integrity 从缓存读出 tarball 字节；取不到返回 null（绝不抛）。 */
+function readTarball(cacheRoot, integrity, { deps = {} } = {}) {
+  const exists = deps.exists ?? existsSync
+  const read = deps.read ?? ((p) => readFileSync(p))
+  const p = integrityToContentPath(cacheRoot, integrity)
+  if (p === null) return null
+  try { return exists(p) ? read(p) : null } catch { return null }
+}
+
+/** 依次在多个缓存根里找同一个 integrity，返回第一个命中的 `{ buf, cacheRoot }`。 */
+function readTarballFromAny(roots, integrity, { deps = {} } = {}) {
+  for (const root of Array.isArray(roots) ? roots : []) {
+    const buf = readTarball(root, integrity, { deps })
+    if (buf !== null && buf.length > 0) return { buf, cacheRoot: root }
+  }
+  return null
+}
+
+/** 读 tar 头里的一个数值字段（八进制，容忍空格/NUL 结尾与 GNU base-256）。 */
+function tarNumber(header, offset, length) {
+  const raw = header.subarray(offset, offset + length)
+  if ((raw[0] & 0x80) !== 0) {
+    // GNU base-256（大文件/长数字）：低位大端
+    let value = 0
+    for (const byte of raw) value = value * 256 + (byte & 0x7f)
+    return value
+  }
+  const text = raw.toString('utf8').replace(/\0.*$/u, '').trim()
+  const n = parseInt(text, 8)
+  return Number.isFinite(n) ? n : 0
+}
+
+/** 读 tar 头里的一个字符串字段（NUL 截断）。 */
+function tarString(header, offset, length) {
+  return header.subarray(offset, offset + length).toString('utf8').replace(/\0.*$/u, '')
+}
+
+/**
+ * 解开 tar 归档（**零依赖**最小实现：ustar 前缀 + GNU longname/longlink + pax 头跳过）。
+ *
+ * 安全：条目路径必须落在 `destDir` 内（拒绝绝对路径与 `..` 穿越）—— 归档来自本地缓存，
+ * 但仍按"不可信输入"处理，避免一次坏缓存把文件写到树外。
+ *
+ * @returns {{ files: number, dirs: number, skipped: number }}
+ */
+function extractTar(tarBuf, destDir, { deps = {} } = {}) {
+  const mkdir = deps.mkdir ?? ((d) => mkdirSync(d, { recursive: true }))
+  const write = deps.write ?? ((p, data) => writeFileSync(p, data))
+  const root = resolve(destDir)
+  const rootWithSep = root.endsWith(sep) ? root : root + sep
+
+  let files = 0
+  let dirs = 0
+  let skipped = 0
+  let offset = 0
+  let longName = null
+  let longLink = null
+
+  while (offset + 512 <= tarBuf.length) {
+    const header = tarBuf.subarray(offset, offset + 512)
+    // 全零块 = 归档结束
+    let allZero = true
+    for (const byte of header) { if (byte !== 0) { allZero = false; break } }
+    if (allZero) break
+
+    const size = tarNumber(header, 124, 12)
+    const type = String.fromCharCode(header[156] === 0 ? 48 : header[156])
+    const prefix = tarString(header, 345, 155)
+    const rawName = tarString(header, 0, 100)
+    const body = tarBuf.subarray(offset + 512, offset + 512 + size)
+    offset += 512 + Math.ceil(size / 512) * 512
+
+    // GNU 长名/长链接：内容即下一条目的真名，本条自身不落盘
+    if (type === 'L') { longName = body.toString('utf8').replace(/\0.*$/u, ''); continue }
+    if (type === 'K') { longLink = body.toString('utf8').replace(/\0.*$/u, ''); continue }
+    // pax 扩展头：按"不认识就跳过"处理（不改判据、不猜语义）
+    if (type === 'x' || type === 'g') { skipped += 1; continue }
+
+    const name = longName !== null ? longName : (prefix === '' ? rawName : `${prefix}/${rawName}`)
+    longName = null
+    longLink = null
+    if (name === '') { skipped += 1; continue }
+
+    // npm tarball 统一带 `package/` 前缀 —— 剥掉后落到目标目录
+    const rel = name.replace(/^package\//u, '').replace(/^\.\//u, '')
+    if (rel === '') { skipped += 1; continue }
+
+    const out = resolve(join(root, rel))
+    if (out !== root && !out.startsWith(rootWithSep)) { skipped += 1; continue }
+
+    if (type === '5') { mkdir(out); dirs += 1; continue }
+    if (type === '1' || type === '2' || type === '3' || type === '4' || type === '6') { skipped += 1; continue }
+    mkdir(dirname(out))
+    write(out, body)
+    files += 1
+  }
+  return { files, dirs, skipped }
+}
+
+/** 解开 `.tgz`（gunzip + extractTar）。 */
+function extractTgz(tgzBuf, destDir, { deps = {} } = {}) {
+  const gunzip = deps.gunzip ?? gunzipSync
+  return extractTar(gunzip(tgzBuf), destDir, { deps })
+}
+
+export {
+  candidateCacheRoots,
+  extractTar,
+  extractTgz,
+  integrityToContentPath,
+  readTarball,
+  readTarballFromAny,
+}

package/lib/server/infra/pnpm-release-gate.js

@@ -9,6 +9,23 @@
 //   桌面壳/服务进程给的是**永不关闭的 stdin 管道** ⇒ 不抛错、不超时，**永久挂住**
 //   （实测两次分别挂到 90s / 180s 被杀）。
 //
+// ★ 2026-10-14（回校上面这段"现场描述"，**本模块行为未动**）：
+//   上述因果链里"pnpm 弹提问 ⇒ 读 stdin 到 EOF ⇒ 永久挂住"这一段**实测不成立**：
+//     · pnpm 的 canPrompt = `!inCi && Boolean(process.stdin.isTTY)`（L194277-278）；
+//       管道下 isTTY 恒假 ⇒ pnpm **从不**走 prompt 分支，直接 `throw failOnImmature`。
+//     · 实测（pnpm 11.7.0，minimumReleaseAge 设成天文数字 + 管道 stdin）：无 ci 位 / CI=true /
+//       npm_config_ci=true / --config.ci=true / 两者齐上 —— **五种配置全部快速失败，无一挂住**。
+//     · 那"挂到 90s / 180s"其实是**我们自己的超时常量**：`runPnpmAdd` 默认 timeout=90000、
+//       `link-self-sufficiency#installTargetDependencies` 默认 timeoutMs=180000 —— 与当时观察
+//       逐一吻合 ⇒ 当时是"某次操作超过我们设的超时被我们杀掉"，**不是**"等输入等到天荒地老"。
+//       那次为什么慢**至今没有证据**（最可能是网络）；corepack 的下载提问也**默认是关的**
+//       （入口 shim 第一行 `COREPACK_ENABLE_DOWNLOAD_PROMPT ??= '0'`）。
+//   ⇒ 本模块的定位不变（**识别 + 翻译成可操作错误**，绝不绕过闸门），仍然有价值；
+//     只是「为什么会挂住」**至今未查明**，不要再照 0.5.48 那段因果链去找。
+//     另两处一并更正（详见 infra/exec.js#pnpmEnvOverrides 上方的完整说明）：
+//       · `npm_config_ci=true` 对 pnpm 自己的配置项是**空操作**（只认 `pnpm_config_*`）；
+//       · `CI=true` **确实**点亮 ci 位（pnpm 配置默认值 `ci: isCI`，L145865），且 v0.5.30 就有。
+//
 // 闸门实现（本机 pnpm 11.7.0 `dist/pnpm.mjs`，只读反编译取证）：
 //   L194277  const inCi = opts3.ci ?? isCI
 //   L194278  const canPrompt = !inCi && Boolean(process.stdin.isTTY)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.49",
+  "version": "0.5.51",
   "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",
@@ -50,7 +50,8 @@
     "lib",
     "cordis.patch.yml",
     "SECURITY.md",
-    "icon.svg"
+    "icon.svg",
+    "scripts"
   ],
   "license": "MIT",
   "scripts": {

package/scripts/apply-framework-patch.cjs

@@ -0,0 +1,134 @@
+/**
+ * 框架层补丁：dsh-app-boot 的 cordis.patch.yml 解析容错（议题 #5）。
+ *
+ * 问题：cordis.patch.yml 若含顶格 `[]` 占位符 + 后续条目（两个 YAML 根节点），
+ * DSH 启动时 parsePatchList 解析崩溃（"end of the stream or a document separator is expected"）。
+ *
+ * 修复：parsePatchList 解析失败时，自动移除顶格空数组占位行（视为 no-op）后重试。
+ *
+ * 用法：node scripts/apply-framework-patch.cjs
+ * 说明：DSH 升级（npx 重新拉取）后框架文件会被覆盖，重新运行本脚本即可。
+ */
+const fs = require('node:fs')
+const path = require('node:path')
+const os = require('node:os')
+
+/** npm 缓存下的 npx 缓存目录候选（**不写死盘符/用户名**）。
+ *  npm 的 cache 位置是用户配置（把 cache 指到别的盘很常见）→ 按 npm 自己的来源读：
+ *  环境变量 npm_config_cache / NPM_CONFIG_CACHE + 用户级 ~/.npmrc 的 `cache=`。
+ *  （原实现第一条写死开发机上的缓存绝对路径：某个盘符下的 node_cache\_npx。） */
+function npmNpxCacheRoots() {
+  const roots = []
+  const push = (value) => {
+    if (typeof value !== 'string') return
+    const dir = value.trim().replace(/^["']|["']$/g, '').replace(/^~(?=[\\/]|$)/, os.homedir())
+    if (dir !== '') roots.push(path.join(dir, '_npx'))
+  }
+  for (const key of ['npm_config_cache', 'NPM_CONFIG_CACHE']) push(process.env[key])
+  try {
+    for (const line of fs.readFileSync(path.join(os.homedir(), '.npmrc'), 'utf8').split(/\r?\n/)) {
+      const hit = /^\s*cache\s*=\s*(.*?)\s*$/i.exec(line)
+      if (hit) push(hit[1])
+    }
+  } catch {}
+  return roots
+}
+
+// 定位 @deepseek-ai/dsh-app-boot（与 @deepseek-ai/dsh 同级）
+function locateAppBoot() {
+  try {
+    const dshPkg = require.resolve('@deepseek-ai/dsh/package.json')
+    const aiDir = path.dirname(dshPkg) // .../node_modules/@deepseek-ai
+    const candidate = path.join(aiDir, 'dsh-app-boot', 'lib', 'index.js')
+    if (fs.existsSync(candidate)) return candidate
+  } catch {}
+  const cacheRoots = [
+    process.env.NODE_CACHE || '',
+    ...npmNpxCacheRoots(),
+    path.join(os.homedir(), '.npm', '_npx'),
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'node_cache', '_npx') : '',
+  ].filter(Boolean)
+  for (const root of cacheRoots) {
+    if (!fs.existsSync(root)) continue
+    let entries = []
+    try { entries = fs.readdirSync(root, { withFileTypes: true }) } catch { continue }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const candidate = path.join(root, entry.name, 'node_modules', '@deepseek-ai', 'dsh-app-boot', 'lib', 'index.js')
+      if (fs.existsSync(candidate)) return candidate
+    }
+  }
+  return null
+}
+
+const MARKER = 'tryDropEmptyArrayPlaceholder'
+const OLD = `function parsePatchList(binName, file, content, label) {
+	let parsed;
+	try {
+		parsed = yaml.load(content, { schema: userPatchesSchema });
+	} catch (error) {
+		throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+	}`
+const NEW = `function parsePatchList(binName, file, content, label) {
+	let parsed;
+	try {
+		parsed = yaml.load(content, { schema: userPatchesSchema });
+	} catch (error) {
+		// 容错（issue #5）：文件可能是「[] 空数组占位符 + 后续条目」两个根节点，
+		// YAML 解析必然失败。移除顶层空数组占位行（视为 no-op）后重试。
+		const retried = tryDropEmptyArrayPlaceholder(content);
+		if (retried !== null) {
+			try {
+				parsed = yaml.load(retried, { schema: userPatchesSchema });
+			} catch {
+				throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+			}
+		} else {
+			throw new Error(\`${'${binName}'}: failed to parse ${'${label}'} ${'${file}'}: ${'${String(error)}'}\`);
+		}
+	}`
+
+const HELPER = `
+/**
+ * 容错辅助（issue #5）：若文件含顶格空数组占位行（\`[]\` / \`[ ]\`，可带行尾注释），
+ * 视为 no-op 全部移除；无此模式返回 null。
+ */
+function tryDropEmptyArrayPlaceholder(content) {
+	const lines = String(content).split("\\n");
+	const kept = [];
+	let dropped = false;
+	for (const line of lines) {
+		if (/^\\[\\s*\\]\\s*(?:#.*)?$/u.test(line)) {
+			dropped = true;
+			continue;
+		}
+		kept.push(line);
+	}
+	if (!dropped) return null;
+	return kept.join("\\n");
+}
+`
+
+function main() {
+  const target = locateAppBoot()
+  if (!target) {
+    console.error('未找到 @deepseek-ai/dsh-app-boot/lib/index.js，请确认 DSH 已安装（或手动指定路径）')
+    process.exit(1)
+  }
+  const source = fs.readFileSync(target, 'utf8')
+  if (source.includes(MARKER)) {
+    console.log('已打过补丁，跳过：' + target)
+    return
+  }
+  if (!source.includes('function parsePatchList')) {
+    console.error('未找到 parsePatchList（框架版本可能已变更），跳过。' + target)
+    process.exit(1)
+  }
+  fs.copyFileSync(target, target + '.bak-issue5')
+  const next = source.replace(OLD, NEW) + HELPER
+  fs.writeFileSync(target, next, 'utf8')
+  console.log('补丁已应用：' + target)
+  console.log('备份：' + target + '.bak-issue5')
+}
+
+main()

package/scripts/apply-npm-names.cjs

@@ -0,0 +1,36 @@
+/**
+ * 给已提交的 marketplace/index.json 就地补 npmName（批次 C-⑪）。
+ *
+ * 为什么单独有这个脚本：build-index.cjs 需要 gh CLI + 网络（本机 github 不可达时跑不了），
+ * 而"补 npmName"这件事**完全离线** —— 映射来自 marketplace/npm-name-hints.json（人工核对）。
+ * 用法：
+ *   node scripts/apply-npm-names.cjs                     # 就地更新 marketplace/index.json
+ *   node scripts/apply-npm-names.cjs --dry-run           # 只报告会改哪几条
+ *   node scripts/apply-npm-names.cjs --file=<index.json> # 指定索引文件
+ * 幂等：已经带 npmName 的条目内容不变；映射里没有的仓库保持原样（老索引兼容）。
+ */
+const fs = require('node:fs')
+const path = require('node:path')
+const { readNpmNameHints, withNpmNames } = require('./build-index.cjs')
+
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry-run')
+const fileArg = args.find((a) => a.startsWith('--file='))
+const hintsArg = args.find((a) => a.startsWith('--hints='))
+const indexFile = fileArg ? fileArg.split('=')[1] : path.join(__dirname, '..', 'marketplace', 'index.json')
+const hints = readNpmNameHints(hintsArg ? hintsArg.split('=')[1] : undefined)
+
+const raw = JSON.parse(fs.readFileSync(indexFile, 'utf8'))
+const before = Array.isArray(raw.items) ? raw.items : []
+const after = withNpmNames(before, hints)
+const changed = after.filter((it, i) => typeof it.npmName === 'string' && before[i]?.npmName !== it.npmName)
+
+console.log(`映射条目 ${Object.keys(hints).length} 条；索引 ${before.length} 条命中 ${changed.length} 条`)
+for (const it of changed) console.log(`  ${it.fullName} → ${it.npmName}`)
+
+if (dryRun) {
+  console.log('（dry-run：未写入）')
+  process.exit(0)
+}
+fs.writeFileSync(indexFile, JSON.stringify({ ...raw, items: after }, null, 2) + '\n', 'utf8')
+console.log(`已写入 ${indexFile}`)