@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/modules/process/ProcessManager.edge-cases.test.js

@@ -0,0 +1,529 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+vi.mock('@server/registry/index', () => ({
+    initRegistry: vi.fn(async () => { }),
+}));
+const state = vi.hoisted(() => {
+    const execAsync = vi.fn();
+    const promisify = vi.fn(() => execAsync);
+    const spawn = vi.fn();
+    const getScriptPath = vi.fn(() => 'C:/scripts/enum-windows.ps1');
+    const discoverBrowsers = vi.fn();
+    const findByWindowClass = vi.fn();
+    const findByProcessName = vi.fn();
+    const detectDebugPort = vi.fn();
+    return {
+        execAsync,
+        promisify,
+        spawn,
+        getScriptPath,
+        discoverBrowsers,
+        findByWindowClass,
+        findByProcessName,
+        detectDebugPort,
+    };
+});
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+    spawn: state.spawn,
+}));
+vi.mock('util', () => ({
+    promisify: state.promisify,
+}));
+vi.mock('@src/native/ScriptLoader', () => ({
+    ScriptLoader: class {
+        getScriptPath = state.getScriptPath;
+    },
+}));
+vi.mock('@src/modules/browser/BrowserDiscovery', () => ({
+    BrowserDiscovery: class {
+        discoverBrowsers = state.discoverBrowsers;
+        findByWindowClass = state.findByWindowClass;
+        findByProcessName = state.findByProcessName;
+        detectDebugPort = state.detectDebugPort;
+    },
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+vi.mock('@modules/process/ProcessManager.chromium', () => ({
+    findChromiumProcessesWithConfig: vi.fn().mockResolvedValue({
+        rendererProcesses: [],
+        utilityProcesses: [],
+    }),
+}));
+import { ProcessManager } from '../../../src/modules/process/ProcessManager.js';
+function createSpawnChild(pid = 9999) {
+    const child = new EventEmitter();
+    child.pid = pid;
+    child.unref = vi.fn();
+    return child;
+}
+describe('ProcessManager — edge cases', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('findProcesses', () => {
+        it('returns empty array on command execution error', async () => {
+            state.execAsync.mockRejectedValue(new Error('PowerShell not found'));
+            const manager = new ProcessManager();
+            const results = await manager.findProcesses('chrome');
+            expect(results).toEqual([]);
+        });
+        it('returns empty array for empty stdout', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '', stderr: '' });
+            const manager = new ProcessManager();
+            const results = await manager.findProcesses('chrome');
+            expect(results).toEqual([]);
+        });
+        it('returns empty array for null stdout', async () => {
+            state.execAsync.mockResolvedValue({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const results = await manager.findProcesses('chrome');
+            expect(results).toEqual([]);
+        });
+        it('handles single process object (non-array JSON)', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify({ Id: 42, ProcessName: 'single', Path: 'C:/single.exe' }),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const results = await manager.findProcesses('single');
+            expect(results).toEqual([{ pid: 42, name: 'single', executablePath: 'C:/single.exe' }]);
+        });
+        it('uses cache on second call within TTL', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify([{ Id: 1, ProcessName: 'test', Path: 'C:/test.exe' }]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            await manager.findProcesses('test');
+            await manager.findProcesses('test');
+            expect(state.execAsync).toHaveBeenCalledTimes(1);
+        });
+        it('handles empty pattern (list all processes)', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify([
+                    { Id: 1, ProcessName: 'proc1', Path: 'C:/proc1.exe' },
+                    { Id: 2, ProcessName: 'proc2', Path: 'C:/proc2.exe' },
+                ]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const results = await manager.findProcesses('');
+            expect(results).toHaveLength(2);
+            const cmd = state.execAsync.mock.calls[0]?.[0];
+            expect(cmd).not.toContain('-Name');
+        });
+        it('sanitizes dangerous characters from pattern', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '[]', stderr: '' });
+            const manager = new ProcessManager();
+            await manager.findProcesses('test`$(){}|<>');
+            const cmd = state.execAsync.mock.calls[0]?.[0];
+            expect(cmd).not.toContain('`');
+            expect(cmd).not.toContain('$');
+            expect(cmd).not.toContain('(');
+            expect(cmd).not.toContain(')');
+        });
+        it('computes diff between cache snapshots: detects added processes', async () => {
+            state.execAsync.mockResolvedValueOnce({
+                stdout: JSON.stringify([]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            await manager.findProcesses('test');
+            state.execAsync.mockResolvedValueOnce({
+                stdout: JSON.stringify([{ Id: 100, ProcessName: 'new-proc', Path: 'C:/new.exe' }]),
+                stderr: '',
+            });
+            const results = await manager.findProcesses('other-pattern');
+            expect(results).toHaveLength(1);
+        });
+    });
+    describe('getProcessByPid', () => {
+        it('returns full process info including optional fields', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify({
+                    Id: 100,
+                    ProcessName: 'chrome',
+                    Path: 'C:/chrome.exe',
+                    MainWindowTitle: 'Google Chrome',
+                    MainWindowHandle: '12345',
+                    CPU: 5.2,
+                    WorkingSet64: 104857600,
+                }),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(100);
+            expect(result).toEqual({
+                pid: 100,
+                name: 'chrome',
+                executablePath: 'C:/chrome.exe',
+                windowTitle: 'Google Chrome',
+                windowHandle: '12345',
+                cpuUsage: 5.2,
+                memoryUsage: 104857600,
+            });
+        });
+        it('returns null on error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Access denied'));
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(123);
+            expect(result).toBeNull();
+        });
+        it('returns null for empty string stdout', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '   ', stderr: '' });
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(123);
+            expect(result).toBeNull();
+        });
+        it('throws for invalid PID (zero)', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(0);
+            expect(result).toBeNull();
+        });
+        it('throws for negative PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(-5);
+            expect(result).toBeNull();
+        });
+        it('throws for NaN PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(NaN);
+            expect(result).toBeNull();
+        });
+        it('throws for Infinity PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.getProcessByPid(Infinity);
+            expect(result).toBeNull();
+        });
+    });
+    describe('getProcessWindows', () => {
+        it('returns empty array for null stdout', async () => {
+            state.execAsync.mockResolvedValue({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const windows = await manager.getProcessWindows(100);
+            expect(windows).toEqual([]);
+        });
+        it('returns empty array on error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Script not found'));
+            const manager = new ProcessManager();
+            const windows = await manager.getProcessWindows(100);
+            expect(windows).toEqual([]);
+        });
+        it('handles array of multiple windows', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify([
+                    { Handle: '0x1', Title: 'Win1', ClassName: 'Class1', ProcessId: 50 },
+                    { Handle: '0x2', Title: 'Win2', ClassName: 'Class2', ProcessId: 50 },
+                ]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const windows = await manager.getProcessWindows(50);
+            expect(windows).toHaveLength(2);
+            expect(windows[0].handle).toBe('0x1');
+            expect(windows[1].handle).toBe('0x2');
+            expect(windows[0].threadId).toBe(0);
+        });
+        it('rejects invalid PID (returns empty)', async () => {
+            const manager = new ProcessManager();
+            const windows = await manager.getProcessWindows(0);
+            expect(windows).toEqual([]);
+        });
+    });
+    describe('getProcessCommandLine', () => {
+        it('returns commandLine and parentPid on success', async () => {
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify({
+                    CommandLine: 'chrome.exe --flag=value',
+                    ParentProcessId: 4,
+                }),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const result = await manager.getProcessCommandLine(100);
+            expect(result).toEqual({
+                commandLine: 'chrome.exe --flag=value',
+                parentPid: 4,
+            });
+        });
+        it('returns empty object for null stdout', async () => {
+            state.execAsync.mockResolvedValue({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const result = await manager.getProcessCommandLine(100);
+            expect(result).toEqual({});
+        });
+        it('returns empty object on error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Access denied'));
+            const manager = new ProcessManager();
+            const result = await manager.getProcessCommandLine(100);
+            expect(result).toEqual({});
+        });
+        it('rejects invalid PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.getProcessCommandLine(-1);
+            expect(result).toEqual({});
+        });
+    });
+    describe('checkDebugPort', () => {
+        it('returns port from explicit commandLine option', async () => {
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(100, {
+                commandLine: 'app.exe --remote-debugging-port=9229',
+            });
+            expect(port).toBe(9229);
+        });
+        it('falls through to port scanning when no match in command line', async () => {
+            state.execAsync
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({ CommandLine: 'app.exe --no-debug', ParentProcessId: 4 }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify([{ LocalPort: 9222 }]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(100);
+            expect(port).toBe(9222);
+        });
+        it('returns null when no debug port found in scanning', async () => {
+            state.execAsync
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({ CommandLine: 'app.exe', ParentProcessId: 4 }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify([{ LocalPort: 80 }, { LocalPort: 443 }]),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(100);
+            expect(port).toBeNull();
+        });
+        it('returns null when port scan returns empty', async () => {
+            state.execAsync
+                .mockResolvedValueOnce({
+                stdout: JSON.stringify({ CommandLine: 'app.exe', ParentProcessId: 4 }),
+                stderr: '',
+            })
+                .mockResolvedValueOnce({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(100);
+            expect(port).toBeNull();
+        });
+        it('returns null on error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Permission denied'));
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(100);
+            expect(port).toBeNull();
+        });
+        it('rejects invalid PID', async () => {
+            const manager = new ProcessManager();
+            const port = await manager.checkDebugPort(0);
+            expect(port).toBeNull();
+        });
+    });
+    describe('killProcess', () => {
+        it('returns true on successful kill', async () => {
+            state.execAsync.mockResolvedValue({ stdout: 'Process 100 killed', stderr: '' });
+            const manager = new ProcessManager();
+            const result = await manager.killProcess(100);
+            expect(result).toBe(true);
+        });
+        it('returns false on error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Access denied'));
+            const manager = new ProcessManager();
+            const result = await manager.killProcess(100);
+            expect(result).toBe(false);
+        });
+        it('rejects negative PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.killProcess(-1);
+            expect(result).toBe(false);
+            expect(state.execAsync).not.toHaveBeenCalled();
+        });
+        it('rejects NaN PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.killProcess(NaN);
+            expect(result).toBe(false);
+            expect(state.execAsync).not.toHaveBeenCalled();
+        });
+        it('rejects Infinity PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.killProcess(Infinity);
+            expect(result).toBe(false);
+        });
+        it('truncates floating point PID', async () => {
+            state.execAsync.mockResolvedValue({ stdout: 'killed', stderr: '' });
+            const manager = new ProcessManager();
+            await manager.killProcess(99.7);
+            const cmd = state.execAsync.mock.calls[0]?.[0];
+            expect(cmd).toContain('99');
+            expect(cmd).not.toContain('99.7');
+        });
+    });
+    describe('launchWithDebug', () => {
+        it('returns null when spawn returns no PID', async () => {
+            vi.useFakeTimers();
+            const child = new EventEmitter();
+            child.pid = 0;
+            child.unref = vi.fn();
+            state.spawn.mockReturnValue(child);
+            state.execAsync.mockResolvedValue({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const pending = manager.launchWithDebug('C:/app.exe', 9222);
+            await vi.runAllTimersAsync();
+            const result = await pending;
+            expect(result).toBeNull();
+            vi.useRealTimers();
+        });
+        it('returns null on spawn error', async () => {
+            state.spawn.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            const manager = new ProcessManager();
+            const result = await manager.launchWithDebug('C:/nonexistent.exe');
+            expect(result).toBeNull();
+        });
+        it('uses default debug port when not specified', async () => {
+            vi.useFakeTimers();
+            const child = createSpawnChild(5000);
+            state.spawn.mockReturnValue(child);
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify({ OwningProcess: 5000 }),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            vi.spyOn(manager, 'getProcessByPid').mockResolvedValue({
+                pid: 5000,
+                name: 'app.exe',
+                executablePath: 'C:/app.exe',
+            });
+            const pending = manager.launchWithDebug('C:/app.exe');
+            await vi.runAllTimersAsync();
+            await pending;
+            const spawnArgs = state.spawn.mock.calls[0]?.[1];
+            expect(spawnArgs[0]).toMatch(/--remote-debugging-port=\d+/);
+            vi.useRealTimers();
+        });
+        it('passes extra arguments to spawn', async () => {
+            vi.useFakeTimers();
+            state.spawn.mockReturnValue(createSpawnChild(7000));
+            state.execAsync.mockResolvedValue({
+                stdout: JSON.stringify({ OwningProcess: 7000 }),
+                stderr: '',
+            });
+            const manager = new ProcessManager();
+            vi.spyOn(manager, 'getProcessByPid').mockResolvedValue({
+                pid: 7000,
+                name: 'app.exe',
+                executablePath: 'C:/app.exe',
+            });
+            const pending = manager.launchWithDebug('C:/app.exe', 9222, ['--incognito', '--headless']);
+            await vi.runAllTimersAsync();
+            await pending;
+            const spawnArgs = state.spawn.mock.calls[0]?.[1];
+            expect(spawnArgs).toContain('--incognito');
+            expect(spawnArgs).toContain('--headless');
+            vi.useRealTimers();
+        });
+        it('extracts executable name from path with backslashes', async () => {
+            vi.useFakeTimers();
+            const child = createSpawnChild(0);
+            state.spawn.mockReturnValue(child);
+            state.execAsync.mockResolvedValue({ stdout: 'null', stderr: '' });
+            const manager = new ProcessManager();
+            const pending = manager.launchWithDebug('C:\\Program Files\\app.exe', 9222);
+            await vi.runAllTimersAsync();
+            const result = await pending;
+            expect(result).toBeNull();
+            vi.useRealTimers();
+        });
+    });
+    describe('injectDll', () => {
+        it('always returns false (safety disabled)', async () => {
+            state.execAsync.mockResolvedValue({ stdout: '', stderr: '' });
+            const manager = new ProcessManager();
+            const result = await manager.injectDll(100, 'C:/hook.dll');
+            expect(result).toBe(false);
+        });
+        it('returns false for invalid PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.injectDll(0, 'C:/hook.dll');
+            expect(result).toBe(false);
+        });
+        it('returns false for negative PID', async () => {
+            const manager = new ProcessManager();
+            const result = await manager.injectDll(-5, 'C:/hook.dll');
+            expect(result).toBe(false);
+        });
+        it('returns false on execution error', async () => {
+            state.execAsync.mockRejectedValue(new Error('Script error'));
+            const manager = new ProcessManager();
+            const result = await manager.injectDll(100, 'C:/hook.dll');
+            expect(result).toBe(false);
+        });
+    });
+    describe('discoverBrowsers', () => {
+        it('returns empty array on error', async () => {
+            state.discoverBrowsers.mockRejectedValue(new Error('Discovery failed'));
+            const manager = new ProcessManager();
+            const result = await manager.discoverBrowsers();
+            expect(result).toEqual([]);
+        });
+    });
+    describe('findBrowserByWindowClass', () => {
+        it('returns empty array on error', async () => {
+            state.findByWindowClass.mockRejectedValue(new Error('Error'));
+            const manager = new ProcessManager();
+            const result = await manager.findBrowserByWindowClass('Chrome_*');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('findBrowserByProcessName', () => {
+        it('returns empty array on error', async () => {
+            state.findByProcessName.mockRejectedValue(new Error('Error'));
+            const manager = new ProcessManager();
+            const result = await manager.findBrowserByProcessName('chrome.exe');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('detectBrowserDebugPort', () => {
+        it('returns null when no debug port detected', async () => {
+            state.detectDebugPort.mockResolvedValue(null);
+            const manager = new ProcessManager();
+            const result = await manager.detectBrowserDebugPort(100);
+            expect(result).toBeNull();
+        });
+        it('passes custom ports array to discovery', async () => {
+            state.detectDebugPort.mockResolvedValue(8888);
+            const manager = new ProcessManager();
+            const customPorts = [8888, 9999];
+            const result = await manager.detectBrowserDebugPort(100, customPorts);
+            expect(result).toBe(8888);
+            expect(state.detectDebugPort).toHaveBeenCalledWith(100, customPorts);
+        });
+        it('returns null on error', async () => {
+            state.detectDebugPort.mockRejectedValue(new Error('Error'));
+            const manager = new ProcessManager();
+            const result = await manager.detectBrowserDebugPort(100);
+            expect(result).toBeNull();
+        });
+    });
+    describe('findChromiumAppProcesses', () => {
+        it('delegates to findChromiumProcesses', async () => {
+            const manager = new ProcessManager();
+            const spy = vi.spyOn(manager, 'findChromiumProcesses');
+            await manager.findChromiumAppProcesses();
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/tests/modules/process/memory/AuditTrail.test.d.ts

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

package/dist/tests/modules/process/memory/AuditTrail.test.js

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { MemoryAuditTrail } from '../../../../src/modules/process/memory/AuditTrail.js';
+describe('MemoryAuditTrail', () => {
+    let originalEnv;
+    beforeEach(() => {
+        originalEnv = {
+            USERNAME: process.env.USERNAME,
+            USER: process.env.USER,
+        };
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        process.env.USERNAME = originalEnv.USERNAME;
+        process.env.USER = originalEnv.USER;
+        vi.useRealTimers();
+    });
+    it('records entries and reports correct size', () => {
+        const trail = new MemoryAuditTrail();
+        trail.record({
+            operation: 'memory_read',
+            pid: 1234,
+            address: '0x1000',
+            size: 4,
+            result: 'success',
+            durationMs: 10,
+        });
+        expect(trail.size()).toBe(1);
+    });
+    it('exports entries as JSON', () => {
+        const trail = new MemoryAuditTrail();
+        vi.setSystemTime(new Date('2025-01-01T00:00:00Z'));
+        process.env.USERNAME = 'testuser';
+        trail.record({
+            operation: 'memory_write',
+            pid: 5678,
+            address: '0x2000',
+            size: 8,
+            result: 'success',
+            durationMs: 5,
+        });
+        const exported = JSON.parse(trail.exportJson());
+        expect(exported).toHaveLength(1);
+        expect(exported[0]).toMatchObject({
+            operation: 'memory_write',
+            pid: 5678,
+            address: '0x2000',
+            size: 8,
+            result: 'success',
+            durationMs: 5,
+            timestamp: '2025-01-01T00:00:00.000Z',
+            user: 'testuser',
+        });
+    });
+    it('records optional fields like pattern and dllPath', () => {
+        const trail = new MemoryAuditTrail();
+        trail.record({
+            operation: 'memory_scan',
+            pid: 100,
+            address: null,
+            size: null,
+            result: 'success',
+            durationMs: 50,
+            pattern: 'AA BB CC',
+            resultsCount: 3,
+        });
+        trail.record({
+            operation: 'inject_dll',
+            pid: 200,
+            address: null,
+            size: null,
+            result: 'failure',
+            durationMs: 100,
+            dllPath: 'C:\\temp\\test.dll',
+            error: 'access denied',
+        });
+        const exported = JSON.parse(trail.exportJson());
+        expect(exported).toHaveLength(2);
+        expect(exported[0].pattern).toBe('AA BB CC');
+        expect(exported[0].resultsCount).toBe(3);
+        expect(exported[1].dllPath).toBe('C:\\temp\\test.dll');
+        expect(exported[1].error).toBe('access denied');
+    });
+    it('clears all entries', () => {
+        const trail = new MemoryAuditTrail();
+        trail.record({ operation: 'read', pid: 1, address: null, size: null, result: 'success', durationMs: 1 });
+        trail.record({ operation: 'write', pid: 2, address: null, size: null, result: 'success', durationMs: 2 });
+        expect(trail.size()).toBe(2);
+        trail.clear();
+        expect(trail.size()).toBe(0);
+        expect(JSON.parse(trail.exportJson())).toEqual([]);
+    });
+    it('wraps around when capacity is reached (ring buffer)', () => {
+        const trail = new MemoryAuditTrail(3);
+        for (let i = 1; i <= 5; i++) {
+            trail.record({
+                operation: `op_${i}`,
+                pid: i,
+                address: null,
+                size: null,
+                result: 'success',
+                durationMs: i,
+            });
+        }
+        expect(trail.size()).toBe(3);
+        const exported = JSON.parse(trail.exportJson());
+        expect(exported).toHaveLength(3);
+        expect(exported.map((e) => e.operation)).toEqual(['op_3', 'op_4', 'op_5']);
+    });
+    it('defaults invalid capacity to 5000', () => {
+        const trail1 = new MemoryAuditTrail(0);
+        const trail2 = new MemoryAuditTrail(-5);
+        const trail3 = new MemoryAuditTrail(3.7);
+        for (const t of [trail1, trail2, trail3]) {
+            t.record({ operation: 'test', pid: 1, address: null, size: null, result: 'success', durationMs: 1 });
+            expect(t.size()).toBe(1);
+        }
+    });
+    it('uses USER env var when USERNAME is not set', () => {
+        delete process.env.USERNAME;
+        process.env.USER = 'linuxuser';
+        const trail = new MemoryAuditTrail();
+        trail.record({ operation: 'test', pid: 1, address: null, size: null, result: 'success', durationMs: 1 });
+        const exported = JSON.parse(trail.exportJson());
+        expect(exported[0].user).toBe('linuxuser');
+    });
+    it('uses "unknown" when no user env vars are set', () => {
+        delete process.env.USERNAME;
+        delete process.env.USER;
+        const trail = new MemoryAuditTrail();
+        trail.record({ operation: 'test', pid: 1, address: null, size: null, result: 'success', durationMs: 1 });
+        const exported = JSON.parse(trail.exportJson());
+        expect(exported[0].user).toBe('unknown');
+    });
+    it('exports empty JSON array when no entries exist', () => {
+        const trail = new MemoryAuditTrail();
+        expect(trail.exportJson()).toBe('[]');
+    });
+});

package/dist/tests/modules/process/memory/availability.extended.test.d.ts

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