@nimbus-sh/worker 0.1.0

package/dist/runtime/process-table.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ProcessTable — maps PIDs to facet names, tracks lifecycle.
+ *
+ * Each `node script.js` invocation gets a PID, which maps to a
+ * facet name like "node-proc-1". The supervisor uses this to
+ * route signals (kill) and track running processes.
+ */
+export type ProcessState = 'running' | 'exited' | 'killed';
+export interface ProcessEntry {
+    pid: number;
+    facetName: string;
+    command: string;
+    argv: string[];
+    cwd: string;
+    state: ProcessState;
+    exitCode: number | null;
+    startTime: number;
+    endTime: number | null;
+    /** arch-gaps: explicit long-running flag set by FacetManager.spawn
+     *  when a script is forked to a long-lived Worker Loader (vite,
+     *  http.listen, --watch, …). Distinct from the regex heuristic in
+     *  process-logs-api.ts:LONG_RUNNING_CMD_RE — when set, the API
+     *  returns this directly. */
+    longRunning?: boolean;
+}
+export declare class ProcessTable {
+    private nextPid;
+    private processes;
+    private facetToPid;
+    /** Allocate a PID and register a new process. */
+    spawn(command: string, argv: string[], cwd: string): ProcessEntry;
+    /**
+     * Mark a process as exited.
+     *
+     * STABILITY-AUDIT.md M-S1: state-idempotent. Once a process reaches
+     * a terminal state (`killed` or `exited`), subsequent exit() calls
+     * are no-ops — the first terminal state wins.
+     *
+     * Without this guard, a `kill <pid>` (which sets state='killed',
+     * exitCode=137) followed by the facet's own crash-catch in
+     * facet-manager.ts:842-864 (which calls processTable.exit(pid, 1))
+     * clobbers the kill signal with an exited/1 reading. `ps` then
+     * disagrees with the ring-buffer footer that still says
+     * "[process killed: killed]".
+     */
+    /** arch-gaps: mark an existing entry as long-running. Idempotent. */
+    setLongRunning(pid: number): void;
+    exit(pid: number, exitCode: number): void;
+    /** Mark a process as killed. */
+    kill(pid: number): boolean;
+    get(pid: number): ProcessEntry | undefined;
+    getByFacet(facetName: string): ProcessEntry | undefined;
+    getRunning(): ProcessEntry[];
+    getAll(): ProcessEntry[];
+    /** Clean up exited processes older than maxAge ms. */
+    reap(maxAge?: number): number;
+    get stats(): {
+        total: number;
+        running: number;
+        exited: number;
+        killed: number;
+        nextPid: number;
+    };
+}
+//# sourceMappingURL=process-table.d.ts.map

package/dist/runtime/process-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-table.d.ts","sourceRoot":"","sources":["../../src/runtime/process-table.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE3D,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;;;;iCAI6B;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,UAAU,CAA6B;IAE/C,iDAAiD;IACjD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY;IAmBjE;;;;;;;;;;;;;OAaG;IACH,qEAAqE;IACrE,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKjC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IASzC,gCAAgC;IAChC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAS1B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI1C,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAKvD,UAAU,IAAI,YAAY,EAAE;IAI5B,MAAM,IAAI,YAAY,EAAE;IAIxB,sDAAsD;IACtD,IAAI,CAAC,MAAM,SAAS,GAAG,MAAM;IAa7B,IAAI,KAAK;;;;;;MASR;CACF"}

package/dist/runtime/process-table.js

@@ -0,0 +1,107 @@
+/**
+ * ProcessTable — maps PIDs to facet names, tracks lifecycle.
+ *
+ * Each `node script.js` invocation gets a PID, which maps to a
+ * facet name like "node-proc-1". The supervisor uses this to
+ * route signals (kill) and track running processes.
+ */
+export class ProcessTable {
+    nextPid = 1;
+    processes = new Map();
+    facetToPid = new Map();
+    /** Allocate a PID and register a new process. */
+    spawn(command, argv, cwd) {
+        const pid = this.nextPid++;
+        const facetName = `node-proc-${pid}`;
+        const entry = {
+            pid,
+            facetName,
+            command,
+            argv,
+            cwd,
+            state: 'running',
+            exitCode: null,
+            startTime: Date.now(),
+            endTime: null,
+        };
+        this.processes.set(pid, entry);
+        this.facetToPid.set(facetName, pid);
+        return entry;
+    }
+    /**
+     * Mark a process as exited.
+     *
+     * STABILITY-AUDIT.md M-S1: state-idempotent. Once a process reaches
+     * a terminal state (`killed` or `exited`), subsequent exit() calls
+     * are no-ops — the first terminal state wins.
+     *
+     * Without this guard, a `kill <pid>` (which sets state='killed',
+     * exitCode=137) followed by the facet's own crash-catch in
+     * facet-manager.ts:842-864 (which calls processTable.exit(pid, 1))
+     * clobbers the kill signal with an exited/1 reading. `ps` then
+     * disagrees with the ring-buffer footer that still says
+     * "[process killed: killed]".
+     */
+    /** arch-gaps: mark an existing entry as long-running. Idempotent. */
+    setLongRunning(pid) {
+        const entry = this.processes.get(pid);
+        if (entry)
+            entry.longRunning = true;
+    }
+    exit(pid, exitCode) {
+        const entry = this.processes.get(pid);
+        if (!entry)
+            return;
+        if (entry.state !== 'running')
+            return; // first terminal state wins
+        entry.state = 'exited';
+        entry.exitCode = exitCode;
+        entry.endTime = Date.now();
+    }
+    /** Mark a process as killed. */
+    kill(pid) {
+        const entry = this.processes.get(pid);
+        if (!entry || entry.state !== 'running')
+            return false;
+        entry.state = 'killed';
+        entry.exitCode = 137; // SIGKILL
+        entry.endTime = Date.now();
+        return true;
+    }
+    get(pid) {
+        return this.processes.get(pid);
+    }
+    getByFacet(facetName) {
+        const pid = this.facetToPid.get(facetName);
+        return pid !== undefined ? this.processes.get(pid) : undefined;
+    }
+    getRunning() {
+        return [...this.processes.values()].filter(p => p.state === 'running');
+    }
+    getAll() {
+        return [...this.processes.values()];
+    }
+    /** Clean up exited processes older than maxAge ms. */
+    reap(maxAge = 60_000) {
+        const now = Date.now();
+        let reaped = 0;
+        for (const [pid, entry] of this.processes) {
+            if (entry.state !== 'running' && entry.endTime && now - entry.endTime > maxAge) {
+                this.facetToPid.delete(entry.facetName);
+                this.processes.delete(pid);
+                reaped++;
+            }
+        }
+        return reaped;
+    }
+    get stats() {
+        const all = [...this.processes.values()];
+        return {
+            total: all.length,
+            running: all.filter(p => p.state === 'running').length,
+            exited: all.filter(p => p.state === 'exited').length,
+            killed: all.filter(p => p.state === 'killed').length,
+            nextPid: this.nextPid,
+        };
+    }
+}

package/dist/runtime/project-detect.d.ts

@@ -0,0 +1,21 @@
+/**
+ * project-detect.ts — small, dependency-free project-type detectors.
+ *
+ * Lives in its own module so unit tests + diag endpoints can import the
+ * detection helpers without pulling in nimbus-session.ts (which depends
+ * on `cloudflare:workers` and won't load under Bun).
+ *
+ * Currently exports detectCloudflareWorkersProject — added in W10 as the
+ * canonical "is this a Cloudflare Workers project?" check. Future waves
+ * can add detectVite, detectNext, etc. here.
+ */
+/**
+ * W10: detect whether the project at `<root>` is a Cloudflare Workers
+ * project. Returns true if any of the standard markers are present:
+ *   - <root>/wrangler.jsonc
+ *   - <root>/wrangler.json
+ *   - <root>/wrangler.toml
+ *   - <root>/package.json with `wrangler` in deps or devDeps
+ */
+export declare function detectCloudflareWorkersProject(vfs: any, root: string): boolean;
+//# sourceMappingURL=project-detect.d.ts.map

package/dist/runtime/project-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-detect.d.ts","sourceRoot":"","sources":["../../src/runtime/project-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAqB9E"}

package/dist/runtime/project-detect.js

@@ -0,0 +1,46 @@
+/**
+ * project-detect.ts — small, dependency-free project-type detectors.
+ *
+ * Lives in its own module so unit tests + diag endpoints can import the
+ * detection helpers without pulling in nimbus-session.ts (which depends
+ * on `cloudflare:workers` and won't load under Bun).
+ *
+ * Currently exports detectCloudflareWorkersProject — added in W10 as the
+ * canonical "is this a Cloudflare Workers project?" check. Future waves
+ * can add detectVite, detectNext, etc. here.
+ */
+/**
+ * W10: detect whether the project at `<root>` is a Cloudflare Workers
+ * project. Returns true if any of the standard markers are present:
+ *   - <root>/wrangler.jsonc
+ *   - <root>/wrangler.json
+ *   - <root>/wrangler.toml
+ *   - <root>/package.json with `wrangler` in deps or devDeps
+ */
+export function detectCloudflareWorkersProject(vfs, root) {
+    const r = String(root).replace(/^\/+/, '').replace(/\/+$/, '');
+    for (const f of ['wrangler.jsonc', 'wrangler.json', 'wrangler.toml']) {
+        try {
+            if (vfs.exists((r ? r + '/' : '') + f))
+                return true;
+        }
+        catch { }
+    }
+    try {
+        const pkgPath = (r ? r + '/' : '') + 'package.json';
+        if (vfs.exists(pkgPath)) {
+            const text = vfs.readFileString(pkgPath);
+            const pkg = JSON.parse(text);
+            if (pkg && typeof pkg === 'object') {
+                if (pkg.devDependencies && typeof pkg.devDependencies === 'object' && 'wrangler' in pkg.devDependencies)
+                    return true;
+                if (pkg.dependencies && typeof pkg.dependencies === 'object' && 'wrangler' in pkg.dependencies)
+                    return true;
+            }
+        }
+    }
+    catch {
+        // Malformed package.json or any other read error: not a CF Workers project per this signal.
+    }
+    return false;
+}

package/dist/runtime/python-repl.d.ts

@@ -0,0 +1,66 @@
+/**
+ * python-repl.ts — Python REPL adapter (Pyodide 0.29.4).
+ *
+ * Implements ReplAdapter for the `python` shell command's no-args
+ * invocation. Reuses the existing Pyodide v2 preamble built by
+ * python-runner.ts's `buildPyodidePreamble`; this file only adds:
+ *   1. A REPL-step facet fn that pushes a line into a long-lived
+ *      pyodide.console.PyodideConsole instance and returns the
+ *      result.
+ *   2. Adapter wiring (banner, push, close, ps1/ps2 prompts).
+ *
+ * Design per /workspace/.seal-internal/2026-05-11-repl-plan/plan.md §5:
+ *   - State persistence: same NimbusLoaderPool reference held across
+ *     submits → same child-facet isolate → globalThis.__nimbusPyodideInstance
+ *     persists.
+ *   - Continuation prompts: PyodideConsole's runsource() returns an
+ *     'incomplete' status when input is mid-block (e.g. unclosed
+ *     `def f():`); the adapter signals 'incomplete' back to ReplSession,
+ *     which renders ps2 ('... ') and accumulates.
+ *   - sys.exit() / exit() / quit(): captured via SystemExit on the
+ *     pyodide.console.Console runtime; returned as ReplPushResult
+ *     'exit' with the captured code.
+ *
+ * NOT supported in v1 (deferred to W5+):
+ *   - top-level await at the REPL prompt (Pyodide supports this via
+ *     runPythonAsync; v1 uses runsource synchronously).
+ *   - Tab-completion (PyodideConsole has rlcompleter; surface deferred).
+ *   - SIGINT mid-statement (no interrupt-buffer plumbing yet).
+ */
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+import type { FacetManager } from '../facets/manager.js';
+import type { WebSocketTerminal } from '../facets/ws-terminal.js';
+/** Inputs needed to bootstrap a Pyodide REPL session. */
+export interface PythonReplDeps {
+    facetMgr: FacetManager;
+    vfs: SqliteVFS;
+    terminal: WebSocketTerminal;
+    /** Per-user-VFS install dir, e.g. 'home/user/.nimbus/runtimes/python/0.29.4'. */
+    installRoot: string;
+    /**
+     * REPL-R7-1 (2026-05-12): optional lifo-sh Shell reference.
+     *
+     * When a user pastes / sends a multi-line WS frame like
+     * `python\nexit(7)`, lifo-sh's input handler splits on \r\n and
+     * pushes everything after the first line into shell.pasteQueue.
+     * Those lines are processed ONLY when the shell becomes idle —
+     * but our REPL is running and the shell is blocked awaiting
+     * runPythonRepl. Result: REPL hangs at `>>> ` because the input
+     * never reaches it.
+     *
+     * Threading shell here lets ReplSession drain pasteQueue
+     * immediately on attach. If undefined, the REPL still works for
+     * single-line invocations (the common case) — it just won't
+     * recover paste-pending input.
+     */
+    shell?: any;
+}
+/**
+ * Top-level wrapper: builds a Python REPL adapter, drives a
+ * ReplSession to completion, returns the exit code.
+ *
+ * Called from the python factory's wrapper in init.ts when the user
+ * runs `python` with no args.
+ */
+export declare function runPythonRepl(deps: PythonReplDeps): Promise<number>;
+//# sourceMappingURL=python-repl.d.ts.map

package/dist/runtime/python-repl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-repl.d.ts","sourceRoot":"","sources":["../../src/runtime/python-repl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAKlE,yDAAyD;AACzD,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,YAAY,CAAC;IACvB,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,EAAE,GAAG,CAAC;CACb;AAwhBD;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzE"}