@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/src/server/domains/browser/handlers.impl.js

@@ -0,0 +1,389 @@
+import { AICaptchaDetector } from '../../domains/shared/modules.js';
+import { DetailedDataManager } from '../../../utils/DetailedDataManager.js';
+import { resolveOutputDirectory } from '../../../utils/outputPaths.js';
+import { logger } from '../../../utils/logger.js';
+import { BrowserControlHandlers } from '../../domains/browser/handlers/browser-control.js';
+import { CamoufoxBrowserHandlers } from '../../domains/browser/handlers/camoufox-browser.js';
+import { PageNavigationHandlers } from '../../domains/browser/handlers/page-navigation.js';
+import { PageInteractionHandlers } from '../../domains/browser/handlers/page-interaction.js';
+import { PageEvaluationHandlers } from '../../domains/browser/handlers/page-evaluation.js';
+import { PageDataHandlers } from '../../domains/browser/handlers/page-data.js';
+import { DOMQueryHandlers } from '../../domains/browser/handlers/dom-query.js';
+import { DOMStyleHandlers } from '../../domains/browser/handlers/dom-style.js';
+import { DOMSearchHandlers } from '../../domains/browser/handlers/dom-search.js';
+import { ConsoleHandlers } from '../../domains/browser/handlers/console-handlers.js';
+import { ScriptManagementHandlers } from '../../domains/browser/handlers/script-management.js';
+import { CaptchaHandlers } from '../../domains/browser/handlers/captcha-handlers.js';
+import { StealthInjectionHandlers } from '../../domains/browser/handlers/stealth-injection.js';
+import { FrameworkStateHandlers } from '../../domains/browser/handlers/framework-state.js';
+import { IndexedDBDumpHandlers } from '../../domains/browser/handlers/indexeddb-dump.js';
+import { DetailedDataHandlers } from '../../domains/browser/handlers/detailed-data.js';
+import { initializeBrowserHandlerModules } from '../../domains/browser/handlers/facade-initializer.js';
+import { handleHumanMouse, handleHumanScroll, handleHumanTyping, } from '../../domains/browser/handlers/human-behavior.js';
+import { handleCaptchaVisionSolve, handleWidgetChallengeSolve, } from '../../domains/browser/handlers/captcha-solver.js';
+import { handleCamoufoxLaunchFlow, handleCamoufoxNavigateFlow, } from '../../domains/browser/handlers/camoufox-flow.js';
+export class BrowserToolHandlers {
+    collector;
+    pageController;
+    domInspector;
+    scriptManager;
+    consoleMonitor;
+    captchaDetector;
+    detailedDataManager;
+    camoufoxManager = null;
+    activeDriver = 'chrome';
+    camoufoxPage = null;
+    autoDetectCaptcha = true;
+    autoSwitchHeadless = true;
+    captchaTimeout = 300000;
+    browserControl;
+    camoufoxBrowser;
+    pageNavigation;
+    pageInteraction;
+    pageEvaluation;
+    pageData;
+    domQuery;
+    domStyle;
+    domSearch;
+    consoleHandlers;
+    scriptManagement;
+    captchaHandlers;
+    stealthInjection;
+    frameworkState;
+    indexedDBDump;
+    jsHeapSearch;
+    tabWorkflow;
+    detailedData;
+    _tabRegistry;
+    constructor(collector, pageController, domInspector, scriptManager, consoleMonitor, llmService) {
+        this.collector = collector;
+        this.pageController = pageController;
+        this.domInspector = domInspector;
+        this.scriptManager = scriptManager;
+        this.consoleMonitor = consoleMonitor;
+        const screenshotDir = resolveOutputDirectory(process.env.CAPTCHA_SCREENSHOT_DIR, 'screenshots/captcha');
+        this.captchaDetector = new AICaptchaDetector(llmService, screenshotDir);
+        this.detailedDataManager = DetailedDataManager.getInstance();
+        const modules = initializeBrowserHandlerModules({
+            collector: this.collector,
+            pageController: this.pageController,
+            domInspector: this.domInspector,
+            scriptManager: this.scriptManager,
+            consoleMonitor: this.consoleMonitor,
+            captchaDetector: this.captchaDetector,
+            detailedDataManager: this.detailedDataManager,
+            getActiveDriver: () => this.activeDriver,
+            getCamoufoxPage: () => this.getCamoufoxPage(),
+            getCamoufoxManager: () => this.camoufoxManager,
+            setCamoufoxManager: (manager) => {
+                this.camoufoxManager = manager;
+            },
+            closeCamoufox: () => this.closeCamoufox(),
+            getAutoDetectCaptcha: () => this.autoDetectCaptcha,
+            getAutoSwitchHeadless: () => this.autoSwitchHeadless,
+            getCaptchaTimeout: () => this.captchaTimeout,
+            setAutoDetectCaptcha: (value) => {
+                this.autoDetectCaptcha = value;
+            },
+            setAutoSwitchHeadless: (value) => {
+                this.autoSwitchHeadless = value;
+            },
+            setCaptchaTimeout: (value) => {
+                this.captchaTimeout = value;
+            },
+        });
+        this.browserControl = modules.browserControl;
+        this.camoufoxBrowser = modules.camoufoxBrowser;
+        this.pageNavigation = modules.pageNavigation;
+        this.pageInteraction = modules.pageInteraction;
+        this.pageEvaluation = modules.pageEvaluation;
+        this.pageData = modules.pageData;
+        this.domQuery = modules.domQuery;
+        this.domStyle = modules.domStyle;
+        this.domSearch = modules.domSearch;
+        this.consoleHandlers = modules.consoleHandlers;
+        this.scriptManagement = modules.scriptManagement;
+        this.captchaHandlers = modules.captchaHandlers;
+        this.stealthInjection = modules.stealthInjection;
+        this.frameworkState = modules.frameworkState;
+        this.indexedDBDump = modules.indexedDBDump;
+        this.jsHeapSearch = modules.jsHeapSearch;
+        this.tabWorkflow = modules.tabWorkflow;
+        this.detailedData = modules.detailedData;
+        this._tabRegistry = modules.tabRegistry;
+    }
+    getTabRegistry() {
+        return this._tabRegistry;
+    }
+    async getCamoufoxPage() {
+        if (!this.camoufoxManager) {
+            throw new Error('Camoufox browser not launched. Call browser_launch(driver="camoufox") first.');
+        }
+        if (!this.camoufoxPage) {
+            this.camoufoxPage = (await this.camoufoxManager.newPage());
+        }
+        return this.camoufoxPage;
+    }
+    async closeCamoufox() {
+        try {
+            await this.consoleMonitor.disable();
+        }
+        catch (error) {
+            logger.warn(`Failed to reset console monitor before closing Camoufox: ${String(error)}`);
+        }
+        this.consoleMonitor.clearPlaywrightPage();
+        if (this.camoufoxManager) {
+            await this.camoufoxManager.close();
+            this.camoufoxManager = null;
+            this.camoufoxPage = null;
+        }
+    }
+    async handleBrowserLaunch(args) {
+        const driver = args.driver || 'chrome';
+        if (driver === 'camoufox') {
+            return this.handleCamoufoxLaunch(args);
+        }
+        if (this.activeDriver === 'camoufox' && this.camoufoxManager) {
+            await this.closeCamoufox();
+        }
+        this.activeDriver = 'chrome';
+        return this.browserControl.handleBrowserLaunch(args);
+    }
+    async handleBrowserClose(args) {
+        if (this.activeDriver === 'camoufox' && this.camoufoxManager) {
+            await this.closeCamoufox();
+            await this.browserControl.handleBrowserClose(args);
+            this.activeDriver = 'chrome';
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, message: 'Camoufox browser closed' }, null, 2),
+                    }],
+            };
+        }
+        return this.browserControl.handleBrowserClose(args);
+    }
+    async handleBrowserStatus(args) {
+        if (this.activeDriver === 'camoufox') {
+            const running = !!(this.camoufoxManager?.getBrowser());
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            driver: 'camoufox',
+                            running,
+                            hasActivePage: !!this.camoufoxPage,
+                        }, null, 2),
+                    }],
+            };
+        }
+        return this.browserControl.handleBrowserStatus(args);
+    }
+    async handleBrowserListTabs(args) {
+        return this.browserControl.handleBrowserListTabs(args);
+    }
+    async handleBrowserSelectTab(args) {
+        return this.browserControl.handleBrowserSelectTab(args);
+    }
+    async handleBrowserAttach(args) {
+        if (this.activeDriver === 'camoufox' && this.camoufoxManager) {
+            await this.closeCamoufox();
+        }
+        this.activeDriver = 'chrome';
+        return this.browserControl.handleBrowserAttach(args);
+    }
+    async handleCamoufoxServerLaunch(args) {
+        return this.camoufoxBrowser.handleCamoufoxServerLaunch(args);
+    }
+    async handleCamoufoxServerClose(args) {
+        return this.camoufoxBrowser.handleCamoufoxServerClose(args);
+    }
+    async handleCamoufoxServerStatus(args) {
+        return this.camoufoxBrowser.handleCamoufoxServerStatus(args);
+    }
+    async handlePageNavigate(args) {
+        if (this.activeDriver === 'camoufox') {
+            return this.handleCamoufoxNavigate(args);
+        }
+        return this.pageNavigation.handlePageNavigate(args);
+    }
+    async handlePageReload(args) {
+        return this.pageNavigation.handlePageReload(args);
+    }
+    async handlePageBack(args) {
+        return this.pageNavigation.handlePageBack(args);
+    }
+    async handlePageForward(args) {
+        return this.pageNavigation.handlePageForward(args);
+    }
+    async handlePageClick(args) {
+        return this.pageInteraction.handlePageClick(args);
+    }
+    async handlePageType(args) {
+        return this.pageInteraction.handlePageType(args);
+    }
+    async handlePageSelect(args) {
+        return this.pageInteraction.handlePageSelect(args);
+    }
+    async handlePageHover(args) {
+        return this.pageInteraction.handlePageHover(args);
+    }
+    async handlePageScroll(args) {
+        return this.pageInteraction.handlePageScroll(args);
+    }
+    async handlePagePressKey(args) {
+        return this.pageInteraction.handlePagePressKey(args);
+    }
+    async handlePageEvaluate(args) {
+        return this.pageEvaluation.handlePageEvaluate(args);
+    }
+    async handlePageScreenshot(args) {
+        return this.pageEvaluation.handlePageScreenshot(args);
+    }
+    async handlePageInjectScript(args) {
+        return this.pageEvaluation.handlePageInjectScript(args);
+    }
+    async handlePageWaitForSelector(args) {
+        return this.pageEvaluation.handlePageWaitForSelector(args);
+    }
+    async handlePageGetPerformance(args) {
+        return this.pageData.handlePageGetPerformance(args);
+    }
+    async handlePageSetCookies(args) {
+        return this.pageData.handlePageSetCookies(args);
+    }
+    async handlePageGetCookies(args) {
+        return this.pageData.handlePageGetCookies(args);
+    }
+    async handlePageClearCookies(args) {
+        return this.pageData.handlePageClearCookies(args);
+    }
+    async handlePageSetViewport(args) {
+        return this.pageData.handlePageSetViewport(args);
+    }
+    async handlePageEmulateDevice(args) {
+        return this.pageData.handlePageEmulateDevice(args);
+    }
+    async handlePageGetLocalStorage(args) {
+        return this.pageData.handlePageGetLocalStorage(args);
+    }
+    async handlePageSetLocalStorage(args) {
+        return this.pageData.handlePageSetLocalStorage(args);
+    }
+    async handlePageGetAllLinks(args) {
+        return this.pageData.handlePageGetAllLinks(args);
+    }
+    async handleDOMQuerySelector(args) {
+        return this.domQuery.handleDOMQuerySelector(args);
+    }
+    async handleDOMQueryAll(args) {
+        return this.domQuery.handleDOMQueryAll(args);
+    }
+    async handleDOMGetStructure(args) {
+        const structure = await this.domInspector.getStructure(args.maxDepth ?? 3, args.includeText ?? true);
+        const processedStructure = this.detailedDataManager.smartHandle(structure, 51200);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(processedStructure, null, 2),
+                }],
+        };
+    }
+    async handleDOMFindClickable(args) {
+        return this.domQuery.handleDOMFindClickable(args);
+    }
+    async handleDOMGetComputedStyle(args) {
+        return this.domStyle.handleDOMGetComputedStyle(args);
+    }
+    async handleDOMIsInViewport(args) {
+        return this.domStyle.handleDOMIsInViewport(args);
+    }
+    async handleDOMFindByText(args) {
+        return this.domSearch.handleDOMFindByText(args);
+    }
+    async handleDOMGetXPath(args) {
+        return this.domSearch.handleDOMGetXPath(args);
+    }
+    async handleConsoleEnable(args) {
+        return this.consoleHandlers.handleConsoleEnable(args);
+    }
+    async handleConsoleGetLogs(args) {
+        return this.consoleHandlers.handleConsoleGetLogs(args);
+    }
+    async handleConsoleExecute(args) {
+        return this.consoleHandlers.handleConsoleExecute(args);
+    }
+    async handleGetAllScripts(args) {
+        return this.scriptManagement.handleGetAllScripts(args);
+    }
+    async handleGetScriptSource(args) {
+        return this.scriptManagement.handleGetScriptSource(args);
+    }
+    async handleCaptchaDetect(args) {
+        return this.captchaHandlers.handleCaptchaDetect(args);
+    }
+    async handleCaptchaWait(args) {
+        return this.captchaHandlers.handleCaptchaWait(args);
+    }
+    async handleCaptchaConfig(args) {
+        return this.captchaHandlers.handleCaptchaConfig(args);
+    }
+    async handleStealthInject(args) {
+        return this.stealthInjection.handleStealthInject(args);
+    }
+    async handleStealthSetUserAgent(args) {
+        return this.stealthInjection.handleStealthSetUserAgent(args);
+    }
+    async handleFrameworkStateExtract(args) {
+        return this.frameworkState.handleFrameworkStateExtract(args);
+    }
+    async handleIndexedDBDump(args) {
+        return this.indexedDBDump.handleIndexedDBDump(args);
+    }
+    async handleJSHeapSearch(args) {
+        return this.jsHeapSearch.handleJSHeapSearch(args);
+    }
+    async handleTabWorkflow(args) {
+        return this.tabWorkflow.handleTabWorkflow(args);
+    }
+    async handleGetDetailedData(args) {
+        return this.detailedData.handleGetDetailedData(args);
+    }
+    async handleCamoufoxLaunch(args) {
+        return handleCamoufoxLaunchFlow({
+            setCamoufoxManager: (manager) => {
+                this.camoufoxManager = manager;
+            },
+            setActiveDriver: (driver) => {
+                this.activeDriver = driver;
+            },
+            clearCamoufoxPage: () => {
+                this.camoufoxPage = null;
+            },
+        }, args);
+    }
+    async handleCamoufoxNavigate(args) {
+        return handleCamoufoxNavigateFlow({
+            getCamoufoxPage: () => this.getCamoufoxPage(),
+            setConsoleMonitorPage: (page) => {
+                this.consoleMonitor.setPlaywrightPage(page);
+            },
+        }, args);
+    }
+    async handleHumanMouse(args) {
+        return handleHumanMouse(args, this.collector);
+    }
+    async handleHumanScroll(args) {
+        return handleHumanScroll(args, this.collector);
+    }
+    async handleHumanTyping(args) {
+        return handleHumanTyping(args, this.collector);
+    }
+    async handleCaptchaVisionSolve(args) {
+        return handleCaptchaVisionSolve(args, this.collector);
+    }
+    async handleWidgetChallengeSolve(args) {
+        return handleWidgetChallengeSolve(args, this.collector);
+    }
+}
+export { BrowserControlHandlers, CamoufoxBrowserHandlers, PageNavigationHandlers, PageInteractionHandlers, PageEvaluationHandlers, PageDataHandlers, DOMQueryHandlers, DOMStyleHandlers, DOMSearchHandlers, ConsoleHandlers, ScriptManagementHandlers, CaptchaHandlers, StealthInjectionHandlers, FrameworkStateHandlers, IndexedDBDumpHandlers, DetailedDataHandlers };

package/dist/src/server/domains/browser/manifest.js

@@ -0,0 +1,85 @@
+import { bindByDepKey, ensureBrowserCore, toolLookup } from '../../domains/shared/registry.js';
+import { browserTools, advancedBrowserToolDefinitions } from '../../domains/browser/definitions.js';
+import { BrowserToolHandlers } from '../../domains/browser/index.js';
+const DOMAIN = 'browser';
+const DEP_KEY = 'browserHandlers';
+const t = toolLookup([...browserTools, ...advancedBrowserToolDefinitions]);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+function ensure(ctx) {
+    ensureBrowserCore(ctx);
+    if (!ctx.browserHandlers) {
+        ctx.browserHandlers = new BrowserToolHandlers(ctx.collector, ctx.pageController, ctx.domInspector, ctx.scriptManager, ctx.consoleMonitor, ctx.llm);
+    }
+    return ctx.browserHandlers;
+}
+const manifest = {
+    kind: 'domain-manifest',
+    version: 1,
+    domain: DOMAIN,
+    depKey: DEP_KEY,
+    profiles: ['workflow', 'full'],
+    ensure,
+    registrations: [
+        { tool: t('get_detailed_data'), domain: DOMAIN, bind: b((h, a) => h.handleGetDetailedData(a)) },
+        { tool: t('browser_attach'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserAttach(a)) },
+        { tool: t('browser_list_tabs'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserListTabs(a)) },
+        { tool: t('browser_select_tab'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserSelectTab(a)) },
+        { tool: t('browser_launch'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserLaunch(a)) },
+        { tool: t('browser_close'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserClose(a)) },
+        { tool: t('browser_status'), domain: DOMAIN, bind: b((h, a) => h.handleBrowserStatus(a)) },
+        { tool: t('page_navigate'), domain: DOMAIN, bind: b((h, a) => h.handlePageNavigate(a)) },
+        { tool: t('page_reload'), domain: DOMAIN, bind: b((h, a) => h.handlePageReload(a)) },
+        { tool: t('page_back'), domain: DOMAIN, bind: b((h, a) => h.handlePageBack(a)) },
+        { tool: t('page_forward'), domain: DOMAIN, bind: b((h, a) => h.handlePageForward(a)) },
+        { tool: t('dom_query_selector'), domain: DOMAIN, bind: b((h, a) => h.handleDOMQuerySelector(a)) },
+        { tool: t('dom_query_all'), domain: DOMAIN, bind: b((h, a) => h.handleDOMQueryAll(a)) },
+        { tool: t('dom_get_structure'), domain: DOMAIN, bind: b((h, a) => h.handleDOMGetStructure(a)) },
+        { tool: t('dom_find_clickable'), domain: DOMAIN, bind: b((h, a) => h.handleDOMFindClickable(a)) },
+        { tool: t('page_click'), domain: DOMAIN, bind: b((h, a) => h.handlePageClick(a)) },
+        { tool: t('page_type'), domain: DOMAIN, bind: b((h, a) => h.handlePageType(a)) },
+        { tool: t('page_select'), domain: DOMAIN, bind: b((h, a) => h.handlePageSelect(a)) },
+        { tool: t('page_hover'), domain: DOMAIN, bind: b((h, a) => h.handlePageHover(a)) },
+        { tool: t('page_scroll'), domain: DOMAIN, bind: b((h, a) => h.handlePageScroll(a)) },
+        { tool: t('page_wait_for_selector'), domain: DOMAIN, bind: b((h, a) => h.handlePageWaitForSelector(a)) },
+        { tool: t('page_evaluate'), domain: DOMAIN, bind: b((h, a) => h.handlePageEvaluate(a)) },
+        { tool: t('page_screenshot'), domain: DOMAIN, bind: b((h, a) => h.handlePageScreenshot(a)) },
+        { tool: t('get_all_scripts'), domain: DOMAIN, bind: b((h, a) => h.handleGetAllScripts(a)) },
+        { tool: t('get_script_source'), domain: DOMAIN, bind: b((h, a) => h.handleGetScriptSource(a)) },
+        { tool: t('console_enable'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleEnable(a)) },
+        { tool: t('console_get_logs'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleGetLogs(a)) },
+        { tool: t('console_execute'), domain: DOMAIN, bind: b((h, a) => h.handleConsoleExecute(a)) },
+        { tool: t('dom_get_computed_style'), domain: DOMAIN, bind: b((h, a) => h.handleDOMGetComputedStyle(a)) },
+        { tool: t('dom_find_by_text'), domain: DOMAIN, bind: b((h, a) => h.handleDOMFindByText(a)) },
+        { tool: t('dom_get_xpath'), domain: DOMAIN, bind: b((h, a) => h.handleDOMGetXPath(a)) },
+        { tool: t('dom_is_in_viewport'), domain: DOMAIN, bind: b((h, a) => h.handleDOMIsInViewport(a)) },
+        { tool: t('page_get_performance'), domain: DOMAIN, bind: b((h, a) => h.handlePageGetPerformance(a)) },
+        { tool: t('page_inject_script'), domain: DOMAIN, bind: b((h, a) => h.handlePageInjectScript(a)) },
+        { tool: t('page_set_cookies'), domain: DOMAIN, bind: b((h, a) => h.handlePageSetCookies(a)) },
+        { tool: t('page_get_cookies'), domain: DOMAIN, bind: b((h, a) => h.handlePageGetCookies(a)) },
+        { tool: t('page_clear_cookies'), domain: DOMAIN, bind: b((h, a) => h.handlePageClearCookies(a)) },
+        { tool: t('page_set_viewport'), domain: DOMAIN, bind: b((h, a) => h.handlePageSetViewport(a)) },
+        { tool: t('page_emulate_device'), domain: DOMAIN, bind: b((h, a) => h.handlePageEmulateDevice(a)) },
+        { tool: t('page_get_local_storage'), domain: DOMAIN, bind: b((h, a) => h.handlePageGetLocalStorage(a)) },
+        { tool: t('page_set_local_storage'), domain: DOMAIN, bind: b((h, a) => h.handlePageSetLocalStorage(a)) },
+        { tool: t('page_press_key'), domain: DOMAIN, bind: b((h, a) => h.handlePagePressKey(a)) },
+        { tool: t('page_get_all_links'), domain: DOMAIN, bind: b((h, a) => h.handlePageGetAllLinks(a)) },
+        { tool: t('captcha_detect'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaDetect(a)) },
+        { tool: t('captcha_wait'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaWait(a)) },
+        { tool: t('captcha_config'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaConfig(a)) },
+        { tool: t('stealth_inject'), domain: DOMAIN, bind: b((h, a) => h.handleStealthInject(a)) },
+        { tool: t('stealth_set_user_agent'), domain: DOMAIN, bind: b((h, a) => h.handleStealthSetUserAgent(a)) },
+        { tool: t('camoufox_server_launch'), domain: DOMAIN, bind: b((h, a) => h.handleCamoufoxServerLaunch(a)) },
+        { tool: t('camoufox_server_close'), domain: DOMAIN, bind: b((h, a) => h.handleCamoufoxServerClose(a)) },
+        { tool: t('camoufox_server_status'), domain: DOMAIN, bind: b((h, a) => h.handleCamoufoxServerStatus(a)) },
+        { tool: t('framework_state_extract'), domain: DOMAIN, bind: b((h, a) => h.handleFrameworkStateExtract(a)) },
+        { tool: t('indexeddb_dump'), domain: DOMAIN, bind: b((h, a) => h.handleIndexedDBDump(a)) },
+        { tool: t('js_heap_search'), domain: DOMAIN, bind: b((h, a) => h.handleJSHeapSearch(a)) },
+        { tool: t('tab_workflow'), domain: DOMAIN, bind: b((h, a) => h.handleTabWorkflow(a)) },
+        { tool: t('human_mouse'), domain: DOMAIN, bind: b((h, a) => h.handleHumanMouse(a)) },
+        { tool: t('human_scroll'), domain: DOMAIN, bind: b((h, a) => h.handleHumanScroll(a)) },
+        { tool: t('human_typing'), domain: DOMAIN, bind: b((h, a) => h.handleHumanTyping(a)) },
+        { tool: t('captcha_vision_solve'), domain: DOMAIN, bind: b((h, a) => h.handleCaptchaVisionSolve(a)) },
+        { tool: t('widget_challenge_solve'), domain: DOMAIN, bind: b((h, a) => h.handleWidgetChallengeSolve(a)) },
+    ],
+};
+export default manifest;