dsh-plugin-snapshot 0.1.1 → 0.3.5

package/lib/probe.js

@@ -0,0 +1,118 @@
+/**
+ * 占用探针：判断待更新的包是否正被运行中的 DSH 锁住。
+ *
+ * 为什么要探：Windows 上 pnpm 替换包的实际动作是「整目录 rename」，
+ * 只要树内任意一个文件被「无删除共享」打开（已加载的 .node、被写开的数据文件），
+ * 整树 rename 就会失败。逐包更新时一旦撞上，前面的包已经写盘，后面的还没动，
+ * 只能整轮回退——探针的价值是提前把这几个包从计划里剔掉，避免白跑。
+ *
+ * 两种探测组合使用：
+ *   1) 目录级：把包目录 rename 到临时名再改回。最接近 pnpm 的真实动作。
+ *   2) 文件级：对 .node 做 open('r+')。捕获「目录可改名但原生模块被加载」的情况。
+ *
+ * 安全约定：目录 rename 成功后必须回滚；回滚失败会重试一次，
+ * 仍然失败则记 RESTORE_FAILED 并以只读方式报警（此时包目录停留在临时名）。
+ */
+import { existsSync, readdirSync, renameSync, openSync, closeSync, statSync, lstatSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const MAX_DEPTH = 3;
+const MAX_FILES = 200;
+
+function findNodeFiles(dir, depth, out) {
+  if (depth > MAX_DEPTH || out.length >= MAX_FILES) return out;
+  let items = [];
+  try { items = readdirSync(dir, { withFileTypes: true }); } catch (e) { return out; }
+  for (const e of items) {
+    if (out.length >= MAX_FILES) break;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) {
+      if (e.name === '.bin') continue;
+      findNodeFiles(p, depth + 1, out);
+    } else if (e.isFile() && e.name.endsWith('.node')) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+/**
+ * 探测一组包是否被占用。
+ * @param {string} profileDir profile 目录
+ * @param {string[]} names 要探测的包名
+ * @returns {{name:string, code:string, at:string}[]} 被占用的条目
+ */
+export function probeLocked(profileDir, names) {
+  const locked = [];
+  const stamp = Date.now().toString(36);
+
+  for (const name of names) {
+    const pkgDir = join(profileDir, 'node_modules', ...String(name).split('/'));
+    if (!existsSync(pkgDir)) continue;
+    /* pnpm 下 scoped 包常是 symlink：对它 rename 在部分平台会 EPERM，造成误报占用。
+       这种情况跳过目录级探测，只做 .node 文件级探测。 */
+    let isLink = false;
+    try { isLink = lstatSync(pkgDir).isSymbolicLink(); } catch (e) { isLink = false; }
+    if (isLink) {
+      const nodes2 = findNodeFiles(pkgDir, 0, []);
+      for (const f of nodes2) {
+        try { const fd = openSync(f, 'r+'); closeSync(fd); }
+        catch (e) { locked.push({ name, code: e.code || 'OPEN_FAILED', at: 'node:' + basename(f) }); break; }
+      }
+      continue;
+    }
+
+    /* ---- 1) 目录级 rename 探测 ---- */
+    const tmp = pkgDir + '.__probe_' + stamp;
+    let renamed = false;
+    try {
+      renameSync(pkgDir, tmp);
+      renamed = true;
+    } catch (e) {
+      locked.push({ name, code: e.code || 'RENAME_FAILED', at: 'dir' });
+      continue;
+    }
+
+    /* 必须还原：还原失败重试一次，再失败就记下来 */
+    try {
+      renameSync(tmp, pkgDir);
+    } catch (e) {
+      try {
+        renameSync(tmp, pkgDir);
+      } catch (e2) {
+        /* 目录停在临时名 = 包已损坏，必须让上层中止本轮并告警，不能当成「跳过」 */
+        locked.push({ name, code: 'RESTORE_FAILED', at: 'dir', fatal: true, tmpPath: tmp });
+        continue;
+      }
+    }
+    if (!renamed) continue;
+
+    /* ---- 2) .node 文件读写探测 ---- */
+    const nodes = findNodeFiles(pkgDir, 0, []);
+    for (const f of nodes) {
+      try {
+        const fd = openSync(f, 'r+');
+        closeSync(fd);
+      } catch (e) {
+        locked.push({ name, code: e.code || 'OPEN_FAILED', at: 'node:' + basename(f) });
+        break;
+      }
+    }
+  }
+
+  return locked;
+}
+
+/** 探测并返回可执行 / 需跳过的两个集合 */
+export function partitionByProbe(profileDir, names) {
+  const locked = probeLocked(profileDir, names);
+  const fatal = locked.filter((x) => x.fatal === true);
+  const blocked = new Set(locked.map((x) => x.name));
+  return {
+    locked,
+    fatal,
+    runnable: names.filter((n) => !blocked.has(n)),
+    skipped: names.filter((n) => blocked.has(n))
+  };
+}
+

package/lib/profile.js

@@ -71,7 +71,12 @@ export function parseLockVersions(lockText) {
     }
     if (curName && indent === depIndent + 4) {
       const m = /^version:\s*(.+)$/.exec(t);
-      if (m) { out[curName] = m[1].trim().replace(/^['"]|['"]$/g, ''); curName = null; }
+      if (m) {
+        /* pnpm 的 lockfile v9 会在版本后面挂 peer 依赖：1.2.0(@types/node@26.2.0)。
+           直接拿去比较会让所有带 peer 的包判成「未知」，必须剥掉括号部分。 */
+        out[curName] = m[1].trim().replace(/^['"]|['"]$/g, '').replace(/\(.*\)$/, '');
+        curName = null;
+      }
     }
   }
   return out;

package/lib/routes.js

@@ -0,0 +1,244 @@
+/**
+ * 设置页面板的数据与操作接口。
+ *
+ * 设计约束：
+ *  - 只读接口（updates / doctor / snapshots）随时可调；
+ *  - 写操作（snapshot.create / snapshot.restore / apply）都要求显式 body，
+ *    并且只动 profile 的三份清单或单个包的安装，不做批量猜测；
+ *  - 所有异常都转成 { ok:false, error } 返回，不让路由 500 把前端打崩。
+ */
+import { execFile } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { checkUpdates } from './updates.js';
+import { scanPlugins, detectConflicts, priorityOf } from './doctor.js';
+import { createSnapshot, listSnapshots, restoreSnapshot } from './snapshot.js';
+import { registerApplyAll } from './apply-all.js';
+import { readAutoState, verifyInstalled, classifyResult } from './auto-update.js';
+import { validateInstallTargets } from './install-guard.js';
+import { findPnpm, runPnpm } from './exec.js';
+
+function send(response, code, payload) {
+  /* 请求体超限时调用方会 destroy socket，此时不能再写响应 */
+  if (response.writableEnded || response.destroyed) return;
+  response.statusCode = code;
+  response.setHeader('content-type', 'application/json; charset=utf-8');
+  response.setHeader('cache-control', 'no-store');
+  response.end(JSON.stringify(payload));
+}
+
+function readBody(request, limit) {
+  return new Promise((resolve) => {
+    let size = 0;
+    const chunks = [];
+    request.on('data', (c) => {
+      size += c.length;
+      if (size > (limit || 65536)) { request.destroy(); resolve(null); return; }
+      chunks.push(c);
+    });
+    request.on('end', () => {
+      if (!chunks.length) return resolve({});
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
+      catch (e) { resolve(null); }
+    });
+    request.on('error', () => resolve(null));
+  });
+}
+
+export function mountRoutes(hostCtx, cfg, needProfile) {
+  const offs = [];
+
+  /* 写接口守卫。
+     跨站写防护靠三件事叠加：
+       1) 要求自定义头 X-DSH-Snapshot —— 跨源带自定义头会触发 CORS preflight，
+          而本服务不应答 preflight，浏览器会直接拦下请求；
+       2) 要求 application/json —— 跨源的 text/plain 简单请求不会被误接受；
+       3) 若带 Origin，必须与 Host 同源，且拒绝 Origin: null。 */
+  const guard = (request, response, opts) => {
+    const o = opts || {};
+    if (o.method && String(request.method || '').toUpperCase() !== o.method) {
+      send(response, 405, { ok: false, error: '方法不允许，需要 ' + o.method });
+      return false;
+    }
+    if (!o.write) return true;
+    if (String(request.headers['x-dsh-snapshot'] || '') !== '1') {
+      send(response, 403, { ok: false, error: '缺少 X-DSH-Snapshot 头，写操作被拒绝' });
+      return false;
+    }
+    const ct = String(request.headers['content-type'] || '');
+    if (ct.indexOf('application/json') < 0) {
+      send(response, 415, { ok: false, error: '写操作只接受 application/json' });
+      return false;
+    }
+    const origin = request.headers.origin;
+    if (origin) {
+      const host = request.headers.host;
+      let sameOrigin = false;
+      if (host && origin !== 'null') {
+        try { sameOrigin = new URL(origin).host === host; } catch (e) { sameOrigin = false; }
+      }
+      if (!sameOrigin) {
+        send(response, 403, { ok: false, error: '跨源写操作被拒绝' });
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /* 写操作节流：同接口 1.5 秒内只接受一次，避免被反复调用把快照保留位挤掉 */
+  const writeTimes = new Map();
+  const THROTTLE_MS = 1500;
+
+  const reg = (path, handler, opts) => {
+    const off = hostCtx.webServer.register({
+      kind: 'exact',
+      path,
+      handler: (request, response) => {
+        const o = Object.assign({}, opts, { path });
+        if (!guard(request, response, o)) return;
+        if (o.write) {
+          const now = Date.now();
+          const prev = writeTimes.get(path) || 0;
+          if (now - prev < THROTTLE_MS) {
+            send(response, 429, { ok: false, error: '写操作过于频繁，请稍后再试' });
+            return;
+          }
+          writeTimes.set(path, now);
+        }
+        return handler(request, response);
+      }
+    });
+    offs.push(typeof off === 'function' ? off : () => {});
+  };
+
+  /* 只读：更新检测 */
+  reg('/dsh-plugin-snapshot/api/updates', async (request, response) => {
+    try {
+      const dir = needProfile(cfg);
+      const r = await checkUpdates(dir, cfg);
+      send(response, 200, {
+        ok: true,
+        profile: r.profile,
+        registry: r.registry,
+        summary: r.summary,
+        items: r.items.map((x) => ({
+          name: x.name,
+          declared: x.declared,
+          resolved: x.resolved || '',
+          candidate: x.candidate || '',
+          state: x.state,
+          reason: x.reason || ''
+        }))
+      });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  });
+
+  /* 只读：诊断 */
+  reg('/dsh-plugin-snapshot/api/doctor', async (request, response) => {
+    try {
+      const dir = needProfile(cfg);
+      /* 宿主版本取不到就传 null，让兼容性判定返回 unknown，而不是用一个过期默认值假装兼容 */
+      const dshVersion = String((cfg && cfg.dshVersion) || process.env.DSH_VERSION || '').trim() || null;
+      const scan = scanPlugins(dir, dshVersion);
+      const conflicts = detectConflicts(scan.items);
+      const priority = scan.items
+        .map((it) => Object.assign({ name: it.name }, priorityOf(it, conflicts)))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 8)
+        .map((x) => ({ name: x.name, score: x.score, level: x.level, factors: x.factors }));
+      send(response, 200, {
+        ok: true,
+        profile: scan.profile,
+        dshVersion,
+        summary: {
+          installed: scan.items.filter((x) => x.installed !== false).length,
+          enabled: scan.items.filter((x) => x.enabled === true).length,
+          unknownEnabled: scan.items.filter((x) => x.enabled === null).length,
+          missing: scan.items.filter((x) => x.installed === false).length,
+          incompatible: scan.items.filter((x) => (x.compatibility || {}).state === 'incompatible').length,
+          untested: scan.items.filter((x) => (x.compatibility || {}).state === 'untested').length,
+          native: scan.items.filter((x) => x.hasNative).length
+        },
+        conflicts: conflicts.slice(0, 40).map((c) => ({ severity: c.severity, kind: c.kind, message: c.message })),
+        priority
+      });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  });
+
+  /* 只读：快照列表 */
+  reg('/dsh-plugin-snapshot/api/snapshots', async (request, response) => {
+    try {
+      const list = listSnapshots(cfg).map((s) => ({
+        name: s.name,
+        createdAt: new Date(s.mtime).toISOString(),
+        deps: s.deps,
+        hasManifest: !!s.hasManifest
+      }));
+      send(response, 200, { ok: true, snapshots: list });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  });
+
+  /* 写：创建快照 */
+  reg('/dsh-plugin-snapshot/api/snapshot/create', async (request, response) => {
+    try {
+      const dir = needProfile(cfg);
+      const s = createSnapshot(dir, cfg);
+      send(response, 200, { ok: true, created: s.name, files: s.files });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  }, { write: true });
+
+  /* 写：恢复快照 */
+  reg('/dsh-plugin-snapshot/api/snapshot/restore', async (request, response) => {
+    try {
+      const body = await readBody(request);
+      if (!body || !body.name) return send(response, 200, { ok: false, error: '缺少快照名' });
+      const dir = needProfile(cfg);
+      const r = restoreSnapshot(dir, cfg, String(body.name));
+      send(response, 200, { ok: true, from: r.from, restored: r.restored, warnings: r.warnings });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  }, { write: true });
+
+  /* 写：更新单个包 */
+  reg('/dsh-plugin-snapshot/api/apply', async (request, response) => {
+    try {
+      const body = await readBody(request);
+      if (!body || !body.name || !body.version) return send(response, 200, { ok: false, error: '缺少 name 或 version' });
+      const dir = needProfile(cfg);
+      /* 只允许：已安装的包 + 精确版本 + 严格升级 + 非预发布 */
+      const check = validateInstallTargets(dir, [{ name: body.name, version: body.version }]);
+      if (!check.approved.length) {
+        const reason = (check.rejected[0] && check.rejected[0].reason) || "目标被拒绝";
+        return send(response, 200, { ok: false, error: reason, rejected: check.rejected });
+      }
+      const target = check.approved[0];
+      const pnpmCjs = findPnpm();
+      if (!pnpmCjs) return send(response, 200, { ok: false, error: '找不到 pnpm，无法执行更新' });
+      const snapshot = createSnapshot(dir, cfg);
+      /* --ignore-scripts：不执行第三方包的生命周期脚本 */
+      const r = await runPnpm(pnpmCjs, ['add', target.name + '@' + target.version, '--save-exact', '--ignore-scripts'], dir, 600000);
+      const installed = verifyInstalled(dir, target.name, target.version);
+      const v = classifyResult(r.code, installed, r.output);
+      send(response, 200, {
+        ok: v.ok,
+        kind: v.kind,
+        code: r.code,
+        snapshot: snapshot.name,
+        output: r.output.slice(-4000),
+        needRestart: v.ok
+      });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  }, { write: true });
+
+  /* 只读：上次自动更新的结果 */
+  reg('/dsh-plugin-snapshot/api/auto', async (request, response) => {
+    try {
+      send(response, 200, { ok: true, state: readAutoState(cfg) });
+    } catch (e) { send(response, 200, { ok: false, error: String((e && e.message) || e) }); }
+  });
+
+  registerApplyAll({ reg, cfg, needProfile, send, readBody, createSnapshot, findPnpm, runPnpm });
+
+  return () => { for (const off of offs) { try { off(); } catch (e) { /* 忽略 */ } } };
+}
+

package/lib/snapshot.js

@@ -6,7 +6,7 @@
  *  - 清理时保护正在使用的快照，按创建时间排序；
  *  - 恢复前校验 profile 身份，摘要不符只告警。
  */
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { renameSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { atomicWrite, sha256, tsStr, isValidSnapName, dataDir, readJson } from './util.js';
 
@@ -21,6 +21,22 @@ export function snapRoot(cfg) {
 function profileId(dir) {
   return sha256(Buffer.from(String(dir))).slice(0, 16);
 }
+/** 与目录路径无关的 profile 标识：profile 名 + 排序后的依赖名集合 */
+function profileKey(profileDir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(profileDir, 'package.json'), 'utf8'));
+    const names = Object.keys(pkg.dependencies || {}).sort().join(',');
+    return sha256(Buffer.from(String(pkg.name || '') + '|' + names)).slice(0, 16);
+  } catch (e) { return null; }
+}
+
+const MAX_JSON = 4 * 1024 * 1024;
+
+/** 从现有文件推断缩进，写回时保留原风格 */
+function detectIndent(text) {
+  const m = /\n([ \t]+)"/.exec(String(text || ''));
+  return m ? m[1] : '  ';
+}
 
 function uniqueDir(base) {
   const stamp = tsStr();
@@ -30,7 +46,10 @@ function uniqueDir(base) {
   return dir;
 }
 
-export function createSnapshot(profileDir, cfg) {
+export function createSnapshot(profileDir, cfg, protectExtra) {
+  /* protectExtra：本次操作额外需要保留的快照名。
+     审查发现：restoreSnapshot 会先 createSnapshot，而 createSnapshot 内部 prune 只保护
+     新建的那一份，待恢复的目标若正好是最旧的，会在复制前被删掉（ENOENT）。 */
   const base = snapRoot(cfg);
   mkdirSync(base, { recursive: true });
   const dir = uniqueDir(base);
@@ -60,16 +79,19 @@ export function createSnapshot(profileDir, cfg) {
       createdAt: Date.now(),
       created: tsStr(),
       tool: 'dsh-plugin-snapshot',
+      profileKey: profileKey(profileDir),
       files
     }, null, 2));
   } catch (e) { /* manifest 失败不影响恢复，只是少了身份校验 */ }
-  prune(cfg, [basename(dir)]);
+  prune(cfg, [basename(dir)].concat(Array.isArray(protectExtra) ? protectExtra : []));
   return { name: basename(dir), dir, files: saved };
 }
 
 export function prune(cfg, protect) {
   const base = snapRoot(cfg);
-  const keep = Math.max(1, Number((cfg && cfg.snapshotsKeep) || 7));
+  /* 审查发现：Math.max(1, NaN) 仍是 NaN，会让 over 判断永远为 false，prune 失效 */
+  const rawKeep = Number(cfg && cfg.snapshotsKeep);
+  const keep = Number.isFinite(rawKeep) && rawKeep >= 1 ? Math.floor(rawKeep) : 7;
   const prot = new Set((protect || []).map((x) => basename(String(x))));
   let items = [];
   try { items = readdirSync(base); } catch (e) { return; }
@@ -103,7 +125,10 @@ export function listSnapshots(cfg) {
     try { mtime = statSync(dir).mtimeMs; } catch (e) { /* 忽略 */ }
     if (man && man.createdAt) mtime = man.createdAt;
     let deps = 0;
-    try { deps = Object.keys(JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')).dependencies || {}).length; }
+    try {
+      const pf = join(dir, 'package.json');
+      deps = statSync(pf).size > MAX_JSON ? -1 : Object.keys(JSON.parse(readFileSync(pf, 'utf8')).dependencies || {}).length;
+    }
     catch (e) { /* 忽略 */ }
     out.push({ name, dir, mtime, deps, hasManifest: !!man, files: FILES.filter((f) => existsSync(join(dir, f))) });
   }
@@ -124,10 +149,16 @@ export function restoreSnapshot(profileDir, cfg, name) {
   if (!present.length) throw new Error('快照目录内没有可恢复的文件: ' + dir);
 
   const man = readJson(join(dir, MANIFEST));
+  const warnings = [];
+  /* 注意：warnings 必须在任何 push 之前声明（TDZ） */
   if (man && man.profileId && man.profileId !== profileId(profileDir)) {
-    throw new Error('快照属于另一个 profile（' + String(man.profileDir || '?') + '），已拒绝恢复');
+    /* 目录可能只是被移动/改名：用与路径无关的 profileKey 再判一次 */
+    const sameEnv = man.profileKey && man.profileKey === profileKey(profileDir);
+    if (!sameEnv) {
+      throw new Error("快照属于另一个 profile（" + String(man.profileDir || "?") + "），已拒绝恢复");
+    }
+    warnings.push("profile 目录路径与快照记录不同，按同一环境处理：" + String(man.profileDir || "?"));
   }
-  const warnings = [];
   if (man && man.files) {
     for (const f of present) {
       const meta = man.files[f];
@@ -138,12 +169,50 @@ export function restoreSnapshot(profileDir, cfg, name) {
     }
   }
 
-  createSnapshot(profileDir, cfg);
+  /* 恢复前再拍一份「当前状态」，但必须把待恢复的目标列入保护名单，否则它可能被 prune 删除 */
+  createSnapshot(profileDir, cfg, [basename(dir)]);
+  if (!existsSync(dir)) throw new Error('待恢复的快照已不存在（可能被保留策略清理）：' + basename(dir));
   const restored = [];
   for (const f of present) {
-    copyFileSync(join(dir, f), join(profileDir, f));
+    /* 先在目标目录写临时文件再 rename：单文件原子替换，
+       避免恢复中途崩溃留下「新旧混合」的 profile */
+    const target = join(profileDir, f);
+    const tmp = target + '.restore-' + process.pid + '-' + Date.now();
+    copyFileSync(join(dir, f), tmp);
+    renameSync(tmp, target);
     restored.push(f);
   }
   return { restored, warnings, from: basename(dir) };
 }
 
+
+/**
+ * 包级回退：只把指定包的版本号改回快照里的值，其余包的更新保留。
+ * 这是分层回退的第一层——部分成功时用它，避免让成功的包陪葬。
+ * @returns {string[]} 实际回退的包（name -> version 描述）
+ */
+export function revertPackages(profileDir, cfg, snapName, names) {
+  const dir = resolveSnap(cfg, snapName);
+  const curPath = join(profileDir, 'package.json');
+  const rawCur = readFileSync(curPath, 'utf8');
+  const snapPkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+  const cur = JSON.parse(rawCur);
+  /* dependencies / devDependencies / optionalDependencies 三处都回退 */
+  const SECTIONS = ['dependencies', 'devDependencies', 'optionalDependencies'];
+  const done = [];
+  for (const n of names) {
+    for (const sec of SECTIONS) {
+      const snapSec = snapPkg[sec] || {};
+      if (!Object.prototype.hasOwnProperty.call(snapSec, n)) continue;
+      if (!cur[sec]) cur[sec] = {};
+      cur[sec][n] = snapSec[n];
+      done.push(n + ' -> ' + snapSec[n]);
+      break;
+    }
+  }
+  if (done.length) {
+    const indent = detectIndent(rawCur);
+    atomicWrite(curPath, JSON.stringify(cur, null, indent) + String.fromCharCode(10));
+  }
+  return done;
+}

package/lib/updates.js

@@ -3,7 +3,8 @@
  * 只读操作，不写 profile、不安装任何东西。
  */
 import { readProfile, readLockVersions, specKind } from './profile.js';
-import { parseSpec, parseSemver, cmpSemver, shortVer, isValidPkgName, Logger } from './util.js';
+import { parseSpec, parseSemver, cmpSemver, isValidPkgName } from './util.js';
+import { judgeCompatibility } from './doctor.js';
 
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
 
@@ -46,6 +47,8 @@ async function mapLimit(items, limit, worker) {
 }
 
 export async function checkUpdates(profileDir, cfg) {
+  /* 宿主版本只能从外部获得；取不到时传 null，兼容性判定会返回 unknown 而不是假装兼容 */
+  const dshVersion = String((cfg && cfg.dshVersion) || process.env.DSH_VERSION || '').trim() || null;
   const prof = readProfile(profileDir);
   const lock = readLockVersions(profileDir);
   const names = Object.keys(prof.deps);
@@ -68,15 +71,22 @@ export async function checkUpdates(profileDir, cfg) {
     const lat = parseSemver(r.latest);
     if (!cur || !lat) return { ...t, state: 'unknown', reason: '版本号无法解析', candidate: r.latest };
     if (lat.pre) return { ...t, state: 'prerelease', reason: '候选是预发布版本', candidate: r.latest };
-    if (cur.major !== lat.major) return { ...t, state: 'major', reason: '主版本变更，需人工确认', candidate: r.latest };
-    const c = cmpSemver(cur.base, r.latest);
-    return {
-      ...t,
-      candidate: r.latest,
-      state: (c !== null && c < 0) ? 'updatable' : 'uptodate',
-      reason: (c !== null && c < 0) ? '' : '',
-      shortResolved: shortVer(t.resolved || t.declared)
-    };
+    /* 先判方向：registry 的 latest 可能低于本地（包被回收、本地装了更高版本） */
+    const dir = cmpSemver(r.latest, cur.base);
+    if (dir === null) return { ...t, state: 'unknown', reason: '版本方向无法判断', candidate: r.latest };
+    if (dir === 0) return { ...t, state: 'uptodate', candidate: r.latest };
+    if (dir < 0) return { ...t, state: 'downgrade', reason: 'registry 最新版低于当前安装版本', candidate: r.latest };
+
+    /* 兼容性：作者声明的 dsh 兼容范围不含当前宿主版本时，不建议升级 */
+    const compat = judgeCompatibility({ dsh: r.dsh }, dshVersion);
+    if (compat.state === 'incompatible') {
+      return { ...t, state: 'incompatible', reason: compat.label, candidate: r.latest, compatibility: compat };
+    }
+
+    if (cur.major !== lat.major) return { ...t, state: 'major', reason: '主版本变更，需人工确认', candidate: r.latest, compatibility: compat };
+    /* 0.x 的次版本变更按 semver 是破坏性的，等同主版本处理 */
+    if (cur.major === 0 && cur.minor !== lat.minor) return { ...t, state: 'major', reason: '0.x 次版本变更（破坏性），需人工确认', candidate: r.latest, compatibility: compat };
+    return { ...t, state: 'updatable', candidate: r.latest, compatibility: compat };
   });
 
   const summary = {
@@ -85,8 +95,10 @@ export async function checkUpdates(profileDir, cfg) {
     major: results.filter((x) => x.state === 'major').length,
     uptodate: results.filter((x) => x.state === 'uptodate').length,
     failed: results.filter((x) => x.state === 'failed').length,
-    skipped: skipped.length
+    skipped: skipped.length,
+    downgrade: results.filter((x) => x.state === 'downgrade').length,
+    incompatible: results.filter((x) => x.state === 'incompatible').length
   };
-  return { items: results, skipped, summary, profile: prof.name, registry: registryOf(cfg) };
+  return { items: results, skipped, summary, profile: prof.name, registry: registryOf(cfg), dshVersion };
 }
 

package/lib/util.js

@@ -2,7 +2,7 @@
  * 通用工具：原子写、摘要、语义化版本、路径与日志。
  * 本文件不依赖 Electron / DSH 内部包，可在纯 Node 下被单测直接覆盖。
  */
-import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, unlinkSync, writeFileSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, unlinkSync, writeFileSync, readFileSync, readdirSync, statSync, rmSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
@@ -111,7 +111,13 @@ export class Logger {
     this.lines = [];
   }
   write(level, msg) {
-    const line = '[' + new Date().toISOString() + '] [' + level + '] ' + msg;
+    /* 写入前脱敏：日志可能包含 pnpm 输出的 registry 地址与凭据 */
+    const safe = String(msg)
+      .replace(/(_authToken[=:]\s*)\S+/gi, '$1***')
+      .replace(/\bnpm_[A-Za-z0-9]{16,}\b/g, 'npm_***')
+      .replace(/(Bearer\s+)[A-Za-z0-9._-]{16,}/gi, '$1***');
+    const line = '[' + new Date().toISOString() + '] [' + level + '] ' + safe;
+    this.pruneOld();
     this.lines.push(line);
     if (this.lines.length > 200) this.lines.shift();
     try {
@@ -119,6 +125,21 @@ export class Logger {
       appendFileSync(this.file, line + '\n', 'utf8');
     } catch (e) { /* 只影响日志，不影响功能 */ }
   }
+  /** 只保留最近 7 天的日志 */
+  pruneOld() {
+    const now = Date.now();
+    const SEVEN = 7 * 24 * 3600 * 1000;
+    if (this._pruned && now - this._pruned < 3600000) return;
+    this._pruned = now;
+    try {
+      for (const f of readdirSync(this.dir)) {
+        if (!f.startsWith('snapshot-') || !f.endsWith('.log')) continue;
+        const p = join(this.dir, f);
+        try { if (now - statSync(p).mtimeMs > SEVEN) rmSync(p, { force: true }); } catch (e) { /* 忽略单个文件 */ }
+      }
+    } catch (e) { /* 目录不存在时忽略 */ }
+  }
+
   info(m) { this.write('info', m); }
   warn(m) { this.write('warn', m); }
   error(m) { this.write('error', m); }