@jshookmcp/jshook 0.1.5 → 0.1.7

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

@@ -1,5 +1,8 @@
+import type { AuditEntry } from '../../../modules/process/memory/AuditTrail.js';
 import { ProcessToolHandlersBase } from '../../domains/process/handlers.impl.core.runtime.base.js';
 export declare class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
+    private safeBuildMemoryDiagnostics;
+    protected recordMemoryAudit(entry: Omit<AuditEntry, 'timestamp' | 'user'>): void;
     handleMemoryRead(args: Record<string, unknown>): Promise<{
         content: {
             type: string;
@@ -18,6 +21,12 @@ export declare class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
             text: string;
         }[];
     }>;
+    handleMemoryAuditExport(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
     handleMemoryCheckProtection(args: Record<string, unknown>): Promise<{
         content: {
             type: string;

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 {

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)) },

package/dist/server/domains/workflow/handlers.impl.workflow-api.js

@@ -119,8 +119,7 @@ export class WorkflowHandlersApi extends WorkflowHandlersBase {
   }
 
   var results = {};
-  for (var i = 0; i < paths.length; i++) {
-    var path = paths[i];
+  async function probePath(path) {
     try {
       var opts = {method: method, headers: headers};
       if (bodyTemplate && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
@@ -137,11 +136,22 @@ export class WorkflowHandlersApi extends WorkflowHandlersBase {
           snippet = '[HTML/XML response suppressed]';
         }
       }
-      results[path] = {status: resp.status, contentType: ct.split(';')[0].trim(), snippet: snippet};
+      return [path, {status: resp.status, contentType: ct.split(';')[0].trim(), snippet: snippet}];
     } catch(e) {
-      results[path] = {status: -1, error: e.message};
+      return [path, {status: -1, error: e instanceof Error ? e.message : String(e)}];
     }
   }
+
+  var nextIndex = 0;
+  var maxConcurrency = Math.min(paths.length, 6);
+  await Promise.all(Array.from({ length: maxConcurrency }, async function() {
+    while (nextIndex < paths.length) {
+      var currentIndex = nextIndex++;
+      var currentPath = paths[currentIndex];
+      var entry = await probePath(currentPath);
+      results[entry[0]] = entry[1];
+    }
+  }));
   return {probed: paths.length, method: method, baseUrl: baseUrl, results: results};
 })()`;
         try {

package/dist/server/registry/discovery.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { dirname, join, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { logger } from '../../utils/logger.js';
 function isDomainManifest(value) {
     if (!value || typeof value !== 'object')
@@ -35,24 +35,29 @@ async function discoverManifestPaths() {
         logger.error('[discovery] Cannot read domains directory:', err);
         return [];
     }
-    const paths = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
+    const directories = entries.filter(e => e.isDirectory());
+    const resolved = await Promise.all(directories.map(async (entry) => {
         for (const ext of ['manifest.js', 'manifest.ts']) {
             const manifestPath = join(domainsDir, entry.name, ext);
             try {
                 const s = await stat(manifestPath);
-                if (s.isFile()) {
-                    paths.push(manifestPath);
-                    break;
-                }
+                if (s.isFile())
+                    return manifestPath;
             }
             catch {
             }
         }
+        return null;
+    }));
+    return resolved.filter((value) => value !== null);
+}
+function toImportSpecifier(absPath) {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const relPath = relative(currentDir, absPath).split(sep).join('/');
+    if (relPath.startsWith('.')) {
+        return relPath;
     }
-    return paths;
+    return `./${relPath}`;
 }
 export async function discoverDomainManifests() {
     const files = await discoverManifestPaths();
@@ -61,7 +66,7 @@ export async function discoverDomainManifests() {
     const seenDepKeys = new Set();
     for (const absPath of files) {
         try {
-            const mod = await import(pathToFileURL(absPath).href);
+            const mod = await import(toImportSpecifier(absPath));
             const manifest = extractManifest(mod);
             if (!manifest) {
                 logger.warn('[discovery] Skipping ' + absPath + ': no valid DomainManifest export');

package/dist/server/registry/index.js

@@ -3,6 +3,8 @@ import { logger } from '../../utils/logger.js';
 let _manifests = null;
 let _registrations = null;
 let _initPromise = null;
+let _domainsView = null;
+let _toolNamesView = null;
 async function init() {
     if (_manifests !== null)
         return;
@@ -26,6 +28,8 @@ async function init() {
             }
         }
         _registrations = [...uniqueByToolName.values()];
+        _domainsView = new Set(_manifests.map(m => m.domain));
+        _toolNamesView = new Set(_registrations.map(r => r.tool.name));
     })();
     await _initPromise;
 }
@@ -49,10 +53,14 @@ export function getAllRegistrations() {
     return getRegistrations();
 }
 export function getAllDomains() {
-    return new Set(getManifests().map(m => m.domain));
+    if (!_domainsView)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _domainsView;
 }
 export function getAllToolNames() {
-    return new Set(getRegistrations().map(r => r.tool.name));
+    if (!_toolNamesView)
+        throw new Error('[registry] Not initialised - call initRegistry() first.');
+    return _toolNamesView;
 }
 export function buildToolGroups() {
     const groups = {};

package/dist/utils/TokenBudgetManager.d.ts

@@ -45,6 +45,7 @@ export declare class TokenBudgetManager {
     recordToolCall(toolName: string, request: unknown, response: unknown): void;
     private isRecord;
     private hasDetailedSummarySize;
+    private tryEstimateMcpEnvelope;
     private calculateSize;
     private normalizeForSizeEstimate;
     private estimateTokens;

package/dist/utils/TokenBudgetManager.js

@@ -74,11 +74,33 @@ export class TokenBudgetManager {
         const { size } = summary;
         return typeof size === 'number' && Number.isFinite(size) && size > 0;
     }
+    tryEstimateMcpEnvelope(data) {
+        if (!this.isRecord(data))
+            return null;
+        const content = data['content'];
+        if (!Array.isArray(content) || content.length === 0)
+            return null;
+        const first = content[0];
+        if (!this.isRecord(first))
+            return null;
+        if (first['type'] !== 'text' || typeof first['text'] !== 'string')
+            return null;
+        const text = first['text'];
+        const truncated = text.length > this.MAX_ESTIMATION_STRING_LENGTH
+            ? `${text.slice(0, this.MAX_ESTIMATION_STRING_LENGTH)}...[truncated:${text.length}]`
+            : text;
+        const overhead = 42 + (data['isError'] === true ? 14 : 0);
+        const textBytes = Buffer.byteLength(truncated, 'utf8');
+        return Math.min(overhead + textBytes, this.MAX_ESTIMATION_BYTES);
+    }
     calculateSize(data) {
         try {
             if (this.hasDetailedSummarySize(data)) {
                 return Math.min(data.summary.size, this.MAX_ESTIMATION_BYTES);
             }
+            const mcpSize = this.tryEstimateMcpEnvelope(data);
+            if (mcpSize !== null)
+                return mcpSize;
             const normalized = this.normalizeForSizeEstimate(data, 0, new WeakSet());
             const serialized = JSON.stringify(normalized);
             if (!serialized) {