@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/browser/BrowserModeManager.js

@@ -1,431 +0,0 @@
-import { existsSync } from 'fs';
-import { launch } from 'rebrowser-puppeteer-core';
-import { logger } from '../../utils/logger.js';
-import { findBrowserExecutable } from '../../utils/browserExecutable.js';
-import { CaptchaDetector } from '../captcha/CaptchaDetector.js';
-import { determineCaptchaResolution } from '../captcha/CaptchaPolicy.js';
-export class BrowserModeManager {
-    browser = null;
-    currentPage = null;
-    isHeadless = true;
-    isClosing = false;
-    launchPromise;
-    config;
-    captchaDetector;
-    launchOptions;
-    chromePid = null;
-    static BROWSER_CLOSE_TIMEOUT_MS = 5000;
-    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 launch(options);
-        const pid = browser.process()?.pid ?? null;
-        if (this.isClosing) {
-            await browser.close().catch((error) => {
-                logger.warn('Failed to close browser launched during shutdown', error);
-                BrowserModeManager.forceKillPid(pid);
-            });
-            throw new Error('Browser launch aborted because close was requested');
-        }
-        this.browser = browser;
-        this.chromePid = pid;
-        if (pid) {
-            logger.debug(`Chrome child process PID: ${pid}`);
-        }
-        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;
-            const pid = this.chromePid;
-            this.browser = null;
-            this.currentPage = null;
-            this.chromePid = null;
-            if (browser) {
-                try {
-                    await Promise.race([
-                        browser.close(),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('browser.close() timed out')), BrowserModeManager.BROWSER_CLOSE_TIMEOUT_MS)),
-                    ]);
-                    logger.info('Browser closed');
-                }
-                catch (error) {
-                    logger.warn('browser.close() failed or timed out, attempting force-kill:', error);
-                    BrowserModeManager.forceKillPid(pid);
-                }
-            }
-        }
-        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 captchaAssessment = await this.captchaDetector.assess(page);
-        const resolution = determineCaptchaResolution(captchaAssessment, {
-            autoDetectCaptcha: this.config.autoDetectCaptcha,
-            autoSwitchHeadless: this.config.autoSwitchHeadless,
-            isHeadless: this.isHeadless,
-        });
-        if (captchaAssessment.candidates.length > 0) {
-            logger.warn(`CAPTCHA assessment candidates: ${captchaAssessment.candidates
-                .map((candidate) => `${candidate.type}@${candidate.source}(${candidate.confidence}%)`)
-                .join(', ')}`);
-        }
-        if (resolution.action === 'ignore') {
-            return;
-        }
-        if (resolution.action === 'ask_ai' || resolution.action === 'observe') {
-            logger.info(`CAPTCHA auto-handling skipped: ${resolution.reason}`);
-            return;
-        }
-        const captchaResult = captchaAssessment.primaryDetection;
-        logger.warn(`CAPTCHA detected (type: ${captchaResult.type}, confidence: ${captchaResult.confidence}%)`);
-        if (captchaResult.providerHint) {
-            logger.warn(`CAPTCHA provider hint: ${captchaResult.providerHint}`);
-        }
-        if (resolution.action === 'switch_to_headed') {
-            await this.switchToHeaded(page, originalUrl, captchaResult);
-        }
-        else {
-            logger.info(`Waiting for manual CAPTCHA completion: ${resolution.reason}`);
-            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);
-        const oldPid = this.chromePid;
-        try {
-            await this.browser?.close();
-        }
-        catch (error) {
-            logger.warn('Failed to close old browser during mode switch:', error);
-            BrowserModeManager.forceKillPid(oldPid);
-        }
-        this.chromePid = null;
-        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.providerHint ? [`Provider hint: ${captchaInfo.providerHint}`] : []),
-            `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) => {
-                    if (data.local) {
-                        for (const [key, value] of Object.entries(data.local)) {
-                            localStorage.setItem(key, value);
-                        }
-                    }
-                    if (data.session) {
-                        for (const [key, value] of Object.entries(data.session)) {
-                            sessionStorage.setItem(key, value);
-                        }
-                    }
-                }, {
-                    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;
-    }
-    getChromePid() {
-        return this.chromePid;
-    }
-    static forceKillPid(pid) {
-        if (!pid)
-            return;
-        try {
-            process.kill(pid, 'SIGKILL');
-            logger.info(`Force-killed Chrome process PID ${pid}`);
-        }
-        catch (error) {
-            if (error.code !== 'ESRCH') {
-                logger.warn(`Failed to force-kill Chrome PID ${pid}:`, error);
-            }
-        }
-    }
-}

package/dist/src/modules/browser/CDPErrorMapper.d.ts

@@ -1,4 +0,0 @@
-import { ToolError } from '../../errors/ToolError.js';
-export declare function mapCDPError(error: unknown, toolName?: string): ToolError | Error;
-export declare function wrapCDPCall<T>(fn: () => Promise<T>, toolName?: string): Promise<T>;
-export declare function isCDPSessionGone(error: unknown): boolean;

package/dist/src/modules/browser/CDPErrorMapper.js

@@ -1,82 +0,0 @@
-import { ToolError } from '../../errors/ToolError.js';
-const CDP_ERROR_MAPPINGS = [
-    {
-        pattern: /Session.*not found|session closed|Session.*closed/i,
-        code: 'CONNECTION',
-        hint: 'The browser session has been destroyed. Re-launch the browser or open a new tab.',
-    },
-    {
-        pattern: /Target closed|target.*has.*been.*closed/i,
-        code: 'CONNECTION',
-        hint: 'The target page/tab was closed. Open a new tab before re-running this tool.',
-    },
-    {
-        pattern: /Protocol error.*Target\.sendMessageToTarget/i,
-        code: 'CONNECTION',
-        hint: 'CDP protocol communication failed. The browser may have crashed — try page_navigate to restore.',
-    },
-    {
-        pattern: /Execution context was destroyed/i,
-        code: 'RUNTIME',
-        hint: 'The page navigated while a script was running. Re-run the tool after navigation completes.',
-    },
-    {
-        pattern: /Cannot find context with specified id/i,
-        code: 'RUNTIME',
-        hint: 'An iframe or context was removed during execution. Retry after the page settles.',
-    },
-    {
-        pattern: /Node.*not found|Could not find node/i,
-        code: 'NOT_FOUND',
-        hint: 'The referenced DOM node no longer exists. The page may have re-rendered.',
-    },
-    {
-        pattern: /Evaluation failed.*timeout|Navigation timeout|TimeoutError/i,
-        code: 'TIMEOUT',
-        hint: 'The operation timed out. Increase the timeout or check if the page is responding.',
-    },
-    {
-        pattern: /net::ERR_|Failed to navigate|net::ERR_NAME_NOT_RESOLVED/i,
-        code: 'CONNECTION',
-        hint: 'Network error while loading the page. Check the URL and network connectivity.',
-    },
-    {
-        pattern: /Debugger.*not.*enabled|Debugger\.enable.*must.*be.*called/i,
-        code: 'PREREQUISITE',
-        hint: 'The CDP Debugger domain is not enabled. Enable it before using debugger tools.',
-    },
-    {
-        pattern: /Permission denied|Not allowed/i,
-        code: 'PERMISSION',
-        hint: 'The browser denied this operation. Check browser security policies.',
-    },
-];
-export function mapCDPError(error, toolName) {
-    const message = error instanceof Error ? error.message : String(error);
-    for (const mapping of CDP_ERROR_MAPPINGS) {
-        if (mapping.pattern.test(message)) {
-            return new ToolError(mapping.code, `${message}\n\nHint: ${mapping.hint}`, {
-                toolName,
-                cause: error instanceof Error ? error : undefined,
-                details: { originalMessage: message, cdpMapping: true },
-            });
-        }
-    }
-    if (error instanceof ToolError)
-        return error;
-    if (error instanceof Error)
-        return error;
-    return new Error(String(error));
-}
-export async function wrapCDPCall(fn, toolName) {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        throw mapCDPError(error, toolName);
-    }
-}
-export function isCDPSessionGone(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /Session.*not found|Target closed|session closed/i.test(message);
-}

package/dist/src/modules/browser/CamoufoxBrowserManager.d.ts

@@ -1,49 +0,0 @@
-export interface CamoufoxPageLike {
-    goto(url: string, options?: Record<string, unknown>): Promise<unknown>;
-    context(): {
-        newCDPSession(page: CamoufoxPageLike): Promise<unknown>;
-    };
-}
-export interface CamoufoxBrowserLike {
-    newPage(): Promise<CamoufoxPageLike>;
-    close(): Promise<void>;
-    isConnected(): boolean;
-}
-export interface CamoufoxBrowserServerLike {
-    wsEndpoint(): string;
-    close(): Promise<void>;
-}
-export interface CamoufoxBrowserConfig {
-    os?: 'windows' | 'macos' | 'linux';
-    headless?: boolean | 'virtual';
-    geoip?: boolean;
-    humanize?: boolean | number;
-    proxy?: {
-        server: string;
-        username?: string;
-        password?: string;
-    };
-    blockImages?: boolean;
-    blockWebrtc?: boolean;
-}
-export declare class CamoufoxBrowserManager {
-    private browser;
-    private browserServer;
-    private config;
-    private isClosing;
-    private launchPromise?;
-    constructor(config?: CamoufoxBrowserConfig);
-    launch(): Promise<CamoufoxBrowserLike>;
-    private doLaunch;
-    newPage(): Promise<CamoufoxPageLike>;
-    goto(url: string, page?: CamoufoxPageLike): Promise<CamoufoxPageLike>;
-    close(): Promise<void>;
-    private static readonly BROWSER_CLOSE_TIMEOUT_MS;
-    private finalizeClose;
-    launchAsServer(port?: number, ws_path?: string): Promise<string>;
-    connectToServer(wsEndpoint: string): Promise<CamoufoxBrowserLike>;
-    closeBrowserServer(): Promise<void>;
-    getBrowserServerEndpoint(): string | null;
-    getBrowser(): CamoufoxBrowserLike | null;
-    getCDPSession(page: CamoufoxPageLike): Promise<unknown>;
-}