@harness-fe/runtime 3.0.1 → 3.1.0

package/dist/capture.d.ts

@@ -27,6 +27,9 @@ export declare class CaptureStore {
         requestBodyTruncated?: boolean | undefined;
         responseBodyTruncated?: boolean | undefined;
         error?: string | undefined;
+        initiator?: {
+            stack?: string | undefined;
+        } | undefined;
     }>;
     readonly errors: RingBuffer<{
         ts: number;
@@ -34,14 +37,46 @@ export declare class CaptureStore {
         stack?: string | undefined;
         source?: string | undefined;
     }>;
+    readonly ws: RingBuffer<{
+        ts: number;
+        id: string;
+        phase: "open" | "send" | "recv" | "close";
+        url: string;
+        protocols?: string[] | undefined;
+        payload?: unknown;
+        payloadTruncated?: boolean | undefined;
+        code?: number | undefined;
+        reason?: string | undefined;
+        wasClean?: boolean | undefined;
+        initiator?: {
+            stack?: string | undefined;
+        } | undefined;
+    }>;
+    readonly storage: RingBuffer<{
+        op: "set" | "remove" | "clear";
+        which: "local" | "session" | "cookie";
+        ts: number;
+        key?: string | undefined;
+        value?: string | undefined;
+        crossTab?: boolean | undefined;
+        initiator?: {
+            stack?: string | undefined;
+        } | undefined;
+    }>;
     private installed;
     private fetchDispose?;
     private xhrDispose?;
-    install(onEvent: (name: string, payload: unknown) => void): void;
+    private wsDispose?;
+    private storageDispose?;
+    install(onEvent: (name: string, payload: unknown) => void, opts?: {
+        daemonUrl?: string;
+    }): void;
     dispose(): void;
     private installConsole;
     private installFetch;
     private installXhr;
+    private installWs;
+    private installStorage;
     private installErrors;
 }
 export declare function getCaptureStore(): CaptureStore;

package/dist/capture.js

@@ -7,23 +7,33 @@
 import { RingBuffer } from './buffer.js';
 import { installFetchPatch } from './fetchPatch.js';
 import { installXhrPatch } from './xhrPatch.js';
+import { installWsPatch } from './wsPatch.js';
+import { installStoragePatch } from './storagePatch.js';
 const CONSOLE_CAP = 500;
 const NETWORK_CAP = 200;
 const ERROR_CAP = 200;
+const WS_CAP = 200;
+const STORAGE_CAP = 200;
 export class CaptureStore {
     console = new RingBuffer(CONSOLE_CAP);
     network = new RingBuffer(NETWORK_CAP);
     errors = new RingBuffer(ERROR_CAP);
+    ws = new RingBuffer(WS_CAP);
+    storage = new RingBuffer(STORAGE_CAP);
     installed = false;
     fetchDispose;
     xhrDispose;
-    install(onEvent) {
+    wsDispose;
+    storageDispose;
+    install(onEvent, opts = {}) {
         if (this.installed)
             return;
         this.installed = true;
         this.installConsole(onEvent);
         this.installFetch(onEvent);
         this.installXhr(onEvent);
+        this.installWs(onEvent, opts.daemonUrl);
+        this.installStorage(onEvent);
         this.installErrors(onEvent);
     }
     dispose() {
@@ -31,6 +41,10 @@ export class CaptureStore {
         this.fetchDispose = undefined;
         this.xhrDispose?.();
         this.xhrDispose = undefined;
+        this.wsDispose?.();
+        this.wsDispose = undefined;
+        this.storageDispose?.();
+        this.storageDispose = undefined;
         this.installed = false;
     }
     installConsole(onEvent) {
@@ -65,6 +79,31 @@ export class CaptureStore {
             },
         });
     }
+    installWs(onEvent, daemonUrl) {
+        // Add the daemon URL itself to the denylist so our own bridge
+        // connection isn't intercepted (otherwise every event we send
+        // would emit a `ws send` that loops back into the outbox).
+        const extra = [];
+        if (daemonUrl) {
+            const escaped = daemonUrl.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            extra.push(new RegExp(`^${escaped}`));
+        }
+        this.wsDispose = installWsPatch({
+            denylist: extra.length > 0 ? [/\/__hfe\//, /sockjs-node/, ...extra] : undefined,
+            onEntry: (entry) => {
+                this.ws.push(entry);
+                onEvent('ws', entry);
+            },
+        });
+    }
+    installStorage(onEvent) {
+        this.storageDispose = installStoragePatch({
+            onEntry: (entry) => {
+                this.storage.push(entry);
+                onEvent('storage', entry);
+            },
+        });
+    }
     installErrors(onEvent) {
         if (typeof window === 'undefined')
             return;

package/dist/client.js

@@ -111,7 +111,8 @@ export class RuntimeClient {
         publishVisitorIdToWindow(this.visitorId);
     }
     start() {
-        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/dist/commands.js

@@ -276,17 +276,159 @@ export const commandHandlers = {
     },
     [COMMAND.CONSOLE_TAIL]: async (raw, ctx) => {
         const args = raw;
-        return { entries: ctx.capture.console.tail(args.n) };
+        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;
-        return { entries: ctx.capture.network.tail(args.n) };
+        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;
-        return { entries: ctx.capture.errors.tail(args.n) };
+        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;
+        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;
+        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;
+        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;
+        // 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;
+        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;
+        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 });
+            }) };
     },
 };
+/**
+ * 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) {
+    try {
+        return new RegExp(source, 'i');
+    }
+    catch {
+        return undefined;
+    }
+}
+function filterTail(items, args, pickHaystack) {
+    const filter = args.filter?.trim();
+    const useRegex = args.match === 'regex';
+    let regex;
+    if (filter && useRegex) {
+        try {
+            regex = new RegExp(filter, 'i');
+        }
+        catch {
+            // Invalid regex: fall back to substring match rather than throwing.
+            regex = undefined;
+        }
+    }
+    const out = [];
+    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, n) {
     if (s.length <= n)
         return s;

package/dist/fetchPatch.js

@@ -22,6 +22,7 @@
  * The patch is idempotent (re-install is a no-op) and returns a dispose
  * function that restores the original `window.fetch`.
  */
+import { captureInitiator } from './initiator.js';
 const DEFAULT_BODY_CAP = 256 * 1024;
 const INTERNAL_FLAG = '__hfeInternal';
 const PATCHED_FLAG = '__hfePatched';
@@ -56,6 +57,7 @@ export function installFetchPatch(opts) {
         const id = generateId();
         const startedAt = performance.now();
         const startedTs = Date.now();
+        const initiator = captureInitiator();
         // Emit request record eagerly (req body is read async — second emit
         // updates the record once body is serialized; consumers join by id).
         const reqRecord = {
@@ -65,6 +67,7 @@ export function installFetchPatch(opts) {
             method: meta.method,
             url: meta.url,
             requestHeaders: meta.headers,
+            initiator,
         };
         emit(reqRecord);
         cloneRequestBody(input, init, bodyCap).then(({ body, truncated }) => {

package/dist/initiator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Initiator stack capture — answers "who issued this network/storage call?".
+ *
+ * Called synchronously from inside a patched API (fetch / xhr / ws / storage).
+ * `new Error().stack` walks the JS call stack from the V8 perspective:
+ *   - frame 0: this helper
+ *   - frame 1: the patched wrapper
+ *   - frame 2+: caller code
+ *
+ * We trim the first 2 frames so the returned `stack` starts at the business
+ * code that triggered the call. Best-effort: shapes vary across engines, so
+ * if the format is unexpected we return the raw stack.
+ *
+ * Cost: ~0.2–0.5 ms per call on a modern V8. Safe to leave on in development;
+ * gated behind NODE_ENV elsewhere so production is unaffected.
+ */
+export interface Initiator {
+    stack?: string;
+}
+export declare function captureInitiator(): Initiator;

package/dist/initiator.js

@@ -0,0 +1,34 @@
+/**
+ * Initiator stack capture — answers "who issued this network/storage call?".
+ *
+ * Called synchronously from inside a patched API (fetch / xhr / ws / storage).
+ * `new Error().stack` walks the JS call stack from the V8 perspective:
+ *   - frame 0: this helper
+ *   - frame 1: the patched wrapper
+ *   - frame 2+: caller code
+ *
+ * We trim the first 2 frames so the returned `stack` starts at the business
+ * code that triggered the call. Best-effort: shapes vary across engines, so
+ * if the format is unexpected we return the raw stack.
+ *
+ * Cost: ~0.2–0.5 ms per call on a modern V8. Safe to leave on in development;
+ * gated behind NODE_ENV elsewhere so production is unaffected.
+ */
+const FRAMES_TO_TRIM = 2;
+export function captureInitiator() {
+    const err = new Error();
+    const raw = err.stack;
+    if (!raw)
+        return {};
+    const lines = raw.split('\n');
+    if (lines.length <= FRAMES_TO_TRIM + 1)
+        return { stack: raw };
+    // Preserve the "Error" header line + caller frames. Drop the frames
+    // representing the helper and the patched wrapper.
+    const header = lines[0].startsWith('Error') ? lines[0] : '';
+    const callerFrames = lines.slice(FRAMES_TO_TRIM + 1);
+    const trimmed = header
+        ? [header, ...callerFrames].join('\n')
+        : callerFrames.join('\n');
+    return { stack: trimmed };
+}

package/dist/storagePatch.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Storage monkey-patch — captures localStorage / sessionStorage / cookie
+ * mutations so agents can answer "who deleted my token?".
+ *
+ * Safety contract (mirrors fetchPatch / wsPatch):
+ *  1. Identity-preserving: replacements use Object.defineProperty so
+ *     `localStorage.setItem` keeps its prototype membership. Cookie wrapping
+ *     uses a `document` getter/setter pair on the prototype.
+ *  2. Error-isolated: capture failures swallowed; never propagate to callers.
+ *  3. No timing or value change: every wrapper calls the original synchronously
+ *     and returns its result.
+ *  4. crossTab events captured via the native `storage` event (no initiator —
+ *     the mutation happened in another tab so the stack is meaningless here).
+ *
+ * Idempotent. Returns a dispose function.
+ */
+import type { StorageEntry } from '@harness-fe/protocol';
+export interface StoragePatchOptions {
+    onEntry: (entry: StorageEntry) => void;
+    /** Per-value byte cap. Default 4 KB — captures small tokens, drops giant blobs. */
+    valueCap?: number;
+}
+export declare function installStoragePatch(opts: StoragePatchOptions): () => void;

package/dist/storagePatch.js

@@ -0,0 +1,190 @@
+/**
+ * Storage monkey-patch — captures localStorage / sessionStorage / cookie
+ * mutations so agents can answer "who deleted my token?".
+ *
+ * Safety contract (mirrors fetchPatch / wsPatch):
+ *  1. Identity-preserving: replacements use Object.defineProperty so
+ *     `localStorage.setItem` keeps its prototype membership. Cookie wrapping
+ *     uses a `document` getter/setter pair on the prototype.
+ *  2. Error-isolated: capture failures swallowed; never propagate to callers.
+ *  3. No timing or value change: every wrapper calls the original synchronously
+ *     and returns its result.
+ *  4. crossTab events captured via the native `storage` event (no initiator —
+ *     the mutation happened in another tab so the stack is meaningless here).
+ *
+ * Idempotent. Returns a dispose function.
+ */
+import { captureInitiator } from './initiator.js';
+const PATCHED_FLAG = '__hfeStoragePatched';
+const DEFAULT_VALUE_CAP = 4 * 1024;
+export function installStoragePatch(opts) {
+    if (typeof window === 'undefined')
+        return () => { };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (window[PATCHED_FLAG])
+        return () => { };
+    const valueCap = opts.valueCap ?? DEFAULT_VALUE_CAP;
+    const emit = (entry) => {
+        try {
+            opts.onEntry(entry);
+        }
+        catch {
+            /* swallow */
+        }
+    };
+    const disposers = [];
+    // Patch each storage instance directly — own properties shadow the
+    // prototype regardless of how the engine implements them. This works
+    // uniformly across real browsers, happy-dom, jsdom, and Electron.
+    try {
+        disposers.push(patchStorageInstance(window.localStorage, 'local', valueCap, emit));
+    }
+    catch { /* localStorage may be inaccessible (private mode, etc.) */ }
+    try {
+        disposers.push(patchStorageInstance(window.sessionStorage, 'session', valueCap, emit));
+    }
+    catch { /* ignore */ }
+    if (typeof document !== 'undefined') {
+        const cookieDispose = patchCookie(valueCap, emit);
+        if (cookieDispose)
+            disposers.push(cookieDispose);
+    }
+    // Cross-tab storage events.
+    const onStorageEvent = (ev) => {
+        const which = ev.storageArea === window.sessionStorage ? 'session' : 'local';
+        const op = ev.key === null ? 'clear' : ev.newValue === null ? 'remove' : 'set';
+        emit({
+            ts: Date.now(),
+            op,
+            which,
+            key: ev.key ?? undefined,
+            value: ev.newValue !== null ? clip(ev.newValue, valueCap) : undefined,
+            crossTab: true,
+        });
+    };
+    window.addEventListener('storage', onStorageEvent);
+    disposers.push(() => window.removeEventListener('storage', onStorageEvent));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    window[PATCHED_FLAG] = true;
+    return () => {
+        for (const d of disposers) {
+            try {
+                d();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        delete window[PATCHED_FLAG];
+    };
+}
+/**
+ * Patch Storage.prototype.setItem / removeItem / clear. Both localStorage and
+ * sessionStorage share the same prototype, so one patch covers both — we
+ * disambiguate at call time via `this === window.sessionStorage`.
+ */
+function patchStorageInstance(storage, kind, valueCap, emit) {
+    const origSet = storage.setItem.bind(storage);
+    const origRemove = storage.removeItem.bind(storage);
+    const origClear = storage.clear.bind(storage);
+    Object.defineProperty(storage, 'setItem', {
+        configurable: true, writable: true,
+        value: (key, value) => {
+            emit({ ts: Date.now(), op: 'set', which: kind, key, value: clip(value, valueCap), initiator: captureInitiator() });
+            origSet(key, value);
+        },
+    });
+    Object.defineProperty(storage, 'removeItem', {
+        configurable: true, writable: true,
+        value: (key) => {
+            emit({ ts: Date.now(), op: 'remove', which: kind, key, initiator: captureInitiator() });
+            origRemove(key);
+        },
+    });
+    Object.defineProperty(storage, 'clear', {
+        configurable: true, writable: true,
+        value: () => {
+            emit({ ts: Date.now(), op: 'clear', which: kind, initiator: captureInitiator() });
+            origClear();
+        },
+    });
+    return () => {
+        // Restore by replacing the own properties with thin shims that
+        // forward to the captured originals. `delete` doesn't reliably
+        // expose the prototype method in every engine (happy-dom in
+        // particular), so this is the safer reset.
+        try {
+            Object.defineProperty(storage, 'setItem', {
+                configurable: true, writable: true,
+                value: (k, v) => origSet(k, v),
+            });
+            Object.defineProperty(storage, 'removeItem', {
+                configurable: true, writable: true,
+                value: (k) => origRemove(k),
+            });
+            Object.defineProperty(storage, 'clear', {
+                configurable: true, writable: true,
+                value: () => origClear(),
+            });
+        }
+        catch { /* ignore */ }
+    };
+}
+function patchCookie(valueCap, emit) {
+    const descriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
+    if (!descriptor || !descriptor.set || !descriptor.get)
+        return undefined;
+    const origSet = descriptor.set;
+    const origGet = descriptor.get;
+    Object.defineProperty(Document.prototype, 'cookie', {
+        configurable: true,
+        get() {
+            return origGet.call(this);
+        },
+        set(val) {
+            const initiator = captureInitiator();
+            const { key, value, removed } = parseCookieAssignment(val);
+            emit({
+                ts: Date.now(),
+                op: removed ? 'remove' : 'set',
+                which: 'cookie',
+                key,
+                value: removed ? undefined : value !== undefined ? clip(value, valueCap) : undefined,
+                initiator,
+            });
+            return origSet.call(this, val);
+        },
+    });
+    return () => {
+        Object.defineProperty(Document.prototype, 'cookie', descriptor);
+    };
+}
+/**
+ * Cookie writes look like "key=value; Path=/; Expires=...; Max-Age=0".
+ * Treat Max-Age=0 or any past Expires as removal. Anything else is set.
+ */
+function parseCookieAssignment(raw) {
+    const parts = raw.split(';');
+    const head = (parts[0] ?? '').trim();
+    const eq = head.indexOf('=');
+    const key = eq >= 0 ? head.slice(0, eq) : head;
+    const value = eq >= 0 ? head.slice(eq + 1) : undefined;
+    let removed = false;
+    for (let i = 1; i < parts.length; i++) {
+        const seg = parts[i].trim();
+        const lower = seg.toLowerCase();
+        if (lower === 'max-age=0' || lower === 'max-age=-1')
+            removed = true;
+        if (lower.startsWith('expires=')) {
+            const date = new Date(seg.slice('expires='.length).trim());
+            if (!Number.isNaN(date.getTime()) && date.getTime() <= Date.now()) {
+                removed = true;
+            }
+        }
+    }
+    return { key: key || undefined, value, removed };
+}
+function clip(s, cap) {
+    return s.length <= cap ? s : `${s.slice(0, cap)}…[+${s.length - cap}B]`;
+}

package/dist/wsPatch.d.ts

@@ -0,0 +1,26 @@
+/**
+ * WebSocket monkey-patch — captures open / send / recv / close frames so
+ * agents can see long-lived push channels (IM, presence, sync, kick-out).
+ *
+ * Safety contract (mirrors fetchPatch):
+ *  1. Identity-preserving: replacement is a constructor with the same name,
+ *     prototype, and CONNECTING/OPEN/CLOSING/CLOSED static fields. Existing
+ *     `instanceof WebSocket` checks still pass because we extend the original.
+ *  2. Error-isolated: capture failures swallowed via safeEmit.
+ *  3. No timing or value change: pass-through to native WebSocket; we only
+ *     observe events and call sites. The original Promise / data flow is
+ *     untouched.
+ *  4. Bounded memory: frame payloads capped at BODY_CAP per send/recv. Binary
+ *     frames record a `[binary Nb]` marker rather than the bytes.
+ *
+ * The patch is idempotent. Returns a dispose function that restores
+ * `window.WebSocket`.
+ */
+import type { WsEntry } from '@harness-fe/protocol';
+export interface WsPatchOptions {
+    onEntry: (entry: WsEntry) => void;
+    bodyCap?: number;
+    /** URL patterns to skip entirely. Default skips daemon traffic. */
+    denylist?: RegExp[];
+}
+export declare function installWsPatch(opts: WsPatchOptions): () => void;