@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/{PointerChainEngine-Cd73qu5b.mjs → PointerChainEngine-K7wN8Z-w.mjs}

@@ -1,7 +1,7 @@
-import { Dt as POINTER_CHAIN_SCAN_CHUNK_SIZE, Et as POINTER_CHAIN_MAX_RESULTS, Tt as POINTER_CHAIN_MAX_OFFSET, wt as POINTER_CHAIN_MAX_DEPTH } from "./constants-CCvsN80K.mjs";
-import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-CB6gJ0NM.mjs";
-import { t as createPlatformProvider } from "./factory-CibqTNC8.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-ChCSIRWT.mjs";
+import { Qt as POINTER_CHAIN_SCAN_CHUNK_SIZE, Xt as POINTER_CHAIN_MAX_OFFSET, Yt as POINTER_CHAIN_MAX_DEPTH, Zt as POINTER_CHAIN_MAX_RESULTS } from "./constants-CDZLOoVv.mjs";
+import { t as createPlatformProvider } from "./factory-C90tBff6.mjs";
+import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-D9Lkovvn.mjs";
+import { n as parseAddress, t as formatAddress } from "./formatAddress-nnMvEohD.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/native/PointerChainEngine.ts
 /**
@@ -15,10 +15,13 @@ import { randomUUID } from "node:crypto";
 * @module PointerChainEngine
 */
 var PointerChainEngine = class {
-	_provider = null;
+	providerCache = null;
 	get provider() {
-		if (!this._provider) this._provider = createPlatformProvider();
-		return this._provider;
+		if (!this.providerCache) this.providerCache = createPlatformProvider();
+		return this.providerCache;
+	}
+	set provider(value) {
+		this.providerCache = value;
 	}
 	/**
 	* Multi-level BFS pointer scan.

package/dist/PrerequisiteError-TuyZIs6n.mjs

@@ -0,0 +1,20 @@
+import { t as ToolError } from "./ToolError-jh9whhMd.mjs";
+//#region src/errors/PrerequisiteError.ts
+/**
+* Thrown when a tool's prerequisite is not met (e.g. debugger not enabled,
+* browser not connected, profiling not started).
+*
+* The MCP server catches this and returns a graceful
+* `{ success: false, message }` response instead of `isError: true`.
+*
+* Extends ToolError with code 'PREREQUISITE' for unified error classification.
+* Constructor signature unchanged — backward-compatible with all existing callers.
+*/
+var PrerequisiteError = class extends ToolError {
+	constructor(message) {
+		super("PREREQUISITE", message);
+		this.name = "PrerequisiteError";
+	}
+};
+//#endregion
+export { PrerequisiteError as t };

package/dist/ProcessRegistry-zGg12QbE.mjs

@@ -0,0 +1,74 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { G as EXTERNAL_TOOL_FORCE_KILL_GRACE_MS } from "./constants-CDZLOoVv.mjs";
+//#region src/utils/ProcessRegistry.ts
+/**
+* Global singleton registry to track and safely terminate orphaned child
+* processes and worker threads upon server shutdown.
+*/
+var ProcessRegistrySingleton = class {
+	processes = /* @__PURE__ */ new Set();
+	/**
+	* Register a ChildProcess or Worker for automatic cleanup on shutdown.
+	*/
+	register(proc) {
+		if (!proc) return;
+		this.processes.add(proc);
+		if ("kill" in proc) proc.once("close", () => this.unregister(proc));
+		else if ("terminate" in proc) {
+			if (typeof proc.once === "function") proc.once("exit", () => this.unregister(proc));
+			else if (typeof proc.on === "function") proc.on("exit", () => this.unregister(proc));
+		}
+	}
+	/**
+	* Unregister a process/worker.
+	*/
+	unregister(proc) {
+		if (!proc) return;
+		this.processes.delete(proc);
+	}
+	/**
+	* Terminate all tracked processes and workers.
+	* Sends SIGTERM, then after a grace period sends SIGKILL.
+	*/
+	async terminateAll() {
+		if (this.processes.size === 0) return;
+		logger.debug(`[ProcessRegistry] Attempting to terminate ${this.processes.size} active processes/workers...`);
+		const terminationPromises = [];
+		for (const proc of this.processes) if ("terminate" in proc) terminationPromises.push(proc.terminate().then(() => {
+			this.processes.delete(proc);
+		}).catch((err) => {
+			logger.warn(`[ProcessRegistry] Error terminating worker: ${err.message}`);
+		}));
+		else if ("kill" in proc) terminationPromises.push(new Promise((resolve) => {
+			if (proc.killed || proc.exitCode !== null || proc.signalCode !== null) {
+				this.processes.delete(proc);
+				return resolve();
+			}
+			proc.kill("SIGTERM");
+			let settled = false;
+			const handleExit = () => {
+				if (settled) return;
+				settled = true;
+				this.processes.delete(proc);
+				resolve();
+			};
+			proc.once("exit", handleExit);
+			proc.once("close", handleExit);
+			setTimeout(() => {
+				if (!settled && !proc.killed && proc.exitCode === null) {
+					logger.debug(`[ProcessRegistry] Force killing child process PID ${proc.pid}`);
+					try {
+						proc.kill("SIGKILL");
+					} catch {}
+					handleExit();
+				}
+			}, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS).unref();
+		}));
+		await Promise.race([Promise.all(terminationPromises), new Promise((resolve) => setTimeout(resolve, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS + 1e3).unref())]);
+		this.processes.clear();
+		logger.debug(`[ProcessRegistry] Termination sweep complete.`);
+	}
+};
+const ProcessRegistry = new ProcessRegistrySingleton();
+//#endregion
+export { ProcessRegistry as t };

package/dist/ResponseBuilder-CJXWmWNw.mjs

@@ -0,0 +1,143 @@
+//#region src/server/domains/shared/ResponseBuilder.ts
+/**
+* Fluent builder for MCP tool responses.
+*
+* Replaces the verbose 14-line deep-nesting pattern:
+* ```
+* return { content: [{ type: 'text', text: JSON.stringify({...}, null, 2) }] };
+* ```
+*
+* With a chainable API:
+* ```
+* return R.ok().set('driver', 'chrome').json();
+* ```
+*/
+var ResponseBuilder = class {
+	payload = {};
+	hasMcpError = false;
+	additionalContent = [];
+	useStructuredContent = false;
+	/** Mark as success (sets `success: true`). */
+	ok() {
+		this.payload.success = true;
+		return this;
+	}
+	/** Mark as failure (sets `success: false, error: <message>, message: <message>`). */
+	fail(error) {
+		this.payload.success = false;
+		const msg = error instanceof Error ? error.message : String(error);
+		this.payload.error = msg;
+		this.payload.message = msg;
+		return this;
+	}
+	/** Set a single key-value pair. */
+	set(key, value) {
+		this.payload[key] = value;
+		return this;
+	}
+	/** Merge multiple fields at once. */
+	merge(fields) {
+		Object.assign(this.payload, fields);
+		return this;
+	}
+	/** Set MCP-level `isError: true` on the response envelope. */
+	mcpError() {
+		this.hasMcpError = true;
+		return this;
+	}
+	/** Push an image block to the final response. */
+	image(base64, mimeType) {
+		this.additionalContent.push({
+			type: "image",
+			data: base64,
+			mimeType
+		});
+		return this;
+	}
+	/** Push an embedded resource block to the final response. */
+	embeddedResource(uri, text, mimeType = "text/plain") {
+		this.additionalContent.push({
+			type: "resource",
+			resource: {
+				uri,
+				text,
+				mimeType
+			}
+		});
+		return this;
+	}
+	/** Send output payload natively as `structuredContent` in the MCP envelope instead of stringifying inside text block. */
+	structured() {
+		this.useStructuredContent = true;
+		return this;
+	}
+	/**
+	* Build the ToolResponse. Handles text vs structured plus extra blocks.
+	* Optionally merges extra fields before building.
+	*/
+	json(fields) {
+		if (fields) this.merge(fields);
+		return {
+			content: [{
+				type: "text",
+				text: JSON.stringify(this.payload, null, 2)
+			}, ...this.additionalContent],
+			...this.hasMcpError ? { isError: true } : {},
+			...this.useStructuredContent ? { structuredContent: this.payload } : {}
+		};
+	}
+	/** Alias for json(). */
+	build(fields) {
+		return this.json(fields);
+	}
+	/** Build a ToolResponse from an arbitrary value (no success/error wrapper). */
+	static raw(data) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(data, null, 2)
+		}] };
+	}
+	/**
+	* Build a ToolResponse from a plain text string.
+	* Setting `isError = true` returns a soft error for macro compatibility
+	* without triggering a JSON-RPC ErrorCode.
+	*/
+	static text(text, isError = false) {
+		return {
+			content: [{
+				type: "text",
+				text
+			}],
+			...isError ? { isError: true } : {}
+		};
+	}
+	/**
+	* Safely extract and parse JSON from an MCP ToolResponse.
+	* Useful for consuming tool results in workflow/orchestration logic.
+	*/
+	static parse(response) {
+		if (!response.content || response.content.length === 0) throw new Error("ToolResponse has no content");
+		const textBlock = response.content.find((c) => c.type === "text");
+		if (!textBlock || !("text" in textBlock)) throw new Error("ToolResponse has no text content block");
+		try {
+			return JSON.parse(textBlock.text);
+		} catch (e) {
+			throw new Error(`Failed to parse tool result as JSON: ${String(e)}\nRaw text: ${textBlock.text.substring(0, 500)}`, { cause: e });
+		}
+	}
+};
+/** Shorthand factory — the primary entry point for building responses. */
+const R = {
+	/** Start a success response (`{ success: true, ... }`). */
+	ok: () => new ResponseBuilder().ok(),
+	/** Start a failure response (`{ success: false, error: "..." }`). */
+	fail: (error) => new ResponseBuilder().fail(error),
+	/** Wrap an existing object as-is (no success/error wrapper). */
+	raw: (data) => ResponseBuilder.raw(data),
+	/** Wrap a plain text string. */
+	text: (text, isError = false) => ResponseBuilder.text(text, isError),
+	/** Parse a response back into an object. */
+	parse: (response) => ResponseBuilder.parse(response)
+};
+//#endregion
+export { R as t };

package/dist/ReverseEvidenceGraph-C02-gXOh.mjs

@@ -0,0 +1,269 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+//#region src/server/evidence/ReverseEvidenceGraph.ts
+var ReverseEvidenceGraph_exports = /* @__PURE__ */ __exportAll({ ReverseEvidenceGraph: () => ReverseEvidenceGraph });
+let nextId = 1;
+function generateId(prefix) {
+	return `${prefix}-${nextId++}`;
+}
+var ReverseEvidenceGraph = class {
+	nodes = /* @__PURE__ */ new Map();
+	edges = /* @__PURE__ */ new Map();
+	eventBus;
+	isDirty = false;
+	mutationSeq = 0;
+	lastPersistedSeq = 0;
+	persistNotifier;
+	setEventBus(eventBus) {
+		this.eventBus = eventBus;
+	}
+	setPersistNotifier(notify) {
+		this.persistNotifier = notify;
+	}
+	markDirty() {
+		this.isDirty = true;
+		this.mutationSeq++;
+		this.persistNotifier?.();
+	}
+	commit() {
+		if (this.isDirty && this.eventBus) {
+			this.isDirty = false;
+			this.eventBus.emit("evidence:updated", {
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				reason: "Tool execution committed changes"
+			});
+		}
+	}
+	/** Add a node to the graph. */
+	addNode(type, label, metadata = {}) {
+		const node = {
+			id: generateId(type),
+			type,
+			label,
+			metadata,
+			createdAt: Date.now()
+		};
+		this.nodes.set(node.id, node);
+		this.markDirty();
+		return node;
+	}
+	/** Add a directed edge between two nodes. */
+	addEdge(sourceId, targetId, type, metadata) {
+		if (!this.nodes.has(sourceId)) throw new Error(`Source node "${sourceId}" not found`);
+		if (!this.nodes.has(targetId)) throw new Error(`Target node "${targetId}" not found`);
+		const edge = {
+			id: generateId("edge"),
+			source: sourceId,
+			target: targetId,
+			type,
+			metadata
+		};
+		this.edges.set(edge.id, edge);
+		this.markDirty();
+		return edge;
+	}
+	/** Get a node by ID. */
+	getNode(id) {
+		return this.nodes.get(id);
+	}
+	/** Remove a node and all connected edges. */
+	removeNode(id) {
+		if (!this.nodes.has(id)) return false;
+		this.nodes.delete(id);
+		for (const [edgeId, edge] of this.edges) if (edge.source === id || edge.target === id) this.edges.delete(edgeId);
+		this.markDirty();
+		return true;
+	}
+	/** Get all edges originating from a node. */
+	getEdgesFrom(nodeId) {
+		return [...this.edges.values()].filter((e) => e.source === nodeId);
+	}
+	/** Get all edges pointing to a node. */
+	getEdgesTo(nodeId) {
+		return [...this.edges.values()].filter((e) => e.target === nodeId);
+	}
+	/** Get total node count. */
+	get nodeCount() {
+		return this.nodes.size;
+	}
+	/** Get total edge count. */
+	get edgeCount() {
+		return this.edges.size;
+	}
+	/**
+	* BFS traversal from a node, following edges in the given direction.
+	* Returns all reachable nodes (including the start node).
+	*/
+	getEvidenceChain(nodeId, direction = "forward") {
+		if (!this.nodes.get(nodeId)) return [];
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [nodeId];
+		const result = [];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (visited.has(current)) continue;
+			visited.add(current);
+			const node = this.nodes.get(current);
+			if (node) result.push(node);
+			const connectedEdges = direction === "forward" ? this.getEdgesFrom(current) : this.getEdgesTo(current);
+			for (const edge of connectedEdges) {
+				const nextNodeId = direction === "forward" ? edge.target : edge.source;
+				if (!visited.has(nextNodeId)) queue.push(nextNodeId);
+			}
+		}
+		return result;
+	}
+	/**
+	* Find all nodes associated with a URL.
+	* Searches request nodes by URL metadata, then returns connected subgraph.
+	*/
+	queryByUrl(url) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "request" && typeof n.metadata.url === "string") return n.metadata.url.includes(url);
+			if (typeof n.metadata.url === "string") return n.metadata.url.includes(url);
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/**
+	* Find all nodes associated with a function name.
+	* Searches function nodes, then returns connected subgraph.
+	*/
+	queryByFunction(name) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "function" && typeof n.metadata.functionName === "string") return n.metadata.functionName.includes(name);
+			if (n.label.includes(name) && (n.type === "function" || n.type === "breakpoint-hook")) return true;
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/**
+	* Find all nodes associated with a script ID.
+	* Searches script nodes by scriptId metadata, then returns connected subgraph.
+	*/
+	queryByScriptId(scriptId) {
+		const matchingNodes = [...this.nodes.values()].filter((n) => {
+			if (n.type === "script" && n.metadata.scriptId === scriptId) return true;
+			return false;
+		});
+		const allNodes = /* @__PURE__ */ new Set();
+		for (const node of matchingNodes) {
+			for (const n of this.getEvidenceChain(node.id, "forward")) allNodes.add(n.id);
+			for (const n of this.getEvidenceChain(node.id, "backward")) allNodes.add(n.id);
+		}
+		return [...allNodes].map((id) => this.nodes.get(id)).filter(Boolean);
+	}
+	/** Export the full graph as a JSON snapshot. */
+	exportJson() {
+		return {
+			version: 1,
+			nodes: [...this.nodes.values()],
+			edges: [...this.edges.values()],
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	/** Export the graph as a readable Markdown report. */
+	exportMarkdown() {
+		const lines = [];
+		lines.push("# Reverse Evidence Graph Report");
+		lines.push("");
+		lines.push(`**Exported:** ${(/* @__PURE__ */ new Date()).toISOString()}`);
+		lines.push(`**Nodes:** ${this.nodes.size} | **Edges:** ${this.edges.size}`);
+		lines.push("");
+		const byType = /* @__PURE__ */ new Map();
+		for (const node of this.nodes.values()) {
+			const list = byType.get(node.type) ?? [];
+			list.push(node);
+			byType.set(node.type, list);
+		}
+		for (const type of [
+			"request",
+			"initiator-stack",
+			"script",
+			"function",
+			"breakpoint-hook",
+			"captured-data",
+			"replay-artifact",
+			"v8-heap-object",
+			"v8-hidden-class",
+			"network-request",
+			"network-response",
+			"canvas-scene-node",
+			"canvas-render-node",
+			"skia-draw-call",
+			"syscall-event",
+			"mojo-message",
+			"mojo-interface",
+			"binary-symbol",
+			"binary-function",
+			"binary-module",
+			"proto-message",
+			"proto-state"
+		]) {
+			const nodes = byType.get(type);
+			if (!nodes || nodes.length === 0) continue;
+			lines.push(`## ${type} (${nodes.length})`);
+			lines.push("");
+			for (const node of nodes) {
+				lines.push(`### ${node.label}`);
+				lines.push(`- **ID:** \`${node.id}\``);
+				lines.push(`- **Created:** ${new Date(node.createdAt).toISOString()}`);
+				const metaKeys = Object.keys(node.metadata);
+				if (metaKeys.length > 0) for (const key of metaKeys) {
+					const val = node.metadata[key];
+					const display = typeof val === "string" ? val : JSON.stringify(val);
+					lines.push(`- **${key}:** ${display}`);
+				}
+				const outEdges = this.getEdgesFrom(node.id);
+				const inEdges = this.getEdgesTo(node.id);
+				if (outEdges.length > 0) lines.push(`- **→ Out:** ${outEdges.map((e) => `${e.type} → \`${e.target}\``).join(", ")}`);
+				if (inEdges.length > 0) lines.push(`- **← In:** ${inEdges.map((e) => `\`${e.source}\` ${e.type} →`).join(", ")}`);
+				lines.push("");
+			}
+		}
+		return lines.join("\n");
+	}
+	getSnapshotSeq() {
+		return this.mutationSeq;
+	}
+	getLastPersistedSeq() {
+		return this.lastPersistedSeq;
+	}
+	markPersisted() {
+		this.lastPersistedSeq = this.mutationSeq;
+	}
+	isPersistDirty() {
+		return this.mutationSeq !== this.lastPersistedSeq;
+	}
+	exportSnapshot() {
+		return {
+			schemaVersion: 1,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			graph: this.exportJson()
+		};
+	}
+	restoreSnapshot(data) {
+		if (!data || typeof data !== "object") return;
+		const snapshot = data;
+		if (snapshot.schemaVersion !== 1 || !snapshot.graph) return;
+		const { nodes, edges } = snapshot.graph;
+		this.nodes.clear();
+		this.edges.clear();
+		for (const node of nodes) this.nodes.set(node.id, node);
+		for (const edge of edges) this.edges.set(edge.id, edge);
+		this.mutationSeq = nodes.length + edges.length;
+		this.lastPersistedSeq = this.mutationSeq;
+		this.isDirty = false;
+	}
+};
+//#endregion
+export { ReverseEvidenceGraph_exports as t };