@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/handlers-CRyRWj2b.mjs

@@ -0,0 +1,859 @@
+import { xr as UNIDBG_TIMEOUT_MS } from "./constants-CDZLOoVv.mjs";
+import { a as invokePlugin, c as FridaSession, i as getAvailablePlugins, n as UnidbgRunner, o as HookCodeGenerator, r as HookGenerator, s as GhidraAnalyzer } from "./binary-instrument--V3MAhJ4.mjs";
+import { n as capabilityReport, t as capabilityFailure } from "./capabilities-CcHlvWgK.mjs";
+import { access } from "node:fs/promises";
+import { execFile } from "node:child_process";
+//#region src/server/domains/binary-instrument/handlers/shared.ts
+/**
+* Shared types and helpers for binary-instrument sub-handlers.
+*/
+const UNIDBG_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+const LEGACY_PLUGIN_FIXES = {
+	plugin_frida_bridge: "Install @jshookmcpextension/plugin-frida-bridge and reload extensions.",
+	plugin_ghidra_bridge: "Install @jshookmcpextension/plugin-ghidra-bridge and reload extensions.",
+	plugin_ida_bridge: "Install @jshookmcpextension/plugin-ida-bridge and reload extensions.",
+	plugin_jadx_bridge: "Install @jshookmcpextension/plugin-jadx-bridge and reload extensions."
+};
+function textResponse(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function jsonResponse(payload) {
+	return textResponse(JSON.stringify(payload));
+}
+function readRequiredString(args, key) {
+	const value = args[key];
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${key} is required`);
+	return value.trim();
+}
+function readOptionalString(args, key) {
+	const value = args[key];
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readOptionalNumber(args, key) {
+	const value = args[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readStringArray(args, key) {
+	const value = args[key];
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isServerContext(value) {
+	return isRecord(value) && value["extensionPluginsById"] instanceof Map && value["extensionPluginRuntimeById"] instanceof Map;
+}
+function hasInstalledLegacyPlugin(context, pluginId) {
+	if (!context) return void 0;
+	const installed = context.extensionPluginsById;
+	if (!(installed instanceof Map)) return void 0;
+	return installed.has(pluginId);
+}
+function getLegacyPluginFix(pluginId) {
+	return LEGACY_PLUGIN_FIXES[pluginId];
+}
+function getLegacyPluginStatus(context, pluginId) {
+	const installed = hasInstalledLegacyPlugin(context, pluginId);
+	if (installed === true) return {
+		status: "available",
+		fix: getLegacyPluginFix(pluginId)
+	};
+	if (installed === false) return {
+		status: "unavailable",
+		reason: `Plugin ${pluginId.replaceAll("_", "-")} is not installed`,
+		fix: getLegacyPluginFix(pluginId)
+	};
+	return {
+		status: "unknown",
+		reason: "Extension plugin registry is not available in the current server context",
+		fix: "Run inside the full MCP server with extension support enabled."
+	};
+}
+async function invokeLegacyPlugin(context, pluginId, toolName, args) {
+	const pluginStatus = getLegacyPluginStatus(context, pluginId);
+	if (!context || pluginStatus.status !== "available") return jsonResponse({
+		...capabilityFailure(toolName, pluginId, pluginStatus.reason ?? `Plugin ${pluginId.replaceAll("_", "-")} is not available`, pluginStatus.fix),
+		status: pluginStatus.status
+	});
+	const result = await invokePlugin(context, {
+		pluginId,
+		toolName,
+		args
+	});
+	if (result.success) return jsonResponse(result);
+	return jsonResponse({ ...capabilityFailure(toolName, pluginId, result.error ?? "Plugin invocation failed", pluginStatus.fix) });
+}
+function readHookOptions(args, key) {
+	const raw = args[key];
+	if (!isRecord(raw)) return void 0;
+	const options = {};
+	const includeArgs = raw["includeArgs"];
+	const includeRetAddr = raw["includeRetAddr"];
+	if (typeof includeArgs === "boolean") options.includeArgs = includeArgs;
+	if (typeof includeRetAddr === "boolean") options.includeRetAddr = includeRetAddr;
+	return options;
+}
+function parsePid(target) {
+	if (!/^\d+$/.test(target)) return null;
+	const parsed = Number.parseInt(target, 10);
+	return Number.isNaN(parsed) ? null : parsed;
+}
+function makeMockId(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+}
+async function getUnidbgAvailability() {
+	const jarPath = process.env["UNIDBG_JAR"] ?? "";
+	if (jarPath.length === 0) return {
+		available: false,
+		reason: "UNIDBG_JAR is not configured",
+		command: "java",
+		jarPath: ""
+	};
+	try {
+		await access(jarPath);
+	} catch {
+		return {
+			available: false,
+			reason: `UNIDBG_JAR not found: ${jarPath}`,
+			command: "java",
+			jarPath
+		};
+	}
+	return {
+		available: true,
+		reason: "",
+		command: "java",
+		jarPath
+	};
+}
+function execFileUtf8(file, args, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		execFile(file, args, {
+			timeout: timeoutMs,
+			windowsHide: true,
+			maxBuffer: UNIDBG_MAX_BUFFER_BYTES,
+			encoding: "utf8"
+		}, (error, stdout, stderr) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve({
+				stdout: typeof stdout === "string" ? stdout : "",
+				stderr: typeof stderr === "string" ? stderr : ""
+			});
+		});
+	});
+}
+function isGhidraAnalysisOutput(value) {
+	return isRecord(value) && Array.isArray(value["functions"]) && Array.isArray(value["imports"]);
+}
+function toHookTemplates(value) {
+	const templates = [];
+	for (const entry of value) {
+		if (!isRecord(entry)) continue;
+		const functionName = readStringRecordField(entry, "functionName");
+		const hookCode = readStringRecordField(entry, "hookCode");
+		const description = readStringRecordField(entry, "description");
+		const parameters = parseHookParameters(entry["parameters"]);
+		if (!functionName || !hookCode || !description) continue;
+		templates.push({
+			functionName,
+			hookCode,
+			description,
+			parameters
+		});
+	}
+	return templates;
+}
+function readStringRecordField(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : void 0;
+}
+function parseHookParameters(value) {
+	if (!Array.isArray(value)) return [];
+	const parameters = [];
+	for (const entry of value) {
+		if (!isRecord(entry)) continue;
+		const name = readStringRecordField(entry, "name");
+		const type = readStringRecordField(entry, "type");
+		const description = readStringRecordField(entry, "description");
+		if (name && type && description) parameters.push({
+			name,
+			type,
+			description
+		});
+	}
+	return parameters;
+}
+//#endregion
+//#region src/server/domains/binary-instrument/handlers/frida-handlers.ts
+/**
+* Frida sub-handler — attach, runScript, detach, listSessions, generateScript,
+* enumerateModules, enumerateFunctions, findSymbols.
+*/
+var FridaHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleFridaAttach(args) {
+		const legacyPid = readOptionalString(args, "pid");
+		if (!readOptionalString(args, "target") && legacyPid) return invokeLegacyPlugin(this.state.context, "plugin_frida_bridge", "frida_attach", args);
+		const target = readRequiredString(args, "target");
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		if (!availability.available) {
+			const sessionId = `mock-frida-${makeMockId(target)}`;
+			return jsonResponse({
+				success: false,
+				available: false,
+				capability: "frida_cli",
+				fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+				target,
+				sessionId,
+				reason: availability.reason ?? "Frida CLI is not available",
+				sessions: [{
+					id: sessionId,
+					target,
+					pid: parsePid(target),
+					status: "unavailable"
+				}]
+			});
+		}
+		let sessionId;
+		try {
+			sessionId = await frida.attach(target);
+		} catch (error) {
+			return jsonResponse({
+				success: false,
+				available: true,
+				capability: "frida_attach",
+				fix: "Run the server elevated or choose a target process that allows Frida injection.",
+				target,
+				reason: error instanceof Error ? error.message : String(error),
+				sessions: frida.listSessions()
+			});
+		}
+		this.state.context?.eventBus.emit("frida:attached", {
+			target,
+			sessionId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return jsonResponse({
+			success: true,
+			available: true,
+			target,
+			sessionId,
+			sessions: frida.listSessions()
+		});
+	}
+	async handleFridaEnumerateModules(args) {
+		const sessionId = readRequiredString(args, "sessionId");
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		if (!availability.available) return jsonResponse({
+			available: false,
+			capability: "frida_cli",
+			fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+			sessionId,
+			reason: availability.reason ?? "Frida CLI is not available",
+			modules: [{
+				name: "mock-module",
+				base: "0x0",
+				size: 0,
+				path: "<unavailable>"
+			}]
+		});
+		if (!frida.useSession(sessionId)) return jsonResponse({
+			available: false,
+			capability: "frida_session",
+			fix: "Call frida_attach first and reuse the returned sessionId.",
+			sessionId,
+			reason: `Unknown Frida session: ${sessionId}`,
+			modules: []
+		});
+		const modules = await frida.enumerateModules();
+		const diagnostics = frida.getSessionDiagnostics(sessionId);
+		if (diagnostics?.status === "error" && diagnostics.lastError) return jsonResponse({
+			success: false,
+			available: true,
+			sessionId,
+			reason: diagnostics.lastError,
+			modules
+		});
+		return jsonResponse({
+			success: true,
+			available: true,
+			sessionId,
+			modules
+		});
+	}
+	async handleFridaRunScript(args) {
+		const sessionId = readOptionalString(args, "sessionId");
+		if (!sessionId) return textResponse("Missing required string argument: sessionId");
+		const script = readRequiredString(args, "script");
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		if (!availability.available) return {
+			available: false,
+			capability: "frida_cli",
+			fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+			sessionId,
+			reason: availability.reason ?? "Frida CLI is not available",
+			execution: {
+				output: "",
+				error: "Frida unavailable"
+			}
+		};
+		if (!frida.useSession(sessionId)) return {
+			available: false,
+			capability: "frida_session",
+			fix: "Call frida_attach first and reuse the returned sessionId.",
+			sessionId,
+			reason: `Unknown Frida session: ${sessionId}`,
+			execution: {
+				output: "",
+				error: "Unknown session"
+			}
+		};
+		const execution = await frida.executeScript(script);
+		if (execution.error) return jsonResponse({
+			success: false,
+			available: true,
+			sessionId,
+			reason: execution.error,
+			execution
+		});
+		return jsonResponse({
+			success: true,
+			available: true,
+			sessionId,
+			execution
+		});
+	}
+	async handleFridaDetach(args) {
+		const sessionId = readOptionalString(args, "sessionId");
+		if (!sessionId) return textResponse("Missing required string argument: sessionId");
+		const frida = this.getFridaSession();
+		if ((await frida.getAvailability()).available && frida.hasSession(sessionId)) {
+			frida.useSession(sessionId);
+			await frida.detach();
+			return jsonResponse({
+				success: true,
+				sessionId,
+				detached: true
+			});
+		}
+		return invokeLegacyPlugin(this.state.context, "plugin_frida_bridge", "frida_detach", args);
+	}
+	async handleFridaListSessions(_args) {
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		const sessions = frida.listSessions();
+		if (availability.available) return jsonResponse({
+			success: true,
+			available: true,
+			sessions,
+			count: sessions.length
+		});
+		const pluginStatus = getLegacyPluginStatus(this.state.context, "plugin_frida_bridge");
+		if (sessions.length > 0 || pluginStatus.status === "unavailable") return jsonResponse({
+			success: true,
+			available: false,
+			capability: "frida_cli",
+			reason: availability.reason ?? "Frida CLI is not available",
+			fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+			sessions,
+			count: sessions.length
+		});
+		return invokeLegacyPlugin(this.state.context, "plugin_frida_bridge", "frida_list_sessions", _args);
+	}
+	async handleFridaGenerateScript(args) {
+		const target = readOptionalString(args, "target") ?? "unknown";
+		const template = readOptionalString(args, "template") ?? "trace";
+		const functionName = readOptionalString(args, "functionName") ?? "target_function";
+		const templates = [{
+			functionName,
+			hookCode: `console.log('[${template}] ${functionName} called');`,
+			description: `${template} hook for ${functionName}`,
+			parameters: []
+		}];
+		return jsonResponse({
+			success: true,
+			target,
+			template,
+			functionName,
+			script: this.state.hookCodeGenerator.exportScript(templates, "frida")
+		});
+	}
+	async handleFridaEnumerateFunctions(args) {
+		const sessionId = readRequiredString(args, "sessionId");
+		const moduleName = readRequiredString(args, "moduleName");
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		if (!availability.available) return {
+			available: false,
+			capability: "frida_cli",
+			fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+			sessionId,
+			moduleName,
+			reason: availability.reason ?? "Frida CLI is not available",
+			functions: []
+		};
+		if (!frida.useSession(sessionId)) return {
+			available: false,
+			capability: "frida_session",
+			fix: "Call frida_attach first and reuse the returned sessionId.",
+			sessionId,
+			reason: `Unknown Frida session: ${sessionId}`,
+			functions: []
+		};
+		const functions = await frida.enumerateFunctions(moduleName);
+		const diagnostics = frida.getSessionDiagnostics(sessionId);
+		if (diagnostics?.status === "error" && diagnostics.lastError) return jsonResponse({
+			success: false,
+			available: true,
+			sessionId,
+			moduleName,
+			reason: diagnostics.lastError,
+			functions,
+			count: functions.length
+		});
+		return jsonResponse({
+			success: true,
+			available: true,
+			sessionId,
+			moduleName,
+			functions,
+			count: functions.length
+		});
+	}
+	async handleFridaFindSymbols(args) {
+		const sessionId = readRequiredString(args, "sessionId");
+		const pattern = readRequiredString(args, "pattern");
+		const frida = this.getFridaSession();
+		const availability = await frida.getAvailability();
+		if (!availability.available) return {
+			available: false,
+			capability: "frida_cli",
+			fix: "Install frida-tools and ensure the frida CLI is on PATH.",
+			sessionId,
+			pattern,
+			reason: availability.reason ?? "Frida CLI is not available",
+			symbols: []
+		};
+		if (!frida.useSession(sessionId)) return {
+			available: false,
+			capability: "frida_session",
+			fix: "Call frida_attach first and reuse the returned sessionId.",
+			sessionId,
+			reason: `Unknown Frida session: ${sessionId}`,
+			symbols: []
+		};
+		const symbols = await frida.findSymbols(pattern);
+		const diagnostics = frida.getSessionDiagnostics(sessionId);
+		if (diagnostics?.status === "error" && diagnostics.lastError) return jsonResponse({
+			success: false,
+			available: true,
+			sessionId,
+			pattern,
+			reason: diagnostics.lastError,
+			symbols,
+			count: symbols.length
+		});
+		return jsonResponse({
+			success: true,
+			available: true,
+			sessionId,
+			pattern,
+			symbols,
+			count: symbols.length
+		});
+	}
+	getFridaSession() {
+		if (!this.state.fridaSession) this.state.fridaSession = new FridaSession();
+		return this.state.fridaSession;
+	}
+};
+//#endregion
+//#region src/server/domains/binary-instrument/handlers/analysis-handlers.ts
+/**
+* Static analysis sub-handler — Ghidra, IDA, JADX, Unidbg, hooks, plugins.
+*/
+var AnalysisHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleGhidraAnalyze(args) {
+		const legacyTargetPath = readOptionalString(args, "targetPath");
+		if (!readOptionalString(args, "binaryPath") && legacyTargetPath) return invokeLegacyPlugin(this.state.context, "plugin_ghidra_bridge", "ghidra_analyze", args);
+		const binaryPath = readRequiredString(args, "binaryPath");
+		const timeout = readOptionalNumber(args, "timeout");
+		const ghidra = this.getGhidraAnalyzer();
+		const availability = await ghidra.getAvailability();
+		const analysis = await ghidra.analyze(binaryPath, timeout !== void 0 ? { timeout } : void 0);
+		if (!availability.available) return {
+			available: false,
+			capability: "ghidra_headless",
+			fix: "Install Ghidra and ensure analyzeHeadless is on PATH.",
+			binaryPath,
+			reason: availability.reason ?? "Ghidra analyzeHeadless is not available",
+			analysis
+		};
+		return {
+			available: true,
+			binaryPath,
+			analysis
+		};
+	}
+	async handleGhidraDecompile(args) {
+		return invokeLegacyPlugin(this.state.context, "plugin_ghidra_bridge", "ghidra_decompile", args);
+	}
+	async handleIdaDecompile(args) {
+		return invokeLegacyPlugin(this.state.context, "plugin_ida_bridge", "ida_decompile", args);
+	}
+	async handleJadxDecompile(args) {
+		return invokeLegacyPlugin(this.state.context, "plugin_jadx_bridge", "jadx_decompile", args);
+	}
+	async handleGenerateHooks(args) {
+		const legacyGhidraOutput = readOptionalString(args, "ghidraOutput");
+		if (legacyGhidraOutput) return this.handleLegacyGenerateHooks(legacyGhidraOutput);
+		const legacyGhidraOutputObj = args["ghidraOutput"];
+		if (isRecord(legacyGhidraOutputObj)) return this.handleLegacyGenerateHooks(JSON.stringify(legacyGhidraOutputObj));
+		const symbols = readStringArray(args, "symbols");
+		if (symbols.length === 0) return textResponse("symbols or ghidraOutput is required");
+		const options = readHookOptions(args, "options");
+		const script = this.getHookGenerator().generateFridaHookScript(symbols, options);
+		return jsonResponse({
+			available: true,
+			symbolCount: symbols.length,
+			script
+		});
+	}
+	async handleExportHookScript(args) {
+		const rawTemplates = readOptionalString(args, "hookTemplates");
+		if (!rawTemplates) {
+			const generated = this.state.hookCodeGenerator.exportScript([], "frida");
+			return jsonResponse({
+				format: "frida",
+				hookCount: 0,
+				script: generated.includes("Java.perform") ? generated : `Java.perform(function() {\n${generated}\n});`
+			});
+		}
+		try {
+			const parsed = JSON.parse(rawTemplates);
+			if (!Array.isArray(parsed)) return textResponse("Invalid JSON");
+			const templates = toHookTemplates(parsed);
+			const script = this.state.hookCodeGenerator.exportScript(templates, "frida");
+			return jsonResponse({
+				format: "frida",
+				hookCount: templates.length,
+				script
+			});
+		} catch {
+			return textResponse("Invalid JSON");
+		}
+	}
+	async handleUnidbgEmulate(args) {
+		const binaryPath = readRequiredString(args, "binaryPath");
+		const functionName = readRequiredString(args, "functionName");
+		const invokeArgs = readStringArray(args, "args");
+		const availability = await getUnidbgAvailability();
+		if (!availability.available) return {
+			available: false,
+			capability: "unidbg_jar",
+			fix: "Set UNIDBG_JAR to a reachable Unidbg JAR path.",
+			binaryPath,
+			functionName,
+			args: invokeArgs,
+			reason: availability.reason,
+			result: {
+				returnValue: "0x0",
+				stdout: "",
+				stderr: "",
+				trace: ["mock-unidbg-unavailable"]
+			}
+		};
+		const result = await execFileUtf8(availability.command, [
+			"-jar",
+			availability.jarPath,
+			binaryPath,
+			functionName,
+			...invokeArgs
+		], UNIDBG_TIMEOUT_MS);
+		return {
+			available: true,
+			binaryPath,
+			functionName,
+			args: invokeArgs,
+			result: {
+				returnValue: "0x0",
+				stdout: result.stdout.trim(),
+				stderr: result.stderr.trim(),
+				trace: []
+			}
+		};
+	}
+	async handleUnidbgLaunch(args) {
+		const soPath = readOptionalString(args, "soPath");
+		if (!soPath) return textResponse("Missing required string argument: soPath");
+		const arch = readOptionalString(args, "arch") ?? "arm";
+		try {
+			const result = await this.state.unidbgRunner.launch(soPath, arch);
+			return {
+				available: true,
+				sessionId: result.sessionId,
+				soPath: result.soPath,
+				arch: result.arch,
+				sessions: this.state.unidbgRunner.listSessions()
+			};
+		} catch (error) {
+			return {
+				available: false,
+				capability: "unidbg_jar",
+				fix: "Set UNIDBG_JAR to a reachable Unidbg JAR path and retry.",
+				soPath,
+				arch,
+				reason: error instanceof Error ? error.message : String(error),
+				sessions: this.state.unidbgRunner.listSessions()
+			};
+		}
+	}
+	async handleUnidbgCall(args) {
+		const sessionId = readOptionalString(args, "sessionId");
+		if (!sessionId) return textResponse("Missing required string argument: sessionId");
+		const functionName = readOptionalString(args, "functionName");
+		if (!functionName) return textResponse("Missing required string argument: functionName");
+		const callArgs = isRecord(args["args"]) ? args["args"] : {};
+		try {
+			return jsonResponse(await this.state.unidbgRunner.callFunction(sessionId, functionName, callArgs));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return textResponse(message.startsWith("No unidbg session found") ? `${message} (not found)` : message);
+		}
+	}
+	async handleUnidbgTrace(args) {
+		const sessionId = readOptionalString(args, "sessionId");
+		if (!sessionId) return textResponse("Missing required string argument: sessionId");
+		try {
+			return jsonResponse(await this.state.unidbgRunner.trace(sessionId));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return textResponse(message.startsWith("No unidbg session found") ? `${message} (not found)` : message);
+		}
+	}
+	async handleGetAvailablePlugins(_args) {
+		const plugins = this.state.context ? getAvailablePlugins(this.state.context) : [];
+		return jsonResponse({
+			plugins,
+			count: plugins.length
+		});
+	}
+	getGhidraAnalyzer() {
+		if (!this.state.ghidra) this.state.ghidra = new GhidraAnalyzer();
+		return this.state.ghidra;
+	}
+	getHookGenerator() {
+		if (!this.state.hookGen) this.state.hookGen = new HookGenerator();
+		return this.state.hookGen;
+	}
+	handleLegacyGenerateHooks(ghidraOutput) {
+		let parsed;
+		try {
+			parsed = JSON.parse(ghidraOutput);
+		} catch {
+			return textResponse("Invalid JSON");
+		}
+		if (!isGhidraAnalysisOutput(parsed)) return textResponse("ghidraOutput is required");
+		const hooks = this.state.hookCodeGenerator.generateHooks(parsed);
+		return jsonResponse({
+			count: hooks.length,
+			hooks
+		});
+	}
+};
+//#endregion
+//#region src/server/domains/binary-instrument/handlers/capability-handlers.ts
+var CapabilityHandlers = class {
+	constructor(state) {
+		this.state = state;
+	}
+	async handleBinaryInstrumentCapabilities() {
+		const fridaAvailability = await this.getFridaSession().getAvailability();
+		const ghidraAvailability = await this.getGhidraAnalyzer().getAvailability();
+		const unidbgAvailability = await getUnidbgAvailability();
+		return jsonResponse(capabilityReport("binary_instrument_capabilities", [
+			{
+				capability: "frida_cli",
+				status: fridaAvailability.available ? "available" : "unavailable",
+				reason: fridaAvailability.reason,
+				fix: fridaAvailability.available ? void 0 : "Install frida-tools and ensure the frida CLI is on PATH.",
+				details: {
+					tools: [
+						"frida_attach",
+						"frida_enumerate_modules",
+						"frida_run_script",
+						"frida_enumerate_functions",
+						"frida_find_symbols"
+					],
+					...fridaAvailability.path ? { path: fridaAvailability.path } : {},
+					...fridaAvailability.version ? { version: fridaAvailability.version } : {}
+				}
+			},
+			{
+				capability: "plugin_frida_bridge",
+				...getLegacyPluginStatus(this.state.context, "plugin_frida_bridge"),
+				details: { tools: [
+					"frida_attach",
+					"frida_detach",
+					"frida_list_sessions"
+				] }
+			},
+			{
+				capability: "ghidra_headless",
+				status: ghidraAvailability.available ? "available" : "unavailable",
+				reason: ghidraAvailability.reason,
+				fix: ghidraAvailability.available ? void 0 : "Install Ghidra and ensure analyzeHeadless is on PATH.",
+				details: {
+					tools: ["ghidra_analyze"],
+					...ghidraAvailability.path ? { path: ghidraAvailability.path } : {},
+					...ghidraAvailability.version ? { version: ghidraAvailability.version } : {}
+				}
+			},
+			{
+				capability: "plugin_ghidra_bridge",
+				...getLegacyPluginStatus(this.state.context, "plugin_ghidra_bridge"),
+				details: { tools: ["ghidra_decompile"] }
+			},
+			{
+				capability: "plugin_ida_bridge",
+				...getLegacyPluginStatus(this.state.context, "plugin_ida_bridge"),
+				details: { tools: ["ida_decompile"] }
+			},
+			{
+				capability: "plugin_jadx_bridge",
+				...getLegacyPluginStatus(this.state.context, "plugin_jadx_bridge"),
+				details: { tools: ["jadx_decompile"] }
+			},
+			{
+				capability: "unidbg_jar",
+				status: unidbgAvailability.available ? "available" : "unavailable",
+				reason: unidbgAvailability.reason || void 0,
+				fix: unidbgAvailability.available ? void 0 : "Set UNIDBG_JAR to a reachable Unidbg JAR path.",
+				details: {
+					tools: [
+						"unidbg_emulate",
+						"unidbg_launch",
+						"unidbg_call",
+						"unidbg_trace"
+					],
+					command: unidbgAvailability.command,
+					jarPath: unidbgAvailability.jarPath
+				}
+			}
+		]));
+	}
+	getFridaSession() {
+		if (!this.state.fridaSession) this.state.fridaSession = new FridaSession();
+		return this.state.fridaSession;
+	}
+	getGhidraAnalyzer() {
+		if (!this.state.ghidra) this.state.ghidra = new GhidraAnalyzer();
+		return this.state.ghidra;
+	}
+};
+//#endregion
+//#region src/server/domains/binary-instrument/handlers.impl.core.ts
+/**
+* BinaryInstrument domain — composition facade.
+*
+* Frida operations in ./handlers/frida-handlers.ts.
+* Analysis/unidbg/hook operations in ./handlers/analysis-handlers.ts.
+*/
+var BinaryInstrumentHandlers = class {
+	state;
+	frida;
+	analysis;
+	capabilities;
+	constructor(first, second, third) {
+		this.state = {
+			hookCodeGenerator: new HookCodeGenerator(),
+			unidbgRunner: new UnidbgRunner()
+		};
+		if (first instanceof FridaSession) this.state.fridaSession = first;
+		else if (isServerContext(first)) this.state.context = first;
+		if (second) this.state.ghidra = second;
+		if (third) this.state.hookGen = third;
+		this.frida = new FridaHandlers(this.state);
+		this.analysis = new AnalysisHandlers(this.state);
+		this.capabilities = new CapabilityHandlers(this.state);
+	}
+	handleBinaryInstrumentCapabilities() {
+		return this.capabilities.handleBinaryInstrumentCapabilities();
+	}
+	handleFridaAttach(args) {
+		return this.frida.handleFridaAttach(args);
+	}
+	handleFridaEnumerateModules(args) {
+		return this.frida.handleFridaEnumerateModules(args);
+	}
+	handleFridaRunScript(args) {
+		return this.frida.handleFridaRunScript(args);
+	}
+	handleFridaDetach(args) {
+		return this.frida.handleFridaDetach(args);
+	}
+	handleFridaListSessions(args) {
+		return this.frida.handleFridaListSessions(args);
+	}
+	handleFridaGenerateScript(args) {
+		return this.frida.handleFridaGenerateScript(args);
+	}
+	handleFridaEnumerateFunctions(args) {
+		return this.frida.handleFridaEnumerateFunctions(args);
+	}
+	handleFridaFindSymbols(args) {
+		return this.frida.handleFridaFindSymbols(args);
+	}
+	handleGhidraAnalyze(args) {
+		return this.analysis.handleGhidraAnalyze(args);
+	}
+	handleGhidraDecompile(args) {
+		return this.analysis.handleGhidraDecompile(args);
+	}
+	handleIdaDecompile(args) {
+		return this.analysis.handleIdaDecompile(args);
+	}
+	handleJadxDecompile(args) {
+		return this.analysis.handleJadxDecompile(args);
+	}
+	handleGenerateHooks(args) {
+		return this.analysis.handleGenerateHooks(args);
+	}
+	handleExportHookScript(args) {
+		return this.analysis.handleExportHookScript(args);
+	}
+	handleUnidbgEmulate(args) {
+		return this.analysis.handleUnidbgEmulate(args);
+	}
+	handleUnidbgLaunch(args) {
+		return this.analysis.handleUnidbgLaunch(args);
+	}
+	handleUnidbgCall(args) {
+		return this.analysis.handleUnidbgCall(args);
+	}
+	handleUnidbgTrace(args) {
+		return this.analysis.handleUnidbgTrace(args);
+	}
+	handleGetAvailablePlugins(args) {
+		return this.analysis.handleGetAvailablePlugins(args);
+	}
+};
+//#endregion
+export { BinaryInstrumentHandlers };