@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/types-Bx92KJfT.mjs

@@ -0,0 +1,4 @@
+//#region src/server/extensions/types.ts
+const INSTALLED_EXTENSION_METADATA_FILENAME = ".jshook-install.json";
+//#endregion
+export { INSTALLED_EXTENSION_METADATA_FILENAME as t };

package/dist/wasm-DQTnHDs4.mjs

@@ -0,0 +1,531 @@
+import { mr as WASM_TOOL_TIMEOUT_MS, pr as WASM_OPTIMIZE_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { o as ExternalToolRunner } from "./modules-C184v-S9.mjs";
+import { i as resolveArtifactPath } from "./artifacts-Bk2-_uPq.mjs";
+import { a as argString, o as argStringArray, r as argNumber, s as argStringRequired, t as argBool } from "./parse-args-BlRjqlkL.mjs";
+import { t as ToolRegistry } from "./ToolRegistry-BjaF4oNz.mjs";
+import "./definitions-Cy3Sl6gV.mjs";
+import { tmpdir } from "node:os";
+import { createHash } from "node:crypto";
+import { normalize, resolve, sep } from "node:path";
+import { stat, writeFile } from "node:fs/promises";
+//#region src/server/domains/wasm/handlers/shared.ts
+/**
+* Shared types and state for WASM sub-handlers.
+*/
+const isRecord = (value) => typeof value === "object" && value !== null;
+const hasErrorResult = (value) => isRecord(value) && typeof value.error === "string";
+function validateOutputPath(outputPath) {
+	const safe = resolve(outputPath);
+	const cwd = normalize(process.cwd());
+	const tmp = normalize(tmpdir());
+	if (!safe.startsWith(`${cwd}${sep}`) && !safe.startsWith(`${tmp}${sep}`)) throw new Error("Path traversal blocked: outputPath must be under project root or temp directory");
+	return safe;
+}
+//#endregion
+//#region src/server/domains/wasm/handlers/external-tool-handlers.ts
+/**
+* External tool sub-handler — disassemble, decompile, inspectSections, offlineRun, optimize.
+*/
+var ExternalToolHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleWasmDisassemble(args) {
+		const inputPath = argStringRequired(args, "inputPath");
+		const outputPath = argString(args, "outputPath");
+		const foldExprs = argBool(args, "foldExprs", true);
+		const toolArgs = [
+			inputPath,
+			"-o",
+			"/dev/stdout"
+		];
+		if (foldExprs) toolArgs.push("--fold-exprs");
+		const result = await this.state.runner.run({
+			tool: "wabt.wasm2wat",
+			args: toolArgs,
+			timeoutMs: WASM_TOOL_TIMEOUT_MS
+		});
+		if (!result.ok) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: result.stderr,
+				exitCode: result.exitCode
+			})
+		}] };
+		let savedPath;
+		if (outputPath) {
+			const safePath = validateOutputPath(outputPath);
+			await writeFile(safePath, result.stdout, "utf-8");
+			savedPath = safePath;
+		} else {
+			const { absolutePath, displayPath } = await resolveArtifactPath({
+				category: "wasm",
+				toolName: "wasm-disassemble",
+				ext: "wat"
+			});
+			await writeFile(absolutePath, result.stdout, "utf-8");
+			savedPath = displayPath;
+		}
+		const lines = result.stdout.split("\n");
+		const preview = lines.slice(0, 50).join("\n");
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				artifactPath: savedPath,
+				totalLines: lines.length,
+				sizeBytes: result.stdout.length,
+				preview: preview + (lines.length > 50 ? "\n... (truncated)" : ""),
+				durationMs: result.durationMs
+			}, null, 2)
+		}] };
+	}
+	async handleWasmDecompile(args) {
+		const inputPath = argStringRequired(args, "inputPath");
+		const outputPath = argString(args, "outputPath");
+		const result = await this.state.runner.run({
+			tool: "wabt.wasm-decompile",
+			args: [
+				inputPath,
+				"-o",
+				"/dev/stdout"
+			],
+			timeoutMs: WASM_TOOL_TIMEOUT_MS
+		});
+		if (!result.ok) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: result.stderr,
+				exitCode: result.exitCode
+			})
+		}] };
+		let savedPath;
+		if (outputPath) {
+			const safePath = validateOutputPath(outputPath);
+			await writeFile(safePath, result.stdout, "utf-8");
+			savedPath = safePath;
+		} else {
+			const { absolutePath, displayPath } = await resolveArtifactPath({
+				category: "wasm",
+				toolName: "wasm-decompile",
+				ext: "dcmp"
+			});
+			await writeFile(absolutePath, result.stdout, "utf-8");
+			savedPath = displayPath;
+		}
+		const lines = result.stdout.split("\n");
+		const preview = lines.slice(0, 60).join("\n");
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				artifactPath: savedPath,
+				totalLines: lines.length,
+				preview: preview + (lines.length > 60 ? "\n... (truncated)" : ""),
+				durationMs: result.durationMs
+			}, null, 2)
+		}] };
+	}
+	async handleWasmInspectSections(args) {
+		const inputPath = argStringRequired(args, "inputPath");
+		const flags = ({
+			headers: "-h",
+			details: "-x",
+			disassemble: "-d",
+			all: "-h -x -d"
+		}[argString(args, "sections", "details")] || "-x").split(" ");
+		const result = await this.state.runner.run({
+			tool: "wabt.wasm-objdump",
+			args: [...flags, inputPath],
+			timeoutMs: WASM_TOOL_TIMEOUT_MS
+		});
+		if (!result.ok) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: result.stderr,
+				exitCode: result.exitCode
+			})
+		}] };
+		const lines = result.stdout.split("\n");
+		const preview = lines.slice(0, 100).join("\n");
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				totalLines: lines.length,
+				preview: preview + (lines.length > 100 ? "\n... (truncated)" : ""),
+				durationMs: result.durationMs
+			}, null, 2)
+		}] };
+	}
+	async handleWasmOfflineRun(args) {
+		const inputPath = argStringRequired(args, "inputPath");
+		const functionName = argStringRequired(args, "functionName");
+		const fnArgs = argStringArray(args, "args");
+		const runtime = argString(args, "runtime", "auto");
+		const timeoutMs = argNumber(args, "timeoutMs", 1e4);
+		let toolName;
+		if (runtime === "auto") {
+			const probes = await this.state.runner.probeAll();
+			if (probes["runtime.wasmtime"]?.available) toolName = "runtime.wasmtime";
+			else if (probes["runtime.wasmer"]?.available) toolName = "runtime.wasmer";
+			else return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error: "No WASM runtime found. Install wasmtime or wasmer."
+				})
+			}] };
+		} else toolName = runtime === "wasmer" ? "runtime.wasmer" : "runtime.wasmtime";
+		const runArgs = toolName === "runtime.wasmtime" ? [
+			"run",
+			"--invoke",
+			functionName,
+			inputPath,
+			...fnArgs
+		] : [
+			"run",
+			inputPath,
+			"--invoke",
+			functionName,
+			"--",
+			...fnArgs
+		];
+		const result = await this.state.runner.run({
+			tool: toolName,
+			args: runArgs,
+			timeoutMs
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: result.ok,
+				runtime: toolName,
+				functionName,
+				args: fnArgs,
+				output: result.stdout.trim(),
+				stderr: result.stderr.trim() || void 0,
+				exitCode: result.exitCode,
+				durationMs: result.durationMs
+			}, null, 2)
+		}] };
+	}
+	async handleWasmOptimize(args) {
+		const inputPath = argStringRequired(args, "inputPath");
+		const outputPath = argString(args, "outputPath");
+		const level = argString(args, "level", "O2");
+		let destPath;
+		if (outputPath) destPath = validateOutputPath(outputPath);
+		else {
+			const { absolutePath } = await resolveArtifactPath({
+				category: "wasm",
+				toolName: "wasm-opt",
+				ext: "wasm"
+			});
+			destPath = absolutePath;
+		}
+		const result = await this.state.runner.run({
+			tool: "binaryen.wasm-opt",
+			args: [
+				`-${level}`,
+				inputPath,
+				"-o",
+				destPath
+			],
+			timeoutMs: WASM_OPTIMIZE_TIMEOUT_MS
+		});
+		if (!result.ok) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: result.stderr,
+				exitCode: result.exitCode
+			})
+		}] };
+		let inputSize = 0;
+		let outputSize = 0;
+		try {
+			inputSize = (await stat(inputPath)).size;
+			outputSize = (await stat(destPath)).size;
+		} catch {}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				artifactPath: destPath,
+				optimizationLevel: level,
+				inputSizeBytes: inputSize,
+				outputSizeBytes: outputSize,
+				reductionPercent: inputSize > 0 ? ((1 - outputSize / inputSize) * 100).toFixed(1) : "0",
+				durationMs: result.durationMs
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/wasm/handlers/browser-handlers.ts
+/**
+* Browser sub-handler — dump, vmpTrace, memoryInspect.
+*/
+var BrowserHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleWasmDump(args) {
+		const moduleIndex = argNumber(args, "moduleIndex", 0);
+		const outputPath = argString(args, "outputPath");
+		const page = await this.state.collector.getActivePage();
+		const result = await page.evaluate((idx) => {
+			const hooksRaw = window.__aiHooks?.["preset-webassembly-full"];
+			if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) return { error: "No WASM modules captured. Ensure the webassembly-full hook preset is active and the page has loaded WASM." };
+			const instantiatedEvents = hooksRaw.filter((e) => e.type === "instantiated");
+			if (idx >= instantiatedEvents.length) return { error: `Module index ${idx} out of range. Found ${instantiatedEvents.length} instantiated modules.` };
+			const event = instantiatedEvents[idx];
+			return {
+				exports: event.exports,
+				importMods: event.importMods,
+				size: event.size,
+				moduleCount: instantiatedEvents.length
+			};
+		}, moduleIndex);
+		if (hasErrorResult(result)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: result.error
+			})
+		}] };
+		const wasmBytes = await page.evaluate((idx) => {
+			const storage = window.__wasmModuleStorage;
+			if (!storage?.[idx]) return null;
+			const buffer = storage[idx];
+			return Array.from(new Uint8Array(buffer));
+		}, moduleIndex);
+		let savedPath;
+		let hash;
+		if (wasmBytes) {
+			const buffer = Buffer.from(wasmBytes);
+			hash = createHash("sha256").update(buffer).digest("hex").substring(0, 16);
+			if (outputPath) {
+				const safePath = validateOutputPath(outputPath);
+				await writeFile(safePath, buffer);
+				savedPath = safePath;
+			} else {
+				const { absolutePath, displayPath } = await resolveArtifactPath({
+					category: "wasm",
+					toolName: "wasm-dump",
+					target: hash,
+					ext: "wasm"
+				});
+				await writeFile(absolutePath, buffer);
+				savedPath = displayPath;
+			}
+		} else savedPath = "(binary not available — hook did not store raw bytes)";
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				artifactPath: savedPath,
+				hash,
+				size: result.size,
+				exports: result.exports,
+				importModules: result.importMods,
+				totalModules: result.moduleCount,
+				hint: wasmBytes ? "Use wasm_disassemble or wasm_decompile on the dumped file for further analysis." : "Binary not captured. Inject hook_preset(\"webassembly-full\") BEFORE page navigation, with window.__wasmModuleStorage patching."
+			}, null, 2)
+		}] };
+	}
+	async handleWasmVmpTrace(args) {
+		const maxEvents = argNumber(args, "maxEvents", 5e3);
+		const filterModule = argString(args, "filterModule");
+		const traceData = await (await this.state.collector.getActivePage()).evaluate((opts) => {
+			const hooksRaw = window.__aiHooks?.["preset-webassembly-full"];
+			if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) return { error: "No WASM hook data. Inject hook_preset(\"webassembly-full\") and reload the page." };
+			let importCalls = hooksRaw.filter((e) => e.type === "import_call");
+			if (opts.filterModule) importCalls = importCalls.filter((e) => e.mod === opts.filterModule);
+			const limited = importCalls.slice(0, opts.maxEvents);
+			const fnCounts = {};
+			for (const call of limited) {
+				const key = `${String(call.mod)}.${String(call.fn)}`;
+				fnCounts[key] = (fnCounts[key] || 0) + 1;
+			}
+			const sorted = Object.entries(fnCounts).toSorted((a, b) => b[1] - a[1]).slice(0, 30).map(([name, count]) => ({
+				name,
+				count
+			}));
+			return {
+				totalEvents: importCalls.length,
+				capturedEvents: limited.length,
+				topFunctions: sorted,
+				trace: limited.slice(0, 200).map((e) => ({
+					mod: e.mod,
+					fn: e.fn,
+					args: e.args,
+					ts: e.ts
+				}))
+			};
+		}, {
+			maxEvents,
+			filterModule
+		});
+		if (hasErrorResult(traceData)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: traceData.error
+			})
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				...traceData,
+				hint: "Top functions show VMP handler dispatch patterns. Use wasm_disassemble to analyze their implementation."
+			}, null, 2)
+		}] };
+	}
+	async handleWasmMemoryInspect(args) {
+		const offset = argNumber(args, "offset", 0);
+		const length = Math.min(argNumber(args, "length", 256), 65536);
+		const format = argString(args, "format", "both");
+		const searchPattern = argString(args, "searchPattern");
+		const memData = await (await this.state.collector.getActivePage()).evaluate((opts) => {
+			const win = window;
+			const hooksRaw = win.__aiHooks?.["preset-webassembly-full"];
+			const memoryEvents = (Array.isArray(hooksRaw) ? hooksRaw : []).filter((e) => e.type === "memory_created");
+			const instances = win.__wasmInstances;
+			if (!Array.isArray(instances) || instances.length === 0) return { error: "No WASM memory available. Ensure the webassembly-full hook is active and a WASM module is instantiated." };
+			try {
+				const memory = instances[0].exports?.memory;
+				if (!memory?.buffer) return { error: "WASM module has no exported memory." };
+				const buffer = new Uint8Array(memory.buffer);
+				const slice = Array.from(buffer.slice(opts.offset, opts.offset + opts.length));
+				let searchResults;
+				if (opts.searchPattern) {
+					searchResults = [];
+					const pattern = opts.searchPattern;
+					if (/^[0-9a-fA-F\s]+$/.test(pattern)) {
+						const hexBytes = pattern.replace(/\s/g, "").match(/.{2}/g)?.map((h) => parseInt(h, 16)) || [];
+						for (let i = opts.offset; i <= Math.min(opts.offset + opts.length - hexBytes.length, buffer.length - hexBytes.length); i++) {
+							let match = true;
+							for (let j = 0; j < hexBytes.length; j++) if (buffer[i + j] !== hexBytes[j]) {
+								match = false;
+								break;
+							}
+							if (match) searchResults.push({ offset: i });
+						}
+					} else {
+						const patternBytes = new TextEncoder().encode(pattern);
+						for (let i = opts.offset; i <= Math.min(opts.offset + opts.length - patternBytes.length, buffer.length - patternBytes.length); i++) {
+							let match = true;
+							for (let j = 0; j < patternBytes.length; j++) if (buffer[i + j] !== patternBytes[j]) {
+								match = false;
+								break;
+							}
+							if (match) searchResults.push({ offset: i });
+						}
+					}
+				}
+				return {
+					totalMemoryPages: memory.buffer.byteLength / 65536,
+					totalMemoryBytes: memory.buffer.byteLength,
+					requestedOffset: opts.offset,
+					requestedLength: opts.length,
+					data: slice,
+					searchResults,
+					memoryInfo: memoryEvents[0] || null
+				};
+			} catch (e) {
+				return { error: `Failed to read WASM memory: ${e instanceof Error ? e.message : String(e)}` };
+			}
+		}, {
+			offset,
+			length,
+			searchPattern
+		});
+		if (hasErrorResult(memData)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: memData.error
+			})
+		}] };
+		const data = memData.data;
+		let hexDump = "";
+		let asciiDump = "";
+		if (format === "hex" || format === "both") for (let i = 0; i < data.length; i += 16) {
+			const row = data.slice(i, i + 16);
+			const addr = (offset + i).toString(16).padStart(8, "0");
+			const hex = row.map((b) => b.toString(16).padStart(2, "0")).join(" ");
+			const ascii = row.map((b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("");
+			hexDump += `${addr}  ${hex.padEnd(48)}  |${ascii}|\n`;
+		}
+		if (format === "ascii") asciiDump = data.map((b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("");
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				totalMemoryPages: memData.totalMemoryPages,
+				totalMemoryBytes: memData.totalMemoryBytes,
+				offset,
+				length: data.length,
+				hexDump: format !== "ascii" ? hexDump : void 0,
+				asciiDump: format === "ascii" ? asciiDump : void 0,
+				searchResults: memData.searchResults
+			}, null, 2)
+		}] };
+	}
+};
+//#endregion
+//#region src/server/domains/wasm/handlers.impl.core.ts
+/**
+* WASM domain — composition facade.
+*
+* External tool operations in ./handlers/external-tool-handlers.ts.
+* Browser operations in ./handlers/browser-handlers.ts.
+*/
+var WasmToolHandlers = class {
+	state;
+	externalTools;
+	browser;
+	constructor(collector) {
+		const runner = new ExternalToolRunner(new ToolRegistry());
+		this.state = {
+			collector,
+			runner
+		};
+		this.externalTools = new ExternalToolHandlers(this.state);
+		this.browser = new BrowserHandlers(this.state);
+	}
+	handleWasmDump(args) {
+		return this.browser.handleWasmDump(args);
+	}
+	handleWasmDisassemble(args) {
+		return this.externalTools.handleWasmDisassemble(args);
+	}
+	handleWasmDecompile(args) {
+		return this.externalTools.handleWasmDecompile(args);
+	}
+	handleWasmInspectSections(args) {
+		return this.externalTools.handleWasmInspectSections(args);
+	}
+	handleWasmOfflineRun(args) {
+		return this.externalTools.handleWasmOfflineRun(args);
+	}
+	handleWasmOptimize(args) {
+		return this.externalTools.handleWasmOptimize(args);
+	}
+	handleWasmVmpTrace(args) {
+		return this.browser.handleWasmVmpTrace(args);
+	}
+	handleWasmMemoryInspect(args) {
+		return this.browser.handleWasmMemoryInspect(args);
+	}
+};
+//#endregion
+export { WasmToolHandlers };