@solidrt/cli 0.0.51 → 0.0.52

package/server/main.ts

@@ -1,308 +0,0 @@
-// The srt dev server as a flux script. srt (Bun) spawns this with one JSON
-// config argument; bundling, file watching, and the repl stay in srt, which
-// drives this process over the loopback-only /__internal__/ routes. The
-// shutdown-when-empty policy also lives in srt (it polls /__internal__/clients);
-// this process runs until srt kills it.
-
-import { serve } from "flux:http"
-import type { FluxRequest, Server } from "flux:http"
-import { file } from "flux:fs"
-import { argv } from "flux:process"
-import { resolveWithin } from "flux:path"
-import { state, type Config } from "./state"
-import * as cache from "./cache"
-import { handleProxy } from "./proxy"
-import { appendLog, clientList, handleControl, resolveQuery } from "./control"
-import { printQr } from "./qr"
-import { createTunnelEndpoint, TUNNEL_PROTOCOL } from "./tunnel"
-
-let config: Config = JSON.parse(argv[0]!)
-state.config = config
-state.sourceDir = config.sourceDir
-state.projectDir = config.projectDir
-state.stats = config.stats
-state.serverUrl = `${config.address}:${config.port}`
-
-if (config.cache) {
-  await cache.initCache({ dir: config.cacheDir })
-  console.log("[cli] HTTP cache enabled")
-}
-
-if (config.capture) {
-  // Start each capture from an empty file: appends would otherwise tack onto
-  // whatever a previous run left behind.
-  await file(config.capture).write("")
-  state.captureStartMs = Date.now()
-}
-
-// Split an origin-form request URL ("/path?a=1&b=2") into its decoded path and
-// query parameters. flux has no URL global; this covers what the routes need.
-function splitQuery(url: string): { path: string; query: Map<string, string> } {
-  let i = url.indexOf("?")
-  let path = i < 0 ? url : url.slice(0, i)
-  let query = new Map<string, string>()
-  if (i >= 0) {
-    for (let pair of url.slice(i + 1).split("&")) {
-      if (!pair) continue
-      let j = pair.indexOf("=")
-      let k = j < 0 ? pair : pair.slice(0, j)
-      let v = j < 0 ? "" : pair.slice(j + 1)
-      query.set(decodeURIComponent(k), decodeURIComponent(v.replace(/\+/g, " ")))
-    }
-  }
-  return { path: decodeURIComponent(path), query }
-}
-
-// Send `text` to the clients with the given ids, or to every client when
-// `ids` is omitted.
-function sendTo(ids: number[] | undefined, text: string) {
-  for (let [ws, info] of state.clients) {
-    if (!ids || ids.includes(info.id)) ws.send(text)
-  }
-}
-
-// The srt -> server IPC under /__internal__/: only the srt process on this
-// machine may drive it, so reject any peer that is not loopback.
-async function handleInternal(req: FluxRequest, server: Server, path: string): Promise<Response> {
-  let ip = server.requestIP(req)
-  let loopback = ip && (ip.address === "127.0.0.1" || ip.address === "::1" || ip.address === "::ffff:127.0.0.1")
-  if (!loopback) return new Response("Forbidden", { status: 403 })
-
-  if (path === "/__internal__/clients") return Response.json(clientList(true))
-  if (path === "/__internal__/watch" && req.method === "GET") return Response.json({ enabled: state.watch })
-  if (req.method !== "POST") return new Response("Method not allowed", { status: 405 })
-
-  switch (path) {
-    case "/__internal__/reload": {
-      // { message, clients?, latch?, sourceDir?, maps? }: send `message` (a
-      // full client-protocol message, built by srt) to the listed client ids,
-      // or to all when omitted. `latch` keeps it for late-joining clients
-      // (code reloads latch, one-shot bytecode loads do not); `sourceDir`
-      // moves the file-serving root (repl `load`; the project root - and with
-      // it the /assets/ root - is fixed for the life of the run); `maps` is
-      // the bundle's sourcemaps keyed by module name for log remapping,
-      // replaced on every reload (absent means none).
-      let body = await req.json()
-      if (typeof body.sourceDir === "string") state.sourceDir = body.sourceDir
-      // Keep the rebuild entry in sync when `load` moves it, so a later MCP
-      // reload bundles the newly loaded file, not the launch-time one.
-      if (typeof body.entry === "string") state.config.entry = body.entry
-      state.currentMaps = body.maps && typeof body.maps === "object" ? body.maps : null
-      let text = JSON.stringify(body.message)
-      if (body.latch) state.currentReload = text
-      sendTo(body.clients, text)
-      return new Response("", { status: 204 })
-    }
-    case "/__internal__/stop": {
-      let body = await req.json()
-      // A broadcast stop also forgets the latched reload, so a client that
-      // connects afterwards starts clean.
-      if (!body.clients) {
-        state.currentReload = null
-        state.currentMaps = null
-      }
-      sendTo(body.clients, JSON.stringify({ type: "stop" }))
-      return new Response("", { status: 204 })
-    }
-    case "/__internal__/watch": {
-      // The repl's `watch on|off`; agents use /__control__/watch instead.
-      let body = await req.json()
-      state.watch = !!body.enabled
-      return new Response("", { status: 204 })
-    }
-    case "/__internal__/stats": {
-      let body = await req.json()
-      state.stats = !!body.stats
-      sendTo(undefined, JSON.stringify({ type: "stats", stats: state.stats }))
-      return new Response("", { status: 204 })
-    }
-    default:
-      return Response.json({ error: "Unknown internal endpoint" }, { status: 404 })
-  }
-}
-
-// The file routes: GET file with single-range 206 support. All paths are
-// contained in `root` (the source directory, or the project dir for the
-// /assets/ convention route).
-async function handleFiles(req: FluxRequest, path: string, root: string): Promise<Response> {
-  let filePath = resolveWithin(root, "." + path)
-  if (!filePath) {
-    return new Response("Forbidden", { status: 403 })
-  }
-
-  console.log("[cli] get " + path)
-
-  let stat
-  try {
-    stat = await file(filePath).stat()
-  } catch {
-    console.log(`[cli] file not found ${path}`)
-    return new Response("Not found", { status: 404 })
-  }
-  if (stat.type === "directory") {
-    return new Response("Not found", { status: 404 })
-  }
-
-  let baseHeaders: Record<string, string> = { "Accept-Ranges": "bytes" }
-
-  // Honor a single byte-range request (e.g. streaming audio decoding on the
-  // client, which seeks and reads on demand). Only the common "bytes=a-b" /
-  // "bytes=a-" / "bytes=-n" forms; anything else falls through to the whole
-  // file. Range makes proxied streaming viable without pulling the whole
-  // track over the wire.
-  let range = req.headers.get("range")
-  let match = range ? /^bytes=(\d*)-(\d*)$/.exec(range.trim()) : null
-  if (match) {
-    let size = stat.size
-    let start: number
-    let end: number
-    if (match[1] === "") {
-      // Suffix range: the last N bytes.
-      let n = parseInt(match[2]!, 10)
-      start = isNaN(n) ? 0 : Math.max(0, size - n)
-      end = size - 1
-    } else {
-      start = parseInt(match[1]!, 10)
-      end = match[2] === "" ? size - 1 : Math.min(parseInt(match[2]!, 10), size - 1)
-    }
-    if (start > end || start >= size) {
-      return new Response("Range not satisfiable", {
-        status: 416,
-        headers: { ...baseHeaders, "Content-Range": `bytes */${size}` },
-      })
-    }
-    return new Response(await file(filePath).read(start, end - start + 1), {
-      status: 206,
-      headers: {
-        ...baseHeaders,
-        "Content-Range": `bytes ${start}-${end}/${size}`,
-        "Content-Length": String(end - start + 1),
-      },
-    })
-  }
-
-  return new Response(await file(filePath).bytes(), { headers: baseHeaders })
-}
-
-// Ticket-paired clients connect through this endpoint; serve() accepts its
-// connections directly alongside the TCP listener.
-let tunnel = config.tunnel ? await createTunnelEndpoint(config.port, config.keyDir) : null
-
-serve({
-  port: config.port,
-  p2p: tunnel ? { endpoint: tunnel, protocol: TUNNEL_PROTOCOL } : undefined,
-  async fetch(req, server) {
-    if (server.upgrade(req)) return
-
-    let { path, query } = splitQuery(req.url)
-
-    if (path === "/__proxy__") {
-      return handleProxy(req)
-    }
-    if (path.startsWith("/__control__/")) {
-      return handleControl(req, path, query)
-    }
-    if (path.startsWith("/__internal__/")) {
-      return handleInternal(req, server, path)
-    }
-    // The assets/ convention roots at the project dir (package.json), which is
-    // not necessarily the entry's dir the file routes serve; clients fetch
-    // manifest asset paths here (live proxy reads and store installs alike).
-    if (path === "/assets" || path.startsWith("/assets/")) {
-      return handleFiles(req, path, state.projectDir)
-    }
-    // Isolate bundles are build outputs, not project files: srt (and the
-    // rebuild here) write them under .srt-data/isolates/, and the manifest
-    // lists them as isolates/<id>.js.
-    if (path.startsWith("/isolates/")) {
-      return handleFiles(req, path, config.cacheDir)
-    }
-    return handleFiles(req, path, state.sourceDir)
-  },
-  websocket: {
-    open(ws) {
-      let id = state.nextClientId++
-      state.clients.set(ws, {
-        platform: "unknown",
-        version: "unknown",
-        profile: "unknown",
-        id,
-        capabilities: [],
-        queries: [],
-      })
-      console.log(`[cli] Client connected ${ws.remoteAddr ?? "unknown"}`)
-      // Advertise our real LAN address so clients dialed over a loopback hop
-      // can show/remember the directly reachable address (see connection.rs).
-      ws.send(
-        JSON.stringify({ type: "welcome", address: state.serverUrl, stats: state.stats, capture: !!config.capture }),
-      )
-      if (state.currentReload) {
-        ws.send(state.currentReload)
-      }
-    },
-    close(ws) {
-      let info = state.clients.get(ws)
-      state.clients.delete(ws)
-      console.log(`[cli] Client disconnected: ${info?.platform ?? "unknown"}`)
-    },
-    message(ws, msg) {
-      try {
-        let data = JSON.parse(typeof msg === "string" ? msg : new TextDecoder().decode(msg))
-        if (data.type === "info") {
-          let existing = state.clients.get(ws)
-          state.clients.set(ws, {
-            platform: data.platform ?? "unknown",
-            version: data.version ?? "unknown",
-            profile: data.profile ?? "unknown",
-            id: existing?.id ?? state.nextClientId++,
-            capabilities: Array.isArray(data.capabilities) ? data.capabilities.map(String) : [],
-            queries: Array.isArray(data.queries) ? data.queries.map(String) : [],
-          })
-          console.log(`[cli] Client info ${ws.remoteAddr ?? "unknown"} ${data.platform} (${data.version})`)
-        } else if (data.type === "log") {
-          // Forwarded console output / runtime errors from the client's
-          // engine logger, buffered for the control API (see control.ts).
-          // Not printed here: the local client already writes to this
-          // terminal, so echoing would duplicate every line.
-          let device = state.clients.get(ws)?.id ?? -1
-          appendLog(device, String(data.level ?? "log"), String(data.text ?? ""))
-        } else if (data.type === "result") {
-          // Reply to a query the control API forwarded to this client.
-          resolveQuery(data)
-        } else if (data.type === "capture" && config.capture) {
-          let device = state.clients.get(ws)?.id ?? -1
-          // Milliseconds, integer: Date.now() is already integer ms, so the
-          // delta needs no rounding.
-          let at = Date.now() - state.captureStartMs
-          let after = at - state.captureLastAt
-          state.captureLastAt = at
-          // JSON Lines: one event object per line, streamed to disk as it
-          // arrives rather than buffered - no in-memory growth for a long
-          // capture, and the file is always complete on disk mid-session.
-          // Appends are chained so events land in arrival order.
-          let line = JSON.stringify({ after, type: data.kind, key: data.key, device }) + "\n"
-          state.captureChain = state.captureChain.then(() => file(config.capture!).append(line))
-        }
-      } catch {}
-    },
-  },
-})
-
-// One QR on screen: with the tunnel on, the ticket QR (printed by
-// createTunnelEndpoint) is the pairing story and the address stays text-only;
-// without it, the address QR is the scan target as before.
-if (!config.tunnel) {
-  console.log("")
-  printQr(state.serverUrl)
-  console.log("")
-}
-console.log(`[cli] WebSocket server on ws://${state.serverUrl}`)
-// mDNS advertise is intentionally not implemented here: the p2p ticket is the
-// cross-device connect story (see okf/backlog/mdns-discovery.md).
-
-// Keepalive
-setInterval(() => {
-  for (let ws of state.clients.keys()) {
-    ws.ping()
-  }
-}, 5000)

package/server/rebuild.ts

@@ -1,76 +0,0 @@
-import { command } from "flux:subprocess"
-import { dir, file } from "flux:fs"
-import { state } from "./state"
-
-// Server-owned "rebuild and push": the single place the running app is rebuilt
-// from source on demand (an MCP reload). The srt repl still bundles in-process
-// for its own keystroke reloads, but both routes call the same bundle-cli, so
-// the bundling logic cannot drift. Making the server the rebuild authority is
-// the interim step toward folding the whole CLI into flux (see
-// okf/backlog/cli-flux-migration.md).
-
-// Build the reload message the same way srt's buildReload does, so a
-// server-triggered reload is indistinguishable from a repl-triggered one to
-// clients. proxyHttp is a message flag, not a build input.
-function buildReload(code: string, manifest?: string) {
-  let config = state.config
-  return {
-    type: "reload",
-    proxyHttp: config.proxyHttp,
-    args: config.args,
-    ...(manifest ? { manifest } : {}),
-    code,
-  }
-}
-
-// Rebuild from state.config.entry via the external bundle-cli subprocess, then
-// latch (for late-joining clients) and broadcast the reload to every connected
-// client. Resolves with an error message on failure (no entry configured, or a
-// build error), or null on success.
-export async function rebuildAndBroadcast(): Promise<string | null> {
-  let config = state.config
-  if (!config.entry) {
-    return "No app entry to rebuild. Start srt with a source file (srt run src/index.tsx)."
-  }
-
-  let params = JSON.stringify({
-    entry: config.entry,
-    devBase: state.serverUrl,
-    dev: true,
-    minify: config.minify,
-  })
-
-  let result = await command(config.bundlerCmd[0]!, [...config.bundlerCmd.slice(1), params]).output()
-  if (!result.success) {
-    let stderr = typeof result.stderr === "string" ? result.stderr : ""
-    return `Rebuild failed:\n${stderr.trim()}`
-  }
-
-  // bundle-cli writes one JSON object { code, map, manifest, isolates } to stdout.
-  let bundle: {
-    code?: string
-    map?: string | null
-    manifest?: string
-    isolates?: { id: string; code: string; map?: string | null }[]
-  }
-  try {
-    bundle = JSON.parse(typeof result.stdout === "string" ? result.stdout : "")
-  } catch {
-    return "Rebuild failed: unreadable bundler output"
-  }
-  // Isolate bundles are manifest assets clients fetch from our /isolates/
-  // route (served from cacheDir), so they must be on disk before the push.
-  let maps: Record<string, string> = {}
-  if (bundle.map) maps.main = bundle.map
-  for (let isolate of bundle.isolates ?? []) {
-    let path = `${config.cacheDir}/isolates/${isolate.id}.js`
-    await dir(path.slice(0, path.lastIndexOf("/"))).create()
-    await file(path).write(isolate.code)
-    if (isolate.map) maps[isolate.id] = isolate.map
-  }
-  state.currentMaps = Object.keys(maps).length ? maps : null
-  let text = JSON.stringify(buildReload(bundle.code ?? "", bundle.manifest))
-  state.currentReload = text
-  for (let ws of state.clients.keys()) ws.send(text)
-  return null
-}

package/server/state.ts

@@ -1,94 +0,0 @@
-// Server-side state shared by the route handlers. The srt process keeps the
-// bundler, watcher, and repl; this state is only what the protocol needs.
-
-import type { ServerWebSocket } from "flux:http"
-
-export type Config = {
-  port: number
-  /** Directory served by the file routes (updatable via /__internal__/reload). */
-  sourceDir: string
-  /** Project root whose assets/ folder the /assets/ route serves (updatable
-   * via /__internal__/reload, moves with the repl `load`). */
-  projectDir: string
-  /** The address clients can reach this machine on (LAN IP or 127.0.0.1). */
-  address: string
-  proxyHttp: boolean
-  /** The app entry (absolute .tsx/.jsx path) the server rebuilds on an
-   * MCP-triggered reload, or undefined when srt was started without a source.
-   * Moved by the repl `load` command via /__internal__/reload. */
-  entry?: string
-  /** The session's app arguments (the srt command-line tail after a bare
-   * "--"), included in every reload push as flux:process argv. */
-  args: string[]
-  /** Minify the rebuild output, mirroring the srt --minify flag. */
-  minify: boolean
-  /** How the server invokes the external bundler: [bunPath, bundleCliPath],
-   * spawned with a JSON params argument appended (see rebuild.ts). */
-  bundlerCmd: string[]
-  /** Enable the sqlite-backed proxy cache. */
-  cache: boolean
-  /** Directory holding the proxy cache db (the project-local .srt-data). */
-  cacheDir: string
-  /** Directory holding tunnel.key (the server's ~/.solidrt/servers/<port>/ folder). */
-  keyDir: string
-  /** Destination for captured key events, or unset when off. */
-  capture?: string
-  stats: boolean
-  /** Accept ticket-paired clients through the p2p tunnel. */
-  tunnel: boolean
-}
-
-export type ClientInfo = {
-  platform: string
-  version: string
-  profile: string
-  id: number
-  capabilities: string[]
-  /** Query kinds this client's runtime answers (empty on runtimes that predate
-   * the advertisement); dev tools plan their verification surface from it. */
-  queries: string[]
-}
-
-export let state = {
-  config: undefined as unknown as Config,
-  clients: new Map<ServerWebSocket, ClientInfo>(),
-  nextClientId: 0,
-  /**
-   * Identity of this server run, included in control responses that carry
-   * cross-call state (client ids, log seq cursors). Both reset on restart, so
-   * a consumer that sees the generation change knows its ids and cursors are
-   * from a dead server and must be re-fetched.
-   */
-  generation: Date.now(),
-  /**
-   * The latched reload message (JSON text), replayed to late-joining clients.
-   * Set by /__internal__/reload posts with `latch`, cleared by a broadcast stop.
-   */
-  currentReload: null as string | null,
-  /**
-   * The running bundle's sourcemaps (JSON text, bundle -> .tsx sources),
-   * keyed by the module name stack frames cite ("main" for the app, the
-   * isolate id for each isolate), used to remap stack traces in forwarded
-   * client logs (see control.ts). Replaced on every reload; a reload without
-   * maps clears them so frames are never remapped against a stale map.
-   */
-  currentMaps: null as Record<string, string> | null,
-  sourceDir: "",
-  projectDir: "",
-  serverUrl: "",
-  stats: false,
-  /**
-   * Whether srt's file watcher may auto-reload on source changes. Agents
-   * pause it (MCP watch tool -> /__control__/watch) while creating or
-   * editing files; a successful /reload or /load re-enables it. srt reads
-   * it via /__internal__/watch before acting on a change event.
-   */
-  watch: true,
-  // Capture events from all connected clients share one clock (captureStartMs,
-  // integer milliseconds) so they merge into one coherent timeline, tagged by
-  // `device`. Streamed to disk as JSON Lines - see main.ts's "capture" handling.
-  captureStartMs: 0,
-  captureLastAt: 0, // ms, same clock as captureStartMs
-  /** Serializes capture appends so events land on disk in arrival order. */
-  captureChain: Promise.resolve(),
-}