@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/tests/e2e/helpers/types.d.ts

@@ -0,0 +1,30 @@
+export type CallFn = (name: string, args: Record<string, unknown>, timeoutMs?: number) => Promise<unknown>;
+export interface Phase {
+    name: string;
+    setup: string[] | ((call: CallFn) => Promise<void>);
+    tools: string[];
+}
+export interface E2EContext {
+    scriptId: string | null;
+    breakpointId: string | null;
+    requestId: string | null;
+    hookId: string | null;
+    objectId: string | null;
+}
+export interface ToolResult {
+    name: string;
+    ok: boolean;
+    isError: boolean;
+    detail: string;
+}
+export interface E2EConfig {
+    targetUrl: string;
+    targetDomain: string;
+    electronPath: string;
+    miniappPath: string;
+    asarPath: string;
+    browserPath: string;
+    perToolTimeout: number;
+    skipSet: Set<string>;
+    artifactDir: string;
+}

package/dist/tests/e2e/helpers/types.js

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

package/dist/tests/e2e/overrides.d.ts

@@ -0,0 +1,2 @@
+import type { E2EContext, E2EConfig } from '../e2e/helpers/types.js';
+export declare function getOverrides(ctx: E2EContext, config: E2EConfig): Record<string, Record<string, unknown>>;

package/dist/tests/e2e/overrides.js

@@ -0,0 +1,149 @@
+export function getOverrides(ctx, config) {
+    const { targetUrl, targetDomain, artifactDir, browserPath, asarPath, electronPath, miniappPath } = config;
+    return {
+        browser_launch: { headless: false },
+        browser_attach: { endpoint: 'http://localhost:9222' },
+        page_navigate: { url: targetUrl },
+        page_evaluate: { code: 'document.title' },
+        page_click: { selector: 'body' },
+        page_type: { selector: 'body', text: 'e2e' },
+        page_select: { selector: '#test_select_e2e', values: ['b'] },
+        page_hover: { selector: 'body' },
+        page_scroll: { direction: 'down', amount: 100 },
+        page_press_key: { key: 'Escape' },
+        page_wait_for_selector: { selector: 'body', timeout: 3000 },
+        page_inject_script: { code: 'window.__e2e_injected = true;' },
+        page_set_viewport: { width: 1280, height: 720 },
+        page_emulate_device: { device: 'iPhone 14' },
+        page_set_cookies: { cookies: [{ name: 'e2e', value: '1', domain: targetDomain }] },
+        page_set_local_storage: { key: 'e2e_test', value: 'hello' },
+        page_back: {}, page_forward: {}, page_reload: {},
+        page_screenshot: { selector: ['.VPNav', '.VPHero', '.VPFeatures'], path: `${artifactDir}/screenshot.png` },
+        page_script_register: { name: 'e2e_lib', code: 'function e2eHelper() { return 42; }' },
+        page_script_run: { name: 'e2e_lib' },
+        dom_query_selector: { selector: 'body' },
+        dom_query_all: { selector: 'div' },
+        dom_get_structure: { selector: 'body', depth: 2 },
+        dom_find_clickable: {}, dom_find_by_text: { text: 'test' },
+        dom_get_xpath: { selector: 'body' },
+        dom_is_in_viewport: { selector: 'body' },
+        dom_get_computed_style: { selector: 'body' },
+        console_enable: { enableNetwork: true },
+        console_execute: { code: '1+1' },
+        console_inject_function_tracer: { functionName: 'fetch' },
+        debugger_evaluate: { expression: '1+1' },
+        debugger_evaluate_global: { expression: 'document.title' },
+        debugger_wait_for_paused: { timeout: 3000 },
+        breakpoint_set: ctx.scriptId ? { scriptId: ctx.scriptId, lineNumber: 1 } : { url: targetUrl, lineNumber: 1 },
+        breakpoint_remove: { breakpointId: ctx.breakpointId || '__placeholder__' },
+        breakpoint_set_on_exception: { state: 'all' },
+        breakpoint_list: {},
+        xhr_breakpoint_set: { urlPattern: '/api/' },
+        xhr_breakpoint_list: {},
+        event_breakpoint_set: { eventName: 'click' },
+        event_breakpoint_set_category: { category: 'mouse' },
+        event_breakpoint_list: {},
+        watch_add: { expression: 'window.location.href' },
+        watch_list: {}, watch_evaluate_all: {},
+        get_scope_variables_enhanced: {},
+        debugger_get_paused_state: {},
+        debugger_step_into: {}, debugger_step_out: {},
+        network_enable: {},
+        network_get_requests: {},
+        network_get_response_body: { requestId: ctx.requestId || '__placeholder__' },
+        network_get_stats: {}, network_get_status: {},
+        network_extract_auth: {},
+        network_export_har: { path: `${artifactDir}/network.har` },
+        network_replay_request: { requestId: ctx.requestId || '__placeholder__' },
+        performance_get_metrics: {},
+        performance_trace_stop: {}, profiler_cpu_stop: {},
+        profiler_heap_sampling_stop: {},
+        performance_stop_coverage: {},
+        performance_take_heap_snapshot: {},
+        ws_monitor_enable: {}, sse_monitor_enable: {},
+        ws_get_frames: {}, ws_get_connections: {}, sse_get_events: {},
+        binary_detect_format: { data: 'SGVsbG8=' },
+        binary_decode: { data: 'SGVsbG8=', format: 'base64' },
+        binary_encode: { data: 'Hello', format: 'base64' },
+        binary_entropy_analysis: { data: 'SGVsbG8gV29ybGQ=' },
+        protobuf_decode_raw: { data: 'CAESBXdvcmxk' },
+        manage_hooks: { action: 'list' },
+        ai_hook_generate: { target: 'fetch', description: 'log fetch calls' },
+        ai_hook_inject: { hookId: ctx.hookId || '__placeholder__' },
+        ai_hook_toggle: { hookId: ctx.hookId || '__placeholder__', enabled: true },
+        ai_hook_get_data: { hookId: ctx.hookId || '__placeholder__' },
+        ai_hook_export: {}, ai_hook_clear: {}, ai_hook_list: {},
+        hook_preset: { presetName: 'network_monitor' },
+        deobfuscate: { code: 'var a = 1;' },
+        advanced_deobfuscate: { code: 'var a = 1;' },
+        webcrack_unpack: { code: 'var a = 1;' },
+        understand_code: { code: 'function add(a,b){return a+b}' },
+        detect_obfuscation: { code: 'eval(atob("YWxlcnQoMSk="))' },
+        detect_crypto: { code: 'crypto.subtle.digest("SHA-256", data)' },
+        search_in_scripts: { keyword: 'fetch' },
+        collect_code: { url: targetUrl, returnSummaryOnly: true },
+        graphql_introspect: { url: targetUrl },
+        graphql_extract_queries: {},
+        graphql_replay: { url: targetUrl, query: '{ __typename }' },
+        script_replace_persist: { scriptId: ctx.scriptId || '1', searchPattern: '__never_match_e2e__', replacement: '__never_match_e2e__' },
+        call_graph_analyze: { code: 'function a(){b()} function b(){return 1}' },
+        ast_transform_preview: { code: 'var a = 1;', transform: 'rename' },
+        ast_transform_apply: { code: 'var a = 1;', transform: 'rename' },
+        ast_transform_chain: { code: 'var a = 1;', transforms: ['rename'] },
+        crypto_compare: { code1: 'CryptoJS.AES.encrypt(a, b)', code2: 'CryptoJS.AES.decrypt(c, d)' },
+        crypto_extract_standalone: { code: 'CryptoJS.AES.encrypt(data, key)' },
+        crypto_test_harness: { code: 'CryptoJS.AES.encrypt(data, key)' },
+        blackbox_add: { pattern: '/node_modules/' },
+        process_get: { pid: 0 }, process_list: {}, process_windows: {},
+        process_find: { pattern: 'browser' }, process_find_chromium: {},
+        process_launch_debug: { executablePath: browserPath, debugPort: 19222, args: ['--headless'] },
+        process_check_debug_port: { port: 9222 },
+        wasm_dump: { url: targetUrl },
+        wasm_decompile: { url: targetUrl }, wasm_disassemble: { url: targetUrl },
+        wasm_inspect_sections: { url: targetUrl },
+        wasm_memory_inspect: {}, wasm_optimize: { url: targetUrl }, wasm_vmp_trace: {},
+        antidebug_detect_protections: {},
+        antidebug_bypass_all: {}, antidebug_bypass_debugger_statement: {},
+        antidebug_bypass_console_detect: {},
+        antidebug_bypass_stack_trace: {}, antidebug_bypass_timing: {},
+        source_map_extract: { url: targetUrl },
+        sourcemap_fetch_and_parse: { url: targetUrl },
+        sourcemap_reconstruct_tree: {}, sourcemap_discover: {},
+        extension_list_installed: {},
+        stealth_inject: {},
+        stealth_set_user_agent: { userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Browser/120.0.0.0' },
+        captcha_detect: {}, captcha_config: { provider: '2captcha', apiKey: 'test' },
+        camoufox_server_status: {},
+        browser_select_tab: { index: 0 },
+        tab_workflow: { action: 'list' }, webpack_enumerate: {},
+        js_heap_search: { query: 'fetch' },
+        indexeddb_dump: {}, framework_state_extract: {},
+        get_object_properties: { objectId: ctx.objectId || '__placeholder__' },
+        web_api_capture_session: { url: targetUrl },
+        api_probe_batch: { urls: [targetUrl] },
+        js_bundle_search: { pattern: 'fetch' },
+        get_token_budget_stats: {}, get_cache_stats: {}, get_collection_stats: {},
+        boost_profile: { profile: 'full' }, unboost_profile: {},
+        asar_extract: { inputPath: asarPath || '__placeholder__' },
+        electron_inspect_app: { appPath: electronPath || '__placeholder__' },
+        miniapp_pkg_scan: { searchPath: miniappPath || '__placeholder__' },
+        miniapp_pkg_unpack: { inputPath: miniappPath || '__placeholder__' },
+        miniapp_pkg_analyze: { unpackedDir: miniappPath || '__placeholder__' },
+        memory_check_protection: { pid: 0, address: '0x0' },
+        memory_read: { pid: 0, address: '0x0', size: 16 },
+        memory_scan: { pid: 0, pattern: 'test' },
+        memory_scan_filtered: { pid: 0, pattern: 'test' },
+        memory_audit_export: { pid: 0, outputPath: `${artifactDir}/memory-audit.json` },
+        human_mouse: { selector: 'body' },
+        human_scroll: { direction: 'down', amount: 200 },
+        human_typing: { selector: 'body', text: 'e2e' },
+        captcha_vision_solve: {},
+        widget_challenge_solve: {},
+        list_extensions: {},
+        reload_extensions: {},
+        browse_extension_registry: {},
+        batch_register: { tools: [] },
+        list_extension_workflows: {},
+        run_extension_workflow: { workflowId: '__placeholder__' },
+    };
+}

package/dist/tests/e2e/phases/analysis-phases.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const analysisPhases: Phase[];

package/dist/tests/e2e/phases/analysis-phases.js

@@ -0,0 +1,30 @@
+export const analysisPhases = [
+    {
+        name: 'Encoding & Binary',
+        setup: [],
+        tools: ['binary_detect_format', 'binary_decode', 'binary_encode', 'binary_entropy_analysis', 'protobuf_decode_raw'],
+    },
+    {
+        name: 'Analysis & Deobfuscation',
+        setup: [],
+        tools: ['deobfuscate', 'advanced_deobfuscate', 'webcrack_unpack', 'understand_code', 'detect_obfuscation', 'detect_crypto', 'extract_function_tree'],
+    },
+    {
+        name: 'Hooks',
+        setup: [],
+        tools: [
+            'manage_hooks', 'ai_hook_generate', 'ai_hook_inject', 'ai_hook_toggle',
+            'ai_hook_get_data', 'ai_hook_list', 'ai_hook_export', 'ai_hook_clear', 'hook_preset',
+        ],
+    },
+    {
+        name: 'GraphQL',
+        setup: [],
+        tools: ['graphql_introspect', 'graphql_extract_queries', 'graphql_replay', 'call_graph_analyze'],
+    },
+    {
+        name: 'Transform & Crypto',
+        setup: [],
+        tools: ['ast_transform_preview', 'ast_transform_apply', 'ast_transform_chain', 'crypto_extract_standalone', 'crypto_test_harness', 'crypto_compare'],
+    },
+];

package/dist/tests/e2e/phases/browser-phases.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const browserPhases: Phase[];

package/dist/tests/e2e/phases/browser-phases.js

@@ -0,0 +1,59 @@
+export const browserPhases = [
+    {
+        name: 'Browser Launch & Navigation',
+        setup: ['browser_launch', 'page_navigate'],
+        tools: ['browser_status', 'browser_list_tabs', 'browser_select_tab', 'page_get_performance'],
+    },
+    {
+        name: 'DOM & Page Interaction',
+        setup: [],
+        tools: [
+            'dom_query_selector', 'dom_query_all', 'dom_get_structure',
+            'dom_find_clickable', 'dom_find_by_text', 'dom_get_xpath',
+            'dom_is_in_viewport', 'dom_get_computed_style',
+            'page_click', 'page_type', 'page_hover', 'page_scroll',
+            'page_back', 'page_forward', 'page_reload',
+            'page_press_key', 'page_wait_for_selector',
+            'page_evaluate', 'page_inject_script',
+            'page_get_all_links', 'page_screenshot',
+            'page_set_viewport', 'page_emulate_device',
+        ],
+    },
+    {
+        name: 'Cookies & Storage',
+        setup: [],
+        tools: ['page_get_cookies', 'page_set_cookies', 'page_clear_cookies', 'page_get_local_storage', 'page_set_local_storage'],
+    },
+    { name: 'IndexedDB', setup: [], tools: ['indexeddb_dump'] },
+    {
+        name: 'Page Select (needs injected element)',
+        setup: async (call) => {
+            await call('page_evaluate', { code: `
+        if (!document.querySelector('#test_select_e2e')) {
+          const s = document.createElement('select');
+          s.id = 'test_select_e2e';
+          s.innerHTML = '<option value="a">A</option><option value="b">B</option>';
+          document.body.appendChild(s);
+        }
+        'ok'
+      ` });
+        },
+        tools: ['page_select'],
+    },
+    {
+        name: 'Stealth & Captcha',
+        setup: [],
+        tools: ['stealth_inject', 'stealth_set_user_agent', 'captcha_detect', 'captcha_config'],
+    },
+    { name: 'Camoufox', setup: [], tools: ['camoufox_server_status'] },
+    {
+        name: 'Human Behavior Simulation',
+        setup: [],
+        tools: ['human_mouse', 'human_scroll', 'human_typing'],
+    },
+    {
+        name: 'Captcha Advanced',
+        setup: [],
+        tools: ['captcha_vision_solve', 'widget_challenge_solve'],
+    },
+];

package/dist/tests/e2e/phases/debugger-phases.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const debuggerPhases: Phase[];

package/dist/tests/e2e/phases/debugger-phases.js

@@ -0,0 +1,44 @@
+export const debuggerPhases = [
+    { name: 'Debugger Enable', setup: ['debugger_enable'], tools: [] },
+    {
+        name: 'Scripts & Source',
+        setup: [],
+        tools: ['get_all_scripts', 'get_script_source', 'get_detailed_data', 'collect_code', 'search_in_scripts'],
+    },
+    {
+        name: 'Breakpoints',
+        setup: [],
+        tools: ['breakpoint_set_on_exception', 'breakpoint_set', 'breakpoint_list', 'breakpoint_remove'],
+    },
+    {
+        name: 'XHR & Event Breakpoints',
+        setup: [],
+        tools: [
+            'xhr_breakpoint_set', 'xhr_breakpoint_list', 'xhr_breakpoint_remove',
+            'event_breakpoint_set', 'event_breakpoint_set_category',
+            'event_breakpoint_list', 'event_breakpoint_remove',
+        ],
+    },
+    {
+        name: 'Watch Expressions',
+        setup: [],
+        tools: ['watch_add', 'watch_list', 'watch_evaluate_all', 'watch_remove', 'watch_clear_all'],
+    },
+    { name: 'Blackbox', setup: [], tools: ['blackbox_add', 'blackbox_add_common', 'blackbox_list'] },
+    {
+        name: 'Debugger Execution (pause/eval/resume)',
+        setup: [],
+        tools: [
+            'debugger_evaluate_global', 'debugger_pause', 'debugger_wait_for_paused',
+            'debugger_get_paused_state', 'debugger_evaluate',
+            'get_call_stack', 'get_scope_variables_enhanced', 'get_object_properties',
+            'debugger_step_over', 'debugger_step_into', 'debugger_step_out',
+            'debugger_resume',
+        ],
+    },
+    {
+        name: 'Debugger Session',
+        setup: [],
+        tools: ['debugger_save_session', 'debugger_list_sessions', 'debugger_export_session'],
+    },
+];

package/dist/tests/e2e/phases/index.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const ALL_PHASES: Phase[];

package/dist/tests/e2e/phases/index.js

@@ -0,0 +1,15 @@
+import { maintenancePhases, cleanupPhases } from '../../e2e/phases/maintenance-phases.js';
+import { browserPhases } from '../../e2e/phases/browser-phases.js';
+import { debuggerPhases } from '../../e2e/phases/debugger-phases.js';
+import { monitorPhases } from '../../e2e/phases/monitor-phases.js';
+import { analysisPhases } from '../../e2e/phases/analysis-phases.js';
+import { systemPhases } from '../../e2e/phases/system-phases.js';
+export const ALL_PHASES = [
+    ...maintenancePhases,
+    ...browserPhases,
+    ...debuggerPhases,
+    ...monitorPhases,
+    ...analysisPhases,
+    ...systemPhases,
+    ...cleanupPhases,
+];

package/dist/tests/e2e/phases/maintenance-phases.d.ts

@@ -0,0 +1,3 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const maintenancePhases: Phase[];
+export declare const cleanupPhases: Phase[];

package/dist/tests/e2e/phases/maintenance-phases.js

@@ -0,0 +1,19 @@
+export const maintenancePhases = [
+    {
+        name: 'Maintenance & Cache',
+        setup: [],
+        tools: [
+            'get_token_budget_stats', 'manual_token_cleanup', 'reset_token_budget',
+            'get_cache_stats', 'smart_cache_cleanup', 'cleanup_artifacts', 'doctor_environment',
+            'boost_profile', 'unboost_profile',
+            'list_extensions', 'reload_extensions', 'browse_extension_registry',
+        ],
+    },
+];
+export const cleanupPhases = [
+    {
+        name: 'Data Cleanup',
+        setup: [],
+        tools: ['clear_collected_data', 'clear_all_caches', 'get_collection_stats', 'browser_close'],
+    },
+];

package/dist/tests/e2e/phases/monitor-phases.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const monitorPhases: Phase[];

package/dist/tests/e2e/phases/monitor-phases.js

@@ -0,0 +1,52 @@
+export const monitorPhases = [
+    {
+        name: 'Console Monitor',
+        setup: ['console_enable'],
+        tools: [
+            'console_get_logs', 'console_execute', 'console_get_exceptions',
+            'console_inject_script_monitor', 'console_inject_function_tracer',
+            'console_clear_injected_buffers', 'console_reset_injected_interceptors',
+        ],
+    },
+    { name: 'Framework & Extension', setup: [], tools: ['framework_state_extract', 'extension_list_installed'] },
+    {
+        name: 'Network Monitor',
+        setup: ['network_enable'],
+        tools: [
+            'network_get_status', 'network_get_requests', 'network_get_stats',
+            'network_extract_auth', 'network_get_response_body', 'network_replay_request',
+            'console_inject_fetch_interceptor', 'console_inject_xhr_interceptor',
+        ],
+    },
+    {
+        name: 'Streaming (WS/SSE)',
+        setup: [],
+        tools: ['ws_monitor_enable', 'ws_get_frames', 'ws_get_connections', 'sse_monitor_enable', 'sse_get_events', 'ws_monitor_disable'],
+    },
+    {
+        name: 'Performance Start',
+        setup: [],
+        tools: ['performance_get_metrics', 'performance_start_coverage', 'profiler_heap_sampling_start', 'performance_trace_start'],
+    },
+    { name: 'JS Heap', setup: [], tools: ['js_heap_search'] },
+    {
+        name: 'Performance Stop',
+        setup: [],
+        tools: ['performance_stop_coverage', 'performance_take_heap_snapshot'],
+    },
+    {
+        name: 'CPU Profiler (after coverage)',
+        setup: async (call) => {
+            await call('profiler_cpu_start', {});
+            await new Promise((r) => setTimeout(r, 300));
+        },
+        tools: ['profiler_cpu_stop'],
+    },
+    {
+        name: 'Remaining Profiler Stops',
+        setup: [],
+        tools: ['profiler_heap_sampling_stop', 'performance_trace_stop'],
+    },
+    { name: 'Network Teardown', setup: [], tools: ['network_export_har', 'network_disable'] },
+    { name: 'Debugger Teardown', setup: [], tools: ['debugger_disable'] },
+];

package/dist/tests/e2e/phases/system-phases.d.ts

@@ -0,0 +1,2 @@
+import type { Phase } from '../../e2e/helpers/types.js';
+export declare const systemPhases: Phase[];

package/dist/tests/e2e/phases/system-phases.js

@@ -0,0 +1,47 @@
+export const systemPhases = [
+    {
+        name: 'Antidebug',
+        setup: [],
+        tools: [
+            'antidebug_detect_protections', 'antidebug_bypass_all',
+            'antidebug_bypass_debugger_statement', 'antidebug_bypass_console_detect',
+            'antidebug_bypass_stack_trace', 'antidebug_bypass_timing',
+        ],
+    },
+    {
+        name: 'Sourcemap',
+        setup: [],
+        tools: ['sourcemap_discover', 'source_map_extract', 'sourcemap_fetch_and_parse', 'sourcemap_reconstruct_tree'],
+    },
+    {
+        name: 'Workflow',
+        setup: [],
+        tools: [
+            'page_script_register', 'page_script_run',
+            'js_bundle_search', 'webpack_enumerate',
+            'web_api_capture_session', 'api_probe_batch',
+            'tab_workflow', 'script_replace_persist',
+        ],
+    },
+    {
+        name: 'Process',
+        setup: [],
+        tools: ['process_list', 'process_get', 'process_windows', 'process_find', 'process_find_chromium', 'process_check_debug_port', 'process_launch_debug'],
+    },
+    {
+        name: 'Memory (read-only)',
+        setup: [],
+        tools: ['memory_list_regions', 'memory_dump_region', 'memory_read', 'memory_scan', 'memory_scan_filtered', 'memory_check_protection', 'enumerate_modules', 'memory_audit_export'],
+    },
+    {
+        name: 'WASM',
+        setup: [],
+        tools: ['wasm_dump', 'wasm_inspect_sections', 'wasm_decompile', 'wasm_disassemble', 'wasm_optimize', 'wasm_memory_inspect', 'wasm_vmp_trace'],
+    },
+    { name: 'Platform', setup: [], tools: ['asar_extract'] },
+    {
+        name: 'Extension Workflows',
+        setup: [],
+        tools: ['batch_register', 'list_extension_workflows', 'run_extension_workflow'],
+    },
+];

package/dist/tests/e2e/skip-list.d.ts

@@ -0,0 +1,5 @@
+export interface SkipListConfig {
+    electronPath: string;
+    miniappPath: string;
+}
+export declare function buildSkipSet(config: SkipListConfig): Set<string>;

package/dist/tests/e2e/skip-list.js

@@ -0,0 +1,17 @@
+export function buildSkipSet(config) {
+    return new Set([
+        'captcha_wait', 'register_account_flow',
+        'inject_dll', 'module_inject_dll', 'inject_shellcode', 'module_inject_shellcode',
+        'memory_write', 'memory_batch_write', 'memory_protect',
+        'process_kill',
+        'frida_bridge', 'jadx_bridge',
+        'camoufox_server_launch', 'camoufox_server_close',
+        'browser_attach', 'extension_execute_in_context', 'wasm_offline_run',
+        'module_list', 'check_debug_port',
+        'debugger_load_session',
+        'install_extension',
+        'captcha_vision_solve', 'widget_challenge_solve',
+        ...(!config.electronPath ? ['electron_attach', 'electron_inspect_app'] : []),
+        ...(!config.miniappPath ? ['miniapp_pkg_analyze', 'miniapp_pkg_scan', 'miniapp_pkg_unpack'] : []),
+    ]);
+}

package/dist/tests/modules/analyzer/AISummarizer.test.d.ts

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

package/dist/tests/modules/analyzer/AISummarizer.test.js

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const loggerState = vi.hoisted(() => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+}));
+const promptState = vi.hoisted(() => ({
+    generateFileSummaryMessages: vi.fn((url, snippet) => [
+        { role: 'user', content: `${url}:${snippet}` },
+    ]),
+    generateProjectSummaryMessages: vi.fn((files) => [
+        { role: 'user', content: `files:${files.length}` },
+    ]),
+}));
+vi.mock('@src/utils/logger', () => ({
+    logger: loggerState,
+}));
+vi.mock('@src/services/prompts/analysis', () => ({
+    generateFileSummaryMessages: promptState.generateFileSummaryMessages,
+    generateProjectSummaryMessages: promptState.generateProjectSummaryMessages,
+}));
+import { AISummarizer } from '../../../src/modules/analyzer/AISummarizer.js';
+function makeFile(overrides = {}) {
+    return {
+        url: 'https://vmoranv.github.io/jshookmcp/cdn/app.js',
+        type: 'inline',
+        size: 120,
+        content: 'function hello(){return 1;}',
+        ...overrides,
+    };
+}
+describe('AISummarizer', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        loggerState.debug.mockReset();
+        loggerState.info.mockReset();
+        loggerState.warn.mockReset();
+        loggerState.error.mockReset();
+        promptState.generateFileSummaryMessages.mockClear();
+        promptState.generateProjectSummaryMessages.mockClear();
+    });
+    it('parses AI JSON summary for a file', async () => {
+        const llm = {
+            chat: vi.fn(async () => ({
+                content: JSON.stringify({
+                    summary: 'ok',
+                    purpose: 'auth',
+                    keyFunctions: ['hello'],
+                    hasAPI: true,
+                    complexity: 'low',
+                }),
+            })),
+        };
+        const result = await new AISummarizer(llm).summarizeFile(makeFile());
+        expect(result.summary).toBe('ok');
+        expect(result.purpose).toBe('auth');
+        expect(result.keyFunctions).toEqual(['hello']);
+        expect(result.hasAPI).toBe(true);
+        expect(result.complexity).toBe('low');
+        expect(result.linesOfCode).toBe(1);
+    });
+    it('truncates long source before sending prompt', async () => {
+        const llm = { chat: vi.fn(async () => ({ content: '{}' })) };
+        const longContent = 'a'.repeat(11050);
+        await new AISummarizer(llm).summarizeFile(makeFile({ content: longContent }));
+        const [, snippet] = promptState.generateFileSummaryMessages.mock.calls[0];
+        expect(snippet.length).toBeGreaterThan(10000);
+        expect(snippet).toContain('... (truncated)');
+    });
+    it('falls back to basic analysis when LLM call throws', async () => {
+        const llm = { chat: vi.fn(async () => Promise.reject(new Error('down'))) };
+        const content = 'function encryptData(){}\nfetch("/api/x")\neval("1")';
+        const result = await new AISummarizer(llm).summarizeFile(makeFile({ content }));
+        expect(result.summary).toContain('Basic analysis');
+        expect(result.hasEncryption).toBe(true);
+        expect(result.hasAPI).toBe(true);
+        expect(result.hasObfuscation).toBe(true);
+        expect(result.keyFunctions).toContain('encryptData');
+    });
+    it('falls back when AI response is not valid JSON', async () => {
+        const llm = { chat: vi.fn(async () => ({ content: 'not-json' })) };
+        const result = await new AISummarizer(llm).summarizeFile(makeFile());
+        expect(result.summary).toContain('Basic analysis');
+        expect(loggerState.warn).toHaveBeenCalled();
+    });
+    it('summarizes files in batches with configured concurrency', async () => {
+        const llm = {
+            chat: vi.fn(async ({ 0: msg }) => ({
+                content: JSON.stringify({
+                    summary: String(msg.content).includes('a.js') ? 'A' : 'B',
+                    purpose: 'x',
+                }),
+            })),
+        };
+        const files = [
+            makeFile({ url: 'a.js', content: 'function a(){}' }),
+            makeFile({ url: 'b.js', content: 'function b(){}' }),
+            makeFile({ url: 'c.js', content: 'function c(){}' }),
+        ];
+        const result = await new AISummarizer(llm).summarizeBatch(files, 2);
+        expect(result).toHaveLength(3);
+        expect(llm.chat).toHaveBeenCalledTimes(3);
+    });
+    it('parses project-level summary and computes totals', async () => {
+        const llm = {
+            chat: vi.fn(async () => ({
+                content: JSON.stringify({
+                    mainPurpose: 'platform',
+                    architecture: 'modular',
+                    technologies: ['ts'],
+                    securityConcerns: ['xss'],
+                    recommendations: ['harden'],
+                }),
+            })),
+        };
+        const result = await new AISummarizer(llm).summarizeProject([
+            makeFile({ size: 10 }),
+            makeFile({ size: 20 }),
+        ]);
+        expect(result.totalFiles).toBe(2);
+        expect(result.totalSize).toBe(30);
+        expect(result.mainPurpose).toBe('platform');
+        expect(result.technologies).toEqual(['ts']);
+    });
+    it('returns safe defaults when project summary fails', async () => {
+        const llm = { chat: vi.fn(async () => ({ content: '{' })) };
+        const result = await new AISummarizer(llm).summarizeProject([makeFile({ size: 7 })]);
+        expect(result.mainPurpose).toBe('Analysis failed');
+        expect(result.totalSize).toBe(7);
+        expect(result.technologies).toEqual([]);
+    });
+});

package/dist/tests/modules/analyzer/CodeAnalyzer.test.d.ts

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