dsh-browser-verify 0.1.0

package/src/browser/scenario.ts

@@ -0,0 +1,173 @@
+/**
+ * One verification scenario = one page + its request mocks + assertion/shot
+ * state. Pure helpers are exported for unit tests; the IO methods use
+ * playwright-core. Polluting nothing outside the page's own requests.
+ * @module dsh-browser-verify/browser/scenario
+ */
+
+import { createHash } from 'node:crypto'
+import type { BrowserContext, Page } from 'playwright-core'
+
+export interface MockRule {
+  json: unknown
+  status: number
+}
+
+export interface OpenResult {
+  title: string
+  url: string
+  status: number | null
+  visible: string[]
+  consoleErrors: string[]
+  elapsedMs: number
+}
+
+export interface AssertResult {
+  pass: boolean
+  count: number
+  actualText: string | null
+  elapsedMs: number
+}
+
+const MAX_VISIBLE = 8
+const MAX_VISIBLE_LEN = 40
+const MAX_ERRORS = 5
+const MAX_ERROR_LEN = 120
+const MAX_DIFF_LEN = 120
+
+export function assertNoMockConflict(patterns: string[], next: string): void {
+  if (patterns.includes(next)) {
+    throw new Error(`browser-verify: 拦截 pattern 已存在: ${next}（已有: ${patterns.join(', ')}）。请先 browser_open 重开场景或用不同的 urlPattern。`)
+  }
+}
+
+export function normalizeCountSpec(count: number | { min: number; max: number } | undefined): { min: number; max: number } | null {
+  if (typeof count === 'number') return { min: count, max: count }
+  if (count !== undefined && typeof count.min === 'number' && typeof count.max === 'number') return { min: count.min, max: count.max }
+  return null
+}
+
+export function summarizeVisibleText(texts: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const raw of texts) {
+    const trimmed = raw.trim()
+    if (trimmed === '') continue
+    const reduced = trimmed.length > MAX_VISIBLE_LEN ? trimmed.slice(0, MAX_VISIBLE_LEN) : trimmed
+    if (seen.has(reduced)) continue
+    seen.add(reduced)
+    out.push(reduced)
+    if (out.length >= MAX_VISIBLE) break
+  }
+  return out
+}
+
+export function capConsoleErrors(errors: string[]): string[] {
+  return errors.slice(0, MAX_ERRORS).map(e => e.length > MAX_ERROR_LEN ? `${e.slice(0, MAX_ERROR_LEN - 1)}…` : e)
+}
+
+export function sha256Hex(data: Buffer): string {
+  return createHash('sha256').update(data).digest('hex')
+}
+
+export function textDiff(actual: string | null, expected: string): string {
+  if (actual === null) return `未找到匹配元素文本（期望包含: ${expected.slice(0, MAX_DIFF_LEN)}）`
+  if (actual === expected) return '文本一致'
+  const head = actual.length > MAX_DIFF_LEN ? `${actual.slice(0, MAX_DIFF_LEN)}…` : actual
+  return `期望包含「${expected.slice(0, MAX_DIFF_LEN)}」，实际: ${head}`
+}
+
+/** Visible-text extraction, evaluated in the page: text of visible elements. */
+export const VISIBLE_TEXT_SCRIPT = `
+Array.from(document.querySelectorAll('body *')).map(el => {
+  const rect = el.getBoundingClientRect()
+  if (rect.width === 0 || rect.height === 0) return ''
+  const text = (el.childElementCount === 0 ? el.textContent ?? '' : '').trim()
+  return text.length > 0 ? text : ''
+})
+`
+
+export class Scenario {
+  readonly mocks = new Map<string, MockRule>()
+  lastScreenshotHash: string | null = null
+
+  constructor(
+    readonly page: Page,
+    readonly context: BrowserContext,
+  ) {}
+
+  async navigate(opts: { url: string; waitSelector?: string; timeoutMs?: number }): Promise<OpenResult> {
+    const started = Date.now()
+    const timeout = opts.timeoutMs ?? 10000
+    const errors: string[] = []
+    const onError = (message: string): void => { errors.push(message) }
+    this.page.on('console', msg => { if (msg.type() === 'error') onError(msg.text()) })
+    this.page.on('pageerror', err => onError(String(err)))
+    const response = await this.page.goto(opts.url, { waitUntil: 'domcontentloaded', timeout })
+    if (opts.waitSelector !== undefined) {
+      await this.page.waitForSelector(opts.waitSelector, { timeout })
+    }
+    const texts = await this.page.evaluate(VISIBLE_TEXT_SCRIPT) as string[]
+    return {
+      title: await this.page.title(),
+      url: this.page.url(),
+      status: response?.status() ?? null,
+      visible: summarizeVisibleText(texts),
+      consoleErrors: capConsoleErrors(errors),
+      elapsedMs: Date.now() - started,
+    }
+  }
+
+  async addMock(rule: { urlPattern: string; json: unknown; status?: number; reload?: boolean; timeoutMs?: number }): Promise<string[]> {
+    assertNoMockConflict([...this.mocks.keys()], rule.urlPattern)
+    const status = rule.status ?? 200
+    this.mocks.set(rule.urlPattern, { json: rule.json, status })
+    await this.context.route(rule.urlPattern, async route => {
+      const body = Buffer.from(JSON.stringify(this.mocks.get(rule.urlPattern)?.json ?? rule.json))
+      await route.fulfill({ status, body, contentType: 'application/json; charset=utf-8' })
+    })
+    if (rule.reload !== false) {
+      await this.page.reload({ waitUntil: 'domcontentloaded', timeout: rule.timeoutMs ?? 10000 })
+    }
+    return [...this.mocks.keys()]
+  }
+
+  async assert(opts: { selector: string; count?: number | { min: number; max: number }; text?: string; timeoutMs: number }): Promise<AssertResult> {
+    const started = Date.now()
+    const expected = normalizeCountSpec(opts.count)
+    try {
+      await this.page.waitForSelector(opts.selector, { state: 'attached', timeout: opts.timeoutMs })
+    } catch (error) {
+      const timedOut = error instanceof Error && /timeout/i.test(error.message)
+      // Element never appeared: a normal verification outcome, not a thrown
+      // failure. An explicit absence assertion (count 0..0, no text) passes;
+      // everything else stays a normal pass:false.
+      if (timedOut) {
+        return {
+          pass: expected !== null && expected.min === 0 && expected.max === 0 && opts.text === undefined,
+          count: 0,
+          actualText: null,
+          elapsedMs: Date.now() - started,
+        }
+      }
+      throw error
+    }
+    const count = await this.page.locator(opts.selector).count()
+    const actualText = await this.page.locator(opts.selector).first().textContent()
+    const pass = (expected === null || (count >= expected.min && count <= expected.max))
+      && (opts.text === undefined || (actualText !== null && actualText.includes(opts.text)))
+    return { pass, count, actualText, elapsedMs: Date.now() - started }
+  }
+
+  async screenshot(opts: { fullPage?: boolean }): Promise<{ data: Buffer; sha256: string; identicalToPrevious: boolean }> {
+    const data = await this.page.screenshot({ fullPage: opts.fullPage ?? false, type: 'png' })
+    const sha256 = sha256Hex(data)
+    const identicalToPrevious = sha256 === this.lastScreenshotHash
+    this.lastScreenshotHash = sha256
+    return { data, sha256, identicalToPrevious }
+  }
+
+  async close(): Promise<void> {
+    try { await this.context.close() } catch { /* already gone */ }
+  }
+}

package/src/cleanup.ts

@@ -0,0 +1,33 @@
+/**
+ * Orphan cleanup for dsh-browser-verify: temp dirs and zombie Chromium
+ * processes left by crashes. Parsers are pure; callers do the I/O.
+ * @module dsh-browser-verify/cleanup
+ */
+
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+/** One line from `ps -Ao pid=,ppid=,command=` (macOS). */
+export function parseZombiePids(psText: string, prefix: string, selfPid: number): number[] {
+  const pids: number[] = []
+  for (const line of psText.split('\n')) {
+    const match = /^\s*(\d+)\s+\d+\s+(.+)$/.exec(line)
+    if (match === null) continue
+    const pid = Number(match[1])
+    if (pid === selfPid) continue
+    if (match[2].includes(`--user-data-dir=${join(tmpdir(), prefix)}`)) pids.push(pid)
+  }
+  return pids
+}
+
+export interface OrphanDir {
+  path: string
+  mtimeMs: number
+}
+
+/** Pick degraded-run temp dirs: name prefixed, old enough, not the current pid dir. */
+export function selectOrphanDirs(entries: Array<{ path: string; mtimeMs: number }>, nowMs: number, ageMs: number, prefix: string): OrphanDir[] {
+  return entries
+    .filter(e => e.path.includes(`/${prefix}`) && nowMs - e.mtimeMs > ageMs)
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+}

package/src/cli.ts

@@ -0,0 +1,92 @@
+/**
+ * Debug CLI for dsh-browser-verify: exercises the same core the tools use,
+ * without the harness. Prints structured JSON results.
+ * @module dsh-browser-verify/cli
+ */
+
+import { readFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { BrowserDriver } from './browser/driver.ts'
+
+export interface CliOptions {
+  url: string
+  mockFile?: string
+  waitSelector?: string
+  assertSelector?: string
+  screenshot?: boolean
+  persistDir?: string
+  viewport: { width: number; height: number }
+}
+
+export function parseCliArgs(argv: string[]): CliOptions {
+  const opts: CliOptions = { url: '', viewport: { width: 390, height: 844 } }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    const next = (): string => { const v = argv[++i]; if (v === undefined) throw new Error(`browser-verify: 参数 ${arg} 缺少值。请按 --url <url> 的用法补充。`); return v }
+    if (arg === '--url') opts.url = next()
+    else if (arg === '--mock') opts.mockFile = next()
+    else if (arg === '--wait-selector') opts.waitSelector = next()
+    else if (arg === '--assert') opts.assertSelector = next()
+    else if (arg === '--screenshot') opts.screenshot = true
+    else if (arg === '--persist') opts.persistDir = next()
+    else if (arg === '--viewport') {
+      const [w, h] = next().split('x').map(Number)
+      opts.viewport = { width: w, height: h }
+    } else throw new Error(`browser-verify: 未知参数 ${arg}。请检查命令行用法（--url/--mock/--assert/--screenshot/--persist/--viewport/--wait-selector）。`)
+  }
+  if (opts.url === '') throw new Error('browser-verify: 缺少 --url。请提供页面地址，如 --url http://localhost:5173/hweb/#/pages/lyp/livingPayment。')
+  return opts
+}
+
+async function main(): Promise<void> {
+  const opts = parseCliArgs(process.argv.slice(2))
+  // Deviation D8-4: read the fixture before opening, then pass it as
+  // startScenario `mocks` so it is registered before the first navigation
+  // (the app boot may bounce to a fallback route if unmocked APIs answer).
+  let rule: { urlPattern: string; json: unknown; status?: number } | null = null
+  if (opts.mockFile !== undefined) {
+    try {
+      rule = JSON.parse(await readFile(opts.mockFile, 'utf8')) as { urlPattern: string; json: unknown; status?: number }
+    } catch (error) {
+      const raw = error instanceof Error ? error.message : String(error)
+      throw new Error(`browser-verify: 读取 --mock 文件失败: ${raw}。请检查文件路径与 JSON 格式。`)
+    }
+  }
+  const driver = new BrowserDriver({ viewport: opts.viewport })
+  try {
+    const opened = await driver.startScenario({
+      url: opts.url,
+      timeoutMs: 15000,
+      waitSelector: opts.waitSelector,
+      mocks: rule === null ? undefined : [{ urlPattern: rule.urlPattern, json: rule.json, status: rule.status }],
+    })
+    console.log(JSON.stringify({ step: 'open', ...opened }))
+    if (rule !== null) {
+      console.log(JSON.stringify({ step: 'mock', patterns: [rule.urlPattern] }))
+    }
+    if (opts.assertSelector !== undefined) {
+      // Deviation D8-2: TS does not narrow property accesses inside closures.
+      const assertSelector = opts.assertSelector
+      const result = await driver.withScenario(s => s.assert({ selector: assertSelector, timeoutMs: 5000 }))
+      console.log(JSON.stringify({ step: 'assert', ...result }))
+    }
+    if (opts.screenshot === true) {
+      const shot = await driver.withScenario(s => s.screenshot({ fullPage: false }))
+      // Default: inside the pid temp dir (deleted by driver.dispose). --persist keeps it.
+      const path = opts.persistDir === undefined
+        ? join(tmpdir(), `dsh-browser-verify-${process.pid}`, 'cli-last.png')
+        : join(resolve(opts.persistDir), `browser-verify-${Date.now()}.png`)
+      await import('node:fs/promises').then(fs => fs.writeFile(path, shot.data))
+      console.log(JSON.stringify({ step: 'screenshot', path, keep: opts.persistDir !== undefined, sha256: shot.sha256, identicalToPrevious: shot.identicalToPrevious }))
+    }
+  } finally {
+    await driver.dispose()
+  }
+}
+
+// Deviation D8-1 (brief omitted the guard): only auto-run when this module is
+// the CLI entry, so importing parseCliArgs (vitest) has no side effects.
+if (process.argv[1] !== undefined && /(^|[\\/])cli\.(js|ts)$/.test(process.argv[1])) {
+  void main().catch(error => { console.error(String(error)); process.exitCode = 1 })
+}

package/src/index.ts

@@ -0,0 +1,40 @@
+import type { Context } from '@deepseek-ai/cordis'
+import { exec as execCb } from 'node:child_process'
+import { readdir, rm, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parseZombiePids, selectOrphanDirs } from './cleanup.ts'
+import { registerBrowserTools } from './tools/index.ts'
+
+export const name = 'browser-verify'
+export const inject = ['tools']
+
+const prefix = 'dsh-browser-verify-'
+
+/** One-shot startup sweep: old temp dirs + stray Chromium, limited to our prefix. */
+async function sweepOrphans(): Promise<void> {
+  const root = tmpdir()
+  const entries: Array<{ path: string; mtimeMs: number }> = []
+  const dirents = await readdir(root, { withFileTypes: true }).catch(() => [])
+  for (const dirent of dirents) {
+    if (dirent.name === `${prefix}${process.pid}`) continue
+    if (!dirent.name.startsWith(prefix) || !dirent.isDirectory()) continue
+    const full = join(root, dirent.name)
+    const info = await stat(full).catch(() => null)
+    if (info !== null) entries.push({ path: full, mtimeMs: info.mtimeMs })
+  }
+  for (const orphan of selectOrphanDirs(entries, Date.now(), 3_600_000, prefix)) {
+    await rm(orphan.path, { recursive: true, force: true }).catch(() => undefined)
+  }
+  execCb('ps -Ao pid=,ppid=,command=', (error, stdout) => {
+    if (error !== null) return
+    for (const pid of parseZombiePids(String(stdout), prefix, process.pid)) {
+      try { process.kill(pid, 'SIGKILL') } catch { /* already gone */ }
+    }
+  })
+}
+
+export function apply(ctx: Context): void {
+  void sweepOrphans().catch(() => {})
+  registerBrowserTools(ctx)
+}

package/src/tools/index.ts

@@ -0,0 +1,186 @@
+/**
+ * The four model-facing browser verification tools. Thin shells: validate
+ * args, take the driver lock, run the scenario core, translate failures.
+ * @module dsh-browser-verify/tools
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import { BrowserDriver } from '../browser/driver.ts'
+import { assertImageCapable, renderScreenshotBlocks, saveScreenshot } from '../attachments.ts'
+import { withTimeout } from './timeout.ts'
+
+/** Parse a positive-integer env var; NaN/zero/negative falls back to the default. */
+const numberFromEnv = (name: string, fallback: number): number => {
+  const value = Number(process.env[name] ?? fallback)
+  return Number.isFinite(value) && value > 0 ? value : fallback
+}
+const envTimeoutMs = (): number => numberFromEnv('DSH_BROWSER_VERIFY_TIMEOUT', 10000)
+const envIdleMs = (): number => numberFromEnv('DSH_BROWSER_VERIFY_IDLE_MS', 600000)
+
+export function registerBrowserTools(ctx: Context): void {
+  const driver = new BrowserDriver({ timeoutMs: envTimeoutMs(), idleMs: envIdleMs() })
+  ctx.effect(() => () => { void driver.dispose() })
+
+  ctx.tools.register(defineTool({
+    name: 'browser_open',
+    description: '在无头浏览器中打开一个页面并返回页面状态（标题/状态码/可见文本摘要/console 错误）用于验证前端页面；可选 waitSelector 等待关键元素出现，默认视口 390×844 @2x（移动端形态）。可传 mocks 在打开时拦截接口（用于启动即依赖接口数据的页面）。验证顺序：先 browser_assert 做 DOM 断言，确需看版式再 browser_screenshot。',
+    parameters: {
+      url: { type: 'string', required: true, description: '页面地址，如 http://localhost:5173/hweb/pages/...' },
+      viewport: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          width: { type: 'number', required: true, description: '视口宽' },
+          height: { type: 'number', required: true, description: '视口高' },
+        },
+        description: '视口尺寸 {width, height}，默认 390x844',
+      },
+      deviceScaleFactor: { type: 'number', description: '缩放比，默认 2' },
+      mocks: {
+        type: 'array',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            urlPattern: { type: 'string', required: true, description: 'glob 模式，如 **/api/*.do*' },
+            json: { type: 'json', required: true, description: '拦截响应体（任意 JSON）' },
+            status: { type: 'number', description: '响应状态码，默认 200' },
+          },
+        },
+        description: '可选：页面启动前注册的接口拦截（glob urlPattern + json，如 [{urlPattern: "**/api/*.do*", json: {...}}]）',
+      },
+      waitSelector: { type: 'string', description: '可选：等待该选择器出现后再返回（优先于固定等待）' },
+      timeoutMs: { type: 'number', description: `加载超时，默认 ${envTimeoutMs()}ms` },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          title: { type: 'string', required: true },
+          url: { type: 'string', required: true },
+          status: { oneOf: [{ type: 'number' }, { type: 'null' }], required: true },
+          visible: { type: 'array', items: { type: 'string' }, required: true },
+          consoleErrors: { type: 'array', items: { type: 'string' }, required: true },
+          elapsedMs: { type: 'number', required: true },
+          browserKnown: { type: 'boolean', required: true },
+          versionHint: { oneOf: [{ type: 'string' }, { type: 'null' }], required: true, description: '浏览器 revision 认证提示（null=认证通过）' },
+        },
+      },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+    },
+    async execute(args) {
+      const timeoutMs = args.timeoutMs ?? envTimeoutMs()
+      return withTimeout(
+        driver.startScenario({ url: args.url, waitSelector: args.waitSelector, timeoutMs, viewport: args.viewport, deviceScaleFactor: args.deviceScaleFactor, mocks: args.mocks }),
+        timeoutMs, 'browser_open',
+      )
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'browser_mock',
+    description: '为当前验证场景注册接口拦截并自动重新加载页面：urlPattern 用 playwright glob（如 **/api/lifeIndex.do*），拦截后返回指定 json，用于 mock 空态/异常态。与已注册 pattern 完全相同时报错；请先 browser_open。',
+    parameters: {
+      urlPattern: { type: 'string', required: true, description: 'glob 模式，如 **/api/lifeIndex.do*' },
+      json: { type: 'json', description: '拦截响应体（任意 JSON）', required: true },
+      status: { type: 'number', description: '响应状态码，默认 200' },
+      reload: { type: 'boolean', description: '注册后自动 reload 当前页，默认 true' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          patterns: { type: 'array', items: { type: 'string' }, required: true },
+        },
+      },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+    },
+    async execute(args) {
+      return driver.withScenario(async scenario => ({ patterns: await scenario.addMock({ urlPattern: args.urlPattern, json: args.json, status: args.status, reload: args.reload, timeoutMs: envTimeoutMs() }) }))
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'browser_assert',
+    description: '对当前页面 DOM 断言：selector 必须存在，可校验匹配数量（count，数字或 {min,max}）与文本包含（text）。不满足时返回 pass:false 并附差异、不抛错。这是最省 token 的验证手段，优先于截图。',
+    parameters: {
+      selector: { type: 'string', required: true, description: 'CSS 选择器' },
+      count: { oneOf: [{ type: 'number' }, { type: 'object', additionalProperties: false, properties: { min: { type: 'number', required: true }, max: { type: 'number', required: true } } }], description: '期望匹配数量：数字=精确，或 {min,max}=范围' },
+      text: { type: 'string', description: '期望包含于首个匹配元素文本（contains 谓词）' },
+      timeoutMs: { type: 'number', description: '等待选择器出现的超时，默认 5000ms' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          pass: { type: 'boolean', required: true },
+          count: { type: 'number', required: true },
+          actualText: { oneOf: [{ type: 'string' }, { type: 'null' }], required: true },
+          elapsedMs: { type: 'number', required: true },
+        },
+      },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+    },
+    async execute(args) {
+      return driver.withScenario(scenario => scenario.assert({
+        selector: args.selector, count: args.count, text: args.text, timeoutMs: args.timeoutMs ?? 5000,
+      }))
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'browser_screenshot',
+    description: '截图当前页面并自动投影进模型上下文（图片块），返回尺寸与哈希；与上一张完全一致时 identicalToPrevious:true（疑似页面未刷新，请 browser_open 重开）。仅需要检查版式时使用——能断言就别截图。',
+    parameters: {
+      name: { type: 'string', description: '可选命名（进入附件名）' },
+      fullPage: { type: 'boolean', description: '是否整页截图，默认 false' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          image: {
+            type: 'object',
+            additionalProperties: false,
+            required: true,
+            properties: {
+              attachmentId: { type: 'string', required: true },
+              mediaType: { type: 'string', enum: ['image/png'], required: true },
+              bytes: { type: 'integer', required: true },
+              width: { type: 'integer', required: true },
+              height: { type: 'integer', required: true },
+              name: { type: 'string' },
+            },
+          },
+          sha256: { type: 'string', required: true },
+          identicalToPrevious: { type: 'boolean', required: true },
+        },
+      },
+      render: (_args, value) => renderScreenshotBlocks(value),
+    },
+    async execute(args, exec) {
+      await assertImageCapable(ctx, exec)
+      return driver.withScenario(async scenario => {
+        const shot = await scenario.screenshot({ fullPage: args.fullPage })
+        const ref = await saveScreenshot(ctx, shot.data, args.name)
+        return {
+          image: {
+            attachmentId: String(ref.attachmentId),
+            mediaType: 'image/png' as const,
+            bytes: ref.bytes,
+            width: ref.width,
+            height: ref.height,
+            ...ref.name === undefined ? {} : { name: ref.name },
+          },
+          sha256: shot.sha256,
+          identicalToPrevious: shot.identicalToPrevious,
+        }
+      })
+    },
+  }))
+}

package/src/tools/timeout.ts

@@ -0,0 +1,10 @@
+/** Race a promise against a deadline; the loser's work is abandoned, not awaited. */
+export function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`browser-verify: ${label} 超时（${ms}ms）。请检查页面或调大 DSH_BROWSER_VERIFY_TIMEOUT 后重试。`)), ms)
+    promise.then(
+      value => { clearTimeout(timer); resolve(value) },
+      error => { clearTimeout(timer); reject(error) },
+    )
+  })
+}