@noob-stupid/dsh-plugin-console 0.5.48 → 0.5.50

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/paths.js

@@ -66,20 +66,45 @@ function baseDirOf(baseUrl) {
  *     成功后从解析结果**向上找最近的 package.json** 作为该包的清单。
  *   ⇒ 负控不变：真不存在的子路径，三条路都失败 ⇒ 仍然返回 null（**绝不放松成"一律放行"**）。
  */
-function nearestPackageJson(fromPath) {
+/** 从解析结果向上找清单。**优先认包名匹配的那份**（★ 0.5.49 改错，见下）。
+ *
+ * ★ 2026-10-14（0.5.49）改错：不能只取"最近的 package.json"。
+ *   真机现场：`@linxin666/dsh-web-all/plugin-manager` 的 exports 目标是 `./lib/shells/shell.js`，
+ *   而 `lib/shells/` 下还有一个**构建产物用的私有子清单**
+ *   （`{"name":"@linxin666/dsh-web-all-shells","private":true}` —— **没有 version 字段**）。
+ *   只认"最近" ⇒ 拿到那份子清单 ⇒ 版本/仓库全空（和"解不出来"一样是坏结果，只是换了个坏法）。
+ *   所以向上找时：命中"name 与引用包名相同"的清单立即返回；一路都没匹配才退回最近的那份
+ *   （不返回 null —— 包确实存在，只是清单不规范，此时宁可给出最近的那份也不谎报"没有这个包"）。
+ */
+function nearestPackageJson(fromPath, expectedName = null) {
   try {
     let dir = dirname(fromPath)
+    let fallback = null
     for (let depth = 0; depth < 40; depth += 1) {
       const candidate = join(dir, 'package.json')
-      if (existsSync(candidate)) return candidate
+      if (existsSync(candidate)) {
+        if (fallback === null) fallback = candidate
+        if (typeof expectedName === 'string' && expectedName !== '' && manifestNameOf(candidate) === expectedName) return candidate
+      }
       const parent = dirname(dir)
       if (parent === dir) break
       dir = parent
     }
+    return fallback
   } catch {}
   return null
 }
 
+/** 读一份清单的 `name`（读不到/不是 JSON 就返回 null）。 */
+function manifestNameOf(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    return typeof parsed?.name === 'string' ? parsed.name : null
+  } catch {
+    return null
+  }
+}
+
 /** 该引用是不是"包 + 子路径"形态（`pkg/sub`、`@scope/pkg/sub`）。
  * 判据与 packageNameOf 同源：剥掉包名后还剩东西 ⇒ 是子路径引用。 */
 function isSubpathRef(refName) {
@@ -87,12 +112,15 @@ function isSubpathRef(refName) {
   return refName !== packageNameOf(refName)
 }
 
-/** 用真实解析语义解析「包/子路径」引用的清单路径：先解析引用本身，再向上找最近的清单。 */
+/** 用真实解析语义解析「包/子路径」引用的清单路径：先解析引用本身，再向上找**该包**的清单。
+ *  向上找时把包名传下去（`nearestPackageJson(refName, expectedName)`）—— 真机上就有子目录里放
+ *  私有子清单的包（`@linxin666/dsh-web-all/lib/shells/package.json`，name 是 `…-shells` 且无 version），
+ *  只取"最近"会拿到那份、版本照样是空的。详见 nearestPackageJson 的注释。 */
 function resolveViaRealSemantics(refName, base) {
   if (typeof base !== 'string' || base === '') return null
   try {
     const entry = createRequire(join(base, 'package.json')).resolve(refName)
-    return nearestPackageJson(entry)
+    return nearestPackageJson(entry, packageNameOf(refName))
   } catch {
     return null
   }
@@ -103,13 +131,27 @@ function resolvePackageJson(pkgName, baseDir, fallbackBase) {
   // ① 真实解析语义（认 exports 子路径）—— 优先，且**不**拼 `/package.json`
   const real = resolveViaRealSemantics(pkgName, baseDir)
   if (real !== null) return real
-  // ★ 子路径引用（`包/子路径`）到此为止：**不许**再退到"按包名找清单"的那两条 fallback。
-  //   为什么：那两条是按**包名**（packageNameOf 剥掉子路径后的 name）找 `node_modules/<包名>/package.json`，
-  //   对不存在的子路径也会命中**包根**那份清单 ⇒ 把一个坏引用判成好的
-  //   —— 正是"校验被放松成一律放行"，任务红线明令不许。
+  // ★ 子路径引用（`包/子路径`）单独一条路：只认「真实解析语义」，但**两个基准都认**。
+  //
+  // 为什么要挡住后两条：那两条是按**包名**（packageNameOf 剥掉子路径后的 name）找
+  //   `node_modules/<包名>/package.json`，对不存在的子路径也会命中**包根**那份清单
+  //   ⇒ 把一个坏引用判成好的 —— 正是"校验被放松成一律放行"，任务红线明令不许。
   //   （本机实测：`@scope/tool/nope` 在 @scope/tool 存在时会从 fallback 拿到包根清单。）
-  //   而真实解析语义对这一类已经给出权威答案：能解析就是好，不能解析就是坏 ⇒ 直接返回 null。
-  if (isSubpathRef(pkgName)) return null
+  //
+  // ★ 2026-10-14（0.5.49）改错：这道闸原先写成**在 fallbackBase 那次真实解析之前**就 `return null`，
+  //   于是把 profile 回退这条**合法**路径也一起掐了 —— 0.5.48 上 `@linxin666/dsh-web-all/plugin-manager`
+  //   （框架树里没有、只在 profile 里）从"解得出"退回 null，面板里那批第三方子路径行的
+  //   版本/安装日期/仓库全变空（实测 /plugin-console/state 确认），而官方子路径行走的是框架基准、
+  //   不受影响 ⇒ 现场不显眼。判据本身没错，错在**位置**：要挡的是"按包名找清单"那两条兜底，
+  //   不是"解析这个引用本身"。所以现在：baseDir 真实解析 → fallbackBase 真实解析 → 再 return null。
+  //   ⇒ 负控不变（`@scope/tool/nope` 两条真实解析都失败 ⇒ 仍是 null，绝不放松成一律放行）。
+  if (isSubpathRef(pkgName)) {
+    if (typeof fallbackBase === 'string' && fallbackBase !== '' && fallbackBase !== baseDir) {
+      const realFallback = resolveViaRealSemantics(pkgName, fallbackBase)
+      if (realFallback !== null) return realFallback
+    }
+    return null
+  }
   // ② 既有两条（顺序与行为不变）：`<name>/package.json` 解析 → node_modules 物理路径
   try {
     return createRequire(join(baseDir, 'package.json')).resolve(`${name}/package.json`)

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

@@ -9,6 +9,21 @@
 //   桌面壳/服务进程给的是**永不关闭的 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 / 两者齐上 —— **五种配置全部快速失败，无一挂住**。
+//     · 真正读 stdin 等人的是 **corepack 的下载提问**（corepack.cjs L22083：
+//       `if (process.stdin.isTTY && !process.env.CI) { stderr.write('? Do you want to continue?');
+//        stdin.resume(); await once(stdin,'data') }`）—— 判据恰恰是 `process.env.CI`。
+//   ⇒ 本模块的定位不变（**识别 + 翻译成可操作错误**，绝不绕过闸门），仍然有价值；
+//     只是"为什么会挂住"要记在 corepack 头上，不是 pnpm 的供应链闸。
+//     顺带更正另两处（详见 infra/exec.js#pnpmEnvOverrides 上方的完整说明）：
+//       · `npm_config_ci=true` 对 pnpm 自己的配置项是**空操作**（只认 `pnpm_config_*`）；
+//       · `CI=true` **确实**点亮 ci 位（pnpm 配置默认值 `ci: isCI`，L145865）。
+//
 // 闸门实现（本机 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.48",
+  "version": "0.5.50",
   "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,9 @@
     "lib",
     "cordis.patch.yml",
     "SECURITY.md",
-    "icon.svg"
+    "icon.svg",
+    "scripts/safe-boot.mjs",
+    "scripts/fw-preflight.mjs"
   ],
   "license": "MIT",
   "scripts": {