@moonquake2004/dsh-doctor 0.4.18 → 0.4.20

package/dsh-doctor.mjs

@@ -1950,7 +1950,277 @@ const flagValue = (name) => { const i = process.argv.indexOf(name); return i >=
 const profileArg = (() => { const i = process.argv.indexOf('--profile'); return i >= 0 ? process.argv[i + 1] : 'web'; })();
 const sessionArg = (() => { const i = process.argv.indexOf('--session'); return i >= 0 ? process.argv[i + 1] : undefined; })();
 
+
+/* ================= 启动失败自救：装载模拟 + 隔离 =================
+ * 场景（用户高频反馈）：装了个不兼容的插件、或 dsh 升级后与旧插件不兼容 → **dsh 根本起不来**，
+ * 于是没法用 dsh 自己来诊断，只能借别的工具。本工具是独立 Node CLI（`npx @moonquake2004/dsh-doctor`），
+ * **不需要 dsh 能启动**，所以这两个子命令正是为此设计：
+ *   --boot-check         离线模拟插件树装载：逐条 entry 真去 import，报出到底哪一条炸、炸在哪
+ *   --quarantine <包名>  把某个 bundle 从启动列表里摘掉（先备份），让 dsh 能先起来
+ *   --unquarantine <包名> 撤销隔离
+ * 注意：--boot-check 会**执行插件顶层代码**（这正是"启动"本身的语义），故为显式开关、非默认行为。
+ */
+
+/** 解析 profile 的启动列表与各 bundle 的 entry（含用户 patch 的 insert），跳过 disabled 与已隔离项。 */
+function collectBootEntries(profileDir) {
+  const manifest = JSON.parse(readFileSync(join(profileDir, 'package.json'), 'utf8'));
+  const prof = manifest.dsh?.profile ?? {};
+  const quarantined = new Set((prof._quarantined ?? []).map((q) => q.name));
+  const bundles = (prof.bundles ?? []).filter((b) => !quarantined.has(b));
+  const out = [];
+  const parsePatch = (text, source) => {
+    let cur = null;
+    const flush = () => { if (cur) out.push(cur); cur = null; };
+    for (const line of text.split('\n')) {
+      const idM = /^\s*-?\s*id:\s*['"]?([\w@/.\-]+)['"]?\s*$/.exec(line);
+      if (idM) { flush(); cur = { id: idM[1], bundle: source, name: null, disabled: false }; continue; }
+      if (!cur) continue;
+      const nameM = /^\s*name:\s*['"]?([^'"\s]+)['"]?\s*$/.exec(line);
+      if (nameM) { cur.name = nameM[1]; continue; }
+      if (/^\s*disabled:\s*true\s*$/.test(line)) cur.disabled = true;
+    }
+    flush();
+  };
+  for (const b of bundles) {
+    const patchPath = join(profileDir, 'node_modules', b, 'cordis.patch.yml');
+    if (!existsSync(patchPath)) continue;
+    try { parsePatch(readFileSync(patchPath, 'utf8'), b); } catch { /* 读不了由 P1/P7 报 */ }
+  }
+  const userPatch = join(profileDir, 'cordis.patch.yml');
+  if (existsSync(userPatch)) { try { parsePatch(readFileSync(userPatch, 'utf8'), '(user patch)'); } catch { /* 同上 */ } }
+  return out.filter((e) => !e.disabled);
+}
+
+/** 归类 import 失败，给出人能照做的判断。 */
+function classifyImportError(msg) {
+  if (/does not provide an export named/.test(msg)) return { kind: 'missing-export', hint: '插件比所装的 @deepseek-ai/* 旧/新：把该插件升级到匹配版本（或降级核心）' };
+  if (/ERR_MODULE_NOT_FOUND|Cannot find module/.test(msg)) return { kind: 'not-installed', hint: '依赖或包本身没装全：在该 profile 里重装该插件' };
+  if (/NODE_MODULE_VERSION|compiled against a different Node\.js version|invalid ELF header|not a valid Win32/.test(msg)) return { kind: 'native-abi', hint: '原生模块与当前 Node ABI 不匹配：重装该插件（npm rebuild / 重新 pnpm add）' };
+  if (/ERR_PACKAGE_PATH_NOT_EXPORTED|ERR_REQUIRE_ESM|require\(\) of ES Module/.test(msg)) return { kind: 'module-format', hint: '包导出/模块格式问题：升级该插件（多为上游未适配）' };
+  if (/was killed|ETIMEDOUT|timed out/.test(msg)) return { kind: 'hang', hint: '顶层代码卡住：该插件在加载期做了阻塞操作，需上游修复' };
+  return { kind: 'other', hint: '按上面的原始报错定位；确认后可先隔离该 bundle 让 dsh 起来' };
+}
+
+
+/* ---- 预检增强（2026-09）：快照对比 + 安全安装 ---- */
+
+const SNAPSHOT_FILE = '.dsh-doctor-snapshot.json';
+
+/** 采集"启动关键状态"：每个 bundle 的解析版本 + 每条 entry 的 spec。 */
+function bootSnapshot(profileDir) {
+  const manifest = JSON.parse(readFileSync(join(profileDir, 'package.json'), 'utf8'));
+  const prof = manifest.dsh?.profile ?? {};
+  const bundles = {};
+  for (const b of prof.bundles ?? []) {
+    let v = null;
+    try { v = JSON.parse(readFileSync(join(profileDir, 'node_modules', b, 'package.json'), 'utf8')).version ?? null; } catch { /* 未装/不可读 */ }
+    bundles[b] = v;
+  }
+  const entries = {};
+  for (const e of collectBootEntries(profileDir)) if (e.name) entries[e.id] = `${e.bundle} → ${e.name}`;
+  return { at: new Date().toISOString(), bundles, entries };
+}
+
+/** 与上次"已知良好"快照对比——这是"到底改了什么"的直接答案（dshmarket 自升级、手动 pnpm add 都算）。 */
+function diffSnapshot(prev, cur) {
+  if (!prev) return null;
+  const out = { addedBundles: [], removedBundles: [], versionChanged: [], addedEntries: [], removedEntries: [] };
+  for (const [k, v] of Object.entries(cur.bundles)) {
+    if (!(k in prev.bundles)) out.addedBundles.push(k);
+    else if (prev.bundles[k] !== v) out.versionChanged.push(`${k}: ${prev.bundles[k]} → ${v}`);
+  }
+  for (const k of Object.keys(prev.bundles)) if (!(k in cur.bundles)) out.removedBundles.push(k);
+  for (const [k, v] of Object.entries(cur.entries)) {
+    if (!(k in prev.entries)) out.addedEntries.push(`${k} (${v})`);
+    else if (prev.entries[k] !== v) out.addedEntries.push(`${k}: ${prev.entries[k]} → ${v}`);
+  }
+  for (const k of Object.keys(prev.entries)) if (!(k in cur.entries)) out.removedEntries.push(k);
+  return out;
+}
+
+function readSnapshot(profileDir) {
+  try { return JSON.parse(readFileSync(join(profileDir, SNAPSHOT_FILE), 'utf8')); } catch { return null; }
+}
+function writeSnapshot(profileDir, snap) {
+  try { writeFileSync(join(profileDir, SNAPSHOT_FILE), JSON.stringify(snap, null, 2) + '\n'); } catch { /* 写不了不致命 */ }
+}
+
+/**
+ * --safe-add <pkg>：装完立即预检，坏了自动回滚。
+ * 顺序：先备份 manifest → 调 `dsh plugin --profile <name> add <pkg>` → boot-check →
+ *  通过：写"已知良好"快照；
+ *  失败：先自动隔离出问题的那几个 bundle（若能就此恢复可启动，则保留安装并如实报告），
+ *        若隔离后仍不可启动 → **整体回滚**到安装前的 manifest。
+ * 这样"装了个不兼容的插件导致 dsh 起不来"在最坏情况下也只是一次无害的失败尝试。
+ */
+function safeAdd(profileArg, pkg) {
+  const profDir = resolveProfile(profileArg || 'web');
+  const manifestPath = join(profDir, 'package.json');
+  const before = readFileSync(manifestPath, 'utf8');
+  writeFileSync(`${manifestPath}.dsh-doctor.pre-add.${Date.now()}`, before);
+  const install = spawnSync(process.platform === 'win32' ? 'dsh.cmd' : 'dsh',
+    ['plugin', '--profile', profileArg || 'web', 'add', pkg],
+    { cwd: profDir, encoding: 'utf8', stdio: 'inherit', timeout: 15 * 60 * 1000 });
+  if (install.status !== 0) {
+    writeFileSync(manifestPath, before); // 安装本身失败：还原
+    return { ok: false, stage: 'install', restored: true, exit: install.status };
+  }
+  const results = runBootCheckSync(profDir);
+  const failed = results.filter((r) => r.status === 'failed');
+  if (!failed.length) {
+    writeSnapshot(profDir, bootSnapshot(profDir));
+    return { ok: true, stage: 'verified', checked: results.length, failed: 0 };
+  }
+  // 自动隔离出问题的 bundle
+  const quarantined = [];
+  for (const name of new Set(failed.map((f) => f.bundle))) {
+    if (name === '(user patch)') continue;
+    try { const r = quarantineBundle(profDir, name, false); if (r.ok) quarantined.push(name); } catch { /* 忽略 */ }
+  }
+  const after = runBootCheckSync(profDir);
+  const stillFailed = after.filter((r) => r.status === 'failed');
+  if (stillFailed.length) {
+    writeFileSync(manifestPath, before); // 隔离都救不回来 → 整体回滚
+    return { ok: false, stage: 'verify', quarantined, restored: true, failures: failed.map((f) => `${f.bundle}/${f.id}: ${f.kind}`) };
+  }
+  writeSnapshot(profDir, bootSnapshot(profDir));
+  return { ok: true, stage: 'quarantined', quarantined, failures: failed.map((f) => `${f.bundle}/${f.id}: ${f.kind} ${f.error}`) };
+}
+
+/** 同步版装载模拟（--safe-add 内部用；与 --boot-check 同一逻辑） */
+function runBootCheckSync(profileDir) {
+  const out = [];
+  for (const e of collectBootEntries(profileDir)) {
+    if (!e.name) continue;
+    const spec = e.name;
+    if (spec.startsWith('cordis:') || spec.startsWith('.') || spec.startsWith('/')) { out.push({ id: e.id, bundle: e.bundle, spec, status: 'skipped' }); continue; }
+    const r = spawnSync(process.execPath, ['--input-type=module', '-e', `await import(${JSON.stringify(spec)});`],
+      { cwd: profileDir, encoding: 'utf8', timeout: 20000, maxBuffer: 8 * 1024 * 1024 });
+    if (r.status === 0) out.push({ id: e.id, bundle: e.bundle, spec, status: 'loadable' });
+    else {
+      const raw = String((r.stderr || '') + (r.stdout || ''));
+      const cls = classifyImportError(raw);
+      out.push({ id: e.id, bundle: e.bundle, spec, status: 'failed', kind: cls.kind, hint: cls.hint, error: (raw.split('\n').find((l) => /Error/.test(l)) || raw.slice(0, 160)).slice(0, 220) });
+    }
+  }
+  return out;
+}
+
+async function runBootCheck(profileDir) {
+  const entries = collectBootEntries(profileDir);
+  const targets = entries.filter((e) => e.name);
+  const results = [];
+  for (const e of targets) {
+    const spec = e.name;
+    // 宿主内置与相对路径不做 import 探测（前者由宿主提供，后者依赖运行上下文）
+    if (spec.startsWith('cordis:') || spec.startsWith('.') || spec.startsWith('/')) {
+      results.push({ id: e.id, bundle: e.bundle, spec, status: 'skipped', reason: '宿主内置或相对路径，不在本探测范围' });
+      continue;
+    }
+    const r = spawnSync(process.execPath, ['--input-type=module', '-e', `await import(${JSON.stringify(spec)});`],
+      { cwd: profileDir, encoding: 'utf8', timeout: 20000, maxBuffer: 8 * 1024 * 1024 });
+    if (r.status === 0) { results.push({ id: e.id, bundle: e.bundle, spec, status: 'loadable' }); continue; }
+    const raw = String((r.stderr || '') + (r.stdout || '')).trim();
+    const first = raw.split('\n').find((l) => /Error|error/.test(l)) || raw.split('\n')[0] || '(无输出)';
+    const cls = classifyImportError(raw);
+    results.push({ id: e.id, bundle: e.bundle, spec, status: 'failed', kind: cls.kind, hint: cls.hint, error: first.slice(0, 220) });
+  }
+  return results;
+}
+
+function quarantineBundle(profileDir, name, undo = false) {
+  const manifestPath = join(profileDir, 'package.json');
+  const raw = readFileSync(manifestPath, 'utf8');
+  const manifest = JSON.parse(raw);
+  manifest.dsh = manifest.dsh ?? {};
+  manifest.dsh.profile = manifest.dsh.profile ?? {};
+  const prof = manifest.dsh.profile;
+  prof.bundles = prof.bundles ?? [];
+  prof._quarantined = prof._quarantined ?? [];
+  if (undo) {
+    const hit = prof._quarantined.find((q) => q.name === name);
+    if (!hit) return { ok: false, error: `隔离列表里没有 ${name}` };
+    prof._quarantined = prof._quarantined.filter((q) => q.name !== name);
+    if (!prof.bundles.includes(name)) prof.bundles.push(name);
+  } else {
+    if (!prof.bundles.includes(name)) return { ok: false, error: `${name} 不在 dsh.profile.bundles 里（当前 ${prof.bundles.length} 项）` };
+    writeFileSync(`${manifestPath}.bak.${Date.now()}`, raw); // 备份原始 manifest
+    prof.bundles = prof.bundles.filter((b) => b !== name);
+    prof._quarantined.push({ name, at: new Date().toISOString(), by: 'dsh-doctor --quarantine' });
+  }
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+  return { ok: true, bundles: prof.bundles.length, quarantined: prof._quarantined.map((q) => q.name) };
+}
+
 async function run() {
+  // 启动失败自救子命令（不需要 dsh 能启动）
+  const bootCheckArg = process.argv.includes('--boot-check');
+  const quarantineArg = flagValue('--quarantine');
+  const unquarantineArg = flagValue('--unquarantine');
+  const safeAddArg = flagValue('--safe-add');
+  if (safeAddArg) {
+    // 装完立即预检、坏了自动回滚——"装了个不兼容插件导致 dsh 起不来"的预防手段
+    const profDir = resolveProfile(profileArg || 'web');
+    const r = safeAdd(profileArg || 'web', safeAddArg);
+    if (jsonOut) console.log(JSON.stringify(r, null, 2));
+    else if (r.ok && r.stage === 'verified') console.log(`✓ 已安装并预检通过（${r.checked} 条 entry 均可导入）——重启 dsh 即可`);
+    else if (r.ok && r.stage === 'quarantined') {
+      console.log(`⚠ 已安装，但该插件的 entry 导入失败，已自动隔离以避免 dsh 起不来：`);
+      for (const f of r.failures || []) console.log(`    ${f}`);
+      console.log(`  隔离项：${r.quarantined.join(', ')}（用 --unquarantine <包名> 放回，修好版本后再重试）`);
+      console.log(`  dsh 现在可以正常启动。`);
+    } else if (r.stage === 'install') console.log(`✗ 安装命令本身失败（exit ${r.exit}），已还原 manifest`);
+    else {
+      console.log(`✗ 安装后无法启动，且隔离也救不回来 → 已整体回滚到安装前状态`);
+      for (const f of r.failures || []) console.log(`    ${f}`);
+    }
+    process.exit(r.ok ? 0 : 2);
+  }
+  if (bootCheckArg || quarantineArg || unquarantineArg) {
+    const profDir = resolveProfile(profileArg || 'web');
+    try {
+      if (quarantineArg || unquarantineArg) {
+        const r = quarantineBundle(profDir, quarantineArg || unquarantineArg, !!unquarantineArg);
+        if (!r.ok) { console.error(`✗ ${r.error}`); process.exit(1); }
+        console.log(JSON.stringify({ ok: true, action: unquarantineArg ? 'unquarantine' : 'quarantine', ...r, next: '重启 dsh；随后用 --boot-check 复查，或用 --unquarantine 撤销' }, null, 2));
+        process.exit(0);
+      }
+      const results = await runBootCheck(profDir);
+      const failed = results.filter((r) => r.status === 'failed');
+      const prevSnap = readSnapshot(profDir);
+      const curSnap = bootSnapshot(profDir);
+      const drift = diffSnapshot(prevSnap, curSnap);
+      if (drift && !jsonOut) {
+        const lines = [];
+        if (drift.addedBundles.length) lines.push(`新增 bundle: ${drift.addedBundles.join(', ')}`);
+        if (drift.versionChanged.length) lines.push(`版本变化: ${drift.versionChanged.join('; ')}`);
+        if (drift.removedBundles.length) lines.push(`移除 bundle: ${drift.removedBundles.join(', ')}`);
+        if (drift.addedEntries.length) lines.push(`新增/变更 entry: ${drift.addedEntries.join('; ')}`);
+        if (drift.removedEntries.length) lines.push(`移除 entry: ${drift.removedEntries.join(', ')}`);
+        if (lines.length) {
+          console.log(`自上次预检通过以来（${String(prevSnap.at).slice(0, 16)}）：`);
+          for (const l of lines) console.log(`  · ${l}`);
+          console.log('  ——若本次启动失败，上面这些就是首要嫌疑。');
+        }
+      }
+      if (!failed.length) writeSnapshot(profDir, curSnap); // 只有通过时才更新"已知良好"快照
+      if (jsonOut) {
+        console.log(JSON.stringify({ ok: failed.length === 0, profile: profDir, checked: results.length, failed: failed.length, drift, results }, null, 2));
+      } else {
+        console.log(`装载模拟（${profDir}）：检查 ${results.length} 条 entry，失败 ${failed.length} 条`);
+        for (const r of results) {
+          if (r.status === 'failed') console.log(`  ✗ [${r.bundle}] ${r.id} → ${r.spec}\n      ${r.kind}: ${r.error}\n      修复方向：${r.hint}\n      先起来：npx @moonquake2004/dsh-doctor --quarantine ${r.bundle}`);
+          else if (r.status === 'skipped') console.log(`  ⊖ ${r.id}（${r.reason}）`);
+        }
+        if (!failed.length) console.log('  ✓ 所有可探测 entry 均可导入——启动失败若仍发生，问题多在配置合并或原生环境，请贴 --json 输出');
+      }
+      process.exit(failed.length ? 2 : 0);
+    } catch (e) {
+      console.error(`启动模拟失败: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
   // 层 C 观察者（--observe / --observe-apply）：独立子命令，跑完即退出，不执行常规检查
   const observeArg = flagValue('--observe');
   const observeApplyArg = flagValue('--observe-apply');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonquake2004/dsh-doctor",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "description": "Offline diagnostic for DeepSeek Harness — 28 built-in + 5 catalog checks across env/profile/session (Layer A checks-as-data), self-update (Layer B), and a semi-automatic LLM observer (Layer C, --observe); Doctor panel in web UI settings.",
   "main": "lib/index.js",
   "files": [