@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,377 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { setTimeout as asyncSetTimeout } from 'node:timers/promises';
-export class PageController {
-    collector;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    async navigate(url, options) {
-        const page = await this.collector.getActivePage();
-        const startTime = Date.now();
-        await page.goto(url, {
-            waitUntil: options?.waitUntil || 'networkidle2',
-            timeout: options?.timeout || 30000,
-        });
-        const loadTime = Date.now() - startTime;
-        const title = await page.title();
-        const currentUrl = page.url();
-        logger.info(`Navigated to: ${url}`);
-        return {
-            url: currentUrl,
-            title,
-            loadTime,
-        };
-    }
-    async reload(options) {
-        const page = await this.collector.getActivePage();
-        await page.reload({
-            waitUntil: options?.waitUntil || 'networkidle2',
-            timeout: options?.timeout || 30000,
-        });
-        logger.info('Page reloaded');
-    }
-    async goBack() {
-        const page = await this.collector.getActivePage();
-        await page.goBack();
-        logger.info('Navigated back');
-    }
-    async goForward() {
-        const page = await this.collector.getActivePage();
-        await page.goForward();
-        logger.info('Navigated forward');
-    }
-    async click(selector, options) {
-        const page = await this.collector.getActivePage();
-        await page.click(selector, {
-            button: options?.button || 'left',
-            clickCount: options?.clickCount || 1,
-            delay: options?.delay,
-        });
-        logger.info(`Clicked: ${selector}`);
-    }
-    async type(selector, text, options) {
-        const page = await this.collector.getActivePage();
-        await page.type(selector, text, {
-            delay: options?.delay,
-        });
-        logger.info(`Typed into ${selector}: ${text.substring(0, 20)}...`);
-    }
-    async select(selector, ...values) {
-        const page = await this.collector.getActivePage();
-        await page.select(selector, ...values);
-        logger.info(`Selected in ${selector}: ${values.join(', ')}`);
-    }
-    async hover(selector) {
-        const page = await this.collector.getActivePage();
-        await page.hover(selector);
-        logger.info(`Hovered: ${selector}`);
-    }
-    async scroll(options) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((opts) => {
-            window.scrollTo(opts.x || 0, opts.y || 0);
-        }, options);
-        logger.info(`Scrolled to: x=${options.x || 0}, y=${options.y || 0}`);
-    }
-    async waitForSelector(selector, timeout) {
-        try {
-            const page = await this.collector.getActivePage();
-            await page.waitForSelector(selector, {
-                timeout: timeout || 30000,
-            });
-            const element = await page.evaluate((sel) => {
-                const el = document.querySelector(sel);
-                if (!el)
-                    return null;
-                return {
-                    tagName: el.tagName.toLowerCase(),
-                    id: el.id || undefined,
-                    className: el.className || undefined,
-                    textContent: el.textContent?.trim().substring(0, 100) || undefined,
-                    attributes: Array.from(el.attributes).reduce((acc, attr) => {
-                        acc[attr.name] = attr.value;
-                        return acc;
-                    }, {}),
-                };
-            }, selector);
-            logger.info(`Selector appeared: ${selector}`);
-            return {
-                success: true,
-                element,
-                message: `Selector appeared: ${selector}`,
-            };
-        }
-        catch (error) {
-            logger.error(`waitForSelector timeout for ${selector}:`, error);
-            return {
-                success: false,
-                message: `Timeout waiting for selector: ${selector}`,
-            };
-        }
-    }
-    async waitForNavigation(timeout) {
-        const page = await this.collector.getActivePage();
-        await page.waitForNavigation({
-            waitUntil: 'networkidle2',
-            timeout: timeout || 30000,
-        });
-        logger.info('Navigation completed');
-    }
-    async evaluate(code) {
-        const page = await this.collector.getActivePage();
-        const result = await evaluateWithTimeout(page, code);
-        logger.info('JavaScript executed');
-        return result;
-    }
-    async getURL() {
-        const page = await this.collector.getActivePage();
-        return page.url();
-    }
-    async getTitle() {
-        const page = await this.collector.getActivePage();
-        return await page.title();
-    }
-    async getContent() {
-        const page = await this.collector.getActivePage();
-        return await page.content();
-    }
-    async screenshot(options) {
-        const page = await this.collector.getActivePage();
-        const screenshotOpts = {
-            path: options?.path,
-            type: options?.type || 'png',
-            quality: options?.quality,
-            fullPage: options?.fullPage || false,
-        };
-        if (options?.clip) {
-            screenshotOpts.clip = options.clip;
-            screenshotOpts.fullPage = false;
-        }
-        const buffer = await page.screenshot(screenshotOpts);
-        logger.info(`Screenshot taken${options?.path ? `: ${options.path}` : ''}`);
-        return buffer;
-    }
-    async getPerformanceMetrics() {
-        const page = await this.collector.getActivePage();
-        const metrics = await evaluateWithTimeout(page, () => {
-            const perf = performance.getEntriesByType('navigation')[0];
-            return {
-                domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
-                loadComplete: perf.loadEventEnd - perf.loadEventStart,
-                dns: perf.domainLookupEnd - perf.domainLookupStart,
-                tcp: perf.connectEnd - perf.connectStart,
-                request: perf.responseStart - perf.requestStart,
-                response: perf.responseEnd - perf.responseStart,
-                total: perf.loadEventEnd - perf.fetchStart,
-                resources: performance.getEntriesByType('resource').length,
-            };
-        });
-        logger.info('Performance metrics retrieved');
-        return metrics;
-    }
-    async injectScript(scriptContent) {
-        const page = await this.collector.getActivePage();
-        await evaluateWithTimeout(page, (script) => {
-            const scriptElement = document.createElement('script');
-            scriptElement.textContent = script;
-            document.head.appendChild(scriptElement);
-        }, scriptContent);
-        logger.info('Script injected into page');
-    }
-    async setCookies(cookies) {
-        const page = await this.collector.getActivePage();
-        await page.setCookie(...cookies);
-        logger.info(`Set ${cookies.length} cookies`);
-    }
-    async getCookies() {
-        const page = await this.collector.getActivePage();
-        const cookies = await page.cookies();
-        logger.info(`Retrieved ${cookies.length} cookies`);
-        return cookies;
-    }
-    async clearCookies() {
-        const page = await this.collector.getActivePage();
-        const cookies = await page.cookies();
-        await page.deleteCookie(...cookies);
-        logger.info('All cookies cleared');
-    }
-    async setViewport(width, height) {
-        const page = await this.collector.getActivePage();
-        await page.setViewport({ width, height });
-        logger.info(`Viewport set to ${width}x${height}`);
-    }
-    async emulateDevice(deviceName) {
-        const page = await this.collector.getActivePage();
-        const devices = {
-            iPhone: {
-                viewport: { width: 375, height: 812, isMobile: true },
-                userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
-            },
-            iPad: {
-                viewport: { width: 768, height: 1024, isMobile: true },
-                userAgent: 'Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
-            },
-            Android: {
-                viewport: { width: 360, height: 640, isMobile: true },
-                userAgent: 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 Chrome/91.0.4472.120',
-            },
-        };
-        const normalized = String(deviceName || '')
-            .trim()
-            .toLowerCase();
-        let resolvedDevice = null;
-        if (normalized.includes('iphone')) {
-            resolvedDevice = 'iPhone';
-        }
-        else if (normalized.includes('ipad')) {
-            resolvedDevice = 'iPad';
-        }
-        else if (normalized.includes('android') || normalized.includes('pixel')) {
-            resolvedDevice = 'Android';
-        }
-        if (!resolvedDevice) {
-            throw new Error(`Unsupported device "${deviceName}". Supported values include: iPhone, iPad, Android (aliases like "iPhone 13" are accepted).`);
-        }
-        const device = devices[resolvedDevice];
-        await page.setViewport(device.viewport);
-        await page.setUserAgent(device.userAgent);
-        logger.info(`Emulating ${resolvedDevice} (input: ${deviceName})`);
-        return resolvedDevice;
-    }
-    async waitForNetworkIdle(timeout = 30000) {
-        const page = await this.collector.getActivePage();
-        await page.waitForNetworkIdle({ timeout });
-        logger.info('Network is idle');
-    }
-    async getLocalStorage() {
-        const page = await this.collector.getActivePage();
-        const storage = await page.evaluate(() => {
-            const items = {};
-            for (let i = 0; i < localStorage.length; i++) {
-                const key = localStorage.key(i);
-                if (key) {
-                    items[key] = localStorage.getItem(key) || '';
-                }
-            }
-            return items;
-        });
-        logger.info(`Retrieved ${Object.keys(storage).length} localStorage items`);
-        return storage;
-    }
-    async setLocalStorage(key, value) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((k, v) => {
-            localStorage.setItem(k, v);
-        }, key, value);
-        logger.info(`Set localStorage: ${key}`);
-    }
-    async clearLocalStorage() {
-        const page = await this.collector.getActivePage();
-        await page.evaluate(() => {
-            localStorage.clear();
-        });
-        logger.info('LocalStorage cleared');
-    }
-    async pressKey(key) {
-        const page = await this.collector.getActivePage();
-        await page.keyboard.press(key);
-        logger.info(`Pressed key: ${key}`);
-    }
-    async uploadFile(selector, filePath) {
-        const page = await this.collector.getActivePage();
-        const input = await page.$(selector);
-        if (!input) {
-            throw new Error(`File input not found: ${selector}`);
-        }
-        await input.uploadFile(filePath);
-        logger.info(`File uploaded: ${filePath}`);
-    }
-    async getAllLinks() {
-        const page = await this.collector.getActivePage();
-        const links = await page.evaluate(() => {
-            const anchors = document.querySelectorAll('a[href]');
-            const result = [];
-            for (let i = 0; i < anchors.length; i++) {
-                const anchor = anchors[i];
-                result.push({
-                    text: anchor.textContent?.trim() || '',
-                    href: anchor.href,
-                });
-            }
-            return result;
-        });
-        logger.info(`Found ${links.length} links`);
-        return links;
-    }
-    async getPage() {
-        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().', { cause: err });
-        }
-        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,11 +0,0 @@
-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, 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,234 +0,0 @@
-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((limit) => {
-        const scriptElements = Array.from(document.querySelectorAll('script'));
-        return scriptElements
-            .filter((script) => !script.src && script.textContent)
-            .map((script, index) => {
-            let content = script.textContent || '';
-            const originalSize = content.length;
-            let truncated = false;
-            if (content.length > limit) {
-                content = content.substring(0, limit);
-                truncated = true;
-            }
-            return {
-                url: `inline-script-${index}`,
-                content,
-                size: content.length,
-                type: 'inline',
-                metadata: {
-                    scriptType: script.type || 'text/javascript',
-                    async: script.async,
-                    defer: script.defer,
-                    integrity: script.integrity || undefined,
-                    truncated,
-                    originalSize: truncated ? originalSize : undefined,
-                },
-            };
-        });
-    }, maxSingleSize);
-    const limitedScripts = scripts.slice(0, maxFilesPerCollect);
-    if (scripts.length > limitedScripts.length) {
-        logger.warn(`Found ${scripts.length} inline scripts, limiting to ${maxFilesPerCollect}`);
-    }
-    const truncatedCount = limitedScripts.filter((s) => s.metadata?.truncated).length;
-    if (truncatedCount > 0) {
-        logger.warn(`${truncatedCount} inline scripts were truncated due to size limits`);
-    }
-    logger.debug(`Collected ${limitedScripts.length} inline scripts`);
-    return limitedScripts;
-}
-export async function collectServiceWorkers(page, shouldCollectUrl = () => true) {
-    try {
-        const serviceWorkers = await page.evaluate(async () => {
-            if (!('serviceWorker' in navigator)) {
-                return [];
-            }
-            const registrations = await navigator.serviceWorker.getRegistrations();
-            const workers = [];
-            for (const registration of registrations) {
-                const worker = registration.active || registration.installing || registration.waiting;
-                if (worker && worker.scriptURL) {
-                    workers.push({
-                        url: worker.scriptURL,
-                        scope: registration.scope,
-                        state: worker.state,
-                    });
-                }
-            }
-            return workers;
-        });
-        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);
-                    return await response.text();
-                }, worker.url);
-                if (content) {
-                    files.push({
-                        url: worker.url,
-                        content,
-                        size: content.length,
-                        type: 'service-worker',
-                    });
-                    logger.debug(`Collected Service Worker: ${worker.url}`);
-                }
-            }
-            catch (error) {
-                logger.warn(`Failed to collect Service Worker: ${worker.url}`, error);
-            }
-        }
-        return files;
-    }
-    catch (error) {
-        logger.warn('Service Worker collection failed', error);
-        return [];
-    }
-}
-export async function collectWebWorkers(page, shouldCollectUrl = () => true) {
-    try {
-        const workerUrls = await page.evaluate(() => {
-            const workerWindow = window;
-            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();
-                }, absoluteUrl);
-                if (content) {
-                    files.push({
-                        url: absoluteUrl,
-                        content,
-                        size: content.length,
-                        type: 'web-worker',
-                    });
-                    logger.debug(`Collected Web Worker: ${absoluteUrl}`);
-                }
-            }
-            catch (error) {
-                logger.warn(`Failed to collect Web Worker: ${url}`, error);
-            }
-        }
-        return files;
-    }
-    catch (error) {
-        logger.warn('Web Worker collection failed', error);
-        return [];
-    }
-}
-export function analyzeDependencies(files) {
-    const nodes = [];
-    const edges = [];
-    files.forEach((file) => {
-        nodes.push({
-            id: file.url,
-            url: file.url,
-            type: file.type,
-        });
-    });
-    files.forEach((file) => {
-        const dependencies = extractDependencies(file.content);
-        dependencies.forEach((dep) => {
-            const targetFile = files.find((f) => f.url.includes(dep) || f.url.endsWith(dep) || f.url.endsWith(`${dep}.js`));
-            if (targetFile) {
-                edges.push({
-                    from: file.url,
-                    to: targetFile.url,
-                    type: 'import',
-                });
-            }
-        });
-    });
-    logger.debug(`Dependency graph: ${nodes.length} nodes, ${edges.length} edges`);
-    return { nodes, edges };
-}
-export function extractDependencies(code) {
-    const dependencies = [];
-    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
-    let match;
-    while ((match = importRegex.exec(code)) !== null) {
-        if (match[1])
-            dependencies.push(match[1]);
-    }
-    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    while ((match = requireRegex.exec(code)) !== null) {
-        if (match[1])
-            dependencies.push(match[1]);
-    }
-    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    while ((match = dynamicImportRegex.exec(code)) !== null) {
-        if (match[1])
-            dependencies.push(match[1]);
-    }
-    return [...new Set(dependencies)];
-}
-export function calculatePriorityScore(file) {
-    let score = 0;
-    if (file.type === 'inline')
-        score += 10;
-    else if (file.type === 'external')
-        score += 5;
-    if (file.size < 10 * 1024)
-        score += 15;
-    else if (file.size < 50 * 1024)
-        score += 10;
-    else if (file.size > 200 * 1024)
-        score -= 10;
-    const url = file.url.toLowerCase();
-    if (url.includes('main') || url.includes('index') || url.includes('app'))
-        score += 20;
-    if (url.includes('crypto') || url.includes('encrypt') || url.includes('sign'))
-        score += 30;
-    if (url.includes('api') || url.includes('request') || url.includes('ajax'))
-        score += 25;
-    if (url.includes('core') || url.includes('common') || url.includes('util'))
-        score += 15;
-    if (url.includes('vendor') ||
-        url.includes('lib') ||
-        url.includes('jquery') ||
-        url.includes('react'))
-        score -= 20;
-    if (url.includes('node_modules') || url.includes('bundle'))
-        score -= 30;
-    return score;
-}

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

@@ -1,37 +0,0 @@
-import type { Page } from 'rebrowser-puppeteer-core';
-import type { CodeFile } from '../../types/index.js';
-export interface SmartCollectOptions {
-    mode: 'summary' | 'priority' | 'incremental' | 'full';
-    maxTotalSize?: number;
-    maxFileSize?: number;
-    priorities?: string[];
-    includePatterns?: string[];
-    excludePatterns?: string[];
-}
-export interface CodeSummary {
-    url: string;
-    size: number;
-    type: string;
-    hasEncryption: boolean;
-    hasAPI: boolean;
-    hasObfuscation: boolean;
-    functions: string[];
-    imports: string[];
-    preview: string;
-}
-export declare class SmartCodeCollector {
-    private readonly DEFAULT_MAX_TOTAL_SIZE;
-    private readonly DEFAULT_MAX_FILE_SIZE;
-    private readonly PREVIEW_LINES;
-    smartCollect(_page: Page, files: CodeFile[], options: SmartCollectOptions): Promise<CodeFile[] | CodeSummary[]>;
-    private collectSummaries;
-    private collectByPriority;
-    private collectIncremental;
-    private collectWithLimit;
-    private calculatePriority;
-    private detectEncryption;
-    private detectAPI;
-    private detectObfuscation;
-    private extractFunctions;
-    private extractImports;
-}