@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/handlers-Dl5a7JS4.mjs

@@ -0,0 +1,572 @@
+import { c as ADB_WEBVIEW_HTTP_TIMEOUT_MS, l as ADB_WEBVIEW_WS_TIMEOUT_MS, o as ADB_DEFAULT_TIMEOUT_MS, s as ADB_SHELL_TIMEOUT_MS } from "./constants-CDZLOoVv.mjs";
+import { n as asJsonResponse } from "./response-CWhh2aLo.mjs";
+import { t as ToolError } from "./ToolError-jh9whhMd.mjs";
+import { r as argNumber, s as argStringRequired } from "./parse-args-B4cY5Vx5.mjs";
+import { access } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createServer } from "node:net";
+//#region src/modules/adb/ADBClient.ts
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = ADB_DEFAULT_TIMEOUT_MS;
+const DEFAULT_NETWORK_PORT = 5555;
+const EXEC_OPTIONS = {
+	encoding: "utf8",
+	maxBuffer: 16 * 1024 * 1024,
+	windowsHide: true
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function getStringValue$1(value) {
+	return typeof value === "string" ? value : null;
+}
+function getErrorMessage$1(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function getErrorOutput(error) {
+	if (!isRecord$1(error)) return "";
+	const stdout = getStringValue$1(error.stdout);
+	return [getStringValue$1(error.stderr), stdout].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+}
+function getErrorCode(error) {
+	if (!isRecord$1(error)) return null;
+	return getStringValue$1(error.code);
+}
+function readCapture$1(match, index) {
+	if (!match) return null;
+	const value = match[index];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseVersionFromOutput(output) {
+	const webViewPackageVersion = readCapture$1(output.match(/Current WebView package.*\(([^()]+)\)/i), 1) ?? readCapture$1(output.match(/versionName=([^\s]+)/i), 1);
+	if (webViewPackageVersion) return webViewPackageVersion.trim();
+	return null;
+}
+var ADBClient = class {
+	connectedTarget = null;
+	async ensureLocalFileExists(filePath) {
+		try {
+			await access(filePath);
+		} catch (error) {
+			throw new ToolError("NOT_FOUND", `Local file not found: ${filePath}`, {
+				toolName: "adb-bridge",
+				details: {
+					filePath,
+					reason: getErrorMessage$1(error)
+				}
+			});
+		}
+	}
+	normalizeError(args, error) {
+		if (error instanceof ToolError) return error;
+		if (getErrorCode(error) === "ENOENT") return new ToolError("PREREQUISITE", "ADB binary not found in PATH. Install Android Platform Tools and ensure `adb` is available.", { toolName: "adb-bridge" });
+		const output = getErrorOutput(error).trim();
+		const message = output.length > 0 ? output : getErrorMessage$1(error);
+		const lower = message.toLowerCase();
+		if (lower.includes("device not found") || lower.includes("no devices/emulators found") || lower.includes("device offline") || lower.includes("device unauthorized")) return new ToolError("NOT_FOUND", message, {
+			toolName: "adb-bridge",
+			details: { command: ["adb", ...args].join(" ") }
+		});
+		if (lower.includes("failed to connect") || lower.includes("unable to connect")) return new ToolError("CONNECTION", message, {
+			toolName: "adb-bridge",
+			details: { command: ["adb", ...args].join(" ") }
+		});
+		return new ToolError("RUNTIME", message, {
+			toolName: "adb-bridge",
+			details: { command: ["adb", ...args].join(" ") }
+		});
+	}
+	async runAdb(args, timeout = DEFAULT_TIMEOUT_MS) {
+		try {
+			const { stdout } = await execFileAsync(process.env["ADB_PATH"] ?? "adb", args, {
+				...EXEC_OPTIONS,
+				timeout
+			});
+			return stdout;
+		} catch (error) {
+			throw this.normalizeError(args, error);
+		}
+	}
+	async connect(host, port) {
+		if (typeof host === "string" && host.trim().length > 0) {
+			const target = `${host.trim()}:${port ?? DEFAULT_NETWORK_PORT}`;
+			const output = await this.runAdb(["connect", target]);
+			if (/(failed|unable)/i.test(output)) throw new ToolError("CONNECTION", output.trim(), {
+				toolName: "adb-bridge",
+				details: { target }
+			});
+			this.connectedTarget = target;
+			return;
+		}
+		await this.runAdb(["start-server"]);
+		this.connectedTarget = null;
+	}
+	async disconnect() {
+		if (this.connectedTarget) {
+			await this.runAdb(["disconnect", this.connectedTarget]);
+			this.connectedTarget = null;
+			return;
+		}
+		await this.runAdb(["disconnect"]);
+	}
+	async listDevices() {
+		const output = await this.runAdb(["devices", "-l"]);
+		const devices = [];
+		for (const rawLine of output.split(/\r?\n/)) {
+			const line = rawLine.trim();
+			if (line.length === 0 || line.startsWith("List of devices attached") || line.startsWith("*")) continue;
+			const parts = line.split(/\s+/);
+			const id = parts[0];
+			const state = parts[1];
+			if (typeof id !== "string" || typeof state !== "string" || state !== "device") continue;
+			let product = "";
+			let model = "";
+			let transport = "";
+			for (const part of parts.slice(2)) {
+				const [key, value] = part.split(":", 2);
+				if (typeof key !== "string" || typeof value !== "string") continue;
+				if (key === "product") product = value;
+				else if (key === "model") model = value;
+				else if (key === "transport_id" || key === "transport" || key === "usb") transport = value;
+			}
+			devices.push({
+				id,
+				type: id.startsWith("emulator-") ? "emulator" : "device",
+				product,
+				model,
+				transport
+			});
+		}
+		return devices;
+	}
+	async shell(deviceId, command) {
+		return (await this.runAdb([
+			"-s",
+			deviceId,
+			"shell",
+			command
+		], ADB_SHELL_TIMEOUT_MS)).replace(/\r?\n$/, "");
+	}
+	async reverse(deviceId, local, remote) {
+		await this.runAdb([
+			"-s",
+			deviceId,
+			"reverse",
+			local,
+			remote
+		]);
+	}
+	async install(deviceId, apkPath) {
+		await this.ensureLocalFileExists(apkPath);
+		await this.runAdb([
+			"-s",
+			deviceId,
+			"install",
+			"-r",
+			apkPath
+		], 18e4);
+	}
+	async pull(deviceId, remotePath, localPath) {
+		await this.runAdb([
+			"-s",
+			deviceId,
+			"pull",
+			remotePath,
+			localPath
+		], 18e4);
+	}
+	async push(deviceId, localPath, remotePath) {
+		await this.ensureLocalFileExists(localPath);
+		await this.runAdb([
+			"-s",
+			deviceId,
+			"push",
+			localPath,
+			remotePath
+		], 18e4);
+	}
+	async forward(deviceId, local, remote) {
+		await this.runAdb([
+			"-s",
+			deviceId,
+			"forward",
+			local,
+			remote
+		]);
+	}
+	async getWebViewVersion(deviceId) {
+		for (const command of [
+			"cmd webviewupdate getCurrentWebViewPackage",
+			"dumpsys webviewupdate",
+			"dumpsys package com.google.android.webview",
+			"dumpsys package com.android.webview",
+			"dumpsys package com.android.chrome"
+		]) try {
+			const version = parseVersionFromOutput(await this.shell(deviceId, command));
+			if (version) return version;
+		} catch {
+			continue;
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/modules/adb/WebViewDebugger.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function getStringValue(value) {
+	return typeof value === "string" ? value : null;
+}
+function readCapture(match, index) {
+	if (!match) return null;
+	const value = match[index];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isDevToolsTargetInfo(value) {
+	if (!isRecord(value)) return false;
+	return typeof value.id === "string" && typeof value.title === "string" && typeof value.url === "string";
+}
+function normalizeSocketName(socketName) {
+	return socketName.startsWith("@") ? socketName.slice(1) : socketName;
+}
+var WebViewDebugger = class {
+	forwardedPorts = /* @__PURE__ */ new Map();
+	constructor(adbClient = new ADBClient()) {
+		this.adbClient = adbClient;
+	}
+	getPortKey(deviceId, webviewId) {
+		return `${deviceId}:${webviewId}`;
+	}
+	async getFreePort() {
+		return new Promise((resolve, reject) => {
+			const server = createServer();
+			server.once("error", reject);
+			server.listen(0, "127.0.0.1", () => {
+				const address = server.address();
+				if (!address || typeof address === "string") {
+					server.close();
+					reject(new ToolError("RUNTIME", "Failed to allocate a local TCP port for WebView debugging."));
+					return;
+				}
+				const { port } = address;
+				server.close((error) => {
+					if (error) {
+						reject(error);
+						return;
+					}
+					resolve(port);
+				});
+			});
+		});
+	}
+	async discoverSockets(deviceId) {
+		const unixSockets = await this.adbClient.shell(deviceId, "cat /proc/net/unix");
+		const sockets = /* @__PURE__ */ new Set();
+		for (const line of unixSockets.split(/\r?\n/)) {
+			const socketName = readCapture(line.match(/(@[^\s]*devtools_remote[^\s]*)$/), 1);
+			if (!socketName) continue;
+			const normalized = normalizeSocketName(socketName);
+			if (normalized === "chrome_devtools_remote") continue;
+			sockets.add(normalized);
+		}
+		return [...sockets];
+	}
+	async ensureForward(deviceId, webviewId) {
+		const key = this.getPortKey(deviceId, webviewId);
+		const existingPort = this.forwardedPorts.get(key);
+		if (typeof existingPort === "number") return existingPort;
+		const port = await this.getFreePort();
+		await this.adbClient.forward(deviceId, `tcp:${port}`, `localabstract:${webviewId}`);
+		this.forwardedPorts.set(key, port);
+		return port;
+	}
+	async fetchTargets(port) {
+		const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(ADB_WEBVIEW_HTTP_TIMEOUT_MS) });
+		if (!response.ok) throw new ToolError("CONNECTION", `Failed to fetch WebView target list on forwarded port ${port}.`, {
+			toolName: "adb_webview",
+			details: { status: response.status }
+		});
+		const payload = await response.json();
+		if (!Array.isArray(payload)) throw new ToolError("RUNTIME", "Unexpected WebView target payload. Expected an array response.", { toolName: "adb_webview" });
+		return payload.filter(isDevToolsTargetInfo);
+	}
+	async resolveProcessId(deviceId, webviewId) {
+		const embeddedPid = readCapture(webviewId.match(/(?:webview_)?devtools_remote_(\d+)/), 1);
+		if (embeddedPid) {
+			const parsed = Number.parseInt(embeddedPid, 10);
+			if (!Number.isNaN(parsed)) return parsed;
+		}
+		const packageName = readCapture(webviewId.match(/^(.*)_devtools_remote$/), 1);
+		if (!packageName) return 0;
+		try {
+			const pidValue = (await this.adbClient.shell(deviceId, `pidof -s ${packageName}`)).split(/\s+/)[0];
+			if (typeof pidValue !== "string") return 0;
+			const parsed = Number.parseInt(pidValue, 10);
+			return Number.isNaN(parsed) ? 0 : parsed;
+		} catch {
+			return 0;
+		}
+	}
+	async getPrimaryTarget(deviceId, webviewId) {
+		const port = await this.ensureForward(deviceId, webviewId);
+		const targets = await this.fetchTargets(port);
+		const primaryTarget = targets.find((target) => target.type === "page") ?? targets[0];
+		if (!primaryTarget) throw new ToolError("NOT_FOUND", `No debuggable targets found for WebView ${webviewId}.`, {
+			toolName: "adb_webview",
+			details: {
+				deviceId,
+				webviewId
+			}
+		});
+		return primaryTarget;
+	}
+	async evaluateViaCdp(wsUrl, script) {
+		const WebSocketClass = globalThis.WebSocket;
+		if (!WebSocketClass) throw new ToolError("PREREQUISITE", "WebSocket API is not available in this Node runtime. Use Node.js 22+ to debug Android WebViews.", { toolName: "adb_webview" });
+		return new Promise((resolve, reject) => {
+			const socket = new WebSocketClass(wsUrl);
+			const timeout = setTimeout(() => {
+				socket.close();
+				reject(new ToolError("TIMEOUT", "Timed out while evaluating script inside the Android WebView.", { toolName: "adb_webview" }));
+			}, ADB_WEBVIEW_WS_TIMEOUT_MS);
+			const finish = (callback) => {
+				clearTimeout(timeout);
+				callback();
+				socket.close();
+			};
+			socket.addEventListener("open", () => {
+				socket.send(JSON.stringify({
+					id: 1,
+					method: "Runtime.evaluate",
+					params: {
+						expression: script,
+						returnByValue: true,
+						awaitPromise: true
+					}
+				}));
+			});
+			socket.addEventListener("message", (event) => {
+				let payload;
+				try {
+					payload = JSON.parse(String(event.data));
+				} catch (error) {
+					finish(() => {
+						reject(new ToolError("RUNTIME", `Failed to parse WebView CDP response: ${String(error)}`, { toolName: "adb_webview" }));
+					});
+					return;
+				}
+				if (!isRecord(payload) || payload.id !== 1) return;
+				if (isRecord(payload.error)) {
+					const message = getStringValue(payload.error.message) ?? "Unknown CDP error";
+					finish(() => {
+						reject(new ToolError("RUNTIME", message, { toolName: "adb_webview" }));
+					});
+					return;
+				}
+				if (!isRecord(payload.result)) {
+					finish(() => {
+						resolve(null);
+					});
+					return;
+				}
+				if (isRecord(payload.result.exceptionDetails)) {
+					const text = getStringValue(payload.result.exceptionDetails.text) ?? getStringValue(payload.result.exceptionDetails.description) ?? "Script execution failed inside the Android WebView.";
+					finish(() => {
+						reject(new ToolError("RUNTIME", text, { toolName: "adb_webview" }));
+					});
+					return;
+				}
+				if (!isRecord(payload.result.result)) {
+					finish(() => {
+						resolve(null);
+					});
+					return;
+				}
+				const runtimeResult = payload.result.result;
+				if ("value" in runtimeResult) {
+					finish(() => {
+						resolve(runtimeResult.value);
+					});
+					return;
+				}
+				const description = getStringValue(runtimeResult.description);
+				finish(() => {
+					resolve(description);
+				});
+			});
+			socket.addEventListener("error", () => {
+				finish(() => {
+					reject(new ToolError("CONNECTION", "WebView DevTools socket reported an error while executing script.", { toolName: "adb_webview" }));
+				});
+			});
+		});
+	}
+	async listWebViews(deviceId) {
+		const sockets = await this.discoverSockets(deviceId);
+		const webviews = [];
+		for (const socketName of sockets) try {
+			const target = await this.getPrimaryTarget(deviceId, socketName);
+			webviews.push({
+				id: socketName,
+				url: target.url,
+				title: target.title,
+				processId: await this.resolveProcessId(deviceId, socketName)
+			});
+		} catch {
+			webviews.push({
+				id: socketName,
+				url: "",
+				title: "",
+				processId: await this.resolveProcessId(deviceId, socketName)
+			});
+		}
+		return webviews;
+	}
+	async attachWebView(deviceId, webviewId) {
+		if (!(await this.discoverSockets(deviceId)).includes(webviewId)) throw new ToolError("NOT_FOUND", `WebView ${webviewId} was not found on device ${deviceId}.`, { toolName: "adb_webview" });
+		await this.getPrimaryTarget(deviceId, webviewId);
+	}
+	async executeScript(deviceId, webviewId, script) {
+		await this.attachWebView(deviceId, webviewId);
+		const target = await this.getPrimaryTarget(deviceId, webviewId);
+		if (typeof target.webSocketDebuggerUrl !== "string" || target.webSocketDebuggerUrl.length === 0) throw new ToolError("CONNECTION", `WebView ${webviewId} does not expose a WebSocket debugger endpoint.`, { toolName: "adb_webview" });
+		return this.evaluateViaCdp(target.webSocketDebuggerUrl, script);
+	}
+};
+//#endregion
+//#region src/server/domains/adb-bridge/handlers.impl.ts
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+var ADBBridgeHandlers = class {
+	adbClient;
+	webviewDbg;
+	constructor(adbClient, webviewDbg) {
+		this.adbClient = adbClient;
+		this.webviewDbg = webviewDbg;
+	}
+	getADBClient() {
+		if (!this.adbClient) this.adbClient = new ADBClient();
+		return this.adbClient;
+	}
+	getWebViewDebugger() {
+		if (!this.webviewDbg) this.webviewDbg = new WebViewDebugger(this.getADBClient());
+		return this.webviewDbg;
+	}
+	async run(_toolName, action) {
+		try {
+			return asJsonResponse(await action());
+		} catch (error) {
+			if (error instanceof ToolError) throw error;
+			throw new ToolError("RUNTIME", getErrorMessage(error), { toolName: _toolName });
+		}
+	}
+	async handleAnalyzeApk(args) {
+		return this.run("adb_apk_analyze", async () => {
+			const serial = argStringRequired(args, "serial");
+			const packageName = argStringRequired(args, "packageName");
+			const output = await this.getADBClient().shell(serial, `dumpsys package ${packageName}`);
+			const info = { packageName };
+			const versionNameMatch = output.match(/versionName=([^\s]+)/);
+			if (versionNameMatch) info.versionName = versionNameMatch[1];
+			const versionCodeMatch = output.match(/versionCode=(\d+)/);
+			if (versionCodeMatch) info.versionCode = versionCodeMatch[1];
+			const minSdkMatch = output.match(/minSdk=(\d+)/);
+			if (minSdkMatch) info.minSdk = minSdkMatch[1];
+			const targetSdkMatch = output.match(/targetSdk=(\d+)/);
+			if (targetSdkMatch) info.targetSdk = targetSdkMatch[1];
+			const permissions = [];
+			const activities = [];
+			const services = [];
+			const receivers = [];
+			let currentSection = "";
+			for (const line of output.split(/\r?\n/)) {
+				if (line.includes("requested permissions:") || line.includes("install permissions:")) {
+					currentSection = "permissions";
+					continue;
+				}
+				if (line.includes("Activity Resolver Table") || line.includes("activities:")) {
+					currentSection = "activities";
+					continue;
+				}
+				if (line.includes("Service Resolver Table") || line.includes("services:")) {
+					currentSection = "services";
+					continue;
+				}
+				if (line.includes("Receiver Resolver Table") || line.includes("receivers:")) {
+					currentSection = "receivers";
+					continue;
+				}
+				const trimmed = line.trim();
+				if (trimmed.startsWith("android.permission.") || trimmed.startsWith("com.")) {
+					const perm = trimmed.split(" ")[0];
+					if (perm) {
+						if (currentSection === "permissions") permissions.push(perm);
+						else if (!currentSection) permissions.push(perm);
+					}
+				}
+				if (currentSection === "activities" && trimmed.includes(packageName)) {
+					const activityMatch = trimmed.match(/(\S+)/);
+					if (activityMatch) activities.push(activityMatch[1]);
+				}
+				if (currentSection === "services" && trimmed.includes(packageName)) {
+					const serviceMatch = trimmed.match(/(\S+)/);
+					if (serviceMatch) services.push(serviceMatch[1]);
+				}
+				if (currentSection === "receivers" && trimmed.includes(packageName)) {
+					const receiverMatch = trimmed.match(/(\S+)/);
+					if (receiverMatch) receivers.push(receiverMatch[1]);
+				}
+			}
+			info.permissions = [...new Set(permissions)];
+			info.activities = [...new Set(activities)];
+			info.services = [...new Set(services)];
+			info.receivers = [...new Set(receivers)];
+			return {
+				success: true,
+				serial,
+				...info
+			};
+		});
+	}
+	async handleWebViewList(args) {
+		return this.run("adb_webview_list", async () => {
+			const serial = argStringRequired(args, "serial");
+			const hostPort = argNumber(args, "hostPort") ?? 9222;
+			return {
+				success: true,
+				serial,
+				webViewVersion: await this.getADBClient().getWebViewVersion(serial),
+				hostPort,
+				webviews: (await this.getWebViewDebugger().listWebViews(serial)).map((wv) => ({
+					id: wv.id,
+					url: wv.url,
+					title: wv.title,
+					processId: wv.processId
+				}))
+			};
+		});
+	}
+	async handleWebViewAttach(args) {
+		return this.run("adb_webview_attach", async () => {
+			const serial = argStringRequired(args, "serial");
+			const targetId = argStringRequired(args, "targetId");
+			const hostPort = argNumber(args, "hostPort") ?? 9222;
+			await this.getWebViewDebugger().attachWebView(serial, targetId);
+			return {
+				success: true,
+				serial,
+				targetId,
+				hostPort,
+				attached: true,
+				snapshot: await this.getWebViewDebugger().executeScript(serial, targetId, "(() => ({ title: document.title, url: location.href, readyState: document.readyState }))()")
+			};
+		});
+	}
+};
+//#endregion
+export { ADBBridgeHandlers };