modelstage 0.5.24 → 0.5.28

package/tool/lib/test-lock.mjs

@@ -1,178 +0,0 @@
-// tool/lib/test-lock.mjs —— 测试运行的「单实例锁」（同一项目同时只允许一个测试实例）
-//
-// 为什么需要：两个人（或两个 AI 会话）同时跑 e2e 会互相踩——端口/共享浏览器/DPR/像素采样都会串味，
-//   结果是"我这边红你那边绿"扯不清。互斥之后，第二个实例**明确跳过并说清谁在跑**，
-//   而不是继续跑出假红（假红比不跑更贵：会误导修错地方）。
-//
-// 约定：
-//   · 锁文件 <repoRoot>/runtime/test.lock，内容 JSON：{ pid, startedAt, startedAtMs, host, label, tool }
-//   · 第二次获取失败 → 退出码 75（EX_TEMPFAIL，区别于 0 通过 / 1 失败），并打印持有者与已运行时长
-//   · 陈旧锁自动接管：持有者 PID 已不存在 ⇒ 直接接管（崩溃/被 kill 不该永久锁死项目）
-//   · 子进程继承：调用方设置 DSH_TEST_LOCK_HELD=1，子工具（如 check-console）不再重复加锁
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-/** "跳过"专用退出码（BSD EX_TEMPFAIL）：与 0 通过 / 1 失败明确区分 */
-export const EXIT_SKIPPED = 75;
-
-/** 子进程继承用的环境变量名 */
-export const HELD_ENV = 'DSH_TEST_LOCK_HELD';
-
-/**
- * PID 是否还活着。
- * @param {number} pid
- * @returns {boolean}
- */
-export function isAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0); // 只探测，不发信号
-    return true;
-  } catch (e) {
-    return e && e.code === 'EPERM'; // 存在但无权限 ⇒ 视为活着
-  }
-}
-
-/**
- * 进程的真实启动时刻（Linux /proc）。
- * 用来识别 **PID 复用**：操作系统回收 PID 后会把它分配给新进程，此时 `kill(pid,0)` 依然成功，
- * 光看 isAlive 会以为锁还被持有 ⇒ 项目被永久锁死。判据：进程启动时刻**晚于**锁创建时刻 ⇒
- * 它不可能是锁的持有者。
- * @returns {number|null} epoch 毫秒；非 Linux 或读取失败返回 null（退回旧行为）
- */
-export function procStartMs(pid) {
-  try {
-    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
-    // comm 字段可能含空格与括号（形如 (chrome-headless)，也可能含右括号）⇒ 取最后一个 ')' 之后
-    const rest = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
-    const startTicks = Number(rest[19]); // 第 22 个字段 starttime（pid/comm/state 之后从 0 数）
-    const btime = Number((fs.readFileSync('/proc/stat', 'utf8').match(/^btime (\d+)$/m) || [])[1]);
-    if (!Number.isFinite(startTicks) || !Number.isFinite(btime)) return null;
-    const CLK_TCK = 100; // 常见值；仅用于量级比较，不做精确计时
-    return btime * 1000 + (startTicks * 1000) / CLK_TCK;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 把锁内容渲染成一句人话（谁在跑 / PID / 开始时间 / 已运行多久）。
- * @param {object} holder
- * @returns {string}
- */
-export function describeHolder(holder) {
-  if (!holder) return '(未知持有者)';
-  const startedMs = Number(holder.startedAtMs) || 0;
-  const elapsed = startedMs ? Math.max(0, Math.round((Date.now() - startedMs) / 1000)) : null;
-  const dur = elapsed === null ? '时长未知'
-    : (elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m${String(elapsed % 60).padStart(2, '0')}s`);
-  return `PID ${holder.pid} · 开始 ${holder.startedAt || '?'} · 已运行 ${dur} · ${holder.label || '?'} · ${holder.tool || '?'}`;
-}
-
-/** 读锁文件；不存在或损坏返回 null */
-function readLock(file) {
-  try {
-    const raw = fs.readFileSync(file, 'utf8');
-    const j = JSON.parse(raw);
-    return j && typeof j === 'object' ? j : null;
-  } catch {
-    return null;
-  }
-}
-
-/** 原子创建：openSync('wx') 成功才算拿到锁（避免两个进程同时判"没有锁"再互相覆盖） */
-function createExclusive(file, body) {
-  try {
-    const fd = fs.openSync(file, 'wx', 0o644);
-    fs.writeSync(fd, JSON.stringify(body, null, 2));
-    fs.closeSync(fd);
-    return true;
-  } catch (e) {
-    if (e && e.code === 'EEXIST') return false;
-    throw e;
-  }
-}
-
-/**
- * 获取测试单实例锁。
- * @param {{root: string, label?: string, tool?: string}} opts
- * @returns {{acquired: boolean, holder?: object, file: string, tookOver?: boolean, release: Function}}
- */
-export function acquireTestLock(opts) {
-  const root = opts.root;
-  const dir = path.join(root, 'runtime');
-  const file = path.join(dir, 'test.lock');
-  const body = {
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    startedAtMs: Date.now(),
-    host: os.hostname(),
-    label: opts.label || 'test',
-    tool: opts.tool || process.argv.slice(1).join(' '),
-  };
-  const noop = { acquired: true, file, release: () => {} };
-
-  // 子进程：父进程已持锁 ⇒ 不再加锁（否则 test-all → check-console 会自己把自己锁死）
-  if (process.env[HELD_ENV] === '1') return { ...noop, inherited: true };
-
-  fs.mkdirSync(dir, { recursive: true });
-
-  if (createExclusive(file, body)) {
-    return { acquired: true, file, release: makeRelease(file) };
-  }
-
-  // 已被占用：判断持有者是否还活着
-  const holder = readLock(file);
-  let alive = holder && isAlive(Number(holder.pid));
-  let pidReused = false;
-  if (alive) {
-    // PID 复用检测：进程启动晚于锁创建 ⇒ 抢锁的进程早已退出，这个 PID 是新进程
-    const startMs = procStartMs(Number(holder.pid));
-    const lockMs = Number(holder.startedAtMs) || 0;
-    if (startMs && lockMs && startMs > lockMs + 2000) {
-      alive = false;
-      pidReused = true;
-    }
-  }
-  if (alive) return { acquired: false, holder, file, release: () => {} };
-
-  // 陈旧锁（进程已死/文件损坏）⇒ 接管；崩溃不该把项目永久锁死
-  try {
-    fs.writeFileSync(file, JSON.stringify(body, null, 2), 'utf8');
-    return { acquired: true, file, tookOver: true, pidReused, holder, release: makeRelease(file) };
-  } catch (e) {
-    return { acquired: false, holder: holder || { pid: 0, label: `锁文件不可写：${e.message}` }, file, release: () => {} };
-  }
-}
-
-/** 释放：只删自己的锁（别人的锁不能被误删） */
-function makeRelease(file) {
-  return () => {
-    const cur = readLock(file);
-    if (cur && Number(cur.pid) !== process.pid) return; // 已不是我的锁，不动
-    try {
-      fs.unlinkSync(file);
-    } catch {
-      /* 已删除 */
-    }
-  };
-}
-
-/** 注册进程退出/中断时的自动释放（含 SIGINT/SIGTERM：Ctrl-C 也要解锁） */
-export function releaseOnExit(lock) {
-  if (!lock || !lock.acquired) return;
-  let done = false;
-  const bye = () => {
-    if (done) return;
-    done = true;
-    lock.release();
-  };
-  process.on('exit', bye);
-  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-    process.on(sig, () => {
-      bye();
-      process.exit(EXIT_SKIPPED);
-    });
-  }
-}

package/tool/lib/test-report.mjs

@@ -1,133 +0,0 @@
-// tool/lib/test-report.mjs —— 回归结果落盘（每套一份 JSON + 本轮汇总 + latest 指针）
-//
-// 为什么需要：以前跑完只看终端汇总，跑挂/超时后想回溯"哪套、什么错、当时内存多少"就得整轮重跑。
-//   落盘后 AI 只读 `runtime/test-results/latest.json` 一个入口就能拿到全部结果。
-//
-// 一个关键能力：**把"真失败"和"超时被杀"分开**。
-//   套件被 SIGKILL 时 failed/total 都是 null，以前会被报成"红"（假红），
-//   实际情况是"跑太久被砍"。这类必须单独标出来，否则会让人去查根本不该查的业务代码。
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-/** 读系统可用内存（MB）；拿不到返回 null（非 Linux 或 /proc 不可读） */
-export function memAvailableMB() {
-  try {
-    // dsh-skip-quality 只读 /proc/meminfo（约 1~2KB 的固定格式伪文件），memory-bomb 不适用
-    const txt = fs.readFileSync('/proc/meminfo', 'utf8');
-    const m = /^MemAvailable:\s+(\d+)\s+kB$/m.exec(txt);
-    return m ? Math.round(Number(m[1]) / 1024) : null;
-  } catch {
-    return null;
-  }
-}
-
-/** 时间戳目录名：yyyyMMdd-HHmmss（本地时区，便于人对号） */
-export function runStamp(date = new Date()) {
-  const p = (n) => String(n).padStart(2, '0');
-  return `${date.getFullYear()}${p(date.getMonth() + 1)}${p(date.getDate())}-${
-    p(date.getHours())}${p(date.getMinutes())}${p(date.getSeconds())}`;
-}
-
-/** 取文本尾巴（行数上限），用于 stdoutTail/stderrTail 诊断 */
-export function tailLines(text, maxLines = 200) {
-  const lines = String(text || '').split('\n');
-  return lines.slice(Math.max(0, lines.length - maxLines)).join('\n');
-}
-
-/**
- * 判定一套的结局。**这是"超时 vs 真失败"的唯一判据**。
- *
- * @param {{result: object|null, status: number|null, signal: string|null, ms: number, limitMs: number}} p
- * @returns {{status: string, hint: string}}
- *   ok                 有结构化结果且 failed=0
- *   failed             有结构化结果且 failed>0（真断言失败）
- *   killed-by-timeout  没结果且被信号杀掉/退出码异常，且耗时≥上限（超时，不是断言失败）
- *   no-result          没结果但不是超时（脚本崩、chrome 起不来、输出不是 JSON…）
- */
-export function classifyOutcome({ result, status, signal, ms, limitMs }) {
-  if (result && Number.isFinite(result.failed)) {
-    return result.failed > 0
-      ? { status: 'failed', hint: `${result.failed} 项断言未通过` }
-      : { status: 'ok', hint: '' };
-  }
-  const nearLimit = Number.isFinite(limitMs) && ms >= limitMs * 0.9;
-  if (signal === 'SIGKILL' || status === 2 || (nearLimit && !result)) {
-    const how = signal ? `被 ${signal} 杀掉` : `退出码 ${status}`;
-    return {
-      status: 'killed-by-timeout',
-      hint: `套件跑了 ${ms}ms，接近/超过上限 ${limitMs}ms，${how} —— 提高超时或查它为什么慢（不是断言失败）`,
-    };
-  }
-  return { status: 'no-result', hint: `没产出结构化结果（exitCode=${status}），看 stdoutTail/stderrTail` };
-}
-
-/** 递归建目录并写 JSON（原子写：先写 .tmp 再 rename，避免读到半个文件） */
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp`;
-  fs.writeFileSync(tmp, `${JSON.stringify(value, null, 1)}\n`, 'utf8');
-  fs.renameSync(tmp, file);
-}
-
-/** 一套的落盘文件名（套件名已限定为 kebab-case，直接当文件名安全） */
-function suiteFile(dir, suiteName) {
-  return path.join(dir, `${suiteName}.json`);
-}
-
-/**
- * 开一轮：建目录、写初始汇总（running=true）。
- * @param {{outRoot: string, base: string, suites: string[], startedAt: string}} p
- * @returns {{dir: string, summaryPath: string}}
- */
-export function openRun({ outRoot, base, suites, startedAt }) {
-  const dir = path.join(outRoot, runStamp());
-  fs.mkdirSync(dir, { recursive: true });
-  const summaryPath = path.join(dir, 'run-summary.json');
-  writeJson(summaryPath, {
-    startedAt,
-    finishedAt: null,
-    running: true,          // 跑完置 false —— 外部可据此判断"还在跑吗"
-    exitCode: null,
-    base,
-    plannedSuites: suites,
-    suites: [],
-    env: { memAvailableMBAtStart: memAvailableMB(), node: process.version, pid: process.pid },
-  });
-  return { dir, summaryPath };
-}
-
-/** 单套写盘（每套跑完立刻写，后台跑中途被杀也留得下已跑部分） */
-export function writeSuiteResult(dir, entry) {
-  writeJson(suiteFile(dir, entry.suite), entry);
-}
-
-/** 更新汇总（每套跑完调一次，保证 running=true 期间也能看到进度） */
-export function updateSummary(summaryPath, patch) {
-  let prev = {};
-  try { prev = JSON.parse(fs.readFileSync(summaryPath, 'utf8')); } catch { prev = {}; }
-  writeJson(summaryPath, { ...prev, ...patch });
-}
-
-/**
- * 收尾：写 finishedAt/exitCode/running=false，并把 `latest.json` 指过来。
- * latest 里只放"去哪读"，避免同一份数据写两处后漂移。
- */
-export function finishRun({ outRoot, dir, summaryPath, exitCode }) {
-  updateSummary(summaryPath, {
-    finishedAt: new Date().toISOString(),
-    running: false,
-    exitCode,
-    env: { ...(readJson(summaryPath, {}).env || {}), memAvailableMBAtEnd: memAvailableMB() },
-  });
-  writeJson(path.join(outRoot, 'latest.json'), {
-    run: path.basename(dir),
-    summary: path.relative(outRoot, summaryPath),
-    finishedAt: new Date().toISOString(),
-  });
-}
-
-/** 读 JSON（失败返回默认值） */
-export function readJson(file, fallback) {
-  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
-}