@nimbus-sh/worker 0.1.0

package/dist/runtime/node-runner.js

@@ -0,0 +1,194 @@
+/**
+ * node-runner.ts — Always-fresh-isolate dispatch for `node` and `bun`.
+ *
+ * Architectural promise (post fresh-isolate-bun-behavioral wave)
+ * ─────────────────────────────────────────────────────────────
+ * Every external runtime invocation (`node script`, `node -e`,
+ * `node --version`, `bun X`, `npx X`) is dispatched into a FRESH
+ * Worker Loader isolate. There is NO content-sniffing heuristic; the
+ * only routing signal is argv flags that explicitly mean "this is
+ * supposed to be long-lived" (`--watch`, `--inspect`, `--inspect-brk`).
+ *
+ * Two execution modes
+ * ───────────────────
+ *   short — `facetMgr.exec(code, opts)`. Per-call LOADER.get(codeId)
+ *           creates a fresh isolate keyed on hash(code+bundle+manifest).
+ *           Output is streamed back via per-pid child DO Facet's
+ *           supervisor RPC (`_rpcStdout` / `_rpcStderr`); supervisor
+ *           awaits and returns the consolidated {exitCode, stdout,
+ *           stderr}. The facet is deleted at completion.
+ *
+ *   long  — `facetMgr.spawn(workerCode, command, cwd)`. Fire-and-
+ *           forget LOADER.load(). Returns {pid, facetStub} immediately;
+ *           the shell prints a `[started (long-running): pid=N
+ *           cmd=...]` notice and returns. The facet outlives the
+ *           supervisor RPC until killed or evicted.
+ *
+ * Routing
+ * ───────
+ *   args.includes('--watch' | '--inspect' | '--inspect-brk')  → long
+ *   default                                                    → short
+ *
+ * The previous `detectLongRunning(code, args)` content-regex sniff
+ * (deprecated) is removed. False-positives (a script that *imports*
+ * http but exits quickly) used to fork unnecessarily; with
+ * argv-only routing, the user gets the inline behaviour they expect
+ * unless they explicitly opted into long-running with a flag.
+ *
+ * For scripts that don't terminate but also don't carry one of the
+ * argv flags (e.g. an http.listen with no --watch), `facetMgr.exec`'s
+ * 5-minute timeout caps the worst case. The supervisor returns the
+ * timeout exit code; the facet is torn down. Documented trade-off.
+ *
+ * Anti-requirements observed
+ * ──────────────────────────
+ *   - NO setTimeout / sleep on hot paths.
+ *   - NO fallback to in-supervisor execution. facetMgr.exec /
+ *     facetMgr.spawn throw if env.LOADER is missing.
+ *   - NO content-sniffing heuristic. argv-only routing.
+ *
+ * Cold-start (measured against prod 9d30dc95):
+ *   first-run `node -e`     : 152–608 ms (warm-isolate cold case)
+ *   warm `node -e` (median) : 102 ms
+ *   warm `node script.js`   : ~50–100 ms
+ * All under the 250ms warm-pool gate; no warm-pool needed.
+ */
+import { resolveLongRunningPort } from './long-running-handle.js';
+/**
+ * Argv-only long-running detection. The ONLY signals we honour:
+ *   --watch       (node --watch / bun --watch)
+ *   --inspect     (node --inspect)
+ *   --inspect-brk (node --inspect-brk)
+ *
+ * No content sniff; no heuristic over the script source. False-positive
+ * class is gone. False-negative class is "user runs a server without
+ * --watch and the supervisor RPC blocks for 5 min" — accepted; users
+ * are guided in docs to add `--watch` for keep-alive servers OR rely
+ * on the 5-min timeout to recover.
+ */
+export function isLongRunningInvocation(args) {
+    for (const a of args) {
+        if (a === '--watch')
+            return true;
+        if (a === '--inspect')
+            return true;
+        if (a === '--inspect-brk')
+            return true;
+    }
+    return false;
+}
+/**
+ * Build a small Worker Loader entrypoint that wraps the user's `code`
+ * for the long-running fork path. The entrypoint exports a fetch
+ * handler stub (FacetManager.spawn requires it) that returns 404 for
+ * everything; the user's code runs once at module init.
+ */
+function buildLongRunningEntrypoint(code) {
+    const safeCode = JSON.stringify(code);
+    return [
+        'async function __nimbusDispatchHttp(req) {',
+        '  const ports = globalThis.__portRegistry;',
+        '  const hinted = Number(req.headers.get("X-Nimbus-Port") || 0);',
+        '  const server = ports && (ports.get(hinted) || ports.values().next().value);',
+        '  if (!server || typeof server._handleRequest !== "function") {',
+        '    return new Response("Nimbus: no HTTP server is listening in this process", { status: 502 });',
+        '  }',
+        '  const url = new URL(req.url);',
+        '  const headers = {};',
+        '  req.headers.forEach((v, k) => { headers[k] = v; });',
+        '  let body = "";',
+        '  if (req.method !== "GET" && req.method !== "HEAD") body = await req.text();',
+        '  const res = server._handleRequest(url.pathname + url.search, req.method, headers, body);',
+        '  if (!res._ended) {',
+        '    await new Promise((resolve) => {',
+        '      try { res.on("finish", resolve); } catch { resolve(); }',
+        '      setTimeout(resolve, 5000);',
+        '    });',
+        '  }',
+        '  return new Response((res._body || []).join(""), { status: res.statusCode || 200, headers: res.headers || {} });',
+        '}',
+        'export default {',
+        '  async fetch(req) { return __nimbusDispatchHttp(req); },',
+        '  async handleHttpRequest(req) { return __nimbusDispatchHttp(req); }',
+        '};',
+        'try {',
+        '  // eslint-disable-next-line no-new-func',
+        '  new Function(' + safeCode + ')();',
+        '} catch (e) {',
+        '  console.error("[long-running] startup error:", e && e.message ? e.message : String(e));',
+        '}',
+    ].join('\n');
+}
+/**
+ * Always-fresh-isolate dispatcher. Replaces the previous
+ * `runNodeScript` content-sniff variant. Used by both `node` and
+ * `bun` shell handlers.
+ */
+export async function runFresh(facetMgr, code, opts) {
+    const args = opts.argv || [];
+    if (!isLongRunningInvocation(args)) {
+        // Short path: fresh-isolate-per-call via facetMgr.exec.
+        // LOADER.get(codeId) keyed on hash(code+bundle+manifest) — every
+        // invocation gets a fresh isolate; warm slots are reused only
+        // for byte-identical re-invocations.
+        const r = await facetMgr.exec(code, opts);
+        return {
+            exitCode: r.exitCode,
+            stdout: r.stdout,
+            stderr: r.stderr,
+            longRunning: false,
+        };
+    }
+    // Long path: argv flag --watch/--inspect/--inspect-brk explicitly
+    // opts in. Fork to a long-lived Worker Loader via facetMgr.spawn
+    // (LOADER.load — one-shot, not cached). Returns immediately with
+    // {pid, facetStub}.
+    const command = opts.command || `node ${opts.filename || '<script>'}`;
+    const workerCode = buildLongRunningEntrypoint(code);
+    const cwd = opts.cwd || '/home/user';
+    let spawned;
+    const port = resolveLongRunningPort({
+        argv: args,
+        env: opts.env,
+        fallback: 3000,
+    });
+    try {
+        if (typeof facetMgr.spawnNode === 'function') {
+            spawned = await facetMgr.spawnNode(code, {
+                argv: args,
+                env: opts.env,
+                cwd,
+                filename: opts.filename,
+                dirname: opts.dirname,
+                command,
+                port,
+            });
+        }
+        else {
+            spawned = facetMgr.spawn(workerCode, command, cwd, { port });
+        }
+    }
+    catch (e) {
+        // Hard-fail per anti-requirement: missing env.LOADER throws here.
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `runFresh: long-running fork failed: ${e?.message ?? String(e)}\n`,
+            longRunning: true,
+        };
+    }
+    const noticeLine = `\x1b[2m[started (long-running): pid=${spawned.pid} cmd="${command}"]\x1b[0m\n`;
+    return {
+        exitCode: 0,
+        stdout: noticeLine,
+        stderr: '',
+        spawnedPid: spawned.pid,
+        longRunning: true,
+    };
+}
+/**
+ * BACKWARD-COMPAT shim. The arch-gaps wave's `runNodeScript` is now an
+ * alias for `runFresh` so the call sites in src/session/init.ts don't
+ * need to change in this commit.
+ */
+export const runNodeScript = runFresh;

package/dist/runtime/node-shims.d.ts

@@ -0,0 +1,24 @@
+/**
+ * node-shims.ts — Nimbus v2.0 Node.js runtime shims for dynamic workers.
+ *
+ * Generates a raw JS string embedded in facet code. Provides:
+ *   - fs: full sync/async/promises/streams VFS-backed filesystem
+ *   - path: complete POSIX path operations
+ *   - os/process: Linux edge environment simulation
+ *   - Buffer: Uint8Array wrapper with encoding support
+ *   - events: full EventEmitter
+ *   - stream: real Readable/Writable/Transform/Duplex with backpressure
+ *   - crypto: createHash (FNV-1a sync, SubtleCrypto async), randomBytes/UUID
+ *   - zlib: real gzip/gunzip/deflate via CompressionStream/DecompressionStream
+ *   - dns: real DNS resolution via Cloudflare DNS-over-HTTPS
+ *   - http: virtual server with port registry for supervisor routing
+ *   - https: fetch()-backed request/get
+ *   - net: Socket/Server with connect/write/end
+ *   - child_process: ChildProcess objects (execution requires supervisor RPC)
+ *   - assert, util, url, querystring, string_decoder, readline, tty, timers
+ *
+ * VFS access: reads from __vfsBundle (pre-bundled by FacetManager),
+ * writes to __vfsWrites (flushed back to VFS on completion).
+ */
+export declare function generateShimsCode(): string;
+//# sourceMappingURL=node-shims.d.ts.map

package/dist/runtime/node-shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shims.d.ts","sourceRoot":"","sources":["../../src/runtime/node-shims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AA2BH,wBAAgB,iBAAiB,IAAI,MAAM,CA65F1C"}