@solidrt/cli 0.0.6 → 0.0.8

package/package.json

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

package/src/args.ts

@@ -19,17 +19,20 @@ export let { values, positionals } = parseArgs({
 export let command = positionals[0]
 export let source = positionals[1]
 export let isTsx = source?.endsWith(".tsx") || source?.endsWith(".jsx")
+export let isTs = source?.endsWith(".ts") || source?.endsWith(".js")
+export let isSource = isTsx || isTs
 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|jsx]     Start dev server + local solidrt-go client
-  server [file.tsx|jsx]  Start dev server only
+  run [file]             Start dev server + local solidrt-go client
+  server [file]          Start dev server only
   client                 Start solidrt-go client only
-  bundle <file.tsx|jsx>  Transpile TSX/JSX to JS or bytecode
+  bundle <file>          Transpile TS/JS/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

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

@@ -20,7 +20,7 @@ export async function bundle(entry = source) {
       target: "browser",
       format: "esm",
       minify: values.minify,
-      external: ["qjs:*"],
+      external: ["flux:*"],
       define,
       plugins: [solidPlugin()],
     })
@@ -74,7 +74,7 @@ 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.")
@@ -86,7 +86,7 @@ export async function runBuildCommand() {
     process.exit()
   }
 
-  let baseName = values.output ?? source!.replace(/\.[jt]sx$/, "")
+  let baseName = values.output ?? source!.replace(/\.[jt]sx?$/, "")
 
   if (values.stdout) {
     let result = await bundle()

package/src/main.ts

@@ -13,9 +13,10 @@
 //   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, isSource, 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,15 +26,15 @@ import { resolve, dirname } from "path"
 
 // -- Validate args --
 
-let COMMANDS = ["run", "server", "client", "bundle", "record"]
+let COMMANDS = ["run", "server", "client", "bundle", "record", "pack"]
 
 if (!command || !COMMANDS.includes(command)) {
   printUsage()
   process.exit(1)
 }
 
-if (command === "bundle" && (!source || (!isTsx && !isPrebuilt))) {
-  console.error("Usage: srt bundle [options] <entry.[tsx|jsx|srt.js|srt.bin]>")
+if (command === "bundle" && (!source || (!isSource && !isPrebuilt))) {
+  console.error("Usage: srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
   process.exit(1)
 }
 
@@ -42,6 +43,11 @@ if (command === "record" && (!source || !isTsx)) {
   process.exit(1)
 }
 
+if (command === "pack" && (!source || !isTs)) {
+  console.error("Usage: srt pack [options] <entry.[ts|js]>")
+  process.exit(1)
+}
+
 // 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 }).
@@ -51,7 +57,7 @@ if (command === "record" && (!source || !isTsx)) {
 // 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
+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)],
@@ -66,7 +72,11 @@ if (isProdBuild && process.env.NODE_ENV !== "production") {
 // -- Bundle command --
 
 if (command === "bundle") {
-  await runBuildCommand()
+  await runBundleCommand()
+}
+
+if (command === "pack") {
+  await runPackCommand()
 }
 
 // -- Record command --
@@ -110,7 +120,7 @@ startServer()
 
 // Bundle initial code if source file given (after server start so the
 // dev base URL is available to the bundler).
-if (source && isTsx) {
+if (source && isSource) {
   let initialResult = await bundle()
   if (initialResult) {
     for (let output of initialResult.outputs) {

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: ["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/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