@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/domains/streaming/handlers.impl.streaming-sse.js

@@ -1,184 +1,183 @@
 import { StreamingToolHandlersWs } from '../../domains/streaming/handlers.impl.streaming-ws.js';
 import { evaluateWithTimeout, evaluateOnNewDocumentWithTimeout, } from '../../../modules/collector/PageController.js';
-export class StreamingToolHandlersSse extends StreamingToolHandlersWs {
-    async enableSseInterceptor(maxEvents, urlFilterRaw, options) {
-        const page = await this.collector.getActivePage();
-        const injectionFn = (config) => {
-            const globalWindow = window;
-            if (!globalWindow.__jshookSSEMonitor) {
-                globalWindow.__jshookSSEMonitor = {
-                    enabled: true,
-                    patched: false,
-                    maxEvents: config.maxEvents,
-                    urlFilterRaw: config.urlFilterRaw,
-                    events: [],
-                    sources: {},
-                };
-            }
-            const state = globalWindow.__jshookSSEMonitor;
-            state.enabled = true;
-            state.maxEvents = config.maxEvents;
-            state.urlFilterRaw = config.urlFilterRaw;
-            if (state.events.length > state.maxEvents) {
-                state.events = state.events.slice(-state.maxEvents);
-            }
-            const shouldCapture = (sourceUrl) => {
-                if (!state.urlFilterRaw) {
-                    return true;
-                }
-                try {
-                    return new RegExp(state.urlFilterRaw).test(sourceUrl);
-                }
-                catch {
-                    return true;
-                }
-            };
-            const toDataString = (value) => {
-                if (typeof value === 'string') {
-                    return value;
-                }
-                if (value === null || value === undefined) {
-                    return '';
-                }
-                if (typeof value === 'object') {
-                    try {
-                        return JSON.stringify(value);
-                    }
-                    catch {
-                        return '[unserializable]';
-                    }
-                }
-                return String(value);
+function toDataString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return '[unserializable]';
+        }
+    }
+    return String(value);
+}
+function sseInjectionFn(config) {
+    const globalWindow = window;
+    if (!globalWindow.__jshookSSEMonitor) {
+        globalWindow.__jshookSSEMonitor = {
+            enabled: true,
+            patched: false,
+            maxEvents: config.maxEvents,
+            urlFilterRaw: config.urlFilterRaw,
+            events: [],
+            sources: {},
+        };
+    }
+    const state = globalWindow.__jshookSSEMonitor;
+    state.enabled = true;
+    state.maxEvents = config.maxEvents;
+    state.urlFilterRaw = config.urlFilterRaw;
+    if (state.events.length > state.maxEvents) {
+        state.events = state.events.slice(-state.maxEvents);
+    }
+    const shouldCapture = (sourceUrl) => {
+        if (!state.urlFilterRaw) {
+            return true;
+        }
+        try {
+            return new RegExp(state.urlFilterRaw).test(sourceUrl);
+        }
+        catch {
+            return true;
+        }
+    };
+    const pushEvent = (sourceUrl, eventType, rawData, lastEventId) => {
+        if (!state.enabled || !shouldCapture(sourceUrl)) {
+            return;
+        }
+        const dataString = toDataString(rawData);
+        const preview = dataString.length > 200 ? `${dataString.slice(0, 200)}…` : dataString;
+        const record = {
+            sourceUrl,
+            eventType,
+            dataPreview: preview,
+            dataLength: dataString.length,
+            lastEventId,
+            timestamp: Date.now(),
+        };
+        state.events.push(record);
+        while (state.events.length > state.maxEvents) {
+            state.events.shift();
+        }
+        const source = state.sources[sourceUrl] ??
+            {
+                url: sourceUrl,
+                status: 'connecting',
+                eventCount: 0,
             };
-            const pushEvent = (sourceUrl, eventType, rawData, lastEventId) => {
-                if (!state.enabled || !shouldCapture(sourceUrl)) {
-                    return;
-                }
-                const dataString = toDataString(rawData);
-                const preview = dataString.length > 200 ? `${dataString.slice(0, 200)}…` : dataString;
-                const record = {
-                    sourceUrl,
-                    eventType,
-                    dataPreview: preview,
-                    dataLength: dataString.length,
-                    lastEventId,
-                    timestamp: Date.now(),
-                };
-                state.events.push(record);
-                while (state.events.length > state.maxEvents) {
-                    state.events.shift();
-                }
+        source.eventCount += 1;
+        source.lastEventTimestamp = record.timestamp;
+        state.sources[sourceUrl] = source;
+    };
+    if (typeof globalWindow.EventSource === 'undefined') {
+        return {
+            success: false,
+            error: 'EventSource is not available in current page context',
+        };
+    }
+    if (!state.patched) {
+        const OriginalEventSource = globalWindow.EventSource;
+        const WrappedEventSource = function (url, eventSourceInitDict) {
+            const sourceUrl = String(url);
+            const es = new OriginalEventSource(url, eventSourceInitDict);
+            if (shouldCapture(sourceUrl)) {
                 const source = state.sources[sourceUrl] ??
                     {
                         url: sourceUrl,
                         status: 'connecting',
                         eventCount: 0,
                     };
-                source.eventCount += 1;
-                source.lastEventTimestamp = record.timestamp;
                 state.sources[sourceUrl] = source;
-            };
-            if (typeof globalWindow.EventSource === 'undefined') {
-                return {
-                    success: false,
-                    error: 'EventSource is not available in current page context',
-                };
             }
-            if (!state.patched) {
-                const OriginalEventSource = globalWindow.EventSource;
-                const WrappedEventSource = function (url, eventSourceInitDict) {
-                    const sourceUrl = String(url);
-                    const es = new OriginalEventSource(url, eventSourceInitDict);
-                    if (shouldCapture(sourceUrl)) {
-                        const source = state.sources[sourceUrl] ??
-                            {
-                                url: sourceUrl,
-                                status: 'connecting',
-                                eventCount: 0,
-                            };
-                        state.sources[sourceUrl] = source;
-                    }
-                    es.addEventListener('open', () => {
-                        const source = state.sources[sourceUrl];
-                        if (source) {
-                            source.status = 'open';
-                        }
-                        pushEvent(sourceUrl, 'open', '', null);
-                    });
-                    es.addEventListener('error', () => {
-                        const source = state.sources[sourceUrl];
-                        if (source) {
-                            source.status = 'error';
-                        }
-                        pushEvent(sourceUrl, 'error', '', null);
-                    });
-                    es.addEventListener('message', (event) => {
-                        const lastEventId = typeof event.lastEventId === 'string' && event.lastEventId.length > 0
-                            ? event.lastEventId
+            es.addEventListener('open', () => {
+                const source = state.sources[sourceUrl];
+                if (source) {
+                    source.status = 'open';
+                }
+                pushEvent(sourceUrl, 'open', '', null);
+            });
+            es.addEventListener('error', () => {
+                const source = state.sources[sourceUrl];
+                if (source) {
+                    source.status = 'error';
+                }
+                pushEvent(sourceUrl, 'error', '', null);
+            });
+            es.addEventListener('message', (event) => {
+                const lastEventId = typeof event.lastEventId === 'string' && event.lastEventId.length > 0
+                    ? event.lastEventId
+                    : null;
+                pushEvent(sourceUrl, event.type || 'message', event.data, lastEventId);
+            });
+            const originalAddEventListener = es.addEventListener.bind(es);
+            const callOriginalAddEventListener = (type, listener, listenerOpts) => {
+                originalAddEventListener(type, listener, listenerOpts);
+            };
+            const wrappedAddEventListener = (type, listener, listenerOpts) => {
+                if (type !== 'message' && type !== 'open' && type !== 'error' && listener) {
+                    const wrapped = (evt) => {
+                        const messageEvent = evt;
+                        const lastEventId = typeof messageEvent.lastEventId === 'string' && messageEvent.lastEventId.length > 0
+                            ? messageEvent.lastEventId
                             : null;
-                        pushEvent(sourceUrl, event.type || 'message', event.data, lastEventId);
-                    });
-                    const originalAddEventListener = es.addEventListener.bind(es);
-                    const callOriginalAddEventListener = (type, listener, options) => {
-                        originalAddEventListener(type, listener, options);
-                    };
-                    const wrappedAddEventListener = (type, listener, options) => {
-                        if (type !== 'message' && type !== 'open' && type !== 'error' && listener) {
-                            const wrapped = (evt) => {
-                                const messageEvent = evt;
-                                const lastEventId = typeof messageEvent.lastEventId === 'string' &&
-                                    messageEvent.lastEventId.length > 0
-                                    ? messageEvent.lastEventId
-                                    : null;
-                                pushEvent(sourceUrl, type, messageEvent.data, lastEventId);
-                                if (typeof listener === 'function') {
-                                    listener.call(es, evt);
-                                }
-                                else {
-                                    listener.handleEvent(evt);
-                                }
-                            };
-                            callOriginalAddEventListener(type, wrapped, options);
-                            return;
+                        pushEvent(sourceUrl, type, messageEvent.data, lastEventId);
+                        if (typeof listener === 'function') {
+                            listener.call(es, evt);
+                        }
+                        else {
+                            listener.handleEvent(evt);
                         }
-                        callOriginalAddEventListener(type, listener, options);
                     };
-                    Object.defineProperty(es, 'addEventListener', {
-                        value: wrappedAddEventListener,
-                        configurable: true,
-                        writable: true,
-                    });
-                    return es;
-                };
-                WrappedEventSource.prototype = OriginalEventSource.prototype;
-                try {
-                    Object.defineProperty(WrappedEventSource, 'CONNECTING', {
-                        value: OriginalEventSource.CONNECTING,
-                    });
-                    Object.defineProperty(WrappedEventSource, 'OPEN', {
-                        value: OriginalEventSource.OPEN,
-                    });
-                    Object.defineProperty(WrappedEventSource, 'CLOSED', {
-                        value: OriginalEventSource.CLOSED,
-                    });
-                }
-                catch {
+                    callOriginalAddEventListener(type, wrapped, listenerOpts);
+                    return;
                 }
-                globalWindow.EventSource = WrappedEventSource;
-                state.originalEventSource = OriginalEventSource;
-                state.patched = true;
-            }
-            return {
-                success: true,
-                message: 'SSE monitor enabled',
-                patched: state.patched,
-                urlFilter: state.urlFilterRaw,
-                maxEvents: state.maxEvents,
-                existingEvents: state.events.length,
+                callOriginalAddEventListener(type, listener, listenerOpts);
             };
+            Object.defineProperty(es, 'addEventListener', {
+                value: wrappedAddEventListener,
+                configurable: true,
+                writable: true,
+            });
+            return es;
         };
+        WrappedEventSource.prototype = OriginalEventSource.prototype;
+        try {
+            Object.defineProperty(WrappedEventSource, 'CONNECTING', {
+                value: OriginalEventSource.CONNECTING,
+            });
+            Object.defineProperty(WrappedEventSource, 'OPEN', {
+                value: OriginalEventSource.OPEN,
+            });
+            Object.defineProperty(WrappedEventSource, 'CLOSED', {
+                value: OriginalEventSource.CLOSED,
+            });
+        }
+        catch {
+        }
+        globalWindow.EventSource = WrappedEventSource;
+        state.originalEventSource = OriginalEventSource;
+        state.patched = true;
+    }
+    return {
+        success: true,
+        message: 'SSE monitor enabled',
+        patched: state.patched,
+        urlFilter: state.urlFilterRaw,
+        maxEvents: state.maxEvents,
+        existingEvents: state.events.length,
+    };
+}
+export class StreamingToolHandlersSse extends StreamingToolHandlersWs {
+    async enableSseInterceptor(maxEvents, urlFilterRaw, options) {
+        const page = await this.collector.getActivePage();
         if (options?.persistent) {
-            await evaluateOnNewDocumentWithTimeout(page, injectionFn, { maxEvents, urlFilterRaw });
+            await evaluateOnNewDocumentWithTimeout(page, sseInjectionFn, { maxEvents, urlFilterRaw });
             return {
                 success: true,
                 message: 'SSE monitor enabled (persistent — survives navigations)',
@@ -188,7 +187,7 @@ export class StreamingToolHandlersSse extends StreamingToolHandlersWs {
                 existingEvents: 0,
             };
         }
-        const result = await evaluateWithTimeout(page, injectionFn, { maxEvents, urlFilterRaw });
+        const result = await evaluateWithTimeout(page, sseInjectionFn, { maxEvents, urlFilterRaw });
         return result;
     }
     async handleSseMonitorEnable(args) {

package/dist/src/server/domains/streaming/handlers.impl.streaming-ws.js

@@ -310,7 +310,7 @@ export class StreamingToolHandlersWs extends StreamingToolHandlersBase {
     }
     async handleWsGetConnections(_args) {
         const connections = Array.from(this.wsConnections.values())
-            .sort((a, b) => a.createdTimestamp - b.createdTimestamp)
+            .toSorted((a, b) => a.createdTimestamp - b.createdTimestamp)
             .map((conn) => ({
             requestId: conn.requestId,
             url: conn.url,

package/dist/src/server/domains/trace/TraceSummarizer.js

@@ -24,14 +24,14 @@ export function summarizeEvents(events, detail = 'balanced') {
         cat.types.set(event.eventType, (cat.types.get(event.eventType) ?? 0) + 1);
     }
     const categories = [...catMap.entries()]
-        .sort((a, b) => b[1].count - a[1].count)
+        .toSorted((a, b) => b[1].count - a[1].count)
         .map(([category, info]) => ({
         category,
         count: info.count,
         firstTimestamp: info.first,
         lastTimestamp: info.last,
         topEventTypes: [...info.types.entries()]
-            .sort((a, b) => b[1] - a[1])
+            .toSorted((a, b) => b[1] - a[1])
             .slice(0, 5)
             .map(([type, count]) => ({ type, count })),
     }));
@@ -73,7 +73,8 @@ export function extractKeyMoments(events) {
                 data: event.data,
             });
         }
-        else if (event.eventType === 'Page.frameNavigated' || event.eventType === 'Page.navigatedWithinDocument') {
+        else if (event.eventType === 'Page.frameNavigated' ||
+            event.eventType === 'Page.navigatedWithinDocument') {
             moments.push({
                 timestamp: event.timestamp,
                 type: 'navigation',
@@ -95,8 +96,10 @@ export function summarizeMemoryDeltas(deltas) {
     const uniqueAddresses = writeMap.size;
     const totalWrites = deltas.length;
     const meanWrites = totalWrites / uniqueAddresses;
-    const sorted = [...writeMap.entries()].sort((a, b) => b[1] - a[1]);
-    const topAddresses = sorted.slice(0, 10).map(([address, writeCount]) => ({ address, writeCount }));
+    const sorted = [...writeMap.entries()].toSorted((a, b) => b[1] - a[1]);
+    const topAddresses = sorted
+        .slice(0, 10)
+        .map(([address, writeCount]) => ({ address, writeCount }));
     const anomalyThreshold = meanWrites * 3;
     const anomalies = sorted
         .filter(([, count]) => count > anomalyThreshold)