@solidrt/cli 0.0.25 → 0.0.27

package/src/bundler.ts

@@ -1,6 +1,7 @@
 import { transformAsync } from "@babel/core"
 import jsx from "@babel/plugin-syntax-jsx"
 import ts from "@babel/preset-typescript"
+import remapping from "@jridgewell/remapping"
 import solid from "babel-preset-solid"
 import { type BunPlugin, type BuildArtifact } from "bun"
 import { readFileSync } from "node:fs"
@@ -53,7 +54,7 @@ function binaryImport({ types: t }: { types: any }) {
 // build, skipping emitted asset outputs. Bun's file loader emits binary assets
 // as extra outputs; the callers that flatten outputs into a single code string
 // must not glue those raw bytes onto the program.
-export async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
+async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
   let code = ""
   for (let o of outputs) {
     if (o.kind === "entry-point" || o.kind === "chunk") code += await o.text()
@@ -62,61 +63,106 @@ export async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string>
 }
 
 // Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
-// generate, targeting @solidrt/core) plus the TS preset.
-function solidPlugin(): BunPlugin {
+// generate, targeting @solidrt/core) plus the TS preset. Plain .js/.ts app
+// modules take the same path (solid is a no-op without JSX) so binaryImport
+// can rewrite their `with { type: "binary" }` imports too; dependency code
+// (node_modules) skips the babel detour and keeps Bun's native loaders.
+// With `babelMaps`, each file's transform map (original -> babel output) is
+// collected there, keyed by absolute path, for sourcemap composition later.
+function solidPlugin(babelMaps?: Map<string, object>): BunPlugin {
   return {
     name: "bun-plugin-solid",
     setup: (build) => {
-      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
+      build.onLoad({ filter: /\.(js|ts)x?$/ }, async (args) => {
+        if (!/\.(js|ts)x$/.test(args.path) && args.path.includes("node_modules")) return
         let file = Bun.file(args.path)
         let code = await file.text()
         let transforms = await transformAsync(code, {
           filename: args.path,
+          sourceMaps: !!babelMaps,
           presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
           plugins: [jsx, binaryImport],
         })
+        if (babelMaps && transforms?.map) babelMaps.set(args.path, transforms.map)
         return { contents: transforms?.code ?? "", loader: "js" }
       })
     },
   }
 }
 
-export async function bundle(entry = source) {
-  let result = null
+export type BundleOptions = { entry: string; devBase?: string; dev: boolean; minify: boolean }
 
-  let devBase = state.serverUrl ?? undefined
-  let dev = !!devBase || values.dev
-  // Keep stdout clean when the bundle itself is written to stdout.
-  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
+export type BundleResult = {
+  code: string
+  /** Composed sourcemap JSON (bundle -> original .tsx sources), dev builds only. */
+  map: string | null
+}
+
+// The pure bundle: every input is explicit, so it runs identically in the srt
+// (Bun) process and in the standalone bundle-cli subprocess the dev server
+// spawns. It never touches the ambient args/state singletons and never prints
+// progress (callers own that), so its stdout stays clean for subprocess use.
+export async function bundleWith(opts: BundleOptions): Promise<BundleResult | null> {
   let define: Record<string, string> = {
-    "process.env.NODE_ENV": dev ? "development" : "production",
+    "process.env.NODE_ENV": opts.dev ? "development" : "production",
   }
-  if (devBase) define.__SRT_DEV_BASE__ = devBase
+  if (opts.devBase) define.__SRT_DEV_BASE__ = opts.devBase
 
+  let babelMaps = opts.dev ? new Map<string, object>() : undefined
+  let result = null
   try {
     result = await Bun.build({
-      entrypoints: [entry!],
+      entrypoints: [opts.entry],
       target: "browser",
       format: "esm",
-      minify: values.minify,
+      minify: opts.minify,
       external: ["flux:*", "srt:*"],
       define,
       loader: { ".svg": "text" },
-      plugins: [solidPlugin()],
+      sourcemap: opts.dev ? "external" : "none",
+      plugins: [solidPlugin(babelMaps)],
     })
   } catch (e) {
     console.error("[cli] compile error:\n", e)
     return null
   }
 
-  if (result?.success) {
-    return result
+  if (!result.success) {
+    for (let msg of result.logs) console.error(msg)
+    return null
   }
 
-  if (result) {
-    for (let msg of result?.logs) console.error(msg)
-  }
-  return null
+  return { code: await codeFromOutputs(result.outputs), map: await composeMap(result.outputs, babelMaps) }
+}
+
+// Compose Bun's bundle map (babel output -> bundle) with the per-file Babel
+// maps (original source -> babel output) so positions point at the .tsx
+// sources. Bun ignores sourcemaps in plugin onLoad contents, so this second
+// hop has to happen here. Only a single-artifact build gets a map: code
+// splitting is off, and concatenated artifacts would invalidate offsets.
+async function composeMap(outputs: BuildArtifact[], babelMaps?: Map<string, object>): Promise<string | null> {
+  if (!babelMaps) return null
+  let js = outputs.filter((o) => o.kind === "entry-point" || o.kind === "chunk")
+  if (js.length !== 1 || !js[0]!.sourcemap) return null
+  let bunMap = JSON.parse(await js[0]!.sourcemap.text())
+  let composed = remapping(bunMap, (file: string) => {
+    // Bun writes cwd-relative source paths; the babel maps are keyed by the
+    // absolute path. Serve each map exactly once: remapping asks again for a
+    // served map's own original source, and that lookup must return null.
+    let abs = resolvePath(file)
+    let map = babelMaps.get(abs)
+    babelMaps.delete(abs)
+    return (map as any) ?? null
+  })
+  return composed.toString()
+}
+
+export async function bundle(entry = source) {
+  let devBase = state.serverUrl ?? undefined
+  let dev = !!devBase || values.dev
+  // Keep stdout clean when the bundle itself is written to stdout.
+  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
+  return bundleWith({ entry: entry!, devBase, dev, minify: values.minify })
 }
 
 export async function bundleTo(outfile: string) {
@@ -125,7 +171,7 @@ export async function bundleTo(outfile: string) {
     console.error("Build failed")
     process.exit(1)
   }
-  await Bun.write(outfile, await codeFromOutputs(result.outputs))
+  await Bun.write(outfile, result.code)
   return result
 }
 
@@ -153,7 +199,7 @@ export async function bundleSolid(): Promise<string> {
     console.error("Build failed")
     process.exit(1)
   }
-  return codeFromOutputs(result.outputs)
+  return result.code
 }
 
 // Compile JS source to QuickJS bytecode via the fluxc binary.

package/src/commands/bundle.ts

@@ -1,5 +1,5 @@
 import { values, source, isPrebuilt } from "../args"
-import { bundle, bundleTo, bundleFlux, compileToBytecode, codeFromOutputs } from "../bundler"
+import { bundle, bundleTo, bundleFlux, compileToBytecode } from "../bundler"
 import { resolve } from "path"
 
 // Write to stdout and resolve only once the whole payload is flushed.
@@ -55,7 +55,7 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    await writeStdout(await codeFromOutputs(result.outputs))
+    await writeStdout(result.code)
     process.exit()
   }
 
@@ -65,15 +65,12 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    let jsCode = await codeFromOutputs(result.outputs)
-    await writeBytecode(jsCode, baseName + ".srt.bin")
+    await writeBytecode(result.code, baseName + ".srt.bin")
     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}`)
-  }
+  console.log(`>> wrote ${result.code.length} bytes to ${jsOutfile}`)
   process.exit()
 }

package/src/commands/mcp.ts

@@ -5,16 +5,25 @@
 //
 // stdout is the JSON-RPC channel; nothing here may print to it.
 
+import { z } from "zod"
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js"
 import { DEV_PORT } from "../dev-server"
 
 const CONTROL_BASE = `http://127.0.0.1:${DEV_PORT}/__control__`
 
 type ControlResult = { ok: true; body: any } | { ok: false; message: string }
 
-async function control(path: string): Promise<ControlResult> {
+async function control(path: string, method: "GET" | "POST" = "GET", payload?: unknown): Promise<ControlResult> {
   let resp
   try {
-    resp = await fetch(CONTROL_BASE + path)
+    let init: RequestInit = { method }
+    if (payload !== undefined) {
+      init.headers = { "content-type": "application/json" }
+      init.body = JSON.stringify(payload)
+    }
+    resp = await fetch(CONTROL_BASE + path, init)
   } catch {
     return {
       ok: false,
@@ -29,56 +38,110 @@ async function control(path: string): Promise<ControlResult> {
   return { ok: true, body }
 }
 
-let TOOLS = [
+let CLIENT_ARG = z
+  .number()
+  .int()
+  .describe("Client id from list_clients (default: the only connected client)")
+  .optional()
+
+let TOOLS: { name: string; description: string; inputSchema: Record<string, z.ZodTypeAny> }[] = [
   {
     name: "list_clients",
     description:
-      "List the app clients connected to the SolidRT dev server. Each entry has id (pass it as `client` to the other tools), platform, runtime version, and the capability names compiled into that client's runtime.",
-    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+      "List the app clients connected to the SolidRT dev server. Each entry has id (pass it as `client` to the other tools), platform, runtime version (git describe; a -dirty suffix means the binary was built from uncommitted engine changes), build profile (debug/release), and the capability names compiled into that client's runtime. Use version/profile to check whether a connected binary contains a given engine change before debugging against it.",
+    inputSchema: {},
   },
   {
     name: "get_logs",
     description:
       "Read console output and runtime errors from connected app clients. Returns entries (seq, at, client, level, text) plus `latest`, the newest seq. Pass `since` (a seq or `latest` from a previous call) to only get newer entries; pass `wait_ms` to hold the call until new output arrives, e.g. right after triggering a reload.",
     inputSchema: {
-      type: "object",
-      properties: {
-        since: {
-          type: "integer",
-          description: "Only return entries with seq greater than this (default 0: the whole buffer)",
-        },
-        wait_ms: {
-          type: "integer",
-          description: "If nothing is newer than `since`, wait up to this many milliseconds for new output (max 30000)",
-        },
-      },
-      additionalProperties: false,
+      since: z
+        .number()
+        .int()
+        .describe("Only return entries with seq greater than this (default 0: the whole buffer)")
+        .optional(),
+      wait_ms: z
+        .number()
+        .int()
+        .describe("If nothing is newer than `since`, wait up to this many milliseconds for new output (max 30000)")
+        .optional(),
     },
   },
   {
     name: "get_stats",
     description:
       "Performance statistics from a running app client: fps, CPU%, memory, smoothed JS/layout/paint/hover frame times (ms), setProperty writes per frame, demand-gate reuse/skip counts per second, and live texture count.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        client: { type: "integer", description: "Client id from list_clients (default: the only connected client)" },
-      },
-      additionalProperties: false,
-    },
+    inputSchema: { client: CLIENT_ARG },
   },
   {
     name: "get_render_tree",
     description:
       "Snapshot of a running app client's render tree: node id, kind, window-relative box (x, y, width, height), text content, and children. Use it to verify what the app actually rendered and where.",
+    inputSchema: { client: CLIENT_ARG },
+  },
+  {
+    name: "get_snapshot",
+    description:
+      "Capture a PNG image of any node in a running app client's render tree, by node id (get ids from get_render_tree). Returns the rendered pixels of that node's subtree, so you can see what the app actually drew. The node must be currently mounted and have a non-zero layout box.",
+    inputSchema: {
+      nodeId: z.number().int().describe("Id of the node to capture, from get_render_tree"),
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "get_gpu_resources",
+    description:
+      "Inventory of a running app client's GPU resources: textures (id, size, whether a shader renders into it), vertex buffers (id, byteLength), and shader/pipeline targets (output textureId, kind, bufferId, topology, drawCount, depth, attribute layout, bound sampler texture ids, last-applied uniform values). Use it when the render tree is just a <texture> leaf and the interesting state lives behind it; follow up with get_texture or get_buffer to see contents.",
+    inputSchema: { client: CLIENT_ARG },
+  },
+  {
+    name: "get_texture",
+    description:
+      "Read back any GPU texture from a running app client as a PNG, by texture id (from get_gpu_resources, or the id returned by createImage/createShader/createPipeline in app code). Works on sampled textures (atlases, data textures) and shader/pipeline render targets alike, without needing a frame. Pass x/y/width/height to crop, e.g. one tile of an atlas.",
+    inputSchema: {
+      id: z.number().int().describe("Texture id, from get_gpu_resources"),
+      x: z.number().int().describe("Crop rect left edge in texture pixels (requires y, width, height)").optional(),
+      y: z.number().int().describe("Crop rect top edge in texture pixels").optional(),
+      width: z.number().int().describe("Crop rect width in texture pixels").optional(),
+      height: z.number().int().describe("Crop rect height in texture pixels").optional(),
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "get_buffer",
+    description:
+      "Read back part of a GPU vertex buffer from a running app client, decoded to numbers. Returns values plus byteOffset/byteLength actually read and bufferByteLength. Reads are capped at 64 KiB per call; page through larger buffers with offset. Use it to verify geometry after a writeBuffer, e.g. the dynamic sprite tail of a vertex buffer.",
+    inputSchema: {
+      id: z.number().int().describe("Buffer id, from get_gpu_resources"),
+      offset: z.number().int().describe("Byte offset to start reading at (default 0)").optional(),
+      length: z.number().int().describe("Number of values to read (default: the rest of the buffer, capped)").optional(),
+      as: z.enum(["f32", "u16", "u8"]).describe("How to decode the bytes (default f32)").optional(),
+      client: CLIENT_ARG,
+    },
+  },
+  {
+    name: "list_debug",
+    description:
+      "List the debug commands the running app registered via registerDebug from srt:dev. Returns the command names; call one with call_debug. Empty when the app registered none.",
+    inputSchema: { client: CLIENT_ARG },
+  },
+  {
+    name: "call_debug",
+    description:
+      "Call a debug command the running app registered via registerDebug from srt:dev, by name (from list_debug). `args` is passed to the command's function as its single argument; the command's return value comes back JSON-serialized (undefined as null). Commands run synchronously on the app's JS thread - use them to query app state (positions, counters, internal flags) or trigger app behavior (toggle a mode, open a door) without touching its real input handling.",
     inputSchema: {
-      type: "object",
-      properties: {
-        client: { type: "integer", description: "Client id from list_clients (default: the only connected client)" },
-      },
-      additionalProperties: false,
+      name: z.string().describe("Debug command name, from list_debug"),
+      args: z.record(z.string(), z.any()).describe("Argument object passed to the command (default: none)").optional(),
+      client: CLIENT_ARG,
     },
   },
+  {
+    name: "reload",
+    description:
+      "Rebuild the app from source and push it to every connected client. Call this after editing the app's .tsx/.jsx source to apply the changes: it bundles once and reloads all clients, so a burst of edits becomes a single explicit reload. Returns the number of clients reloaded, or a build error if the source failed to compile. Follow with get_logs to see runtime output from the reloaded app.",
+    inputSchema: {},
+  },
 ]
 
 function clientParam(args: any): string {
@@ -100,27 +163,72 @@ async function callTool(name: string, args: any): Promise<ControlResult> {
       return control(`/stats${clientParam(args)}`)
     case "get_render_tree":
       return control(`/tree${clientParam(args)}`)
+    case "reload":
+      return control("/reload", "POST")
+    case "get_snapshot": {
+      if (typeof args?.nodeId !== "number") return { ok: false, message: "get_snapshot requires a numeric nodeId" }
+      let params = new URLSearchParams({ node: String(args.nodeId) })
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/snapshot?${params.toString()}`)
+    }
+    case "get_gpu_resources":
+      return control(`/gpu${clientParam(args)}`)
+    case "list_debug":
+      return control(`/debug${clientParam(args)}`)
+    case "call_debug": {
+      if (typeof args?.name !== "string") return { ok: false, message: "call_debug requires a command name" }
+      let params = new URLSearchParams({ name: args.name })
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/debug?${params.toString()}`, "POST", args?.args)
+    }
+    case "get_texture": {
+      if (typeof args?.id !== "number") return { ok: false, message: "get_texture requires a numeric id" }
+      let params = new URLSearchParams({ id: String(args.id) })
+      for (let key of ["x", "y", "width", "height"]) {
+        if (typeof args?.[key] === "number") params.set(key, String(args[key]))
+      }
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/texture?${params.toString()}`)
+    }
+    case "get_buffer": {
+      if (typeof args?.id !== "number") return { ok: false, message: "get_buffer requires a numeric id" }
+      let params = new URLSearchParams({ id: String(args.id) })
+      if (typeof args?.offset === "number") params.set("offset", String(args.offset))
+      if (typeof args?.length === "number") params.set("length", String(args.length))
+      if (typeof args?.as === "string") params.set("as", args.as)
+      if (typeof args?.client === "number") params.set("client", String(args.client))
+      return control(`/buffer?${params.toString()}`)
+    }
     default:
       return { ok: false, message: `Unknown tool: ${name}` }
   }
 }
 
-export async function runMcpCommand() {
-  let { Server } = await import("@modelcontextprotocol/sdk/server/index.js")
-  let { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js")
-  let { ListToolsRequestSchema, CallToolRequestSchema } = await import("@modelcontextprotocol/sdk/types.js")
-
-  let server = new Server({ name: "solidrt", version: "0.0.0" }, { capabilities: { tools: {} } })
+function toContent(name: string, result: ControlResult): CallToolResult {
+  if (!result.ok) return { content: [{ type: "text", text: result.message }], isError: true }
+  if (name === "get_snapshot" || name === "get_texture") {
+    let { pngBase64, width, height } = result.body
+    let label = name === "get_snapshot" ? "Captured node snapshot" : "Texture contents"
+    return {
+      content: [
+        { type: "image", data: pngBase64, mimeType: "image/png" },
+        { type: "text", text: `${label}: ${width}x${height} px` },
+      ],
+    }
+  }
+  return { content: [{ type: "text", text: JSON.stringify(result.body, null, 2) }] }
+}
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }))
+export async function runMcpCommand() {
+  let server = new McpServer({ name: "solidrt", version: "0.0.0" })
 
-  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
-    let result = await callTool(request.params.name, request.params.arguments ?? {})
-    if (!result.ok) {
-      return { content: [{ type: "text", text: result.message }], isError: true }
-    }
-    return { content: [{ type: "text", text: JSON.stringify(result.body, null, 2) }] }
-  })
+  for (let tool of TOOLS) {
+    server.registerTool(
+      tool.name,
+      { description: tool.description, inputSchema: tool.inputSchema },
+      async (args: any) => toContent(tool.name, await callTool(tool.name, args ?? {})),
+    )
+  }
 
   // The stdin read keeps the process alive; it exits when the agent host
   // closes the pipe.

package/src/commands/server.ts

@@ -1,45 +1,41 @@
 import pkg from "../../package.json"
 import { source, isSource, isPrebuilt, values } from "../args"
 import { state, shutdown } from "../util"
-import { bundle, codeFromOutputs } from "../bundler"
-import { startServer, showBuildFailure } from "../dev-server"
+import { bundle } from "../bundler"
+import { startServer, buildReload, sendReload, showBuildFailure } from "../dev-server"
 import { startRepl } from "../repl"
 import { startWatcher } from "../watcher"
-import * as cache from "../cache"
 import { resolve, dirname } from "path"
-import { writeFileSync } from "node:fs"
 
-// Brings up the dev server (HTTP/WS + initial bundle + repl + watcher). The
-// `run` command spawns a local client on top of this from main.ts.
+// 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()
   state.stats = values.stats
   state.capture = values.capture ? resolve(values.capture) : undefined
-  state.captureStartMs = Date.now()
-  // Start each capture from an empty file: appendFileSync (dev-server.ts)
-  // would otherwise tack onto whatever a previous run left behind.
-  if (state.capture) writeFileSync(state.capture, "")
 
-  if (values["proxy-http"]) {
-    cache.initCache({ dir: process.cwd() })
-    console.log("[cli] HTTP cache enabled")
-  }
-
-  startServer()
+  // 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).
+  // 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 = await codeFromOutputs(initialResult.outputs)
+      state.currentCode = initialResult.code
+      state.currentMap = initialResult.map
+      await sendReload(buildReload({ code: state.currentCode }), { latch: true, map: state.currentMap })
     } else {
-      showBuildFailure()
+      await showBuildFailure()
     }
   } else if (source && isPrebuilt && source.endsWith(".srt.js")) {
     state.currentCode = await Bun.file(resolve(source)).text()
+    await sendReload(buildReload({ code: state.currentCode }), { latch: true })
   }
 
   process.on("SIGINT", shutdown)
@@ -49,4 +45,4 @@ export async function runServerCommand() {
   console.log(`[cli] Welcome to SolidRT${version}!`)
   startRepl()
   startWatcher()
-}
+}

package/src/dev-client.ts

@@ -1,20 +1,7 @@
-import { state, print, requireBinary } from "./util"
-import { DEV_HOST, DEV_PORT } from "./dev-server"
+import { state, print, requireBinary, pipeAbovePrompt, shutdown } from "./util"
+import { DEV_HOST, DEV_PORT, getClients, shutdownWhenEmpty } from "./dev-server"
 import { values } from "./args"
 
-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")
   // The local client and dev server share this machine, so connect straight to
@@ -30,11 +17,13 @@ export function spawnClient() {
   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)
+  state.child.exited.then(async () => {
+    let clients = await getClients().catch(() => [])
+    if (clients.length === 0) {
+      shutdown()
     }
-    print(`[cli] Local client exited, ${state.clients.size} remote client(s) still connected`)
+    print(`[cli] Local client exited, ${clients.length} remote client(s) still connected`)
+    // From here, exit once the last remote client disconnects.
+    shutdownWhenEmpty()
   })
-}
+}