@solidrt/cli 0.0.23 → 0.0.24

package/AGENTS.md

@@ -18,21 +18,25 @@ bundled `flux` runtime, not on Bun. Invoke via `bunx srt <command>`.
 - `bunx srt bundle src/index.tsx` - transpile to `<file>.srt.js`. With
   `--compile`, emits `.srt.bin` bytecode. `--minify`, `--dev`, `--stdout`,
   `--output` also available.
-- `bunx srt record src/index.tsx [flags]` - render OFFSCREEN to PNG frames.
+- `bunx srt render src/index.tsx [flags]` - render OFFSCREEN to PNG frames,
+  optionally replaying a `--script` file recorded via `--capture`.
 - `bunx srt server [file]` / `bunx srt client` - the two halves of `run`
   separately (server distributes code; clients on other devices connect to it).
+- `bunx srt run src/index.tsx --capture out.script.json` - records keydown/keyup
+  from every connected client into one script file (written on client
+  disconnect), for replaying later with `render --script`.
 
 ## Verifying without a display (headless / CI / agent box)
 
 Two reliable checks that need no GUI:
 
 1. `bunx srt bundle src/index.tsx` - exit 0 means the app compiles. Fast.
-2. `bunx srt record src/index.tsx --size 480x640 --duration 1 --fps 2` -
+2. `bunx srt render src/index.tsx --size 480x640 --duration 1 --fps 2` -
    renders offscreen via EGL/wgpu and writes `frame-NNNNNN.png`. This actually
    proves the app renders. Combine with `--fps`/`--duration` (defaults
    1280x720, 60fps, 1s).
 
-`record` gotchas:
+`render` gotchas:
 - Frames are written to the RUNTIME's working dir (`~/.local/share/SolidRT/go/`),
   NOT the directory you ran the command from. Look there for the PNGs.
 - The recording includes a debug overlay (FPS/REQ/MiB/CPU) in a corner.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -22,12 +22,12 @@
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.23",
-    "@solidrt/linux-x64-gnu": "0.0.23",
-    "@solidrt/win32-x64-msvc": "0.0.23"
+    "@solidrt/darwin-arm64": "0.0.24",
+    "@solidrt/linux-x64-gnu": "0.0.24",
+    "@solidrt/win32-x64-msvc": "0.0.24"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.23",
+    "@solidrt/core": "0.0.24",
     "typescript": "^6"
   },
   "devDependencies": {

package/scaffold/AGENTS.md

@@ -81,6 +81,6 @@ Authoritative references ship inside the installed packages - read them:
 
 - bunx srt run src/index.tsx     - dev server + window (needs a display)
 - bunx srt bundle src/index.tsx  - exit 0 means it compiles
-- bunx srt record src/index.tsx --size 480x640 --duration 1 --fps 2 - headless
+- bunx srt render src/index.tsx --size 480x640 --duration 1 --fps 2 - headless
   render to PNG frames (proves it renders; see the cli AGENTS.md for where the
   frames land)

package/scaffold/package.json

@@ -9,12 +9,12 @@
     "android": "srt client --android"
   },
   "dependencies": {
-    "@solidrt/core": "0.0.23",
-    "@solidrt/components": "0.0.23"
+    "@solidrt/core": "0.0.24",
+    "@solidrt/components": "0.0.24"
   },
   "devDependencies": {
-    "@solidrt/cli": "0.0.23",
-    "@solidrt/flux-types": "0.0.23",
+    "@solidrt/cli": "0.0.24",
+    "@solidrt/flux-types": "0.0.24",
     "typescript": "^6"
   }
 }

package/scaffold/templates/minimal/index.tsx

@@ -0,0 +1,11 @@
+import { render } from "@solidrt/core"
+
+function App() {
+  return (
+    <window>
+      <text>Hello, World!</text>
+    </window>
+  )
+}
+
+render(() => <App />)

package/src/args.ts

@@ -13,6 +13,8 @@ export let { values, positionals } = parseArgs({
     fps: { type: "string" },
     duration: { type: "string" },
     size: { type: "string" },
+    script: { type: "string" },
+    capture: { type: "string" },
     stats: { type: "boolean", default: false },
     android: { type: "boolean", default: false },
     device: { type: "string" },
@@ -43,8 +45,8 @@ export function validateArgs() {
         usage("srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
       }
       break
-    case "record":
-      if (!source || !isTsx) usage("srt record <entry.[tsx|jsx]>")
+    case "render":
+      if (!source || !isTsx) usage("srt render <entry.[tsx|jsx]>")
       break
     case "pack":
       if (values.flux) {
@@ -71,7 +73,7 @@ Commands:
   server [file]          Start dev server only
   client                 Start solidrt-go client only
   bundle <file>          Transpile TS/JS/TSX/JSX to JS or bytecode
-  record <file.tsx|jsx>  Capture frames for video generation
+  render <file.tsx|jsx>  Replay a script (optional) and render frames for video generation
   pack <file>            Bundle + compile to a standalone executable (experimental)
 
 init options:
@@ -80,6 +82,7 @@ init options:
 run/server options:
       --proxy-files      Route file/dir access through the dev server
       --proxy-http       Route fetch calls through the dev server (HTTP cache enabled)
+      --capture <file>   Record connected clients' key events to a script file
 
 run/client options:
       --size <WxH>       Window size (default: 1280x720)
@@ -102,7 +105,8 @@ pack options:
   -m, --minify           Minify the output
   -o, --output <name>    Output filename
 
-record options:
+render options:
+      --script <file>    Script file to replay (default: no scripted input)
       --fps <N>          Frames per second (default: 60)
       --duration <N>     Duration in seconds (default: 1)
       --size <WxH>       Frame size (default: 1280x720)`)

package/src/commands/render.ts

@@ -0,0 +1,18 @@
+import { source, values } from "../args"
+import { requireBinary, run } from "../util"
+import { bundleTo } from "../bundler"
+import { resolve } from "path"
+
+export async function runRenderCommand() {
+  let jsOutfile = source!.replace(/\.[jt]sx$/, "") + ".srt.js"
+  await bundleTo(jsOutfile)
+  let runner = requireBinary("solidrt-go")
+  let playbackArgs = ["--playback"]
+  if (values.fps) playbackArgs.push("--fps", values.fps)
+  if (values.duration) playbackArgs.push("--duration", values.duration)
+  if (values.size) playbackArgs.push("--size", values.size)
+  if (values.script) playbackArgs.push("--script", resolve(values.script))
+  playbackArgs.push(resolve(jsOutfile))
+  let exit = await run(runner, playbackArgs)
+  process.exit(exit)
+}

package/src/commands/server.ts

@@ -7,6 +7,7 @@ import { startRepl } from "../repl"
 import { startWatcher } from "../watcher"
 import * as cache from "../cache"
 import { resolve, dirname } from "path"
+import { writeFileSync } from "node:fs"
 
 // Brings up the dev server (HTTP/WS + initial bundle + repl + watcher). The
 // `run` command spawns a local client on top of this from main.ts.
@@ -15,6 +16,11 @@ export async function runServerCommand() {
   state.source = source
   state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
   state.stats = values.stats
+  state.capture = values.capture ? resolve(values.capture) : undefined
+  state.captureStartMs = Date.now()
+  // Start each capture from an empty file: appendFileSync (dev-server.ts)
+  // would otherwise tack onto whatever a previous run left behind.
+  if (state.capture) writeFileSync(state.capture, "")
 
   if (values["proxy-http"]) {
     cache.initCache({ dir: process.cwd() })

package/src/dev-server.ts

@@ -1,5 +1,6 @@
 import { resolve } from "path"
 import { stat as fsStat, readdir } from "node:fs/promises"
+import { appendFileSync } from "node:fs"
 import { networkInterfaces } from "node:os"
 import { Bonjour } from "bonjour-service"
 import qrcode from "qrcode-generator"
@@ -172,11 +173,14 @@ export function startServer() {
     },
     websocket: {
       open(ws) {
-        state.clients.set(ws, { platform: "unknown", version: "unknown" })
+        let id = state.nextClientId++
+        state.clients.set(ws, { platform: "unknown", version: "unknown", id })
         print(`[cli] Client connected ${ws.remoteAddress}`)
         // Advertise our real LAN address so clients dialed over the adb loopback
         // can show/remember the directly reachable address (see connection.rs).
-        ws.send(JSON.stringify({ type: "welcome", address: state.serverUrl, stats: state.stats }))
+        ws.send(
+          JSON.stringify({ type: "welcome", address: state.serverUrl, stats: state.stats, capture: !!state.capture }),
+        )
         if (state.currentCode) {
           ws.send(buildReload({ code: state.currentCode }))
         }
@@ -195,11 +199,25 @@ export function startServer() {
         try {
           let data = JSON.parse(typeof msg === "string" ? msg : Buffer.from(msg).toString())
           if (data.type === "info") {
+            let existing = state.clients.get(ws)
             state.clients.set(ws, {
               platform: data.platform ?? "unknown",
               version: data.version ?? "unknown",
+              id: existing?.id ?? state.nextClientId++,
             })
             print(`[cli] Client info ${ws.remoteAddress} ${data.platform} (${data.version})`)
+          } else if (data.type === "capture" && state.capture) {
+            let device = state.clients.get(ws)?.id ?? -1
+            // Milliseconds, integer: Date.now() is already integer ms, so the
+            // delta needs no rounding.
+            let at = Date.now() - state.captureStartMs
+            let after = at - state.captureLastAt
+            state.captureLastAt = at
+            // JSON Lines: one event object per line, streamed to disk as it
+            // arrives rather than buffered - no in-memory growth for a long
+            // capture, and the file is always complete on disk mid-session.
+            let line = JSON.stringify({ after, type: data.kind, key: data.key, device }) + "\n"
+            appendFileSync(state.capture, line)
           }
         } catch {}
       },

package/src/main.ts

@@ -4,7 +4,7 @@ import { values, command, validateArgs, printUsage } from "./args"
 import { runInitCommand } from "./commands/init"
 import { runBundleCommand } from "./commands/bundle"
 import { runPackCommand } from "./commands/pack"
-import { runRecordCommand } from "./commands/record"
+import { runRenderCommand } from "./commands/render"
 import { runServerCommand } from "./commands/server"
 import { runClientCommand } from "./commands/client"
 import { spawnClient } from "./dev-client"
@@ -22,7 +22,7 @@ validateArgs()
 // the auto-activation by setting NODE_ENV=production. Since that is read at startup,
 // we re-exec rather than mutate process.env. Assumes srt runs via bun (argv is
 // [bun, script, ...]); would need rework if ever shipped as a compiled binary.
-let isProdBuild = (command === "bundle" || command === "record" || command === "pack") && !values.dev
+let isProdBuild = (command === "bundle" || command === "render" || command === "pack") && !values.dev
 if (isProdBuild && process.env.NODE_ENV !== "production") {
   let proc = Bun.spawnSync({
     cmd: [process.execPath, ...process.argv.slice(1)],
@@ -42,8 +42,8 @@ if (command === "init") {
   await runBundleCommand()
 } else if (command === "pack") {
   await runPackCommand()
-} else if (command === "record") {
-  await runRecordCommand()
+} else if (command === "render") {
+  await runRenderCommand()
 } else if (command === "client") {
   await runClientCommand()
 } else if (command === "server") {

package/src/util.ts

@@ -6,7 +6,8 @@ import type { Server as BunServer } from "bun"
 import type { Bonjour } from "bonjour-service"
 
 export let state = {
-  clients: new Map<any, { platform: string; version: string }>(),
+  clients: new Map<any, { platform: string; version: string; id: number }>(),
+  nextClientId: 0,
   currentCode: null as string | null,
   source: undefined as string | undefined,
   sourceDir: process.cwd(),
@@ -16,6 +17,16 @@ export let state = {
   rl: null as ReadlineInterface | null,
   bonjour: null as Bonjour | null,
   stats: false,
+  // --capture <file>: destination for captured key events, or undefined when
+  // off. Clients only report kind/key; the server stamps `after` itself (one
+  // shared clock from captureStartMs, integer milliseconds) so events from
+  // several connected clients merge into one coherent timeline, tagged by
+  // `device` (see dev-server.ts) so they can be told apart. Streamed to disk
+  // as JSON Lines (one event object per line) as each arrives - see
+  // dev-server.ts's "capture" message handling.
+  capture: undefined as string | undefined,
+  captureStartMs: 0,
+  captureLastAt: 0, // ms, same clock as captureStartMs
 }
 
 // Build target per binary, for the "not found" hint. Run from the repo root.

package/src/commands/record.ts

@@ -1,16 +0,0 @@
-import { source, values } from "../args"
-import { requireBinary, run } from "../util"
-import { bundleTo } from "../bundler"
-import { resolve } from "path"
-
-export async function runRecordCommand() {
-  let jsOutfile = source!.replace(/\.[jt]sx$/, "") + ".srt.js"
-  await bundleTo(jsOutfile)
-  let runner = requireBinary("solidrt-go")
-  let recordArgs = ["--record", resolve(jsOutfile)]
-  if (values.fps) recordArgs.push("--fps", values.fps)
-  if (values.duration) recordArgs.push("--duration", values.duration)
-  if (values.size) recordArgs.push("--size", values.size)
-  let exit = await run(runner, recordArgs)
-  process.exit(exit)
-}