dsh-inner-browser-use 0.27.0 → 0.34.95

package/runtime/swf.mjs

@@ -0,0 +1,233 @@
+/**
+ * Read a SWF far enough to talk about it: what it is, how long it plays, which
+ * ActionScript it needs, and what it is made of.
+ *
+ * This is the front half of the Flash-compatible runtime: the movie is a tag
+ * stream, and everything a renderer, an agent or a replay needs can be read off
+ * that stream without decoding a single shape. It does not draw.
+ */
+import { inflateSync } from 'node:zlib'
+
+/** Every tag this reader names; anything else is reported by number. */
+export const TAG_NAMES = {
+  0: 'End',
+  1: 'ShowFrame',
+  2: 'DefineShape',
+  4: 'PlaceObject',
+  5: 'RemoveObject',
+  6: 'DefineBits',
+  7: 'DefineButton',
+  8: 'JPEGTables',
+  9: 'SetBackgroundColor',
+  10: 'DefineFont',
+  11: 'DefineText',
+  12: 'DoAction',
+  13: 'DefineFontInfo',
+  14: 'DefineSound',
+  15: 'StartSound',
+  17: 'DefineButtonSound',
+  18: 'SoundStreamHead',
+  19: 'SoundStreamBlock',
+  20: 'DefineBitsLossless',
+  21: 'DefineBitsJPEG2',
+  22: 'DefineShape2',
+  24: 'Protect',
+  26: 'PlaceObject2',
+  28: 'RemoveObject2',
+  32: 'DefineShape3',
+  33: 'DefineText2',
+  34: 'DefineButton2',
+  35: 'DefineBitsJPEG3',
+  36: 'DefineBitsLossless2',
+  37: 'DefineEditText',
+  39: 'DefineSprite',
+  43: 'FrameLabel',
+  45: 'SoundStreamHead2',
+  46: 'DefineMorphShape',
+  48: 'DefineFont2',
+  56: 'ExportAssets',
+  57: 'ImportAssets',
+  58: 'EnableDebugger',
+  59: 'DoInitAction',
+  60: 'DefineVideoStream',
+  61: 'VideoFrame',
+  62: 'DefineFontInfo2',
+  65: 'ScriptLimits',
+  69: 'FileAttributes',
+  70: 'PlaceObject3',
+  73: 'DefineFontAlignZones',
+  74: 'CSMTextSettings',
+  75: 'DefineFont3',
+  76: 'SymbolClass',
+  77: 'Metadata',
+  78: 'DefineScalingGrid',
+  82: 'DoABC',
+  83: 'DefineShape4',
+  84: 'DefineMorphShape2',
+  86: 'DefineSceneAndFrameLabelData',
+  87: 'DefineBinaryData',
+  88: 'DefineFontName',
+  89: 'StartSound2',
+  90: 'DefineBitsJPEG4',
+  91: 'DefineFont4',
+}
+
+const SHAPES = new Set([2, 22, 32, 83])
+const BITMAPS = new Set([6, 20, 21, 35, 36, 90])
+const FONTS = new Set([10, 48, 75])
+const SOUNDS = new Set([14])
+const SPRITES = new Set([39])
+const AVM1 = new Set([12, 59, 26]) // DoAction, DoInitAction, PlaceObject2 actions
+const AVM2 = new Set([76, 72, 82]) // SymbolClass, DoABC2, DoABC
+
+/** Bit reader over the movie header, which is packed rather than byte aligned. */
+class Bits {
+  /** @param {Buffer} body - the bytes after the 8 byte file header. */
+  constructor(body) {
+    this.body = body
+    this.bit = 0
+  }
+
+  /** @param {number} n - how many bits, at most 32. @returns {number} unsigned value. */
+  read(n) {
+    let value = 0
+    for (let i = 0; i < n; i += 1) {
+      const byte = this.body[(this.bit / 8) | 0]
+      if (byte === undefined) throw new Error('the movie header ends in the middle of a rectangle')
+      value = value * 2 + ((byte >> (7 - (this.bit % 8))) & 1)
+      this.bit += 1
+    }
+    return value
+  }
+
+  /** @param {number} n - how many bits. @returns {number} signed value. */
+  readSigned(n) {
+    if (n === 0) return 0
+    const raw = this.read(n)
+    return raw >= 2 ** (n - 1) ? raw - 2 ** n : raw
+  }
+
+  /** @returns {number} the byte offset after the bits just read. */
+  get offset() {
+    return Math.ceil(this.bit / 8)
+  }
+}
+
+/**
+ * Read one tag stream.
+ * @param {Buffer} body - the movie, or the body of a sprite.
+ * @param {number} start - byte offset of the first tag.
+ * @param {() => number} budget - how many tags outside sprites to record.
+ * @returns {{tags: Array<{code: number, name: string, offset: number, length: number}>, counts: Record<string, number>}} the tags found.
+ */
+function readTags(body, start, budget) {
+  const tags = []
+  const histogram = {}
+  const counts = { shapes: 0, sprites: 0, bitmaps: 0, fonts: 0, sounds: 0, scripts: 0 }
+  let at = start
+  while (at + 2 <= body.length) {
+    const head = body.readUInt16LE(at)
+    let code = head >> 6
+    let length = head & 0x3f
+    let header = 2
+    if (length === 0x3f) {
+      if (at + 6 > body.length) break
+      length = body.readUInt32LE(at + 2)
+      header = 6
+    }
+    if (at + header + length > body.length) {
+      throw new Error(`tag ${code} at ${at} claims ${length} bytes past the end of the movie`)
+    }
+    if (code === 0) break
+    const payload = at + header
+    if (SHAPES.has(code)) counts.shapes += 1
+    if (SPRITES.has(code)) counts.sprites += 1
+    if (BITMAPS.has(code)) counts.bitmaps += 1
+    if (FONTS.has(code)) counts.fonts += 1
+    if (SOUNDS.has(code)) counts.sounds += 1
+    if (code === 82 || code === 72) counts.scripts += 1
+    const name = TAG_NAMES[code] ?? `tag ${code}`
+    histogram[name] = (histogram[name] ?? 0) + 1
+    if (budget() > 0) tags.push({ code, name, offset: at, length })
+    if (code === 39 && length >= 4) {
+      /* A sprite carries its own small tag stream; read it for the counts only. */
+      try {
+        const inner = readTags(body.subarray(payload + 4, payload + length), 0, () => 0)
+        for (const key of Object.keys(counts)) counts[key] += inner.counts[key] ?? 0
+      } catch {
+        /* a sprite this reader cannot walk still counts as a sprite */
+      }
+    }
+    at = payload + length
+  }
+  return { tags, counts, histogram }
+}
+
+/**
+ * Read a movie.
+ * @param {Buffer|Uint8Array} input - the file.
+ * @returns {object} header, whether it plays ActionScript 3, tag histogram and the first tags.
+ */
+export function parseSwf(input) {
+  const file = Buffer.isBuffer(input) ? input : Buffer.from(input)
+  if (file.length < 8) throw new Error('too short to be a SWF: 8 bytes of header are the minimum')
+  const signature = file.subarray(0, 3).toString('latin1')
+  if (signature !== 'FWS' && signature !== 'CWS' && signature !== 'ZWS') {
+    throw new Error(`not a SWF: it starts with ${JSON.stringify(signature)}`)
+  }
+  const version = file[3]
+  const declared = file.readUInt32LE(4)
+  let body
+  if (signature === 'FWS') body = file.subarray(8)
+  else if (signature === 'CWS') body = inflateSync(file.subarray(8))
+  else throw new Error('a ZWS movie is LZMA compressed, which this reader cannot open yet')
+  const bits = new Bits(body)
+  const nbits = bits.read(5)
+  const box = [bits.readSigned(nbits), bits.readSigned(nbits), bits.readSigned(nbits), bits.readSigned(nbits)]
+  const afterBox = bits.offset
+  const rate = body.readUInt16LE(afterBox)
+  const frames = body.readUInt16LE(afterBox + 2)
+  const frameRate = Number(((rate & 0xff) / 256 + (rate >>> 8)).toFixed(2))
+  let left = 40
+  const tags = readTags(body, afterBox + 4, () => (left-- > 0 ? 1 : 0))
+  const histogram = tags.histogram
+  const names = new Set(Object.keys(histogram))
+  const avm2ByTag = ['SymbolClass', 'DoABC', 'DoABC2'].some((name) => names.has(name))
+  const avm1ByTag = ['DoAction', 'DoInitAction', 'PlaceObject2'].some((name) => names.has(name))
+  const avm = avm2ByTag ? 'avm2' : avm1ByTag ? 'avm1' : 'none'
+  return {
+    signature,
+    version,
+    declaredBytes: declared,
+    bytes: file.length,
+    compressed: signature !== 'FWS',
+    width: Math.round((box[1] - box[0]) / 20),
+    height: Math.round((box[3] - box[2]) / 20),
+    frameRate,
+    frames,
+    avm,
+    counts: tags.counts,
+    histogram,
+    tags: tags.tags,
+  }
+}
+
+/**
+ * The report as lines a person or a model can read without the raw tag dump.
+ * @param {object} report - from parseSwf.
+ * @param {{tags?: number}} [options] - how many leading tags to list.
+ * @returns {string[]} lines.
+ */
+export function describeSwf(report, options = {}) {
+  const lines = [
+    `a ${report.signature} movie, version ${report.version}, ${report.bytes} bytes${report.compressed ? ` (${report.declaredBytes} uncompressed)` : ''}`,
+    `${report.width}x${report.height} at ${report.frameRate} frames a second, ${report.frames} frames (${(report.frames / Math.max(report.frameRate, 0.01)).toFixed(1)} s)`,
+    report.avm === 'none' ? 'no ActionScript' : `needs ${report.avm === 'avm2' ? 'ActionScript 3 (AVM2)' : 'ActionScript 1/2 (AVM1)'}`,
+    `made of ${report.counts.shapes} shape(s), ${report.counts.sprites} sprite(s), ${report.counts.bitmaps} bitmap(s), ${report.counts.fonts} font(s), ${report.counts.sounds} sound(s), ${report.counts.scripts} script block(s)`,
+  ]
+  const listed = report.tags.slice(0, options.tags ?? 12)
+  if (listed.length > 0) {
+    lines.push(`first tags ${listed.map((tag) => `${tag.name}@${tag.offset}+${tag.length}`).join(' ')}`)
+  }
+  return lines
+}

package/scripts/check-flash-local.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * The Flash path, measured without the network: a page served from this
+ * process, its movie from the repo's own fixture, and the same bridge a site
+ * would be driven through. A site being slow or rate-limiting for a minute is
+ * not a plugin regression, and this check can tell the two apart.
+ *
+ *   node scripts/check-flash-local.mjs
+ *
+ * Asserts the movie painted, frames reach a viewer, and a press, a release and
+ * a key each reach the plugin in well under the time a person would notice.
+ * Own profile, own state directory, closed afterwards; nothing appears on the
+ * desktop.
+ */
+import { createServer } from 'node:http'
+import { createHash } from 'node:crypto'
+import { mkdtempSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+/* The looping movie, because a still one paints once and says nothing about
+   whether frames follow a moving picture. */
+const movie = readFileSync(join(here, '..', 'test', 'fixtures', 'loop.swf'))
+const page = `<!doctype html>
+<html><head><meta charset="utf-8"><title>Flash fixture</title></head>
+<body style="margin:0;background:#101820">
+<embed src="/tiny.swf" type="application/x-shockwave-flash" width="400" height="300">
+</body></html>`
+
+const server = createServer((request, reply) => {
+  if (request.url === '/tiny.swf') {
+    reply.writeHead(200, { 'content-type': 'application/x-shockwave-flash', 'content-length': movie.length })
+    reply.end(movie)
+    return
+  }
+  reply.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+  reply.end(page)
+})
+await new Promise((ready) => server.listen(0, '127.0.0.1', ready))
+const url = `http://127.0.0.1:${server.address().port}/`
+
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-flash-local-'))
+const { Sidecar } = await import('../sidecar.js')
+
+/** @param {number} ms - how long. */
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const hash = (buffer) => createHash('sha1').update(Buffer.from(buffer ?? '')).digest('hex').slice(0, 12)
+
+const sidecar = new Sidecar({ profile: 'flash-local', headless: false, flash: true })
+let ok = false
+try {
+  await sidecar.launch('about:blank')
+  const seen = []
+  const detach = await sidecar.watch((frame) => {
+    seen.push({ at: Date.now(), shape: hash(frame.jpeg), kb: Math.round(String(frame.jpeg ?? '').length * 0.75 / 1024) })
+  })
+  const navigatedAt = Date.now()
+  await sidecar.page.navigate(url).catch(() => {})
+  for (let i = 0; i < 60 && seen.length === 0; i += 1) await wait(250)
+  const firstFrameMs = Date.now() - navigatedAt
+  await wait(3000)
+  detach()
+  const gaps = seen.slice(1).map((one, index) => one.at - seen[index].at).sort((a, b) => a - b)
+  const fps = gaps.length === 0 ? 0 : Math.round((1000 / (gaps[Math.floor(gaps.length / 2)] || 1000)) * 10) / 10
+  const shapes = new Set(seen.map((one) => one.shape))
+  const info = await fetch(`http://127.0.0.1:${sidecar.page.flashBridge}/info`, { signal: AbortSignal.timeout(1500) }).then((one) => one.json()).catch(() => ({}))
+  const pressedAt = Date.now()
+  await sidecar.page.mouse('mousePressed', { x: 640, y: 420 })
+  const pressMs = Date.now() - pressedAt
+  const releasedAt = Date.now()
+  await sidecar.page.mouse('mouseReleased', { x: 640, y: 420 })
+  const releaseMs = Date.now() - releasedAt
+  const keyAt = Date.now()
+  await sidecar.page.key('keyDown', { key: 'a', text: 'a' })
+  const keyMs = Date.now() - keyAt
+  await sidecar.page.key('keyUp', { key: 'a' })
+  await wait(600)
+  /* The same endpoint a click uses, asked directly: the plugin took the input
+     rather than a path timing out on the way there. */
+  const fedReply = await fetch(`http://127.0.0.1:${sidecar.page.flashBridge}/input`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ type: 'mouseMove', x: 200, y: 150, button: 'left', clickCount: 0 }),
+    signal: AbortSignal.timeout(1500),
+  }).catch((error) => ({ status: 0, text: () => Promise.resolve(String(error?.message ?? error)) }))
+  const fedStatus = fedReply.status
+  const fedText = await fedReply.text().catch(() => '')
+  const fed = { ok: fedText.includes('"ok":true') }
+  const frameKB = seen.length === 0 ? 0 : Math.round(seen.reduce((sum, one) => sum + one.kb, 0) / seen.length)
+  /* The fixture movie is not a game: what is asserted here is that the movie
+     painted, that frames reached a viewer, and that input arrived without a
+     detour through the debugging protocol. Frame rate on moving pictures is
+     measured by check-flash-mirror against a real site. */
+  ok = Number(info.painted ?? 0) > 1 && seen.length >= 3 && shapes.size >= 2 && firstFrameMs < 1500 && pressMs < 40 && releaseMs < 40 && keyMs < 40 && fed.ok === true && frameKB > 0
+  console.log(JSON.stringify({ url, firstFrameMs, frames: seen.length, fps, shapes: shapes.size, frameKB, painted: info.painted ?? 0, pressMs, releaseMs, keyMs, fedStatus, fedText: fedText.slice(0, 80), fed: fed.ok === true, ok }))
+} catch (error) {
+  console.log(JSON.stringify({ ok: false, error: String(error?.message ?? error).slice(0, 160) }))
+} finally {
+  await sidecar.shutdown().catch(() => {})
+  server.close()
+}
+process.exitCode = ok ? 0 : 1

package/scripts/check-flash-mirror.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Does a Flash page mirror into the column at a usable rate, and do clicks land?
+ *
+ *   node scripts/check-flash-mirror.mjs [url]
+ *
+ * Counts the frames a viewer really receives, times a press and a release
+ * through the page, and reports both next to the frame size. Own profile, own
+ * state directory, closed afterwards; nothing is shown on the desktop.
+ */
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const url = process.argv[2] ?? 'http://account.100bt.com/game/auth/login.html?gameName=aola&action=startgame&platform=100bt'
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-flash-mirror-'))
+
+const { Sidecar } = await import('../sidecar.js')
+
+/** @param {number} ms - how long. */
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'flash-mirror', headless: false, flash: true })
+let ok = false
+try {
+  const started = Date.now()
+  await sidecar.launch('about:blank')
+  const sizes = []
+  const times = []
+  const detach = await sidecar.watch((frame) => {
+    sizes.push(Math.round(String(frame.jpeg ?? '').length * 0.75 / 1024))
+    times.push(Date.now())
+  })
+  const navigatedAt = Date.now()
+  const page = sidecar.page
+  await page.navigate(url).catch(() => {})
+  for (let i = 0; i < 60 && times.length === 0; i += 1) await wait(250)
+  const firstFrame = Date.now() - navigatedAt
+  await wait(4000)
+  detach()
+  const gaps = times.slice(1).map((at, index) => at - times[index]).sort((a, b) => a - b)
+  const fps = gaps.length === 0 ? 0 : Math.round((1000 / (gaps[Math.floor(gaps.length / 2)] || 1000)) * 10) / 10
+  const pressedAt = Date.now()
+  await page.mouse('mousePressed', { x: 640, y: 420 })
+  const pressMs = Date.now() - pressedAt
+  const releasedAt = Date.now()
+  await page.mouse('mouseReleased', { x: 640, y: 420 })
+  const releaseMs = Date.now() - releasedAt
+  await wait(400)
+  const before = await page.picture()
+  const keyAt = Date.now()
+  await page.key('keyDown', { key: 'a', text: 'a' })
+  const keyMs = Date.now() - keyAt
+  await page.key('keyUp', { key: 'a' })
+  await wait(600)
+  const moved = await page.picture()
+  ok = fps >= 15 && pressMs < 40 && releaseMs < 40 && keyMs < 40 && moved !== before && sizes.length > 5
+  console.log(JSON.stringify({
+    firstFrameMs: firstFrame,
+    frames: sizes.length,
+    fps,
+    frameKB: sizes.length === 0 ? 0 : Math.round(sizes.reduce((a, b) => a + b, 0) / sizes.length),
+    pressMs,
+    releaseMs,
+    keyMs,
+    responded: moved !== '' && moved !== before,
+    ok,
+  }))
+} catch (error) {
+  console.log(JSON.stringify({ ok: false, error: String(error?.message ?? error).slice(0, 160) }))
+} finally {
+  await sidecar.shutdown().catch(() => {})
+}
+process.exitCode = ok ? 0 : 1

package/scripts/check-flash-tools.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * What a tool call costs on a Flash page, from the model's side.
+ *
+ *   node scripts/check-flash-tools.mjs [url]
+ *
+ * Runs the real tool definitions against a real Flash runtime and reports time
+ * and characters for a click, a view and a type, plus whether the picture moved.
+ */
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const url = process.argv[2] ?? 'http://account.100bt.com/game/auth/login.html?gameName=aola&action=startgame&platform=100bt'
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-flash-tools-'))
+
+const { Sidecar } = await import('../sidecar.js')
+const { sidecarTools } = await import('../tools.js')
+
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'flash-tools', headless: false, flash: true })
+const refs = { byChat: new Map() }
+const tools = sidecarTools(sidecar, refs, {})
+const tool = (name) => tools.find((one) => one.name === name)
+let ok = false
+try {
+  await sidecar.launch('about:blank')
+  await sidecar.watch(() => {})
+  await sidecar.page.navigate(url).catch(() => {})
+  await wait(9000)
+  const said = []
+  const timed = async (name, args) => {
+    const started = Date.now()
+    const value = await tool(name).execute(args, { agent: { id: 'flash-check' } })
+    const text = String(value?.text ?? '')
+    const record = { tool: name, ms: Date.now() - started, chars: text.length, text: text.slice(0, 120) }
+    said.push(record)
+    return record
+  }
+  await timed('browser_view', {})
+  /* One call is a sample, five are a cost: a plugin page blocks its main
+     thread while it draws, so a single number swings by a hundred ms. */
+  const rounds = []
+  for (let i = 0; i < 5; i += 1) {
+    rounds.push(await timed('browser_click', { x: 640, y: 420 }))
+    rounds.push(await timed('browser_type', { text: 'a' }))
+  }
+  const median = (list) => {
+    const sorted = list.map((one) => one.ms).sort((a, b) => a - b)
+    return sorted[Math.floor(sorted.length / 2)]
+  }
+  /* A read of a page just read is mostly the page again: it must cost a line,
+     not a snapshot. */
+  const viewAgain = await timed('browser_view', {})
+  const viewThird = await timed('browser_view', {})
+  const clicks = rounds.filter((one) => one.tool === 'browser_click')
+  const types = rounds.filter((one) => one.tool === 'browser_type')
+  const last = rounds[rounds.length - 1]
+  /* A step that repeats the address it read a moment ago is spend with nothing
+     to teach, so the budget is per step and tight: one line, not a page. */
+  const within = (one) => Number(one?.chars ?? 999) < 300
+  /* A page whose own requests fail still answers, but slowly: the numbers to
+     gate on are the token ones, and latency is judged only when the page came
+     up whole. Otherwise a bad minute at the site reads as a regression here. */
+  const degraded = said[0].chars < 300 || said[0].text.includes('page trouble')
+  const fast = () => degraded || (median(clicks) < 120 && median(types) < 120)
+  ok = clicks.length === 5 && fast() && clicks.every(within) && types.every(within) && Number(last?.chars ?? 0) > 0 && viewAgain.chars < said[0].chars && viewThird.chars < said[0].chars
+  console.log(JSON.stringify({ view: said[0], clickMedianMs: median(clicks), clickMaxMs: Math.max(...clicks.map((one) => one.ms)), typeMedianMs: median(types), typeMaxMs: Math.max(...types.map((one) => one.ms)), clickChars: clicks[0].chars, typeChars: types[0].chars, viewAgainChars: viewAgain.chars, viewThirdChars: viewThird.chars, viewAgainText: viewAgain.text, degraded, ok }))
+} catch (error) {
+  console.log(JSON.stringify({ ok: false, error: String(error?.message ?? error).slice(0, 160) }))
+} finally {
+  await sidecar.shutdown().catch(() => {})
+}
+process.exitCode = ok ? 0 : 1

package/scripts/check-flash-window.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Can a Flash game run without ever appearing on the desktop?
+ *
+ *   node scripts/check-flash-window.mjs [url]
+ *
+ * Starts the plugin's own Flash runtime on the address, then checks three
+ * things that together mean "only the column sees it": the window was never
+ * shown, the picture keeps changing, and the process is not a frontmost or
+ * Dock-bearing app. Its own profile and state directory; both are closed.
+ */
+import { mkdtempSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const url = process.argv[2] ?? 'http://account.100bt.com/game/auth/login.html?gameName=aola&action=startgame&platform=100bt'
+process.env.DSH_INNER_BROWSER_STATE_DIR = mkdtempSync(join(tmpdir(), 'dsh-flash-window-'))
+
+const { Sidecar } = await import('../sidecar.js')
+
+/** @param {number} ms - how long. */
+const wait = (ms) => new Promise((settle) => setTimeout(settle, ms))
+const sidecar = new Sidecar({ profile: 'flash-window', headless: false, flash: true })
+let ok = false
+try {
+  const started = Date.now()
+  await sidecar.launch('about:blank')
+  await sidecar.page.navigate(url).catch(() => {})
+  await wait(10_000)
+  const base = `http://127.0.0.1:${sidecar.flashBridge}`
+  const info = await fetch(`${base}/info`).then((reply) => reply.json()).catch(() => null)
+  const grab = async () => {
+    const body = Buffer.from(await (await fetch(`${base}/frame.jpg`)).arrayBuffer())
+    return { kb: Math.round(body.length / 1024), hash: createHash('sha1').update(body).digest('hex').slice(0, 8) }
+  }
+  const one = await grab()
+  await wait(900)
+  const two = await grab()
+  const neverShown = info !== null && info.visible === false
+  const painting = info !== null && Number(info.painted ?? 0) > 10
+  const moving = one.hash !== two.hash
+  ok = neverShown && painting && moving
+  console.log(JSON.stringify({
+    url: String(info?.url ?? url).slice(0, 80),
+    visible: info?.visible,
+    painted: info?.painted,
+    frameKB: one.kb,
+    moved: moving,
+    ms: Date.now() - started,
+    ok,
+  }))
+} catch (error) {
+  console.log(JSON.stringify({ ok: false, error: String(error?.message ?? error).slice(0, 160) }))
+} finally {
+  await sidecar.shutdown().catch(() => {})
+}
+process.exitCode = ok ? 0 : 1

package/scripts/doctor.mjs

@@ -66,9 +66,10 @@ const state = await get(`${ROUTE}/sidecar/state`)
 console.log(`host     ${state === null ? `not answering under ${ROUTE}` : base}`)
 if (state === null) {
   console.log('         start the app, or set DSH_BRIDGE to the app address')
-  process.exit(0)
+  process.exitCode = 0
 }
 
+if (state !== null) {
 console.log(`browser  ${state.alive === true ? `attached, ${state.headless === true ? 'headless' : 'with a window'}` : 'not running'}`)
 const profileDir = join(PROFILES, String(state.profile ?? ''))
 console.log(`profile  ${state.profile} in ${profileDir}`)
@@ -87,3 +88,4 @@ if (existsSync(portFile)) {
 }
 
 if (String(state.error ?? '') !== '') console.log(`error    ${state.error}`)
+}