@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.dynamic.js

@@ -3,104 +3,112 @@ import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
 function asDynamicCoreContext(ctx) {
     return ctx;
 }
-export async function enableDynamicScriptMonitoringCore(ctx) {
+export async function enableDynamicScriptMonitoringCore(ctx, options) {
     const coreCtx = asDynamicCoreContext(ctx);
     await coreCtx.ensureSession();
     if (!coreCtx.cdpSession) {
         throw new PrerequisiteError('CDP session not available after reconnect attempt');
     }
-    const monitorCode = `
-      (function() {
-        if (window.__dynamicScriptMonitorInstalled) {
-          console.log('[ScriptMonitor] Already installed');
-          return;
-        }
-        window.__dynamicScriptMonitorInstalled = true;
-
-        const maxRecords = ${coreCtx.MAX_INJECTED_DYNAMIC_SCRIPTS};
-        if (!window.__dynamicScripts) {
-          window.__dynamicScripts = [];
-        }
-        const dynamicScripts = window.__dynamicScripts;
-        const state = window.__dynamicScriptMonitorState || {};
-        if (!state.originalCreateElement) state.originalCreateElement = document.createElement;
-        if (!state.originalEval) state.originalEval = window.eval;
-        if (!state.originalFunction) state.originalFunction = window.Function;
-        window.__dynamicScriptMonitorState = state;
-
-        const observer = new MutationObserver((mutations) => {
-          mutations.forEach((mutation) => {
-            mutation.addedNodes.forEach((node) => {
-              if (node.nodeName === 'SCRIPT') {
-                const script = node;
-                const info = {
-                  type: 'dynamic',
-                  src: script.src || '(inline)',
-                  content: script.src ? null : script.textContent,
-                  timestamp: Date.now(),
-                  async: script.async,
-                  defer: script.defer,
-                };
-
-                dynamicScripts.push(info);
-                if (dynamicScripts.length > maxRecords) {
-                  dynamicScripts.splice(0, dynamicScripts.length - maxRecords);
-                }
-                console.log('[ScriptMonitor] Dynamic script added:', info);
-              }
-            });
-          });
+    const monitorCode = `
+      (function() {
+        if (window.__dynamicScriptMonitorInstalled) {
+          console.log('[ScriptMonitor] Already installed');
+          return;
+        }
+        window.__dynamicScriptMonitorInstalled = true;
+
+        const maxRecords = ${coreCtx.MAX_INJECTED_DYNAMIC_SCRIPTS};
+        if (!window.__dynamicScripts) {
+          window.__dynamicScripts = [];
+        }
+        const dynamicScripts = window.__dynamicScripts;
+        const state = window.__dynamicScriptMonitorState || {};
+        if (!state.originalCreateElement) state.originalCreateElement = document.createElement;
+        if (!state.originalEval) state.originalEval = window.eval;
+        if (!state.originalFunction) state.originalFunction = window.Function;
+        window.__dynamicScriptMonitorState = state;
+
+        const observer = new MutationObserver((mutations) => {
+          mutations.forEach((mutation) => {
+            mutation.addedNodes.forEach((node) => {
+              if (node.nodeName === 'SCRIPT') {
+                const script = node;
+                const info = {
+                  type: 'dynamic',
+                  src: script.src || '(inline)',
+                  content: script.src ? null : script.textContent,
+                  timestamp: Date.now(),
+                  async: script.async,
+                  defer: script.defer,
+                };
+
+                dynamicScripts.push(info);
+                if (dynamicScripts.length > maxRecords) {
+                  dynamicScripts.splice(0, dynamicScripts.length - maxRecords);
+                }
+                console.log('[ScriptMonitor] Dynamic script added:', info);
+              }
+            });
+          });
+        });
+
+        observer.observe(document.documentElement, {
+          childList: true,
+          subtree: true,
+        });
+        state.observer = observer;
+
+        const originalCreateElement = state.originalCreateElement;
+        document.createElement = function(tagName) {
+          const element = originalCreateElement.call(document, tagName);
+
+          if (tagName.toLowerCase() === 'script') {
+            console.log('[ScriptMonitor] Script element created via createElement');
+
+            const originalSetAttribute = element.setAttribute;
+            element.setAttribute = function(name, value) {
+              if (name === 'src') {
+                console.log('[ScriptMonitor] Script src set to:', value);
+              }
+              return originalSetAttribute.call(element, name, value);
+            };
+          }
+
+          return element;
+        };
+
+        const originalEval = state.originalEval;
+        window.eval = function(code) {
+          console.log('[ScriptMonitor] eval() called with code:',
+            typeof code === 'string' ? code.substring(0, 100) + '...' : code);
+          return originalEval.call(window, code);
+        };
+
+        const originalFunction = state.originalFunction;
+        window.Function = function(...args) {
+          console.log('[ScriptMonitor] Function() constructor called with args:', args);
+          return originalFunction.apply(this, args);
+        };
+
+        window.__getDynamicScripts = function() {
+          return dynamicScripts;
+        };
+
+        console.log('[ScriptMonitor] Dynamic script monitoring enabled');
+      })();
+    `;
+    if (options?.persistent) {
+        await coreCtx.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
+            source: monitorCode,
         });
-
-        observer.observe(document.documentElement, {
-          childList: true,
-          subtree: true,
+        logger.info('Dynamic script monitoring enabled (persistent)');
+    }
+    else {
+        await coreCtx.cdpSession.send('Runtime.evaluate', {
+            expression: monitorCode,
         });
-        state.observer = observer;
-
-        const originalCreateElement = state.originalCreateElement;
-        document.createElement = function(tagName) {
-          const element = originalCreateElement.call(document, tagName);
-
-          if (tagName.toLowerCase() === 'script') {
-            console.log('[ScriptMonitor] Script element created via createElement');
-
-            const originalSetAttribute = element.setAttribute;
-            element.setAttribute = function(name, value) {
-              if (name === 'src') {
-                console.log('[ScriptMonitor] Script src set to:', value);
-              }
-              return originalSetAttribute.call(element, name, value);
-            };
-          }
-
-          return element;
-        };
-
-        const originalEval = state.originalEval;
-        window.eval = function(code) {
-          console.log('[ScriptMonitor] eval() called with code:',
-            typeof code === 'string' ? code.substring(0, 100) + '...' : code);
-          return originalEval.call(window, code);
-        };
-
-        const originalFunction = state.originalFunction;
-        window.Function = function(...args) {
-          console.log('[ScriptMonitor] Function() constructor called with args:', args);
-          return originalFunction.apply(this, args);
-        };
-
-        window.__getDynamicScripts = function() {
-          return dynamicScripts;
-        };
-
-        console.log('[ScriptMonitor] Dynamic script monitoring enabled');
-      })();
-    `;
-    await coreCtx.cdpSession.send('Runtime.evaluate', {
-        expression: monitorCode,
-    });
-    logger.info('Dynamic script monitoring enabled');
+        logger.info('Dynamic script monitoring enabled');
+    }
 }
 export async function clearDynamicScriptBufferCore(ctx) {
     const coreCtx = asDynamicCoreContext(ctx);
@@ -109,19 +117,19 @@ export async function clearDynamicScriptBufferCore(ctx) {
     }
     try {
         const result = await coreCtx.cdpSession.send('Runtime.evaluate', {
-            expression: `
-          (() => {
-            const store = Array.isArray(window.__dynamicScripts)
-              ? window.__dynamicScripts
-              : (typeof window.__getDynamicScripts === 'function'
-                ? window.__getDynamicScripts()
-                : null);
-            const dynamicScriptsCleared = Array.isArray(store) ? store.length : 0;
-            if (Array.isArray(store)) {
-              store.length = 0;
-            }
-            return { dynamicScriptsCleared };
-          })()
+            expression: `
+          (() => {
+            const store = Array.isArray(window.__dynamicScripts)
+              ? window.__dynamicScripts
+              : (typeof window.__getDynamicScripts === 'function'
+                ? window.__getDynamicScripts()
+                : null);
+            const dynamicScriptsCleared = Array.isArray(store) ? store.length : 0;
+            if (Array.isArray(store)) {
+              store.length = 0;
+            }
+            return { dynamicScriptsCleared };
+          })()
         `,
             returnByValue: true,
         });
@@ -146,48 +154,48 @@ export async function resetDynamicScriptMonitoringCore(ctx) {
     }
     try {
         const result = await coreCtx.cdpSession.send('Runtime.evaluate', {
-            expression: `
-          (() => {
-            const state = window.__dynamicScriptMonitorState;
-            let scriptMonitorReset = false;
-
-            try {
-              if (state && state.observer && typeof state.observer.disconnect === 'function') {
-                state.observer.disconnect();
-                state.observer = null;
-                scriptMonitorReset = true;
-              }
-            } catch (_) {}
-
-            try {
-              if (state && state.originalCreateElement) {
-                document.createElement = state.originalCreateElement;
-                scriptMonitorReset = true;
-              }
-            } catch (_) {}
-
-            try {
-              if (state && state.originalEval) {
-                window.eval = state.originalEval;
-                scriptMonitorReset = true;
-              }
-            } catch (_) {}
-
-            try {
-              if (state && state.originalFunction) {
-                window.Function = state.originalFunction;
-                scriptMonitorReset = true;
-              }
-            } catch (_) {}
-
-            if (Array.isArray(window.__dynamicScripts)) {
-              window.__dynamicScripts.length = 0;
-            }
-            delete window.__getDynamicScripts;
-            window.__dynamicScriptMonitorInstalled = false;
-
-            return { scriptMonitorReset };
-          })()
+            expression: `
+          (() => {
+            const state = window.__dynamicScriptMonitorState;
+            let scriptMonitorReset = false;
+
+            try {
+              if (state && state.observer && typeof state.observer.disconnect === 'function') {
+                state.observer.disconnect();
+                state.observer = null;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalCreateElement) {
+                document.createElement = state.originalCreateElement;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalEval) {
+                window.eval = state.originalEval;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            try {
+              if (state && state.originalFunction) {
+                window.Function = state.originalFunction;
+                scriptMonitorReset = true;
+              }
+            } catch (_) {}
+
+            if (Array.isArray(window.__dynamicScripts)) {
+              window.__dynamicScripts.length = 0;
+            }
+            delete window.__getDynamicScripts;
+            window.__dynamicScriptMonitorInstalled = false;
+
+            return { scriptMonitorReset };
+          })()
         `,
             returnByValue: true,
         });
@@ -223,77 +231,93 @@ export async function getDynamicScriptsCore(ctx) {
         return [];
     }
 }
-export async function injectFunctionTracerCore(ctx, functionName) {
+export async function injectFunctionTracerCore(ctx, functionName, options) {
     const coreCtx = asDynamicCoreContext(ctx);
     if (!coreCtx.cdpSession) {
         throw new PrerequisiteError('CDP session not initialized');
     }
-    const tracerCode = `
-      (function() {
-        const originalFunc = window.${functionName};
-        if (typeof originalFunc !== 'function') {
-          console.error('[Tracer] ${functionName} is not a function');
-          return;
-        }
-
-        window.${functionName} = new Proxy(originalFunc, {
-          apply: function(target, thisArg, args) {
-            console.log('[Tracer] ${functionName} called with args:', args);
-            const startTime = performance.now();
-
-            try {
-              const result = target.apply(thisArg, args);
-              const endTime = performance.now();
-              console.log('[Tracer] ${functionName} returned:', result, 'Time:', (endTime - startTime).toFixed(2), 'ms');
-              return result;
-            } catch (error) {
-              console.error('[Tracer] ${functionName} threw error:', error);
-              throw error;
-            }
-          }
-        });
-
-        console.log('[Tracer] ${functionName} is now being traced');
-      })();
+    const tracerCode = `
+      (function() {
+        const originalFunc = window.${functionName};
+        if (typeof originalFunc !== 'function') {
+          console.error('[Tracer] ${functionName} is not a function');
+          return;
+        }
+
+        window.${functionName} = new Proxy(originalFunc, {
+          apply: function(target, thisArg, args) {
+            console.log('[Tracer] ${functionName} called with args:', args);
+            const startTime = performance.now();
+
+            try {
+              const result = target.apply(thisArg, args);
+              const endTime = performance.now();
+              console.log('[Tracer] ${functionName} returned:', result, 'Time:', (endTime - startTime).toFixed(2), 'ms');
+              return result;
+            } catch (error) {
+              console.error('[Tracer] ${functionName} threw error:', error);
+              throw error;
+            }
+          }
+        });
+
+        console.log('[Tracer] ${functionName} is now being traced');
+      })();
     `;
-    await coreCtx.cdpSession.send('Runtime.evaluate', {
-        expression: tracerCode,
-    });
-    logger.info(`Function tracer injected for: ${functionName}`);
+    if (options?.persistent) {
+        await coreCtx.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
+            source: tracerCode,
+        });
+        logger.info(`Function tracer injected for: ${functionName} (persistent)`);
+    }
+    else {
+        await coreCtx.cdpSession.send('Runtime.evaluate', {
+            expression: tracerCode,
+        });
+        logger.info(`Function tracer injected for: ${functionName}`);
+    }
 }
-export async function injectPropertyWatcherCore(ctx, objectPath, propertyName) {
+export async function injectPropertyWatcherCore(ctx, objectPath, propertyName, options) {
     const coreCtx = asDynamicCoreContext(ctx);
     if (!coreCtx.cdpSession) {
         throw new PrerequisiteError('CDP session not initialized');
     }
-    const watcherCode = `
-      (function() {
-        const obj = ${objectPath};
-        if (!obj) {
-          console.error('[Watcher] Object not found: ${objectPath}');
-          return;
-        }
-
-        let value = obj.${propertyName};
-
-        Object.defineProperty(obj, '${propertyName}', {
-          get: function() {
-            console.log('[Watcher] ${objectPath}.${propertyName} accessed, value:', value);
-            return value;
-          },
-          set: function(newValue) {
-            console.log('[Watcher] ${objectPath}.${propertyName} changed from', value, 'to', newValue);
-            value = newValue;
-          },
-          enumerable: true,
-          configurable: true
-        });
-
-        console.log('[Watcher] Property watcher installed for ${objectPath}.${propertyName}');
-      })();
+    const watcherCode = `
+      (function() {
+        const obj = ${objectPath};
+        if (!obj) {
+          console.error('[Watcher] Object not found: ${objectPath}');
+          return;
+        }
+
+        let value = obj.${propertyName};
+
+        Object.defineProperty(obj, '${propertyName}', {
+          get: function() {
+            console.log('[Watcher] ${objectPath}.${propertyName} accessed, value:', value);
+            return value;
+          },
+          set: function(newValue) {
+            console.log('[Watcher] ${objectPath}.${propertyName} changed from', value, 'to', newValue);
+            value = newValue;
+          },
+          enumerable: true,
+          configurable: true
+        });
+
+        console.log('[Watcher] Property watcher installed for ${objectPath}.${propertyName}');
+      })();
     `;
-    await coreCtx.cdpSession.send('Runtime.evaluate', {
-        expression: watcherCode,
-    });
-    logger.info(`Property watcher injected for: ${objectPath}.${propertyName}`);
+    if (options?.persistent) {
+        await coreCtx.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
+            source: watcherCode,
+        });
+        logger.info(`Property watcher injected for: ${objectPath}.${propertyName} (persistent)`);
+    }
+    else {
+        await coreCtx.cdpSession.send('Runtime.evaluate', {
+            expression: watcherCode,
+        });
+        logger.info(`Property watcher injected for: ${objectPath}.${propertyName}`);
+    }
 }

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.network.d.ts

@@ -51,8 +51,12 @@ export declare function resetInjectedInterceptorsCore(ctx: unknown): Promise<{
     scriptMonitorReset: boolean;
 }>;
 export declare function getNetworkStatsCore(ctx: unknown): NetworkStats;
-export declare function injectXHRInterceptorCore(ctx: unknown): Promise<void>;
-export declare function injectFetchInterceptorCore(ctx: unknown): Promise<void>;
+export declare function injectXHRInterceptorCore(ctx: unknown, options?: {
+    persistent?: boolean;
+}): Promise<void>;
+export declare function injectFetchInterceptorCore(ctx: unknown, options?: {
+    persistent?: boolean;
+}): Promise<void>;
 export declare function getXHRRequestsCore(ctx: unknown): Promise<NetworkRecord[]>;
 export declare function getFetchRequestsCore(ctx: unknown): Promise<NetworkRecord[]>;
 export {};

package/dist/src/modules/monitor/ConsoleMonitor.impl.core.network.js

@@ -120,25 +120,25 @@ export function getNetworkStatsCore(ctx) {
         byType: {},
     });
 }
-export async function injectXHRInterceptorCore(ctx) {
+export async function injectXHRInterceptorCore(ctx, options) {
     const coreCtx = asNetworkCoreContext(ctx);
     if (coreCtx.playwrightNetworkMonitor) {
-        return coreCtx.playwrightNetworkMonitor.injectXHRInterceptor();
+        return coreCtx.playwrightNetworkMonitor.injectXHRInterceptor(options);
     }
     if (!coreCtx.networkMonitor) {
         throw new PrerequisiteError('Network monitoring is not enabled. Call enable() with enableNetwork: true first.');
     }
-    return coreCtx.networkMonitor.injectXHRInterceptor();
+    return coreCtx.networkMonitor.injectXHRInterceptor(options);
 }
-export async function injectFetchInterceptorCore(ctx) {
+export async function injectFetchInterceptorCore(ctx, options) {
     const coreCtx = asNetworkCoreContext(ctx);
     if (coreCtx.playwrightNetworkMonitor) {
-        return coreCtx.playwrightNetworkMonitor.injectFetchInterceptor();
+        return coreCtx.playwrightNetworkMonitor.injectFetchInterceptor(options);
     }
     if (!coreCtx.networkMonitor) {
         throw new PrerequisiteError('Network monitoring is not enabled. Call enable() with enableNetwork: true first.');
     }
-    return coreCtx.networkMonitor.injectFetchInterceptor();
+    return coreCtx.networkMonitor.injectFetchInterceptor(options);
 }
 export async function getXHRRequestsCore(ctx) {
     const coreCtx = asNetworkCoreContext(ctx);

package/dist/src/modules/monitor/NetworkMonitor.impl.d.ts

@@ -56,8 +56,12 @@ export declare class NetworkMonitor {
         byStatus: Record<number, number>;
         byType: Record<string, number>;
     };
-    injectXHRInterceptor(): Promise<void>;
-    injectFetchInterceptor(): Promise<void>;
+    injectXHRInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
+    injectFetchInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
     getXHRRequests(): Promise<Record<string, unknown>[]>;
     getFetchRequests(): Promise<Record<string, unknown>[]>;
     clearInjectedBuffers(): Promise<{

package/dist/src/modules/monitor/NetworkMonitor.impl.js

@@ -369,25 +369,41 @@ export class NetworkMonitor {
             byType,
         };
     }
-    async injectXHRInterceptor() {
+    async injectXHRInterceptor(options) {
         if (!this.cdpSession) {
             throw new Error('CDP session not initialized');
         }
         const interceptorCode = buildXHRInterceptorCode(this.MAX_INJECTED_RECORDS);
-        await this.cdpSession.send('Runtime.evaluate', {
-            expression: interceptorCode,
-        });
-        logger.info('XHR interceptor injected');
+        if (options?.persistent) {
+            await this.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
+                source: interceptorCode,
+            });
+            logger.info('XHR interceptor injected (persistent)');
+        }
+        else {
+            await this.cdpSession.send('Runtime.evaluate', {
+                expression: interceptorCode,
+            });
+            logger.info('XHR interceptor injected');
+        }
     }
-    async injectFetchInterceptor() {
+    async injectFetchInterceptor(options) {
         if (!this.cdpSession) {
             throw new Error('CDP session not initialized');
         }
         const interceptorCode = buildFetchInterceptorCode(this.MAX_INJECTED_RECORDS);
-        await this.cdpSession.send('Runtime.evaluate', {
-            expression: interceptorCode,
-        });
-        logger.info('Fetch interceptor injected');
+        if (options?.persistent) {
+            await this.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
+                source: interceptorCode,
+            });
+            logger.info('Fetch interceptor injected (persistent)');
+        }
+        else {
+            await this.cdpSession.send('Runtime.evaluate', {
+                expression: interceptorCode,
+            });
+            logger.info('Fetch interceptor injected');
+        }
     }
     async getXHRRequests() {
         if (!this.cdpSession) {