@jshookmcp/jshook 0.1.8 → 0.2.0

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

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

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

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

@@ -0,0 +1,213 @@
+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.d.ts

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

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

@@ -0,0 +1,74 @@
+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.d.ts

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

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

@@ -0,0 +1,190 @@
+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),
+        });
+    });
+});

package/dist/tests/modules/captcha/AICaptchaDetector.test.d.ts

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