@solidrt/cli 0.0.50 → 0.0.52

package/src/{project.ts → lib/project.ts}

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path"
+import { fail } from "./util"
 
-// Project configuration lives in the `solidrt` key of the nearest package.json
-// above the entry file (okf/plans/client-storage-updates.md):
+// Project configuration lives in the `solidrt` key of the project's
+// package.json (okf/plans/client-storage-updates.md):
 //
 //   "solidrt": {
 //     "appId": "com.example.app",   // stable identity: storage dir, Android package id
@@ -15,16 +16,68 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "nod
 //   }
 //
 // Everything defaults from the package name (or the entry filename when there
-// is no package.json) so a dev project needs zero config; `srt pack` warns
+// is no project) so a dev project needs zero config; `srt pack` warns
 // when appId is defaulted, since a distributed app should pin its identity.
+//
+// The key is read in one place, loadProject, which checks every field's
+// shape (throw-in-dev policy: a bad value fails the command); the readers
+// (mode.ts, fonts.ts, and the identity and asset collectors below) take
+// their fields from the result and only check what is specific to them.
+//
+// Which project an entry belongs to is the caller's decision (mode.ts: the
+// cwd, never a search); the one exception is `srt check`, which verifies
+// trees of entries from one cwd and walks up from each (findProject).
+
+/** The `solidrt` key: every field optional, every present field shape-checked. */
+export type ProjectConfig = {
+  entry?: string
+  appId?: string
+  org?: string
+  displayName?: string
+  /** alias -> font file path, or false to drop a role default (fonts.ts). */
+  fonts?: Record<string, string | false>
+  icon?: string
+}
+
+export type Project = { dir: string; name: string | undefined; config: ProjectConfig }
+
+function parseProjectConfig(raw: unknown): ProjectConfig {
+  if (raw === undefined) return {}
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) fail('"solidrt" in package.json must be an object')
+  let config = raw as Record<string, unknown>
+  for (let key of ["entry", "appId", "org", "displayName", "icon"]) {
+    if (key in config && typeof config[key] !== "string") fail(`"solidrt": "${key}" must be a string`)
+  }
+  if ("fonts" in config) {
+    let fonts = config.fonts
+    if (typeof fonts !== "object" || fonts === null || Array.isArray(fonts)) {
+      fail('The "solidrt.fonts" key in package.json must be a map of alias to font file path (or false)')
+    }
+    for (let [alias, value] of Object.entries(fonts)) {
+      if (value !== false && typeof value !== "string") {
+        fail(`"solidrt.fonts": "${alias}" must be a font file path or false, got ${JSON.stringify(value)}`)
+      }
+      if (Buffer.byteLength(alias, "utf8") > 255) fail(`"solidrt.fonts": alias "${alias}" is too long (max 255 bytes)`)
+    }
+  }
+  return config as ProjectConfig
+}
+
+// The project at `dir`: its package name and validated `solidrt` config. A
+// dir without a package.json is an empty project; null (file mode: the entry
+// stands alone) stays null.
+export function loadProject(dir: string | null): Project | null {
+  if (dir === null) return null
+  let pkgPath = resolve(dir, "package.json")
+  let pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf8")) : {}
+  return { dir, name: typeof pkg.name === "string" ? pkg.name : undefined, config: parseProjectConfig(pkg.solidrt) }
+}
 
-export function findProjectPackage(sourcePath: string): { dir: string; pkg: any } | null {
+// The nearest project above a source file (see the note on searching above).
+export function findProject(sourcePath: string): Project | null {
   let dir = resolve(dirname(sourcePath))
   while (true) {
-    let pkgPath = resolve(dir, "package.json")
-    if (existsSync(pkgPath)) {
-      return { dir, pkg: JSON.parse(readFileSync(pkgPath, "utf8")) }
-    }
+    if (existsSync(resolve(dir, "package.json"))) return loadProject(dir)
     let parent = dirname(dir)
     if (parent === dir) return null
     dir = parent
@@ -33,11 +86,6 @@ export function findProjectPackage(sourcePath: string): { dir: string; pkg: any
 
 export type AppIdentity = { appId: string; org: string; displayName: string; defaulted: boolean }
 
-function fail(message: string): never {
-  console.error(message)
-  process.exit(1)
-}
-
 // Storage directory component (matches the runtime's safe_component check).
 let APP_ID_PATTERN = /^[A-Za-z0-9._-]+$/
 
@@ -64,19 +112,36 @@ function checkField(value: string, what: string) {
 // derivation question is settled (see plan).
 export const RUNTIME_VERSION = 1
 
+// This CLI's version, the one value every "which srt is this" answer comes
+// from (--version, the manifest stamp, the MCP server). A published CLI
+// carries the real version in its package.json; in-repo that is the 0.0.0
+// placeholder (see CLAUDE.md, "Versioning"), so a checkout reports the same
+// git describe the runtime builds stamp themselves with (lattice/Makefile,
+// flux/build.rs). Falls back to the placeholder when git cannot answer.
+function cliVersion(): string {
+  let pkgVersion = JSON.parse(readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf8")).version
+  if (pkgVersion !== "0.0.0") return pkgVersion
+  let git = Bun.spawnSync({
+    cmd: ["git", "describe", "--tags", "--always", "--dirty"],
+    cwd: import.meta.dir,
+    stdout: "pipe",
+    stderr: "ignore",
+  })
+  return git.success ? git.stdout.toString().trim().replace(/^v/, "") : pkgVersion
+}
+export const CLI_VERSION: string = cliVersion()
+
 // The manifest's solidrtVersion: provenance, not a compat gate like
-// runtimeVersion - the CLI release that built the version. Published CLIs
-// carry the real version in their package.json; the in-repo 0.0.0
-// placeholder stamps "unknown".
-let pkgVersion = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")).version
-export const SOLIDRT_VERSION: string = pkgVersion === "0.0.0" ? "unknown" : pkgVersion
+// runtimeVersion - the CLI release (or checkout) that built the version. The
+// packed runner warns when it differs from its own (lattice/src/main.rs).
+export const SOLIDRT_VERSION: string = CLI_VERSION
 
 // `extra` are build outputs that ship as assets too (isolate bundles); they
 // follow the assets/ tree in the list, in the order given.
-export function buildManifest(code: string, entry: string, extra: ManifestAsset[] = []): string {
-  let identity = loadAppIdentity(entry)
+export function buildManifest(code: string, entry: string, extra: ManifestAsset[], projectDir: string | null): string {
+  let identity = loadAppIdentity(entry, projectDir)
   let sha256 = new Bun.CryptoHasher("sha256").update(code).digest("hex")
-  let { assets, fonts, icon } = collectAssets(entry)
+  let { assets, fonts, icon } = collectAssets(projectDir)
   assets.push(...extra)
   return JSON.stringify({
     appId: identity.appId,
@@ -98,12 +163,6 @@ export function manifestAssetFor(path: string, bytes: Uint8Array): ManifestAsset
   return { path, sha256: new Bun.CryptoHasher("sha256").update(bytes).digest("hex"), size: bytes.length }
 }
 
-// The project root the assets/ convention hangs off: the nearest package.json
-// dir, or the entry's own dir when there is none.
-export function projectDirFor(sourcePath: string): string {
-  return findProjectPackage(sourcePath)?.dir ?? resolve(dirname(sourcePath))
-}
-
 // The manifest asset path for an absolute file inside the project's assets/
 // dir, or null when it lies outside it.
 export function assetPathFor(projectDir: string, abs: string): string | null {
@@ -137,13 +196,15 @@ function walkAssets(assetsDir: string, dir: string, out: ManifestAsset[]) {
 // and the raster surfaces (window icon, OS embedding) come with later stages
 // (okf/backlog/app-icons.md). An undeclared assets/icon.svg is picked up by
 // convention.
-export function collectAssets(entry: string): {
+export function collectAssets(dir: string | null): {
   assets: ManifestAsset[]
   fonts: ManifestFont[]
   icon: string | null
 } {
-  let project = findProjectPackage(entry)
-  let projectDir = projectDirFor(entry)
+  let project = loadProject(dir)
+  // No project (file mode): the entry stands alone, so no assets at all.
+  if (!project) return { assets: [], fonts: [], icon: null }
+  let projectDir = project.dir
   let assetsDir = resolve(projectDir, "assets")
 
   let assets: ManifestAsset[] = []
@@ -153,25 +214,21 @@ export function collectAssets(entry: string): {
   }
 
   let fonts: ManifestFont[] = []
-  let map = project?.pkg.solidrt?.fonts
-  if (map && typeof map === "object" && !Array.isArray(map)) {
-    for (let [alias, value] of Object.entries(map)) {
-      if (typeof value !== "string") continue
-      let path = assetPathFor(projectDir, resolve(projectDir, value))
-      if (!path) {
-        fail(`"solidrt.fonts": "${alias}": ${value} must live under assets/ (fonts ship as version assets)`)
-      }
-      if (!assets.some((a) => a.path === path)) {
-        fail(`"solidrt.fonts": "${alias}": no such file: ${resolve(projectDir, value)}`)
-      }
-      fonts.push({ path, alias })
+  for (let [alias, value] of Object.entries(project.config.fonts ?? {})) {
+    if (value === false) continue
+    let path = assetPathFor(projectDir, resolve(projectDir, value))
+    if (!path) {
+      fail(`"solidrt.fonts": "${alias}": ${value} must live under assets/ (fonts ship as version assets)`)
+    }
+    if (!assets.some((a) => a.path === path)) {
+      fail(`"solidrt.fonts": "${alias}": no such file: ${resolve(projectDir, value)}`)
     }
+    fonts.push({ path, alias })
   }
 
   let icon: string | null = null
-  let declared = project?.pkg.solidrt?.icon
+  let declared = project.config.icon
   if (declared !== undefined) {
-    if (typeof declared !== "string") fail('"solidrt": "icon" must be a string path')
     let path = assetPathFor(projectDir, resolve(projectDir, declared))
     if (!path) {
       fail(`"solidrt.icon": ${declared} must live under assets/ (the icon ships as a version asset)`)
@@ -192,26 +249,17 @@ export function collectAssets(entry: string): {
 
 // Resolve the app identity for a pack. All three fields are guaranteed
 // non-empty and 255 bytes max (the trailer encoding's length prefix).
-export function loadAppIdentity(sourcePath: string): AppIdentity {
-  let project = findProjectPackage(sourcePath)
-  let config = project?.pkg.solidrt ?? {}
+export function loadAppIdentity(sourcePath: string, projectDir: string | null): AppIdentity {
+  let project = loadProject(projectDir)
+  let config = project?.config ?? {}
   // A scoped package name (@org/name) defaults to its last segment: identity
   // fields reject path separators, and derived defaults must never fail that.
-  let fallbackName = (project?.pkg.name ?? basename(sourcePath).replace(/\.[jt]sx?$/, "")).split("/").pop()!
+  let fallbackName = (project?.name ?? basename(sourcePath).replace(/\.[jt]sx?$/, "")).split("/").pop()!
 
-  for (let key of ["appId", "org", "displayName"]) {
-    if (key in config && typeof config[key] !== "string") fail(`"solidrt": "${key}" must be a string`)
-  }
-
-  let appId: string
-  let defaulted = typeof config.appId !== "string"
-  if (defaulted) {
-    appId = sanitizeAppId(fallbackName)
-  } else {
-    appId = config.appId
-    if (!APP_ID_PATTERN.test(appId) || appId === "." || appId === "..") {
-      fail(`"solidrt": "appId" must match ${APP_ID_PATTERN} (reverse-DNS recommended, e.g. "com.example.app")`)
-    }
+  let defaulted = config.appId === undefined
+  let appId = config.appId ?? sanitizeAppId(fallbackName)
+  if (!defaulted && (!APP_ID_PATTERN.test(appId) || appId === "." || appId === "..")) {
+    fail(`"solidrt": "appId" must match ${APP_ID_PATTERN} (reverse-DNS recommended, e.g. "com.example.app")`)
   }
   let displayName = config.displayName ?? fallbackName
   let org = config.org ?? displayName

package/src/lib/registry.ts

@@ -0,0 +1,120 @@
+// Reading the server registry: every running dev server keeps a live.json in
+// ~/.solidrt/servers/<key hash>/ (written by the server itself, see
+// packages/cli/src/server/registry.ts). `srt client`, `srt mcp` and the launcher
+// resolve a server from it by key: the canonical project root or file path
+// (see mode.ts). The record is a hint; the server is authoritative, so a
+// caller confirms with a control call (the x-solidrt-project header names
+// the key it serves).
+
+import { readdirSync, readFileSync, realpathSync } from "node:fs"
+import { join } from "node:path"
+import { serversRoot } from "./dev-dir"
+import type { LiveRecord } from "../types/registry"
+
+// Only ESRCH means the process is gone. EPERM is a live process this bridge
+// may not signal (Windows reports it for other users' processes), and a
+// bare try/catch would drop that healthy server from the registry.
+export function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e: any) {
+    return e?.code === "EPERM"
+  }
+}
+
+// Two keys from different processes agree by construction on the path, not
+// the spelling (drive-letter case, 8.3 names, symlinks); compare canonical.
+export function sameKey(a: string, b: string): boolean {
+  if (a === b) return true
+  try {
+    return realpathSync.native(a) === realpathSync.native(b)
+  } catch {
+    return false
+  }
+}
+
+/** Every readable record whose process is alive. Malformed records are
+ * skipped, not fatal. */
+export function liveRecords(): LiveRecord[] {
+  let root = serversRoot()
+  let names: string[]
+  try {
+    names = readdirSync(root)
+  } catch {
+    return []
+  }
+  let records: LiveRecord[] = []
+  for (let name of names) {
+    try {
+      let record = JSON.parse(readFileSync(join(root, name, "live.json"), "utf8"))
+      if (
+        typeof record?.pid === "number" &&
+        typeof record?.port === "number" &&
+        typeof record?.key === "string" &&
+        pidAlive(record.pid)
+      ) {
+        records.push(record)
+      }
+    } catch {}
+  }
+  return records
+}
+
+export type Resolution = { ok: true; record: LiveRecord } | { ok: false; message: string }
+
+/** Whether the server a record names is really there: its control API
+ * answers on the port and names the record's key. A pid reused by an
+ * unrelated process, or a port taken over by another server, fails here. */
+export async function confirmed(record: LiveRecord): Promise<boolean> {
+  try {
+    let resp = await fetch(`http://127.0.0.1:${record.port}/__control__/clients`, {
+      signal: AbortSignal.timeout(1000),
+    })
+    let served = resp.headers.get("x-solidrt-project")
+    return served !== null && sameKey(served, record.key)
+  } catch {
+    return false
+  }
+}
+
+// The one record the registry offered was a fossil (its pid lives on in an
+// unrelated process); the next server start prunes it.
+function stale(record: LiveRecord): string {
+  return (
+    `The registry names port ${record.port} (pid ${record.pid}) for ${record.key}, ` +
+    `but no dev server answers there: the record is stale. Start one with srt run.`
+  )
+}
+
+async function confirm(record: LiveRecord): Promise<Resolution> {
+  return (await confirmed(record)) ? { ok: true, record } : { ok: false, message: stale(record) }
+}
+
+/** The server on `port`, if the registry names one there. */
+export async function resolveByPort(port: number): Promise<Resolution> {
+  let record = liveRecords().find((r) => r.port === port)
+  return record ? confirm(record) : { ok: false, message: `No dev server on port ${port}.` }
+}
+
+/**
+ * The server for `cwd`: the project server keyed by cwd itself; otherwise
+ * the one file server whose file lies under cwd; otherwise an error that
+ * lists the candidates. The record is a hint and the server is
+ * authoritative, so the chosen record is confirmed before it is returned.
+ */
+export async function resolveFromCwd(cwd: string): Promise<Resolution> {
+  let records = liveRecords()
+  let project = records.find((r) => r.mode === "project" && sameKey(r.key, cwd))
+  if (project) return confirm(project)
+  let prefix = cwd.replace(/[\\/]+$/, "") + "/"
+  let files = records.filter((r) => r.mode === "file" && r.key.replace(/\\/g, "/").startsWith(prefix.replace(/\\/g, "/")))
+  if (files.length === 1) return confirm(files[0]!)
+  let listing =
+    records.length === 0
+      ? `Registry ${serversRoot()}: no running servers.`
+      : `Registry ${serversRoot()}: ${records.length} running server(s).\n` +
+        records.map((r) => `  port ${r.port}  ${r.mode} ${r.key}`).join("\n")
+  let hint = files.length > 1 ? `${files.length} file servers run under ${cwd}; pass --port <N> to pick one.` : "Start one with srt run."
+  return { ok: false, message: `No dev server for ${cwd}.\n${listing}\n${hint}` }
+}

package/src/lib/server-bundle.ts

@@ -0,0 +1,24 @@
+import { fileURLToPath } from "node:url"
+
+// The dev server (src/server/) is a flux script; the flux binary
+// runs one plain-JS file, so the server's TypeScript modules are bundled
+// into one. Bun is already the bundler; the browser target keeps node
+// builtins out, and the flux: capability modules stay external (the runtime
+// provides them). A published CLI ships this bundle prebuilt as
+// dist/server.js (the Makefile target, run at release time); a checkout
+// builds it per launch (main.ts).
+export async function buildServerBundle(outfile: string): Promise<void> {
+  let entry = fileURLToPath(new URL("../server/main.ts", import.meta.url))
+  let result = await Bun.build({
+    entrypoints: [entry],
+    target: "browser",
+    format: "esm",
+    external: ["flux:*"],
+  })
+  if (!result.success) {
+    console.error("[cli] Failed to bundle the dev server:")
+    for (let log of result.logs) console.error(String(log))
+    process.exit(1)
+  }
+  await Bun.write(outfile, result.outputs[0]!)
+}

package/src/lib/usage.ts

@@ -0,0 +1,117 @@
+import { CLI_VERSION } from "./project"
+
+// What srt says about itself: the version, the usage, and the short hint a
+// bare `srt`, an unknown command or a bad flag gets instead of the full usage
+// (so an error line stays on screen).
+
+export function printVersion() {
+  console.log(CLI_VERSION)
+}
+
+// The banner is information, not the error: only the error line goes to
+// stderr, and only an error fails the run.
+export function hint(error?: string): never {
+  if (error) console.error(error)
+  console.log(`srt ${CLI_VERSION}\nRun srt --help for usage.`)
+  process.exit(error ? 1 : 0)
+}
+
+export function printUsage() {
+  console.log(USAGE)
+}
+
+const USAGE = `Usage: srt <command> [options] [file]
+
+Commands:
+  init <dir>             Scaffold a new SolidRT project into a new (empty) folder
+  run [file]             Start dev server + local solidrt-go client
+  server [file]          Start dev server only
+  client                 Start solidrt-go client only
+  demo [<number>]        List the demos the installed packages ship, or run one
+  tool [<pkg>/<name>]    List the tools the installed packages ship, or run one
+                         (everything after the tool name is the tool's own arguments)
+  console                Start the dev console: the dev servers on this machine and their clients
+  android                Launch the client on a connected Android device (--install to install it first)
+  bundle [file]          Transpile TS/JS/TSX/JSX to JS or bytecode
+                         (a prebuilt <name>.srt.js: compile it to bytecode)
+  check [file]           Verify the app builds and typechecks, without writing anything
+                         (no file: every examples/*/src/index.tsx, packages/*/examples/*.tsx
+                         and packages/*/demos/src/*.tsx)
+  render [file]          Replay a script (optional) and render frames for video generation
+  pack [file]            Bundle + compile to a standalone executable (experimental)
+  mcp                    MCP server (stdio) exposing the running dev server to coding agents
+
+Global options:
+      --help             Print this usage and exit
+      --version          Print the srt version and exit
+
+run/server/bundle/pack/render: what the command works on
+  srt run                In a project root (package.json): the project, entry from
+                         "solidrt": { "entry" } (default src/index.tsx)
+  srt run <file>         Outside a project: the file on its own (no assets, no isolates)
+  srt run <file> --project   In a project root: the project, with this entry
+  srt run <file> --file      In a project root: the file on its own, ignoring the project
+  Build outputs land under dist/ in the current directory.
+  One server per project or file; each keeps the port it had last time,
+  else the first free one from 34884 up (see the startup line). Loopback only unless --lan.
+
+run/server/demo options:
+      --port <N>         Bind this port instead of the remembered/next free one
+      --lan              Bind every interface and announce the LAN address (QR)
+      --proxy-http       Route fetch calls through the dev server (HTTP cache enabled)
+      --capture <file>   Record connected clients' key events to a script file
+      --tunnel           Accept ticket-paired clients through the p2p tunnel
+      -- <args...>       Everything after -- reaches the app on every client (flux:process argv)
+
+run/client options:
+      --size <WxH>       Window size (default: 1280x720)
+      --stats            Show the debug stats overlay (FPS, memory, frame timings)
+      --data-root <dir>  Client data root (default: ~/.solidrt/clients)
+  -c, --client <N>       Client number: its own data tree under the data root (default: 0)
+
+client options:
+  (no flags)             Connect to the dev server of the project (or file) in the current directory
+      --port <N>         Connect to the local dev server on this port
+      --server <host:port>  Connect to a dev server at this address
+
+android options:
+  (no flags)             Launch the installed client, pointed at the dev server of the project (or file)
+                         in the current directory (the server must run with --lan, or be reached from an emulator)
+      --install          Install or update the client first, from the project's @solidrt/android-<abi> package
+      --port <N>         Point it at the local dev server on this port
+      --device <serial>  Target a specific adb device by serial or unique prefix
+
+mcp options:
+      --port <N>         Attach to the dev server on this port (default: resolve by project)
+
+bundle options:
+  -f, --flux             Bundle for the bare Flux runtime, without SolidJS (entry must be .ts|.js)
+  -d, --dev              Use development build of SolidJS (default: production)
+  -m, --minify           Minify the output
+      --compile          Compile to bytecode
+  -o, --output <dir>     Output directory (default: dist/bundle; for a prebuilt
+                         .srt.js, its own directory)
+      --stdout           Write bundle to stdout
+      --json             Write the bundle, its manifest and its isolates as one JSON object
+                         to stdout (the dev server's rebuild; --server <host:port> names it)
+
+console options:
+      -- <args...>       Everything after -- reaches the console (flux:process argv)
+
+pack options:
+      --folder           Write the flat app folder (runner + manifest + bundle + assets)
+                         instead of the single-file executable
+      --app              Write the app alone as one <entry>.srtapp (manifest + bundle + assets,
+                         no runner), for a runner to load: solidrt <file>.srtapp
+  -f, --flux             Pack for the bare Flux runtime instead of SolidRT (entry must be .ts|.js)
+  -m, --minify           Minify the output
+  -o, --output <name>    Output filename
+
+render options:
+      --script <file>    Script file to replay (default: no scripted input)
+      --fps <N>          Frames per second (default: 60)
+      --duration <N>     Duration in seconds, fractions allowed (default: 1)
+      --size <WxH>       Frame size in physical pixels (default: 1280x720)
+  -o, --output <path>    Where frames land: a directory (frame-NNNNNN.png inside it)
+                         or a path prefix (default: the current directory)
+      -- <args...>       Everything after -- is passed to the app (flux:process argv)`

package/src/lib/util.ts

@@ -0,0 +1,36 @@
+import { resolveBinary } from "./artifacts"
+
+// A fatal usage or configuration error: the message, then exit. The
+// throw-in-dev policy (CLAUDE.md, "API design"): a bad value fails the
+// command instead of being papered over.
+export function fail(message: string): never {
+  console.error(message)
+  process.exit(1)
+}
+
+// Build target per binary, for the "not found" hint. Run from the repo root.
+let BUILD_HINTS: Record<string, string> = {
+  "solidrt-go": "make client",
+  solidrt: "make runtime",
+  flux: "make -C flux flux",
+  fluxc: "make -C flux fluxc",
+  fluxrt: "make -C flux fluxrt PROFILE=release-opt",
+}
+
+export function requireBinary(name: string) {
+  let path = resolveBinary(name)
+  if (path) return path
+  let hint = BUILD_HINTS[name]
+  console.error(`Could not find ${name} binary.`)
+  if (hint) {
+    console.error(`Build it from source: run ${hint}, with SRT_HOME pointing at your SolidRT checkout.`)
+  } else {
+    console.error("Build it from source, with SRT_HOME pointing at your SolidRT checkout.")
+  }
+  process.exit(1)
+}
+
+export async function run(binary: string, args: string[]) {
+  let proc = Bun.spawn([binary, ...args], { stdio: ["inherit", "inherit", "inherit"] })
+  return proc.exited
+}