@jshookmcp/jshook 0.2.6 → 0.2.8

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

@@ -1,316 +0,0 @@
-import * as parser from '@babel/parser';
-import traverse from '@babel/traverse';
-import { existsSync } from 'fs';
-import { logger } from '../../utils/logger.js';
-import { chromeEnvironmentTemplate } from '../emulator/templates/chrome-env.js';
-import { generateEmulationCode, generateRecommendations } from '../emulator/EmulatorCodeGen.js';
-import { findBrowserExecutable } from '../../utils/browserExecutable.js';
-import { fetchRealEnvironmentData } from '../emulator/EnvironmentEmulatorFetch.js';
-export class EnvironmentEmulator {
-    browser;
-    constructor(legacyDependency) {
-        void legacyDependency;
-    }
-    async analyze(options) {
-        const startTime = Date.now();
-        logger.info(' ...');
-        const { code, targetRuntime = 'both', autoFetch = false, browserUrl, browserType = 'chrome', includeComments = true, extractDepth = 3, } = options;
-        try {
-            logger.info(' ...');
-            const detectedVariables = this.detectEnvironmentVariables(code);
-            let variableManifest = {};
-            if (autoFetch && browserUrl) {
-                logger.info(' ...');
-                variableManifest = await this.fetchRealEnvironment(browserUrl, detectedVariables, extractDepth);
-            }
-            else {
-                variableManifest = this.buildManifestFromTemplate(detectedVariables, browserType);
-            }
-            const missingAPIs = this.identifyMissingAPIs(detectedVariables, variableManifest);
-            logger.info(' ...');
-            const emulationCode = generateEmulationCode(variableManifest, targetRuntime, includeComments);
-            const recommendations = generateRecommendations(detectedVariables, missingAPIs);
-            const totalVariables = Object.values(detectedVariables).reduce((sum, arr) => sum + arr.length, 0);
-            const autoFilledVariables = Object.keys(variableManifest).length;
-            const manualRequiredVariables = missingAPIs.length;
-            const result = {
-                detectedVariables,
-                emulationCode,
-                missingAPIs,
-                variableManifest,
-                recommendations,
-                stats: {
-                    totalVariables,
-                    autoFilledVariables,
-                    manualRequiredVariables,
-                },
-            };
-            const processingTime = Date.now() - startTime;
-            logger.info(`Environment emulation complete in ${processingTime}ms`);
-            logger.info(`  Detected ${totalVariables} variables, auto-filled ${autoFilledVariables}`);
-            return result;
-        }
-        catch (error) {
-            logger.error('', error);
-            throw error;
-        }
-    }
-    detectEnvironmentVariables(code) {
-        const detected = {
-            window: [],
-            document: [],
-            navigator: [],
-            location: [],
-            screen: [],
-            other: [],
-        };
-        const accessedPaths = new Set();
-        try {
-            const ast = parser.parse(code, {
-                sourceType: 'unambiguous',
-                plugins: ['jsx', 'typescript'],
-            });
-            traverse(ast, {
-                MemberExpression: (path) => {
-                    const fullPath = this.getMemberExpressionPath(path.node);
-                    if (fullPath) {
-                        accessedPaths.add(fullPath);
-                    }
-                },
-                Identifier: (path) => {
-                    const name = path.node.name;
-                    if ([
-                        'window',
-                        'document',
-                        'navigator',
-                        'location',
-                        'screen',
-                        'console',
-                        'localStorage',
-                        'sessionStorage',
-                    ].includes(name)) {
-                        if (path.scope.hasBinding(name)) {
-                            return;
-                        }
-                        accessedPaths.add(name);
-                    }
-                },
-            });
-            for (const path of accessedPaths) {
-                if (path.startsWith('window.')) {
-                    detected.window.push(path);
-                }
-                else if (path.startsWith('document.')) {
-                    detected.document.push(path);
-                }
-                else if (path.startsWith('navigator.')) {
-                    detected.navigator.push(path);
-                }
-                else if (path.startsWith('location.')) {
-                    detected.location.push(path);
-                }
-                else if (path.startsWith('screen.')) {
-                    detected.screen.push(path);
-                }
-                else {
-                    detected.other.push(path);
-                }
-            }
-            for (const key of Object.keys(detected)) {
-                detected[key] = Array.from(new Set(detected[key])).toSorted();
-            }
-        }
-        catch (error) {
-            logger.warn('AST analysis failed', error);
-            this.detectWithRegex(code, detected);
-        }
-        return detected;
-    }
-    getMemberExpressionPath(node) {
-        const parts = [];
-        let current = node;
-        while (current) {
-            if (this.isMemberExpressionNode(current)) {
-                if (this.isIdentifierNode(current.property)) {
-                    parts.unshift(current.property.name);
-                }
-                else if (this.isStringLiteralNode(current.property)) {
-                    parts.unshift(current.property.value);
-                }
-                current = current.object;
-            }
-            else if (this.isIdentifierNode(current)) {
-                parts.unshift(current.name);
-                break;
-            }
-            else {
-                break;
-            }
-        }
-        if (parts.length > 0 &&
-            parts[0] &&
-            ['window', 'document', 'navigator', 'location', 'screen'].includes(parts[0])) {
-            return parts.join('.');
-        }
-        return null;
-    }
-    detectWithRegex(code, detected) {
-        const patterns = [
-            { regex: /window\.[a-zA-Z_$][a-zA-Z0-9_$]*/g, category: 'window' },
-            { regex: /document\.[a-zA-Z_$][a-zA-Z0-9_$]*/g, category: 'document' },
-            { regex: /navigator\.[a-zA-Z_$][a-zA-Z0-9_$]*/g, category: 'navigator' },
-            { regex: /location\.[a-zA-Z_$][a-zA-Z0-9_$]*/g, category: 'location' },
-            { regex: /screen\.[a-zA-Z_$][a-zA-Z0-9_$]*/g, category: 'screen' },
-        ];
-        for (const { regex, category } of patterns) {
-            const matches = code.match(regex) || [];
-            detected[category].push(...matches);
-        }
-        for (const key of Object.keys(detected)) {
-            detected[key] = Array.from(new Set(detected[key])).toSorted();
-        }
-    }
-    buildManifestFromTemplate(detected, _browserType) {
-        const manifest = {};
-        const template = chromeEnvironmentTemplate;
-        const allPaths = [
-            ...detected.window,
-            ...detected.document,
-            ...detected.navigator,
-            ...detected.location,
-            ...detected.screen,
-            ...detected.other,
-        ];
-        for (const path of allPaths) {
-            const value = this.getValueFromTemplate(path, template);
-            if (value !== undefined) {
-                manifest[path] = value;
-            }
-        }
-        return manifest;
-    }
-    getValueFromTemplate(path, template) {
-        if (!this.isRecord(template)) {
-            return undefined;
-        }
-        const parts = path.split('.');
-        let current = template;
-        for (const part of parts) {
-            if (part === 'window') {
-                current = template.window;
-            }
-            else if (part === 'document') {
-                current = template.document;
-            }
-            else if (part === 'navigator') {
-                current = template.navigator;
-            }
-            else if (part === 'location') {
-                current = template.location;
-            }
-            else if (part === 'screen') {
-                current = template.screen;
-            }
-            else if (this.isRecord(current) && part in current) {
-                current = current[part];
-            }
-            else {
-                return undefined;
-            }
-        }
-        return current;
-    }
-    async fetchRealEnvironment(url, detected, depth) {
-        const { manifest, browser } = await fetchRealEnvironmentData({
-            browser: this.browser ?? undefined,
-            url,
-            detected,
-            depth,
-            resolveExecutablePath: () => this.resolveExecutablePath(),
-            buildManifestFromTemplate: (vars, browserType) => this.buildManifestFromTemplate(vars, browserType),
-        });
-        if (browser) {
-            this.browser = browser;
-        }
-        return manifest;
-    }
-    resolveExecutablePath() {
-        const configuredPath = process.env.PUPPETEER_EXECUTABLE_PATH?.trim() ||
-            process.env.CHROME_PATH?.trim() ||
-            process.env.BROWSER_EXECUTABLE_PATH?.trim();
-        if (configuredPath) {
-            if (existsSync(configuredPath)) {
-                return configuredPath;
-            }
-            throw new Error(`Configured browser executable was not found: ${configuredPath}. ` +
-                'Set a valid executablePath or configure CHROME_PATH / PUPPETEER_EXECUTABLE_PATH / BROWSER_EXECUTABLE_PATH.');
-        }
-        const detectedPath = findBrowserExecutable();
-        if (detectedPath) {
-            return detectedPath;
-        }
-        logger.info('No explicit browser executable configured. Falling back to Puppeteer-managed browser resolution.');
-        return undefined;
-    }
-    identifyMissingAPIs(detected, manifest) {
-        const missing = [];
-        const allPaths = [
-            ...detected.window,
-            ...detected.document,
-            ...detected.navigator,
-            ...detected.location,
-            ...detected.screen,
-            ...detected.other,
-        ];
-        for (const path of allPaths) {
-            if (!(path in manifest) || manifest[path] === undefined) {
-                let type = 'property';
-                if (path.includes('()')) {
-                    type = 'function';
-                }
-                else if (path.endsWith('Element') || path.endsWith('List')) {
-                    type = 'object';
-                }
-                missing.push({
-                    name: path.split('.').pop() || path,
-                    type,
-                    path,
-                    suggestion: this.getSuggestionForMissingAPI(path, type),
-                });
-            }
-        }
-        return missing;
-    }
-    getSuggestionForMissingAPI(path, type) {
-        if (type === 'function') {
-            return `: ${path} = function() {}`;
-        }
-        else if (type === 'object') {
-            return `: ${path} = {}`;
-        }
-        else {
-            return `null: ${path} = null`;
-        }
-    }
-    async cleanup() {
-        if (this.browser) {
-            await this.browser.close();
-            this.browser = undefined;
-        }
-    }
-    isRecord(value) {
-        return typeof value === 'object' && value !== null;
-    }
-    isIdentifierNode(node) {
-        return this.isRecord(node) && node.type === 'Identifier' && typeof node.name === 'string';
-    }
-    isStringLiteralNode(node) {
-        return this.isRecord(node) && node.type === 'StringLiteral' && typeof node.value === 'string';
-    }
-    isMemberExpressionNode(node) {
-        return (this.isRecord(node) &&
-            node.type === 'MemberExpression' &&
-            'object' in node &&
-            'property' in node);
-    }
-}

package/dist/src/modules/emulator/EnvironmentEmulatorFetch.d.ts

@@ -1,16 +0,0 @@
-import type { Browser } from 'rebrowser-puppeteer-core';
-import type { DetectedEnvironmentVariables } from '../../types/index.js';
-type ManifestRecord = Record<string, unknown>;
-interface FetchRealEnvironmentParams {
-    browser?: Browser;
-    url: string;
-    detected: DetectedEnvironmentVariables;
-    depth: number;
-    resolveExecutablePath: () => string | undefined;
-    buildManifestFromTemplate: (detected: DetectedEnvironmentVariables, browserType: string) => ManifestRecord;
-}
-export declare function fetchRealEnvironmentData(params: FetchRealEnvironmentParams): Promise<{
-    manifest: ManifestRecord;
-    browser?: Browser;
-}>;
-export {};

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

@@ -1,333 +0,0 @@
-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 = {};
-    let browser = params.browser;
-    let page;
-    try {
-        if (!browser) {
-            const executablePath = resolveExecutablePath();
-            const launchOptions = {
-                headless: true,
-                args: [
-                    '--no-sandbox',
-                    '--disable-setuid-sandbox',
-                    '--disable-blink-features=AutomationControlled',
-                    '--disable-extensions',
-                    '--disable-component-extensions-with-background-pages',
-                    '--disable-dev-shm-usage',
-                    '--disable-accelerated-2d-canvas',
-                    '--no-first-run',
-                    '--no-zygote',
-                    '--disable-gpu',
-                ],
-            };
-            if (executablePath) {
-                launchOptions.executablePath = executablePath;
-            }
-            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;
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined,
-                configurable: true,
-            });
-            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 = [
-                        {
-                            0: {
-                                type: 'application/x-google-chrome-pdf',
-                                suffixes: 'pdf',
-                                description: 'Portable Document Format',
-                                enabledPlugin: null,
-                            },
-                            description: 'Portable Document Format',
-                            filename: 'internal-pdf-viewer',
-                            length: 1,
-                            name: 'Chrome PDF Plugin',
-                        },
-                        {
-                            0: {
-                                type: 'application/pdf',
-                                suffixes: 'pdf',
-                                description: '',
-                                enabledPlugin: null,
-                            },
-                            description: '',
-                            filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
-                            length: 1,
-                            name: 'Chrome PDF Viewer',
-                        },
-                        {
-                            0: {
-                                type: 'application/x-nacl',
-                                suffixes: '',
-                                description: 'Native Client Executable',
-                                enabledPlugin: null,
-                            },
-                            1: {
-                                type: 'application/x-pnacl',
-                                suffixes: '',
-                                description: 'Portable Native Client Executable',
-                                enabledPlugin: null,
-                            },
-                            description: '',
-                            filename: 'internal-nacl-plugin',
-                            length: 2,
-                            name: 'Native Client',
-                        },
-                    ];
-                    return pluginArray;
-                },
-                configurable: true,
-            });
-            Object.defineProperty(navigator, 'languages', {
-                get: () => ['zh-CN', 'zh', 'en-US', 'en'],
-                configurable: true,
-            });
-            const permissions = window.navigator.permissions;
-            const originalQuery = permissions.query.bind(permissions);
-            permissions.query = (parameters) => parameters.name === 'notifications'
-                ? Promise.resolve({ state: Notification.permission })
-                : originalQuery(parameters);
-            if (!typedWindow.requestAnimationFrame) {
-                typedWindow.requestAnimationFrame = function (callback) {
-                    return window.setTimeout(() => callback(performance.now()), 16);
-                };
-            }
-            if (!typedWindow.cancelAnimationFrame) {
-                typedWindow.cancelAnimationFrame = function (id) {
-                    window.clearTimeout(id);
-                };
-            }
-            typedWindow._sdkGlueVersionMap = typedWindow._sdkGlueVersionMap || {};
-        });
-        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        const allPaths = [
-            ...detected.window,
-            ...detected.document,
-            ...detected.navigator,
-            ...detected.location,
-            ...detected.screen,
-            ...detected.other,
-        ];
-        const extractedValues = await page.evaluate((paths, maxDepth) => {
-            const result = {};
-            const seen = new WeakSet();
-            function extractValue(path) {
-                try {
-                    const parts = path.split('.');
-                    let current = window;
-                    for (const part of parts) {
-                        if (typeof current === 'object' && current !== null && part in current) {
-                            current = current[part];
-                        }
-                        else {
-                            return undefined;
-                        }
-                    }
-                    return serializeValue(current, maxDepth, seen);
-                }
-                catch (error) {
-                    return `[Error: ${error.message}]`;
-                }
-            }
-            function serializeValue(value, recurseDepth, seenObjects) {
-                if (recurseDepth <= 0)
-                    return '[Max Depth]';
-                if (value === null)
-                    return null;
-                if (value === undefined)
-                    return undefined;
-                const type = typeof value;
-                if (type === 'string' || type === 'number' || type === 'boolean') {
-                    return value;
-                }
-                if (type === 'function') {
-                    const fn = value;
-                    try {
-                        return {
-                            __type: 'Function',
-                            name: fn.name || 'anonymous',
-                            toString: fn.toString().substring(0, 200),
-                        };
-                    }
-                    catch {
-                        return '[Function]';
-                    }
-                }
-                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, recurseDepth - 1, seenObjects));
-                    if (value.length > 20) {
-                        arr.push(`[... ${value.length - 20} more items]`);
-                    }
-                    return arr;
-                }
-                if (typeof value === 'object' && value !== null) {
-                    seenObjects.add(value);
-                    const serialized = {};
-                    const allKeys = Object.getOwnPropertyNames(value);
-                    const limitedKeys = allKeys.slice(0, 100);
-                    for (const key of limitedKeys) {
-                        try {
-                            const descriptor = Object.getOwnPropertyDescriptor(value, key);
-                            if (descriptor) {
-                                if (descriptor.get) {
-                                    try {
-                                        serialized[key] = serializeValue(value[key], recurseDepth - 1, seenObjects);
-                                    }
-                                    catch {
-                                        serialized[key] = '[Getter Error]';
-                                    }
-                                }
-                                else if (descriptor.value !== undefined) {
-                                    serialized[key] = serializeValue(descriptor.value, recurseDepth - 1, seenObjects);
-                                }
-                            }
-                        }
-                        catch (e) {
-                            serialized[key] = `[Error: ${e.message}]`;
-                        }
-                    }
-                    if (allKeys.length > 100) {
-                        serialized['__more'] = `[... ${allKeys.length - 100} more properties]`;
-                    }
-                    return serialized;
-                }
-                try {
-                    return String(value);
-                }
-                catch {
-                    return '[Unserializable]';
-                }
-            }
-            for (const path of paths) {
-                result[path] = extractValue(path);
-            }
-            const commonAntiCrawlVars = [
-                'navigator.userAgent',
-                'navigator.platform',
-                'navigator.vendor',
-                'navigator.hardwareConcurrency',
-                'navigator.deviceMemory',
-                'navigator.maxTouchPoints',
-                'navigator.language',
-                'navigator.languages',
-                'navigator.onLine',
-                'navigator.cookieEnabled',
-                'navigator.doNotTrack',
-                'screen.width',
-                'screen.height',
-                'screen.availWidth',
-                'screen.availHeight',
-                'screen.colorDepth',
-                'screen.pixelDepth',
-                'screen.orientation.type',
-                'window.innerWidth',
-                'window.innerHeight',
-                'window.outerWidth',
-                'window.outerHeight',
-                'window.devicePixelRatio',
-                'window.screenX',
-                'window.screenY',
-                'document.referrer',
-                'document.cookie',
-                'document.title',
-                'document.URL',
-                'document.documentURI',
-                'document.domain',
-                'location.href',
-                'location.protocol',
-                'location.host',
-                'location.hostname',
-                'location.port',
-                'location.pathname',
-                'location.search',
-                'location.hash',
-                'location.origin',
-            ];
-            for (const varPath of commonAntiCrawlVars) {
-                if (!result[varPath]) {
-                    result[varPath] = extractValue(varPath);
-                }
-            }
-            return result;
-        }, allPaths, depth);
-        Object.assign(manifest, extractedValues);
-        logger.info(`  ${Object.keys(manifest).length} `);
-    }
-    catch (error) {
-        logger.warn('Variable extraction failed', error);
-        return { manifest: buildManifestFromTemplate(detected, 'chrome'), browser };
-    }
-    finally {
-        if (page) {
-            try {
-                await page.close();
-            }
-            catch {
-            }
-        }
-    }
-    return { manifest, browser };
-}