mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-15 00:01:58 +00:00
check-all 提速：从约 10 分钟降到约 3 分钟；可选隔离环境，边改代码边跑也不被打断
- 关浏览器不干等：系统 Chrome 建过浏览器上下文之后，关浏览器要空等约 4.5 秒才退出。 check-all 给检查用的 Chrome 套一层转发，见到「关浏览器」就替它应答、再让它退出（几十毫秒）， 其余消息原样转发，检查脚本一行不改；CHECK_FAST_CLOSE=0 关掉。最慢的两项因此从 317 秒、281 秒降到 184 秒、117 秒 - 拆开最慢的两项：run-states 拆成 3 份、canvas-fx 拆成 2 份，分到不同的道；每一段恰好跑一次，断言数不变， 以后新加的段自动落进「其余」那一份；汇总表按原检查名合成一行，没过的只重跑那一份 - 量时间的几份同一时刻最多跑一份（原来是整项互斥），这条链排在最前面；默认 4 道改成 8 道 - 新增 --stacks N（要 CHECK_DATA_SRC 指定数据目录）：从当前工作区另起 N 套后端和前端， 各用一份数据拷贝，端口自动挑空闲的；后端不热重载、前端不监听文件，代码中途被改也不会打断检查； 跑完、出错或被中断都会把进程和临时目录清干净 - 前端开发服务器新增两个可选开关（AGENTLAB_VITE_NO_WATCH、AGENTLAB_VITE_CACHE_DIR），不设时行为不变 - 写稳一处断言竞态：数据页点亮「数据」的判断，路由状态在地址变化之后才提交，改成最多等 3 秒再判，判定条件不变 实测（17 项、4361 条断言，一条没删、没放松）：原来 9 分 58 秒；默认跑法 3 分 26 秒； --stacks 2 --lanes 12 约 3 分 03 秒（另加约 10 秒起服务），连续 3 次全绿
This commit is contained in:
ThearchyHelios
+14
-1
@@ -1,4 +1,4 @@
|
||||
import { defineConfig } from 'vite'
|
||||
import { defineConfig, searchForWorkspaceRoot } from 'vite'
|
||||
import react from '@vitejs/plugin-react'
|
||||
import tailwindcss from '@tailwindcss/vite'
|
||||
|
||||
@@ -6,11 +6,24 @@ import tailwindcss from '@tailwindcss/vite'
|
||||
// 环境变量告诉这边，否则前端会把请求代理到别人的服务上去。
|
||||
const API_PORT = process.env.AGENTLAB_PORT || '8000'
|
||||
|
||||
// 下面两个只给检查用的隔离环境（scripts/check-all.mjs --stacks）设，平时不设、行为不变：
|
||||
// - AGENTLAB_VITE_NO_WATCH=1：不监听文件、不开热更新。边改代码边跑检查时，热更新会把页面
|
||||
// 整个重载、或者把 store 模块换掉，检查就偶发失败
|
||||
// - AGENTLAB_VITE_CACHE_DIR：依赖预构建的缓存放到这里（每套一份）。关了热更新，React 插件就不挂
|
||||
// Fast Refresh，预构建的指纹跟着变：要是和平时的开发服务器共用 node_modules/.vite，它会把那边
|
||||
// 的缓存整个重建一遍。所以关热更新时缓存一定另放，没给目录就放 node_modules/.vite-no-watch
|
||||
const NO_WATCH = process.env.AGENTLAB_VITE_NO_WATCH === '1'
|
||||
const CACHE_DIR = process.env.AGENTLAB_VITE_CACHE_DIR || (NO_WATCH ? 'node_modules/.vite-no-watch' : '')
|
||||
|
||||
export default defineConfig({
|
||||
plugins: [react(), tailwindcss()],
|
||||
...(CACHE_DIR ? { cacheDir: CACHE_DIR } : {}),
|
||||
server: {
|
||||
// 5173 太容易和别的项目撞车，挪开一点
|
||||
port: 5273,
|
||||
...(NO_WATCH ? { watch: null, hmr: false } : {}),
|
||||
// 缓存放到项目外面（/tmp 下）时要放行它：默认只放行项目目录
|
||||
...(CACHE_DIR ? { fs: { allow: [searchForWorkspaceRoot(process.cwd()), CACHE_DIR] } } : {}),
|
||||
proxy: {
|
||||
// 前端开发服务器代理到后端，省掉跨域配置
|
||||
'/api': { target: `http://127.0.0.1:${API_PORT}`, changeOrigin: true, ws: true },
|
||||
|
||||
+423
-96
@@ -1,34 +1,63 @@
|
||||
// 分道并行跑全部检查，汇总成一张表，给一个总的退出码。
|
||||
//
|
||||
// node scripts/check-all.mjs 全部跑一遍
|
||||
// node scripts/check-all.mjs 全部跑一遍（默认 8 道并行）
|
||||
// node scripts/check-all.mjs ui runs 只跑 check-ui、check-runs（名字去掉 check- 前缀）
|
||||
// node scripts/check-all.mjs --repeat 2 整套连跑两遍，列出只在某一遍失败的项（偶发）
|
||||
// node scripts/check-all.mjs --lanes 1 一个接一个地跑（以前的跑法）；也可以写 CHECK_LANES=1
|
||||
// CHECK_DATA_SRC=<数据目录> node scripts/check-all.mjs --stacks 2 --lanes 12
|
||||
// 推荐：从当前工作区另起 2 套专给检查用的「后端 + vite」，
|
||||
// 12 道分在上面跑，边改代码边跑也不受热更新打扰（见下）
|
||||
//
|
||||
// 默认连 5273 / 8000。对别的实例（比如一份沙箱拷贝）跑时带上地址，会原样传给每个检查：
|
||||
// AGENTLAB_WEB=http://localhost:<前端端口> AGENTLAB_API=http://localhost:<后端端口>/api node scripts/check-all.mjs
|
||||
// 每个检查的完整输出写进 CHECK_LOGS（默认 /tmp/agentlab-checks/<时间>/），终端只给汇总。
|
||||
//
|
||||
// 默认 4 道并行。各检查对后端只读（几处 POST 都是纯计算的排版接口），截图各有各的目录，
|
||||
// 时间大多花在 waitForTimeout 的固定等待上，所以并行几乎是线性提速。代价是共用同一个
|
||||
// vite 开发服务器，有几项还量时间（审批卡多少毫秒出现、计时器走没走）。两道防线：
|
||||
// - 量时间最多的几项（EXCLUSIVE）互相不重叠，同一时刻最多跑其中一项；
|
||||
// - 并行时没过的，全部跑完后再单独、一个接一个地重跑一遍。重跑通过的算通过，但单列成
|
||||
// 「偶发」：它在挤的时候会挂，迟早也会在别处挂。连跑几遍（--repeat）时不重跑，要的就是
|
||||
// 原始的偶发率。
|
||||
// 默认 8 道并行（CHECK_LANES 或 --lanes 改）。各检查对后端只读（几处 POST 都是纯计算的排版接口），
|
||||
// 截图各有各的目录，时间大多花在固定等待和开关浏览器上，CPU 闲着一大半，所以并行几乎是线性提速。
|
||||
// 代价是大家挤同一台机器、同一个 vite 开发服务器，有几段还量时间（计时器走没走、动效多少毫秒播完、
|
||||
// 取景动画落没落地）。三道防线：
|
||||
// - 最慢的两项（run-states、canvas-fx）按段拆成几份（SPLIT），分到不同的道上。量时间的那几份
|
||||
// 同一时刻最多跑其中一份；其余的段不量时间，和别的检查一样随便排。汇总表里仍按原检查名合并成一行；
|
||||
// - 并行时没过的，全部跑完后再单独、一个接一个地重跑一遍（拆开的只重跑没过的那一份）。重跑通过
|
||||
// 的算通过，但单列成「偶发」：它在挤的时候会挂，迟早也会在别处挂。连跑几遍（--repeat）时不重跑，
|
||||
// 要的就是原始的偶发率；
|
||||
// - --stacks N：另起 N 套隔离的「后端 + vite」，各道轮流分到各套上，见下。
|
||||
//
|
||||
// 关浏览器：系统 Chrome（154 起）只要开过浏览器上下文，browser.close() 就要干等 4 秒多才退出，
|
||||
// 而 run-states、canvas-fx 每一段都是开一个浏览器、查完关掉——光这一项，run-states 就从 5 分多钟
|
||||
// 降到 3 分钟、canvas-fx 从 4 分 40 秒降到 2 分钟。
|
||||
// 所以默认给各检查的 CHROME_PATH 套一层转发：Playwright 发来「关浏览器」时替 Chrome 应答，直接
|
||||
// SIGTERM 它（几十毫秒退干净），其余消息原样转发，检查本身一行不改。CHECK_FAST_CLOSE=0 关掉。
|
||||
//
|
||||
// --stacks N（或 CHECK_STACKS=N）：从当前工作区另起 N 套「后端 + vite」，只给这一次检查用，跑完
|
||||
// 连同临时目录一起收掉（出错、Ctrl+C 也收）。好处是边改代码边跑也不受影响：后端不带 --reload，
|
||||
// vite 不监听文件、不开热更新（AGENTLAB_VITE_NO_WATCH，见 frontend/vite.config.ts），起来后先把
|
||||
// 页面加载一遍，之后测的就是那一刻的代码；几道分摊到几个 vite 上，也不再挤一个。
|
||||
// - CHECK_DATA_SRC：数据目录，必填。每套拷一份到 /tmp 下的临时目录（APFS 上是写时复制，一秒内），
|
||||
// 不碰原目录；
|
||||
// - CHECK_PYTHON：后端解释器，默认 ~/miniforge3/envs/agentlab/bin/python；
|
||||
// - 端口由系统分配空闲的，避开 5273 / 8000 / 5373 / 8100；后端去掉模型密钥的环境变量，
|
||||
// seed 不会拿会话里的密钥去种 provider；后端、vite 的输出也在 CHECK_LOGS 里。
|
||||
// 带 --stacks 时 AGENTLAB_WEB / AGENTLAB_API 不用。
|
||||
//
|
||||
// 各检查自己的段过滤（CHECK_ONLY、ONLY、THEMES……）不往下传：整套检查就是整套，只跑某几段
|
||||
// 请直接跑那个脚本。
|
||||
//
|
||||
// 退出码：0 全部通过；1 有检查没通过、中途崩了、超时或一项都没跑；2 前后端连不上，一项都没跑。
|
||||
// 退出码：0 全部通过；1 有检查没通过、中途崩了、超时或一项都没跑；2 前后端连不上（或另起的
|
||||
// 那几套没起来），一项都没跑。
|
||||
import { spawn } from 'node:child_process'
|
||||
import { createWriteStream, mkdirSync, readFileSync, readdirSync } from 'node:fs'
|
||||
import {
|
||||
chmodSync, constants as fsConstants, cpSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, openSync,
|
||||
readFileSync, readdirSync, rmSync, writeFileSync,
|
||||
} from 'node:fs'
|
||||
import { createServer } from 'node:net'
|
||||
import { homedir } from 'node:os'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, join } from 'node:path'
|
||||
import { dirname, join, resolve } from 'node:path'
|
||||
|
||||
const WEB = process.env.AGENTLAB_WEB ?? 'http://localhost:5273'
|
||||
const API = process.env.AGENTLAB_API ?? 'http://localhost:8000/api'
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const ROOT = dirname(HERE)
|
||||
const SYSTEM_CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
|
||||
|
||||
// 先跑快的、不开浏览器的，再按页面从外壳往里跑；最后是连真数据的两项
|
||||
const ORDER = [
|
||||
@@ -50,20 +79,38 @@ const ORDER = [
|
||||
'manage', // 数据、工具、知识、设置
|
||||
'ui', // 各页面端到端，连真数据
|
||||
]
|
||||
// 最近一次全量里各项的耗时（秒）。只决定排队顺序：长的先开跑，短的填空，结果不受影响。
|
||||
// 新加的检查不在表里就按 60 秒算
|
||||
// 2026-09-29 三期收尾那一次四道并行的实测（秒）：只用来排先后，长的先跑
|
||||
// 各项的耗时（秒）。只决定排队顺序：长的先开跑，短的填空，结果不受影响。新加的检查不在表里就按 60 秒算；
|
||||
// 拆开的两项看 SPLIT 里各份的 est。2026-09-29 八道并行、关浏览器不干等之后的实测
|
||||
const ESTIMATE = {
|
||||
'run-states': 299, 'canvas-fx': 264, stream: 176, chat: 164, studio: 153, manage: 142, runs: 105,
|
||||
shell: 85, 'ui-kit': 74, evidence: 67, ui: 67, publish: 54, guards: 17, 'canvas-layout': 8, tokens: 1, trace: 1, decode: 1,
|
||||
stream: 173, chat: 160, studio: 149, manage: 145, runs: 112, publish: 92, shell: 87,
|
||||
evidence: 75, 'ui-kit': 67, ui: 61, guards: 8, 'canvas-layout': 2, tokens: 1, trace: 1, decode: 1,
|
||||
}
|
||||
// 最慢的两项按段拆成几份。用的是它们自己的段过滤：最后一份用 *_SKIP 兜住「其余全部」，以后新加的段
|
||||
// 不用改这里也跑得到（拆出去的那几份要是一段都没对上，那一份会报「一项都没跑」）。
|
||||
// timing 的几份量时间：计时器走没走、动效多少毫秒内播出来又停掉、取景动画落没落地、减少动效时
|
||||
// 一帧到位——机器一挤就可能读早了。它们同一时刻最多跑其中一份，这就是以前「run-states、canvas-fx
|
||||
// 互不重叠」的意思，只是收窄到真正量时间的段；其余的段只看结构和文字，挤不挤都一样
|
||||
const FX_TIMING = ['运行中：胶囊', '失败：接着跑', '跑完：执行路径', '打开宽图', 'Copilot 搭图', 'Copilot 这一轮删掉', '系统关了动效']
|
||||
const SPLIT = {
|
||||
'run-states': [
|
||||
{ part: 'themes', env: { RUN_STATES_ONLY: 'themes' }, timing: true, est: 86 },
|
||||
{ part: 'interact,exits,reduced', env: { RUN_STATES_ONLY: 'interact,exits,reduced' }, timing: true, est: 45 },
|
||||
{ part: '其余', env: { RUN_STATES_SKIP: 'themes,interact,exits,reduced' }, est: 60 },
|
||||
],
|
||||
'canvas-fx': [
|
||||
{ part: '量时间的段', env: { FX_ONLY: FX_TIMING.join(',') }, timing: true, est: 52 },
|
||||
{ part: '其余', env: { FX_SKIP: FX_TIMING.join(',') }, est: 72 },
|
||||
],
|
||||
}
|
||||
// 量时间最多、以前并行最容易挂的：同一时刻最多跑其中一项
|
||||
const EXCLUSIVE = new Set(['run-states', 'canvas-fx'])
|
||||
const TIMEOUT_MS = Number(process.env.CHECK_TIMEOUT_MS ?? 15 * 60_000)
|
||||
// 各检查只跑其中几段、只跑一套主题的开关。壳里留着一个 ONLY=… 就会让整套检查悄悄只跑一小截，
|
||||
// 却照样报「全部通过」，所以一律不传给子进程
|
||||
const FILTERS = ['CHECK_ONLY', 'ONLY', 'THEMES', 'FX_ONLY', 'STUDIO_ONLY', 'RUN_STATES_ONLY', 'UI_KIT_ONLY', 'CHECK_THEME',
|
||||
'EVIDENCE_ONLY', 'PUBLISH_ONLY']
|
||||
const FILTERS = ['CHECK_ONLY', 'ONLY', 'THEMES', 'FX_ONLY', 'FX_SKIP', 'STUDIO_ONLY', 'RUN_STATES_ONLY', 'RUN_STATES_SKIP',
|
||||
'UI_KIT_ONLY', 'CHECK_THEME', 'EVIDENCE_ONLY', 'PUBLISH_ONLY', 'RUNS_ONLY']
|
||||
// 另起的后端不拿会话里的模型密钥：seed 见到它们会种一个真的 provider
|
||||
const SECRETS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN', 'OPENAI_API_KEY']
|
||||
// 另起的几套不许占这几个口：开发（5273 / 8000）和沙箱（5373 / 8100）
|
||||
const RESERVED_PORTS = new Set([5273, 8000, 5373, 8100])
|
||||
// 新加的 check-*.mjs 忘了写进 ORDER 就永远不会跑：列出来提醒
|
||||
const unlisted = readdirSync(HERE)
|
||||
.map((f) => f.match(/^check-(.+)\.mjs$/)?.[1])
|
||||
@@ -71,13 +118,15 @@ const unlisted = readdirSync(HERE)
|
||||
|
||||
const args = process.argv.slice(2)
|
||||
let repeat = 1
|
||||
let lanes = Math.max(1, Number(process.env.CHECK_LANES) || 4)
|
||||
let lanes = Math.max(1, Number(process.env.CHECK_LANES) || 8)
|
||||
let stackCount = Math.max(0, Number(process.env.CHECK_STACKS) || 0)
|
||||
const picked = []
|
||||
for (let i = 0; i < args.length; i++) {
|
||||
if (args[i] === '--repeat') repeat = Math.max(1, Number(args[++i]) || 1)
|
||||
else if (args[i].startsWith('--repeat=')) repeat = Math.max(1, Number(args[i].slice(9)) || 1)
|
||||
else if (args[i] === '--lanes') lanes = Math.max(1, Number(args[++i]) || 1)
|
||||
else if (args[i].startsWith('--lanes=')) lanes = Math.max(1, Number(args[i].slice(8)) || 1)
|
||||
const [flag, inline] = args[i].split('=')
|
||||
const value = () => Number(inline ?? args[++i])
|
||||
if (flag === '--repeat') repeat = Math.max(1, value() || 1)
|
||||
else if (flag === '--lanes') lanes = Math.max(1, value() || 1)
|
||||
else if (flag === '--stacks') stackCount = Math.max(0, value() || 0)
|
||||
else picked.push(args[i].replace(/^check-/, '').replace(/\.mjs$/, ''))
|
||||
}
|
||||
const unknown = picked.filter((n) => !ORDER.includes(n))
|
||||
@@ -86,54 +135,300 @@ if (unknown.length) {
|
||||
process.exit(2)
|
||||
}
|
||||
const names = picked.length ? ORDER.filter((n) => picked.includes(n)) : ORDER
|
||||
|
||||
// 连不上就别跑：十几个检查挨个报「打不开页面」只会淹没真正的原因
|
||||
const reach = async (url) => {
|
||||
try {
|
||||
const r = await fetch(url, { signal: AbortSignal.timeout(5000) })
|
||||
return r.ok ? '' : `HTTP ${r.status}`
|
||||
} catch (e) {
|
||||
return e.cause?.code ?? e.name ?? String(e)
|
||||
}
|
||||
}
|
||||
const needsServers = names.some((n) => n !== 'tokens')
|
||||
if (needsServers) {
|
||||
const [web, api] = await Promise.all([reach(WEB), reach(`${API}/health`)])
|
||||
if (web || api) {
|
||||
if (web) console.error(`✗ 前端连不上：${WEB}（${web}）`)
|
||||
if (api) console.error(`✗ 后端连不上：${API}/health（${api}）`)
|
||||
console.error(' 先把前后端起来（./scripts/dev.sh），或者用 AGENTLAB_WEB / AGENTLAB_API 指到要检查的那一份')
|
||||
process.exit(2)
|
||||
|
||||
// ---------------------------------------------------------------- 收尾
|
||||
//
|
||||
// 自己拉起来的东西（另起的几套服务、正在跑的检查、临时目录）登记在这里。正常跑完、出错、
|
||||
// Ctrl+C、被 kill 都走一遍；进程退出前只能做同步的事，所以这里一律同步
|
||||
|
||||
const cleanups = []
|
||||
let cleaned = false
|
||||
function cleanup() {
|
||||
if (cleaned) return
|
||||
cleaned = true
|
||||
for (const fn of cleanups.reverse()) {
|
||||
try { fn() } catch { /* 收尾时能收多少收多少 */ }
|
||||
}
|
||||
}
|
||||
process.on('exit', cleanup)
|
||||
for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
|
||||
process.on(sig, () => {
|
||||
console.error(`\n收到 ${sig}：停掉检查和另起的服务，删掉临时目录`)
|
||||
cleanup()
|
||||
process.exit(130)
|
||||
})
|
||||
}
|
||||
for (const ev of ['uncaughtException', 'unhandledRejection']) {
|
||||
process.on(ev, (e) => {
|
||||
console.error(e)
|
||||
cleanup()
|
||||
process.exit(1)
|
||||
})
|
||||
}
|
||||
const running = new Set() // 正在跑的检查子进程：被中断时一起停掉
|
||||
cleanups.push(() => { for (const c of running) c.kill('SIGTERM') })
|
||||
|
||||
const TMP = mkdtempSync('/tmp/agentlab-check-')
|
||||
cleanups.push(() => rmSync(TMP, { recursive: true, force: true }))
|
||||
|
||||
const now = new Date()
|
||||
const pad = (n) => String(n).padStart(2, '0')
|
||||
const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
|
||||
const LOGS = process.env.CHECK_LOGS ?? join('/tmp/agentlab-checks', stamp)
|
||||
mkdirSync(LOGS, { recursive: true })
|
||||
console.log(`前端 ${WEB} · 后端 ${API}`)
|
||||
const dropped = FILTERS.filter((k) => process.env[k])
|
||||
if (dropped.length) console.log(`没传给各检查的段过滤：${dropped.map((k) => `${k}=${process.env[k]}`).join(' ')}（只跑某几段请直接跑那个脚本）`)
|
||||
lanes = Math.min(lanes, names.length)
|
||||
console.log(`${names.length} 项检查${repeat > 1 ? ` × ${repeat} 遍` : ''}，${lanes > 1 ? `${lanes} 道并行` : '一个接一个'}，完整输出在 ${LOGS}/\n`)
|
||||
|
||||
const childEnv = { ...process.env, AGENTLAB_WEB: WEB, AGENTLAB_API: API }
|
||||
for (const k of FILTERS) delete childEnv[k]
|
||||
const baseEnv = { ...process.env }
|
||||
for (const k of FILTERS) delete baseEnv[k]
|
||||
|
||||
// ---------------------------------------------------------------- 关浏览器不干等
|
||||
|
||||
/**
|
||||
* 跑一个检查，输出落盘，数 ✓ / ✗。退出码非 0 却一个 ✗ 都没有的，是中途崩了；
|
||||
* 套在真 Chrome 外面的转发：Playwright 用 fd 3 发、fd 4 收（--remote-debugging-pipe），消息以 \0
|
||||
* 分隔。见到 Browser.close 就不转发，替 Chrome 应答、再 SIGTERM 它——Chrome 收到 Browser.close
|
||||
* 之后连 SIGTERM 也一起晾着，一样要等满 4 秒。应答要插在 Chrome 两条消息之间：它正写到一半就
|
||||
* 等这条写完再插，不然 Playwright 那头的分帧就乱了。管道用 net.Socket 读写：fs 流读管道会占住
|
||||
* 线程池，进程退不掉
|
||||
*/
|
||||
const RELAY = `import { spawn } from 'node:child_process'
|
||||
import { Socket } from 'node:net'
|
||||
const child = spawn(process.argv[2], process.argv.slice(3), { stdio: ['ignore', 'inherit', 'inherit', 'pipe', 'pipe'] })
|
||||
const fromPw = new Socket({ fd: 3, readable: true, writable: false })
|
||||
const toPw = new Socket({ fd: 4, readable: false, writable: true })
|
||||
for (const s of [fromPw, toPw, child.stdio[3], child.stdio[4]]) s.on('error', () => {})
|
||||
let tail = ''
|
||||
let ack = null // 等着插进去的应答
|
||||
let sealed = false // 应答已经发出，Chrome 之后说的都不再转
|
||||
let between = true // 转给 Playwright 的最后一个字节是 \\0：正好在两条消息之间
|
||||
const seal = () => {
|
||||
toPw.write(ack)
|
||||
sealed = true
|
||||
child.kill('SIGTERM')
|
||||
}
|
||||
fromPw.on('data', (chunk) => {
|
||||
if (ack) return
|
||||
const parts = (tail + chunk.toString('latin1')).split('\\0')
|
||||
tail = parts.pop()
|
||||
for (const m of parts) {
|
||||
const hit = m.includes('"method":"Browser.close"') && /"id":(-?\\d+)/.exec(m)
|
||||
if (hit) {
|
||||
ack = '{"id":' + hit[1] + ',"result":{}}\\0'
|
||||
if (between) seal()
|
||||
else setTimeout(() => { if (!sealed) seal() }, 1000) // 兜底：这条迟迟写不完就不等了
|
||||
return
|
||||
}
|
||||
child.stdio[3].write(Buffer.from(m + '\\0', 'latin1'))
|
||||
}
|
||||
})
|
||||
fromPw.on('end', () => child.stdio[3].end())
|
||||
child.stdio[4].on('data', (chunk) => {
|
||||
if (sealed) return
|
||||
if (ack) {
|
||||
const i = chunk.indexOf(0)
|
||||
if (i < 0) return void toPw.write(chunk)
|
||||
toPw.write(chunk.subarray(0, i + 1))
|
||||
return seal()
|
||||
}
|
||||
toPw.write(chunk)
|
||||
between = chunk[chunk.length - 1] === 0
|
||||
})
|
||||
child.on('exit', (code, sig) => {
|
||||
const done = () => process.exit(code ?? (sig ? 0 : 1))
|
||||
toPw.end(done)
|
||||
setTimeout(done, 500)
|
||||
})
|
||||
for (const s of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.on(s, () => child.kill(s))
|
||||
`
|
||||
const sq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`
|
||||
let chromePath = process.env.CHROME_PATH ?? SYSTEM_CHROME
|
||||
if (process.env.CHECK_FAST_CLOSE !== '0' && existsSync(chromePath)) {
|
||||
writeFileSync(join(TMP, 'chrome-relay.mjs'), RELAY)
|
||||
const wrapper = join(TMP, 'chrome')
|
||||
writeFileSync(wrapper, `#!/bin/sh\nexec ${sq(process.execPath)} ${sq(join(TMP, 'chrome-relay.mjs'))} ${sq(chromePath)} "$@"\n`)
|
||||
chmodSync(wrapper, 0o755)
|
||||
chromePath = wrapper
|
||||
}
|
||||
baseEnv.CHROME_PATH = chromePath
|
||||
|
||||
// ---------------------------------------------------------------- 另起的几套服务
|
||||
|
||||
const reach = async (url, want) => {
|
||||
try {
|
||||
const r = await fetch(url, { signal: AbortSignal.timeout(5000) })
|
||||
if (!r.ok) return `HTTP ${r.status}`
|
||||
return want && !(await r.text()).includes(want) ? '答话的不是 agentlab' : ''
|
||||
} catch (e) {
|
||||
return e.cause?.code ?? e.name ?? String(e)
|
||||
}
|
||||
}
|
||||
const takenPorts = new Set()
|
||||
function freePort() {
|
||||
return new Promise((resolvePort, reject) => {
|
||||
const srv = createServer()
|
||||
srv.on('error', reject)
|
||||
srv.listen(0, '127.0.0.1', () => {
|
||||
const { port } = srv.address()
|
||||
srv.close(() => {
|
||||
if (RESERVED_PORTS.has(port) || takenPorts.has(port)) freePort().then(resolvePort, reject)
|
||||
else { takenPorts.add(port); resolvePort(port) }
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
|
||||
const tailOf = (file, n = 6) => {
|
||||
try { return readFileSync(file, 'utf8').split('\n').filter(Boolean).slice(-n).join('\n ') } catch { return '' }
|
||||
}
|
||||
|
||||
/** 起一个服务：自成一个进程组，收尾时整组杀掉（uvicorn、vite 自己再拉的子进程也在组里） */
|
||||
function launch(cmd, argv, { cwd, env, log }) {
|
||||
const fd = openSync(log, 'a')
|
||||
const child = spawn(cmd, argv, { cwd, env, detached: true, stdio: ['ignore', fd, fd] })
|
||||
child.exited = new Promise((r) => child.on('exit', r))
|
||||
let dead = false
|
||||
child.on('exit', () => { dead = true })
|
||||
child.isDead = () => dead
|
||||
const kill = (sig) => { if (!dead) { try { process.kill(-child.pid, sig) } catch { /* 已经没了 */ } } }
|
||||
child.stop = async () => {
|
||||
kill('SIGTERM')
|
||||
await Promise.race([child.exited, sleep(5000)])
|
||||
kill('SIGKILL')
|
||||
}
|
||||
cleanups.push(() => kill('SIGKILL'))
|
||||
return child
|
||||
}
|
||||
|
||||
async function waitUntil(label, url, want, child, log, ms) {
|
||||
const end = Date.now() + ms
|
||||
for (;;) {
|
||||
if (child.isDead()) throw new Error(`${label}没起来，进程退出了：\n ${tailOf(log)}`)
|
||||
if (!(await reach(url, want))) return
|
||||
if (Date.now() > end) throw new Error(`${label} ${Math.round(ms / 1000)} 秒内没就绪（${url}）：\n ${tailOf(log)}`)
|
||||
await sleep(300)
|
||||
}
|
||||
}
|
||||
|
||||
async function startStack(i, dataSrc, python) {
|
||||
const dir = join(TMP, `stack-${i}`)
|
||||
// 写时复制地拷一份数据目录。-shm 是正在用它的进程的共享内存索引，不拷：打开拷贝时按 -wal 重建
|
||||
cpSync(dataSrc, join(dir, 'data'), { recursive: true, mode: fsConstants.COPYFILE_FICLONE, filter: (p) => !p.endsWith('-shm') })
|
||||
const [apiPort, webPort] = [await freePort(), await freePort()]
|
||||
const WEB = `http://127.0.0.1:${webPort}`
|
||||
const API = `http://127.0.0.1:${apiPort}/api`
|
||||
const env = { ...baseEnv }
|
||||
for (const k of SECRETS) delete env[k]
|
||||
|
||||
// 后端照 scripts/dev.sh 的起法，只是不带 --reload
|
||||
const backendLog = join(LOGS, `stack-${i}.backend.log`)
|
||||
const backend = launch(python, ['-m', 'uvicorn', 'app.main:app', '--host', '127.0.0.1', '--port', String(apiPort)], {
|
||||
cwd: join(ROOT, 'backend'), log: backendLog,
|
||||
env: {
|
||||
...env, PYTHONUNBUFFERED: '1', AGENTLAB_DATA_DIR: join(dir, 'data'), AGENTLAB_HOST: '127.0.0.1', AGENTLAB_PORT: String(apiPort),
|
||||
AGENTLAB_CORS_ORIGINS: JSON.stringify([WEB, `http://localhost:${webPort}`]),
|
||||
},
|
||||
})
|
||||
await waitUntil(`第 ${i} 套后端`, `${API}/health`, '"agentlab"', backend, backendLog, 90_000)
|
||||
|
||||
const viteLog = join(LOGS, `stack-${i}.vite.log`)
|
||||
const vite = launch(process.execPath, [join(ROOT, 'frontend', 'node_modules', 'vite', 'bin', 'vite.js'),
|
||||
'--port', String(webPort), '--strictPort', '--host', '127.0.0.1'], {
|
||||
cwd: join(ROOT, 'frontend'), log: viteLog,
|
||||
env: { ...env, AGENTLAB_PORT: String(apiPort), AGENTLAB_VITE_NO_WATCH: '1', AGENTLAB_VITE_CACHE_DIR: join(dir, 'vite') },
|
||||
})
|
||||
await waitUntil(`第 ${i} 套 vite`, `${WEB}/`, '', vite, viteLog, 60_000)
|
||||
return { i, WEB, API, backend, vite }
|
||||
}
|
||||
|
||||
/**
|
||||
* 把几个入口页各加载一遍：vite 按需转译，第一个打开页面的检查不用替大家等转译。每套的依赖在
|
||||
* 自己的缓存目录里从头预构建（关了热更新，指纹和平时的开发服务器不一样），预构建赶上页面加载
|
||||
* 引起的整页重载也发生在这里，不落在检查中途
|
||||
*/
|
||||
async function warmUp(stacks) {
|
||||
const { chromium } = await import(join(ROOT, 'frontend', 'node_modules', 'playwright-core', 'index.mjs'))
|
||||
const browser = await chromium.launch({ executablePath: chromePath })
|
||||
try {
|
||||
await Promise.all(stacks.map(async (s) => {
|
||||
const page = await browser.newPage()
|
||||
for (const path of ['/', '/studio', '/preview.html', '/ui-harness.html']) {
|
||||
await page.goto(`${s.WEB}${path}`, { waitUntil: 'networkidle', timeout: 60_000 })
|
||||
}
|
||||
await page.close()
|
||||
}))
|
||||
} finally {
|
||||
await browser.close()
|
||||
}
|
||||
}
|
||||
|
||||
let stacks = []
|
||||
if (stackCount > 0 && needsServers) {
|
||||
const dataSrc = process.env.CHECK_DATA_SRC && resolve(process.env.CHECK_DATA_SRC)
|
||||
const python = process.env.CHECK_PYTHON ?? join(homedir(), 'miniforge3', 'envs', 'agentlab', 'bin', 'python')
|
||||
const problems = []
|
||||
if (!dataSrc) problems.push('--stacks 要知道拿哪份数据：用 CHECK_DATA_SRC=<数据目录> 指定（里面有 agentlab.db 的那一层）')
|
||||
else if (!existsSync(join(dataSrc, 'agentlab.db'))) problems.push(`CHECK_DATA_SRC=${dataSrc} 里没有 agentlab.db`)
|
||||
if (!existsSync(python)) problems.push(`找不到后端解释器 ${python}，用 CHECK_PYTHON 指定`)
|
||||
if (problems.length) {
|
||||
for (const p of problems) console.error(`✗ ${p}`)
|
||||
process.exit(2)
|
||||
}
|
||||
const t0 = Date.now()
|
||||
console.log(`另起 ${stackCount} 套后端 + vite（数据拷自 ${dataSrc}）……`)
|
||||
try {
|
||||
stacks = await Promise.all(Array.from({ length: stackCount }, (_, k) => startStack(k + 1, dataSrc, python)))
|
||||
await warmUp(stacks)
|
||||
} catch (e) {
|
||||
console.error(`✗ ${String(e?.message ?? e)}`)
|
||||
process.exit(2)
|
||||
}
|
||||
for (const s of stacks) console.log(` 第 ${s.i} 套：前端 ${s.WEB} · 后端 ${s.API}`)
|
||||
console.log(` ${Math.round((Date.now() - t0) / 1000)} 秒就绪，日志 ${LOGS}/stack-*.log`)
|
||||
} else {
|
||||
const WEB = process.env.AGENTLAB_WEB ?? 'http://localhost:5273'
|
||||
const API = process.env.AGENTLAB_API ?? 'http://localhost:8000/api'
|
||||
// 连不上就别跑：十几个检查挨个报「打不开页面」只会淹没真正的原因
|
||||
if (needsServers) {
|
||||
const [web, api] = await Promise.all([reach(WEB), reach(`${API}/health`)])
|
||||
if (web || api) {
|
||||
if (web) console.error(`✗ 前端连不上：${WEB}（${web}）`)
|
||||
if (api) console.error(`✗ 后端连不上：${API}/health（${api}）`)
|
||||
console.error(' 先把前后端起来（./scripts/dev.sh），或者用 AGENTLAB_WEB / AGENTLAB_API 指到要检查的那一份，或者带上 --stacks')
|
||||
process.exit(2)
|
||||
}
|
||||
}
|
||||
stacks = [{ i: 0, WEB, API }]
|
||||
console.log(`前端 ${WEB} · 后端 ${API}`)
|
||||
}
|
||||
const dropped = FILTERS.filter((k) => process.env[k])
|
||||
if (dropped.length) console.log(`没传给各检查的段过滤：${dropped.map((k) => `${k}=${process.env[k]}`).join(' ')}（只跑某几段请直接跑那个脚本）`)
|
||||
|
||||
// ---------------------------------------------------------------- 排队与跑
|
||||
|
||||
// 一道一次跑一份。并行时最慢的两项拆开；一个接一个地跑时拆开没有好处，整项跑
|
||||
const split = lanes > 1
|
||||
const jobs = names.flatMap((name) => (split && SPLIT[name]
|
||||
? SPLIT[name].map((p) => ({ name, part: p.part, env: p.env, timing: !!p.timing, est: p.est ?? 60 }))
|
||||
: [{ name, part: '', env: {}, timing: false, est: ESTIMATE[name] ?? 60 }]))
|
||||
lanes = Math.min(lanes, jobs.length)
|
||||
console.log(`${names.length} 项检查${jobs.length > names.length ? `（拆成 ${jobs.length} 份）` : ''}${repeat > 1 ? ` × ${repeat} 遍` : ''}，`
|
||||
+ `${lanes > 1 ? `${lanes} 道并行` : '一个接一个'}${stacks.length > 1 ? `、分在 ${stacks.length} 套服务上` : ''}，完整输出在 ${LOGS}/\n`)
|
||||
|
||||
const label = (r) => `check-${r.name}${r.part ? `〔${r.part}〕` : ''}`
|
||||
|
||||
/**
|
||||
* 跑一份检查，输出落盘，数 ✓ / ✗。退出码非 0 却一个 ✗ 都没有的，是中途崩了；
|
||||
* 退出码 0 却一个 ✓ 都没有的，是什么都没查——都不算通过
|
||||
*/
|
||||
function runOne(name, pass, suffix = '') {
|
||||
const file = join(LOGS, `${name}${repeat > 1 ? `.${pass}` : ''}${suffix}.log`)
|
||||
function runOne(job, pass, stack, suffix = '') {
|
||||
const file = join(LOGS, `${job.name}${job.part ? `.${job.part.replace(/[^\w一-鿿-]+/g, '_')}` : ''}${repeat > 1 ? `.${pass}` : ''}${suffix}.log`)
|
||||
const out = createWriteStream(file)
|
||||
const started = Date.now()
|
||||
return new Promise((resolve) => {
|
||||
const child = spawn(process.execPath, [join(HERE, `check-${name}.mjs`)], {
|
||||
env: childEnv,
|
||||
return new Promise((resolveRun) => {
|
||||
const child = spawn(process.execPath, [join(HERE, `check-${job.name}.mjs`)], {
|
||||
env: { ...baseEnv, AGENTLAB_WEB: stack.WEB, AGENTLAB_API: stack.API, ...job.env },
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
})
|
||||
running.add(child)
|
||||
child.stdout.pipe(out, { end: false })
|
||||
child.stderr.pipe(out, { end: false })
|
||||
let timedOut = false
|
||||
@@ -145,6 +440,7 @@ function runOne(name, pass, suffix = '') {
|
||||
hard = setTimeout(() => child.kill('SIGKILL'), 10_000)
|
||||
}, TIMEOUT_MS)
|
||||
child.on('close', (code) => {
|
||||
running.delete(child)
|
||||
clearTimeout(timer)
|
||||
clearTimeout(hard)
|
||||
out.end(() => {
|
||||
@@ -158,83 +454,108 @@ function runOne(name, pass, suffix = '') {
|
||||
const empty = !timedOut && code === 0 && ok === 0
|
||||
const passed = code === 0 && ok > 0
|
||||
const tail = crashed || empty ? lines.filter(Boolean).slice(-4).join(' ⏎ ').slice(0, 300) : ''
|
||||
resolve({ name, pass, code, ok, bad, secs, timedOut, crashed, empty, passed, tail, file })
|
||||
resolveRun({ name: job.name, part: job.part, job, pass, code, ok, bad, secs, timedOut, crashed, empty, passed, tail, file })
|
||||
})
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/** 拆开跑的几份合成一行：通过要每份都通过，没过的项前面标上是哪一份 */
|
||||
function merge(rs) {
|
||||
if (rs.length === 1) return rs[0]
|
||||
const worst = rs.find((r) => r.timedOut) ?? rs.find((r) => r.crashed) ?? rs.find((r) => r.empty) ?? rs.find((r) => !r.passed)
|
||||
return {
|
||||
name: rs[0].name, part: '', pass: rs[0].pass, parts: rs,
|
||||
ok: rs.reduce((n, r) => n + r.ok, 0),
|
||||
bad: rs.flatMap((r) => r.bad.map((l) => `〔${r.part}〕${l}`)),
|
||||
secs: rs.reduce((n, r) => n + r.secs, 0),
|
||||
timedOut: rs.some((r) => r.timedOut), crashed: rs.some((r) => r.crashed), empty: rs.some((r) => r.empty),
|
||||
passed: rs.every((r) => r.passed),
|
||||
tail: worst?.tail ? `〔${worst.part}〕${worst.tail}` : '',
|
||||
file: worst?.file ?? rs[0].file,
|
||||
}
|
||||
}
|
||||
|
||||
const limit = TIMEOUT_MS >= 60_000 ? `${Math.round(TIMEOUT_MS / 60_000)} 分钟` : `${Math.round(TIMEOUT_MS / 1000)} 秒`
|
||||
const verdict = (r) => r.timedOut ? `超时（${limit}）`
|
||||
: r.crashed ? '中途崩了'
|
||||
: r.empty ? '一项都没跑'
|
||||
: r.passed ? '通过'
|
||||
: `${r.bad.length} 项没过`
|
||||
let spent = 0 // 各项累计的秒数，重跑的那次也算
|
||||
let spent = 0 // 各份累计的秒数，重跑的那次也算
|
||||
const report = (r) => {
|
||||
spent += r.secs
|
||||
const mark = r.passed ? '✓' : '✗'
|
||||
console.log(`${mark} ${`check-${r.name}`.padEnd(20)} ${verdict(r).padEnd(10)} ${String(r.ok).padStart(4)} 项通过 · ${r.secs}s`)
|
||||
const secs = r.parts ? `${r.secs}s（${r.parts.length} 份：${r.parts.map((p) => `${p.secs}s`).join(' / ')}）` : `${r.secs}s`
|
||||
console.log(`${mark} ${label(r).padEnd(20)} ${verdict(r).padEnd(10)} ${String(r.ok).padStart(4)} 项通过 · ${secs}`)
|
||||
for (const l of r.bad.slice(0, 5)) console.log(` ${l}`)
|
||||
if (r.bad.length > 5) console.log(` ……另有 ${r.bad.length - 5} 项，见 ${r.file}`)
|
||||
if (r.bad.length > 5) console.log(` ……另有 ${r.bad.length - 5} 项，见 ${r.parts ? r.parts.filter((p) => !p.passed).map((p) => p.file).join('、') : r.file}`)
|
||||
if (r.tail) console.log(` ${r.tail}`)
|
||||
}
|
||||
|
||||
/**
|
||||
* 一遍：lanes 道同时从队里取。长的排前面；EXCLUSIVE 里的一项在跑时，另一项先让给队里
|
||||
* 后面的。结果按跑完的先后打印，返回时按 ORDER 排好
|
||||
* 一遍：lanes 道同时从队里取，第 k 道用第 k % N 套服务。长的排前面；量时间的一份在跑时，
|
||||
* 别的量时间的先让给队里后面的。量时间的几份反正一份接一份，合起来就是一条长链，按整条链的
|
||||
* 长度排队：开头就起跑，一份跑完下一份马上接上，不被别的长项压到后面。一项的几份都跑完了才
|
||||
* 打印这一项（合成一行），返回时按 ORDER 排好
|
||||
*/
|
||||
async function runPass(pass) {
|
||||
const queue = [...names].sort((a, b) => (ESTIMATE[b] ?? 60) - (ESTIMATE[a] ?? 60))
|
||||
const chain = jobs.filter((j) => j.timing).reduce((n, j) => n + j.est, 0)
|
||||
const rank = (j) => (j.timing ? chain : j.est)
|
||||
const queue = [...jobs].sort((a, b) => rank(b) - rank(a) || b.est - a.est)
|
||||
const done = []
|
||||
let exclusiveBusy = false
|
||||
let waiting = [] // 等 EXCLUSIVE 那一项跑完的几道
|
||||
let timingBusy = false
|
||||
let waiting = [] // 等量时间的那一份跑完的几道
|
||||
const take = () => {
|
||||
const i = queue.findIndex((n) => !(EXCLUSIVE.has(n) && exclusiveBusy))
|
||||
const i = queue.findIndex((j) => !(j.timing && timingBusy))
|
||||
return i < 0 ? null : queue.splice(i, 1)[0]
|
||||
}
|
||||
const lane = async () => {
|
||||
const lane = async (k) => {
|
||||
const stack = stacks[k % stacks.length]
|
||||
while (queue.length) {
|
||||
const name = take()
|
||||
if (!name) {
|
||||
// 队里只剩 EXCLUSIVE 的，而另一项正在跑：等它跑完再取
|
||||
await new Promise((resolve) => waiting.push(resolve))
|
||||
const job = take()
|
||||
if (!job) {
|
||||
// 队里只剩量时间的，而另一份正在跑：等它跑完再取
|
||||
await new Promise((r) => waiting.push(r))
|
||||
continue
|
||||
}
|
||||
const exclusive = EXCLUSIVE.has(name)
|
||||
if (exclusive) exclusiveBusy = true
|
||||
const r = await runOne(name, pass)
|
||||
if (exclusive) {
|
||||
exclusiveBusy = false
|
||||
if (job.timing) timingBusy = true
|
||||
const r = await runOne(job, pass, stack)
|
||||
spent += r.secs
|
||||
if (job.timing) {
|
||||
timingBusy = false
|
||||
const woken = waiting
|
||||
waiting = []
|
||||
for (const resolve of woken) resolve()
|
||||
for (const wake of woken) wake()
|
||||
}
|
||||
done.push(r)
|
||||
report(r)
|
||||
const mine = jobs.filter((j) => j.name === job.name).map((j) => done.find((d) => d.job === j))
|
||||
if (mine.every(Boolean)) report(merge(mine))
|
||||
}
|
||||
}
|
||||
await Promise.all(Array.from({ length: lanes }, lane))
|
||||
return names.map((n) => done.find((r) => r.name === n))
|
||||
await Promise.all(Array.from({ length: lanes }, (_, k) => lane(k)))
|
||||
return done
|
||||
}
|
||||
|
||||
const byName = (done) => names.map((n) => merge(jobs.filter((j) => j.name === n).map((j) => done.find((r) => r.job === j))))
|
||||
|
||||
const results = []
|
||||
const flakyRerun = [] // 并行时没过、单独重跑通过的
|
||||
const started = Date.now()
|
||||
for (let pass = 1; pass <= repeat; pass++) {
|
||||
if (repeat > 1) console.log(`—— 第 ${pass} 遍 ——`)
|
||||
const got = await runPass(pass)
|
||||
if (lanes > 1 && repeat === 1 && got.some((r) => !r.passed)) {
|
||||
const failed = got.filter((r) => !r.passed)
|
||||
console.log(`\n并行时没过的 ${failed.length} 项，单独重跑一遍：`)
|
||||
const done = await runPass(pass)
|
||||
if (lanes > 1 && repeat === 1 && done.some((r) => !r.passed)) {
|
||||
const failed = jobs.map((j) => done.find((r) => r.job === j)).filter((r) => !r.passed)
|
||||
console.log(`\n并行时没过的 ${failed.length} 份，单独重跑一遍：`)
|
||||
for (const first of failed) {
|
||||
const again = await runOne(first.name, pass, '.solo')
|
||||
const again = await runOne(first.job, pass, stacks[0], '.solo')
|
||||
spent += again.secs
|
||||
report(again)
|
||||
if (again.passed) flakyRerun.push({ first, again })
|
||||
got[got.indexOf(first)] = again
|
||||
done[done.indexOf(first)] = again
|
||||
}
|
||||
}
|
||||
results.push(...got)
|
||||
results.push(...byName(done))
|
||||
if (repeat > 1) console.log('')
|
||||
}
|
||||
|
||||
@@ -242,7 +563,7 @@ if (flakyRerun.length) {
|
||||
console.log('\n偶发（并行时没过、单独重跑通过）：')
|
||||
for (const { first } of flakyRerun) {
|
||||
const why = first.bad.length ? first.bad.slice(0, 3).join('；') : verdict(first)
|
||||
console.log(` check-${first.name}：${why}（见 ${first.file}）`)
|
||||
console.log(` ${label(first)}：${why}（见 ${first.file}）`)
|
||||
}
|
||||
}
|
||||
console.log('')
|
||||
@@ -252,10 +573,13 @@ console.log('')
|
||||
if (repeat > 1) {
|
||||
const seen = new Map() // `${name}\t${项名}` → [{ pass, line }]
|
||||
for (const r of results) {
|
||||
const lines = r.crashed || r.timedOut || r.empty ? [verdict(r)] : r.bad
|
||||
for (const line of lines) {
|
||||
const k = `${r.name}\t${line.replace(/ — .*$/, '')}`
|
||||
seen.set(k, [...(seen.get(k) ?? []), { pass: r.pass, line }])
|
||||
for (const p of r.parts ?? [r]) {
|
||||
const lines = p.crashed || p.timedOut || p.empty ? [`${p.part ? `〔${p.part}〕` : ''}${verdict(p)}`]
|
||||
: p.bad.map((l) => `${p.part ? `〔${p.part}〕` : ''}${l}`)
|
||||
for (const line of lines) {
|
||||
const k = `${r.name}\t${line.replace(/ — .*$/, '')}`
|
||||
seen.set(k, [...(seen.get(k) ?? []), { pass: r.pass, line }])
|
||||
}
|
||||
}
|
||||
}
|
||||
const flaky = [...seen].filter(([, hits]) => new Set(hits.map((h) => h.pass)).size < repeat)
|
||||
@@ -277,11 +601,14 @@ const failedRuns = results.filter((r) => !r.passed)
|
||||
const total = results.reduce((n, r) => n + r.ok, 0)
|
||||
const minutes = (secs) => `${Math.floor(secs / 60)} 分 ${String(secs % 60).padStart(2, '0')} 秒`
|
||||
const wall = Math.round((Date.now() - started) / 1000)
|
||||
const clock = lanes > 1 ? `用时 ${minutes(wall)}（各项累计 ${minutes(spent)}）` : `共 ${minutes(wall)}`
|
||||
const flakyNote = flakyRerun.length ? `，其中 ${flakyRerun.length} 项是重跑才过的，见上面「偶发」` : ''
|
||||
const clock = lanes > 1 ? `用时 ${minutes(wall)}（各份累计 ${minutes(spent)}）` : `共 ${minutes(wall)}`
|
||||
const flakyNote = flakyRerun.length ? `，其中 ${flakyRerun.length} 份是重跑才过的，见上面「偶发」` : ''
|
||||
if (failedRuns.length) {
|
||||
console.log(`✗ ${failedRuns.length}/${results.length} 次检查没通过（${[...new Set(failedRuns.map((r) => `check-${r.name}`))].join('、')}）· ${clock}`)
|
||||
} else {
|
||||
console.log(`✓ 全部通过：${results.length} 次检查、${total} 项${flakyNote} · ${clock}`)
|
||||
}
|
||||
|
||||
// 另起的几套先好好停（SIGTERM，等它们退），停不下来的由 cleanup 里的 SIGKILL 兜底
|
||||
await Promise.all(stacks.flatMap((s) => [s.vite?.stop?.(), s.backend?.stop?.()]))
|
||||
process.exit(failedRuns.length ? 1 : 0)
|
||||
|
||||
@@ -36,8 +36,10 @@ const API = process.env.AGENTLAB_API ?? 'http://localhost:8000/api'
|
||||
const CHROME = process.env.CHROME_PATH
|
||||
?? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
|
||||
|
||||
// FX_ONLY=九天,运行中点节点 只跑段名里含这些字的段（逗号分隔）
|
||||
// FX_ONLY=九天,运行中点节点 只跑段名里含这些字的段（逗号分隔）。FX_SKIP 反过来，跳过段名里含这些字的段：
|
||||
// check-all 把这个检查拆成几份分到不同的道上，最后一份用它兜住「其余全部」，以后新加的段不用改 check-all
|
||||
const ONLY = (process.env.FX_ONLY ?? '').split(',').filter(Boolean)
|
||||
const SKIP = (process.env.FX_SKIP ?? '').split(',').filter(Boolean)
|
||||
/**
|
||||
* 一节一节地跑：某一节里等待超时、元素找不到，只记成这一节失败，关掉它开的浏览器，
|
||||
* 接着跑下一节——不让一处卡住把后面几十项一起吞掉
|
||||
@@ -45,6 +47,7 @@ const ONLY = (process.env.FX_ONLY ?? '').split(',').filter(Boolean)
|
||||
const opened = new Set()
|
||||
async function section(name, fn) {
|
||||
if (ONLY.length && !ONLY.some((k) => name.includes(k))) return
|
||||
if (SKIP.some((k) => name.includes(k))) return
|
||||
console.log(`=== ${name} ===`)
|
||||
try {
|
||||
await fn()
|
||||
|
||||
@@ -35,9 +35,12 @@ const SHOTS = process.env.RUN_STATES_SHOTS ?? '/tmp/agentlab-run-states'
|
||||
// 截图的像素密度：要看清卡片里 11px 的字时设成 2
|
||||
const DSF = Number(process.env.RUN_STATES_DSF ?? 1) || 1
|
||||
mkdirSync(SHOTS, { recursive: true })
|
||||
// 只跑其中几段（逗号分隔：themes, interact, team, endings, replay, history, issues, exits, reduced），调样式时省时间
|
||||
// 只跑其中几段（逗号分隔：themes, interact, team, endings, replay, history, issues, exits, reduced），调样式时省时间。
|
||||
// RUN_STATES_SKIP 反过来，跳过这几段：check-all 把这个检查拆成几份分到不同的道上，最后一份用它
|
||||
// 兜住「其余全部」，以后新加的段不用改 check-all 也跑得到
|
||||
const ONLY = (process.env.RUN_STATES_ONLY ?? '').split(',').filter(Boolean)
|
||||
const want = (part) => !ONLY.length || ONLY.includes(part)
|
||||
const SKIP = (process.env.RUN_STATES_SKIP ?? '').split(',').filter(Boolean)
|
||||
const want = (part) => (!ONLY.length || ONLY.includes(part)) && !SKIP.includes(part)
|
||||
/**
|
||||
* 一段一段地跑：某一段里等待超时、元素找不到，只记成这一段失败，关掉它开的浏览器，
|
||||
* 接着跑下一段——不让一处卡住把后面几百项一起吞掉。段标题在各段自己里面打
|
||||
|
||||
@@ -166,7 +166,12 @@ await section('导航', '=== 导航 ===', async () => {
|
||||
|
||||
await page.goto(`${WEB}/settings/datasources`)
|
||||
check('旧地址 /settings/datasources 重定向到 /data', await page.waitForURL(/\/data(\/|$)/, { timeout: 8000 }).then(() => true, () => false), page.url())
|
||||
check('数据页点亮「数据」', (await nav(page).locator('a[aria-current="page"]').innerText()).startsWith('数据'))
|
||||
// 地址先变、导航后亮：RouterProvider 把路由状态放在 startTransition 里提交，history 却是当场
|
||||
// 改的，waitForURL 一返回就读，机器一挤读到的还是重定向前那一帧（「设置」亮着）。等它最多
|
||||
// 3 秒再判，真没点亮照样判错
|
||||
const lit = () => nav(page).locator('a[aria-current="page"]').innerText().catch(() => '')
|
||||
for (const end = Date.now() + 3000; !(await lit()).startsWith('数据') && Date.now() < end;) await page.waitForTimeout(100)
|
||||
check('数据页点亮「数据」', (await lit()).startsWith('数据'), await lit())
|
||||
|
||||
// 矮窗口：导航按高度收紧，最底下的遥测点和署名不能被切掉
|
||||
const bottomFits = () => page.evaluate(() => {
|
||||
|
||||
Reference in New Issue
Block a user