@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/mojo-ipc-B_H61Afw.mjs

@@ -0,0 +1,525 @@
+import { n as __require } from "./chunk-CjcI7cDX.mjs";
+import { Ht as MOJO_MONITOR_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { a as argString, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
+import "./manifest-B3QVVeBS.mjs";
+import { execFile, spawn } from "node:child_process";
+//#region src/modules/mojo-ipc/MojoMonitor.ts
+function getDefaultInterfaces() {
+	return [
+		{
+			name: "blink.mojom.WidgetHost",
+			version: 1,
+			pendingMessages: 0
+		},
+		{
+			name: "content.mojom.FrameHost",
+			version: 2,
+			pendingMessages: 0
+		},
+		{
+			name: "network.mojom.URLLoaderFactory",
+			version: 3,
+			pendingMessages: 0
+		}
+	];
+}
+function detectFridaNpmPackage() {
+	try {
+		__require.resolve("frida");
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function probeFridaCli() {
+	return new Promise((resolve) => {
+		const child = spawn("frida", ["--version"], {
+			timeout: MOJO_MONITOR_TIMEOUT_MS,
+			windowsHide: true
+		});
+		let stdout = "";
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.on("close", (code) => {
+			if (code === 0 && stdout.trim().length > 0) {
+				resolve("frida");
+				return;
+			}
+			resolve(null);
+		});
+		child.on("error", () => {
+			resolve(null);
+		});
+	});
+}
+async function detectAvailability() {
+	const flag = process.env["JSHOOK_ENABLE_MOJO_IPC"];
+	const fridaNpm = detectFridaNpmPackage();
+	const fridaCli = await probeFridaCli();
+	const fridaAvailable = fridaNpm || fridaCli !== null;
+	if (flag === "0" || flag === "false") return {
+		available: false,
+		fridaAvailable,
+		fridaCliAvailable: fridaCli !== null,
+		reason: "Mojo IPC disabled by JSHOOK_ENABLE_MOJO_IPC=0."
+	};
+	return {
+		available: fridaAvailable,
+		fridaAvailable,
+		fridaCliAvailable: fridaCli !== null,
+		reason: fridaAvailable ? void 0 : "Mojo IPC backend is not connected. Install Frida for real IPC monitoring: https://frida.re/docs/installation/"
+	};
+}
+function matchesFilter(message, filter) {
+	if (filter.interfaceName && message.interfaceName !== filter.interfaceName) return false;
+	if (filter.messageType && message.messageType !== filter.messageType) return false;
+	if (typeof filter.pid === "number" && message.sourcePid !== filter.pid && message.targetPid !== filter.pid) return false;
+	return true;
+}
+function buildFridaScript() {
+	return `
+const messages = [];
+recv('message', () => {});
+rpc.exports = {
+  flush() {
+    return messages;
+  },
+};
+`;
+}
+var MojoMonitor = class {
+	active = false;
+	simulationMode = false;
+	deviceId;
+	messages = [];
+	interfaces = /* @__PURE__ */ new Map();
+	availability = {
+		available: false,
+		fridaAvailable: false,
+		fridaCliAvailable: false,
+		reason: "Not yet initialized. Call start() to probe availability."
+	};
+	constructor() {
+		for (const item of getDefaultInterfaces()) this.interfaces.set(item.name, { ...item });
+	}
+	isAvailable() {
+		return this.availability.available;
+	}
+	getUnavailableReason() {
+		return this.availability.reason;
+	}
+	isSimulationMode() {
+		return this.simulationMode;
+	}
+	setSimulationMode(enabled) {
+		this.simulationMode = enabled;
+	}
+	isActive() {
+		return this.active;
+	}
+	getDeviceId() {
+		return this.deviceId;
+	}
+	async start(deviceId) {
+		this.deviceId = deviceId;
+		this.availability = await detectAvailability();
+		if (!this.availability.available) {
+			this.active = false;
+			return;
+		}
+		this.active = true;
+		this.resetPendingCounts();
+		if (this.availability.fridaCliAvailable) await this.captureWithFrida(deviceId);
+		else this.simulationMode = true;
+	}
+	async stop() {
+		this.active = false;
+		this.deviceId = void 0;
+		this.messages.length = 0;
+		this.resetPendingCounts();
+	}
+	async captureMessages(filter = {}) {
+		if (!this.active) return [];
+		const captured = [];
+		const remaining = [];
+		for (const message of this.messages) if (matchesFilter(message, filter)) captured.push({ ...message });
+		else remaining.push(message);
+		this.messages.length = 0;
+		this.messages.push(...remaining);
+		this.recomputePendingCounts();
+		return captured;
+	}
+	async listInterfaces() {
+		return [...this.interfaces.values()].map((item) => ({
+			name: item.name,
+			version: item.version,
+			pendingMessages: item.pendingMessages
+		})).toSorted((left, right) => left.name.localeCompare(right.name));
+	}
+	async getMessages(options) {
+		if (!this.active) return {
+			messages: [],
+			totalAvailable: 0,
+			filtered: false,
+			_simulation: this.simulationMode
+		};
+		const filter = {};
+		if (options?.interfaceName) filter.interfaceName = options.interfaceName;
+		const allMessages = await this.captureMessages(filter);
+		const limit = options?.limit ?? 100;
+		return {
+			messages: allMessages.slice(0, limit),
+			totalAvailable: allMessages.length,
+			filtered: !!options?.interfaceName,
+			_simulation: this.simulationMode
+		};
+	}
+	recordMessage(message, version = 1) {
+		if (!this.active) return;
+		this.messages.push({ ...message });
+		const existing = this.interfaces.get(message.interfaceName);
+		if (existing) {
+			existing.pendingMessages += 1;
+			return;
+		}
+		this.interfaces.set(message.interfaceName, {
+			name: message.interfaceName,
+			version,
+			pendingMessages: 1
+		});
+	}
+	async captureWithFrida(deviceId) {
+		const targetProcess = deviceId ?? "chrome";
+		const script = buildFridaScript();
+		await new Promise((resolve, reject) => {
+			execFile("frida", [
+				"-q",
+				"-n",
+				targetProcess,
+				"-l",
+				"-",
+				"--runtime=v8"
+			], {
+				timeout: MOJO_MONITOR_TIMEOUT_MS,
+				windowsHide: true
+			}, (error) => {
+				if (error) {
+					this.simulationMode = true;
+					reject(error);
+					return;
+				}
+				this.simulationMode = false;
+				resolve();
+			}).stdin?.end(script);
+		}).catch(() => {
+			this.simulationMode = true;
+		});
+	}
+	recomputePendingCounts() {
+		this.resetPendingCounts();
+		for (const message of this.messages) {
+			const item = this.interfaces.get(message.interfaceName);
+			if (item) item.pendingMessages += 1;
+			else this.interfaces.set(message.interfaceName, {
+				name: message.interfaceName,
+				version: 1,
+				pendingMessages: 1
+			});
+		}
+	}
+	resetPendingCounts() {
+		for (const item of this.interfaces.values()) item.pendingMessages = 0;
+	}
+};
+//#endregion
+//#region src/modules/mojo-ipc/MojoDecoder.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const FIELD_TYPE_BOOL = 1;
+const FIELD_TYPE_INT32 = 6;
+const FIELD_TYPE_UINT32 = 8;
+const FIELD_TYPE_STRING = 12;
+const FIELD_TYPE_HANDLE = 16;
+function isHandleField(value) {
+	if (!isRecord(value)) return false;
+	return typeof value["handle"] === "number";
+}
+function normalizeHexInput(hex) {
+	const cleaned = hex.replace(/\s+/g, "");
+	if (cleaned.length % 2 === 0) return cleaned.toLowerCase();
+	return `0${cleaned.toLowerCase()}`;
+}
+var MojoDecoder = class {
+	decodePayload(hex, context) {
+		const raw = this.cleanHex(hex);
+		const bytes = Buffer.from(raw, "hex");
+		const version = this.readUInt8(bytes, 0);
+		const flags = this.readUInt8(bytes, 1);
+		const messageType = this.readUInt8(bytes, 2);
+		const numFields = this.readUInt8(bytes, 3);
+		const declaredHandles = this.readUInt16LE(bytes, 4);
+		const fields = {};
+		const summaryParts = [];
+		let cursor = 6;
+		let actualHandles = 0;
+		for (let index = 0; index < numFields; index += 1) {
+			if (cursor >= bytes.length) {
+				summaryParts.push("payload ended before all fields were decoded");
+				break;
+			}
+			const typeCode = this.readUInt8(bytes, cursor);
+			cursor += 1;
+			const fieldName = `field${index}`;
+			if (typeCode === FIELD_TYPE_BOOL) {
+				if (!this.hasBytes(bytes, cursor, 1)) {
+					summaryParts.push(`${fieldName} truncated`);
+					break;
+				}
+				fields[fieldName] = this.readUInt8(bytes, cursor) !== 0;
+				cursor += 1;
+				continue;
+			}
+			if (typeCode === FIELD_TYPE_INT32) {
+				if (!this.hasBytes(bytes, cursor, 4)) {
+					summaryParts.push(`${fieldName} truncated`);
+					break;
+				}
+				fields[fieldName] = bytes.readInt32LE(cursor);
+				cursor += 4;
+				continue;
+			}
+			if (typeCode === FIELD_TYPE_UINT32) {
+				if (!this.hasBytes(bytes, cursor, 4)) {
+					summaryParts.push(`${fieldName} truncated`);
+					break;
+				}
+				fields[fieldName] = bytes.readUInt32LE(cursor);
+				cursor += 4;
+				continue;
+			}
+			if (typeCode === FIELD_TYPE_STRING) {
+				if (!this.hasBytes(bytes, cursor, 2)) {
+					summaryParts.push(`${fieldName} length prefix truncated`);
+					break;
+				}
+				const length = this.readUInt16LE(bytes, cursor);
+				cursor += 2;
+				if (!this.hasBytes(bytes, cursor, length)) {
+					summaryParts.push(`${fieldName} string data truncated`);
+					break;
+				}
+				fields[fieldName] = bytes.subarray(cursor, cursor + length).toString("utf8");
+				cursor += length;
+				continue;
+			}
+			if (typeCode === FIELD_TYPE_HANDLE) {
+				if (!this.hasBytes(bytes, cursor, 4)) {
+					summaryParts.push(`${fieldName} handle truncated`);
+					break;
+				}
+				fields[fieldName] = { handle: bytes.readUInt32LE(cursor) };
+				actualHandles += 1;
+				cursor += 4;
+				continue;
+			}
+			summaryParts.push(`unknown field type 0x${typeCode.toString(16).padStart(2, "0")}`);
+			break;
+		}
+		const summary = summaryParts.length > 0 ? summaryParts.join("; ") : this.buildSummary(context, Object.keys(fields).length, numFields, actualHandles);
+		return {
+			header: {
+				version,
+				flags,
+				messageType,
+				numFields,
+				handles: declaredHandles
+			},
+			fields,
+			handles: actualHandles,
+			raw,
+			_raw_summary: summary
+		};
+	}
+	encodeMessage(interfaceName, messageType, fields) {
+		const encodedParts = [];
+		let handles = 0;
+		for (const field of fields) {
+			if (typeof field === "boolean") {
+				encodedParts.push(Buffer.from([FIELD_TYPE_BOOL, field ? 1 : 0]));
+				continue;
+			}
+			if (typeof field === "number" && Number.isInteger(field) && field >= 0) {
+				const chunk = Buffer.alloc(5);
+				chunk.writeUInt8(FIELD_TYPE_UINT32, 0);
+				chunk.writeUInt32LE(field, 1);
+				encodedParts.push(chunk);
+				continue;
+			}
+			if (typeof field === "number" && Number.isInteger(field)) {
+				const chunk = Buffer.alloc(5);
+				chunk.writeUInt8(FIELD_TYPE_INT32, 0);
+				chunk.writeInt32LE(field, 1);
+				encodedParts.push(chunk);
+				continue;
+			}
+			if (isHandleField(field)) {
+				const chunk = Buffer.alloc(5);
+				chunk.writeUInt8(FIELD_TYPE_HANDLE, 0);
+				chunk.writeUInt32LE(field.handle, 1);
+				encodedParts.push(chunk);
+				handles += 1;
+				continue;
+			}
+			const text = typeof field === "string" ? field : JSON.stringify(field);
+			const textBuffer = Buffer.from(text, "utf8");
+			const header = Buffer.alloc(3);
+			header.writeUInt8(FIELD_TYPE_STRING, 0);
+			header.writeUInt16LE(textBuffer.length, 1);
+			encodedParts.push(header, textBuffer);
+		}
+		const messageTypeCode = this.resolveMessageType(interfaceName, messageType);
+		const fieldCount = Math.min(fields.length, 255);
+		const header = Buffer.alloc(6);
+		header.writeUInt8(1, 0);
+		header.writeUInt8(0, 1);
+		header.writeUInt8(messageTypeCode, 2);
+		header.writeUInt8(fieldCount, 3);
+		header.writeUInt16LE(handles, 4);
+		return Buffer.concat([header, ...encodedParts]).toString("hex");
+	}
+	cleanHex(hex) {
+		return normalizeHexInput(hex);
+	}
+	resolveMessageType(interfaceName, messageType) {
+		if (/^[0-9]+$/.test(messageType)) return Number.parseInt(messageType, 10) & 255;
+		if (/^0x[0-9a-f]+$/i.test(messageType)) return Number.parseInt(messageType.slice(2), 16) & 255;
+		let hash = 0;
+		const seed = `${interfaceName}:${messageType}`;
+		for (const char of seed) hash = hash * 31 + char.charCodeAt(0) & 255;
+		return hash;
+	}
+	buildSummary(context, decodedFields, declaredFields, handles) {
+		return `${context ? `${context}: ` : ""}decoded ${decodedFields}/${declaredFields} fields, ${handles} handle(s)`;
+	}
+	readUInt8(bytes, offset) {
+		if (!this.hasBytes(bytes, offset, 1)) return 0;
+		return bytes.readUInt8(offset);
+	}
+	readUInt16LE(bytes, offset) {
+		if (!this.hasBytes(bytes, offset, 2)) return 0;
+		return bytes.readUInt16LE(offset);
+	}
+	hasBytes(bytes, offset, length) {
+		return offset >= 0 && length >= 0 && offset + length <= bytes.length;
+	}
+};
+//#endregion
+//#region src/server/domains/mojo-ipc/handlers.impl.ts
+function unavailablePayload(reason, action) {
+	return {
+		success: false,
+		available: false,
+		action,
+		error: reason
+	};
+}
+var MojoIPCHandlers = class {
+	constructor(monitor, decoder, eventBus) {
+		this.monitor = monitor;
+		this.decoder = decoder;
+		this.eventBus = eventBus;
+	}
+	async handleMojoMonitorDispatch(args) {
+		return String(args["action"] ?? "") === "stop" ? this.handleMojoMonitorStop() : this.handleMojoMonitorStart(args);
+	}
+	async handleMojoMonitorStart(args) {
+		const monitor = this.getMonitor();
+		if (!monitor.isAvailable()) return unavailablePayload(monitor.getUnavailableReason() ?? "Mojo IPC monitoring is not available", "mojo_monitor");
+		const deviceId = argString(args, "deviceId");
+		await monitor.start(deviceId);
+		return {
+			success: true,
+			available: true,
+			started: monitor.isActive(),
+			deviceId: monitor.getDeviceId() ?? null
+		};
+	}
+	async handleMojoMonitorStop() {
+		const monitor = this.getMonitor();
+		if (!monitor.isAvailable()) return unavailablePayload(monitor.getUnavailableReason() ?? "Mojo IPC monitoring is not available", "mojo_monitor");
+		await monitor.stop();
+		return {
+			success: true,
+			available: true,
+			started: false
+		};
+	}
+	async handleMojoDecodeMessage(args) {
+		const hexPayload = argString(args, "hexPayload", "");
+		if (hexPayload.length === 0) return {
+			success: false,
+			error: "hexPayload is required"
+		};
+		return {
+			success: true,
+			decoded: this.getDecoder().decodePayload(hexPayload)
+		};
+	}
+	async handleMojoListInterfaces() {
+		const monitor = this.getMonitor();
+		if (!monitor.isAvailable()) return {
+			...unavailablePayload(monitor.getUnavailableReason() ?? "Mojo IPC monitoring is not available", "mojo_list_interfaces"),
+			interfaces: []
+		};
+		const interfaces = await monitor.listInterfaces();
+		return {
+			success: true,
+			available: true,
+			active: monitor.isActive(),
+			interfaces
+		};
+	}
+	async handleMojoMessagesGet(args) {
+		const monitor = this.getMonitor();
+		if (!monitor.isAvailable()) return {
+			...unavailablePayload(monitor.getUnavailableReason() ?? "Mojo IPC monitoring is not available", "mojo_messages_get"),
+			messages: [],
+			totalAvailable: 0,
+			filtered: false,
+			_simulation: true
+		};
+		const limit = argNumber(args, "limit");
+		const interfaceName = argString(args, "interface");
+		const result = await monitor.getMessages({
+			limit: limit !== void 0 ? Math.min(limit, 1e4) : 100,
+			interfaceName
+		});
+		const response = {
+			success: true,
+			available: true,
+			active: monitor.isActive(),
+			messages: result.messages,
+			totalAvailable: result.totalAvailable,
+			filtered: result.filtered,
+			_simulation: result._simulation
+		};
+		if (result.messages && Array.isArray(result.messages) && result.messages.length > 0) this.eventBus?.emit("mojo:message_captured", {
+			messageCount: result.messages.length,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		if (monitor.isSimulationMode()) response._warning = "Mojo IPC is operating in simulation mode. Messages are not captured from real Frida hooks. Install Frida for live IPC monitoring.";
+		return response;
+	}
+	getMonitor() {
+		if (!this.monitor) this.monitor = new MojoMonitor();
+		return this.monitor;
+	}
+	getDecoder() {
+		if (!this.decoder) this.decoder = new MojoDecoder();
+		return this.decoder;
+	}
+};
+//#endregion
+export { MojoIPCHandlers };