@jshookmcp/jshook 0.1.4 → 0.1.6

package/dist/server/domains/process/handlers.impl.core.runtime.memory.js

@@ -14,14 +14,67 @@ function normalizePatternType(value) {
     }
     return 'hex';
 }
+function getOptionalPid(value) {
+    const pid = Number(value);
+    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+function getOptionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function getOptionalPositiveNumber(value) {
+    const size = Number(value);
+    return Number.isFinite(size) && size > 0 ? size : undefined;
+}
+function getWriteSize(data, encoding) {
+    if (encoding === 'hex') {
+        const normalized = data.replace(/\s+/g, '');
+        return Math.ceil(normalized.length / 2);
+    }
+    return Buffer.from(data, 'base64').length;
+}
 export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
+    async safeBuildMemoryDiagnostics(input) {
+        try {
+            return await this.buildMemoryDiagnostics(input);
+        }
+        catch (diagnosticError) {
+            logger.warn('Memory diagnostics generation failed:', diagnosticError);
+            return undefined;
+        }
+    }
+    recordMemoryAudit(entry) {
+        try {
+            this.auditTrail.record(entry);
+        }
+        catch (auditError) {
+            logger.warn('Memory audit trail recording failed:', auditError);
+        }
+    }
     async handleMemoryRead(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const address = requireString(args.address, 'address');
             const size = requirePositiveNumber(args.size, 'size');
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_read',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_read',
+                    pid,
+                    address,
+                    size,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -34,38 +87,82 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 requestedAddress: address,
                                 requestedSize: size,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.readMemory(pid, address, size);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_read',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_read',
+                pid,
+                address,
+                size,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                data: result.data,
+                error: result.error,
+                pid,
+                address,
+                size,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            data: result.data,
-                            error: result.error,
-                            pid,
-                            address,
-                            size,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory read failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const address = getOptionalString(args.address);
+            const size = getOptionalPositiveNumber(args.size);
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                address,
+                size,
+                operation: 'memory_read',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_read',
+                pid: pid ?? null,
+                address: address ?? null,
+                size: size ?? null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
                         }, null, 2),
                     },
                 ],
@@ -73,13 +170,32 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
         }
     }
     async handleMemoryWrite(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const address = requireString(args.address, 'address');
             const data = requireString(args.data, 'data');
             const encoding = args.encoding || 'hex';
+            const size = getWriteSize(data, encoding);
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_write',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_write',
+                    pid,
+                    address,
+                    size,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -93,39 +209,85 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 dataLength: data != null ? data.length : 0,
                                 encoding,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.writeMemory(pid, address, data, encoding);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_write',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_write',
+                pid,
+                address,
+                size,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                bytesWritten: result.bytesWritten,
+                error: result.error,
+                pid,
+                address,
+                dataLength: data.length,
+                encoding,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            bytesWritten: result.bytesWritten,
-                            error: result.error,
-                            pid,
-                            address,
-                            dataLength: data.length,
-                            encoding,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory write failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const address = getOptionalString(args.address);
+            const data = getOptionalString(args.data);
+            const encoding = args.encoding || 'hex';
+            const size = data ? getWriteSize(data, encoding) : undefined;
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                address,
+                size,
+                operation: 'memory_write',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_write',
+                pid: pid ?? null,
+                address: address ?? null,
+                size: size ?? null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
                         }, null, 2),
                     },
                 ],
@@ -133,12 +295,28 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
         }
     }
     async handleMemoryScan(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const pattern = requireString(args.pattern, 'pattern');
             const patternType = normalizePatternType(args.patternType);
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    operation: 'memory_scan',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_scan',
+                    pid,
+                    address: null,
+                    size: null,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -151,43 +329,116 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 requestedPattern: pattern,
                                 patternType,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.scanMemory(pid, pattern, patternType);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    operation: 'memory_scan',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_scan',
+                pid,
+                address: null,
+                size: null,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                addresses: result.addresses,
+                error: result.error,
+                pid,
+                pattern,
+                patternType,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            addresses: result.addresses,
-                            error: result.error,
-                            pid,
-                            pattern,
-                            patternType,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory scan failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                operation: 'memory_scan',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_scan',
+                pid: pid ?? null,
+                address: null,
+                size: null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleMemoryAuditExport(args) {
+        try {
+            const exportedJson = this.auditTrail.exportJson();
+            const entries = JSON.parse(exportedJson);
+            const clear = args.clear === true;
+            const count = this.auditTrail.size();
+            if (clear) {
+                this.auditTrail.clear();
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count,
+                            cleared: clear,
+                            entries,
                         }, null, 2),
                     },
                 ],
             };
         }
+        catch (error) {
+            logger.error('Memory audit export failed:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
+                    },
+                ],
+            };
+        }
     }
     async handleMemoryCheckProtection(args) {
         try {
@@ -360,4 +611,3 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
         }
     }
 }
-//# sourceMappingURL=handlers.impl.core.runtime.memory.js.map

package/dist/server/domains/process/handlers.impl.d.ts

@@ -1,2 +1 @@
 export { ProcessToolHandlers } from '../../domains/process/handlers.impl.core.js';
-//# sourceMappingURL=handlers.impl.d.ts.map

package/dist/server/domains/process/handlers.impl.js

@@ -1,2 +1 @@
 export { ProcessToolHandlers } from '../../domains/process/handlers.impl.core.js';
-//# sourceMappingURL=handlers.impl.js.map

package/dist/server/domains/process/handlers.js

@@ -1,2 +1 @@
 export { ProcessToolHandlers } from '../../domains/process/handlers.impl.js';
-//# sourceMappingURL=handlers.js.map

package/dist/server/domains/process/index.d.ts

@@ -1,3 +1,2 @@
 export { processToolDefinitions } from '../../domains/process/definitions.js';
 export { ProcessToolHandlers } from '../../domains/process/handlers.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/domains/process/index.js

@@ -1,3 +1,2 @@
 export { processToolDefinitions } from '../../domains/process/definitions.js';
 export { ProcessToolHandlers } from '../../domains/process/handlers.js';
-//# sourceMappingURL=index.js.map

package/dist/server/domains/process/manifest.d.ts

@@ -5,4 +5,3 @@ declare const DEP_KEY: "processHandlers";
 type H = ProcessToolHandlers;
 declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
 export default manifest;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/server/domains/process/manifest.js

@@ -36,6 +36,7 @@ const manifest = {
         { tool: t('memory_batch_write'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryBatchWrite(a)) },
         { tool: t('memory_dump_region'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryDumpRegion(a)) },
         { tool: t('memory_list_regions'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryListRegions(a)) },
+        { tool: t('memory_audit_export'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryAuditExport(a)) },
         { tool: t('inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
         { tool: t('module_inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
         { tool: t('inject_shellcode'), domain: DOMAIN, bind: b((h, a) => h.handleInjectShellcode(a)) },
@@ -46,4 +47,3 @@ const manifest = {
     ],
 };
 export default manifest;
-//# sourceMappingURL=manifest.js.map

package/dist/server/domains/shared/modules.d.ts

@@ -22,4 +22,3 @@ export { ConsoleMonitor } from '../../../modules/monitor/ConsoleMonitor.js';
 export { PerformanceMonitor } from '../../../modules/monitor/PerformanceMonitor.js';
 export { MemoryManager, UnifiedProcessManager } from '../../../modules/process/index.js';
 export { StealthScripts } from '../../../modules/stealth/StealthScripts.js';
-//# sourceMappingURL=modules.d.ts.map

package/dist/server/domains/shared/modules.js

@@ -21,4 +21,3 @@ export { ConsoleMonitor } from '../../../modules/monitor/ConsoleMonitor.js';
 export { PerformanceMonitor } from '../../../modules/monitor/PerformanceMonitor.js';
 export { MemoryManager, UnifiedProcessManager } from '../../../modules/process/index.js';
 export { StealthScripts } from '../../../modules/stealth/StealthScripts.js';
-//# sourceMappingURL=modules.js.map

package/dist/server/domains/shared/registry.d.ts

@@ -3,4 +3,3 @@ export { toolLookup } from '../../registry/types.js';
 export { bindByDepKey, getDep } from '../../registry/bind-helpers.js';
 export { ensureBrowserCore } from '../../registry/ensure-browser-core.js';
 export type { MCPServerContext } from '../../MCPServer.context.js';
-//# sourceMappingURL=registry.d.ts.map

package/dist/server/domains/shared/registry.js

@@ -1,4 +1,3 @@
 export { toolLookup } from '../../registry/types.js';
 export { bindByDepKey, getDep } from '../../registry/bind-helpers.js';
 export { ensureBrowserCore } from '../../registry/ensure-browser-core.js';
-//# sourceMappingURL=registry.js.map

package/dist/server/domains/shared/response.d.ts

@@ -7,4 +7,3 @@ export declare function serializeError(error: unknown): {
     error: string;
 };
 export declare function toolErrorToResponse(error: unknown): ToolResponse;
-//# sourceMappingURL=response.d.ts.map

package/dist/server/domains/shared/response.js

@@ -39,4 +39,3 @@ export function toolErrorToResponse(error) {
     }
     return asErrorResponse(error);
 }
-//# sourceMappingURL=response.js.map

package/dist/server/domains/sourcemap/definitions.d.ts

@@ -1,3 +1,2 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export declare const sourcemapTools: Tool[];
-//# sourceMappingURL=definitions.d.ts.map

package/dist/server/domains/sourcemap/definitions.js

@@ -81,4 +81,3 @@ export const sourcemapTools = [
         },
     },
 ];
-//# sourceMappingURL=definitions.js.map

package/dist/server/domains/sourcemap/handlers.d.ts

@@ -1,2 +1 @@
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.impl.js';
-//# sourceMappingURL=handlers.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.core.d.ts

@@ -1,4 +1,3 @@
 import { SourcemapToolHandlersMain } from '../../domains/sourcemap/handlers.impl.sourcemap-main.js';
 export declare class SourcemapToolHandlers extends SourcemapToolHandlersMain {
 }
-//# sourceMappingURL=handlers.impl.core.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.core.js

@@ -1,4 +1,3 @@
 import { SourcemapToolHandlersMain } from '../../domains/sourcemap/handlers.impl.sourcemap-main.js';
 export class SourcemapToolHandlers extends SourcemapToolHandlersMain {
 }
-//# sourceMappingURL=handlers.impl.core.js.map

package/dist/server/domains/sourcemap/handlers.impl.d.ts

@@ -1,2 +1 @@
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.impl.core.js';
-//# sourceMappingURL=handlers.impl.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.js

@@ -1,2 +1 @@
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.impl.core.js';
-//# sourceMappingURL=handlers.impl.js.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-common.d.ts

@@ -17,4 +17,3 @@ export declare class SourcemapToolHandlersCommon extends SourcemapToolHandlersPa
     protected json(payload: unknown): TextToolResponse;
     protected fail(tool: string, error: unknown): TextToolResponse;
 }
-//# sourceMappingURL=handlers.impl.sourcemap-common.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-common.js

@@ -139,4 +139,3 @@ export class SourcemapToolHandlersCommon extends SourcemapToolHandlersParseBase
         });
     }
 }
-//# sourceMappingURL=handlers.impl.sourcemap-common.js.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-extension.d.ts

@@ -11,4 +11,3 @@ export declare class SourcemapToolHandlersExtension extends SourcemapToolHandler
         exceptionDetails: unknown;
     }>;
 }
-//# sourceMappingURL=handlers.impl.sourcemap-extension.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-extension.js

@@ -191,4 +191,3 @@ export class SourcemapToolHandlersExtension extends SourcemapToolHandlersCommon
         };
     }
 }
-//# sourceMappingURL=handlers.impl.sourcemap-extension.js.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-main.d.ts

@@ -5,4 +5,3 @@ export declare class SourcemapToolHandlersMain extends SourcemapToolHandlersExte
     handleSourcemapFetchAndParse(args: Record<string, unknown>): Promise<TextToolResponse>;
     handleSourcemapReconstructTree(args: Record<string, unknown>): Promise<TextToolResponse>;
 }
-//# sourceMappingURL=handlers.impl.sourcemap-main.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-main.js

@@ -154,4 +154,3 @@ export class SourcemapToolHandlersMain extends SourcemapToolHandlersExtension {
         }
     }
 }
-//# sourceMappingURL=handlers.impl.sourcemap-main.js.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-parse-base.d.ts

@@ -71,4 +71,3 @@ export declare class SourcemapToolHandlersParseBase {
     protected asRecord(value: unknown): JsonRecord;
     protected asString(value: unknown): string | undefined;
 }
-//# sourceMappingURL=handlers.impl.sourcemap-parse-base.d.ts.map

package/dist/server/domains/sourcemap/handlers.impl.sourcemap-parse-base.js

@@ -287,4 +287,3 @@ export class SourcemapToolHandlersParseBase {
         return typeof value === 'string' ? value : undefined;
     }
 }
-//# sourceMappingURL=handlers.impl.sourcemap-parse-base.js.map

package/dist/server/domains/sourcemap/handlers.js

@@ -1,2 +1 @@
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.impl.js';
-//# sourceMappingURL=handlers.js.map

package/dist/server/domains/sourcemap/index.d.ts

@@ -1,3 +1,2 @@
 export { sourcemapTools } from '../../domains/sourcemap/definitions.js';
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/domains/sourcemap/index.js

@@ -1,3 +1,2 @@
 export { sourcemapTools } from '../../domains/sourcemap/definitions.js';
 export { SourcemapToolHandlers } from '../../domains/sourcemap/handlers.js';
-//# sourceMappingURL=index.js.map

package/dist/server/domains/sourcemap/manifest.d.ts

@@ -5,4 +5,3 @@ declare const DEP_KEY: "sourcemapHandlers";
 type H = SourcemapToolHandlers;
 declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
 export default manifest;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/server/domains/sourcemap/manifest.js

@@ -29,4 +29,3 @@ const manifest = {
     ],
 };
 export default manifest;
-//# sourceMappingURL=manifest.js.map

package/dist/server/domains/streaming/definitions.d.ts

@@ -1,3 +1,2 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 export declare const streamingTools: Tool[];
-//# sourceMappingURL=definitions.d.ts.map

package/dist/server/domains/streaming/definitions.js

@@ -108,4 +108,3 @@ export const streamingTools = [
         },
     },
 ];
-//# sourceMappingURL=definitions.js.map

package/dist/server/domains/streaming/handlers.d.ts

@@ -1,2 +1 @@
 export { StreamingToolHandlers } from '../../domains/streaming/handlers.impl.js';
-//# sourceMappingURL=handlers.d.ts.map