@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/domains/browser/handlers/browser-control.js

@@ -1,545 +0,0 @@
-import { argBool, argString, argNumber } from '../../../domains/shared/parse-args.js';
-import { logger } from '../../../../utils/logger.js';
-import { projectRoot } from '../../../../utils/config.js';
-import { readFile, writeFile } from 'fs/promises';
-import { join } from 'path';
-const projectEnvPath = join(projectRoot, '.env');
-const CHROME_CHANNELS = new Set(['stable', 'beta', 'dev', 'canary']);
-export class BrowserControlHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async resetAndEnableMonitoring(context) {
-        try {
-            await this.deps.consoleMonitor.disable();
-        }
-        catch (error) {
-            logger.warn(`[${context}] Failed to reset existing console monitor: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        try {
-            await this.deps.consoleMonitor.enable({
-                enableNetwork: true,
-                enableExceptions: true,
-            });
-            return {
-                networkMonitoringEnabled: true,
-                consoleMonitoringEnabled: true,
-            };
-        }
-        catch (error) {
-            logger.warn(`[${context}] Auto-enable monitoring failed: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                networkMonitoringEnabled: false,
-                consoleMonitoringEnabled: false,
-            };
-        }
-    }
-    async syncTabRegistryWithCollectorPages(context) {
-        try {
-            const resolvedPages = await this.deps.collector.listResolvedPages();
-            const registry = this.deps.getTabRegistry();
-            registry.reconcilePages(resolvedPages.map((entry) => entry.page), resolvedPages.map(({ page: _page, ...meta }) => meta));
-        }
-        catch (error) {
-            logger.warn(`[${context}] Failed to sync attached tabs into TabRegistry: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    parseHeadlessArg(value) {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        if (typeof value === 'number') {
-            if (value === 1)
-                return true;
-            if (value === 0)
-                return false;
-            return undefined;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            if (['true', '1', 'yes', 'on'].includes(normalized)) {
-                return true;
-            }
-            if (['false', '0', 'no', 'off'].includes(normalized)) {
-                return false;
-            }
-        }
-        return undefined;
-    }
-    parseChromeConnectRequest(args) {
-        const channelValue = argString(args, 'channel');
-        if (channelValue && !CHROME_CHANNELS.has(channelValue)) {
-            throw new Error(`Invalid channel "${channelValue}". Expected one of: stable, beta, dev, canary.`);
-        }
-        return {
-            browserURL: argString(args, 'browserURL'),
-            wsEndpoint: argString(args, 'wsEndpoint'),
-            autoConnect: argBool(args, 'autoConnect'),
-            userDataDir: argString(args, 'userDataDir'),
-            channel: channelValue,
-        };
-    }
-    hasChromeConnectRequest(request) {
-        return Boolean(request.browserURL ||
-            request.wsEndpoint ||
-            request.autoConnect ||
-            request.userDataDir ||
-            request.channel);
-    }
-    describeChromeConnectRequest(request) {
-        if (request.wsEndpoint) {
-            return request.wsEndpoint;
-        }
-        if (request.browserURL) {
-            return request.browserURL;
-        }
-        if (request.userDataDir) {
-            return `autoConnect:${request.userDataDir}`;
-        }
-        return `autoConnect:${request.channel ?? 'stable'}`;
-    }
-    isAutoConnectRequest(request) {
-        return Boolean(request.autoConnect || request.userDataDir || request.channel);
-    }
-    getAutoConnectApprovalHint(request) {
-        if (!this.isAutoConnectRequest(request)) {
-            return null;
-        }
-        return 'Chrome 144+ autoConnect may prompt for manual approval. Switch to Chrome and click Allow for this client if prompted.';
-    }
-    shouldAttemptLinuxHeadfulFallback(headlessArg, error) {
-        const requestedHeadful = headlessArg === false ||
-            (headlessArg === undefined && process.env.PUPPETEER_HEADLESS === 'false');
-        const linuxRuntime = process.platform === 'linux' || process.env.JSHOOK_FORCE_LINUX_FALLBACK === 'true';
-        if (!requestedHeadful || !linuxRuntime) {
-            return false;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        return /Missing X server|cannot open display|Failed to launch the browser process|ozone|No protocol specified|X11|Wayland|DevToolsActivePort/i.test(message);
-    }
-    async persistHeadlessEnv(value) {
-        try {
-            let envContent = '';
-            try {
-                envContent = await readFile(projectEnvPath, 'utf-8');
-            }
-            catch (error) {
-                const code = error?.code;
-                if (code !== 'ENOENT') {
-                    throw error;
-                }
-            }
-            const nextLine = `PUPPETEER_HEADLESS=${value}`;
-            const updated = /^PUPPETEER_HEADLESS=.*$/m.test(envContent)
-                ? envContent.replace(/^PUPPETEER_HEADLESS=.*$/m, nextLine)
-                : `${envContent.trimEnd()}\n${nextLine}\n`;
-            await writeFile(projectEnvPath, updated, 'utf-8');
-        }
-        catch (error) {
-            logger.warn(`Failed to persist PUPPETEER_HEADLESS=${value} to .env: ${String(error)}`);
-        }
-    }
-    async handleBrowserLaunch(args) {
-        const driver = argString(args, 'driver', 'chrome');
-        if (driver === 'camoufox') {
-            const mode = argString(args, 'mode', 'launch');
-            if (mode === 'connect') {
-                const wsEndpoint = argString(args, 'wsEndpoint');
-                if (!wsEndpoint) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    error: 'wsEndpoint is required for connect mode. Use camoufox_server_launch first to get a wsEndpoint.',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                driver: 'camoufox',
-                                mode: 'connect',
-                                wsEndpoint,
-                                message: 'Connected to Camoufox server. Use page_navigate to begin.',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            driver: 'camoufox',
-                            mode: 'launch',
-                            message: 'Camoufox (Firefox) browser launched',
-                            note: 'Use page_navigate to begin. CDP debugger is limited in Firefox; network_enable and console_enable use Playwright events and are fully supported.',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const mode = argString(args, 'mode', 'launch');
-        if (mode === 'connect') {
-            const connectRequest = this.parseChromeConnectRequest(args);
-            if (!this.hasChromeConnectRequest(connectRequest)) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: 'browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required for chrome connect mode.',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            await this.deps.collector.connect(connectRequest);
-            const status = await this.deps.collector.getStatus();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            driver: 'chrome',
-                            mode: 'connect',
-                            endpoint: this.describeChromeConnectRequest(connectRequest),
-                            autoConnect: this.isAutoConnectRequest(connectRequest),
-                            channel: connectRequest.channel ?? null,
-                            userDataDir: connectRequest.userDataDir ?? null,
-                            manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
-                            approvalHint: this.getAutoConnectApprovalHint(connectRequest),
-                            message: 'Connected to existing Chrome browser successfully',
-                            status,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const chromeHeadless = this.parseHeadlessArg(args.headless);
-        try {
-            await this.deps.collector.init(chromeHeadless);
-        }
-        catch (error) {
-            if (!this.shouldAttemptLinuxHeadfulFallback(chromeHeadless, error)) {
-                throw error;
-            }
-            const reason = error instanceof Error ? error.message : String(error);
-            logger.warn(`Headful launch failed on Linux, fallback to headless=true: ${reason}`);
-            process.env.PUPPETEER_HEADLESS = 'true';
-            await this.persistHeadlessEnv('true');
-            await this.deps.collector.init(true);
-            const fallbackStatus = await this.deps.collector.getStatus();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            driver: 'chrome',
-                            message: 'Browser launched with Linux fallback (headless=true)',
-                            status: fallbackStatus,
-                            fallback: {
-                                applied: true,
-                                reason: 'Headful browser is unavailable in current Linux runtime; switched to headless and updated .env',
-                                newEnv: 'PUPPETEER_HEADLESS=true',
-                            },
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const status = await this.deps.collector.getStatus();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        driver: 'chrome',
-                        message: 'Browser launched successfully',
-                        status,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleBrowserClose(_args) {
-        await this.deps.collector.close();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        message: 'Browser closed successfully',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleBrowserStatus(_args) {
-        const status = await this.deps.collector.getStatus();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({ driver: 'chrome', ...status }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleBrowserListTabs(args) {
-        try {
-            const connectRequest = this.parseChromeConnectRequest(args);
-            if (this.hasChromeConnectRequest(connectRequest)) {
-                await this.deps.collector.connect(connectRequest);
-            }
-            const pages = await this.deps.collector.listPages();
-            const registry = this.deps.getTabRegistry();
-            await this.syncTabRegistryWithCollectorPages('browser_list_tabs');
-            const enrichedPages = pages.map((page) => {
-                const tab = registry.getTabByIndex(page.index);
-                return {
-                    ...page,
-                    pageId: tab?.pageId ?? null,
-                    aliases: tab?.aliases ?? [],
-                };
-            });
-            const currentInfo = registry.getContextMeta();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            count: pages.length,
-                            pages: enrichedPages,
-                            currentPageId: currentInfo.pageId,
-                            currentIndex: currentInfo.tabIndex,
-                            autoConnect: this.isAutoConnectRequest(connectRequest),
-                            manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
-                            approvalHint: this.getAutoConnectApprovalHint(connectRequest),
-                            hint: 'Use browser_select_tab(index=N) to switch to a specific tab',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Failed to list tabs:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                            hint: 'Make sure browser is attached via browser_attach first, or provide browserURL/autoConnect. Chrome 144+ autoConnect may require manual approval in the Chrome window.',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleBrowserSelectTab(args) {
-        try {
-            const index = argNumber(args, 'index');
-            const urlPattern = argString(args, 'urlPattern');
-            const titlePattern = argString(args, 'titlePattern');
-            const registry = this.deps.getTabRegistry();
-            if (index !== undefined) {
-                await this.deps.collector.selectPage(index);
-                const pages = await this.deps.collector.listPages();
-                await this.syncTabRegistryWithCollectorPages('browser_select_tab');
-                const selected = pages[index];
-                const tab = registry.setCurrentByIndex(index);
-                const monitoring = tab?.pageId
-                    ? await this.resetAndEnableMonitoring('browser_select_tab')
-                    : { networkMonitoringEnabled: false, consoleMonitoringEnabled: false };
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                selectedIndex: index,
-                                selectedPageId: tab?.pageId ?? null,
-                                url: selected?.url,
-                                title: selected?.title,
-                                activeContextRefreshed: true,
-                                networkMonitoringEnabled: monitoring.networkMonitoringEnabled,
-                                consoleMonitoringEnabled: monitoring.consoleMonitoringEnabled,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const pages = await this.deps.collector.listPages();
-            let matchIndex = -1;
-            for (const page of pages) {
-                if (urlPattern && page.url.includes(urlPattern)) {
-                    matchIndex = page.index;
-                    break;
-                }
-                if (titlePattern && page.title.includes(titlePattern)) {
-                    matchIndex = page.index;
-                    break;
-                }
-            }
-            if (matchIndex === -1) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: 'No matching tab found',
-                                availablePages: pages,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            await this.deps.collector.selectPage(matchIndex);
-            await this.syncTabRegistryWithCollectorPages('browser_select_tab');
-            const selected = pages[matchIndex];
-            const tab = registry.setCurrentByIndex(matchIndex);
-            const monitoring = tab?.pageId
-                ? await this.resetAndEnableMonitoring('browser_select_tab')
-                : { networkMonitoringEnabled: false, consoleMonitoringEnabled: false };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            selectedIndex: matchIndex,
-                            selectedPageId: tab?.pageId ?? null,
-                            url: selected?.url,
-                            title: selected?.title,
-                            activeContextRefreshed: true,
-                            networkMonitoringEnabled: monitoring.networkMonitoringEnabled,
-                            consoleMonitoringEnabled: monitoring.consoleMonitoringEnabled,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Failed to select tab:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleBrowserAttach(args) {
-        let connectRequest = null;
-        try {
-            connectRequest = this.parseChromeConnectRequest(args);
-            if (!this.hasChromeConnectRequest(connectRequest)) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: 'browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            await this.deps.collector.connect(connectRequest);
-            const rawPageIndex = args.pageIndex;
-            const pageIndex = typeof rawPageIndex === 'number'
-                ? rawPageIndex
-                : typeof rawPageIndex === 'string' && rawPageIndex.trim() !== ''
-                    ? Number(rawPageIndex)
-                    : 0;
-            const selectedIndex = Number.isFinite(pageIndex) ? pageIndex : 0;
-            const pages = await this.deps.collector.listPages();
-            if (pages.length > 0 && selectedIndex < pages.length) {
-                await this.deps.collector.selectPage(selectedIndex);
-            }
-            else if (pages.length > 0) {
-                await this.deps.collector.selectPage(0);
-                logger.warn(`[browser_attach] pageIndex ${selectedIndex} out of range (0-${pages.length - 1}), fell back to 0`);
-            }
-            const registry = this.deps.getTabRegistry();
-            await this.syncTabRegistryWithCollectorPages('browser_attach');
-            const actualIndex = pages.length > 0 ? Math.min(selectedIndex, pages.length - 1) : 0;
-            const tab = registry.setCurrentByIndex(actualIndex);
-            const selected = pages[actualIndex];
-            const pageHandleReady = Boolean(tab?.pageId);
-            const { networkMonitoringEnabled, consoleMonitoringEnabled } = pageHandleReady
-                ? await this.resetAndEnableMonitoring('browser_attach')
-                : { networkMonitoringEnabled: false, consoleMonitoringEnabled: false };
-            const status = await this.deps.collector.getStatus();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            message: 'Attached to existing browser successfully',
-                            endpoint: this.describeChromeConnectRequest(connectRequest),
-                            autoConnect: this.isAutoConnectRequest(connectRequest),
-                            channel: connectRequest.channel ?? null,
-                            userDataDir: connectRequest.userDataDir ?? null,
-                            manualApprovalMayBeRequired: this.isAutoConnectRequest(connectRequest),
-                            approvalHint: this.getAutoConnectApprovalHint(connectRequest),
-                            selectedIndex: actualIndex,
-                            selectedPageId: tab?.pageId ?? null,
-                            currentUrl: selected?.url ?? null,
-                            currentTitle: selected?.title ?? null,
-                            totalPages: pages.length,
-                            networkMonitoringEnabled,
-                            consoleMonitoringEnabled,
-                            takeoverReady: pageHandleReady,
-                            note: pageHandleReady
-                                ? null
-                                : 'Connected to existing Chrome, but the selected tab does not currently expose a stable Puppeteer Page handle. Tab discovery still works; try selecting a different tab or navigate the tab and retry.',
-                            status,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Failed to attach to browser:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                            hint: this.getAutoConnectApprovalHint(connectRequest ?? {}),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/browser/handlers/camoufox-browser.d.ts

@@ -1,29 +0,0 @@
-import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
-interface CamoufoxBrowserHandlersDeps {
-    getCamoufoxManager: () => CamoufoxBrowserManager | null;
-    setCamoufoxManager: (manager: CamoufoxBrowserManager) => void;
-    closeCamoufox: () => Promise<void>;
-}
-export declare class CamoufoxBrowserHandlers {
-    private deps;
-    constructor(deps: CamoufoxBrowserHandlersDeps);
-    handleCamoufoxServerLaunch(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleCamoufoxServerClose(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleCamoufoxServerStatus(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};

package/dist/src/server/domains/browser/handlers/camoufox-browser.js

@@ -1,121 +0,0 @@
-import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
-import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
-import { formatBetterSqlite3Error, isBetterSqlite3RelatedError } from '../../../../utils/betterSqlite3.js';
-import { logger } from '../../../../utils/logger.js';
-async function checkCamoufoxDependencies() {
-    try {
-        await import('camoufox-js');
-        return null;
-    }
-    catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        if (isBetterSqlite3RelatedError(error)) {
-            return `Camoufox requires the same native SQLite backend used by trace tooling. ${formatBetterSqlite3Error(error)}`;
-        }
-        if (errorMsg.includes("Cannot find package 'camoufox-js'")) {
-            return 'camoufox-js package is not installed. Run: pnpm add camoufox-js && npx camoufox-js fetch';
-        }
-        return `Camoufox dependencies check failed: ${errorMsg}`;
-    }
-}
-export class CamoufoxBrowserHandlers {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async handleCamoufoxServerLaunch(args) {
-        const depError = await checkCamoufoxDependencies();
-        if (depError) {
-            logger.warn(`Camoufox dependencies not available: ${depError}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: depError,
-                            hint: 'Camoufox is optional. Use browser_launch with Chrome driver instead, or install dependencies.',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const port = argNumber(args, 'port');
-        const ws_path = argString(args, 'ws_path');
-        const headless = argBool(args, 'headless', true);
-        const os = argString(args, 'os', 'windows');
-        let camoufoxManager = this.deps.getCamoufoxManager();
-        if (!camoufoxManager) {
-            camoufoxManager = new CamoufoxBrowserManager({ headless, os });
-            this.deps.setCamoufoxManager(camoufoxManager);
-        }
-        try {
-            const wsEndpoint = await camoufoxManager.launchAsServer(port, ws_path);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            wsEndpoint,
-                            message: 'Camoufox server launched. Connect with: browser_launch(driver="camoufox", mode="connect", wsEndpoint=<wsEndpoint>)',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            logger.error(`Failed to launch Camoufox server: ${errorMsg}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: errorMsg,
-                            hint: 'Try running: npx camoufox-js fetch to download browser binaries',
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleCamoufoxServerClose(_args) {
-        const camoufoxManager = this.deps.getCamoufoxManager();
-        if (!camoufoxManager) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: 'No camoufox server is running.' }, null, 2),
-                    },
-                ],
-            };
-        }
-        await camoufoxManager.closeBrowserServer();
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({ success: true, message: 'Camoufox server closed.' }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleCamoufoxServerStatus(_args) {
-        const camoufoxManager = this.deps.getCamoufoxManager();
-        const wsEndpoint = camoufoxManager?.getBrowserServerEndpoint() ?? null;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        running: wsEndpoint !== null,
-                        wsEndpoint,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}