@solidrt/cli 0.0.51 → 0.0.53

package/src/commands/server.ts

@@ -1,73 +0,0 @@
-import pkg from "../../package.json"
-import { source, isSource, isPrebuilt, values } from "../args"
-import { state, shutdown, print, printErr } from "../util"
-import { findProjectRoot, typecheck, reportTypes } from "./check"
-import { bundle, bundleMaps, prebuiltManifest } from "../bundler"
-import { projectDirFor } from "../project"
-import { startServer, buildReload, sendReload, showBuildFailure } from "../dev-server"
-import { startRepl } from "../repl"
-import { startWatcher } from "../watcher"
-import { resolve, dirname } from "path"
-
-// Brings up the dev server (a spawned flux script serving HTTP/WS) plus the
-// initial bundle, repl, and watcher in this process. 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()
-  // With no entry the project is wherever srt was started: walk up to the
-  // nearest package.json exactly like an entry would, so the projectDir the
-  // MCP bridge derives for its registry match agrees with ours.
-  state.projectDir = projectDirFor(source ? resolve(source) : resolve("package.json"))
-  state.stats = values.stats
-  state.capture = values.capture ? resolve(values.capture) : undefined
-
-  // Spawns the server process and waits until it answers; it owns the QR and
-  // address announcements, the capture file, and the proxy cache.
-  await startServer()
-
-  // Bundle initial code if source file given (after server start so the
-  // dev base URL is available to the bundler), and latch it on the server
-  // for the clients about to connect.
-  if (source && isSource) {
-    let initialResult = await bundle()
-    if (initialResult) {
-      state.currentCode = initialResult.code
-      state.currentMaps = bundleMaps(initialResult)
-      state.currentManifest = initialResult.manifest
-      await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
-        latch: true,
-        maps: state.currentMaps,
-      })
-    } else {
-      await showBuildFailure()
-    }
-  } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
-    let path = resolve(source)
-    state.currentCode = await Bun.file(path).text()
-    state.currentManifest = prebuiltManifest(state.currentCode, path, state.projectDir)
-    await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), { latch: true })
-  }
-
-  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()
-
-  // Startup typecheck, deliberately not awaited: diagnostics print over the
-  // repl when tsc finishes, and a type error never gates the boot (srt check
-  // is the hard gate). Once per server lifetime; hot reloads never typecheck.
-  // Source builds only: a prebuilt .srt.js has no checkable project here.
-  if (source && isSource) startupTypecheck(source)
-}
-
-async function startupTypecheck(entry: string) {
-  let root = findProjectRoot(entry)
-  if (!root) return
-  let types = await typecheck(root, entry)
-  if (types) reportTypes(types, print, printErr)
-}

package/src/dev-android.ts

@@ -1,176 +0,0 @@
-import { networkInterfaces } from "node:os"
-import { print, requireAdb } from "./util"
-import { resolveApk, ANDROID_PKG_MAP } from "./artifacts"
-import { values } from "./args"
-import { DEV_PORT } from "./dev-server"
-
-// Launch component of the "go" dev-client flavor (see lattice/Makefile.android).
-let PACKAGE_ACTIVITY = "com.solidrt.go/com.solidrt.app.MainActivity"
-
-let ipToInt = (ip: string) => ip.split(".").reduce((acc, o) => (acc << 8) + (parseInt(o, 10) & 255), 0) >>> 0
-
-// This host's IPv4 on the same subnet as `deviceIp`: the interface whose
-// (address & netmask) matches the device's. Pure computation over what the OS
-// reports (cross-platform, no routing socket, no hardcoded ranges).
-function hostIpFor(deviceIp: string): string | null {
-  let d = ipToInt(deviceIp)
-  for (let addrs of Object.values(networkInterfaces())) {
-    for (let a of addrs ?? []) {
-      if (a.family === "IPv4" && !a.internal && (ipToInt(a.address) & ipToInt(a.netmask)) === (d & ipToInt(a.netmask))) {
-        return a.address
-      }
-    }
-  }
-  return null
-}
-
-// The device's own IPv4 on its primary network: from the serial for wireless adb
-// (ip:port), else queried over adb. `ip route get` reports the source IP of the
-// route to a public address, i.e. the device's main interface IP.
-function deviceIp(adb: string, target: string): string | null {
-  let m = target.match(/^(\d+\.\d+\.\d+\.\d+):\d+$/)
-  if (m) return m[1] ?? null
-  let res = Bun.spawnSync([adb, "-s", target, "shell", "ip", "route", "get", "1.1.1.1"], {
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  return res.stdout.toString().match(/src (\d+\.\d+\.\d+\.\d+)/)?.[1] ?? null
-}
-
-// The host:port the client on `target` should dial to reach this machine's dev
-// server, by adb transport: the emulator reaches the host through its NAT alias
-// 10.0.2.2; every other transport shares a LAN with the host, so match the
-// device's IP to the host interface on its subnet. Replaces the old adb-reverse
-// loopback tunnel, which never worked over wireless adb. Returns null when the
-// address cannot be resolved (the client then falls back to QR/recents).
-function devServerAddress(adb: string, target: string): string | null {
-  if (target.startsWith("emulator-")) return `10.0.2.2:${DEV_PORT}`
-  let dip = deviceIp(adb, target)
-  if (!dip) return null
-  let host = hostIpFor(dip)
-  return host ? `${host}:${DEV_PORT}` : null
-}
-
-// Serials of connected, authorized devices (excludes offline/unauthorized).
-function listDevices(adb: string): string[] {
-  let listed = Bun.spawnSync([adb, "devices"], { stdout: "pipe", stderr: "pipe" })
-  return listed.stdout
-    .toString()
-    .split("\n")
-    .slice(1)
-    .map((l) => l.trim())
-    .filter(Boolean)
-    .filter((l) => l.endsWith("\tdevice"))
-    .map((l) => l.split("\t")[0])
-    .filter((s): s is string => Boolean(s))
-}
-
-// Primary ABI of the connected device (e.g. "arm64-v8a", "armeabi-v7a"), used
-// to pick the matching APK -- a fat (multi-ABI) APK reports its 64-bit ABI
-// here and still installs fine, so this only matters for single-ABI builds.
-function deviceAbi(adb: string, target: string): string {
-  let res = Bun.spawnSync([adb, "-s", target, "shell", "getprop", "ro.product.cpu.abi"], {
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  return res.stdout.toString().trim()
-}
-
-// Always shown up front, regardless of how many devices are connected or
-// whether --device narrows it down: one line per device with the ABI its APK
-// build would target, then a dev-dependency hint for each ABI that isn't
-// resolvable locally yet. Returns the device->abi map so callers don't have
-// to re-query it.
-function printDeviceStatus(adb: string, devices: string[]): Map<string, string> {
-  let abiByDevice = new Map<string, string>()
-  let missingAbis = new Set<string>()
-  for (let d of devices) {
-    let abi = deviceAbi(adb, d)
-    abiByDevice.set(d, abi)
-    print(`${d} - ${abi}`)
-    if (!resolveApk(abi)) missingAbis.add(abi)
-  }
-  let missingPkgs = [...missingAbis].map((abi) => ANDROID_PKG_MAP[abi]).filter((pkg): pkg is string => Boolean(pkg))
-  if (missingPkgs.length > 0) print(`Add dev dependencies with: bun add -d ${missingPkgs.join(" ")}`)
-  return abiByDevice
-}
-
-// Resolve the target device serial (and its ABI). With --device, treat the
-// value as a serial prefix and require it to match exactly one connected
-// device; without it, use the sole connected device. Exits with a clear
-// message on any ambiguity.
-function resolveTarget(adb: string): { target: string; abi: string } {
-  let devices = listDevices(adb)
-  let abiByDevice = printDeviceStatus(adb, devices)
-
-  if (values.device) {
-    let prefix = values.device
-    let matches = devices.filter((d) => d.startsWith(prefix))
-    if (matches.length > 1) {
-      console.error(`--device "${prefix}" is ambiguous; matches: ${matches.join(", ")}`)
-      process.exit(1)
-    }
-    let [match] = matches
-    if (!match) {
-      console.error(`No connected device matches --device "${prefix}".`)
-      process.exit(1)
-    }
-    return { target: match, abi: abiByDevice.get(match)! }
-  }
-
-  if (devices.length > 1) {
-    console.error("Pick one with --device <serial or prefix>.")
-    process.exit(1)
-  }
-  let [only] = devices
-  if (!only) {
-    console.error("No authorized Android device found. Enable USB debugging and check `adb devices`.")
-    process.exit(1)
-  }
-  return { target: only, abi: abiByDevice.get(only)! }
-}
-
-// Install + launch the Android client on a connected device over adb, passing it
-// the dev-server address to dial as a launch-intent extra (see devServerAddress).
-// 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 { target, abi } = resolveTarget(adb)
-
-  let apk = resolveApk(abi)
-  if (!apk) {
-    console.error(`Could not find a SolidRT-Go APK for ABI "${abi}".`)
-    let pkg = ANDROID_PKG_MAP[abi]
-    if (pkg) console.error(`Add it with: bun add -d ${pkg}`)
-    process.exit(1)
-  }
-
-  print(`[cli] Installing SolidRT-Go on ${target}`)
-  let install = Bun.spawn([adb, "-s", target, "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)
-  }
-
-  // Hand the client the dev-server address to dial, as a launch-intent extra that
-  // MainActivity forwards to native argv (--dev-server); the client auto-connects
-  // to it. Replaces adb reverse, which never worked over wireless adb.
-  let devServer = devServerAddress(adb, target)
-  let launchArgs = [adb, "-s", target, "shell", "am", "start", "-n", PACKAGE_ACTIVITY]
-  if (devServer) {
-    print(`[cli] Client will dial dev server at ${devServer}`)
-    launchArgs.push("--es", "srt_dev_server", devServer)
-  } else {
-    print("[cli] Could not resolve a host address for the device; client will need a manual/QR connect")
-  }
-
-  let start = Bun.spawn(launchArgs, { 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 connect to the dev server...`)
-}

package/src/dev-client.ts

@@ -1,29 +0,0 @@
-import { state, print, requireBinary, pipeAbovePrompt, shutdown } from "./util"
-import { DEV_HOST, DEV_PORT, getClients, shutdownWhenEmpty } from "./dev-server"
-import { values, clientStorageArgs } from "./args"
-
-export function spawnClient() {
-  let runner = requireBinary("solidrt-go")
-  // The local client and dev server share this machine, so connect straight to
-  // the loopback server: no mDNS discovery or recents lookup is needed for `run`.
-  let args: string[] = ["--dev-server", `${DEV_HOST}:${DEV_PORT}`, ...clientStorageArgs()]
-  if (values.size) args.push("--size", values.size)
-  state.child = Bun.spawn([runner, ...args], {
-    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(async () => {
-    let clients = await getClients().catch(() => [])
-    if (clients.length === 0) {
-      shutdown()
-    }
-    print(`[cli] Local client exited, ${clients.length} remote client(s) still connected`)
-    // From here, exit once the last remote client disconnects.
-    shutdownWhenEmpty()
-  })
-}

package/src/dev-server.ts

@@ -1,302 +0,0 @@
-import { resolve, join } from "path"
-import { tmpdir, networkInterfaces } from "node:os"
-import { fileURLToPath } from "node:url"
-import { mkdirSync, writeFileSync, unlinkSync } from "node:fs"
-import { state, print, printErr, requireBinary, pipeAbovePrompt, shutdown } from "./util"
-import { appArgs, values, session, DEFAULT_DEV_PORT } from "./args"
-import { serverDir } from "./dev-dir"
-
-export const DEV_HOST = "127.0.0.1"
-
-// The port every dev-server consumer dials: the spawned server, the local and
-// Android clients' --dev-server address, and the MCP bridge's control base.
-// Resolved once here, so --port/--session need no threading through those
-// call sites. An explicit --port wins over the session; the server folder is
-// keyed by the port actually bound either way.
-function resolveDevPort(): number {
-  let raw = values.port
-  if (raw === undefined) return DEFAULT_DEV_PORT + session
-  let port = Number(raw)
-  if (!/^\d+$/.test(raw) || port < 1 || port > 65535) {
-    console.error(`Invalid --port value "${raw}": expected a port number between 1 and 65535`)
-    process.exit(1)
-  }
-  return port
-}
-
-export let DEV_PORT = resolveDevPort()
-
-// The dev server itself is a flux script (packages/cli/server/), spawned by
-// srt: bundling, file watching, and the repl stay here and drive the server
-// process over its loopback-only /__internal__/ routes.
-
-const INTERNAL_BASE = `http://${DEV_HOST}:${DEV_PORT}/__internal__`
-
-// Build the reload message for the client protocol. The server latches a
-// broadcast reload verbatim for late-joining clients, so srt owns the message
-// shape (including the proxy flags) end to end. `manifest` is the bundle's
-// version manifest JSON string; when present, clients install the push into
-// their version store before applying it (absent for bytecode one-shots and
-// the BSOD trigger, which must not be installed).
-export function buildReload(payload: { code?: string | null; bytecode?: string; manifest?: string | null }) {
-  let { manifest, ...rest } = payload
-  return {
-    type: "reload",
-    proxyHttp: values["proxy-http"],
-    // The session's app arguments ride every push (flux:process argv), so
-    // remote clients see the same vector as the local one.
-    args: appArgs,
-    ...(manifest ? { manifest } : {}),
-    ...rest,
-  }
-}
-
-async function post(path: string, body: object) {
-  let resp = await fetch(`${INTERNAL_BASE}${path}`, { method: "POST", body: JSON.stringify(body) })
-  if (!resp.ok) throw new Error(`Dev server ${path} failed: ${resp.status}`)
-}
-
-/**
- * Send a client-protocol message through the server: to the given client ids,
- * or to every client when omitted. `latch` keeps the message for late-joining
- * clients (code reloads latch, one-shot bytecode loads do not); `sourceDir`
- * moves the server's file-serving root (repl `load`; the project root is
- * fixed for the life of the run); `maps` is the bundle's sourcemaps keyed by
- * module name ("main", each isolate id), kept server-side for stack-trace
- * remapping (omitting it clears the server's maps, so a mapless reload never
- * remaps against stale ones).
- */
-export async function sendReload(
-  message: object,
-  opts: {
-    clients?: number[]
-    latch?: boolean
-    sourceDir?: string
-    entry?: string
-    maps?: Record<string, string> | null
-  } = {},
-) {
-  await post("/reload", { message, ...opts })
-}
-
-/** Send a stop to the given client ids, or all. A broadcast stop clears the server's latched reload. */
-export async function sendStop(clients?: number[]) {
-  await post("/stop", clients ? { clients } : {})
-}
-
-/** Latch the stats-overlay flag on the server (for welcome) and broadcast it. */
-export async function sendStats(stats: boolean) {
-  await post("/stats", { stats })
-}
-
-/** Latch the auto-reload flag on the server (repl `watch on|off`). */
-export async function sendWatch(enabled: boolean) {
-  await post("/watch", { enabled })
-}
-
-/**
- * Whether the watcher may auto-reload: agents pause it via the MCP watch
- * tool, latched on the server. Fails open so an unreachable server surfaces
- * as a reload error, not a silently ignored change.
- */
-export async function watchAllowed(): Promise<boolean> {
-  try {
-    let resp = await fetch(`${INTERNAL_BASE}/watch`)
-    if (!resp.ok) return true
-    let data = (await resp.json()) as { enabled?: boolean }
-    return data.enabled !== false
-  } catch {
-    return true
-  }
-}
-
-export type ClientEntry = {
-  id: number
-  platform: string
-  version: string
-  capabilities: string[]
-  address: string | null
-}
-
-/** The connected-client list, in connect order. */
-export async function getClients(): Promise<ClientEntry[]> {
-  let resp = await fetch(`${INTERNAL_BASE}/clients`)
-  if (!resp.ok) throw new Error(`Dev server /clients failed: ${resp.status}`)
-  return resp.json() as Promise<ClientEntry[]>
-}
-
-// Reload code that fails to start the engine on purpose. The runtime treats a
-// startup error like any app that never called render() and falls back to its
-// baked-in BSOD screen, so a build that doesn't compile shows the BSOD instead
-// of leaving the previous app frozen on screen.
-const BSOD_TRIGGER = `throw new Error("SolidRT: build failed")`
-
-// Called when a bundle fails to compile. Latches the BSOD trigger as the
-// current code (so a client connecting after the failure gets it too) and
-// pushes it to every connected client.
-export async function showBuildFailure() {
-  state.currentCode = BSOD_TRIGGER
-  // No manifest: the BSOD trigger is not a version and must never be installed.
-  state.currentManifest = null
-  await sendReload(buildReload({ code: BSOD_TRIGGER }), { latch: true })
-}
-
-// The Bun-hosted server used to exit from its ws close handler once the
-// spawned local client had exited and the last remote client disconnected.
-// The server process cannot see the child, so the policy lives here: called
-// after the local client exits, poll the client list and shut down when it
-// empties.
-export function shutdownWhenEmpty() {
-  let timer = setInterval(async () => {
-    let clients = await getClients().catch(() => null)
-    if (clients && clients.length === 0) {
-      clearInterval(timer)
-      print("[cli] All clients disconnected, shutting down")
-      shutdown()
-    }
-  }, 2000)
-}
-
-// Bundle the server script to one plain-JS file the flux binary can run. Bun
-// is already the bundler; the browser target keeps node builtins out, and the
-// flux: capability modules stay external (the runtime provides them).
-async function bundleServer(): Promise<string> {
-  let entry = fileURLToPath(new URL("../server/main.ts", import.meta.url))
-  let outfile = resolve(tmpdir(), `srt-dev-server-${process.pid}.js`)
-  let result = await Bun.build({
-    entrypoints: [entry],
-    target: "browser",
-    format: "esm",
-    external: ["flux:*"],
-  })
-  if (!result.success) {
-    printErr("[cli] Failed to bundle the dev server:")
-    for (let log of result.logs) printErr(String(log))
-    process.exit(1)
-  }
-  await Bun.write(outfile, result.outputs[0]!)
-  return outfile
-}
-
-// The server runs as a separate flux process, so a port clash surfaces there as
-// a bare non-zero exit ("Dev server exited unexpectedly (1)"). Claim the port
-// here first to turn that into the actual reason, and into the fix.
-function requireFreePort(port: number) {
-  try {
-    // Default hostname: the server binds every interface, so probe the same way.
-    let probe = Bun.serve({ port, fetch: () => new Response() })
-    probe.stop(true)
-  } catch {
-    printErr(`[cli] Port ${port} is already in use; start on another session with -s <N> (or --port <P>)`)
-    process.exit(1)
-  }
-}
-
-// The server's registry record: written once the server answers, removed at
-// exit, so MCP bridges can resolve a project to a port without any per-project
-// config (okf/backlog/parallel-dev-servers.md). The pid is the flux server's
-// (the process owning the port), so a record left behind by a crash fails the
-// bridge's liveness check; the record is a hint either way - the bridge's
-// /__control__/clients probe is authoritative.
-function writeLiveRecord() {
-  let record = {
-    pid: state.serverProc?.pid,
-    port: DEV_PORT,
-    projectDir: state.projectDir,
-    entry: state.source ?? null,
-    started: new Date().toISOString(),
-  }
-  writeFileSync(join(serverDir(DEV_PORT), "live.json"), JSON.stringify(record))
-}
-
-function removeLiveRecord() {
-  try {
-    unlinkSync(join(serverDir(DEV_PORT), "live.json"))
-  } catch {}
-}
-
-export async function startServer() {
-  let flux = requireBinary("flux")
-  requireFreePort(DEV_PORT)
-  let script = await bundleServer()
-  // The server's own folder (tunnel.key lands there, written by the flux
-  // process, which does not create directories).
-  mkdirSync(serverDir(DEV_PORT), { recursive: true })
-
-  let lanAddress = Object.values(networkInterfaces())
-    .flat()
-    .find((i) => i?.family === "IPv4" && !i.internal)?.address
-  let address = lanAddress ?? DEV_HOST
-  // The address clients can reach us on; also the dev base URL the bundler
-  // rewrites asset imports against. The server has no OS module, so srt
-  // computes it and passes it down.
-  state.serverUrl = `${address}:${DEV_PORT}`
-
-  // How the server rebuilds on an MCP-triggered reload: it cannot call
-  // Bun.build itself (it is a flux process), so it spawns srt's own bun on the
-  // standalone bundle-cli entry. Both paths are known here at spawn time.
-  let bundleCli = fileURLToPath(new URL("./bundle-cli.ts", import.meta.url))
-
-  let config = {
-    port: DEV_PORT,
-    sourceDir: state.sourceDir,
-    projectDir: state.projectDir,
-    address,
-    proxyHttp: values["proxy-http"],
-    entry: state.source,
-    args: appArgs,
-    minify: values.minify,
-    bundlerCmd: [process.execPath, bundleCli],
-    cache: values["proxy-http"],
-    cacheDir: resolve(state.projectDir, ".srt-data"),
-    keyDir: serverDir(DEV_PORT),
-    capture: state.capture,
-    stats: state.stats,
-    tunnel: values.tunnel,
-  }
-
-  state.serverProc = Bun.spawn([flux, script, JSON.stringify(config)], {
-    stdio: ["ignore", "pipe", "pipe"],
-  })
-  if (state.serverProc.stdout && typeof state.serverProc.stdout !== "number")
-    pipeAbovePrompt(state.serverProc.stdout, process.stdout)
-  if (state.serverProc.stderr && typeof state.serverProc.stderr !== "number")
-    pipeAbovePrompt(state.serverProc.stderr, process.stderr)
-
-  state.serverProc.exited.then((code) => {
-    if (!state.shuttingDown) {
-      printErr(`[cli] Dev server exited unexpectedly (${code})`)
-      process.exit(1)
-    }
-  })
-
-  // Wait until the server answers on the internal API before anything else
-  // (the initial bundle needs the dev base URL, clients need the port bound).
-  for (let i = 0; ; i++) {
-    try {
-      await getClients()
-      break
-    } catch {
-      if (i >= 100) {
-        printErr("[cli] Dev server did not start")
-        process.exit(1)
-      }
-      await Bun.sleep(100)
-    }
-  }
-
-  writeLiveRecord()
-  // shutdown() exits via process.exit, so the exit hook covers every orderly
-  // path; only a kill -9 leaves the record behind, for the pid check to catch.
-  process.on("exit", removeLiveRecord)
-
-  // mDNS advertise (dropped, code kept for future use - see
-  // okf/backlog/mdns-discovery.md): the p2p ticket is the cross-device connect
-  // story now. If advertise returns, it belongs next to the server (a flux
-  // capability), not here.
-  //
-  // import { Bonjour } from "bonjour-service"  (top of file)
-  // state.bonjour = new Bonjour()
-  // state.bonjour.publish({ name: "SolidRT Dev Server", type: "solidrt", protocol: "tcp", port: DEV_PORT })
-  // print(`[cli] Advertising _solidrt._tcp on port ${DEV_PORT} via mDNS`)
-}