@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/domains/memory/handlers.impl.js

@@ -1,497 +1,66 @@
-function toTextResponse(payload) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
-    };
-}
-function toErrorResponse(tool, error) {
-    return toTextResponse({
-        success: false,
-        tool,
-        error: error instanceof Error ? error.message : String(error),
-    });
-}
+import { SessionHandlers } from './handlers/session.js';
+import { ScanHandlers } from './handlers/scan.js';
+import { PointerChainHandlers } from './handlers/pointer-chain.js';
+import { StructureHandlers } from './handlers/structure.js';
+import { HookHandlers } from './handlers/hooks.js';
+import { ReadWriteHandlers } from './handlers/readwrite.js';
+import { IntegrityHandlers } from './handlers/integrity.js';
 export class MemoryScanHandlers {
-    scanner;
-    sessionManager;
-    ptrEngine;
-    structAnalyzer;
-    bpEngine;
-    injector;
-    memCtrl;
-    speedhackEngine;
-    heapAnalyzer;
-    peAnalyzer;
-    antiCheatDetector;
+    sessions;
+    scans;
+    ptrChains;
+    structures;
+    hooks;
+    readwrite;
+    integrity;
     constructor(scanner, sessionManager, ptrEngine, structAnalyzer, bpEngine, injector, memCtrl, speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector) {
-        this.scanner = scanner;
-        this.sessionManager = sessionManager;
-        this.ptrEngine = ptrEngine;
-        this.structAnalyzer = structAnalyzer;
-        this.bpEngine = bpEngine;
-        this.injector = injector;
-        this.memCtrl = memCtrl;
-        this.speedhackEngine = speedhackEngine;
-        this.heapAnalyzer = heapAnalyzer;
-        this.peAnalyzer = peAnalyzer;
-        this.antiCheatDetector = antiCheatDetector;
-    }
-    async handleFirstScan(args) {
-        try {
-            const pid = args.pid;
-            const value = args.value;
-            const valueType = args.valueType;
-            const options = {
-                valueType,
-                alignment: args.alignment,
-                maxResults: args.maxResults,
-                regionFilter: args.regionFilter,
-            };
-            const result = await this.scanner.firstScan(pid, value, options);
-            return toTextResponse({
-                success: true, ...result,
-                hint: result.totalMatches > 0
-                    ? `Found ${result.totalMatches} matches. Use memory_next_scan with sessionId "${result.sessionId}" to narrow down.`
-                    : 'No matches found. Try a different value or type.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_first_scan', error);
-        }
-    }
-    async handleNextScan(args) {
-        try {
-            const result = await this.scanner.nextScan(args.sessionId, args.mode, args.value, args.value2);
-            return toTextResponse({
-                success: true, ...result,
-                hint: result.totalMatches <= 10
-                    ? 'Few matches remaining — inspect these addresses.'
-                    : `${result.totalMatches} matches remain. Continue narrowing with memory_next_scan.`,
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_next_scan', error);
-        }
-    }
-    async handleUnknownScan(args) {
-        try {
-            const options = {
-                valueType: args.valueType,
-                alignment: args.alignment,
-                maxResults: args.maxResults,
-                regionFilter: args.regionFilter,
-            };
-            const result = await this.scanner.unknownInitialScan(args.pid, options);
-            return toTextResponse({
-                success: true, ...result,
-                hint: `Captured ${result.totalMatches} addresses. Use memory_next_scan with changed/unchanged/increased/decreased to narrow.`,
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_unknown_scan', error);
-        }
-    }
-    async handlePointerScan(args) {
-        try {
-            const result = await this.scanner.pointerScan(args.pid, args.targetAddress, {
-                maxResults: args.maxResults,
-                moduleOnly: args.moduleOnly,
-            });
-            return toTextResponse({ success: true, ...result });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pointer_scan', error);
-        }
-    }
-    async handleGroupScan(args) {
-        try {
-            const result = await this.scanner.groupScan(args.pid, args.pattern, { alignment: args.alignment, maxResults: args.maxResults });
-            return toTextResponse({ success: true, ...result });
-        }
-        catch (error) {
-            return toErrorResponse('memory_group_scan', error);
-        }
-    }
-    async handleScanList(_args) {
-        try {
-            const sessions = this.sessionManager.listSessions();
-            return toTextResponse({ success: true, sessions, count: sessions.length });
-        }
-        catch (error) {
-            return toErrorResponse('memory_scan_list', error);
-        }
-    }
-    async handleScanDelete(args) {
-        try {
-            return toTextResponse({ success: true, deleted: this.sessionManager.deleteSession(args.sessionId) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_scan_delete', error);
-        }
-    }
-    async handleScanExport(args) {
-        try {
-            return toTextResponse({ success: true, exportedData: this.sessionManager.exportSession(args.sessionId) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_scan_export', error);
-        }
-    }
-    async handlePointerChainScan(args) {
-        try {
-            const result = await this.ptrEngine.scan(args.pid, args.targetAddress, {
-                maxDepth: args.maxDepth,
-                maxOffset: args.maxOffset,
-                staticOnly: args.staticOnly,
-                modules: args.modules,
-                maxResults: args.maxResults,
-            });
-            return toTextResponse({
-                success: true, ...result,
-                hint: result.totalFound > 0
-                    ? `Found ${result.totalFound} pointer chains. Static chains survive process restarts.`
-                    : 'No pointer chains found. Try increasing maxDepth or maxOffset.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pointer_chain_scan', error);
-        }
-    }
-    async handlePointerChainValidate(args) {
-        try {
-            const chains = JSON.parse(args.chains);
-            const results = await this.ptrEngine.validateChains(args.pid, chains);
-            return toTextResponse({ success: true, results, validCount: results.filter((r) => r.isValid).length, totalChecked: chains.length });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pointer_chain_validate', error);
-        }
-    }
-    async handlePointerChainResolve(args) {
-        try {
-            const chain = JSON.parse(args.chain);
-            const resolved = await this.ptrEngine.resolveChain(args.pid, chain);
-            return toTextResponse({ success: true, chainId: chain.id, resolvedAddress: resolved, isResolvable: resolved !== null });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pointer_chain_resolve', error);
-        }
-    }
-    async handlePointerChainExport(args) {
-        try {
-            const chains = JSON.parse(args.chains);
-            return toTextResponse({ success: true, exportedData: this.ptrEngine.exportChains(chains), chainCount: chains.length });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pointer_chain_export', error);
-        }
-    }
-    async handleStructureAnalyze(args) {
-        try {
-            const result = await this.structAnalyzer.analyzeStructure(args.pid, args.address, {
-                size: args.size,
-                otherInstances: args.otherInstances,
-                parseRtti: args.parseRtti,
-            });
-            return toTextResponse({
-                success: true, ...result,
-                hint: result.className
-                    ? `Detected class: ${result.className}${result.baseClasses?.length ? ` (inherits: ${result.baseClasses.join(' → ')})` : ''}`
-                    : `Inferred ${result.fields.length} fields. Use memory_structure_export_c to export as C struct.`,
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_structure_analyze', error);
-        }
-    }
-    async handleVtableParse(args) {
-        try {
-            return toTextResponse({ success: true, ...await this.structAnalyzer.parseVtable(args.pid, args.vtableAddress) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_vtable_parse', error);
-        }
-    }
-    async handleStructureExportC(args) {
-        try {
-            const structure = JSON.parse(args.structure);
-            return toTextResponse({ success: true, ...this.structAnalyzer.exportToCStruct(structure, args.name) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_structure_export_c', error);
-        }
-    }
-    async handleStructureCompare(args) {
-        try {
-            const result = await this.structAnalyzer.compareInstances(args.pid, args.address1, args.address2, args.size);
-            return toTextResponse({ success: true, matchingFieldCount: result.matching.length, differingFieldCount: result.differing.length, ...result });
-        }
-        catch (error) {
-            return toErrorResponse('memory_structure_compare', error);
-        }
-    }
-    async handleBreakpointSet(args) {
-        try {
-            const config = await this.bpEngine.setBreakpoint(args.pid, args.address, args.access, args.size ?? 4);
-            return toTextResponse({
-                success: true, ...config,
-                hint: `Hardware breakpoint set on DR register. Use memory_breakpoint_trace to collect hits.`,
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_breakpoint_set', error);
-        }
-    }
-    async handleBreakpointRemove(args) {
-        try {
-            return toTextResponse({ success: true, removed: await this.bpEngine.removeBreakpoint(args.breakpointId) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_breakpoint_remove', error);
-        }
-    }
-    async handleBreakpointList(_args) {
-        try {
-            const bps = this.bpEngine.listBreakpoints();
-            return toTextResponse({ success: true, breakpoints: bps, count: bps.length });
-        }
-        catch (error) {
-            return toErrorResponse('memory_breakpoint_list', error);
-        }
-    }
-    async handleBreakpointTrace(args) {
-        try {
-            const hits = await this.bpEngine.traceAccess(args.pid, args.address, args.access, args.maxHits, args.timeoutMs);
-            return toTextResponse({
-                success: true, hits, hitCount: hits.length,
-                hint: hits.length > 0 ? `${hits.length} accesses captured. Check instructionAddress to find the code accessing this address.` : 'No hits captured within timeout.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_breakpoint_trace', error);
-        }
-    }
-    async handlePatchBytes(args) {
-        try {
-            const patch = await this.injector.patchBytes(args.pid, args.address, args.bytes);
-            return toTextResponse({ success: true, ...patch, hint: `Patch applied. Use memory_patch_undo with patchId "${patch.id}" to restore.` });
-        }
-        catch (error) {
-            return toErrorResponse('memory_patch_bytes', error);
-        }
-    }
-    async handlePatchNop(args) {
-        try {
-            const patch = await this.injector.nopBytes(args.pid, args.address, args.count);
-            return toTextResponse({ success: true, ...patch, hint: `${args.count} bytes NOP'd. Use memory_patch_undo to restore.` });
-        }
-        catch (error) {
-            return toErrorResponse('memory_patch_nop', error);
-        }
-    }
-    async handlePatchUndo(args) {
-        try {
-            return toTextResponse({ success: true, restored: await this.injector.unpatch(args.patchId) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_patch_undo', error);
-        }
-    }
-    async handleCodeCaves(args) {
-        try {
-            const caves = await this.injector.findCodeCaves(args.pid, args.minSize);
-            return toTextResponse({ success: true, caves, count: caves.length });
-        }
-        catch (error) {
-            return toErrorResponse('memory_code_caves', error);
-        }
-    }
-    async handleWriteValue(args) {
-        try {
-            const entry = await this.memCtrl.writeValue(args.pid, args.address, args.value, args.valueType);
-            return toTextResponse({ success: true, ...entry, hint: 'Use memory_write_undo to revert.' });
-        }
-        catch (error) {
-            return toErrorResponse('memory_write_value', error);
-        }
-    }
-    async handleFreeze(args) {
-        try {
-            const entry = await this.memCtrl.freeze(args.pid, args.address, args.value, args.valueType, args.intervalMs);
-            return toTextResponse({ success: true, ...entry, hint: `Frozen. Use memory_unfreeze with freezeId "${entry.id}" to stop.` });
-        }
-        catch (error) {
-            return toErrorResponse('memory_freeze', error);
-        }
-    }
-    async handleUnfreeze(args) {
-        try {
-            return toTextResponse({ success: true, unfrozen: await this.memCtrl.unfreeze(args.freezeId) });
-        }
-        catch (error) {
-            return toErrorResponse('memory_unfreeze', error);
-        }
-    }
-    async handleDump(args) {
-        try {
-            const hexDump = await this.memCtrl.dumpMemoryHex(args.pid, args.address, args.size ?? 256);
-            return toTextResponse({ success: true, dump: hexDump });
-        }
-        catch (error) {
-            return toErrorResponse('memory_dump', error);
-        }
-    }
-    async handleSpeedhackApply(args) {
-        try {
-            const result = await this.speedhackEngine.apply(args.pid, args.speed);
-            return toTextResponse({ ...result, success: true, hint: `Speedhack active (${args.speed}x). Use memory_speedhack_set to adjust.` });
-        }
-        catch (error) {
-            return toErrorResponse('memory_speedhack_apply', error);
-        }
-    }
-    async handleSpeedhackSet(args) {
-        try {
-            return toTextResponse({ success: true, updated: await this.speedhackEngine.setSpeed(args.pid, args.speed), newSpeed: args.speed });
-        }
-        catch (error) {
-            return toErrorResponse('memory_speedhack_set', error);
-        }
-    }
-    async handleWriteUndo(_args) {
-        try {
-            const entry = await this.memCtrl.undo();
-            return toTextResponse({ success: true, undone: entry !== null, entry });
-        }
-        catch (error) {
-            return toErrorResponse('memory_write_undo', error);
-        }
-    }
-    async handleWriteRedo(_args) {
-        try {
-            const entry = await this.memCtrl.redo();
-            return toTextResponse({ success: true, redone: entry !== null, entry });
-        }
-        catch (error) {
-            return toErrorResponse('memory_write_redo', error);
-        }
-    }
-    async handleHeapEnumerate(args) {
-        try {
-            const result = await this.heapAnalyzer.enumerateHeaps(args.pid);
-            return toTextResponse({
-                success: true, ...result,
-                hint: `Enumerated ${result.heaps.length} heaps. Use memory_heap_stats for statistics or memory_heap_anomalies to check for issues.`,
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_heap_enumerate', error);
-        }
-    }
-    async handleHeapStats(args) {
-        try {
-            const stats = await this.heapAnalyzer.getStats(args.pid);
-            return toTextResponse({ success: true, ...stats });
-        }
-        catch (error) {
-            return toErrorResponse('memory_heap_stats', error);
-        }
-    }
-    async handleHeapAnomalies(args) {
-        try {
-            const anomalies = await this.heapAnalyzer.detectAnomalies(args.pid);
-            return toTextResponse({
-                success: true, anomalies, count: anomalies.length,
-                hint: anomalies.length > 0
-                    ? `Found ${anomalies.length} anomalies — inspect types for spray, UAF, or suspicious patterns.`
-                    : 'No heap anomalies detected.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_heap_anomalies', error);
-        }
-    }
-    async handlePEHeaders(args) {
-        try {
-            const headers = await this.peAnalyzer.parseHeaders(args.pid, args.moduleBase);
-            return toTextResponse({ success: true, ...headers });
-        }
-        catch (error) {
-            return toErrorResponse('memory_pe_headers', error);
-        }
-    }
-    async handlePEImportsExports(args) {
-        try {
-            const table = args.table || 'both';
-            const base = args.moduleBase;
-            const pid = args.pid;
-            const result = { success: true };
-            if (table === 'imports' || table === 'both') {
-                result.imports = await this.peAnalyzer.parseImports(pid, base);
-            }
-            if (table === 'exports' || table === 'both') {
-                result.exports = await this.peAnalyzer.parseExports(pid, base);
-            }
-            return toTextResponse(result);
-        }
-        catch (error) {
-            return toErrorResponse('memory_pe_imports_exports', error);
-        }
-    }
-    async handleInlineHookDetect(args) {
-        try {
-            const hooks = await this.peAnalyzer.detectInlineHooks(args.pid, args.moduleName);
-            return toTextResponse({
-                success: true, hooks, count: hooks.length,
-                hint: hooks.length > 0
-                    ? `Detected ${hooks.length} inline hooks — check hookType and jumpTarget for each.`
-                    : 'No inline hooks detected — exports match disk bytes.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_inline_hook_detect', error);
-        }
-    }
-    async handleAntiCheatDetect(args) {
-        try {
-            const detections = await this.antiCheatDetector.detect(args.pid);
-            return toTextResponse({
-                success: true, detections, count: detections.length,
-                hint: detections.length > 0
-                    ? `Found ${detections.length} anti-debug mechanisms. Each includes a bypassSuggestion.`
-                    : 'No anti-debug mechanisms detected in imports.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_anticheat_detect', error);
-        }
-    }
-    async handleGuardPages(args) {
-        try {
-            const pages = await this.antiCheatDetector.findGuardPages(args.pid);
-            return toTextResponse({
-                success: true, guardPages: pages, count: pages.length,
-                hint: pages.length > 0
-                    ? `Found ${pages.length} guard page regions — these may indicate anti-tampering.`
-                    : 'No guard pages found.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_guard_pages', error);
-        }
-    }
-    async handleIntegrityCheck(args) {
-        try {
-            const results = await this.antiCheatDetector.checkIntegrity(args.pid, args.moduleName);
-            const modified = results.filter(r => r.isModified);
-            return toTextResponse({
-                success: true, sections: results, totalChecked: results.length, modifiedCount: modified.length,
-                hint: modified.length > 0
-                    ? `${modified.length} section(s) modified — code may have been patched or hooked.`
-                    : 'All checked sections match disk — no runtime modifications detected.',
-            });
-        }
-        catch (error) {
-            return toErrorResponse('memory_integrity_check', error);
-        }
-    }
+        this.sessions = new SessionHandlers(sessionManager);
+        this.scans = new ScanHandlers(scanner);
+        this.ptrChains = new PointerChainHandlers(ptrEngine);
+        this.structures = new StructureHandlers(structAnalyzer);
+        this.hooks = new HookHandlers(bpEngine, injector);
+        this.readwrite = new ReadWriteHandlers(memCtrl);
+        this.integrity = new IntegrityHandlers(speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector);
+    }
+    handleScanList = (args) => this.sessions.handleScanList(args);
+    handleScanDelete = (args) => this.sessions.handleScanDelete(args);
+    handleScanExport = (args) => this.sessions.handleScanExport(args);
+    handleFirstScan = (args) => this.scans.handleFirstScan(args);
+    handleNextScan = (args) => this.scans.handleNextScan(args);
+    handleUnknownScan = (args) => this.scans.handleUnknownScan(args);
+    handlePointerScan = (args) => this.scans.handlePointerScan(args);
+    handleGroupScan = (args) => this.scans.handleGroupScan(args);
+    handlePointerChainScan = (args) => this.ptrChains.handlePointerChainScan(args);
+    handlePointerChainValidate = (args) => this.ptrChains.handlePointerChainValidate(args);
+    handlePointerChainResolve = (args) => this.ptrChains.handlePointerChainResolve(args);
+    handlePointerChainExport = (args) => this.ptrChains.handlePointerChainExport(args);
+    handleStructureAnalyze = (args) => this.structures.handleStructureAnalyze(args);
+    handleVtableParse = (args) => this.structures.handleVtableParse(args);
+    handleStructureExportC = (args) => this.structures.handleStructureExportC(args);
+    handleStructureCompare = (args) => this.structures.handleStructureCompare(args);
+    handleBreakpointSet = (args) => this.hooks.handleBreakpointSet(args);
+    handleBreakpointRemove = (args) => this.hooks.handleBreakpointRemove(args);
+    handleBreakpointList = (args) => this.hooks.handleBreakpointList(args);
+    handleBreakpointTrace = (args) => this.hooks.handleBreakpointTrace(args);
+    handlePatchBytes = (args) => this.hooks.handlePatchBytes(args);
+    handlePatchNop = (args) => this.hooks.handlePatchNop(args);
+    handlePatchUndo = (args) => this.hooks.handlePatchUndo(args);
+    handleCodeCaves = (args) => this.hooks.handleCodeCaves(args);
+    handleWriteValue = (args) => this.readwrite.handleWriteValue(args);
+    handleFreeze = (args) => this.readwrite.handleFreeze(args);
+    handleUnfreeze = (args) => this.readwrite.handleUnfreeze(args);
+    handleDump = (args) => this.readwrite.handleDump(args);
+    handleWriteUndo = (args) => this.readwrite.handleWriteUndo(args);
+    handleWriteRedo = (args) => this.readwrite.handleWriteRedo(args);
+    handleSpeedhackApply = (args) => this.integrity.handleSpeedhackApply(args);
+    handleSpeedhackSet = (args) => this.integrity.handleSpeedhackSet(args);
+    handleHeapEnumerate = (args) => this.integrity.handleHeapEnumerate(args);
+    handleHeapStats = (args) => this.integrity.handleHeapStats(args);
+    handleHeapAnomalies = (args) => this.integrity.handleHeapAnomalies(args);
+    handlePEHeaders = (args) => this.integrity.handlePEHeaders(args);
+    handlePEImportsExports = (args) => this.integrity.handlePEImportsExports(args);
+    handleInlineHookDetect = (args) => this.integrity.handleInlineHookDetect(args);
+    handleAntiCheatDetect = (args) => this.integrity.handleAntiCheatDetect(args);
+    handleGuardPages = (args) => this.integrity.handleGuardPages(args);
+    handleIntegrityCheck = (args) => this.integrity.handleIntegrityCheck(args);
 }