@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/mojo-ipc-B_H61Afw.mjs

@@ -1,525 +0,0 @@
-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 };