@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/modules/collector/SmartCodeCollector.test.js

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { SmartCodeCollector } from '../../../src/modules/collector/SmartCodeCollector.js';
+function makeFiles() {
+    return [
+        {
+            url: 'https://site/main.js',
+            content: `import x from "./dep"; function alpha(){}; fetch('/api');`,
+            size: 200,
+            type: 'external',
+        },
+        {
+            url: 'https://site/crypto.js',
+            content: `const cipher = 'aes'; eval('1+1');`,
+            size: 300,
+            type: 'inline',
+        },
+        {
+            url: 'https://site/vendor.js',
+            content: 'x'.repeat(2000),
+            size: 2000,
+            type: 'external',
+        },
+    ];
+}
+describe('SmartCodeCollector', () => {
+    it('summary mode returns code heuristics and previews', async () => {
+        const collector = new SmartCodeCollector();
+        const result = (await collector.smartCollect({}, makeFiles(), {
+            mode: 'summary',
+        }));
+        expect(result).toHaveLength(3);
+        expect(result[0]?.hasAPI).toBe(true);
+        expect(result[1]?.hasEncryption).toBe(true);
+        expect(result[1]?.hasObfuscation).toBe(true);
+        expect(result[0]?.imports).toContain('./dep');
+    });
+    it('priority mode sorts by score and truncates oversized files', async () => {
+        const collector = new SmartCodeCollector();
+        const result = (await collector.smartCollect({}, makeFiles(), {
+            mode: 'priority',
+            priorities: ['crypto', 'main'],
+            maxFileSize: 100,
+            maxTotalSize: 260,
+        }));
+        expect(result.length).toBeGreaterThan(0);
+        expect(result[0]?.url).toContain('crypto');
+        expect(result[0]?.metadata?.priorityScore).toBeTypeOf('number');
+        expect(result.some((f) => f.metadata?.truncated)).toBe(true);
+    });
+    it('incremental mode applies include and exclude patterns', async () => {
+        const collector = new SmartCodeCollector();
+        const result = (await collector.smartCollect({}, makeFiles(), {
+            mode: 'incremental',
+            includePatterns: ['main|crypto'],
+            excludePatterns: ['main'],
+            maxTotalSize: 10_000,
+            maxFileSize: 10_000,
+        }));
+        expect(result).toHaveLength(1);
+        expect(result[0]?.url).toContain('crypto');
+    });
+    it('full mode enforces total size ceiling', async () => {
+        const collector = new SmartCodeCollector();
+        const result = (await collector.smartCollect({}, makeFiles(), {
+            mode: 'full',
+            maxTotalSize: 250,
+            maxFileSize: 10_000,
+        }));
+        expect(result).toHaveLength(2);
+        expect(result[0]?.url).toContain('main');
+        expect(result[1]?.url).toContain('crypto');
+    });
+    it('unknown mode falls back to full collection behavior', async () => {
+        const collector = new SmartCodeCollector();
+        const result = (await collector.smartCollect({}, makeFiles(), {
+            mode: 'unknown',
+            maxTotalSize: 250,
+            maxFileSize: 10_000,
+        }));
+        expect(result).toHaveLength(2);
+        expect(result[0]?.url).toContain('main');
+        expect(result[1]?.url).toContain('crypto');
+    });
+});

package/dist/tests/modules/collector/StreamingCollector.test.d.ts

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

package/dist/tests/modules/collector/StreamingCollector.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { StreamingCollector } from '../../../src/modules/collector/StreamingCollector.js';
+async function collectAsync(iterable) {
+    const out = [];
+    for await (const item of iterable)
+        out.push(item);
+    return out;
+}
+describe('StreamingCollector', () => {
+    it('splits a file into chunks with metadata', async () => {
+        const collector = new StreamingCollector();
+        const chunks = await collectAsync(collector.streamFile({ url: 'a.js', content: '1234567890', size: 10, type: 'external' }, { chunkSize: 4 }));
+        expect(chunks).toHaveLength(3);
+        expect(chunks[0]?.metadata?.offset).toBe(0);
+        expect(chunks[2]?.isLast).toBe(true);
+    });
+    it('collectStream reconstructs content per URL', async () => {
+        const collector = new StreamingCollector();
+        const stream = collector.streamFiles([
+            { url: 'a.js', content: 'AAAA', size: 4, type: 'external' },
+            { url: 'b.js', content: 'BBBB', size: 4, type: 'external' },
+        ], { chunkSize: 2 });
+        const rebuilt = await collector.collectStream(stream);
+        expect(rebuilt.get('a.js')).toBe('AAAA');
+        expect(rebuilt.get('b.js')).toBe('BBBB');
+    });
+    it('streamByPriority yields higher-scored files first', async () => {
+        const collector = new StreamingCollector();
+        const chunks = await collectAsync(collector.streamByPriority([
+            { url: 'vendor.js', content: 'noop', size: 4, type: 'external' },
+            { url: 'crypto-main.js', content: 'encrypt + fetch', size: 20, type: 'external' },
+        ], ['crypto']));
+        expect(chunks[0]?.url).toBe('crypto-main.js');
+    });
+    it('streamFiltered only emits chunks from matched files', async () => {
+        const collector = new StreamingCollector();
+        const chunks = await collectAsync(collector.streamFiltered([
+            { url: 'a.js', content: 'aa', size: 2, type: 'external' },
+            { url: 'b.js', content: 'bb', size: 2, type: 'external' },
+        ], (f) => f.url.startsWith('b')));
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0]?.url).toBe('b.js');
+    });
+    it('getStreamStats reports chunk count, bytes and unique files', async () => {
+        const collector = new StreamingCollector();
+        const stream = collector.streamFiles([
+            { url: 'a.js', content: '1234', size: 4, type: 'external' },
+            { url: 'b.js', content: '12', size: 2, type: 'external' },
+        ], { chunkSize: 2 });
+        const stats = await collector.getStreamStats(stream);
+        expect(stats.totalChunks).toBe(3);
+        expect(stats.totalSize).toBe(6);
+        expect(stats.files).toBe(2);
+    });
+});

package/dist/tests/modules/crypto/CryptoDetector.test.d.ts

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

package/dist/tests/modules/crypto/CryptoDetector.test.js

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { CryptoDetector } from '../../../src/modules/crypto/CryptoDetector.js';
+describe('CryptoDetector', () => {
+    it('detects algorithms, libraries and security issues without AI', async () => {
+        const detector = new CryptoDetector({ chat: async () => ({ content: '{}' }) });
+        const code = `
+      const algo = "MD5";
+      const encrypted = CryptoJS.AES.encrypt("text", "key");
+      console.log(encrypted, algo);
+    `;
+        const result = await detector.detect({ code, useAI: false });
+        expect(result.algorithms.some((a) => a.name === 'AES')).toBe(true);
+        expect(result.algorithms.some((a) => a.name === 'MD5')).toBe(true);
+        expect(result.libraries.some((lib) => lib.name === 'CryptoJS')).toBe(true);
+        expect(result.securityIssues?.some((issue) => issue.algorithm === 'MD5')).toBe(true);
+        expect(result.strength?.score).toBeLessThan(100);
+    });
+    it('merges AI results when AI detection is enabled', async () => {
+        const detector = new CryptoDetector({
+            chat: async () => ({
+                content: '{"algorithms":[{"name":"AIHash","type":"hash","confidence":0.92,"usage":"from model"}]}',
+            }),
+        });
+        const result = await detector.detect({ code: 'const x = 1;' });
+        expect(result.algorithms.some((a) => a.name === 'AIHash')).toBe(true);
+    });
+    it('handles malformed AI output gracefully', async () => {
+        const detector = new CryptoDetector({
+            chat: async () => ({ content: 'not-json-at-all' }),
+        });
+        const result = await detector.detect({ code: 'const x = 1;' });
+        expect(result.algorithms.some((a) => a.name === 'Unknown')).toBe(false);
+    });
+    it('handles AI provider failures without throwing', async () => {
+        const detector = new CryptoDetector({
+            chat: async () => {
+                throw new Error('provider down');
+            },
+        });
+        await expect(detector.detect({ code: 'const y = SHA256;' })).resolves.toMatchObject({
+            algorithms: expect.any(Array),
+            libraries: expect.any(Array),
+        });
+    });
+    it('supports loading custom keyword rules and detecting them', async () => {
+        const detector = new CryptoDetector({ chat: async () => ({ content: '{}' }) });
+        detector.loadCustomRules(JSON.stringify({
+            keywords: [{ category: 'hash', keywords: ['MY_HASH_X'], confidence: 0.88 }],
+        }));
+        const result = await detector.detect({ code: 'const algo = "MY_HASH_X";', useAI: false });
+        expect(result.algorithms.some((a) => a.name === 'MY_HASH_X')).toBe(true);
+    });
+    it('exports rules as valid JSON string', () => {
+        const detector = new CryptoDetector({ chat: async () => ({ content: '{}' }) });
+        const rules = detector.exportRules();
+        const parsed = JSON.parse(rules);
+        expect(parsed).toHaveProperty('keywords');
+        expect(parsed).toHaveProperty('libraries');
+        expect(parsed).toHaveProperty('constants');
+    });
+});

package/dist/tests/modules/crypto/CryptoRules.test.d.ts

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

package/dist/tests/modules/crypto/CryptoRules.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { CryptoRulesManager } from '../../../src/modules/crypto/CryptoRules.js';
+describe('CryptoRulesManager', () => {
+    it('loads default keyword/library/constant/security rules', () => {
+        const manager = new CryptoRulesManager();
+        expect(manager.getKeywordRules().length).toBeGreaterThan(0);
+        expect(manager.getLibraryRules().some((r) => r.name === 'CryptoJS')).toBe(true);
+        expect(manager.getConstantRules().some((r) => r.name === 'SHA256')).toBe(true);
+        expect(manager.getSecurityRules().some((r) => r.name === 'weak-md5')).toBe(true);
+    });
+    it('supports adding pattern rules', () => {
+        const manager = new CryptoRulesManager();
+        manager.addPatternRule({
+            name: 'custom-regex',
+            type: 'hash',
+            pattern: { type: 'regex', matcher: /sha3/i },
+            confidence: 0.7,
+        });
+        expect(manager.getPatternRules().some((r) => r.name === 'custom-regex')).toBe(true);
+    });
+    it('can load additional rules from JSON', () => {
+        const manager = new CryptoRulesManager();
+        const json = JSON.stringify({
+            keywords: [{ category: 'other', keywords: ['FOO_CIPHER'], confidence: 0.5 }],
+            libraries: [{ name: 'MyCryptoLib', patterns: ['my-crypto-lib'], confidence: 0.8 }],
+            constants: [{ name: 'CONST_X', type: 'other', values: [1, 2, 3], confidence: 0.6 }],
+        });
+        manager.loadFromJSON(json);
+        expect(manager.getKeywordRules().some((r) => r.keywords.includes('FOO_CIPHER'))).toBe(true);
+        expect(manager.getLibraryRules().some((r) => r.name === 'MyCryptoLib')).toBe(true);
+        expect(manager.getConstantRules().some((r) => r.name === 'CONST_X')).toBe(true);
+    });
+    it('throws a descriptive error for invalid JSON input', () => {
+        const manager = new CryptoRulesManager();
+        expect(() => manager.loadFromJSON('{ invalid json')).toThrow('Failed to load rules from JSON');
+    });
+    it('exports current ruleset as parseable JSON', () => {
+        const manager = new CryptoRulesManager();
+        const out = manager.exportToJSON();
+        const parsed = JSON.parse(out);
+        expect(Array.isArray(parsed.keywords)).toBe(true);
+        expect(Array.isArray(parsed.libraries)).toBe(true);
+        expect(Array.isArray(parsed.constants)).toBe(true);
+        expect(Array.isArray(parsed.security)).toBe(true);
+    });
+    it('addKeywordRule overrides rule for same category key', () => {
+        const manager = new CryptoRulesManager();
+        manager.addKeywordRule({
+            category: 'hash',
+            keywords: ['ONLY_HASH_X'],
+            confidence: 0.99,
+        });
+        const hashRule = manager.getKeywordRules().find((r) => r.category === 'hash');
+        expect(hashRule?.keywords).toEqual(['ONLY_HASH_X']);
+        expect(hashRule?.confidence).toBe(0.99);
+    });
+});

package/dist/tests/modules/debugger/BlackboxManager.test.d.ts

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

package/dist/tests/modules/debugger/BlackboxManager.test.js

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { BlackboxManager } from '../../../src/modules/debugger/BlackboxManager.js';
+function createSession() {
+    return {
+        send: vi.fn().mockResolvedValue({}),
+        on: vi.fn(),
+        off: vi.fn(),
+        detach: vi.fn(),
+    };
+}
+describe('BlackboxManager', () => {
+    let session;
+    let manager;
+    beforeEach(() => {
+        session = createSession();
+        manager = new BlackboxManager(session);
+    });
+    it('normalizes wildcard patterns and sends to CDP', async () => {
+        await manager.blackboxByPattern('*vendor-lib*.js');
+        const patterns = manager.getAllBlackboxedPatterns();
+        expect(patterns).toHaveLength(1);
+        expect(patterns[0]).toContain('.*vendor-lib.*');
+        expect(session.send).toHaveBeenCalledWith('Debugger.setBlackboxPatterns', {
+            patterns,
+        });
+    });
+    it('rejects empty patterns', async () => {
+        await expect(manager.blackboxByPattern('   ')).rejects.toThrow('Pattern cannot be empty');
+    });
+    it('returns false when removing a non-existing pattern', async () => {
+        await expect(manager.unblackboxByPattern('*missing*')).resolves.toBe(false);
+    });
+    it('rolls back deletion when unblackbox request fails', async () => {
+        await manager.blackboxByPattern('*ui-framework*.js');
+        session.send.mockRejectedValueOnce(new Error('cdp failure'));
+        await expect(manager.unblackboxByPattern('*ui-framework*.js')).rejects.toThrow('cdp failure');
+        expect(manager.getAllBlackboxedPatterns()[0]).toContain('ui-framework');
+    });
+    it('loads common library patterns in one call', async () => {
+        await manager.blackboxCommonLibraries();
+        expect(manager.getAllBlackboxedPatterns().length).toBe(BlackboxManager.COMMON_LIBRARY_PATTERNS.length);
+    });
+    it('clears all blackbox patterns', async () => {
+        await manager.blackboxByPattern('*lodash*.js');
+        await manager.clearAllBlackboxedPatterns();
+        expect(manager.getAllBlackboxedPatterns()).toEqual([]);
+        expect(session.send).toHaveBeenCalledWith('Debugger.setBlackboxPatterns', { patterns: [] });
+    });
+});

package/dist/tests/modules/debugger/DebuggerManager.test.d.ts

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

package/dist/tests/modules/debugger/DebuggerManager.test.js

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { DebuggerManager } from '../../../src/modules/debugger/DebuggerManager.js';
+function createMockCDPSession() {
+    const listeners = new Map();
+    const send = vi.fn(async (method) => {
+        if (method === 'Debugger.setBreakpointByUrl') {
+            return { breakpointId: 'bp-url-1' };
+        }
+        if (method === 'Debugger.setBreakpoint') {
+            return { breakpointId: 'bp-script-1' };
+        }
+        if (method === 'Runtime.getProperties') {
+            return { result: [] };
+        }
+        return {};
+    });
+    const on = vi.fn((event, handler) => {
+        const group = listeners.get(event) ?? new Set();
+        group.add(handler);
+        listeners.set(event, group);
+    });
+    const off = vi.fn((event, handler) => {
+        listeners.get(event)?.delete(handler);
+    });
+    const detach = vi.fn().mockResolvedValue(undefined);
+    const emit = (event, payload) => {
+        listeners.get(event)?.forEach((handler) => void handler(payload));
+    };
+    return {
+        session: { send, on, off, detach },
+        send,
+        off,
+        detach,
+        emit,
+    };
+}
+function pausedPayload(hitBreakpoints = []) {
+    return {
+        reason: 'other',
+        hitBreakpoints,
+        callFrames: [
+            {
+                callFrameId: 'cf-1',
+                functionName: 'main',
+                location: { scriptId: 's1', lineNumber: 10, columnNumber: 2 },
+                url: 'https://site/app.js',
+                scopeChain: [],
+                this: {},
+            },
+        ],
+    };
+}
+describe('DebuggerManager', () => {
+    let cdp;
+    let manager;
+    let collector;
+    beforeEach(() => {
+        cdp = createMockCDPSession();
+        const page = { createCDPSession: vi.fn().mockResolvedValue(cdp.session) };
+        collector = { getActivePage: vi.fn().mockResolvedValue(page) };
+        manager = new DebuggerManager(collector);
+    });
+    it('initializes debugger and registers CDP listeners', async () => {
+        await manager.init();
+        expect(cdp.send).toHaveBeenCalledWith('Debugger.enable');
+        expect(manager.isEnabled()).toBe(true);
+        expect(cdp.session.on).toHaveBeenCalledWith('Debugger.paused', expect.any(Function));
+        expect(cdp.session.on).toHaveBeenCalledWith('Debugger.resumed', expect.any(Function));
+    });
+    it('sets breakpoint by url and persists it in manager state', async () => {
+        await manager.init();
+        const bp = await manager.setBreakpointByUrl({
+            url: 'https://site/app.js',
+            lineNumber: 12,
+            condition: 'x > 1',
+        });
+        expect(bp.breakpointId).toBe('bp-url-1');
+        expect(manager.listBreakpoints()).toHaveLength(1);
+        expect(manager.getBreakpoint('bp-url-1')?.condition).toBe('x > 1');
+    });
+    it('rejects removing a breakpoint that does not exist', async () => {
+        await manager.init();
+        await expect(manager.removeBreakpoint('missing-bp')).rejects.toThrow('Breakpoint not found');
+    });
+    it('waitForPaused resolves when paused event arrives', async () => {
+        await manager.init();
+        const waiting = manager.waitForPaused(1000);
+        cdp.emit('Debugger.paused', pausedPayload());
+        const state = await waiting;
+        expect(state.reason).toBe('other');
+        expect(state.callFrames[0]?.functionName).toBe('main');
+        expect(manager.isPaused()).toBe(true);
+    });
+    it('increments hit count and invokes breakpoint-hit callbacks', async () => {
+        await manager.init();
+        await manager.setBreakpointByUrl({ url: 'https://site/app.js', lineNumber: 10 });
+        const callback = vi.fn();
+        manager.onBreakpointHit(callback);
+        cdp.emit('Debugger.paused', pausedPayload(['bp-url-1']));
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(manager.getBreakpoint('bp-url-1')?.hitCount).toBe(1);
+        expect(callback).toHaveBeenCalledTimes(1);
+    });
+    it('disables debugger and detaches session during cleanup', async () => {
+        await manager.init();
+        await manager.disable();
+        expect(cdp.send).toHaveBeenCalledWith('Debugger.disable');
+        expect(cdp.detach).toHaveBeenCalled();
+        expect(manager.isEnabled()).toBe(false);
+    });
+});

package/dist/tests/modules/debugger/DebuggerSessionManager.test.d.ts

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

package/dist/tests/modules/debugger/DebuggerSessionManager.test.js

@@ -0,0 +1,130 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { DebuggerSessionManager } from '../../../src/modules/debugger/DebuggerSessionManager.js';
+describe('DebuggerSessionManager', () => {
+    let workDir;
+    let cwdSpy;
+    beforeEach(async () => {
+        workDir = await mkdtemp(join(tmpdir(), 'dbg-session-'));
+        cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(workDir);
+    });
+    afterEach(async () => {
+        cwdSpy.mockRestore();
+        await rm(workDir, { recursive: true, force: true });
+    });
+    it('exports session with breakpoints and metadata', () => {
+        const managerMock = {
+            getBreakpoints: () => new Map([
+                [
+                    'bp1',
+                    {
+                        location: { url: 'https://a.js', lineNumber: 1, columnNumber: 2 },
+                        condition: 'x>0',
+                        enabled: true,
+                    },
+                ],
+            ]),
+            getPauseOnExceptionsState: () => 'uncaught',
+        };
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        const session = sessionManager.exportSession({ tag: 'unit' });
+        expect(session.version).toBe('1.0');
+        expect(session.breakpoints).toHaveLength(1);
+        expect(session.pauseOnExceptions).toBe('uncaught');
+        expect(session.metadata).toEqual({ tag: 'unit' });
+    });
+    it('throws when importing session while debugger is disabled', async () => {
+        const managerMock = { isEnabled: () => false };
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        await expect(sessionManager.importSession({
+            version: '1.0',
+            timestamp: Date.now(),
+            breakpoints: [],
+            pauseOnExceptions: 'none',
+        })).rejects.toThrow('Debugger must be enabled');
+    });
+    it('imports url/script breakpoints and applies pauseOnExceptions', async () => {
+        const managerMock = {
+            isEnabled: vi.fn(() => true),
+            clearAllBreakpoints: vi.fn().mockResolvedValue(undefined),
+            setBreakpointByUrl: vi.fn().mockResolvedValue(undefined),
+            setBreakpoint: vi.fn().mockResolvedValue(undefined),
+            setPauseOnExceptions: vi.fn().mockResolvedValue(undefined),
+        };
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        await sessionManager.importSession({
+            version: '1.0',
+            timestamp: Date.now(),
+            breakpoints: [
+                { location: { url: 'https://a.js', lineNumber: 3 }, enabled: true },
+                { location: { scriptId: 's1', lineNumber: 7 }, enabled: true },
+                { location: { lineNumber: 0 }, enabled: true },
+            ],
+            pauseOnExceptions: 'all',
+        });
+        expect(managerMock.clearAllBreakpoints).toHaveBeenCalledTimes(1);
+        expect(managerMock.setBreakpointByUrl).toHaveBeenCalledTimes(1);
+        expect(managerMock.setBreakpoint).toHaveBeenCalledTimes(1);
+        expect(managerMock.setPauseOnExceptions).toHaveBeenCalledWith('all');
+    });
+    it('restores breakpoints concurrently within a batch', async () => {
+        const pendingResolvers = [];
+        const managerMock = {
+            isEnabled: vi.fn(() => true),
+            clearAllBreakpoints: vi.fn().mockResolvedValue(undefined),
+            setBreakpointByUrl: vi.fn(() => new Promise((resolve) => pendingResolvers.push(resolve))),
+            setBreakpoint: vi.fn().mockResolvedValue(undefined),
+            setPauseOnExceptions: vi.fn().mockResolvedValue(undefined),
+        };
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        const importPromise = sessionManager.importSession({
+            version: '1.0',
+            timestamp: Date.now(),
+            breakpoints: [
+                { location: { url: 'https://a.js', lineNumber: 3 }, enabled: true },
+                { location: { url: 'https://b.js', lineNumber: 5 }, enabled: true },
+            ],
+            pauseOnExceptions: 'none',
+        });
+        await Promise.resolve();
+        expect(managerMock.setBreakpointByUrl).toHaveBeenCalledTimes(2);
+        pendingResolvers.splice(0).forEach((resolve) => resolve());
+        await importPromise;
+    });
+    it('saves session JSON to disk (default path)', async () => {
+        const managerMock = {
+            getBreakpoints: () => new Map(),
+            getPauseOnExceptionsState: () => 'none',
+        };
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        const savedPath = await sessionManager.saveSession(undefined, { source: 'test' });
+        const content = await readFile(savedPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        expect(savedPath).toContain('debugger-sessions');
+        expect(parsed.metadata).toEqual({ source: 'test' });
+    });
+    it('lists saved sessions sorted by descending timestamp and skips invalid files', async () => {
+        const sessionsDir = join(workDir, 'debugger-sessions');
+        await mkdir(sessionsDir, { recursive: true });
+        await writeFile(join(sessionsDir, 'a.json'), JSON.stringify({ version: '1.0', timestamp: 1000, breakpoints: [], metadata: { id: 'a' } }));
+        await writeFile(join(sessionsDir, 'b.json'), JSON.stringify({ version: '1.0', timestamp: 2000, breakpoints: [], metadata: { id: 'b' } }));
+        await writeFile(join(sessionsDir, 'broken.json'), '{not-json');
+        const managerMock = {};
+        const sessionManager = new DebuggerSessionManager(managerMock);
+        const sessions = await sessionManager.listSavedSessions();
+        expect(sessions).toHaveLength(2);
+        expect(sessions[0]?.metadata?.id).toBe('b');
+        expect(sessions[1]?.metadata?.id).toBe('a');
+    });
+});

package/dist/tests/modules/debugger/EventBreakpointManager.test.d.ts

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

package/dist/tests/modules/debugger/EventBreakpointManager.test.js

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+import { EventBreakpointManager } from '../../../src/modules/debugger/EventBreakpointManager.js';
+describe('EventBreakpointManager', () => {
+    let session;
+    let manager;
+    beforeEach(() => {
+        session = {
+            send: vi.fn().mockResolvedValue({}),
+            on: vi.fn(),
+            off: vi.fn(),
+            detach: vi.fn(),
+        };
+        manager = new EventBreakpointManager(session);
+    });
+    it('sets event listener breakpoints and tracks them', async () => {
+        const id = await manager.setEventListenerBreakpoint('click');
+        expect(id).toBe('event_1');
+        expect(manager.getEventBreakpoint(id)?.eventName).toBe('click');
+        expect(session.send).toHaveBeenCalledWith('DOMDebugger.setEventListenerBreakpoint', {
+            eventName: 'click',
+            targetName: undefined,
+        });
+    });
+    it('returns false when removing missing breakpoint', async () => {
+        await expect(manager.removeEventListenerBreakpoint('nope')).resolves.toBe(false);
+    });
+    it('sets all mouse event breakpoints', async () => {
+        const ids = await manager.setMouseEventBreakpoints();
+        expect(ids.length).toBe(EventBreakpointManager.MOUSE_EVENTS.length);
+        expect(manager.getAllEventBreakpoints()).toHaveLength(EventBreakpointManager.MOUSE_EVENTS.length);
+    });
+    it('clears all breakpoints even if one CDP removal fails', async () => {
+        await manager.setEventListenerBreakpoint('click');
+        await manager.setEventListenerBreakpoint('keydown');
+        session.send.mockRejectedValueOnce(new Error('remove failed'));
+        await manager.clearAllEventBreakpoints();
+        expect(manager.getAllEventBreakpoints()).toEqual([]);
+    });
+    it('close delegates to clearAllEventBreakpoints', async () => {
+        const spy = vi.spyOn(manager, 'clearAllEventBreakpoints').mockResolvedValue(undefined);
+        await manager.close();
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/modules/debugger/RuntimeInspector.test.d.ts

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