@solidrt/cli 0.0.25 → 0.0.27

package/src/repl.ts

@@ -2,28 +2,41 @@ import { createInterface } from "node:readline"
 import { resolve, dirname } from "path"
 import { readdirSync } from "node:fs"
 import { state, print, printErr, shutdown } from "./util"
-import { buildReload, broadcast, showBuildFailure } from "./dev-server"
-import { bundle, codeFromOutputs } from "./bundler"
+import { buildReload, getClients, sendReload, sendStop, sendStats, showBuildFailure } from "./dev-server"
+import { bundle } from "./bundler"
 import { startWatcher, stopWatcher } from "./watcher"
 
-function cmdStop(args: string) {
+// 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.source = undefined
-    broadcast({ type: "stop" })
+    await sendStop()
     print("[cli] 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(`[cli] Sent stop to client ${idx}`)
+  let ids = await indexesToIds(args)
+  if (ids.length) {
+    await sendStop(ids)
+    print(`[cli] Sent stop to client(s) ${ids.join(", ")}`)
   }
 }
 
@@ -32,30 +45,26 @@ async function cmdReload(args: string) {
     let result = await bundle(state.source)
     if (!result) {
       printErr("[cli] Build failed, reload aborted")
-      showBuildFailure()
+      await showBuildFailure()
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
+    state.currentCode = result.code
+    state.currentMap = result.map
   }
   let msg = buildReload({ code: state.currentCode })
   if (!args) {
-    for (let ws of state.clients.keys()) ws.send(msg)
+    await sendReload(msg, { latch: true, map: state.currentMap })
     print("[cli] 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(`[cli] Sent reload to client ${idx}`)
+  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(", ")}`)
   }
 }
 
-function cmdStats(args: string) {
+async function cmdStats(args: string) {
   if (args === "on") {
     state.stats = true
   } else if (args === "off") {
@@ -66,19 +75,20 @@ function cmdStats(args: string) {
     print("Usage: stats [on|off]")
     return
   }
-  broadcast({ type: "stats", stats: state.stats })
+  await sendStats(state.stats)
   print(`[cli] Stats overlay ${state.stats ? "on" : "off"}`)
 }
 
-function cmdList() {
-  if (state.clients.size === 0) {
+async function cmdList() {
+  let clients = await getClients()
+  if (clients.length === 0) {
     print("No connected clients")
     return
   }
-  print(`${state.clients.size} connected client(s):`)
+  print(`${clients.length} connected client(s):`)
   let i = 0
-  for (let [ws, info] of state.clients) {
-    print(`  ${i++}: ${ws.remoteAddress} [${info.platform}, ${info.version}]`)
+  for (let c of clients) {
+    print(`  ${i++}: ${c.address ?? "unknown"} [${c.platform}, ${c.version}]`)
   }
 }
 
@@ -94,13 +104,15 @@ async function cmdLoad(file: string) {
       printErr("[cli] Build failed")
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
+    state.currentCode = result.code
+    state.currentMap = result.map
   } else if (file.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(path).text()
+    state.currentMap = null
   } else if (file.endsWith(".srt.bin")) {
     let bytes = await Bun.file(path).arrayBuffer()
-    let msg = buildReload({ bytecode: Buffer.from(bytes).toString("base64") })
-    for (let ws of state.clients.keys()) ws.send(msg)
+    // 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 {
@@ -110,10 +122,14 @@ async function cmdLoad(file: string) {
   state.source = path
   state.sourceDir = dirname(path)
   startWatcher()
-  let reloadMsg = buildReload({ code: state.currentCode })
-  for (let ws of state.clients.keys()) {
-    ws.send(reloadMsg)
-  }
+  // 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).
+  await sendReload(buildReload({ code: state.currentCode }), {
+    latch: true,
+    sourceDir: state.sourceDir,
+    entry: file.endsWith(".tsx") ? path : undefined,
+    map: state.currentMap,
+  })
   print(`[cli] Loaded ${file}`)
 }
 
@@ -146,6 +162,12 @@ function completer(line: string): [string[], string] {
   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> ")
@@ -155,15 +177,15 @@ export function startRepl() {
   state.rl.on("line", (line) => {
     let cmd = line.trim()
     if (cmd === "stop" || cmd.startsWith("stop ")) {
-      cmdStop(cmd.slice(5).trim())
+      guard(cmdStop(cmd.slice(5).trim()))
     } else if (cmd === "reload" || cmd.startsWith("reload ")) {
-      cmdReload(cmd.slice(7).trim())
+      guard(cmdReload(cmd.slice(7).trim()))
     } else if (cmd.startsWith("load ")) {
-      cmdLoad(cmd.slice(5).trim())
+      guard(cmdLoad(cmd.slice(5).trim()))
     } else if (cmd === "list") {
-      cmdList()
+      guard(cmdList())
     } else if (cmd === "stats" || cmd.startsWith("stats ")) {
-      cmdStats(cmd.slice(6).trim())
+      guard(cmdStats(cmd.slice(6).trim()))
     } else if (cmd === "quit" || cmd === "exit") {
       shutdown()
     } else if (cmd.startsWith("!")) {
@@ -187,4 +209,4 @@ export function startRepl() {
   })
 
   state.rl.prompt()
-}
+}

package/src/util.ts

@@ -2,31 +2,29 @@ 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"
-import type { Bonjour } from "bonjour-service"
+// import type { Bonjour } from "bonjour-service"  (mDNS advertise, kept - see dev-server.ts)
 
 export let state = {
-  clients: new Map<any, { platform: string; version: string; id: number; capabilities: string[] }>(),
-  nextClientId: 0,
+  // 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,
   source: undefined as string | undefined,
   sourceDir: process.cwd(),
   child: null as ReturnType<typeof Bun.spawn> | null,
-  server: null as BunServer<undefined> | 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,
+  // 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. Clients only report kind/key; the server stamps `after` itself (one
-  // shared clock from captureStartMs, integer milliseconds) so events from
-  // several connected clients merge into one coherent timeline, tagged by
-  // `device` (see dev-server.ts) so they can be told apart. Streamed to disk
-  // as JSON Lines (one event object per line) as each arrives - see
-  // dev-server.ts's "capture" message handling.
+  // 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,
-  captureStartMs: 0,
-  captureLastAt: 0, // ms, same clock as captureStartMs
 }
 
 // Build target per binary, for the "not found" hint. Run from the repo root.
@@ -93,9 +91,25 @@ export function printErr(...args: any[]) {
   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.server) state.server.stop()
-  if (state.bonjour) state.bonjour.destroy()
+  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,8 +1,8 @@
 import { watch } from "node:fs"
 import { resolve, dirname } from "path"
 import { state, print, printErr } from "./util"
-import { buildReload, showBuildFailure } from "./dev-server"
-import { bundle, codeFromOutputs } from "./bundler"
+import { buildReload, sendReload, showBuildFailure } from "./dev-server"
+import { bundle } from "./bundler"
 
 let currentWatcher: ReturnType<typeof watch> | null = null
 
@@ -28,13 +28,11 @@ export function startWatcher() {
     let result = await bundle(state.source)
     if (!result) {
       printErr("[cli] Build failed, waiting for changes...")
-      showBuildFailure()
+      await showBuildFailure()
       return
     }
-    state.currentCode = await codeFromOutputs(result.outputs)
-    let msg = buildReload({ code: state.currentCode })
-    for (let ws of state.clients.keys()) {
-      ws.send(msg)
-    }
+    state.currentCode = result.code
+    state.currentMap = result.map
+    await sendReload(buildReload({ code: state.currentCode }), { latch: true, map: state.currentMap })
   })
 }

package/src/control.ts

@@ -1,119 +0,0 @@
-import { state } from "./util"
-
-// The control API under /__control__/: read-only introspection of connected
-// app clients, served next to the file routes. The MCP bridge (srt mcp) is the
-// primary consumer. Two shapes: server-held data answered directly (clients,
-// logs) and queries forwarded to a client over its websocket and correlated
-// back by id (tree, stats).
-
-export type LogEntry = { seq: number; at: number; client: number; level: string; text: string }
-
-// Ring buffer of forwarded client logs. Capped so a chatty app cannot grow the
-// server without bound; readers page through it with the `since` cursor.
-const LOG_CAP = 2000
-const QUERY_TIMEOUT_MS = 5000
-const MAX_WAIT_MS = 30000
-
-let logs: LogEntry[] = []
-let logSeq = 0
-// Pending long-poll wakeups (see handleLogs). Flushed on every append; a
-// waiter that already timed out resolves again harmlessly.
-let logWaiters: Array<() => void> = []
-
-let nextQueryId = 1
-let pendingQueries = new Map<number, (msg: any) => void>()
-
-/// A `log` message arrived from a client: buffer it and wake long-polls.
-export function appendLog(client: number, level: string, text: string) {
-  logs.push({ seq: ++logSeq, at: Date.now(), client, level, text })
-  if (logs.length > LOG_CAP) logs.splice(0, logs.length - LOG_CAP)
-  let waiters = logWaiters
-  logWaiters = []
-  for (let wake of waiters) wake()
-}
-
-/// A `result` message arrived from a client: hand it to the awaiting query.
-export function resolveQuery(msg: { id?: number }) {
-  if (typeof msg.id !== "number") return
-  let resolve = pendingQueries.get(msg.id)
-  if (resolve) {
-    pendingQueries.delete(msg.id)
-    resolve(msg)
-  }
-}
-
-function clientList() {
-  return [...state.clients.values()].map((info) => ({
-    id: info.id,
-    platform: info.platform,
-    version: info.version,
-    capabilities: info.capabilities,
-  }))
-}
-
-// Resolve the target client for a query: an explicit ?client=<id>, or the only
-// connected client when the parameter is omitted.
-function findClient(param: string | null): { ws: any } | { error: Response } {
-  let entries = [...state.clients.entries()]
-  if (param === null) {
-    if (entries.length === 1) return { ws: entries[0]![0] }
-    if (entries.length === 0) return { error: Response.json({ error: "No connected clients" }, { status: 503 }) }
-    return { error: Response.json({ error: "Multiple clients connected; pass ?client=<id>" }, { status: 400 }) }
-  }
-  let id = parseInt(param, 10)
-  let entry = entries.find(([, info]) => info.id === id)
-  if (!entry) return { error: Response.json({ error: `No client with id ${param}` }, { status: 404 }) }
-  return { ws: entry[0] }
-}
-
-async function handleQuery(url: URL, kind: string): Promise<Response> {
-  let target = findClient(url.searchParams.get("client"))
-  if ("error" in target) return target.error
-  let id = nextQueryId++
-  let reply = new Promise<any>((resolve) => {
-    pendingQueries.set(id, resolve)
-  })
-  target.ws.send(JSON.stringify({ type: "query", kind, id }))
-  let msg = await Promise.race([reply, Bun.sleep(QUERY_TIMEOUT_MS)])
-  pendingQueries.delete(id)
-  if (!msg) return Response.json({ error: "Query timed out" }, { status: 504 })
-  if (msg.error) return Response.json({ error: msg.error }, { status: 502 })
-  return Response.json(msg.data)
-}
-
-// GET /__control__/logs?since=N&wait=MS: entries with seq > since, plus the
-// latest seq as the next cursor. With `wait`, holds the response until a new
-// entry arrives or the timeout passes (long-poll), so a caller can follow the
-// stream without tight polling.
-async function handleLogs(url: URL): Promise<Response> {
-  let since = parseInt(url.searchParams.get("since") ?? "0", 10) || 0
-  let wait = Math.min(parseInt(url.searchParams.get("wait") ?? "0", 10) || 0, MAX_WAIT_MS)
-  let entries = logs.filter((e) => e.seq > since)
-  if (entries.length === 0 && wait > 0) {
-    await new Promise<void>((resolve) => {
-      let timer = setTimeout(resolve, wait)
-      logWaiters.push(() => {
-        clearTimeout(timer)
-        resolve()
-      })
-    })
-    entries = logs.filter((e) => e.seq > since)
-  }
-  return Response.json({ entries, latest: logSeq })
-}
-
-export async function handleControl(req: Request, path: string): Promise<Response> {
-  let url = new URL(req.url)
-  switch (path) {
-    case "/__control__/clients":
-      return Response.json(clientList())
-    case "/__control__/logs":
-      return handleLogs(url)
-    case "/__control__/tree":
-      return handleQuery(url, "tree")
-    case "/__control__/stats":
-      return handleQuery(url, "stats")
-    default:
-      return Response.json({ error: "Unknown control endpoint" }, { status: 404 })
-  }
-}