@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/platform-CYeFoTWp.mjs

@@ -0,0 +1,2161 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { Sr as V8_BYTECODE_SUBPROC_TIMEOUT_MS } from "./constants-CDZLOoVv.mjs";
+import { o as ExternalToolRunner } from "./modules-tZozf0LQ.mjs";
+import { i as resolveArtifactPath } from "./artifacts-DkfosXH3.mjs";
+import { n as capabilityReport } from "./capabilities-CcHlvWgK.mjs";
+import { t as ToolRegistry } from "./ToolRegistry-B9krbTtI.mjs";
+import "./definitions-CVPD9hzZ.mjs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, normalize, relative, resolve, sep } from "node:path";
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/server/domains/platform/handlers/platform-utils.ts
+function toTextResponse(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+function toErrorResponse(tool, error, extra = {}) {
+	return toTextResponse({
+		success: false,
+		tool,
+		error: error instanceof Error ? error.message : String(error),
+		...extra
+	});
+}
+function getCollectorState(collector) {
+	return "attached";
+}
+function parseStringArg(args, key, required = false) {
+	const value = args[key];
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed.length > 0) return trimmed;
+	}
+	if (required) throw new Error(`${key} must be a non-empty string`);
+}
+function parseBooleanArg(args, key, defaultValue) {
+	const value = args[key];
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (value === 1) return true;
+		if (value === 0) return false;
+	}
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if ([
+			"true",
+			"1",
+			"yes",
+			"on"
+		].includes(normalized)) return true;
+		if ([
+			"false",
+			"0",
+			"no",
+			"off"
+		].includes(normalized)) return false;
+	}
+	return defaultValue;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	const output = [];
+	for (const item of value) if (typeof item === "string") {
+		const trimmed = item.trim();
+		if (trimmed.length > 0) output.push(trimmed);
+	}
+	return output;
+}
+function toDisplayPath(absolutePath) {
+	const relPath = relative(process.cwd(), absolutePath).replace(/\\/g, "/");
+	if (relPath.length === 0) return ".";
+	return relPath.startsWith("..") ? absolutePath.replace(/\\/g, "/") : relPath;
+}
+async function pathExists(targetPath) {
+	try {
+		await stat(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getDefaultSearchPaths() {
+	const userProfile = process.env.USERPROFILE ?? homedir();
+	const appData = process.env.APPDATA ?? join(userProfile, "AppData", "Roaming");
+	const candidates = [join(userProfile, "Documents"), join(appData)];
+	const knownSubPatterns = [
+		"Applet",
+		"XPlugin",
+		"MiniApp"
+	];
+	const resolvedPaths = [];
+	for (const base of candidates) for (const sub of knownSubPatterns) resolvedPaths.push(resolve(base, sub));
+	return Array.from(new Set(resolvedPaths));
+}
+async function walkDirectory(rootDir, onFile) {
+	const stack = [resolve(rootDir)];
+	while (stack.length > 0) {
+		const currentDir = stack.pop();
+		if (!currentDir) continue;
+		let entries;
+		try {
+			entries = await readdir(currentDir, { withFileTypes: true });
+		} catch (error) {
+			logger.debug("walkDirectory skip unreadable directory", {
+				currentDir,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			continue;
+		}
+		for (const entry of entries) {
+			const absolutePath = join(currentDir, String(entry.name));
+			if (entry.isDirectory()) {
+				stack.push(absolutePath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			try {
+				await onFile(absolutePath, await stat(absolutePath));
+			} catch (error) {
+				logger.warn("walkDirectory skip unreadable file", {
+					absolutePath,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+	}
+}
+async function resolveOutputDirectory(toolName, target, requestedDir) {
+	if (requestedDir) {
+		const absolutePath = resolve(requestedDir);
+		await mkdir(absolutePath, { recursive: true });
+		return {
+			absolutePath,
+			displayPath: toDisplayPath(absolutePath)
+		};
+	}
+	const { absolutePath: markerPath, displayPath: markerDisplayPath } = await resolveArtifactPath({
+		category: "tmp",
+		toolName,
+		target,
+		ext: "tmpdir"
+	});
+	const generatedDir = markerPath.replace(/\.tmpdir$/i, "");
+	await mkdir(generatedDir, { recursive: true });
+	return {
+		absolutePath: generatedDir,
+		displayPath: markerDisplayPath.replace(/\.tmpdir$/i, "")
+	};
+}
+function sanitizeArchiveRelativePath(rawPath) {
+	return normalize(rawPath.replace(/\\/g, "/")).replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0 && segment !== "." && segment !== "..").join("/");
+}
+function resolveSafeOutputPath(rootDir, rawRelativePath) {
+	const sanitized = sanitizeArchiveRelativePath(rawRelativePath);
+	const fallbackName = basename(rawRelativePath) || "unnamed.bin";
+	const outputPath = resolve(rootDir, sanitized.length > 0 ? sanitized : fallbackName);
+	const normalizedRoot = resolve(rootDir);
+	if (outputPath !== normalizedRoot && !outputPath.startsWith(`${normalizedRoot}${sep}`)) throw new Error(`Path traversal blocked: ${rawRelativePath}`);
+	return outputPath;
+}
+async function readJsonFileSafe(filePath) {
+	try {
+		const raw = await readFile(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function extractAppIdFromPath(filePath) {
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	for (const pattern of [/\/([a-zA-Z]{2,4}[a-zA-Z0-9]{6,})\//, /\/Applet\/([^/]+)\//i]) {
+		const match = normalizedPath.match(pattern);
+		if (match?.[1]) return match[1];
+	}
+	const fileMatch = basename(filePath, extname(filePath)).match(/([a-zA-Z]{2,4}[a-zA-Z0-9]{6,})/);
+	if (fileMatch?.[1]) return fileMatch[1];
+	return null;
+}
+//#endregion
+//#region src/server/domains/platform/handlers/miniapp-handlers.ts
+function parseMiniappPkgBuffer(buffer) {
+	if (buffer.length < 18) throw new Error("Invalid miniapp package: file too small");
+	const magic = buffer.readUInt8(0);
+	if (magic !== 190) throw new Error(`Invalid miniapp package magic: expected 0xBE, got 0x${magic.toString(16)}`);
+	const info = buffer.readUInt32BE(1);
+	const indexInfoLength = buffer.readUInt32BE(5);
+	const dataLength = buffer.readUInt32BE(9);
+	const lastIdent = buffer.readUInt8(13);
+	const indexStart = 14;
+	const indexEnd = indexStart + indexInfoLength;
+	if (indexEnd > buffer.length) throw new Error("Invalid miniapp package: index section out of range");
+	let cursor = indexStart;
+	if (cursor + 4 > indexEnd) throw new Error("Invalid miniapp package: missing file count in index");
+	const fileCount = buffer.readUInt32BE(cursor);
+	cursor += 4;
+	const entries = [];
+	for (let i = 0; i < fileCount; i += 1) {
+		if (cursor + 4 > indexEnd) throw new Error(`Invalid miniapp package index at entry ${i}: missing nameLen`);
+		const nameLen = buffer.readUInt32BE(cursor);
+		cursor += 4;
+		if (nameLen <= 0 || cursor + nameLen > indexEnd) throw new Error(`Invalid miniapp package index at entry ${i}: invalid nameLen`);
+		const name = buffer.subarray(cursor, cursor + nameLen).toString("utf-8");
+		cursor += nameLen;
+		if (cursor + 8 > indexEnd) throw new Error(`Invalid miniapp package index at entry ${i}: missing offset/size`);
+		const offset = buffer.readUInt32BE(cursor);
+		cursor += 4;
+		const size = buffer.readUInt32BE(cursor);
+		cursor += 4;
+		entries.push({
+			name,
+			offset,
+			size
+		});
+	}
+	return {
+		magic,
+		info,
+		indexInfoLength,
+		dataLength,
+		lastIdent,
+		dataOffset: indexEnd,
+		entries
+	};
+}
+async function tryExternalUnpack(runner, inputPath, outputDir) {
+	const miniappPkgProbe = (await runner.probeAll())["miniapp.unpacker"];
+	if (!miniappPkgProbe?.available) return {
+		used: false,
+		stderr: miniappPkgProbe?.reason ?? "外部解包工具 is unavailable"
+	};
+	const attempts = [
+		[
+			"unpack",
+			inputPath,
+			"-o",
+			outputDir
+		],
+		[
+			"unpack",
+			"-o",
+			outputDir,
+			inputPath
+		],
+		[
+			"-o",
+			outputDir,
+			inputPath
+		],
+		[inputPath, outputDir]
+	];
+	let lastError = "外部解包工具 failed for all argument patterns";
+	for (const attempt of attempts) {
+		const result = await runner.run({
+			tool: "miniapp.unpacker",
+			args: attempt,
+			timeoutMs: 18e4,
+			cwd: dirname(inputPath)
+		});
+		if (result.ok) return {
+			used: true,
+			command: `unveilr ${attempt.join(" ")}`
+		};
+		lastError = result.stderr?.trim() || `exitCode=${String(result.exitCode)}`;
+	}
+	return {
+		used: false,
+		stderr: lastError
+	};
+}
+var MiniappHandlers = class {
+	runner;
+	collector;
+	constructor(runner, collector) {
+		this.runner = runner;
+		this.collector = collector;
+	}
+	async handleMiniappPkgScan(args) {
+		try {
+			const searchPath = parseStringArg(args, "searchPath");
+			const candidateRoots = searchPath ? [resolve(searchPath)] : getDefaultSearchPaths();
+			const searchedRoots = [];
+			const skippedRoots = [];
+			for (const root of candidateRoots) try {
+				if ((await stat(root)).isDirectory()) searchedRoots.push(root);
+				else skippedRoots.push(root);
+			} catch {
+				skippedRoots.push(root);
+			}
+			const foundFiles = [];
+			for (const root of searchedRoots) await walkDirectory(root, async (absolutePath, fileStats) => {
+				if (extname(absolutePath).toLowerCase() !== ".pkg") return;
+				try {
+					const fd = await import("node:fs/promises").then((m) => m.open(absolutePath, "r"));
+					try {
+						const buf = Buffer.alloc(1);
+						await fd.read(buf, 0, 1, 0);
+						if (buf[0] !== 190) return;
+					} finally {
+						await fd.close();
+					}
+				} catch {
+					return;
+				}
+				foundFiles.push({
+					path: absolutePath.replace(/\\/g, "/"),
+					size: Number(fileStats.size),
+					appId: extractAppIdFromPath(absolutePath),
+					lastModified: fileStats.mtime.toISOString()
+				});
+			});
+			foundFiles.sort((left, right) => new Date(right.lastModified).getTime() - new Date(left.lastModified).getTime());
+			return toTextResponse({
+				success: true,
+				searchedRoots: searchedRoots.map((item) => item.replace(/\\/g, "/")),
+				skippedRoots: skippedRoots.map((item) => item.replace(/\\/g, "/")),
+				count: foundFiles.length,
+				files: foundFiles,
+				collectorState: getCollectorState(this.collector)
+			});
+		} catch (error) {
+			return toErrorResponse("miniapp_pkg_scan", error);
+		}
+	}
+	async handleMiniappPkgUnpack(args) {
+		try {
+			const inputPath = parseStringArg(args, "inputPath", true);
+			const outputDirArg = parseStringArg(args, "outputDir");
+			if (!inputPath) throw new Error("inputPath is required");
+			const absoluteInputPath = resolve(inputPath);
+			if (!(await stat(absoluteInputPath)).isFile()) throw new Error("inputPath must be a file");
+			const outputDirectory = await resolveOutputDirectory("miniapp-unpack", extractAppIdFromPath(absoluteInputPath) ?? basename(absoluteInputPath, extname(absoluteInputPath)), outputDirArg);
+			await mkdir(outputDirectory.absolutePath, { recursive: true });
+			const externalAttempt = await tryExternalUnpack(this.runner, absoluteInputPath, outputDirectory.absolutePath);
+			if (externalAttempt.used) {
+				let extractedByCli = 0;
+				await walkDirectory(outputDirectory.absolutePath, async (_absolutePath, _fileStats) => {
+					extractedByCli += 1;
+				});
+				if (extractedByCli > 0) return toTextResponse({
+					success: true,
+					usedExternalCli: true,
+					cliCommand: externalAttempt.command ?? null,
+					outputDir: outputDirectory.displayPath,
+					extractedFiles: extractedByCli,
+					appId: extractAppIdFromPath(absoluteInputPath),
+					collectorState: getCollectorState(this.collector)
+				});
+				logger.warn("External unpack tool reported success but produced no output; falling back to parser", {
+					inputPath: absoluteInputPath,
+					outputDir: outputDirectory.absolutePath
+				});
+			}
+			const pkgBuffer = await readFile(absoluteInputPath);
+			const parsed = parseMiniappPkgBuffer(pkgBuffer);
+			const failedFiles = [];
+			let extractedFiles = 0;
+			let totalBytesExtracted = 0;
+			for (const [index, entry] of parsed.entries.entries()) {
+				const logicalPath = entry.name.trim().length > 0 ? entry.name : `file-${index}.bin`;
+				try {
+					let start = entry.offset;
+					let end = start + entry.size;
+					if (start < 0 || end > pkgBuffer.length) {
+						const fallbackStart = parsed.dataOffset + entry.offset;
+						const fallbackEnd = fallbackStart + entry.size;
+						if (fallbackStart >= 0 && fallbackEnd <= pkgBuffer.length) {
+							start = fallbackStart;
+							end = fallbackEnd;
+						} else throw new Error("entry offset out of range");
+					}
+					const data = pkgBuffer.subarray(start, end);
+					const outputFilePath = resolveSafeOutputPath(outputDirectory.absolutePath, logicalPath);
+					await mkdir(dirname(outputFilePath), { recursive: true });
+					await writeFile(outputFilePath, data);
+					extractedFiles += 1;
+					totalBytesExtracted += data.length;
+				} catch (error) {
+					failedFiles.push({
+						path: logicalPath,
+						reason: error instanceof Error ? error.message : String(error)
+					});
+				}
+			}
+			return toTextResponse({
+				success: extractedFiles > 0,
+				usedExternalCli: false,
+				cliError: externalAttempt.stderr ?? null,
+				outputDir: outputDirectory.displayPath,
+				appId: extractAppIdFromPath(absoluteInputPath),
+				header: {
+					magic: parsed.magic,
+					info: parsed.info,
+					indexInfoLength: parsed.indexInfoLength,
+					dataLength: parsed.dataLength,
+					lastIdent: parsed.lastIdent
+				},
+				fileCount: parsed.entries.length,
+				extractedFiles,
+				totalBytesExtracted,
+				failedFiles,
+				collectorState: getCollectorState(this.collector)
+			});
+		} catch (error) {
+			return toErrorResponse("miniapp_pkg_unpack", error);
+		}
+	}
+	async handleMiniappPkgAnalyze(args) {
+		try {
+			const unpackedDir = parseStringArg(args, "unpackedDir", true);
+			if (!unpackedDir) throw new Error("unpackedDir is required");
+			const absoluteUnpackedDir = resolve(unpackedDir);
+			if (!(await stat(absoluteUnpackedDir)).isDirectory()) throw new Error("unpackedDir must be a directory");
+			const pages = /* @__PURE__ */ new Set();
+			const components = /* @__PURE__ */ new Set();
+			const jsFiles = [];
+			let totalSize = 0;
+			let appJsonPath;
+			let appConfigPath;
+			let pageFramePath;
+			await walkDirectory(absoluteUnpackedDir, async (absolutePath, fileStats) => {
+				totalSize += Number(fileStats.size);
+				const relPath = relative(absoluteUnpackedDir, absolutePath).replace(/\\/g, "/");
+				const lowerName = basename(absolutePath).toLowerCase();
+				const lowerExt = extname(absolutePath).toLowerCase();
+				if (lowerName === "app.json" && !appJsonPath) appJsonPath = absolutePath;
+				else if (lowerName === "app-config.json" && !appConfigPath) appConfigPath = absolutePath;
+				else if (lowerName === "page-frame.html" && !pageFramePath) pageFramePath = absolutePath;
+				if (lowerExt === ".js") jsFiles.push(relPath);
+				if (relPath.includes("/components/") && [
+					".js",
+					".wxml",
+					".json",
+					".wxss"
+				].includes(lowerExt)) components.add(relPath);
+			});
+			const subPackages = [];
+			let appId = null;
+			if (appJsonPath) {
+				const appJson = await readJsonFileSafe(appJsonPath);
+				if (appJson) {
+					for (const page of toStringArray(appJson.pages)) pages.add(page);
+					const subPackagesRaw = appJson.subPackages ?? appJson.subpackages;
+					if (Array.isArray(subPackagesRaw)) for (const item of subPackagesRaw) {
+						if (!isRecord(item)) continue;
+						const root = typeof item.root === "string" ? item.root.trim() : "";
+						const packagePages = toStringArray(item.pages);
+						subPackages.push({
+							root,
+							pages: packagePages
+						});
+						for (const page of packagePages) if (root.length > 0) pages.add(`${root}/${page}`);
+						else pages.add(page);
+					}
+					const usingComponents = appJson.usingComponents;
+					if (isRecord(usingComponents)) {
+						for (const componentPath of Object.values(usingComponents)) if (typeof componentPath === "string" && componentPath.trim()) components.add(componentPath.trim());
+					}
+					const appIdFromAppJson = typeof appJson.appId === "string" ? appJson.appId : typeof appJson.appid === "string" ? appJson.appid : null;
+					if (appIdFromAppJson && appIdFromAppJson.trim().length > 0) appId = appIdFromAppJson.trim();
+				}
+			}
+			if (appConfigPath) {
+				const appConfig = await readJsonFileSafe(appConfigPath);
+				if (appConfig) {
+					const appIdFromConfig = typeof appConfig.appId === "string" ? appConfig.appId : typeof appConfig.appid === "string" ? appConfig.appid : null;
+					if (appIdFromConfig && appIdFromConfig.trim().length > 0 && !appId) appId = appIdFromConfig.trim();
+					for (const page of toStringArray(appConfig.pages)) pages.add(page);
+				}
+			}
+			if (!appId) appId = extractAppIdFromPath(absoluteUnpackedDir);
+			return toTextResponse({
+				success: true,
+				unpackedDir: absoluteUnpackedDir.replace(/\\/g, "/"),
+				pages: Array.from(pages).toSorted(),
+				subPackages,
+				components: Array.from(components).toSorted(),
+				jsFiles: jsFiles.toSorted(),
+				totalSize,
+				appId,
+				discovered: {
+					appJsonPath: appJsonPath ? toDisplayPath(appJsonPath) : null,
+					appConfigPath: appConfigPath ? toDisplayPath(appConfigPath) : null,
+					pageFramePath: pageFramePath ? toDisplayPath(pageFramePath) : null
+				},
+				collectorState: getCollectorState(this.collector)
+			});
+		} catch (error) {
+			return toErrorResponse("miniapp_pkg_analyze", error);
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/platform/handlers/electron-asar-helpers.ts
+function trimTrailingNulls(value) {
+	let end = value.length;
+	while (end > 0 && value.charCodeAt(end - 1) === 0) end -= 1;
+	return end === value.length ? value : value.slice(0, end);
+}
+function flattenAsarEntries(headerNode) {
+	if (!isRecord(headerNode.files)) return [];
+	const files = [];
+	const walk = (nodes, prefix) => {
+		for (const [name, rawNode] of Object.entries(nodes)) {
+			if (!isRecord(rawNode)) continue;
+			const pathPart = prefix.length > 0 ? `${prefix}/${name}` : name;
+			if (isRecord(rawNode.files)) {
+				walk(rawNode.files, pathPart);
+				continue;
+			}
+			const sizeRaw = rawNode.size;
+			const offsetRaw = rawNode.offset;
+			const unpacked = rawNode.unpacked === true;
+			const size = typeof sizeRaw === "number" && Number.isFinite(sizeRaw) && sizeRaw >= 0 ? sizeRaw : 0;
+			let offset = 0;
+			if (typeof offsetRaw === "number" || typeof offsetRaw === "string") {
+				const parsedOffset = Number(offsetRaw);
+				if (Number.isFinite(parsedOffset) && parsedOffset >= 0) offset = parsedOffset;
+			}
+			files.push({
+				path: sanitizeArchiveRelativePath(pathPart),
+				size,
+				offset,
+				unpacked
+			});
+		}
+	};
+	walk(headerNode.files, "");
+	return files;
+}
+function isAsarDataOffsetValid(files, dataOffset, totalSize) {
+	const samples = files.filter((entry) => !entry.unpacked).slice(0, 32);
+	for (const file of samples) {
+		const start = dataOffset + file.offset;
+		const end = start + file.size;
+		if (start < 0 || end < start || end > totalSize) return false;
+	}
+	return true;
+}
+function parseAsarBuffer(asarBuffer) {
+	if (asarBuffer.length < 16) throw new Error("Invalid ASAR: file too small");
+	const headerSize = asarBuffer.readUInt32LE(0);
+	const headerStringSize = asarBuffer.readUInt32LE(4);
+	const headerContentSize = asarBuffer.readUInt32LE(8);
+	const padding = asarBuffer.readUInt32LE(12);
+	const headerStart = 16;
+	const lengthCandidates = Array.from(new Set([
+		headerContentSize,
+		headerStringSize,
+		headerSize - 8,
+		headerSize
+	])).filter((value) => value > 0 && headerStart + value <= asarBuffer.length);
+	let headerObject = null;
+	let headerLength = 0;
+	for (const candidateLength of lengthCandidates) {
+		const normalizedHeaderText = trimTrailingNulls(asarBuffer.subarray(headerStart, headerStart + candidateLength).toString("utf-8")).trim();
+		if (normalizedHeaderText.length === 0) continue;
+		try {
+			const parsed = JSON.parse(normalizedHeaderText);
+			if (isRecord(parsed)) {
+				headerObject = parsed;
+				headerLength = candidateLength;
+				break;
+			}
+		} catch {
+			const lastBrace = normalizedHeaderText.lastIndexOf("}");
+			if (lastBrace > 0) try {
+				const trimmed = normalizedHeaderText.substring(0, lastBrace + 1);
+				const parsed = JSON.parse(trimmed);
+				if (isRecord(parsed)) {
+					headerObject = parsed;
+					headerLength = candidateLength;
+					break;
+				}
+			} catch {}
+		}
+	}
+	if (!headerObject) throw new Error("Invalid ASAR: cannot parse header JSON");
+	const files = flattenAsarEntries(isRecord(headerObject.files) ? headerObject : { files: headerObject });
+	const offsetCandidates = Array.from(new Set([
+		headerStart + headerLength + padding,
+		8 + headerSize,
+		headerStart + headerContentSize + padding,
+		headerStart + headerStringSize + padding
+	])).filter((value) => value >= 0 && value <= asarBuffer.length);
+	let dataOffset = offsetCandidates[0] ?? headerStart + headerLength;
+	for (const candidate of offsetCandidates) if (isAsarDataOffsetValid(files, candidate, asarBuffer.length)) {
+		dataOffset = candidate;
+		break;
+	}
+	return {
+		files,
+		dataOffset,
+		headerSize,
+		headerStringSize,
+		headerContentSize,
+		padding
+	};
+}
+function readAsarEntryBuffer(asarBuffer, parsedAsar, entryPath) {
+	const normalizedEntryPath = sanitizeArchiveRelativePath(entryPath);
+	if (normalizedEntryPath.length === 0) return;
+	const matchedEntry = parsedAsar.files.find((entry) => entry.path === normalizedEntryPath) ?? parsedAsar.files.find((entry) => entry.path.endsWith(`/${normalizedEntryPath}`));
+	if (!matchedEntry || matchedEntry.unpacked) return;
+	const start = parsedAsar.dataOffset + matchedEntry.offset;
+	const end = start + matchedEntry.size;
+	if (start < 0 || end > asarBuffer.length || end < start) return;
+	return asarBuffer.subarray(start, end);
+}
+function readAsarEntryText(asarBuffer, parsedAsar, entryPath) {
+	const data = readAsarEntryBuffer(asarBuffer, parsedAsar, entryPath);
+	return data ? data.toString("utf-8") : void 0;
+}
+function parseBrowserWindowHints(sourceText) {
+	const preloadScripts = /* @__PURE__ */ new Set();
+	const preloadPattern = /preload\s*:\s*(?:path\.(?:join|resolve)\([^)]*?['"`]([^'"`]+)['"`][^)]*\)|['"`]([^'"`]+)['"`])/g;
+	let preloadMatch = preloadPattern.exec(sourceText);
+	while (preloadMatch) {
+		const preloadValue = preloadMatch[1] ?? preloadMatch[2];
+		if (preloadValue) preloadScripts.add(preloadValue.trim());
+		preloadMatch = preloadPattern.exec(sourceText);
+	}
+	const explicitDevToolsMatch = sourceText.match(/devTools\s*:\s*(true|false)/);
+	let devToolsEnabled = null;
+	if (explicitDevToolsMatch?.[1]) devToolsEnabled = explicitDevToolsMatch[1] === "true";
+	if (/\.openDevTools\s*\(/.test(sourceText)) devToolsEnabled = true;
+	return {
+		preloadScripts: Array.from(preloadScripts),
+		devToolsEnabled
+	};
+}
+async function findFilesystemPreloadScripts(rootDir) {
+	const matches = /* @__PURE__ */ new Set();
+	await walkDirectory(rootDir, async (absolutePath, _fileStats) => {
+		const lowerName = basename(absolutePath).toLowerCase();
+		if (extname(absolutePath).toLowerCase() === ".js" && lowerName.includes("preload")) matches.add(toDisplayPath(absolutePath));
+	});
+	return Array.from(matches).toSorted().slice(0, 100);
+}
+//#endregion
+//#region src/server/domains/platform/handlers/electron-handlers.ts
+var ElectronHandlers = class {
+	collector;
+	constructor(collector) {
+		this.collector = collector;
+	}
+	async handleAsarExtract(args) {
+		try {
+			const inputPath = parseStringArg(args, "inputPath", true);
+			const outputDirArg = parseStringArg(args, "outputDir");
+			const listOnly = parseBooleanArg(args, "listOnly", false);
+			if (!inputPath) throw new Error("inputPath is required");
+			const absoluteInputPath = resolve(inputPath);
+			if (!(await stat(absoluteInputPath)).isFile()) throw new Error("inputPath must be a file");
+			const asarBuffer = await readFile(absoluteInputPath);
+			const parsedAsar = parseAsarBuffer(asarBuffer);
+			const files = parsedAsar.files.map((entry) => ({
+				path: entry.path,
+				size: entry.size,
+				offset: entry.offset
+			}));
+			const totalSize = files.reduce((sum, entry) => sum + entry.size, 0);
+			if (listOnly) return toTextResponse({
+				success: true,
+				files,
+				totalFiles: files.length,
+				totalSize,
+				dataOffset: parsedAsar.dataOffset,
+				header: {
+					headerSize: parsedAsar.headerSize,
+					headerStringSize: parsedAsar.headerStringSize,
+					headerContentSize: parsedAsar.headerContentSize,
+					padding: parsedAsar.padding
+				},
+				collectorState: getCollectorState(this.collector)
+			});
+			const outputDirectory = await resolveOutputDirectory("asar-extract", basename(absoluteInputPath, extname(absoluteInputPath)), outputDirArg);
+			let extractedFiles = 0;
+			const failedFiles = [];
+			for (const entry of parsedAsar.files) {
+				if (entry.unpacked) {
+					failedFiles.push({
+						path: entry.path,
+						reason: "Entry is marked as unpacked and not stored inside app.asar"
+					});
+					continue;
+				}
+				const start = parsedAsar.dataOffset + entry.offset;
+				const end = start + entry.size;
+				if (start < 0 || end > asarBuffer.length || end < start) {
+					failedFiles.push({
+						path: entry.path,
+						reason: "Entry data range is out of bounds"
+					});
+					continue;
+				}
+				try {
+					const data = asarBuffer.subarray(start, end);
+					const outputPath = resolveSafeOutputPath(outputDirectory.absolutePath, entry.path);
+					await mkdir(dirname(outputPath), { recursive: true });
+					await writeFile(outputPath, data);
+					extractedFiles += 1;
+				} catch (error) {
+					failedFiles.push({
+						path: entry.path,
+						reason: error instanceof Error ? error.message : String(error)
+					});
+				}
+			}
+			return toTextResponse({
+				success: extractedFiles > 0,
+				files,
+				totalFiles: files.length,
+				totalSize,
+				extractedFiles,
+				failedFiles,
+				outputDir: outputDirectory.displayPath,
+				dataOffset: parsedAsar.dataOffset,
+				header: {
+					headerSize: parsedAsar.headerSize,
+					headerStringSize: parsedAsar.headerStringSize,
+					headerContentSize: parsedAsar.headerContentSize,
+					padding: parsedAsar.padding
+				},
+				collectorState: getCollectorState(this.collector)
+			});
+		} catch (error) {
+			return toErrorResponse("asar_extract", error);
+		}
+	}
+	async handleElectronInspectApp(args) {
+		try {
+			const appPath = parseStringArg(args, "appPath", true);
+			if (!appPath) throw new Error("appPath is required");
+			const absoluteAppPath = resolve(appPath);
+			const scanRoot = (await stat(absoluteAppPath)).isDirectory() ? absoluteAppPath : dirname(absoluteAppPath);
+			const asarCandidates = [
+				join(scanRoot, "resources", "app.asar"),
+				join(scanRoot, "Contents", "Resources", "app.asar"),
+				join(scanRoot, "app.asar")
+			];
+			let asarPath = null;
+			for (const candidate of asarCandidates) {
+				if (!await pathExists(candidate)) continue;
+				if ((await stat(candidate)).isFile()) {
+					asarPath = candidate;
+					break;
+				}
+			}
+			let asarBuffer = null;
+			let parsedAsar = null;
+			if (asarPath) try {
+				asarBuffer = await readFile(asarPath);
+				parsedAsar = parseAsarBuffer(asarBuffer);
+			} catch (error) {
+				logger.warn("electron_inspect_app failed to parse asar", {
+					asarPath,
+					error: error instanceof Error ? error.message : String(error)
+				});
+				asarBuffer = null;
+				parsedAsar = null;
+			}
+			let packageJson = null;
+			let packageJsonPath = "";
+			let packageSource = "none";
+			if (parsedAsar && asarBuffer) {
+				const packageEntry = parsedAsar.files.find((entry) => entry.path === "package.json" || entry.path.endsWith("/package.json"));
+				if (packageEntry) {
+					const packageText = readAsarEntryText(asarBuffer, parsedAsar, packageEntry.path);
+					if (packageText) try {
+						const parsed = JSON.parse(packageText);
+						if (isRecord(parsed)) {
+							packageJson = parsed;
+							packageJsonPath = packageEntry.path;
+							packageSource = "asar";
+						}
+					} catch (error) {
+						logger.warn("electron_inspect_app invalid package.json in asar", {
+							packagePath: packageEntry.path,
+							error: error instanceof Error ? error.message : String(error)
+						});
+					}
+				}
+			}
+			if (!packageJson) {
+				const packageCandidates = [
+					join(scanRoot, "package.json"),
+					join(scanRoot, "app", "package.json"),
+					join(scanRoot, "resources", "app", "package.json"),
+					join(scanRoot, "Contents", "Resources", "app", "package.json")
+				];
+				for (const candidate of packageCandidates) {
+					const candidateJson = await readJsonFileSafe(candidate);
+					if (candidateJson) {
+						packageJson = candidateJson;
+						packageJsonPath = candidate;
+						packageSource = "filesystem";
+						break;
+					}
+				}
+			}
+			if (!packageJson) return toTextResponse({
+				success: false,
+				tool: "electron_inspect_app",
+				error: "Cannot locate package.json in app directory or app.asar",
+				appPath: absoluteAppPath.replace(/\\/g, "/"),
+				scanRoot: scanRoot.replace(/\\/g, "/"),
+				asarPath: asarPath ? asarPath.replace(/\\/g, "/") : null,
+				collectorState: getCollectorState(this.collector)
+			});
+			const mainEntry = typeof packageJson.main === "string" && packageJson.main.trim().length > 0 ? packageJson.main.trim() : "index.js";
+			const version = typeof packageJson.version === "string" ? packageJson.version : null;
+			const dependenciesRaw = packageJson.dependencies;
+			const dependencies = isRecord(dependenciesRaw) ? Object.keys(dependenciesRaw).toSorted() : [];
+			let mainScriptSource = "";
+			let mainScriptPath = "";
+			if (packageSource === "asar" && parsedAsar && asarBuffer) {
+				const packageBase = packageJsonPath.length > 0 ? dirname(packageJsonPath) : "";
+				const candidateMainPaths = Array.from(new Set([
+					sanitizeArchiveRelativePath(join(packageBase, mainEntry)),
+					sanitizeArchiveRelativePath(mainEntry),
+					sanitizeArchiveRelativePath(basename(mainEntry))
+				])).filter((value) => value.length > 0);
+				for (const candidate of candidateMainPaths) {
+					const text = readAsarEntryText(asarBuffer, parsedAsar, candidate);
+					if (typeof text === "string") {
+						mainScriptSource = text;
+						mainScriptPath = candidate;
+						break;
+					}
+				}
+				if (mainScriptSource.length === 0) {
+					const fallbackEntry = parsedAsar.files.find((entry) => basename(entry.path) === basename(mainEntry));
+					if (fallbackEntry) {
+						const fallbackText = readAsarEntryText(asarBuffer, parsedAsar, fallbackEntry.path);
+						if (typeof fallbackText === "string") {
+							mainScriptSource = fallbackText;
+							mainScriptPath = fallbackEntry.path;
+						}
+					}
+				}
+			} else if (packageSource === "filesystem") {
+				const absoluteMainPath = resolve(dirname(packageJsonPath), mainEntry);
+				if (await pathExists(absoluteMainPath)) {
+					if ((await stat(absoluteMainPath)).isFile()) try {
+						mainScriptSource = await readFile(absoluteMainPath, "utf-8");
+						mainScriptPath = absoluteMainPath;
+					} catch (error) {
+						logger.warn("electron_inspect_app failed to read main script", {
+							absoluteMainPath,
+							error: error instanceof Error ? error.message : String(error)
+						});
+					}
+				}
+			}
+			const parsedHints = mainScriptSource.length > 0 ? parseBrowserWindowHints(mainScriptSource) : {
+				preloadScripts: [],
+				devToolsEnabled: null
+			};
+			const preloadScripts = new Set(parsedHints.preloadScripts);
+			if (preloadScripts.size === 0 && parsedAsar) for (const entry of parsedAsar.files) {
+				const lowerPath = entry.path.toLowerCase();
+				if (lowerPath.includes("preload") && extname(lowerPath) === ".js") preloadScripts.add(entry.path);
+			}
+			if (preloadScripts.size === 0) {
+				const filesystemPreloads = await findFilesystemPreloadScripts(scanRoot);
+				for (const preload of filesystemPreloads) preloadScripts.add(preload);
+			}
+			const devToolsEnabled = parsedHints.devToolsEnabled !== null ? parsedHints.devToolsEnabled : true;
+			return toTextResponse({
+				success: true,
+				appPath: absoluteAppPath.replace(/\\/g, "/"),
+				scanRoot: scanRoot.replace(/\\/g, "/"),
+				mainEntry,
+				version,
+				preloadScripts: Array.from(preloadScripts).toSorted(),
+				dependencies,
+				devToolsEnabled,
+				packageSource,
+				packagePath: packageSource === "filesystem" ? toDisplayPath(packageJsonPath) : packageJsonPath,
+				mainScriptPath: mainScriptPath.length > 0 ? packageSource === "filesystem" ? toDisplayPath(mainScriptPath) : mainScriptPath : null,
+				asarPath: asarPath ? toDisplayPath(asarPath) : null,
+				browserWindowDetected: mainScriptSource.length > 0 ? mainScriptSource.includes("BrowserWindow") : false,
+				collectorState: getCollectorState(this.collector)
+			});
+		} catch (error) {
+			return toErrorResponse("electron_inspect_app", error);
+		}
+	}
+	/**
+	* asar_search — regex search inside ASAR archive files.
+	* Pattern is agent-provided, no hardcoded defaults.
+	*/
+	async handleAsarSearch(args) {
+		try {
+			const inputPath = parseStringArg(args, "inputPath", true);
+			const searchPattern = parseStringArg(args, "pattern", true);
+			if (!inputPath) throw new Error("inputPath is required");
+			if (!searchPattern) throw new Error("pattern is required");
+			const fileGlob = parseStringArg(args, "fileGlob") || "*.js";
+			const maxResults = typeof args.maxResults === "number" && args.maxResults > 0 ? args.maxResults : 100;
+			const searchAbsPath = resolve(inputPath);
+			if (!await pathExists(searchAbsPath)) return toTextResponse({
+				success: false,
+				tool: "asar_search",
+				error: `File does not exist: ${inputPath}`
+			});
+			const searchAsarBuf = await readFile(searchAbsPath);
+			const searchParsed = parseAsarBuffer(searchAsarBuf);
+			const globExt = fileGlob.startsWith("*.") ? fileGlob.slice(1) : null;
+			const matchingFiles = searchParsed.files.filter((entry) => {
+				if (entry.unpacked || entry.size <= 0) return false;
+				if (globExt) return extname(entry.path).toLowerCase() === globExt.toLowerCase();
+				return true;
+			});
+			let regex;
+			try {
+				regex = new RegExp(searchPattern, "gi");
+			} catch {
+				return toTextResponse({
+					success: false,
+					tool: "asar_search",
+					error: `Invalid regex pattern: ${searchPattern}`
+				});
+			}
+			const matches = [];
+			let totalMatches = 0;
+			let filesScanned = 0;
+			for (const entry of matchingFiles) {
+				if (totalMatches >= maxResults) break;
+				const start = searchParsed.dataOffset + entry.offset;
+				const end = start + entry.size;
+				if (start < 0 || end > searchAsarBuf.length || end < start) continue;
+				if (entry.size > 512e3) continue;
+				const content = searchAsarBuf.subarray(start, end).toString("utf-8");
+				filesScanned++;
+				regex.lastIndex = 0;
+				const lines = content.split("\n");
+				const fileMatches = [];
+				for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+					if (totalMatches >= maxResults) break;
+					const line = lines[lineIdx];
+					if (!line) continue;
+					regex.lastIndex = 0;
+					if (regex.test(line)) {
+						fileMatches.push({
+							lineNumber: lineIdx + 1,
+							text: line.slice(0, 200)
+						});
+						totalMatches++;
+					}
+				}
+				if (fileMatches.length > 0) matches.push({
+					filePath: entry.path,
+					matchCount: fileMatches.length,
+					matchLines: fileMatches
+				});
+			}
+			return toTextResponse({
+				success: true,
+				tool: "asar_search",
+				matches,
+				totalMatches,
+				filesScanned,
+				pattern: searchPattern
+			});
+		} catch (error) {
+			return toErrorResponse("asar_search", error);
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/platform/handlers/electron-userdata-handler.ts
+/**
+* electron_scan_userdata — Scans a directory for JSON files
+* and returns their raw content. Cross-platform: Agent provides the
+* appropriate path (Windows %APPDATA%, macOS ~/Library/Application Support,
+* Linux ~/.config, etc.).
+*/
+async function handleElectronScanUserdata(args) {
+	try {
+		const dirPath = parseStringArg(args, "dirPath", true);
+		if (!dirPath) throw new Error("dirPath is required");
+		const maxFiles = typeof args.maxFiles === "number" && args.maxFiles > 0 ? args.maxFiles : 20;
+		const maxFileSize = (typeof args.maxFileSizeKB === "number" && args.maxFileSizeKB > 0 ? args.maxFileSizeKB : 1024) * 1024;
+		if (!await pathExists(dirPath)) return toTextResponse({
+			success: false,
+			tool: "electron_scan_userdata",
+			error: `Directory does not exist: ${dirPath}`
+		});
+		if (!(await stat(dirPath)).isDirectory()) return toTextResponse({
+			success: false,
+			tool: "electron_scan_userdata",
+			error: `Path is not a directory: ${dirPath}`
+		});
+		let dirEntries;
+		try {
+			dirEntries = await readdir(dirPath);
+		} catch {
+			return toTextResponse({
+				success: false,
+				tool: "electron_scan_userdata",
+				error: `Cannot read directory: ${dirPath}`
+			});
+		}
+		const jsonFiles = dirEntries.filter((name) => name.endsWith(".json")).slice(0, maxFiles);
+		const files = [];
+		const skipped = [];
+		for (const fileName of jsonFiles) {
+			const filePath = join(dirPath, fileName);
+			try {
+				const fileStat = await stat(filePath);
+				if (!fileStat.isFile()) {
+					skipped.push({
+						name: fileName,
+						reason: "not a file"
+					});
+					continue;
+				}
+				if (fileStat.size > maxFileSize) {
+					skipped.push({
+						name: fileName,
+						reason: "exceeds maxFileSizeKB"
+					});
+					continue;
+				}
+				const raw = await readFile(filePath, "utf-8");
+				const parsed = JSON.parse(raw);
+				files.push({
+					name: fileName,
+					sizeBytes: fileStat.size,
+					content: parsed
+				});
+			} catch {
+				skipped.push({
+					name: fileName,
+					reason: "read or parse error"
+				});
+			}
+		}
+		return toTextResponse({
+			success: true,
+			tool: "electron_scan_userdata",
+			files,
+			skipped,
+			totalScanned: jsonFiles.length,
+			directory: dirPath
+		});
+	} catch (error) {
+		return toErrorResponse("electron_scan_userdata", error);
+	}
+}
+//#endregion
+//#region src/server/domains/platform/handlers/electron-fuse-handler.ts
+/**
+* electron_patch_fuses — Extends check_fuses with binary patching capability.
+* Patches Electron fuse sentinel to enable/disable debug-related fuses.
+* Creates backup before patching.
+*/
+/**
+* The Electron fuse sentinel string embedded in Electron binaries.
+*/
+const FUSE_SENTINEL$1 = "dL7pKGdnNz796PbbjQWNKmHXBZIA";
+/** Fuse names in the order they appear after the sentinel. */
+const FUSE_NAMES = [
+	"RunAsNode",
+	"EnableCookieEncryption",
+	"EnableNodeOptionsEnvironmentVariable",
+	"EnableNodeCliInspectArguments",
+	"EnableEmbeddedAsarIntegrityValidation",
+	"OnlyLoadAppFromAsar",
+	"LoadBrowserProcessSpecificV8Snapshot",
+	"GrantFileProtocolExtraPrivileges"
+];
+/** Fuse byte values - ASCII-based. */
+const FUSE_DISABLE = 48;
+const FUSE_ENABLE$1 = 49;
+const FUSE_REMOVED = 114;
+const FUSE_LABEL = {
+	[FUSE_DISABLE]: "DISABLE",
+	[FUSE_ENABLE$1]: "ENABLE",
+	[FUSE_REMOVED]: "REMOVED"
+};
+/** Default patch profile: enable debug-related fuses. */
+const DEBUG_PATCH_PROFILE = {
+	RunAsNode: "ENABLE",
+	EnableNodeOptionsEnvironmentVariable: "ENABLE",
+	EnableNodeCliInspectArguments: "ENABLE",
+	OnlyLoadAppFromAsar: "DISABLE"
+};
+function parseFuses(buffer, sentinelIndex) {
+	const fuseDataStart = sentinelIndex + Buffer.from(FUSE_SENTINEL$1, "ascii").length;
+	const fuses = {};
+	for (let i = 0; i < FUSE_NAMES.length; i++) {
+		const fuseName = FUSE_NAMES[i];
+		if (!fuseName) continue;
+		const byteIndex = fuseDataStart + i;
+		if (byteIndex >= buffer.length) {
+			fuses[fuseName] = "UNKNOWN";
+			continue;
+		}
+		const byteValue = buffer[byteIndex];
+		if (byteValue === void 0) {
+			fuses[fuseName] = "UNKNOWN";
+			continue;
+		}
+		fuses[fuseName] = FUSE_LABEL[byteValue] ?? "UNKNOWN";
+	}
+	return fuses;
+}
+async function handleElectronCheckFuses(args) {
+	try {
+		const exePath = parseStringArg(args, "exePath", true);
+		if (!exePath) throw new Error("exePath is required");
+		if (!await pathExists(exePath)) return toTextResponse({
+			success: false,
+			tool: "electron_check_fuses",
+			error: `File does not exist: ${exePath}`
+		});
+		const buffer = await readFile(exePath);
+		const sentinelBuffer = Buffer.from(FUSE_SENTINEL$1, "ascii");
+		const sentinelIndex = buffer.indexOf(sentinelBuffer);
+		if (sentinelIndex === -1) return toTextResponse({
+			success: true,
+			tool: "electron_check_fuses",
+			exePath,
+			fuseWireFound: false,
+			fuses: {},
+			note: "No fuse sentinel found. This may not be an Electron binary, or fuses are not configured."
+		});
+		return toTextResponse({
+			success: true,
+			tool: "electron_check_fuses",
+			exePath,
+			fuseWireFound: true,
+			fuses: parseFuses(buffer, sentinelIndex)
+		});
+	} catch (error) {
+		return toErrorResponse("electron_check_fuses", error);
+	}
+}
+async function handleElectronPatchFuses(args) {
+	try {
+		const exePath = parseStringArg(args, "exePath", true);
+		if (!exePath) throw new Error("exePath is required");
+		if (!await pathExists(exePath)) return toTextResponse({
+			success: false,
+			tool: "electron_patch_fuses",
+			error: `File does not exist: ${exePath}`
+		});
+		const profile = parseStringArg(args, "profile") ?? "debug";
+		const createBackup = args.createBackup !== false;
+		let patchMap;
+		if (profile === "debug") patchMap = { ...DEBUG_PATCH_PROFILE };
+		else if (profile === "custom") {
+			const customFuses = args.fuses;
+			if (!customFuses || Object.keys(customFuses).length === 0) throw new Error("profile=\"custom\" requires a `fuses` object mapping fuse names to ENABLE/DISABLE");
+			patchMap = {};
+			for (const [name, value] of Object.entries(customFuses)) {
+				if (!FUSE_NAMES.includes(name)) throw new Error(`Unknown fuse: ${name}. Valid: ${FUSE_NAMES.join(", ")}`);
+				if (value !== "ENABLE" && value !== "DISABLE") throw new Error(`Invalid fuse value for ${name}: ${value}. Must be ENABLE or DISABLE`);
+				patchMap[name] = value;
+			}
+		} else throw new Error(`Unknown profile: ${profile}. Use "debug" or "custom"`);
+		const buffer = await readFile(exePath);
+		const sentinelBuffer = Buffer.from(FUSE_SENTINEL$1, "ascii");
+		const sentinelIndex = buffer.indexOf(sentinelBuffer);
+		if (sentinelIndex === -1) return toTextResponse({
+			success: false,
+			tool: "electron_patch_fuses",
+			error: "No fuse sentinel found. This may not be an Electron binary.",
+			exePath
+		});
+		const fusesBefore = parseFuses(buffer, sentinelIndex);
+		const fuseDataStart = sentinelIndex + sentinelBuffer.length;
+		const changes = [];
+		for (const [fuseName, targetState] of Object.entries(patchMap)) {
+			const fuseIndex = FUSE_NAMES.indexOf(fuseName);
+			if (fuseIndex === -1) continue;
+			const byteIndex = fuseDataStart + fuseIndex;
+			if (byteIndex >= buffer.length) continue;
+			const currentByte = buffer[byteIndex];
+			if (currentByte === FUSE_REMOVED) {
+				changes.push({
+					fuse: fuseName,
+					before: "REMOVED",
+					after: "REMOVED (cannot patch)"
+				});
+				continue;
+			}
+			const targetByte = targetState === "ENABLE" ? FUSE_ENABLE$1 : FUSE_DISABLE;
+			const currentLabel = FUSE_LABEL[currentByte ?? 0] ?? "UNKNOWN";
+			if (currentByte === targetByte) continue;
+			buffer[byteIndex] = targetByte;
+			changes.push({
+				fuse: fuseName,
+				before: currentLabel,
+				after: targetState
+			});
+		}
+		if (changes.length === 0) return toTextResponse({
+			success: true,
+			tool: "electron_patch_fuses",
+			exePath,
+			message: "All target fuses are already in the desired state. No changes needed.",
+			fuses: fusesBefore
+		});
+		let backupPath = null;
+		if (createBackup) {
+			backupPath = `${exePath}.bak`;
+			await copyFile(exePath, backupPath);
+		}
+		await writeFile(exePath, buffer);
+		const fusesAfter = parseFuses(buffer, sentinelIndex);
+		return toTextResponse({
+			success: true,
+			tool: "electron_patch_fuses",
+			exePath,
+			backupPath,
+			profile,
+			changes,
+			fusesBefore,
+			fusesAfter,
+			note: backupPath ? `Backup created at ${backupPath}. Restore with: copy "${backupPath}" "${exePath}"` : "No backup created (createBackup=false)."
+		});
+	} catch (error) {
+		return toErrorResponse("electron_patch_fuses", error);
+	}
+}
+//#endregion
+//#region src/server/domains/platform/handlers/v8-bytecode-handler.ts
+/**
+* v8_bytecode_decompile — V8 bytecode (.jsc / bytenode) decompiler.
+* Strategy 1: view8 Python package via subprocess
+* Strategy 2: Built-in constant pool extractor (parses V8 serialized data)
+*/
+const execFileAsync = promisify(execFile);
+/** V8 bytecode magic bytes for detection. */
+const V8_MAGIC = Buffer.from([192, 222]);
+const BYTENODE_MAGIC = Buffer.from("BYTN");
+/** Known V8 bytecode file extensions. */
+const JSC_EXTENSIONS = new Set([".jsc", ".bin"]);
+/**
+* Detect if a buffer contains V8 bytecode.
+*/
+function detectFormat(buffer, filePath) {
+	const ext = extname(filePath).toLowerCase();
+	if (buffer.length >= 4 && buffer.subarray(0, 4).equals(BYTENODE_MAGIC)) return "bytenode";
+	if (buffer.length >= 2 && buffer.subarray(0, 2).equals(V8_MAGIC)) return "v8-raw";
+	if (JSC_EXTENSIONS.has(ext)) return "jsc-extension";
+	const v8Markers = [
+		Buffer.from("Ldar"),
+		Buffer.from("Star"),
+		Buffer.from("LdaSmi"),
+		Buffer.from("CallRuntime")
+	];
+	for (const marker of v8Markers) if (buffer.indexOf(marker) !== -1) return "v8-heuristic";
+	return null;
+}
+/**
+* Strategy 1: Use View8 Python package for full decompilation.
+*/
+async function tryView8(filePath) {
+	try {
+		const { stdout, stderr } = await execFileAsync("python", [
+			"-m",
+			"view8",
+			filePath
+		], {
+			timeout: V8_BYTECODE_SUBPROC_TIMEOUT_MS,
+			maxBuffer: 10 * 1024 * 1024
+		});
+		if (stdout && stdout.trim().length > 0) return {
+			ok: true,
+			output: stdout
+		};
+		return {
+			ok: false,
+			error: stderr || "Empty output from view8"
+		};
+	} catch {
+		try {
+			const { stdout } = await execFileAsync("python3", [
+				"-m",
+				"view8",
+				filePath
+			], {
+				timeout: V8_BYTECODE_SUBPROC_TIMEOUT_MS,
+				maxBuffer: 10 * 1024 * 1024
+			});
+			if (stdout && stdout.trim().length > 0) return {
+				ok: true,
+				output: stdout
+			};
+			return {
+				ok: false,
+				error: "Empty output from view8"
+			};
+		} catch {
+			return {
+				ok: false,
+				error: "view8 not available. Install with: pip install view8"
+			};
+		}
+	}
+}
+async function tryView8Interpreter(interpreter) {
+	try {
+		await execFileAsync(interpreter, ["-c", "import view8; print(getattr(view8, \"__file__\", \"view8\"))"], {
+			timeout: V8_BYTECODE_SUBPROC_TIMEOUT_MS,
+			maxBuffer: 1024 * 1024
+		});
+		return {
+			available: true,
+			interpreter
+		};
+	} catch (error) {
+		return {
+			available: false,
+			interpreter,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function probeView8Availability() {
+	const python = await tryView8Interpreter("python");
+	if (python.available) return python;
+	const python3 = await tryView8Interpreter("python3");
+	if (python3.available) return python3;
+	return {
+		available: false,
+		reason: python.reason && python3.reason ? `${python.reason}; ${python3.reason}` : python.reason ?? python3.reason ?? "view8 is not available"
+	};
+}
+/**
+* Strategy 2: Built-in constant pool extractor.
+* Extracts readable strings and numeric constants from V8 serialized bytecode.
+*/
+function extractConstantPool(buffer) {
+	const strings = [];
+	const numbers = [];
+	const seen = /* @__PURE__ */ new Set();
+	const MIN_STRING_LEN = 4;
+	const MAX_STRING_LEN = 2e3;
+	let currentString = "";
+	for (let i = 0; i < buffer.length; i++) {
+		const byte = buffer[i];
+		if (byte >= 32 && byte <= 126) currentString += String.fromCharCode(byte);
+		else {
+			if (currentString.length >= MIN_STRING_LEN && currentString.length <= MAX_STRING_LEN) {
+				if (isLikelyCodeString(currentString) && !seen.has(currentString)) {
+					seen.add(currentString);
+					strings.push(currentString);
+				}
+			}
+			currentString = "";
+		}
+	}
+	for (let i = 0; i < buffer.length - 3; i++) if (buffer[i + 1] === 0 && buffer[i] >= 32 && buffer[i] <= 126) {
+		let utf16str = "";
+		let j = i;
+		while (j < buffer.length - 1 && buffer[j] >= 32 && buffer[j] <= 126 && buffer[j + 1] === 0) {
+			utf16str += String.fromCharCode(buffer[j]);
+			j += 2;
+		}
+		if (utf16str.length >= MIN_STRING_LEN && utf16str.length <= MAX_STRING_LEN) {
+			if (isLikelyCodeString(utf16str) && !seen.has(utf16str)) {
+				seen.add(utf16str);
+				strings.push(utf16str);
+			}
+		}
+	}
+	return {
+		strings,
+		numbers
+	};
+}
+/**
+* Filter heuristic: is this string likely from source code rather than binary noise?
+*/
+function isLikelyCodeString(s) {
+	if (new Set(s).size <= 2) return false;
+	if ((s.match(/[^a-zA-Z0-9_\-.\s/\\:;=+*&|!?,'"(){}[\]<>@#$%^~`]/g) ?? []).length / s.length > .3) return false;
+	return [
+		/[a-zA-Z_$][a-zA-Z0-9_$]*/,
+		/function\s/,
+		/return\s/,
+		/const\s/,
+		/let\s/,
+		/var\s/,
+		/require\(/,
+		/module\.exports/,
+		/import\s/,
+		/\.prototype\./,
+		/\.call\(/,
+		/\.apply\(/,
+		/async\s/,
+		/await\s/,
+		/Promise/,
+		/https?:\/\//,
+		/[a-zA-Z]+Error/
+	].some((p) => p.test(s));
+}
+async function handleV8BytecodeDecompile(args) {
+	try {
+		const filePath = parseStringArg(args, "filePath", true);
+		if (!filePath) throw new Error("filePath is required — path to a .jsc or V8 bytecode file");
+		if (!await pathExists(filePath)) return toTextResponse({
+			success: false,
+			tool: "v8_bytecode_decompile",
+			error: `File does not exist: ${filePath}`
+		});
+		const fileStat = await stat(filePath);
+		if (fileStat.size > 50 * 1024 * 1024) return toTextResponse({
+			success: false,
+			tool: "v8_bytecode_decompile",
+			error: `File too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Maximum: 50MB.`
+		});
+		const buffer = await readFile(filePath);
+		const format = detectFormat(buffer, filePath);
+		if (!format) return toTextResponse({
+			success: false,
+			tool: "v8_bytecode_decompile",
+			filePath,
+			fileSize: fileStat.size,
+			error: "Not a recognized V8 bytecode format. Expected .jsc, bytenode, or V8 serialized bytecode.",
+			hint: "Ensure the file is a V8 compiled bytecode file (created by bytenode or v8.serialize)."
+		});
+		const result = {
+			success: false,
+			tool: "v8_bytecode_decompile",
+			filePath,
+			fileSize: fileStat.size,
+			detectedFormat: format,
+			strategy: "pending"
+		};
+		const view8Result = await tryView8(filePath);
+		if (view8Result.ok && view8Result.output) {
+			result.success = true;
+			result.strategy = "view8";
+			result.pseudocode = view8Result.output.length > 5e4 ? view8Result.output.slice(0, 5e4) + "\n\n... [truncated, total " + view8Result.output.length + " chars]" : view8Result.output;
+			return toTextResponse(result);
+		}
+		const { strings } = extractConstantPool(buffer);
+		if (strings.length > 0) {
+			result.success = true;
+			result.strategy = "constant-pool-extraction";
+			result.strings = strings.slice(0, 500);
+			result.note = [
+				`view8 unavailable (${view8Result.error}). Used built-in constant pool extraction.`,
+				`Found ${strings.length} code-relevant strings. These include function names, identifiers, URLs, and string literals from the original source.`,
+				`For full decompilation, install view8: pip install view8`
+			].join(" ");
+		} else {
+			result.success = false;
+			result.strategy = "none";
+			result.error = `Could not decompile. view8: ${view8Result.error}. Built-in extraction found no code strings.`;
+			result.note = "The bytecode may be heavily optimized or use an unsupported V8 version.";
+		}
+		return toTextResponse(result);
+	} catch (error) {
+		return toErrorResponse("v8_bytecode_decompile", error);
+	}
+}
+//#endregion
+//#region src/server/domains/platform/handlers/electron-dual-cdp.ts
+/**
+* electron_launch_debug — Launch Electron with dual CDP debugging.
+* Main process: --inspect=<port> (Node.js inspector)
+* Renderer: --remote-debugging-port=<port> (Chromium DevTools)
+*
+* Auto-checks fuse status and warns if debug fuses are disabled.
+*/
+/** Fuse sentinel for quick check */
+const FUSE_SENTINEL = "dL7pKGdnNz796PbbjQWNKmHXBZIA";
+const FUSE_ENABLE = 49;
+/** Track launched processes for cleanup */
+const launchedProcesses = /* @__PURE__ */ new Map();
+/**
+* Quick-check if critical debug fuses are enabled.
+*/
+async function quickFuseCheck(exePath) {
+	try {
+		const buffer = await readFile(exePath);
+		const sentinelBuf = Buffer.from(FUSE_SENTINEL, "ascii");
+		const idx = buffer.indexOf(sentinelBuf);
+		if (idx === -1) return {
+			fuseFound: false,
+			runAsNode: false,
+			inspectArgs: false,
+			nodeOptions: false
+		};
+		const base = idx + sentinelBuf.length;
+		return {
+			fuseFound: true,
+			runAsNode: buffer[base] === FUSE_ENABLE,
+			nodeOptions: buffer[base + 2] === FUSE_ENABLE,
+			inspectArgs: buffer[base + 3] === FUSE_ENABLE
+		};
+	} catch {
+		return {
+			fuseFound: false,
+			runAsNode: false,
+			inspectArgs: false,
+			nodeOptions: false
+		};
+	}
+}
+/**
+* Wait for a CDP port to become available (returns JSON version info).
+*/
+async function waitForCDP(port, timeoutMs = 1e4) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const res = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(2e3) });
+			if (res.ok) return {
+				ok: true,
+				info: await res.text()
+			};
+		} catch {}
+		await new Promise((r) => setTimeout(r, 500));
+	}
+	return {
+		ok: false,
+		error: `CDP port ${port} did not respond within ${timeoutMs}ms`
+	};
+}
+async function handleElectronLaunchDebug(args) {
+	try {
+		const exePath = parseStringArg(args, "exePath", true);
+		if (!exePath) throw new Error("exePath is required — path to the Electron .exe");
+		if (!await pathExists(exePath)) return toTextResponse({
+			success: false,
+			tool: "electron_launch_debug",
+			error: `File does not exist: ${exePath}`
+		});
+		const exeBaseName = exePath.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+		if (![
+			/^electron/i,
+			/\.app$/i,
+			/chrome/i,
+			/chromium/i
+		].some((p) => p.test(exeBaseName))) return toTextResponse({
+			success: false,
+			tool: "electron_launch_debug",
+			error: `exePath does not appear to be an Electron binary: ${exeBaseName}. Only Electron/Chromium executables are allowed.`
+		});
+		const mainPort = args.mainPort ?? 9229;
+		const rendererPort = args.rendererPort ?? 9222;
+		const rawExtraArgs = args.args ?? [];
+		const BLOCKED_FLAGS = [
+			"--require",
+			"--loader",
+			"--import",
+			"-e",
+			"--eval",
+			"-p",
+			"--print"
+		];
+		const extraArgs = rawExtraArgs.filter((arg) => !BLOCKED_FLAGS.some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
+		const skipFuseCheck = args.skipFuseCheck === true;
+		const waitMs = args.waitMs ?? 8e3;
+		const fuseWarnings = [];
+		if (!skipFuseCheck) {
+			const fuses = await quickFuseCheck(exePath);
+			if (fuses.fuseFound) {
+				if (!fuses.inspectArgs) fuseWarnings.push("EnableNodeCliInspectArguments is DISABLED — main process --inspect may be blocked. Use electron_patch_fuses first.");
+				if (!fuses.nodeOptions) fuseWarnings.push("EnableNodeOptionsEnvironmentVariable is DISABLED — NODE_OPTIONS injection blocked.");
+				if (!fuses.runAsNode) fuseWarnings.push("RunAsNode is DISABLED — ELECTRON_RUN_AS_NODE=1 will not work.");
+			}
+		}
+		const child = spawn(exePath, [
+			`--inspect=${mainPort}`,
+			`--remote-debugging-port=${rendererPort}`,
+			...extraArgs
+		], {
+			stdio: "ignore",
+			detached: true,
+			env: { ...process.env }
+		});
+		child.unref();
+		if (!child.pid) return toTextResponse({
+			success: false,
+			tool: "electron_launch_debug",
+			error: "Failed to spawn process — no PID returned."
+		});
+		const sessionId = `electron-${child.pid}`;
+		launchedProcesses.set(sessionId, {
+			child,
+			pid: child.pid,
+			ports: {
+				main: mainPort,
+				renderer: rendererPort
+			}
+		});
+		const [mainCDP, rendererCDP] = await Promise.all([waitForCDP(mainPort, waitMs), waitForCDP(rendererPort, waitMs)]);
+		return toTextResponse({
+			success: true,
+			tool: "electron_launch_debug",
+			sessionId,
+			pid: child.pid,
+			ports: {
+				main: {
+					port: mainPort,
+					available: mainCDP.ok,
+					info: mainCDP.ok ? "Ready" : mainCDP.error
+				},
+				renderer: {
+					port: rendererPort,
+					available: rendererCDP.ok,
+					info: rendererCDP.ok ? "Ready" : rendererCDP.error
+				}
+			},
+			fuseWarnings: fuseWarnings.length > 0 ? fuseWarnings : void 0,
+			usage: {
+				main: `Use electron_attach(port=${mainPort}) to debug the main process (Node.js)`,
+				renderer: `Use electron_attach(port=${rendererPort}) to debug the renderer (Chromium)`,
+				combined: "Both sessions can be used simultaneously for cross-process analysis"
+			}
+		});
+	} catch (error) {
+		return toErrorResponse("electron_launch_debug", error);
+	}
+}
+async function handleElectronDebugStatus(args) {
+	try {
+		const sessionId = parseStringArg(args, "sessionId");
+		if (sessionId) {
+			const session = launchedProcesses.get(sessionId);
+			if (!session) return toTextResponse({
+				success: false,
+				tool: "electron_debug_status",
+				error: `No session found: ${sessionId}`,
+				activeSessions: Array.from(launchedProcesses.keys())
+			});
+			const [mainCDP, rendererCDP] = await Promise.all([waitForCDP(session.ports.main, 2e3), waitForCDP(session.ports.renderer, 2e3)]);
+			return toTextResponse({
+				success: true,
+				tool: "electron_debug_status",
+				sessionId,
+				pid: session.pid,
+				main: {
+					port: session.ports.main,
+					alive: mainCDP.ok
+				},
+				renderer: {
+					port: session.ports.renderer,
+					alive: rendererCDP.ok
+				}
+			});
+		}
+		return toTextResponse({
+			success: true,
+			tool: "electron_debug_status",
+			sessions: Array.from(launchedProcesses.entries()).map(([id, s]) => ({
+				sessionId: id,
+				pid: s.pid,
+				ports: s.ports
+			}))
+		});
+	} catch (error) {
+		return toErrorResponse("electron_debug_status", error);
+	}
+}
+//#endregion
+//#region src/server/domains/platform/handlers/electron-ipc-sniffer.ts
+/**
+* electron_ipc_sniff — Intercept Electron IPC messages via CDP injection.
+*
+* Injects a preload-style hook into the renderer process via CDP to
+* instrument ipcRenderer.invoke / send / sendSync, capturing channel
+* names and arguments. Messages are buffered and can be dumped on demand.
+*
+* EADV-03: IPC sniffing probe.
+*/
+const ipcSessions = /* @__PURE__ */ new Map();
+function getElectronIPCSniffRuntimeCapability() {
+	if (typeof globalThis.WebSocket === "function") return { available: true };
+	return {
+		available: false,
+		reason: "Global WebSocket is not available in this Node runtime.",
+		fix: "Use Node.js 21+ or provide a WebSocket-compatible runtime."
+	};
+}
+/**
+* The JS payload injected into the renderer to hook ipcRenderer methods.
+* Uses CDP Runtime.evaluate to execute in the page context.
+*/
+const IPC_HOOK_PAYLOAD = `
+(function() {
+  if (window.__ipcSnifferInstalled) return 'already_installed';
+
+  const captured = [];
+  window.__ipcSnifferCaptured = captured;
+  window.__ipcSnifferInstalled = true;
+
+  // Try to access ipcRenderer from contextBridge-exposed API or require
+  let ipcRenderer = null;
+
+  // Method 1: Direct require (works if nodeIntegration is enabled)
+  try {
+    ipcRenderer = require('electron').ipcRenderer;
+  } catch(e) {}
+
+  // Method 2: window.electron (common contextBridge pattern)
+  if (!ipcRenderer && window.electron && window.electron.ipcRenderer) {
+    ipcRenderer = window.electron.ipcRenderer;
+  }
+
+  if (!ipcRenderer) {
+    return 'ipcRenderer_not_accessible';
+  }
+
+  // Hook invoke
+  const origInvoke = ipcRenderer.invoke.bind(ipcRenderer);
+  ipcRenderer.invoke = function(channel, ...args) {
+    captured.push({
+      timestamp: Date.now(),
+      method: 'invoke',
+      channel: channel,
+      args: args.map(a => {
+        try { return JSON.parse(JSON.stringify(a)); }
+        catch { return String(a); }
+      })
+    });
+    return origInvoke(channel, ...args);
+  };
+
+  // Hook send
+  const origSend = ipcRenderer.send.bind(ipcRenderer);
+  ipcRenderer.send = function(channel, ...args) {
+    captured.push({
+      timestamp: Date.now(),
+      method: 'send',
+      channel: channel,
+      args: args.map(a => {
+        try { return JSON.parse(JSON.stringify(a)); }
+        catch { return String(a); }
+      })
+    });
+    return origSend(channel, ...args);
+  };
+
+  // Hook sendSync
+  if (ipcRenderer.sendSync) {
+    const origSendSync = ipcRenderer.sendSync.bind(ipcRenderer);
+    ipcRenderer.sendSync = function(channel, ...args) {
+      captured.push({
+        timestamp: Date.now(),
+        method: 'sendSync',
+        channel: channel,
+        args: args.map(a => {
+          try { return JSON.parse(JSON.stringify(a)); }
+          catch { return String(a); }
+        })
+      });
+      return origSendSync(channel, ...args);
+    };
+  }
+
+  return 'hooks_installed';
+})();
+`;
+/**
+* JS payload to dump captured messages from the renderer.
+*/
+const IPC_DUMP_PAYLOAD = `
+(function() {
+  const captured = window.__ipcSnifferCaptured || [];
+  const result = JSON.stringify(captured);
+  return result;
+})();
+`;
+/**
+* JS payload to clear captured messages.
+*/
+const IPC_CLEAR_PAYLOAD = `
+(function() {
+  if (window.__ipcSnifferCaptured) {
+    const count = window.__ipcSnifferCaptured.length;
+    window.__ipcSnifferCaptured.length = 0;
+    return String(count);
+  }
+  return '0';
+})();
+`;
+/**
+* Execute a CDP command via HTTP.
+*/
+async function cdpEvaluate(wsDebuggerUrl, expression) {
+	const match = wsDebuggerUrl.match(/ws:\/\/([\d.]+:\d+)\//);
+	if (!match?.[1]) return {
+		ok: false,
+		error: `Invalid wsDebuggerUrl: ${wsDebuggerUrl}`
+	};
+	const hostPort = match[1];
+	try {
+		const page = (await (await fetch(`http://${hostPort}/json`, { signal: AbortSignal.timeout(5e3) })).json()).find((t) => t.type === "page");
+		if (!page) return {
+			ok: false,
+			error: "No page target found"
+		};
+		const pageWsUrl = page.webSocketDebuggerUrl;
+		if (!pageWsUrl) return {
+			ok: false,
+			error: "Page target has no WebSocket debugger URL"
+		};
+		return await cdpEvalViaWs(pageWsUrl, expression);
+	} catch (error) {
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Minimal WebSocket CDP Runtime.evaluate call.
+*/
+function cdpEvalViaWs(wsUrl, expression) {
+	return new Promise((resolve) => {
+		try {
+			const runtimeCapability = getElectronIPCSniffRuntimeCapability();
+			if (!runtimeCapability.available) {
+				resolve({
+					ok: false,
+					error: `${runtimeCapability.reason} ${runtimeCapability.fix ?? ""}`.trim()
+				});
+				return;
+			}
+			const WS = globalThis.WebSocket;
+			const ws = new WS(wsUrl);
+			const timeout = setTimeout(() => {
+				try {
+					ws.close();
+				} catch {}
+				resolve({
+					ok: false,
+					error: "CDP WebSocket timeout (10s)"
+				});
+			}, 1e4);
+			ws.addEventListener("open", () => {
+				ws.send(JSON.stringify({
+					id: 1,
+					method: "Runtime.evaluate",
+					params: {
+						expression,
+						returnByValue: true,
+						awaitPromise: false
+					}
+				}));
+			});
+			ws.addEventListener("message", (event) => {
+				clearTimeout(timeout);
+				try {
+					const data = JSON.parse(String(event.data));
+					if (data.result?.exceptionDetails) resolve({
+						ok: false,
+						error: data.result.exceptionDetails.text
+					});
+					else resolve({
+						ok: true,
+						result: String(data.result?.result?.value ?? "")
+					});
+				} catch (e) {
+					resolve({
+						ok: false,
+						error: `Parse error: ${e}`
+					});
+				}
+				try {
+					ws.close();
+				} catch {}
+			});
+			ws.addEventListener("error", (err) => {
+				clearTimeout(timeout);
+				resolve({
+					ok: false,
+					error: `WebSocket error: ${err}`
+				});
+			});
+		} catch (error) {
+			resolve({
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	});
+}
+async function handleElectronIPCSniff(args) {
+	try {
+		const action = parseStringArg(args, "action") ?? "guide";
+		if (action === "start") {
+			const port = args.port ?? 9222;
+			const sessionId = `ipc-sniff-${port}-${Date.now()}`;
+			let wsUrl;
+			try {
+				wsUrl = (await (await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(5e3) })).json()).webSocketDebuggerUrl ?? `ws://127.0.0.1:${port}/devtools/browser`;
+			} catch {
+				return toTextResponse({
+					success: false,
+					tool: "electron_ipc_sniff",
+					error: `Cannot connect to CDP at port ${port}. Ensure Electron is launched with --remote-debugging-port=${port}.`,
+					hint: "Use electron_launch_debug to start the app with CDP enabled."
+				});
+			}
+			const injectResult = await cdpEvaluate(wsUrl, IPC_HOOK_PAYLOAD);
+			if (!injectResult.ok) return toTextResponse({
+				success: false,
+				tool: "electron_ipc_sniff",
+				error: `Failed to inject IPC hooks: ${injectResult.error}`,
+				hint: "The renderer may have contextIsolation enabled. Try injecting via main process CDP instead."
+			});
+			const session = {
+				id: sessionId,
+				port,
+				wsUrl,
+				messages: [],
+				startedAt: Date.now(),
+				active: true
+			};
+			ipcSessions.set(sessionId, session);
+			return toTextResponse({
+				success: true,
+				tool: "electron_ipc_sniff",
+				action: "start",
+				sessionId,
+				port,
+				hookStatus: injectResult.result,
+				usage: {
+					dump: `electron_ipc_sniff(action="dump", sessionId="${sessionId}")`,
+					stop: `electron_ipc_sniff(action="stop", sessionId="${sessionId}")`
+				},
+				note: injectResult.result === "ipcRenderer_not_accessible" ? "ipcRenderer not accessible — contextIsolation may be enabled. IPC hooking requires nodeIntegration or a custom preload." : "IPC hooks installed. Interact with the app, then use dump to retrieve captured messages."
+			});
+		}
+		if (action === "dump") {
+			const sessionId = parseStringArg(args, "sessionId");
+			const port = args.port;
+			const clear = args.clear !== false;
+			let session;
+			if (sessionId) session = ipcSessions.get(sessionId);
+			else if (port) session = Array.from(ipcSessions.values()).find((s) => s.port === port);
+			else {
+				const sessions = Array.from(ipcSessions.values());
+				session = sessions[sessions.length - 1];
+			}
+			if (!session) return toTextResponse({
+				success: false,
+				tool: "electron_ipc_sniff",
+				error: "No active IPC sniff session found.",
+				activeSessions: Array.from(ipcSessions.keys()),
+				hint: "Start a session first: electron_ipc_sniff(action=\"start\", port=9222)"
+			});
+			const dumpResult = await cdpEvaluate(session.wsUrl, IPC_DUMP_PAYLOAD);
+			if (!dumpResult.ok) return toTextResponse({
+				success: false,
+				tool: "electron_ipc_sniff",
+				error: `Failed to dump IPC messages: ${dumpResult.error}`
+			});
+			let messages = [];
+			try {
+				messages = JSON.parse(dumpResult.result ?? "[]");
+			} catch {
+				messages = [];
+			}
+			if (clear && messages.length > 0) await cdpEvaluate(session.wsUrl, IPC_CLEAR_PAYLOAD);
+			const channelSummary = {};
+			for (const msg of messages) channelSummary[msg.channel] = (channelSummary[msg.channel] ?? 0) + 1;
+			return toTextResponse({
+				success: true,
+				tool: "electron_ipc_sniff",
+				action: "dump",
+				sessionId: session.id,
+				messageCount: messages.length,
+				channelSummary,
+				messages: messages.slice(0, 200),
+				cleared: clear,
+				note: messages.length > 200 ? `Showing first 200 of ${messages.length} messages. Use dump repeatedly for ongoing capture.` : void 0
+			});
+		}
+		if (action === "stop") {
+			const sessionId = parseStringArg(args, "sessionId");
+			if (!sessionId) return toTextResponse({
+				success: false,
+				tool: "electron_ipc_sniff",
+				error: "sessionId is required for stop.",
+				activeSessions: Array.from(ipcSessions.keys())
+			});
+			const session = ipcSessions.get(sessionId);
+			if (!session) return toTextResponse({
+				success: false,
+				tool: "electron_ipc_sniff",
+				error: `Session not found: ${sessionId}`
+			});
+			session.active = false;
+			ipcSessions.delete(sessionId);
+			return toTextResponse({
+				success: true,
+				tool: "electron_ipc_sniff",
+				action: "stop",
+				sessionId,
+				message: "IPC sniff session stopped.",
+				uptime: Math.round((Date.now() - session.startedAt) / 1e3)
+			});
+		}
+		if (action === "list") {
+			const sessions = Array.from(ipcSessions.entries()).map(([id, s]) => ({
+				sessionId: id,
+				port: s.port,
+				active: s.active,
+				uptime: Math.round((Date.now() - s.startedAt) / 1e3)
+			}));
+			return toTextResponse({
+				success: true,
+				tool: "electron_ipc_sniff",
+				action: "list",
+				sessions,
+				count: sessions.length
+			});
+		}
+		return toTextResponse({
+			success: true,
+			guide: {
+				what: "Electron IPC sniffer — intercepts ipcRenderer.invoke/send/sendSync messages via CDP injection.",
+				workflow: [
+					"1. Launch Electron with: electron_launch_debug(exePath=\"...\")",
+					"2. Start sniffing: electron_ipc_sniff(action=\"start\", port=9222)",
+					"3. Interact with the app to trigger IPC messages",
+					"4. Dump captured: electron_ipc_sniff(action=\"dump\", sessionId=\"...\")",
+					"5. Stop when done: electron_ipc_sniff(action=\"stop\", sessionId=\"...\")"
+				],
+				actions: [
+					"start",
+					"dump",
+					"stop",
+					"list",
+					"guide"
+				],
+				limitations: [
+					"Requires renderer CDP port (--remote-debugging-port)",
+					"contextIsolation=true may block direct ipcRenderer access",
+					"Main process IPC (ipcMain) is captured indirectly through renderer-side hooks"
+				]
+			}
+		});
+	} catch (error) {
+		return toErrorResponse("electron_ipc_sniff", error);
+	}
+}
+//#endregion
+//#region src/server/domains/platform/handlers/capabilities.ts
+async function handlePlatformCapabilities(runner) {
+	const miniappProbe = (await runner.probeAll())["miniapp.unpacker"];
+	const view8Availability = await probeView8Availability() ?? {
+		available: false,
+		reason: "view8 probe returned no result"
+	};
+	const ipcCapability = getElectronIPCSniffRuntimeCapability() ?? {
+		available: false,
+		reason: "IPC runtime probe returned no result"
+	};
+	return toTextResponse(capabilityReport("platform_capabilities", [
+		{
+			capability: "miniapp_unpacker",
+			status: miniappProbe?.available ? "available" : "unavailable",
+			reason: miniappProbe?.reason,
+			fix: miniappProbe?.available ? void 0 : "Install unveilr to enable the fast external unpack path.",
+			details: {
+				tools: ["miniapp_pkg_unpack"],
+				fallback: "Built-in Node.js parser remains available.",
+				...miniappProbe?.path ? { path: miniappProbe.path } : {},
+				...miniappProbe?.version ? { version: miniappProbe.version } : {}
+			}
+		},
+		{
+			capability: "view8",
+			status: view8Availability.available ? "available" : "unavailable",
+			reason: view8Availability.reason,
+			fix: view8Availability.available ? void 0 : "Install view8 with pip install view8 to enable full bytecode decompilation.",
+			details: {
+				tools: ["v8_bytecode_decompile"],
+				fallback: "Built-in constant-pool extraction remains available.",
+				...view8Availability.interpreter ? { interpreter: view8Availability.interpreter } : {}
+			}
+		},
+		{
+			capability: "electron_ipc_sniff_runtime",
+			status: ipcCapability.available ? "available" : "unavailable",
+			reason: ipcCapability.reason,
+			fix: ipcCapability.fix,
+			details: {
+				tools: ["electron_ipc_sniff"],
+				note: "A renderer CDP port is still required at call time."
+			}
+		}
+	]));
+}
+//#endregion
+//#region src/server/domains/platform/handlers.ts
+var PlatformToolHandlers = class {
+	miniapp;
+	electron;
+	runner;
+	constructor(collector) {
+		const registry = new ToolRegistry();
+		this.runner = new ExternalToolRunner(registry);
+		this.miniapp = new MiniappHandlers(this.runner, collector);
+		this.electron = new ElectronHandlers(collector);
+	}
+	handlePlatformCapabilities() {
+		return handlePlatformCapabilities(this.runner);
+	}
+	handleMiniappPkgScan(args) {
+		return this.miniapp.handleMiniappPkgScan(args);
+	}
+	handleMiniappPkgUnpack(args) {
+		return this.miniapp.handleMiniappPkgUnpack(args);
+	}
+	handleMiniappPkgAnalyze(args) {
+		return this.miniapp.handleMiniappPkgAnalyze(args);
+	}
+	handleAsarExtract(args) {
+		return this.electron.handleAsarExtract(args);
+	}
+	handleElectronInspectApp(args) {
+		return this.electron.handleElectronInspectApp(args);
+	}
+	handleElectronScanUserdata(args) {
+		return handleElectronScanUserdata(args);
+	}
+	handleAsarSearch(args) {
+		return this.electron.handleAsarSearch(args);
+	}
+	handleElectronCheckFuses(args) {
+		return handleElectronCheckFuses(args);
+	}
+	handleElectronPatchFuses(args) {
+		return handleElectronPatchFuses(args);
+	}
+	handleV8BytecodeDecompile(args) {
+		return handleV8BytecodeDecompile(args);
+	}
+	handleElectronLaunchDebug(args) {
+		return handleElectronLaunchDebug(args);
+	}
+	handleElectronDebugStatus(args) {
+		return handleElectronDebugStatus(args);
+	}
+	handleElectronIPCSniff(args) {
+		return handleElectronIPCSniff(args);
+	}
+};
+//#endregion
+export { PlatformToolHandlers };