omakit 0.5.0 → 0.6.1

package/tools/lab/paths.mjs

@@ -0,0 +1,173 @@
+// Where the lab keeps its bytes, and the one guard every write goes
+// through.
+//
+// Heavy files (the verified ISO, the base disk, a run's overlay) live
+// under the user cache, $XDG_CACHE_HOME/omakit/lab or ~/.cache/omakit/lab;
+// compact run records under the user state, $XDG_STATE_HOME/omakit/lab or
+// ~/.local/state/omakit/lab. Nothing is written anywhere else: every path
+// the lab writes to is built by `inLab`, which refuses a path outside the
+// resolved root, and tests/unit/self-containment.test.mjs holds every
+// write under tools/lab/ to that builder. Measured before this
+// (docs/history/2026-09-18-lab-inventory.md P6): the base, the firmware
+// variables and the SSH key lived inside the omarchy-iso checkout, named
+// by the ISO's file name.
+
+import { closeSync, createReadStream, createWriteStream, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs"
+import { pipeline } from "node:stream/promises"
+import { join, resolve, sep } from "node:path"
+import { omakitCacheDir, omakitStateDir } from "../marketplace/paths.mjs"
+
+/** The cache root: downloads, base, staging, the lock. */
+export function labCacheDir(env = process.env) {
+  return omakitCacheDir("lab", env)
+}
+
+/** The state root: run records, one directory per run id. */
+export function labStateDir(env = process.env) {
+  return omakitStateDir("lab", env)
+}
+
+/**
+ * The layout under the cache root. One base, not one per release
+ * (packaging/LAB_PLAN.md, the one-base rule): a pin update replaces it.
+ */
+export function labLayout(env = process.env) {
+  const cache = labCacheDir(env)
+  const state = labStateDir(env)
+  return Object.freeze({
+    cache,
+    state,
+    downloads: join(cache, "downloads"),
+    base: join(cache, "base"),
+    staging: join(cache, "staging"),
+    plugins: join(cache, "plugins"),
+    lock: join(cache, "lab.lock"),
+    toolchain: join(cache, "toolchain.json"),
+    runs: join(state, "runs"),
+  })
+}
+
+/**
+ * A path under one of the two lab roots, or a throw. Every write in
+ * tools/lab/ names its target through this, so a target outside the lab
+ * is a bug that fails before a byte moves, not a file somewhere else.
+ */
+export function inLab(root, ...parts) {
+  const target = resolve(root, ...parts)
+  const roots = [resolve(root)]
+  if (!roots.some((allowed) => target === allowed || target.startsWith(`${allowed}${sep}`))) {
+    throw new Error(`lab: ${target} is outside ${root}`)
+  }
+  return target
+}
+
+/** A directory under the lab, created private (0700) with its parents. */
+export function labDir(root, ...parts) {
+  const dir = inLab(root, ...parts)
+  mkdirSync(dir, { recursive: true, mode: 0o700 })
+  return dir
+}
+
+/** JSON written whole and fsynced, so a manifest is either there or not. */
+export function writeJson(root, relative, value) {
+  const file = inLab(root, relative)
+  const fd = openSync(file, "w", 0o600)
+  try {
+    writeFileSync(fd, `${JSON.stringify(value, null, 2)}\n`)
+    fsyncSync(fd)
+  } finally {
+    closeSync(fd)
+  }
+  return file
+}
+
+export function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Move a file or directory within the lab: a rename when the two are on
+ * one filesystem, and for a file on another one a streamed copy followed
+ * by the removal of the source. The destination must not exist. This is
+ * the one place the lab renames anything, and tests/unit/self-containment
+ * holds the tree to it.
+ */
+export async function moveIntoLab(root, from, relative) {
+  const to = inLab(root, relative)
+  try {
+    statSync(to)
+    throw new Error(`lab: ${to} exists; nothing is moved over it`)
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error
+  }
+  try {
+    renameSync(from, to)
+    return to
+  } catch (error) {
+    if (error.code !== "EXDEV") throw error
+  }
+  const source = statSync(from)
+  if (!source.isFile()) throw new Error(`lab: ${from} is on another filesystem and is not a file; move it by hand`)
+  await copyIntoLab(root, from, relative)
+  unlinkSync(from)
+  return to
+}
+
+/** A streamed copy of one file into the lab, mode 0600, fsynced. The destination must not exist. */
+export async function copyIntoLab(root, from, relative) {
+  const to = inLab(root, relative)
+  try {
+    statSync(to)
+    throw new Error(`lab: ${to} exists; nothing is copied over it`)
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error
+  }
+  const out = createWriteStream(to, { mode: 0o600, flags: "wx" })
+  await pipeline(createReadStream(from), out)
+  const fd = openSync(to, "r")
+  try {
+    fsyncSync(fd)
+  } finally {
+    closeSync(fd)
+  }
+  return to
+}
+
+/** Remove something under the lab, and nothing outside it. */
+export function removeFromLab(root, relative) {
+  rmSync(inLab(root, relative), { recursive: true, force: true })
+}
+
+/** `20260918-150245`, the run id shape the toolchain used, kept so a run directory sorts by time. */
+export function stampNow(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, "0")
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`
+}
+
+/** Allocated bytes of a path, like `du -B1`: blocks times 512, so a sparse qcow2 is measured by what it takes. */
+export function allocatedBytes(path) {
+  const walk = (p) => {
+    let st
+    try {
+      st = statSync(p)
+    } catch {
+      return 0
+    }
+    let total = st.blocks * 512
+    if (st.isDirectory()) {
+      let entries = []
+      try {
+        entries = readdirSync(p)
+      } catch {
+        return total
+      }
+      for (const entry of entries) total += walk(join(p, entry))
+    }
+    return total
+  }
+  return walk(path)
+}

package/tools/lab/pin.json

@@ -0,0 +1,42 @@
+{
+  "schema": 1,
+  "release": {
+    "name": "4.0.3",
+    "embeddedBuild": "2026.09.08",
+    "volume": "OMARCHY_202609",
+    "isoUrl": "https://iso.omarchy.org/omarchy-4.0.3.iso",
+    "checksumUrl": "https://iso.omarchy.org/omarchy-4.0.3.iso.sha256",
+    "signatureUrl": "https://iso.omarchy.org/omarchy-4.0.3.iso.sig",
+    "fileName": "omarchy-4.0.3.iso",
+    "bytes": 6260654080,
+    "sha256": "03d60bc74306dca51f96e1a84b690871d8d606826b260edd0208962da8507d14",
+    "signingFingerprint": "40DFB630FF42BCFFB047046CF0134EE680CAC571",
+    "signingKey": "omarchy.gpg",
+    "signingKeySha256": "15d6aac44df688165b2ea35fe0b23af239bbc66a6909c10a5c219e8d94b707de",
+    "expectedGuestVersion": "4.0.3-1"
+  },
+  "toolchain": {
+    "repository": "https://github.com/omacom-io/omarchy-iso",
+    "commit": "268bac16d351a21d867e37565738f458b11cb06c",
+    "harness": "bin/omarchy-iso-test",
+    "upstreamHarnessSha256": "fbc236a674464743c6ff8e4cc53be932dc36a16c9fcb159932006e9d7452439c",
+    "patch": "patches/omarchy-iso-test.patch",
+    "patchedHarnessSha256": "8637e8cc82413fb421daa17eb758e3136cf71099b108b6412326172993974e97"
+  },
+  "guest": {
+    "memoryMiB": 5120,
+    "user": "omarchy",
+    "password": "omarchy",
+    "diskGiB": 40
+  },
+  "measured": {
+    "on": "2026-09-18",
+    "buildMilliseconds": 357800,
+    "baseAllocatedBytes": 6181490688,
+    "baseDirectoryBytes": 6182264832,
+    "preparedLabBytes": 12442931200,
+    "overlayAfterRunBytes": 610734080,
+    "pluginsBytes": 6836224,
+    "source": "docs/MEASUREMENTS.md M14, measured by omakit lab on the reference host; packaging/LAB_PLAN.md M4 to M7 are the 2026-09-10 to 2026-09-13 observations it re-measured"
+  }
+}

package/tools/lab/pin.mjs

@@ -0,0 +1,64 @@
+// The release pin: the one Omarchy release the lab prepares, its exact
+// digest, its signer, and the toolchain that builds a base from it.
+//
+// Read from tools/lab/pin.json, never from the network: the lab never
+// resolves "latest" (docs/history/2026-09-18-lab-inventory.md P13: the
+// old setup scraped omarchy.org for the first ISO link and verified it
+// against a sidecar downloaded beside it, so a substituted pair passed).
+// Updating the pin is a reviewed change, docs/LAB.md says how.
+
+import { readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+export const LAB_DIR = dirname(fileURLToPath(import.meta.url))
+
+let cached = null
+
+/** The pin, parsed once. `file` is injectable for tests that need a small release. */
+export function labPin(file = join(LAB_DIR, "pin.json")) {
+  if (file === join(LAB_DIR, "pin.json") && cached) return cached
+  const pin = JSON.parse(readFileSync(file, "utf8"))
+  for (const key of ["release", "toolchain", "guest", "measured"]) {
+    if (!pin[key] || typeof pin[key] !== "object") throw new Error(`lab pin: no ${key} section in ${file}`)
+  }
+  if (!/^[0-9a-f]{64}$/.test(pin.release.sha256)) throw new Error("lab pin: the release sha256 is not 64 hex characters")
+  if (!/^[0-9A-F]{40}$/.test(pin.release.signingFingerprint)) throw new Error("lab pin: the signing fingerprint is not 40 hex characters")
+  if (!Number.isInteger(pin.release.bytes) || pin.release.bytes <= 0) throw new Error("lab pin: the release byte count is not a positive integer")
+  if (/latest/i.test(pin.release.isoUrl)) throw new Error("lab pin: the ISO URL resolves latest; the pin names one release")
+  if (file === join(LAB_DIR, "pin.json")) cached = pin
+  return pin
+}
+
+/**
+ * Bytes for a person, in both units, so a size cannot be made to look
+ * smaller by choosing one: `6,260,654,080 B (6.261 GB / 5.831 GiB)`.
+ * Decimal GB is what the download page and the disk vendor say, binary
+ * GiB is what `df` and `du -h` say; both are printed every time.
+ */
+export function bytesBoth(bytes) {
+  const n = Number(bytes)
+  const gb = (n / 1e9).toFixed(3)
+  const gib = (n / 2 ** 30).toFixed(3)
+  return `${n.toLocaleString("en-US")} B (${gb} GB / ${gib} GiB)`
+}
+
+/** The two units without the byte count, for a breakdown whose total already printed it: `6.261 GB / 5.831 GiB`. */
+export function gbBoth(bytes) {
+  const n = Number(bytes)
+  return `${(n / 1e9).toFixed(3)} GB / ${(n / 2 ** 30).toFixed(3)} GiB`
+}
+
+/** `4m 49.5s` from milliseconds, the way a person reads a build time. */
+export function durationWords(ms) {
+  const seconds = Math.round(ms / 100) / 10
+  if (seconds < 60) return `${seconds.toFixed(1)}s`
+  const minutes = Math.floor(seconds / 60)
+  return `${minutes}m ${(seconds - minutes * 60).toFixed(1)}s`
+}
+
+/** The first eight and last eight characters of a digest or fingerprint, for a line that names it without being it. */
+export function shortId(value) {
+  const s = String(value)
+  return s.length > 20 ? `${s.slice(0, 8)}...${s.slice(-8)}` : s
+}

package/tools/lab/prune.mjs

@@ -0,0 +1,68 @@
+// `omakit lab prune`: the explicit owner of lab-cache deletion. It
+// inventories what the lab owns under its own roots, prints each target
+// with its allocated bytes and the exact total, asks once (or takes
+// --yes), refuses while a run holds the lab or a QEMU still answers on a
+// staged socket, and afterwards reports what was recovered and what
+// remains. It never follows a symlink out of the lab, never touches the
+// marketplace pin or a checkout, and leaves run records alone unless
+// --runs names them.
+
+import { existsSync, lstatSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+import { bytesBoth, labPin } from "./pin.mjs"
+import { allocatedBytes, labLayout, removeFromLab } from "./paths.mjs"
+import { inspectBase, inspectLock, inspectStaging } from "./inspect.mjs"
+import { LabError } from "./run.mjs"
+
+/**
+ * What prune would remove. `keepIso` leaves the verified download (the
+ * expensive fetch); `runs` adds the run records under the state root.
+ */
+export async function planPrune({ env = process.env, pin = labPin(), keepIso = false, runs = false } = {}) {
+  const layout = labLayout(env)
+  const targets = []
+  const add = (root, relative, what) => {
+    const path = join(root, relative)
+    if (!existsSync(path)) return
+    if (lstatSync(path).isSymbolicLink()) throw new LabError("prune-refused", `${path} is a symbolic link; the lab wrote none, so nothing under it is removed`)
+    targets.push({ root, relative, path, what, bytes: allocatedBytes(path) })
+  }
+  const lock = await inspectLock(layout)
+  const staging = await inspectStaging(layout)
+  const active = staging.filter((entry) => entry.alive)
+  const blockers = []
+  if (lock.held && lock.alive) blockers.push(`run ${lock.record?.runId || "unknown"} holds the lab (pid ${lock.record?.pid || "?"}${lock.qemuAnswers ? ", its QEMU answers on QMP" : ""})`)
+  for (const entry of active) blockers.push(`a QEMU still answers on ${entry.socket}`)
+  if (existsSync(layout.downloads)) {
+    for (const digest of readdirSync(layout.downloads)) {
+      const dir = join(layout.downloads, digest)
+      const verified = digest === pin.release.sha256 && existsSync(join(dir, "verified.json")) && existsSync(join(dir, pin.release.fileName))
+      if (verified && keepIso) {
+        add(layout.cache, `downloads/${digest}/${pin.release.fileName}.part`, "a partial download beside the verified ISO")
+        continue
+      }
+      add(layout.cache, `downloads/${digest}`, verified ? `the verified ISO of ${pin.release.name} and its record` : digest === pin.release.sha256 ? "the unverified or partial download of the pinned release" : `a download directory of another digest (${digest.slice(0, 12)})`)
+    }
+  }
+  const base = inspectBase(layout, pin)
+  if (base.state !== "missing") add(layout.cache, "base", `the ${base.state} base${base.manifest ? ` (Omarchy ${base.manifest.release.name}, guest ${base.manifest.guest.version})` : ""}`)
+  for (const entry of staging) if (!entry.alive) add(layout.cache, `staging/${entry.name}`, `staging left by ${entry.name}`)
+  if (existsSync(layout.plugins)) add(layout.cache, "plugins", "the listed plugins cached for the weigh evidence gate")
+  if (lock.held && !lock.alive) add(layout.cache, "lab.lock", `a stale lock from ${lock.record?.runId || "an unknown run"}`)
+  if (runs && existsSync(layout.runs)) add(layout.state, "runs", "every run record and document under the state root")
+  const total = targets.reduce((sum, target) => sum + target.bytes, 0)
+  return { layout, targets, total, blockers, remaining: { cache: existsSync(layout.cache) ? allocatedBytes(layout.cache) : 0, runs: existsSync(layout.runs) ? allocatedBytes(layout.runs) : 0 } }
+}
+
+/** Remove exactly the plan's targets, after the caller's consent; report recovered and remaining bytes. */
+export function prune(plan) {
+  if (plan.blockers.length) throw new LabError("lab-busy", `prune refuses while ${plan.blockers.join("; ")}`, { remedy: "wait for the run, or `omakit lab inspect` to see it" })
+  const removed = []
+  for (const target of plan.targets) {
+    removeFromLab(target.root, target.relative)
+    removed.push(target)
+  }
+  const recovered = removed.reduce((sum, target) => sum + target.bytes, 0)
+  const remaining = { cache: existsSync(plan.layout.cache) ? allocatedBytes(plan.layout.cache) : 0, runs: existsSync(plan.layout.runs) ? allocatedBytes(plan.layout.runs) : 0 }
+  return { removed, recovered, remaining, words: `recovered ${bytesBoth(recovered)}; ${bytesBoth(remaining.cache)} remain in the lab cache and ${bytesBoth(remaining.runs)} in run records` }
+}

package/tools/lab/qemu.mjs

@@ -0,0 +1,153 @@
+// The guest's machine: QEMU's argument list, built pure so a test can read
+// it, and the QMP socket, spoken to from Node so a run needs no socat.
+//
+// What the argument list guarantees, and tests/unit/lab.test.mjs holds it
+// to: the base disk is the overlay's backing file, opened by QEMU read-only
+// because the overlay is what is written; the firmware variables are the
+// run's own copy, never the base's template (docs/history/2026-09-18-lab-
+// inventory.md P15: the template's mtime moved with every run); no display,
+// no host directory, no host socket and no host device reaches the guest;
+// the one network device is user-mode with SSH forwarded on 127.0.0.1 and
+// nothing else forwarded.
+
+import { spawn } from "node:child_process"
+import { connect } from "node:net"
+import { OVMF_CODE } from "./host.mjs"
+
+/**
+ * @param {{ overlay: string, vars: string, memoryMiB: number, cpus: number, sshPort: number, qmpSocket: string, serialLog: string, pidFile: string, ovmfCode?: string }} options
+ */
+export function qemuArgs({ overlay, vars, memoryMiB, cpus, sshPort, qmpSocket, serialLog, pidFile, ovmfCode = OVMF_CODE }) {
+  if (!Number.isInteger(sshPort) || sshPort < 1024 || sshPort > 65535) throw new Error(`lab: the SSH port must be an unprivileged port, not ${sshPort}`)
+  return [
+    "-cpu", "host", "-enable-kvm", "-machine", "q35,accel=kvm",
+    "-smp", String(cpus),
+    "-m", String(memoryMiB),
+    "-drive", `if=pflash,format=raw,readonly=on,file=${ovmfCode}`,
+    "-drive", `if=pflash,format=raw,file=${vars}`,
+    "-drive", `file=${overlay},format=qcow2,if=none,id=drive0`,
+    "-device", "virtio-blk-pci,drive=drive0,bootindex=1",
+    "-device", "virtio-vga",
+    "-display", "none",
+    "-usb", "-device", "usb-tablet",
+    "-netdev", `user,id=net0,hostfwd=tcp:127.0.0.1:${sshPort}-:22`,
+    "-device", "virtio-net-pci,netdev=net0",
+    "-qmp", `unix:${qmpSocket},server,nowait`,
+    "-serial", `file:${serialLog}`,
+    "-pidfile", pidFile,
+  ]
+}
+
+/**
+ * Start QEMU as a child of this process, not daemonised: the lifetime is
+ * the run's, and the exit handlers in run.mjs end it on every path. The
+ * child's stdio goes to the run's log so a QEMU that refuses to start
+ * says why.
+ */
+export function startQemu(args, { log, binary = "qemu-system-x86_64" } = {}) {
+  const child = spawn(binary, args, { stdio: ["ignore", log, log] })
+  return child
+}
+
+/**
+ * One QMP session: the capabilities handshake, then `execute` per
+ * command. A command's answer is the first `return` or `error` object
+ * after it, events in between are dropped. The socket is opened per
+ * command, as the toolchain's socat did; QMP allows one client and a
+ * held-open socket would block a diagnostic connection.
+ */
+export function qmpExecute(socket, command, args = undefined, { timeoutMs = 5000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const client = connect(socket)
+    let buffer = ""
+    let stage = 0
+    let settled = false
+    const timer = setTimeout(() => finish(new Error(`QMP ${command} did not answer within ${timeoutMs} ms`)), timeoutMs)
+    const finish = (error, value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      client.destroy()
+      if (error) reject(error)
+      else resolve(value)
+    }
+    client.on("error", (error) => finish(Object.assign(new Error(`QMP socket ${socket}: ${error.code || error.message}`), { code: "qmp-unavailable" })))
+    client.on("data", (chunk) => {
+      buffer += chunk.toString("utf8")
+      let index
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index)
+        buffer = buffer.slice(index + 1)
+        let message
+        try {
+          message = JSON.parse(line)
+        } catch {
+          continue
+        }
+        if (stage === 0 && message.QMP) {
+          stage = 1
+          client.write(`${JSON.stringify({ execute: "qmp_capabilities" })}\n`)
+        } else if (stage === 1 && "return" in message) {
+          stage = 2
+          client.write(`${JSON.stringify({ execute: command, ...(args ? { arguments: args } : {}) })}\n`)
+        } else if (stage === 2 && "return" in message) {
+          finish(null, message.return)
+        } else if (stage === 2 && message.error) {
+          finish(Object.assign(new Error(`QMP ${command}: ${message.error.desc || message.error.class}`), { code: "qmp-error" }))
+        }
+      }
+    })
+  })
+}
+
+/** Whether a QEMU answers on this socket: the cross-namespace liveness question prune and the lock ask. */
+export async function qmpAlive(socket) {
+  try {
+    const status = await qmpExecute(socket, "query-status", undefined, { timeoutMs: 2000 })
+    return { alive: true, status: status?.status || null }
+  } catch {
+    return { alive: false, status: null }
+  }
+}
+
+/**
+ * The qcode for one character, as the toolchain's `type_text` mapped it.
+ * Only what a login needs is typed by the lab (the guest password), but
+ * the table is the toolchain's whole one so a suite that asks for more
+ * gets the same keys.
+ */
+const SHIFTED = {
+  "_": "minus", ":": "semicolon", "@": "2", "|": "backslash", '"': "apostrophe", "+": "equal", "%": "5", "&": "7", "*": "8",
+  "(": "9", ")": "0", "<": "comma", ">": "dot", "!": "1", "#": "3", "$": "4", "?": "slash", "~": "grave_accent", "{": "bracket_left", "}": "bracket_right",
+}
+const PLAIN = { " ": "spc", ".": "dot", ",": "comma", "-": "minus", "/": "slash", ";": "semicolon", "'": "apostrophe", "=": "equal", "\\": "backslash", "[": "bracket_left", "]": "bracket_right" }
+
+export function qcodesFor(text) {
+  const chords = []
+  for (const ch of String(text)) {
+    if (/^[a-z0-9]$/.test(ch)) chords.push([ch])
+    else if (/^[A-Z]$/.test(ch)) chords.push(["shift", ch.toLowerCase()])
+    else if (ch in PLAIN) chords.push([PLAIN[ch]])
+    else if (ch in SHIFTED) chords.push(["shift", SHIFTED[ch]])
+    else throw new Error(`lab: no qcode for ${JSON.stringify(ch)}`)
+  }
+  return chords
+}
+
+/** Press one chord: `["ctrl","alt","f3"]`, or `["ret"]`. */
+export async function press(socket, chord) {
+  await qmpExecute(socket, "send-key", { keys: chord.map((key) => ({ type: "qcode", data: key })) })
+}
+
+/** Type text one chord at a time, 50 ms apart as the toolchain did. */
+export async function typeText(socket, text) {
+  for (const chord of qcodesFor(text)) {
+    await press(socket, chord)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+  }
+}
+
+/** A screendump to a PPM file; the caller converts it if it has `magick`. */
+export async function screendump(socket, file) {
+  await qmpExecute(socket, "screendump", { filename: file })
+}

package/tools/lab/qmp-cli.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// QMP from a shell: `node tools/lab/qmp-cli.mjs <socket> screendump <file>`,
+// `... status`, `... press <chord>`. The harness's capture_console is the
+// one caller; it exists so a suite needs no socat.
+
+import { press, qmpExecute, screendump } from "./qemu.mjs"
+
+const [socket, command, argument] = process.argv.slice(2)
+if (!socket || !command) {
+  process.stderr.write("usage: qmp-cli.mjs <socket> screendump <file> | status | press <chord>\n")
+  process.exit(2)
+}
+try {
+  if (command === "screendump") await screendump(socket, argument)
+  else if (command === "status") process.stdout.write(`${JSON.stringify(await qmpExecute(socket, "query-status"))}\n`)
+  else if (command === "press") await press(socket, String(argument).split("-"))
+  else throw new Error(`unknown command ${command}`)
+} catch (error) {
+  process.stderr.write(`${error.message}\n`)
+  process.exit(1)
+}