workspace-groups-remote/tools/preview-rssh-settings.mjs

1121 lines
42 KiB
JavaScript

#!/usr/bin/env node
/**
* tools/preview-rssh-settings.mjs
*
* One command: build the isolated preview bundle → serve it locally → drive a
* headless Chrome over CDP → save real rendered screenshots.
*
* It renders the REAL section component (`src/client/rssh-settings/index.tsx`)
* bundled by Vite, mounted with the fake `/remote-ssh/api` layer. Screenshots
* are therefore real renders of the built component, NOT mockups, and the page
* is clearly labelled 隔离预览.
*
* Usage:
* node tools/preview-rssh-settings.mjs # requires the real component
* node tools/preview-rssh-settings.mjs --smoke # pipeline smoke test (mock component)
* node tools/preview-rssh-settings.mjs --only=01-default,07-dark
*
* Exit code 0 only when every requested screenshot was produced.
*
* What it never does: touch the running DSH GUI, the daily profile, an
* installed plugin directory or package.json. Chrome runs with its own
* throwaway user-data-dir and is killed before exit; the local HTTP server is
* closed too.
*/
import { spawn, spawnSync } from 'node:child_process'
import { existsSync, readFileSync } from 'node:fs'
import fs from 'node:fs/promises'
import http from 'node:http'
import os from 'node:os'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
const HERE = path.dirname(fileURLToPath(import.meta.url))
const ROOT = path.resolve(HERE, '..')
const PREVIEW_DIR = path.join(ROOT, 'tools', 'preview')
const REAL_COMPONENT = path.join(ROOT, 'src', 'client', 'rssh-settings', 'index.tsx')
const MODAL_STUB = path.join(PREVIEW_DIR, 'modal-stub.tsx')
const CHROME_PATH = 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
const OUT_DIR = path.join(ROOT, 'screenshots', 'remote-ssh-settings')
const TEMP_ROOT = path.join(os.tmpdir(), `rssh-settings-preview-${process.pid}`)
const args = process.argv.slice(2)
const BUILD_ONLY = args.includes('--build-only')
const KEEP_TEMP = args.includes('--keep-temp')
const onlyArg = args.find(item => item.startsWith('--only='))
const ONLY = onlyArg ? onlyArg.slice('--only='.length).split(',').map(item => item.trim()).filter(Boolean) : null
const log = (message) => console.log(`[preview] ${message}`)
const warn = (message) => console.warn(`[preview][warn] ${message}`)
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
/* ------------------------------------------------------------------ */
/* Scene table */
/* ------------------------------------------------------------------ */
const fillAddForm = async ctx => {
await ctx.setValue('[data-rsui-field="name"]', '超算集群(测试)')
await ctx.setValue('[data-rsui-field="host"]', 'login.hpc.example.com')
await ctx.setValue('[data-rsui-field="user"]', 'demo-user')
await ctx.setValue('[data-rsui-field="keyPath"]', '~/.ssh/id_ed25519')
await ctx.setValue('[data-rsui-field="remoteRoot"]', '~/project')
}
const expandAll = async ctx => {
await ctx.click('[data-rsui-toggle-advanced]')
await ctx.waitVisible('[data-rsui-advanced-content]', '高级设置内容展开')
await ctx.waitAttr('[data-rsui-toggle-advanced]', 'aria-expanded', 'true', '高级设置 aria-expanded')
await ctx.click('[data-rsui-toggle-workspaces]')
await ctx.waitExists('[data-rsui-workspace]', '远程工作区卡片')
await ctx.waitAttr('[data-rsui-toggle-workspaces]', 'aria-expanded', 'true', '远程工作区 aria-expanded')
await ctx.clickAll('[data-rsui-ws-expand]')
await ctx.waitAttr('[data-rsui-ws-expand]', 'aria-expanded', 'true', '工作区配置展开')
await ctx.click('[data-rsui-toggle-more]')
await ctx.waitAttr('[data-rsui-toggle-more]', 'aria-expanded', 'true', '更多连接选项展开')
await ctx.waitVisible('[data-rsui-field="proxyJump"]', 'ProxyJump 字段')
}
const openImportDialog = async ctx => {
await ctx.click('[data-rsui-import-open]')
await ctx.waitExists('[data-rsui-import-dialog]', '导入弹窗')
await ctx.waitAtLeast('[data-rsui-import-row]', 1, '导入主机行')
await ctx.waitText(/已选\s+\d+\s*\/\s*\d+/, '已选数量')
}
const scenes = [
{
name: '01-default',
title: '默认(高级设置收起)',
query: { scene: 'default', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: [],
checks: [
{
label: '高级设置内容已挂载且处于收起(不可见)状态',
expression: `(() => {
const el = document.querySelector('[data-rsui-advanced-content]');
if (!el) return 'missing data-rsui-advanced-content';
const visible = typeof el.checkVisibility === 'function'
? el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true })
: el.offsetParent !== null;
const expanded = document.querySelector('[data-rsui-toggle-advanced]')?.getAttribute('aria-expanded');
return visible === false && expanded === 'false';
})()`,
},
{
label: '高级设置内没有出现保存按钮(收起时不显示内部按钮)',
expression: `(() => {
const content = document.querySelector('[data-rsui-advanced-content]');
const save = document.querySelector('[data-rsui-prefs-save]');
if (!content || !save) return 'missing content or save button';
const visible = typeof save.checkVisibility === 'function'
? save.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true })
: save.offsetParent !== null;
return visible === false;
})()`,
},
{
label: '添加连接表单初始展开',
expression: `(() => {
const el = document.querySelector('[data-rsui-field="host"]');
return !!el && (typeof el.checkVisibility !== 'function' || el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true }));
})()`,
},
],
},
{
name: '02-expanded',
title: '全部展开(字段可核对)',
query: { scene: 'expanded', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: async ctx => {
await expandAll(ctx)
await fillAddForm(ctx)
await ctx.settle('填写添加连接表单')
},
checks: [
{
label: '高级设置内容可见',
expression: `(() => {
const el = document.querySelector('[data-rsui-advanced-content]');
return !!el && el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true });
})()`,
},
{
label: 'ProxyJump 字段可见',
expression: `(() => {
const el = document.querySelector('[data-rsui-field="proxyJump"]');
return !!el && el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true });
})()`,
},
{
label: '添加表单已填入示例值',
expression: `(() => {
const host = document.querySelector('[data-rsui-field="host"]');
const user = document.querySelector('[data-rsui-field="user"]');
return !!host && !!user && host.value === 'login.hpc.example.com' && user.value === 'demo-user';
})()`,
},
],
},
{
name: '03-import-dialog',
title: 'SSH 导入弹窗(列表 / 已选数量)',
query: { scene: 'import-ready', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'viewport',
actions: async ctx => {
await openImportDialog(ctx)
// Best effort: uncheck one row so the selected counter is visibly dynamic.
const toggled = await ctx.evaluate(`(() => {
const row = document.querySelector('[data-rsui-import-row]');
if (!row) return 'no-row';
const checkbox = row.querySelector('input[type="checkbox"]');
if (!checkbox) return 'no-checkbox';
checkbox.click();
return 'ok';
})()`)
await sleep(250)
if (toggled !== 'ok') warn(`03-import-dialog: could not toggle a row (${toggled}); keeping default selection`)
},
checks: [
{
label: '导入行数量 >= 1',
expression: `document.querySelectorAll('[data-rsui-import-row]').length >= 1`,
},
{
label: '已选数量文案存在',
expression: `(/已选\\s*\\d+\\s*\\/\\s*\\d+/.test(document.body.innerText))`,
},
],
},
{
name: '04-import-partial',
title: '导入部分失败结果 + 仅重试失败项',
query: { scene: 'import-partial', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'viewport',
actions: async ctx => {
await openImportDialog(ctx)
await ctx.click('[data-rsui-import-submit]')
await ctx.waitExists('[data-rsui-import-result]', '导入结果块', 15000)
await ctx.waitExists('[data-rsui-import-retry]', '仅重试失败项按钮', 15000)
await ctx.settle('导入结果渲染')
},
checks: [
{
label: '结果显示部分失败',
expression: `(() => { const block = document.querySelector('[data-rsui-import-result]'); return !!block && /成功\\s*\\d+\\s*个/.test(block.innerText) && /失败\\s*\\d+\\s*个/.test(block.innerText); })()`,
},
{
label: '存在重试按钮且只针对失败项',
expression: `(() => { const btn = document.querySelector('[data-rsui-import-retry]'); return !!btn && btn.innerText.includes('重试失败项'); })()`,
},
{
label: '失败主机逐项列出',
expression: `(() => { const block = document.querySelector('[data-rsui-import-result]'); return !!block && block.innerText.includes('mirror.example.org') && block.innerText.includes('broken.example.net'); })()`,
},
],
},
{
name: '05-workspaces',
title: '远程工作区独立配置展开 + 未保存徽标',
query: { scene: 'workspaces', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: async ctx => {
await ctx.click('[data-rsui-toggle-workspaces]')
await ctx.waitExists('[data-rsui-workspace]', '工作区卡片')
await ctx.clickAll('[data-rsui-ws-expand]')
await ctx.waitAttr('[data-rsui-ws-expand]', 'aria-expanded', 'true', '工作区配置展开')
const edited = await ctx.evaluate(`(() => {
const card = document.querySelector('[data-rsui-workspace]');
if (!card) return 'no-card';
const textarea = card.querySelector('textarea');
if (!textarea) return 'no-textarea';
const proto = HTMLTextAreaElement.prototype;
const setter = Object.getOwnPropertyDescriptor(proto, 'value').set;
setter.call(textarea, textarea.value + (textarea.value ? '\\n' : '') + '_patch/');
textarea.dispatchEvent(new Event('input', { bubbles: true }));
textarea.dispatchEvent(new Event('change', { bubbles: true }));
return 'ok';
})()`)
if (edited !== 'ok') throw new Error(`05-workspaces: could not edit a workspace textarea (${edited})`)
await ctx.waitExists('[data-rsui-ws-dirty]', '未保存徽标', 4000)
await ctx.settle('未保存徽标渲染')
},
checks: [
{
label: '工作区设置已展开',
expression: `(() => { const btn = document.querySelector('[data-rsui-ws-expand]'); return !!btn && btn.getAttribute('aria-expanded') === 'true'; })()`,
},
{
label: '未保存徽标存在',
expression: `!!document.querySelector('[data-rsui-ws-dirty]')`,
},
{
label: '工作区说明文案(写回排除 / 同步排除用途区分)存在',
expression: `(() => { const text = document.body.innerText; return text.includes('写回排除') && text.includes('同步排除') && text.includes('与写回排除用途不同'); })()`,
},
],
},
{
name: '06-password-auth',
title: '密码认证表单',
query: { scene: 'password', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: async ctx => {
await ctx.setValue('[data-rsui-field="authMethod"]', 'password')
await ctx.waitVisible('[data-rsui-field="password"]', '密码输入框')
await ctx.setValue('[data-rsui-field="name"]', '实验室工作站(测试)')
await ctx.setValue('[data-rsui-field="host"]', 'workstation.lab.example.com')
await ctx.setValue('[data-rsui-field="user"]', 'lab-user')
// Sample secret, masked by type=password: never rendered as plain text.
await ctx.setValue('[data-rsui-field="password"]', 'example-masked-secret')
await ctx.settle('密码表单渲染')
await ctx.evaluate(`(() => { if (document.activeElement && document.activeElement.blur) document.activeElement.blur(); return true; })()`)
},
checks: [
{
label: '密码输入框可见且 type=password',
expression: `(() => {
const el = document.querySelector('[data-rsui-field="password"]');
const input = el && (el.matches('input') ? el : el.querySelector('input'));
return !!input && input.type === 'password' && input.getAttribute('autocomplete') === 'new-password';
})()`,
},
{
label: '明文示例密码未出现在页面文本中',
expression: `!document.body.innerText.includes('example-masked-secret')`,
},
{
label: '密码认证卡片(已保存密码)可见',
expression: `document.body.innerText.includes('已保存密码')`,
},
],
},
{
name: '07-dark',
title: '深色模式(全部展开)',
query: { scene: 'expanded', theme: 'dark' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: async ctx => {
await expandAll(ctx)
await fillAddForm(ctx)
await ctx.settle('深色模式渲染')
},
checks: [
{
label: '深色主题已生效',
expression: `document.documentElement.dataset.theme === 'dark'`,
},
{
label: '深色模式页面背景为暗色',
expression: `(() => { const bg = getComputedStyle(document.body).backgroundColor; const m = bg.match(/rgb\\((\\d+),\\s*(\\d+),\\s*(\\d+)/); return !!m && (Number(m[1]) + Number(m[2]) + Number(m[3])) / 3 < 80; })()`,
},
{
label: '高级设置内容可见',
expression: `(() => { const el = document.querySelector('[data-rsui-advanced-content]'); return !!el && el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true }); })()`,
},
],
},
{
name: '08-narrow',
title: '窄屏约 480px 单列',
query: { scene: 'default', theme: 'light' },
viewport: { width: 480, height: 900 },
capture: 'full',
actions: async ctx => {
await ctx.setValue('[data-rsui-field="host"]', 'login.hpc.example.com')
await ctx.setValue('[data-rsui-field="user"]', 'demo-user')
await ctx.settle('窄屏渲染')
},
checks: [
{
label: '视口宽度约 480px',
expression: `Math.abs(window.innerWidth - 480) <= 8`,
},
{
label: '表单在窄屏下单列排布(端口与用户名不再并排)',
expression: `(() => {
const port = document.querySelector('[data-rsui-field="port"]');
const user = document.querySelector('[data-rsui-field="user"]');
if (!port || !user) return 'missing fields';
const portInput = port.matches('input') ? port : port.querySelector('input');
const userInput = user.matches('input') ? user : user.querySelector('input');
if (!portInput || !userInput) return 'missing inputs';
const a = portInput.getBoundingClientRect();
const b = userInput.getBoundingClientRect();
if (!a.width || !b.width) return 'zero width';
return Math.abs(a.top - b.top) > 8;
})()`,
},
{
label: '页面无横向溢出',
expression: `document.documentElement.scrollWidth <= window.innerWidth + 2`,
},
],
},
{
name: '09-test-failure',
title: '连接测试失败诊断',
query: { scene: 'test-failure', theme: 'light' },
viewport: { width: 1280, height: 900 },
capture: 'full',
actions: async ctx => {
await ctx.click('[data-rsui-test]')
await ctx.waitExists('[data-rsui-test-result][data-status="error"]', '连接失败结果块', 6000)
await ctx.settle('诊断输出渲染')
await ctx.evaluate(`(() => { if (document.activeElement && document.activeElement.blur) document.activeElement.blur(); return true; })()`)
},
checks: [
{
label: '失败结果块状态为 error',
expression: `document.querySelector('[data-rsui-test-result]').getAttribute('data-status') === 'error'`,
},
{
label: '显示连接失败与诊断输出',
expression: `(() => { const block = document.querySelector('[data-rsui-test-result]'); return !!block && block.innerText.includes('连接失败') && (block.innerText.includes('Connection timed out') || block.innerText.includes('诊断输出')); })()`,
},
],
},
]
/* ------------------------------------------------------------------ */
/* Vite build */
/* ------------------------------------------------------------------ */
async function walkFiles(directory) {
const entries = await fs.readdir(directory, { withFileTypes: true })
const results = []
for (const entry of entries) {
const entryPath = path.join(directory, entry.name)
if (entry.isDirectory()) results.push(...(await walkFiles(entryPath)))
else results.push(entryPath)
}
return results
}
function htmlDocument(cssFiles) {
const cssLinks = cssFiles
.map(file => `<link rel="stylesheet" href="./${path.basename(file)}">`)
.join('\n ')
return `<!doctype html>
<html lang="zh-CN" data-theme="light">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Remote SSH 设置 · 隔离预览</title>
${cssLinks}
</head>
<body>
<div id="preview-root"></div>
<script type="module" src="./preview.js"></script>
</body>
</html>
`
}
async function buildPreview() {
const componentTarget = REAL_COMPONENT
if (!existsSync(REAL_COMPONENT)) {
throw new Error(`real component is missing: ${REAL_COMPONENT}`)
}
const distDir = path.join(TEMP_ROOT, 'dist')
await fs.rm(distDir, { recursive: true, force: true })
await fs.mkdir(TEMP_ROOT, { recursive: true })
log('building preview bundle with vite (real component)')
const { build } = await import('vite')
await build({
configFile: false,
root: PREVIEW_DIR,
mode: 'production',
logLevel: 'warn',
publicDir: false,
define: {
__PREVIEW_ISOLATED__: 'true',
// React DOM / scheduler ship CJS branches guarded by
// `process.env.NODE_ENV`. Vite's lib-mode build did not inline the
// browser define here, so the module threw "process is not defined" at
// startup (blank page, ready flag never set). Pin the production branch.
'process.env.NODE_ENV': JSON.stringify('production'),
},
resolve: {
alias: [
{ find: /^#rssh-settings$/, replacement: componentTarget },
{ find: /^@deepseek-ai\/dsh-client-ui-primitives$/, replacement: MODAL_STUB },
],
},
esbuild: { jsx: 'automatic' },
build: {
outDir: distDir,
emptyOutDir: true,
target: 'chrome120',
minify: false,
write: true,
cssCodeSplit: false,
lib: {
entry: path.join(PREVIEW_DIR, 'main.tsx'),
formats: ['es'],
fileName: () => 'preview.js',
},
rollupOptions: {
output: { inlineDynamicImports: true },
},
},
})
const files = await walkFiles(distDir)
const cssFiles = files.filter(file => file.endsWith('.css'))
const jsFiles = files.filter(file => file.endsWith('.js'))
if (!jsFiles.length) throw new Error('vite build produced no JS bundle')
await fs.writeFile(path.join(distDir, 'index.html'), htmlDocument(cssFiles), 'utf8')
log(`bundle ready: ${jsFiles.map(file => path.basename(file)).join(', ')}${cssFiles.length ? ` + ${cssFiles.map(file => path.basename(file)).join(', ')}` : ''}`)
return distDir
}
/* ------------------------------------------------------------------ */
/* Static server */
/* ------------------------------------------------------------------ */
const MIME_TYPES = {
'.html': 'text/html; charset=utf-8',
'.js': 'text/javascript; charset=utf-8',
'.css': 'text/css; charset=utf-8',
'.json': 'application/json; charset=utf-8',
'.svg': 'image/svg+xml',
'.png': 'image/png',
}
function startStaticServer(distDir) {
const server = http.createServer((request, response) => {
try {
const requestUrl = new URL(request.url || '/', 'http://127.0.0.1')
const relativePath = requestUrl.pathname === '/' ? 'index.html' : decodeURIComponent(requestUrl.pathname.replace(/^\//, ''))
const filePath = path.join(distDir, relativePath)
if (!filePath.startsWith(distDir)) {
response.writeHead(403).end('forbidden')
return
}
const body = readFileSyncSafe(filePath)
if (body === null) {
response.writeHead(404).end('not found')
return
}
const type = MIME_TYPES[path.extname(filePath)] || 'application/octet-stream'
response.writeHead(200, { 'content-type': type, 'cache-control': 'no-store' })
response.end(body)
} catch (error) {
response.writeHead(500).end(String(error && error.message ? error.message : error))
}
})
return new Promise((resolve, reject) => {
server.once('error', reject)
server.listen(0, '127.0.0.1', () => {
const address = server.address()
resolve({ server, port: address.port })
})
})
}
// Sync read keeps the tiny handler simple (all files are local and small).
function readFileSyncSafe(filePath) {
try {
return readFileSync(filePath)
} catch {
return null
}
}
/* ------------------------------------------------------------------ */
/* CDP client */
/* ------------------------------------------------------------------ */
class CdpClient {
constructor(webSocket) {
this.webSocket = webSocket
this.nextId = 1
this.pending = new Map()
this.consoleErrors = []
this.pageErrors = []
this.closed = false
webSocket.addEventListener('message', event => {
let message
try {
message = JSON.parse(event.data)
} catch {
return
}
if (message.id && this.pending.has(message.id)) {
const pending = this.pending.get(message.id)
this.pending.delete(message.id)
if (message.error) pending.reject(new Error(`${message.error.message}${message.error.data ? ` (${message.error.data})` : ''}`))
else pending.resolve(message.result)
return
}
if (message.method === 'Runtime.consoleAPICalled' && message.params.type === 'error') {
this.consoleErrors.push(message.params.args.map(arg => arg.value ?? arg.description ?? '').join(' '))
}
if (message.method === 'Runtime.exceptionThrown') {
const details = message.params.exceptionDetails
this.pageErrors.push(details.exception?.description || details.text || 'page exception')
}
})
webSocket.addEventListener('close', () => {
this.closed = true
for (const pending of this.pending.values()) pending.reject(new Error('CDP connection closed'))
this.pending.clear()
})
}
static async connect(url) {
const webSocket = new WebSocket(url)
await new Promise((resolve, reject) => {
const onOpen = () => {
webSocket.removeEventListener('error', onError)
resolve()
}
const onError = () => {
webSocket.removeEventListener('open', onOpen)
reject(new Error(`could not connect CDP websocket ${url}`))
}
webSocket.addEventListener('open', onOpen, { once: true })
webSocket.addEventListener('error', onError, { once: true })
})
return new CdpClient(webSocket)
}
send(method, params = {}, { timeout = 45000 } = {}) {
if (this.closed) return Promise.reject(new Error('CDP connection already closed'))
const id = this.nextId++
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
this.pending.delete(id)
reject(new Error(`CDP ${method} timed out after ${timeout}ms`))
}, timeout)
this.pending.set(id, {
resolve: value => {
clearTimeout(timer)
resolve(value)
},
reject: error => {
clearTimeout(timer)
reject(error)
},
})
this.webSocket.send(JSON.stringify({ id, method, params }))
})
}
async evaluate(expression, options = {}) {
const response = await this.send('Runtime.evaluate', {
expression,
returnByValue: true,
awaitPromise: options.awaitPromise !== false,
})
if (response.exceptionDetails) {
const description = response.exceptionDetails.exception?.description || response.exceptionDetails.text || 'evaluate threw'
throw new Error(`page evaluate failed: ${description}`)
}
return response.result?.value
}
close() {
try {
this.webSocket.close()
} catch {
/* ignore */
}
}
}
/* ------------------------------------------------------------------ */
/* Chrome */
/* ------------------------------------------------------------------ */
async function waitForFile(filePath, timeoutMs) {
const deadline = Date.now() + timeoutMs
while (Date.now() < deadline) {
if (existsSync(filePath)) return true
await sleep(60)
}
return false
}
async function launchChrome(profileDir) {
await fs.mkdir(profileDir, { recursive: true })
const chromeProcess = spawn(
CHROME_PATH,
[
'--headless=new',
'--remote-debugging-port=0',
`--user-data-dir=${profileDir}`,
'--no-first-run',
'--no-default-browser-check',
'--disable-gpu',
'--disable-extensions',
'--disable-background-networking',
'--disable-sync',
'--mute-audio',
'--hide-scrollbars',
'--window-size=1280,900',
'about:blank',
],
{ stdio: 'ignore' },
)
const portFile = path.join(profileDir, 'DevToolsActivePort')
const ready = await waitForFile(portFile, 20000)
if (!ready) {
throw new Error(`Chrome did not expose DevToolsActivePort (profile: ${profileDir})`)
}
let port
for (let attempt = 0; attempt < 20 && !port; attempt += 1) {
try {
const content = await fs.readFile(portFile, 'utf8')
const firstLine = content.split(/\r?\n/)[0]
if (firstLine) port = Number(firstLine)
} catch {
/* keep retrying while Chrome finishes writing */
}
if (!port) await sleep(100)
}
if (!port) throw new Error('DevToolsActivePort did not contain a port')
log(`chrome devtools port: ${port}`)
const deadline = Date.now() + 20000
let pageTarget = null
while (Date.now() < deadline && !pageTarget) {
try {
const list = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json()
pageTarget = list.find(target => target.type === 'page' && target.webSocketDebuggerUrl)
} catch {
/* Chrome HTTP endpoint may not be up yet */
}
if (!pageTarget) await sleep(100)
}
if (!pageTarget) throw new Error('no page target in Chrome')
return { chromeProcess, port, pageTarget }
}
function killChrome(chromeProcess) {
if (!chromeProcess || chromeProcess.exitCode !== null) return
spawnSync('taskkill', ['/PID', String(chromeProcess.pid), '/T', '/F'], { stdio: 'ignore' })
try {
chromeProcess.kill('SIGKILL')
} catch {
/* ignore */
}
}
/* ------------------------------------------------------------------ */
/* Page context helpers */
/* ------------------------------------------------------------------ */
class SceneContext {
constructor(cdp, sceneName, { strict }) {
this.cdp = cdp
this.sceneName = sceneName
this.strict = strict
}
async evaluate(expression) {
return this.cdp.evaluate(expression)
}
async sleep(ms) {
await sleep(ms)
}
async click(selector) {
const result = await this.evaluate(
`(() => { const el = document.querySelector(${JSON.stringify(selector)}); if (!el) return 'missing'; el.click(); return 'ok'; })()`,
)
if (result !== 'ok') throw new Error(`${this.sceneName}: click ${selector} -> ${result}`)
await sleep(80)
}
async clickAll(selector) {
let count = await this.evaluate(`document.querySelectorAll(${JSON.stringify(selector)}).length`)
if (count <= 0) {
if (this.strict) throw new Error(`${this.sceneName}: no elements for ${selector}`)
return
}
for (let index = 0; index < count; index += 1) {
const result = await this.evaluate(
`(() => { const els = document.querySelectorAll(${JSON.stringify(selector)}); const el = els[${index}]; if (!el) return 'missing'; el.click(); return 'ok'; })()`,
)
if (result !== 'ok') {
if (this.strict) throw new Error(`${this.sceneName}: clickAll(${selector})[${index}] -> ${result}`)
return
}
await sleep(120)
count = await this.evaluate(`document.querySelectorAll(${JSON.stringify(selector)}).length`)
}
}
async setValue(selector, value) {
const result = await this.evaluate(
`(() => {
const el = document.querySelector(${JSON.stringify(selector)});
if (!el) return 'missing';
const control = el.matches('input,textarea,select')
? el
: el.querySelector('input,textarea,select') || (el.parentElement && el.parentElement.querySelector('input,textarea,select'));
if (!control) return 'no-control';
const proto = control instanceof HTMLSelectElement
? HTMLSelectElement.prototype
: control instanceof HTMLTextAreaElement
? HTMLTextAreaElement.prototype
: HTMLInputElement.prototype;
const setter = Object.getOwnPropertyDescriptor(proto, 'value').set;
setter.call(control, ${JSON.stringify(value)});
control.dispatchEvent(new Event('input', { bubbles: true }));
control.dispatchEvent(new Event('change', { bubbles: true }));
return 'ok';
})()`,
)
if (result !== 'ok') throw new Error(`${this.sceneName}: setValue(${selector}) -> ${result}`)
await sleep(60)
}
async waitExpr(expression, label, timeoutMs = 8000) {
const deadline = Date.now() + timeoutMs
let lastError = null
while (Date.now() < deadline) {
try {
const value = await this.evaluate(expression)
if (value) return value
} catch (error) {
lastError = error
}
await sleep(100)
}
const suffix = lastError ? ` (last error: ${lastError.message})` : ''
if (this.strict) throw new Error(`${this.sceneName}: timeout waiting for ${label}${suffix}`)
warn(`${this.sceneName}: timeout waiting for ${label}; continuing (smoke mode)`)
return null
}
async waitExists(selector, label, timeoutMs = 8000) {
await this.waitExpr(
`(() => { const el = document.querySelector(${JSON.stringify(selector)}); return !!el; })()`,
label,
timeoutMs,
)
}
async waitVisible(selector, label, timeoutMs = 8000) {
await this.waitExpr(
`(() => {
const el = document.querySelector(${JSON.stringify(selector)});
if (!el) return false;
return typeof el.checkVisibility === 'function'
? el.checkVisibility({ checkOpacity: false, checkVisibilityCSS: true })
: el.offsetParent !== null;
})()`,
label,
timeoutMs,
)
}
async waitAtLeast(selector, minimum, label, timeoutMs = 8000) {
await this.waitExpr(
`document.querySelectorAll(${JSON.stringify(selector)}).length >= ${Number(minimum)}`,
label,
timeoutMs,
)
}
async waitAttr(selector, attribute, expected, label, timeoutMs = 8000) {
await this.waitExpr(
`(() => { const el = document.querySelector(${JSON.stringify(selector)}); return !!el && el.getAttribute(${JSON.stringify(attribute)}) === ${JSON.stringify(expected)}; })()`,
label,
timeoutMs,
)
}
async waitText(regex, label, timeoutMs = 8000) {
await this.waitExpr(`(${regex.toString()}).test(document.body.innerText)`, label, timeoutMs)
}
async settle(label = 'page settle') {
await sleep(220)
await this.waitExpr('window.__RSH_PREVIEW_IDLE__ !== false', `${label} / API idle`, 6000)
await sleep(120)
}
}
/* ------------------------------------------------------------------ */
/* Main per-scene flow */
/* ------------------------------------------------------------------ */
async function captureScreenshot(cdp, filePath, { fullPage, width, height }) {
let clip
let captureBeyondViewport = false
if (fullPage) {
const metrics = await cdp.send('Page.getLayoutMetrics')
const contentSize = metrics.cssContentSize || metrics.contentSize
const fullWidth = Math.max(Math.ceil(contentSize.width), width)
const fullHeight = Math.max(Math.ceil(contentSize.height), height)
clip = { x: 0, y: 0, width: fullWidth, height: fullHeight, scale: 1 }
captureBeyondViewport = true
}
const params = { format: 'png', fromSurface: true, captureBeyondViewport }
if (clip) params.clip = clip
const result = await cdp.send('Page.captureScreenshot', params)
const data = result.data
if (!data) throw new Error('Page.captureScreenshot returned no data')
await fs.writeFile(filePath, Buffer.from(data, 'base64'))
return clip ? `${clip.width}x${clip.height}` : `${width}x${height}`
}
async function waitPageReady(cdp, sceneName) {
const ctx = new SceneContext(cdp, sceneName, { strict: true })
await ctx.waitExpr(
`window.__RSH_PREVIEW_READY__ === true && document.documentElement.dataset.previewReady === '1'`,
'preview ready flag',
20000,
)
await ctx.waitExists('[data-rsui-root]', 'settings root (data-rsui-root)', 20000)
await ctx.waitExpr(
`typeof window.__RSH_PREVIEW_EXPECTED_TEXT__ === 'string' && document.body.innerText.includes(window.__RSH_PREVIEW_EXPECTED_TEXT__)`,
'settings section title rendered',
20000,
)
await ctx.settle('initial load')
await ctx.waitExpr(
`!document.body.innerText.includes('加载中…') && !document.body.innerText.includes('正在读取 ~/.ssh/config…')`,
'no loading copy',
8000,
)
}
async function runScene(cdp, scene, { outDir }) {
const startedAt = Date.now()
const targetUrl = `http://127.0.0.1:${serverPort}/index.html?${new URLSearchParams(
Object.entries(scene.query).map(([key, value]) => [key, String(value)]),
).toString()}`
const ctx = new SceneContext(cdp, scene.name, { strict: true })
const errorsBefore = cdp.pageErrors.length + cdp.consoleErrors.length
await cdp.send('Emulation.setDeviceMetricsOverride', {
width: scene.viewport.width,
height: scene.viewport.height,
deviceScaleFactor: 1,
mobile: false,
screenWidth: scene.viewport.width,
screenHeight: scene.viewport.height,
})
await cdp.send('Page.navigate', { url: targetUrl })
await waitPageReady(cdp, scene.name)
if (typeof scene.actions === 'function') {
await scene.actions(ctx)
}
// Capture BEFORE the acceptance checks: a failed assertion must never throw
// away an otherwise valid render of the scene.
// Reset transient UI state (focus, scroll) before the shot.
await ctx.evaluate(`(() => {
if (document.activeElement && document.activeElement.blur) document.activeElement.blur();
window.scrollTo(0, 0);
return true;
})()`)
await sleep(120)
const pageErrors = cdp.pageErrors.slice(errorsBefore)
const consoleErrors = cdp.consoleErrors.slice(errorsBefore)
const filePath = path.join(outDir, `${scene.name}.png`)
const size = await captureScreenshot(cdp, filePath, {
fullPage: scene.capture === 'full',
width: scene.viewport.width,
height: scene.viewport.height,
})
const durationMs = Date.now() - startedAt
log(`captured ${path.basename(filePath)} (${size}, ${durationMs}ms)`)
const failures = []
for (const check of scene.checks || []) {
try {
const value = await ctx.evaluate(check.expression)
if (!value) failures.push(check.label)
} catch (error) {
failures.push(`${check.label} (evaluate error: ${error.message})`)
}
}
if (failures.length) warn(`${scene.name}: checks failed: ${failures.join('; ')}`)
if (pageErrors.length) warn(`${scene.name}: page exceptions: ${pageErrors.join(' | ')}`)
if (consoleErrors.length) warn(`${scene.name}: console errors: ${consoleErrors.slice(0, 3).join(' | ')}`)
return { filePath, size, durationMs, pageErrors, consoleErrors, failures }
}
/* ------------------------------------------------------------------ */
/* Entry */
/* ------------------------------------------------------------------ */
let server
let serverPort
let chrome
async function main() {
const outDir = OUT_DIR
if (ONLY && ONLY.some(name => !scenes.some(scene => scene.name === name))) {
throw new Error(`unknown --only value(s): ${ONLY.join(', ')}`)
}
await fs.mkdir(TEMP_ROOT, { recursive: true })
const distDir = await buildPreview()
if (BUILD_ONLY) {
log(`build-only done: ${distDir}`)
return 0
}
if (!existsSync(CHROME_PATH)) throw new Error(`Chrome not found at ${CHROME_PATH}`)
await fs.mkdir(outDir, { recursive: true })
const startedServer = await startStaticServer(distDir)
server = startedServer.server
serverPort = startedServer.port
log(`static server: http://127.0.0.1:${serverPort}/index.html`)
const profileDir = path.join(TEMP_ROOT, 'chrome-profile')
let launched
try {
launched = await launchChrome(profileDir)
} catch (error) {
throw new Error(
`${error.message}\n` +
'Chromium cannot start its IPC toward child processes in this environment. ' +
'If the command runs inside a constrained/Low-integrity sandbox job, run the same command ' +
'from a normal user terminal instead.',
)
}
chrome = launched.chromeProcess
log(`chrome pid: ${chrome.pid}`)
const cdp = await CdpClient.connect(launched.pageTarget.webSocketDebuggerUrl)
try {
await cdp.send('Page.enable')
await cdp.send('Runtime.enable')
await cdp.send('Log.enable')
await cdp.send('Emulation.setEmulatedMedia', { features: [] })
const selectedScenes = ONLY ? scenes.filter(scene => ONLY.includes(scene.name)) : scenes
const results = []
const failures = []
const runLog = [`run at ${new Date().toISOString()}`, `component: src/client/rssh-settings/index.tsx`]
for (const scene of selectedScenes) {
try {
const result = await runScene(cdp, scene, { outDir })
results.push(result)
runLog.push(`${scene.name}: captured (${result.size})`)
if (result.failures.length) {
failures.push({ scene: scene.name, error: new Error(`checks failed: ${result.failures.join('; ')}`) })
runLog.push(` checks failed: ${result.failures.join('; ')}`)
}
if (result.pageErrors.length) {
failures.push({ scene: scene.name, error: new Error(`page exceptions: ${result.pageErrors.join(' | ')}`) })
runLog.push(` page exceptions: ${result.pageErrors.join(' | ')}`)
}
} catch (error) {
failures.push({ scene: scene.name, error })
runLog.push(`${scene.name}: FAILED: ${error.message}`)
warn(`${scene.name} failed: ${error.message}`)
}
}
const manifest = {
isolatedPreview: true,
note: '真实组件 + 假 /remote-ssh/api 数据,在 headless Chrome 中渲染截图;不是 AI 效果图,未修改 DSH GUI / daily profile / node_modules。',
component: 'src/client/rssh-settings/index.tsx',
builtAt: new Date().toISOString(),
screenshots: results.map(result => {
const scene = scenes.find(item => item.name === path.basename(result.filePath, '.png'))
return {
file: path.relative(ROOT, result.filePath).replaceAll('\\', '/'),
absolutePath: result.filePath,
scene: scene?.query.scene,
theme: scene?.query.theme,
viewportWidth: scene?.viewport.width,
capture: scene?.capture,
size: result.size,
durationMs: result.durationMs,
description: scene?.title,
}
}),
}
// A partial `--only=` run must never drop the other captured scenes from
// the manifest: merge with the previous entries that were not re-shot.
if (ONLY) {
try {
const previous = JSON.parse(await fs.readFile(path.join(outDir, 'manifest.json'), 'utf8'))
const currentFiles = new Set(manifest.screenshots.map(entry => entry.file))
for (const entry of previous.screenshots || []) {
if (!currentFiles.has(entry.file)) manifest.screenshots.push(entry)
}
manifest.screenshots.sort((a, b) => String(a.file).localeCompare(String(b.file)))
} catch {
/* first run or unreadable previous manifest: keep the current list */
}
}
await fs.writeFile(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf8')
await fs.writeFile(path.join(outDir, 'last-run.log'), runLog.join('\n') + '\n', 'utf8')
log(`done: ${results.length}/${selectedScenes.length} screenshots in ${outDir}`)
for (const result of results) log(` - ${result.filePath}`)
if (failures.length) {
for (const failure of failures) log(` FAILED ${failure.scene}: ${failure.error.message}`)
return 1
}
return 0
} finally {
cdp.close()
}
}
async function cleanup() {
try {
if (chrome) killChrome(chrome)
} catch (error) {
warn(`cleanup chrome failed: ${error.message}`)
}
try {
if (server) await new Promise(resolve => server.close(resolve))
} catch (error) {
warn(`cleanup server failed: ${error.message}`)
}
if (!KEEP_TEMP) {
await sleep(250)
try {
await fs.rm(TEMP_ROOT, { recursive: true, force: true })
} catch (error) {
warn(`cleanup temp failed (${TEMP_ROOT}): ${error.message}`)
}
} else {
log(`temp kept at ${TEMP_ROOT}`)
}
}
let exitCode = 1
try {
exitCode = await main()
} catch (error) {
console.error(`[preview][error] ${error && error.stack ? error.stack : error}`)
exitCode = 1
} finally {
await cleanup()
}
process.exit(exitCode)