@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/tests/modules/analyzer/SecurityCodeAnalyzer.test.js

@@ -1,82 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import * as parser from '@babel/parser';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-import { checkSanitizer, getMemberExpressionName, identifySecurityRisks, } from '../../../src/modules/analyzer/SecurityCodeAnalyzer.js';
-describe('SecurityCodeAnalyzer', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-    });
-    it('builds full member-expression name', () => {
-        const expr = parser.parseExpression('window.security.escapeHtml');
-        const name = getMemberExpressionName(expr);
-        expect(name).toBe('window.security.escapeHtml');
-    });
-    it('checks sanitizers for identifier and member-expression calls', () => {
-        const idCall = parser.parseExpression('sanitize(input)');
-        const memberCall = parser.parseExpression('DOMPurify.sanitize(input)');
-        const sanitizers = new Set(['sanitize', 'DOMPurify.sanitize']);
-        expect(checkSanitizer(idCall, sanitizers)).toBe(true);
-        expect(checkSanitizer(memberCall, sanitizers)).toBe(true);
-    });
-    it('merges AI-reported risks into final result', () => {
-        const risks = identifySecurityRisks('const a = 1;', {
-            securityRisks: [
-                {
-                    type: 'xss',
-                    severity: 'high',
-                    location: { line: 8 },
-                    description: 'ai',
-                    recommendation: 'fix',
-                },
-            ],
-        });
-        expect(risks.some((r) => r.type === 'xss' && r.location.line === 8)).toBe(true);
-    });
-    it('detects key static vulnerabilities from source', () => {
-        const code = `
-      element.innerHTML = userInput;
-      eval(payload);
-      db.query("SELECT * FROM users WHERE id=" + userId);
-      const apiKey = "1234567890abcdef";
-      const n = Math.random();
-    `;
-        const risks = identifySecurityRisks(code, {});
-        expect(risks.some((r) => r.type === 'xss')).toBe(true);
-        expect(risks.some((r) => r.type === 'sql-injection')).toBe(true);
-        expect(risks.some((r) => r.description.includes('eval'))).toBe(true);
-        expect(risks.some((r) => r.description.includes('Hardcoded'))).toBe(true);
-        expect(risks.some((r) => r.description.includes('Math.random'))).toBe(true);
-    });
-    it('deduplicates same type+line risks from AI and static analysis', () => {
-        const code = 'x.innerHTML = input;';
-        const risks = identifySecurityRisks(code, {
-            securityRisks: [
-                {
-                    type: 'xss',
-                    severity: 'high',
-                    location: { line: 1 },
-                    description: 'duplicate',
-                    recommendation: 'dup',
-                },
-            ],
-        });
-        const xssLine1 = risks.filter((r) => r.type === 'xss' && r.location.line === 1);
-        expect(xssLine1).toHaveLength(1);
-    });
-    it('keeps AI risks even when static parse fails', () => {
-        const risks = identifySecurityRisks('function bad( {', {
-            securityRisks: [{ type: 'other', severity: 'low', location: { line: 99 } }],
-        });
-        expect(risks.some((r) => r.location.line === 99)).toBe(true);
-        expect(loggerState.warn).toHaveBeenCalled();
-    });
-});

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.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.test.js

@@ -1,74 +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 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),
-}));
-import { CamoufoxBrowserManager } from '../../../src/modules/browser/CamoufoxBrowserManager.js';
-describe('CamoufoxBrowserManager', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('reuses the same launch promise for concurrent launch calls', async () => {
-        const deferred = createDeferred();
-        const fakeBrowser = {
-            newPage: vi.fn(),
-            close: vi.fn(async () => { }),
-            isConnected: vi.fn(() => true),
-        };
-        camoufoxLaunchMock.mockReturnValue(deferred.promise);
-        const manager = new CamoufoxBrowserManager();
-        const firstLaunch = manager.launch();
-        const secondLaunch = manager.launch();
-        await vi.waitFor(() => {
-            expect(camoufoxLaunchMock).toHaveBeenCalledTimes(1);
-        });
-        deferred.resolve(fakeBrowser);
-        await expect(Promise.all([firstLaunch, secondLaunch])).resolves.toEqual([
-            fakeBrowser,
-            fakeBrowser,
-        ]);
-    });
-    it('returns from close while launch is still pending and closes once launch settles', async () => {
-        const deferred = createDeferred();
-        const fakeBrowser = {
-            newPage: vi.fn(),
-            close: vi.fn(async () => { }),
-            isConnected: vi.fn(() => true),
-        };
-        camoufoxLaunchMock.mockReturnValue(deferred.promise);
-        const manager = new CamoufoxBrowserManager();
-        const launchPromise = manager.launch();
-        await vi.waitFor(() => {
-            expect(camoufoxLaunchMock).toHaveBeenCalledTimes(1);
-        });
-        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/UnifiedBrowserManager.test.js

@@ -1,190 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-}));
-const chromeState = vi.hoisted(() => ({
-    ctor: null,
-    instances: [],
-    launchImpl: null,
-}));
-const camoufoxState = vi.hoisted(() => ({
-    ctor: null,
-    instances: [],
-    launchImpl: null,
-}));
-const discoveryState = vi.hoisted(() => ({
-    discoverBrowsers: vi.fn(async () => []),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/modules/browser/BrowserModeManager', () => {
-    const ctorSpy = vi.fn();
-    chromeState.ctor = ctorSpy;
-    class BrowserModeManager {
-        __modeConfig;
-        __launchOptions;
-        browser = { isConnected: vi.fn(() => true) };
-        page = { id: 'primary-browser-page' };
-        launch = vi.fn(async () => chromeState.launchImpl ? chromeState.launchImpl(this) : this.browser);
-        newPage = vi.fn(async () => this.page);
-        goto = vi.fn(async (_url, targetPage) => targetPage ?? this.page);
-        close = vi.fn(async () => { });
-        getBrowser = vi.fn(() => this.browser);
-        constructor(modeConfig, launchOptions) {
-            ctorSpy(modeConfig, launchOptions);
-            this.__modeConfig = modeConfig;
-            this.__launchOptions = launchOptions;
-            chromeState.instances.push(this);
-        }
-    }
-    return { BrowserModeManager };
-});
-vi.mock('@src/modules/browser/CamoufoxBrowserManager', () => {
-    const ctorSpy = vi.fn();
-    camoufoxState.ctor = ctorSpy;
-    class CamoufoxBrowserManager {
-        __config;
-        browser = { isConnected: vi.fn(() => true) };
-        page = { id: 'camoufox-page' };
-        launch = vi.fn(async () => camoufoxState.launchImpl ? camoufoxState.launchImpl(this) : this.browser);
-        connectToServer = vi.fn(async () => this.browser);
-        newPage = vi.fn(async () => this.page);
-        goto = vi.fn(async (_url, targetPage) => targetPage ?? this.page);
-        close = vi.fn(async () => { });
-        getBrowser = vi.fn(() => this.browser);
-        constructor(config) {
-            ctorSpy(config);
-            this.__config = config;
-            camoufoxState.instances.push(this);
-        }
-    }
-    return {
-        CamoufoxBrowserManager,
-    };
-});
-vi.mock('@src/modules/browser/BrowserDiscovery', () => {
-    class BrowserDiscovery {
-        discoverBrowsers = discoveryState.discoverBrowsers;
-    }
-    return { BrowserDiscovery };
-});
-import { UnifiedBrowserManager } from '../../../src/modules/browser/UnifiedBrowserManager.js';
-describe('UnifiedBrowserManager', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        loggerState.info.mockReset();
-        loggerState.warn.mockReset();
-        loggerState.error.mockReset();
-        loggerState.debug.mockReset();
-        chromeState.instances.length = 0;
-        camoufoxState.instances.length = 0;
-        chromeState.launchImpl = null;
-        camoufoxState.launchImpl = null;
-        chromeState.ctor?.mockClear?.();
-        camoufoxState.ctor?.mockClear?.();
-        discoveryState.discoverBrowsers.mockReset();
-        discoveryState.discoverBrowsers.mockResolvedValue([]);
-    });
-    it('launches Chrome with normalized headless mode and merged launch args', async () => {
-        const manager = new UnifiedBrowserManager({
-            driver: 'chrome',
-            headless: 'virtual',
-            args: ['--custom-arg'],
-            proxy: { server: 'http://127.0.0.1:8888' },
-            debugPort: 9222,
-        });
-        await manager.launch();
-        expect(chromeState.ctor).toHaveBeenCalledTimes(1);
-        const chromeInstance = chromeState.instances[0];
-        expect(chromeInstance.__modeConfig.defaultHeadless).toBe(true);
-        expect(chromeInstance.__launchOptions.headless).toBe(true);
-        expect(chromeInstance.__launchOptions.args).toContain('--custom-arg');
-        expect(chromeInstance.__launchOptions.args).toContain('--proxy-server=http://127.0.0.1:8888');
-        expect(chromeInstance.__launchOptions.args).toContain('--remote-debugging-port=9222');
-    });
-    it('launches Camoufox with driver-specific headless normalization', async () => {
-        const manager = new UnifiedBrowserManager({
-            driver: 'camoufox',
-            headless: 'shell',
-            os: 'linux',
-            proxy: { server: 'socks5://127.0.0.1:9000' },
-        });
-        await manager.launch();
-        expect(camoufoxState.ctor).toHaveBeenCalledTimes(1);
-        const camoufoxInstance = camoufoxState.instances[0];
-        expect(camoufoxInstance.__config.headless).toBe(true);
-        expect(camoufoxInstance.__config.os).toBe('linux');
-        expect(camoufoxInstance.__config.proxy).toEqual({ server: 'socks5://127.0.0.1:9000' });
-    });
-    it('creates new pages lazily and tracks active page state', async () => {
-        const manager = new UnifiedBrowserManager({ driver: 'chrome' });
-        const page = await manager.newPage();
-        expect(chromeState.instances).toHaveLength(1);
-        expect(chromeState.instances[0].launch).toHaveBeenCalledTimes(1);
-        expect(chromeState.instances[0].newPage).toHaveBeenCalledTimes(1);
-        expect(page).toEqual({ id: 'primary-browser-page' });
-        expect(manager.getActivePage()).toEqual({ id: 'primary-browser-page' });
-    });
-    it('delegates navigation for camoufox using active page context', async () => {
-        const manager = new UnifiedBrowserManager({ driver: 'camoufox' });
-        const page = await manager.newPage();
-        await manager.goto('https://vmoranv.github.io/jshookmcp/path');
-        expect(camoufoxState.instances[0].goto).toHaveBeenCalledWith('https://vmoranv.github.io/jshookmcp/path', page);
-    });
-    it('finds Chrome/Edge instances with preferred debug ports', async () => {
-        discoveryState.discoverBrowsers.mockResolvedValue([
-            { type: 'firefox', pid: 1, debugPort: 9222 },
-            { type: 'chrome', pid: 2, debugPort: 9333 },
-            { type: 'edge', pid: 3, debugPort: 9229 },
-        ]);
-        const manager = new UnifiedBrowserManager({ driver: 'chrome' });
-        const found = await manager.findChromeWithDebugPort([9229, 9333]);
-        expect(found).toEqual({ type: 'chrome', pid: 2, debugPort: 9333 });
-    });
-    it('returns null when attach-to-existing Chrome connection fails', async () => {
-        const manager = new UnifiedBrowserManager({ driver: 'chrome' });
-        vi.spyOn(manager, 'findChromeWithDebugPort').mockResolvedValue({
-            type: 'chrome',
-            pid: 99,
-            debugPort: 9222,
-        });
-        const connectSpy = vi
-            .spyOn(manager, 'connectChrome')
-            .mockRejectedValue(new Error('connection failed'));
-        const browser = await manager.attachToExistingChrome([9222]);
-        expect(connectSpy).toHaveBeenCalledWith('ws://127.0.0.1:9222');
-        expect(browser).toBeNull();
-    });
-    it('closes active manager and resets active page', async () => {
-        const manager = new UnifiedBrowserManager({ driver: 'chrome' });
-        await manager.newPage();
-        await manager.close();
-        expect(chromeState.instances[0].close).toHaveBeenCalledTimes(1);
-        expect(manager.getActivePage()).toBeNull();
-    });
-    it('does not wait for an in-flight Chrome launch before closing', async () => {
-        let resolveLaunch;
-        const pendingLaunch = new Promise(resolve => {
-            resolveLaunch = resolve;
-        });
-        chromeState.launchImpl = () => pendingLaunch;
-        const manager = new UnifiedBrowserManager({ driver: 'chrome' });
-        const launchPromise = manager.launch();
-        await Promise.resolve();
-        expect(chromeState.instances).toHaveLength(1);
-        const closeResult = await Promise.race([
-            manager.close().then(() => 'closed'),
-            new Promise(resolve => setTimeout(() => resolve('timeout'), 50)),
-        ]);
-        expect(closeResult).toBe('closed');
-        expect(chromeState.instances[0].close).toHaveBeenCalledTimes(1);
-        resolveLaunch({ isConnected: vi.fn(() => true) });
-        await expect(launchPromise).resolves.toMatchObject({
-            isConnected: expect.any(Function),
-        });
-    });
-});