@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/tests/modules/browser/BrowserDiscovery.test.js

@@ -1,72 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const getScriptPathMock = vi.fn((name) => `C:/scripts/${name}`);
-vi.mock('@src/native/ScriptLoader', () => ({
-    ScriptLoader: class {
-        getScriptPath(name) {
-            return getScriptPathMock(name);
-        }
-    },
-}));
-import { BrowserDiscovery } from '../../../src/modules/browser/BrowserDiscovery.js';
-describe('BrowserDiscovery', () => {
-    let discovery;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        discovery = new BrowserDiscovery();
-    });
-    it('discovers browsers by aggregating signatures', async () => {
-        const findBySignature = vi
-            .spyOn(discovery, 'findBySignature')
-            .mockResolvedValueOnce([{ type: 'chrome', pid: 1 }])
-            .mockResolvedValueOnce([{ type: 'edge', pid: 2 }])
-            .mockResolvedValueOnce([{ type: 'firefox', pid: 3 }]);
-        const result = await discovery.discoverBrowsers();
-        expect(findBySignature).toHaveBeenCalledTimes(3);
-        expect(result.map((r) => r.pid)).toEqual([1, 2, 3]);
-    });
-    it('parses windows result and infers browser type by title/class', () => {
-        const parse = discovery.parseWindowsResult.bind(discovery);
-        const signatures = Array.from(discovery.browserSignatures.entries());
-        const primary = signatures.find(([, signature]) => Array.isArray(signature.windowClasses) && signature.windowClasses.length > 0);
-        const secondary = signatures.find(([browserName, signature]) => browserName !== primary[0] && Array.isArray(signature.windowClasses) && signature.windowClasses.length > 0);
-        const payload = JSON.stringify([
-            { ProcessId: 11, Handle: '0x1', Title: 'Docs - Primary Browser', ClassName: primary[1].windowClasses[0] },
-            { ProcessId: 12, Handle: '0x2', Title: 'Unknown', ClassName: secondary[1].windowClasses[0] },
-        ]);
-        const result = parse(payload, '*');
-        expect(result[0].type).toBe(primary[0]);
-        expect(result[1].type).toBe(secondary[0]);
-    });
-    it('parses process results and infers browser type by process name', () => {
-        const parse = discovery.parseProcessResult.bind(discovery);
-        const signatures = Array.from(discovery.browserSignatures.entries());
-        const payload = JSON.stringify([
-            { Id: 21, ProcessName: signatures[0][1].processNames[0], MainWindowHandle: 3, MainWindowTitle: 'a' },
-            { Id: 22, ProcessName: signatures[1][1].processNames[0], MainWindowHandle: 4, MainWindowTitle: 'b' },
-            { Id: 23, ProcessName: signatures[2][1].processNames[0], MainWindowHandle: 5, MainWindowTitle: 'c' },
-        ]);
-        const result = parse(payload, 'x');
-        expect(result.map((r) => r.type)).toEqual(signatures.slice(0, 3).map(([name]) => name));
-    });
-    it('detectDebugPort prioritizes command-line detected port', async () => {
-        vi.spyOn(discovery, 'checkDebugPortFromCommandLine').mockResolvedValue(9555);
-        const checkPort = vi.spyOn(discovery, 'checkPort').mockResolvedValue(true);
-        const port = await discovery.detectDebugPort(100, [9222, 9333]);
-        expect(port).toBe(9555);
-        expect(checkPort).not.toHaveBeenCalled();
-    });
-    it('detectDebugPort falls back to probing known ports', async () => {
-        vi.spyOn(discovery, 'checkDebugPortFromCommandLine').mockResolvedValue(null);
-        vi.spyOn(discovery, 'checkPort')
-            .mockResolvedValueOnce(false)
-            .mockResolvedValueOnce(true);
-        const port = await discovery.detectDebugPort(100, [9222, 9333]);
-        expect(port).toBe(9333);
-    });
-    it('detectDebugPort returns null when no port is found', async () => {
-        vi.spyOn(discovery, 'checkDebugPortFromCommandLine').mockResolvedValue(null);
-        vi.spyOn(discovery, 'checkPort').mockResolvedValue(false);
-        const port = await discovery.detectDebugPort(100, [9222]);
-        expect(port).toBeNull();
-    });
-});

package/dist/tests/modules/browser/BrowserModeManager.test.d.ts

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

package/dist/tests/modules/browser/BrowserModeManager.test.js

@@ -1,213 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
-const existsSyncMock = vi.fn();
-const findBrowserExecutableMock = vi.fn();
-const launchMock = vi.fn();
-const detectMock = vi.fn();
-const assessMock = vi.fn();
-const waitForCompletionMock = vi.fn();
-vi.mock('fs', () => ({
-    existsSync: (...args) => existsSyncMock(...args),
-}));
-vi.mock('rebrowser-puppeteer-core', () => ({
-    default: {
-        launch: (...args) => launchMock(...args),
-    },
-}));
-vi.mock('@src/utils/browserExecutable', () => ({
-    findBrowserExecutable: (...args) => findBrowserExecutableMock(...args),
-}));
-vi.mock('@src/modules/captcha/CaptchaDetector', () => ({
-    CaptchaDetector: class {
-        detect = detectMock;
-        assess = assessMock;
-        waitForCompletion = waitForCompletionMock;
-    },
-}));
-import { BrowserModeManager } from '../../../src/modules/browser/BrowserModeManager.js';
-describe('BrowserModeManager', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        assessMock.mockResolvedValue({
-            signals: [],
-            candidates: [],
-            score: 0,
-            excludeScore: 0,
-            confidence: 0,
-            likelyCaptcha: false,
-            recommendedNextStep: 'ignore',
-            primaryDetection: { detected: false, type: 'none', confidence: 0 },
-        });
-    });
-    it('resolves configured executable path when file exists', () => {
-        existsSyncMock.mockReturnValue(true);
-        const manager = new BrowserModeManager({}, { executablePath: '/my/browser-bin' });
-        const path = manager.resolveExecutablePath();
-        expect(path).toBe('/my/browser-bin');
-    });
-    it('throws when configured executable path does not exist', () => {
-        existsSyncMock.mockReturnValue(false);
-        const manager = new BrowserModeManager({}, { executablePath: '/missing/browser-bin' });
-        expect(() => manager.resolveExecutablePath()).toThrow(/not found/i);
-    });
-    it('uses detected executable path when not explicitly configured', () => {
-        findBrowserExecutableMock.mockReturnValue('/detected/browser-bin');
-        const manager = new BrowserModeManager();
-        const path = manager.resolveExecutablePath();
-        expect(path).toBe('/detected/browser-bin');
-    });
-    it('launches browser with hardened args', async () => {
-        findBrowserExecutableMock.mockReturnValue('/detected/browser-bin');
-        const fakeBrowser = { newPage: vi.fn(), close: vi.fn() };
-        launchMock.mockResolvedValue(fakeBrowser);
-        const manager = new BrowserModeManager({ defaultHeadless: true }, { args: ['--foo'] });
-        const browser = await manager.launch();
-        expect(browser).toBe(fakeBrowser);
-        expect(launchMock).toHaveBeenCalledOnce();
-        const options = launchMock.mock.calls[0]?.[0];
-        expect(options.headless).toBe(true);
-        expect(options.args).toContain('--foo');
-        expect(options.args).toContain('--disable-extensions');
-        expect(options.executablePath).toBe('/detected/browser-bin');
-    });
-    it('goto throws when no active page is available', async () => {
-        const manager = new BrowserModeManager();
-        await expect(manager.goto('https://vmoranv.github.io/jshookmcp')).rejects.toThrow(/newPage/i);
-    });
-    it('waits for manual completion when captcha detected and no auto switch', async () => {
-        assessMock.mockResolvedValue({
-            signals: [],
-            candidates: [
-                {
-                    source: 'dom',
-                    value: '.captcha-slider',
-                    confidence: 90,
-                    type: 'slider',
-                    providerHint: 'regional_service',
-                },
-            ],
-            score: 90,
-            excludeScore: 0,
-            confidence: 90,
-            likelyCaptcha: true,
-            recommendedNextStep: 'manual',
-            primaryDetection: {
-                detected: true,
-                type: 'slider',
-                confidence: 90,
-                providerHint: 'regional_service',
-            },
-        });
-        waitForCompletionMock.mockResolvedValue(true);
-        const manager = new BrowserModeManager({
-            autoSwitchHeadless: false,
-            autoDetectCaptcha: true,
-            defaultHeadless: true,
-        });
-        const page = {};
-        await manager.checkAndHandleCaptcha(page, 'https://vmoranv.github.io/jshookmcp');
-        expect(waitForCompletionMock).toHaveBeenCalledOnce();
-    });
-    it('does not auto-act when assessment recommends AI review', async () => {
-        assessMock.mockResolvedValue({
-            signals: [
-                {
-                    source: 'url',
-                    kind: 'captcha',
-                    value: 'https://vmoranv.github.io/jshookmcp/challenge',
-                    confidence: 70,
-                    typeHint: 'url_redirect',
-                },
-                {
-                    source: 'text',
-                    kind: 'exclude',
-                    value: 'Text exclusion: Enter verification code',
-                    confidence: 75,
-                },
-            ],
-            candidates: [
-                {
-                    source: 'url',
-                    value: 'https://vmoranv.github.io/jshookmcp/challenge',
-                    confidence: 70,
-                    type: 'url_redirect',
-                },
-            ],
-            score: 70,
-            excludeScore: 75,
-            confidence: 70,
-            likelyCaptcha: false,
-            recommendedNextStep: 'ask_ai',
-            primaryDetection: { detected: false, type: 'none', confidence: 0 },
-        });
-        const manager = new BrowserModeManager({
-            autoSwitchHeadless: true,
-            autoDetectCaptcha: true,
-            defaultHeadless: true,
-        });
-        const page = {};
-        await manager.checkAndHandleCaptcha(page, 'https://vmoranv.github.io/jshookmcp');
-        expect(waitForCompletionMock).not.toHaveBeenCalled();
-        expect(detectMock).not.toHaveBeenCalled();
-    });
-    it('reuses the same launch promise for concurrent newPage calls', async () => {
-        findBrowserExecutableMock.mockReturnValue('/detected/browser-bin');
-        const firstPage = {
-            evaluateOnNewDocument: vi.fn(async () => { }),
-            setCookie: vi.fn(async () => { }),
-        };
-        const secondPage = {
-            evaluateOnNewDocument: vi.fn(async () => { }),
-            setCookie: vi.fn(async () => { }),
-        };
-        const fakeBrowser = {
-            newPage: vi.fn()
-                .mockResolvedValueOnce(firstPage)
-                .mockResolvedValueOnce(secondPage),
-            close: vi.fn(async () => { }),
-            isConnected: vi.fn(() => true),
-        };
-        const deferred = createDeferred();
-        launchMock.mockReturnValue(deferred.promise);
-        const manager = new BrowserModeManager({ defaultHeadless: true });
-        const firstNewPage = manager.newPage();
-        const secondNewPage = manager.newPage();
-        expect(launchMock).toHaveBeenCalledTimes(1);
-        deferred.resolve(fakeBrowser);
-        await expect(Promise.all([firstNewPage, secondNewPage])).resolves.toEqual([
-            firstPage,
-            secondPage,
-        ]);
-        expect(fakeBrowser.newPage).toHaveBeenCalledTimes(2);
-    });
-    it('returns from close while launch is still pending and closes once launch settles', async () => {
-        findBrowserExecutableMock.mockReturnValue('/detected/browser-bin');
-        const deferred = createDeferred();
-        const fakeBrowser = {
-            newPage: vi.fn(),
-            close: vi.fn(async () => { }),
-            isConnected: vi.fn(() => true),
-        };
-        launchMock.mockReturnValue(deferred.promise);
-        const manager = new BrowserModeManager({ defaultHeadless: true });
-        const launchPromise = manager.launch();
-        const closeResult = await Promise.race([
-            manager.close().then(() => 'closed'),
-            new Promise(resolve => setTimeout(() => resolve('timeout'), 50)),
-        ]);
-        expect(closeResult).toBe('closed');
-        deferred.resolve(fakeBrowser);
-        await expect(launchPromise).rejects.toThrow(/close/i);
-        await vi.waitFor(() => {
-            expect(fakeBrowser.close).toHaveBeenCalledTimes(1);
-        });
-    });
-});

package/dist/tests/modules/browser/CamoufoxBrowserManager.coverage.test.d.ts

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

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

@@ -1,375 +0,0 @@
-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

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