@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/PointerChainEngine-BOhyVsjx.mjs

@@ -1,322 +0,0 @@
-import { Jt as POINTER_CHAIN_MAX_DEPTH, Xt as POINTER_CHAIN_MAX_RESULTS, Yt as POINTER_CHAIN_MAX_OFFSET, Zt as POINTER_CHAIN_SCAN_CHUNK_SIZE } from "./constants-B0OANIBL.mjs";
-import { t as createPlatformProvider } from "./factory-DxlGh9Xf.mjs";
-import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-dZtA1ZGn.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-DVkj9kpI.mjs";
-import { randomUUID } from "node:crypto";
-//#region src/native/PointerChainEngine.ts
-/**
-* Pointer Chain Engine — multi-level BFS pointer scanning.
-*
-* Finds stable pointer chains: [base_module+offset] → [+off1] → [+off2] → ... → target
-* Supports chain validation, resolution, and persistence.
-*
-* Uses PlatformMemoryAPI for cross-platform memory operations.
-*
-* @module PointerChainEngine
-*/
-var PointerChainEngine = class {
-	_provider = null;
-	get provider() {
-		if (!this._provider) this._provider = createPlatformProvider();
-		return this._provider;
-	}
-	/**
-	* Multi-level BFS pointer scan.
-	*
-	* Algorithm:
-	* Level 0: Find pointers P where *P ∈ [target - maxOffset, target + maxOffset]
-	* Level 1: Find pointers Q where *Q ∈ [P - maxOffset, P + maxOffset] for each P
-	* ... repeat up to maxDepth
-	* Construct chains backward from target to base.
-	*/
-	async scan(pid, targetAddress, options) {
-		const start = performance.now();
-		const maxDepth = Math.min(options?.maxDepth ?? 4, POINTER_CHAIN_MAX_DEPTH);
-		const maxOffset = options?.maxOffset ?? POINTER_CHAIN_MAX_OFFSET;
-		const maxResults = options?.maxResults ?? POINTER_CHAIN_MAX_RESULTS;
-		const alignment = options?.alignment ?? 8;
-		const staticOnly = options?.staticOnly ?? false;
-		const targetAddr = parseAddress(targetAddress);
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			const modules = await this.getModuleMap(pid);
-			const levelResults = [];
-			let currentTargets = new Set([targetAddr]);
-			for (let depth = 0; depth < maxDepth; depth++) {
-				if (currentTargets.size === 0) break;
-				const matches = this.scanLevel(handle, currentTargets, maxOffset, alignment, options?.modules ? { modules: options.modules } : void 0);
-				if (matches.length === 0) break;
-				levelResults.push(matches);
-				currentTargets = /* @__PURE__ */ new Set();
-				for (const m of matches) {
-					currentTargets.add(m.pointerAddress);
-					if (currentTargets.size > 5e4) break;
-				}
-			}
-			const chains = this.buildChains(levelResults, targetAddr, modules, maxResults, staticOnly);
-			const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-			return {
-				pid,
-				targetAddress: formatAddress(targetAddr),
-				chains,
-				totalFound: chains.length,
-				maxDepth,
-				elapsed
-			};
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-	}
-	/**
-	* Validate a pointer chain by re-dereferencing each link.
-	*/
-	async validateChain(pid, chain) {
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			let currentAddr = parseAddress(chain.baseAddress);
-			for (let i = 0; i < chain.links.length; i++) {
-				const link = chain.links[i];
-				let ptrValue;
-				try {
-					ptrValue = this.provider.readMemory(handle, currentAddr, 8).data.readBigUInt64LE(0);
-				} catch {
-					return {
-						chainId: chain.id,
-						isValid: false,
-						resolvedAddress: null,
-						expectedAddress: chain.targetAddress,
-						brokenAt: i
-					};
-				}
-				currentAddr = ptrValue + BigInt(link.offset);
-			}
-			const resolvedStr = formatAddress(currentAddr);
-			const expectedAddr = parseAddress(chain.targetAddress);
-			const isValid = currentAddr === expectedAddr;
-			return {
-				chainId: chain.id,
-				isValid,
-				resolvedAddress: resolvedStr,
-				expectedAddress: chain.targetAddress,
-				brokenAt: isValid ? void 0 : chain.links.length - 1
-			};
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-	}
-	/**
-	* Validate multiple chains in batch.
-	*/
-	async validateChains(pid, chains) {
-		const results = [];
-		for (const chain of chains) results.push(await this.validateChain(pid, chain));
-		return results;
-	}
-	/**
-	* Resolve a pointer chain to its current target address.
-	*/
-	async resolveChain(pid, chain) {
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			let currentAddr = parseAddress(chain.baseAddress);
-			for (const link of chain.links) {
-				let ptrValue;
-				try {
-					ptrValue = this.provider.readMemory(handle, currentAddr, 8).data.readBigUInt64LE(0);
-				} catch {
-					return null;
-				}
-				currentAddr = ptrValue + BigInt(link.offset);
-			}
-			return formatAddress(currentAddr);
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-	}
-	/**
-	* Export chains to JSON for persistence.
-	*/
-	exportChains(chains) {
-		return JSON.stringify(chains, null, 2);
-	}
-	/**
-	* Import chains from JSON.
-	*/
-	importChains(data) {
-		const parsed = JSON.parse(data);
-		if (!Array.isArray(parsed)) throw new Error("Invalid chain data: expected array");
-		return parsed;
-	}
-	/**
-	* Get module info map for resolving module-relative addresses.
-	*/
-	async getModuleMap(pid) {
-		const modules = /* @__PURE__ */ new Map();
-		try {
-			const result = await nativeMemoryManager.enumerateModules(pid);
-			if (result.success && result.modules) for (const mod of result.modules) {
-				const base = parseAddress(mod.baseAddress);
-				modules.set(mod.name.toLowerCase(), {
-					name: mod.name,
-					base,
-					size: mod.size
-				});
-			}
-		} catch {}
-		return modules;
-	}
-	/**
-	* Resolve an address to module+offset notation.
-	*/
-	resolveToModule(address, moduleMap) {
-		for (const entry of moduleMap.values()) if (address >= entry.base && address < entry.base + BigInt(entry.size)) return {
-			module: entry.name,
-			offset: Number(address - entry.base)
-		};
-		return null;
-	}
-	/**
-	* BFS scan for one level: find all addresses whose pointer-sized value
-	* points within ±maxOffset of any target address.
-	*/
-	scanLevel(handle, targetAddresses, maxOffset, alignment, _filter) {
-		const matches = [];
-		const chunkSize = POINTER_CHAIN_SCAN_CHUNK_SIZE;
-		const targets = Array.from(targetAddresses).toSorted((a, b) => a < b ? -1 : a > b ? 1 : 0);
-		if (targets.length === 0) return matches;
-		const maxOffsetBig = BigInt(maxOffset);
-		const globalMin = targets[0] - maxOffsetBig;
-		const globalMax = targets[targets.length - 1] + maxOffsetBig;
-		let address = 0n;
-		const maxAddress = BigInt("0x7FFFFFFF0000");
-		while (address < maxAddress) {
-			const regionInfo = this.provider.queryRegion(handle, address);
-			if (!regionInfo) break;
-			const regionSize = regionInfo.size;
-			if (regionInfo.isReadable && regionSize > 0 && regionSize <= Number.MAX_SAFE_INTEGER) {
-				const regionBase = regionInfo.baseAddress;
-				for (let offset = 0; offset < regionSize && matches.length < 1e5; offset += chunkSize) {
-					const readSize = Math.min(chunkSize, regionSize - offset);
-					const chunkAddr = regionBase + BigInt(offset);
-					let chunk;
-					try {
-						chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-					} catch {
-						break;
-					}
-					for (let i = 0; i <= chunk.length - 8; i += alignment) {
-						const ptrValue = chunk.readBigUInt64LE(i);
-						if (ptrValue < globalMin || ptrValue > globalMax) continue;
-						const searchMin = ptrValue - maxOffsetBig;
-						const searchMax = ptrValue + maxOffsetBig;
-						let lo = 0;
-						let hi = targets.length;
-						while (lo < hi) {
-							const mid = lo + hi >>> 1;
-							if (targets[mid] < searchMin) lo = mid + 1;
-							else hi = mid;
-						}
-						for (let t = lo; t < targets.length && targets[t] <= searchMax; t++) {
-							const target = targets[t];
-							if ((ptrValue > target ? Number(ptrValue - target) : Number(target - ptrValue)) <= maxOffset) {
-								const pointerAddr = chunkAddr + BigInt(i);
-								const matchOffset = Number(target - ptrValue);
-								matches.push({
-									pointerAddress: pointerAddr,
-									pointsTo: ptrValue,
-									offset: matchOffset
-								});
-								break;
-							}
-						}
-					}
-				}
-			}
-			address = regionInfo.baseAddress + BigInt(regionInfo.size);
-		}
-		return matches;
-	}
-	/**
-	* Build pointer chains from level results (backward: deepest level = base).
-	*/
-	buildChains(levelResults, targetAddr, modules, maxResults, staticOnly) {
-		if (levelResults.length === 0) return [];
-		const chains = [];
-		const targetAddrStr = formatAddress(targetAddr);
-		for (let depth = 0; depth < levelResults.length && chains.length < maxResults; depth++) {
-			const level = levelResults[depth];
-			if (depth === 0) for (const match of level) {
-				if (chains.length >= maxResults) break;
-				const baseAddrStr = formatAddress(match.pointerAddress);
-				const modInfo = this.resolveToModule(match.pointerAddress, modules);
-				const isStatic = modInfo !== null;
-				if (staticOnly && !isStatic) continue;
-				const link = {
-					address: baseAddrStr,
-					module: modInfo?.module,
-					moduleOffset: modInfo?.offset,
-					offset: match.offset
-				};
-				chains.push({
-					id: randomUUID(),
-					links: [link],
-					targetAddress: targetAddrStr,
-					baseAddress: baseAddrStr,
-					isStatic,
-					depth: 1,
-					lastValidated: Date.now(),
-					isValid: true
-				});
-			}
-			else {
-				const prevLevel = levelResults[depth - 1];
-				const prevByAddr = /* @__PURE__ */ new Map();
-				for (const pm of prevLevel) prevByAddr.set(pm.pointerAddress, pm);
-				const maxOff = BigInt(POINTER_CHAIN_MAX_OFFSET);
-				for (const match of level) {
-					if (chains.length >= maxResults) break;
-					let prevMatch;
-					prevMatch = prevByAddr.get(match.pointsTo);
-					if (!prevMatch) {
-						for (const pm of prevLevel) if ((match.pointsTo > pm.pointerAddress ? match.pointsTo - pm.pointerAddress : pm.pointerAddress - match.pointsTo) <= maxOff) {
-							prevMatch = pm;
-							break;
-						}
-					}
-					if (!prevMatch) continue;
-					const baseAddrStr = formatAddress(match.pointerAddress);
-					const modInfo = this.resolveToModule(match.pointerAddress, modules);
-					const isStatic = modInfo !== null;
-					if (staticOnly && !isStatic) continue;
-					const links = [{
-						address: baseAddrStr,
-						module: modInfo?.module,
-						moduleOffset: modInfo?.offset,
-						offset: Number(prevMatch.pointerAddress - match.pointsTo)
-					}, {
-						address: formatAddress(prevMatch.pointerAddress),
-						offset: prevMatch.offset
-					}];
-					chains.push({
-						id: randomUUID(),
-						links,
-						targetAddress: targetAddrStr,
-						baseAddress: baseAddrStr,
-						isStatic,
-						depth: links.length,
-						lastValidated: Date.now(),
-						isValid: true
-					});
-				}
-			}
-		}
-		chains.sort((a, b) => {
-			if (a.isStatic !== b.isStatic) return a.isStatic ? -1 : 1;
-			return a.depth - b.depth;
-		});
-		return chains.slice(0, maxResults);
-	}
-};
-const pointerChainEngine = new PointerChainEngine();
-//#endregion
-export { PointerChainEngine, pointerChainEngine };

package/dist/PrerequisiteError-Dl33Svkz.mjs

@@ -1,20 +0,0 @@
-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/ResponseBuilder-D3iFYx2N.mjs

@@ -1,143 +0,0 @@
-//#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 = {};
-	_isError = false;
-	_additionalContent = [];
-	_useStructured = 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._isError = 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._useStructured = 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._isError ? { isError: true } : {},
-			...this._useStructured ? { 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 };