@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/process-QcbIy5Zq.mjs

@@ -0,0 +1,1401 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { V as ENABLE_INJECTION_TOOLS, wt as MEMORY_AUDIT_TRAIL_CAPACITY } from "./constants-B0OANIBL.mjs";
+import { i as MemoryManager, r as UnifiedProcessManager } from "./modules-C184v-S9.mjs";
+import { o as argStringArray, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
+import { i as connectPlaywrightCdpFallback } from "./ScriptManager-aHHq0X7U.mjs";
+import "./definitions-B4rAvHNZ.mjs";
+//#region src/modules/process/memory/AuditTrail.ts
+var MemoryAuditTrail = class {
+	buffer;
+	head = 0;
+	count = 0;
+	capacity;
+	constructor(capacity = MEMORY_AUDIT_TRAIL_CAPACITY) {
+		this.capacity = Number.isInteger(capacity) && capacity > 0 ? capacity : MEMORY_AUDIT_TRAIL_CAPACITY;
+		this.buffer = Array.from({ length: this.capacity });
+	}
+	record(entry) {
+		const fullEntry = {
+			...entry,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			user: process.env.USERNAME || process.env.USER || "unknown"
+		};
+		if (this.count < this.capacity) {
+			const writeIndex = (this.head + this.count) % this.capacity;
+			this.buffer[writeIndex] = fullEntry;
+			this.count += 1;
+			return;
+		}
+		this.buffer[this.head] = fullEntry;
+		this.head = (this.head + 1) % this.capacity;
+	}
+	exportJson() {
+		const entries = [];
+		for (let i = 0; i < this.count; i += 1) {
+			const index = (this.head + i) % this.capacity;
+			const entry = this.buffer[index];
+			if (entry) entries.push(entry);
+		}
+		return JSON.stringify(entries, null, 2);
+	}
+	clear() {
+		this.buffer = [];
+		this.head = 0;
+		this.count = 0;
+	}
+	size() {
+		return this.count;
+	}
+};
+//#endregion
+//#region src/server/domains/process/handlers.base.types.ts
+const MEMORY_PATTERN_TYPES = new Set([
+	"hex",
+	"int32",
+	"int64",
+	"float",
+	"double",
+	"string"
+]);
+/** Validate an arg is a positive integer PID. */
+function validatePid(value) {
+	const n = Number(value);
+	if (!Number.isInteger(n) || n <= 0) throw new Error(`Invalid PID: ${JSON.stringify(value)}`);
+	return n;
+}
+/** Validate an arg is a non-empty string. */
+function requireString(value, name) {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${name} must be a non-empty string`);
+	return value;
+}
+/** Validate an arg is a positive number. */
+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;
+}
+function normalizePatternType(value) {
+	if (typeof value === "string" && MEMORY_PATTERN_TYPES.has(value)) return value;
+	return "hex";
+}
+function getOptionalPid$1(value) {
+	const pid = Number(value);
+	return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+function getOptionalString$1(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function getOptionalPositiveNumber(value) {
+	const size = Number(value);
+	return Number.isFinite(size) && size > 0 ? size : void 0;
+}
+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;
+}
+//#endregion
+//#region src/server/domains/process/handlers/process-management.ts
+/**
+* Process management handlers — find/get/windows/findChromium/checkDebugPort/launchDebug/kill.
+*
+* Also provides buildMemoryDiagnostics and recordMemoryAudit helpers
+* shared by other sub-handlers via deps.
+*/
+var ProcessManagementHandlers = class {
+	processManager;
+	memoryManager;
+	platform;
+	auditTrail;
+	constructor(deps) {
+		this.processManager = deps.processManager;
+		this.memoryManager = deps.memoryManager;
+		this.platform = deps.platform;
+		this.auditTrail = deps.auditTrail;
+	}
+	async buildMemoryDiagnostics(input) {
+		const recommendedActions = /* @__PURE__ */ new Set();
+		const permission = await this.memoryManager.checkAvailability();
+		if (!permission.available) recommendedActions.add("Run as administrator");
+		const processInfo = await this.resolveProcessInfo(input.pid);
+		if (input.pid !== void 0 && input.pid !== null && !processInfo) recommendedActions.add("Check if process is still running");
+		const protectionResult = await this.queryProtection(input);
+		if (protectionResult.queryFailed || protectionResult.info?.success === false) recommendedActions.add("Verify address is within valid memory region");
+		if (input.size !== void 0 && input.size !== null && protectionResult.info?.regionSize !== void 0 && protectionResult.info.regionSize !== null && input.size > protectionResult.info.regionSize) recommendedActions.add("Reduce the requested size to fit the target memory region");
+		if (input.operation === "memory_read" && protectionResult.info?.success && protectionResult.info.isReadable === false) recommendedActions.add("Ensure target memory region is readable");
+		if (input.operation === "memory_write" && protectionResult.info?.success && protectionResult.info.isWritable === false) recommendedActions.add("Ensure target memory region is writable");
+		const modulesInfo = await this.enumerateModulesSafe(input.pid);
+		if (input.pid !== void 0 && 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 = modulesInfo.enumerated ? modulesInfo.count && modulesInfo.count > 0 ? `Enumerated ${modulesInfo.count} 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 !== void 0 && input.pid !== null ? Boolean(processInfo) : null,
+				pid: input.pid ?? null,
+				name: processInfo?.name ?? null
+			},
+			address: {
+				queried: input.pid !== void 0 && input.pid !== null && Boolean(input.address),
+				valid: input.pid !== void 0 && input.pid !== null && input.address ? protectionResult.info?.success ?? null : null,
+				protection: protectionResult.info?.protection ?? null,
+				regionStart: protectionResult.info?.regionStart ?? null,
+				regionSize: protectionResult.info?.regionSize ?? null
+			},
+			aslr: {
+				heuristic: true,
+				note: aslrNote
+			},
+			recommendedActions: Array.from(recommendedActions)
+		};
+	}
+	async safeBuildMemoryDiagnostics(input) {
+		try {
+			return await this.buildMemoryDiagnostics(input);
+		} catch (diagnosticError) {
+			logger.warn("Memory diagnostics generation failed:", diagnosticError);
+			return;
+		}
+	}
+	recordMemoryAudit(entry) {
+		try {
+			this.auditTrail.record(entry);
+		} catch (auditError) {
+			logger.warn("Memory audit trail recording failed:", auditError);
+		}
+	}
+	get platformValue() {
+		return this.platform;
+	}
+	async handleProcessList(_args) {
+		try {
+			const processes = await this.processManager.findProcesses("");
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					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) : void 0
+					}))
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Process list failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	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) : void 0
+					}))
+				}, 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 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 = argNumber(args, "debugPort", 9222);
+			const argsList = argStringArray(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)
+			}] };
+		}
+	}
+	async resolveProcessInfo(pid) {
+		if (pid === void 0 || pid === null) return null;
+		try {
+			const resolvedProcess = await this.processManager.getProcessByPid(pid);
+			return resolvedProcess ? {
+				pid: resolvedProcess.pid,
+				name: resolvedProcess.name,
+				executablePath: resolvedProcess.executablePath,
+				windowTitle: resolvedProcess.windowTitle,
+				windowHandle: resolvedProcess.windowHandle,
+				memoryUsage: resolvedProcess.memoryUsage
+			} : null;
+		} catch {
+			return null;
+		}
+	}
+	async queryProtection(input) {
+		if (input.pid === void 0 || input.pid === null || !input.address) return {
+			info: null,
+			queryFailed: false
+		};
+		let queryFailed = false;
+		let info = null;
+		try {
+			info = await this.memoryManager.checkMemoryProtection(input.pid, input.address);
+		} catch {
+			queryFailed = true;
+		}
+		return {
+			info,
+			queryFailed
+		};
+	}
+	async enumerateModulesSafe(pid) {
+		if (pid === void 0 || pid === null) return {
+			enumerated: false,
+			count: null
+		};
+		try {
+			const modulesResult = await this.memoryManager.enumerateModules(pid);
+			return {
+				enumerated: modulesResult.success,
+				count: modulesResult.modules?.length ?? null
+			};
+		} catch {
+			return {
+				enumerated: false,
+				count: null
+			};
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/process/handlers/memory-operations.ts
+/**
+* Memory operation handlers — read/write/scan/audit/protection/filtered/batch/dump/regions.
+*/
+var MemoryOperationHandlers = class {
+	memoryManager;
+	platform;
+	processMgmt;
+	constructor(deps, processMgmt) {
+		this.memoryManager = deps.memoryManager;
+		this.platform = deps.platform;
+		this.processMgmt = processMgmt;
+	}
+	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) return await this.unavailableResponse("memory_read", pid, address, size, startedAt, availability.reason);
+			const result = await this.memoryManager.readMemory(pid, address, size);
+			const diagnostics = !result.success ? await this.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				address,
+				size,
+				operation: "memory_read",
+				error: result.error
+			}) : void 0;
+			this.processMgmt.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(payload, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory read failed:", error);
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const pid = getOptionalPid$1(args.pid);
+			const address = getOptionalString$1(args.address);
+			const size = getOptionalPositiveNumber(args.size);
+			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				address,
+				size,
+				operation: "memory_read",
+				error: errorMessage
+			});
+			this.processMgmt.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: errorMessage,
+					diagnostics
+				}, null, 2)
+			}] };
+		}
+	}
+	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.processMgmt.safeBuildMemoryDiagnostics({
+					pid,
+					address,
+					size,
+					operation: "memory_write",
+					error: errorMessage
+				});
+				this.processMgmt.recordMemoryAudit({
+					operation: "memory_write",
+					pid,
+					address,
+					size,
+					result: "failure",
+					error: errorMessage,
+					durationMs: Date.now() - startedAt
+				});
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						message: "Memory operations not available",
+						reason: availability.reason,
+						platform: this.platform,
+						requestedAddress: address,
+						dataLength: data !== void 0 && 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.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				address,
+				size,
+				operation: "memory_write",
+				error: result.error
+			}) : void 0;
+			this.processMgmt.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(payload, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory write failed:", error);
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const pid = getOptionalPid$1(args.pid);
+			const address = getOptionalString$1(args.address);
+			const data = getOptionalString$1(args.data);
+			const encoding = args.encoding || "hex";
+			const size = data ? getWriteSize(data, encoding) : void 0;
+			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				address,
+				size,
+				operation: "memory_write",
+				error: errorMessage
+			});
+			this.processMgmt.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: errorMessage,
+					diagnostics
+				}, null, 2)
+			}] };
+		}
+	}
+	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 suspendTarget = args.suspendTarget === true;
+			const availability = await this.memoryManager.checkAvailability();
+			if (!availability.available) {
+				const errorMessage = availability.reason ?? "Memory operations not available";
+				const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
+					pid,
+					operation: "memory_scan",
+					error: errorMessage
+				});
+				this.processMgmt.recordMemoryAudit({
+					operation: "memory_scan",
+					pid,
+					address: null,
+					size: null,
+					result: "failure",
+					error: errorMessage,
+					durationMs: Date.now() - startedAt
+				});
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						message: "Memory operations not available",
+						reason: availability.reason,
+						platform: this.platform,
+						requestedPattern: pattern,
+						patternType,
+						pid,
+						diagnostics
+					}, null, 2)
+				}] };
+			}
+			const result = await this.memoryManager.scanMemory(pid, pattern, patternType, suspendTarget);
+			const diagnostics = !result.success ? await this.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				operation: "memory_scan",
+				error: result.error
+			}) : void 0;
+			this.processMgmt.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(payload, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory scan failed:", error);
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const pid = getOptionalPid$1(args.pid);
+			const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
+				pid,
+				operation: "memory_scan",
+				error: errorMessage
+			});
+			this.processMgmt.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: errorMessage,
+					diagnostics
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleMemoryAuditExport(args) {
+		try {
+			const exportedJson = this.processMgmt["auditTrail"].exportJson();
+			const entries = JSON.parse(exportedJson);
+			const clear = args.clear === true;
+			const count = this.processMgmt["auditTrail"].size();
+			if (clear) this.processMgmt["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 {
+			const pid = validatePid(args.pid);
+			const address = requireString(args.address, "address");
+			const result = await this.memoryManager.checkMemoryProtection(pid, address);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory check protection failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleMemoryScanFiltered(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const pattern = requireString(args.pattern, "pattern");
+			const addresses = args.addresses;
+			const patternType = normalizePatternType(args.patternType);
+			const availability = await this.memoryManager.checkAvailability();
+			if (!availability.available) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Memory operations not available",
+					reason: availability.reason,
+					platform: this.platform,
+					pid
+				}, null, 2)
+			}] };
+			const result = await this.memoryManager.scanMemoryFiltered(pid, pattern, addresses, patternType);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory scan filtered failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleMemoryBatchWrite(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const patches = args.patches;
+			const availability = await this.memoryManager.checkAvailability();
+			if (!availability.available) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					message: "Memory operations not available",
+					reason: availability.reason,
+					platform: this.platform,
+					pid
+				}, null, 2)
+			}] };
+			const result = await this.memoryManager.batchMemoryWrite(pid, patches);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory batch write failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleMemoryDumpRegion(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const address = requireString(args.address, "address");
+			const size = requirePositiveNumber(args.size, "size");
+			const outputPath = requireString(args.outputPath, "outputPath");
+			if (/^[/\\]/.test(outputPath) || /\.\./.test(outputPath) || /^[A-Za-z]:/.test(outputPath)) throw new Error("outputPath must be a relative path without parent directory traversal or drive letters");
+			const result = await this.memoryManager.dumpMemoryRegion(pid, address, size, outputPath);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory dump region failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleMemoryListRegions(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const result = await this.memoryManager.enumerateRegions(pid);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Memory list regions failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async unavailableResponse(operation, pid, address, size, startedAt, reason) {
+		const errorMessage = reason ?? "Memory operations not available";
+		const diagnostics = await this.processMgmt.safeBuildMemoryDiagnostics({
+			pid,
+			address,
+			size,
+			operation,
+			error: errorMessage
+		});
+		this.processMgmt.recordMemoryAudit({
+			operation,
+			pid,
+			address,
+			size,
+			result: "failure",
+			error: errorMessage,
+			durationMs: Date.now() - startedAt
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				message: "Memory operations not available",
+				reason,
+				platform: this.platform,
+				requestedAddress: address,
+				requestedSize: size,
+				pid,
+				diagnostics
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/process/handlers/injection-handlers.ts
+/**
+* Injection handlers — DLL/shellcode injection, check_debug_port, enumerate_modules, electron_attach.
+*/
+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.";
+function buildInjectionDisabledPayload() {
+	return {
+		success: false,
+		error: INJECTION_TOOLS_DISABLED_ERROR,
+		howToEnable: INJECTION_TOOLS_ENABLE_GUIDANCE,
+		securityNotice: INJECTION_TOOLS_SECURITY_NOTICE
+	};
+}
+function getOptionalPid(value) {
+	const pid = Number(value);
+	return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function formatUnknownError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null) try {
+		return JSON.stringify(error, null, 2);
+	} catch {
+		return String(error);
+	}
+	return String(error);
+}
+function getOptionalString(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getShellcodeSize(shellcode, encoding) {
+	if (encoding === "hex") {
+		const normalized = shellcode.replace(/\s+/g, "");
+		return Math.ceil(normalized.length / 2);
+	}
+	return Buffer.from(shellcode, "base64").length;
+}
+const ELECTRON_ATTACH_CONNECT_TIMEOUT_MS = Number(process.env.JSHOOK_ELECTRON_ATTACH_CONNECT_TIMEOUT_MS) || 5e3;
+async function connectElectronBrowserCompatible(browserWSEndpoint) {
+	const { default: puppeteer } = await import("rebrowser-puppeteer-core");
+	try {
+		return await new Promise((resolve, reject) => {
+			let settled = false;
+			const timer = setTimeout(() => {
+				settled = true;
+				reject(/* @__PURE__ */ new Error(`Timed out after ${ELECTRON_ATTACH_CONNECT_TIMEOUT_MS}ms while connecting to Electron browser endpoint ${browserWSEndpoint}.`));
+			}, ELECTRON_ATTACH_CONNECT_TIMEOUT_MS);
+			puppeteer.connect({
+				browserWSEndpoint,
+				defaultViewport: null
+			}).then(async (browser) => {
+				if (settled) {
+					try {
+						await browser.disconnect();
+					} catch {}
+					return;
+				}
+				settled = true;
+				clearTimeout(timer);
+				resolve(browser);
+			}).catch((error) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				reject(error);
+			});
+		});
+	} catch (primaryError) {
+		try {
+			return await connectPlaywrightCdpFallback(browserWSEndpoint, ELECTRON_ATTACH_CONNECT_TIMEOUT_MS);
+		} catch (fallbackError) {
+			throw new Error(`Failed to connect to Electron browser endpoint ${browserWSEndpoint} via both rebrowser-puppeteer and Playwright compatibility fallback. Primary error: ${formatUnknownError(primaryError)}. Fallback error: ${formatUnknownError(fallbackError)}.`, { cause: fallbackError });
+		}
+	}
+}
+var InjectionHandlers = class {
+	memoryManager;
+	processMgmt;
+	constructor(deps, processMgmt) {
+		this.memoryManager = deps.memoryManager;
+		this.processMgmt = processMgmt;
+	}
+	async handleInjectDll(args) {
+		const startedAt = Date.now();
+		if (!ENABLE_INJECTION_TOOLS) {
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_dll",
+				pid: getOptionalPid(args.pid),
+				address: getOptionalString(args.dllPath),
+				size: null,
+				result: "failure",
+				error: INJECTION_TOOLS_DISABLED_ERROR,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(buildInjectionDisabledPayload(), null, 2)
+			}] };
+		}
+		try {
+			const pid = validatePid(args.pid);
+			const dllPath = requireString(args.dllPath, "dllPath");
+			const result = await this.memoryManager.injectDll(pid, dllPath);
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_dll",
+				pid,
+				address: dllPath,
+				size: null,
+				result: result.success ? "success" : "failure",
+				error: result.error,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("DLL injection failed:", error);
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_dll",
+				pid: getOptionalPid(args.pid),
+				address: getOptionalString(args.dllPath),
+				size: null,
+				result: "failure",
+				error: errorMessage,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: errorMessage
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleInjectShellcode(args) {
+		const startedAt = Date.now();
+		if (!ENABLE_INJECTION_TOOLS) {
+			const shellcode = getOptionalString(args.shellcode);
+			const encoding = args.encoding || "hex";
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_shellcode",
+				pid: getOptionalPid(args.pid),
+				address: null,
+				size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
+				result: "failure",
+				error: INJECTION_TOOLS_DISABLED_ERROR,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(buildInjectionDisabledPayload(), null, 2)
+			}] };
+		}
+		try {
+			const pid = validatePid(args.pid);
+			const shellcode = requireString(args.shellcode, "shellcode");
+			const encoding = args.encoding || "hex";
+			const size = getShellcodeSize(shellcode, encoding);
+			const result = await this.memoryManager.injectShellcode(pid, shellcode, encoding);
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_shellcode",
+				pid,
+				address: null,
+				size,
+				result: result.success ? "success" : "failure",
+				error: result.error,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("Shellcode injection failed:", error);
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			const shellcode = getOptionalString(args.shellcode);
+			const encoding = args.encoding || "hex";
+			this.processMgmt.recordMemoryAudit({
+				operation: "inject_shellcode",
+				pid: getOptionalPid(args.pid),
+				address: null,
+				size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
+				result: "failure",
+				error: errorMessage,
+				durationMs: Date.now() - startedAt
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: errorMessage
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleCheckDebugPort(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const result = await this.memoryManager.checkDebugPort(pid);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: result.success,
+					pid,
+					isDebugged: result.isDebugged ?? null,
+					error: result.error
+				}, 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 handleEnumerateModules(args) {
+		try {
+			const pid = validatePid(args.pid);
+			const result = await this.memoryManager.enumerateModules(pid);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: result.success,
+					pid,
+					moduleCount: result.modules?.length ?? 0,
+					modules: result.modules ?? [],
+					error: result.error
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("enumerate_modules failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: error instanceof Error ? error.message : String(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async handleElectronAttach(args) {
+		const rawPort = args.port ?? 9229;
+		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.`
+			})
+		}] };
+		const wsEndpointArg = args.wsEndpoint ?? "";
+		const evaluateExpr = args.evaluate ?? "";
+		const pageUrl = args.pageUrl ?? "";
+		try {
+			const baseUrl = `http://127.0.0.1:${port}`;
+			const targets = await this.fetchCdpTargets(baseUrl);
+			if (!Array.isArray(targets)) throw new Error("CDP target list is not an array");
+			const filtered = pageUrl ? targets.filter((t) => t.url.includes(pageUrl)) : targets;
+			if (!evaluateExpr) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					total: targets.length,
+					filtered: filtered.length,
+					pages: filtered.map((t) => ({
+						id: t.id,
+						title: t.title,
+						url: t.url,
+						type: t.type,
+						wsUrl: t.webSocketDebuggerUrl
+					}))
+				}, null, 2)
+			}] };
+			const target = filtered[0];
+			if (!target?.webSocketDebuggerUrl) return { content: [{
+				type: "text",
+				text: `No matching page found (pageUrl filter: "${pageUrl}"). Available targets:\n` + targets.map((t) => `  [${t.type}] ${t.title} — ${t.url}`).join("\n")
+			}] };
+			const browserWsEndpoint = await this.resolveBrowserWsEndpoint(baseUrl, wsEndpointArg, target);
+			if (!browserWsEndpoint) throw new Error("Could not determine browser WebSocket endpoint");
+			const browser = await connectElectronBrowserCompatible(browserWsEndpoint);
+			let evalResult;
+			let evalError;
+			try {
+				const pages = await browser.pages();
+				const matchedPage = pages.find((p) => p.url().includes(target.url)) ?? pages[0];
+				if (!matchedPage) throw new Error("Could not get page from connected browser");
+				const evaluated = await matchedPage.evaluate((expression) => {
+					try {
+						return {
+							ok: true,
+							result: new Function("return (" + expression + ")")()
+						};
+					} catch (e) {
+						const errorLike = typeof e === "object" && e !== null ? e : {};
+						return {
+							ok: false,
+							error: {
+								name: errorLike.name || "Error",
+								message: String(errorLike.message || e),
+								stack: errorLike.stack ? String(errorLike.stack) : void 0
+							}
+						};
+					}
+				}, evaluateExpr);
+				if (!evaluated?.ok) evalError = `Evaluation failed: ${evaluated?.error?.name || "Error"}: ${evaluated?.error?.message || "Unknown error"}`;
+				else evalResult = evaluated.result;
+			} finally {
+				await browser.disconnect();
+			}
+			if (evalError) return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: evalError,
+					target: {
+						title: target.title,
+						url: target.url
+					}
+				}, null, 2)
+			}] };
+			logger.info(`electron_attach: evaluated in ${target.title}`);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					target: {
+						title: target.title,
+						url: target.url
+					},
+					result: evalResult
+				}, null, 2)
+			}] };
+		} catch (error) {
+			logger.error("electron_attach failed:", error);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: formatUnknownError(error)
+				}, null, 2)
+			}] };
+		}
+	}
+	async fetchCdpTargets(baseUrl) {
+		const listUrl = `${baseUrl}/json/list`;
+		try {
+			const resp = await fetch(listUrl);
+			if (!resp.ok) throw new Error(`CDP list endpoint returned HTTP ${resp.status}`);
+			return await resp.json();
+		} catch (listError) {
+			try {
+				const resp = await fetch(`${baseUrl}/json`);
+				if (!resp.ok) throw new Error(`CDP fallback endpoint returned HTTP ${resp.status}`, { cause: listError });
+				return await resp.json();
+			} catch (fallbackError) {
+				const original = formatUnknownError(fallbackError || listError);
+				throw new Error(`Cannot connect to Electron CDP at ${baseUrl}. Ensure the target app is running with a remote debugging port (for example: process_launch_debug with debugPort=${baseUrl.split(":").pop()}), then retry electron_attach. Original error: ${original}`, { cause: fallbackError });
+			}
+		}
+	}
+	async resolveBrowserWsEndpoint(baseUrl, wsEndpointArg, target) {
+		if (wsEndpointArg) return wsEndpointArg;
+		try {
+			const versionResp = await fetch(`${baseUrl}/json/version`);
+			if (versionResp.ok) {
+				const versionData = await versionResp.json();
+				if (versionData.webSocketDebuggerUrl) return versionData.webSocketDebuggerUrl;
+			}
+		} catch {}
+		if (target.webSocketDebuggerUrl) return target.webSocketDebuggerUrl.replace(/\/devtools\/page\/[^/]+$/, "").replace("/devtools/page", "/devtools/browser");
+	}
+};
+//#endregion
+//#region src/server/domains/process/handlers.impl.ts
+/**
+* Process tool handlers — composition facade.
+*
+* Delegates to three sub-handler modules:
+*   - ProcessManagementHandlers: process find/get/windows/kill/debug launch
+*   - MemoryOperationHandlers:   memory read/write/scan/audit/protection/dump/regions
+*   - InjectionHandlers:         DLL/shellcode injection, check_debug_port, enumerate_modules, electron_attach
+*/
+function createDeps() {
+	const processManager = new UnifiedProcessManager();
+	const memoryManager = new MemoryManager();
+	const platform = processManager.getPlatform();
+	return {
+		processManager,
+		memoryManager,
+		auditTrail: new MemoryAuditTrail(),
+		platform
+	};
+}
+/**
+* ProcessHandlersBase — backward-compatible class for tests.
+* Exposes process management + memory operation methods.
+* Matches the old ProcessHandlersBase which extended ProcessHandlersCore
+* and added all memory handlers.
+*/
+var ProcessHandlersBase = class {
+	processMgmt;
+	memoryOps;
+	_deps;
+	buildMemoryDiagnostics;
+	safeBuildMemoryDiagnostics;
+	recordMemoryAudit;
+	constructor() {
+		this._deps = createDeps();
+		logger.info(`ProcessToolHandlers initialized for platform: ${this._deps.platform}`);
+		this.processMgmt = new ProcessManagementHandlers(this._deps);
+		this.memoryOps = new MemoryOperationHandlers(this._deps, this.processMgmt);
+		this.buildMemoryDiagnostics = this.processMgmt.buildMemoryDiagnostics.bind(this.processMgmt);
+		this.safeBuildMemoryDiagnostics = this.processMgmt.safeBuildMemoryDiagnostics.bind(this.processMgmt);
+		this.recordMemoryAudit = this.processMgmt.recordMemoryAudit.bind(this.processMgmt);
+	}
+	async handleProcessWindows(args) {
+		return this.processMgmt.handleProcessWindows(args);
+	}
+	async handleProcessCheckDebugPort(args) {
+		return this.processMgmt.handleProcessCheckDebugPort(args);
+	}
+	async handleProcessLaunchDebug(args) {
+		return this.processMgmt.handleProcessLaunchDebug(args);
+	}
+	async handleMemoryRead(args) {
+		return this.memoryOps.handleMemoryRead(args);
+	}
+	async handleMemoryWrite(args) {
+		return this.memoryOps.handleMemoryWrite(args);
+	}
+	async handleMemoryScan(args) {
+		return this.memoryOps.handleMemoryScan(args);
+	}
+	async handleMemoryAuditExport(args) {
+		return this.memoryOps.handleMemoryAuditExport(args);
+	}
+	async handleMemoryCheckProtection(args) {
+		return this.memoryOps.handleMemoryCheckProtection(args);
+	}
+	async handleMemoryScanFiltered(args) {
+		return this.memoryOps.handleMemoryScanFiltered(args);
+	}
+	async handleMemoryBatchWrite(args) {
+		return this.memoryOps.handleMemoryBatchWrite(args);
+	}
+	async handleMemoryDumpRegion(args) {
+		return this.memoryOps.handleMemoryDumpRegion(args);
+	}
+	async handleMemoryListRegions(args) {
+		return this.memoryOps.handleMemoryListRegions(args);
+	}
+};
+/**
+* ProcessToolHandlers — main facade class used by the manifest.
+* Adds injection handlers on top of ProcessHandlersBase.
+*/
+var ProcessToolHandlers = class extends ProcessHandlersBase {
+	injection;
+	constructor() {
+		super();
+		this.injection = new InjectionHandlers(this._deps, this.processMgmt);
+	}
+	async handleInjectDll(args) {
+		return this.injection.handleInjectDll(args);
+	}
+	async handleInjectShellcode(args) {
+		return this.injection.handleInjectShellcode(args);
+	}
+	async handleCheckDebugPort(args) {
+		return this.injection.handleCheckDebugPort(args);
+	}
+	async handleEnumerateModules(args) {
+		return this.injection.handleEnumerateModules(args);
+	}
+	async handleElectronAttach(args) {
+		return this.injection.handleElectronAttach(args);
+	}
+};
+//#endregion
+export { ProcessToolHandlers };