@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/proxy-r8YN6nP1.mjs

@@ -0,0 +1,192 @@
+import { a as argString, r as argNumber, s as argStringRequired, t as argBool } from "./parse-args-B4cY5Vx5.mjs";
+import { t as R } from "./ResponseBuilder-CJXWmWNw.mjs";
+import "./definitions-j9KdHVNR.mjs";
+import * as fs from "fs";
+import * as path$1 from "path";
+//#region src/server/domains/proxy/handlers.impl.ts
+const ResponseBuilder = {
+	success: (data) => R.ok().merge(data).json(),
+	error: (msg) => R.fail(msg).mcpError().json()
+};
+function compileUrlPattern(urlPattern) {
+	const trimmed = urlPattern.trim();
+	const regexLiteral = /^\/(.+)\/([a-z]*)$/.exec(trimmed);
+	if (regexLiteral && regexLiteral[1] !== void 0) {
+		const source = regexLiteral[1];
+		const flags = regexLiteral[2] ?? "";
+		return new RegExp(source, flags);
+	}
+	return new RegExp(trimmed);
+}
+var ProxyHandlers = class {
+	server = null;
+	caPathDir;
+	currentPort = null;
+	captureBuffer = [];
+	mockttpModule = null;
+	constructor() {
+		const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+		this.caPathDir = path$1.join(home, ".jshookmcp", "ca");
+		fs.mkdirSync(this.caPathDir, { recursive: true });
+	}
+	async handleProxyStart(args) {
+		const port = argNumber(args, "port") || 8080;
+		const useHttps = argBool(args, "useHttps") ?? true;
+		if (this.server) return ResponseBuilder.error(`Proxy is already running on port ${this.currentPort}`);
+		try {
+			const mockttp = this.mockttpModule ?? await import("mockttp");
+			this.mockttpModule = mockttp;
+			if (useHttps) {
+				const keyPath = path$1.join(this.caPathDir, "ca.key");
+				const certPath = path$1.join(this.caPathDir, "ca.pem");
+				if (!fs.existsSync(keyPath) || !fs.existsSync(certPath)) {
+					console.log("[Proxy] generating new CA certificates...");
+					const ca = await mockttp.generateCACertificate();
+					fs.writeFileSync(keyPath, ca.key);
+					fs.writeFileSync(certPath, ca.cert);
+				}
+				this.server = mockttp.getLocal({
+					https: {
+						keyPath,
+						certPath
+					},
+					cors: true
+				});
+			} else this.server = mockttp.getLocal();
+			this.server.on("request", (req) => {
+				this.captureBuffer.push({
+					type: "request",
+					id: req.id,
+					method: req.method,
+					url: req.url,
+					headers: req.headers,
+					timestamp: Date.now()
+				});
+				if (this.captureBuffer.length > 5e3) this.captureBuffer.shift();
+			});
+			this.server.on("response", (res) => {
+				this.captureBuffer.push({
+					type: "response",
+					id: res.id,
+					status: res.statusCode,
+					headers: res.headers,
+					timestamp: Date.now()
+				});
+			});
+			await this.server.start(port);
+			this.currentPort = port;
+			return ResponseBuilder.success({
+				message: `Proxy started.`,
+				port: this.currentPort,
+				caCertPath: useHttps ? path$1.join(this.caPathDir, "ca.pem") : null
+			});
+		} catch (e) {
+			this.server = null;
+			return ResponseBuilder.error(`Failed to start proxy: ${e.message}`);
+		}
+	}
+	async handleProxyStop(_args) {
+		if (!this.server) return ResponseBuilder.error("Proxy is not running.");
+		await this.server.stop();
+		this.server = null;
+		this.currentPort = null;
+		return ResponseBuilder.success({ message: "Proxy stopped successfully" });
+	}
+	async handleProxyStatus(_args) {
+		return ResponseBuilder.success({
+			running: !!this.server,
+			port: this.currentPort,
+			caDir: this.caPathDir,
+			caCertPath: path$1.join(this.caPathDir, "ca.pem")
+		});
+	}
+	async handleProxyExportCa(_args) {
+		const certPath = path$1.join(this.caPathDir, "ca.pem");
+		if (!fs.existsSync(certPath)) return ResponseBuilder.error("CA certificate not found. Start the proxy with HTTPS enabled first.");
+		const certContent = fs.readFileSync(certPath, "utf8");
+		return ResponseBuilder.success({
+			path: certPath,
+			content: certContent
+		});
+	}
+	async handleProxyAddRule(args) {
+		if (!this.server) return ResponseBuilder.error("Proxy must be running to add rules.");
+		const action = argStringRequired(args, "action");
+		const method = (argString(args, "method") || "GET").toUpperCase();
+		const urlPattern = argString(args, "urlPattern") || ".*";
+		try {
+			const matcher = compileUrlPattern(urlPattern);
+			let builder;
+			if (method === "GET") builder = this.server.forGet(matcher);
+			else if (method === "POST") builder = this.server.forPost(matcher);
+			else if (method === "PUT") builder = this.server.forPut(matcher);
+			else if (method === "DELETE") builder = this.server.forDelete(matcher);
+			else builder = this.server.forAnyRequest();
+			let endpoint;
+			if (action === "forward") endpoint = await builder.thenPassThrough();
+			else if (action === "block") endpoint = await builder.thenCloseConnection();
+			else if (action === "mock_response") {
+				const mockStatus = argNumber(args, "mockStatus") || 200;
+				const mockBody = argString(args, "mockBody") || "";
+				endpoint = await builder.thenReply(mockStatus, mockBody);
+			} else return ResponseBuilder.error(`Unknown action: ${action}`);
+			return ResponseBuilder.success({
+				message: "Rule added successfully",
+				endpointId: endpoint.id
+			});
+		} catch (e) {
+			return ResponseBuilder.error(`Failed to add rule: ${e.message}`);
+		}
+	}
+	async handleProxyGetRequests(args) {
+		const urlFilter = argString(args, "urlFilter");
+		let results = this.captureBuffer;
+		if (urlFilter) results = results.filter((r) => r.url && r.url.includes(urlFilter));
+		return ResponseBuilder.success({
+			count: results.length,
+			logs: results.slice(-100)
+		});
+	}
+	async handleProxyClearLogs(_args) {
+		this.captureBuffer = [];
+		return ResponseBuilder.success({ message: "Captured proxy logs cleared." });
+	}
+	async handleProxySetupAdbDevice(args) {
+		const port = this.currentPort;
+		if (!port) return ResponseBuilder.error("Proxy must be running locally to setup ADB device reverse tethering.");
+		const certPath = path$1.join(this.caPathDir, "ca.pem");
+		if (!fs.existsSync(certPath)) return ResponseBuilder.error("CA certificate not found. Start the proxy with HTTPS enabled first.");
+		const { exec } = await import("child_process");
+		const { promisify } = await import("util");
+		const execAsync = promisify(exec);
+		const deviceSerial = argString(args, "deviceSerial");
+		const deviceFlag = deviceSerial ? `-s ${deviceSerial}` : "";
+		try {
+			try {
+				await execAsync("adb version");
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return R.fail(`ADB binary not available: ${message}`).merge({
+					available: false,
+					capability: "adb_binary",
+					status: "unavailable",
+					fix: "Install Android Platform Tools and ensure `adb` is available on PATH."
+				}).json();
+			}
+			await execAsync(`adb ${deviceFlag} get-state`);
+			await execAsync(`adb ${deviceFlag} push "${certPath}" /data/local/tmp/ca.pem`);
+			await execAsync(`adb ${deviceFlag} reverse tcp:${port} tcp:${port}`);
+			await execAsync(`adb ${deviceFlag} shell settings put global http_proxy 127.0.0.1:${port}`);
+			const instructions = `ADB Configuration Applied Automatically:\n- Verified device connection.\n- Pushed CA to /data/local/tmp/ca.pem\n- Reversed forwarded tcp:${port} -> tcp:${port}\n- Set global http_proxy to 127.0.0.1:${port}\n\nNote: For HTTPS decryption, you still need to manually install the CA cert from /data/local/tmp/ca.pem in Android Settings (due to security restrictions) unless device is rooted.`;
+			return ResponseBuilder.success({
+				message: "ADB device successfully configured.",
+				deviceId: deviceSerial || "default",
+				instructions
+			});
+		} catch (e) {
+			return ResponseBuilder.error(`Failed to configure ADB device: ${e.message}`);
+		}
+	}
+};
+//#endregion
+export { ProxyHandlers };

package/dist/registry-Bl8ZQW61.mjs

@@ -0,0 +1,34 @@
+import { n as DOMInspector, r as CodeCollector, t as ScriptManager } from "./ScriptManager-ZuWD-0Jg.mjs";
+import { t as PageController } from "./PageController-BPJNqqBN.mjs";
+//#region src/server/registry/types.ts
+/**
+* Helper: create a name-based lookup from a Tool array.
+* Throws at module load time if a tool name is missing — acts as a build-time guard.
+*/
+function toolLookup(tools) {
+	const map = new Map(tools.map((t) => [t.name, t]));
+	return (name) => {
+		const tool = map.get(name);
+		if (!tool) throw new Error(`[registry] Tool definition not found: "${name}"`);
+		return tool;
+	};
+}
+//#endregion
+//#region src/server/registry/ensure-browser-core.ts
+let ConsoleMonitorClass = null;
+async function getConsoleMonitorClass() {
+	if (!ConsoleMonitorClass) ConsoleMonitorClass = (await import("./ConsoleMonitor-DykL3IAw.mjs").then((n) => n.t)).ConsoleMonitor;
+	return ConsoleMonitorClass;
+}
+async function ensureBrowserCore(ctx) {
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.pageController) ctx.pageController = new PageController(ctx.collector);
+	if (!ctx.domInspector) ctx.domInspector = new DOMInspector(ctx.collector);
+	if (!ctx.scriptManager) ctx.scriptManager = new ScriptManager(ctx.collector);
+	if (!ctx.consoleMonitor) ctx.consoleMonitor = new (await (getConsoleMonitorClass()))(ctx.collector);
+}
+//#endregion
+export { toolLookup as n, ensureBrowserCore as t };

package/dist/response-CWhh2aLo.mjs

@@ -0,0 +1,34 @@
+//#region src/server/domains/shared/response.ts
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function asTextResponse(text, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function asJsonResponse(payload) {
+	return asTextResponse(JSON.stringify(payload, null, 2));
+}
+function isToolResponse(value) {
+	return value !== null && typeof value === "object" && Array.isArray(value.content);
+}
+function asToolResponse(payload) {
+	return isToolResponse(payload) ? payload : asJsonResponse(payload);
+}
+function asErrorResponse(error) {
+	return asTextResponse(`Error: ${toErrorMessage(error)}`, true);
+}
+function serializeError(error) {
+	return {
+		success: false,
+		error: toErrorMessage(error)
+	};
+}
+//#endregion
+export { serializeError as a, asToolResponse as i, asJsonResponse as n, asTextResponse as r, asErrorResponse as t };

package/dist/server/plugin-api.mjs

@@ -1,10 +1,10 @@
-import "node:fs/promises";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import "node:fs/promises";
 import dotenv from "dotenv";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { existsSync } from "node:fs";
 //#region src/server/extensions/plugin-config.ts
 function normalizeSegment(value) {
 	return value.trim().replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();