@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/modules/collector/PageController.d.ts

@@ -1,4 +1,5 @@
 import type { CodeCollector } from '../collector/CodeCollector.js';
+import type { Page } from 'rebrowser-puppeteer-core';
 export interface NavigationOptions {
     waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
     timeout?: number;
@@ -97,6 +98,18 @@ export declare class PageController {
         text: string;
         href: string;
     }>>;
-    getPage(): Promise<import("rebrowser-puppeteer-core").Page>;
+    getPage(): Promise<Page>;
 }
+export declare function evaluateWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: (...args: Args) => Result, ...args: Args): Promise<Awaited<Result>>;
+export declare function evaluateWithTimeout(page: Page, pageFunction: string, ...args: readonly unknown[]): Promise<unknown>;
+export declare function evaluateOnNewDocumentWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: string | ((...args: never[]) => Result), ...args: Args): Promise<unknown>;
+export declare function coverageStartJSWithTimeout(page: any, options?: {
+    resetOnNavigation?: boolean;
+    reportAnonymousScripts?: boolean;
+}): Promise<void>;
+export declare function coverageStartCSSWithTimeout(page: any, options?: {
+    resetOnNavigation?: boolean;
+}): Promise<void>;
+export declare function coverageStopJSWithTimeout(page: any): Promise<unknown>;
+export declare function coverageStopCSSWithTimeout(page: any): Promise<unknown>;
 export {};

package/dist/src/modules/collector/PageController.js

@@ -1,4 +1,5 @@
 import { logger } from '../../utils/logger.js';
+import { setTimeout as asyncSetTimeout } from 'node:timers/promises';
 export class PageController {
     collector;
     constructor(collector) {
@@ -118,7 +119,7 @@ export class PageController {
     }
     async evaluate(code) {
         const page = await this.collector.getActivePage();
-        const result = await page.evaluate(code);
+        const result = await evaluateWithTimeout(page, code);
         logger.info('JavaScript executed');
         return result;
     }
@@ -152,7 +153,7 @@ export class PageController {
     }
     async getPerformanceMetrics() {
         const page = await this.collector.getActivePage();
-        const metrics = await page.evaluate(() => {
+        const metrics = await evaluateWithTimeout(page, () => {
             const perf = performance.getEntriesByType('navigation')[0];
             return {
                 domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
@@ -170,7 +171,7 @@ export class PageController {
     }
     async injectScript(scriptContent) {
         const page = await this.collector.getActivePage();
-        await page.evaluate((script) => {
+        await evaluateWithTimeout(page, (script) => {
             const scriptElement = document.createElement('script');
             scriptElement.textContent = script;
             document.head.appendChild(scriptElement);
@@ -215,7 +216,9 @@ export class PageController {
                 userAgent: 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 Chrome/91.0.4472.120',
             },
         };
-        const normalized = String(deviceName || '').trim().toLowerCase();
+        const normalized = String(deviceName || '')
+            .trim()
+            .toLowerCase();
         let resolvedDevice = null;
         if (normalized.includes('iphone')) {
             resolvedDevice = 'iPhone';
@@ -304,3 +307,74 @@ export class PageController {
         return await this.collector.getActivePage();
     }
 }
+async function checkPageCDPHealth(page, timeoutMs = 500) {
+    const ac = new AbortController();
+    const timer = asyncSetTimeout(timeoutMs, undefined, { signal: ac.signal }).then(() => {
+        throw new Error('cdp_unreachable');
+    });
+    try {
+        const cdp = await Promise.race([
+            page.createCDPSession(),
+            timer,
+        ]);
+        await Promise.race([
+            cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
+            timer,
+        ]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg === 'cdp_unreachable') {
+            throw new Error('CDP session unresponsive — the debugger may be blocking page evaluation. ' +
+                'Call debugger_disable() before this tool, or run it before debugger_enable().');
+        }
+        throw err;
+    }
+    finally {
+        ac.abort();
+    }
+}
+export async function evaluateWithTimeout(page, pageFunction, ...args) {
+    const timeoutMs = 30000;
+    await checkPageCDPHealth(page);
+    return Promise.race([
+        page.evaluate(pageFunction, ...[...args]),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`page.evaluate timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+export async function evaluateOnNewDocumentWithTimeout(page, pageFunction, ...args) {
+    const timeoutMs = 30000;
+    await checkPageCDPHealth(page);
+    return Promise.race([
+        page.evaluateOnNewDocument(pageFunction, ...[...args]),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`page.evaluateOnNewDocument timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+export async function coverageStartJSWithTimeout(page, options) {
+    const timeoutMs = 30000;
+    return Promise.race([
+        page.coverage.startJSCoverage(options),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`coverage.startJSCoverage timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+export async function coverageStartCSSWithTimeout(page, options) {
+    const timeoutMs = 30000;
+    return Promise.race([
+        page.coverage.startCSSCoverage(options),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`coverage.startCSSCoverage timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+export async function coverageStopJSWithTimeout(page) {
+    const timeoutMs = 30000;
+    return Promise.race([
+        page.coverage.stopJSCoverage(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`coverage.stopJSCoverage timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+export async function coverageStopCSSWithTimeout(page) {
+    const timeoutMs = 30000;
+    return Promise.race([
+        page.coverage.stopCSSCoverage(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`coverage.stopCSSCoverage timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}

package/dist/src/modules/collector/PageScriptCollectors.d.ts

@@ -1,8 +1,11 @@
 import type { Page } from 'rebrowser-puppeteer-core';
 import type { CodeFile, DependencyGraph } from '../../types/index.js';
+type UrlFilter = (url: string) => boolean;
+export declare function setupWebWorkerTracking(page: Page): Promise<void>;
 export declare function collectInlineScripts(page: Page, maxSingleSize: number, maxFilesPerCollect: number): Promise<CodeFile[]>;
-export declare function collectServiceWorkers(page: Page): Promise<CodeFile[]>;
-export declare function collectWebWorkers(page: Page): Promise<CodeFile[]>;
+export declare function collectServiceWorkers(page: Page, shouldCollectUrl?: UrlFilter): Promise<CodeFile[]>;
+export declare function collectWebWorkers(page: Page, shouldCollectUrl?: UrlFilter): Promise<CodeFile[]>;
 export declare function analyzeDependencies(files: CodeFile[]): DependencyGraph;
 export declare function extractDependencies(code: string): string[];
 export declare function calculatePriorityScore(file: CodeFile): number;
+export {};

package/dist/src/modules/collector/PageScriptCollectors.js

@@ -1,4 +1,32 @@
 import { logger } from '../../utils/logger.js';
+export async function setupWebWorkerTracking(page) {
+    await page.evaluateOnNewDocument(() => {
+        const workerWindow = window;
+        const originalWorker = workerWindow.Worker;
+        if (typeof originalWorker !== 'function') {
+            return;
+        }
+        const workerUrls = Array.isArray(workerWindow.__workerUrls)
+            ? workerWindow.__workerUrls
+            : [];
+        const trackedWorker = new Proxy(originalWorker, {
+            construct(target, args, newTarget) {
+                const worker = Reflect.construct(target, args, newTarget);
+                const [scriptURL] = args;
+                if (typeof scriptURL === 'string') {
+                    workerUrls.push(scriptURL);
+                    workerWindow.__workerUrls = workerUrls;
+                }
+                else if (scriptURL instanceof URL) {
+                    workerUrls.push(scriptURL.toString());
+                    workerWindow.__workerUrls = workerUrls;
+                }
+                return worker;
+            },
+        });
+        workerWindow.Worker = trackedWorker;
+    });
+}
 export async function collectInlineScripts(page, maxSingleSize, maxFilesPerCollect) {
     const scripts = await page.evaluate((maxSingleSize) => {
         const scriptElements = Array.from(document.querySelectorAll('script'));
@@ -39,7 +67,7 @@ export async function collectInlineScripts(page, maxSingleSize, maxFilesPerColle
     logger.debug(`Collected ${limitedScripts.length} inline scripts`);
     return limitedScripts;
 }
-export async function collectServiceWorkers(page) {
+export async function collectServiceWorkers(page, shouldCollectUrl = () => true) {
     try {
         const serviceWorkers = await page.evaluate(async () => {
             if (!('serviceWorker' in navigator)) {
@@ -61,6 +89,9 @@ export async function collectServiceWorkers(page) {
         });
         const files = [];
         for (const worker of serviceWorkers) {
+            if (!shouldCollectUrl(worker.url)) {
+                continue;
+            }
             try {
                 const content = await page.evaluate(async (url) => {
                     const response = await fetch(url);
@@ -87,28 +118,19 @@ export async function collectServiceWorkers(page) {
         return [];
     }
 }
-export async function collectWebWorkers(page) {
+export async function collectWebWorkers(page, shouldCollectUrl = () => true) {
     try {
-        await page.evaluateOnNewDocument(() => {
-            const workerWindow = window;
-            const originalWorker = workerWindow.Worker;
-            const workerUrls = [];
-            const trackedWorker = function (scriptURL, options) {
-                const scriptUrlString = typeof scriptURL === 'string' ? scriptURL : scriptURL.toString();
-                workerUrls.push(scriptUrlString);
-                workerWindow.__workerUrls = workerUrls;
-                return new originalWorker(scriptURL, options);
-            };
-            workerWindow.Worker = trackedWorker;
-        });
         const workerUrls = await page.evaluate(() => {
             const workerWindow = window;
-            return workerWindow.__workerUrls || [];
+            return Array.isArray(workerWindow.__workerUrls) ? workerWindow.__workerUrls : [];
         });
         const files = [];
         for (const url of workerUrls) {
             try {
                 const absoluteUrl = new URL(url, page.url()).href;
+                if (!shouldCollectUrl(absoluteUrl)) {
+                    continue;
+                }
                 const content = await page.evaluate(async (workerUrl) => {
                     const response = await fetch(workerUrl);
                     return await response.text();

package/dist/src/modules/crypto/CryptoDetector.js

@@ -1,6 +1,7 @@
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
+import { LLMService } from '../../services/LLMService.js';
 import { generateCryptoDetectionPrompt } from '../../services/prompts/crypto.js';
 import { logger } from '../../utils/logger.js';
 import { CRYPTO_DETECT_LLM_MAX_TOKENS } from '../../constants.js';
@@ -84,7 +85,10 @@ export class CryptoDetector {
     async detectByAI(code) {
         try {
             const messages = generateCryptoDetectionPrompt(code);
-            const response = await this.llm.chat(messages, { temperature: 0.2, maxTokens: CRYPTO_DETECT_LLM_MAX_TOKENS });
+            const response = await this.llm.chat(messages, {
+                temperature: 0.2,
+                maxTokens: CRYPTO_DETECT_LLM_MAX_TOKENS,
+            });
             const jsonMatch = response.content.match(/\{[\s\S]*\}/);
             if (!jsonMatch)
                 return [];

package/dist/src/modules/debugger/DebuggerManager.impl.core.execution.js

@@ -46,6 +46,13 @@ export async function resumeCore(ctx) {
         logger.info('Execution resumed');
     }
     catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('not paused') ||
+            msg.includes('cannot be resumed') ||
+            msg.includes('while paused')) {
+            logger.warn('Debugger resume skipped: not currently paused');
+            return;
+        }
         logger.error('Failed to resume execution:', error);
         throw error;
     }

package/dist/src/modules/debugger/DebuggerManager.impl.core.scope.js

@@ -14,7 +14,7 @@ export async function getScopeVariablesCore(ctx, options = {}) {
     if (!coreCtx.pausedState) {
         throw new PrerequisiteError('Not in paused state. Use pause() or set a breakpoint first.');
     }
-    const { callFrameId, includeObjectProperties = false, maxDepth = 1, skipErrors = true, } = options;
+    const { callFrameId, includeObjectProperties = false, maxDepth = 1, skipErrors = true } = options;
     try {
         const targetFrame = callFrameId
             ? coreCtx.pausedState.callFrames.find((f) => f.callFrameId === callFrameId)

package/dist/src/modules/deobfuscator/AdvancedDeobfuscator.ast.js

@@ -1,6 +1,6 @@
 import * as parser from '@babel/parser';
 import generate from '@babel/generator';
-import traverse from '@babel/traverse';
+import traverse, {} from '@babel/traverse';
 import * as t from '@babel/types';
 import { logger } from '../../utils/logger.js';
 export function derotateStringArray(code) {
@@ -13,7 +13,8 @@ export function derotateStringArray(code) {
         let derotated = 0;
         traverse(ast, {
             CallExpression(path) {
-                if (!t.isFunctionExpression(path.node.callee) && !t.isArrowFunctionExpression(path.node.callee)) {
+                if (!t.isFunctionExpression(path.node.callee) &&
+                    !t.isArrowFunctionExpression(path.node.callee)) {
                     return;
                 }
                 const func = path.node.callee;

package/dist/src/modules/deobfuscator/Deobfuscator.js

@@ -1,6 +1,7 @@
 import crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
+import { LLMService } from '../../services/LLMService.js';
 import { generateDeobfuscationPrompt } from '../../services/prompts/deobfuscation.js';
 import { calculateReadabilityScore as calculateReadabilityScoreUtil, detectObfuscationType as detectObfuscationTypeUtil, } from '../deobfuscator/Deobfuscator.utils.js';
 import { runWebcrack } from '../deobfuscator/webcrack.js';
@@ -149,7 +150,9 @@ export class Deobfuscator {
         return Math.min(confidence, 0.99);
     }
     buildAnalysis(webcrackResult, obfuscationType) {
-        const parts = [`webcrack completed deobfuscation for detected types: ${obfuscationType.join(', ')}.`];
+        const parts = [
+            `webcrack completed deobfuscation for detected types: ${obfuscationType.join(', ')}.`,
+        ];
         if (webcrackResult.bundle) {
             parts.push(`Recovered a ${webcrackResult.bundle.type} bundle with ${webcrackResult.bundle.moduleCount} modules.`);
         }

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.js

@@ -5,7 +5,7 @@ import * as t from '@babel/types';
 import { logger } from '../../utils/logger.js';
 import { JSVMP_DEOBFUSCATE_TIMEOUT_MS, JSVMP_MAX_ITERATIONS } from '../../constants.js';
 import { ExecutionSandbox } from '../security/ExecutionSandbox.js';
-import { restoreCustomVMBasic, restoreJSVMPCode } from '../deobfuscator/JSVMPDeobfuscator.restore.js';
+import { restoreCustomVMBasic, restoreJSVMPCode, } from '../deobfuscator/JSVMPDeobfuscator.restore.js';
 export class JSVMPDeobfuscator {
     llm;
     sandbox = new ExecutionSandbox();

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.restore.js

@@ -1,5 +1,6 @@
 import { generateVMAnalysisMessages } from '../../services/prompts/deobfuscation.js';
 import { logger } from '../../utils/logger.js';
+import { ExecutionSandbox } from '../security/ExecutionSandbox.js';
 export async function restoreJSVMPCode(context, code, vmType, aggressive) {
     const warnings = [];
     const unresolvedParts = [];
@@ -92,7 +93,10 @@ async function restoreJSFuck(context, code, warnings) {
                     warnings,
                 };
             }
-            const sandboxResult = await context.sandbox.execute({ code: `return ${code};`, timeoutMs: 5000 });
+            const sandboxResult = await context.sandbox.execute({
+                code: `return ${code};`,
+                timeoutMs: 5000,
+            });
             const result = sandboxResult.ok ? sandboxResult.output : undefined;
             if (typeof result === 'string') {
                 logger.info(' JSFuck');

package/dist/src/modules/deobfuscator/PackerDeobfuscator.js

@@ -63,7 +63,10 @@ export class PackerDeobfuscator {
     }
     async parsePackerParams(argsString) {
         try {
-            const sandboxResult = await this.sandbox.execute({ code: `return [${argsString}];`, timeoutMs: PACKER_SANDBOX_TIMEOUT_MS });
+            const sandboxResult = await this.sandbox.execute({
+                code: `return [${argsString}];`,
+                timeoutMs: PACKER_SANDBOX_TIMEOUT_MS,
+            });
             if (!sandboxResult.ok)
                 return null;
             const params = sandboxResult.output;
@@ -131,7 +134,10 @@ export class AAEncodeDeobfuscator {
     async deobfuscate(code) {
         logger.info(' AAEncode...');
         try {
-            const sandboxResult = await this.sandbox.execute({ code: `return (${code})`, timeoutMs: 5000 });
+            const sandboxResult = await this.sandbox.execute({
+                code: `return (${code})`,
+                timeoutMs: 5000,
+            });
             const decoded = sandboxResult.ok ? sandboxResult.output : undefined;
             if (typeof decoded === 'string') {
                 logger.info(' AAEncode');

package/dist/src/modules/deobfuscator/VMDeobfuscator.js

@@ -1,5 +1,6 @@
 import { logger } from '../../utils/logger.js';
 import { VM_DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
+import { LLMService } from '../../services/LLMService.js';
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';

package/dist/src/modules/deobfuscator/webcrack.js

@@ -126,7 +126,9 @@ export async function runWebcrack(code, options) {
             unminify: optionsUsed.unminify,
             mangle: optionsUsed.mangle,
         });
-        const remapped = result.bundle ? applyBundleMappings(result.bundle, options.mappings) : new Map();
+        const remapped = result.bundle
+            ? applyBundleMappings(result.bundle, options.mappings)
+            : new Map();
         let savedTo;
         let savedArtifacts;
         if (typeof options.outputDir === 'string' && options.outputDir.trim().length > 0) {

package/dist/src/modules/detector/ObfuscationDetector.d.ts

@@ -1,4 +1,4 @@
-import { ObfuscationType, VMFeatures } from '../../types/index.js';
+import type { ObfuscationType, VMFeatures } from '../../types/index.js';
 export interface DetectionResult {
     types: ObfuscationType[];
     confidence: Record<ObfuscationType, number>;

package/dist/src/modules/emulator/EmulatorCodeGen.js

@@ -303,8 +303,7 @@ function isFunctionMarker(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
     }
-    return ('__type' in value &&
-        value.__type === 'Function');
+    return '__type' in value && value.__type === 'Function';
 }
 export function formatValue(value) {
     if (value === null)

package/dist/src/modules/emulator/EnvironmentEmulator.js

@@ -386,10 +386,10 @@ export class EnvironmentEmulator {
         return typeof value === 'object' && value !== null;
     }
     isIdentifierNode(node) {
-        return (this.isRecord(node) && node.type === 'Identifier' && typeof node.name === 'string');
+        return this.isRecord(node) && node.type === 'Identifier' && typeof node.name === 'string';
     }
     isStringLiteralNode(node) {
-        return (this.isRecord(node) && node.type === 'StringLiteral' && typeof node.value === 'string');
+        return this.isRecord(node) && node.type === 'StringLiteral' && typeof node.value === 'string';
     }
     isMemberExpressionNode(node) {
         return (this.isRecord(node) &&

package/dist/src/modules/external/ExternalToolRunner.js

@@ -3,6 +3,7 @@ import { resolve, relative, sep } from 'node:path';
 import { getProjectRoot } from '../../utils/outputPaths.js';
 import { logger } from '../../utils/logger.js';
 import { ioLimit } from '../../utils/concurrency.js';
+import { ToolRegistry } from '../external/ToolRegistry.js';
 import { EXTERNAL_TOOL_TIMEOUT_MS, EXTERNAL_TOOL_MAX_STDOUT_BYTES, EXTERNAL_TOOL_MAX_STDERR_BYTES, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS, } from '../../constants.js';
 const DEFAULT_TIMEOUT_MS = EXTERNAL_TOOL_TIMEOUT_MS;
 const DEFAULT_MAX_STDOUT = EXTERNAL_TOOL_MAX_STDOUT_BYTES;
@@ -155,12 +156,7 @@ export class ExternalToolRunner {
         if (rel && !rel.startsWith('..') && !resolve(rel).startsWith(sep)) {
             return resolved;
         }
-        const tmpDirs = [
-            process.env.TEMP,
-            process.env.TMP,
-            '/tmp',
-            '/var/tmp',
-        ].filter(Boolean);
+        const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);
         for (const tmp of tmpDirs) {
             if (!tmp)
                 continue;

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

@@ -112,8 +112,12 @@ export declare class ConsoleMonitor {
         scriptMonitorReset: boolean;
     }>;
     getNetworkStats(): import("../monitor/ConsoleMonitor.impl.core.network.js").NetworkStats;
-    injectXHRInterceptor(): Promise<void>;
-    injectFetchInterceptor(): Promise<void>;
+    injectXHRInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
+    injectFetchInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
     getXHRRequests(): Promise<unknown[]>;
     getFetchRequests(): Promise<unknown[]>;
     getExceptions(filter?: {
@@ -124,12 +128,18 @@ export declare class ConsoleMonitor {
     clearExceptions(): void;
     inspectObject(objectId: string): Promise<InspectedObjectProperties>;
     clearObjectCache(): void;
-    enableDynamicScriptMonitoring(): Promise<void>;
+    enableDynamicScriptMonitoring(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
     private clearDynamicScriptBuffer;
     private resetDynamicScriptMonitoring;
     getDynamicScripts(): Promise<unknown[]>;
-    injectFunctionTracer(functionName: string): Promise<void>;
-    injectPropertyWatcher(objectPath: string, propertyName: string): Promise<void>;
+    injectFunctionTracer(functionName: string, options?: {
+        persistent?: boolean;
+    }): Promise<void>;
+    injectPropertyWatcher(objectPath: string, propertyName: string, options?: {
+        persistent?: boolean;
+    }): Promise<void>;
     private formatRemoteObject;
     private extractValue;
 }

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

@@ -71,15 +71,18 @@ export class ConsoleMonitor {
             return;
         }
         const page = await this.collector.getActivePage();
-        this.cdpSession = await page.createCDPSession();
+        this.cdpSession = await Promise.race([
+            page.createCDPSession(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
+        ]);
         this.lastEnableOptions = { ...options };
         this.cdpSession.on('disconnected', () => {
             logger.warn('ConsoleMonitor CDP session disconnected');
             this.cdpSession = null;
             this.networkMonitor = null;
         });
-        await this.cdpSession.send('Runtime.enable');
-        await this.cdpSession.send('Console.enable');
+        await cdpSendWithTimeout(this.cdpSession, 'Runtime.enable', {}, 5000);
+        await cdpSendWithTimeout(this.cdpSession, 'Console.enable', {}, 5000);
         this.cdpSession.on('Runtime.consoleAPICalled', (params) => {
             const stackTrace = params.stackTrace?.callFrames?.map((frame) => ({
                 functionName: frame.functionName || '(anonymous)',
@@ -225,14 +228,16 @@ export class ConsoleMonitor {
                     try {
                         page.off('console', this.playwrightConsoleHandler);
                     }
-                    catch { }
+                    catch {
+                    }
                     this.playwrightConsoleHandler = null;
                 }
                 if (this.playwrightErrorHandler) {
                     try {
                         page.off('pageerror', this.playwrightErrorHandler);
                     }
-                    catch { }
+                    catch {
+                    }
                     this.playwrightErrorHandler = null;
                 }
             }
@@ -276,6 +281,22 @@ export class ConsoleMonitor {
         if (!this.cdpSession && !this.playwrightPage) {
             logger.info('ConsoleMonitor CDP session lost, reinitializing...');
             await this.enable(this.lastEnableOptions);
+            return;
+        }
+        if (this.cdpSession) {
+            try {
+                await Promise.race([
+                    this.cdpSession.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('session_unreachable')), 3000)),
+                ]);
+                return;
+            }
+            catch {
+                logger.warn('ConsoleMonitor CDP session unresponsive (zombie), reinitializing...');
+                this.cdpSession = null;
+                this.networkMonitor = null;
+                await this.enable(this.lastEnableOptions);
+            }
         }
     }
     isSessionActive() {
@@ -287,7 +308,7 @@ export class ConsoleMonitor {
     async execute(expression) {
         await this.ensureSession();
         try {
-            const result = (await this.cdpSession.send('Runtime.evaluate', {
+            const result = (await cdpSendWithTimeout(this.cdpSession, 'Runtime.evaluate', {
                 expression,
                 returnByValue: true,
             }));
@@ -351,11 +372,11 @@ export class ConsoleMonitor {
     getNetworkStats() {
         return getNetworkStatsCore(this);
     }
-    async injectXHRInterceptor() {
-        return injectXHRInterceptorCore(this);
+    async injectXHRInterceptor(options) {
+        return injectXHRInterceptorCore(this, options);
     }
-    async injectFetchInterceptor() {
-        return injectFetchInterceptorCore(this);
+    async injectFetchInterceptor(options) {
+        return injectFetchInterceptorCore(this, options);
     }
     async getXHRRequests() {
         return getXHRRequestsCore(this);
@@ -375,8 +396,8 @@ export class ConsoleMonitor {
     clearObjectCache() {
         clearObjectCacheCore(this);
     }
-    async enableDynamicScriptMonitoring() {
-        return enableDynamicScriptMonitoringCore(this);
+    async enableDynamicScriptMonitoring(options) {
+        return enableDynamicScriptMonitoringCore(this, options);
     }
     async clearDynamicScriptBuffer() {
         return clearDynamicScriptBufferCore(this);
@@ -387,11 +408,11 @@ export class ConsoleMonitor {
     async getDynamicScripts() {
         return getDynamicScriptsCore(this);
     }
-    async injectFunctionTracer(functionName) {
-        return injectFunctionTracerCore(this, functionName);
+    async injectFunctionTracer(functionName, options) {
+        return injectFunctionTracerCore(this, functionName, options);
     }
-    async injectPropertyWatcher(objectPath, propertyName) {
-        return injectPropertyWatcherCore(this, objectPath, propertyName);
+    async injectPropertyWatcher(objectPath, propertyName, options) {
+        return injectPropertyWatcherCore(this, objectPath, propertyName, options);
     }
     formatRemoteObject(obj) {
         if (obj.value !== undefined) {
@@ -428,3 +449,9 @@ export class ConsoleMonitor {
         return obj.description || `[${obj.type}]`;
     }
 }
+async function cdpSendWithTimeout(session, method, params, timeoutMs = 30000) {
+    return Promise.race([
+        session.send(method, params),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}

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

@@ -7,7 +7,9 @@ interface DynamicScriptRecord {
     defer?: boolean;
     [key: string]: unknown;
 }
-export declare function enableDynamicScriptMonitoringCore(ctx: unknown): Promise<void>;
+export declare function enableDynamicScriptMonitoringCore(ctx: unknown, options?: {
+    persistent?: boolean;
+}): Promise<void>;
 export declare function clearDynamicScriptBufferCore(ctx: unknown): Promise<{
     dynamicScriptsCleared: number;
 }>;
@@ -15,6 +17,10 @@ export declare function resetDynamicScriptMonitoringCore(ctx: unknown): Promise<
     scriptMonitorReset: boolean;
 }>;
 export declare function getDynamicScriptsCore(ctx: unknown): Promise<DynamicScriptRecord[]>;
-export declare function injectFunctionTracerCore(ctx: unknown, functionName: string): Promise<void>;
-export declare function injectPropertyWatcherCore(ctx: unknown, objectPath: string, propertyName: string): Promise<void>;
+export declare function injectFunctionTracerCore(ctx: unknown, functionName: string, options?: {
+    persistent?: boolean;
+}): Promise<void>;
+export declare function injectPropertyWatcherCore(ctx: unknown, objectPath: string, propertyName: string, options?: {
+    persistent?: boolean;
+}): Promise<void>;
 export {};