@solidrt/cli 0.0.50 → 0.0.52

package/src/packer.ts

@@ -1,103 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, join } from "node:path"
-import { requireBinary } from "./util"
-import { compileToBytecode } from "./bundler"
-import type { PackFolder } from "./pack-folder"
-
-// 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_payload).
-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"
-}
-
-// Section kinds in the solidrt trailer. Must match lattice/src/main.rs.
-const SECTION_MANIFEST = 1
-const SECTION_FILE = 2
-const SECTION_GL_LIB = 3
-
-// The GL libraries the runner needs next to it (or, single-file, embedded as
-// kind-3 sections it extracts at boot): ANGLE's libraries on Windows and
-// macOS, nothing on platforms with a system GL. Order matters and the runner
-// preloads in section order: libGLESv2 must load before libEGL so libEGL's
-// import of it resolves against the already-loaded module instead of a
-// directory search.
-const GL_LIB_NAMES: Partial<Record<NodeJS.Platform, string[]>> = {
-  win32: ["libGLESv2.dll", "libEGL.dll"],
-  darwin: ["libGLESv2.dylib", "libEGL.dylib"],
-}
-
-// The GL libraries shipped next to the runner binary, resolved to their paths.
-// Missing files are fatal: a pack without them cannot create a window.
-export function runnerGlLibs(runnerPath: string): Array<{ name: string; path: string }> {
-  let names = GL_LIB_NAMES[process.platform] ?? []
-  let dir = dirname(runnerPath)
-  return names.map((name) => {
-    let path = join(dir, name)
-    if (!existsSync(path)) {
-      console.error(`Could not find ${name} next to the runner (${dir}); the packed app needs it to create a GL context.`)
-      process.exit(1)
-    }
-    return { name, path }
-  })
-}
-
-type Section = { kind: number; bytes: Buffer; name?: string }
-
-// Append sections to the runner image: each section's bytes, then a table of
-// section entries, then [table offset u64 LE][entry count u32 LE][magic].
-// Table entry: [kind u32 LE][offset u64 LE][len u64 LE][name len u16 LE][name].
-// Offsets are absolute file offsets. The runner reads its own image at
-// startup, validates the magic, and slices the sections back out.
-function packSections(runnerBytes: Buffer, sections: Section[], magic: Buffer): Buffer {
-  let parts: Buffer[] = [runnerBytes]
-  let entries: Buffer[] = []
-  let offset = runnerBytes.length
-  for (let section of sections) {
-    parts.push(section.bytes)
-    let name = Buffer.from(section.name ?? "", "utf8")
-    let entry = Buffer.allocUnsafe(22 + name.length)
-    entry.writeUInt32LE(section.kind, 0)
-    entry.writeBigUInt64LE(BigInt(offset), 4)
-    entry.writeBigUInt64LE(BigInt(section.bytes.length), 12)
-    entry.writeUInt16LE(name.length, 20)
-    name.copy(entry, 22)
-    entries.push(entry)
-    offset += section.bytes.length
-  }
-  let tail = Buffer.allocUnsafe(12)
-  tail.writeBigUInt64LE(BigInt(offset), 0) // the table starts where the sections end
-  tail.writeUInt32LE(sections.length, 8)
-  return Buffer.concat([...parts, ...entries, tail, magic])
-}
-
-// The single-file solidrt executable: the runner image plus the pack folder in
-// section form - the canonical manifest verbatim, then every manifest-listed
-// file named by its manifest path. Bundle, fonts, and identity all come from
-// the manifest; assets are read in place via ranged reads at their section
-// offsets, so nothing is unpacked at runtime. GL libraries ride along as
-// kind-3 sections (runtime freight, deliberately outside the manifest); the
-// runner extracts those to its cache and preloads them before window setup.
-export function packSolid(folder: PackFolder, bytecode: Buffer): Buffer {
-  let runnerPath = requireBinary("solidrt")
-  let runnerBytes = readFileSync(runnerPath)
-  let sections: Section[] = [
-    { kind: SECTION_MANIFEST, bytes: Buffer.from(folder.manifest, "utf8") },
-    { kind: SECTION_FILE, bytes: bytecode, name: "bundle.bin" },
-    ...folder.copies.map((c) => ({ kind: SECTION_FILE, bytes: readFileSync(c.from), name: c.to })),
-    ...folder.files.map((f) => ({ kind: SECTION_FILE, bytes: f.bytes, name: f.to })),
-    ...runnerGlLibs(runnerPath).map((lib) => ({ kind: SECTION_GL_LIB, bytes: readFileSync(lib.path), name: lib.name })),
-  ]
-  return packSections(runnerBytes, sections, MAGIC.solidrt)
-}
-
-// Compile JS to bytecode and append it to the fluxrt runner as its
-// single-payload trailer: [bytecode][u64 offset LE][8-byte magic].
-export async function packFlux(jsCode: string): Promise<Buffer> {
-  let bytecode = await compileToBytecode(jsCode)
-  let runnerBytes = readFileSync(requireBinary("fluxrt"))
-  let offsetBuf = Buffer.allocUnsafe(8)
-  offsetBuf.writeBigUInt64LE(BigInt(runnerBytes.length))
-  return Buffer.concat([runnerBytes, bytecode, offsetBuf, MAGIC.fluxrt])
-}

package/src/repl.ts

@@ -1,233 +0,0 @@
-import { createInterface } from "node:readline"
-import { resolve, dirname } from "path"
-import { readdirSync } from "node:fs"
-import { state, print, printErr, shutdown } from "./util"
-import { buildReload, getClients, sendReload, sendStop, sendStats, sendWatch, showBuildFailure } from "./dev-server"
-import { bundle } from "./bundler"
-import { buildManifest } from "./project"
-import { startWatcher, stopWatcher } from "./watcher"
-
-// Resolve repl client indexes ("0 2") against the server's client list,
-// printing a complaint for each invalid token. The list order is connect
-// order, matching what `list` shows.
-async function indexesToIds(args: string): Promise<number[]> {
-  let clients = await getClients()
-  let ids: number[] = []
-  for (let token of args.split(/\s+/)) {
-    let idx = parseInt(token, 10)
-    if (isNaN(idx) || idx < 0 || idx >= clients.length) {
-      print(`Invalid client index: ${token}`)
-      continue
-    }
-    ids.push(clients[idx]!.id)
-  }
-  return ids
-}
-
-async function cmdStop(args: string) {
-  if (!args) {
-    stopWatcher()
-    state.currentCode = null
-    state.currentMap = null
-    state.currentManifest = null
-    state.source = undefined
-    await sendStop()
-    print("[cli] Sent stop to all clients")
-    return
-  }
-  let ids = await indexesToIds(args)
-  if (ids.length) {
-    await sendStop(ids)
-    print(`[cli] Sent stop to client(s) ${ids.join(", ")}`)
-  }
-}
-
-async function cmdReload(args: string) {
-  if (state.source && state.source.endsWith(".tsx")) {
-    let result = await bundle(state.source)
-    if (!result) {
-      printErr("[cli] Build failed, reload aborted")
-      await showBuildFailure()
-      return
-    }
-    state.currentCode = result.code
-    state.currentMap = result.map
-    state.currentManifest = result.manifest
-  }
-  let msg = buildReload({ code: state.currentCode, manifest: state.currentManifest })
-  if (!args) {
-    await sendReload(msg, { latch: true, map: state.currentMap })
-    print("[cli] Sent reload to all clients")
-    return
-  }
-  let ids = await indexesToIds(args)
-  if (ids.length) {
-    await sendReload(msg, { clients: ids, map: state.currentMap })
-    print(`[cli] Sent reload to client(s) ${ids.join(", ")}`)
-  }
-}
-
-async function cmdStats(args: string) {
-  if (args === "on") {
-    state.stats = true
-  } else if (args === "off") {
-    state.stats = false
-  } else if (!args) {
-    state.stats = !state.stats
-  } else {
-    print("Usage: stats [on|off]")
-    return
-  }
-  await sendStats(state.stats)
-  print(`[cli] Stats overlay ${state.stats ? "on" : "off"}`)
-}
-
-async function cmdList() {
-  let clients = await getClients()
-  if (clients.length === 0) {
-    print("No connected clients")
-    return
-  }
-  print(`${clients.length} connected client(s):`)
-  let i = 0
-  for (let c of clients) {
-    print(`  ${i++}: ${c.address ?? "unknown"} [${c.platform}, ${c.version}]`)
-  }
-}
-
-async function cmdLoad(file: string) {
-  if (!file) {
-    print("Usage: load <file.tsx|.srt.js|.srt.bin>")
-    return
-  }
-  let path = resolve(file)
-  // Same rule as /__control__/load (control.ts): a server run serves the
-  // project it started in, and an entry outside the project root cannot
-  // resolve the project's dependencies anyway.
-  let norm = (p: string) => p.replace(/\\/g, "/")
-  let root = norm(state.projectDir).replace(/\/+$/, "") + "/"
-  if (!norm(path).startsWith(root)) {
-    printErr(`[cli] Entry is outside the project root: ${path} is not under ${state.projectDir}. Restart srt in that project to work on it.`)
-    return
-  }
-  if (file.endsWith(".tsx")) {
-    let result = await bundle(path)
-    if (!result) {
-      printErr("[cli] Build failed")
-      return
-    }
-    state.currentCode = result.code
-    state.currentMap = result.map
-    state.currentManifest = result.manifest
-  } else if (file.endsWith(".srt.js")) {
-    state.currentCode = await Bun.file(path).text()
-    state.currentMap = null
-    state.currentManifest = buildManifest(state.currentCode, path)
-  } else if (file.endsWith(".srt.bin")) {
-    let bytes = await Bun.file(path).arrayBuffer()
-    // One-shot: bytecode loads are pushed but not latched for late joiners.
-    await sendReload(buildReload({ bytecode: Buffer.from(bytes).toString("base64") }))
-    print(`[cli] 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()
-  // The load also moves the server's file-serving root to the new source dir
-  // and its rebuild entry to the new file (for a later MCP reload). The
-  // project root - and with it the /assets/ root - is fixed for the life of
-  // the run.
-  await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
-    latch: true,
-    sourceDir: state.sourceDir,
-    entry: file.endsWith(".tsx") ? path : undefined,
-    map: state.currentMap,
-  })
-  print(`[cli] Loaded ${file}`)
-}
-
-let COMMANDS = ["load ", "stop", "reload", "list", "stats", "watch ", "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]
-}
-
-// Run a repl command, reporting a failed server round-trip instead of leaving
-// an unhandled rejection (e.g. the server process died mid-command).
-function guard(p: Promise<void>) {
-  p.catch((e) => printErr(`[cli] ${String(e)}`))
-}
-
-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 ")) {
-      guard(cmdStop(cmd.slice(5).trim()))
-    } else if (cmd === "reload" || cmd.startsWith("reload ")) {
-      guard(cmdReload(cmd.slice(7).trim()))
-    } else if (cmd.startsWith("load ")) {
-      guard(cmdLoad(cmd.slice(5).trim()))
-    } else if (cmd === "list") {
-      guard(cmdList())
-    } else if (cmd === "stats" || cmd.startsWith("stats ")) {
-      guard(cmdStats(cmd.slice(6).trim()))
-    } else if (cmd === "watch on" || cmd === "watch off") {
-      // Manual override for the agent-latched auto-reload pause (an agent
-      // that died mid-edit leaves it off; its reload normally restores it).
-      let enabled = cmd === "watch on"
-      guard(sendWatch(enabled).then(() => print(`[cli] Auto-reload on change ${enabled ? "on" : "off"}`)))
-    } 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, stats, watch on|off, !<cmd>, quit, help")
-    } else if (cmd) {
-      print(`Unknown command: ${cmd}`)
-    }
-    state.rl!.prompt()
-  })
-
-  state.rl.prompt()
-}

package/src/util.ts

@@ -1,121 +0,0 @@
-import { resolveBinary } from "./artifacts"
-import { existsSync } from "node:fs"
-import { resolve } from "node:path"
-import type { Interface as ReadlineInterface } from "node:readline"
-// import type { Bonjour } from "bonjour-service"  (mDNS advertise, kept - see dev-server.ts)
-
-export let state = {
-  // What srt believes the current bundle is; the server process keeps its own
-  // latched copy for late-joining clients (see packages/cli/server/).
-  currentCode: null as string | null,
-  // The bundle's composed sourcemap (dev builds), sent to the server alongside
-  // reloads so it can remap logged stack traces to .tsx positions.
-  currentMap: null as string | null,
-  // The bundle's version manifest (canonical JSON string, see buildManifest);
-  // travels with code reloads so clients install the push as a version.
-  currentManifest: null as string | null,
-  source: undefined as string | undefined,
-  sourceDir: process.cwd(),
-  // The project root the assets/ convention hangs off (see project.ts
-  // projectDirFor); the server's /assets/ route serves from under it.
-  projectDir: process.cwd(),
-  child: null as ReturnType<typeof Bun.spawn> | null,
-  // The spawned flux dev-server process (see dev-server.ts startServer).
-  serverProc: null as ReturnType<typeof Bun.spawn> | null,
-  shuttingDown: false,
-  serverUrl: null as string | null,
-  rl: null as ReadlineInterface | null,
-  // bonjour: null as Bonjour | null,  (mDNS advertise, kept - see dev-server.ts)
-  stats: false,
-  // --capture <file>: destination for captured key events, or undefined when
-  // off; the server process owns the capture file and clock (see
-  // packages/cli/server/main.ts's "capture" message handling).
-  capture: undefined as string | undefined,
-}
-
-// Build target per binary, for the "not found" hint. Run from the repo root.
-let BUILD_HINTS: Record<string, string> = {
-  "solidrt-go": "make client",
-  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.`)
-  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)
-}
-
-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)
-}
-
-// Pipe a child stream to `out` without mangling the repl prompt: clear the
-// prompt line, write the chunk, redraw the prompt.
-export 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 shutdown() {
-  state.shuttingDown = true
-  if (state.child) state.child.kill()
-  if (state.serverProc) state.serverProc.kill()
-  // if (state.bonjour) state.bonjour.destroy()  (mDNS advertise, kept - see dev-server.ts)
-  process.exit(0)
-}

package/src/watcher.ts

@@ -1,69 +0,0 @@
-import { existsSync, watch } from "node:fs"
-import { resolve, dirname, sep, basename } from "path"
-import { state, print, printErr } from "./util"
-import { buildReload, sendReload, showBuildFailure, watchAllowed } from "./dev-server"
-import { bundle } from "./bundler"
-
-let watchers: ReturnType<typeof watch>[] = []
-
-export function stopWatcher() {
-  for (let w of watchers) w.close()
-  watchers = []
-}
-
-async function rebuild(filename: string) {
-  if (!(await watchAllowed())) {
-    print(`[cli] Change detected: ${filename} (auto-reload paused by agent; "watch on" resumes)`)
-    return
-  }
-
-  print(`[cli] Change detected: ${filename}`)
-  let result = await bundle(state.source)
-  if (!result) {
-    printErr("[cli] Build failed, waiting for changes...")
-    await showBuildFailure()
-    return
-  }
-  state.currentCode = result.code
-  state.currentMap = result.map
-  state.currentManifest = result.manifest
-  await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
-    latch: true,
-    map: state.currentMap,
-  })
-}
-
-export function startWatcher() {
-  if (!state.source) return
-  let watchDir = dirname(resolve(state.source))
-
-  stopWatcher()
-
-  // An asset edit re-pushes too: the assets/ tree is part of the manifest, so
-  // clients install the new version. The tree roots at the project dir; the
-  // project dir is an ancestor of (or equal to) the entry's dir, so assets/
-  // is inside watchDir exactly when they are the same dir. An assets/ folder
-  // created after startup needs a restart or `load` to be picked up.
-  let assetsDir = resolve(state.projectDir, "assets")
-  let covered = resolve(state.projectDir) === watchDir
-  let isAsset = (filename: string) =>
-    (filename === "assets" || filename.startsWith("assets" + sep)) && !basename(filename).startsWith(".")
-
-  print(`[cli] Watching ${watchDir} for changes...`)
-  watchers.push(
-    watch(watchDir, { recursive: true }, (_event, filename) => {
-      if (!filename) return
-      if (!/\.(tsx?|jsx?)$/.test(filename) && !(covered && isAsset(filename))) return
-      rebuild(filename)
-    }),
-  )
-
-  if (!covered && existsSync(assetsDir)) {
-    watchers.push(
-      watch(assetsDir, { recursive: true }, (_event, filename) => {
-        if (!filename || basename(filename).startsWith(".")) return
-        rebuild("assets" + sep + filename)
-      }),
-    )
-  }
-}