@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/modules/emulator/EnvironmentEmulatorFetch.additional.test.js

@@ -0,0 +1,449 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
+}));
+const puppeteerState = vi.hoisted(() => ({
+    launch: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('rebrowser-puppeteer-core', () => ({
+    default: {
+        launch: puppeteerState.launch,
+    },
+}));
+import { fetchRealEnvironmentData } from '../../../src/modules/emulator/EnvironmentEmulatorFetch.js';
+function createDetected() {
+    return {
+        window: ['window.innerWidth'],
+        document: ['document.title'],
+        navigator: ['navigator.userAgent'],
+        location: ['location.href'],
+        screen: ['screen.width'],
+        other: ['custom.var'],
+    };
+}
+function createEmptyDetected() {
+    return {
+        window: [],
+        document: [],
+        navigator: [],
+        location: [],
+        screen: [],
+        other: [],
+    };
+}
+function createPage(extractedValues) {
+    return {
+        setUserAgent: vi.fn().mockResolvedValue(undefined),
+        evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(extractedValues),
+        close: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function createBrowser(page) {
+    return {
+        newPage: vi.fn().mockResolvedValue(page),
+    };
+}
+describe('EnvironmentEmulatorFetch – additional coverage', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        Object.values(loggerState).forEach((fn) => fn.mockReset());
+        puppeteerState.launch.mockReset();
+    });
+    describe('browser launch', () => {
+        it('launches without executablePath when resolveExecutablePath returns undefined', async () => {
+            const page = createPage({ 'window.innerWidth': 1920 });
+            const browser = createBrowser(page);
+            puppeteerState.launch.mockResolvedValue(browser);
+            await fetchRealEnvironmentData({
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 2,
+                resolveExecutablePath: () => undefined,
+                buildManifestFromTemplate: vi.fn(),
+            });
+            const launchArgs = puppeteerState.launch.mock.calls[0][0];
+            expect(launchArgs.executablePath).toBeUndefined();
+            expect(launchArgs.headless).toBe(true);
+            expect(launchArgs.args).toContain('--no-sandbox');
+        });
+        it('launches with executablePath when resolveExecutablePath returns a path', async () => {
+            const page = createPage({ 'window.innerWidth': 1920 });
+            const browser = createBrowser(page);
+            puppeteerState.launch.mockResolvedValue(browser);
+            await fetchRealEnvironmentData({
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 2,
+                resolveExecutablePath: () => '/usr/bin/chromium',
+                buildManifestFromTemplate: vi.fn(),
+            });
+            const launchArgs = puppeteerState.launch.mock.calls[0][0];
+            expect(launchArgs.executablePath).toBe('/usr/bin/chromium');
+        });
+        it('does not call puppeteer.launch when browser is provided', async () => {
+            const page = createPage({ 'window.innerWidth': 1920 });
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 2,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(puppeteerState.launch).not.toHaveBeenCalled();
+        });
+    });
+    describe('page configuration', () => {
+        it('sets a Chrome-like user agent', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Chrome/120.0.0.0'));
+        });
+        it('calls evaluateOnNewDocument for stealth injection', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [fn] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof fn).toBe('function');
+        });
+        it('navigates to the provided URL with networkidle2 and timeout', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://target-site.com/page',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.goto).toHaveBeenCalledWith('https://target-site.com/page', {
+                waitUntil: 'networkidle2',
+                timeout: 30000,
+            });
+        });
+    });
+    describe('data extraction', () => {
+        it('passes all detected paths concatenated to page.evaluate', async () => {
+            const detected = {
+                window: ['window.innerWidth', 'window.outerWidth'],
+                document: ['document.title'],
+                navigator: ['navigator.userAgent'],
+                location: ['location.href'],
+                screen: ['screen.width'],
+                other: ['custom.prop'],
+            };
+            const page = createPage({
+                'window.innerWidth': 1920,
+                'window.outerWidth': 1920,
+                'document.title': 'Test',
+                'navigator.userAgent': 'Mozilla',
+                'location.href': 'https://test.com',
+                'screen.width': 1920,
+                'custom.prop': 'value',
+            });
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected,
+                depth: 3,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.evaluate).toHaveBeenCalledTimes(1);
+            const evaluateArgs = page.evaluate.mock.calls[0];
+            expect(evaluateArgs[1]).toEqual([
+                'window.innerWidth',
+                'window.outerWidth',
+                'document.title',
+                'navigator.userAgent',
+                'location.href',
+                'screen.width',
+                'custom.prop',
+            ]);
+            expect(evaluateArgs[2]).toBe(3);
+            expect(result.manifest['window.innerWidth']).toBe(1920);
+            expect(result.manifest['document.title']).toBe('Test');
+            expect(result.manifest['custom.prop']).toBe('value');
+        });
+        it('handles empty detected arrays gracefully', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.evaluate).toHaveBeenCalledTimes(1);
+            const evaluateArgs = page.evaluate.mock.calls[0];
+            expect(evaluateArgs[1]).toEqual([]);
+            expect(result.manifest).toEqual({});
+        });
+        it('merges extracted values into manifest object', async () => {
+            const page = createPage({
+                'window.innerWidth': 1920,
+                'navigator.userAgent': 'Chrome',
+                'screen.width': 2560,
+            });
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 2,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(result.manifest).toEqual({
+                'window.innerWidth': 1920,
+                'navigator.userAgent': 'Chrome',
+                'screen.width': 2560,
+            });
+        });
+        it('returns the browser reference in the result', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(result.browser).toBe(browser);
+        });
+    });
+    describe('error handling', () => {
+        it('falls back to template manifest when page.goto fails', async () => {
+            const page = createPage({});
+            page.goto.mockRejectedValueOnce(new Error('Navigation timeout'));
+            const browser = createBrowser(page);
+            const buildManifestFromTemplate = vi.fn(() => ({ fallbackKey: 'val' }));
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate,
+            });
+            expect(buildManifestFromTemplate).toHaveBeenCalledWith(createDetected(), 'chrome');
+            expect(result.manifest).toEqual({ fallbackKey: 'val' });
+            expect(loggerState.warn).toHaveBeenCalledWith('Variable extraction failed', expect.any(Error));
+        });
+        it('falls back to template manifest when page.evaluate throws', async () => {
+            const page = createPage({});
+            page.evaluate.mockRejectedValueOnce(new Error('evaluate error'));
+            const browser = createBrowser(page);
+            const buildManifestFromTemplate = vi.fn(() => ({ tmpl: true }));
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate,
+            });
+            expect(buildManifestFromTemplate).toHaveBeenCalledWith(createDetected(), 'chrome');
+            expect(result.manifest).toEqual({ tmpl: true });
+        });
+        it('falls back to template manifest when newPage fails', async () => {
+            const browser = {
+                newPage: vi.fn().mockRejectedValue(new Error('newPage failed')),
+            };
+            const buildManifestFromTemplate = vi.fn(() => ({ fromTemplate: true }));
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate,
+            });
+            expect(buildManifestFromTemplate).toHaveBeenCalledWith(createDetected(), 'chrome');
+            expect(result.manifest).toEqual({ fromTemplate: true });
+        });
+        it('falls back to template manifest when puppeteer.launch fails', async () => {
+            puppeteerState.launch.mockRejectedValueOnce(new Error('launch failed'));
+            const buildManifestFromTemplate = vi.fn(() => ({ launchFailed: true }));
+            const result = await fetchRealEnvironmentData({
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: () => '/usr/bin/chrome',
+                buildManifestFromTemplate,
+            });
+            expect(buildManifestFromTemplate).toHaveBeenCalledWith(createDetected(), 'chrome');
+            expect(result.manifest).toEqual({ launchFailed: true });
+        });
+    });
+    describe('page cleanup', () => {
+        it('always closes the page on success', async () => {
+            const page = createPage({ key: 'val' });
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(page.close).toHaveBeenCalledTimes(1);
+        });
+        it('closes the page even when evaluate throws', async () => {
+            const page = createPage({});
+            page.evaluate.mockRejectedValueOnce(new Error('boom'));
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(() => ({})),
+            });
+            expect(page.close).toHaveBeenCalledTimes(1);
+        });
+        it('does not throw if page.close itself fails', async () => {
+            const page = createPage({ key: 'val' });
+            page.close.mockRejectedValueOnce(new Error('close failed'));
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(result.manifest).toEqual({ key: 'val' });
+        });
+        it('does not attempt to close page when newPage fails (page is undefined)', async () => {
+            const browser = {
+                newPage: vi.fn().mockRejectedValue(new Error('newPage failed')),
+            };
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(() => ({ safe: true })),
+            });
+            expect(result.manifest).toEqual({ safe: true });
+        });
+    });
+    describe('depth parameter', () => {
+        it('passes the depth value to page.evaluate', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 5,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            const evaluateArgs = page.evaluate.mock.calls[0];
+            expect(evaluateArgs[2]).toBe(5);
+        });
+        it('works with depth 0', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 0,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(),
+            });
+            const evaluateArgs = page.evaluate.mock.calls[0];
+            expect(evaluateArgs[2]).toBe(0);
+        });
+    });
+    describe('launch args', () => {
+        it('passes security-hardened launch args when launching browser', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            puppeteerState.launch.mockResolvedValue(browser);
+            await fetchRealEnvironmentData({
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: () => '/chrome',
+                buildManifestFromTemplate: vi.fn(),
+            });
+            const launchArgs = puppeteerState.launch.mock.calls[0][0];
+            expect(launchArgs.args).toContain('--no-sandbox');
+            expect(launchArgs.args).toContain('--disable-setuid-sandbox');
+            expect(launchArgs.args).toContain('--disable-blink-features=AutomationControlled');
+            expect(launchArgs.args).toContain('--disable-extensions');
+            expect(launchArgs.args).toContain('--disable-gpu');
+            expect(launchArgs.args).toContain('--no-first-run');
+            expect(launchArgs.args).toContain('--no-zygote');
+        });
+    });
+    describe('returned browser reference', () => {
+        it('returns newly-launched browser when none was provided', async () => {
+            const page = createPage({});
+            const browser = createBrowser(page);
+            puppeteerState.launch.mockResolvedValue(browser);
+            const result = await fetchRealEnvironmentData({
+                url: 'https://example.com',
+                detected: createEmptyDetected(),
+                depth: 1,
+                resolveExecutablePath: () => undefined,
+                buildManifestFromTemplate: vi.fn(),
+            });
+            expect(result.browser).toBe(browser);
+        });
+        it('returns provided browser in error fallback path', async () => {
+            const page = createPage({});
+            page.goto.mockRejectedValueOnce(new Error('nav error'));
+            const browser = createBrowser(page);
+            const result = await fetchRealEnvironmentData({
+                browser: browser,
+                url: 'https://example.com',
+                detected: createDetected(),
+                depth: 1,
+                resolveExecutablePath: vi.fn(),
+                buildManifestFromTemplate: vi.fn(() => ({})),
+            });
+            expect(result.browser).toBe(browser);
+        });
+    });
+});

package/dist/tests/modules/emulator/EnvironmentEmulatorFetch.test.d.ts

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

package/dist/tests/modules/emulator/EnvironmentEmulatorFetch.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
+}));
+const puppeteerState = vi.hoisted(() => ({
+    launch: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('rebrowser-puppeteer-core', () => ({
+    default: {
+        launch: puppeteerState.launch,
+    },
+}));
+import { fetchRealEnvironmentData } from '../../../src/modules/emulator/EnvironmentEmulatorFetch.js';
+function createDetected() {
+    return {
+        window: ['window.innerWidth'],
+        document: ['document.title'],
+        navigator: ['navigator.userAgent'],
+        location: [],
+        screen: [],
+        other: [],
+    };
+}
+function createPage(extractedValues) {
+    return {
+        setUserAgent: vi.fn().mockResolvedValue(undefined),
+        evaluateOnNewDocument: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(extractedValues),
+        close: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function createBrowser(page) {
+    return {
+        newPage: vi.fn().mockResolvedValue(page),
+    };
+}
+describe('EnvironmentEmulatorFetch', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        Object.values(loggerState).forEach((fn) => fn.mockReset());
+        puppeteerState.launch.mockReset();
+    });
+    it('launches a browser when none is provided and merges extracted values into the manifest', async () => {
+        const page = createPage({
+            'window.innerWidth': 1920,
+            'document.title': 'Example',
+        });
+        const browser = createBrowser(page);
+        const resolveExecutablePath = vi.fn(() => 'C:/Browsers/chrome.exe');
+        const buildManifestFromTemplate = vi.fn();
+        puppeteerState.launch.mockResolvedValue(browser);
+        const result = await fetchRealEnvironmentData({
+            url: 'https://example.com',
+            detected: createDetected(),
+            depth: 2,
+            resolveExecutablePath,
+            buildManifestFromTemplate,
+        });
+        expect(resolveExecutablePath).toHaveBeenCalledTimes(1);
+        expect(puppeteerState.launch).toHaveBeenCalledWith(expect.objectContaining({
+            headless: true,
+            executablePath: 'C:/Browsers/chrome.exe',
+        }));
+        expect(browser.newPage).toHaveBeenCalledTimes(1);
+        expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Chrome/120.0.0.0'));
+        expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+        expect(page.goto).toHaveBeenCalledWith('https://example.com', {
+            waitUntil: 'networkidle2',
+            timeout: 30000,
+        });
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(buildManifestFromTemplate).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            manifest: {
+                'window.innerWidth': 1920,
+                'document.title': 'Example',
+            },
+            browser,
+        });
+    });
+    it('reuses a provided browser without launching a new one', async () => {
+        const page = createPage({
+            'navigator.userAgent': 'Mozilla/5.0',
+        });
+        const browser = createBrowser(page);
+        const result = await fetchRealEnvironmentData({
+            browser: browser,
+            url: 'https://example.com',
+            detected: createDetected(),
+            depth: 1,
+            resolveExecutablePath: vi.fn(() => 'ignored'),
+            buildManifestFromTemplate: vi.fn(() => ({ fallback: true })),
+        });
+        expect(puppeteerState.launch).not.toHaveBeenCalled();
+        expect(browser.newPage).toHaveBeenCalledTimes(1);
+        expect(result.browser).toBe(browser);
+        expect(result.manifest).toEqual({
+            'navigator.userAgent': 'Mozilla/5.0',
+        });
+    });
+    it('falls back to the template manifest when extraction fails and still closes the page', async () => {
+        const page = createPage({});
+        page.evaluate.mockRejectedValueOnce(new Error('evaluate failed'));
+        const browser = createBrowser(page);
+        const buildManifestFromTemplate = vi.fn(() => ({ fallback: true }));
+        const result = await fetchRealEnvironmentData({
+            browser: browser,
+            url: 'https://example.com',
+            detected: createDetected(),
+            depth: 1,
+            resolveExecutablePath: vi.fn(),
+            buildManifestFromTemplate,
+        });
+        expect(buildManifestFromTemplate).toHaveBeenCalledWith(createDetected(), 'chrome');
+        expect(page.close).toHaveBeenCalledTimes(1);
+        expect(loggerState.warn).toHaveBeenCalledWith('Variable extraction failed', expect.any(Error));
+        expect(result).toEqual({
+            manifest: { fallback: true },
+            browser,
+        });
+    });
+});

package/dist/tests/modules/emulator/chrome-env.test.d.ts

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