@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/tests/e2e/helpers/schema-builder.d.ts

@@ -0,0 +1,6 @@
+import type { E2EConfig } from '../../e2e/helpers/types.js';
+type SchemaBuilderConfig = Pick<E2EConfig, 'targetUrl' | 'artifactDir'>;
+export declare function scalarFromSchema(name: string, schema: Record<string, unknown> | undefined, config: SchemaBuilderConfig): unknown;
+export declare function valueFromSchema(name: string, schema: Record<string, unknown> | undefined, config: SchemaBuilderConfig, depth?: number): unknown;
+export declare function buildArgs(inputSchema: Record<string, unknown> | undefined, config: SchemaBuilderConfig): Record<string, unknown>;
+export {};

package/dist/tests/e2e/helpers/schema-builder.js

@@ -0,0 +1,108 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function scalarFromSchema(name, schema, config) {
+    if (schema?.const !== undefined)
+        return schema.const;
+    const enumValues = schema?.enum;
+    if (Array.isArray(enumValues) && enumValues.length > 0)
+        return enumValues[0];
+    const type = typeof schema?.type === 'string' ? schema.type : undefined;
+    const n = name.toLowerCase();
+    if (type === 'boolean')
+        return false;
+    if (type === 'number' || type === 'integer') {
+        if (typeof schema?.minimum === 'number')
+            return schema.minimum;
+        if (typeof schema?.exclusiveMinimum === 'number')
+            return schema.exclusiveMinimum + 1;
+        return type === 'integer' ? 1 : 1.0;
+    }
+    if (type === 'string' || !type) {
+        if (n.includes('url') || n.includes('endpoint') || n.includes('baseurl') || n.includes('registerurl'))
+            return config.targetUrl;
+        if (n.includes('selector'))
+            return 'body';
+        if (n.includes('path') || n.includes('file') || n.includes('artifactpath'))
+            return `${config.artifactDir}/${name}.txt`;
+        if (n.includes('query'))
+            return '{ __typename }';
+        if (n.includes('operationname'))
+            return 'TestOp';
+        if (n.includes('eventname'))
+            return 'click';
+        if (n === 'category')
+            return 'mouse';
+        if (n === 'state')
+            return 'none';
+        if (n === 'method')
+            return 'GET';
+        if (n === 'device')
+            return 'iPhone 14';
+        if (n === 'action')
+            return 'list';
+        if (n.includes('expression'))
+            return '1+1';
+        if (n.includes('code'))
+            return 'return 1;';
+        if (n.includes('pattern') || n.includes('keyword'))
+            return 'test';
+        if (n.includes('key') && !n.includes('apikey'))
+            return 'test_key';
+        if (n.includes('value'))
+            return 'test_value';
+        if (n.includes('hookid'))
+            return '__placeholder__';
+        if (n.includes('scriptid'))
+            return '__placeholder__';
+        if (n.includes('breakpointid'))
+            return '__placeholder__';
+        if (n.includes('requestid'))
+            return '__placeholder__';
+        if (n.includes('objectid'))
+            return '__placeholder__';
+        if (n.includes('callframeid'))
+            return '__placeholder__';
+        return 'test';
+    }
+    return null;
+}
+export function valueFromSchema(name, schema, config, depth = 0) {
+    if (!schema || depth > 4)
+        return scalarFromSchema(name, schema, config);
+    if (schema.const !== undefined || schema.enum !== undefined)
+        return scalarFromSchema(name, schema, config);
+    const oneOf = schema.oneOf;
+    if (Array.isArray(oneOf) && oneOf.length > 0 && isRecord(oneOf[0])) {
+        return valueFromSchema(name, oneOf[0], config, depth + 1);
+    }
+    const anyOf = schema.anyOf;
+    if (Array.isArray(anyOf) && anyOf.length > 0 && isRecord(anyOf[0])) {
+        return valueFromSchema(name, anyOf[0], config, depth + 1);
+    }
+    const type = typeof schema.type === 'string' ? schema.type : undefined;
+    if (type === 'object' || isRecord(schema.properties)) {
+        const props = isRecord(schema.properties) ? schema.properties : {};
+        const required = Array.isArray(schema.required) ? schema.required.filter((key) => typeof key === 'string') : [];
+        const out = {};
+        for (const key of required) {
+            const propSchema = isRecord(props[key]) ? props[key] : undefined;
+            out[key] = valueFromSchema(key, propSchema, config, depth + 1);
+        }
+        return out;
+    }
+    if (type === 'array') {
+        const itemSchema = isRecord(schema.items) ? schema.items : undefined;
+        const minItems = typeof schema.minItems === 'number' ? schema.minItems : 0;
+        return Array.from({ length: Math.max(1, minItems) }, () => valueFromSchema(name, itemSchema, config, depth + 1));
+    }
+    return scalarFromSchema(name, schema, config);
+}
+export function buildArgs(inputSchema, config) {
+    const props = isRecord(inputSchema?.properties) ? inputSchema.properties : {};
+    const required = Array.isArray(inputSchema?.required) ? inputSchema.required.filter((key) => typeof key === 'string') : [];
+    const args = {};
+    for (const key of required)
+        args[key] = valueFromSchema(key, isRecord(props[key]) ? props[key] : undefined, config, 0);
+    return args;
+}

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 {};