@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/modules/browser/BrowserModeManager.js

@@ -1,370 +0,0 @@
-import { existsSync } from 'fs';
-import puppeteer from 'rebrowser-puppeteer-core';
-import { logger } from '../../utils/logger.js';
-import { findBrowserExecutable } from '../../utils/browserExecutable.js';
-import { CaptchaDetector } from '../captcha/CaptchaDetector.js';
-export class BrowserModeManager {
-    browser = null;
-    currentPage = null;
-    isHeadless = true;
-    isClosing = false;
-    launchPromise;
-    config;
-    captchaDetector;
-    launchOptions;
-    sessionData = {};
-    constructor(config = {}, launchOptions = {}) {
-        this.config = {
-            autoDetectCaptcha: config.autoDetectCaptcha ?? true,
-            autoSwitchHeadless: config.autoSwitchHeadless ?? true,
-            captchaTimeout: config.captchaTimeout ?? 300000,
-            defaultHeadless: config.defaultHeadless ?? true,
-            askBeforeSwitchBack: config.askBeforeSwitchBack ?? true,
-        };
-        this.isHeadless = this.config.defaultHeadless;
-        this.captchaDetector = new CaptchaDetector();
-        this.launchOptions = launchOptions;
-    }
-    async launch() {
-        if (this.browser?.isConnected()) {
-            return this.browser;
-        }
-        if (this.isClosing) {
-            throw new Error('Cannot launch browser while closing');
-        }
-        if (this.launchPromise) {
-            return this.launchPromise;
-        }
-        const launchPromise = this.doLaunch();
-        this.launchPromise = launchPromise;
-        try {
-            return await launchPromise;
-        }
-        finally {
-            if (this.launchPromise === launchPromise) {
-                this.launchPromise = undefined;
-            }
-        }
-    }
-    async doLaunch() {
-        const headlessMode = this.isHeadless;
-        const executablePath = this.resolveExecutablePath();
-        logger.info(`Launching browser (${headlessMode ? 'headless' : 'headed'} mode)...`);
-        const options = {
-            ...this.launchOptions,
-            headless: headlessMode,
-            args: [
-                ...(this.launchOptions.args || []),
-                '--no-sandbox',
-                '--disable-setuid-sandbox',
-                '--disable-blink-features=AutomationControlled',
-                '--disable-extensions',
-                '--disable-component-extensions-with-background-pages',
-            ],
-            ignoreDefaultArgs: ['--enable-automation'],
-        };
-        if (executablePath) {
-            options.executablePath = executablePath;
-        }
-        const browser = await puppeteer.launch(options);
-        if (this.isClosing) {
-            await browser.close().catch(error => {
-                logger.warn('Failed to close browser launched during shutdown', error);
-            });
-            throw new Error('Browser launch aborted because close was requested');
-        }
-        this.browser = browser;
-        logger.info('Browser launched successfully');
-        return this.browser;
-    }
-    resolveExecutablePath() {
-        const configuredPath = this.launchOptions.executablePath?.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;
-    }
-    async newPage() {
-        const browser = this.browser?.isConnected() ? this.browser : await this.launch();
-        const page = await browser.newPage();
-        this.currentPage = page;
-        await this.injectAntiDetectionScripts(page);
-        if (this.sessionData.cookies && this.sessionData.cookies.length > 0) {
-            await page.setCookie(...this.sessionData.cookies);
-        }
-        return page;
-    }
-    async finalizeClose() {
-        try {
-            const browser = this.browser;
-            this.browser = null;
-            this.currentPage = null;
-            if (browser) {
-                await browser.close();
-                logger.info('Browser closed');
-            }
-        }
-        finally {
-            this.isClosing = false;
-        }
-    }
-    async goto(url, page) {
-        const targetPage = page || this.currentPage;
-        if (!targetPage) {
-            throw new Error('No page available. Call newPage() first.');
-        }
-        logger.info(`Navigating to URL: ${url}`);
-        await targetPage.goto(url, { waitUntil: 'networkidle2' });
-        if (this.config.autoDetectCaptcha) {
-            await this.checkAndHandleCaptcha(targetPage, url);
-        }
-        return targetPage;
-    }
-    async checkAndHandleCaptcha(page, originalUrl) {
-        const captchaResult = await this.captchaDetector.detect(page);
-        if (captchaResult.detected) {
-            logger.warn(`CAPTCHA detected (type: ${captchaResult.type}, confidence: ${captchaResult.confidence}%)`);
-            if (captchaResult.vendor) {
-                logger.warn(`CAPTCHA vendor detected: ${captchaResult.vendor}`);
-            }
-            if (this.config.autoSwitchHeadless && this.isHeadless) {
-                await this.switchToHeaded(page, originalUrl, captchaResult);
-            }
-            else {
-                logger.info('Waiting for manual CAPTCHA completion in current browser mode');
-                await this.captchaDetector.waitForCompletion(page, this.config.captchaTimeout);
-            }
-        }
-    }
-    async switchToHeaded(currentPage, url, captchaInfo) {
-        logger.info('Switching browser to headed mode for manual CAPTCHA solving');
-        await this.saveSessionData(currentPage);
-        await this.browser?.close();
-        this.isHeadless = false;
-        await this.launch();
-        const newPage = await this.newPage();
-        await newPage.goto(url, { waitUntil: 'networkidle2' });
-        await this.restoreSessionData(newPage);
-        if (this.sessionData.localStorage || this.sessionData.sessionStorage) {
-            await newPage.reload({ waitUntil: 'networkidle2' });
-        }
-        this.showCaptchaPrompt(captchaInfo);
-        const completed = await this.captchaDetector.waitForCompletion(newPage, this.config.captchaTimeout);
-        if (completed) {
-            logger.info('CAPTCHA solved in headed mode');
-            if (this.config.askBeforeSwitchBack && this.config.defaultHeadless) {
-                logger.info('Headless mode can be restored based on configured policy');
-            }
-        }
-        else {
-            logger.error('CAPTCHA completion timed out in headed mode');
-            throw new Error('Captcha completion timeout');
-        }
-    }
-    showCaptchaPrompt(captchaInfo) {
-        const lines = [
-            '',
-            '='.repeat(60),
-            'CAPTCHA detected. Please solve it manually.',
-            '='.repeat(60),
-            `Type: ${captchaInfo.type}`,
-            ...(captchaInfo.vendor ? [`Vendor: ${captchaInfo.vendor}`] : []),
-            `Confidence: ${captchaInfo.confidence}%`,
-            '',
-            'Please:',
-            '  1. Complete the CAPTCHA in the visible browser window.',
-            '  2. Keep this process running.',
-            '  3. The script will continue automatically after completion.',
-            `  4. Timeout: ${this.config.captchaTimeout / 1000}s`,
-            '='.repeat(60),
-            '',
-        ];
-        for (const line of lines) {
-            process.stderr.write(`${line}\n`);
-        }
-    }
-    async saveSessionData(page) {
-        this.sessionData = {};
-        try {
-            const url = page.url();
-            this.sessionData.origin = url !== 'about:blank' ? new URL(url).origin : undefined;
-            this.sessionData.cookies = await page.cookies();
-            const storageData = await page.evaluate(() => {
-                const local = {};
-                const session = {};
-                for (let i = 0; i < localStorage.length; i++) {
-                    const key = localStorage.key(i);
-                    if (key) {
-                        local[key] = localStorage.getItem(key) || '';
-                    }
-                }
-                for (let i = 0; i < sessionStorage.length; i++) {
-                    const key = sessionStorage.key(i);
-                    if (key) {
-                        session[key] = sessionStorage.getItem(key) || '';
-                    }
-                }
-                return { local, session };
-            });
-            this.sessionData.localStorage = storageData.local;
-            this.sessionData.sessionStorage = storageData.session;
-            logger.info('Session data captured before browser mode switch');
-        }
-        catch (error) {
-            logger.error('Failed to capture session data before mode switch', error);
-        }
-    }
-    async restoreSessionData(page) {
-        try {
-            const currentUrl = page.url();
-            const currentOrigin = currentUrl !== 'about:blank' ? new URL(currentUrl).origin : undefined;
-            if (this.sessionData.origin && currentOrigin && this.sessionData.origin !== currentOrigin) {
-                logger.warn(`Origin mismatch: session data from ${this.sessionData.origin} cannot be restored to ${currentOrigin}. ` +
-                    'This prevents cross-origin data leakage.');
-                return;
-            }
-            if (this.sessionData.localStorage || this.sessionData.sessionStorage) {
-                await page.evaluate((data) => {
-                    const restoreStorage = (storage, items) => {
-                        if (items) {
-                            for (const [key, value] of Object.entries(items)) {
-                                storage.setItem(key, value);
-                            }
-                        }
-                    };
-                    restoreStorage(localStorage, data.local);
-                    restoreStorage(sessionStorage, data.session);
-                }, {
-                    local: this.sessionData.localStorage,
-                    session: this.sessionData.sessionStorage
-                });
-                logger.info('Session storage data restored');
-            }
-        }
-        catch (error) {
-            logger.error('Failed to restore session storage data', error);
-        }
-    }
-    async injectAntiDetectionScripts(page) {
-        await page.evaluateOnNewDocument(() => {
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined,
-            });
-            const win = window;
-            win.chrome = {
-                runtime: {
-                    connect: () => { },
-                    sendMessage: () => { },
-                    onMessage: {
-                        addListener: () => { },
-                        removeListener: () => { },
-                    },
-                },
-                loadTimes: function () {
-                    return {
-                        commitLoadTime: Date.now() / 1000,
-                        connectionInfo: 'http/1.1',
-                        finishDocumentLoadTime: Date.now() / 1000,
-                        finishLoadTime: Date.now() / 1000,
-                        firstPaintAfterLoadTime: 0,
-                        firstPaintTime: Date.now() / 1000,
-                        navigationType: 'Other',
-                        npnNegotiatedProtocol: 'unknown',
-                        requestTime: 0,
-                        startLoadTime: Date.now() / 1000,
-                        wasAlternateProtocolAvailable: false,
-                        wasFetchedViaSpdy: false,
-                        wasNpnNegotiated: false,
-                    };
-                },
-                csi: function () {
-                    return {
-                        onloadT: Date.now(),
-                        pageT: Date.now(),
-                        startE: Date.now(),
-                        tran: 15,
-                    };
-                },
-            };
-            Object.defineProperty(navigator, 'plugins', {
-                get: () => [
-                    {
-                        0: {
-                            type: 'application/pdf',
-                            suffixes: 'pdf',
-                            description: 'Portable Document Format',
-                        },
-                        description: 'Portable Document Format',
-                        filename: 'internal-pdf-viewer',
-                        length: 1,
-                        name: 'Chrome PDF Plugin',
-                    },
-                    {
-                        0: { type: 'application/x-google-chrome-pdf', suffixes: 'pdf', description: '' },
-                        description: '',
-                        filename: 'internal-pdf-viewer',
-                        length: 1,
-                        name: 'Chrome PDF Viewer',
-                    },
-                    {
-                        0: {
-                            type: 'application/x-nacl',
-                            suffixes: '',
-                            description: 'Native Client Executable',
-                        },
-                        1: {
-                            type: 'application/x-pnacl',
-                            suffixes: '',
-                            description: 'Portable Native Client Executable',
-                        },
-                        description: '',
-                        filename: 'internal-nacl-plugin',
-                        length: 2,
-                        name: 'Native Client',
-                    },
-                ],
-            });
-            const originalQuery = window.navigator.permissions.query.bind(window.navigator.permissions);
-            const notification = Notification;
-            window.navigator.permissions.query = (parameters) => parameters.name === 'notifications'
-                ? Promise.resolve({ state: notification.permission })
-                : originalQuery(parameters);
-            Object.defineProperty(navigator, 'languages', {
-                get: () => ['en-US', 'en'],
-            });
-        });
-        logger.info('Injected anti-detection scripts');
-    }
-    async close() {
-        this.sessionData = {};
-        this.isClosing = true;
-        const pendingLaunch = this.launchPromise;
-        if (pendingLaunch) {
-            void pendingLaunch
-                .catch(() => undefined)
-                .finally(() => {
-                void this.finalizeClose();
-            });
-            return;
-        }
-        await this.finalizeClose();
-    }
-    getBrowser() {
-        return this.browser;
-    }
-    getCurrentPage() {
-        return this.currentPage;
-    }
-    isHeadlessMode() {
-        return this.isHeadless;
-    }
-}

package/dist/modules/browser/CamoufoxBrowserManager.js

@@ -1,172 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-export class CamoufoxBrowserManager {
-    browser = null;
-    browserServer = null;
-    config;
-    isClosing = false;
-    launchPromise;
-    constructor(config = {}) {
-        this.config = {
-            os: config.os ?? 'windows',
-            headless: config.headless ?? true,
-            geoip: config.geoip ?? false,
-            humanize: config.humanize ?? false,
-            blockImages: config.blockImages ?? false,
-            blockWebrtc: config.blockWebrtc ?? false,
-            proxy: config.proxy,
-        };
-    }
-    async launch() {
-        if (this.browser?.isConnected()) {
-            return this.browser;
-        }
-        if (this.isClosing) {
-            throw new Error('Cannot launch browser while closing');
-        }
-        if (this.launchPromise) {
-            return this.launchPromise;
-        }
-        this.launchPromise = this.doLaunch();
-        try {
-            return await this.launchPromise;
-        }
-        finally {
-            this.launchPromise = undefined;
-        }
-    }
-    async doLaunch() {
-        if (this.browser) {
-            logger.info('Closing existing Camoufox browser before relaunch');
-            await this.browser.close().catch(err => logger.warn('Failed to close previous browser:', err));
-            this.browser = null;
-        }
-        logger.info(`Launching Camoufox (Firefox) [os=${this.config.os}, headless=${this.config.headless}]...`);
-        let Camoufox;
-        try {
-            ({ Camoufox } = await import('camoufox-js'));
-        }
-        catch (error) {
-            throw new PrerequisiteError(`camoufox-js is not installed or its binaries are missing. Run \`pnpm run install:full\` or \`pnpm exec camoufox-js fetch\` before using the Camoufox driver. Root cause: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        this.browser = (await Camoufox({
-            os: this.config.os,
-            headless: this.config.headless,
-            geoip: this.config.geoip,
-            humanize: this.config.humanize,
-            proxy: this.config.proxy,
-            block_images: this.config.blockImages,
-            block_webrtc: this.config.blockWebrtc,
-        }));
-        if (this.isClosing) {
-            await this.browser.close().catch(error => {
-                logger.warn('Failed to close Camoufox browser launched during shutdown:', error);
-            });
-            this.browser = null;
-            throw new Error('Camoufox launch aborted because close was requested');
-        }
-        logger.info('Camoufox browser launched');
-        return this.browser;
-    }
-    async newPage() {
-        if (!this.browser) {
-            await this.launch();
-        }
-        const page = await this.browser.newPage();
-        logger.info('New Camoufox page created');
-        return page;
-    }
-    async goto(url, page) {
-        const targetPage = page ?? (await this.newPage());
-        logger.info(`Navigating to: ${url}`);
-        await targetPage.goto(url, { waitUntil: 'networkidle' });
-        return targetPage;
-    }
-    async close() {
-        this.isClosing = true;
-        const pendingLaunch = this.launchPromise;
-        if (pendingLaunch) {
-            void pendingLaunch
-                .catch(() => undefined)
-                .finally(() => {
-                void this.finalizeClose();
-            });
-            return;
-        }
-        await this.finalizeClose();
-    }
-    async finalizeClose() {
-        try {
-            const browser = this.browser;
-            this.browser = null;
-            if (browser) {
-                await browser.close();
-                logger.info('Camoufox browser closed');
-            }
-        }
-        finally {
-            this.isClosing = false;
-        }
-    }
-    async launchAsServer(port, ws_path) {
-        logger.info(`Launching Camoufox server [os=${this.config.os}, port=${port ?? 'auto'}]...`);
-        let launchServer;
-        try {
-            ({ launchServer } = await import('camoufox-js'));
-        }
-        catch (error) {
-            throw new PrerequisiteError(`camoufox-js server support is unavailable. Run \`pnpm run install:full\` or \`pnpm exec camoufox-js fetch\` before launching a Camoufox WebSocket server. Root cause: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const serverOptions = {
-            os: this.config.os,
-            headless: this.config.headless,
-            geoip: this.config.geoip,
-            humanize: this.config.humanize,
-            proxy: this.config.proxy,
-            block_images: this.config.blockImages,
-            block_webrtc: this.config.blockWebrtc,
-            port,
-            ws_path,
-        };
-        if (this.browserServer) {
-            logger.info('Closing existing Camoufox server before relaunch');
-            await this.browserServer.close().catch(err => logger.warn('Failed to close previous server:', err));
-            this.browserServer = null;
-        }
-        this.browserServer = await launchServer(serverOptions);
-        const endpoint = this.browserServer.wsEndpoint();
-        logger.info(`Camoufox server listening on: ${endpoint}`);
-        return endpoint;
-    }
-    async connectToServer(wsEndpoint) {
-        logger.info(`Connecting to Camoufox server: ${wsEndpoint}`);
-        if (this.browser) {
-            logger.info('Disconnecting existing browser before new connection');
-            await this.browser.close().catch(err => logger.warn('Failed to close previous browser:', err));
-            this.browser = null;
-        }
-        const playwrightModule = await import('playwright-core');
-        const firefox = playwrightModule.firefox;
-        this.browser = (await firefox.connect(wsEndpoint));
-        logger.info('Connected to Camoufox server');
-        return this.browser;
-    }
-    async closeBrowserServer() {
-        if (this.browserServer) {
-            await this.browserServer.close();
-            this.browserServer = null;
-            logger.info('Camoufox server closed');
-        }
-    }
-    getBrowserServerEndpoint() {
-        return this.browserServer ? this.browserServer.wsEndpoint() : null;
-    }
-    getBrowser() {
-        return this.browser;
-    }
-    async getCDPSession(page) {
-        logger.warn('CDP sessions on camoufox (Firefox) have limited support — consider using Chrome driver for CDP-heavy operations');
-        const context = page.context();
-        return context.newCDPSession(page);
-    }
-}

package/dist/modules/captcha/AICaptchaDetector.d.ts

@@ -1,32 +0,0 @@
-import { Page } from 'rebrowser-puppeteer-core';
-import { LLMService } from '../../services/LLMService.js';
-export interface AICaptchaDetectionResult {
-    detected: boolean;
-    type?: 'slider' | 'image' | 'recaptcha' | 'hcaptcha' | 'cloudflare' | 'text_input' | 'none';
-    confidence: number;
-    reasoning: string;
-    location?: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    screenshot?: string;
-    screenshotPath?: string;
-    vendor?: string;
-    suggestions?: string[];
-}
-export declare class AICaptchaDetector {
-    private llm;
-    private screenshotDir;
-    private hasLoggedVisionFallback;
-    constructor(llm: LLMService, screenshotDir?: string);
-    private saveScreenshot;
-    detect(page: Page): Promise<AICaptchaDetectionResult>;
-    private getPageInfo;
-    private analyzeWithAI;
-    private buildAnalysisPrompt;
-    private parseAIResponse;
-    private fallbackTextAnalysis;
-    waitForCompletion(page: Page, timeout?: number): Promise<boolean>;
-}