@solidrt/cli 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "license": "MIT",
   "author": "Antoine van Wel",
   "type": "module",
@@ -15,16 +15,16 @@
   "dependencies": {
     "@babel/core": "^7.28.5",
     "@babel/preset-typescript": "^7.28.5",
-    "babel-preset-solid": "2.0.0-beta.13",
+    "babel-preset-solid": "2.0.0-beta.14",
     "qrcode-generator": "^2.0.4"
   },
   "optionalDependencies": {
-    "@solidrt/darwin-arm64": "0.0.5",
-    "@solidrt/linux-x64-gnu": "0.0.5",
-    "@solidrt/win32-x64-msvc": "0.0.5"
+    "@solidrt/darwin-arm64": "0.0.7",
+    "@solidrt/linux-x64-gnu": "0.0.7",
+    "@solidrt/win32-x64-msvc": "0.0.7"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.5",
+    "@solidrt/core": "0.0.7",
     "typescript": "^5"
   },
   "devDependencies": {

package/src/args.ts

@@ -2,14 +2,13 @@ import { parseArgs } from "node:util"
 
 export let { values, positionals } = parseArgs({
   options: {
+    dev: { type: "boolean", short: "d", default: false },
     minify: { type: "boolean", short: "m", default: false },
     compile: { type: "boolean", short: "c", default: false },
     stdout: { type: "boolean", default: false },
     output: { type: "string", short: "o" },
-    client: { type: "boolean", default: false },
-    server: { type: "boolean", default: false },
-    cache: { type: "boolean", default: false },
-    proxy: { type: "boolean", default: false },
+    "proxy-files": { type: "boolean", default: false },
+    "proxy-http": { type: "boolean", default: false },
     fps: { type: "string" },
     duration: { type: "string" },
     size: { type: "string" },
@@ -19,34 +18,37 @@ export let { values, positionals } = parseArgs({
 
 export let command = positionals[0]
 export let source = positionals[1]
-export let isTsx = source?.endsWith(".tsx")
+export let isTsx = source?.endsWith(".tsx") || source?.endsWith(".jsx")
+export let isTs = source?.endsWith(".ts") || source?.endsWith(".js")
 export let isPrebuilt = source?.endsWith(".srt.js") || source?.endsWith(".srt.bin")
 
 export function printUsage() {
   console.error(`Usage: srt <command> [options] [file]
 
 Commands:
-  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
-
-run options:
-      --client              Run client only
-      --server              Run server only
-      --cache               Enable HTTP cache
-      --proxy               Tell connected clients to route file/dir/fetch through the dev server
-      --size <WxH>          Window size (default: 1280x720)
-
-build options:
-  -m, --minify          Minify the output
-  -c, --compile         Compile to bytecode
-  -o, --output <name>   Output filename
-      --stdout          Write bundle to stdout
+  run [file.tsx|jsx]     Start dev server + local solidrt-go client
+  server [file.tsx|jsx]  Start dev server only
+  client                 Start solidrt-go client only
+  bundle <file.tsx|jsx>  Transpile TSX/JSX to JS or bytecode
+  record <file.tsx|jsx>  Capture frames for video generation
+  pack <file.ts|js>      Bundle + compile to a standalone executable (experimental, Flux only)
+
+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)
+
+run/client options:
+      --size <WxH>       Window size (default: 1280x720)
+
+bundle options:
+  -d, --dev              Use development build of SolidJS (default: production)
+  -m, --minify           Minify the output
+  -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)`)
-}
+      --fps <N>          Frames per second (default: 60)
+      --duration <N>     Duration in seconds (default: 1)
+      --size <WxH>       Frame size (default: 1280x720)`)
+}

package/src/{build.ts → bundle.ts}

@@ -1,14 +1,18 @@
 import { solidPlugin } from "./bun-plugin-solid"
 import { values, source, isPrebuilt } from "./args"
-import { requireBinary, state } from "./util"
+import { requireBinary, state, print } from "./util"
 import { resolve } from "path"
 
 export async function bundle(entry = source) {
   let result = null
 
   let devBase = state.serverUrl ?? undefined
-  let define: Record<string, string> = { "process.env.NODE_ENV": "production" }
-  if (devBase) define.__SRT_DEV_BASE__ = JSON.stringify(devBase)
+  let dev = !!devBase || values.dev
+  print(`[cli] Bundling (${dev ? "development" : "production"})`)
+  let define: Record<string, string> = {
+    "process.env.NODE_ENV": dev ? "development" : "production",
+  }
+  if (devBase) define.__SRT_DEV_BASE__ = devBase
 
   try {
     result = await Bun.build({
@@ -16,9 +20,9 @@ export async function bundle(entry = source) {
       target: "browser",
       format: "esm",
       minify: values.minify,
-      external: ["qjs:*"],
+      external: ["qjs:*", "flux:*"],
       define,
-      plugins: [solidPlugin({ devBase })],
+      plugins: [solidPlugin()],
     })
   } catch (e) {
     console.error("[cli] compile error:\n", e)
@@ -70,17 +74,19 @@ async function compileFromStdin(jsCode: string, outfile: string) {
   return compileJs(jsCode, outfile)
 }
 
-export async function runBuildCommand() {
+export async function runBundleCommand() {
   if (isPrebuilt) {
     if (!source!.endsWith(".srt.js")) {
       console.error("Can only compile .srt.js files. .srt.bin is already compiled.")
       process.exit(1)
     }
-    await compileToBytecode(resolve(source!))
+    let binOut = await compileToBytecode(resolve(source!))
+    let binSize = (await Bun.file(binOut).stat()).size
+    console.log(`>> wrote ${binSize} bytes to ${binOut}`)
     process.exit()
   }
 
-  let baseName = values.output ?? source!.replace(/\.tsx$/, "")
+  let baseName = values.output ?? source!.replace(/\.[jt]sx$/, "")
 
   if (values.stdout) {
     let result = await bundle()
@@ -106,6 +112,8 @@ export async function runBuildCommand() {
     }
     let binOutfile = baseName + ".srt.bin"
     await compileFromStdin(jsCode, binOutfile)
+    let binSize = (await Bun.file(binOutfile).stat()).size
+    console.log(`>> wrote ${binSize} bytes to ${binOutfile}`)
     process.exit()
   }
 
@@ -115,4 +123,4 @@ export async function runBuildCommand() {
     console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
   }
   process.exit()
-}
+}

package/src/cache.ts

@@ -1,19 +1,17 @@
 // 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.
+// Project-local: stored at <cwd>/.srt-cache.db. Opt-in via the --cache
+// flag. Entries live forever; delete .srt-cache.db 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 { resolve } from "path"
 import { createHash } from "node:crypto"
 
-const CACHE_DIR = ".srt-cache"
-const CACHE_DB = "cache.db"
+const CACHE_FILE = ".srt-cache.db"
 
 export type Decision = "hit" | "miss" | "bypass" | "skip"
 
@@ -30,8 +28,7 @@ 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 })
+  let d = new Database(resolve(opts.dir, CACHE_FILE), { create: true })
   d.run(`CREATE TABLE IF NOT EXISTS entries (
     key         TEXT PRIMARY KEY,
     method      TEXT NOT NULL,

package/src/main.ts

@@ -5,17 +5,18 @@
 // Usage:
 //   srt run                             - start dev server + client
 //   srt run examples/hello.tsx          - start dev server + client, bundle + push via WS
-//   srt run --client                    - start dev client only (connects to WS server)
-//   srt run --server examples/hello.tsx - start dev server only, no client
-//   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 server examples/hello.tsx       - start dev server only, no client
+//   srt client                          - start dev client only (connects to WS server)
+//   srt bundle examples/hello.tsx       - bundle TSX to .srt.js
+//   srt bundle -c examples/hello.tsx    - bundle TSX to .srt.js + compile to .srt.bin
+//   srt bundle 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 { values, command, source, isTsx, isTs, isPrebuilt, printUsage } from "./args"
 import { state, requireBinary, run, shutdown } from "./util"
-import { bundle, bundleTo, runBuildCommand } from "./build"
+import { bundle, bundleTo, runBundleCommand } from "./bundle"
+import { runPackCommand } from "./pack"
 import { startServer } from "./server"
 import { spawnClient } from "./client"
 import { startRepl } from "./repl"
@@ -25,31 +26,63 @@ import { resolve, dirname } from "path"
 
 // -- Validate args --
 
-if (!command || (command !== "build" && command !== "run" && command !== "record")) {
+let COMMANDS = ["run", "server", "client", "bundle", "record", "pack"]
+
+if (!command || !COMMANDS.includes(command)) {
   printUsage()
   process.exit(1)
 }
 
-if (command === "build" && (!source || (!isTsx && !isPrebuilt))) {
-  console.error("Usage: srt build [options] <entry.tsx|.srt.js|.srt.bin>")
+if (command === "bundle" && (!source || (!isTsx && !isPrebuilt))) {
+  console.error("Usage: srt bundle [options] <entry.[tsx|jsx|srt.js|srt.bin]>")
   process.exit(1)
 }
 
 if (command === "record" && (!source || !isTsx)) {
-  console.error("Usage: srt record <entry.tsx>")
+  console.error("Usage: srt record <entry.[tsx|jsx]>")
   process.exit(1)
 }
 
-// -- Build command --
+if (command === "pack" && (!source || !isTs)) {
+  console.error("Usage: srt pack [options] <entry.[ts|js]>")
+  process.exit(1)
+}
 
-if (command === "build") {
-  await runBuildCommand()
+// Force the production export condition for prod bundles. Bun auto-activates the
+// "development" condition whenever NODE_ENV != "production" (read once at startup),
+// and an auto-active condition cannot be turned off via Bun.build({ conditions }).
+// Our deps (@solidjs/signals, solid-js) only expose a "development" branch + a
+// default fallback - no "production" key - so adding conditions does nothing; the
+// only way to reach the default (smaller, no extra invariants) build is to stop
+// 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
+if (isProdBuild && process.env.NODE_ENV !== "production") {
+  let proc = Bun.spawnSync({
+    cmd: [process.execPath, ...process.argv.slice(1)],
+    env: { ...process.env, NODE_ENV: "production" },
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  })
+  process.exit(proc.exitCode ?? 0)
+}
+
+// -- Bundle command --
+
+if (command === "bundle") {
+  await runBundleCommand()
+}
+
+if (command === "pack") {
+  await runPackCommand()
 }
 
 // -- Record command --
 
 if (command === "record") {
-  let jsOutfile = source!.replace(/\.tsx$/, "") + ".srt.js"
+  let jsOutfile = source!.replace(/\.[jt]sx$/, "") + ".srt.js"
   await bundleTo(jsOutfile)
   let runner = requireBinary("solidrt-go")
   let recordArgs = ["--record", resolve(jsOutfile)]
@@ -60,9 +93,9 @@ if (command === "record") {
   process.exit(exit)
 }
 
-// -- Run command --
+// -- Client command --
 
-if (values.client) {
+if (command === "client") {
   let runner = requireBinary("solidrt-go")
   let args: string[] = []
   if (values.size) args.push("--size", values.size)
@@ -72,11 +105,13 @@ if (values.client) {
   process.exit(exit)
 }
 
+// -- Server / Run command --
+
 // Initialize state from args
 state.source = source
 state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
 
-if (values.cache) {
+if (values["proxy-http"]) {
   cache.initCache({ dir: process.cwd() })
   console.log("[cli] HTTP cache enabled")
 }
@@ -92,9 +127,11 @@ if (source && isTsx) {
       state.currentCode = await output.text()
     }
   }
+} else if (source && isPrebuilt && source.endsWith(".srt.js")) {
+  state.currentCode = await Bun.file(resolve(source)).text()
 }
 
-if (!values.server) {
+if (command === "run") {
   spawnClient()
 }
 

package/src/pack.ts

@@ -0,0 +1,58 @@
+import { values, source } from "./args"
+import { requireBinary } from "./util"
+
+const MAGIC = Buffer.from([0x46, 0x4c, 0x55, 0x58, 0x52, 0x54, 0x00, 0x01]) // "FLUXRT\x00\x01"
+
+async function bundleFlux(entry: string): Promise<string> {
+  let result = await Bun.build({
+    entrypoints: [entry],
+    target: "browser",
+    format: "esm",
+    minify: values.minify,
+    external: ["qjs:*", "flux:*"],
+  })
+  if (!result.success) {
+    for (let msg of result.logs) console.error(msg)
+    console.error("Build failed")
+    process.exit(1)
+  }
+  let jsCode = ""
+  for (let output of result.outputs) jsCode += await output.text()
+  return jsCode
+}
+
+async function compileToBytecode(jsCode: string): Promise<Buffer> {
+  let compiler = requireBinary("fluxc")
+  let proc = Bun.spawn([compiler], {
+    stdin: new Blob([jsCode]),
+    stdout: "pipe",
+    stderr: "inherit",
+  })
+  let [bytecode, code] = await Promise.all([new Response(proc.stdout).arrayBuffer(), proc.exited])
+  if (code !== 0) process.exit(code)
+  return Buffer.from(bytecode)
+}
+
+export async function runPackCommand() {
+  let outfile = values.output ?? source!.replace(/\.[jt]s$/, "")
+
+  let jsCode = await bundleFlux(source!)
+
+  let bytecode = await compileToBytecode(jsCode)
+
+  let runner = requireBinary("fluxrt")
+  let runnerBytes = Buffer.from(await Bun.file(runner).arrayBuffer())
+
+  let offsetBuf = Buffer.allocUnsafe(8)
+  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
+
+  let packed = Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC])
+  await Bun.write(outfile, packed)
+
+  if (process.platform !== "win32") {
+    Bun.spawnSync(["chmod", "+x", outfile])
+  }
+
+  console.log(`>> wrote ${packed.length} bytes to ${outfile}`)
+  process.exit()
+}

package/src/repl.ts

@@ -2,7 +2,7 @@ import { createInterface } from "node:readline"
 import { resolve, dirname } from "path"
 import { readdirSync } from "node:fs"
 import { state, print, printErr, broadcastStop, buildReload, shutdown } from "./util"
-import { bundle } from "./build"
+import { bundle } from "./bundle"
 import { startWatcher, stopWatcher } from "./watcher"
 
 function cmdStop(args: string) {

package/src/util.ts

@@ -43,7 +43,7 @@ export function printErr(...args: any[]) {
 }
 
 export function buildReload(payload: { code?: string | null; bytecode?: string }) {
-  return JSON.stringify({ type: "reload", proxy: values.proxy, ...payload })
+  return JSON.stringify({ type: "reload", proxyFiles: values["proxy-files"], proxyHttp: values["proxy-http"], ...payload })
 }
 
 export function broadcastStop() {

package/src/watcher.ts

@@ -1,7 +1,7 @@
 import { watch } from "node:fs"
 import { resolve, dirname } from "path"
 import { state, print, printErr, buildReload } from "./util"
-import { bundle } from "./build"
+import { bundle } from "./bundle"
 
 let currentWatcher: ReturnType<typeof watch> | null = null