@solidrt/cli 0.0.2 → 0.0.4

package/package.json

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

package/src/args.ts

@@ -8,6 +8,10 @@ export let { values, positionals } = parseArgs({
     output: { type: "string", short: "o" },
     client: { type: "boolean", default: false },
     server: { type: "boolean", default: false },
+    cache: { type: "boolean", default: false },
+    fps: { type: "string" },
+    duration: { type: "string" },
+    size: { type: "string" },
   },
   allowPositionals: true,
 })
@@ -18,16 +22,29 @@ export let isTsx = source?.endsWith(".tsx")
 export let isPrebuilt = source?.endsWith(".srt.js") || source?.endsWith(".srt.bin")
 
 export function printUsage() {
-  console.error(`Usage: srt <build|run> [options] [entry.tsx]
+  console.error(`Usage: srt <command> [options] [file]
 
 Commands:
-  run [file.tsx]        Start dev server + client (no file = embedded default)
-  run --client          Start dev client only (connects to WS server)
-  run --server [file]   Start dev server only, no client
+  run [file.tsx]              Start dev server + local solidrt-go client
+  run --client                Start solidrt-go client only
+  run --server [file.tsx]     Start dev server only
+  build <file.tsx>            Bundle
+  record <file.tsx>           Capture frames for video generation
 
-Options:
+run options:
+      --client              Run client only
+      --server              Run server only
+      --cache               Enable HTTP cache
+      --size <WxH>          Window size (default: 1280x720)
+
+build options:
   -m, --minify          Minify the output
-  -c, --compile         Compile to bytecode (build only)
-  -o, --output <name>   Bundle filename (build only)
-      --stdout          Write bundle to stdout (build only)`)
+  -c, --compile         Compile to bytecode
+  -o, --output <name>   Output filename
+      --stdout          Write bundle to stdout
+
+record options:
+      --fps <N>             Frames per second (default: 60)
+      --duration <N>        Duration in seconds (default: 1)
+      --size <WxH>          Frame size (default: 1280x720)`)
 }

package/src/cache.ts

@@ -0,0 +1,129 @@
+// SQLite-backed HTTP response cache for the dev server's /__proxy__ endpoint.
+//
+// Project-local: stored at <cwd>/.srt-cache/cache.db. Opt-in via the --cache
+// flag. Entries live forever; delete the .srt-cache directory to drop them.
+//
+// Cached: GET (and HEAD) 2xx responses with no Authorization on the request
+// and no Cache-Control: no-store on either side. The cache key is
+// sha256(method + "\n" + url); headers are intentionally not part of the key.
+
+import { Database } from "bun:sqlite"
+import { resolve, join } from "path"
+import { mkdirSync } from "node:fs"
+import { createHash } from "node:crypto"
+
+const CACHE_DIR = ".srt-cache"
+const CACHE_DB = "cache.db"
+
+export type Decision = "hit" | "miss" | "bypass" | "skip"
+
+export type Entry = {
+  method: string
+  url: string
+  status: number
+  headers: Record<string, string>
+  body: Uint8Array
+  cachedAt: number
+}
+
+let db: Database | null = null
+let enabled = false
+
+export function initCache(opts: { dir: string }) {
+  mkdirSync(resolve(opts.dir, CACHE_DIR), { recursive: true })
+  let d = new Database(join(resolve(opts.dir, CACHE_DIR), CACHE_DB), { create: true })
+  d.run(`CREATE TABLE IF NOT EXISTS entries (
+    key         TEXT PRIMARY KEY,
+    method      TEXT NOT NULL,
+    url         TEXT NOT NULL,
+    status      INTEGER NOT NULL,
+    headers     TEXT NOT NULL,
+    body        BLOB NOT NULL,
+    cached_at   INTEGER NOT NULL
+  )`)
+  db = d
+  enabled = true
+}
+
+export function isEnabled(): boolean {
+  return enabled
+}
+
+function keyFor(method: string, url: string): string {
+  let h = createHash("sha256")
+  h.update(method)
+  h.update("\n")
+  h.update(url)
+  return h.digest("hex")
+}
+
+function cacheableMethod(method: string): boolean {
+  return method === "GET" || method === "HEAD"
+}
+
+function hasNoStore(headerVal: string | null): boolean {
+  if (!headerVal) return false
+  return /(^|,)\s*no-store(\s*,|$)/i.test(headerVal)
+}
+
+function hasNoCache(headerVal: string | null): boolean {
+  if (!headerVal) return false
+  return /(^|,)\s*no-cache(\s*,|$)/i.test(headerVal)
+}
+
+export function shouldConsider(method: string, reqHeaders: Headers): { skip: boolean } {
+  if (!enabled) return { skip: true }
+  if (!cacheableMethod(method)) return { skip: true }
+  if (reqHeaders.has("authorization")) return { skip: true }
+  if (hasNoStore(reqHeaders.get("cache-control"))) return { skip: true }
+  return { skip: false }
+}
+
+export function isBypass(reqHeaders: Headers): boolean {
+  if (reqHeaders.get("x-srt-cache")?.toLowerCase() === "bypass") return true
+  if (hasNoCache(reqHeaders.get("cache-control"))) return true
+  return false
+}
+
+export function get(method: string, url: string): Entry | null {
+  if (!db || !enabled) return null
+  let row = db
+    .query("SELECT method, url, status, headers, body, cached_at FROM entries WHERE key = ?")
+    .get(keyFor(method, url)) as
+    | {
+        method: string
+        url: string
+        status: number
+        headers: string
+        body: Uint8Array
+        cached_at: number
+      }
+    | null
+  if (!row) return null
+  return {
+    method: row.method,
+    url: row.url,
+    status: row.status,
+    headers: JSON.parse(row.headers),
+    body: row.body,
+    cachedAt: row.cached_at,
+  }
+}
+
+export function put(
+  method: string,
+  url: string,
+  status: number,
+  headers: Record<string, string>,
+  body: Uint8Array,
+) {
+  if (!db || !enabled) return
+  if (status < 200 || status >= 300) return
+  if (hasNoStore(headers["cache-control"] ?? null)) return
+  db.run(
+    `INSERT OR REPLACE INTO entries
+     (key, method, url, status, headers, body, cached_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [keyFor(method, url), method, url, status, JSON.stringify(headers), body, Date.now()],
+  )
+}

package/src/client.ts

@@ -1,4 +1,5 @@
 import { DEV_HOST, DEV_PORT, state, print, requireBinary } from "./util"
+import { values } from "./args"
 
 function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteStream) {
   let reader = stream.getReader()
@@ -15,7 +16,8 @@ function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteSt
 
 export function spawnClient() {
   let runner = requireBinary("solidrt-go")
-  state.child = Bun.spawn([runner], {
+  let args = values.size ? ["--size", values.size] : []
+  state.child = Bun.spawn([runner, ...args], {
   //TODO implement dev server connection
   // state.child = Bun.spawn([runner, "--dev-server", `${DEV_HOST}:${DEV_PORT}`], {
     stdio: ["ignore", "pipe", "pipe"],

package/src/main.ts

@@ -10,20 +10,22 @@
 //   srt build examples/hello.tsx        - bundle TSX to .srt.js
 //   srt build -c examples/hello.tsx     - bundle TSX to .srt.js + compile to .srt.bin
 //   srt build examples/hello.srt.js     - compile .srt.js to .srt.bin
+//   srt record examples/hello.tsx       - bundle TSX and run with frame capture
 
 import pkg from "../package.json"
 import { values, command, source, isTsx, isPrebuilt, printUsage } from "./args"
 import { state, requireBinary, run, shutdown } from "./util"
-import { bundle, runBuildCommand } from "./build"
+import { bundle, bundleTo, runBuildCommand } from "./build"
 import { startServer } from "./server"
 import { spawnClient } from "./client"
 import { startRepl } from "./repl"
 import { startWatcher } from "./watcher"
+import * as cache from "./cache"
 import { resolve, dirname } from "path"
 
 // -- Validate args --
 
-if (!command || (command !== "build" && command !== "run")) {
+if (!command || (command !== "build" && command !== "run" && command !== "record")) {
   printUsage()
   process.exit(1)
 }
@@ -33,17 +35,37 @@ if (command === "build" && (!source || (!isTsx && !isPrebuilt))) {
   process.exit(1)
 }
 
+if (command === "record" && (!source || !isTsx)) {
+  console.error("Usage: srt record <entry.tsx>")
+  process.exit(1)
+}
+
 // -- Build command --
 
 if (command === "build") {
   await runBuildCommand()
 }
 
+// -- Record command --
+
+if (command === "record") {
+  let jsOutfile = source!.replace(/\.tsx$/, "") + ".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)
+}
+
 // -- Run command --
 
 if (values.client) {
   let runner = requireBinary("solidrt-go")
-  let args = []
+  let args: string[] = []
+  if (values.size) args.push("--size", values.size)
   //TODO add dev server connection
   // if (source) args.push("--dev-server", source)
   let exit = await run(runner, args)
@@ -54,6 +76,11 @@ if (values.client) {
 state.source = source
 state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
 
+if (values.cache) {
+  cache.initCache({ dir: process.cwd() })
+  console.log("[cli] HTTP cache enabled (.srt-cache/)")
+}
+
 startServer()
 
 // Bundle initial code if source file given (after server start so the

package/src/server.ts

@@ -4,6 +4,82 @@ import { networkInterfaces } from "node:os"
 import { createSocket } from "node:dgram"
 import qrcode from "qrcode-generator"
 import { DEV_HOST, DEV_PORT, state, print } from "./util"
+import * as cache from "./cache"
+
+function headersToObject(h: Headers): Record<string, string> {
+  let out: Record<string, string> = {}
+  h.forEach((v, k) => {
+    out[k] = v
+  })
+  return out
+}
+
+async function handleProxy(req: Request): Promise<Response> {
+  let target = req.headers.get("x-srt-proxy-url")
+  if (!target) {
+    return new Response("Missing X-SRT-Proxy-Url", { status: 400 })
+  }
+
+  let forwardHeaders = new Headers(req.headers)
+  forwardHeaders.delete("host")
+  forwardHeaders.delete("x-srt-proxy-url")
+  forwardHeaders.delete("x-srt-cache")
+  forwardHeaders.delete("content-length")
+
+  let cacheStatus: cache.Decision = "skip"
+  let cacheable = !cache.shouldConsider(req.method, req.headers).skip
+  let bypass = cacheable && cache.isBypass(req.headers)
+
+  if (cacheable && !bypass) {
+    let hit = cache.get(req.method, target)
+    if (hit) {
+      print("[cli] proxy %s %s [cache hit]", req.method, target)
+      let respHeaders = new Headers(hit.headers)
+      respHeaders.set("x-srt-cache", "hit")
+      return new Response(hit.body, { status: hit.status, headers: respHeaders })
+    }
+  }
+
+  let hasBody = req.method !== "GET" && req.method !== "HEAD"
+  if (cacheable) {
+    cacheStatus = bypass ? "bypass" : "miss"
+    print("[cli] proxy %s %s [%s]", req.method, target, cacheStatus)
+  } else {
+    print("[cli] proxy %s %s", req.method, target)
+  }
+
+  try {
+    let upstream = await fetch(target, {
+      method: req.method,
+      headers: forwardHeaders,
+      body: hasBody ? await req.arrayBuffer() : undefined,
+      redirect: "follow",
+    })
+    let respHeaders = new Headers(upstream.headers)
+    respHeaders.delete("content-encoding")
+    respHeaders.delete("transfer-encoding")
+
+    let bodyBytes = new Uint8Array(await upstream.arrayBuffer())
+    if (cacheable) {
+      cache.put(
+        req.method,
+        target,
+        upstream.status,
+        headersToObject(respHeaders),
+        bodyBytes,
+      )
+      respHeaders.set("x-srt-cache", cacheStatus)
+    }
+    return new Response(bodyBytes, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: respHeaders,
+    })
+  } catch (e) {
+    print("[cli] proxy error %s: %s", target, String(e))
+    return new Response(`Proxy error: ${String(e)}`, { status: 502 })
+  }
+}
 
 export function startServer() {
   state.server = Bun.serve({
@@ -14,12 +90,24 @@ export function startServer() {
       let url = new URL(req.url)
       let path = decodeURIComponent(url.pathname)
 
-      print("[cli] get", path)
+      if (path === "/__proxy__") {
+        return handleProxy(req)
+      }
 
       let filePath = resolve(state.sourceDir, "." + path)
       if (!filePath.startsWith(state.sourceDir)) {
         return new Response("Forbidden", { status: 403 })
       }
+
+      if (req.method === "PUT") {
+        print("[cli] put", path)
+        let bytes = new Uint8Array(await req.arrayBuffer())
+        await Bun.write(filePath, bytes)
+        return new Response(null, { status: 204 })
+      }
+
+      print("[cli] get", path)
+
       let stat
       try {
         stat = await fsStat(filePath)