@solidrt/cli 0.0.48 → 0.0.50

package/src/commands/pack.ts

@@ -41,8 +41,12 @@ export async function runPackCommand() {
   let fonts = resolvePackFonts(source!)
   console.log(`>> fonts: ${fonts.length ? fonts.map((f) => f.alias).join(", ") : "none"}`)
 
-  let bytecode = await compileToBytecode(await bundleSolid())
-  let folder = buildPackFolder(source!, bytecode)
+  let bundled = await bundleSolid()
+  let bytecode = await compileToBytecode(bundled.code)
+  let isolates = []
+  for (let i of bundled.isolates) isolates.push({ id: i.id, bytecode: await compileToBytecode(i.code) })
+  if (isolates.length) console.log(`>> isolates: ${isolates.map((i) => i.id).join(", ")}`)
+  let folder = buildPackFolder(source!, bytecode, isolates)
 
   if (values.folder) {
     let outDir = values.output ?? "dist"

package/src/commands/server.ts

@@ -16,7 +16,10 @@ export async function runServerCommand() {
   // Initialize state from args
   state.source = source
   state.sourceDir = source ? dirname(resolve(source)) : process.cwd()
-  state.projectDir = source ? projectDirFor(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
 

package/src/dev-dir.ts

@@ -0,0 +1,25 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+// The folder name is deliberately isolated here: one switch point if it ever
+// changes or becomes configurable.
+const DEV_DIR_NAME = ".solidrt"
+
+// All dev-tooling state lives in one home dotdir, one rule on every platform
+// (okf/backlog/parallel-dev-servers.md): servers/<port>/ holds a dev server's
+// identity (tunnel.key) and its registry record (live.json), clients/ is the
+// data root srt passes for every locally spawned client, so dev client trees
+// land in clients/client<M>/. Deleting the dir resets every bit of dev state.
+export function devDir(...parts: string[]): string {
+  return join(homedir(), DEV_DIR_NAME, ...parts)
+}
+
+/** `servers/<port>/` under the dev dir - a dev server's identity and registry record, keyed by port. */
+export function serverDir(port: number): string {
+  return devDir("servers", String(port))
+}
+
+/** `clients/` under the dev dir - the --data-root for locally spawned dev clients. */
+export function clientsRoot(): string {
+  return devDir("clients")
+}

package/src/dev-server.ts

@@ -1,18 +1,21 @@
-import { resolve } from "path"
+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 } from "./args"
+import { appArgs, values, session, DEFAULT_DEV_PORT } from "./args"
+import { serverDir } from "./dev-dir"
 
 export const DEV_HOST = "127.0.0.1"
-export const DEFAULT_DEV_PORT = 0x8844
 
 // 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 needs no threading through those call sites.
+// 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
+  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`)
@@ -58,10 +61,10 @@ async function post(path: string, body: object) {
  * 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 and `projectDir` its /assets/ root
- * (repl `load`); `map` is the bundle's sourcemap, kept server-side for
- * stack-trace remapping (omitting it clears the server's map, so a mapless
- * reload never remaps against a stale one).
+ * moves the server's file-serving root (repl `load`; the project root is
+ * fixed for the life of the run); `map` is the bundle's sourcemap, kept
+ * server-side for stack-trace remapping (omitting it clears the server's map,
+ * so a mapless reload never remaps against a stale one).
  */
 export async function sendReload(
   message: object,
@@ -69,7 +72,6 @@ export async function sendReload(
     clients?: number[]
     latch?: boolean
     sourceDir?: string
-    projectDir?: string
     entry?: string
     map?: string | null
   } = {},
@@ -185,15 +187,41 @@ function requireFreePort(port: number) {
     let probe = Bun.serve({ port, fetch: () => new Response() })
     probe.stop(true)
   } catch {
-    printErr(`[cli] Port ${port} is already in use; start on another port with --port <N>`)
+    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()
@@ -220,8 +248,8 @@ export async function startServer() {
     minify: values.minify,
     bundlerCmd: [process.execPath, bundleCli],
     cache: values["proxy-http"],
-    cacheDir: resolve(".srt-data"),
-    keyDir: process.cwd(),
+    cacheDir: resolve(state.projectDir, ".srt-data"),
+    keyDir: serverDir(DEV_PORT),
     capture: state.capture,
     stats: state.stats,
     tunnel: values.tunnel,
@@ -257,6 +285,11 @@ export async function startServer() {
     }
   }
 
+  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
   // docs/flux-dev-server-plan.md): the p2p ticket is the cross-device connect
   // story now. If advertise returns, it belongs next to the server (a flux

package/src/pack-folder.ts

@@ -10,6 +10,8 @@ import {
   type ManifestFont,
 } from "./project"
 import { resolvePackFonts } from "./fonts"
+import { runnerGlLibs } from "./packer"
+import { isolateAssetPath } from "./bundler"
 
 // The canonical flat pack folder (okf/plans/client-storage-updates.md, Pack
 // output): runner + manifest.json + bundle.bin + assets/. The manifest
@@ -32,13 +34,20 @@ export type PackFolder = {
   manifest: string
   /** Files to place in the folder: absolute source -> folder-relative path. */
   copies: Array<{ from: string; to: string }>
+  /** Build outputs to place in the folder (isolate bytecode): folder-relative path + bytes. */
+  files: Array<{ to: string; bytes: Buffer }>
 }
 
-export function buildPackFolder(entry: string, bytecode: Buffer): PackFolder {
+// `isolates` are the app's isolate bundles compiled to bytecode; they ship as
+// the manifest assets isolates/<id>.bin (the production runtime has no
+// compiler, so pack never ships isolate source).
+export function buildPackFolder(entry: string, bytecode: Buffer, isolates: { id: string; bytecode: Buffer }[]): PackFolder {
   let identity = loadAppIdentity(entry)
   let projectDir = projectDirFor(resolve(entry))
   let { assets, icon } = collectAssets(entry)
   let copies = assets.map((a) => ({ from: join(projectDir, a.path), to: a.path }))
+  let files = isolates.map((i) => ({ to: isolateAssetPath(i.id, "bin"), bytes: i.bytecode }))
+  for (let f of files) assets.push({ path: f.to, sha256: hashHex(f.bytes), size: f.bytes.length })
 
   // The full resolved font set: custom fonts are already collected assets;
   // defaults materialize under assets/fonts/ (a user file already at that
@@ -77,7 +86,7 @@ export function buildPackFolder(entry: string, bytecode: Buffer): PackFolder {
     ...(assets.length ? { assets } : {}),
     ...(fonts.length ? { fonts } : {}),
   })
-  return { manifest, copies }
+  return { manifest, copies, files }
 }
 
 /**
@@ -93,9 +102,11 @@ export function writePackFolder(outDir: string, runnerPath: string, bytecode: Bu
   }
 
   let runnerName = "solidrt" + (process.platform === "win32" ? ".exe" : "")
+  let glLibs = runnerGlLibs(runnerPath)
   mkdirSync(outDir, { recursive: true })
   rmSync(join(outDir, "assets"), { recursive: true, force: true })
-  for (let name of ["manifest.json", "bundle.bin", runnerName]) {
+  rmSync(join(outDir, "isolates"), { recursive: true, force: true })
+  for (let name of ["manifest.json", "bundle.bin", runnerName, ...glLibs.map((lib) => lib.name)]) {
     rmSync(join(outDir, name), { force: true })
   }
 
@@ -105,6 +116,11 @@ export function writePackFolder(outDir: string, runnerPath: string, bytecode: Bu
   if (process.platform !== "win32") {
     Bun.spawnSync(["chmod", "+x", join(outDir, runnerName)])
   }
+  // The runner loads its GL libraries from next to itself; a folder pack must
+  // carry them like the platform package does.
+  for (let lib of glLibs) {
+    cpSync(lib.path, join(outDir, lib.name), { dereference: true })
+  }
   writeFileSync(join(outDir, "bundle.bin"), bytecode)
   writeFileSync(join(outDir, "manifest.json"), folder.manifest)
   for (let { from, to } of folder.copies) {
@@ -112,4 +128,9 @@ export function writePackFolder(outDir: string, runnerPath: string, bytecode: Bu
     mkdirSync(dirname(dest), { recursive: true })
     cpSync(from, dest)
   }
+  for (let { to, bytes } of folder.files) {
+    let dest = join(outDir, to)
+    mkdirSync(dirname(dest), { recursive: true })
+    writeFileSync(dest, bytes)
+  }
 }

package/src/packer.ts

@@ -1,4 +1,5 @@
-import { readFileSync } from "node:fs"
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
 import { requireBinary } from "./util"
 import { compileToBytecode } from "./bundler"
 import type { PackFolder } from "./pack-folder"
@@ -14,6 +15,33 @@ const MAGIC = {
 // Section kinds in the solidrt trailer. Must match lattice/src/main.rs.
 const SECTION_MANIFEST = 1
 const SECTION_FILE = 2
+const SECTION_GL_LIB = 3
+
+// The GL libraries the runner needs next to it (or, single-file, embedded as
+// kind-3 sections it extracts at boot): ANGLE's libraries on Windows and
+// macOS, nothing on platforms with a system GL. Order matters and the runner
+// preloads in section order: libGLESv2 must load before libEGL so libEGL's
+// import of it resolves against the already-loaded module instead of a
+// directory search.
+const GL_LIB_NAMES: Partial<Record<NodeJS.Platform, string[]>> = {
+  win32: ["libGLESv2.dll", "libEGL.dll"],
+  darwin: ["libGLESv2.dylib", "libEGL.dylib"],
+}
+
+// The GL libraries shipped next to the runner binary, resolved to their paths.
+// Missing files are fatal: a pack without them cannot create a window.
+export function runnerGlLibs(runnerPath: string): Array<{ name: string; path: string }> {
+  let names = GL_LIB_NAMES[process.platform] ?? []
+  let dir = dirname(runnerPath)
+  return names.map((name) => {
+    let path = join(dir, name)
+    if (!existsSync(path)) {
+      console.error(`Could not find ${name} next to the runner (${dir}); the packed app needs it to create a GL context.`)
+      process.exit(1)
+    }
+    return { name, path }
+  })
+}
 
 type Section = { kind: number; bytes: Buffer; name?: string }
 
@@ -48,13 +76,18 @@ function packSections(runnerBytes: Buffer, sections: Section[], magic: Buffer):
 // section form - the canonical manifest verbatim, then every manifest-listed
 // file named by its manifest path. Bundle, fonts, and identity all come from
 // the manifest; assets are read in place via ranged reads at their section
-// offsets, so nothing is unpacked at runtime.
+// offsets, so nothing is unpacked at runtime. GL libraries ride along as
+// kind-3 sections (runtime freight, deliberately outside the manifest); the
+// runner extracts those to its cache and preloads them before window setup.
 export function packSolid(folder: PackFolder, bytecode: Buffer): Buffer {
-  let runnerBytes = readFileSync(requireBinary("solidrt"))
+  let runnerPath = requireBinary("solidrt")
+  let runnerBytes = readFileSync(runnerPath)
   let sections: Section[] = [
     { kind: SECTION_MANIFEST, bytes: Buffer.from(folder.manifest, "utf8") },
     { kind: SECTION_FILE, bytes: bytecode, name: "bundle.bin" },
     ...folder.copies.map((c) => ({ kind: SECTION_FILE, bytes: readFileSync(c.from), name: c.to })),
+    ...folder.files.map((f) => ({ kind: SECTION_FILE, bytes: f.bytes, name: f.to })),
+    ...runnerGlLibs(runnerPath).map((lib) => ({ kind: SECTION_GL_LIB, bytes: readFileSync(lib.path), name: lib.name })),
   ]
   return packSections(runnerBytes, sections, MAGIC.solidrt)
 }

package/src/project.ts

@@ -71,10 +71,13 @@ export const RUNTIME_VERSION = 1
 let pkgVersion = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")).version
 export const SOLIDRT_VERSION: string = pkgVersion === "0.0.0" ? "unknown" : pkgVersion
 
-export function buildManifest(code: string, entry: string): string {
+// `extra` are build outputs that ship as assets too (isolate bundles); they
+// follow the assets/ tree in the list, in the order given.
+export function buildManifest(code: string, entry: string, extra: ManifestAsset[] = []): string {
   let identity = loadAppIdentity(entry)
   let sha256 = new Bun.CryptoHasher("sha256").update(code).digest("hex")
   let { assets, fonts, icon } = collectAssets(entry)
+  assets.push(...extra)
   return JSON.stringify({
     appId: identity.appId,
     displayName: identity.displayName,
@@ -90,6 +93,11 @@ export function buildManifest(code: string, entry: string): string {
 export type ManifestAsset = { path: string; sha256: string; size: number }
 export type ManifestFont = { path: string; alias: string }
 
+/** The manifest entry for in-memory asset bytes at `path`. */
+export function manifestAssetFor(path: string, bytes: Uint8Array): ManifestAsset {
+  return { path, sha256: new Bun.CryptoHasher("sha256").update(bytes).digest("hex"), size: bytes.length }
+}
+
 // The project root the assets/ convention hangs off: the nearest package.json
 // dir, or the entry's own dir when there is none.
 export function projectDirFor(sourcePath: string): string {

package/src/prompt.ts

@@ -1,18 +1,21 @@
-import { createInterface, emitKeypressEvents } from "node:readline"
+import * as clack from "@clack/prompts"
+
+// Thin wrappers over @clack/prompts. Every prompt guards on a TTY: a non-TTY
+// stdin resolves the default rather than blocking on input that will never
+// arrive. Cancelling (ctrl-c) exits the process.
+
+function unwrap<T>(value: T | symbol): T {
+  if (clack.isCancel(value)) {
+    clack.cancel("Cancelled")
+    process.exit(130)
+  }
+  return value as T
+}
 
-// Single-line text prompt with an optional default (shown in parentheses, used
-// when the answer is blank). Non-TTY stdin resolves the default rather than
-// blocking on input that will never arrive.
-export function text(message: string, def = ""): Promise<string> {
-  return new Promise<string>((resolve) => {
-    if (!process.stdin.isTTY) return resolve(def)
-    let rl = createInterface({ input: process.stdin, output: process.stdout })
-    let suffix = def ? ` (${def})` : ""
-    rl.question(`? ${message}${suffix}: `, (answer) => {
-      rl.close()
-      resolve(answer.trim() || def)
-    })
-  })
+// Single-line text prompt; a blank answer resolves the default.
+export async function text(message: string, def = ""): Promise<string> {
+  if (!process.stdin.isTTY) return def
+  return unwrap(await clack.text({ message, defaultValue: def, placeholder: def }))
 }
 
 export interface SelectOption {
@@ -20,65 +23,36 @@ export interface SelectOption {
   value: string
 }
 
-// Minimal arrow-key single-select prompt, built on node:readline (same
-// dependency-free approach as repl.ts). Renders the option list, moves the
-// highlight on up/down, resolves the chosen value on enter. Options are plain
-// strings or { label, value } pairs when the display text differs from the
-// resolved value. Callers guard on process.stdin.isTTY; a non-TTY stdin here
-// resolves the first option rather than hanging on input that will never
-// arrive.
-export function select(message: string, options: Array<string | SelectOption>): Promise<string> {
+// Arrow-key single-select; non-TTY resolves the first option.
+export async function select(message: string, options: Array<string | SelectOption>): Promise<string> {
   let items = options.map((o) => (typeof o === "string" ? { label: o, value: o } : o))
-  return new Promise((resolve) => {
-    let input = process.stdin
-    let output = process.stdout
-    if (!input.isTTY) return resolve(items[0]!.value)
-
-    let selected = 0
-    emitKeypressEvents(input)
-    let wasRaw = input.isRaw
-    input.setRawMode(true)
-
-    let render = (first = false) => {
-      // After the first paint the cursor sits below the block; move it back up
-      // to the message line so the list redraws in place.
-      if (!first) output.write(`\x1b[${items.length + 1}A`)
-      output.write(`\x1b[K? ${message}\n`)
-      for (let i = 0; i < items.length; i++) {
-        let active = i === selected
-        let pointer = active ? "\x1b[36m> " : "  "
-        let reset = active ? "\x1b[0m" : ""
-        output.write(`\x1b[K${pointer}${items[i]!.label}${reset}\n`)
-      }
-    }
-
-    let cleanup = () => {
-      input.off("keypress", onKey)
-      input.setRawMode(wasRaw)
-      input.pause()
-    }
+  if (!process.stdin.isTTY) return items[0]!.value
+  return unwrap(await clack.select({ message, options: items }))
+}
 
-    let onKey = (_str: string, key: { name: string; ctrl: boolean } | undefined) => {
-      if (!key) return
-      if (key.name === "up") {
-        selected = (selected - 1 + items.length) % items.length
-        render()
-      } else if (key.name === "down") {
-        selected = (selected + 1) % items.length
-        render()
-      } else if (key.name === "return" || key.name === "enter") {
-        cleanup()
-        output.write("\n")
-        resolve(items[selected]!.value)
-      } else if (key.ctrl && (key.name === "c" || key.name === "d")) {
-        cleanup()
-        output.write("\n")
-        process.exit(130)
-      }
-    }
+export interface MultiSelectOption {
+  label: string
+  value: string
+  checked?: boolean
+}
 
-    input.on("keypress", onKey)
-    input.resume()
-    render(true)
-  })
+// Space toggles, enter confirms; resolves the selected values in option
+// order. Non-TTY resolves the preselected values.
+export async function multiselect(message: string, options: MultiSelectOption[]): Promise<string[]> {
+  let preset = options.filter((o) => o.checked).map((o) => o.value)
+  if (!process.stdin.isTTY) return preset
+  let picked = unwrap(
+    await clack.multiselect({
+      message,
+      options: options.map((o) => ({ label: o.label, value: o.value })),
+      initialValues: preset,
+      required: false,
+    }),
+  )
+  return options.filter((o) => picked.includes(o.value)).map((o) => o.value)
 }
+
+// Boxed informational message; silent on a non-TTY.
+export function note(message: string, title?: string) {
+  if (process.stdin.isTTY) clack.note(message, title)
+}

package/src/repl.ts

@@ -4,7 +4,7 @@ import { readdirSync } from "node:fs"
 import { state, print, printErr, shutdown } from "./util"
 import { buildReload, getClients, sendReload, sendStop, sendStats, sendWatch, showBuildFailure } from "./dev-server"
 import { bundle } from "./bundler"
-import { buildManifest, projectDirFor } from "./project"
+import { buildManifest } from "./project"
 import { startWatcher, stopWatcher } from "./watcher"
 
 // Resolve repl client indexes ("0 2") against the server's client list,
@@ -101,6 +101,15 @@ async function cmdLoad(file: string) {
     return
   }
   let path = resolve(file)
+  // Same rule as /__control__/load (control.ts): a server run serves the
+  // project it started in, and an entry outside the project root cannot
+  // resolve the project's dependencies anyway.
+  let norm = (p: string) => p.replace(/\\/g, "/")
+  let root = norm(state.projectDir).replace(/\/+$/, "") + "/"
+  if (!norm(path).startsWith(root)) {
+    printErr(`[cli] Entry is outside the project root: ${path} is not under ${state.projectDir}. Restart srt in that project to work on it.`)
+    return
+  }
   if (file.endsWith(".tsx")) {
     let result = await bundle(path)
     if (!result) {
@@ -126,15 +135,14 @@ async function cmdLoad(file: string) {
   }
   state.source = path
   state.sourceDir = dirname(path)
-  state.projectDir = projectDirFor(path)
   startWatcher()
-  // The load also moves the server's file-serving root to the new source dir,
-  // its /assets/ root to the new project dir, and its rebuild entry to the
-  // new file (for a later MCP reload).
+  // 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). The
+  // project root - and with it the /assets/ root - is fixed for the life of
+  // the run.
   await sendReload(buildReload({ code: state.currentCode, manifest: state.currentManifest }), {
     latch: true,
     sourceDir: state.sourceDir,
-    projectDir: state.projectDir,
     entry: file.endsWith(".tsx") ? path : undefined,
     map: state.currentMap,
   })

package/scaffold/templates/components/template.json

@@ -1,4 +0,0 @@
-{
-  "level": "components",
-  "description": "components starter application"
-}

package/scaffold/templates/default/template.json

@@ -1,4 +0,0 @@
-{
-  "level": "core",
-  "description": "core starter application"
-}