@jshookmcp/jshook 0.2.0 → 0.2.2

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

@@ -1,87 +1 @@
-import { UnifiedProcessManager, MemoryManager } from '../../domains/shared/modules.js';
-import { MemoryAuditTrail } from '../../../modules/process/memory/AuditTrail.js';
-interface MemoryDiagnosticsInput {
-    pid?: number;
-    address?: string;
-    size?: number;
-    operation: string;
-    error?: string;
-}
-interface MemoryDiagnostics {
-    permission: {
-        available: boolean;
-        reason?: string;
-        platform: string;
-    };
-    process: {
-        exists: boolean | null;
-        pid: number | null;
-        name: string | null;
-    };
-    address: {
-        queried: boolean;
-        valid: boolean | null;
-        protection: string | null;
-        regionStart: string | null;
-        regionSize: number | null;
-    };
-    aslr: {
-        heuristic: true;
-        note: string;
-    };
-    recommendedActions: string[];
-}
-export declare function validatePid(value: unknown): number;
-export declare function requireString(value: unknown, name: string): string;
-export declare function requirePositiveNumber(value: unknown, name: string): number;
-export declare class ProcessToolHandlersBase {
-    protected processManager: UnifiedProcessManager;
-    protected memoryManager: MemoryManager;
-    protected platform: string;
-    protected auditTrail: MemoryAuditTrail;
-    constructor();
-    protected buildMemoryDiagnostics(input: MemoryDiagnosticsInput): Promise<MemoryDiagnostics>;
-    handleProcessFind(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessGet(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessWindows(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessFindChromium(_args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessCheckDebugPort(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessLaunchDebug(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleProcessKill(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
-export {};
+export { validatePid, requireString, requirePositiveNumber, ProcessHandlersBase as ProcessToolHandlersBase, } from '../../domains/process/handlers.base.js';

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

@@ -1,404 +1 @@
-import { UnifiedProcessManager, MemoryManager } from '../../domains/shared/modules.js';
-import { MemoryAuditTrail } from '../../../modules/process/memory/AuditTrail.js';
-import { logger } from '../../../utils/logger.js';
-export function validatePid(value) {
-    const n = Number(value);
-    if (!Number.isInteger(n) || n <= 0)
-        throw new Error(`Invalid PID: ${JSON.stringify(value)}`);
-    return n;
-}
-export function requireString(value, name) {
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`${name} must be a non-empty string`);
-    }
-    return value;
-}
-export function requirePositiveNumber(value, name) {
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0)
-        throw new Error(`${name} must be a positive number`);
-    return n;
-}
-export class ProcessToolHandlersBase {
-    processManager;
-    memoryManager;
-    platform;
-    auditTrail = new MemoryAuditTrail();
-    constructor() {
-        this.processManager = new UnifiedProcessManager();
-        this.memoryManager = new MemoryManager();
-        this.platform = this.processManager.getPlatform();
-        logger.info(`ProcessToolHandlers initialized for platform: ${this.platform}`);
-    }
-    async buildMemoryDiagnostics(input) {
-        const recommendedActions = new Set();
-        const permission = await this.memoryManager.checkAvailability();
-        if (!permission.available) {
-            recommendedActions.add('Run as administrator');
-        }
-        let processInfo = null;
-        if (input.pid != null) {
-            try {
-                const resolvedProcess = await this.processManager.getProcessByPid(input.pid);
-                processInfo = resolvedProcess
-                    ? {
-                        pid: resolvedProcess.pid,
-                        name: resolvedProcess.name,
-                        executablePath: resolvedProcess.executablePath,
-                        windowTitle: resolvedProcess.windowTitle,
-                        windowHandle: resolvedProcess.windowHandle,
-                        memoryUsage: resolvedProcess.memoryUsage,
-                    }
-                    : null;
-            }
-            catch {
-                processInfo = null;
-            }
-            if (!processInfo) {
-                recommendedActions.add('Check if process is still running');
-            }
-        }
-        let protectionInfo = null;
-        let protectionQueryFailed = false;
-        if (input.pid != null && input.address) {
-            try {
-                protectionInfo = await this.memoryManager.checkMemoryProtection(input.pid, input.address);
-            }
-            catch {
-                protectionQueryFailed = true;
-            }
-            if (protectionQueryFailed || protectionInfo?.success === false) {
-                recommendedActions.add('Verify address is within valid memory region');
-            }
-        }
-        if (input.size != null && protectionInfo?.regionSize != null && input.size > protectionInfo.regionSize) {
-            recommendedActions.add('Reduce the requested size to fit the target memory region');
-        }
-        if (input.operation === 'memory_read' && protectionInfo?.success && protectionInfo.isReadable === false) {
-            recommendedActions.add('Ensure target memory region is readable');
-        }
-        if (input.operation === 'memory_write' && protectionInfo?.success && protectionInfo.isWritable === false) {
-            recommendedActions.add('Ensure target memory region is writable');
-        }
-        let modulesEnumerated = false;
-        let moduleCount = null;
-        if (input.pid != null) {
-            try {
-                const modulesResult = await this.memoryManager.enumerateModules(input.pid);
-                modulesEnumerated = modulesResult.success;
-                moduleCount = modulesResult.modules?.length ?? null;
-            }
-            catch {
-                modulesEnumerated = false;
-            }
-        }
-        if (input.pid != null && input.address) {
-            recommendedActions.add('Re-resolve the address after the process restarts because ASLR can shift module addresses');
-        }
-        const normalizedError = input.error?.toLowerCase() ?? '';
-        if (normalizedError.includes('access denied') ||
-            normalizedError.includes('permission') ||
-            normalizedError.includes('privilege') ||
-            normalizedError.includes('administrator')) {
-            recommendedActions.add('Run as administrator');
-        }
-        const aslrNote = modulesEnumerated
-            ? moduleCount && moduleCount > 0
-                ? `Enumerated ${moduleCount} module(s). Treat absolute addresses as session-specific because ASLR can shift module bases between launches.`
-                : 'Module enumeration succeeded but returned no modules. Absolute addresses may still change across process launches because of ASLR.'
-            : 'Module enumeration was unavailable. Assume ASLR may shift absolute addresses between launches and re-resolve addresses after restarts.';
-        return {
-            permission: {
-                available: permission.available,
-                reason: permission.reason,
-                platform: this.platform,
-            },
-            process: {
-                exists: input.pid != null ? Boolean(processInfo) : null,
-                pid: input.pid ?? null,
-                name: processInfo?.name ?? null,
-            },
-            address: {
-                queried: input.pid != null && Boolean(input.address),
-                valid: input.pid != null && input.address ? protectionInfo?.success ?? null : null,
-                protection: protectionInfo?.protection ?? null,
-                regionStart: protectionInfo?.regionStart ?? null,
-                regionSize: protectionInfo?.regionSize ?? null,
-            },
-            aslr: {
-                heuristic: true,
-                note: aslrNote,
-            },
-            recommendedActions: Array.from(recommendedActions),
-        };
-    }
-    async handleProcessFind(args) {
-        try {
-            const pattern = requireString(args.pattern, 'pattern');
-            const processes = await this.processManager.findProcesses(pattern);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            pattern,
-                            count: processes.length,
-                            processes: processes.map((p) => ({
-                                pid: p.pid,
-                                name: p.name,
-                                path: p.executablePath,
-                                windowTitle: p.windowTitle,
-                                windowHandle: p.windowHandle,
-                                memoryMB: p.memoryUsage ? Math.round(p.memoryUsage / 1024 / 1024) : undefined,
-                            })),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Process find failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleProcessGet(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const process = await this.processManager.getProcessByPid(pid);
-            if (!process) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                message: `Process with PID ${pid} not found`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const cmdLine = await this.processManager.getProcessCommandLine(pid);
-            const debugPort = await this.processManager.checkDebugPort(pid, {
-                commandLine: cmdLine.commandLine,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            process: {
-                                ...process,
-                                commandLine: cmdLine.commandLine,
-                                parentPid: cmdLine.parentPid,
-                                debugPort,
-                            },
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Process get failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleProcessWindows(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const windows = await this.processManager.getProcessWindows(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            pid,
-                            windowCount: windows.length,
-                            windows: windows.map((w) => ({
-                                handle: w.handle,
-                                title: w.title,
-                                className: w.className,
-                                processId: w.processId,
-                            })),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Process windows failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleProcessFindChromium(_args) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        disabled: true,
-                        message: 'process_find_chromium is disabled to avoid scanning user-installed browser processes.',
-                        guidance: [
-                            'Use browser_launch(driver="chrome"|"camoufox") to start a managed browser session.',
-                            'Use browser_attach/browser_launch(mode="connect") with an explicit browserURL/wsEndpoint.',
-                            'Use process_launch_debug for explicitly targeted Electron/Chromium executables.',
-                        ],
-                        platform: this.platform,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleProcessCheckDebugPort(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const debugPort = await this.processManager.checkDebugPort(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            pid,
-                            debugPort,
-                            canAttach: debugPort !== null,
-                            attachUrl: debugPort ? `http://localhost:${debugPort}` : null,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Check debug port failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleProcessLaunchDebug(args) {
-        try {
-            const executablePath = requireString(args.executablePath, 'executablePath');
-            const debugPort = args.debugPort || 9222;
-            const argsList = args.args || [];
-            const process = await this.processManager.launchWithDebug(executablePath, debugPort, argsList);
-            if (!process) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                message: 'Failed to launch process',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            process: {
-                                pid: process.pid,
-                                name: process.name,
-                                path: process.executablePath,
-                            },
-                            debugPort,
-                            attachUrl: `http://localhost:${debugPort}`,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Launch debug failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleProcessKill(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const killed = await this.processManager.killProcess(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: killed,
-                            pid,
-                            message: killed ? `Process ${pid} killed successfully` : `Failed to kill process ${pid}`,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Process kill failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: error instanceof Error ? error.message : String(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}
+export { validatePid, requireString, requirePositiveNumber, ProcessHandlersBase as ProcessToolHandlersBase, } from '../../domains/process/handlers.base.js';

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

@@ -1,5 +1,5 @@
-import { ProcessToolHandlersMemory } from '../../domains/process/handlers.impl.core.runtime.memory.js';
-export declare class ProcessToolHandlersRuntime extends ProcessToolHandlersMemory {
+import { ProcessHandlersBase } from '../../domains/process/handlers.base.js';
+export declare class ProcessToolHandlersRuntime extends ProcessHandlersBase {
     handleInjectDll(args: Record<string, unknown>): Promise<{
         content: {
             type: string;

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

@@ -1,7 +1,6 @@
 import { logger } from '../../../utils/logger.js';
 import { ENABLE_INJECTION_TOOLS } from '../../../constants.js';
-import { ProcessToolHandlersMemory } from '../../domains/process/handlers.impl.core.runtime.memory.js';
-import { requireString, validatePid } from '../../domains/process/handlers.impl.core.runtime.base.js';
+import { ProcessHandlersBase, requireString, validatePid, } from '../../domains/process/handlers.base.js';
 const INJECTION_TOOLS_DISABLED_ERROR = 'Injection tools are disabled by configuration. Set ENABLE_INJECTION_TOOLS=true before starting the server to enable DLL and shellcode injection.';
 const INJECTION_TOOLS_ENABLE_GUIDANCE = 'Set ENABLE_INJECTION_TOOLS=true before starting the server.';
 const INJECTION_TOOLS_SECURITY_NOTICE = 'Injection tools can destabilize target processes; review impact before use.';
@@ -27,7 +26,7 @@ function getShellcodeSize(shellcode, encoding) {
     }
     return Buffer.from(shellcode, 'base64').length;
 }
-export class ProcessToolHandlersRuntime extends ProcessToolHandlersMemory {
+export class ProcessToolHandlersRuntime extends ProcessHandlersBase {
     async handleInjectDll(args) {
         const startedAt = Date.now();
         if (!ENABLE_INJECTION_TOOLS) {
@@ -219,7 +218,15 @@ export class ProcessToolHandlersRuntime extends ProcessToolHandlersMemory {
         const port = Number(rawPort);
         if (!Number.isInteger(port) || port < 1 || port > 65535) {
             return {
-                content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Invalid port: ${JSON.stringify(rawPort)}. Must be integer 1-65535.` }) }],
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: `Invalid port: ${JSON.stringify(rawPort)}. Must be integer 1-65535.`,
+                        }),
+                    },
+                ],
             };
         }
         const wsEndpointArg = args.wsEndpoint ?? '';

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

@@ -1,60 +1 @@
-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;
-            text: string;
-        }[];
-    }>;
-    handleMemoryWrite(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryScan(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryAuditExport(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryCheckProtection(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryScanFiltered(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryBatchWrite(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryDumpRegion(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleMemoryListRegions(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}
+export { ProcessHandlersBase as ProcessToolHandlersMemory } from '../../domains/process/handlers.base.js';