2994 lines
104 KiB
JavaScript
2994 lines
104 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* preview-workbench.mjs — 任意 DSH 客户端 bundle 的离线渲染 + 截图工具。
|
||
*
|
||
* 与 scripts/preview.mjs 的区别:那个脚本是「朝堂侧栏」专用、演示数据写死;
|
||
* 这个脚本接受任意 bundle 路径,用 vm 在伪 window 上加载真实 bundle,
|
||
* 打桩 fetch 数据,用会真正重渲染的 hooks 替身跑完异步 effect,
|
||
* 把组件树序列化成 HTML,最后交给本机 Chrome 截图。
|
||
*
|
||
* 用法:
|
||
* node scripts/preview-workbench.mjs --bundle=<path> --out=<dir> --name=<file> \
|
||
* --theme=light|dark --width=400
|
||
*/
|
||
|
||
import vm from 'node:vm'
|
||
import {
|
||
existsSync,
|
||
mkdirSync,
|
||
readFileSync,
|
||
statSync,
|
||
writeFileSync,
|
||
} from 'node:fs'
|
||
import { dirname, join, resolve } from 'node:path'
|
||
import { fileURLToPath, pathToFileURL } from 'node:url'
|
||
import { spawnSync } from 'node:child_process'
|
||
|
||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||
const ROOT = resolve(HERE, '..')
|
||
const SCRATCH = join(ROOT, '.scratch', 'preview-workbench')
|
||
const ROUTE_PREFIX = '/sansheng/workbench'
|
||
const LEAD_SESSION = 'sess-lead'
|
||
|
||
function unrefTimer(timer) {
|
||
if (timer && typeof timer.unref === 'function') timer.unref()
|
||
return timer
|
||
}
|
||
|
||
const CHROME_CANDIDATES = [
|
||
'C:/Program Files/Google/Chrome/Application/chrome.exe',
|
||
'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
|
||
'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe',
|
||
'C:/Program Files/Microsoft/Edge/Application/msedge.exe',
|
||
]
|
||
|
||
// #region 基础工具
|
||
|
||
function fail(message) {
|
||
const error = new Error(message)
|
||
error.previewFailure = true
|
||
throw error
|
||
}
|
||
|
||
function log(message) {
|
||
process.stdout.write(`[preview-workbench] ${message}\n`)
|
||
}
|
||
|
||
function ensureDir(path) {
|
||
mkdirSync(path, { recursive: true })
|
||
}
|
||
|
||
function parseArgs(argv) {
|
||
const options = {
|
||
bundle: 'workbench/panel/lib/client.js',
|
||
out: 'docs/preview',
|
||
name: 'v01-workbench-rail',
|
||
theme: 'light',
|
||
width: 400,
|
||
scale: 2,
|
||
chrome: null,
|
||
view: 'court',
|
||
open: '',
|
||
scenario: '',
|
||
live: false,
|
||
help: false,
|
||
}
|
||
const keys = {
|
||
bundle: 'bundle',
|
||
out: 'out',
|
||
name: 'name',
|
||
theme: 'theme',
|
||
width: 'width',
|
||
scale: 'scale',
|
||
chrome: 'chrome',
|
||
view: 'view',
|
||
open: 'open',
|
||
scenario: 'scenario',
|
||
}
|
||
for (let index = 0; index < argv.length; index += 1) {
|
||
const arg = argv[index]
|
||
if (arg === '--help' || arg === '-h') {
|
||
options.help = true
|
||
continue
|
||
}
|
||
if (!arg.startsWith('--')) fail(`无法识别的参数:${arg}`)
|
||
const body = arg.slice(2)
|
||
const eq = body.indexOf('=')
|
||
const rawKey = eq === -1 ? body : body.slice(0, eq)
|
||
if (rawKey === 'help') {
|
||
options.help = true
|
||
continue
|
||
}
|
||
if (rawKey === 'live') {
|
||
if (eq !== -1 && body.slice(eq + 1) === 'false') options.live = false
|
||
else options.live = true
|
||
continue
|
||
}
|
||
const field = keys[rawKey]
|
||
if (!field) fail(`无法识别的参数:--${rawKey}`)
|
||
let value
|
||
if (eq === -1) {
|
||
index += 1
|
||
value = argv[index]
|
||
if (value === undefined) fail(`参数 --${rawKey} 缺少值`)
|
||
} else {
|
||
value = body.slice(eq + 1)
|
||
}
|
||
options[field] = value
|
||
}
|
||
return options
|
||
}
|
||
|
||
function inferLiveScenario(name, view) {
|
||
if (/cancel/i.test(name)) return 'cancel'
|
||
if (/revise/i.test(name)) return 'revise'
|
||
if (/missing/i.test(name)) return 'missing'
|
||
if (view === 'tasks') return 'tasks'
|
||
if (view === 'artifacts') return 'revise'
|
||
return 'court'
|
||
}
|
||
|
||
function usage() {
|
||
return [
|
||
'用法:',
|
||
' node scripts/preview-workbench.mjs --bundle=<path> --out=<dir> --name=<file> \\',
|
||
' --theme=light|dark --width=400',
|
||
'',
|
||
'选项:',
|
||
' --bundle bundle 路径,默认 workbench/panel/lib/client.js',
|
||
' --out 截图输出目录,默认 docs/preview',
|
||
' --name 输出文件名前缀,默认 v01-workbench-rail',
|
||
' --theme light | dark,默认 light',
|
||
' --width 截图宽度(CSS px),默认 400',
|
||
' --scale 设备像素比,默认 2',
|
||
' --chrome Chrome/Edge 可执行文件路径,默认自动探测',
|
||
' --view court | tasks | artifacts,先切到该页签再截图,默认 court',
|
||
' --open 切到成果页后点开匹配这段文字的成果行(看详情抽屉)',
|
||
' --scenario live 场景:court | tasks | cancel | revise | missing(默认按 --name 推断)',
|
||
' --live 不打死数据:把 bundle 的 fetch 接到仓库内真实 Host 路由(内存账本)',
|
||
' --help 显示本帮助',
|
||
].join('\n')
|
||
}
|
||
|
||
function chromeRun(chrome, args, label) {
|
||
const result = spawnSync(chrome, args, {
|
||
encoding: 'utf8',
|
||
windowsHide: true,
|
||
maxBuffer: 128 * 1024 * 1024,
|
||
timeout: 180000,
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
})
|
||
if (result.error) fail(`${label} 调用 Chrome 失败:${result.error.message}`)
|
||
if (result.status !== 0) {
|
||
const stderr = String(result.stderr || '').trim().split(/\r?\n/).slice(-8).join('\n')
|
||
fail(`${label} 失败(Chrome 退出码 ${result.status})${stderr ? `:\n${stderr}` : ''}`)
|
||
}
|
||
return result
|
||
}
|
||
|
||
function findChrome(explicit) {
|
||
const candidates = explicit ? [explicit, ...CHROME_CANDIDATES] : CHROME_CANDIDATES
|
||
for (const candidate of candidates) {
|
||
try {
|
||
if (candidate && statSync(candidate).isFile()) return candidate
|
||
} catch (error) {
|
||
// 继续找下一个
|
||
}
|
||
}
|
||
fail(`找不到 Chrome/Edge。可用 --chrome=<path> 指定。尝试过:\n${candidates.join('\n')}`)
|
||
}
|
||
|
||
function readPngSize(pngPath) {
|
||
const bytes = readFileSync(pngPath)
|
||
if (bytes.length < 33) fail(`截图文件不完整:${pngPath}(${bytes.length} 字节)`)
|
||
if (bytes.subarray(0, 8).toString('hex') !== '89504e470d0a1a0a') {
|
||
fail(`截图不是合法 PNG:${pngPath}`)
|
||
}
|
||
return {
|
||
width: bytes.readUInt32BE(16),
|
||
height: bytes.readUInt32BE(20),
|
||
bytes: bytes.length,
|
||
}
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 固定演示数据(形状对齐 workbench/host/service.mjs)
|
||
|
||
const SEATS = [
|
||
{ roleId: 'lead', name: '丞相', short: '丞', tier: 'leaders', group: 'lead', column: 'span', row: 0, duty: '接需求、分流、协调、汇报', canDispatch: true },
|
||
{ roleId: 'zhongshu', name: '中书', short: '中', tier: 'leaders', group: 'sansheng', column: 'left', row: 1, duty: '调查、澄清、规划', canDispatch: false },
|
||
{ roleId: 'shangshu', name: '尚书', short: '尚', tier: 'leaders', group: 'sansheng', column: 'center', row: 1, duty: '分工建议、组织交付', canDispatch: true },
|
||
{ roleId: 'menxia', name: '门下', short: '门', tier: 'leaders', group: 'sansheng', column: 'right', row: 1, duty: '审议与整体审核', canDispatch: false },
|
||
{ roleId: 'libu', name: '吏部', short: '吏', tier: 'ministries', group: 'ministries', column: 'left', row: 2, duty: '角色和技能配置建议', canDispatch: false },
|
||
{ roleId: 'hubu', name: '户部', short: '户', tier: 'ministries', group: 'ministries', column: 'center', row: 2, duty: '数据、表格、计算', canDispatch: false },
|
||
{ roleId: 'lipu', name: '礼部', short: '礼', tier: 'ministries', group: 'ministries', column: 'right', row: 2, duty: '文档、内容、呈现', canDispatch: false },
|
||
{ roleId: 'bingbu', name: '兵部', short: '兵', tier: 'ministries', group: 'ministries', column: 'left', row: 3, duty: '环境、调试、部署', canDispatch: false },
|
||
{ roleId: 'xingbu', name: '刑部', short: '刑', tier: 'ministries', group: 'ministries', column: 'center', row: 3, duty: '测试与风险检查', canDispatch: false },
|
||
{ roleId: 'gongbu', name: '工部', short: '工', tier: 'ministries', group: 'ministries', column: 'right', row: 3, duty: '代码实现与工程产出', canDispatch: false },
|
||
]
|
||
|
||
const TASKS = [
|
||
{
|
||
id: 'task_demo_running',
|
||
projectId: 'prj_demo1',
|
||
title: '生成离线预览截图',
|
||
objective: '在 400px 窄栏下渲染工作台并输出 light / dark 两张截图。',
|
||
acceptance: ['两张 PNG 宽度为 800px(2x)', '不修改被预览的 bundle'],
|
||
constraints: ['只写 .scratch 与 docs/preview'],
|
||
scope: 'preview',
|
||
ownerRoleId: 'gongbu',
|
||
sourceRoleId: 'shangshu',
|
||
originMessageRef: 'msg_demo_1',
|
||
returnTarget: 'shangshu',
|
||
status: 'running',
|
||
activeAttemptId: 'attempt_demo_running',
|
||
attempts: [
|
||
{
|
||
id: 'attempt_demo_running',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_running',
|
||
state: 'running',
|
||
startedAt: '2026-11-09T22:10:00.000Z',
|
||
endedAt: null,
|
||
},
|
||
],
|
||
startedAt: '2026-11-09T22:10:00.000Z',
|
||
endedAt: null,
|
||
reportReceivedAt: null,
|
||
needsAttentionReason: null,
|
||
failureReason: null,
|
||
waitingReason: null,
|
||
revision: 3,
|
||
createdAt: '2026-11-09T22:09:00.000Z',
|
||
updatedAt: '2026-11-09T22:12:00.000Z',
|
||
open: true,
|
||
attemptCount: 1,
|
||
resultCount: 0,
|
||
},
|
||
{
|
||
id: 'task_demo_attention',
|
||
projectId: 'prj_demo1',
|
||
title: '复核 2x 截图的验收口径',
|
||
objective: '确认 800px 宽的 PNG 是否满足交付要求,并记录结论。',
|
||
acceptance: ['给出明确的接受 / 不接受结论'],
|
||
constraints: ['不重启 DSH'],
|
||
scope: 'review',
|
||
ownerRoleId: 'xingbu',
|
||
sourceRoleId: 'lead',
|
||
originMessageRef: 'msg_demo_2',
|
||
returnTarget: 'lead',
|
||
status: 'needs_attention',
|
||
activeAttemptId: null,
|
||
attempts: [],
|
||
startedAt: '2026-11-09T22:05:00.000Z',
|
||
endedAt: null,
|
||
reportReceivedAt: null,
|
||
needsAttentionReason: '验收标准需要人工确认:是否接受 2x 设备像素比截图?',
|
||
failureReason: null,
|
||
waitingReason: null,
|
||
revision: 2,
|
||
createdAt: '2026-11-09T22:04:00.000Z',
|
||
updatedAt: '2026-11-09T22:14:00.000Z',
|
||
open: true,
|
||
attemptCount: 0,
|
||
resultCount: 0,
|
||
},
|
||
{
|
||
id: 'task_demo_revision',
|
||
projectId: 'prj_demo1',
|
||
title: '修订:离线预览截图',
|
||
kind: 'revision',
|
||
objective: '按验收意见重拍 light 页并补一张成果详情。',
|
||
acceptance: ['修订后的截图进入成果账本'],
|
||
constraints: ['不重启 DSH'],
|
||
scope: 'preview',
|
||
ownerRoleId: 'gongbu',
|
||
sourceRoleId: 'xingbu',
|
||
originMessageRef: 'msg_demo_4',
|
||
returnTarget: 'xingbu',
|
||
status: 'queued',
|
||
activeAttemptId: null,
|
||
attempts: [],
|
||
startedAt: null,
|
||
endedAt: null,
|
||
reportReceivedAt: null,
|
||
needsAttentionReason: null,
|
||
failureReason: null,
|
||
waitingReason: null,
|
||
revision: 1,
|
||
createdAt: '2026-11-09T22:15:00.000Z',
|
||
updatedAt: '2026-11-09T22:16:00.000Z',
|
||
open: true,
|
||
attemptCount: 0,
|
||
resultCount: 0,
|
||
},
|
||
{
|
||
id: 'task_demo_done',
|
||
projectId: 'prj_demo1',
|
||
title: '核对十席角色文案',
|
||
objective: '按 roles.mjs 校对十席名称、简写和职责。',
|
||
acceptance: ['十席全部一致'],
|
||
constraints: [],
|
||
scope: 'copy',
|
||
ownerRoleId: 'hubu',
|
||
sourceRoleId: 'zhongshu',
|
||
originMessageRef: 'msg_demo_3',
|
||
returnTarget: 'zhongshu',
|
||
status: 'completed',
|
||
activeAttemptId: null,
|
||
attempts: [
|
||
{
|
||
id: 'attempt_demo_done',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_done',
|
||
state: 'completed',
|
||
startedAt: '2026-11-09T21:40:00.000Z',
|
||
endedAt: '2026-11-09T21:52:00.000Z',
|
||
},
|
||
],
|
||
startedAt: '2026-11-09T21:40:00.000Z',
|
||
endedAt: '2026-11-09T21:52:00.000Z',
|
||
reportReceivedAt: '2026-11-09T21:52:30.000Z',
|
||
needsAttentionReason: null,
|
||
failureReason: null,
|
||
waitingReason: null,
|
||
revision: 5,
|
||
createdAt: '2026-11-09T21:39:00.000Z',
|
||
updatedAt: '2026-11-09T21:53:00.000Z',
|
||
open: false,
|
||
attemptCount: 1,
|
||
resultCount: 1,
|
||
},
|
||
]
|
||
|
||
const ARTIFACTS = [
|
||
{
|
||
id: 'artifact_demo_light',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_running',
|
||
ownerRoleId: 'gongbu',
|
||
fileRef: '.scratch/preview-workbench/v01-workbench-rail-400-light.png',
|
||
displayName: 'v01-workbench-rail-400-light.png',
|
||
mediaType: 'image/png',
|
||
versionOrHash: 'sha256:preview-demo-light',
|
||
verification: { status: 'verified' },
|
||
sourceResultId: null,
|
||
createdAt: '2026-11-09T22:11:00.000Z',
|
||
updatedAt: '2026-11-09T22:11:00.000Z',
|
||
},
|
||
{
|
||
id: 'artifact_demo_report',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_attention',
|
||
ownerRoleId: 'xingbu',
|
||
fileRef: 'docs/preview/巡检报告.md',
|
||
displayName: '巡检报告.md',
|
||
mediaType: 'text/markdown',
|
||
versionOrHash: 'sha256:preview-demo-report',
|
||
verification: { status: 'pending' },
|
||
sourceResultId: null,
|
||
createdAt: '2026-11-09T22:13:00.000Z',
|
||
updatedAt: '2026-11-09T22:13:00.000Z',
|
||
},
|
||
{
|
||
id: 'artifact_demo_missing',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_attention',
|
||
ownerRoleId: 'xingbu',
|
||
fileRef: '.scratch/preview-workbench/缺失的验收单.pdf',
|
||
displayName: '缺失的验收单.pdf',
|
||
mediaType: 'application/pdf',
|
||
versionOrHash: 'sha256:preview-demo-missing',
|
||
verification: { status: 'missing' },
|
||
existence: 'missing',
|
||
revision: 1,
|
||
sourceResultId: null,
|
||
createdAt: '2026-11-09T22:13:20.000Z',
|
||
updatedAt: '2026-11-09T22:13:20.000Z',
|
||
},
|
||
{
|
||
id: 'artifact_demo_unknown',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_running',
|
||
ownerRoleId: 'gongbu',
|
||
fileRef: '.scratch/preview-workbench/待核验的交付物.zip',
|
||
displayName: '待核验的交付物.zip',
|
||
mediaType: 'application/zip',
|
||
versionOrHash: 'sha256:preview-demo-unknown',
|
||
verification: { status: 'unknown' },
|
||
existence: 'unknown',
|
||
revision: 1,
|
||
sourceResultId: null,
|
||
createdAt: '2026-11-09T22:13:40.000Z',
|
||
updatedAt: '2026-11-09T22:13:40.000Z',
|
||
},
|
||
{
|
||
id: 'artifact_demo_revision',
|
||
projectId: 'prj_demo1',
|
||
taskId: 'task_demo_revision',
|
||
ownerRoleId: 'gongbu',
|
||
fileRef: 'docs/preview/v01-workbench-rail-400-light.png',
|
||
displayName: '预览截图(第 2 版).png',
|
||
mediaType: 'image/png',
|
||
versionOrHash: 'sha256:preview-demo-revision-2',
|
||
verification: { status: 'verified' },
|
||
existence: 'present',
|
||
revision: 2,
|
||
revisesArtifactId: 'artifact_demo_light',
|
||
sourceResultId: null,
|
||
createdAt: '2026-11-09T22:16:10.000Z',
|
||
updatedAt: '2026-11-09T22:16:10.000Z',
|
||
},
|
||
]
|
||
|
||
const PROJECT = {
|
||
id: 'prj_demo1',
|
||
hostWorkspaceId: 'ws_demo',
|
||
displayNameCache: '演示项目',
|
||
canonicalRoot: 'C:\\demo',
|
||
status: 'active',
|
||
schemaVersion: 1,
|
||
revision: 4,
|
||
createdAt: '2026-11-09T20:00:00.000Z',
|
||
updatedAt: '2026-11-09T22:14:00.000Z',
|
||
}
|
||
|
||
function buildSeats() {
|
||
const states = {
|
||
lead: 'idle',
|
||
gongbu: 'running',
|
||
xingbu: 'needs_attention',
|
||
}
|
||
return SEATS.map((seat) => {
|
||
const status = states[seat.roleId] || 'uninitialized'
|
||
const connected = status !== 'uninitialized'
|
||
const sessionId = connected ? `sess_${seat.roleId}` : null
|
||
const activeTask = TASKS.find(
|
||
(task) => task.ownerRoleId === seat.roleId && task.open,
|
||
)
|
||
return {
|
||
roleId: seat.roleId,
|
||
name: seat.name,
|
||
short: seat.short,
|
||
tier: seat.tier,
|
||
group: seat.group,
|
||
column: seat.column,
|
||
row: seat.row,
|
||
duty: seat.duty,
|
||
canDispatch: seat.canDispatch,
|
||
connected,
|
||
pending: !connected,
|
||
pendingLabel: connected ? null : '尚未接通',
|
||
activeTaskId: activeTask ? activeTask.id : null,
|
||
binding: connected
|
||
? {
|
||
id: `binding_${seat.roleId}`,
|
||
currentSessionId: sessionId,
|
||
bindingGeneration: 1,
|
||
status,
|
||
historyCount: 0,
|
||
revision: 1,
|
||
}
|
||
: null,
|
||
config: {
|
||
provider: 'magpie',
|
||
model: 'workbuddy/deepseek-v4.1-flash',
|
||
reasoningEffort: 'high',
|
||
configRevision: 3,
|
||
configured: true,
|
||
},
|
||
session: {
|
||
running: seat.roleId === 'gongbu',
|
||
available: true,
|
||
},
|
||
}
|
||
})
|
||
}
|
||
|
||
function buildBootstrap() {
|
||
const seats = buildSeats()
|
||
return {
|
||
projects: [
|
||
{
|
||
...PROJECT,
|
||
seatCount: SEATS.length,
|
||
taskCount: TASKS.length,
|
||
openTaskCount: TASKS.filter((task) => task.open).length,
|
||
},
|
||
],
|
||
projectId: PROJECT.id,
|
||
project: { ...PROJECT },
|
||
seats,
|
||
layout: {
|
||
lead: ['lead'],
|
||
chancellery: ['zhongshu', 'shangshu', 'menxia'],
|
||
sansheng: ['zhongshu', 'shangshu', 'menxia'],
|
||
ministries: [
|
||
['libu', 'hubu', 'lipu'],
|
||
['bingbu', 'xingbu', 'gongbu'],
|
||
],
|
||
},
|
||
tasks: TASKS,
|
||
artifacts: ARTIFACTS,
|
||
results: [],
|
||
eventSeq: 42,
|
||
}
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 伪浏览器环境 + fetch 打桩
|
||
|
||
function createDemoStorage() {
|
||
const store = new Map([
|
||
[
|
||
'sansheng-liubu.route.gongbu',
|
||
JSON.stringify({ provider: 'deepseek', model: 'deepseek-v4', reasoningEffort: 'high' }),
|
||
],
|
||
])
|
||
return {
|
||
getItem: (key) => (store.has(key) ? store.get(key) : null),
|
||
setItem: (key, value) => { store.set(key, String(value)) },
|
||
removeItem: (key) => { store.delete(key) },
|
||
clear: () => { store.clear() },
|
||
key: () => null,
|
||
get length() { return store.size },
|
||
}
|
||
}
|
||
|
||
function routePath(input) {
|
||
const raw = typeof input === 'string'
|
||
? input
|
||
: input && typeof input.url === 'string'
|
||
? input.url
|
||
: String(input)
|
||
try {
|
||
return new URL(raw, 'http://preview.local').pathname
|
||
} catch (error) {
|
||
return raw.split('?')[0]
|
||
}
|
||
}
|
||
|
||
function makeResponse(status, payload) {
|
||
const text = JSON.stringify(payload)
|
||
return {
|
||
ok: status >= 200 && status < 300,
|
||
status,
|
||
statusText: status === 200 ? 'OK' : 'Error',
|
||
headers: { get: (name) => (String(name).toLowerCase() === 'content-type' ? 'application/json' : null) },
|
||
json: async () => JSON.parse(text),
|
||
text: async () => text,
|
||
clone() { return makeResponse(status, payload) },
|
||
}
|
||
}
|
||
|
||
function createFetchStub(theme, onUnknown) {
|
||
const unknown = new Set()
|
||
const routes = new Map([
|
||
[`${ROUTE_PREFIX}/bootstrap`, () => buildBootstrap()],
|
||
[`${ROUTE_PREFIX}/events`, () => ({ events: [], reset: false, seq: 42, hasMore: false })],
|
||
[`${ROUTE_PREFIX}/projects`, () => buildBootstrap().projects],
|
||
[`${ROUTE_PREFIX}/seats`, () => buildSeats()],
|
||
[`${ROUTE_PREFIX}/layout`, () => buildBootstrap().layout],
|
||
[`${ROUTE_PREFIX}/tasks`, () => TASKS],
|
||
[`${ROUTE_PREFIX}/artifacts`, () => ARTIFACTS],
|
||
[`${ROUTE_PREFIX}/results`, () => []],
|
||
])
|
||
return async function fetchStub(input, init) {
|
||
const path = routePath(input)
|
||
const method = String((init && init.method) || (input && input.method) || 'GET').toUpperCase()
|
||
const factory = routes.get(path)
|
||
if (factory) return makeResponse(200, { ok: true, value: factory() })
|
||
if (!unknown.has(path)) {
|
||
unknown.add(path)
|
||
if (typeof onUnknown === 'function') onUnknown(path, method)
|
||
}
|
||
// 未知路由不抛错:尽量让面板继续渲染,而不是整页空白。
|
||
const fallback = path.endsWith('s') ? [] : {}
|
||
return makeResponse(200, { ok: true, value: fallback, previewStub: true })
|
||
}
|
||
}
|
||
|
||
function createBrowserEnv({ theme, fetchStub }) {
|
||
const styleTexts = []
|
||
const listeners = new Map()
|
||
|
||
const document = {
|
||
getElementById: () => null,
|
||
querySelector: () => null,
|
||
querySelectorAll: () => [],
|
||
createElement(tagName) {
|
||
return {
|
||
tagName: String(tagName).toUpperCase(),
|
||
dataset: {},
|
||
style: {},
|
||
classList: { add() {}, remove() {}, toggle() {}, contains: () => false },
|
||
textContent: '',
|
||
innerHTML: '',
|
||
setAttribute() {},
|
||
removeAttribute() {},
|
||
appendChild() {},
|
||
remove() {},
|
||
addEventListener() {},
|
||
removeEventListener() {},
|
||
getBoundingClientRect: () => ({ width: 0, height: 0, top: 0, left: 0 }),
|
||
}
|
||
},
|
||
createTextNode(text) {
|
||
return { textContent: String(text) }
|
||
},
|
||
head: {
|
||
appendChild(node) {
|
||
if (node && typeof node.textContent === 'string' && node.textContent.trim() !== '') {
|
||
styleTexts.push(node.textContent)
|
||
}
|
||
},
|
||
},
|
||
body: {
|
||
appendChild() {},
|
||
removeChild() {},
|
||
},
|
||
documentElement: {
|
||
dataset: {},
|
||
style: {},
|
||
classList: { add() {}, remove() {}, toggle() {}, contains: () => false },
|
||
setAttribute() {},
|
||
getAttribute: () => null,
|
||
},
|
||
addEventListener(type, handler) {
|
||
const list = listeners.get(type) || []
|
||
list.push(handler)
|
||
listeners.set(type, list)
|
||
},
|
||
removeEventListener() {},
|
||
visibilityState: 'visible',
|
||
hidden: false,
|
||
cookie: '',
|
||
}
|
||
|
||
const window = {
|
||
document,
|
||
location: { href: 'http://preview.local/', pathname: '/', origin: 'http://preview.local', search: '' },
|
||
navigator: { userAgent: 'preview-workbench', language: 'zh-CN', languages: ['zh-CN'], platform: 'Win32' },
|
||
localStorage: createDemoStorage(),
|
||
sessionStorage: createDemoStorage(),
|
||
devicePixelRatio: 2,
|
||
innerWidth: 400,
|
||
innerHeight: 800,
|
||
matchMedia(query) {
|
||
const wantsDark = theme === 'dark' && /prefers-color-scheme\s*:\s*dark/i.test(String(query))
|
||
return {
|
||
matches: wantsDark,
|
||
media: String(query),
|
||
addEventListener() {},
|
||
removeEventListener() {},
|
||
addListener() {},
|
||
removeListener() {},
|
||
onchange: null,
|
||
}
|
||
},
|
||
getComputedStyle: () => ({ getPropertyValue: () => '' }),
|
||
// bundle 里有事件轮询(setTimeout 链 / setInterval)。这些计时器若保持
|
||
// ref 状态,截图跑完后 Node 永远不会退出。unref 掉:只要主流程结束,
|
||
// 进程就能正常收尾,同时轮询在存活期间照常执行。
|
||
requestAnimationFrame: (callback) => unrefTimer(setTimeout(() => callback(Date.now()), 0)),
|
||
cancelAnimationFrame: (handle) => clearTimeout(handle),
|
||
addEventListener(type, handler) {
|
||
const list = listeners.get(type) || []
|
||
list.push(handler)
|
||
listeners.set(type, list)
|
||
},
|
||
removeEventListener() {},
|
||
fetch: fetchStub,
|
||
alert() {},
|
||
focus() {},
|
||
scrollTo() {},
|
||
}
|
||
|
||
class ResizeObserver {
|
||
observe() {}
|
||
unobserve() {}
|
||
disconnect() {}
|
||
}
|
||
class IntersectionObserver {
|
||
constructor(callback) { this.callback = callback }
|
||
observe() {}
|
||
unobserve() {}
|
||
disconnect() {}
|
||
}
|
||
class MutationObserver {
|
||
observe() {}
|
||
disconnect() {}
|
||
}
|
||
|
||
return { document, window, styleTexts, ResizeObserver, IntersectionObserver, MutationObserver }
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 加载 bundle + React / hooks 替身
|
||
|
||
function createHooks() {
|
||
const slotMap = new Map()
|
||
const instanceMap = new Map()
|
||
const contextStack = []
|
||
const keyStack = []
|
||
const cursorStack = []
|
||
let currentKey = null
|
||
let cursor = 0
|
||
let dirty = false
|
||
let effectQueue = []
|
||
let idCounter = 0
|
||
|
||
const markDirty = () => { dirty = true }
|
||
|
||
const depsEqual = (a, b) => {
|
||
if (a === undefined) return false
|
||
if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false
|
||
return a.every((value, index) => Object.is(value, b[index]))
|
||
}
|
||
|
||
const rootKey = '<root>'
|
||
const slotsFor = (key) => {
|
||
let slots = slotMap.get(key)
|
||
if (!slots) {
|
||
slots = []
|
||
slotMap.set(key, slots)
|
||
}
|
||
return slots
|
||
}
|
||
const useSlot = () => {
|
||
const key = currentKey === null ? rootKey : currentKey
|
||
const slots = slotsFor(key)
|
||
const index = cursor
|
||
cursor += 1
|
||
if (!slots[index]) slots[index] = {}
|
||
return slots[index]
|
||
}
|
||
|
||
class Component {
|
||
constructor(props) {
|
||
this.props = props || {}
|
||
this.state = {}
|
||
this.context = undefined
|
||
}
|
||
setState(partial) {
|
||
const next = typeof partial === 'function' ? partial(this.state) : partial
|
||
this.state = { ...this.state, ...(next || {}) }
|
||
markDirty()
|
||
}
|
||
forceUpdate() { markDirty() }
|
||
}
|
||
Component.prototype.isReactComponent = {}
|
||
|
||
function createElement(type, config, ...children) {
|
||
const props = { ...(config || {}) }
|
||
if (children.length === 1) props.children = children[0]
|
||
else if (children.length > 1) props.children = children
|
||
return { type, props, children }
|
||
}
|
||
|
||
function createContext(defaultValue) {
|
||
const context = {
|
||
_defaultValue: defaultValue,
|
||
_stack: [],
|
||
}
|
||
context.Provider = function ContextProvider(props) {
|
||
return props.children
|
||
}
|
||
context.Provider.__previewContext = context
|
||
context.Consumer = function ContextConsumer(props) {
|
||
const value = context._stack.length > 0
|
||
? context._stack[context._stack.length - 1]
|
||
: context._defaultValue
|
||
return typeof props.children === 'function' ? props.children(value) : null
|
||
}
|
||
context.Consumer.__previewContext = context
|
||
return context
|
||
}
|
||
|
||
const React = {
|
||
createElement,
|
||
cloneElement: (element, extraProps, ...children) => {
|
||
const props = { ...(element.props || {}), ...(extraProps || {}) }
|
||
if (children.length === 1) props.children = children[0]
|
||
else if (children.length > 1) props.children = children
|
||
return { type: element.type, props, children }
|
||
},
|
||
isValidElement: (value) => Boolean(value && typeof value === 'object' && value.type !== undefined),
|
||
createContext,
|
||
Component,
|
||
PureComponent: Component,
|
||
Fragment: 'fragment',
|
||
StrictMode: 'fragment',
|
||
Suspense: function Suspense(props) { return props.children },
|
||
memo: (component) => component,
|
||
forwardRef: (render) => function ForwardRefComponent(props) {
|
||
return render(props, props && props.ref ? props.ref : { current: null })
|
||
},
|
||
useContext(context) {
|
||
if (!context || !Array.isArray(context._stack)) return undefined
|
||
return context._stack.length > 0
|
||
? context._stack[context._stack.length - 1]
|
||
: context._defaultValue
|
||
},
|
||
useState(initial) {
|
||
const slot = useSlot()
|
||
if (!('value' in slot)) {
|
||
slot.value = typeof initial === 'function' ? initial() : initial
|
||
}
|
||
const setState = (next) => {
|
||
const value = typeof next === 'function' ? next(slot.value) : next
|
||
if (Object.is(value, slot.value)) return
|
||
slot.value = value
|
||
markDirty()
|
||
}
|
||
return [slot.value, setState]
|
||
},
|
||
useReducer(reducer, initialArg, init) {
|
||
const slot = useSlot()
|
||
if (!('value' in slot)) {
|
||
slot.value = typeof init === 'function' ? init(initialArg) : initialArg
|
||
}
|
||
const dispatch = (action) => {
|
||
const value = reducer(slot.value, action)
|
||
if (Object.is(value, slot.value)) return
|
||
slot.value = value
|
||
markDirty()
|
||
}
|
||
return [slot.value, dispatch]
|
||
},
|
||
useRef(initial) {
|
||
const slot = useSlot()
|
||
if (!('ref' in slot)) slot.ref = { current: initial }
|
||
return slot.ref
|
||
},
|
||
useEffect(effect, deps) {
|
||
const slot = useSlot()
|
||
if (!depsEqual(slot.deps, deps)) {
|
||
slot.deps = deps ? deps.slice() : undefined
|
||
const previousCleanup = slot.cleanup
|
||
effectQueue.push(() => {
|
||
if (typeof previousCleanup === 'function') previousCleanup()
|
||
const cleanup = effect()
|
||
slot.cleanup = typeof cleanup === 'function' ? cleanup : undefined
|
||
})
|
||
}
|
||
},
|
||
useLayoutEffect(effect, deps) {
|
||
React.useEffect(effect, deps)
|
||
},
|
||
useInsertionEffect(effect, deps) {
|
||
React.useEffect(effect, deps)
|
||
},
|
||
useMemo(factory, deps) {
|
||
const slot = useSlot()
|
||
if (!depsEqual(slot.deps, deps)) {
|
||
slot.deps = deps ? deps.slice() : undefined
|
||
slot.value = factory()
|
||
}
|
||
return slot.value
|
||
},
|
||
useCallback(fn, deps) {
|
||
const slot = useSlot()
|
||
if (!depsEqual(slot.deps, deps)) {
|
||
slot.deps = deps ? deps.slice() : undefined
|
||
slot.value = fn
|
||
}
|
||
return slot.value
|
||
},
|
||
useImperativeHandle(ref, create, deps) {
|
||
const slot = useSlot()
|
||
if (!depsEqual(slot.deps, deps)) {
|
||
slot.deps = deps ? deps.slice() : undefined
|
||
const value = create()
|
||
if (ref && typeof ref === 'object') ref.current = value
|
||
else if (typeof ref === 'function') ref(value)
|
||
}
|
||
},
|
||
useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
|
||
const slot = useSlot()
|
||
if (!slot.subscribed) {
|
||
slot.subscribed = true
|
||
try {
|
||
slot.value = getSnapshot()
|
||
} catch (error) {
|
||
slot.value = typeof getServerSnapshot === 'function' ? getServerSnapshot() : undefined
|
||
}
|
||
if (typeof subscribe === 'function') {
|
||
try {
|
||
const unsubscribe = subscribe(() => {
|
||
let next
|
||
try {
|
||
next = getSnapshot()
|
||
} catch (error) {
|
||
return
|
||
}
|
||
if (!Object.is(next, slot.value)) {
|
||
slot.value = next
|
||
markDirty()
|
||
}
|
||
})
|
||
if (typeof unsubscribe === 'function') slot.unsubscribe = unsubscribe
|
||
} catch (error) {
|
||
// 预览里订阅失败不阻断渲染
|
||
}
|
||
}
|
||
}
|
||
return slot.value
|
||
},
|
||
useId() {
|
||
idCounter += 1
|
||
return `:pv${idCounter}:`
|
||
},
|
||
useDebugValue() {},
|
||
useTransition() { return [false, (callback) => { callback() }] },
|
||
useDeferredValue(value) { return value },
|
||
}
|
||
|
||
return {
|
||
React,
|
||
enter(key) {
|
||
keyStack.push(currentKey)
|
||
cursorStack.push(cursor)
|
||
currentKey = key
|
||
cursor = 0
|
||
},
|
||
leave() {
|
||
currentKey = keyStack.length > 0 ? keyStack.pop() : null
|
||
cursor = cursorStack.length > 0 ? cursorStack.pop() : 0
|
||
},
|
||
beginRender() {
|
||
cursor = 0
|
||
effectQueue = []
|
||
},
|
||
runEffects() {
|
||
const queue = effectQueue
|
||
effectQueue = []
|
||
for (const effect of queue) effect()
|
||
return queue.length
|
||
},
|
||
consumeDirty() {
|
||
const value = dirty
|
||
dirty = false
|
||
return value
|
||
},
|
||
instanceMap,
|
||
}
|
||
}
|
||
|
||
function loadBundle(sourcePath, hooks, options) {
|
||
if (!existsSync(sourcePath)) fail(`找不到 bundle:${sourcePath}`)
|
||
const source = readFileSync(sourcePath, 'utf8').replace(/^\uFEFF/, '')
|
||
if (!source.includes('__ModuleLoader__')) {
|
||
fail(`${sourcePath} 看起来不是 DSH 客户端 bundle(未找到 __ModuleLoader__)。`)
|
||
}
|
||
|
||
const { React } = hooks
|
||
const env = createBrowserEnv({
|
||
theme: options.theme,
|
||
fetchStub: options.fetchStub || createFetchStub(options.theme, (path, method) => {
|
||
log(`fetch 未命中固定数据:${method} ${path}(返回空对象/数组占位)`)
|
||
}),
|
||
})
|
||
const { document, window, styleTexts } = env
|
||
let loaded = null
|
||
|
||
window.__ModuleLoader__ = {
|
||
load(registration) {
|
||
loaded = registration
|
||
const module = { exports: {} }
|
||
const requireStub = (name) => {
|
||
if (name === 'react') return React
|
||
throw new Error(`预览加载器不认识的模块:${name}(只支持 react)`)
|
||
}
|
||
const exported = registration.factory(requireStub)
|
||
if (exported !== undefined) module.exports = exported
|
||
loaded.exports = module.exports
|
||
},
|
||
}
|
||
|
||
const sandbox = {
|
||
window,
|
||
document,
|
||
console,
|
||
URL,
|
||
URLSearchParams,
|
||
Map,
|
||
Set,
|
||
WeakMap,
|
||
WeakSet,
|
||
Promise,
|
||
Symbol,
|
||
Proxy,
|
||
Reflect,
|
||
Date,
|
||
Math,
|
||
JSON,
|
||
Number,
|
||
String,
|
||
Boolean,
|
||
Array,
|
||
Object,
|
||
Error,
|
||
TypeError,
|
||
RangeError,
|
||
RegExp,
|
||
Intl,
|
||
TextEncoder,
|
||
TextDecoder,
|
||
setTimeout: (callback, delay, ...args) => unrefTimer(setTimeout(callback, delay, ...args)),
|
||
clearTimeout,
|
||
setInterval: (callback, delay, ...args) => unrefTimer(setInterval(callback, delay, ...args)),
|
||
clearInterval,
|
||
setImmediate,
|
||
clearImmediate,
|
||
queueMicrotask,
|
||
structuredClone,
|
||
fetch: window.fetch,
|
||
localStorage: window.localStorage,
|
||
sessionStorage: window.sessionStorage,
|
||
matchMedia: window.matchMedia,
|
||
requestAnimationFrame: window.requestAnimationFrame,
|
||
cancelAnimationFrame: window.cancelAnimationFrame,
|
||
getComputedStyle: window.getComputedStyle,
|
||
ResizeObserver: env.ResizeObserver,
|
||
IntersectionObserver: env.IntersectionObserver,
|
||
MutationObserver: env.MutationObserver,
|
||
devicePixelRatio: window.devicePixelRatio,
|
||
innerWidth: window.innerWidth,
|
||
innerHeight: window.innerHeight,
|
||
navigator: window.navigator,
|
||
location: window.location,
|
||
addEventListener: window.addEventListener,
|
||
removeEventListener: window.removeEventListener,
|
||
}
|
||
sandbox.globalThis = sandbox
|
||
sandbox.self = sandbox
|
||
|
||
try {
|
||
vm.runInNewContext(source, sandbox, { filename: sourcePath, timeout: 30000 })
|
||
} catch (error) {
|
||
fail(`加载 bundle 失败(${sourcePath}):\n${error && error.stack ? error.stack : error}`)
|
||
}
|
||
if (!loaded || !loaded.exports) fail(`bundle 没有调用 __ModuleLoader__.load:${sourcePath}`)
|
||
|
||
// 保留 bundle 自己注册样式的插入顺序(后面的覆盖前面的),只做去重,
|
||
// 避免按长度排序改变级联顺序、把主题变量覆盖错。
|
||
const seen = new Set()
|
||
const cssParts = []
|
||
for (const text of styleTexts) {
|
||
if (!text || text.trim() === '' || seen.has(text)) continue
|
||
seen.add(text)
|
||
cssParts.push(text)
|
||
}
|
||
const css = cssParts.join('\n')
|
||
|
||
return {
|
||
exports: loaded.exports,
|
||
css,
|
||
sourcePath,
|
||
document,
|
||
window,
|
||
styleTexts,
|
||
}
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region vnode → HTML
|
||
|
||
const VOID_TAGS = new Set([
|
||
'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
|
||
'link', 'meta', 'param', 'source', 'track', 'wbr',
|
||
])
|
||
|
||
const ATTR_ALIASES = {
|
||
className: 'class',
|
||
htmlFor: 'for',
|
||
tabIndex: 'tabindex',
|
||
colSpan: 'colspan',
|
||
rowSpan: 'rowspan',
|
||
maxLength: 'maxlength',
|
||
minLength: 'minlength',
|
||
readOnly: 'readonly',
|
||
autoFocus: 'autofocus',
|
||
autoComplete: 'autocomplete',
|
||
viewBox: 'viewBox',
|
||
preserveAspectRatio: 'preserveAspectRatio',
|
||
strokeWidth: 'stroke-width',
|
||
strokeLinecap: 'stroke-linecap',
|
||
strokeLinejoin: 'stroke-linejoin',
|
||
strokeDasharray: 'stroke-dasharray',
|
||
fillRule: 'fill-rule',
|
||
clipRule: 'clip-rule',
|
||
xmlnsXlink: 'xmlns:xlink',
|
||
}
|
||
|
||
const BOOLEAN_ATTRS = new Set([
|
||
'disabled', 'checked', 'selected', 'hidden', 'readonly', 'required',
|
||
'multiple', 'open', 'autofocus', 'novalidate', 'formnovalidate',
|
||
])
|
||
|
||
function escapeText(value) {
|
||
return String(value)
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
}
|
||
|
||
function escapeAttr(value) {
|
||
return String(value)
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
.replace(/"/g, '"')
|
||
}
|
||
|
||
function kebabStyleName(name) {
|
||
if (name.startsWith('--')) return name
|
||
if (name === 'msTransform') return '-ms-transform'
|
||
const prefixed = name.replace(/^(Webkit|Moz|O)(?=[A-Z])/, (match) => `-${match.toLowerCase()}`)
|
||
return prefixed.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)
|
||
}
|
||
|
||
const UNITLESS_STYLES = new Set([
|
||
'line-height', 'opacity', 'font-weight', 'z-index', 'flex', 'flex-grow',
|
||
'flex-shrink', 'order', 'zoom', 'aspect-ratio', 'flex-basis',
|
||
])
|
||
|
||
function styleToString(style) {
|
||
if (!style || typeof style !== 'object') return ''
|
||
const parts = []
|
||
for (const [name, raw] of Object.entries(style)) {
|
||
if (raw === null || raw === undefined || raw === false) continue
|
||
const key = kebabStyleName(name)
|
||
let value = raw
|
||
if (typeof value === 'number' && value !== 0 && !UNITLESS_STYLES.has(key)) value = `${value}px`
|
||
parts.push(`${key}:${value}`)
|
||
}
|
||
return parts.join(';')
|
||
}
|
||
|
||
function buildAttributes(type, props) {
|
||
const attrs = []
|
||
for (const [rawName, rawValue] of Object.entries(props || {})) {
|
||
if (rawName === 'children' || rawName === 'key' || rawName === 'ref') continue
|
||
if (rawName === '__self' || rawName === '__source') continue
|
||
if (rawName === 'dangerouslySetInnerHTML') continue
|
||
if (rawName === 'value' && type === 'select') continue
|
||
if (rawName === 'value' && type === 'option') continue
|
||
if (rawName === 'selected' && type === 'option') continue
|
||
if (typeof rawValue === 'function' || typeof rawValue === 'symbol') continue
|
||
if (rawValue === undefined || rawValue === null) continue
|
||
|
||
let name = rawName
|
||
if (rawName === 'className') {
|
||
name = 'class'
|
||
} else if (ATTR_ALIASES[rawName]) {
|
||
name = ATTR_ALIASES[rawName]
|
||
} else if (!rawName.includes('-') && /[A-Z]/.test(rawName)) {
|
||
name = rawName.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)
|
||
}
|
||
|
||
if (name === 'class') {
|
||
const value = Array.isArray(rawValue) ? rawValue.filter(Boolean).join(' ') : String(rawValue)
|
||
if (value) attrs.push(`class="${escapeAttr(value)}"`)
|
||
continue
|
||
}
|
||
if (name === 'style') {
|
||
const value = styleToString(rawValue)
|
||
if (value) attrs.push(`style="${escapeAttr(value)}"`)
|
||
continue
|
||
}
|
||
if (name.startsWith('aria-') || name.startsWith('data-')) {
|
||
attrs.push(`${name}="${escapeAttr(String(rawValue))}"`)
|
||
continue
|
||
}
|
||
if (name === 'value' && type === 'option') continue
|
||
if (BOOLEAN_ATTRS.has(name)) {
|
||
if (rawValue === true || rawValue === '') attrs.push(`${name}=""`)
|
||
continue
|
||
}
|
||
if (rawValue === false) continue
|
||
if (rawValue === true) {
|
||
attrs.push(`${name}=""`)
|
||
continue
|
||
}
|
||
attrs.push(`${name}="${escapeAttr(String(rawValue))}"`)
|
||
}
|
||
return attrs.length ? ` ${attrs.join(' ')}` : ''
|
||
}
|
||
|
||
function serializeNode(node, options = {}) {
|
||
if (!node) return ''
|
||
if (node.text !== undefined) return escapeText(node.text)
|
||
if (node.fragment) return node.children.map((child) => serializeNode(child, options)).join('')
|
||
|
||
const { type, props, children } = node
|
||
if (typeof type !== 'string') fail(`序列化遇到非字符串标签:${String(type)}`)
|
||
|
||
if (type === 'select') {
|
||
const attrs = buildAttributes(type, props)
|
||
const inner = children.map((child) => serializeNode(child, { selectValue: props.value })).join('')
|
||
return `<select${attrs}>${inner}</select>`
|
||
}
|
||
|
||
if (type === 'option') {
|
||
const attrs = []
|
||
for (const [name, value] of Object.entries(props || {})) {
|
||
if (name === 'children' || name === 'key' || name === 'selected' || name === 'value') continue
|
||
if (value === undefined || value === null || value === false || typeof value === 'function') continue
|
||
attrs.push(`${name}="${escapeAttr(String(value))}"`)
|
||
}
|
||
if (props && props.value !== undefined && props.value !== null) attrs.push(`value="${escapeAttr(String(props.value))}"`)
|
||
const selected = (props && props.selected === true)
|
||
|| (options.selectValue !== undefined && options.selectValue !== null && props && String(props.value) === String(options.selectValue))
|
||
if (selected) attrs.push('selected=""')
|
||
const inner = children.map((child) => serializeNode(child, options)).join('')
|
||
return `<option${attrs.length ? ` ${attrs.join(' ')}` : ''}>${inner}</option>`
|
||
}
|
||
|
||
const attrs = buildAttributes(type, props)
|
||
if (VOID_TAGS.has(type)) return `<${type}${attrs}>`
|
||
const rawHtml = props && props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === 'string'
|
||
? props.dangerouslySetInnerHTML.__html
|
||
: null
|
||
const inner = rawHtml !== null
|
||
? rawHtml
|
||
: children.map((child) => serializeNode(child, options)).join('')
|
||
return `<${type}${attrs}>${inner}</${type}>`
|
||
}
|
||
|
||
function pickChildren(node) {
|
||
const positional = Array.isArray(node.children) ? node.children : []
|
||
const fromProps = node.props && node.props.children !== undefined ? node.props.children : undefined
|
||
const source = positional.length > 0 ? positional : fromProps === undefined ? [] : [fromProps]
|
||
const flat = []
|
||
for (const item of source) {
|
||
if (Array.isArray(item)) flat.push(...item)
|
||
else flat.push(item)
|
||
}
|
||
return flat
|
||
}
|
||
|
||
function mountNode(node, hooks, depth = 0, path = '0') {
|
||
if (depth > 200) fail('组件树递归超过 200 层,疑似存在渲染死循环。')
|
||
if (node === null || node === undefined || node === false || node === true) return null
|
||
if (typeof node === 'string' || typeof node === 'number') return { text: String(node) }
|
||
if (Array.isArray(node)) {
|
||
const children = []
|
||
for (let index = 0; index < node.length; index += 1) {
|
||
const mounted = mountNode(node[index], hooks, depth + 1, `${path}/a${index}`)
|
||
if (mounted) children.push(mounted)
|
||
}
|
||
return { fragment: true, children }
|
||
}
|
||
if (typeof node !== 'object' || node.type === undefined) {
|
||
fail(`无法渲染的节点:${JSON.stringify(node)}`)
|
||
}
|
||
|
||
const { type } = node
|
||
const props = node.props || {}
|
||
|
||
if (typeof type === 'function') {
|
||
if (type.__previewContext && type.__previewContext._stack) {
|
||
const context = type.__previewContext
|
||
context._stack.push(props.value)
|
||
try {
|
||
return mountNode(type(props), hooks, depth + 1, `${path}/ctx`)
|
||
} finally {
|
||
context._stack.pop()
|
||
}
|
||
}
|
||
if (type.__previewContext && type.__previewContext._stack === undefined) {
|
||
return mountNode(type(props), hooks, depth + 1, `${path}/ctx`)
|
||
}
|
||
|
||
const key = `${path}|${type.name || 'anonymous'}`
|
||
let output
|
||
if (type.prototype && typeof type.prototype.render === 'function') {
|
||
let instance = hooks.instanceMap.get(key)
|
||
if (!instance) {
|
||
instance = new type(props)
|
||
hooks.instanceMap.set(key, instance)
|
||
}
|
||
instance.props = props
|
||
output = instance.render()
|
||
if (typeof instance.componentDidMount === 'function') {
|
||
// 用 effect 队列在本次渲染后执行,避免在 render 里做副作用
|
||
output = output
|
||
hooks.pendingLifecycle = hooks.pendingLifecycle || []
|
||
hooks.pendingLifecycle.push(() => instance.componentDidMount())
|
||
}
|
||
} else {
|
||
hooks.enter(key)
|
||
try {
|
||
output = type(props)
|
||
} finally {
|
||
hooks.leave()
|
||
}
|
||
}
|
||
return mountNode(output, hooks, depth + 1, `${key}/r`)
|
||
}
|
||
|
||
if (type === 'fragment') {
|
||
const kids = pickChildren(node)
|
||
const children = []
|
||
for (let index = 0; index < kids.length; index += 1) {
|
||
const mounted = mountNode(kids[index], hooks, depth + 1, `${path}/f${index}`)
|
||
if (mounted) children.push(mounted)
|
||
}
|
||
return { fragment: true, children }
|
||
}
|
||
|
||
const kids = pickChildren(node)
|
||
const children = []
|
||
for (let index = 0; index < kids.length; index += 1) {
|
||
const mounted = mountNode(kids[index], hooks, depth + 1, `${path}/h${index}`)
|
||
if (mounted) children.push(mounted)
|
||
}
|
||
return { type, props, children }
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 旧 bundle 的演示 ctx(createHost 需要)
|
||
|
||
const DEMO_ROLES = SEATS.map((seat) => seat.roleId)
|
||
const DEMO_LABELS = Object.fromEntries(SEATS.map((seat) => [seat.roleId, seat.name]))
|
||
const DEMO_RUNNING = new Set(['shangshu', 'hubu', 'gongbu'])
|
||
const DEMO_STATUS_TEXT =
|
||
'Chrome、Edge 和内置 Node 都可用。我把「真实组件预览生成器」交给队友做,现在已经能出图了。'
|
||
const DEMO_NODES = new Map([
|
||
['demo-1', { kind: 'assistant', anchorSeq: 1, data: { blocks: [{ kind: 'text', text: DEMO_STATUS_TEXT }] } }],
|
||
])
|
||
|
||
function createDemoContext() {
|
||
const members = DEMO_ROLES.map((role) => ({ id: `sess-${role}`, name: role, phase: 'active' }))
|
||
const tasks = [
|
||
{ id: 'task-1', subject: '拆解 0.5.1 侧栏验收清单', status: 'in_progress', ownerName: 'zhongshu' },
|
||
{ id: 'task-2', subject: '复算朝堂统计投影', status: 'in_progress', ownerName: 'hubu' },
|
||
{ id: 'task-3', subject: '补齐右侧栏窄宽度回归', status: 'pending', ownerName: 'xingbu' },
|
||
{ id: 'task-4', subject: '整理 @ 部门入口说明', status: 'pending', ownerName: 'lipu' },
|
||
{ id: 'task-5', subject: '删除未渲染的旧样式', status: 'completed', ownerName: 'gongbu' },
|
||
{ id: 'task-6', subject: '核对十席角色文案', status: 'completed', ownerName: 'libu' },
|
||
]
|
||
|
||
const byId = {}
|
||
const ids = []
|
||
for (const role of DEMO_ROLES) {
|
||
const id = `sess-${role}`
|
||
ids.push(id)
|
||
byId[id] = {
|
||
id,
|
||
name: DEMO_LABELS[role],
|
||
updatedAt: 1_760_000_000_000 + DEMO_ROLES.indexOf(role),
|
||
running: DEMO_RUNNING.has(role),
|
||
workspaceId: 'demo-workspace',
|
||
}
|
||
}
|
||
byId[LEAD_SESSION] = { ...byId[LEAD_SESSION], subagent: undefined }
|
||
|
||
const team = { members, tasks }
|
||
const sessionList = {
|
||
getSnapshot: () => ({
|
||
ids: ids.slice(),
|
||
byId,
|
||
projectionsBySession: {
|
||
[LEAD_SESSION]: {
|
||
sessionId: LEAD_SESSION,
|
||
values: {
|
||
agentTeam: team,
|
||
agentPreset: 'sansheng-liubu',
|
||
subagentCatalog: [],
|
||
},
|
||
},
|
||
},
|
||
phase: 'ready',
|
||
}),
|
||
subscribe: () => () => {},
|
||
}
|
||
|
||
const statuses = new Map()
|
||
for (const role of DEMO_ROLES) {
|
||
statuses.set(`sess-${role}`, { running: DEMO_RUNNING.has(role) })
|
||
}
|
||
const statusStore = {
|
||
getSnapshot: () => statuses,
|
||
subscribe: () => () => {},
|
||
}
|
||
|
||
const catalogSnapshot = {
|
||
status: 'ready',
|
||
error: null,
|
||
current: { provider: 'openai', model: 'gpt-6-astra', reasoningEffort: 'high' },
|
||
default: { provider: 'openai', model: 'gpt-6-astra', reasoningEffort: 'high' },
|
||
groups: [
|
||
{
|
||
id: 'openai',
|
||
name: 'OpenAI',
|
||
models: [
|
||
{
|
||
id: 'gpt-6-astra',
|
||
name: 'GPT-6 Astra',
|
||
reasoning: {
|
||
defaultEffort: 'high',
|
||
efforts: [
|
||
{ id: 'low', name: '低' },
|
||
{ id: 'medium', name: '中' },
|
||
{ id: 'high', name: '高' },
|
||
],
|
||
},
|
||
},
|
||
{
|
||
id: 'gpt-6-mini',
|
||
name: 'GPT-6 Mini',
|
||
reasoning: {
|
||
defaultEffort: 'medium',
|
||
efforts: [
|
||
{ id: 'low', name: '低' },
|
||
{ id: 'medium', name: '中' },
|
||
],
|
||
},
|
||
},
|
||
],
|
||
},
|
||
{
|
||
id: 'deepseek',
|
||
name: 'DeepSeek',
|
||
models: [
|
||
{
|
||
id: 'deepseek-v4',
|
||
name: 'DeepSeek V4',
|
||
reasoning: { defaultEffort: 'high', efforts: [{ id: 'high', name: '高' }] },
|
||
},
|
||
],
|
||
},
|
||
],
|
||
}
|
||
|
||
const binding = {
|
||
session: {
|
||
projections: {
|
||
faceOf: () => ({ getSnapshot: () => ({ model: { name: 'GPT-6 Astra' } }) }),
|
||
},
|
||
prompt: async () => ({ ok: true }),
|
||
},
|
||
}
|
||
|
||
const ctx = {
|
||
effect(callback) {
|
||
const dispose = callback()
|
||
return typeof dispose === 'function' ? dispose : () => {}
|
||
},
|
||
sessions: {
|
||
list: sessionList,
|
||
statuses: statusStore,
|
||
binding: () => binding,
|
||
subagentAddress: (sessionId) => (sessionId === LEAD_SESSION ? undefined : { parentSessionId: LEAD_SESSION, childSessionId: sessionId }),
|
||
refreshProjections: async () => {},
|
||
},
|
||
uiWorkspace: {
|
||
selection: {
|
||
getSnapshot: () => ({ sessionId: LEAD_SESSION }),
|
||
subscribe: () => () => {},
|
||
set: () => {},
|
||
},
|
||
currentWorkspaceId: 'demo-workspace',
|
||
openSession: () => {},
|
||
startSession: () => {},
|
||
},
|
||
uiConversation: {
|
||
binding: () => ({
|
||
target: () => ({ getSnapshot: () => ({ nodes: DEMO_NODES }) }),
|
||
}),
|
||
},
|
||
modelDirectories: {
|
||
catalog: {
|
||
load: async () => ({
|
||
default: catalogSnapshot.current,
|
||
groups: catalogSnapshot.groups,
|
||
failures: [],
|
||
}),
|
||
store: { getSnapshot: () => ({ value: catalogSnapshot, status: 'ready', error: null }) },
|
||
},
|
||
directoryFor: () => ({
|
||
load: () => Promise.resolve(),
|
||
select: () => Promise.resolve({ ok: true }),
|
||
store: {
|
||
getSnapshot: () => catalogSnapshot,
|
||
subscribe: () => () => {},
|
||
},
|
||
}),
|
||
},
|
||
remote: {
|
||
agentPresets: {
|
||
list: async () => ({ ok: true, value: { presets: [] } }),
|
||
select: async () => ({ ok: true }),
|
||
},
|
||
session: {
|
||
selectModel: async () => ({ ok: true }),
|
||
},
|
||
commands: {
|
||
execute: async (_agentId, line) => ({ commandId: 'preview-command', result: { kind: 'success', text: line } }),
|
||
},
|
||
subagents: {
|
||
prompt: async () => ({ messageId: 'preview-msg' }),
|
||
},
|
||
},
|
||
get: () => undefined,
|
||
layout: { selectPanel: () => {} },
|
||
sidebarRight: { openTab: () => {}, openTabIn: () => {} },
|
||
sidebarRightTabs: { register: () => () => {} },
|
||
slots: { register: () => () => {}, inject: (name, callback) => callback() },
|
||
}
|
||
|
||
return { ctx, team, catalogSnapshot }
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 选择要渲染的组件
|
||
|
||
/* #region 真实 Host 模式(--live)
|
||
与打桩模式共用同一套 vm/hooks/序列化/截图;区别只在于 fetch:
|
||
这里把 bundle 的 fetch 桥到 workbench/host 真正注册的路由,账本用内存 store,
|
||
绝不碰 %USERPROFILE%\.dsh\sansheng-liubu\workbench.json。 */
|
||
|
||
function createLiveSessionController(onPrompt) {
|
||
let next = 1
|
||
const sessions = new Map()
|
||
const calls = { create: [], prompt: [], inspect: [], selectModel: [], cancel: [] }
|
||
const controller = {
|
||
calls,
|
||
sessions,
|
||
async create(request = {}) {
|
||
calls.create.push(request)
|
||
const existing = [...sessions.values()].find(
|
||
(row) => row.workspaceId === (request.workspaceId ?? null) && request.sessionId === undefined,
|
||
)
|
||
if (existing !== undefined) return { sessionId: existing.sessionId, agentPreset: existing.agentPreset ?? null }
|
||
const sessionId = request.sessionId ?? `sess_live_${next++}`
|
||
sessions.set(sessionId, {
|
||
sessionId,
|
||
workspaceId: request.workspaceId ?? null,
|
||
agentPreset: request.agentPreset ?? null,
|
||
running: false,
|
||
accepted: new Set(),
|
||
})
|
||
return { sessionId, agentPreset: request.agentPreset ?? null }
|
||
},
|
||
async inspect(sessionId) {
|
||
calls.inspect.push(sessionId)
|
||
const row = sessions.get(sessionId)
|
||
if (row === undefined) throw Object.assign(new Error('not found'), { code: 'session/not-found' })
|
||
return { sessionId, attached: true }
|
||
},
|
||
async prompt(request) {
|
||
calls.prompt.push(request)
|
||
const row = sessions.get(request.sessionId)
|
||
if (row === undefined) throw Object.assign(new Error('no session'), { code: 'session/conflict' })
|
||
const text = request?.content?.[0]?.text ?? ''
|
||
if (typeof onPrompt === 'function') onPrompt({ sessionId: request.sessionId, requestId: request.requestId, text })
|
||
if (row.accepted.has(request.requestId)) return { accepted: true }
|
||
row.accepted.add(request.requestId)
|
||
row.running = true
|
||
return { accepted: true }
|
||
},
|
||
cancel(request) {
|
||
calls.cancel.push(request)
|
||
const row = sessions.get(request?.sessionId)
|
||
if (row !== undefined) row.running = false
|
||
return { accepted: true }
|
||
},
|
||
async selectModel(request) {
|
||
calls.selectModel.push(request)
|
||
return { selected: { provider: request?.provider ?? null, model: request?.model ?? null } }
|
||
},
|
||
async list() {
|
||
return {
|
||
items: [...sessions.values()].map((row) => ({
|
||
sessionId: row.sessionId,
|
||
running: row.running,
|
||
agentAvailable: true,
|
||
updatedAt: '',
|
||
blank: false,
|
||
})),
|
||
}
|
||
},
|
||
}
|
||
return controller
|
||
}
|
||
|
||
/** 把标准 fetch 调用桥到 workbench/host 注册的 route handler。 */
|
||
function createLiveFetch(handlers, live) {
|
||
return async function liveFetch(input, init = {}) {
|
||
const raw = typeof input === 'string'
|
||
? input
|
||
: input && typeof input.url === 'string'
|
||
? input.url
|
||
: String(input)
|
||
const url = new URL(raw, 'http://preview.local')
|
||
const method = String((init && init.method) || (input && input.method) || 'GET').toUpperCase()
|
||
const path = url.pathname
|
||
const handler = handlers.get(path)
|
||
const bodyText = init && init.body !== undefined && init.body !== null
|
||
? (typeof init.body === 'string' ? init.body : JSON.stringify(init.body))
|
||
: ''
|
||
|
||
if (typeof handler !== 'function') {
|
||
const entry = { method, path, query: url.search, status: 404, note: '未注册路由' }
|
||
live.requests.push(entry)
|
||
log(`[live] ${method} ${path} → 404(未注册路由)`)
|
||
return makeResponse(404, { ok: false, error: { code: 'NOT_FOUND', message: `未注册路由:${path}` } })
|
||
}
|
||
|
||
const req = {
|
||
method,
|
||
url: `${path}${url.search}`,
|
||
headers: Object.assign({}, init && init.headers),
|
||
async *[Symbol.asyncIterator]() {
|
||
if (bodyText !== '') yield Buffer.from(bodyText, 'utf8')
|
||
},
|
||
}
|
||
const headers = {}
|
||
let body = ''
|
||
const res = {
|
||
statusCode: 200,
|
||
headers,
|
||
headersSent: false,
|
||
writableEnded: false,
|
||
destroyed: false,
|
||
setHeader(name, value) { headers[String(name).toLowerCase()] = value },
|
||
getHeader(name) { return headers[String(name).toLowerCase()] },
|
||
writeHead(status, extra) {
|
||
this.statusCode = status
|
||
if (extra && typeof extra === 'object') {
|
||
for (const [key, value] of Object.entries(extra)) headers[String(key).toLowerCase()] = value
|
||
}
|
||
this.headersSent = true
|
||
return this
|
||
},
|
||
write(chunk) { body += chunk === undefined ? '' : String(chunk); return true },
|
||
end(chunk) {
|
||
if (chunk !== undefined && chunk !== null) body += String(chunk)
|
||
this.writableEnded = true
|
||
},
|
||
on() {}, once() {}, off() {}, emit() {}, removeListener() {},
|
||
}
|
||
|
||
let failure = null
|
||
try {
|
||
await handler(req, res)
|
||
} catch (error) {
|
||
failure = error
|
||
if (!res.writableEnded) {
|
||
res.writeHead(500, { 'content-type': 'application/json' })
|
||
res.end(JSON.stringify({ ok: false, error: { code: 'LIVE_BRIDGE_CRASH', message: String(error?.message ?? error) } }))
|
||
}
|
||
}
|
||
|
||
let payload = {}
|
||
try { payload = body === '' ? {} : JSON.parse(body) } catch { payload = { raw: body } }
|
||
const entry = { method, path, query: url.search, status: res.statusCode }
|
||
live.requests.push(entry)
|
||
log(`[live] ${method} ${path}${url.search} → ${res.statusCode}`)
|
||
if (failure) log(`[live] handler 抛错:${failure?.stack ?? failure}`)
|
||
|
||
if (path.endsWith('/dispatch')) {
|
||
const record = payload && payload.value ? payload.value.dispatch : null
|
||
live.dispatches.push({
|
||
status: record ? (record.status || record.state || null) : null,
|
||
httpStatus: res.statusCode,
|
||
payload,
|
||
})
|
||
log(`[live] dispatch.status=${record ? (record.status || record.state) : '(无)'}`)
|
||
}
|
||
if (path.endsWith('/task/cancel')) {
|
||
live.cancellations.push({ httpStatus: res.statusCode, payload })
|
||
log(`[live] cancel.status=${payload?.value?.task?.status ?? '(无)'}`)
|
||
}
|
||
if (path.endsWith('/artifact/revision')) {
|
||
live.revisions.push({ httpStatus: res.statusCode, payload })
|
||
log(`[live] revision.task.kind=${payload?.value?.task?.kind ?? '(无)'}`)
|
||
}
|
||
|
||
return {
|
||
ok: res.statusCode >= 200 && res.statusCode < 300,
|
||
status: res.statusCode,
|
||
statusText: res.statusCode === 200 ? 'OK' : 'Error',
|
||
headers: { get: (name) => headers[String(name).toLowerCase()] ?? null },
|
||
json: async () => JSON.parse(JSON.stringify(payload)),
|
||
text: async () => body,
|
||
}
|
||
}
|
||
}
|
||
|
||
async function setupLiveHost() {
|
||
const hostModule = await import(pathToFileURL(join(ROOT, 'workbench/host/index.mjs')).href)
|
||
const storeModule = await import(pathToFileURL(join(ROOT, 'workbench/core/store.mjs')).href)
|
||
const clock = () => Date.now()
|
||
const store = new storeModule.WorkbenchStore({
|
||
file: null,
|
||
clock,
|
||
env: { DSH_HOME: join(SCRATCH, 'live-home') },
|
||
})
|
||
const live = {
|
||
requests: [],
|
||
dispatches: [],
|
||
cancellations: [],
|
||
revisions: [],
|
||
prompts: [],
|
||
projectId: null,
|
||
controller: null,
|
||
}
|
||
const controller = createLiveSessionController((entry) => {
|
||
live.prompts.push(entry)
|
||
log(`[live] 伪 sessionController 收到 prompt(${entry.text.length} 字符):${entry.text.slice(0, 80).replace(/\\s+/g, ' ')}…`)
|
||
})
|
||
live.controller = controller
|
||
|
||
const handlers = new Map()
|
||
const webServer = {
|
||
register(registration = {}) {
|
||
const path = registration.path
|
||
if (typeof path !== 'string' || typeof registration.handler !== 'function') {
|
||
throw new Error('webServer.register 需要 path 与 handler')
|
||
}
|
||
handlers.set(path, registration.handler)
|
||
return () => { handlers.delete(path) }
|
||
},
|
||
}
|
||
|
||
const ctx = {
|
||
webServer,
|
||
// 故意先不给 sessionController:让 Host 走 ctx.inject(['sessionController']) 的晚挂路径。
|
||
inject(deps, callback) {
|
||
const scoped = { webServer, sessionController: controller }
|
||
try {
|
||
callback(scoped)
|
||
} catch (error) {
|
||
log(`[live] ctx.inject 回调失败:${error?.message ?? error}`)
|
||
}
|
||
return () => {}
|
||
},
|
||
uiWorkspace: {
|
||
currentWorkspaceId: 'ws_demo',
|
||
openSession(sessionId) { log(`[live] openSession(${sessionId})(替身,仅记录)`) },
|
||
selection: {
|
||
getSnapshot: () => ({ workspaceId: 'ws_demo' }),
|
||
set(value) { log(`[live] uiWorkspace.selection.set(${JSON.stringify(value)})`) },
|
||
},
|
||
},
|
||
}
|
||
|
||
const host = hostModule.createWorkbenchHost(ctx, {
|
||
store,
|
||
clock,
|
||
load: false,
|
||
startReconciler: false,
|
||
longPollMs: 0,
|
||
pollIntervalMs: 10,
|
||
log: (message) => log(`[host] ${message}`),
|
||
})
|
||
if (host.registered === false) fail(`真实 Host 路由未注册:${host.warning || '未知原因'}`)
|
||
if (host.hasSessions !== true) fail('真实 Host 没有挂上伪 sessionController(inject 晚挂失败)')
|
||
|
||
live.host = host
|
||
live.routes = host.routes
|
||
live.fetchLive = createLiveFetch(handlers, live)
|
||
log(`[live] Host 就绪:账本 file=${String(store.file)},路由 ${host.routes.paths?.length ?? handlers.size} 条,hasSessions=${host.hasSessions}`)
|
||
return live
|
||
}
|
||
|
||
async function registerLiveProject(live) {
|
||
const response = await live.fetchLive(`${ROUTE_PREFIX}/project`, {
|
||
method: 'POST',
|
||
headers: { 'content-type': 'application/json' },
|
||
body: JSON.stringify({
|
||
hostWorkspaceId: 'ws_demo',
|
||
displayNameCache: '演示项目',
|
||
canonicalRoot: 'C:\\\\demo',
|
||
}),
|
||
})
|
||
const payload = await response.json()
|
||
const project = payload && payload.value && payload.value.project
|
||
if (!response.ok || !project || typeof project.id !== 'string') {
|
||
fail(`通过真实 POST /project 注册项目失败(HTTP ${response.status}):${JSON.stringify(payload)}`)
|
||
}
|
||
live.projectId = project.id
|
||
log(`[live] 已通过真实 /project 注册项目:${project.id}`)
|
||
return project.id
|
||
}
|
||
|
||
function createLiveUiContext() {
|
||
return {
|
||
uiWorkspace: {
|
||
currentWorkspaceId: 'ws_demo',
|
||
openSession(sessionId) { log(`[live] bundle 请求打开会话 ${sessionId}`) },
|
||
selection: {
|
||
getSnapshot: () => ({ workspaceId: 'ws_demo' }),
|
||
set(value) { log(`[live] selection.set(${JSON.stringify(value)})`) },
|
||
},
|
||
},
|
||
}
|
||
}
|
||
|
||
function findAllMounted(node, predicate, out = []) {
|
||
if (!node) return out
|
||
if (predicate(node)) out.push(node)
|
||
if (node.fragment) {
|
||
for (const child of node.children) findAllMounted(child, predicate, out)
|
||
} else if (Array.isArray(node.children)) {
|
||
for (const child of node.children) findAllMounted(child, predicate, out)
|
||
}
|
||
return out
|
||
}
|
||
|
||
function textOf(node) {
|
||
return mountedText(node).replace(/\\s+/g, ' ').trim()
|
||
}
|
||
|
||
function findClass(node, className) {
|
||
return findMounted(node, (child) => classNameOf(child).includes(className))
|
||
}
|
||
|
||
function findSeatCard(tree, roleName) {
|
||
return findMounted(tree, (node) => {
|
||
if (!classNameOf(node).includes('wb-card')) return false
|
||
const text = textOf(node)
|
||
return text.includes(roleName)
|
||
})
|
||
}
|
||
|
||
function findClickableByText(node, needle) {
|
||
return findMounted(node, (child) => {
|
||
if (child.type !== 'button') return false
|
||
return textOf(child).includes(needle)
|
||
})
|
||
}
|
||
|
||
async function liveSettle(hooks, rootVNode, label) {
|
||
const result = await settle(hooks, rootVNode, 4000)
|
||
log(`[live] ${label}:${result.settled ? '稳定' : '未稳定'},${result.passes} 轮,${result.elapsedMs}ms`)
|
||
return result.tree
|
||
}
|
||
|
||
async function liveWait(hooks, rootVNode, predicate, label, budgetMs = 4000) {
|
||
const started = Date.now()
|
||
let tree = null
|
||
let passes = 0
|
||
while (Date.now() - started < budgetMs) {
|
||
const result = await settle(hooks, rootVNode, 1000)
|
||
tree = result.tree
|
||
passes += result.passes
|
||
if (predicate(tree)) {
|
||
log(`[live] ${label}:满足(${Date.now() - started}ms,${passes} 轮)`)
|
||
return { tree, passes, ok: true }
|
||
}
|
||
await new Promise((resolveWait) => setTimeout(resolveWait, 30))
|
||
}
|
||
log(`[live] ${label}:超时未满足(${budgetMs}ms)`)
|
||
return { tree, passes, ok: false }
|
||
}
|
||
|
||
async function connectSeatLive(hooks, rootVNode, tree, roleName) {
|
||
const card = findSeatCard(tree, roleName)
|
||
if (!card) fail(`[live] 在朝堂里找不到「${roleName}」卡片`)
|
||
const before = textOf(card)
|
||
const button = findMounted(card, (node) => classNameOf(node).includes('wb-connect'))
|
||
if (!button) fail(`[live]「${roleName}」卡片没有「接通」按钮:${before}`)
|
||
log(`[live] 点击「${roleName} · 接通」;点击前:${before}`)
|
||
if (!clickMounted(button)) fail(`[live]「${roleName} · 接通」的 onClick 不可调用`)
|
||
const waited = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(nextTree) => {
|
||
const nextCard = findSeatCard(nextTree, roleName)
|
||
return Boolean(nextCard) && !textOf(nextCard).includes('未接通') && !classNameOf(nextCard).includes('is-pending')
|
||
},
|
||
`等待「${roleName}」接通`,
|
||
)
|
||
const afterCard = findSeatCard(waited.tree, roleName)
|
||
const after = afterCard ? textOf(afterCard) : '(卡片消失)'
|
||
log(`[live]「${roleName}」点击后:${after}`)
|
||
return { tree: waited.tree, before, after, ok: waited.ok, passes: waited.passes }
|
||
}
|
||
|
||
async function openTaskFormLive(hooks, rootVNode, tree) {
|
||
const newButton = findClickableByText(tree, '新建')
|
||
if (!newButton) fail('[live] 任务页找不到「新建」按钮')
|
||
clickMounted(newButton)
|
||
const opened = await liveWait(hooks, rootVNode, (next) => Boolean(findClass(next, 'wb-form')), '等待任务表单展开')
|
||
if (!opened.ok) fail('[live] 点击「新建」后表单没有出现')
|
||
return opened.tree
|
||
}
|
||
|
||
async function setFormFieldLive(hooks, rootVNode, tree, className, value) {
|
||
const form = findClass(tree, 'wb-form')
|
||
if (!form) fail(`[live] 找不到任务表单(设置 ${className} 时)`)
|
||
const field = findClass(form, className)
|
||
if (!field || !field.props || typeof field.props.onChange !== 'function') {
|
||
fail(`[live] 任务表单里找不到可输入的 .${className}`)
|
||
}
|
||
field.props.onChange({ target: { value }, currentTarget: { value } })
|
||
return liveSettle(hooks, rootVNode, `填写 ${className}=${value}`)
|
||
}
|
||
|
||
async function submitTaskFormLive(hooks, rootVNode, tree) {
|
||
const form = findClass(tree, 'wb-form')
|
||
if (!form || !form.props || typeof form.props.onSubmit !== 'function') fail('[live] 任务表单没有 onSubmit')
|
||
form.props.onSubmit({ preventDefault() {}, target: {}, currentTarget: {} })
|
||
return liveSettle(hooks, rootVNode, '提交任务草稿')
|
||
}
|
||
|
||
async function dispatchTaskLive(hooks, rootVNode, tree, title) {
|
||
const taskCard = findMounted(tree, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
if (!taskCard) fail(`[live] 任务列表里找不到「${title}」`)
|
||
const before = textOf(taskCard)
|
||
const button = findClickableByText(taskCard, '派工')
|
||
if (!button) fail(`[live]「${title}」没有「派工」按钮:${before}`)
|
||
log(`[live] 点击「派工」;点击前:${before}`)
|
||
clickMounted(button)
|
||
const waited = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(next) => {
|
||
const card = findMounted(next, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
const text = card ? textOf(card) : ''
|
||
return Boolean(card) && !text.includes('排队') && !text.includes('草稿') && (text.includes('执行中') || text.includes('正在运行'))
|
||
},
|
||
'等待任务进入运行态',
|
||
)
|
||
const afterCard = findMounted(waited.tree, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
const after = afterCard ? textOf(afterCard) : '(任务消失)'
|
||
log(`[live]「派工」后:${after}`)
|
||
return { tree: waited.tree, before, after, ok: waited.ok, passes: waited.passes }
|
||
}
|
||
|
||
async function createDraftTaskThroughFormLive(hooks, rootVNode, tree, title, objective) {
|
||
let next = await openTaskFormLive(hooks, rootVNode, tree)
|
||
let passes = 0
|
||
for (const [className, value] of [
|
||
['wb-input', title],
|
||
['wb-textarea', objective],
|
||
['wb-select', 'gongbu'],
|
||
]) {
|
||
next = await setFormFieldLive(hooks, rootVNode, next, className, value)
|
||
passes += 1
|
||
}
|
||
next = await submitTaskFormLive(hooks, rootVNode, next)
|
||
const drafted = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(candidate) => Boolean(findMounted(candidate, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))),
|
||
'等待草稿任务出现在列表',
|
||
)
|
||
if (!drafted.ok) fail(`[live] 表单提交后任务列表没有出现「${title}」`)
|
||
next = drafted.tree
|
||
passes += drafted.passes
|
||
log(`[live] 表单已存为草稿:${title}`)
|
||
return { tree: next, passes }
|
||
}
|
||
|
||
async function cancelTaskLive(hooks, rootVNode, tree, title) {
|
||
const taskCard = findMounted(tree, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
if (!taskCard) fail(`[live] 任务列表里找不到「${title}」`)
|
||
const before = textOf(taskCard)
|
||
const button = findClickableByText(taskCard, '取消')
|
||
if (!button) fail(`[live]「${title}」没有「取消」按钮:${before}`)
|
||
log(`[live] 点击「取消」;点击前:${before}`)
|
||
clickMounted(button)
|
||
const waited = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(next) => {
|
||
const card = findMounted(next, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
if (!card) return false
|
||
const text = textOf(card)
|
||
return text.includes('已取消') && !findClickableByText(card, '取消')
|
||
},
|
||
'等待任务变成已取消且取消按钮消失',
|
||
)
|
||
const afterCard = findMounted(waited.tree, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes(title))
|
||
const after = afterCard ? textOf(afterCard) : '(任务消失)'
|
||
log(`[live]「取消」后:${after}`)
|
||
return { tree: waited.tree, before, after, ok: waited.ok, passes: waited.passes }
|
||
}
|
||
|
||
async function openArtifactLive(hooks, rootVNode, tree, name) {
|
||
const row = findMounted(tree, (node) => classNameOf(node).includes('wb-artifact') && textOf(node).includes(name))
|
||
if (!row) fail(`[live] 成果列表里找不到「${name}」`)
|
||
const before = textOf(row)
|
||
const className = classNameOf(row)
|
||
clickMounted(row)
|
||
const opened = await liveWait(hooks, rootVNode, (next) => Boolean(findClass(next, 'wb-drawer')), '等待成果详情抽屉')
|
||
if (!opened.ok) fail('[live] 点击成果行后详情抽屉没有出现')
|
||
log(`[live] 已打开成果「${name}」;行 class="${className}"`)
|
||
return { tree: opened.tree, before, className, passes: opened.passes }
|
||
}
|
||
|
||
async function openRevisionFormLive(hooks, rootVNode, tree) {
|
||
const drawer = findClass(tree, 'wb-drawer')
|
||
if (!drawer) fail('[live] 成果抽屉不存在')
|
||
const button = findClickableByText(drawer, '找主责部门修改')
|
||
if (!button) fail('[live] 成果抽屉里没有「找主责部门修改」')
|
||
clickMounted(button)
|
||
const opened = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(next) => Boolean(findClass(findClass(next, 'wb-drawer'), 'wb-form')),
|
||
'等待修订表单展开',
|
||
)
|
||
if (!opened.ok) fail('[live] 点击「找主责部门修改」后表单没有出现')
|
||
return { tree: opened.tree, passes: opened.passes }
|
||
}
|
||
|
||
async function submitRevisionLive(hooks, rootVNode, tree, instruction) {
|
||
const field = findClass(findClass(tree, 'wb-drawer'), 'wb-textarea')
|
||
if (!field || !field.props || typeof field.props.onChange !== 'function') fail('[live] 修订表单里没有可输入的 textarea')
|
||
field.props.onChange({ target: { value: instruction }, currentTarget: { value: instruction } })
|
||
let next = await liveSettle(hooks, rootVNode, '填写修订说明')
|
||
const form = findClass(findClass(next, 'wb-drawer'), 'wb-form')
|
||
if (!form || !form.props || typeof form.props.onSubmit !== 'function') fail('[live] 修订表单没有 onSubmit')
|
||
log('[live] 点击「存为草稿」提交修订')
|
||
form.props.onSubmit({ preventDefault() {}, target: {}, currentTarget: {} })
|
||
const waited = await liveWait(
|
||
hooks,
|
||
rootVNode,
|
||
(candidate) => Boolean(findMounted(candidate, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes('修订'))),
|
||
'等待修订任务出现在任务页',
|
||
)
|
||
next = waited.tree
|
||
log(`[live] 修订后任务页可见:${Boolean(findMounted(next, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes('修订')))}`)
|
||
return { tree: next, ok: waited.ok, passes: waited.passes + 1 }
|
||
}
|
||
|
||
async function postLiveJson(live, path, body) {
|
||
const response = await live.fetchLive(`${ROUTE_PREFIX}${path}`, {
|
||
method: 'POST',
|
||
headers: { 'content-type': 'application/json' },
|
||
body: JSON.stringify(body),
|
||
})
|
||
const payload = await response.json()
|
||
if (!response.ok || !payload?.ok) {
|
||
fail(`[live] POST ${path} 失败:HTTP ${response.status} ${JSON.stringify(payload)}`)
|
||
}
|
||
return { response, payload }
|
||
}
|
||
|
||
async function prepareLiveScenario(live, scenario) {
|
||
if (scenario !== 'revise' && scenario !== 'missing') return
|
||
log(`[live] 准备 ${scenario} 场景:真实 POST /connect + POST /task,成果走 service.registerArtifact`)
|
||
await postLiveJson(live, '/connect', { projectId: live.projectId, roleId: 'gongbu' })
|
||
const created = await postLiveJson(live, '/task', {
|
||
projectId: live.projectId,
|
||
title: scenario === 'revise' ? '修订载体任务' : '失效载体任务',
|
||
objective: '为成果页场景准备一条真实任务。',
|
||
ownerRoleId: 'gongbu',
|
||
sourceRoleId: 'lead',
|
||
status: 'draft',
|
||
})
|
||
const task = created.payload.value && created.payload.value.task
|
||
if (!task || typeof task.id !== 'string') fail('[live] /task 没有返回 task.id')
|
||
const artifactInput = scenario === 'missing'
|
||
? {
|
||
projectId: live.projectId,
|
||
taskId: task.id,
|
||
ownerRoleId: 'gongbu',
|
||
fileRef: join(SCRATCH, 'live-missing', '不存在的验收单.pdf'),
|
||
displayName: '已失效验收单.pdf',
|
||
mediaType: 'application/pdf',
|
||
verification: { status: 'verified' },
|
||
}
|
||
: {
|
||
projectId: live.projectId,
|
||
taskId: task.id,
|
||
ownerRoleId: 'gongbu',
|
||
fileRef: join(ROOT, 'docs/preview/v01-live-court-400-light.png'),
|
||
displayName: '待修订预览截图.png',
|
||
mediaType: 'image/png',
|
||
verification: { status: 'verified' },
|
||
}
|
||
// 仓库没有 POST /artifact 端点(routes.mjs 只有 /artifact/revision),
|
||
// 所以按 Lead 允许的方式直接调 service.registerArtifact;这条不是 HTTP。
|
||
const registered = live.host.service.registerArtifact(artifactInput)
|
||
log(`[live] 直接调用 service.registerArtifact(非 HTTP):${registered.artifact.id},existence=${registered.artifact.existence}`)
|
||
live.preparedArtifact = registered.artifact
|
||
}
|
||
|
||
async function runLiveScenario({ hooks, rootVNode, view, live, projectId, scenario }) {
|
||
let tree = await liveSettle(hooks, rootVNode, '首屏 bootstrap')
|
||
const assertions = []
|
||
let passes = 0
|
||
|
||
if (scenario === 'court') {
|
||
const connected = await connectSeatLive(hooks, rootVNode, tree, '丞相')
|
||
tree = connected.tree
|
||
passes += connected.passes
|
||
assertions.push({
|
||
name: '丞相接通后从「未接通」变「空闲」',
|
||
ok: connected.ok && connected.after.includes('空闲'),
|
||
before: connected.before,
|
||
after: connected.after,
|
||
})
|
||
const courtNotice = findMounted(connected.tree, (node) => classNameOf(node).includes('wb-alert'))
|
||
const courtNoticeClass = courtNotice ? classNameOf(courtNotice) : ''
|
||
const courtNoticeText = courtNotice ? textOf(courtNotice) : ''
|
||
log(`[live] 接通提示:class="${courtNoticeClass}" text="${courtNoticeText}"`)
|
||
assertions.push({
|
||
name: '接通成功提示为绿色信息条(is-info)',
|
||
ok: courtNoticeClass.includes('is-info') && courtNoticeText.includes('已接通'),
|
||
before: '(无)',
|
||
after: courtNoticeText,
|
||
})
|
||
} else if (scenario === 'tasks' || scenario === 'cancel') {
|
||
const connected = await connectSeatLive(hooks, rootVNode, tree, '工部')
|
||
tree = connected.tree
|
||
passes += connected.passes
|
||
assertions.push({
|
||
name: '工部接通',
|
||
ok: connected.ok,
|
||
before: connected.before,
|
||
after: connected.after,
|
||
})
|
||
|
||
const switched = await switchPreviewState(hooks, rootVNode, 'tasks', '', tree)
|
||
tree = switched.tree
|
||
passes += switched.passes
|
||
log(`[live] 已切到任务页:${switched.clickedTab || '(未切换)'}`)
|
||
|
||
const title = '实机验证:预览器直连 Host'
|
||
const objective = '确认 --live 模式能把任务单真正送进工部会话。'
|
||
// 真实路径:新建 → 存为草稿 → 任务行点「派工」,不经过 queued 接口。
|
||
const drafted = await createDraftTaskThroughFormLive(hooks, rootVNode, tree, title, objective)
|
||
tree = drafted.tree
|
||
passes += drafted.passes
|
||
|
||
const dispatched = await dispatchTaskLive(hooks, rootVNode, tree, title)
|
||
const dispatchRecord = live.dispatches.length > 0 ? live.dispatches[live.dispatches.length - 1] : null
|
||
if (dispatchRecord) {
|
||
log(`[live] /dispatch 返回:HTTP ${dispatchRecord.httpStatus} ${JSON.stringify(dispatchRecord.payload)}`)
|
||
}
|
||
tree = dispatched.tree
|
||
passes += dispatched.passes
|
||
assertions.push({
|
||
name: '派工后任务离开排队态、进入执行中',
|
||
ok: dispatched.ok && !dispatched.after.includes('排队') && !dispatched.after.includes('草稿')
|
||
&& (dispatched.after.includes('执行中') || dispatched.after.includes('正在运行')),
|
||
before: dispatched.before,
|
||
after: dispatched.after,
|
||
})
|
||
const noticeNode = findMounted(dispatched.tree, (node) => classNameOf(node).includes('wb-alert'))
|
||
const noticeClass = noticeNode ? classNameOf(noticeNode) : ''
|
||
const noticeText = noticeNode ? textOf(noticeNode) : ''
|
||
log(`[live] 派工提示:class="${noticeClass}" text="${noticeText}"`)
|
||
assertions.push({
|
||
name: '派工成功提示为绿色信息条(is-info)',
|
||
ok: noticeClass.includes('is-info') && noticeText.includes('已派出'),
|
||
before: '(无)',
|
||
after: noticeText,
|
||
})
|
||
|
||
if (scenario === 'cancel') {
|
||
const cancelled = await cancelTaskLive(hooks, rootVNode, tree, title)
|
||
tree = cancelled.tree
|
||
passes += cancelled.passes
|
||
const cancelRecord = live.cancellations.length > 0 ? live.cancellations[live.cancellations.length - 1] : null
|
||
if (cancelRecord) {
|
||
log(`[live] /task/cancel 返回:HTTP ${cancelRecord.httpStatus} ${JSON.stringify(cancelRecord.payload)}`)
|
||
}
|
||
const cancelledTask = cancelRecord?.payload?.value?.task
|
||
assertions.push({
|
||
name: '任务状态变为已取消且取消按钮消失',
|
||
ok: cancelled.ok && cancelled.after.includes('已取消') && !cancelled.after.includes('派工')
|
||
&& !cancelled.after.includes('取消取消'),
|
||
before: cancelled.before,
|
||
after: cancelled.after,
|
||
})
|
||
assertions.push({
|
||
name: 'POST /task/cancel 返回 task.status=cancelled',
|
||
ok: cancelRecord?.httpStatus === 200 && cancelledTask?.status === 'cancelled',
|
||
before: '(无)',
|
||
after: `HTTP ${cancelRecord?.httpStatus ?? '(无)'} status=${cancelledTask?.status ?? '(无)'}`,
|
||
})
|
||
}
|
||
} else if (scenario === 'revise') {
|
||
const switched = await switchPreviewState(hooks, rootVNode, 'artifacts', '', tree)
|
||
tree = switched.tree
|
||
passes += switched.passes
|
||
log(`[live] 已切到成果页:${switched.clickedTab || '(未切换)'}`)
|
||
|
||
const name = live.preparedArtifact?.displayName
|
||
if (!name) fail('[live] revise 场景没有准备好的成果')
|
||
const opened = await openArtifactLive(hooks, rootVNode, tree, name)
|
||
tree = opened.tree
|
||
passes += opened.passes
|
||
|
||
const reviseOpened = await openRevisionFormLive(hooks, rootVNode, tree)
|
||
tree = reviseOpened.tree
|
||
passes += reviseOpened.passes
|
||
|
||
const submitted = await submitRevisionLive(
|
||
hooks,
|
||
rootVNode,
|
||
tree,
|
||
'请把标题改得更清楚,并补一张 800px 宽的截图。',
|
||
)
|
||
tree = submitted.tree
|
||
passes += submitted.passes
|
||
|
||
const revisionRecord = live.revisions.length > 0 ? live.revisions[live.revisions.length - 1] : null
|
||
const revisionTask = revisionRecord?.payload?.value?.task
|
||
if (revisionRecord) {
|
||
log(`[live] /artifact/revision 返回:HTTP ${revisionRecord.httpStatus} ${JSON.stringify(revisionRecord.payload)}`)
|
||
}
|
||
assertions.push({
|
||
name: 'POST /artifact/revision 返回 200 且任务是 artifact-revision',
|
||
ok: revisionRecord?.httpStatus === 200
|
||
&& revisionTask?.kind === 'revision'
|
||
&& revisionTask?.scope?.kind === 'artifact-revision',
|
||
before: '(无)',
|
||
after: `HTTP ${revisionRecord?.httpStatus ?? '(无)'} kind=${revisionTask?.kind ?? '(无)'} scope=${revisionTask?.scope?.kind ?? '(无)'}`,
|
||
})
|
||
const revisionRow = findMounted(submitted.tree, (node) => classNameOf(node).includes('wb-task') && textOf(node).includes('修订'))
|
||
assertions.push({
|
||
name: '任务页出现带「修订」标签的新任务行',
|
||
ok: Boolean(revisionRow) && submitted.ok,
|
||
before: '(无)',
|
||
after: revisionRow ? textOf(revisionRow) : '(未找到)',
|
||
})
|
||
} else if (scenario === 'missing') {
|
||
const switched = await switchPreviewState(hooks, rootVNode, 'artifacts', '', tree)
|
||
tree = switched.tree
|
||
passes += switched.passes
|
||
log(`[live] 已切到成果页:${switched.clickedTab || '(未切换)'}`)
|
||
|
||
const name = live.preparedArtifact?.displayName
|
||
if (!name) fail('[live] missing 场景没有准备好的成果')
|
||
const row = findMounted(tree, (node) => classNameOf(node).includes('wb-artifact') && textOf(node).includes(name))
|
||
const rowClass = row ? classNameOf(row) : ''
|
||
const rowText = row ? textOf(row) : ''
|
||
log(`[live] 失效成果行:class="${rowClass}" text="${rowText}"`)
|
||
assertions.push({
|
||
name: '缺失文件显示虚线淡红卡(is-missing)',
|
||
ok: Boolean(row) && rowClass.includes('is-missing'),
|
||
before: '(无)',
|
||
after: rowClass,
|
||
})
|
||
assertions.push({
|
||
name: '缺失文件行显示「· 文件已失效」',
|
||
ok: Boolean(row) && rowText.includes('文件已失效'),
|
||
before: '(无)',
|
||
after: rowText,
|
||
})
|
||
} else {
|
||
fail(`--live 未知场景:${scenario}`)
|
||
}
|
||
|
||
const dispatch = live.dispatches.length > 0 ? live.dispatches[live.dispatches.length - 1] : null
|
||
return {
|
||
tree,
|
||
passes,
|
||
assertions,
|
||
requests: live.requests,
|
||
dispatches: live.dispatches,
|
||
cancellations: live.cancellations,
|
||
revisions: live.revisions,
|
||
preparedArtifact: live.preparedArtifact ?? null,
|
||
dispatchStatus: dispatch ? dispatch.status : null,
|
||
prompts: live.prompts,
|
||
projectId,
|
||
controllerCalls: live.controller.calls,
|
||
}
|
||
}
|
||
|
||
/* #endregion */
|
||
|
||
function pickComponent(exports) {
|
||
const keys = Object.keys(exports || {})
|
||
const preview = exports && exports.__preview
|
||
if (preview) {
|
||
if (typeof preview === 'function') {
|
||
return { component: preview, props: {}, mode: '__preview(function)' }
|
||
}
|
||
if (typeof preview === 'object') {
|
||
const component = preview.component || preview.default || preview.render
|
||
if (typeof component === 'function') {
|
||
return { component, props: preview.props || {}, mode: '__preview(object)' }
|
||
}
|
||
}
|
||
}
|
||
|
||
const preferred = [
|
||
'SanshengWorkbenchPanel',
|
||
'WorkbenchPanel',
|
||
'SanshengPanel',
|
||
'Workbench',
|
||
'Panel',
|
||
'default',
|
||
]
|
||
for (const name of preferred) {
|
||
const value = exports && exports[name]
|
||
if (typeof value === 'function') {
|
||
return { component: value, props: {}, mode: `exports.${name}` }
|
||
}
|
||
}
|
||
|
||
// 兜底:任何名字里带 panel/workbench 的函数组件
|
||
for (const name of keys) {
|
||
const value = exports[name]
|
||
if (typeof value === 'function' && /panel|workbench/i.test(name) && !/^create/.test(name)) {
|
||
return { component: value, props: {}, mode: `exports.${name}(name-match)` }
|
||
}
|
||
}
|
||
|
||
return { component: null, props: {}, mode: 'placeholder', keys }
|
||
}
|
||
|
||
// #endregion
|
||
|
||
// #region 渲染流程
|
||
|
||
async function tick(times = 4) {
|
||
for (let index = 0; index < times; index += 1) {
|
||
await new Promise((resolveTick) => setImmediate(resolveTick))
|
||
}
|
||
}
|
||
|
||
function flushLifecycle(hooks) {
|
||
const queue = hooks.pendingLifecycle || []
|
||
hooks.pendingLifecycle = []
|
||
for (const callback of queue) callback()
|
||
}
|
||
|
||
async function settle(hooks, rootVNode, budgetMs = 1500) {
|
||
const started = Date.now()
|
||
let tree = null
|
||
let passes = 0
|
||
let settled = false
|
||
while (passes < 80) {
|
||
passes += 1
|
||
hooks.beginRender()
|
||
tree = mountNode(rootVNode, hooks, 0, 'root')
|
||
hooks.runEffects()
|
||
flushLifecycle(hooks)
|
||
await tick(3)
|
||
if (passes > 6) await new Promise((resolveWait) => setTimeout(resolveWait, 4))
|
||
if (!hooks.consumeDirty()) {
|
||
// 给「effect 里再排一个短定时器」的组件一点时间:最多多等一个 60ms 窗口。
|
||
if (passes <= 3 && Date.now() - started < 400) {
|
||
await new Promise((resolveWait) => setTimeout(resolveWait, 60))
|
||
if (hooks.consumeDirty()) {
|
||
if (Date.now() - started > budgetMs) break
|
||
continue
|
||
}
|
||
}
|
||
settled = true
|
||
break
|
||
}
|
||
if (Date.now() - started > budgetMs) break
|
||
}
|
||
return { tree, passes, settled, elapsedMs: Date.now() - started }
|
||
}
|
||
|
||
function mountedText(node) {
|
||
if (!node) return ''
|
||
if (node.text !== undefined) return String(node.text)
|
||
if (node.fragment) return node.children.map(mountedText).join('')
|
||
const parts = []
|
||
if (node.props && typeof node.props.children === 'string') parts.push(node.props.children)
|
||
if (Array.isArray(node.children)) parts.push(node.children.map(mountedText).join(''))
|
||
return parts.join('')
|
||
}
|
||
|
||
function findMounted(node, predicate) {
|
||
if (!node) return null
|
||
if (predicate(node)) return node
|
||
if (node.fragment) {
|
||
for (const child of node.children) {
|
||
const hit = findMounted(child, predicate)
|
||
if (hit) return hit
|
||
}
|
||
return null
|
||
}
|
||
if (Array.isArray(node.children)) {
|
||
for (const child of node.children) {
|
||
const hit = findMounted(child, predicate)
|
||
if (hit) return hit
|
||
}
|
||
}
|
||
return null
|
||
}
|
||
|
||
function classNameOf(node) {
|
||
const value = node && node.props ? node.props.className : ''
|
||
return typeof value === 'string' ? value.split(/\s+/).filter(Boolean) : []
|
||
}
|
||
|
||
function clickMounted(node) {
|
||
if (!node || !node.props || typeof node.props.onClick !== 'function') return false
|
||
try {
|
||
node.props.onClick({
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
target: {},
|
||
currentTarget: {},
|
||
})
|
||
return true
|
||
} catch (error) {
|
||
log(`模拟点击失败:${error && error.message ? error.message : error}`)
|
||
return false
|
||
}
|
||
}
|
||
|
||
/* 静态 HTML 里没有 React 运行时,Chrome 里点页签不会触发组件状态。
|
||
这里直接在替身的 vnode 上调 onClick,再重渲染一遍抓取目标页签/抽屉。 */
|
||
async function switchPreviewState(hooks, rootVNode, view, openText, initialTree) {
|
||
const labels = { court: '朝堂', tasks: '任务', artifacts: '成果' }
|
||
const label = labels[view]
|
||
const result = { clickedTab: null, openedArtifact: null }
|
||
if (!label) return { ...result, tree: initialTree, passes: 0 }
|
||
const tab = findMounted(initialTree, (node) => {
|
||
const classes = classNameOf(node)
|
||
return node.type === 'button' && classes.includes('wb-tab') && mountedText(node).includes(label)
|
||
})
|
||
if (!tab) {
|
||
log(`没有找到「${label}」页签,保持当前视图`)
|
||
return { ...result, tree: initialTree, passes: 0 }
|
||
}
|
||
clickMounted(tab)
|
||
let next = await settle(hooks, rootVNode, 1500)
|
||
let extraPasses = next.passes
|
||
result.clickedTab = label
|
||
if (openText) {
|
||
const artifact = findMounted(next.tree, (node) => {
|
||
const classes = classNameOf(node)
|
||
if (!classes.includes('wb-artifact')) return false
|
||
const haystack = `${mountedText(node)} ${node.props && node.props.title ? node.props.title : ''}`
|
||
return haystack.includes(openText)
|
||
})
|
||
if (!artifact) {
|
||
log(`成果页里没有匹配「${openText}」的行,抽屉不打开`)
|
||
} else if (clickMounted(artifact)) {
|
||
result.openedArtifact = openText
|
||
next = await settle(hooks, rootVNode, 1500)
|
||
extraPasses += next.passes
|
||
}
|
||
}
|
||
return { ...result, tree: next.tree, passes: extraPasses }
|
||
}
|
||
|
||
/* 在真实 Chrome 里按最终 DOM 的 rect 重算连线。
|
||
React 替身环境里 getBoundingClientRect 全是 0,bundle 的 measure() 会退到
|
||
computeRailLayout 的几何坐标;那套坐标和真实 CSS 布局(rail 内边距、
|
||
行高、卡片实际高度)不是同一套,端点会落在卡片上方。这里在页面加载后
|
||
用真浏览器的 rect 重写 4 条 path,公式与 bundle 的 branchPathD / trunk 完全一致:
|
||
分叉:M cx0 y0 V mid C cx0 y1 cx1 mid cx1 y1 (mid = y0 + (y1-y0)*0.55)
|
||
主干:M cx bottom L cx group.top
|
||
只跑一次(成功即 done),失败留给后续 tick 重试,不挂 MutationObserver。 */
|
||
const WIRE_RECOMPUTE = `
|
||
(function () {
|
||
var done = false;
|
||
function r(value) { return Math.round(Number(value) * 10) / 10; }
|
||
function rel(element, box) {
|
||
var rect = element.getBoundingClientRect();
|
||
return {
|
||
top: rect.top - box.top,
|
||
bottom: rect.bottom - box.top,
|
||
left: rect.left - box.left,
|
||
cx: rect.left - box.left + rect.width / 2,
|
||
width: rect.width,
|
||
height: rect.height
|
||
};
|
||
}
|
||
function recompute() {
|
||
if (done) return;
|
||
var tree = document.querySelector('.wb-tree');
|
||
if (!tree) return;
|
||
var svg = tree.querySelector('svg.wb-wires');
|
||
var leadEl = tree.querySelector('.wb-lead-row .wb-card');
|
||
var trioEls = tree.querySelectorAll('.wb-trio > .wb-card');
|
||
var groupEl = tree.querySelector('.wb-group');
|
||
var pathEls = tree.querySelectorAll('svg.wb-wires path');
|
||
if (!svg || !leadEl || trioEls.length < 3 || !groupEl || pathEls.length < 4) return;
|
||
|
||
var box = tree.getBoundingClientRect();
|
||
if (!box || !box.width || !box.height) return;
|
||
|
||
var lead = rel(leadEl, box);
|
||
var sansheng = [rel(trioEls[0], box), rel(trioEls[1], box), rel(trioEls[2], box)];
|
||
var group = rel(groupEl, box);
|
||
var before = [];
|
||
for (var i = 0; i < pathEls.length; i++) before.push(pathEls[i].getAttribute('d') || '');
|
||
|
||
var y0 = lead.bottom;
|
||
for (var j = 0; j < 3; j++) {
|
||
var y1 = sansheng[j].top;
|
||
if (!(y1 > y0)) return;
|
||
var mid = y0 + (y1 - y0) * 0.55;
|
||
pathEls[j].setAttribute('d',
|
||
'M ' + r(lead.cx) + ' ' + r(y0) +
|
||
' V ' + r(mid) +
|
||
' C ' + r(lead.cx) + ' ' + r(y1) + ' ' + r(sansheng[j].cx) + ' ' + r(mid) +
|
||
' ' + r(sansheng[j].cx) + ' ' + r(y1));
|
||
}
|
||
if (!(group.top > sansheng[1].bottom)) return;
|
||
pathEls[3].setAttribute('d',
|
||
'M ' + r(sansheng[1].cx) + ' ' + r(sansheng[1].bottom) +
|
||
' L ' + r(sansheng[1].cx) + ' ' + r(group.top));
|
||
|
||
svg.setAttribute('width', String(Math.round(box.width)));
|
||
svg.setAttribute('height', String(Math.round(box.height)));
|
||
|
||
var after = [];
|
||
for (var k = 0; k < pathEls.length; k++) after.push(pathEls[k].getAttribute('d') || '');
|
||
var report = {
|
||
applied: true,
|
||
box: { width: box.width, height: box.height },
|
||
lead: lead,
|
||
sansheng: sansheng,
|
||
group: group,
|
||
before: before,
|
||
after: after
|
||
};
|
||
var marker = document.getElementById('pv-wires');
|
||
if (!marker) {
|
||
marker = document.createElement('script');
|
||
marker.type = 'application/json';
|
||
marker.id = 'pv-wires';
|
||
document.body.appendChild(marker);
|
||
}
|
||
marker.textContent = JSON.stringify(report);
|
||
document.documentElement.setAttribute('data-pv-wires', 'applied');
|
||
done = true;
|
||
}
|
||
function tick() {
|
||
try { recompute(); } catch (error) {
|
||
document.documentElement.setAttribute('data-pv-wires', 'error:' + String(error && error.message || error));
|
||
}
|
||
}
|
||
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', tick);
|
||
else tick();
|
||
requestAnimationFrame(function () { requestAnimationFrame(tick); });
|
||
window.addEventListener('load', tick);
|
||
setTimeout(tick, 60);
|
||
setTimeout(tick, 250);
|
||
setTimeout(tick, 800);
|
||
})();
|
||
`
|
||
|
||
function buildPage({ css, panelHtml, width, theme }) {
|
||
const dark = theme === 'dark'
|
||
const shellCss = `
|
||
*{box-sizing:border-box}
|
||
html,body{margin:0;padding:0}
|
||
body{
|
||
background:#eef0f4;color:#1f2329;
|
||
font-family:"Segoe UI","Microsoft YaHei",-apple-system,BlinkMacSystemFont,"Helvetica Neue",Arial,sans-serif;
|
||
-webkit-font-smoothing:antialiased;
|
||
}
|
||
.pv-shell{width:${width}px;min-height:100vh;display:flex;flex-direction:column;background:#f7f8fa;overflow:hidden}
|
||
.pv-chat-head{
|
||
flex:0 0 auto;display:flex;align-items:center;gap:8px;
|
||
padding:10px 12px;background:#ffffff;border-bottom:1px solid #e2e6ec;
|
||
font-size:12px;line-height:18px;color:#5b6472;
|
||
}
|
||
.pv-chat-avatar{
|
||
width:24px;height:24px;border-radius:50%;
|
||
background:linear-gradient(135deg,#5b8def,#8a63f4);color:#fff;
|
||
display:flex;align-items:center;justify-content:center;font-size:11px;font-weight:600;
|
||
}
|
||
.pv-chat-title{font-weight:600;color:#1f2329;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
|
||
.pv-chat-sub{margin-left:auto;font-size:11px;color:#8b93a1;white-space:nowrap}
|
||
.pv-panel{flex:1 1 auto;min-height:0;padding:10px 12px 16px;overflow:visible}
|
||
.pv-shell .sl-root{height:auto!important;min-height:0!important;background:transparent!important;color:inherit}
|
||
.pv-shell .sl-body{background:transparent}
|
||
.pv-shell .sl-body-sidebar{padding:0;overflow:visible}
|
||
.pv-shell .sl-body-sidebar .sl-right{overflow:visible;padding-right:0}
|
||
.pv-placeholder{
|
||
border:1px dashed #b6bfcc;border-radius:8px;padding:12px;background:#fff;color:#1f2329;
|
||
font-size:12px;line-height:1.5;
|
||
}
|
||
.pv-placeholder h3{margin:0 0 6px;font-size:13px}
|
||
.pv-placeholder pre{
|
||
margin:8px 0 0;padding:8px;background:#f2f4f7;border-radius:6px;
|
||
font-size:11px;white-space:pre-wrap;word-break:break-all;color:#475063;
|
||
}
|
||
html.dark body{background:#0e1014;color:#e8eaee}
|
||
html.dark .pv-shell{background:#111318}
|
||
html.dark .pv-chat-head{background:#16181d;border-bottom-color:#262a32;color:#a9b0bd}
|
||
html.dark .pv-chat-title{color:#e8eaee}
|
||
html.dark .pv-chat-sub{color:#7f8794}
|
||
html.dark .pv-placeholder{background:#1a1d24;border-color:#333a46;color:#e8eaee}
|
||
html.dark .pv-placeholder pre{background:#22262f;color:#c7cedb}
|
||
`
|
||
|
||
const darkOverride = dark
|
||
? `
|
||
/* 兜底:bundle 若用媒体查询切暗色,--blink-settings=preferredColorScheme=0 已生效;
|
||
若用 .dark 类名切暗色,这里保证外壳的语义变量也进入暗色。 */
|
||
html.dark{
|
||
color-scheme:dark;
|
||
--dsw-alias-bg-layer-1:#1f222a;
|
||
--dsw-alias-bg-layer-2:#16181d;
|
||
--dsw-alias-bg-layer-3:rgba(255,255,255,.10);
|
||
--dsw-alias-label-primary:#e8eaee;
|
||
--dsw-alias-label-secondary:#b7bcc6;
|
||
--dsw-alias-label-tertiary:#8b93a1;
|
||
--dsw-alias-label-caption:#7f8794;
|
||
--dsw-alias-border-l1:rgba(255,255,255,.12);
|
||
--dsw-alias-border-l2:rgba(255,255,255,.18);
|
||
--dsw-alias-border-l3:rgba(255,255,255,.28);
|
||
--dsw-alias-state-business-primary:#6b8afd;
|
||
--dsw-alias-state-error-primary:#f2777a;
|
||
}
|
||
`
|
||
: ''
|
||
|
||
const html = `<!doctype html>
|
||
<html lang="zh-CN"${dark ? ' class="dark" data-theme="dark"' : ''}>
|
||
<head>
|
||
<meta charset="utf-8">
|
||
<meta name="viewport" content="width=${width}, initial-scale=1">
|
||
<title>三省六部 · 工作台预览 (${theme} / ${width}px)</title>
|
||
<style>
|
||
${shellCss}
|
||
${css}
|
||
${darkOverride}
|
||
</style>
|
||
</head>
|
||
<body>
|
||
<div class="pv-shell" data-dsw-theme="${theme}" data-pv-width="${width}">
|
||
<header class="pv-chat-head">
|
||
<div class="pv-chat-avatar">三</div>
|
||
<div class="pv-chat-title">三省六部 · 工作台</div>
|
||
<div class="pv-chat-sub">${theme} · ${width}px</div>
|
||
</header>
|
||
<main class="pv-panel">
|
||
${panelHtml}
|
||
</main>
|
||
</div>
|
||
<script>
|
||
${WIRE_RECOMPUTE}
|
||
</script>
|
||
<div id="pv-height" hidden></div>
|
||
<script>
|
||
(function () {
|
||
function measure() {
|
||
var shell = document.querySelector('.pv-shell');
|
||
var shellHeight = shell ? Math.ceil(shell.getBoundingClientRect().height) : 0;
|
||
var height = Math.max(
|
||
document.documentElement.scrollHeight,
|
||
document.body.scrollHeight,
|
||
shellHeight
|
||
);
|
||
var marker = document.getElementById('pv-height');
|
||
if (marker) marker.textContent = String(height);
|
||
}
|
||
measure();
|
||
requestAnimationFrame(function () { measure(); });
|
||
setTimeout(measure, 80);
|
||
})();
|
||
</script>
|
||
</body>
|
||
</html>
|
||
`
|
||
return html
|
||
}
|
||
|
||
function measureHeight(chrome, htmlPath, width, theme, profileDir) {
|
||
const args = [
|
||
'--headless=new',
|
||
'--disable-gpu',
|
||
'--disable-crash-reporter',
|
||
'--disable-breakpad',
|
||
'--no-first-run',
|
||
'--hide-scrollbars',
|
||
`--window-size=${width},200`,
|
||
'--force-device-scale-factor=1',
|
||
'--virtual-time-budget=3000',
|
||
'--dump-dom',
|
||
`--user-data-dir=${profileDir}`,
|
||
]
|
||
if (theme === 'dark') args.push('--blink-settings=preferredColorScheme=0')
|
||
args.push(pathToFileURL(htmlPath).href)
|
||
const result = chromeRun(chrome, args, '量高')
|
||
const dom = String(result.stdout || '')
|
||
const match = /id="pv-height"[^>]*>([0-9]+)</.exec(dom)
|
||
if (!match) {
|
||
fail(`量高失败:页面里没有写回 #pv-height。dump-dom 前 500 字符:\n${dom.slice(0, 500)}`)
|
||
}
|
||
const measured = Number.parseInt(match[1], 10)
|
||
const height = Math.max(200, Math.min(4000, measured))
|
||
|
||
// 连线重算脚本把真实 rect 与 before/after d 写进 #pv-wires(JSON)。
|
||
// 旧 bundle 没有 .wb-tree,这个标记不存在,属正常情况。
|
||
let wires = null
|
||
const wireMatch = /id="pv-wires"[^>]*>([\s\S]*?)<\/script>/.exec(dom)
|
||
if (wireMatch) {
|
||
const raw = wireMatch[1]
|
||
.replace(/"/g, '"')
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
try {
|
||
wires = JSON.parse(raw)
|
||
} catch (error) {
|
||
log(`连线重算结果解析失败:${error && error.message ? error.message : error}`)
|
||
}
|
||
}
|
||
return { height, wires, dom }
|
||
}
|
||
|
||
function screenshot(chrome, htmlPath, pngPath, width, height, theme, scale, profileDir) {
|
||
const args = [
|
||
'--headless=new',
|
||
'--disable-gpu',
|
||
'--disable-crash-reporter',
|
||
'--disable-breakpad',
|
||
'--no-first-run',
|
||
'--hide-scrollbars',
|
||
`--window-size=${width},${height}`,
|
||
`--force-device-scale-factor=${scale}`,
|
||
'--virtual-time-budget=2000',
|
||
`--screenshot=${pngPath}`,
|
||
`--user-data-dir=${profileDir}`,
|
||
]
|
||
if (theme === 'dark') args.push('--blink-settings=preferredColorScheme=0')
|
||
args.push(pathToFileURL(htmlPath).href)
|
||
chromeRun(chrome, args, '截图')
|
||
if (!existsSync(pngPath)) fail(`Chrome 没有写出截图:${pngPath}`)
|
||
const size = readPngSize(pngPath)
|
||
const expectedWidth = width * scale
|
||
if (size.width !== expectedWidth) {
|
||
fail(`截图宽度异常:期望 ${expectedWidth}px,实际 ${size.width}px(${pngPath})`)
|
||
}
|
||
if (size.bytes < 3000) {
|
||
fail(`截图疑似空白:${pngPath} 只有 ${size.bytes} 字节`)
|
||
}
|
||
return size
|
||
}
|
||
|
||
async function main() {
|
||
const options = parseArgs(process.argv.slice(2))
|
||
if (options.help) {
|
||
process.stdout.write(`${usage()}\n`)
|
||
return
|
||
}
|
||
|
||
const theme = String(options.theme)
|
||
if (theme !== 'light' && theme !== 'dark') fail(`--theme 只能是 light 或 dark,收到:${theme}`)
|
||
const width = Number.parseInt(options.width, 10)
|
||
if (!Number.isFinite(width) || width < 200 || width > 1200) fail(`--width 需要在 200–1200 之间,收到:${options.width}`)
|
||
const scale = Number.parseInt(options.scale, 10)
|
||
if (!Number.isFinite(scale) || scale < 1 || scale > 4) fail(`--scale 需要在 1–4 之间,收到:${options.scale}`)
|
||
const name = String(options.name)
|
||
if (!/^[A-Za-z0-9._-]+$/.test(name)) fail(`--name 只允许字母、数字、点、下划线和短横线,收到:${name}`)
|
||
const view = String(options.view || 'court')
|
||
if (!['court', 'tasks', 'artifacts'].includes(view)) fail(`--view 只能是 court / tasks / artifacts,收到:${view}`)
|
||
const openText = String(options.open || '')
|
||
const scenario = options.live ? String(options.scenario || inferLiveScenario(name, view)) : ''
|
||
if (options.live && !['court', 'tasks', 'cancel', 'revise', 'missing'].includes(scenario)) {
|
||
fail(`--scenario 只能是 court / tasks / cancel / revise / missing,收到:${scenario}`)
|
||
}
|
||
const effectiveView = scenario === 'revise' || scenario === 'missing'
|
||
? 'artifacts'
|
||
: (scenario === 'cancel' ? 'tasks' : (openText && view === 'court' ? 'artifacts' : view))
|
||
|
||
const bundlePath = resolve(ROOT, options.bundle)
|
||
const outDir = resolve(ROOT, options.out)
|
||
ensureDir(SCRATCH)
|
||
ensureDir(outDir)
|
||
|
||
if (!existsSync(bundlePath)) {
|
||
fail(`bundle 不存在:${bundlePath}\n(相对路径按仓库根目录解析:${ROOT})`)
|
||
}
|
||
|
||
const pngPath = join(outDir, `${name}-${width}-${theme}.png`)
|
||
const htmlPath = join(SCRATCH, `${name}-${width}-${theme}.html`)
|
||
const profileDir = join(SCRATCH, 'chrome-profile')
|
||
ensureDir(profileDir)
|
||
|
||
let live = null
|
||
if (options.live) {
|
||
log('模式:--live(真实 Host 路由,内存账本,不使用固定数据)')
|
||
live = await setupLiveHost()
|
||
await registerLiveProject(live)
|
||
await prepareLiveScenario(live, scenario)
|
||
}
|
||
|
||
log(`加载 bundle:${bundlePath}`)
|
||
const hooks = createHooks()
|
||
const loaded = loadBundle(bundlePath, hooks, { theme, fetchStub: live ? live.fetchLive : null })
|
||
log(`bundle 导出键:${Object.keys(loaded.exports).join(', ') || '(空)'}`)
|
||
log(`捕获 CSS:${loaded.css.length} 字符`)
|
||
|
||
const picked = pickComponent(loaded.exports)
|
||
log(`渲染入口:${picked.mode}`)
|
||
|
||
let component = picked.component
|
||
let props = { ...picked.props }
|
||
let placeholder = false
|
||
let entryMode = picked.mode
|
||
|
||
if (live && typeof loaded.exports.WorkbenchRail === 'function') {
|
||
// 真实 Host 模式下用 rail 本体(WorkbenchPanel 会丢掉 projectId 并走工作区推导,
|
||
// 这里已经有真实注册出来的项目号,直接喂给它)。
|
||
component = loaded.exports.WorkbenchRail
|
||
props = { ctx: createLiveUiContext(), projectId: live.projectId, compact: true }
|
||
entryMode = 'exports.WorkbenchRail(live)'
|
||
log(`渲染入口改为 exports.WorkbenchRail(projectId=${live.projectId})`)
|
||
} else if (typeof component !== 'function') {
|
||
placeholder = true
|
||
const keyList = (picked.keys || Object.keys(loaded.exports)).join(', ') || '(空)'
|
||
log(`没有找到面板组件,退化为占位 div。bundle 导出键:${keyList}`)
|
||
component = () => hooks.React.createElement(
|
||
'div',
|
||
{ className: 'pv-placeholder' },
|
||
hooks.React.createElement('h3', null, '预览占位'),
|
||
hooks.React.createElement('p', null, '这个 bundle 没有导出 __preview,也没有可识别的默认面板组件。'),
|
||
hooks.React.createElement('pre', null, `导出键:${keyList}`),
|
||
)
|
||
props = {}
|
||
} else if (typeof loaded.exports.createHost === 'function') {
|
||
try {
|
||
const demo = createDemoContext()
|
||
props = {
|
||
...props,
|
||
host: loaded.exports.createHost(demo.ctx),
|
||
sessionId: LEAD_SESSION,
|
||
compact: true,
|
||
}
|
||
log('已用 createHost(ctx) 构造旧式 host')
|
||
} catch (error) {
|
||
log(`createHost 失败,改为直接传 props:${error && error.message ? error.message : error}`)
|
||
}
|
||
}
|
||
|
||
if (!live && props.projectId === undefined) props.projectId = 'prj_demo1'
|
||
if (!live && props.sessionId === undefined) props.sessionId = LEAD_SESSION
|
||
if (props.compact === undefined) props.compact = true
|
||
|
||
const rootVNode = hooks.React.createElement(component, props)
|
||
const settleResult = await settle(hooks, rootVNode, 1500)
|
||
log(`渲染稳定:${settleResult.settled ? '是' : '否(达到 1.5s 预算)'},${settleResult.passes} 轮,${settleResult.elapsedMs}ms`)
|
||
|
||
let tree = settleResult.tree
|
||
let stateSwitch = { clickedTab: null, openedArtifact: null }
|
||
let liveScenario = null
|
||
if (live) {
|
||
liveScenario = await runLiveScenario({
|
||
hooks,
|
||
rootVNode,
|
||
view: effectiveView,
|
||
live,
|
||
projectId: live.projectId,
|
||
scenario,
|
||
})
|
||
tree = liveScenario.tree
|
||
settleResult.passes += liveScenario.passes
|
||
for (const assertion of liveScenario.assertions) {
|
||
log(`[live] 断言「${assertion.name}」:${assertion.ok ? '通过' : '未通过'};after=${assertion.after}`)
|
||
}
|
||
log(`[live] 请求 ${liveScenario.requests.length} 次;dispatch.status=${liveScenario.dispatchStatus ?? '(无)'};prompt ${liveScenario.prompts.length} 条`)
|
||
} else if (effectiveView !== 'court' || openText) {
|
||
const switched = await switchPreviewState(hooks, rootVNode, effectiveView, openText, tree)
|
||
tree = switched.tree
|
||
stateSwitch = { clickedTab: switched.clickedTab, openedArtifact: switched.openedArtifact }
|
||
settleResult.passes += switched.passes
|
||
log(`视图切换:${stateSwitch.clickedTab || '(未切换)'}${stateSwitch.openedArtifact ? `,已打开成果「${stateSwitch.openedArtifact}」` : ''}`)
|
||
}
|
||
|
||
const panelHtml = serializeNode(tree)
|
||
const html = buildPage({ css: loaded.css, panelHtml, width, theme })
|
||
writeFileSync(htmlPath, html, 'utf8')
|
||
log(`HTML:${htmlPath}(${html.length} 字符,面板 DOM ${panelHtml.length} 字符)`)
|
||
|
||
const chrome = findChrome(options.chrome)
|
||
log(`Chrome:${chrome}`)
|
||
const measured = measureHeight(chrome, htmlPath, width, theme, profileDir)
|
||
const height = measured.height
|
||
log(`页面 scrollHeight:${height}px`)
|
||
|
||
const wires = measured.wires
|
||
if (wires && wires.applied) {
|
||
log(`连线重算:已按真实 DOM rect 重写 ${wires.after.length} 条 path`)
|
||
log(` 分叉[0] before:${wires.before[0]}`)
|
||
log(` 分叉[0] after :${wires.after[0]}`)
|
||
log(` 丞相底边 y=${wires.lead.bottom},三省顶边 y=${wires.sansheng.map((card) => card.top).join('/')},六部组顶边 y=${wires.group.top}`)
|
||
log(` 端点:分支终点 y 与卡片 top 相等;主干终点 y 与 group.top 相等(${wires.group.top})`)
|
||
} else {
|
||
log('连线重算:页面里没有 .wb-tree 或未写入 #pv-wires(旧 bundle / 占位渲染属正常)')
|
||
}
|
||
|
||
const size = screenshot(chrome, htmlPath, pngPath, width, height, theme, scale, profileDir)
|
||
log(`截图:${pngPath}(${size.width}x${size.height},${size.bytes} 字节,scale=${scale})`)
|
||
|
||
const sourceLines = readFileSync(fileURLToPath(import.meta.url), 'utf8').split(/\r?\n/).length
|
||
const report = {
|
||
bundle: bundlePath,
|
||
bundleBase: options.bundle,
|
||
bundleBytes: statSync(bundlePath).size,
|
||
entry: entryMode,
|
||
placeholder,
|
||
live: liveScenario
|
||
? {
|
||
projectId: liveScenario.projectId,
|
||
requests: liveScenario.requests,
|
||
dispatches: liveScenario.dispatches,
|
||
cancellations: liveScenario.cancellations,
|
||
revisions: liveScenario.revisions,
|
||
preparedArtifact: liveScenario.preparedArtifact,
|
||
dispatchStatus: liveScenario.dispatchStatus,
|
||
prompts: liveScenario.prompts.map((entry) => ({
|
||
sessionId: entry.sessionId,
|
||
requestId: entry.requestId,
|
||
text: entry.text.slice(0, 200),
|
||
chars: entry.text.length,
|
||
})),
|
||
assertions: liveScenario.assertions,
|
||
controllerCalls: liveScenario.controllerCalls,
|
||
}
|
||
: null,
|
||
theme,
|
||
width,
|
||
scale,
|
||
view: effectiveView,
|
||
scenario: scenario || null,
|
||
openedArtifact: stateSwitch.openedArtifact,
|
||
html: htmlPath,
|
||
png: pngPath,
|
||
pngSize: { width: size.width, height: size.height, bytes: size.bytes },
|
||
scrollHeight: height,
|
||
passes: settleResult.passes,
|
||
settled: settleResult.settled,
|
||
elapsedMs: settleResult.elapsedMs,
|
||
cssLength: loaded.css.length,
|
||
exportKeys: Object.keys(loaded.exports),
|
||
wireRecompute: wires && wires.applied
|
||
? {
|
||
applied: true,
|
||
box: wires.box,
|
||
branchBefore: wires.before[0],
|
||
branchAfter: wires.after[0],
|
||
trunkBefore: wires.before[3],
|
||
trunkAfter: wires.after[3],
|
||
leadBottom: wires.lead.bottom,
|
||
sanshengTops: wires.sansheng.map((card) => card.top),
|
||
groupTop: wires.group.top,
|
||
}
|
||
: null,
|
||
scriptLines: sourceLines,
|
||
}
|
||
if (liveScenario) {
|
||
const liveLogPath = join(SCRATCH, `${name}-${width}-${theme}-live.json`)
|
||
writeFileSync(liveLogPath, JSON.stringify({
|
||
bundle: bundlePath,
|
||
projectId: liveScenario.projectId,
|
||
requests: liveScenario.requests,
|
||
dispatches: liveScenario.dispatches,
|
||
cancellations: liveScenario.cancellations,
|
||
revisions: liveScenario.revisions,
|
||
preparedArtifact: liveScenario.preparedArtifact,
|
||
dispatchStatus: liveScenario.dispatchStatus,
|
||
prompts: liveScenario.prompts,
|
||
assertions: liveScenario.assertions,
|
||
controllerCalls: liveScenario.controllerCalls,
|
||
}, null, 2), 'utf8')
|
||
log(`[live] 请求/派发/prompt 日志:${liveLogPath}`)
|
||
}
|
||
process.stdout.write(`PREVIEW_RESULT ${JSON.stringify(report)}\n`)
|
||
}
|
||
|
||
main().catch((error) => {
|
||
if (error && error.previewFailure) {
|
||
process.stderr.write(`\n[preview-workbench] 失败:${error.message}\n`)
|
||
} else {
|
||
process.stderr.write(`\n[preview-workbench] 未预期错误:${error && error.stack ? error.stack : error}\n`)
|
||
}
|
||
process.exitCode = 1
|
||
})
|