@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/modules/process/process-index.test.js

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    WindowsProcessManager: vi.fn(),
+    LinuxProcessManager: vi.fn(),
+    MacProcessManager: vi.fn(),
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('@modules/process/ProcessManager', () => ({
+    ProcessManager: mocks.WindowsProcessManager,
+    DEFAULT_CHROMIUM_CONFIG: { processNamePattern: 'chrome' },
+}));
+vi.mock('@modules/process/LinuxProcessManager', () => ({
+    LinuxProcessManager: mocks.LinuxProcessManager,
+}));
+vi.mock('@modules/process/MacProcessManager', () => ({
+    MacProcessManager: mocks.MacProcessManager,
+}));
+vi.mock('@modules/process/MemoryManager', () => ({
+    MemoryManager: vi.fn(),
+}));
+vi.mock('@modules/process/memoryUtils', () => ({
+    scanMemory: vi.fn(),
+    dumpMemory: vi.fn(),
+    listMemoryRegions: vi.fn(),
+    checkProtection: vi.fn(),
+    scanFiltered: vi.fn(),
+    batchWrite: vi.fn(),
+    startMonitor: vi.fn(),
+    stopMonitor: vi.fn(),
+    injectDll: vi.fn(),
+    injectShellcode: vi.fn(),
+    checkDebugPort: vi.fn(),
+    enumerateModules: vi.fn(),
+}));
+vi.mock('@utils/logger', () => ({
+    logger: mocks.logger,
+}));
+describe('modules/process/index', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    describe('detectPlatform', () => {
+        it('returns win32 on Windows', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const { detectPlatform } = await import('../../../src/modules/process/index.js');
+            expect(detectPlatform()).toBe('win32');
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('returns linux on Linux', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            const { detectPlatform } = await import('../../../src/modules/process/index.js');
+            expect(detectPlatform()).toBe('linux');
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('returns darwin on macOS', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+            const { detectPlatform } = await import('../../../src/modules/process/index.js');
+            expect(detectPlatform()).toBe('darwin');
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('returns unknown for unsupported platforms', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'freebsd', configurable: true });
+            const { detectPlatform } = await import('../../../src/modules/process/index.js');
+            expect(detectPlatform()).toBe('unknown');
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+    });
+    describe('createProcessManager', () => {
+        it('creates WindowsProcessManager on win32', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const { createProcessManager } = await import('../../../src/modules/process/index.js');
+            createProcessManager();
+            expect(mocks.WindowsProcessManager).toHaveBeenCalled();
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('creates LinuxProcessManager on linux', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            mocks.LinuxProcessManager.mockImplementation(function () { });
+            const { createProcessManager } = await import('../../../src/modules/process/index.js');
+            createProcessManager();
+            expect(mocks.LinuxProcessManager).toHaveBeenCalled();
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('creates MacProcessManager on darwin', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+            mocks.MacProcessManager.mockImplementation(function () { });
+            const { createProcessManager } = await import('../../../src/modules/process/index.js');
+            createProcessManager();
+            expect(mocks.MacProcessManager).toHaveBeenCalled();
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('throws on unsupported platform', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'freebsd', configurable: true });
+            const { createProcessManager } = await import('../../../src/modules/process/index.js');
+            expect(() => createProcessManager()).toThrow('Unsupported platform');
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+    });
+    describe('isProcessManagementSupported', () => {
+        it('returns true on supported platforms', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const { isProcessManagementSupported } = await import('../../../src/modules/process/index.js');
+            expect(isProcessManagementSupported()).toBe(true);
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('returns false on unsupported platforms', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'freebsd', configurable: true });
+            const { isProcessManagementSupported } = await import('../../../src/modules/process/index.js');
+            expect(isProcessManagementSupported()).toBe(false);
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+    });
+    describe('UnifiedProcessManager', () => {
+        it('initializes with current platform manager', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const mockFindProcesses = vi.fn().mockResolvedValue([]);
+            const mockGetProcessByPid = vi.fn().mockResolvedValue(null);
+            const mockGetProcessWindows = vi.fn().mockResolvedValue([]);
+            const mockCheckDebugPort = vi.fn().mockResolvedValue(null);
+            const mockLaunchWithDebug = vi.fn().mockResolvedValue({});
+            const mockKillProcess = vi.fn().mockResolvedValue(true);
+            const mockGetProcessCommandLine = vi.fn().mockResolvedValue('');
+            const mockFindChromiumAppProcesses = vi.fn().mockResolvedValue([]);
+            const mockFindChromiumProcesses = vi.fn().mockResolvedValue([]);
+            mocks.WindowsProcessManager.mockImplementation(function () {
+                this.findProcesses = mockFindProcesses;
+                this.getProcessByPid = mockGetProcessByPid;
+                this.getProcessWindows = mockGetProcessWindows;
+                this.checkDebugPort = mockCheckDebugPort;
+                this.launchWithDebug = mockLaunchWithDebug;
+                this.killProcess = mockKillProcess;
+                this.getProcessCommandLine = mockGetProcessCommandLine;
+                this.findChromiumAppProcesses = mockFindChromiumAppProcesses;
+                this.findChromiumProcesses = mockFindChromiumProcesses;
+            });
+            const { UnifiedProcessManager } = await import('../../../src/modules/process/index.js');
+            const upm = new UnifiedProcessManager();
+            expect(upm.getPlatform()).toBe('win32');
+            await upm.findProcesses('test');
+            expect(mockFindProcesses).toHaveBeenCalledWith('test');
+            await upm.getProcessByPid(1234);
+            expect(mockGetProcessByPid).toHaveBeenCalledWith(1234);
+            await upm.getProcessWindows(1234);
+            expect(mockGetProcessWindows).toHaveBeenCalledWith(1234);
+            await upm.checkDebugPort(1234, { commandLine: 'test' });
+            expect(mockCheckDebugPort).toHaveBeenCalledWith(1234, { commandLine: 'test' });
+            await upm.launchWithDebug('/path/to/exe', 9222, ['--arg']);
+            expect(mockLaunchWithDebug).toHaveBeenCalledWith('/path/to/exe', 9222, ['--arg']);
+            await upm.killProcess(1234);
+            expect(mockKillProcess).toHaveBeenCalledWith(1234);
+            await upm.getProcessCommandLine(1234);
+            expect(mockGetProcessCommandLine).toHaveBeenCalledWith(1234);
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('findBrowserProcesses uses Windows-specific methods on win32', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const mockFindChromiumAppProcesses = vi.fn().mockResolvedValue([{ pid: 1 }]);
+            const mockFindChromiumProcesses = vi.fn().mockResolvedValue([{ pid: 2 }]);
+            mocks.WindowsProcessManager.mockImplementation(function () {
+                this.findProcesses = vi.fn();
+                this.getProcessByPid = vi.fn();
+                this.getProcessWindows = vi.fn();
+                this.checkDebugPort = vi.fn();
+                this.launchWithDebug = vi.fn();
+                this.killProcess = vi.fn();
+                this.getProcessCommandLine = vi.fn();
+                this.findChromiumAppProcesses = mockFindChromiumAppProcesses;
+                this.findChromiumProcesses = mockFindChromiumProcesses;
+            });
+            const { UnifiedProcessManager } = await import('../../../src/modules/process/index.js');
+            const upm = new UnifiedProcessManager();
+            await upm.findBrowserProcesses();
+            expect(mockFindChromiumAppProcesses).toHaveBeenCalled();
+            await upm.findBrowserProcesses({ processNamePattern: 'chrome' });
+            expect(mockFindChromiumProcesses).toHaveBeenCalledWith({
+                processNamePattern: 'chrome',
+                windowClassPattern: undefined,
+            });
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+        it('findBrowserProcesses uses Linux-specific methods on linux', async () => {
+            const originalPlatform = process.platform;
+            Object.defineProperty(process, 'platform', { value: 'linux', configurable: true });
+            const mockFindChromeProcesses = vi.fn().mockResolvedValue([]);
+            mocks.LinuxProcessManager.mockImplementation(function () {
+                this.findProcesses = vi.fn();
+                this.getProcessByPid = vi.fn();
+                this.getProcessWindows = vi.fn();
+                this.checkDebugPort = vi.fn();
+                this.launchWithDebug = vi.fn();
+                this.killProcess = vi.fn();
+                this.getProcessCommandLine = vi.fn();
+                this.findChromeProcesses = mockFindChromeProcesses;
+            });
+            const { UnifiedProcessManager } = await import('../../../src/modules/process/index.js');
+            const upm = new UnifiedProcessManager();
+            await upm.findBrowserProcesses();
+            expect(mockFindChromeProcesses).toHaveBeenCalled();
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+        });
+    });
+    describe('exports', () => {
+        it('re-exports all expected symbols', async () => {
+            const mod = await import('../../../src/modules/process/index.js');
+            expect(mod.WindowsProcessManager).toBeDefined();
+            expect(mod.LinuxProcessManager).toBeDefined();
+            expect(mod.MacProcessManager).toBeDefined();
+            expect(mod.MemoryManager).toBeDefined();
+            expect(mod.DEFAULT_CHROMIUM_CONFIG).toBeDefined();
+            expect(mod.detectPlatform).toBeTypeOf('function');
+            expect(mod.createProcessManager).toBeTypeOf('function');
+            expect(mod.isProcessManagementSupported).toBeTypeOf('function');
+            expect(mod.UnifiedProcessManager).toBeTypeOf('function');
+            expect(mod.scanMemory).toBeDefined();
+            expect(mod.dumpMemory).toBeDefined();
+            expect(mod.listMemoryRegions).toBeDefined();
+            expect(mod.checkProtection).toBeDefined();
+            expect(mod.scanFiltered).toBeDefined();
+            expect(mod.batchWrite).toBeDefined();
+            expect(mod.startMonitor).toBeDefined();
+            expect(mod.stopMonitor).toBeDefined();
+            expect(mod.injectDll).toBeDefined();
+            expect(mod.injectShellcode).toBeDefined();
+            expect(mod.checkDebugPort).toBeDefined();
+            expect(mod.enumerateModules).toBeDefined();
+        });
+    });
+});

package/dist/tests/modules/stealth/StealthScripts.additional.test.d.ts

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

package/dist/tests/modules/stealth/StealthScripts.additional.test.js

@@ -0,0 +1,149 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StealthScripts } from '../../../src/modules/stealth/StealthScripts.js';
+function createPageMock() {
+    return {
+        evaluateOnNewDocument: vi.fn(async () => undefined),
+        setUserAgent: vi.fn(async () => undefined),
+    };
+}
+function resetInjectedPages() {
+    StealthScripts.injectedPages = new WeakSet();
+}
+describe('StealthScripts – additional coverage', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        resetInjectedPages();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('injectAll idempotency', () => {
+        it('skips injection when the same page is injected twice', async () => {
+            const page = createPageMock();
+            const spy = vi.spyOn(StealthScripts, 'hideWebDriver').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockChrome').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockPlugins').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixPermissions').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockCanvas').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockWebGL').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixLanguages').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockBattery').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixMediaDevices').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockNotifications').mockResolvedValue(undefined);
+            await StealthScripts.injectAll(page);
+            await StealthScripts.injectAll(page);
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+        it('injects separately for different page objects', async () => {
+            const page1 = createPageMock();
+            const page2 = createPageMock();
+            const spy = vi.spyOn(StealthScripts, 'hideWebDriver').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockChrome').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockPlugins').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixPermissions').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockCanvas').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockWebGL').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixLanguages').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockBattery').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'fixMediaDevices').mockResolvedValue(undefined);
+            vi.spyOn(StealthScripts, 'mockNotifications').mockResolvedValue(undefined);
+            await StealthScripts.injectAll(page1);
+            await StealthScripts.injectAll(page2);
+            expect(spy).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('mockChrome', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockChrome(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('mockPlugins', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockPlugins(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('mockCanvas', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockCanvas(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('mockWebGL', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockWebGL(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('fixLanguages', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.fixLanguages(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('mockBattery', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockBattery(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('mockNotifications', () => {
+        it('calls evaluateOnNewDocument with a function', async () => {
+            const page = createPageMock();
+            await StealthScripts.mockNotifications(page);
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledTimes(1);
+            const [script] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+        });
+    });
+    describe('setRealisticUserAgent', () => {
+        it('uses linux user agent and platform', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'linux');
+            expect(page.setUserAgent).toHaveBeenCalledWith(expect.stringContaining('Linux x86_64'));
+            expect(page.evaluateOnNewDocument).toHaveBeenCalledWith(expect.any(Function), 'Linux x86_64');
+        });
+        it('passes a function and platform string to evaluateOnNewDocument', async () => {
+            const page = createPageMock();
+            await StealthScripts.setRealisticUserAgent(page, 'mac');
+            const [script, platformValue] = page.evaluateOnNewDocument.mock.calls[0];
+            expect(typeof script).toBe('function');
+            expect(platformValue).toBe('MacIntel');
+        });
+    });
+    describe('getRecommendedLaunchArgs', () => {
+        it('returns an array with expected security-related flags', () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            expect(Array.isArray(args)).toBe(true);
+            expect(args.length).toBeGreaterThan(0);
+            expect(args).toContain('--disable-gpu');
+            expect(args).toContain('--disable-extensions');
+            expect(args).toContain('--mute-audio');
+            expect(args).toContain('--disable-web-security');
+            expect(args).toContain('--disable-renderer-backgrounding');
+        });
+        it('contains no duplicate entries', () => {
+            const args = StealthScripts.getRecommendedLaunchArgs();
+            expect(new Set(args).size).toBe(args.length);
+        });
+    });
+});

package/dist/tests/modules/stealth/StealthScripts.comprehensive.test.d.ts

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