@volter/world-runtime 2.0.0 → 2.0.1

package/dist/src/pglite-backing.js

@@ -1,18 +1,23 @@
-// The containerless backing for World-managed infrastructure: PGlite hosts
-// (see pglite-host.ts) instead of docker compose. Selected by
-// `volter-world-infra` when no container runtime is available (or by
-// explicit VOLTER_WORLD_INFRA_BACKING=pglite); the world config, definition
-// file, injected env, and declared-service contract are byte-identical either
-// way — backing is private, exactly as the boundary comment in
-// infra-cli.ts promises.
+// The containerless backing for World-managed infrastructure, instead of docker
+// compose: a POSTGRES service is a PGlite host (see pglite-host.mjs), a MONGODB
+// service is the MongoDB twin (@volter/twin-mongodb: the MongoDB wire protocol over
+// the World state kernel). Selected by `volter-world-infra` when no container
+// runtime is available (or by explicit VOLTER_WORLD_INFRA_BACKING=pglite); the
+// world config, definition file, injected env, and declared-service contract are
+// byte-identical either way — backing is private, exactly as the boundary comment
+// in infra-cli.ts promises. Each service's bytes live under VOLTER_WORLD_DATA, so
+// they survive down/up as the compose volumes do.
 //
-// Capability is stated, not stretched: this backing serves POSTGRES services
-// only. A definition declaring mysql/redis without a container runtime is
-// refused with the kinds named, never half-booted.
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+// Capability is stated, not stretched: this backing serves POSTGRES and MONGODB
+// services only. A definition declaring mysql without a container runtime is
+// refused with the kinds named, never half-booted. Redis never reaches it: every
+// redis service is the redis twin's (redis-backing.ts).
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { connect } from 'node:net';
 import { dirname, join } from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { findInstalledPackage, packCli } from "./catalog.js";
 /** Parse the services out of world.infrastructure.yml. This is NOT a YAML
  * parser: init's renderComposeFile emits a deterministic shape, and this
  * reads exactly that shape back (service key at 2-space indent = the kind;
@@ -61,10 +66,46 @@ export function infraConnections(services, env) {
     }
     return connections;
 }
-const HOST = join(import.meta.dir, 'pglite-host.mjs');
+// this module's directory under Node as under Bun: `volter-world-infra` is a node-shebang bin, where
+// `import.meta.dir` (Bun's) is undefined
+const HERE = fileURLToPath(new URL('.', import.meta.url));
+const HOST = join(HERE, 'pglite-host.mjs');
 const READY_TIMEOUT_MS = 60_000;
+const MONGODB_TWIN = '@volter/twin-mongodb';
+/** The kinds this backing serves, and the name its files carry under the data dir. */
+const CONTAINERLESS = { postgres: 'pglite-postgres', mongodb: 'twin-mongodb' };
 function pidPath(dataDir, kind) {
-    return join(dataDir, `pglite-${kind}.pid`);
+    return join(dataDir, `${CONTAINERLESS[kind] ?? `pglite-${kind}`}.pid`);
+}
+/** The MongoDB twin's cli: the package installed above the World's config (an app repo), else the one
+ *  this runtime was installed with (its dependency, or the checkout's workspace link). */
+export function mongodbTwinCli(worldConfig, froms = [...(worldConfig ? [dirname(worldConfig)] : []), HERE]) {
+    for (const from of froms) {
+        const dir = findInstalledPackage(from, MONGODB_TWIN);
+        const cli = dir === undefined ? undefined : packCli(dir);
+        if (cli !== undefined)
+            return cli;
+    }
+    throw new Error(`the containerless mongodb service is served by ${MONGODB_TWIN} (an optional dependency of @volter/world-runtime), which is not installed above ${froms.join(' or ')} — install it, or run the World with a container runtime`);
+}
+/** The runtime a twin's cli runs under. A published package's cli is JavaScript and runs under this
+ *  process's own runtime; a checkout's is TypeScript whose kernel needs more than Node's type
+ *  stripping, so it runs under Bun (this process's, or the one on PATH) — the repository's toolchain —
+ *  and without Bun it is refused by name rather than started to fail. */
+export function twinRunner(cli, bunOnPath = () => spawnSync('bun', ['--version'], { stdio: 'ignore', timeout: 10_000 }).status === 0, underBun = typeof globalThis.Bun !== 'undefined') {
+    if (!cli.endsWith('.ts') || underBun)
+        return process.execPath;
+    if (bunOnPath())
+        return 'bun';
+    throw new Error(`a checkout's MongoDB twin runs under bun, which is not on PATH (${cli} is TypeScript that Node cannot run)`);
+}
+/** The argv that serves one service on its declared loopback port, with its bytes in `serviceData`. */
+function hostArgv(service, serviceData) {
+    if (service.kind === 'mongodb') {
+        const cli = mongodbTwinCli(process.env.VOLTER_WORLD_CONFIG);
+        return [twinRunner(cli), cli, 'serve', '--port', String(service.hostPort), '--root', serviceData];
+    }
+    return ['node', HOST, '--port', String(service.hostPort), '--data', serviceData];
 }
 function alive(pid) {
     try {
@@ -88,36 +129,78 @@ function listening(port) {
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** The kinds this backing cannot serve, or [] when it can serve the world. */
 export function unsupportedKinds(services) {
-    return [...new Set(services.filter((s) => s.kind !== 'postgres').map((s) => s.kind))];
+    return [...new Set(services.filter((s) => CONTAINERLESS[s.kind] === undefined).map((s) => s.kind))];
+}
+/** The line each host prints once ITS OWN listener is bound: readiness is taken from the child, never
+ *  from a connect to the port, which any other process holding the port would answer. */
+function readyLine(kind, port) {
+    return kind === 'mongodb' ? `listening on mongodb://127.0.0.1:${port}` : `serving postgres wire protocol on 127.0.0.1:${port}`;
+}
+function logSince(log, offset) {
+    try {
+        return readFileSync(log).subarray(offset).toString('utf8');
+    }
+    catch {
+        return '';
+    }
 }
 export async function pgliteUp(services, dataDir) {
+    // Every check before any start: a refused up starts nothing, so it never leaves the World half-booted.
+    const plan = [];
     for (const service of services) {
         const pidFile = pidPath(dataDir, service.kind);
         if (existsSync(pidFile) && alive(Number(readFileSync(pidFile, 'utf8').trim())))
             continue;
-        const serviceData = join(dataDir, `pglite-${service.kind}-data`);
-        mkdirSync(serviceData, { recursive: true });
-        const log = join(dataDir, `pglite-${service.kind}.log`);
-        mkdirSync(dirname(log), { recursive: true });
-        // a real fd, not a pipe: the host must outlive this process untethered
-        const logFd = openSync(log, 'a');
-        const child = spawn('node', [HOST, '--port', String(service.hostPort), '--data', serviceData], {
-            detached: true,
-            stdio: ['ignore', logFd, logFd],
-        });
-        child.unref();
-        closeSync(logFd);
-        writeFileSync(pidFile, `${child.pid}\n`);
-        const deadline = Date.now() + READY_TIMEOUT_MS;
-        while (!(await listening(service.hostPort))) {
-            if (!alive(child.pid)) {
-                throw new Error(`pglite ${service.kind} exited before serving — see ${log}`);
+        const name = CONTAINERLESS[service.kind] ?? `pglite-${service.kind}`;
+        const serviceData = join(dataDir, `${name}-data`);
+        const log = join(dataDir, `${name}.log`);
+        if (await listening(service.hostPort)) {
+            throw new Error(`${name} cannot serve port ${service.hostPort}: another process is already listening on it`);
+        }
+        plan.push({ service, name, serviceData, log, pidFile, argv: hostArgv(service, serviceData) });
+    }
+    const started = [];
+    try {
+        for (const { service, name, serviceData, log, pidFile, argv } of plan) {
+            mkdirSync(serviceData, { recursive: true });
+            mkdirSync(dirname(log), { recursive: true });
+            const offset = existsSync(log) ? statSync(log).size : 0;
+            const [command, ...args] = argv;
+            // a real fd, not a pipe: the host must outlive this process untethered
+            const logFd = openSync(log, 'a');
+            const child = spawn(command, args, {
+                detached: true,
+                stdio: ['ignore', logFd, logFd],
+            });
+            child.unref();
+            closeSync(logFd);
+            writeFileSync(pidFile, `${child.pid}\n`);
+            started.push({ pid: child.pid, pidFile });
+            const deadline = Date.now() + READY_TIMEOUT_MS;
+            const line = readyLine(service.kind, service.hostPort);
+            // ready when OUR child says its listener is bound (a squatter that took the port after the check
+            // above makes the child fail its bind and exit, never print this) and the port answers
+            while (!(alive(child.pid) && logSince(log, offset).includes(line) && await listening(service.hostPort))) {
+                if (!alive(child.pid))
+                    throw new Error(`${name} exited before serving — see ${log}`);
+                if (Date.now() > deadline)
+                    throw new Error(`${name} did not serve port ${service.hostPort} within ${READY_TIMEOUT_MS / 1000}s — see ${log}`);
+                await sleep(200);
             }
-            if (Date.now() > deadline) {
-                throw new Error(`pglite ${service.kind} did not serve port ${service.hostPort} within ${READY_TIMEOUT_MS / 1000}s — see ${log}`);
+        }
+    }
+    catch (error) {
+        // tear down what this up started, so a failed up leaves nothing running
+        for (const { pid, pidFile } of started) {
+            if (alive(pid)) {
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch { /* already gone */ }
             }
-            await sleep(200);
+            rmSync(pidFile, { force: true });
         }
+        throw error;
     }
 }
 export async function pgliteStatus(services, dataDir) {