@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,97 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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,266 +0,0 @@
-import type { MemoryScanner } from '../../../native/MemoryScanner.js';
-import type { MemoryScanSessionManager } from '../../../native/MemoryScanSession.js';
-import type { PointerChainEngine } from '../../../native/PointerChainEngine.js';
-import type { HardwareBreakpointEngine } from '../../../native/HardwareBreakpoint.js';
-import type { CodeInjector } from '../../../native/CodeInjector.js';
-import type { MemoryController } from '../../../native/MemoryController.js';
-import type { Speedhack } from '../../../native/Speedhack.js';
-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 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;
-        }[];
-    }>;
-    handleScanDelete: (args: Record<string, unknown>) => Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleScanExport: (args: Record<string, unknown>) => Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    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;
-        }[];
-    }>;
-    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.impl.js

@@ -1,66 +0,0 @@
-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 {
-    sessions;
-    scans;
-    ptrChains;
-    structures;
-    hooks;
-    readwrite;
-    integrity;
-    constructor(scanner, sessionManager, ptrEngine, structAnalyzer, bpEngine, injector, memCtrl, speedhackEngine, heapAnalyzer, peAnalyzer, antiCheatDetector) {
-        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);
-}

package/dist/src/server/domains/memory/index.d.ts

@@ -1,2 +0,0 @@
-export { MemoryScanHandlers } from './handlers.impl.js';
-export { memoryScanToolDefinitions } from './definitions.js';

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

@@ -1,2 +0,0 @@
-export { MemoryScanHandlers } from './handlers.impl.js';
-export { memoryScanToolDefinitions } from './definitions.js';

package/dist/src/server/domains/memory/manifest.d.ts

@@ -1,7 +0,0 @@
-import type { DomainManifest } from '../../registry/contracts.js';
-import { MemoryScanHandlers } from './handlers.impl.js';
-declare const DOMAIN: "memory";
-declare const DEP_KEY: "memoryScanHandlers";
-type H = MemoryScanHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
-export default manifest;