@harness-fe/runtime 3.0.1 → 3.2.0

package/src/capture.ts

@@ -1,110 +1,140 @@
 /**
- * Console + network + error capture. Monkey-patches in place once on init.
+ * CaptureStore — thin adapter on top of `@harness-fe/sandbox`.
  *
- * Network capture covers fetch + XMLHttpRequest. Body capture is opt-in
- * per-request to keep memory bounded.
+ * Sandbox does the actual browser-API patching (fetch / xhr / ws / storage /
+ * navigation / console / errors / globals / indexeddb) and exposes a unified
+ * observer + interceptor surface. This module only:
+ *   1. Installs sandbox with the runtime's `onEvent` callback wired in.
+ *   2. Adapts each `SandboxEvent` into the harness-fe protocol shape
+ *      (`NetworkEntry` / `WsEntry` / `StorageEntry` / `ConsoleEntry` /
+ *      `ErrorEntry`) so the daemon's existing ingestion + tail tools keep
+ *      working unchanged.
+ *   3. Mirrors events into bounded `RingBuffer`s so the runtime's
+ *      `console.tail` / `network.tail` / `ws.tail` / `storage.tail` MCP tool
+ *      handlers have something to read.
+ *
+ * Identity / interceptor / reentry safety all live in sandbox.
  */
 
 import type {
     ConsoleEntry,
     ErrorEntry,
     NetworkEntry,
+    WsEntry,
+    StorageEntry,
+    NavigationEntry,
+    GlobalsEntry,
+    IndexedDbEntry,
 } from '@harness-fe/protocol';
+import {
+    installSandbox,
+    type SandboxEvent,
+    type SandboxHandle,
+    type FetchReqObservation,
+    type FetchResObservation,
+    type WsObservation,
+    type StorageObservation,
+    type ConsoleObservation,
+    type ErrorObservation,
+    type NavigationObservation,
+    type GlobalsObservation,
+    type IndexedDbObservation,
+} from '@harness-fe/sandbox';
 import { RingBuffer } from './buffer.js';
-import { installFetchPatch } from './fetchPatch.js';
-import { installXhrPatch } from './xhrPatch.js';
 
 const CONSOLE_CAP = 500;
 const NETWORK_CAP = 200;
 const ERROR_CAP = 200;
+const WS_CAP = 200;
+const STORAGE_CAP = 200;
+const NAVIGATION_CAP = 100;
+const GLOBALS_CAP = 200;
+const INDEXEDDB_CAP = 200;
 
 export class CaptureStore {
     readonly console = new RingBuffer<ConsoleEntry>(CONSOLE_CAP);
     readonly network = new RingBuffer<NetworkEntry>(NETWORK_CAP);
     readonly errors = new RingBuffer<ErrorEntry>(ERROR_CAP);
+    readonly ws = new RingBuffer<WsEntry>(WS_CAP);
+    readonly storage = new RingBuffer<StorageEntry>(STORAGE_CAP);
+    readonly navigation = new RingBuffer<NavigationEntry>(NAVIGATION_CAP);
+    readonly globals = new RingBuffer<GlobalsEntry>(GLOBALS_CAP);
+    readonly indexeddb = new RingBuffer<IndexedDbEntry>(INDEXEDDB_CAP);
+
+    private handle?: SandboxHandle;
 
-    private installed = false;
-    private fetchDispose?: () => void;
-    private xhrDispose?: () => void;
-
-    install(onEvent: (name: string, payload: unknown) => void): void {
-        if (this.installed) return;
-        this.installed = true;
-        this.installConsole(onEvent);
-        this.installFetch(onEvent);
-        this.installXhr(onEvent);
-        this.installErrors(onEvent);
+    install(
+        onEvent: (name: string, payload: unknown) => void,
+        opts: { daemonUrl?: string } = {},
+    ): void {
+        if (this.handle) return;
+        const selfUrls = opts.daemonUrl ? [opts.daemonUrl] : undefined;
+        this.handle = installSandbox({
+            selfUrls,
+            onEvent: (e) => this.adapt(e, onEvent),
+        });
     }
 
     dispose(): void {
-        this.fetchDispose?.();
-        this.fetchDispose = undefined;
-        this.xhrDispose?.();
-        this.xhrDispose = undefined;
-        this.installed = false;
+        this.handle?.dispose();
+        this.handle = undefined;
     }
 
-    private installConsole(onEvent: (name: string, payload: unknown) => void): void {
-        const methods: Array<ConsoleEntry['level']> = ['log', 'info', 'warn', 'error', 'debug'];
-        for (const level of methods) {
-            const original = console[level].bind(console);
-            console[level] = (...args: unknown[]) => {
-                const entry: ConsoleEntry = {
-                    ts: Date.now(),
-                    level,
-                    args: args.map(safeClone),
-                };
+    private adapt(e: SandboxEvent, onEvent: (name: string, payload: unknown) => void): void {
+        switch (e.source) {
+            case 'fetch':
+            case 'xhr': {
+                const entry = adaptFetchLike(e);
+                this.network.push(entry);
+                onEvent('network', entry);
+                return;
+            }
+            case 'ws': {
+                const entry = adaptWs(e);
+                this.ws.push(entry);
+                onEvent('ws', entry);
+                return;
+            }
+            case 'storage': {
+                const entry = adaptStorage(e);
+                if (entry) {
+                    this.storage.push(entry);
+                    onEvent('storage', entry);
+                }
+                return;
+            }
+            case 'console': {
+                const entry = adaptConsole(e);
                 this.console.push(entry);
                 onEvent('console', entry);
-                original(...args);
-            };
+                return;
+            }
+            case 'errors': {
+                const entry = adaptError(e);
+                this.errors.push(entry);
+                onEvent('error', entry);
+                return;
+            }
+            case 'navigation': {
+                const entry = adaptNavigation(e);
+                this.navigation.push(entry);
+                onEvent('navigation', entry);
+                return;
+            }
+            case 'globals': {
+                const entry = adaptGlobals(e);
+                this.globals.push(entry);
+                onEvent('globals', entry);
+                return;
+            }
+            case 'indexeddb': {
+                const entry = adaptIndexedDb(e);
+                this.indexeddb.push(entry);
+                onEvent('indexeddb', entry);
+                return;
+            }
         }
     }
-
-    private installFetch(onEvent: (name: string, payload: unknown) => void): void {
-        this.fetchDispose = installFetchPatch({
-            onEntry: (entry) => {
-                this.network.push(entry);
-                onEvent('network', entry);
-            },
-        });
-    }
-
-    private installXhr(onEvent: (name: string, payload: unknown) => void): void {
-        this.xhrDispose = installXhrPatch({
-            onEntry: (entry) => {
-                this.network.push(entry);
-                onEvent('network', entry);
-            },
-        });
-    }
-
-    private installErrors(onEvent: (name: string, payload: unknown) => void): void {
-        if (typeof window === 'undefined') return;
-        window.addEventListener('error', (e: ErrorEvent) => {
-            const entry: ErrorEntry = {
-                ts: Date.now(),
-                message: e.message,
-                stack: e.error?.stack,
-                source: e.filename ? `${e.filename}:${e.lineno}:${e.colno}` : undefined,
-            };
-            this.errors.push(entry);
-            onEvent('error', entry);
-        });
-        window.addEventListener('unhandledrejection', (e: PromiseRejectionEvent) => {
-            const reason: unknown = e.reason;
-            const message =
-                reason instanceof Error ? reason.message : String(reason ?? 'unhandled rejection');
-            const stack = reason instanceof Error ? reason.stack : undefined;
-            const entry: ErrorEntry = {
-                ts: Date.now(),
-                message: `Unhandled: ${message}`,
-                stack,
-            };
-            this.errors.push(entry);
-            onEvent('error', entry);
-        });
-    }
 }
 
 let captureStoreSingleton: CaptureStore | undefined;
@@ -113,14 +143,130 @@ export function getCaptureStore(): CaptureStore {
     return captureStoreSingleton;
 }
 
-function safeClone(value: unknown): unknown {
-    if (value === null) return null;
-    if (typeof value === 'object') {
-        try {
-            return JSON.parse(JSON.stringify(value));
-        } catch {
-            return String(value);
-        }
+// ────────────────────────────────────────────────────────────────────
+// SandboxEvent → harness-fe protocol entry adapters
+// ────────────────────────────────────────────────────────────────────
+
+function adaptFetchLike(e: SandboxEvent & { source: 'fetch' | 'xhr' }): NetworkEntry {
+    const d = e.data as FetchReqObservation | FetchResObservation;
+    if (e.kind === 'req') {
+        const r = d as FetchReqObservation;
+        return {
+            ts: e.ts,
+            id: r.id,
+            phase: 'req',
+            method: r.method,
+            url: r.url,
+            requestHeaders: r.headers,
+            requestBody: r.body,
+            requestBodyTruncated: r.bodyTruncated || undefined,
+            initiator: e.initiator,
+        };
     }
-    return value;
+    const r = d as FetchResObservation;
+    return {
+        ts: e.ts,
+        id: r.id,
+        phase: 'res',
+        method: r.method,
+        url: r.url,
+        status: r.status,
+        durationMs: r.durationMs,
+        responseHeaders: r.headers,
+        responseBody: r.body,
+        responseBodyTruncated: r.bodyTruncated || undefined,
+        error: r.error,
+        initiator: e.initiator,
+    };
+}
+
+function adaptWs(e: SandboxEvent & { source: 'ws' }): WsEntry {
+    const d = e.data as WsObservation;
+    return {
+        ts: e.ts,
+        id: d.id,
+        phase: d.phase,
+        url: d.url,
+        protocols: d.protocols,
+        payload: d.payload,
+        payloadTruncated: d.payloadTruncated,
+        code: d.code,
+        reason: d.reason,
+        wasClean: d.wasClean,
+        initiator: e.initiator,
+    };
+}
+
+function adaptStorage(e: SandboxEvent & { source: 'storage' }): StorageEntry | null {
+    const d = e.data as StorageObservation;
+    // Sandbox emits a 'get' op; harness-fe protocol storage only models set/remove/clear.
+    if (d.op === 'get') return null;
+    return {
+        ts: e.ts,
+        op: d.op,
+        which: d.which,
+        key: d.key,
+        value: d.value,
+        crossTab: d.crossTab,
+        initiator: e.initiator,
+    };
+}
+
+function adaptConsole(e: SandboxEvent & { source: 'console' }): ConsoleEntry {
+    const d = e.data as ConsoleObservation;
+    return {
+        ts: e.ts,
+        level: d.level,
+        args: d.args,
+    };
+}
+
+function adaptError(e: SandboxEvent & { source: 'errors' }): ErrorEntry {
+    const d = e.data as ErrorObservation;
+    return {
+        ts: e.ts,
+        message: d.message,
+        stack: d.stack,
+        source: d.source,
+    };
+}
+
+function adaptNavigation(e: SandboxEvent & { source: 'navigation' }): NavigationEntry {
+    const d = e.data as NavigationObservation;
+    return {
+        ts: e.ts,
+        kind: d.kind,
+        url: d.url,
+        state: d.state,
+        replace: d.replace,
+        initiator: e.initiator,
+    };
+}
+
+function adaptGlobals(e: SandboxEvent & { source: 'globals' }): GlobalsEntry {
+    const d = e.data as GlobalsObservation;
+    return {
+        ts: e.ts,
+        op: d.op,
+        key: d.key,
+        value: d.value,
+        previousValue: d.previousValue,
+        initiator: e.initiator,
+    };
+}
+
+function adaptIndexedDb(e: SandboxEvent & { source: 'indexeddb' }): IndexedDbEntry {
+    const d = e.data as IndexedDbObservation;
+    return {
+        ts: e.ts,
+        op: d.op,
+        db: d.db,
+        version: d.version,
+        store: d.store,
+        key: d.key,
+        value: d.value,
+        success: d.success,
+        error: d.error,
+        initiator: e.initiator,
+    };
 }

package/src/client.ts

@@ -163,7 +163,11 @@ export class RuntimeClient {
 
 
     start(): void {
-        this.ctx.capture.install((name, payload) => this.sendEvent(name, payload));
+        const daemonUrl = this.opts.mcpUrl ?? `ws://127.0.0.1:${DEFAULT_WS_PORT}`;
+        this.ctx.capture.install(
+            (name, payload) => this.sendEvent(name, payload),
+            { daemonUrl },
+        );
         this.recorder.start();
         this.connect();
     }

package/src/commands.ts

@@ -305,21 +305,208 @@ export const commandHandlers: Record<string, CommandHandler> = {
     },
 
     [COMMAND.CONSOLE_TAIL]: async (raw, ctx) => {
-        const args = raw as { n: number };
-        return { entries: ctx.capture.console.tail(args.n) };
+        const args = raw as TailArgs & { level?: string };
+        const all = ctx.capture.console.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.level && e.level !== args.level) return undefined;
+            return JSON.stringify({ level: e.level, args: e.args });
+        }) };
     },
 
     [COMMAND.NETWORK_TAIL]: async (raw, ctx) => {
-        const args = raw as { n: number };
-        return { entries: ctx.capture.network.tail(args.n) };
+        const args = raw as TailArgs & {
+            urlContains?: string;
+            method?: string;
+            statusCode?: number;
+        };
+        const all = ctx.capture.network.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.urlContains && !e.url.includes(args.urlContains)) return undefined;
+            if (args.method && e.method.toUpperCase() !== args.method.toUpperCase()) return undefined;
+            if (args.statusCode !== undefined && e.status !== args.statusCode) return undefined;
+            return JSON.stringify({ url: e.url, method: e.method, requestBody: e.requestBody, responseBody: e.responseBody });
+        }) };
     },
 
     [COMMAND.ERRORS_TAIL]: async (raw, ctx) => {
-        const args = raw as { n: number };
-        return { entries: ctx.capture.errors.tail(args.n) };
+        const args = raw as TailArgs;
+        const all = ctx.capture.errors.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) =>
+            JSON.stringify({ message: e.message, stack: e.stack, source: e.source }),
+        ) };
+    },
+
+    [COMMAND.WS_TAIL]: async (raw, ctx) => {
+        const args = raw as TailArgs & { phase?: string };
+        const all = ctx.capture.ws.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.phase && e.phase !== args.phase) return undefined;
+            return JSON.stringify({ url: e.url, payload: e.payload, reason: e.reason });
+        }) };
+    },
+
+    [COMMAND.NETWORK_WAIT_FOR]: async (raw, ctx) => {
+        const args = raw as {
+            urlContains?: string;
+            urlRegex?: string;
+            method?: string;
+            statusCode?: number;
+            timeoutMs?: number;
+        };
+        const timeoutMs = args.timeoutMs ?? 10_000;
+        const deadline = Date.now() + timeoutMs;
+        const regex = args.urlRegex ? safeRegex(args.urlRegex) : undefined;
+        // Anchor on the existing buffer head so we only consider new requests
+        // (otherwise an old matching entry would resolve immediately).
+        const baselineLen = ctx.capture.network.size();
+        while (Date.now() < deadline) {
+            const all = ctx.capture.network.tail(500);
+            const newOnes = all.slice(Math.max(0, all.length - (ctx.capture.network.size() - baselineLen)));
+            for (const e of newOnes) {
+                if (args.urlContains && !e.url.includes(args.urlContains)) continue;
+                if (regex && !regex.test(e.url)) continue;
+                if (args.method && e.method.toUpperCase() !== args.method.toUpperCase()) continue;
+                if (args.statusCode !== undefined && e.status !== args.statusCode) continue;
+                return { ok: true, entry: e, after: Date.now() };
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        throw new Error(`network.wait_for: no matching request within ${timeoutMs}ms`);
+    },
+
+    [COMMAND.NETWORK_WAIT_FOR_IDLE]: async (raw, ctx) => {
+        const args = raw as { idleMs?: number; timeoutMs?: number };
+        const idleMs = args.idleMs ?? 500;
+        const timeoutMs = args.timeoutMs ?? 10_000;
+        const deadline = Date.now() + timeoutMs;
+        let lastSize = ctx.capture.network.size();
+        let stableSince = Date.now();
+        while (Date.now() < deadline) {
+            const currentSize = ctx.capture.network.size();
+            if (currentSize !== lastSize) {
+                lastSize = currentSize;
+                stableSince = Date.now();
+            } else if (Date.now() - stableSince >= idleMs) {
+                return { ok: true, idleFor: Date.now() - stableSince, after: Date.now() };
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        throw new Error(`network.wait_for_idle: never quiet for ${idleMs}ms within ${timeoutMs}ms`);
+    },
+
+    [COMMAND.NETWORK_GET]: async (raw, ctx) => {
+        const args = raw as { reqId: string };
+        // Return both req + res entries for this id (one or both may exist).
+        const all = ctx.capture.network.tail(200);
+        const matches = all.filter((e) => e.id === args.reqId);
+        return { entries: matches, found: matches.length > 0 };
+    },
+
+    [COMMAND.WS_GET]: async (raw, ctx) => {
+        const args = raw as { wsId: string };
+        const all = ctx.capture.ws.tail(200);
+        const matches = all.filter((e) => e.id === args.wsId);
+        return { entries: matches, found: matches.length > 0 };
+    },
+
+    [COMMAND.STORAGE_TAIL]: async (raw, ctx) => {
+        const args = raw as TailArgs & {
+            which?: string;
+            op?: string;
+            key?: string;
+        };
+        const all = ctx.capture.storage.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.which && e.which !== args.which) return undefined;
+            if (args.op && e.op !== args.op) return undefined;
+            if (args.key && e.key !== args.key) return undefined;
+            return JSON.stringify({ op: e.op, which: e.which, key: e.key, value: e.value });
+        }) };
+    },
+
+    [COMMAND.NAVIGATION_TAIL]: async (raw, ctx) => {
+        const args = raw as TailArgs & { kind?: string };
+        const all = ctx.capture.navigation.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.kind && e.kind !== args.kind) return undefined;
+            return JSON.stringify({ kind: e.kind, url: e.url, replace: e.replace });
+        }) };
+    },
+
+    [COMMAND.GLOBALS_TAIL]: async (raw, ctx) => {
+        const args = raw as TailArgs & { op?: string; key?: string };
+        const all = ctx.capture.globals.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.op && e.op !== args.op) return undefined;
+            if (args.key && e.key !== args.key) return undefined;
+            return JSON.stringify({ op: e.op, key: e.key, value: e.value });
+        }) };
+    },
+
+    [COMMAND.INDEXEDDB_TAIL]: async (raw, ctx) => {
+        const args = raw as TailArgs & { op?: string; store?: string; db?: string };
+        const all = ctx.capture.indexeddb.tail(args.n ?? 20);
+        return { entries: filterTail(all, args, (e) => {
+            if (args.op && e.op !== args.op) return undefined;
+            if (args.store && e.store !== args.store) return undefined;
+            if (args.db && e.db !== args.db) return undefined;
+            return JSON.stringify({ op: e.op, store: e.store, key: e.key });
+        }) };
     },
 };
 
+interface TailArgs {
+    n?: number;
+    filter?: string;
+    match?: 'contains' | 'regex';
+}
+
+/**
+ * Apply caller-supplied filtering to a tail() result. `pickHaystack` returns
+ * the string to match against (or `undefined` to drop the entry due to a
+ * type-specific narrow like `level` / `urlContains`). The shared `filter`
+ * string then runs as substring (default) or regex against the haystack.
+ */
+function safeRegex(source: string): RegExp | undefined {
+    try {
+        return new RegExp(source, 'i');
+    } catch {
+        return undefined;
+    }
+}
+
+function filterTail<T>(
+    items: T[],
+    args: TailArgs,
+    pickHaystack: (item: T) => string | undefined,
+): T[] {
+    const filter = args.filter?.trim();
+    const useRegex = args.match === 'regex';
+    let regex: RegExp | undefined;
+    if (filter && useRegex) {
+        try {
+            regex = new RegExp(filter, 'i');
+        } catch {
+            // Invalid regex: fall back to substring match rather than throwing.
+            regex = undefined;
+        }
+    }
+    const out: T[] = [];
+    for (const item of items) {
+        const haystack = pickHaystack(item);
+        if (haystack === undefined) continue;
+        if (filter) {
+            if (regex) {
+                if (!regex.test(haystack)) continue;
+            } else {
+                if (!haystack.toLowerCase().includes(filter.toLowerCase())) continue;
+            }
+        }
+        out.push(item);
+    }
+    return out;
+}
+
 function truncate(s: string, n: number): string {
     if (s.length <= n) return s;
     return `${s.slice(0, n)}… (truncated, total ${s.length} chars)`;