@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/tests/modules/monitor/PerformanceMonitor.test.js

@@ -0,0 +1,204 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
+}));
+const writeState = vi.hoisted(() => ({
+    writeFile: vi.fn(async () => undefined),
+}));
+const cdpState = vi.hoisted(() => ({
+    cdpLimit: vi.fn(async (fn) => fn()),
+}));
+const artifactState = vi.hoisted(() => ({
+    resolveArtifactPath: vi.fn(async () => ({
+        absolutePath: '/tmp/artifact.json',
+        displayPath: 'tmp/artifact.json',
+    })),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('node:fs/promises', () => ({
+    writeFile: writeState.writeFile,
+}));
+vi.mock('@src/utils/concurrency', () => ({
+    cdpLimit: cdpState.cdpLimit,
+}));
+vi.mock('@src/utils/artifacts', () => ({
+    resolveArtifactPath: artifactState.resolveArtifactPath,
+}));
+import { PerformanceMonitor } from '../../../src/modules/monitor/PerformanceMonitor.js';
+function createSession(sendImpl) {
+    const listeners = new Map();
+    const emit = (event, payload) => {
+        listeners.get(event)?.forEach((handler) => handler(payload));
+    };
+    const send = vi.fn(async (method, params) => {
+        if (sendImpl)
+            return sendImpl(method, params, emit);
+        return {};
+    });
+    const on = vi.fn((event, handler) => {
+        const set = listeners.get(event) ?? new Set();
+        set.add(handler);
+        listeners.set(event, set);
+    });
+    const off = vi.fn((event, handler) => {
+        listeners.get(event)?.delete(handler);
+    });
+    const detach = vi.fn(async () => { });
+    return { session: { send, on, off, detach }, send, on, off, detach, emit };
+}
+function createCollector(session, evaluateResult) {
+    const page = {
+        createCDPSession: vi.fn(async () => session),
+        evaluate: vi.fn(async () => evaluateResult ?? {}),
+        coverage: {
+            startJSCoverage: vi.fn(async () => undefined),
+            stopJSCoverage: vi.fn(async () => [
+                {
+                    url: 'a.js',
+                    text: '01234567890123456789',
+                    ranges: [{ start: 0, end: 10 }],
+                },
+            ]),
+            startCSSCoverage: vi.fn(async () => undefined),
+            stopCSSCoverage: vi.fn(async () => []),
+        },
+        tracing: {
+            start: vi.fn(async () => undefined),
+            stop: vi.fn(async () => Buffer.from('')),
+        },
+    };
+    return { collector: { getActivePage: vi.fn(async () => page) }, page };
+}
+describe('PerformanceMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
+        writeState.writeFile.mockReset();
+        cdpState.cdpLimit.mockImplementation(async (fn) => fn());
+        artifactState.resolveArtifactPath.mockResolvedValue({
+            absolutePath: '/tmp/artifact.json',
+            displayPath: 'tmp/artifact.json',
+        });
+    });
+    it('collects page performance metrics via page.evaluate', async () => {
+        const { session } = createSession();
+        const metrics = { fcp: 111, lcp: 222, cls: 0.01, ttfb: 45 };
+        const { collector, page } = createCollector(session, metrics);
+        const monitor = new PerformanceMonitor(collector);
+        const result = await monitor.getPerformanceMetrics();
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(result).toMatchObject(metrics);
+    });
+    it('starts and stops precise coverage with computed percentages', async () => {
+        const { session } = createSession();
+        const { collector, page } = createCollector(session);
+        page.coverage.stopJSCoverage.mockResolvedValue([
+            {
+                url: 'a.js',
+                text: '01234567890123456789',
+                ranges: [{ start: 0, end: 10 }],
+            },
+        ]);
+        page.coverage.stopCSSCoverage.mockResolvedValue([]);
+        const monitor = new PerformanceMonitor(collector);
+        await monitor.startCoverage();
+        const coverage = await monitor.stopCoverage();
+        expect(page.coverage.startJSCoverage).toHaveBeenCalledWith({
+            resetOnNavigation: undefined,
+            reportAnonymousScripts: undefined,
+        });
+        expect(page.coverage.startCSSCoverage).toHaveBeenCalledWith({
+            resetOnNavigation: undefined,
+        });
+        expect(coverage[0].coveragePercentage).toBe(50);
+    });
+    it('throws when stopCoverage is called before startCoverage', async () => {
+        const { session } = createSession();
+        const { collector } = createCollector(session);
+        const monitor = new PerformanceMonitor(collector);
+        await expect(monitor.stopCoverage()).rejects.toThrow('Coverage not enabled');
+    });
+    it('starts and stops CPU profiling', async () => {
+        const profile = { nodes: [{ id: 1, callFrame: { functionName: 'fn', url: '', lineNumber: 0, columnNumber: 0 } }], startTime: 1, endTime: 2 };
+        const { session, send } = createSession((method) => {
+            if (method === 'Profiler.stop')
+                return { profile };
+            return {};
+        });
+        const { collector } = createCollector(session);
+        const monitor = new PerformanceMonitor(collector);
+        await monitor.startCPUProfiling();
+        const result = await monitor.stopCPUProfiling();
+        expect(send).toHaveBeenCalledWith('Profiler.start');
+        expect(result).toEqual(profile);
+    });
+    it('captures heap snapshot chunks and detaches listener', async () => {
+        const { session, on, off } = createSession((method, _params, emit) => {
+            if (method === 'HeapProfiler.takeHeapSnapshot') {
+                emit('HeapProfiler.addHeapSnapshotChunk', { chunk: 'partA' });
+                emit('HeapProfiler.addHeapSnapshotChunk', { chunk: 'partB' });
+            }
+            return {};
+        });
+        const { collector } = createCollector(session);
+        const monitor = new PerformanceMonitor(collector);
+        const snapshot = await monitor.takeHeapSnapshot();
+        expect(snapshot).toBe('partApartB');
+        expect(on).toHaveBeenCalledWith('HeapProfiler.addHeapSnapshotChunk', expect.any(Function));
+        expect(off).toHaveBeenCalledWith('HeapProfiler.addHeapSnapshotChunk', expect.any(Function));
+    });
+    it('stops tracing, reads stream and saves artifact', async () => {
+        const { session } = createSession();
+        const { collector, page } = createCollector(session);
+        page.tracing.stop.mockResolvedValue(Buffer.from('{"traceEvents":[{"ph":"X"}]}'));
+        const monitor = new PerformanceMonitor(collector);
+        await monitor.startTracing();
+        const result = await monitor.stopTracing({ artifactPath: '/tmp/custom-trace.json' });
+        expect(page.tracing.start).toHaveBeenCalledWith(expect.objectContaining({
+            categories: expect.any(Array),
+        }));
+        expect(writeState.writeFile).toHaveBeenCalledWith('/tmp/custom-trace.json', expect.any(String), 'utf-8');
+        expect(result.eventCount).toBe(1);
+    });
+    it('counts trace events without parsing the full trace payload', async () => {
+        const parseSpy = vi.spyOn(JSON, 'parse');
+        const { session } = createSession();
+        const { collector, page } = createCollector(session);
+        page.tracing.stop.mockResolvedValue(Buffer.from('{"traceEvents":[{"ph":"B"},{"ph":"E"}]}'));
+        const monitor = new PerformanceMonitor(collector);
+        await monitor.startTracing();
+        const result = await monitor.stopTracing({ artifactPath: '/tmp/compact-trace.json' });
+        expect(result.eventCount).toBe(2);
+        expect(parseSpy).not.toHaveBeenCalled();
+    });
+    it('collects heap sampling profile and returns top allocations', async () => {
+        const profile = {
+            head: {
+                callFrame: { functionName: 'root', url: '', lineNumber: 0, columnNumber: 0 },
+                selfSize: 0,
+                children: [
+                    { callFrame: { functionName: 'heavy', url: 'a.js', lineNumber: 1, columnNumber: 1 }, selfSize: 500 },
+                    { callFrame: { functionName: 'light', url: 'b.js', lineNumber: 1, columnNumber: 1 }, selfSize: 50 },
+                ],
+            },
+        };
+        const { session } = createSession((method) => {
+            if (method === 'HeapProfiler.stopSampling')
+                return { profile };
+            return {};
+        });
+        const { collector } = createCollector(session);
+        const monitor = new PerformanceMonitor(collector);
+        await monitor.startHeapSampling({ samplingInterval: 1024 });
+        const result = await monitor.stopHeapSampling({ artifactPath: '/tmp/heap.json', topN: 1 });
+        expect(result.topAllocations).toHaveLength(1);
+        expect(result.topAllocations[0].functionName).toBe('heavy');
+        expect(writeState.writeFile).toHaveBeenCalledWith('/tmp/heap.json', expect.any(String), 'utf-8');
+    });
+});

package/dist/tests/modules/monitor/PlaywrightNetworkMonitor.test.d.ts

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

package/dist/tests/modules/monitor/PlaywrightNetworkMonitor.test.js

@@ -0,0 +1,138 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+import { PlaywrightNetworkMonitor } from '../../../src/modules/monitor/PlaywrightNetworkMonitor.js';
+function createPage() {
+    const handlers = {};
+    const evaluateMock = vi.fn(async () => []);
+    return {
+        handlers,
+        on: vi.fn((event, handler) => {
+            handlers[event] = handler;
+        }),
+        off: vi.fn((event) => {
+            delete handlers[event];
+        }),
+        evaluate: evaluateMock,
+    };
+}
+function makeRequest(url, method = 'GET', resourceType = 'xhr', postData) {
+    return {
+        url: () => url,
+        method: () => method,
+        headers: () => ({ authorization: 'Bearer x' }),
+        postData: () => postData ?? null,
+        resourceType: () => resourceType,
+    };
+}
+function makeResponse(req, url, status = 200) {
+    return {
+        request: () => req,
+        url: () => url,
+        status: () => status,
+        statusText: () => 'OK',
+        headers: () => ({ 'content-type': 'application/json' }),
+    };
+}
+describe('PlaywrightNetworkMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
+    });
+    it('enables listeners and captures correlated request/response records', async () => {
+        const page = createPage();
+        const monitor = new PlaywrightNetworkMonitor(page);
+        await monitor.enable();
+        const req = makeRequest('https://api.test/user?id=1', 'POST', 'xhr', '{"x":1}');
+        page.handlers['request'](req);
+        page.handlers['response'](makeResponse(req, 'https://api.test/user?id=1', 201));
+        const requests = monitor.getRequests();
+        const responses = monitor.getResponses();
+        expect(monitor.isEnabled()).toBe(true);
+        expect(requests).toHaveLength(1);
+        expect(responses).toHaveLength(1);
+        expect(responses[0].requestId).toBe(requests[0].requestId);
+    });
+    it('supports request/response filtering and activity lookup', async () => {
+        const page = createPage();
+        const monitor = new PlaywrightNetworkMonitor(page);
+        await monitor.enable();
+        const req1 = makeRequest('https://api.test/a', 'GET', 'xhr');
+        const req2 = makeRequest('https://api.test/b', 'PUT', 'fetch');
+        page.handlers['request'](req1);
+        page.handlers['request'](req2);
+        page.handlers['response'](makeResponse(req1, 'https://api.test/a', 200));
+        page.handlers['response'](makeResponse(req2, 'https://api.test/b', 404));
+        const onlyPut = monitor.getRequests({ method: 'PUT' });
+        const only404 = monitor.getResponses({ status: 404 });
+        const activity = monitor.getActivity(onlyPut[0].requestId);
+        expect(onlyPut).toHaveLength(1);
+        expect(only404).toHaveLength(1);
+        expect(activity.request?.method).toBe('PUT');
+        expect(activity.response?.status).toBe(404);
+    });
+    it('computes method/status/type statistics', async () => {
+        const page = createPage();
+        const monitor = new PlaywrightNetworkMonitor(page);
+        await monitor.enable();
+        const req = makeRequest('https://api.test/a', 'GET', 'script');
+        page.handlers['request'](req);
+        page.handlers['response'](makeResponse(req, 'https://api.test/a', 200));
+        const stats = monitor.getStats();
+        expect(stats.byMethod.GET).toBe(1);
+        expect(stats.byStatus[200]).toBe(1);
+        expect(stats.byType.script).toBe(1);
+    });
+    it('disables listeners and clears state', async () => {
+        const page = createPage();
+        const monitor = new PlaywrightNetworkMonitor(page);
+        await monitor.enable();
+        await monitor.disable();
+        monitor.clearRecords();
+        expect(monitor.isEnabled()).toBe(false);
+        expect(page.off).toHaveBeenCalledTimes(2);
+        expect(monitor.getStatus().requestCount).toBe(0);
+    });
+    it('injects fetch/xhr interceptors and reads injected buffers', async () => {
+        const page = createPage();
+        page.evaluate
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce([{ id: 'xhr-1' }])
+            .mockResolvedValueOnce([{ id: 'fetch-1' }])
+            .mockResolvedValueOnce({ xhrCleared: 2, fetchCleared: 3 })
+            .mockResolvedValueOnce({ xhrReset: true, fetchReset: true });
+        const monitor = new PlaywrightNetworkMonitor(page);
+        await monitor.injectXHRInterceptor();
+        await monitor.injectFetchInterceptor();
+        const xhr = await monitor.getXHRRequests();
+        const fetch = await monitor.getFetchRequests();
+        const cleared = await monitor.clearInjectedBuffers();
+        const reset = await monitor.resetInjectedInterceptors();
+        expect(page.evaluate).toHaveBeenCalledTimes(6);
+        expect(xhr).toEqual([{ id: 'xhr-1' }]);
+        expect(fetch).toEqual([{ id: 'fetch-1' }]);
+        expect(cleared).toEqual({ xhrCleared: 2, fetchCleared: 3 });
+        expect(reset).toEqual({ xhrReset: true, fetchReset: true });
+    });
+    it('returns safe defaults when injected buffer operations fail', async () => {
+        const page = createPage();
+        page.evaluate.mockRejectedValue(new Error('page gone'));
+        const monitor = new PlaywrightNetworkMonitor(page);
+        expect(await monitor.getXHRRequests()).toEqual([]);
+        expect(await monitor.getFetchRequests()).toEqual([]);
+        expect(await monitor.clearInjectedBuffers()).toEqual({ xhrCleared: 0, fetchCleared: 0 });
+        expect(await monitor.resetInjectedInterceptors()).toEqual({
+            xhrReset: false,
+            fetchReset: false,
+        });
+    });
+});

package/dist/tests/modules/process/BaseMemoryManager.test.d.ts

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

package/dist/tests/modules/process/BaseMemoryManager.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { BaseMemoryManager } from '../../../src/modules/process/BaseMemoryManager.js';
+class TestMemoryManager extends BaseMemoryManager {
+    platform = 'test';
+    readMemory(_pid, _address, _size) {
+        return Promise.resolve({ success: true, data: '' });
+    }
+    writeMemory(_pid, _address, _data) {
+        return Promise.resolve({ success: true, bytesWritten: 0 });
+    }
+    scanMemory(_pid, _pattern, _patternType) {
+        return Promise.resolve({ success: true, addresses: [] });
+    }
+    checkMemoryProtection(_pid, _address) {
+        return Promise.resolve({ success: true, isReadable: true });
+    }
+    enumerateRegions(_pid) {
+        return Promise.resolve({ success: true, regions: [] });
+    }
+    enumerateModules(_pid) {
+        return Promise.resolve({ success: true, modules: [] });
+    }
+    dumpMemoryRegion(_pid, _address, _size, _outputPath) {
+        return Promise.resolve({ success: true });
+    }
+    injectDll(_pid, _dllPath) {
+        return Promise.resolve({ success: true, remoteThreadId: 1 });
+    }
+    injectShellcode(_pid, _shellcode) {
+        return Promise.resolve({ success: true, remoteThreadId: 1 });
+    }
+    checkDebugPort(_pid) {
+        return Promise.resolve({ success: true, isDebugged: false });
+    }
+    checkAvailability() {
+        return Promise.resolve({ available: true });
+    }
+    convert(pattern, type) {
+        return this.convertPatternToBytes(pattern, type);
+    }
+}
+describe('BaseMemoryManager', () => {
+    it('converts hex pattern with wildcard bytes', () => {
+        const mgr = new TestMemoryManager();
+        const result = mgr.convert('AA ?? BB', 'hex');
+        expect(result.bytes).toEqual([0xaa, 0x00, 0xbb]);
+        expect(result.mask).toEqual([1, 0, 1]);
+    });
+    it('converts int32 pattern in little-endian form', () => {
+        const mgr = new TestMemoryManager();
+        const result = mgr.convert('305419896', 'int32');
+        expect(result.bytes).toEqual([0x78, 0x56, 0x34, 0x12]);
+        expect(result.mask).toEqual([1, 1, 1, 1]);
+    });
+    it('converts int64 pattern to 8 bytes', () => {
+        const mgr = new TestMemoryManager();
+        const result = mgr.convert('1', 'int64');
+        expect(result.bytes.length).toBe(8);
+        expect(result.mask.length).toBe(8);
+        expect(result.bytes[0]).toBe(1);
+    });
+    it('converts float and double patterns to expected byte sizes', () => {
+        const mgr = new TestMemoryManager();
+        const floatResult = mgr.convert('3.5', 'float');
+        const doubleResult = mgr.convert('3.5', 'double');
+        expect(floatResult.bytes.length).toBe(4);
+        expect(doubleResult.bytes.length).toBe(8);
+    });
+    it('converts utf8 string pattern with full mask', () => {
+        const mgr = new TestMemoryManager();
+        const result = mgr.convert('ABC', 'string');
+        expect(result.bytes).toEqual([65, 66, 67]);
+        expect(result.mask).toEqual([1, 1, 1]);
+    });
+    it('returns empty arrays for invalid numeric patterns', () => {
+        const mgr = new TestMemoryManager();
+        const result = mgr.convert('not-a-number', 'int32');
+        expect(result.bytes).toEqual([]);
+        expect(result.mask).toEqual([]);
+    });
+});

package/dist/tests/modules/process/LinuxProcessManager.test.d.ts

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

package/dist/tests/modules/process/LinuxProcessManager.test.js

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+const state = vi.hoisted(() => {
+    const execAsync = vi.fn();
+    const promisify = vi.fn(() => execAsync);
+    const spawn = vi.fn();
+    return { execAsync, promisify, spawn };
+});
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+    spawn: state.spawn,
+}));
+vi.mock('util', () => ({
+    promisify: state.promisify,
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+import { LinuxProcessManager } from '../../../src/modules/process/LinuxProcessManager.js';
+function setupExecByCommand(map) {
+    state.execAsync.mockImplementation(async (cmd) => {
+        for (const [key, value] of Object.entries(map)) {
+            if (cmd.includes(key))
+                return { stdout: value.stdout, stderr: value.stderr ?? '' };
+        }
+        return { stdout: '', stderr: '' };
+    });
+}
+describe('LinuxProcessManager', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('parses processes from ps output', async () => {
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+            'ps aux': {
+                stdout: 'user 123 1.0 2.0 0 0 ? S 00:00 00:00 /usr/bin/browser-bin --flag\n',
+            },
+        });
+        const manager = new LinuxProcessManager();
+        const list = await manager.findProcesses('browse"r-bin`');
+        expect(list).toHaveLength(1);
+        expect(list[0]?.pid).toBe(123);
+        expect(list[0]?.name).toContain('/usr/bin/browser-bin');
+    });
+    it('getProcessByPid parses /proc status/cmdline/stat data', async () => {
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+            '/status': { stdout: 'Name:\tbrowser-bin\nPPid:\t1\nVmRSS:\t2048 kB\n' },
+            '/cmdline': { stdout: '/usr/bin/browser-bin --remote-debugging-port=9222 ' },
+            '/stat': { stdout: '0 0 0 0 0 0 0 0 0 0 0 0 0 10 20' },
+            'readlink -f /proc/123/exe': { stdout: '/usr/bin/browser-bin\n' },
+        });
+        const manager = new LinuxProcessManager();
+        const proc = await manager.getProcessByPid(123);
+        expect(proc?.name).toBe('browser-bin');
+        expect(proc?.parentPid).toBe(1);
+        expect(proc?.memoryUsage).toBe(2048 * 1024);
+        expect(proc?.cpuUsage).toBe(30);
+        expect(proc?.executablePath).toBe('/usr/bin/browser-bin');
+    });
+    it('returns empty windows list under Wayland mode', async () => {
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'wayland\n' },
+        });
+        const manager = new LinuxProcessManager();
+        manager.isWayland = true;
+        const windows = await manager.getProcessWindows(100);
+        expect(windows).toEqual([]);
+    });
+    it('checkDebugPort prefers command-line argument', async () => {
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+        });
+        const manager = new LinuxProcessManager();
+        vi.spyOn(manager, 'getProcessCommandLine').mockResolvedValue({
+            commandLine: '--remote-debugging-port=9333',
+        });
+        const port = await manager.checkDebugPort(200);
+        expect(port).toBe(9333);
+    });
+    it('launchWithDebug spawns process and returns resolved process info', async () => {
+        vi.useFakeTimers();
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+        });
+        const child = new EventEmitter();
+        child.pid = 444;
+        child.unref = vi.fn();
+        state.spawn.mockReturnValue(child);
+        const manager = new LinuxProcessManager();
+        vi.spyOn(manager, 'getProcessByPid').mockResolvedValue({
+            pid: 444,
+            name: 'browser-bin',
+            executablePath: '/usr/bin/browser-bin',
+        });
+        const pending = manager.launchWithDebug('/usr/bin/browser-bin', 9222, ['--foo']);
+        await vi.runAllTimersAsync();
+        const result = await pending;
+        expect(state.spawn).toHaveBeenCalledWith('/usr/bin/browser-bin', ['--remote-debugging-port=9222', '--foo'], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        expect(result?.pid).toBe(444);
+        vi.useRealTimers();
+    });
+    it('killProcess rejects invalid pid', async () => {
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+        });
+        const manager = new LinuxProcessManager();
+        const ok = await manager.killProcess(-1);
+        expect(ok).toBe(false);
+    });
+    it('launchWithDebug returns null when spawn returns undefined PID', async () => {
+        vi.useFakeTimers();
+        setupExecByCommand({
+            'echo $XDG_SESSION_TYPE': { stdout: 'x11\n' },
+        });
+        const child = new EventEmitter();
+        child.pid = undefined;
+        child.unref = vi.fn();
+        state.spawn.mockReturnValue(child);
+        const manager = new LinuxProcessManager();
+        const pending = manager.launchWithDebug('/usr/bin/browser-bin', 9222);
+        await vi.runAllTimersAsync();
+        const result = await pending;
+        expect(result).toBeNull();
+        vi.useRealTimers();
+    });
+});

package/dist/tests/modules/process/MacProcessManager.test.d.ts

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