@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/browser/CamoufoxBrowserManager.coverage.test.js

@@ -0,0 +1,375 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+const camoufoxLaunchMock = vi.hoisted(() => vi.fn());
+const camoufoxServerLaunchMock = vi.hoisted(() => vi.fn());
+const playwrightConnectMock = vi.hoisted(() => vi.fn());
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('camoufox-js', () => ({
+    Camoufox: (...args) => camoufoxLaunchMock(...args),
+    launchServer: (...args) => camoufoxServerLaunchMock(...args),
+}));
+vi.mock('playwright-core', () => ({
+    firefox: {
+        connect: (...args) => playwrightConnectMock(...args),
+    },
+}));
+import { CamoufoxBrowserManager } from '../../../src/modules/browser/CamoufoxBrowserManager.js';
+function createFakeBrowser(connected = true) {
+    return {
+        newPage: vi.fn().mockResolvedValue(createFakePage()),
+        close: vi.fn(async () => { }),
+        isConnected: vi.fn(() => connected),
+    };
+}
+function createFakePage() {
+    return {
+        goto: vi.fn(async () => { }),
+        context: vi.fn(() => ({
+            newCDPSession: vi.fn(async () => ({ send: vi.fn() })),
+        })),
+    };
+}
+describe('CamoufoxBrowserManager — coverage expansion', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('launch — camoufox-js import failure', () => {
+        it('throws PrerequisiteError when camoufox-js import fails', async () => {
+            camoufoxLaunchMock.mockImplementation(() => {
+                throw new Error('Cannot find module camoufox-js');
+            });
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.launch()).rejects.toThrow();
+        });
+    });
+    describe('launch — close during launch', () => {
+        it('aborts launch if close is requested while Camoufox is starting', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockImplementation(async () => {
+                return fakeBrowser;
+            });
+            const manager = new CamoufoxBrowserManager();
+            const launchPromise = manager.launch();
+            await manager.close();
+            await expect(launchPromise).rejects.toThrow(/close/i);
+            expect(fakeBrowser.close).toHaveBeenCalled();
+        });
+    });
+    describe('launch — relaunch with existing disconnected browser', () => {
+        it('closes previous browser and relaunches when disconnected', async () => {
+            const firstBrowser = createFakeBrowser(true);
+            const secondBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock
+                .mockResolvedValueOnce(firstBrowser)
+                .mockResolvedValueOnce(secondBrowser);
+            const manager = new CamoufoxBrowserManager();
+            const b1 = await manager.launch();
+            expect(b1).toBe(firstBrowser);
+            firstBrowser.isConnected.mockReturnValue(false);
+            const b2 = await manager.launch();
+            expect(b2).toBe(secondBrowser);
+            expect(firstBrowser.close).toHaveBeenCalled();
+            expect(loggerState.info).toHaveBeenCalledWith(expect.stringContaining('Closing existing Camoufox browser before relaunch'));
+        });
+        it('handles close error on previous browser during relaunch gracefully', async () => {
+            const firstBrowser = createFakeBrowser(true);
+            firstBrowser.close.mockRejectedValue(new Error('close err'));
+            const secondBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock
+                .mockResolvedValueOnce(firstBrowser)
+                .mockResolvedValueOnce(secondBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            firstBrowser.isConnected.mockReturnValue(false);
+            const b2 = await manager.launch();
+            expect(b2).toBe(secondBrowser);
+            expect(loggerState.warn).toHaveBeenCalledWith('Failed to close previous browser:', expect.any(Error));
+        });
+    });
+    describe('close — pending launch interactions', () => {
+        it('waits for pending launch to settle before finalizing close', async () => {
+            let launchResolve;
+            const launchDeferred = new Promise((res) => {
+                launchResolve = res;
+            });
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockReturnValue(launchDeferred);
+            const manager = new CamoufoxBrowserManager();
+            const launchPromise = manager.launch();
+            const closePromise = manager.close();
+            await closePromise;
+            launchResolve(fakeBrowser);
+            await expect(launchPromise).rejects.toThrow(/close/i);
+        });
+        it('close handles launch rejection gracefully', async () => {
+            camoufoxLaunchMock.mockRejectedValue(new Error('launch fail'));
+            const manager = new CamoufoxBrowserManager();
+            const launchPromise = manager.launch().catch(() => { });
+            await manager.close();
+            await launchPromise;
+        });
+    });
+    describe('finalizeClose', () => {
+        it('does nothing when browser is already null', async () => {
+            const manager = new CamoufoxBrowserManager();
+            await manager.close();
+            expect(manager.getBrowser()).toBeNull();
+        });
+        it('resets isClosing even when browser.close throws', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            fakeBrowser.close.mockRejectedValue(new Error('Close error'));
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await expect(manager.close()).rejects.toThrow('Close error');
+            const newBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(newBrowser);
+            const result = await manager.launch();
+            expect(result).toBe(newBrowser);
+        });
+    });
+    describe('newPage', () => {
+        it('auto-launches browser and creates page', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            const page = await manager.newPage();
+            expect(page).toBeDefined();
+            expect(camoufoxLaunchMock).toHaveBeenCalledOnce();
+            expect(fakeBrowser.newPage).toHaveBeenCalledOnce();
+        });
+    });
+    describe('goto', () => {
+        it('creates new page when none provided and navigates', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            const fakePage = createFakePage();
+            fakeBrowser.newPage.mockResolvedValue(fakePage);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const result = await manager.goto('https://example.com');
+            expect(result).toBe(fakePage);
+            expect(fakePage.goto).toHaveBeenCalledWith('https://example.com', {
+                waitUntil: 'networkidle',
+            });
+        });
+        it('uses provided page and navigates', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const existingPage = createFakePage();
+            const result = await manager.goto('https://example.com', existingPage);
+            expect(result).toBe(existingPage);
+            expect(existingPage.goto).toHaveBeenCalledWith('https://example.com', {
+                waitUntil: 'networkidle',
+            });
+            expect(fakeBrowser.newPage).not.toHaveBeenCalled();
+        });
+    });
+    describe('launchAsServer — import failure', () => {
+        it('throws PrerequisiteError when camoufox-js server import fails', async () => {
+            camoufoxServerLaunchMock.mockImplementation(() => {
+                throw new Error('Module not found');
+            });
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.launchAsServer(8888)).rejects.toThrow();
+        });
+        it('passes config to server launch', async () => {
+            const fakeServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/test'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock.mockResolvedValue(fakeServer);
+            const manager = new CamoufoxBrowserManager({
+                os: 'linux',
+                headless: 'virtual',
+                geoip: true,
+                humanize: true,
+                blockImages: true,
+                blockWebrtc: true,
+                proxy: { server: 'http://proxy:8080' },
+            });
+            const endpoint = await manager.launchAsServer(9999, '/ws');
+            expect(endpoint).toBe('ws://127.0.0.1:8888/test');
+            expect(camoufoxServerLaunchMock).toHaveBeenCalledWith(expect.objectContaining({
+                os: 'linux',
+                headless: 'virtual',
+                geoip: true,
+                humanize: true,
+                block_images: true,
+                block_webrtc: true,
+                proxy: { server: 'http://proxy:8080' },
+                port: 9999,
+                ws_path: '/ws',
+            }));
+        });
+        it('closes existing server before relaunch and warns on close failure', async () => {
+            const firstServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/first'),
+                close: vi.fn().mockRejectedValue(new Error('close fail')),
+            };
+            const secondServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:9999/second'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock
+                .mockResolvedValueOnce(firstServer)
+                .mockResolvedValueOnce(secondServer);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launchAsServer(8888);
+            const endpoint = await manager.launchAsServer(9999);
+            expect(endpoint).toBe('ws://127.0.0.1:9999/second');
+            expect(firstServer.close).toHaveBeenCalled();
+            expect(loggerState.warn).toHaveBeenCalledWith('Failed to close previous server:', expect.any(Error));
+        });
+    });
+    describe('connectToServer', () => {
+        it('connects to remote server and returns browser', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            playwrightConnectMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            const result = await manager.connectToServer('ws://127.0.0.1:8888/test');
+            expect(result).toBe(fakeBrowser);
+            expect(playwrightConnectMock).toHaveBeenCalledWith('ws://127.0.0.1:8888/test');
+            expect(manager.getBrowser()).toBe(fakeBrowser);
+        });
+        it('disconnects existing browser before connecting to new server', async () => {
+            const existingBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(existingBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const newBrowser = createFakeBrowser(true);
+            playwrightConnectMock.mockResolvedValue(newBrowser);
+            const result = await manager.connectToServer('ws://127.0.0.1:9999/new');
+            expect(existingBrowser.close).toHaveBeenCalled();
+            expect(result).toBe(newBrowser);
+            expect(loggerState.info).toHaveBeenCalledWith(expect.stringContaining('Disconnecting existing browser'));
+        });
+        it('handles close error on existing browser when connecting', async () => {
+            const existingBrowser = createFakeBrowser(true);
+            existingBrowser.close.mockRejectedValue(new Error('disconnect fail'));
+            camoufoxLaunchMock.mockResolvedValue(existingBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const newBrowser = createFakeBrowser(true);
+            playwrightConnectMock.mockResolvedValue(newBrowser);
+            const result = await manager.connectToServer('ws://127.0.0.1:9999/new');
+            expect(result).toBe(newBrowser);
+            expect(loggerState.warn).toHaveBeenCalledWith('Failed to close previous browser:', expect.any(Error));
+        });
+    });
+    describe('closeBrowserServer', () => {
+        it('closes server and resets endpoint', async () => {
+            const fakeServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/test'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock.mockResolvedValue(fakeServer);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launchAsServer(8888);
+            expect(manager.getBrowserServerEndpoint()).toBe('ws://127.0.0.1:8888/test');
+            await manager.closeBrowserServer();
+            expect(fakeServer.close).toHaveBeenCalled();
+            expect(manager.getBrowserServerEndpoint()).toBeNull();
+            expect(loggerState.info).toHaveBeenCalledWith('Camoufox server closed');
+        });
+        it('is a no-op when no server exists', async () => {
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.closeBrowserServer()).resolves.not.toThrow();
+            expect(manager.getBrowserServerEndpoint()).toBeNull();
+        });
+    });
+    describe('getCDPSession', () => {
+        it('logs warning about limited CDP support', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const fakePage = createFakePage();
+            await manager.getCDPSession(fakePage);
+            expect(loggerState.warn).toHaveBeenCalledWith(expect.stringContaining('CDP sessions on camoufox'));
+        });
+        it('returns CDP session from page context', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const fakePage = createFakePage();
+            const session = await manager.getCDPSession(fakePage);
+            expect(session).toBeDefined();
+            expect(fakePage.context).toHaveBeenCalled();
+        });
+    });
+    describe('constructor config', () => {
+        it('uses all default config values', () => {
+            const manager = new CamoufoxBrowserManager();
+            expect(manager.getBrowser()).toBeNull();
+            expect(manager.getBrowserServerEndpoint()).toBeNull();
+        });
+        it('applies custom config', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager({
+                os: 'macos',
+                headless: false,
+                geoip: true,
+                humanize: 2,
+                blockImages: true,
+                blockWebrtc: true,
+                proxy: { server: 'socks5://proxy:1080', username: 'user', password: 'pass' },
+            });
+            await manager.launch();
+            expect(camoufoxLaunchMock).toHaveBeenCalledWith(expect.objectContaining({
+                os: 'macos',
+                headless: false,
+                geoip: true,
+                humanize: 2,
+                block_images: true,
+                block_webrtc: true,
+                proxy: { server: 'socks5://proxy:1080', username: 'user', password: 'pass' },
+            }));
+        });
+        it('launches with default headless true when not specified', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager({});
+            await manager.launch();
+            expect(camoufoxLaunchMock).toHaveBeenCalledWith(expect.objectContaining({
+                os: 'windows',
+                headless: true,
+                geoip: false,
+                humanize: false,
+                block_images: false,
+                block_webrtc: false,
+            }));
+        });
+    });
+    describe('launch — concurrent dedup', () => {
+        it('clears launchPromise after launch completes', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const result = await manager.launch();
+            expect(result).toBe(fakeBrowser);
+            expect(camoufoxLaunchMock).toHaveBeenCalledOnce();
+        });
+        it('clears launchPromise even when launch fails', async () => {
+            camoufoxLaunchMock.mockRejectedValueOnce(new Error('launch boom'));
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.launch()).rejects.toThrow('launch boom');
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const result = await manager.launch();
+            expect(result).toBe(fakeBrowser);
+        });
+    });
+});

package/dist/tests/modules/browser/CamoufoxBrowserManager.edge-cases.test.d.ts

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

package/dist/tests/modules/browser/CamoufoxBrowserManager.edge-cases.test.js

@@ -0,0 +1,250 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+const camoufoxLaunchMock = vi.hoisted(() => vi.fn());
+const camoufoxServerLaunchMock = vi.hoisted(() => vi.fn());
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('camoufox-js', () => ({
+    Camoufox: (...args) => camoufoxLaunchMock(...args),
+    launchServer: (...args) => camoufoxServerLaunchMock(...args),
+}));
+vi.mock('playwright-core', () => ({
+    firefox: {
+        connect: vi.fn(),
+    },
+}));
+import { CamoufoxBrowserManager } from '../../../src/modules/browser/CamoufoxBrowserManager.js';
+function createFakeBrowser(connected = true) {
+    return {
+        newPage: vi.fn().mockResolvedValue(createFakePage()),
+        close: vi.fn(async () => { }),
+        isConnected: vi.fn(() => connected),
+    };
+}
+function createFakePage() {
+    return {
+        goto: vi.fn(async () => { }),
+        context: vi.fn(() => ({
+            newCDPSession: vi.fn(async () => ({ send: vi.fn() })),
+        })),
+    };
+}
+describe('CamoufoxBrowserManager — edge cases', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('applies default config values', () => {
+            const manager = new CamoufoxBrowserManager();
+            expect(manager).toBeDefined();
+            expect(manager.getBrowser()).toBeNull();
+        });
+        it('accepts custom config values', () => {
+            const manager = new CamoufoxBrowserManager({
+                os: 'linux',
+                headless: false,
+                geoip: true,
+                humanize: true,
+                blockImages: true,
+                blockWebrtc: true,
+                proxy: { server: 'http://proxy:8080', username: 'user', password: 'pass' },
+            });
+            expect(manager).toBeDefined();
+        });
+    });
+    describe('launch', () => {
+        it('returns existing browser when already connected', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValueOnce(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            const first = await manager.launch();
+            expect(first).toBe(fakeBrowser);
+            const second = await manager.launch();
+            expect(second).toBe(fakeBrowser);
+            expect(camoufoxLaunchMock).toHaveBeenCalledTimes(1);
+        });
+        it('throws when trying to launch while closing', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValueOnce(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            fakeBrowser.isConnected.mockReturnValue(false);
+            const closePromise = manager.close();
+            await closePromise;
+            expect(manager.getBrowser()).toBeNull();
+        });
+        it('relaunches when existing browser is disconnected', async () => {
+            const firstBrowser = createFakeBrowser(true);
+            const secondBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock
+                .mockResolvedValueOnce(firstBrowser)
+                .mockResolvedValueOnce(secondBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            firstBrowser.isConnected.mockReturnValue(false);
+            const result = await manager.launch();
+            expect(result).toBe(secondBrowser);
+            expect(firstBrowser.close).toHaveBeenCalled();
+        });
+    });
+    describe('newPage', () => {
+        it('auto-launches browser if not launched yet', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            const page = await manager.newPage();
+            expect(page).toBeDefined();
+            expect(fakeBrowser.newPage).toHaveBeenCalledTimes(1);
+        });
+        it('uses existing browser if already launched', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await manager.newPage();
+            expect(camoufoxLaunchMock).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('goto', () => {
+        it('navigates an existing page', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const fakePage = createFakePage();
+            const result = await manager.goto('https://example.com', fakePage);
+            expect(fakePage.goto).toHaveBeenCalledWith('https://example.com', {
+                waitUntil: 'networkidle',
+            });
+            expect(result).toBe(fakePage);
+        });
+        it('creates a new page when no page is provided', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await manager.goto('https://example.com');
+            expect(fakeBrowser.newPage).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('close', () => {
+        it('closes the browser and resets state', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await manager.close();
+            expect(fakeBrowser.close).toHaveBeenCalledTimes(1);
+            expect(manager.getBrowser()).toBeNull();
+        });
+        it('does nothing when no browser is launched', async () => {
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.close()).resolves.not.toThrow();
+        });
+        it('resets isClosing flag even on close error', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            fakeBrowser.close.mockRejectedValue(new Error('Close failed'));
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await expect(manager.close()).rejects.toThrow('Close failed');
+            const newBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(newBrowser);
+            const result = await manager.launch();
+            expect(result).toBe(newBrowser);
+        });
+    });
+    describe('getBrowser', () => {
+        it('returns null before launch', () => {
+            const manager = new CamoufoxBrowserManager();
+            expect(manager.getBrowser()).toBeNull();
+        });
+        it('returns browser after launch', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            expect(manager.getBrowser()).toBe(fakeBrowser);
+        });
+        it('returns null after close', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            await manager.close();
+            expect(manager.getBrowser()).toBeNull();
+        });
+    });
+    describe('getCDPSession', () => {
+        it('creates CDP session through page context', async () => {
+            const fakeBrowser = createFakeBrowser(true);
+            camoufoxLaunchMock.mockResolvedValue(fakeBrowser);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launch();
+            const fakePage = createFakePage();
+            const session = await manager.getCDPSession(fakePage);
+            expect(session).toBeDefined();
+            expect(loggerState.warn).toHaveBeenCalledWith(expect.stringContaining('CDP sessions on camoufox'));
+        });
+    });
+    describe('launchAsServer', () => {
+        it('launches server and returns ws endpoint', async () => {
+            const fakeServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/camoufox'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock.mockResolvedValue(fakeServer);
+            const manager = new CamoufoxBrowserManager();
+            const endpoint = await manager.launchAsServer(8888, '/camoufox');
+            expect(endpoint).toBe('ws://127.0.0.1:8888/camoufox');
+            expect(manager.getBrowserServerEndpoint()).toBe('ws://127.0.0.1:8888/camoufox');
+        });
+        it('closes existing server before relaunch', async () => {
+            const firstServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/first'),
+                close: vi.fn(async () => { }),
+            };
+            const secondServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:9999/second'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock
+                .mockResolvedValueOnce(firstServer)
+                .mockResolvedValueOnce(secondServer);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launchAsServer(8888);
+            await manager.launchAsServer(9999);
+            expect(firstServer.close).toHaveBeenCalled();
+            expect(manager.getBrowserServerEndpoint()).toBe('ws://127.0.0.1:9999/second');
+        });
+    });
+    describe('closeBrowserServer', () => {
+        it('closes the server and resets state', async () => {
+            const fakeServer = {
+                wsEndpoint: vi.fn(() => 'ws://127.0.0.1:8888/path'),
+                close: vi.fn(async () => { }),
+            };
+            camoufoxServerLaunchMock.mockResolvedValue(fakeServer);
+            const manager = new CamoufoxBrowserManager();
+            await manager.launchAsServer(8888);
+            await manager.closeBrowserServer();
+            expect(fakeServer.close).toHaveBeenCalled();
+            expect(manager.getBrowserServerEndpoint()).toBeNull();
+        });
+        it('does nothing when no server exists', async () => {
+            const manager = new CamoufoxBrowserManager();
+            await expect(manager.closeBrowserServer()).resolves.not.toThrow();
+        });
+    });
+    describe('getBrowserServerEndpoint', () => {
+        it('returns null when no server is running', () => {
+            const manager = new CamoufoxBrowserManager();
+            expect(manager.getBrowserServerEndpoint()).toBeNull();
+        });
+    });
+});

package/dist/tests/modules/browser/DOMInspector.additional.test.d.ts

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