@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/browser/browser-control.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
-vi.mock('@src/utils/logger', () => ({
+vi.mock('@utils/logger', () => ({
     logger: {
         debug: vi.fn(),
         info: vi.fn(),
@@ -7,14 +7,24 @@ vi.mock('@src/utils/logger', () => ({
         error: vi.fn(),
     },
 }));
+vi.mock('fs/promises', () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+}));
+vi.mock('@utils/config', () => ({
+    projectRoot: '/fake/project',
+}));
 import { BrowserControlHandlers } from '../../../../src/server/domains/browser/handlers/browser-control.js';
 function parseJson(response) {
     return JSON.parse(response.content[0].text);
 }
-describe('BrowserControlHandlers monitoring refresh', () => {
+function createMocks() {
     const collector = {
         connect: vi.fn(async () => { }),
+        init: vi.fn(async () => { }),
+        close: vi.fn(async () => { }),
         listPages: vi.fn(async () => []),
+        listResolvedPages: vi.fn(async () => []),
         selectPage: vi.fn(async () => { }),
         getStatus: vi.fn(async () => ({ connected: true })),
     };
@@ -23,7 +33,16 @@ describe('BrowserControlHandlers monitoring refresh', () => {
         enable: vi.fn(async () => { }),
     };
     const tabRegistry = {
-        setCurrentByIndex: vi.fn((index) => ({ pageId: `page-${index}` })),
+        reconcilePages: vi.fn(() => []),
+        setCurrentByIndex: vi.fn((index) => ({
+            pageId: `page-${index}`,
+            aliases: [],
+        })),
+        getTabByIndex: vi.fn((index) => ({
+            pageId: `page-${index}`,
+            aliases: [`alias-${index}`],
+        })),
+        getContextMeta: vi.fn(() => ({ pageId: 'page-0', tabIndex: 0 })),
     };
     const deps = {
         collector,
@@ -34,41 +53,377 @@ describe('BrowserControlHandlers monitoring refresh', () => {
         getCamoufoxPage: async () => null,
         getTabRegistry: () => tabRegistry,
     };
+    return { collector, consoleMonitor, tabRegistry, deps };
+}
+describe('BrowserControlHandlers – handleBrowserLaunch', () => {
+    let handlers;
+    let collector;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        const m = createMocks();
+        collector = m.collector;
+        handlers = new BrowserControlHandlers(m.deps);
+    });
+    it('launches chrome in default mode and returns status', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true, pages: 1 });
+        const body = parseJson(await handlers.handleBrowserLaunch({}));
+        expect(collector.init).toHaveBeenCalledWith(undefined);
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('chrome');
+        expect(body.status.connected).toBe(true);
+    });
+    it('connects chrome when mode=connect with browserURL', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserLaunch({
+            mode: 'connect',
+            browserURL: 'http://127.0.0.1:9222',
+        }));
+        expect(collector.connect).toHaveBeenCalledWith({
+            browserURL: 'http://127.0.0.1:9222',
+            wsEndpoint: undefined,
+            autoConnect: undefined,
+            userDataDir: undefined,
+            channel: undefined,
+        });
+        expect(body.success).toBe(true);
+        expect(body.mode).toBe('connect');
+        expect(body.endpoint).toBe('http://127.0.0.1:9222');
+    });
+    it('connects chrome when mode=connect with wsEndpoint', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserLaunch({
+            mode: 'connect',
+            wsEndpoint: 'ws://127.0.0.1:9222/devtools/browser/abc',
+        }));
+        expect(collector.connect).toHaveBeenCalledWith({
+            browserURL: undefined,
+            wsEndpoint: 'ws://127.0.0.1:9222/devtools/browser/abc',
+            autoConnect: undefined,
+            userDataDir: undefined,
+            channel: undefined,
+        });
+        expect(body.success).toBe(true);
+    });
+    it('returns error when chrome connect mode has no endpoint', async () => {
+        const body = parseJson(await handlers.handleBrowserLaunch({ mode: 'connect' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required');
+    });
+    it('launches camoufox in default launch mode', async () => {
+        const body = parseJson(await handlers.handleBrowserLaunch({ driver: 'camoufox' }));
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.mode).toBe('launch');
+    });
+    it('connects camoufox when mode=connect with wsEndpoint', async () => {
+        const body = parseJson(await handlers.handleBrowserLaunch({
+            driver: 'camoufox',
+            mode: 'connect',
+            wsEndpoint: 'ws://localhost:1234',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.driver).toBe('camoufox');
+        expect(body.mode).toBe('connect');
+        expect(body.wsEndpoint).toBe('ws://localhost:1234');
+    });
+    it('returns error when camoufox connect mode has no wsEndpoint', async () => {
+        const body = parseJson(await handlers.handleBrowserLaunch({
+            driver: 'camoufox',
+            mode: 'connect',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('wsEndpoint is required');
+    });
+    it('passes headless boolean true to collector.init', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: true });
+        expect(collector.init).toHaveBeenCalledWith(true);
+    });
+    it('passes headless boolean false to collector.init', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: false });
+        expect(collector.init).toHaveBeenCalledWith(false);
+    });
+    it('parses headless string "true" correctly', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 'true' });
+        expect(collector.init).toHaveBeenCalledWith(true);
+    });
+    it('parses headless string "false" correctly', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 'false' });
+        expect(collector.init).toHaveBeenCalledWith(false);
+    });
+    it('parses headless string "yes"/"no" correctly', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 'yes' });
+        expect(collector.init).toHaveBeenCalledWith(true);
+    });
+    it('parses headless number 1 as true', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 1 });
+        expect(collector.init).toHaveBeenCalledWith(true);
+    });
+    it('parses headless number 0 as false', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 0 });
+        expect(collector.init).toHaveBeenCalledWith(false);
+    });
+    it('treats unrecognized headless values as undefined', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        await handlers.handleBrowserLaunch({ headless: 'maybe' });
+        expect(collector.init).toHaveBeenCalledWith(undefined);
+    });
+    it('re-throws non-linux-display errors from init', async () => {
+        collector.init.mockRejectedValueOnce(new Error('some other error'));
+        await expect(handlers.handleBrowserLaunch({})).rejects.toThrow('some other error');
+    });
+});
+describe('BrowserControlHandlers – handleBrowserClose', () => {
+    let handlers;
+    let collector;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        const m = createMocks();
+        collector = m.collector;
+        handlers = new BrowserControlHandlers(m.deps);
+    });
+    it('closes the browser and returns success', async () => {
+        const body = parseJson(await handlers.handleBrowserClose({}));
+        expect(collector.close).toHaveBeenCalledOnce();
+        expect(body.success).toBe(true);
+        expect(body.message).toContain('closed');
+    });
+});
+describe('BrowserControlHandlers – handleBrowserStatus', () => {
+    let handlers;
+    let collector;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        const m = createMocks();
+        collector = m.collector;
+        handlers = new BrowserControlHandlers(m.deps);
+    });
+    it('returns the collector status with driver field', async () => {
+        collector.getStatus.mockResolvedValueOnce({ connected: true, pages: 2 });
+        const body = parseJson(await handlers.handleBrowserStatus({}));
+        expect(body.driver).toBe('chrome');
+        expect(body.connected).toBe(true);
+        expect(body.pages).toBe(2);
+    });
+});
+describe('BrowserControlHandlers – handleBrowserListTabs', () => {
+    let handlers;
+    let collector;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        const m = createMocks();
+        collector = m.collector;
+        handlers = new BrowserControlHandlers(m.deps);
+    });
+    it('lists pages enriched with tab registry info', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+            { index: 1, url: 'https://b.com', title: 'B' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserListTabs({}));
+        expect(body.success).toBe(true);
+        expect(body.count).toBe(2);
+        expect(body.pages).toHaveLength(2);
+        expect(body.pages[0].pageId).toBe('page-0');
+        expect(body.pages[1].aliases).toEqual(['alias-1']);
+        expect(body.currentPageId).toBe('page-0');
+    });
+    it('connects first when browserURL is provided', async () => {
+        collector.listPages.mockResolvedValueOnce([]);
+        await handlers.handleBrowserListTabs({
+            browserURL: 'http://127.0.0.1:9222',
+        });
+        expect(collector.connect).toHaveBeenCalledWith({
+            browserURL: 'http://127.0.0.1:9222',
+            wsEndpoint: undefined,
+            autoConnect: undefined,
+            userDataDir: undefined,
+            channel: undefined,
+        });
+    });
+    it('returns error payload when listPages throws', async () => {
+        collector.listPages.mockRejectedValueOnce(new Error('no browser'));
+        const body = parseJson(await handlers.handleBrowserListTabs({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('no browser');
+        expect(body.hint).toBeDefined();
+    });
+});
+describe('BrowserControlHandlers – handleBrowserSelectTab', () => {
     let handlers;
+    let collector;
+    let consoleMonitor;
+    let tabRegistry;
     beforeEach(() => {
         vi.clearAllMocks();
-        handlers = new BrowserControlHandlers(deps);
+        const m = createMocks();
+        collector = m.collector;
+        consoleMonitor = m.consoleMonitor;
+        tabRegistry = m.tabRegistry;
+        handlers = new BrowserControlHandlers(m.deps);
     });
-    it('refreshes monitoring after selecting a tab', async () => {
+    it('selects a tab by index', async () => {
         collector.listPages.mockResolvedValueOnce([
-            { index: 0, url: 'https://vmoranv.github.io/jshookmcp/page-a', title: 'A' },
-            { index: 1, url: 'https://vmoranv.github.io/jshookmcp/page-b', title: 'B' },
+            { index: 0, url: 'https://a.com', title: 'A' },
+            { index: 1, url: 'https://b.com', title: 'B' },
         ]);
         const body = parseJson(await handlers.handleBrowserSelectTab({ index: 1 }));
         expect(collector.selectPage).toHaveBeenCalledWith(1);
-        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
-        expect(consoleMonitor.enable).toHaveBeenCalledWith({
-            enableNetwork: true,
-            enableExceptions: true,
+        expect(tabRegistry.setCurrentByIndex).toHaveBeenCalledWith(1);
+        expect(body.success).toBe(true);
+        expect(body.selectedIndex).toBe(1);
+        expect(body.url).toBe('https://b.com');
+        expect(body.title).toBe('B');
+        expect(body.activeContextRefreshed).toBe(true);
+    });
+    it('selects a tab by urlPattern', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com/page', title: 'A' },
+            { index: 1, url: 'https://b.com/target', title: 'B' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserSelectTab({ urlPattern: 'target' }));
+        expect(collector.selectPage).toHaveBeenCalledWith(1);
+        expect(body.success).toBe(true);
+        expect(body.selectedIndex).toBe(1);
+    });
+    it('selects a tab by titlePattern', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'First' },
+            { index: 1, url: 'https://b.com', title: 'Second Tab' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserSelectTab({ titlePattern: 'Second' }));
+        expect(body.success).toBe(true);
+        expect(body.selectedIndex).toBe(1);
+    });
+    it('returns error when no matching tab found', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+        ]);
+        const body = parseJson(await handlers.handleBrowserSelectTab({ urlPattern: 'notfound' }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('No matching tab found');
+        expect(body.availablePages).toBeDefined();
+    });
+    it('returns error payload when selectPage throws', async () => {
+        collector.selectPage.mockRejectedValueOnce(new Error('select failed'));
+        const body = parseJson(await handlers.handleBrowserSelectTab({ index: 0 }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('select failed');
+    });
+    it('continues with monitoring disabled when consoleMonitor.disable fails', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+        ]);
+        consoleMonitor.disable.mockRejectedValueOnce(new Error('disable fail'));
+        const body = parseJson(await handlers.handleBrowserSelectTab({ index: 0 }));
+        expect(body.success).toBe(true);
+        expect(consoleMonitor.enable).toHaveBeenCalled();
+    });
+    it('reports monitoring disabled when consoleMonitor.enable fails', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+        ]);
+        consoleMonitor.enable.mockRejectedValueOnce(new Error('enable fail'));
+        const body = parseJson(await handlers.handleBrowserSelectTab({ index: 0 }));
+        expect(body.success).toBe(true);
+        expect(body.networkMonitoringEnabled).toBe(false);
+        expect(body.consoleMonitoringEnabled).toBe(false);
+    });
+});
+describe('BrowserControlHandlers – handleBrowserAttach', () => {
+    let handlers;
+    let collector;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        const m = createMocks();
+        collector = m.collector;
+        handlers = new BrowserControlHandlers(m.deps);
+    });
+    it('returns error when no endpoint provided', async () => {
+        const body = parseJson(await handlers.handleBrowserAttach({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required');
+    });
+    it('attaches to browser and selects the default page 0', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://example.com', title: 'Example' },
+        ]);
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserAttach({ browserURL: 'http://127.0.0.1:9222' }));
+        expect(collector.connect).toHaveBeenCalledWith({
+            browserURL: 'http://127.0.0.1:9222',
+            wsEndpoint: undefined,
+            autoConnect: undefined,
+            userDataDir: undefined,
+            channel: undefined,
         });
+        expect(collector.selectPage).toHaveBeenCalledWith(0);
+        expect(body.success).toBe(true);
+        expect(body.selectedIndex).toBe(0);
+        expect(body.totalPages).toBe(1);
+        expect(body.takeoverReady).toBe(true);
+    });
+    it('attaches and selects the requested pageIndex', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+            { index: 1, url: 'https://b.com', title: 'B' },
+        ]);
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserAttach({
+            wsEndpoint: 'ws://localhost:1234',
+            pageIndex: 1,
+        }));
+        expect(collector.selectPage).toHaveBeenCalledWith(1);
         expect(body.selectedIndex).toBe(1);
-        expect(body.networkMonitoringEnabled).toBe(true);
-        expect(body.consoleMonitoringEnabled).toBe(true);
+        expect(body.currentUrl).toBe('https://b.com');
     });
-    it('resets and re-enables monitoring after browser attach', async () => {
+    it('falls back to page 0 when pageIndex is out of range', async () => {
         collector.listPages.mockResolvedValueOnce([
-            { index: 0, url: 'https://vmoranv.github.io/jshookmcp/workspace/chat', title: 'Workspace Chat' },
+            { index: 0, url: 'https://a.com', title: 'A' },
         ]);
-        const body = parseJson(await handlers.handleBrowserAttach({ browserURL: 'http://127.0.0.1:9222', pageIndex: 0 }));
-        expect(collector.connect).toHaveBeenCalledWith('http://127.0.0.1:9222');
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserAttach({
+            browserURL: 'http://127.0.0.1:9222',
+            pageIndex: 99,
+        }));
         expect(collector.selectPage).toHaveBeenCalledWith(0);
-        expect(consoleMonitor.disable).toHaveBeenCalledTimes(1);
-        expect(consoleMonitor.enable).toHaveBeenCalledWith({
-            enableNetwork: true,
-            enableExceptions: true,
-        });
-        expect(body.networkMonitoringEnabled).toBe(true);
-        expect(body.consoleMonitoringEnabled).toBe(true);
-        expect(body.currentUrl).toBe('https://vmoranv.github.io/jshookmcp/workspace/chat');
+        expect(body.selectedIndex).toBe(0);
+    });
+    it('parses string pageIndex correctly', async () => {
+        collector.listPages.mockResolvedValueOnce([
+            { index: 0, url: 'https://a.com', title: 'A' },
+            { index: 1, url: 'https://b.com', title: 'B' },
+        ]);
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserAttach({
+            browserURL: 'http://127.0.0.1:9222',
+            pageIndex: '1',
+        }));
+        expect(collector.selectPage).toHaveBeenCalledWith(1);
+        expect(body.selectedIndex).toBe(1);
+    });
+    it('returns error payload when connect throws', async () => {
+        collector.connect.mockRejectedValueOnce(new Error('connection refused'));
+        const body = parseJson(await handlers.handleBrowserAttach({
+            browserURL: 'http://127.0.0.1:9222',
+        }));
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('connection refused');
+    });
+    it('handles empty pages list gracefully', async () => {
+        collector.listPages.mockResolvedValueOnce([]);
+        collector.getStatus.mockResolvedValueOnce({ connected: true });
+        const body = parseJson(await handlers.handleBrowserAttach({
+            browserURL: 'http://127.0.0.1:9222',
+        }));
+        expect(body.success).toBe(true);
+        expect(body.totalPages).toBe(0);
+        expect(body.selectedIndex).toBe(0);
     });
 });

package/dist/tests/server/domains/browser/camoufox-flow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/browser/camoufox-flow.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockManager = vi.hoisted(() => ({
+    launch: vi.fn(),
+    connectToServer: vi.fn(),
+}));
+vi.mock('@server/domains/shared/modules', () => ({
+    CamoufoxBrowserManager: class MockCamoufoxBrowserManager {
+        launch = mockManager.launch;
+        connectToServer = mockManager.connectToServer;
+    },
+}));
+import { handleCamoufoxLaunchFlow, handleCamoufoxNavigateFlow } from '../../../../src/server/domains/browser/handlers/camoufox-flow.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('camoufox-flow', () => {
+    beforeEach(() => {
+        mockManager.launch.mockResolvedValue(undefined);
+        mockManager.connectToServer.mockResolvedValue(undefined);
+    });
+    describe('handleCamoufoxLaunchFlow', () => {
+        function makeContext() {
+            return {
+                setCamoufoxManager: vi.fn(),
+                setActiveDriver: vi.fn(),
+                clearCamoufoxPage: vi.fn(),
+            };
+        }
+        it('launches in default mode', async () => {
+            const ctx = makeContext();
+            const result = await handleCamoufoxLaunchFlow(ctx, {});
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.mode).toBe('launch');
+            expect(body.driver).toBe('camoufox');
+            expect(ctx.setCamoufoxManager).toHaveBeenCalled();
+            expect(ctx.setActiveDriver).toHaveBeenCalledWith('camoufox');
+            expect(ctx.clearCamoufoxPage).toHaveBeenCalled();
+        });
+        it('connects in connect mode with wsEndpoint', async () => {
+            const ctx = makeContext();
+            const result = await handleCamoufoxLaunchFlow(ctx, {
+                mode: 'connect',
+                wsEndpoint: 'ws://localhost:1234',
+            });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.mode).toBe('connect');
+            expect(body.wsEndpoint).toBe('ws://localhost:1234');
+            expect(ctx.setCamoufoxManager).toHaveBeenCalled();
+        });
+        it('returns error when connect mode missing wsEndpoint', async () => {
+            const ctx = makeContext();
+            const result = await handleCamoufoxLaunchFlow(ctx, { mode: 'connect' });
+            const body = parseJson(result);
+            expect(body.success).toBe(false);
+            expect(body.error).toContain('wsEndpoint is required');
+        });
+        it('passes headless and os options', async () => {
+            const ctx = makeContext();
+            await handleCamoufoxLaunchFlow(ctx, { headless: false, os: 'linux' });
+            expect(ctx.setCamoufoxManager).toHaveBeenCalled();
+        });
+    });
+    describe('handleCamoufoxNavigateFlow', () => {
+        function makeContext() {
+            const page = {
+                goto: vi.fn().mockResolvedValue(undefined),
+                url: vi.fn().mockReturnValue('https://example.com'),
+                title: vi.fn().mockResolvedValue('Example'),
+            };
+            return {
+                context: {
+                    getCamoufoxPage: vi.fn().mockResolvedValue(page),
+                    setConsoleMonitorPage: vi.fn(),
+                },
+                page,
+            };
+        }
+        it('navigates to URL with default waitUntil', async () => {
+            const { context, page } = makeContext();
+            const result = await handleCamoufoxNavigateFlow(context, { url: 'https://test.com' });
+            const body = parseJson(result);
+            expect(body.success).toBe(true);
+            expect(body.driver).toBe('camoufox');
+            expect(body.url).toBe('https://example.com');
+            expect(body.title).toBe('Example');
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', { waitUntil: 'networkidle', timeout: undefined });
+        });
+        it('normalizes networkidle2 to networkidle', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', waitUntil: 'networkidle2' });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'networkidle' }));
+        });
+        it('passes load waitUntil unchanged', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', waitUntil: 'load' });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'load' }));
+        });
+        it('passes domcontentloaded waitUntil', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', waitUntil: 'domcontentloaded' });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'domcontentloaded' }));
+        });
+        it('passes commit waitUntil', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', waitUntil: 'commit' });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'commit' }));
+        });
+        it('normalizes unknown waitUntil to networkidle', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', waitUntil: 'unknown' });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ waitUntil: 'networkidle' }));
+        });
+        it('passes timeout option', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com', timeout: 5000 });
+            expect(page.goto).toHaveBeenCalledWith('https://test.com', expect.objectContaining({ timeout: 5000 }));
+        });
+        it('sets console monitor page after navigation', async () => {
+            const { context, page } = makeContext();
+            await handleCamoufoxNavigateFlow(context, { url: 'https://test.com' });
+            expect(context.setConsoleMonitorPage).toHaveBeenCalledWith(page);
+        });
+    });
+});

package/dist/tests/server/domains/browser/captcha-handlers.test.d.ts

@@ -0,0 +1 @@
+export {};