@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -0,0 +1,97 @@
+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),
+    });
+}
+export class ScanHandlers {
+    scanner;
+    constructor(scanner) {
+        this.scanner = scanner;
+    }
+    async handleFirstScan(args) {
+        try {
+            const options = {
+                valueType: args.valueType,
+                alignment: args.alignment,
+                maxResults: args.maxResults,
+                regionFilter: args.regionFilter,
+            };
+            const result = await this.scanner.firstScan(args.pid, args.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);
+        }
+    }
+}

package/dist/src/server/domains/memory/handlers/session.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryScanSessionManager } from '../../../../native/MemoryScanSession.js';
+export declare class SessionHandlers {
+    private readonly sessionManager;
+    constructor(sessionManager: MemoryScanSessionManager);
+    handleScanList(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleScanDelete(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleScanExport(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,49 @@
+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),
+    });
+}
+export class SessionHandlers {
+    sessionManager;
+    constructor(sessionManager) {
+        this.sessionManager = sessionManager;
+    }
+    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);
+        }
+    }
+}

package/dist/src/server/domains/memory/handlers/structure.d.ts

@@ -0,0 +1,29 @@
+import type { StructureAnalyzer } from '../../../../native/StructureAnalyzer.js';
+export declare class StructureHandlers {
+    private readonly structAnalyzer;
+    constructor(structAnalyzer: StructureAnalyzer);
+    handleStructureAnalyze(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleVtableParse(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleStructureExportC(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleStructureCompare(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,74 @@
+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),
+    });
+}
+export class StructureHandlers {
+    structAnalyzer;
+    constructor(structAnalyzer) {
+        this.structAnalyzer = structAnalyzer;
+    }
+    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);
+        }
+    }
+}

package/dist/src/server/domains/memory/handlers.impl.d.ts

@@ -1,7 +1,6 @@
 import type { MemoryScanner } from '../../../native/MemoryScanner.js';
 import type { MemoryScanSessionManager } from '../../../native/MemoryScanSession.js';
 import type { PointerChainEngine } from '../../../native/PointerChainEngine.js';
-import type { StructureAnalyzer } from '../../../native/StructureAnalyzer.js';
 import type { HardwareBreakpointEngine } from '../../../native/HardwareBreakpoint.js';
 import type { CodeInjector } from '../../../native/CodeInjector.js';
 import type { MemoryController } from '../../../native/MemoryController.js';
@@ -10,259 +9,255 @@ import type { HeapAnalyzer } from '../../../native/HeapAnalyzer.js';
 import type { PEAnalyzer } from '../../../native/PEAnalyzer.js';
 import type { AntiCheatDetector } from '../../../native/AntiCheatDetector.js';
 export declare class MemoryScanHandlers {
-    private readonly scanner;
-    private readonly sessionManager;
-    private readonly ptrEngine;
-    private readonly structAnalyzer;
-    private readonly bpEngine;
-    private readonly injector;
-    private readonly memCtrl;
-    private readonly speedhackEngine;
-    private readonly heapAnalyzer;
-    private readonly peAnalyzer;
-    private readonly antiCheatDetector;
-    constructor(scanner: MemoryScanner, sessionManager: MemoryScanSessionManager, ptrEngine: PointerChainEngine, structAnalyzer: StructureAnalyzer, bpEngine: HardwareBreakpointEngine | null, injector: CodeInjector, memCtrl: MemoryController, speedhackEngine: Speedhack | null, heapAnalyzer: HeapAnalyzer | null, peAnalyzer: PEAnalyzer | null, antiCheatDetector: AntiCheatDetector | null);
-    handleFirstScan(args: Record<string, unknown>): Promise<{
+    private readonly sessions;
+    private readonly scans;
+    private readonly ptrChains;
+    private readonly structures;
+    private readonly hooks;
+    private readonly readwrite;
+    private readonly integrity;
+    constructor(scanner: MemoryScanner, sessionManager: MemoryScanSessionManager, ptrEngine: PointerChainEngine, structAnalyzer: import('../../../native/StructureAnalyzer.js').StructureAnalyzer, bpEngine: HardwareBreakpointEngine | null, injector: CodeInjector, memCtrl: MemoryController, speedhackEngine: Speedhack | null, heapAnalyzer: HeapAnalyzer | null, peAnalyzer: PEAnalyzer | null, antiCheatDetector: AntiCheatDetector | null);
+    handleScanList: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleNextScan(args: Record<string, unknown>): Promise<{
+    handleScanDelete: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleUnknownScan(args: Record<string, unknown>): Promise<{
+    handleScanExport: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePointerScan(args: Record<string, unknown>): Promise<{
+    handleFirstScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleGroupScan(args: Record<string, unknown>): Promise<{
+    handleNextScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleScanList(_args: Record<string, unknown>): Promise<{
+    handleUnknownScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleScanDelete(args: Record<string, unknown>): Promise<{
+    handlePointerScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleScanExport(args: Record<string, unknown>): Promise<{
+    handleGroupScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePointerChainScan(args: Record<string, unknown>): Promise<{
+    handlePointerChainScan: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePointerChainValidate(args: Record<string, unknown>): Promise<{
+    handlePointerChainValidate: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePointerChainResolve(args: Record<string, unknown>): Promise<{
+    handlePointerChainResolve: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePointerChainExport(args: Record<string, unknown>): Promise<{
+    handlePointerChainExport: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleStructureAnalyze(args: Record<string, unknown>): Promise<{
+    handleStructureAnalyze: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleVtableParse(args: Record<string, unknown>): Promise<{
+    handleVtableParse: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleStructureExportC(args: Record<string, unknown>): Promise<{
+    handleStructureExportC: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleStructureCompare(args: Record<string, unknown>): Promise<{
+    handleStructureCompare: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleBreakpointSet(args: Record<string, unknown>): Promise<{
+    handleBreakpointSet: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleBreakpointRemove(args: Record<string, unknown>): Promise<{
+    handleBreakpointRemove: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleBreakpointList(_args: Record<string, unknown>): Promise<{
+    handleBreakpointList: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleBreakpointTrace(args: Record<string, unknown>): Promise<{
+    handleBreakpointTrace: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePatchBytes(args: Record<string, unknown>): Promise<{
+    handlePatchBytes: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePatchNop(args: Record<string, unknown>): Promise<{
+    handlePatchNop: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePatchUndo(args: Record<string, unknown>): Promise<{
+    handlePatchUndo: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleCodeCaves(args: Record<string, unknown>): Promise<{
+    handleCodeCaves: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleWriteValue(args: Record<string, unknown>): Promise<{
+    handleWriteValue: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleFreeze(args: Record<string, unknown>): Promise<{
+    handleFreeze: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleUnfreeze(args: Record<string, unknown>): Promise<{
+    handleUnfreeze: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleDump(args: Record<string, unknown>): Promise<{
+    handleDump: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleSpeedhackApply(args: Record<string, unknown>): Promise<{
+    handleWriteUndo: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleSpeedhackSet(args: Record<string, unknown>): Promise<{
+    handleWriteRedo: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleWriteUndo(_args: Record<string, unknown>): Promise<{
+    handleSpeedhackApply: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleWriteRedo(_args: Record<string, unknown>): Promise<{
+    handleSpeedhackSet: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleHeapEnumerate(args: Record<string, unknown>): Promise<{
+    handleHeapEnumerate: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleHeapStats(args: Record<string, unknown>): Promise<{
+    handleHeapStats: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleHeapAnomalies(args: Record<string, unknown>): Promise<{
+    handleHeapAnomalies: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePEHeaders(args: Record<string, unknown>): Promise<{
+    handlePEHeaders: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handlePEImportsExports(args: Record<string, unknown>): Promise<{
+    handlePEImportsExports: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleInlineHookDetect(args: Record<string, unknown>): Promise<{
+    handleInlineHookDetect: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleAntiCheatDetect(args: Record<string, unknown>): Promise<{
+    handleAntiCheatDetect: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleGuardPages(args: Record<string, unknown>): Promise<{
+    handleGuardPages: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;
         }[];
     }>;
-    handleIntegrityCheck(args: Record<string, unknown>): Promise<{
+    handleIntegrityCheck: (args: Record<string, unknown>) => Promise<{
         content: {
             type: "text";
             text: string;