@jshookmcp/jshook 0.2.0 → 0.2.1

package/dist/tests/modules/debugger/ScriptManager.impl.class.test.js

@@ -0,0 +1,226 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const scriptClassMocks = vi.hoisted(() => ({
+    logger: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        success: vi.fn(),
+    },
+}));
+vi.mock('@utils/logger', () => ({
+    logger: scriptClassMocks.logger,
+}));
+import { ScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
+function createSession() {
+    const listeners = new Map();
+    const session = {
+        send: vi.fn(async (method, params) => {
+            if (method === 'Debugger.enable' || method === 'Debugger.disable') {
+                return {};
+            }
+            if (method === 'Debugger.getScriptSource') {
+                return {
+                    scriptSource: `function hello(){ const token${params?.scriptId ?? ''} = "abc"; }\n` +
+                        `const api = fetch('/api/${params?.scriptId ?? '1'}');\n` +
+                        `export default hello;`,
+                };
+            }
+            return {};
+        }),
+        on: vi.fn((event, handler) => {
+            const set = listeners.get(event) ?? new Set();
+            set.add(handler);
+            listeners.set(event, set);
+        }),
+        off: vi.fn(),
+        detach: vi.fn().mockResolvedValue(undefined),
+        emit(event, payload) {
+            listeners.get(event)?.forEach((handler) => handler(payload));
+        },
+    };
+    return { session, listeners };
+}
+function emitScriptParsed(session, scriptId, url, length = 120) {
+    session.emit('Debugger.scriptParsed', {
+        scriptId,
+        url,
+        startLine: 0,
+        startColumn: 0,
+        endLine: 3,
+        endColumn: 0,
+        length,
+    });
+}
+describe('ScriptManager core class internals', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns cached script sources without reloading them', async () => {
+        const cdp = createSession();
+        const manager = new ScriptManager({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
+            }),
+        });
+        await manager.init();
+        const script = {
+            scriptId: 'script-1',
+            url: 'https://site/app.js',
+            startLine: 0,
+            startColumn: 0,
+            endLine: 1,
+            endColumn: 0,
+            source: 'const cached = true;',
+            sourceLength: 20,
+        };
+        const loaded = await manager.loadScriptSourceInternal(script);
+        expect(loaded).toBe(true);
+        expect(cdp.session.send).toHaveBeenCalledTimes(1);
+    });
+    it('supports wildcard URL lookup and validates missing identifiers', async () => {
+        const cdp = createSession();
+        const manager = new ScriptManager({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
+            }),
+        });
+        await manager.init();
+        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
+        await expect(manager.getScriptSource()).rejects.toThrow('Either scriptId or url parameter must be provided');
+        const script = await manager.getScriptSource(undefined, '*app*');
+        expect(script?.scriptId).toBe('script-1');
+        expect(script?.source).toContain('function hello');
+    });
+    it('loads sources in batches of eight when includeSource=true', async () => {
+        const cdp = createSession();
+        const resolvers = [];
+        cdp.session.send.mockImplementation((method, params) => {
+            if (method === 'Debugger.enable' || method === 'Debugger.disable') {
+                return Promise.resolve({});
+            }
+            if (method === 'Debugger.getScriptSource') {
+                return new Promise((resolve) => {
+                    resolvers.push(() => resolve({
+                        scriptSource: `const script${params?.scriptId} = true;`,
+                    }));
+                });
+            }
+            return Promise.resolve({});
+        });
+        const manager = new ScriptManager({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
+            }),
+        });
+        await manager.init();
+        for (let index = 1; index <= 9; index++) {
+            emitScriptParsed(cdp.session, `script-${index}`, `https://site/${index}.js`, 20);
+        }
+        const loading = manager.getAllScripts(true, 9);
+        await Promise.resolve();
+        expect(cdp.session.send.mock.calls.filter(([method]) => method === 'Debugger.getScriptSource')).toHaveLength(8);
+        resolvers.splice(0, 8).forEach((resolve) => resolve());
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(cdp.session.send.mock.calls.filter(([method]) => method === 'Debugger.getScriptSource')).toHaveLength(9);
+        resolvers.splice(0).forEach((resolve) => resolve());
+        const scripts = await loading;
+        expect(scripts).toHaveLength(9);
+        expect(scripts.every((script) => typeof script.source === 'string')).toBe(true);
+    });
+    it('searches scripts with regex options and honors max match limits', async () => {
+        const cdp = createSession();
+        const manager = new ScriptManager({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
+            }),
+        });
+        await manager.init();
+        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
+        await manager.getScriptSource('script-1');
+        const result = await manager.searchInScripts('token\\w+', {
+            isRegex: true,
+            contextLines: 0,
+            maxMatches: 1,
+        });
+        expect(result.totalMatches).toBe(1);
+        expect(result.matches[0]?.matchText).toMatch(/^token/);
+        expect(result.matches[0]?.context).not.toContain('\n');
+    });
+    it('clears in-memory script caches and resets close state even when CDP cleanup fails', async () => {
+        const cdp = createSession();
+        cdp.session.send.mockImplementation(async (method) => {
+            if (method === 'Debugger.enable') {
+                return {};
+            }
+            if (method === 'Debugger.disable') {
+                throw new Error('disable failed');
+            }
+            if (method === 'Debugger.getScriptSource') {
+                return { scriptSource: 'const token = "abc";' };
+            }
+            return {};
+        });
+        const manager = new ScriptManager({
+            getActivePage: vi.fn().mockResolvedValue({
+                createCDPSession: vi.fn().mockResolvedValue(cdp.session),
+            }),
+        });
+        await manager.init();
+        emitScriptParsed(cdp.session, 'script-1', 'https://site/app.js');
+        await manager.getScriptSource('script-1');
+        expect(manager.getStats().totalScripts).toBe(1);
+        manager.clear();
+        expect(manager.getStats()).toEqual({
+            totalScripts: 0,
+            totalUrls: 0,
+            indexedKeywords: 0,
+            totalChunks: 0,
+        });
+        emitScriptParsed(cdp.session, 'script-2', 'https://site/app-2.js');
+        await manager.close();
+        expect(scriptClassMocks.logger.warn).toHaveBeenCalledWith('Failed to close CDP session:', expect.any(Error));
+        expect(manager.initialized).toBe(false);
+        expect(manager.cdpSession).toBeNull();
+    });
+    it('indexes keywords in lowercase and chunks scripts for later retrieval', () => {
+        const manager = new ScriptManager({ getActivePage: vi.fn() });
+        manager.CHUNK_SIZE = 5;
+        manager.buildKeywordIndex('script-1', 'https://site/app.js', 'line1\nLine2 tokenValue\nline3\nline4\nline5');
+        manager.chunkScript('script-1', 'abcdefghij');
+        const keywordEntries = manager.keywordIndex.get('tokenvalue');
+        expect(keywordEntries).toHaveLength(1);
+        expect(keywordEntries[0]).toMatchObject({
+            scriptId: 'script-1',
+            url: 'https://site/app.js',
+            line: 2,
+            column: 6,
+        });
+        expect(keywordEntries[0]?.context).toContain('line1');
+        expect(keywordEntries[0]?.context).toContain('line5');
+        expect(manager.getScriptChunk('script-1', 0)).toBe('abcde');
+        expect(manager.getScriptChunk('script-1', 1)).toBe('fghij');
+        expect(manager.getScriptChunk('script-1', 2)).toBeNull();
+    });
+    it('delegates regex enhanced search to the full script searcher', async () => {
+        const manager = new ScriptManager({ getActivePage: vi.fn() });
+        const searchSpy = vi.spyOn(manager, 'searchInScripts').mockResolvedValue({
+            keyword: 'tok.*',
+            totalMatches: 1,
+            matches: [
+                {
+                    scriptId: 'script-1',
+                    url: 'https://site/app.js',
+                    line: 1,
+                    column: 0,
+                    matchText: 'token',
+                    context: 'token',
+                },
+            ],
+        });
+        const result = await manager.searchInScriptsEnhanced('tok.*', { isRegex: true });
+        expect(searchSpy).toHaveBeenCalledWith('tok.*', { isRegex: true });
+        expect(result.searchMethod).toBe('regex');
+        expect(result.totalMatches).toBe(1);
+    });
+});

package/dist/tests/modules/debugger/ScriptManager.impl.extract-function-tree.test.d.ts

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

package/dist/tests/modules/debugger/ScriptManager.impl.extract-function-tree.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const functionTreeMocks = vi.hoisted(() => {
+    const state = {
+        declarations: [],
+        variables: [],
+        parse: vi.fn(),
+        traverse: vi.fn(),
+        generate: vi.fn(),
+        logger: {
+            debug: vi.fn(),
+            info: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+            success: vi.fn(),
+        },
+    };
+    const createPath = (node, type) => ({
+        node: type === 'FunctionDeclaration'
+            ? {
+                type,
+                id: { type: 'Identifier', name: node.name },
+                loc: {
+                    start: { line: node.startLine },
+                    end: { line: node.endLine },
+                },
+                mockCode: node.code,
+                mockDeps: node.deps,
+            }
+            : {
+                type,
+                id: { type: 'Identifier', name: node.name },
+                init: { type: node.initType },
+                loc: {
+                    start: { line: node.startLine },
+                    end: { line: node.endLine },
+                },
+                mockCode: node.code,
+                mockDeps: node.deps,
+            },
+        traverse(visitor) {
+            node.deps.forEach((dep) => {
+                visitor.CallExpression?.({
+                    node: {
+                        callee: {
+                            type: 'Identifier',
+                            name: dep,
+                        },
+                    },
+                });
+            });
+        },
+    });
+    return { ...state, createPath };
+});
+vi.mock('@utils/logger', () => ({
+    logger: functionTreeMocks.logger,
+}));
+vi.mock('@babel/parser', () => ({
+    parse: functionTreeMocks.parse,
+}));
+vi.mock('@babel/traverse', () => ({
+    default: functionTreeMocks.traverse,
+    traverse: functionTreeMocks.traverse,
+}));
+vi.mock('@babel/generator', () => ({
+    default: functionTreeMocks.generate,
+    generate: functionTreeMocks.generate,
+}));
+vi.mock('@babel/types', () => ({
+    isIdentifier: (value) => value?.type === 'Identifier',
+    isFunctionExpression: (value) => value?.type === 'FunctionExpression',
+    isArrowFunctionExpression: (value) => value?.type === 'ArrowFunctionExpression',
+}));
+import { extractFunctionTreeCore } from '../../../src/modules/debugger/ScriptManager.impl.extract-function-tree.js';
+describe('ScriptManager extract-function-tree internals', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        functionTreeMocks.declarations = [];
+        functionTreeMocks.variables = [];
+        functionTreeMocks.parse.mockReturnValue({ type: 'File' });
+        functionTreeMocks.traverse.mockImplementation((_ast, visitor) => {
+            functionTreeMocks.declarations.forEach((item) => visitor.FunctionDeclaration?.(functionTreeMocks.createPath(item, 'FunctionDeclaration')));
+            functionTreeMocks.variables.forEach((item) => visitor.VariableDeclarator?.(functionTreeMocks.createPath(item, 'VariableDeclarator')));
+        });
+        functionTreeMocks.generate.mockImplementation((node, options) => ({
+            code: node.mockCode ?? '',
+            comments: options?.comments,
+        }));
+    });
+    it('rejects missing scripts before attempting parsing', async () => {
+        const ctx = {
+            getScriptSource: vi.fn().mockResolvedValue(null),
+        };
+        await expect(extractFunctionTreeCore(ctx, 'script-1', 'main')).rejects.toThrow('Script not found: script-1');
+    });
+    it('wraps parser failures with script context', async () => {
+        const ctx = {
+            getScriptSource: vi.fn().mockResolvedValue({
+                source: 'const =',
+            }),
+        };
+        functionTreeMocks.parse.mockImplementation(() => {
+            throw new Error('Unexpected token');
+        });
+        await expect(extractFunctionTreeCore(ctx, 'script-1', 'main')).rejects.toThrow('Failed to parse script script-1: Unexpected token');
+    });
+    it('extracts function declarations, variable functions, and call graphs', async () => {
+        const ctx = {
+            getScriptSource: vi.fn().mockResolvedValue({
+                source: 'function main() {}',
+            }),
+        };
+        functionTreeMocks.declarations = [
+            {
+                name: 'main',
+                code: 'function main() { helper(); util(); }',
+                deps: ['helper', 'util'],
+                startLine: 1,
+                endLine: 3,
+            },
+            {
+                name: 'helper',
+                code: 'function helper() { return leaf(); }',
+                deps: ['leaf'],
+                startLine: 5,
+                endLine: 7,
+            },
+            {
+                name: 'leaf',
+                code: 'function leaf() { return true; }',
+                deps: [],
+                startLine: 9,
+                endLine: 11,
+            },
+        ];
+        functionTreeMocks.variables = [
+            {
+                name: 'util',
+                code: 'const util = () => 1;',
+                deps: [],
+                startLine: 13,
+                endLine: 13,
+                initType: 'ArrowFunctionExpression',
+            },
+        ];
+        const result = await extractFunctionTreeCore(ctx, 'script-1', 'main', {
+            includeComments: false,
+            maxDepth: 5,
+        });
+        expect(result.mainFunction).toBe('main');
+        expect(result.extractedCount).toBe(4);
+        expect(result.functions.map((func) => func.name)).toEqual(expect.arrayContaining(['main', 'helper', 'leaf', 'util']));
+        expect(result.callGraph).toEqual({
+            main: ['helper', 'util'],
+            helper: ['leaf'],
+            leaf: [],
+            util: [],
+        });
+        expect(result.code).toContain('function main()');
+        expect(result.code).toContain('const util = () => 1;');
+        expect(functionTreeMocks.generate).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ comments: false }));
+        expect(functionTreeMocks.logger.info).toHaveBeenCalledWith(expect.stringContaining('extractFunctionTree: main - extracted 4 functions'));
+    });
+    it('limits extraction by maxDepth and warns on oversized output', async () => {
+        const ctx = {
+            getScriptSource: vi.fn().mockResolvedValue({
+                source: 'function main() {}',
+            }),
+        };
+        functionTreeMocks.declarations = [
+            {
+                name: 'main',
+                code: 'function main() { helper(); }',
+                deps: ['helper'],
+                startLine: 1,
+                endLine: 3,
+            },
+            {
+                name: 'helper',
+                code: 'function helper() { return leaf(); }',
+                deps: ['leaf'],
+                startLine: 5,
+                endLine: 7,
+            },
+            {
+                name: 'leaf',
+                code: 'function leaf() { return true; }',
+                deps: [],
+                startLine: 9,
+                endLine: 11,
+            },
+        ];
+        const result = await extractFunctionTreeCore(ctx, 'script-1', 'main', {
+            maxDepth: 2,
+            maxSize: 0,
+        });
+        expect(result.functions.map((func) => func.name)).toEqual(['main', 'helper']);
+        expect(functionTreeMocks.logger.warn).toHaveBeenCalledWith(expect.stringContaining('Extracted code size'));
+    });
+});

package/dist/tests/modules/debugger/ScriptManager.impl.test.d.ts

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

package/dist/tests/modules/debugger/ScriptManager.impl.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { ScriptManager as ImplScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.js';
+import { ScriptManager as ClassScriptManager } from '../../../src/modules/debugger/ScriptManager.impl.class.js';
+describe('ScriptManager.impl.ts', () => {
+    it('re-exports the ScriptManager class from the class module', () => {
+        expect(ImplScriptManager).toBe(ClassScriptManager);
+    });
+});

package/dist/tests/modules/deobfuscator/AdvancedDeobfuscator.ast.additional.test.d.ts

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