@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -0,0 +1,55 @@
+import type { HardwareBreakpointEngine } from '../../../../native/HardwareBreakpoint.js';
+import type { CodeInjector } from '../../../../native/CodeInjector.js';
+export declare class HookHandlers {
+    private readonly bpEngine;
+    private readonly injector;
+    constructor(bpEngine: HardwareBreakpointEngine | null, injector: CodeInjector);
+    handleBreakpointSet(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleBreakpointRemove(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleBreakpointList(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleBreakpointTrace(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePatchBytes(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePatchNop(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePatchUndo(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleCodeCaves(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,115 @@
+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 HookHandlers {
+    bpEngine;
+    injector;
+    constructor(bpEngine, injector) {
+        this.bpEngine = bpEngine;
+        this.injector = injector;
+    }
+    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);
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+import type { HeapAnalyzer } from '../../../../native/HeapAnalyzer.js';
+import type { PEAnalyzer } from '../../../../native/PEAnalyzer.js';
+import type { AntiCheatDetector } from '../../../../native/AntiCheatDetector.js';
+import type { Speedhack } from '../../../../native/Speedhack.js';
+export declare class IntegrityHandlers {
+    private readonly speedhackEngine;
+    private readonly heapAnalyzer;
+    private readonly peAnalyzer;
+    private readonly antiCheatDetector;
+    constructor(speedhackEngine: Speedhack | null, heapAnalyzer: HeapAnalyzer | null, peAnalyzer: PEAnalyzer | null, antiCheatDetector: AntiCheatDetector | null);
+    handleSpeedhackApply(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleSpeedhackSet(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleHeapEnumerate(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleHeapStats(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleHeapAnomalies(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePEHeaders(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePEImportsExports(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleInlineHookDetect(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleAntiCheatDetect(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleGuardPages(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleIntegrityCheck(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,180 @@
+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 IntegrityHandlers {
+    speedhackEngine;
+    heapAnalyzer;
+    peAnalyzer;
+    antiCheatDetector;
+    constructor(speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector) {
+        this.speedhackEngine = speedhackEngine;
+        this.heapAnalyzer = heapAnalyzer;
+        this.peAnalyzer = peAnalyzer;
+        this.antiCheatDetector = antiCheatDetector;
+    }
+    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 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);
+        }
+    }
+}

package/dist/src/server/domains/memory/handlers/pointer-chain.d.ts

@@ -0,0 +1,29 @@
+import type { PointerChainEngine } from '../../../../native/PointerChainEngine.js';
+export declare class PointerChainHandlers {
+    private readonly ptrEngine;
+    constructor(ptrEngine: PointerChainEngine);
+    handlePointerChainScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePointerChainValidate(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePointerChainResolve(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePointerChainExport(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

package/dist/src/server/domains/memory/handlers/pointer-chain.js

@@ -0,0 +1,82 @@
+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 PointerChainHandlers {
+    ptrEngine;
+    constructor(ptrEngine) {
+        this.ptrEngine = ptrEngine;
+    }
+    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);
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { MemoryController } from '../../../../native/MemoryController.js';
+export declare class ReadWriteHandlers {
+    private readonly memCtrl;
+    constructor(memCtrl: MemoryController);
+    handleWriteValue(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleFreeze(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleUnfreeze(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleDump(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleWriteUndo(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleWriteRedo(_args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,78 @@
+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 ReadWriteHandlers {
+    memCtrl;
+    constructor(memCtrl) {
+        this.memCtrl = memCtrl;
+    }
+    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 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);
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { MemoryScanner } from '../../../../native/MemoryScanner.js';
+export declare class ScanHandlers {
+    private readonly scanner;
+    constructor(scanner: MemoryScanner);
+    handleFirstScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleNextScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleUnknownScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handlePointerScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+    handleGroupScan(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}