@solidrt/cli 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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.4",
-    "@solidrt/linux-x64-gnu": "0.0.4",
-    "@solidrt/win32-x64-msvc": "0.0.4"
+    "@solidrt/darwin-arm64": "0.0.6",
+    "@solidrt/linux-x64-gnu": "0.0.6",
+    "@solidrt/win32-x64-msvc": "0.0.6"
   },
   "peerDependencies": {
-    "@solidrt/core": "0.0.4",
+    "@solidrt/core": "0.0.6",
     "typescript": "^5"
   },
   "devDependencies": {

package/src/args.ts

@@ -2,13 +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-files": { type: "boolean", default: false },
+    "proxy-http": { type: "boolean", default: false },
     fps: { type: "string" },
     duration: { type: "string" },
     size: { type: "string" },
@@ -18,33 +18,35 @@ 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 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
-      --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
+
+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

@@ -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({
@@ -18,7 +22,7 @@ export async function bundle(entry = source) {
       minify: values.minify,
       external: ["qjs:*"],
       define,
-      plugins: [solidPlugin({ devBase })],
+      plugins: [solidPlugin()],
     })
   } catch (e) {
     console.error("[cli] compile error:\n", e)
@@ -76,11 +80,13 @@ export async function runBuildCommand() {
       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/client.ts

@@ -16,7 +16,8 @@ function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteSt
 
 export function spawnClient() {
   let runner = requireBinary("solidrt-go")
-  let args = values.size ? ["--size", values.size] : []
+  let args: string[] = []
+  if (values.size) args.push("--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}`], {

package/src/main.ts

@@ -5,11 +5,11 @@
 // 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"
@@ -25,31 +25,54 @@ import { resolve, dirname } from "path"
 
 // -- Validate args --
 
-if (!command || (command !== "build" && command !== "run" && command !== "record")) {
+let COMMANDS = ["run", "server", "client", "bundle", "record"]
+
+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 --
+// 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") && !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 === "build") {
+if (command === "bundle") {
   await runBuildCommand()
 }
 
 // -- 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 +83,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,13 +95,15 @@ 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 (.srt-cache/)")
+  console.log("[cli] HTTP cache enabled")
 }
 
 startServer()
@@ -92,9 +117,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/repl.ts

@@ -1,7 +1,7 @@
 import { createInterface } from "node:readline"
 import { resolve, dirname } from "path"
 import { readdirSync } from "node:fs"
-import { state, print, printErr, broadcastStop, shutdown } from "./util"
+import { state, print, printErr, broadcastStop, buildReload, shutdown } from "./util"
 import { bundle } from "./build"
 import { startWatcher, stopWatcher } from "./watcher"
 
@@ -37,7 +37,7 @@ async function cmdReload(args: string) {
       state.currentCode = await output.text()
     }
   }
-  let msg = JSON.stringify({ type: "reload", code: state.currentCode })
+  let msg = buildReload({ code: state.currentCode })
   if (!args) {
     for (let ws of state.clients.keys()) ws.send(msg)
     print("[cli] Sent reload to all clients")
@@ -86,8 +86,8 @@ async function cmdLoad(file: string) {
     state.currentCode = await Bun.file(path).text()
   } else if (file.endsWith(".srt.bin")) {
     let bytes = await Bun.file(path).arrayBuffer()
-    let msg = { type: "reload", bytecode: Buffer.from(bytes).toString("base64") }
-    for (let ws of state.clients.keys()) ws.send(JSON.stringify(msg))
+    let msg = buildReload({ bytecode: Buffer.from(bytes).toString("base64") })
+    for (let ws of state.clients.keys()) ws.send(msg)
     print(`[cli] Loaded ${file} (bytecode, ${bytes.byteLength} bytes)`)
     return
   } else {
@@ -97,8 +97,9 @@ async function cmdLoad(file: string) {
   state.source = path
   state.sourceDir = dirname(path)
   startWatcher()
+  let reloadMsg = buildReload({ code: state.currentCode })
   for (let ws of state.clients.keys()) {
-    ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+    ws.send(reloadMsg)
   }
   print(`[cli] Loaded ${file}`)
 }

package/src/server.ts

@@ -3,7 +3,7 @@ import { stat as fsStat, readdir } from "node:fs/promises"
 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 { DEV_HOST, DEV_PORT, state, print, buildReload } from "./util"
 import * as cache from "./cache"
 
 function headersToObject(h: Headers): Record<string, string> {
@@ -142,7 +142,7 @@ export function startServer() {
         state.clients.set(ws, { platform: "unknown", version: "unknown" })
         print(`[cli] Client connected ${ws.remoteAddress}`)
         if (state.currentCode) {
-          ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+          ws.send(buildReload({ code: state.currentCode }))
         }
       },
       close(ws) {

package/src/util.ts

@@ -1,4 +1,5 @@
 import { resolveBinary } from "./native"
+import { values } from "./args"
 import type { Interface as ReadlineInterface } from "node:readline"
 import type { Server as BunServer } from "bun"
 
@@ -41,6 +42,10 @@ export function printErr(...args: any[]) {
   state.rl?.prompt(true)
 }
 
+export function buildReload(payload: { code?: string | null; bytecode?: string }) {
+  return JSON.stringify({ type: "reload", proxyFiles: values["proxy-files"], proxyHttp: values["proxy-http"], ...payload })
+}
+
 export function broadcastStop() {
   for (let ws of state.clients.keys()) {
     ws.send(JSON.stringify({ type: "stop" }))

package/src/watcher.ts

@@ -1,6 +1,6 @@
 import { watch } from "node:fs"
 import { resolve, dirname } from "path"
-import { state, print, printErr } from "./util"
+import { state, print, printErr, buildReload } from "./util"
 import { bundle } from "./build"
 
 let currentWatcher: ReturnType<typeof watch> | null = null
@@ -32,8 +32,9 @@ export function startWatcher() {
     for (let output of result.outputs) {
       state.currentCode = await output.text()
     }
+    let msg = buildReload({ code: state.currentCode })
     for (let ws of state.clients.keys()) {
-      ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+      ws.send(msg)
     }
   })
 }