@jshookmcp/jshook 0.2.2 → 0.2.5

package/dist/src/server/domains/memory/manifest.js

@@ -1,28 +1,37 @@
 import { memoryScanToolDefinitions } from './definitions.js';
 import { MemoryScanHandlers } from './handlers.impl.js';
-import { memoryScanner } from '../../../native/MemoryScanner.js';
-import { scanSessionManager } from '../../../native/MemoryScanSession.js';
-import { pointerChainEngine } from '../../../native/PointerChainEngine.js';
-import { structureAnalyzer } from '../../../native/StructureAnalyzer.js';
-import { codeInjector } from '../../../native/CodeInjector.js';
-import { memoryController } from '../../../native/MemoryController.js';
 const DOMAIN = 'memory';
 const DEP_KEY = 'memoryScanHandlers';
-const IS_WIN32 = process.platform === 'win32';
-function ensure(ctx) {
+const EFFECTIVE_PLATFORM = process.env.JSHOOK_REGISTRY_PLATFORM === 'win32' ||
+    process.env.JSHOOK_REGISTRY_PLATFORM === 'linux' ||
+    process.env.JSHOOK_REGISTRY_PLATFORM === 'darwin'
+    ? process.env.JSHOOK_REGISTRY_PLATFORM
+    : process.platform;
+const IS_WIN32 = EFFECTIVE_PLATFORM === 'win32';
+async function ensure(ctx) {
     const ctxAny = ctx;
-    if (!ctxAny[DEP_KEY]) {
-        if (IS_WIN32) {
-            const { hardwareBreakpointEngine } = require('../../../native/HardwareBreakpoint.js');
-            const { speedhack } = require('../../../native/Speedhack.js');
-            const { heapAnalyzer } = require('../../../native/HeapAnalyzer.js');
-            const { peAnalyzer } = require('../../../native/PEAnalyzer.js');
-            const { antiCheatDetector } = require('../../../native/AntiCheatDetector.js');
-            ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner, scanSessionManager, pointerChainEngine, structureAnalyzer, hardwareBreakpointEngine, codeInjector, memoryController, speedhack, heapAnalyzer, peAnalyzer, antiCheatDetector);
-        }
-        else {
-            ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner, scanSessionManager, pointerChainEngine, structureAnalyzer, null, codeInjector, memoryController, null, null, null, null);
-        }
+    if (ctxAny[DEP_KEY])
+        return ctxAny[DEP_KEY];
+    const [memoryScanner, scanSessionManager, pointerChainEngine, structureAnalyzer, codeInjector, memoryController,] = await Promise.all([
+        import('../../../native/MemoryScanner.js'),
+        import('../../../native/MemoryScanSession.js'),
+        import('../../../native/PointerChainEngine.js'),
+        import('../../../native/StructureAnalyzer.js'),
+        import('../../../native/CodeInjector.js'),
+        import('../../../native/MemoryController.js'),
+    ]);
+    if (IS_WIN32) {
+        const [hardwareBreakpointEngine, speedhack, heapAnalyzer, peAnalyzer, antiCheatDetector] = await Promise.all([
+            import('../../../native/HardwareBreakpoint.js'),
+            import('../../../native/Speedhack.js'),
+            import('../../../native/HeapAnalyzer.js'),
+            import('../../../native/PEAnalyzer.js'),
+            import('../../../native/AntiCheatDetector.js'),
+        ]);
+        ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, hardwareBreakpointEngine.hardwareBreakpointEngine, codeInjector.codeInjector, memoryController.memoryController, speedhack.speedhack, heapAnalyzer.heapAnalyzer, peAnalyzer.peAnalyzer, antiCheatDetector.antiCheatDetector);
+    }
+    else {
+        ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, null, codeInjector.codeInjector, memoryController.memoryController, null, null, null, null);
     }
     return ctxAny[DEP_KEY];
 }
@@ -56,47 +65,207 @@ const WIN32_ONLY_TOOLS = new Set([
     'memory_speedhack_set',
 ]);
 const allRegistrations = [
-    { tool: toolByName('memory_first_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleFirstScan(a)) },
-    { tool: toolByName('memory_next_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleNextScan(a)) },
-    { tool: toolByName('memory_unknown_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleUnknownScan(a)) },
-    { tool: toolByName('memory_pointer_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePointerScan(a)) },
-    { tool: toolByName('memory_group_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleGroupScan(a)) },
-    { tool: toolByName('memory_scan_list'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleScanList(a)) },
-    { tool: toolByName('memory_scan_delete'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleScanDelete(a)) },
-    { tool: toolByName('memory_scan_export'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleScanExport(a)) },
-    { tool: toolByName('memory_pointer_chain_scan'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePointerChainScan(a)) },
-    { tool: toolByName('memory_pointer_chain_validate'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePointerChainValidate(a)) },
-    { tool: toolByName('memory_pointer_chain_resolve'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePointerChainResolve(a)) },
-    { tool: toolByName('memory_pointer_chain_export'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePointerChainExport(a)) },
-    { tool: toolByName('memory_structure_analyze'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleStructureAnalyze(a)) },
-    { tool: toolByName('memory_vtable_parse'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleVtableParse(a)) },
-    { tool: toolByName('memory_structure_export_c'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleStructureExportC(a)) },
-    { tool: toolByName('memory_structure_compare'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleStructureCompare(a)) },
-    { tool: toolByName('memory_breakpoint_set'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleBreakpointSet(a)) },
-    { tool: toolByName('memory_breakpoint_remove'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleBreakpointRemove(a)) },
-    { tool: toolByName('memory_breakpoint_list'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleBreakpointList(a)) },
-    { tool: toolByName('memory_breakpoint_trace'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleBreakpointTrace(a)) },
-    { tool: toolByName('memory_patch_bytes'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePatchBytes(a)) },
-    { tool: toolByName('memory_patch_nop'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePatchNop(a)) },
-    { tool: toolByName('memory_patch_undo'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePatchUndo(a)) },
-    { tool: toolByName('memory_code_caves'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleCodeCaves(a)) },
-    { tool: toolByName('memory_write_value'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleWriteValue(a)) },
-    { tool: toolByName('memory_freeze'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleFreeze(a)) },
-    { tool: toolByName('memory_unfreeze'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleUnfreeze(a)) },
+    {
+        tool: toolByName('memory_first_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleFirstScan(a)),
+    },
+    {
+        tool: toolByName('memory_next_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleNextScan(a)),
+    },
+    {
+        tool: toolByName('memory_unknown_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleUnknownScan(a)),
+    },
+    {
+        tool: toolByName('memory_pointer_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePointerScan(a)),
+    },
+    {
+        tool: toolByName('memory_group_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleGroupScan(a)),
+    },
+    {
+        tool: toolByName('memory_scan_list'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleScanList(a)),
+    },
+    {
+        tool: toolByName('memory_scan_delete'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleScanDelete(a)),
+    },
+    {
+        tool: toolByName('memory_scan_export'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleScanExport(a)),
+    },
+    {
+        tool: toolByName('memory_pointer_chain_scan'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePointerChainScan(a)),
+    },
+    {
+        tool: toolByName('memory_pointer_chain_validate'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePointerChainValidate(a)),
+    },
+    {
+        tool: toolByName('memory_pointer_chain_resolve'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePointerChainResolve(a)),
+    },
+    {
+        tool: toolByName('memory_pointer_chain_export'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePointerChainExport(a)),
+    },
+    {
+        tool: toolByName('memory_structure_analyze'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleStructureAnalyze(a)),
+    },
+    {
+        tool: toolByName('memory_vtable_parse'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleVtableParse(a)),
+    },
+    {
+        tool: toolByName('memory_structure_export_c'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleStructureExportC(a)),
+    },
+    {
+        tool: toolByName('memory_structure_compare'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleStructureCompare(a)),
+    },
+    {
+        tool: toolByName('memory_breakpoint_set'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleBreakpointSet(a)),
+    },
+    {
+        tool: toolByName('memory_breakpoint_remove'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleBreakpointRemove(a)),
+    },
+    {
+        tool: toolByName('memory_breakpoint_list'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleBreakpointList(a)),
+    },
+    {
+        tool: toolByName('memory_breakpoint_trace'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleBreakpointTrace(a)),
+    },
+    {
+        tool: toolByName('memory_patch_bytes'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePatchBytes(a)),
+    },
+    {
+        tool: toolByName('memory_patch_nop'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePatchNop(a)),
+    },
+    {
+        tool: toolByName('memory_patch_undo'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePatchUndo(a)),
+    },
+    {
+        tool: toolByName('memory_code_caves'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleCodeCaves(a)),
+    },
+    {
+        tool: toolByName('memory_write_value'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleWriteValue(a)),
+    },
+    {
+        tool: toolByName('memory_freeze'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleFreeze(a)),
+    },
+    {
+        tool: toolByName('memory_unfreeze'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleUnfreeze(a)),
+    },
     { tool: toolByName('memory_dump'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleDump(a)) },
-    { tool: toolByName('memory_speedhack_apply'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleSpeedhackApply(a)) },
-    { tool: toolByName('memory_speedhack_set'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleSpeedhackSet(a)) },
-    { tool: toolByName('memory_write_undo'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleWriteUndo(a)) },
-    { tool: toolByName('memory_write_redo'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleWriteRedo(a)) },
-    { tool: toolByName('memory_heap_enumerate'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleHeapEnumerate(a)) },
-    { tool: toolByName('memory_heap_stats'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleHeapStats(a)) },
-    { tool: toolByName('memory_heap_anomalies'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleHeapAnomalies(a)) },
-    { tool: toolByName('memory_pe_headers'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePEHeaders(a)) },
-    { tool: toolByName('memory_pe_imports_exports'), domain: DOMAIN, bind: bindByKey((h, a) => h.handlePEImportsExports(a)) },
-    { tool: toolByName('memory_inline_hook_detect'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleInlineHookDetect(a)) },
-    { tool: toolByName('memory_anticheat_detect'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleAntiCheatDetect(a)) },
-    { tool: toolByName('memory_guard_pages'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleGuardPages(a)) },
-    { tool: toolByName('memory_integrity_check'), domain: DOMAIN, bind: bindByKey((h, a) => h.handleIntegrityCheck(a)) },
+    {
+        tool: toolByName('memory_speedhack_apply'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleSpeedhackApply(a)),
+    },
+    {
+        tool: toolByName('memory_speedhack_set'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleSpeedhackSet(a)),
+    },
+    {
+        tool: toolByName('memory_write_undo'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleWriteUndo(a)),
+    },
+    {
+        tool: toolByName('memory_write_redo'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleWriteRedo(a)),
+    },
+    {
+        tool: toolByName('memory_heap_enumerate'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleHeapEnumerate(a)),
+    },
+    {
+        tool: toolByName('memory_heap_stats'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleHeapStats(a)),
+    },
+    {
+        tool: toolByName('memory_heap_anomalies'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleHeapAnomalies(a)),
+    },
+    {
+        tool: toolByName('memory_pe_headers'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePEHeaders(a)),
+    },
+    {
+        tool: toolByName('memory_pe_imports_exports'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handlePEImportsExports(a)),
+    },
+    {
+        tool: toolByName('memory_inline_hook_detect'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleInlineHookDetect(a)),
+    },
+    {
+        tool: toolByName('memory_anticheat_detect'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleAntiCheatDetect(a)),
+    },
+    {
+        tool: toolByName('memory_guard_pages'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleGuardPages(a)),
+    },
+    {
+        tool: toolByName('memory_integrity_check'),
+        domain: DOMAIN,
+        bind: bindByKey((h, a) => h.handleIntegrityCheck(a)),
+    },
 ];
 const registrations = IS_WIN32
     ? allRegistrations
@@ -140,14 +309,17 @@ const manifest = {
             'memory_structure_analyze',
             'memory_vtable_parse',
             'memory_scan_list',
-            ...(IS_WIN32
-                ? ['memory_breakpoint_set', 'memory_breakpoint_trace']
-                : []),
+            ...(IS_WIN32 ? ['memory_breakpoint_set', 'memory_breakpoint_trace'] : []),
             'memory_patch_bytes',
             'memory_freeze',
             'memory_dump',
             ...(IS_WIN32
-                ? ['memory_speedhack_apply', 'memory_heap_enumerate', 'memory_pe_headers', 'memory_anticheat_detect']
+                ? [
+                    'memory_speedhack_apply',
+                    'memory_heap_enumerate',
+                    'memory_pe_headers',
+                    'memory_anticheat_detect',
+                ]
                 : []),
             'memory_write_undo',
         ],

package/dist/src/server/domains/native-bridge/definitions.js

@@ -1,194 +1,56 @@
+import { tool } from '../../registry/tool-builder.js';
 export const nativeBridgeTools = [
-    {
-        name: 'native_bridge_status',
-        description: 'Check connectivity to Ghidra and/or IDA bridge servers.\n\n' +
-            'Returns health status, version info, and available capabilities for each configured backend.\n\n' +
-            'Use this first to verify your analysis environment is ready.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                backend: {
-                    type: 'string',
-                    enum: ['ghidra', 'ida', 'all'],
-                    description: 'Which backend to check (default: all)',
-                    default: 'all',
-                },
-                ghidraEndpoint: {
-                    type: 'string',
-                    description: 'Ghidra bridge server URL (default: http://127.0.0.1:18080)',
-                },
-                idaEndpoint: {
-                    type: 'string',
-                    description: 'IDA bridge server URL (default: http://127.0.0.1:18081)',
-                },
-            },
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ghidra_bridge',
-        description: 'Interact with Ghidra headless analyzer via a bridge server.\n\n' +
-            'Supported actions:\n' +
-            '- `status`: Check Ghidra server health\n' +
-            '- `open_project`: Open/create a Ghidra project for a binary\n' +
-            '- `list_functions`: List all functions in the analyzed binary\n' +
-            '- `decompile_function`: Decompile a specific function by name or address\n' +
-            '- `run_script`: Execute a Ghidra Python/Java script\n' +
-            '- `get_xrefs`: Get cross-references for a symbol\n' +
-            '- `search_strings`: Search for strings in the binary\n\n' +
-            'Requires a Ghidra bridge server (ghidra_bridge or ghidriff) running locally.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: {
-                    type: 'string',
-                    enum: [
-                        'status',
-                        'open_project',
-                        'list_functions',
-                        'decompile_function',
-                        'run_script',
-                        'get_xrefs',
-                        'search_strings',
-                    ],
-                    description: 'Action to perform',
-                },
-                binaryPath: {
-                    type: 'string',
-                    description: 'Path to binary file (for open_project)',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Function name or address (for decompile_function, get_xrefs)',
-                },
-                scriptPath: {
-                    type: 'string',
-                    description: 'Path to Ghidra script (for run_script)',
-                },
-                scriptArgs: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Arguments for the script',
-                },
-                searchPattern: {
-                    type: 'string',
-                    description: 'String pattern to search (for search_strings)',
-                },
-                endpoint: {
-                    type: 'string',
-                    description: 'Ghidra bridge server URL',
-                },
-            },
-            required: ['action'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'ida_bridge',
-        description: 'Interact with IDA Pro via a Python sidecar bridge server.\n\n' +
-            'Supported actions:\n' +
-            '- `status`: Check IDA bridge server health\n' +
-            '- `open_binary`: Load a binary into IDA\n' +
-            '- `list_functions`: List all functions\n' +
-            '- `decompile_function`: Decompile with Hex-Rays (if available)\n' +
-            '- `run_script`: Execute an IDAPython script\n' +
-            '- `get_xrefs`: Get cross-references\n' +
-            '- `get_strings`: List defined strings\n\n' +
-            'Requires an IDA Python bridge server (ida_bridge or idalink) running locally.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: {
-                    type: 'string',
-                    enum: [
-                        'status',
-                        'open_binary',
-                        'list_functions',
-                        'decompile_function',
-                        'run_script',
-                        'get_xrefs',
-                        'get_strings',
-                    ],
-                    description: 'Action to perform',
-                },
-                binaryPath: {
-                    type: 'string',
-                    description: 'Path to binary file (for open_binary)',
-                },
-                functionName: {
-                    type: 'string',
-                    description: 'Function name or address (for decompile_function, get_xrefs)',
-                },
-                scriptPath: {
-                    type: 'string',
-                    description: 'Path to IDAPython script (for run_script)',
-                },
-                scriptArgs: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Arguments for the script',
-                },
-                endpoint: {
-                    type: 'string',
-                    description: 'IDA bridge server URL',
-                },
-            },
-            required: ['action'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
-    {
-        name: 'native_symbol_sync',
-        description: 'Synchronize symbol information between native analysis tools and jshookmcp.\n\n' +
-            'Export function names and addresses from Ghidra/IDA, then make them available ' +
-            'for WASM analysis, source map reconstruction, or hook generation.\n\n' +
-            'Useful when JS calls into WASM or native libraries — bridges the gap between ' +
-            'web-level and binary-level analysis.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                source: {
-                    type: 'string',
-                    enum: ['ghidra', 'ida'],
-                    description: 'Which tool to export symbols from',
-                },
-                filter: {
-                    type: 'string',
-                    description: 'Regex pattern to filter symbol names',
-                },
-                exportFormat: {
-                    type: 'string',
-                    enum: ['json', 'csv', 'idc'],
-                    description: 'Output format (default: json)',
-                    default: 'json',
-                },
-                endpoint: {
-                    type: 'string',
-                    description: 'Bridge server URL',
-                },
-            },
-            required: ['source'],
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-    },
+    tool('native_bridge_status')
+        .desc('Check connectivity to Ghidra and/or IDA bridge servers.\n\nReturns health status, version info, and available capabilities for each configured backend.\n\nUse this first to verify your analysis environment is ready.')
+        .enum('backend', ['ghidra', 'ida', 'all'], 'Which backend to check', { default: 'all' })
+        .string('ghidraEndpoint', 'Ghidra bridge server URL', { default: 'http://127.0.0.1:18080' })
+        .string('idaEndpoint', 'IDA bridge server URL', { default: 'http://127.0.0.1:18081' })
+        .readOnly()
+        .idempotent()
+        .build(),
+    tool('ghidra_bridge')
+        .desc('Interact with Ghidra headless analyzer via a bridge server.\n\nSupported actions:\n- `status`: Check Ghidra server health\n- `open_project`: Open/create a Ghidra project for a binary\n- `list_functions`: List all functions in the analyzed binary\n- `decompile_function`: Decompile a specific function by name or address\n- `run_script`: Execute a Ghidra Python/Java script\n- `get_xrefs`: Get cross-references for a symbol\n- `search_strings`: Search for strings in the binary\n\nRequires a Ghidra bridge server (ghidra_bridge or ghidriff) running locally.')
+        .enum('action', [
+        'status',
+        'open_project',
+        'list_functions',
+        'decompile_function',
+        'run_script',
+        'get_xrefs',
+        'search_strings',
+    ], 'Action to perform')
+        .string('binaryPath', 'Path to binary file (for open_project)')
+        .string('functionName', 'Function name or address (for decompile_function, get_xrefs)')
+        .string('scriptPath', 'Path to Ghidra script (for run_script)')
+        .array('scriptArgs', { type: 'string' }, 'Arguments for the script')
+        .string('searchPattern', 'String pattern to search (for search_strings)')
+        .string('endpoint', 'Ghidra bridge server URL')
+        .required('action')
+        .build(),
+    tool('ida_bridge')
+        .desc('Interact with IDA Pro via a Python sidecar bridge server.\n\nSupported actions:\n- `status`: Check IDA bridge server health\n- `open_binary`: Load a binary into IDA\n- `list_functions`: List all functions\n- `decompile_function`: Decompile with Hex-Rays (if available)\n- `run_script`: Execute an IDAPython script\n- `get_xrefs`: Get cross-references\n- `get_strings`: List defined strings\n\nRequires an IDA Python bridge server (ida_bridge or idalink) running locally.')
+        .enum('action', [
+        'status',
+        'open_binary',
+        'list_functions',
+        'decompile_function',
+        'run_script',
+        'get_xrefs',
+        'get_strings',
+    ], 'Action to perform')
+        .string('binaryPath', 'Path to binary file (for open_binary)')
+        .string('functionName', 'Function name or address (for decompile_function, get_xrefs)')
+        .string('scriptPath', 'Path to IDAPython script (for run_script)')
+        .array('scriptArgs', { type: 'string' }, 'Arguments for the script')
+        .string('endpoint', 'IDA bridge server URL')
+        .required('action')
+        .build(),
+    tool('native_symbol_sync')
+        .desc('Synchronize symbol information between native analysis tools and jshookmcp.\n\nExport function names and addresses from Ghidra/IDA, then make them available for WASM analysis, source map reconstruction, or hook generation.\n\nUseful when JS calls into WASM or native libraries — bridges the gap between web-level and binary-level analysis.')
+        .enum('source', ['ghidra', 'ida'], 'Which tool to export symbols from')
+        .string('filter', 'Regex pattern to filter symbol names')
+        .enum('exportFormat', ['json', 'csv', 'idc'], 'Output format', { default: 'json' })
+        .string('endpoint', 'Bridge server URL')
+        .required('source')
+        .build(),
 ];

package/dist/src/server/domains/native-bridge/index.d.ts

@@ -1,3 +1,4 @@
+export * from './definitions.js';
 export declare class NativeBridgeHandlers {
     private readonly ghidraEndpoint;
     private readonly idaEndpoint;

package/dist/src/server/domains/native-bridge/index.js

@@ -1,4 +1,5 @@
 import { GHIDRA_BRIDGE_ENDPOINT, IDA_BRIDGE_ENDPOINT } from '../../../constants.js';
+export * from './definitions.js';
 function toTextResponse(payload) {
     return {
         content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
@@ -17,7 +18,7 @@ async function bridgeFetch(baseUrl, path, method = 'GET', body) {
     const res = await fetch(url, {
         method,
         headers: { 'Content-Type': 'application/json' },
-        body,
+        ...(body === undefined ? {} : { body }),
         signal: AbortSignal.timeout(15_000),
     });
     const data = await res.json().catch(() => ({}));

package/dist/src/server/domains/network/auth-extractor.js

@@ -125,5 +125,5 @@ export function extractAuthFromRequests(requests) {
             }
         }
     }
-    return findings.sort((a, b) => b.confidence - a.confidence);
+    return findings.toSorted((a, b) => b.confidence - a.confidence);
 }