@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/PackageScan.res.mjs

@@ -0,0 +1,81 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+
+function readPackage(pkgJsonPath) {
+  try {
+    let json = JSON.parse(Nodefs.readFileSync(pkgJsonPath, "utf8"));
+    if (typeof json !== "object" || json === null || Array.isArray(json)) {
+      return;
+    }
+    let match = json["name"];
+    let name = typeof match === "string" ? match : "";
+    let match$1 = json["scripts"];
+    if (match$1 === undefined) {
+      return;
+    }
+    if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+      return;
+    }
+    let match$2 = match$1["start"];
+    if (typeof match$2 === "string") {
+      return [
+        name,
+        match$2
+      ];
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+function findOwning(_dir) {
+  while (true) {
+    let dir = _dir;
+    let pkgJson = Nodepath.join(dir, "package.json");
+    let here = Nodefs.existsSync(pkgJson) ? readPackage(pkgJson) : undefined;
+    if (here !== undefined) {
+      return {
+        name: here[0],
+        dir: dir,
+        build: here[1]
+      };
+    }
+    let parent = Nodepath.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    _dir = parent;
+    continue;
+  };
+}
+
+function scan(testFiles) {
+  let seen = {};
+  let out = [];
+  testFiles.forEach(file => {
+    let pkg = findOwning(Nodepath.dirname(file));
+    if (pkg === undefined) {
+      return;
+    }
+    let match = seen[pkg.dir];
+    if (match !== undefined) {
+      return;
+    } else {
+      seen[pkg.dir] = true;
+      out.push(pkg);
+      return;
+    }
+  });
+  return out;
+}
+
+export {
+  readPackage,
+  findOwning,
+  scan,
+}
+/* node:fs Not a pure module */

package/src/PlatformRunner.res

@@ -0,0 +1,181 @@
+// Local platform runner (features plan Phase 9). Spawns an app's reventless-local
+// platform as a managed child with the LocalBus NDJSON event tap enabled, on
+// per-session free ports, classifies its stdout into structured lifecycle/event
+// callbacks, and tears the child down on cancellation. The CLI (`reventless-gwt
+// platform`) wires the callbacks to FormatterVsCode; tests drive `classifyLine`
+// directly.
+//
+// Channels (Spike A/B): commands in / state out go to the platform's GraphQL
+// server (the runner just reports its endpoint); the live event stream comes from
+// the tap on stdout — one sentinel-prefixed JSON line per published event.
+
+let tapSentinel = "@@RVLESS_EVT@@ "
+
+type lineClass =
+  | Domain(JSON.t) // a tap line; the parsed `{event:"domainEvent",…}` payload
+  | Ready // the Domain GraphQL server's "listening on …" line
+  | Log(string) // any other stdout/stderr line (the platform's human logs)
+
+// Pure line classifier — the unit-tested core. ANSI escapes around bracketed
+// component tags survive substring checks, so readiness is detected structurally.
+// The human-log payload is passed through **with its ANSI intact**: the extension
+// renders it in a VS Code Pseudoterminal (xterm), which interprets colour/bold so
+// the runner log reads exactly as on the command line. (Plain non-terminal sinks
+// that want stripped text — CloudWatch etc. — are the framework's concern; see
+// docs/plans/logging-output-optimization.md.)
+let classifyLine = (line: string): lineClass =>
+  if line->String.startsWith(tapSentinel) {
+    let jsonStr = line->String.slice(~start=tapSentinel->String.length, ~end=line->String.length)
+    switch JSON.parseOrThrow(jsonStr) {
+    | exception _ => Log(line)
+    | json => Domain(json)
+    }
+  } else if line->String.includes("GraphQL:Domain") && line->String.includes("listening on") {
+    Ready
+  } else {
+    Log(line)
+  }
+
+type callbacks = {
+  onStart: (~package: string, ~dir: string, ~domainPort: int, ~platformPort: int) => unit,
+  onReady: (~domainEndpoint: string) => unit,
+  onDomainEvent: JSON.t => unit,
+  onLog: string => unit,
+  onStop: option<int> => unit,
+}
+
+// ── Free-port allocation ────────────────────────────────────────────────────
+// One platform child per app folder; default ports (4000/4001/3001/3002) collide
+// with a developer's own `dev:full`, so the runner binds ephemeral ports and
+// passes them to the child via the env overrides added in Phase 1.
+type netServer
+@module("node:net") external _createServer: unit => netServer = "createServer"
+@send external _listen: (netServer, int, string, unit => unit) => unit = "listen"
+@send external _address: netServer => {"port": int} = "address"
+@send external _close: (netServer, unit => unit) => unit = "close"
+
+let openEphemeral = (): promise<(netServer, int)> =>
+  Promise.make((resolve, _reject) => {
+    let s = _createServer()
+    s->_listen(0, "127.0.0.1", () => resolve((s, (s->_address)["port"])))
+  })
+
+let closeServer = (s: netServer): promise<unit> =>
+  Promise.make((resolve, _reject) => s->_close(() => resolve()))
+
+// Hold all n open while collecting ports so they're guaranteed distinct, then
+// release them just before the child binds.
+let allocFreePorts = async (n: int): array<int> => {
+  let servers = []
+  let ports = []
+  for _i in 1 to n {
+    let (s, p) = await openEphemeral()
+    servers->Array.push(s)
+    ports->Array.push(p)
+  }
+  // Await every close so the ports are actually released before the child binds
+  // them. Closing fire-and-forget returned the ports while the sockets were
+  // still bound, racing the child's bind into EADDRINUSE.
+  let _ = await Promise.all(servers->Array.map(closeServer))
+  ports
+}
+
+// The platform child's default ports (Platform.startServers): domain / platform /
+// domain-MCP / platform-MCP. `~fixedPorts` pins to these instead of allocating
+// ephemeral ones — the VS Code extension uses it when launching the host-shell UI,
+// whose Vite proxy hardcodes localhost:4000/4001. The caller is responsible for
+// ensuring they're free (it pre-checks and toasts on conflict).
+let fixedPlatformPorts = [4000, 4001, 3001, 3002]
+
+// Discover the platform package under `roots`, spawn it with the tap + per-session
+// ports + in-memory backend, stream its events through `callbacks`, and stay alive
+// until cancelled (the child is killed via its process group on SIGTERM/SIGINT).
+let run = async (
+  ~roots: array<string>,
+  ~backend: string,
+  ~fixedPorts: bool=false,
+  ~callbacks: callbacks,
+): int => {
+  let pkgs = await PlatformScan.scan(roots)
+  switch pkgs->Array.get(0) {
+  | None =>
+    callbacks.onLog(
+      "no reventless-local platform package (src/Main.res.mjs + @reventlessdev/reventless-local) found under: " ++
+      roots->Array.join(", "),
+    )
+    1
+  | Some(pkg) =>
+    let ports = fixedPorts ? fixedPlatformPorts : await allocFreePorts(4)
+    let dPort = ports->Array.getUnsafe(0)
+    let pPort = ports->Array.getUnsafe(1)
+    let dMcp = ports->Array.getUnsafe(2)
+    let pMcp = ports->Array.getUnsafe(3)
+    let env = Dict.fromArray([
+      ("REVENTLESS_EVENT_TAP", "ndjson"),
+      ("REVENTLESS_LOCAL_BACKEND", backend),
+      ("REVENTLESS_DOMAIN_PORT", Int.toString(dPort)),
+      ("REVENTLESS_PLATFORM_PORT", Int.toString(pPort)),
+      ("REVENTLESS_DOMAIN_MCP_PORT", Int.toString(dMcp)),
+      ("REVENTLESS_PLATFORM_MCP_PORT", Int.toString(pMcp)),
+      ("NODE_OPTIONS", "--disable-warning=ExperimentalWarning"),
+      // The gwt bin defaults LOG_LEVEL=silent so its OWN stdout stays pure NDJSON;
+      // the platform child is a separate process whose stdout we parse, so it needs
+      // real logs — the "listening on" line drives readiness and the rest becomes
+      // platformLog. Override the inherited silent.
+      ("LOG_LEVEL", "info"),
+      // The child's stdout is a pipe (we line-parse it), so the framework's sink
+      // detection would auto-pick JSON (non-TTY). But every consumer of `onLog`
+      // renders ANSI — the CLI forwards to the developer's terminal, the extension
+      // to an xterm Pseudoterminal — so force human text mode for bold/colour.
+      // (Tap event lines stay JSON regardless: they're sentinel-prefixed.)
+      ("REVENTLESS_LOG_FORMAT", "text"),
+    ])
+
+    callbacks.onStart(~package=pkg.name, ~dir=pkg.dir, ~domainPort=dPort, ~platformPort=pPort)
+
+    // Run the compiled entrypoint directly with `node`. `src/Main.res.mjs` is plain
+    // ESM, so it needs no tsx/loader, and spawning a single process (vs `pnpm run
+    // serve` → `pnpm run serve` → `npx tsx`) keeps the child's stdout piped straight
+    // to us — nested pnpm buffers a long-running grandchild's output, so the event
+    // tap never streams through it. cwd = the package dir so `PackageVersion.fromCwd`
+    // and relative paths resolve. We set the backend + tap + ports via env directly,
+    // so the package's own serve script (which would otherwise pick them) is bypassed.
+    let proc = ChildProcess.spawn("node", ["src/Main.res.mjs"], ~cwd=pkg.dir, ~env)
+    Cancellation.onCancel(() => ChildProcess.killTree(proc, "SIGTERM"))
+
+    let readyEmitted = ref(false)
+    let handle = line =>
+      switch classifyLine(line) {
+      | Domain(json) => callbacks.onDomainEvent(json)
+      | Ready =>
+        if !readyEmitted.contents {
+          readyEmitted := true
+          callbacks.onReady(~domainEndpoint="http://localhost:" ++ Int.toString(dPort) ++ "/graphql")
+        }
+      | Log(l) => callbacks.onLog(l)
+      }
+    ChildProcess.onStdoutLine(proc, handle)
+    ChildProcess.onStderrLine(proc, handle)
+
+    // Keep the parent alive until either the operator cancels or the child exits.
+    // The previous shape awaited cancellation *forever* and always returned 0, so
+    // a crashed platform child left a zombie parent that reported success. Resolve
+    // on child close (or a spawn error) too, and surface the child's exit code.
+    let exitCode = ref(0)
+    await Promise.make((resolve, _reject) => {
+      Cancellation.onCancel(() => resolve())
+      ChildProcess.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " ++ msg)
+        callbacks.onStop(None)
+        exitCode := 1
+        resolve()
+      })
+      ChildProcess.onClose(proc, code => {
+        callbacks.onStop(code)
+        exitCode := code->Option.getOr(0)
+        resolve()
+      })
+    })
+    exitCode.contents
+  }
+}

package/src/PlatformRunner.res.mjs

@@ -0,0 +1,176 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodenet from "node:net";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Cancellation$ReventlessGwt from "./Cancellation.res.mjs";
+import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
+import * as PlatformScan$ReventlessGwt from "./PlatformScan.res.mjs";
+
+let tapSentinel = "@@RVLESS_EVT@@ ";
+
+function classifyLine(line) {
+  if (!line.startsWith(tapSentinel)) {
+    if (line.includes("GraphQL:Domain") && line.includes("listening on")) {
+      return "Ready";
+    } else {
+      return {
+        TAG: "Log",
+        _0: line
+      };
+    }
+  }
+  let jsonStr = line.slice(tapSentinel.length, line.length);
+  let json;
+  try {
+    json = JSON.parse(jsonStr);
+  } catch (exn) {
+    return {
+      TAG: "Log",
+      _0: line
+    };
+  }
+  return {
+    TAG: "Domain",
+    _0: json
+  };
+}
+
+function openEphemeral() {
+  return new Promise((resolve, _reject) => {
+    let s = Nodenet.createServer();
+    s.listen(0, "127.0.0.1", () => resolve([
+      s,
+      s.address().port
+    ]));
+  });
+}
+
+function closeServer(s) {
+  return new Promise((resolve, _reject) => {
+    s.close(() => resolve());
+  });
+}
+
+async function allocFreePorts(n) {
+  let servers = [];
+  let ports = [];
+  for (let _i = 1; _i <= n; ++_i) {
+    let match = await openEphemeral();
+    servers.push(match[0]);
+    ports.push(match[1]);
+  }
+  await Promise.all(servers.map(closeServer));
+  return ports;
+}
+
+let fixedPlatformPorts = [
+  4000,
+  4001,
+  3001,
+  3002
+];
+
+async function run(roots, backend, fixedPortsOpt, callbacks) {
+  let fixedPorts = fixedPortsOpt !== undefined ? fixedPortsOpt : false;
+  let pkgs = await PlatformScan$ReventlessGwt.scan(roots);
+  let pkg = pkgs[0];
+  if (pkg !== undefined) {
+    let ports = fixedPorts ? fixedPlatformPorts : await allocFreePorts(4);
+    let dPort = ports[0];
+    let pPort = ports[1];
+    let dMcp = ports[2];
+    let pMcp = ports[3];
+    let env = Object.fromEntries([
+      [
+        "REVENTLESS_EVENT_TAP",
+        "ndjson"
+      ],
+      [
+        "REVENTLESS_LOCAL_BACKEND",
+        backend
+      ],
+      [
+        "REVENTLESS_DOMAIN_PORT",
+        dPort.toString()
+      ],
+      [
+        "REVENTLESS_PLATFORM_PORT",
+        pPort.toString()
+      ],
+      [
+        "REVENTLESS_DOMAIN_MCP_PORT",
+        dMcp.toString()
+      ],
+      [
+        "REVENTLESS_PLATFORM_MCP_PORT",
+        pMcp.toString()
+      ],
+      [
+        "NODE_OPTIONS",
+        "--disable-warning=ExperimentalWarning"
+      ],
+      [
+        "LOG_LEVEL",
+        "info"
+      ],
+      [
+        "REVENTLESS_LOG_FORMAT",
+        "text"
+      ]
+    ]);
+    callbacks.onStart(pkg.name, pkg.dir, dPort, pPort);
+    let proc = ChildProcess$ReventlessGwt.spawn("node", ["src/Main.res.mjs"], pkg.dir, env);
+    Cancellation$ReventlessGwt.onCancel(() => ChildProcess$ReventlessGwt.killTree(proc, "SIGTERM"));
+    let readyEmitted = {
+      contents: false
+    };
+    let handle = line => {
+      let json = classifyLine(line);
+      if (typeof json !== "object") {
+        if (!readyEmitted.contents) {
+          readyEmitted.contents = true;
+          return callbacks.onReady("http://localhost:" + dPort.toString() + "/graphql");
+        } else {
+          return;
+        }
+      } else if (json.TAG === "Domain") {
+        return callbacks.onDomainEvent(json._0);
+      } else {
+        return callbacks.onLog(json._0);
+      }
+    };
+    ChildProcess$ReventlessGwt.onStdoutLine(proc, handle);
+    ChildProcess$ReventlessGwt.onStderrLine(proc, handle);
+    let exitCode = {
+      contents: 0
+    };
+    await new Promise((resolve, _reject) => {
+      Cancellation$ReventlessGwt.onCancel(() => resolve());
+      ChildProcess$ReventlessGwt.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " + msg);
+        callbacks.onStop(undefined);
+        exitCode.contents = 1;
+        resolve();
+      });
+      ChildProcess$ReventlessGwt.onClose(proc, code => {
+        callbacks.onStop(code);
+        exitCode.contents = Stdlib_Option.getOr(code, 0);
+        resolve();
+      });
+    });
+    return exitCode.contents;
+  }
+  callbacks.onLog("no reventless-local platform package (src/Main.res.mjs + @reventlessdev/reventless-local) found under: " + roots.join(", "));
+  return 1;
+}
+
+export {
+  tapSentinel,
+  classifyLine,
+  openEphemeral,
+  closeServer,
+  allocFreePorts,
+  fixedPlatformPorts,
+  run,
+}
+/* node:net Not a pure module */

package/src/PlatformScan.res

@@ -0,0 +1,142 @@
+// Discovers the local-platform package(s) the runner can launch (features plan
+// Phase 9). A platform package is one that (a) depends on
+// `@reventlessdev/reventless-local` and (b) carries a compiled run entrypoint at
+// `src/Main.res.mjs` (what `tsx`/`node` execute). This mirrors PackageScan's
+// role for the watch session, but keys off the run entrypoint rather than test
+// files. The matching predicate is pure so it can be unit-tested without a real
+// workspace tree.
+
+type platformPkg = {
+  // Package name from package.json (may be "" if absent).
+  name: string,
+  // Absolute package directory (the one containing package.json + src/).
+  dir: string,
+  // Absolute path to the compiled run entrypoint (src/Main.res.mjs).
+  mainPath: string,
+  // The npm-script name to launch, preferring an in-memory variant: "serve:memory"
+  // if declared, else "serve". None ⇒ no serve script (runner falls back to running
+  // src/Main.res.mjs via tsx directly).
+  serveScript: option<string>,
+}
+
+type dirent = {
+  name: string,
+  @as("isDirectory") _isDirectory: unit => bool,
+}
+type readdirOpts = {withFileTypes: bool}
+@module("node:fs/promises")
+external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
+@module("node:fs") external _existsSync: string => bool = "existsSync"
+@module("node:fs") external _readFileSync: (string, string) => string = "readFileSync"
+@module("node:path") external join: (string, string) => string = "join"
+
+let localPlatformDep = "@reventlessdev/reventless-local"
+let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
+
+// Pure predicate: given a package.json's text and whether src/Main.res.mjs exists,
+// decide whether this is a launchable platform package and surface its name +
+// serve script. Depends on reventless-local appearing in any dependency block.
+let matchPlatform = (
+  ~pkgJsonText: string,
+  ~mainExists: bool,
+): option<(string, option<string>)> => {
+  if !mainExists {
+    None
+  } else {
+    switch JSON.parseOrThrow(pkgJsonText) {
+    | exception _ => None
+    | json =>
+      switch json->JSON.Decode.object {
+      | None => None
+      | Some(obj) =>
+        let name = switch obj->Dict.get("name") {
+        | Some(String(n)) => n
+        | _ => ""
+        }
+        let depsHave = key =>
+          switch obj->Dict.get(key)->Option.flatMap(JSON.Decode.object) {
+          | Some(deps) => deps->Dict.get(localPlatformDep)->Option.isSome
+          | None => false
+          }
+        let dependsOnLocal =
+          depsHave("dependencies") ||
+          depsHave("devDependencies") ||
+          depsHave("optionalDependencies")
+        if dependsOnLocal {
+          let serveScript =
+            switch obj->Dict.get("scripts")->Option.flatMap(JSON.Decode.object) {
+            | Some(scripts) =>
+              if scripts->Dict.get("serve:memory")->Option.isSome {
+                Some("serve:memory")
+              } else if scripts->Dict.get("serve")->Option.isSome {
+                Some("serve")
+              } else {
+                None
+              }
+            | None => None
+            }
+          Some((name, serveScript))
+        } else {
+          None
+        }
+      }
+    }
+  }
+}
+
+// Inspect a single directory: is it a platform package?
+let inspectDir = (dir: string): option<platformPkg> => {
+  let pkgJson = join(dir, "package.json")
+  let mainPath = join(join(dir, "src"), "Main.res.mjs")
+  if !_existsSync(pkgJson) {
+    None
+  } else {
+    let text = try _readFileSync(pkgJson, "utf8") catch {
+    | _ => ""
+    }
+    switch matchPlatform(~pkgJsonText=text, ~mainExists=_existsSync(mainPath)) {
+    | Some((name, serveScript)) => Some({name, dir, mainPath, serveScript})
+    | None => None
+    }
+  }
+}
+
+// Walk the roots, returning every platform package found (deduped by dir,
+// declaration order preserved). Prunes node_modules/lib/.git like Discovery.
+let rec walk = async (dir: string, acc: array<platformPkg>): array<platformPkg> => {
+  switch inspectDir(dir) {
+  // A platform package — record it and stop: descending into its own subtree
+  // (src/, generated code, nested workspace copies) can only waste I/O or turn
+  // up spurious inner matches. This is what the "don't descend" comment always
+  // intended; the recursion below used to run regardless.
+  | Some(pkg) => acc->Array.push(pkg)
+  | None =>
+    let entries = try await _readdir(dir, {withFileTypes: true}) catch {
+    | _ => []
+    }
+    for i in 0 to entries->Array.length - 1 {
+      let entry = entries->Array.getUnsafe(i)
+      if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
+        let _ = await walk(join(dir, entry.name), acc)
+      }
+    }
+  }
+  acc
+}
+
+let scan = async (roots: array<string>): array<platformPkg> => {
+  let seen = Dict.make()
+  let out = []
+  for i in 0 to roots->Array.length - 1 {
+    let found = await walk(roots->Array.getUnsafe(i), [])
+    found->Array.forEach(pkg =>
+      switch seen->Dict.get(pkg.dir) {
+      | Some(_) => ()
+      | None =>
+        seen->Dict.set(pkg.dir, true)
+        out->Array.push(pkg)
+      }
+    )
+  }
+  out
+}