@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/server/ToolHandlerMap.test.js

@@ -0,0 +1,75 @@
+import { describe, expect, it, vi } from 'vitest';
+import { HANDLED_TOOL_NAMES, createToolHandlerMap, } from '../../src/server/ToolHandlerMap.js';
+function createDeps() {
+    const spies = {
+        handleGetTokenBudgetStats: vi.fn(async () => ({ ok: 'budget' })),
+        handlePageNavigate: vi.fn(async (args) => ({ ok: 'navigate', args })),
+        handleNetworkGetRequests: vi.fn(async (args) => ({ ok: 'network', args })),
+    };
+    const deps = {
+        browserHandlers: {
+            handlePageNavigate: spies.handlePageNavigate,
+        },
+        debuggerHandlers: {},
+        advancedHandlers: {
+            handleNetworkGetRequests: spies.handleNetworkGetRequests,
+        },
+        aiHookHandlers: {},
+        hookPresetHandlers: {},
+        coreAnalysisHandlers: {},
+        coreMaintenanceHandlers: {
+            handleGetTokenBudgetStats: spies.handleGetTokenBudgetStats,
+        },
+        processHandlers: {},
+        workflowHandlers: {},
+        wasmHandlers: {},
+        streamingHandlers: {},
+        encodingHandlers: {},
+        antidebugHandlers: {},
+        graphqlHandlers: {},
+        platformHandlers: {},
+        sourcemapHandlers: {},
+        transformHandlers: {},
+    };
+    return { deps, spies };
+}
+describe('ToolHandlerMap', () => {
+    it('exposes known handled tool names', () => {
+        expect(HANDLED_TOOL_NAMES.has('get_token_budget_stats')).toBe(true);
+        expect(HANDLED_TOOL_NAMES.has('page_navigate')).toBe(true);
+        expect(HANDLED_TOOL_NAMES.has('network_get_requests')).toBe(true);
+    });
+    it('creates filtered map when selectedToolNames is provided', () => {
+        const { deps } = createDeps();
+        const map = createToolHandlerMap(deps, new Set(['page_navigate', 'get_token_budget_stats']));
+        expect(Object.keys(map).sort()).toEqual(['get_token_budget_stats', 'page_navigate']);
+    });
+    it('mapped browser handler delegates with original args', async () => {
+        const { deps, spies } = createDeps();
+        const map = createToolHandlerMap(deps, new Set(['page_navigate']));
+        const payload = { url: 'https://vmoranv.github.io/jshookmcp' };
+        await expect(map.page_navigate?.(payload)).resolves.toEqual({
+            ok: 'navigate',
+            args: payload,
+        });
+        expect(spies.handlePageNavigate).toHaveBeenCalledWith(payload);
+    });
+    it('mapped maintenance handler works without args contract', async () => {
+        const { deps, spies } = createDeps();
+        const map = createToolHandlerMap(deps, new Set(['get_token_budget_stats']));
+        await expect(map.get_token_budget_stats?.({ ignored: true })).resolves.toEqual({
+            ok: 'budget',
+        });
+        expect(spies.handleGetTokenBudgetStats).toHaveBeenCalledOnce();
+    });
+    it('returns empty map for unknown selected names', () => {
+        const { deps } = createDeps();
+        const map = createToolHandlerMap(deps, new Set(['totally_unknown']));
+        expect(map).toEqual({});
+    });
+    it('returns full binding map when no filter is provided', () => {
+        const { deps } = createDeps();
+        const map = createToolHandlerMap(deps);
+        expect(Object.keys(map).length).toBe(HANDLED_TOOL_NAMES.size);
+    });
+});

package/dist/tests/server/ToolSearch.test.d.ts

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

package/dist/tests/server/ToolSearch.test.js

@@ -0,0 +1,329 @@
+import { describe, it, expect } from 'vitest';
+import { ToolSearchEngine } from '../../src/server/ToolSearch.js';
+function makeTool(name, description) {
+    return {
+        name,
+        description,
+        inputSchema: { type: 'object', properties: {} },
+    };
+}
+describe('ToolSearchEngine', () => {
+    const testTools = [
+        makeTool('page_navigate', 'Navigate to a URL in the browser tab'),
+        makeTool('debugger_pause', 'Pause JavaScript execution at the current point'),
+        makeTool('breakpoint_set', 'Set a breakpoint at a specific line in a script'),
+        makeTool('network_get_requests', 'Get captured network requests with filtering options'),
+        makeTool('ws_monitor_enable', 'Enable WebSocket frame monitoring'),
+        makeTool('wasm_dump', 'Dump WebAssembly module binary from page memory'),
+        makeTool('binary_decode', 'Decode binary data from various formats (base64, hex, etc.)'),
+        makeTool('captcha_detect', 'Detect CAPTCHA challenges on the current page'),
+        makeTool('antidebug_bypass_all', 'Bypass all detected anti-debugging protections'),
+        makeTool('page_screenshot', 'Take a screenshot of the current page'),
+    ];
+    it('finds exact name matches with high score', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('page_navigate');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('page_navigate');
+    });
+    it('finds tools by description keywords', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('breakpoint');
+        const names = results.map((r) => r.name);
+        expect(names).toContain('breakpoint_set');
+    });
+    it('finds tools by partial name (prefix match)', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('debug');
+        const names = results.map((r) => r.name);
+        expect(names).toContain('debugger_pause');
+    });
+    it('returns empty for nonsense query', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('xyzzy12345');
+        expect(results.length).toBe(0);
+    });
+    it('respects top_k limit', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('page', 2);
+        expect(results.length).toBeLessThanOrEqual(2);
+    });
+    it('multi-word queries combine scores', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('websocket monitor');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('ws_monitor_enable');
+    });
+    it('marks active tools correctly', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const activeNames = new Set(['page_navigate']);
+        const results = engine.search('page', 5, activeNames);
+        const navResult = results.find((r) => r.name === 'page_navigate');
+        const ssResult = results.find((r) => r.name === 'page_screenshot');
+        expect(navResult?.isActive).toBe(true);
+        expect(ssResult?.isActive).toBe(false);
+    });
+    it('results include shortDescription', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('captcha');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].shortDescription).toBeTruthy();
+        expect(results[0].shortDescription.length).toBeGreaterThan(0);
+    });
+    it('getDomainSummary returns domain breakdown', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const summary = engine.getDomainSummary();
+        expect(summary.length).toBeGreaterThan(0);
+        const totalTools = summary.reduce((acc, s) => acc + s.count, 0);
+        expect(totalTools).toBe(testTools.length);
+    });
+    it('searches against real allTools catalog', () => {
+        const engine = new ToolSearchEngine();
+        const results = engine.search('breakpoint');
+        expect(results.length).toBeGreaterThan(0);
+        const names = results.map((r) => r.name);
+        expect(names).toContain('breakpoint_set');
+        expect(names).toContain('breakpoint_remove');
+        expect(names).toContain('breakpoint_list');
+    });
+    it('handles empty query gracefully', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('');
+        expect(results).toEqual([]);
+    });
+    it('scores name matches higher than description matches', () => {
+        const engine = new ToolSearchEngine(testTools);
+        const results = engine.search('wasm');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('wasm_dump');
+    });
+    it('applies domain score multipliers for workflow-biased ranking', () => {
+        const rankedTools = [
+            makeTool('browser_flow_helper', 'Execute a reusable flow helper'),
+            makeTool('workflow_flow_helper', 'Execute a reusable flow helper'),
+        ];
+        const domainOverrides = new Map([
+            ['browser_flow_helper', 'browser'],
+            ['workflow_flow_helper', 'workflow'],
+        ]);
+        const domainScoreMultipliers = new Map([['workflow', 1.5]]);
+        const engine = new ToolSearchEngine(rankedTools, domainOverrides, domainScoreMultipliers);
+        const results = engine.search('execute reusable flow');
+        expect(results.length).toBeGreaterThan(1);
+        expect(results[0].name).toBe('workflow_flow_helper');
+    });
+    it('expands Chinese workflow intent terms for API capture queries', () => {
+        const rankedTools = [
+            makeTool('web_api_capture_session', 'Capture API requests and export HAR in one workflow'),
+            makeTool('page_navigate', 'Navigate to a URL in the browser tab'),
+        ];
+        const domainOverrides = new Map([
+            ['web_api_capture_session', 'workflow'],
+            ['page_navigate', 'browser'],
+        ]);
+        const domainScoreMultipliers = new Map([['workflow', 1.5]]);
+        const engine = new ToolSearchEngine(rankedTools, domainOverrides, domainScoreMultipliers);
+        const results = engine.search('抓取接口');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('web_api_capture_session');
+    });
+    it('expands Chinese registration intent for workflow onboarding tools', () => {
+        const rankedTools = [
+            makeTool('register_account_flow', 'Automate account registration with email verification'),
+            makeTool('page_type', 'Type text into an input field'),
+        ];
+        const domainOverrides = new Map([
+            ['register_account_flow', 'workflow'],
+            ['page_type', 'browser'],
+        ]);
+        const domainScoreMultipliers = new Map([['workflow', 1.5]]);
+        const engine = new ToolSearchEngine(rankedTools, domainOverrides, domainScoreMultipliers);
+        const results = engine.search('账号注册验证');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('register_account_flow');
+    });
+    it('applies explicit intent-to-tool boosts for zero-overlap intent phrases', () => {
+        const rankedTools = [
+            makeTool('web_api_capture_session', 'Composite flow helper without API keywords'),
+            makeTool('api_probe_batch', 'Composite flow helper without probe keywords'),
+            makeTool('page_navigate', 'Navigate to a URL in the browser tab'),
+        ];
+        const domainOverrides = new Map([
+            ['web_api_capture_session', 'workflow'],
+            ['api_probe_batch', 'workflow'],
+            ['page_navigate', 'browser'],
+        ]);
+        const domainScoreMultipliers = new Map([['workflow', 1.5]]);
+        const engine = new ToolSearchEngine(rankedTools, domainOverrides, domainScoreMultipliers);
+        const results = engine.search('端到端闭环');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('web_api_capture_session');
+        expect(results.some((r) => r.name === 'api_probe_batch')).toBe(true);
+    });
+    it('applies tool score multipliers for extension-priority ranking', () => {
+        const rankedTools = [
+            makeTool('builtin_flow_search', 'Inspect flow details and capture outputs'),
+            makeTool('plugin_flow_search', 'Inspect flow details and capture outputs'),
+        ];
+        const toolScoreMultipliers = new Map([['plugin_flow_search', 1.12]]);
+        const engine = new ToolSearchEngine(rankedTools, undefined, undefined, toolScoreMultipliers);
+        const results = engine.search('inspect flow capture');
+        expect(results.length).toBeGreaterThan(1);
+        expect(results[0].name).toBe('plugin_flow_search');
+    });
+    it('prioritizes workflow entry tools for register/captcha/keygen intent', () => {
+        const rankedTools = [
+            makeTool('run_extension_workflow', 'Execute extension workflow by workflowId'),
+            makeTool('list_extension_workflows', 'List loaded extension workflows'),
+            makeTool('register_account_flow', 'Automate account registration flow'),
+            makeTool('page_type', 'Type text into an input field'),
+        ];
+        const domainOverrides = new Map([
+            ['run_extension_workflow', 'workflow'],
+            ['list_extension_workflows', 'workflow'],
+            ['register_account_flow', 'workflow'],
+            ['page_type', 'browser'],
+        ]);
+        const domainScoreMultipliers = new Map([['workflow', 1.5]]);
+        const engine = new ToolSearchEngine(rankedTools, domainOverrides, domainScoreMultipliers);
+        const results = engine.search('账号注册 验证码 keygen');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].name).toBe('run_extension_workflow');
+        expect(results.some((r) => r.name === 'list_extension_workflows')).toBe(true);
+    });
+    describe('TF-IDF cosine hybrid scoring (§4.1.3)', () => {
+        it('boosts semantically aligned results via TF-IDF cosine', () => {
+            const tools = [
+                makeTool('network_capture', 'Capture and inspect HTTP network requests and responses'),
+                makeTool('page_click', 'Click an element on the page'),
+                makeTool('network_replay', 'Replay captured HTTP network requests for testing'),
+            ];
+            const engine = new ToolSearchEngine(tools);
+            const results = engine.search('capture network requests');
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].name).toBe('network_capture');
+            expect(results.some((r) => r.name === 'network_replay')).toBe(true);
+        });
+        it('cosine boost does not harm unrelated tools (no false positives)', () => {
+            const tools = [
+                makeTool('wasm_dump', 'Dump WebAssembly module binary'),
+                makeTool('page_navigate', 'Navigate to a URL'),
+            ];
+            const engine = new ToolSearchEngine(tools);
+            const results = engine.search('wasm binary module');
+            expect(results[0].name).toBe('wasm_dump');
+        });
+    });
+    describe('tool affinity graph (§4.1.4)', () => {
+        it('boosts prefix-group neighbors of top results', () => {
+            const tools = [
+                makeTool('breakpoint_set', 'Set a breakpoint at a line'),
+                makeTool('breakpoint_list', 'List all active breakpoints'),
+                makeTool('breakpoint_remove', 'Remove a breakpoint'),
+                makeTool('page_navigate', 'Navigate to a URL'),
+            ];
+            const engine = new ToolSearchEngine(tools);
+            const results = engine.search('set breakpoint');
+            const names = results.map((r) => r.name);
+            expect(names[0]).toBe('breakpoint_set');
+            expect(names).toContain('breakpoint_list');
+            expect(names).toContain('breakpoint_remove');
+        });
+        it('prefix affinity decays for larger groups', () => {
+            const tools = Array.from({ length: 10 }, (_, i) => makeTool(`test_tool_${i}`, `Test tool number ${i} for general testing`));
+            tools.push(makeTool('other_thing', 'Something completely different'));
+            const engine = new ToolSearchEngine(tools);
+            const results = engine.search('test tool 0');
+            expect(results[0].name).toBe('test_tool_0');
+        });
+    });
+    describe('domain hub expansion (§4.1.4)', () => {
+        it('applies coherence boost when domain is concentrated in top results', () => {
+            const tools = [
+                makeTool('debug_pause', 'Pause execution'),
+                makeTool('debug_eval', 'Evaluate expression in paused context'),
+                makeTool('debug_step', 'Step over next statement'),
+                makeTool('debug_resume', 'Resume execution after pause'),
+                makeTool('page_navigate', 'Navigate to a URL'),
+            ];
+            const domainOverrides = new Map([
+                ['debug_pause', 'debugger'],
+                ['debug_eval', 'debugger'],
+                ['debug_step', 'debugger'],
+                ['debug_resume', 'debugger'],
+                ['page_navigate', 'browser'],
+            ]);
+            const engine = new ToolSearchEngine(tools, domainOverrides);
+            const results = engine.search('debug pause eval step');
+            const names = results.map((r) => r.name);
+            expect(names).toContain('debug_resume');
+        });
+    });
+    describe('query category adaptive weights (§4.1.3)', () => {
+        it('boosts security domain tools for security-related queries', () => {
+            const tools = [
+                makeTool('sec_scan', 'Scan for security vulnerabilities'),
+                makeTool('page_scan', 'Scan page for elements'),
+            ];
+            const domainOverrides = new Map([
+                ['sec_scan', 'security'],
+                ['page_scan', 'browser'],
+            ]);
+            const engine = new ToolSearchEngine(tools, domainOverrides);
+            const results = engine.search('scan for xss vulnerability');
+            expect(results[0].name).toBe('sec_scan');
+        });
+        it('boosts debugger domain tools for debug-related queries', () => {
+            const tools = [
+                makeTool('dbg_helper', 'Helper for debugging sessions'),
+                makeTool('page_helper', 'Helper for page interaction'),
+            ];
+            const domainOverrides = new Map([
+                ['dbg_helper', 'debugger'],
+                ['page_helper', 'browser'],
+            ]);
+            const engine = new ToolSearchEngine(tools, domainOverrides);
+            const results = engine.search('debug breakpoint helper');
+            expect(results[0].name).toBe('dbg_helper');
+        });
+        it('boosts network domain tools for network-related queries', () => {
+            const tools = [
+                makeTool('net_inspect', 'Inspect network traffic details'),
+                makeTool('code_inspect', 'Inspect source code structure'),
+            ];
+            const domainOverrides = new Map([
+                ['net_inspect', 'network'],
+                ['code_inspect', 'analysis'],
+            ]);
+            const engine = new ToolSearchEngine(tools, domainOverrides);
+            const results = engine.search('inspect request response headers');
+            expect(results[0].name).toBe('net_inspect');
+        });
+    });
+    describe('query result LRU cache (§4.3 CSAPC)', () => {
+        it('returns cached results for identical queries', () => {
+            const engine = new ToolSearchEngine(testTools);
+            const first = engine.search('page navigate');
+            const second = engine.search('page navigate');
+            expect(first.map((r) => r.name)).toEqual(second.map((r) => r.name));
+            expect(first.map((r) => r.score)).toEqual(second.map((r) => r.score));
+        });
+        it('updates isActive on cache hit without re-scoring', () => {
+            const engine = new ToolSearchEngine(testTools);
+            const first = engine.search('page navigate', 5, new Set());
+            const second = engine.search('page navigate', 5, new Set(['page_navigate']));
+            expect(first.map((r) => r.score)).toEqual(second.map((r) => r.score));
+            const navFirst = first.find((r) => r.name === 'page_navigate');
+            const navSecond = second.find((r) => r.name === 'page_navigate');
+            expect(navFirst?.isActive).toBe(false);
+            expect(navSecond?.isActive).toBe(true);
+        });
+        it('does not confuse different queries', () => {
+            const engine = new ToolSearchEngine(testTools);
+            const wasm = engine.search('wasm dump');
+            const captcha = engine.search('captcha detect');
+            expect(wasm[0].name).toBe('wasm_dump');
+            expect(captcha[0].name).toBe('captcha_detect');
+        });
+    });
+});

package/dist/tests/server/discovery.test.d.ts

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

package/dist/tests/server/discovery.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@src/utils/logger', () => ({
+    logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+const { discoverDomainManifests } = await import('../../src/server/registry/discovery.js');
+describe('discoverDomainManifests', () => {
+    it('returns an array of valid domain manifests', async () => {
+        const manifests = await discoverDomainManifests();
+        expect(Array.isArray(manifests)).toBe(true);
+        for (const manifest of manifests) {
+            expect(manifest.kind).toBe('domain-manifest');
+            expect(manifest.version).toBe(1);
+            expect(typeof manifest.domain).toBe('string');
+            expect(typeof manifest.depKey).toBe('string');
+            expect(Array.isArray(manifest.profiles)).toBe(true);
+            expect(Array.isArray(manifest.registrations)).toBe(true);
+            expect(typeof manifest.ensure).toBe('function');
+        }
+    });
+    it('discovers domains without duplicate domain names', async () => {
+        const manifests = await discoverDomainManifests();
+        const domainNames = manifests.map((m) => m.domain);
+        const uniqueNames = new Set(domainNames);
+        expect(domainNames.length).toBe(uniqueNames.size);
+    });
+    it('discovers domains without duplicate depKeys', async () => {
+        const manifests = await discoverDomainManifests();
+        const depKeys = manifests.map((m) => m.depKey);
+        const uniqueKeys = new Set(depKeys);
+        expect(depKeys.length).toBe(uniqueKeys.size);
+    });
+    it('every domain has at least one registration', async () => {
+        const manifests = await discoverDomainManifests();
+        for (const manifest of manifests) {
+            expect(manifest.registrations.length, `Domain "${manifest.domain}" should have at least one registration`).toBeGreaterThan(0);
+        }
+    });
+    it('every registration has a valid tool definition', async () => {
+        const manifests = await discoverDomainManifests();
+        for (const manifest of manifests) {
+            for (const reg of manifest.registrations) {
+                expect(typeof reg.tool.name).toBe('string');
+                expect(reg.tool.name.length).toBeGreaterThan(0);
+                expect(typeof reg.bind).toBe('function');
+            }
+        }
+    });
+    it('no two registrations share the same tool name across all domains', async () => {
+        const manifests = await discoverDomainManifests();
+        const toolNames = [];
+        for (const manifest of manifests) {
+            for (const reg of manifest.registrations) {
+                toolNames.push(reg.tool.name);
+            }
+        }
+        const uniqueNames = new Set(toolNames);
+        expect(toolNames.length).toBe(uniqueNames.size);
+    });
+});

package/dist/tests/server/domains/analysis/handlers.test.d.ts

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

package/dist/tests/server/domains/analysis/handlers.test.js

@@ -0,0 +1,184 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CoreAnalysisHandlers } from '../../../../src/server/domains/analysis/handlers.js';
+const webcrackState = vi.hoisted(() => ({
+    runWebcrack: vi.fn(async () => ({
+        applied: true,
+        code: 'decoded-bundle',
+        bundle: {
+            type: 'webpack',
+            entryId: '0',
+            moduleCount: 1,
+            truncated: false,
+            modules: [{ id: '0', path: './index.js', isEntry: true, size: 12, code: 'decoded-bundle' }],
+        },
+        savedTo: 'artifacts/webcrack',
+        optionsUsed: { jsx: true, mangle: false, unminify: true, unpack: true },
+    })),
+}));
+vi.mock('@modules/deobfuscator/webcrack', () => ({
+    runWebcrack: webcrackState.runWebcrack,
+}));
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('CoreAnalysisHandlers', () => {
+    const deps = {
+        collector: { collect: vi.fn(), getActivePage: vi.fn() },
+        scriptManager: { init: vi.fn(), searchInScripts: vi.fn(), extractFunctionTree: vi.fn() },
+        deobfuscator: { deobfuscate: vi.fn() },
+        advancedDeobfuscator: { deobfuscate: vi.fn() },
+        obfuscationDetector: { detect: vi.fn(), generateReport: vi.fn() },
+        analyzer: { understand: vi.fn() },
+        cryptoDetector: { detect: vi.fn() },
+        hookManager: {
+            createHook: vi.fn(),
+            getAllHooks: vi.fn(),
+            getHookRecords: vi.fn(),
+            clearHookRecords: vi.fn(),
+        },
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        webcrackState.runWebcrack.mockClear();
+        handlers = new CoreAnalysisHandlers(deps);
+    });
+    it('rejects deobfuscate when code is missing', async () => {
+        const body = parseJson(await handlers.handleDeobfuscate({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('code is required');
+    });
+    it('delegates deobfuscate to deobfuscator', async () => {
+        deps.deobfuscator.deobfuscate.mockResolvedValue({ success: true, code: 'x' });
+        const body = parseJson(await handlers.handleDeobfuscate({ code: 'a()', llm: 'provider-a', aggressive: true }));
+        expect(deps.deobfuscator.deobfuscate).toHaveBeenCalledWith({
+            code: 'a()',
+            llm: 'provider-a',
+            aggressive: true,
+        });
+        expect(body.success).toBe(true);
+    });
+    it('passes webcrack-specific options through deobfuscate', async () => {
+        deps.deobfuscator.deobfuscate.mockResolvedValue({ success: true, code: 'decoded' });
+        await handlers.handleDeobfuscate({
+            code: 'bundle',
+            unpack: false,
+            unminify: false,
+            jsx: false,
+            mangle: true,
+            outputDir: 'artifacts/deobf',
+            forceOutput: true,
+            includeModuleCode: true,
+            maxBundleModules: 10,
+            mappings: [{ path: './main.js', pattern: 'bootstrap', matchType: 'includes', target: 'code' }],
+        });
+        expect(deps.deobfuscator.deobfuscate).toHaveBeenCalledWith({
+            code: 'bundle',
+            unpack: false,
+            unminify: false,
+            jsx: false,
+            mangle: true,
+            outputDir: 'artifacts/deobf',
+            forceOutput: true,
+            includeModuleCode: true,
+            maxBundleModules: 10,
+            mappings: [{ path: './main.js', pattern: 'bootstrap', matchType: 'includes', target: 'code' }],
+        });
+    });
+    it('creates hook with default action in manage hooks', async () => {
+        deps.hookManager.createHook.mockResolvedValue({ success: true, id: 'h1' });
+        const body = parseJson(await handlers.handleManageHooks({
+            action: 'create',
+            target: 'fetch',
+            type: 'fetch',
+        }));
+        expect(deps.hookManager.createHook).toHaveBeenCalledWith({
+            target: 'fetch',
+            type: 'fetch',
+            action: 'log',
+            customCode: undefined,
+        });
+        expect(body.id).toBe('h1');
+    });
+    it('returns graceful error for unknown hook action', async () => {
+        const result = await handlers.handleManageHooks({ action: 'nope' });
+        const body = parseJson(result);
+        expect(body.success).toBe(false);
+        expect(body.message).toMatch(/Unknown hook action/);
+    });
+    it('delegates advanced deobfuscate directly to webcrack-backed implementation', async () => {
+        deps.advancedDeobfuscator.deobfuscate.mockResolvedValue({
+            code: 'raw',
+            success: true,
+            astOptimized: false,
+            warnings: [
+                'useASTOptimization is deprecated and ignored; legacy AST post-processing has been removed.',
+            ],
+        });
+        const body = parseJson(await handlers.handleAdvancedDeobfuscate({
+            code: 'obf',
+            useASTOptimization: true,
+            aggressiveVM: true,
+            timeout: 3210,
+            unpack: false,
+        }));
+        expect(deps.advancedDeobfuscator.deobfuscate).toHaveBeenCalledWith({
+            code: 'obf',
+            useASTOptimization: true,
+            aggressiveVM: true,
+            timeout: 3210,
+            unpack: false,
+        });
+        expect(body.code).toBe('raw');
+        expect(body.astOptimized).toBe(false);
+    });
+    it('does not inject deprecated defaults when advanced args are omitted', async () => {
+        deps.advancedDeobfuscator.deobfuscate.mockResolvedValue({ code: 'raw2', success: true });
+        await handlers.handleAdvancedDeobfuscate({ code: 'obf' });
+        expect(deps.advancedDeobfuscator.deobfuscate).toHaveBeenCalledWith({
+            code: 'obf',
+        });
+    });
+    it('runs webcrack_unpack directly and returns bundle details', async () => {
+        const response = parseJson(await handlers.handleWebcrackUnpack({
+            code: 'bundle',
+            includeModuleCode: true,
+            maxBundleModules: 5,
+        }));
+        expect(response.success).toBe(true);
+        expect(response.engine).toBe('webcrack');
+        expect(response.optionsUsed).toBeDefined();
+        expect(webcrackState.runWebcrack).toHaveBeenCalledWith('bundle', {
+            unpack: true,
+            unminify: true,
+            jsx: true,
+            mangle: false,
+            includeModuleCode: true,
+            maxBundleModules: 5,
+        });
+    });
+    it('returns structured error when webcrack_unpack fails', async () => {
+        webcrackState.runWebcrack.mockResolvedValueOnce({
+            applied: false,
+            code: 'original-code',
+            optionsUsed: { jsx: true, mangle: false, unminify: true, unpack: true },
+            reason: 'webcrack requires Node.js 22+; current runtime is 20.0.0',
+        });
+        const response = parseJson(await handlers.handleWebcrackUnpack({ code: 'original-code' }));
+        expect(response.success).toBe(false);
+        expect(response.error).toBe('webcrack requires Node.js 22+; current runtime is 20.0.0');
+        expect(response.optionsUsed).toEqual({ jsx: true, mangle: false, unminify: true, unpack: true });
+        expect(response.engine).toBe('webcrack');
+    });
+    it('returns structured error when webcrack_unpack fails without reason', async () => {
+        webcrackState.runWebcrack.mockResolvedValueOnce({
+            applied: false,
+            code: 'original-code',
+            optionsUsed: { jsx: true, mangle: false, unminify: true, unpack: true },
+        });
+        const response = parseJson(await handlers.handleWebcrackUnpack({ code: 'original-code' }));
+        expect(response.success).toBe(false);
+        expect(response.error).toBe('webcrack execution failed');
+        expect(response.engine).toBe('webcrack');
+    });
+});

package/dist/tests/server/domains/antidebug/handlers.test.d.ts

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