@nimbus-sh/worker 0.1.0

package/dist/facets/ws-terminal.js

@@ -0,0 +1,207 @@
+/**
+ * WebSocket-backed terminal matching Nimbus's ITerminal interface.
+ * HeadlessTerminal has: write, writeln, onData, sendData, cols, rows, focus, clear
+ *
+ * [B'.5] The `ws` ref is no longer readonly: a wsClose leaves the
+ * Shell + this terminal alive in-memory; the next /ws upgrade calls
+ * `attach(newWs, ...)` to swap in the new socket. The buffer/flush
+ * timer state is preserved across the swap so any in-flight
+ * coalescing continues seamlessly.
+ */
+export class WebSocketTerminal {
+    ws;
+    dataCallback = null;
+    /**
+     * REPL-W1: secondary input callback installed by interactive runtimes
+     * (e.g. `python` no-args). When non-null, sendData() routes input to
+     * this callback INSTEAD of the shell. Set via attachRepl(); cleared
+     * by the disposer the attach call returns. Supports nesting (the
+     * disposer restores the prior callback).
+     *
+     * Reasoning per /workspace/.seal-internal/2026-05-11-repl-plan/plan.md
+     * §3 (Layer 2): the explicit handoff mirrors how `vim`/`less` swap
+     * the parent shell's terminal handler. Auto-detect was rejected as
+     * fragile. Additive only — when null, behavior is identical to pre-W1.
+     */
+    replCallback = null;
+    /**
+     * monaco-wave-a (2026-05-13): Editor-pane file-system bridge.
+     *
+     * When non-null, fs-* messages (fs-read / fs-write / fs-list) are
+     * routed to this callback INSTEAD of the shell. The callback is
+     * supplied by init.ts which holds the SqliteVFS handle; it uses
+     * the same `reply` lambda we provide to send back fs-*-result
+     * frames over the live WS.
+     *
+     * Additive — when null, fs-* messages are silently dropped (same
+     * pre-Wave-A behavior, since handleMessage's switch had no case
+     * for them).
+     */
+    fsCallback = null;
+    _cols = 80;
+    _rows = 24;
+    buffer = [];
+    flushTimer = null;
+    /** [B'.3] Optional tee called from flush() with the final coalesced
+     *  frame data. Used by initSession to mirror every WS output frame
+     *  into nimbus_terminal_scrollback. Single-frame granularity (not
+     *  per-write) keeps the row count bounded by the 5 ms flush cadence. */
+    onFlush;
+    constructor(ws, onFlush) {
+        this.ws = ws;
+        this.onFlush = onFlush ?? null;
+    }
+    /**
+     * [B'.5] Swap the underlying WebSocket on a warm rejoin. The Shell
+     * keeps `terminal` as a stable instance reference (it stored
+     * `this.terminal = e` in its ctor); we just point our ws ref at
+     * the new socket. The optional onFlush replaces the prior tee
+     * (initSession passes a fresh closure capturing the same
+     * self.ctx, but TypeScript-wise it's a fresh function value).
+     */
+    attach(ws, onFlush) {
+        this.ws = ws;
+        if (onFlush !== undefined)
+            this.onFlush = onFlush;
+    }
+    get cols() { return this._cols; }
+    get rows() { return this._rows; }
+    write(data) {
+        this.buffer.push(data);
+        if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => this.flush(), 5);
+        }
+    }
+    writeln(data) { this.write(data + '\r\n'); }
+    /**
+     * REPL-A1 (master plan §1): drain the buffer synchronously, bypassing
+     * the 5 ms coalescer. Used by ReplSession.submitLine to emit stdout,
+     * stderr, and the next-prompt as three discrete frames in deterministic
+     * order. Without this, all three coalesce into one `{type:'output'}`
+     * frame and probes asserting frame-order (stderr-before-stdout or
+     * prompt-after-output) see false-RED.
+     *
+     * Idempotent: cancels the pending timer + sends current buffer (if any).
+     * Safe to call on an empty buffer (no-op).
+     */
+    flushNow() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flush();
+    }
+    flush() {
+        this.flushTimer = null;
+        if (this.buffer.length === 0)
+            return;
+        const combined = this.buffer.join('');
+        this.buffer = [];
+        try {
+            this.ws.send(JSON.stringify({ type: 'output', data: combined }));
+        }
+        catch { }
+        // [B'.3] Tee to scrollback. Runs AFTER the WS send so a thrown
+        // tee can't break the live stream. Fail-soft on the call: any
+        // throw is swallowed; appendScrollback itself catches its own
+        // SQL errors via try/catch in initSession's wrapper.
+        if (this.onFlush) {
+            try {
+                this.onFlush(combined);
+            }
+            catch { }
+        }
+    }
+    onData(callback) { this.dataCallback = callback; }
+    handleMessage(msg) {
+        switch (msg.type) {
+            case 'input':
+                if (msg.data)
+                    this.sendData(msg.data);
+                break;
+            case 'resize':
+                if (msg.cols)
+                    this._cols = msg.cols;
+                if (msg.rows)
+                    this._rows = msg.rows;
+                break;
+            // monaco-wave-a (2026-05-13): editor-pane fs bridge. Route to
+            // the registered fsCallback (set by init.ts which holds the
+            // SqliteVFS). Callback uses the reply lambda to push fs-*-result
+            // frames over this WS. Untouched messages (no callback) are
+            // silently dropped — same pre-Wave-A behavior.
+            case 'fs-read':
+            case 'fs-write':
+            case 'fs-list':
+                if (this.fsCallback) {
+                    // monaco-wave-a hotfix (2026-05-13): auto-echo reqId from
+                    // the inbound msg into every reply frame. The client side
+                    // (public/s/index.html Editor.fsRequest) keys its pending-
+                    // request Map on reqId; without echo, every request hangs
+                    // until the 15s timeout. Doing the merge HERE (vs at every
+                    // reply site in init.ts's handler) means the handler stays
+                    // ignorant of multiplexing — single source of truth.
+                    const reqId = msg.reqId;
+                    const reply = (frame) => {
+                        try {
+                            const merged = (reqId !== undefined && frame && typeof frame === 'object')
+                                ? { ...frame, reqId }
+                                : frame;
+                            this.ws.send(JSON.stringify(merged));
+                        }
+                        catch { }
+                    };
+                    try {
+                        this.fsCallback(msg, reply);
+                    }
+                    catch (e) {
+                        reply({
+                            type: msg.type + '-result',
+                            path: msg.path, dir: msg.dir,
+                            ok: false,
+                            error: 'fs handler threw: ' + (e?.message || String(e)),
+                        });
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * monaco-wave-a (2026-05-13): install the fs-* message handler.
+     * The callback receives the raw message + a reply lambda that
+     * accepts a JSON-serializable frame and pushes it over this WS.
+     * Single-slot (last call wins) — init.ts is the only caller and
+     * reinstalls on warm rejoin via `attach()`.
+     */
+    onFs(cb) {
+        this.fsCallback = cb;
+    }
+    sendData(data) {
+        // REPL-W1: replCallback takes priority when set. Restored by the
+        // disposer attachRepl() returns.
+        if (this.replCallback) {
+            this.replCallback(data);
+            return;
+        }
+        if (this.dataCallback)
+            this.dataCallback(data);
+    }
+    /**
+     * REPL-W1: install a runtime-side input handler. Returns a disposer
+     * that restores the prior handler (supports nesting). Calling this
+     * does NOT change the shell's dataCallback — it just shadows it
+     * until the disposer runs.
+     */
+    attachRepl(cb) {
+        const prior = this.replCallback;
+        this.replCallback = cb;
+        return () => {
+            // Idempotent: only restore if we're still the current shadow.
+            // If a nested attachRepl ran in between, the disposer chain
+            // resolves bottom-up correctly.
+            this.replCallback = prior;
+        };
+    }
+    focus() { }
+    clear() { this.write('\x1b[2J\x1b[H'); }
+}

package/dist/git/commands.d.ts

@@ -0,0 +1,13 @@
+/**
+ * git-commands.ts — Nimbus v2.0 Git integration via isomorphic-git.
+ *
+ * Provides a full `git` command with subcommands:
+ * init, clone, status, add, commit, log, branch, checkout,
+ * diff, remote, fetch, pull, push, merge, reset, tag, stash
+ *
+ * Uses a VFS→isomorphic-git FS adapter that maps all operations
+ * to the SqliteVFS.
+ */
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+export declare function registerGitCommands(registry: any, vfs: SqliteVFS, doCtx?: DurableObjectState, doEnv?: any): void;
+//# sourceMappingURL=commands.d.ts.map

package/dist/git/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/git/commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAwKtD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,GAAG,EACb,GAAG,EAAE,SAAS,EACd,KAAK,CAAC,EAAE,kBAAkB,EAC1B,KAAK,CAAC,EAAE,GAAG,GACV,IAAI,CAwaN"}