@solidrt/cli 0.0.51 → 0.0.52

package/src/repl.ts

@@ -1,249 +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, bundleMaps, prebuiltManifest } from "./bundler"
-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.currentMaps = 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.currentMaps = bundleMaps(result)
-    state.currentManifest = result.manifest
-  }
-  let msg = buildReload({ code: state.currentCode, manifest: state.currentManifest })
-  if (!args) {
-    await sendReload(msg, { latch: true, maps: state.currentMaps })
-    print("[cli] Sent reload to all clients")
-    return
-  }
-  let ids = await indexesToIds(args)
-  if (ids.length) {
-    await sendReload(msg, { clients: ids, maps: state.currentMaps })
-    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.
-  // Windows paths are case-insensitive and the same drive shows up as both
-  // `c:` and `C:` (an editor-spawned bridge keeps its parent's spelling), so a
-  // drive-letter path folds case; a POSIX path stays exact.
-  let norm = (p: string) => {
-    let s = p.replace(/\\/g, "/")
-    return /^[a-zA-Z]:\//.test(s) ? s.toLowerCase() : s
-  }
-  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.currentMaps = bundleMaps(result)
-    state.currentManifest = result.manifest
-  } else if (file.endsWith(".srt.js")) {
-    state.currentCode = await Bun.file(path).text()
-    state.currentMaps = null
-    state.currentManifest = prebuiltManifest(state.currentCode, path, state.projectDir)
-  } 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,
-    maps: state.currentMaps,
-  })
-  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() {
-  // Without a terminal there is nobody to prompt, and stdin is at EOF from the
-  // start: readline would fire `close` immediately and shutdown() would tear
-  // down the server, the client and the registry record about a second after
-  // boot. A backgrounded or supervisor-launched srt therefore runs with no
-  // repl at all, kept alive by the server process and the watcher, and stopped
-  // with a signal. See okf/backlog/srt-run-exits-on-stdin-eof.md.
-  if (!process.stdin.isTTY) {
-    print("[cli] No terminal on stdin, running without the repl")
-    return
-  }
-
-  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,122 +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 sourcemaps (dev builds), keyed by module name
-  // ("main", each isolate id), sent to the server alongside reloads so it can
-  // remap logged stack traces to .tsx positions.
-  currentMaps: null as Record<string, 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,73 +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, bundleMaps } 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.currentMaps = bundleMaps(result)
-  state.currentManifest = result.manifest
-  await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
-    latch: true,
-    maps: state.currentMaps,
-  })
-}
-
-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
-      // Dot directories are never sources: .srt-data in particular is this
-      // server's own output (isolate bundles are .js files in there), and
-      // rebuilding on it would rebuild forever.
-      if (filename.split(sep).some((part, i, parts) => i < parts.length - 1 && part.startsWith("."))) 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)
-      }),
-    )
-  }
-}