@noob-stupid/dsh-plugin-console 0.5.99 → 0.5.100

package/lib/server/domain/patch.js

@@ -1,20 +1,70 @@
 // L1 · domain —— patch.js（由 Step 2 从 lib/index.js 原样切出，只搬移未改逻辑）
 // 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
 
-import { readFile, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
 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'
 import { makePackageResolver } from '../infra/package-resolve.js'
 
-/** 读取补丁文件并扫描：停用块与 insert 行的 id。 */
-async function readPatchState(patchPath) {
+/**
+ * 写补丁前先建父目录（issue #27 的**派生缺口**，0.5.99 加法）。
+ *
+ * 为什么必须补：补丁路径是从 loader 的 `cordis:include` 条目推导出来的（见 infra/paths.js），
+ * 推导一旦指向一个**还不存在**的 profile 目录，本文件里原先 7 处 `writeFile` 全是**裸写** ——
+ * 父目录不在就 ENOENT。表现分两种，都很难查：
+ *   ① 调用方 catch 了异常 ⇒ 面板显示"已启用"，文件里却一个字都没有（假成功）；
+ *   ② 异常冒到接口 ⇒ 500，但真正的原因（profile 目录不存在）没人说出来。
+ * ⇒ 现在写前 `mkdir(dirname(p), { recursive: true })`：只把"**本来该成功却失败**"的那条路补上；
+ *   原本就写得成功的路径一个字节都不变（目录已存在时 recursive mkdir 是幂等 no-op）。
+ *
+ * mkdir 自己失败时**原样抛出**（绝不吞成"写成功"）：要么调用方 catch，要么接口如实报错 ——
+ * 但绝不能出现"目录没建出来、函数却正常返回"。
+ * `deps.mkdir` 只是给测试用的注入缝（模拟 EPERM），生产默认就是 node:fs/promises#mkdir。
+ */
+async function ensurePatchParentDir(patchPath, deps = {}) {
+  const make = typeof deps.mkdir === 'function' ? deps.mkdir : mkdir
+  await make(dirname(patchPath), { recursive: true })
+}
+
+/**
+ * 父目录是不是**真的不存在**（`readPatchState` 区分"两种缺失"的判据）。
+ *
+ * 只在 readFile 已经 ENOENT 之后才被调用 —— 文件正常读取时一次 syscall 都不多。
+ * 判据**保守**：只有确证（ENOENT / ENOTDIR）才说"父目录不存在"；
+ * EPERM/EACCES 这类"读不到但不一定没有"的情况一律返回 false（宁可不说，不谎报路径错）。
+ */
+async function parentDirMissing(patchPath, statFn) {
+  try {
+    await statFn(dirname(patchPath))
+    return false
+  } catch (error) {
+    return error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+  }
+}
+
+/** 读取补丁文件并扫描：停用块与 insert 行的 id。
+ *
+ *  ★ 0.5.99 加法：「文件不存在」过去被 ENOENT 一起吞成"空补丁"，于是**路径推导错了**与
+ *    **文件真的是空的**在返回值上完全一样 —— issue #27 那个 bug（补丁全写到废弃的 web profile、
+ *    在用的 desktop 静默收不到）正是靠这条配合才藏了三周。
+ *    现在区分两种缺失，但**一个字都不改既有语义**：
+ *      ① 父目录在、文件还没建（新 profile 第一次写补丁，**正常**）⇒ 空补丁，`parentMissing: false`；
+ *      ② 父目录也不在（**路径推导错了**）⇒ 仍然返回空补丁（不抛错、既有调用方行为不变），
+ *         只多带 `parentMissing: true` + `missingReason: 'parent-missing'`，让上层看得见。
+ *    健康环境下的返回值只比过去多**一个**字段（`parentMissing`）——`missingReason` 仅在缺失时出现。
+ *  `deps.stat` 是给测试用的注入缝；生产默认 node:fs/promises#stat。公开调用面仍是 `readPatchState(path)`。
+ */
+async function readPatchState(patchPath, deps = {}) {
+  const statFn = typeof deps.stat === 'function' ? deps.stat : stat
   let text = ''
+  let parentMissing = false
   try {
     text = await readFile(patchPath, 'utf8')
   } catch (error) {
     if (error.code !== 'ENOENT') throw error
+    parentMissing = await parentDirMissing(patchPath, statFn)
   }
   const disables = []
   const forced = []
@@ -39,7 +89,11 @@ async function readPatchState(patchPath) {
     if (/^ {2}disabled: true\s*$/u.test(next)) disables.push(disableRow[1])
     else if (/^ {2}disabled: false\s*$/u.test(next)) forced.push(disableRow[1])
   }
-  return { disables, forced, inserts, text }
+  // ★ 只增字段：健康环境下 = 既有 4 个字段 + `parentMissing: false`；
+  //   父目录缺失时才多一个 `missingReason`（见上面的注释）。
+  const state = { disables, forced, inserts, text, parentMissing }
+  if (parentMissing) state.missingReason = 'parent-missing'
+  return state
 }
 
 /** 停用：追加 disabled:true 块（已存在则不动）。 */
@@ -49,6 +103,7 @@ async function disableEntry(patchPath, id) {
     if (disables.includes(id)) return { changed: false }
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}${disableBlock(id)}`, 'utf8')
     return { changed: true }
   })
@@ -60,12 +115,14 @@ async function enableEntry(patchPath, id) {
     const { disables, forced, text } = await readPatchState(patchPath)
     const blockRe = new RegExp(`^- id: ${escapeRegExp(id)}\\r?\\n  disabled: true\\r?\\n`, 'mu')
     if (blockRe.test(text)) {
+      await ensurePatchParentDir(patchPath)
       await writeFile(patchPath, sanitizePatchText(text.replace(blockRe, '')), 'utf8')
       return { changed: true }
     }
     if (forced.includes(id)) return { changed: false }
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}- id: ${id}\n  disabled: false\n`, 'utf8')
     return { changed: true }
   })
@@ -110,6 +167,7 @@ async function appendInsert(patchPath, entryId, packageName) {
     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`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}${block}`, 'utf8')
     return { changed: true }
   })
@@ -123,7 +181,10 @@ async function removeInsertRow(patchPath, rowId) {
     let next = text.replace(blockRe, '')
     const overrideRe = new RegExp(`^- id: ${escapeRegExp(rowId)}\\s*\\r?\\n {2}disabled: (true|false)\\s*\\r?\\n`, 'mu')
     next = next.replace(overrideRe, '')
-    if (next !== text) await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    if (next !== text) {
+      await ensurePatchParentDir(patchPath)
+      await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    }
   })
 }
 
@@ -133,7 +194,10 @@ function removeDisableBlock(patchPath, rowId) {
     const { text } = await readPatchState(patchPath)
     const overrideRe = new RegExp(`^- id: ${escapeRegExp(rowId)}\\s*\\r?\\n {2}disabled: (true|false)\\s*\\r?\\n`, 'mu')
     const next = text.replace(overrideRe, '')
-    if (next !== text) await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    if (next !== text) {
+      await ensurePatchParentDir(patchPath)
+      await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    }
   })
 }
 
@@ -212,7 +276,12 @@ function parseInsertNames(text) {
 async function healPatchSafety(patchPath, deps = {}) {
   const profileDir = dirname(patchPath)
   const readText = deps.readText ?? ((p) => readFile(p, 'utf8'))
-  const writeText = deps.writeText ?? ((p, data) => writeFile(p, data, 'utf8'))
+  // 默认写盘实现也走「先建父目录」：注入缝只是把 writeFile 换成别的写盘手段，
+  // 不该因此丢掉父目录保证（过去注入 readText/writeText 的调用方拿到的行为不变）。
+  const writeText = deps.writeText ?? (async (p, data) => {
+    await ensurePatchParentDir(p, deps)
+    await writeFile(p, data, 'utf8')
+  })
   const { text } = await readPatchState(patchPath)
   const healed = []
   const autoDisabled = []

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

@@ -103,28 +103,146 @@ function fwRootFromNpxCache({ env = process.env, home = homedir(), deps = {} } =
   return hits[0]
 }
 
-/** 扫 `<dshHome>/profiles/**` 与各类 node_modules，找一棵像框架树的。 */
+/** 路径比较用的归一键（只用于"是不是同一个目录"的去重/比对，不用于任何业务判据）。 */
+function dirKey(dir) {
+  if (typeof dir !== 'string' || dir === '') return ''
+  let out = dir
+  try { out = resolve(dir) } catch {}
+  out = out.replace(/[\\/]+$/u, '')
+  // Windows 路径大小写不敏感（`C:\Users` 与 `c:\users` 是同一个目录）—— 其他平台保持原样
+  return process.platform === 'win32' ? out.toLowerCase() : out
+}
+
+/** 两个路径是不是同一个目录（同上：仅用于比对）。 */
+function sameDir(a, b) {
+  const ka = dirKey(a)
+  return ka !== '' && ka === dirKey(b)
+}
+
+/**
+ * 当前生效的补丁落在哪个 profile 目录？推导不出来返回 `null`（**绝不猜、也绝不报错**）。
+ *
+ * 为什么要它（0.5.99 加法，issue #27 的同一批现场）：`<dshHome>/profiles/` 下**每个**子目录都会
+ * 变成框架树候选（包括早已废弃的那个 profile —— 真机上 desktop 在用、web 是 issue #27 的受害者）。
+ * 废弃 profile 里往往还留着旧框架的残影，`looksLikeFwRoot()` **分不出死活** ⇒ 谁先试谁被选中。
+ * ⇒ 用"当前补丁所在的 profile"给候选排个序：同一 profile 的先试（剩下的照旧）。
+ *
+ * 取值顺序（都拿不到就返回 null，排序优化自动跳过）：
+ *   ① `deps.derivePatchPath()`（调用方注入，一般就是 infra/paths.js#findPatchPath 的包装）
+ *   ② `deps.patchPath`（补丁文件全路径）/ `deps.profileDir`（profile 目录）
+ *   ③ `DSH_PROFILE_DIR`（桌面端/CLI 显式设置，最可信 —— 与 paths.js#defaultPatchPath 同源）
+ *   ④ `DSH_PROFILE`（只给名字时拼 `profiles/<name>`）
+ * ★ 这里刻意**不**去调 `defaultPatchPath()`：它读的是进程级 `process.env` 与真实 home，
+ *   在注入了 `env`/`home` 的调用（测试、预检脚本）里会串味成"另一台机器的 profile"。
+ */
+function activeProfileDirOf({ env = process.env, dshHome, deps = {} } = {}) {
+  const nonEmpty = (v) => typeof v === 'string' && v.trim() !== '' ? v.trim() : null
+  if (typeof deps.derivePatchPath === 'function') {
+    try {
+      const p = nonEmpty(deps.derivePatchPath())
+      if (p !== null) return dirname(resolve(p))
+    } catch {}
+  }
+  const fromPatchPath = nonEmpty(deps.patchPath)
+  if (fromPatchPath !== null) return dirname(resolve(fromPatchPath))
+  const fromProfileDir = nonEmpty(deps.profileDir)
+  if (fromProfileDir !== null) return resolve(fromProfileDir)
+  const fromEnvDir = nonEmpty(env.DSH_PROFILE_DIR)
+  if (fromEnvDir !== null) return resolve(fromEnvDir)
+  const fromEnvName = nonEmpty(env.DSH_PROFILE)
+  if (fromEnvName !== null) return join(dshHome, 'profiles', fromEnvName)
+  return null
+}
+
+/**
+ * 给 `profiles/<name>/node_modules` 这批候选**排序**（只排，不删 —— 判据仍是既有的 looksLikeFwRoot）。
+ *
+ * 优先级：
+ *   0 与当前生效补丁同 profile（"活着的那棵树"）→ 先试；
+ *   1 像框架树（既有判据 `looksLikeFwRoot`）→ 次之；
+ *   2 其余 → 最后。
+ * 同档内保持**传入顺序**（= readdir 原顺序）⇒ 结果稳定，不随目录名排序漂移。
+ *
+ * ★ 排序器只影响**先试谁**，绝不决定"能不能选到"：`fwRootFromDshHome()` 末尾仍会按**旧顺序**
+ *   把每个候选再兜一遍（见那里的 `legacy` 循环），所以任何原本能选到的树都还能选到。
+ */
+function rankProfileCandidates(candidates, { activeProfileDir = null, looksLike = null } = {}) {
+  const list = Array.isArray(candidates) ? candidates.filter((d) => typeof d === 'string' && d !== '') : []
+  const isTree = typeof looksLike === 'function' ? looksLike : (dir) => looksLikeFwRoot(dir)
+  const tierOf = (dir) => {
+    if (activeProfileDir !== null && sameDir(dirname(dir), activeProfileDir)) return 0
+    try { if (isTree(dir)) return 1 } catch {}
+    return 2
+  }
+  return list
+    .map((dir, index) => ({ dir, index, tier: tierOf(dir) }))
+    .sort((a, b) => (a.tier - b.tier) || (a.index - b.index))
+    .map((x) => x.dir)
+}
+
+/** 扫 `<dshHome>/profiles/**` 与各类 node_modules，找一棵像框架树的。
+ *
+ *  ★ 0.5.99 加法（issue #27 的同一批现场）：`profiles/<name>/node_modules` 这批候选**不再按
+ *    readdir 顺序盲试**，而是先试"当前生效补丁同 profile"的那棵、再试像框架树的，其余垫底
+ *    （见 `rankProfileCandidates`）。前三项（DSH_PROFILE_DIR / DSH_PROFILE / 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())
+  // 同一次调用里每个候选只判定一次（排序用一次、挑选用一次，别重复扫盘）
+  const looksCache = new Map()
+  const looks = (dir) => {
+    if (!looksCache.has(dir)) looksCache.set(dir, looksLikeFwRoot(dir, { deps }))
+    return looksCache.get(dir)
+  }
+
+  const head = []
+  // ① 显式 profile 目录（桌面端/CLI 都会设 DSH_PROFILE_DIR）—— 既有最高优先级，位置不动
+  if (typeof env.DSH_PROFILE_DIR === 'string' && env.DSH_PROFILE_DIR.trim() !== '') head.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'))
+  if (typeof env.DSH_PROFILE === 'string' && env.DSH_PROFILE.trim() !== '') head.push(join(dshHome, 'profiles', env.DSH_PROFILE.trim()))
+  // ③ 共享投影层（各 profile 共用）
+  head.push(join(dshHome, 'profiles', 'node_modules'))
+
+  // ④ 各 profile 自己的 node_modules（readdir 原顺序 = 旧顺序，兜底要用它）
+  const legacy = []
   try {
     for (const d of readdir(join(dshHome, 'profiles'))) {
       if (d === 'node_modules') continue
-      cands.push(join(dshHome, 'profiles', d, 'node_modules'))
+      legacy.push(join(dshHome, 'profiles', d, 'node_modules'))
     }
   } catch {}
 
-  for (const dir of cands) {
-    if (!looksLikeFwRoot(dir, { deps })) continue
+  // 排序（可注入；排序器抛错/返回怪东西时**原样退回旧顺序**，绝不因此少试一棵树）
+  let ranked = legacy
+  if (legacy.length > 0) {
+    const rank = typeof deps.rankCandidates === 'function' ? deps.rankCandidates : rankProfileCandidates
+    try {
+      const out = rank(legacy, { activeProfileDir: activeProfileDirOf({ env, dshHome, deps }), looksLike: looks, deps })
+      if (Array.isArray(out)) ranked = out.filter((d) => typeof d === 'string' && legacy.includes(d))
+    } catch { ranked = legacy }
+  }
+
+  // 一个队列，三段顺序：既有前三项 → 排过序的 profile 候选 → **旧顺序兜底**
+  const ordered = []
+  const seen = new Set()
+  const enqueue = (dir) => {
+    const key = dirKey(dir)
+    if (key === '' || seen.has(key)) return
+    seen.add(key)
+    ordered.push(dir)
+  }
+  for (const dir of head) enqueue(dir)
+  for (const dir of ranked) enqueue(dir)
+  for (const dir of legacy) enqueue(dir)
+
+  for (const dir of ordered) {
+    if (!looks(dir)) continue
     return { fwRoot: dir, via: 'dsh-home' }
   }
   return null
@@ -206,4 +324,4 @@ function detectFrameworkRoot({ pluginDir = null, entryHint = null, env = process
   return { fwRoot: null, via: null, tried }
 }
 
-export { detectFrameworkRoot, fwRootFromBase, fwRootFromDshHome, fwRootFromNpxCache, looksLikeFwRoot, realRootOf }
+export { detectFrameworkRoot, fwRootFromBase, fwRootFromDshHome, fwRootFromNpxCache, looksLikeFwRoot, realRootOf, rankProfileCandidates, activeProfileDirOf }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noob-stupid/dsh-plugin-console",
-  "version": "0.5.99",
+  "version": "0.5.100",
   "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",