@solidrt/cli 0.0.1-exp.1

package/bin/srt

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/main"

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@solidrt/cli",
+  "version": "0.0.1-exp.1",
+  "author": "Antoine van Wel",
+  "type": "module",
+  "bin": {
+    "srt": "./bin/srt"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "babel-preset-solid": "2.0.0-beta.7",
+    "qrcode-generator": "^2.0.4"
+  },
+  "optionalDependencies": {
+    "@solidrt/android-arm64-v8a": "0.0.0",
+    "@solidrt/darwin-arm64": "0.0.0",
+    "@solidrt/linux-x64-gnu": "0.0.0"
+  },
+  "peerDependencies": {
+    "@solidjs/signals": "2.0.0-beta.7",
+    "@solidjs/universal": "2.0.0-beta.7",
+    "@solidrt/core": "0.0.0",
+    "typescript": "^5"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/args.ts

@@ -0,0 +1,33 @@
+import { parseArgs } from "node:util"
+
+export let { values, positionals } = parseArgs({
+  options: {
+    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 },
+  },
+  allowPositionals: true,
+})
+
+export let command = positionals[0]
+export let source = positionals[1]
+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]
+
+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
+
+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)`)
+}

package/src/build.ts

@@ -0,0 +1,118 @@
+import { solidPlugin } from "./bun-plugin-solid"
+import { values, source, isPrebuilt } from "./args"
+import { requireBinary, state } 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)
+
+  try {
+    result = await Bun.build({
+      entrypoints: [entry!],
+      target: "browser",
+      format: "esm",
+      minify: values.minify,
+      external: ["qjs:*"],
+      define,
+      plugins: [solidPlugin({ devBase })],
+    })
+  } catch (e) {
+    console.error("[dev] 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("flux")
+  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 runBuildCommand() {
+  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!))
+    process.exit()
+  }
+
+  let baseName = values.output ?? source!.replace(/\.tsx$/, "")
+
+  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)
+    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/bun-plugin-solid.ts

@@ -0,0 +1,38 @@
+import { transformAsync } from "@babel/core"
+import ts from "@babel/preset-typescript"
+import solid from "babel-preset-solid"
+import { type BunPlugin } from "bun"
+import { resolve } from "path"
+
+// let ioDevPath = resolve(import.meta.dir, "io-dev.ts")
+
+export function solidPlugin(opts: { devBase?: string } = {}): 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" }
+      })
+
+      // // -- dev-mode qjs:io rewrite ----------------------------------
+      // // In dev, user code's `import * as io from "qjs:io"` is redirected
+      // // to a wrapper that proxies non-http targets through the dev
+      // // server. The wrapper itself imports `qjs:io` -- that one import
+      // // is short-circuited to `external` to break the cycle.
+      // if (opts.devBase) {
+      //   build.onResolve({ filter: /^qjs:io$/ }, (args) => {
+      //     if (args.importer === ioDevPath) {
+      //       return { path: "qjs:io", external: true }
+      //     }
+      //     return { path: ioDevPath }
+      //   })
+      // }
+    },
+  }
+}

package/src/client.ts

@@ -0,0 +1,36 @@
+import { DEV_HOST, DEV_PORT, state, print, requireBinary } from "./util"
+
+function pipeAbovePrompt(stream: ReadableStream<Uint8Array>, out: NodeJS.WriteStream) {
+  let reader = stream.getReader()
+  ;(async () => {
+    while (true) {
+      let { done, value } = await reader.read()
+      if (done || !value) break
+      process.stdout.write("\r\x1b[K")
+      out.write(value)
+      state.rl?.prompt(true)
+    }
+  })()
+}
+
+export function spawnClient() {
+  let runner = requireBinary("solidrt-go")
+  state.child = Bun.spawn([runner], {
+  //TODO implement dev server connection
+  // state.child = Bun.spawn([runner, "--dev-server", `${DEV_HOST}:${DEV_PORT}`], {
+    stdio: ["ignore", "pipe", "pipe"],
+  })
+
+  if (state.child.stdout && typeof state.child.stdout !== "number")
+    pipeAbovePrompt(state.child.stdout, process.stdout)
+  if (state.child.stderr && typeof state.child.stderr !== "number")
+    pipeAbovePrompt(state.child.stderr, process.stderr)
+
+  state.child.exited.then(() => {
+    if (state.clients.size === 0) {
+      state.server?.stop()
+      process.exit(0)
+    }
+    print(`[dev] Local client exited, ${state.clients.size} remote client(s) still connected`)
+  })
+}

package/src/main.ts

@@ -0,0 +1,80 @@
+#!/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 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
+
+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 { startServer } from "./server"
+import { spawnClient } from "./client"
+import { startRepl } from "./repl"
+import { startWatcher } from "./watcher"
+import { resolve, dirname } from "path"
+
+// -- Validate args --
+
+if (!command || (command !== "build" && command !== "run")) {
+  printUsage()
+  process.exit(1)
+}
+
+if (command === "build" && (!source || (!isTsx && !isPrebuilt))) {
+  console.error("Usage: srt build [options] <entry.tsx|.srt.js|.srt.bin>")
+  process.exit(1)
+}
+
+// -- Build command --
+
+if (command === "build") {
+  await runBuildCommand()
+}
+
+// -- Run command --
+
+if (values.client) {
+  let runner = requireBinary("solidrt-go")
+  let args = []
+  //TODO add dev server connection
+  // if (source) args.push("--dev-server", source)
+  let exit = await run(runner, args)
+  process.exit(exit)
+}
+
+// Initialize state from args
+state.source = source
+state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
+
+startServer()
+
+// Bundle initial code if source file given (after server start so the
+// dev base URL is available to the bundler).
+if (source && isTsx) {
+  let initialResult = await bundle()
+  if (initialResult) {
+    for (let output of initialResult.outputs) {
+      state.currentCode = await output.text()
+    }
+  }
+}
+
+if (!values.server) {
+  spawnClient()
+}
+
+process.on("SIGINT", shutdown)
+process.on("SIGTERM", shutdown)
+
+let version = pkg.version === "0.0.0" ? "" : " version " + pkg.version
+console.log(`Welcome to SolidRT${version}!`)
+startRepl()
+startWatcher()

package/src/native.ts

@@ -0,0 +1,45 @@
+import { createRequire } from "node:module"
+import { existsSync } from "node:fs"
+import { resolve, dirname } from "node:path"
+import process from "node:process"
+
+let require = createRequire(import.meta.url)
+
+let TRIPLE_MAP: Record<string, string> = {
+  "linux-x64": "linux-x64-gnu",
+  "darwin-arm64": "darwin-arm64",
+  "win32-x64": "win32-x64-msvc",
+}
+
+let PKG_MAP: Record<string, string> = {
+  "linux-x64": "@solidrt/linux-x64-gnu",
+  "darwin-arm64": "@solidrt/darwin-arm64",
+  "win32-x64": "@solidrt/win32-x64-msvc",
+}
+
+export function resolveBinary(name: string) {
+  let key = `${process.platform}-${process.arch}`
+  let ext = process.platform === "win32" ? ".exe" : ""
+
+  // 1. SRT_HOME: contributors pointing at their local solidrt checkout
+  let srtRoot = process.env.SRT_HOME
+  if (srtRoot) {
+    let triple = TRIPLE_MAP[key]
+    if (triple) {
+      let bin = resolve(srtRoot, "dist", triple, name + ext)
+      if (existsSync(bin)) return bin
+    }
+  }
+
+  // 2. Platform npm package (installed via optionalDependencies)
+  let pkg = PKG_MAP[key]
+  if (pkg) {
+    try {
+      let pkgDir = dirname(require.resolve(`${pkg}/package.json`))
+      let bin = resolve(pkgDir, name + ext)
+      if (existsSync(bin)) return bin
+    } catch {}
+  }
+
+  return null
+}

package/src/repl.ts

@@ -0,0 +1,171 @@
+import { createInterface } from "node:readline"
+import { resolve, dirname } from "path"
+import { readdirSync } from "node:fs"
+import { state, print, printErr, broadcastStop, shutdown } from "./util"
+import { bundle } from "./build"
+import { startWatcher } from "./watcher"
+
+function cmdStop(args: string) {
+  if (!args) {
+    broadcastStop()
+    print("[dev] Sent stop to all clients")
+    return
+  }
+  let clientList = [...state.clients.keys()]
+  for (let token of args.split(/\s+/)) {
+    let idx = parseInt(token, 10)
+    if (isNaN(idx) || idx < 0 || idx >= clientList.length) {
+      print(`Invalid client index: ${token}`)
+      continue
+    }
+    clientList[idx].send(JSON.stringify({ type: "stop" }))
+    print(`[dev] Sent stop to client ${idx}`)
+  }
+}
+
+async function cmdReload(args: string) {
+  if (state.source && state.source.endsWith(".tsx")) {
+    let result = await bundle(state.source)
+    if (!result) {
+      printErr("[dev] Build failed, reload aborted")
+      return
+    }
+    for (let output of result.outputs) {
+      state.currentCode = await output.text()
+    }
+  }
+  let msg = JSON.stringify({ type: "reload", code: state.currentCode })
+  if (!args) {
+    for (let ws of state.clients.keys()) ws.send(msg)
+    print("[dev] Sent reload to all clients")
+    return
+  }
+  let clientList = [...state.clients.keys()]
+  for (let token of args.split(/\s+/)) {
+    let idx = parseInt(token, 10)
+    if (isNaN(idx) || idx < 0 || idx >= clientList.length) {
+      print(`Invalid client index: ${token}`)
+      continue
+    }
+    clientList[idx].send(msg)
+    print(`[dev] Sent reload to client ${idx}`)
+  }
+}
+
+function cmdList() {
+  if (state.clients.size === 0) {
+    print("No connected clients")
+    return
+  }
+  print(`${state.clients.size} connected client(s):`)
+  let i = 0
+  for (let [ws, info] of state.clients) {
+    print(`  ${i++}: ${ws.remoteAddress} [${info.platform}, ${info.version}]`)
+  }
+}
+
+async function cmdLoad(file: string) {
+  if (!file) {
+    print("Usage: load <file.tsx|.srt.js|.srt.bin>")
+    return
+  }
+  let path = resolve(file)
+  if (file.endsWith(".tsx")) {
+    let result = await bundle(path)
+    if (!result) {
+      printErr("[dev] Build failed")
+      return
+    }
+    for (let output of result.outputs) {
+      state.currentCode = await output.text()
+    }
+  } else if (file.endsWith(".srt.js")) {
+    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))
+    print(`[dev] Loaded ${file} (bytecode, ${bytes.byteLength} bytes)`)
+    return
+  } else {
+    print("Unsupported file type. Use .tsx, .srt.js, or .srt.bin")
+    return
+  }
+  state.source = path
+  state.sourceDir = dirname(path)
+  startWatcher()
+  for (let ws of state.clients.keys()) {
+    ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+  }
+  print(`[dev] Loaded ${file}`)
+}
+
+let COMMANDS = ["load ", "stop", "reload", "list", "quit", "exit", "help"]
+let LOAD_EXTENSIONS = [".tsx", ".srt.js", ".srt.bin"]
+
+function completer(line: string): [string[], string] {
+  if (line.startsWith("load ")) {
+    let partial = line.slice(5)
+    let dir = partial.includes("/") ? partial.slice(0, partial.lastIndexOf("/") + 1) : ""
+    let prefix = partial.slice(dir.length)
+    let absDir = resolve(dir || ".")
+    try {
+      let entries = readdirSync(absDir, { withFileTypes: true })
+      let matches: string[] = []
+      for (let entry of entries) {
+        if (!entry.name.startsWith(prefix)) continue
+        if (entry.isDirectory()) {
+          matches.push(entry.name + "/")
+        } else if (LOAD_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+          matches.push(entry.name)
+        }
+      }
+      return [matches, prefix]
+    } catch {
+      return [[], line]
+    }
+  }
+  let matches = COMMANDS.filter((c) => c.startsWith(line))
+  return [matches, line]
+}
+
+export function startRepl() {
+  state.rl = createInterface({ input: process.stdin, output: process.stdout, completer })
+  state.rl.setPrompt("srt> ")
+
+  state.rl.on("close", shutdown)
+
+  state.rl.on("line", (line) => {
+    let cmd = line.trim()
+    if (cmd === "stop" || cmd.startsWith("stop ")) {
+      cmdStop(cmd.slice(5).trim())
+    } else if (cmd === "reload" || cmd.startsWith("reload ")) {
+      cmdReload(cmd.slice(7).trim())
+    } else if (cmd.startsWith("load ")) {
+      cmdLoad(cmd.slice(5).trim())
+    } else if (cmd === "list") {
+      cmdList()
+    } else if (cmd === "quit" || cmd === "exit") {
+      shutdown()
+    } else if (cmd.startsWith("!")) {
+      let shell = cmd.slice(1)
+      if (shell) {
+        Bun.$`${{ raw: shell }}`.quiet().then(
+          (r) => {
+            if (r.stdout.length) print(r.text())
+          },
+          (e) => {
+            printErr(e.stderr.toString())
+          },
+        )
+      }
+    } else if (cmd === "help") {
+      print("Commands: load, stop, reload, list, !<cmd>, quit, help")
+    } else if (cmd) {
+      print(`Unknown command: ${cmd}`)
+    }
+    state.rl!.prompt()
+  })
+
+  state.rl.prompt()
+}

package/src/server.ts

@@ -0,0 +1,131 @@
+import { resolve } from "path"
+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"
+
+export function startServer() {
+  state.server = Bun.serve({
+    port: DEV_PORT,
+    async fetch(req, server) {
+      if (server.upgrade(req)) return
+
+      let url = new URL(req.url)
+      let path = decodeURIComponent(url.pathname)
+
+      print("[http] get", path)
+
+      let filePath = resolve(state.sourceDir, "." + path)
+      if (!filePath.startsWith(state.sourceDir)) {
+        return new Response("Forbidden", { status: 403 })
+      }
+      let stat
+      try {
+        stat = await fsStat(filePath)
+      } catch {
+        print("[http] file not found %s", path)
+        return new Response("Not found", { status: 404 })
+      }
+
+      if (stat.isDirectory()) {
+        let dirents = await readdir(filePath, { withFileTypes: true })
+        let entries = await Promise.all(
+          dirents.map(async (d) => {
+            let entry = { name: d.name, type: d.isDirectory() ? 2 : 1, size: 0, modified: 0 }
+            if (!d.isDirectory()) {
+              try {
+                let s = await fsStat(resolve(filePath, d.name))
+                entry.size = s.size
+                entry.modified = Math.floor(s.mtimeMs)
+              } catch {}
+            }
+            return entry
+          }),
+        )
+        entries.sort((a, b) => a.name.localeCompare(b.name))
+        return Response.json(entries)
+      }
+
+      return new Response(Bun.file(filePath))
+    },
+    websocket: {
+      open(ws) {
+        state.clients.set(ws, { platform: "unknown", version: "unknown" })
+        print(`[dev] Client connected ${ws.remoteAddress}`)
+        if (state.currentCode) {
+          ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+        }
+      },
+      close(ws) {
+        let info = state.clients.get(ws)
+        state.clients.delete(ws)
+        print(`[dev] Client disconnected: ${info?.platform ?? "unknown"}`)
+        if (state.child && state.clients.size === 0 && state.child.exitCode !== null) {
+          print("[dev] All clients disconnected, shutting down")
+          state.server?.stop()
+          process.exit(0)
+        }
+      },
+      message(ws, msg) {
+        try {
+          let data = JSON.parse(typeof msg === "string" ? msg : Buffer.from(msg).toString())
+          if (data.type === "info") {
+            state.clients.set(ws, {
+              platform: data.platform ?? "unknown",
+              version: data.version ?? "unknown",
+            })
+            print(`[dev] Client info ${ws.remoteAddress} ${data.platform} (${data.version})`)
+          }
+        } catch {}
+      },
+    },
+  })
+
+  let lanAddress = Object.values(networkInterfaces())
+    .flat()
+    .find((i) => i?.family === "IPv4" && !i.internal)?.address
+
+  let address = lanAddress ?? DEV_HOST
+  let serverUrl = `${address}:${state.server.port}`
+  state.serverUrl = serverUrl
+
+  console.log("")
+
+  let qr = qrcode(0, "L")
+  qr.addData(serverUrl)
+  qr.make()
+  let modCount = qr.getModuleCount()
+  for (let y = 0; y < modCount; y += 2) {
+    let row = "  "
+    for (let x = 0; x < modCount; x++) {
+      let top = qr.isDark(y, x)
+      let bot = y + 1 < modCount && qr.isDark(y + 1, x)
+      row += top && bot ? "\u2588" : top ? "\u2580" : bot ? "\u2584" : " "
+    }
+    console.log(row)
+  }
+
+  console.log("")
+  console.log(`[dev] WebSocket server on ws://${serverUrl}`)
+
+  // UDP discovery
+  let udp = createSocket("udp4")
+  udp.on("message", (msg, rinfo) => {
+    if (msg.toString() === "SRT_DISCOVER") {
+      print(`[dev] Discovery request from ${rinfo.address}:${rinfo.port}`)
+      udp.send("SRT_SERVER", rinfo.port, rinfo.address)
+    }
+  })
+  udp.bind(DEV_PORT, () => {
+    udp.setBroadcast(true)
+    print("[dev] UDP discovery listener on port " + DEV_PORT)
+  })
+
+  // Keepalive
+  setInterval(() => {
+    for (let ws of state.clients.keys()) {
+      ws.ping()
+    }
+  }, 5000)
+}

package/src/util.ts

@@ -0,0 +1,54 @@
+import { resolveBinary } from "./native"
+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,
+  source: undefined as string | undefined,
+  sourceDir: process.cwd(),
+  child: null as ReturnType<typeof Bun.spawn> | null,
+  server: null as BunServer<unknown> | null,
+  serverUrl: null as string | null,
+  rl: null as ReadlineInterface | null,
+}
+
+export function requireBinary(name: string) {
+  let path = resolveBinary(name)
+  if (path) return path
+  console.error(`Could not find ${name} binary.`)
+  console.error("Build from source: run make solidrt-go, then set SRT_HOME=<SolidRT project home>")
+  process.exit(1)
+}
+
+export async function run(binary: string, args: string[]) {
+  let proc = Bun.spawn([binary, ...args], { stdio: ["inherit", "inherit", "inherit"] })
+  return proc.exited
+}
+
+export function print(...args: any[]) {
+  process.stdout.write("\r\x1b[K")
+  console.log(...args)
+  state.rl?.prompt(true)
+}
+
+export function printErr(...args: any[]) {
+  process.stdout.write("\r\x1b[K")
+  console.error(...args)
+  state.rl?.prompt(true)
+}
+
+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()
+  process.exit(0)
+}

package/src/watcher.ts

@@ -0,0 +1,32 @@
+import { watch } from "node:fs"
+import { resolve, dirname } from "path"
+import { state, print, printErr } from "./util"
+import { bundle } from "./build"
+
+let currentWatcher: ReturnType<typeof watch> | null = null
+
+export function startWatcher() {
+  if (!state.source) return
+  let watchDir = dirname(resolve(state.source))
+
+  if (currentWatcher) currentWatcher.close()
+
+  print(`[dev] Watching ${watchDir} for changes...`)
+  currentWatcher = watch(watchDir, { recursive: true }, async (_event, filename) => {
+    if (!filename) return
+    if (!/\.(tsx?|jsx?)$/.test(filename)) return
+
+    print(`[watch] Change detected: ${filename}`)
+    let result = await bundle(state.source)
+    if (!result) {
+      printErr("[dev] Build failed, waiting for changes...")
+      return
+    }
+    for (let output of result.outputs) {
+      state.currentCode = await output.text()
+    }
+    for (let ws of state.clients.keys()) {
+      ws.send(JSON.stringify({ type: "reload", code: state.currentCode }))
+    }
+  })
+}