@solidrt/cli 0.0.8 → 0.0.9

package/package.json

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

package/src/args.ts

@@ -5,6 +5,7 @@ export let { values, positionals } = parseArgs({
     dev: { type: "boolean", short: "d", default: false },
     minify: { type: "boolean", short: "m", default: false },
     compile: { type: "boolean", short: "c", default: false },
+    flux: { type: "boolean", default: false },
     stdout: { type: "boolean", default: false },
     output: { type: "string", short: "o" },
     "proxy-files": { type: "boolean", default: false },
@@ -12,6 +13,8 @@ export let { values, positionals } = parseArgs({
     fps: { type: "string" },
     duration: { type: "string" },
     size: { type: "string" },
+    android: { type: "boolean", default: false },
+    device: { type: "string" },
   },
   allowPositionals: true,
 })
@@ -23,6 +26,37 @@ 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")
 
+function usage(line: string): never {
+  console.error("Usage: " + line)
+  process.exit(1)
+}
+
+// Per-command argument requirements. Called once before dispatch.
+export function validateArgs() {
+  switch (command) {
+    case "bundle":
+      if (!source || (!isSource && !isPrebuilt))
+        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]>")
+      break
+    case "pack":
+      if (values.flux) {
+        if (!source || !isTs) usage("srt pack --flux [options] <entry.[ts|js]>")
+      } else if (!source || !isSource) {
+        usage("srt pack [options] <entry.[tsx|jsx|ts|js]>")
+      }
+      break
+  }
+
+  // --android installs/launches the client on a device; it is a client action,
+  // so it is only valid for `client`.
+  if (values.android && command !== "client") {
+    usage("srt client --android  (--android is only valid with the client command)")
+  }
+}
+
 export function printUsage() {
   console.error(`Usage: srt <command> [options] [file]
 
@@ -32,7 +66,7 @@ Commands:
   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
-  pack <file.ts|js>      Bundle + compile to a standalone executable (experimental, Flux only)
+  pack <file>            Bundle + compile to a standalone executable (experimental)
 
 run/server options:
       --proxy-files      Route file/dir access through the dev server
@@ -41,6 +75,10 @@ run/server options:
 run/client options:
       --size <WxH>       Window size (default: 1280x720)
 
+client options:
+      --android          Install and launch the client on a connected Android device
+      --device <serial>  Target a specific adb device (when several are connected)
+
 bundle options:
   -d, --dev              Use development build of SolidJS (default: production)
   -m, --minify           Minify the output
@@ -48,6 +86,11 @@ bundle options:
   -o, --output <name>    Output filename
       --stdout           Write bundle to stdout
 
+pack options:
+      --flux             Pack for the bare Flux runtime instead of SolidRT (entry must be .ts|.js)
+  -m, --minify           Minify the output
+  -o, --output <name>    Output filename
+
 record options:
       --fps <N>          Frames per second (default: 60)
       --duration <N>     Duration in seconds (default: 1)

package/src/{native.ts → artifacts.ts}

@@ -41,5 +41,30 @@ export function resolveBinary(name: string) {
     } catch {}
   }
 
+  return null
+}
+
+// The Android client APK is per-ABI (it bundles native .so for one architecture)
+// and host-independent, so it lives under dist/android/<abi>/ rather than the
+// host triple map. Only arm64-v8a is supported for now.
+let ANDROID_ABI = "arm64-v8a"
+let ANDROID_PKG = "@solidrt/android-arm64-v8a"
+
+export function resolveApk() {
+  // 1. SRT_HOME: contributor checkout, where `make dist-android` stages the APK
+  //    under dist/android/<abi>/.
+  let srtRoot = process.env.SRT_HOME
+  if (srtRoot) {
+    let apk = resolve(srtRoot, "dist/android", ANDROID_ABI, "solidrt-go.apk")
+    if (existsSync(apk)) return apk
+  }
+
+  // 2. Platform npm package
+  try {
+    let pkgDir = dirname(require.resolve(`${ANDROID_PKG}/package.json`))
+    let apk = resolve(pkgDir, "solidrt-go.apk")
+    if (existsSync(apk)) return apk
+  } catch {}
+
   return null
 }

package/src/bundler.ts

@@ -0,0 +1,117 @@
+import { transformAsync } from "@babel/core"
+import ts from "@babel/preset-typescript"
+import solid from "babel-preset-solid"
+import { type BunPlugin } from "bun"
+import { values, source } from "./args"
+import { state, print, requireBinary } from "./util"
+
+// Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
+// generate, targeting @solidrt/core) plus the TS preset.
+function solidPlugin(): BunPlugin {
+  return {
+    name: "bun-plugin-solid",
+    setup: (build) => {
+      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
+        let file = Bun.file(args.path)
+        let code = await file.text()
+        let transforms = await transformAsync(code, {
+          filename: args.path,
+          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
+        })
+        return { contents: transforms?.code ?? "", loader: "js" }
+      })
+    },
+  }
+}
+
+export async function bundle(entry = source) {
+  let result = null
+
+  let devBase = state.serverUrl ?? undefined
+  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({
+      entrypoints: [entry!],
+      target: "browser",
+      format: "esm",
+      minify: values.minify,
+      external: ["flux:*"],
+      define,
+      plugins: [solidPlugin()],
+    })
+  } catch (e) {
+    console.error("[cli] compile error:\n", e)
+    return null
+  }
+
+  if (result?.success) {
+    return result
+  }
+
+  if (result) {
+    for (let msg of result?.logs) console.error(msg)
+  }
+  return null
+}
+
+export async function bundleTo(outfile: string) {
+  let result = await bundle()
+  if (!result) {
+    console.error("Build failed")
+    process.exit(1)
+  }
+  for (let output of result.outputs) {
+    await Bun.write(outfile, output)
+  }
+  return result
+}
+
+// Bundle for the bare Flux runtime: no Solid plugin, flux: modules stay external.
+export 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
+}
+
+// Bundle for the SolidRT runtime via the standard Solid-aware bundler.
+export async function bundleSolid(): Promise<string> {
+  let result = await bundle()
+  if (!result) {
+    console.error("Build failed")
+    process.exit(1)
+  }
+  let jsCode = ""
+  for (let output of result.outputs) jsCode += await output.text()
+  return jsCode
+}
+
+// Compile JS source to QuickJS bytecode via the fluxc binary.
+export 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)
+}

package/src/commands/bundle.ts

@@ -0,0 +1,59 @@
+import { values, source, isPrebuilt } from "../args"
+import { bundle, bundleTo, compileToBytecode } from "../bundler"
+import { resolve } from "path"
+
+// Compile JS to a .srt.bin file and report its size.
+async function writeBytecode(jsCode: string, outfile: string) {
+  let bytecode = await compileToBytecode(jsCode)
+  await Bun.write(outfile, bytecode)
+  let binSize = (await Bun.file(outfile).stat()).size
+  console.log(`>> wrote ${binSize} bytes to ${outfile}`)
+}
+
+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)
+    }
+    let jsFile = resolve(source!)
+    let binOut = jsFile.replace(/\.srt\.js$/, ".srt.bin").replace(/\.js$/, ".bin")
+    await writeBytecode(await Bun.file(jsFile).text(), binOut)
+    process.exit()
+  }
+
+  let baseName = values.output ?? source!.replace(/\.[jt]sx?$/, "")
+
+  if (values.stdout) {
+    let result = await bundle()
+    if (!result) {
+      console.error("Build failed")
+      process.exit(1)
+    }
+    for (let output of result.outputs) {
+      process.stdout.write(await output.text())
+    }
+    process.exit()
+  }
+
+  if (values.compile) {
+    let result = await bundle()
+    if (!result) {
+      console.error("Build failed")
+      process.exit(1)
+    }
+    let jsCode = ""
+    for (let output of result.outputs) {
+      jsCode += await output.text()
+    }
+    await writeBytecode(jsCode, baseName + ".srt.bin")
+    process.exit()
+  }
+
+  let jsOutfile = baseName + ".srt.js"
+  let result = await bundleTo(jsOutfile)
+  for (let output of result.outputs) {
+    console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
+  }
+  process.exit()
+}

package/src/commands/client.ts

@@ -0,0 +1,22 @@
+import { values } from "../args"
+import { requireBinary, run } from "../util"
+import { spawnAndroidClient } from "../dev-android"
+
+// Standalone solidrt-go client (no dev server). The `run` command instead uses
+// spawnClient() to launch a client tied to the dev-server lifecycle. Either way
+// the client discovers a dev server over the LAN; with --android it is installed
+// and launched on a connected Android device instead of run locally.
+export async function runClientCommand() {
+  if (values.android) {
+    await spawnAndroidClient()
+    return
+  }
+
+  let runner = requireBinary("solidrt-go")
+  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)
+  process.exit(exit)
+}

package/src/commands/pack.ts

@@ -0,0 +1,25 @@
+import { values, source } from "../args"
+import { bundleFlux, bundleSolid } from "../bundler"
+import { packRunner } from "../packer"
+
+// Write the packed executable, mark it runnable, and report its size.
+async function writeExecutable(packed: Buffer, outfile: string) {
+  await Bun.write(outfile, packed)
+  if (process.platform !== "win32") {
+    Bun.spawnSync(["chmod", "+x", outfile])
+  }
+  console.log(`>> wrote ${packed.length} bytes to ${outfile}`)
+}
+
+export async function runPackCommand() {
+  let outfile = values.output ?? source!.replace(/\.[jt]sx?$/, "")
+  // On Windows the packed image is a PE executable; it needs a .exe name to run.
+  if (process.platform === "win32" && !outfile.toLowerCase().endsWith(".exe")) {
+    outfile += ".exe"
+  }
+  let packed = values.flux
+    ? await packRunner("fluxrt", await bundleFlux(source!))
+    : await packRunner("solidrt", await bundleSolid())
+  await writeExecutable(packed, outfile)
+  process.exit()
+}

package/src/commands/record.ts

@@ -0,0 +1,16 @@
+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)
+}

package/src/commands/server.ts

@@ -0,0 +1,45 @@
+import pkg from "../../package.json"
+import { source, isSource, isPrebuilt, values } from "../args"
+import { state, shutdown } from "../util"
+import { bundle } from "../bundler"
+import { startServer } from "../dev-server"
+import { startRepl } from "../repl"
+import { startWatcher } from "../watcher"
+import * as cache from "../cache"
+import { resolve, dirname } from "path"
+
+// 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.
+export async function runServerCommand() {
+  // Initialize state from args
+  state.source = source
+  state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
+
+  if (values["proxy-http"]) {
+    cache.initCache({ dir: process.cwd() })
+    console.log("[cli] HTTP cache enabled")
+  }
+
+  startServer()
+
+  // Bundle initial code if source file given (after server start so the
+  // dev base URL is available to the bundler).
+  if (source && isSource) {
+    let initialResult = await bundle()
+    if (initialResult) {
+      for (let output of initialResult.outputs) {
+        state.currentCode = await output.text()
+      }
+    }
+  } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
+    state.currentCode = await Bun.file(resolve(source)).text()
+  }
+
+  process.on("SIGINT", shutdown)
+  process.on("SIGTERM", shutdown)
+
+  let version = pkg.version === "0.0.0" ? "" : " version " + pkg.version
+  console.log(`[cli] Welcome to SolidRT${version}!`)
+  startRepl()
+  startWatcher()
+}

package/src/dev-android.ts

@@ -0,0 +1,69 @@
+import { print, requireAdb } from "./util"
+import { resolveApk } from "./artifacts"
+import { values } from "./args"
+
+// Launch component of the "go" dev-client flavor (see lattice/Makefile.x-android).
+let PACKAGE_ACTIVITY = "com.solidrt.go/com.solidrt.app.MainActivity"
+
+// Prefix adb args with `-s <serial>` only when the user pinned a device; with a
+// single connected device adb selects it on its own.
+function adbArgs(extra: string[]) {
+  return values.device ? ["-s", values.device, ...extra] : extra
+}
+
+// Install + launch the Android client on a connected device over adb, then let
+// the device discover the running dev server over LAN UDP (the same path as a
+// manually launched client). Fire-and-forget: the client's lifecycle is tracked
+// via WS connect/disconnect in dev-server.ts, not as a child process here.
+export async function spawnAndroidClient() {
+  let adb = requireAdb()
+
+  let apk = resolveApk()
+  if (!apk) {
+    console.error("Could not find the SolidRT-Go APK.")
+    console.error("Add it with: bun add -d @solidrt/android-arm64-v8a")
+    process.exit(1)
+  }
+
+  // Resolve the target device: 0 -> error, 1 -> use it, many -> require --device.
+  let target = values.device
+  if (!target) {
+    let listed = Bun.spawnSync([adb, "devices"], { stdout: "pipe", stderr: "pipe" })
+    let devices = listed.stdout
+      .toString()
+      .split("\n")
+      .slice(1)
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .filter((l) => l.endsWith("\tdevice"))
+      .map((l) => l.split("\t")[0])
+
+    if (devices.length === 0) {
+      console.error("No authorized Android device found. Enable USB debugging and check `adb devices`.")
+      process.exit(1)
+    }
+    if (devices.length > 1) {
+      console.error(`Multiple devices connected (${devices.join(", ")}); pick one with --device <serial>.`)
+      process.exit(1)
+    }
+    target = devices[0]
+  }
+
+  print(`[cli] Installing SolidRT-Go on ${target}`)
+  let install = Bun.spawn([adb, ...adbArgs(["install", "-r", apk])], { stdout: "pipe", stderr: "pipe" })
+  if ((await install.exited) !== 0) {
+    console.error("adb install failed:\n" + (await new Response(install.stderr).text()))
+    process.exit(1)
+  }
+
+  let start = Bun.spawn([adb, ...adbArgs(["shell", "am", "start", "-n", PACKAGE_ACTIVITY])], {
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  if ((await start.exited) !== 0) {
+    console.error("adb start failed:\n" + (await new Response(start.stderr).text()))
+    process.exit(1)
+  }
+
+  print(`[cli] Launched SolidRT-Go on ${target}; waiting for it to discover the dev server...`)
+}

package/src/{client.ts → dev-client.ts}

@@ -1,4 +1,5 @@
-import { DEV_HOST, DEV_PORT, state, print, requireBinary } from "./util"
+import { state, print, requireBinary } from "./util"
+import { DEV_HOST, DEV_PORT } from "./dev-server"
 import { values } from "./args"
 
 function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteStream) {

package/src/{server.ts → dev-server.ts}

@@ -3,9 +3,24 @@ 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, buildReload } from "./util"
+import { state, print } from "./util"
+import { values } from "./args"
 import * as cache from "./cache"
 
+export const DEV_HOST = "127.0.0.1"
+export const DEV_PORT = 15194
+
+// Dev-server WS protocol helpers: the reload message shape and the stop broadcast.
+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" }))
+  }
+}
+
 function headersToObject(h: Headers): Record<string, string> {
   let out: Record<string, string> = {}
   h.forEach((v, k) => {

package/src/main.ts

@@ -1,52 +1,16 @@
 #!/usr/bin/env bun
 
-// Build/run script that bundles/runs a Solid-RT app for the QuickJS runtime.
-//
-// Usage:
-//   srt run                             - start dev server + client
-//   srt run examples/hello.tsx          - start dev server + client, bundle + push via WS
-//   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, isTs, isSource, isPrebuilt, printUsage } from "./args"
-import { state, requireBinary, run, shutdown } from "./util"
-import { bundle, bundleTo, runBundleCommand } from "./bundle"
-import { runPackCommand } from "./pack"
-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"
+import { values, command, validateArgs, printUsage } from "./args"
+import { runBundleCommand } from "./commands/bundle"
+import { runPackCommand } from "./commands/pack"
+import { runRecordCommand } from "./commands/record"
+import { runServerCommand } from "./commands/server"
+import { runClientCommand } from "./commands/client"
+import { spawnClient } from "./dev-client"
 
 // -- Validate args --
 
-let COMMANDS = ["run", "server", "client", "bundle", "record", "pack"]
-
-if (!command || !COMMANDS.includes(command)) {
-  printUsage()
-  process.exit(1)
-}
-
-if (command === "bundle" && (!source || (!isSource && !isPrebuilt))) {
-  console.error("Usage: srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
-  process.exit(1)
-}
-
-if (command === "record" && (!source || !isTsx)) {
-  console.error("Usage: srt record <entry.[tsx|jsx]>")
-  process.exit(1)
-}
-
-if (command === "pack" && (!source || !isTs)) {
-  console.error("Usage: srt pack [options] <entry.[ts|js]>")
-  process.exit(1)
-}
+validateArgs()
 
 // Force the production export condition for prod bundles. Bun auto-activates the
 // "development" condition whenever NODE_ENV != "production" (read once at startup),
@@ -69,76 +33,22 @@ if (isProdBuild && process.env.NODE_ENV !== "production") {
   process.exit(proc.exitCode ?? 0)
 }
 
-// -- Bundle command --
+// -- Dispatch --
 
 if (command === "bundle") {
   await runBundleCommand()
-}
-
-if (command === "pack") {
+} else if (command === "pack") {
   await runPackCommand()
-}
-
-// -- Record command --
-
-if (command === "record") {
-  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)
-}
-
-// -- Client command --
-
-if (command === "client") {
-  let runner = requireBinary("solidrt-go")
-  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)
-  process.exit(exit)
-}
-
-// -- Server / Run command --
-
-// Initialize state from args
-state.source = source
-state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
-
-if (values["proxy-http"]) {
-  cache.initCache({ dir: process.cwd() })
-  console.log("[cli] HTTP cache enabled")
-}
-
-startServer()
-
-// Bundle initial code if source file given (after server start so the
-// dev base URL is available to the bundler).
-if (source && isSource) {
-  let initialResult = await bundle()
-  if (initialResult) {
-    for (let output of initialResult.outputs) {
-      state.currentCode = await output.text()
-    }
-  }
-} else if (source && isPrebuilt && source.endsWith(".srt.js")) {
-  state.currentCode = await Bun.file(resolve(source)).text()
-}
-
-if (command === "run") {
+} else if (command === "record") {
+  await runRecordCommand()
+} else if (command === "client") {
+  await runClientCommand()
+} else if (command === "server") {
+  await runServerCommand()
+} else if (command === "run") {
+  await runServerCommand()
   spawnClient()
-}
-
-process.on("SIGINT", shutdown)
-process.on("SIGTERM", shutdown)
-
-let version = pkg.version === "0.0.0" ? "" : " version " + pkg.version
-console.log(`[cli] Welcome to SolidRT${version}!`)
-startRepl()
-startWatcher()
+} else {
+  printUsage()
+  process.exit(1)
+}

package/src/packer.ts

@@ -0,0 +1,27 @@
+import { requireBinary } from "./util"
+import { compileToBytecode } from "./bundler"
+
+// Trailer magic identifying the runner an embedded payload belongs to. Must match
+// the runner-side checks: fluxrt -> flux/src/bin/fluxrt.rs, solidrt ->
+// lattice/src/main.rs (load_embedded_bytecode).
+const MAGIC = {
+  fluxrt: Buffer.from([0x46, 0x4c, 0x55, 0x58, 0x52, 0x54, 0x88, 0x44]), // "FLUXRT\x88\x44"
+  solidrt: Buffer.from([0x53, 0x4f, 0x4c, 0x49, 0x44, 0x52, 0x54, 0x88, 0x44]), // "SOLIDRT\x88\x44"
+}
+
+export type Runner = keyof typeof MAGIC
+
+// Compile JS to bytecode and append it to the runner binary, followed by a
+// trailer of [u64 offset LE][8-byte magic]. The runner reads its own image at
+// startup, validates the magic, and slices the bytecode back out.
+export async function packRunner(runner: Runner, jsCode: string): Promise<Buffer> {
+  let bytecode = await compileToBytecode(jsCode)
+
+  let runnerPath = requireBinary(runner)
+  let runnerBytes = Buffer.from(await Bun.file(runnerPath).arrayBuffer())
+
+  let offsetBuf = Buffer.allocUnsafe(8)
+  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
+
+  return Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC[runner]])
+}

package/src/repl.ts

@@ -1,8 +1,9 @@
 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 "./bundle"
+import { state, print, printErr, shutdown } from "./util"
+import { buildReload, broadcastStop } from "./dev-server"
+import { bundle } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
 function cmdStop(args: string) {

package/src/util.ts

@@ -1,11 +1,9 @@
-import { resolveBinary } from "./native"
-import { values } from "./args"
+import { resolveBinary } from "./artifacts"
+import { existsSync } from "node:fs"
+import { resolve } from "node:path"
 import type { Interface as ReadlineInterface } from "node:readline"
 import type { Server as BunServer } from "bun"
 
-export const DEV_HOST = "127.0.0.1"
-export const DEV_PORT = 15194
-
 export let state = {
   clients: new Map<any, { platform: string; version: string }>(),
   currentCode: null as string | null,
@@ -17,11 +15,50 @@ export let state = {
   rl: null as ReadlineInterface | null,
 }
 
+// Build target per binary, for the "not found" hint. Run from the repo root.
+let BUILD_HINTS: Record<string, string> = {
+  "solidrt-go": "make solidrt-go",
+  solidrt: "make runtime",
+  flux: "make -C flux flux",
+  fluxc: "make -C flux fluxc",
+  fluxrt: "make -C flux fluxrt PROFILE=release-opt",
+}
+
 export function requireBinary(name: string) {
   let path = resolveBinary(name)
   if (path) return path
+  let hint = BUILD_HINTS[name]
   console.error(`Could not find ${name} binary.`)
-  console.error("Build from source: run make solidrt-go, then set SRT_HOME=<SolidRT project home>")
+  if (hint) {
+    console.error(`Build it from source: run ${hint}, with SRT_HOME pointing at your SolidRT checkout.`)
+  } else {
+    console.error("Build it from source, with SRT_HOME pointing at your SolidRT checkout.")
+  }
+  process.exit(1)
+}
+
+// adb is a system tool (Android Platform Tools), never bundled. Look on PATH
+// first, then the standard SDK location.
+export function resolveAdb() {
+  let exe = process.platform === "win32" ? "adb.exe" : "adb"
+  let onPath = Bun.which(exe)
+  if (onPath) return onPath
+  for (let root of [process.env.ANDROID_HOME, process.env.ANDROID_SDK_ROOT]) {
+    if (!root) continue
+    let candidate = resolve(root, "platform-tools", exe)
+    if (existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+export function requireAdb() {
+  let path = resolveAdb()
+  if (path) return path
+  console.error("Could not find adb (Android Platform Tools).")
+  console.error("Install it:")
+  console.error("  Windows: winget install Google.PlatformTools")
+  console.error("  macOS:   brew install android-platform-tools")
+  console.error("  Linux:   install your distro's android-tools / adb package")
   process.exit(1)
 }
 
@@ -42,16 +79,6 @@ 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" }))
-  }
-}
-
 export function shutdown() {
   if (state.child) state.child.kill()
   if (state.server) state.server.stop()

package/src/watcher.ts

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

package/src/bun-plugin-solid.ts

@@ -1,21 +0,0 @@
-import { transformAsync } from "@babel/core"
-import ts from "@babel/preset-typescript"
-import solid from "babel-preset-solid"
-import { type BunPlugin } from "bun"
-
-export function solidPlugin(): BunPlugin {
-  return {
-    name: "bun-plugin-solid",
-    setup: (build) => {
-      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
-        let file = Bun.file(args.path)
-        let code = await file.text()
-        let transforms = await transformAsync(code, {
-          filename: args.path,
-          presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
-        })
-        return { contents: transforms?.code ?? "", loader: "js" }
-      })
-    },
-  }
-}

package/src/bundle.ts

@@ -1,126 +0,0 @@
-import { solidPlugin } from "./bun-plugin-solid"
-import { values, source, isPrebuilt } from "./args"
-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 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({
-      entrypoints: [entry!],
-      target: "browser",
-      format: "esm",
-      minify: values.minify,
-      external: ["flux:*"],
-      define,
-      plugins: [solidPlugin()],
-    })
-  } catch (e) {
-    console.error("[cli] compile error:\n", e)
-    return null
-  }
-
-  if (result?.success) {
-    return result
-  }
-
-  if (result) {
-    for (let msg of result?.logs) console.error(msg)
-  }
-  return null
-}
-
-export async function bundleTo(outfile: string) {
-  let result = await bundle()
-  if (!result) {
-    console.error("Build failed")
-    process.exit(1)
-  }
-  for (let output of result.outputs) {
-    await Bun.write(outfile, output)
-  }
-  return result
-}
-
-async function compileJs(jsCode: string, outfile: string) {
-  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)
-  await Bun.write(outfile, bytecode)
-  return outfile
-}
-
-async function compileToBytecode(jsFile: string, outFile?: string) {
-  let jsCode = await Bun.file(jsFile).text()
-  let dest = outFile ?? jsFile.replace(/\.srt\.js$/, ".srt.bin").replace(/\.js$/, ".bin")
-  return compileJs(jsCode, dest)
-}
-
-async function compileFromStdin(jsCode: string, outfile: string) {
-  return compileJs(jsCode, outfile)
-}
-
-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)
-    }
-    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(/\.[jt]sx?$/, "")
-
-  if (values.stdout) {
-    let result = await bundle()
-    if (!result) {
-      console.error("Build failed")
-      process.exit(1)
-    }
-    for (let output of result.outputs) {
-      process.stdout.write(await output.text())
-    }
-    process.exit()
-  }
-
-  if (values.compile) {
-    let result = await bundle()
-    if (!result) {
-      console.error("Build failed")
-      process.exit(1)
-    }
-    let jsCode = ""
-    for (let output of result.outputs) {
-      jsCode += await output.text()
-    }
-    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()
-  }
-
-  let jsOutfile = baseName + ".srt.js"
-  let result = await bundleTo(jsOutfile)
-  for (let output of result.outputs) {
-    console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
-  }
-  process.exit()
-}

package/src/pack.ts

@@ -1,58 +0,0 @@
-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()
-}