@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -1,5 +1,6 @@
 import puppeteer from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
+const launchBrowser = Reflect.get(puppeteer, 'launch');
 export async function fetchRealEnvironmentData(params) {
     const { url, detected, depth, resolveExecutablePath, buildManifestFromTemplate } = params;
     const manifest = {};
@@ -26,67 +27,64 @@ export async function fetchRealEnvironmentData(params) {
             if (executablePath) {
                 launchOptions.executablePath = executablePath;
             }
-            browser = await puppeteer.launch(launchOptions);
+            browser = await launchBrowser(launchOptions);
         }
         page = await browser.newPage();
         await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
         await page.evaluateOnNewDocument(() => {
             const typedWindow = window;
-            const setChromeObject = (target) => {
-                target.chrome = {
-                    runtime: {
-                        connect: () => { },
-                        sendMessage: () => { },
-                        onMessage: {
-                            addListener: () => { },
-                            removeListener: () => { },
-                        },
-                    },
-                    loadTimes: function () {
-                        return {
-                            commitLoadTime: Date.now() / 1000 - Math.random() * 10,
-                            connectionInfo: 'http/1.1',
-                            finishDocumentLoadTime: Date.now() / 1000 - Math.random() * 5,
-                            finishLoadTime: Date.now() / 1000 - Math.random() * 3,
-                            firstPaintAfterLoadTime: 0,
-                            firstPaintTime: Date.now() / 1000 - Math.random() * 8,
-                            navigationType: 'Other',
-                            npnNegotiatedProtocol: 'http/1.1',
-                            requestTime: Date.now() / 1000 - Math.random() * 15,
-                            startLoadTime: Date.now() / 1000 - Math.random() * 12,
-                            wasAlternateProtocolAvailable: false,
-                            wasFetchedViaSpdy: false,
-                            wasNpnNegotiated: true,
-                        };
-                    },
-                    csi: function () {
-                        return {
-                            onloadT: Date.now(),
-                            pageT: Math.random() * 1000,
-                            startE: Date.now() - Math.random() * 5000,
-                            tran: 15,
-                        };
-                    },
-                    app: {
-                        isInstalled: false,
-                        InstallState: {
-                            DISABLED: 'disabled',
-                            INSTALLED: 'installed',
-                            NOT_INSTALLED: 'not_installed',
-                        },
-                        RunningState: {
-                            CANNOT_RUN: 'cannot_run',
-                            READY_TO_RUN: 'ready_to_run',
-                            RUNNING: 'running',
-                        },
-                    },
-                };
-            };
             Object.defineProperty(navigator, 'webdriver', {
                 get: () => undefined,
                 configurable: true,
             });
-            setChromeObject(typedWindow);
+            typedWindow.chrome = {
+                runtime: {
+                    connect: () => { },
+                    sendMessage: () => { },
+                    onMessage: {
+                        addListener: () => { },
+                        removeListener: () => { },
+                    },
+                },
+                loadTimes: function () {
+                    return {
+                        commitLoadTime: Date.now() / 1000 - Math.random() * 10,
+                        connectionInfo: 'http/1.1',
+                        finishDocumentLoadTime: Date.now() / 1000 - Math.random() * 5,
+                        finishLoadTime: Date.now() / 1000 - Math.random() * 3,
+                        firstPaintAfterLoadTime: 0,
+                        firstPaintTime: Date.now() / 1000 - Math.random() * 8,
+                        navigationType: 'Other',
+                        npnNegotiatedProtocol: 'http/1.1',
+                        requestTime: Date.now() / 1000 - Math.random() * 15,
+                        startLoadTime: Date.now() / 1000 - Math.random() * 12,
+                        wasAlternateProtocolAvailable: false,
+                        wasFetchedViaSpdy: false,
+                        wasNpnNegotiated: true,
+                    };
+                },
+                csi: function () {
+                    return {
+                        onloadT: Date.now(),
+                        pageT: Math.random() * 1000,
+                        startE: Date.now() - Math.random() * 5000,
+                        tran: 15,
+                    };
+                },
+                app: {
+                    isInstalled: false,
+                    InstallState: {
+                        DISABLED: 'disabled',
+                        INSTALLED: 'installed',
+                        NOT_INSTALLED: 'not_installed',
+                    },
+                    RunningState: {
+                        CANNOT_RUN: 'cannot_run',
+                        READY_TO_RUN: 'ready_to_run',
+                        RUNNING: 'running',
+                    },
+                },
+            };
             Object.defineProperty(navigator, 'plugins', {
                 get: () => {
                     const pluginArray = [
@@ -170,13 +168,12 @@ export async function fetchRealEnvironmentData(params) {
         const extractedValues = await page.evaluate((paths, maxDepth) => {
             const result = {};
             const seen = new WeakSet();
-            const isObjectLike = (value) => typeof value === 'object' && value !== null;
             function extractValue(path) {
                 try {
                     const parts = path.split('.');
                     let current = window;
                     for (const part of parts) {
-                        if (isObjectLike(current) && part in current) {
+                        if (typeof current === 'object' && current !== null && part in current) {
                             current = current[part];
                         }
                         else {
@@ -189,8 +186,8 @@ export async function fetchRealEnvironmentData(params) {
                     return `[Error: ${error.message}]`;
                 }
             }
-            function serializeValue(value, depth, seenObjects) {
-                if (depth <= 0)
+            function serializeValue(value, recurseDepth, seenObjects) {
+                if (recurseDepth <= 0)
                     return '[Max Depth]';
                 if (value === null)
                     return null;
@@ -213,20 +210,20 @@ export async function fetchRealEnvironmentData(params) {
                         return '[Function]';
                     }
                 }
-                if (isObjectLike(value) && seenObjects.has(value)) {
+                if (typeof value === 'object' && value !== null && seenObjects.has(value)) {
                     return '[Circular Reference]';
                 }
                 if (Array.isArray(value)) {
                     seenObjects.add(value);
                     const arr = value
                         .slice(0, 20)
-                        .map((item) => serializeValue(item, depth - 1, seenObjects));
+                        .map((item) => serializeValue(item, recurseDepth - 1, seenObjects));
                     if (value.length > 20) {
                         arr.push(`[... ${value.length - 20} more items]`);
                     }
                     return arr;
                 }
-                if (isObjectLike(value)) {
+                if (typeof value === 'object' && value !== null) {
                     seenObjects.add(value);
                     const serialized = {};
                     const allKeys = Object.getOwnPropertyNames(value);
@@ -237,14 +234,14 @@ export async function fetchRealEnvironmentData(params) {
                             if (descriptor) {
                                 if (descriptor.get) {
                                     try {
-                                        serialized[key] = serializeValue(value[key], depth - 1, seenObjects);
+                                        serialized[key] = serializeValue(value[key], recurseDepth - 1, seenObjects);
                                     }
                                     catch {
                                         serialized[key] = '[Getter Error]';
                                     }
                                 }
                                 else if (descriptor.value !== undefined) {
-                                    serialized[key] = serializeValue(descriptor.value, depth - 1, seenObjects);
+                                    serialized[key] = serializeValue(descriptor.value, recurseDepth - 1, seenObjects);
                                 }
                             }
                         }

package/dist/src/modules/emulator/templates/chrome-env.d.ts

@@ -162,17 +162,21 @@ export declare const chromeEnvironmentTemplate: {
             };
         };
         WebSocket: {
-            new (_url: string): {
+            new (): {
                 send(): void;
                 close(): void;
                 addEventListener(): void;
             };
         };
         Blob: {
-            new (_parts: unknown[], _options?: unknown): {};
+            new (): {
+                size: number;
+                type: string;
+            };
         };
         File: {
-            new (parts: BlobPart[], _name: string, options?: BlobPropertyBag): {
+            new (parts: BlobPart[], name: string, options?: BlobPropertyBag): {
+                name: string;
                 readonly size: number;
                 readonly type: string;
                 arrayBuffer(): Promise<ArrayBuffer>;
@@ -202,16 +206,22 @@ export declare const chromeEnvironmentTemplate: {
             };
         };
         Request: {
-            new (_input: unknown, _init?: unknown): {};
+            new (): {
+                clone(): any;
+            };
         };
         Response: {
-            new (_body?: unknown, _init?: unknown): {};
+            new (): {
+                clone(): any;
+            };
         };
         URL: {
-            new (_url: string, _base?: string): {};
+            new (): {
+                toString(): string;
+            };
         };
         URLSearchParams: {
-            new (_init?: unknown): {
+            new (): {
                 append(): void;
                 delete(): void;
                 get(): void;

package/dist/src/modules/emulator/templates/chrome-env.js

@@ -161,17 +161,19 @@ export const chromeEnvironmentTemplate = {
             addEventListener() { }
         },
         WebSocket: class WebSocket {
-            constructor(_url) { }
             send() { }
             close() { }
             addEventListener() { }
         },
         Blob: class Blob {
-            constructor(_parts, _options) { }
+            size = 0;
+            type = '';
         },
         File: class File extends Blob {
-            constructor(parts, _name, options) {
+            name = '';
+            constructor(parts, name, options) {
                 super(parts, options);
+                this.name = name;
             }
         },
         FormData: class FormData {
@@ -190,16 +192,21 @@ export const chromeEnvironmentTemplate = {
             set() { }
         },
         Request: class Request {
-            constructor(_input, _init) { }
+            clone() {
+                return this;
+            }
         },
         Response: class Response {
-            constructor(_body, _init) { }
+            clone() {
+                return this;
+            }
         },
         URL: class URL {
-            constructor(_url, _base) { }
+            toString() {
+                return '';
+            }
         },
         URLSearchParams: class URLSearchParams {
-            constructor(_init) { }
             append() { }
             delete() { }
             get() { }

package/dist/src/modules/external/ExternalToolRunner.d.ts

@@ -1,4 +1,4 @@
-import { ToolRegistry } from '../external/ToolRegistry.js';
+import { type ToolRegistry } from '../external/ToolRegistry.js';
 import type { ToolRunRequest, ToolRunResult } from '../external/types.js';
 export declare class ExternalToolRunner {
     private readonly registry;

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

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
-import { resolve, relative, sep } from 'node:path';
+import { resolve, relative, sep, isAbsolute } 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 {} 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;
@@ -37,9 +37,16 @@ export class ExternalToolRunner {
         const args = [...(spec.defaultArgs || []), ...request.args];
         const env = { PATH: process.env.PATH || '' };
         if (process.platform === 'win32') {
-            env.SYSTEMROOT = process.env.SYSTEMROOT || 'C:\\Windows';
-            env.TEMP = process.env.TEMP || '';
-            env.TMP = process.env.TMP || '';
+            const systemRoot = process.env.SYSTEMROOT || process.env.SystemRoot || process.env.WINDIR;
+            if (systemRoot) {
+                env.SYSTEMROOT = systemRoot;
+            }
+            if (process.env.TEMP) {
+                env.TEMP = process.env.TEMP;
+            }
+            if (process.env.TMP) {
+                env.TMP = process.env.TMP;
+            }
         }
         if (spec.envAllowlist) {
             for (const key of spec.envAllowlist) {
@@ -66,13 +73,23 @@ export class ExternalToolRunner {
             let stdoutTruncated = false;
             let stderrTruncated = false;
             let settled = false;
-            let timeoutHandle;
+            const timeoutHandle = setTimeout(() => {
+                if (!settled) {
+                    child.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!settled) {
+                            child.kill('SIGKILL');
+                            finish(null, 'SIGKILL');
+                        }
+                    }, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS);
+                    request.onProgress?.({ phase: 'timeout', ts: Date.now() });
+                }
+            }, timeoutMs);
             const finish = (exitCode, signal) => {
                 if (settled)
                     return;
                 settled = true;
-                if (timeoutHandle)
-                    clearTimeout(timeoutHandle);
+                clearTimeout(timeoutHandle);
                 const durationMs = Date.now() - startTime;
                 const result = {
                     ok: exitCode === 0,
@@ -91,18 +108,6 @@ export class ExternalToolRunner {
                 }
                 resolvePromise(result);
             };
-            timeoutHandle = setTimeout(() => {
-                if (!settled) {
-                    child.kill('SIGTERM');
-                    setTimeout(() => {
-                        if (!settled) {
-                            child.kill('SIGKILL');
-                            finish(null, 'SIGKILL');
-                        }
-                    }, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS);
-                    request.onProgress?.({ phase: 'timeout', ts: Date.now() });
-                }
-            }, timeoutMs);
             if (request.stdin) {
                 child.stdin.write(request.stdin);
                 child.stdin.end();
@@ -153,13 +158,11 @@ export class ExternalToolRunner {
         const resolved = resolve(requestedCwd);
         const projectRoot = getProjectRoot();
         const rel = relative(projectRoot, resolved);
-        if (rel && !rel.startsWith('..') && !resolve(rel).startsWith(sep)) {
+        if (rel && !rel.startsWith('..') && !isAbsolute(rel) && !resolve(rel).startsWith(sep)) {
             return resolved;
         }
         const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);
         for (const tmp of tmpDirs) {
-            if (!tmp)
-                continue;
             const resolvedTmp = resolve(tmp);
             if (resolved === resolvedTmp || resolved.startsWith(resolvedTmp + sep)) {
                 return resolved;

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

@@ -1,6 +1,8 @@
 import type { CodeCollector } from '../collector/CodeCollector.js';
+import type { FetchInterceptRule, FetchInterceptRuleInput } from '../monitor/FetchInterceptor.js';
 import type { InspectedObjectProperties } from '../monitor/ConsoleMonitor.impl.core.object-cache.js';
 export type { NetworkRequest, NetworkResponse } from '../monitor/NetworkMonitor.js';
+export type { FetchInterceptRule, FetchInterceptRuleInput, } from '../monitor/FetchInterceptor.js';
 type ConsoleMessageType = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'trace' | 'dir' | 'table';
 export interface ConsoleMessage {
     type: ConsoleMessageType | string;
@@ -32,6 +34,7 @@ export declare class ConsoleMonitor {
     private collector;
     private cdpSession;
     private networkMonitor;
+    private fetchInterceptor;
     private playwrightNetworkMonitor;
     private playwrightPage;
     private playwrightConsoleHandler;
@@ -140,6 +143,16 @@ export declare class ConsoleMonitor {
     injectPropertyWatcher(objectPath: string, propertyName: string, options?: {
         persistent?: boolean;
     }): Promise<void>;
+    enableFetchIntercept(rules: FetchInterceptRuleInput[]): Promise<FetchInterceptRule[]>;
+    disableFetchIntercept(): Promise<{
+        removedRules: number;
+    }>;
+    removeFetchInterceptRule(ruleId: string): Promise<boolean>;
+    getFetchInterceptStatus(): {
+        enabled: boolean;
+        rules: FetchInterceptRule[];
+        totalHits: number;
+    };
     private formatRemoteObject;
     private extractValue;
 }

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

@@ -1,6 +1,7 @@
 import { logger } from '../../utils/logger.js';
 import { NetworkMonitor } from '../monitor/NetworkMonitor.js';
 import { PlaywrightNetworkMonitor } from '../monitor/PlaywrightNetworkMonitor.js';
+import { FetchInterceptor } from '../monitor/FetchInterceptor.js';
 import { clearExceptionsCore, clearLogsCore, getExceptionsCore, getLogsCore, getStatsCore, } from '../monitor/ConsoleMonitor.impl.core.logs.js';
 import { clearInjectedBuffersCore, clearNetworkRecordsCore, getAllJavaScriptResponsesCore, getFetchRequestsCore, getNetworkActivityCore, getNetworkRequestsCore, getNetworkResponsesCore, getNetworkStatsCore, getNetworkStatusCore, getResponseBodyCore, getXHRRequestsCore, injectFetchInterceptorCore, injectXHRInterceptorCore, isNetworkEnabledCore, resetInjectedInterceptorsCore, } from '../monitor/ConsoleMonitor.impl.core.network.js';
 import { clearObjectCacheCore, inspectObjectCore, } from '../monitor/ConsoleMonitor.impl.core.object-cache.js';
@@ -9,6 +10,7 @@ export class ConsoleMonitor {
     collector;
     cdpSession = null;
     networkMonitor = null;
+    fetchInterceptor = null;
     playwrightNetworkMonitor = null;
     playwrightPage = null;
     playwrightConsoleHandler = null;
@@ -80,6 +82,7 @@ export class ConsoleMonitor {
             logger.warn('ConsoleMonitor CDP session disconnected');
             this.cdpSession = null;
             this.networkMonitor = null;
+            this.fetchInterceptor = null;
         });
         await cdpSendWithTimeout(this.cdpSession, 'Runtime.enable', {}, 5000);
         await cdpSendWithTimeout(this.cdpSession, 'Console.enable', {}, 5000);
@@ -246,6 +249,10 @@ export class ConsoleMonitor {
                 this.playwrightNetworkMonitor = null;
             }
             if (this.cdpSession) {
+                if (this.fetchInterceptor) {
+                    await this.fetchInterceptor.disable();
+                    this.fetchInterceptor = null;
+                }
                 if (this.networkMonitor) {
                     await this.networkMonitor.disable();
                     this.networkMonitor = null;
@@ -295,6 +302,7 @@ export class ConsoleMonitor {
                 logger.warn('ConsoleMonitor CDP session unresponsive (zombie), reinitializing...');
                 this.cdpSession = null;
                 this.networkMonitor = null;
+                this.fetchInterceptor = null;
                 await this.enable(this.lastEnableOptions);
             }
         }
@@ -414,6 +422,40 @@ export class ConsoleMonitor {
     async injectPropertyWatcher(objectPath, propertyName, options) {
         return injectPropertyWatcherCore(this, objectPath, propertyName, options);
     }
+    async enableFetchIntercept(rules) {
+        await this.ensureSession();
+        if (!this.cdpSession) {
+            throw new Error('No CDP session available for Fetch interception');
+        }
+        if (!this.fetchInterceptor) {
+            this.fetchInterceptor = new FetchInterceptor(this.cdpSession);
+        }
+        return this.fetchInterceptor.enable(rules);
+    }
+    async disableFetchIntercept() {
+        if (!this.fetchInterceptor) {
+            return { removedRules: 0 };
+        }
+        const result = await this.fetchInterceptor.disable();
+        this.fetchInterceptor = null;
+        return result;
+    }
+    async removeFetchInterceptRule(ruleId) {
+        if (!this.fetchInterceptor) {
+            return false;
+        }
+        const removed = await this.fetchInterceptor.removeRule(ruleId);
+        if (!this.fetchInterceptor.isEnabled()) {
+            this.fetchInterceptor = null;
+        }
+        return removed;
+    }
+    getFetchInterceptStatus() {
+        if (!this.fetchInterceptor) {
+            return { enabled: false, rules: [], totalHits: 0 };
+        }
+        return this.fetchInterceptor.listRules();
+    }
     formatRemoteObject(obj) {
         if (obj.value !== undefined) {
             return String(obj.value);

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;
+}