@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/domains/analysis/manifest.d.ts

@@ -1,7 +1,57 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext } from '../../domains/shared/registry.js';
 import { CoreAnalysisHandlers } from '../../domains/analysis/index.js';
-declare const DOMAIN: "core";
-declare const DEP_KEY: "coreAnalysisHandlers";
 type H = CoreAnalysisHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "core";
+    depKey: "coreAnalysisHandlers";
+    profiles: ("workflow" | "full")[];
+    ensure: typeof ensure;
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "core";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;

package/dist/src/server/domains/antidebug/manifest.d.ts

@@ -1,7 +1,57 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
+import type { MCPServerContext } from '../../domains/shared/registry.js';
 import { AntiDebugToolHandlers } from '../../domains/antidebug/index.js';
-declare const DOMAIN: "antidebug";
-declare const DEP_KEY: "antidebugHandlers";
 type H = AntiDebugToolHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
+declare function ensure(ctx: MCPServerContext): H;
+declare const manifest: {
+    kind: "domain-manifest";
+    version: 1;
+    domain: "antidebug";
+    depKey: "antidebugHandlers";
+    profiles: "full"[];
+    ensure: typeof ensure;
+    registrations: {
+        tool: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        };
+        domain: "antidebug";
+        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
+    }[];
+};
 export default manifest;

package/dist/src/server/domains/browser/definitions.tools.runtime.js

@@ -38,7 +38,7 @@ Drivers:
 Modes:
 - launch (default): launch a local browser instance
 - connect: reuse an existing browser instance
-  - chrome: connect via browserURL (http://host:port) or wsEndpoint
+  - chrome: connect via browserURL (http://host:port), wsEndpoint, or Chrome 144+ autoConnect
   - camoufox: connect via wsEndpoint from camoufox_server_launch`,
         inputSchema: {
             type: 'object',
@@ -62,7 +62,7 @@ Modes:
                 },
                 mode: {
                     type: 'string',
-                    description: 'Launch mode. launch = start local browser. connect = reuse existing browser (chrome: browserURL/wsEndpoint, camoufox: wsEndpoint).',
+                    description: 'Launch mode. launch = start local browser. connect = reuse existing browser (chrome: browserURL/wsEndpoint/autoConnect, camoufox: wsEndpoint).',
                     enum: ['launch', 'connect'],
                     default: 'launch',
                 },
@@ -74,6 +74,21 @@ Modes:
                     type: 'string',
                     description: 'WebSocket endpoint to connect to (chrome or camoufox connect mode). For camoufox, get this from camoufox_server_launch.',
                 },
+                autoConnect: {
+                    type: 'boolean',
+                    description: 'Chrome 144+ only. Auto-detect the local Chrome debugging WebSocket from DevToolsActivePort. Requires remote debugging to be enabled at chrome://inspect/#remote-debugging, and Chrome may prompt you to manually approve this client.',
+                    default: false,
+                },
+                channel: {
+                    type: 'string',
+                    description: 'Chrome channel used for autoConnect when userDataDir is not provided.',
+                    enum: ['stable', 'beta', 'dev', 'canary'],
+                    default: 'stable',
+                },
+                userDataDir: {
+                    type: 'string',
+                    description: 'Optional Chrome profile directory for autoConnect. If omitted, the default profile path for the selected channel is used.',
+                },
             },
         },
     },
@@ -136,11 +151,12 @@ Requires binaries: npx camoufox-js fetch`,
         description: `Attach to an existing browser instance via Chrome DevTools Protocol (CDP).
 
 Use this when a browser is already running with remote debugging enabled.
-Supports both browserURL (http://host:port) and WebSocket endpoint (ws://...).
+Supports browserURL (http://host:port), WebSocket endpoint (ws://...), and Chrome 144+ autoConnect.
 
 Example:
 - browser_attach(browserURL="http://127.0.0.1:9222")
 - browser_attach(wsEndpoint="ws://127.0.0.1:9222/devtools/browser/xxx")
+- browser_attach(autoConnect=true, channel="stable")
 - browser_attach(browserURL="http://127.0.0.1:9222", pageIndex=0)
 
 After attaching, use page_navigate / page_screenshot / debugger_enable normally.`,
@@ -155,6 +171,21 @@ After attaching, use page_navigate / page_screenshot / debugger_enable normally.
                     type: 'string',
                     description: 'WebSocket URL from /json/version (e.g., ws://127.0.0.1:9222/devtools/browser/xxx)',
                 },
+                autoConnect: {
+                    type: 'boolean',
+                    description: 'Chrome 144+ only. Auto-detect the local Chrome debugging WebSocket from DevToolsActivePort. Requires remote debugging to be enabled at chrome://inspect/#remote-debugging, and Chrome may prompt you to manually approve this client.',
+                    default: false,
+                },
+                channel: {
+                    type: 'string',
+                    description: 'Chrome channel used for autoConnect when userDataDir is not provided.',
+                    enum: ['stable', 'beta', 'dev', 'canary'],
+                    default: 'stable',
+                },
+                userDataDir: {
+                    type: 'string',
+                    description: 'Optional Chrome profile directory for autoConnect. If omitted, the default profile path for the selected channel is used.',
+                },
                 pageIndex: {
                     type: 'number',
                     description: 'Index of the page/tab to activate (default: 0)',

package/dist/src/server/domains/browser/definitions.tools.security.js

@@ -133,12 +133,13 @@ Use this after browser_attach to see all available pages/tabs.
 Returns index, URL, and title for each tab.
 
 Workflow:
-1. browser_attach(browserURL="http://127.0.0.1:9222")
+1. browser_attach(browserURL="http://127.0.0.1:9222") or browser_attach(autoConnect=true)
 2. browser_list_tabs() -> see all tabs with their indexes
 3. browser_select_tab(index=N) -> switch to desired tab
 
 Can also connect and list in one call:
-browser_list_tabs(browserURL="http://127.0.0.1:9222")`,
+browser_list_tabs(browserURL="http://127.0.0.1:9222")
+browser_list_tabs(autoConnect=true, channel="stable")`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -146,6 +147,25 @@ browser_list_tabs(browserURL="http://127.0.0.1:9222")`,
                     type: 'string',
                     description: 'Optional: connect to this browser URL before listing (e.g. http://127.0.0.1:9222)',
                 },
+                wsEndpoint: {
+                    type: 'string',
+                    description: 'Optional: connect to this browser WebSocket endpoint before listing.',
+                },
+                autoConnect: {
+                    type: 'boolean',
+                    description: 'Chrome 144+ only. Auto-detect the local Chrome debugging WebSocket from DevToolsActivePort. Requires remote debugging to be enabled at chrome://inspect/#remote-debugging, and Chrome may prompt you to manually approve this client.',
+                    default: false,
+                },
+                channel: {
+                    type: 'string',
+                    description: 'Chrome channel used for autoConnect when userDataDir is not provided.',
+                    enum: ['stable', 'beta', 'dev', 'canary'],
+                    default: 'stable',
+                },
+                userDataDir: {
+                    type: 'string',
+                    description: 'Optional Chrome profile directory for autoConnect. If omitted, the default profile path for the selected channel is used.',
+                },
             },
         },
     },

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

@@ -16,7 +16,13 @@ export declare class BrowserControlHandlers {
     private deps;
     constructor(deps: BrowserControlHandlersDeps);
     private resetAndEnableMonitoring;
+    private syncTabRegistryWithCollectorPages;
     private parseHeadlessArg;
+    private parseChromeConnectRequest;
+    private hasChromeConnectRequest;
+    private describeChromeConnectRequest;
+    private isAutoConnectRequest;
+    private getAutoConnectApprovalHint;
     private shouldAttemptLinuxHeadfulFallback;
     private persistHeadlessEnv;
     handleBrowserLaunch(args: Record<string, unknown>): Promise<{

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

@@ -1,8 +1,10 @@
+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) {
@@ -33,6 +35,16 @@ export class BrowserControlHandlers {
             };
         }
     }
+    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;
@@ -55,6 +67,47 @@ export class BrowserControlHandlers {
         }
         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');
@@ -88,11 +141,11 @@ export class BrowserControlHandlers {
         }
     }
     async handleBrowserLaunch(args) {
-        const driver = args.driver || 'chrome';
+        const driver = argString(args, 'driver', 'chrome');
         if (driver === 'camoufox') {
-            const mode = args.mode ?? 'launch';
+            const mode = argString(args, 'mode', 'launch');
             if (mode === 'connect') {
-                const wsEndpoint = args.wsEndpoint;
+                const wsEndpoint = argString(args, 'wsEndpoint');
                 if (!wsEndpoint) {
                     return {
                         content: [
@@ -136,25 +189,23 @@ export class BrowserControlHandlers {
                 ],
             };
         }
-        const mode = args.mode ?? 'launch';
+        const mode = argString(args, 'mode', 'launch');
         if (mode === 'connect') {
-            const browserURL = args.browserURL;
-            const wsEndpoint = args.wsEndpoint;
-            const endpoint = browserURL || wsEndpoint;
-            if (!endpoint) {
+            const connectRequest = this.parseChromeConnectRequest(args);
+            if (!this.hasChromeConnectRequest(connectRequest)) {
                 return {
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify({
                                 success: false,
-                                error: 'browserURL or wsEndpoint is required for chrome connect mode.',
+                                error: 'browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required for chrome connect mode.',
                             }, null, 2),
                         },
                     ],
                 };
             }
-            await this.deps.collector.connect(endpoint);
+            await this.deps.collector.connect(connectRequest);
             const status = await this.deps.collector.getStatus();
             return {
                 content: [
@@ -164,7 +215,12 @@ export class BrowserControlHandlers {
                             success: true,
                             driver: 'chrome',
                             mode: 'connect',
-                            endpoint,
+                            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),
@@ -247,12 +303,13 @@ export class BrowserControlHandlers {
     }
     async handleBrowserListTabs(args) {
         try {
-            const browserURL = args.browserURL;
-            if (browserURL) {
-                await this.deps.collector.connect(browserURL);
+            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 {
@@ -272,6 +329,9 @@ export class BrowserControlHandlers {
                             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),
                     },
@@ -287,7 +347,7 @@ export class BrowserControlHandlers {
                         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 parameter',
+                            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),
                     },
                 ],
@@ -296,16 +356,19 @@ export class BrowserControlHandlers {
     }
     async handleBrowserSelectTab(args) {
         try {
-            const index = args.index;
-            const urlPattern = args.urlPattern;
-            const titlePattern = args.titlePattern;
+            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 = await this.resetAndEnableMonitoring('browser_select_tab');
+                const monitoring = tab?.pageId
+                    ? await this.resetAndEnableMonitoring('browser_select_tab')
+                    : { networkMonitoringEnabled: false, consoleMonitoringEnabled: false };
                 return {
                     content: [
                         {
@@ -351,9 +414,12 @@ export class BrowserControlHandlers {
                 };
             }
             await this.deps.collector.selectPage(matchIndex);
+            await this.syncTabRegistryWithCollectorPages('browser_select_tab');
             const selected = pages[matchIndex];
             const tab = registry.setCurrentByIndex(matchIndex);
-            const monitoring = await this.resetAndEnableMonitoring('browser_select_tab');
+            const monitoring = tab?.pageId
+                ? await this.resetAndEnableMonitoring('browser_select_tab')
+                : { networkMonitoringEnabled: false, consoleMonitoringEnabled: false };
             return {
                 content: [
                     {
@@ -388,25 +454,28 @@ export class BrowserControlHandlers {
         }
     }
     async handleBrowserAttach(args) {
+        let connectRequest = null;
         try {
-            const browserURL = args.browserURL;
-            const wsEndpoint = args.wsEndpoint;
-            const endpoint = browserURL || wsEndpoint;
-            if (!endpoint) {
+            connectRequest = this.parseChromeConnectRequest(args);
+            if (!this.hasChromeConnectRequest(connectRequest)) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({ success: false, error: 'browserURL or wsEndpoint is required' }, null, 2),
+                            text: JSON.stringify({
+                                success: false,
+                                error: 'browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required',
+                            }, null, 2),
                         },
                     ],
                 };
             }
-            await this.deps.collector.connect(endpoint);
-            const pageIndex = typeof args.pageIndex === 'number'
-                ? args.pageIndex
-                : typeof args.pageIndex === 'string' && args.pageIndex.trim() !== ''
-                    ? Number(args.pageIndex)
+            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();
@@ -418,10 +487,14 @@ export class BrowserControlHandlers {
                 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 { networkMonitoringEnabled, consoleMonitoringEnabled } = await this.resetAndEnableMonitoring('browser_attach');
+            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: [
@@ -430,7 +503,12 @@ export class BrowserControlHandlers {
                         text: JSON.stringify({
                             success: true,
                             message: 'Attached to existing browser successfully',
-                            endpoint,
+                            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,
@@ -438,7 +516,10 @@ export class BrowserControlHandlers {
                             totalPages: pages.length,
                             networkMonitoringEnabled,
                             consoleMonitoringEnabled,
-                            takeoverReady: true,
+                            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),
                     },
@@ -454,6 +535,7 @@ export class BrowserControlHandlers {
                         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.js

@@ -1,4 +1,5 @@
 import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
+import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
 import { logger } from '../../../../utils/logger.js';
 async function checkCamoufoxDependencies() {
     try {
@@ -38,10 +39,10 @@ export class CamoufoxBrowserHandlers {
                 ],
             };
         }
-        const port = args.port;
-        const ws_path = args.ws_path;
-        const headless = args.headless ?? true;
-        const os = args.os ?? 'windows';
+        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 });

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

@@ -1,10 +1,11 @@
 import { CamoufoxBrowserManager } from '../../../domains/shared/modules.js';
+import { argString, argNumber, argBool } from '../../../domains/shared/parse-args.js';
 export async function handleCamoufoxLaunchFlow(context, args) {
-    const headless = args.headless ?? true;
-    const os = args.os ?? 'windows';
-    const mode = args.mode ?? 'launch';
+    const headless = argBool(args, 'headless', true);
+    const os = argString(args, 'os', 'windows');
+    const mode = argString(args, 'mode', 'launch');
     if (mode === 'connect') {
-        const wsEndpoint = args.wsEndpoint;
+        const wsEndpoint = argString(args, 'wsEndpoint');
         if (!wsEndpoint) {
             return {
                 content: [{
@@ -63,9 +64,9 @@ function normalizeWaitUntil(waitUntil) {
     return 'networkidle';
 }
 export async function handleCamoufoxNavigateFlow(context, args) {
-    const url = args.url;
-    const rawWaitUntil = args.waitUntil || 'networkidle';
-    const timeout = args.timeout;
+    const url = argString(args, 'url', '');
+    const rawWaitUntil = argString(args, 'waitUntil', 'networkidle');
+    const timeout = argNumber(args, 'timeout');
     const page = await context.getCamoufoxPage();
     await page.goto(url, { waitUntil: normalizeWaitUntil(rawWaitUntil), timeout });
     context.setConsoleMonitorPage(page);

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

@@ -1,3 +1,4 @@
+import { argNumber, argBool } from '../../../domains/shared/parse-args.js';
 import { logger } from '../../../../utils/logger.js';
 export class CaptchaHandlers {
     deps;
@@ -21,7 +22,7 @@ export class CaptchaHandlers {
         };
     }
     async handleCaptchaWait(args) {
-        const timeout = args.timeout || this.deps.captchaTimeout;
+        const timeout = argNumber(args, 'timeout', this.deps.captchaTimeout);
         const page = await this.deps.pageController.getPage();
         logger.info('Waiting for CAPTCHA to be solved...');
         const completed = await this.deps.captchaDetector.waitForCompletion(page, timeout);
@@ -39,13 +40,13 @@ export class CaptchaHandlers {
     }
     async handleCaptchaConfig(args) {
         if (args.autoDetectCaptcha !== undefined) {
-            this.deps.setAutoDetectCaptcha(args.autoDetectCaptcha);
+            this.deps.setAutoDetectCaptcha(argBool(args, 'autoDetectCaptcha', false));
         }
         if (args.autoSwitchHeadless !== undefined) {
-            this.deps.setAutoSwitchHeadless(args.autoSwitchHeadless);
+            this.deps.setAutoSwitchHeadless(argBool(args, 'autoSwitchHeadless', false));
         }
         if (args.captchaTimeout !== undefined) {
-            this.deps.setCaptchaTimeout(args.captchaTimeout);
+            this.deps.setCaptchaTimeout(argNumber(args, 'captchaTimeout', 0));
         }
         return {
             content: [