@jshookmcp/jshook 0.2.3 → 0.2.5

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

@@ -9,93 +9,93 @@ export async function enableDynamicScriptMonitoringCore(ctx, options) {
     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);
-              }
-            });
-          });
-        });
-
-        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');
-      })();
+    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', {
@@ -117,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,
         });
@@ -154,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,
         });
@@ -236,33 +236,33 @@ export async function injectFunctionTracerCore(ctx, functionName, options) {
     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');
+      })();
     `;
     if (options?.persistent) {
         await coreCtx.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {
@@ -282,31 +282,31 @@ export async function injectPropertyWatcherCore(ctx, objectPath, propertyName, o
     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}');
+      })();
     `;
     if (options?.persistent) {
         await coreCtx.cdpSession.send('Page.addScriptToEvaluateOnNewDocument', {

package/dist/src/modules/monitor/FetchInterceptor.d.ts

@@ -0,0 +1,46 @@
+import type { CDPSession } from 'rebrowser-puppeteer-core';
+export interface FetchInterceptRule {
+    id: string;
+    urlPattern: string;
+    urlPatternType: 'glob' | 'regex';
+    stage: 'Request' | 'Response';
+    responseCode: number;
+    responseHeaders: Array<{
+        name: string;
+        value: string;
+    }>;
+    responseBody: string;
+    hitCount: number;
+    createdAt: number;
+}
+export interface FetchInterceptRuleInput {
+    urlPattern: string;
+    urlPatternType?: 'glob' | 'regex';
+    stage?: 'Request' | 'Response';
+    responseCode?: number;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+}
+export declare class FetchInterceptor {
+    private cdpSession;
+    private rules;
+    private enabled;
+    private eventHandler;
+    private compiledPatterns;
+    constructor(cdpSession: CDPSession);
+    enable(ruleInputs: FetchInterceptRuleInput[]): Promise<FetchInterceptRule[]>;
+    disable(): Promise<{
+        removedRules: number;
+    }>;
+    removeRule(ruleId: string): Promise<boolean>;
+    listRules(): {
+        enabled: boolean;
+        rules: FetchInterceptRule[];
+        totalHits: number;
+    };
+    isEnabled(): boolean;
+    private createRule;
+    private compilePattern;
+    private applyRules;
+    private handleRequestPaused;
+}

package/dist/src/modules/monitor/FetchInterceptor.js

@@ -0,0 +1,191 @@
+import { logger } from '../../utils/logger.js';
+import { randomUUID } from 'node:crypto';
+export class FetchInterceptor {
+    cdpSession;
+    rules = new Map();
+    enabled = false;
+    eventHandler = null;
+    compiledPatterns = new Map();
+    constructor(cdpSession) {
+        this.cdpSession = cdpSession;
+    }
+    async enable(ruleInputs) {
+        const newRules = [];
+        for (const input of ruleInputs) {
+            const rule = this.createRule(input);
+            this.rules.set(rule.id, rule);
+            this.compiledPatterns.set(rule.id, this.compilePattern(rule));
+            newRules.push(rule);
+        }
+        await this.applyRules();
+        if (!this.eventHandler) {
+            this.eventHandler = (params) => {
+                void this.handleRequestPaused(params);
+            };
+            this.cdpSession.on('Fetch.requestPaused', this.eventHandler);
+        }
+        this.enabled = true;
+        logger.info(`FetchInterceptor enabled with ${this.rules.size} rule(s)`);
+        return newRules;
+    }
+    async disable() {
+        const count = this.rules.size;
+        if (this.eventHandler) {
+            try {
+                this.cdpSession.off('Fetch.requestPaused', this.eventHandler);
+            }
+            catch {
+            }
+            this.eventHandler = null;
+        }
+        try {
+            await this.cdpSession.send('Fetch.disable');
+        }
+        catch (error) {
+            logger.warn('Fetch.disable failed:', error);
+        }
+        this.rules.clear();
+        this.compiledPatterns.clear();
+        this.enabled = false;
+        logger.info(`FetchInterceptor disabled, removed ${count} rule(s)`);
+        return { removedRules: count };
+    }
+    async removeRule(ruleId) {
+        const removed = this.rules.delete(ruleId);
+        this.compiledPatterns.delete(ruleId);
+        if (removed) {
+            if (this.rules.size === 0) {
+                await this.disable();
+            }
+            else {
+                await this.applyRules();
+            }
+        }
+        return removed;
+    }
+    listRules() {
+        const rules = Array.from(this.rules.values());
+        return {
+            enabled: this.enabled,
+            rules,
+            totalHits: rules.reduce((sum, r) => sum + r.hitCount, 0),
+        };
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    createRule(input) {
+        const headers = [];
+        if (input.responseHeaders) {
+            for (const [name, value] of Object.entries(input.responseHeaders)) {
+                headers.push({ name, value });
+            }
+        }
+        return {
+            id: randomUUID().slice(0, 8),
+            urlPattern: input.urlPattern,
+            urlPatternType: input.urlPatternType ?? 'glob',
+            stage: input.stage ?? 'Response',
+            responseCode: input.responseCode ?? 200,
+            responseHeaders: headers,
+            responseBody: input.responseBody ?? '',
+            hitCount: 0,
+            createdAt: Date.now(),
+        };
+    }
+    compilePattern(rule) {
+        if (rule.urlPatternType === 'regex') {
+            try {
+                return new RegExp(rule.urlPattern, 'i');
+            }
+            catch {
+                return new RegExp(rule.urlPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+            }
+        }
+        const escaped = rule.urlPattern
+            .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '⟨GLOBSTAR⟩')
+            .replace(/\*/g, '[^/]*')
+            .replace(/⟨GLOBSTAR⟩/g, '.*');
+        return new RegExp(escaped, 'i');
+    }
+    async applyRules() {
+        const patterns = [];
+        for (const rule of this.rules.values()) {
+            patterns.push({
+                urlPattern: rule.urlPatternType === 'glob' ? rule.urlPattern : '*',
+                requestStage: rule.stage,
+            });
+        }
+        if (patterns.length === 0) {
+            return;
+        }
+        try {
+            try {
+                await this.cdpSession.send('Fetch.disable');
+            }
+            catch {
+            }
+            await this.cdpSession.send('Fetch.enable', {
+                patterns: patterns.length > 0 ? patterns : [{ urlPattern: '*', requestStage: 'Response' }],
+                handleAuthRequests: false,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to apply Fetch interception rules:', error);
+            throw error;
+        }
+    }
+    async handleRequestPaused(params) {
+        const requestUrl = params.request.url;
+        for (const [ruleId, rule] of this.rules) {
+            const pattern = this.compiledPatterns.get(ruleId);
+            if (!pattern)
+                continue;
+            if (pattern.test(requestUrl)) {
+                rule.hitCount++;
+                logger.info(`[FetchInterceptor] Rule "${rule.urlPattern}" matched: ${requestUrl}`);
+                try {
+                    const headers = [...rule.responseHeaders];
+                    if (!headers.some((h) => h.name.toLowerCase() === 'content-type')) {
+                        const body = rule.responseBody;
+                        if (body.startsWith('{') || body.startsWith('[')) {
+                            headers.push({ name: 'Content-Type', value: 'application/json' });
+                        }
+                        else {
+                            headers.push({ name: 'Content-Type', value: 'text/plain' });
+                        }
+                    }
+                    if (!headers.some((h) => h.name.toLowerCase() === 'access-control-allow-origin')) {
+                        headers.push({ name: 'Access-Control-Allow-Origin', value: '*' });
+                    }
+                    await this.cdpSession.send('Fetch.fulfillRequest', {
+                        requestId: params.requestId,
+                        responseCode: rule.responseCode,
+                        responseHeaders: headers,
+                        body: Buffer.from(rule.responseBody, 'utf-8').toString('base64'),
+                    });
+                    return;
+                }
+                catch (error) {
+                    logger.error(`[FetchInterceptor] fulfillRequest failed for ${requestUrl}:`, error);
+                }
+            }
+        }
+        try {
+            if (params.responseStatusCode !== undefined) {
+                await this.cdpSession.send('Fetch.continueResponse', {
+                    requestId: params.requestId,
+                });
+            }
+            else {
+                await this.cdpSession.send('Fetch.continueRequest', {
+                    requestId: params.requestId,
+                });
+            }
+        }
+        catch (error) {
+            logger.warn(`[FetchInterceptor] continue failed for ${requestUrl}:`, error);
+        }
+    }
+}