@solidrt/cli 0.0.50 → 0.0.52

package/src/main.ts

@@ -1,15 +1,32 @@
 #!/usr/bin/env bun
 
-import { values, command, validateArgs, printUsage } from "./args"
-import { runInitCommand } from "./commands/init"
-import { runBundleCommand } from "./commands/bundle"
-import { runCheckCommand } from "./commands/check"
-import { runPackCommand } from "./commands/pack"
-import { runRenderCommand } from "./commands/render"
-import { runServerCommand } from "./commands/server"
-import { runClientCommand } from "./commands/client"
-import { runMcpCommand } from "./commands/mcp"
-import { spawnClient } from "./dev-client"
+// bin/srt lands here. This file routes the command word and nothing else:
+// the bun commands live one folder each (src/<command>/main.ts) and load on
+// demand, and `run`/`server` launch the flux dev server (src/server/), a
+// process complete on its own that this launcher only resolves the binaries
+// for (okf/done/srt-command-folders.md).
+
+import { fileURLToPath } from "node:url"
+import { existsSync, unlinkSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, resolve } from "node:path"
+import { values, command, source, port, appArgs, validateArgs } from "./lib/args"
+import { printUsage, printVersion, hint } from "./lib/usage"
+import { requireBinary } from "./lib/util"
+import { buildServerBundle } from "./lib/server-bundle"
+
+// -- Help and version --
+
+// Answered before anything else: neither takes a command, so they must not
+// fall through to the usage error.
+if (values.help) {
+  printUsage()
+  process.exit(0)
+}
+if (values.version) {
+  printVersion()
+  process.exit(0)
+}
 
 // -- Validate args --
 
@@ -36,28 +53,89 @@ if (isProdBuild && process.env.NODE_ENV !== "production") {
   process.exit(proc.exitCode ?? 0)
 }
 
+// -- run / server: launch the dev server --
+
+// The server script the flux binary runs: the prebuilt bundle a published
+// CLI ships, or (in a checkout) one built now into a temp file, removed on
+// exit.
+async function serverScript(): Promise<{ path: string; temp: boolean }> {
+  let prebuilt = fileURLToPath(new URL("../dist/server.js", import.meta.url))
+  if (existsSync(prebuilt)) return { path: prebuilt, temp: false }
+  let outfile = resolve(tmpdir(), `srt-dev-server-${process.pid}.js`)
+  await buildServerBundle(outfile)
+  return { path: outfile, temp: true }
+}
+
+// `demo` serves a demos project the same way `run` serves any other one:
+// the entry is resolved for the caller (src/demo/main.ts) and the server is
+// started IN that project, so mode.ts resolves it as a project and its
+// assets/ folder is served like any app's.
+async function launchServer(withClient: boolean, demo?: { cwd: string; entry: string }) {
+  let flux = requireBinary("flux")
+  let script = await serverScript()
+
+  let args: string[] = []
+  if (demo) {
+    args.push(demo.entry, "--project")
+  } else {
+    if (source !== undefined) args.push(source)
+    if (values.project) args.push("--project")
+    if (values.file) args.push("--file")
+  }
+  if (port !== undefined) args.push("--port", String(port))
+  for (let flag of ["lan", "proxy-http", "tunnel", "stats", "minify"] as const) {
+    if (values[flag]) args.push(`--${flag}`)
+  }
+  if (values.capture) args.push("--capture", values.capture)
+  if (withClient) {
+    args.push("--client", values.client ?? "0")
+    if (values["data-root"]) args.push("--data-root", values["data-root"])
+    if (values.size) args.push("--size", values.size)
+  }
+  if (appArgs.length) args.push("--", ...appArgs)
+
+  let proc = Bun.spawn([flux, script.path, ...args], {
+    cwd: demo?.cwd,
+    // stdin is passed through for the server's repl (flux:tty): with no
+    // terminal there the server runs without one.
+    stdio: ["inherit", "inherit", "inherit"],
+    env: {
+      ...process.env,
+      SRT_PLATFORM_DIR: dirname(flux),
+      SRT_BUN: process.execPath,
+      SRT_CLI: fileURLToPath(new URL("..", import.meta.url)),
+    },
+  })
+  // The server ends itself on these (drops its record, stops the client);
+  // this process just relays them and waits.
+  let relay = () => proc.kill("SIGTERM")
+  process.on("SIGINT", relay)
+  process.on("SIGTERM", relay)
+  let code = await proc.exited
+  if (script.temp) {
+    try {
+      unlinkSync(script.path)
+    } catch {}
+  }
+  process.exit(code)
+}
+
 // -- Dispatch --
 
-if (command === "init") {
-  await runInitCommand()
-} else if (command === "bundle") {
-  await runBundleCommand()
-} else if (command === "check") {
-  await runCheckCommand()
-} else if (command === "pack") {
-  await runPackCommand()
-} else if (command === "render") {
-  await runRenderCommand()
-} else if (command === "client") {
-  await runClientCommand()
-} else if (command === "server") {
-  await runServerCommand()
+const COMMANDS = ["init", "bundle", "check", "pack", "render", "client", "console", "android", "mcp", "tool"] as const
+type Command = (typeof COMMANDS)[number]
+
+if (command === "server") {
+  await launchServer(false)
 } else if (command === "run") {
-  await runServerCommand()
-  spawnClient()
-} else if (command === "mcp") {
-  await runMcpCommand()
+  await launchServer(true)
+} else if (command === "demo") {
+  let { main } = await import("./demo/main")
+  let target = await main()
+  if (target) await launchServer(true, target)
+} else if (command !== undefined && (COMMANDS as readonly string[]).includes(command)) {
+  let { main } = await import(`./${command as Command}/main`)
+  await main()
 } else {
-  printUsage()
-  process.exit(1)
-}
+  hint(command === undefined ? undefined : `Unknown command "${command}"`)
+}

package/src/mcp/docs.md

@@ -0,0 +1,22 @@
+# srt mcp
+
+{{ usage mcp }}
+
+Exposes the running app to a coding agent over MCP: logs (source-mapped back
+to your TSX), stats (and the on-screen overlay), the live render tree,
+screenshots and texture readback, GPU resources, input injection, a
+virtual-time transport (`step_frames`, `set_time_scale`), reload and load, a
+mute on the user's own input while the agent measures or tests
+(`mute_user_input`/`unmute_user_input`), a pause on reload-on-save while it
+edits (`pause_watch`/`resume_watch`), and any debug commands the app itself
+registers.
+A scaffolded project ships an `.mcp.json`, so Claude Code attaches to your
+running app with no setup. Other agents keep their server list in their own
+file; point it at `bun node_modules/@solidrt/cli/bin/srt mcp`, run from the
+project root (agents/debugging.md in this package lists the file per client).
+
+That connection is why SolidRT keeps the app inspectable from outside: an
+agent working on your app should be able to look at what it is actually
+doing, not just at the source. Every tool is a thin wrapper over the dev
+server's HTTP control API, so a shell script or a CI step can do the same
+without MCP (agents/debugging.md).