@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/types-Bx92KJfT.mjs

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

package/dist/types-CPhOReNX.mjs

@@ -1,37 +0,0 @@
-import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { exec, execFile } from "child_process";
-import { promisify } from "util";
-//#region src/modules/process/memory/types.ts
-/**
-* Shared types and utility helpers for the memory sub-modules.
-*/
-var types_exports = /* @__PURE__ */ __exportAll({
-	execAsync: () => execAsync,
-	execFileAsync: () => execFileAsync,
-	executePowerShellScript: () => executePowerShellScript
-});
-const execAsync = promisify(exec);
-const execFileAsync = promisify(execFile);
-function getPowerShellExecutable() {
-	return process.platform === "win32" ? "powershell.exe" : "powershell";
-}
-async function executePowerShellScript(script, options = {}) {
-	const args = [
-		"-NoProfile",
-		"-ExecutionPolicy",
-		"Bypass",
-		"-EncodedCommand",
-		Buffer.from(script, "utf16le").toString("base64")
-	];
-	const { stdout, stderr } = await execFileAsync(getPowerShellExecutable(), args, {
-		maxBuffer: options.maxBuffer ?? 1024 * 1024,
-		timeout: options.timeout,
-		windowsHide: true
-	});
-	return {
-		stdout: String(stdout ?? ""),
-		stderr: String(stderr ?? "")
-	};
-}
-//#endregion
-export { types_exports as i, execFileAsync as n, executePowerShellScript as r, execAsync as t };

package/dist/wasm-DQTnHDs4.mjs

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