@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/evidence-graph-bridge-C_fv9PuC.mjs

@@ -0,0 +1,135 @@
+//#region src/server/domains/cross-domain/handlers/evidence-graph-bridge.impl.ts
+var CrossDomainEvidenceBridge = class {
+	graph;
+	constructor(graph) {
+		this.graph = graph;
+	}
+	getGraph() {
+		return this.graph;
+	}
+	addNode(type, label, metadata) {
+		return this.graph.addNode(type, label, metadata);
+	}
+	addV8Object(input, scriptNodeId) {
+		const node = this.graph.addNode("v8-heap-object", input.name, {
+			domain: "v8-inspector",
+			address: input.address,
+			name: input.name
+		});
+		if (scriptNodeId) this.graph.addEdge(scriptNodeId, node.id, "heap-allocates", {
+			domain: "cross-domain",
+			relation: "script-allocates-heap-object"
+		});
+		return node;
+	}
+	addNetworkRequest(input, initiatorHeapNodeId) {
+		const label = input.method ? `${input.method} ${input.url}` : input.url;
+		const node = this.graph.addNode("network-request", label, {
+			domain: "network",
+			url: input.url,
+			method: input.method ?? "GET"
+		});
+		let initiatorNode;
+		if (initiatorHeapNodeId) {
+			initiatorNode = this.graph.getNode(initiatorHeapNodeId);
+			this.graph.addEdge(initiatorHeapNodeId, node.id, "network-initiated-by", {
+				domain: "cross-domain",
+				relation: "heap-initiates-network"
+			});
+		}
+		return {
+			node,
+			initiatorNode
+		};
+	}
+	addCanvasNode(input, creatorHeapNodeId) {
+		const node = this.graph.addNode("canvas-scene-node", input.label, {
+			domain: "canvas",
+			nodeId: input.nodeId,
+			label: input.label
+		});
+		if (creatorHeapNodeId) this.graph.addEdge(creatorHeapNodeId, node.id, "canvas-rendered-by", {
+			domain: "cross-domain",
+			relation: "heap-creates-canvas-node"
+		});
+		return node;
+	}
+	addSyscallEvent(input, jsFunctionNodeId) {
+		const node = this.graph.addNode("syscall-event", input.syscallName, {
+			domain: "syscall-hook",
+			pid: input.pid,
+			tid: input.tid,
+			syscallName: input.syscallName,
+			timestamp: input.timestamp
+		});
+		if (jsFunctionNodeId) this.graph.addEdge(jsFunctionNodeId, node.id, "syscall-emitted-by", {
+			domain: "cross-domain",
+			relation: "js-triggers-syscall"
+		});
+		return node;
+	}
+	addMojoMessage(input, cdpEventNodeId) {
+		const node = this.graph.addNode("mojo-message", `${input.interface}:${input.method}`, {
+			domain: "mojo-ipc",
+			interface: input.interface,
+			method: input.method,
+			timestamp: input.timestamp
+		});
+		if (cdpEventNodeId) this.graph.addEdge(cdpEventNodeId, node.id, "mojo-routed-to", {
+			domain: "cross-domain",
+			relation: "cdp-routes-to-mojo"
+		});
+		return node;
+	}
+	addBinarySymbol(input, jsFunctionNodeId) {
+		const node = this.graph.addNode("binary-symbol", input.symbolName, {
+			domain: "binary-instrument",
+			moduleName: input.moduleName,
+			symbolName: input.symbolName,
+			address: input.address
+		});
+		if (jsFunctionNodeId) this.graph.addEdge(jsFunctionNodeId, node.id, "binary-exports", {
+			domain: "cross-domain",
+			relation: "js-references-native-symbol"
+		});
+		return node;
+	}
+	queryByHeapAddress(addr) {
+		const snapshot = this.graph.exportJson();
+		const matchingIds = [];
+		for (const node of snapshot.nodes) {
+			const address = node.metadata["address"];
+			if (typeof address === "string" && address.includes(addr)) matchingIds.push(node.id);
+		}
+		return this.collectConnectedNodes(matchingIds);
+	}
+	queryByNetworkUrl(url) {
+		return this.graph.queryByUrl(url);
+	}
+	exportGraph() {
+		return this.graph.exportJson();
+	}
+	getStats() {
+		const snapshot = this.graph.exportJson();
+		const nodesByType = {};
+		for (const node of snapshot.nodes) {
+			const currentCount = nodesByType[node.type] ?? 0;
+			nodesByType[node.type] = currentCount + 1;
+		}
+		return {
+			nodeCount: snapshot.nodes.length,
+			edgeCount: snapshot.edges.length,
+			nodesByType
+		};
+	}
+	collectConnectedNodes(nodeIds) {
+		const collected = /* @__PURE__ */ new Map();
+		for (const nodeId of nodeIds) {
+			for (const node of this.graph.getEvidenceChain(nodeId, "forward")) collected.set(node.id, node);
+			for (const node of this.graph.getEvidenceChain(nodeId, "backward")) collected.set(node.id, node);
+		}
+		return [...collected.values()];
+	}
+};
+//#endregion
+export { CrossDomainEvidenceBridge };

package/dist/{factory-CibqTNC8.mjs → factory-DxlGh9Xf.mjs}

@@ -1,22 +1,7 @@
 import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, f as VirtualAllocEx, h as VirtualQueryEx, i as GetModuleBaseName, l as MEM, m as VirtualProtectEx, n as EnumProcessModules, p as VirtualFreeEx, s as GetModuleInformation, t as CloseHandle, u as PAGE, v as isKoffiAvailable, y as isWindows } from "./Win32API-Bc0QnQsN.mjs";
-import { _ as machVmReadOverwrite, a as VM_PROT, b as taskForPid, c as dyldImageCount, d as kernReturnName, f as machPortDeallocate, g as machVmProtect, h as machVmDeallocate, i as VM_FLAGS, l as isDarwin, m as machVmAllocate, n as KERN, o as dyldGetImageHeader, p as machTaskSelf, r as SM, s as dyldGetImageName, u as isKoffiAvailableOnDarwin, v as machVmRegion, y as machVmWrite } from "./DarwinAPI-B8hg_yhz.mjs";
+import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, f as VirtualAllocEx, h as VirtualQueryEx, i as GetModuleBaseName, l as MEM, m as VirtualProtectEx, n as EnumProcessModules, p as VirtualFreeEx, s as GetModuleInformation, t as CloseHandle, u as PAGE, v as isKoffiAvailable, y as isWindows } from "./Win32API-CePkipZY.mjs";
+import { _ as machVmReadOverwrite, a as VM_PROT, b as taskForPid, c as dyldImageCount, d as kernReturnName, f as machPortDeallocate, g as machVmProtect, h as machVmDeallocate, i as VM_FLAGS, l as isDarwin, m as machVmAllocate, n as KERN, o as dyldGetImageHeader, p as machTaskSelf, r as SM, s as dyldGetImageName, u as isKoffiAvailableOnDarwin, v as machVmRegion, y as machVmWrite } from "./DarwinAPI-BNPxu0RH.mjs";
 import fs from "node:fs";
-//#region src/native/platform/types.ts
-/** Memory protection flags (platform-independent) */
-let MemoryProtection = /* @__PURE__ */ function(MemoryProtection) {
-	MemoryProtection[MemoryProtection["NoAccess"] = 0] = "NoAccess";
-	MemoryProtection[MemoryProtection["Read"] = 1] = "Read";
-	MemoryProtection[MemoryProtection["Write"] = 2] = "Write";
-	MemoryProtection[MemoryProtection["Execute"] = 4] = "Execute";
-	MemoryProtection[MemoryProtection["ReadWrite"] = 3] = "ReadWrite";
-	MemoryProtection[MemoryProtection["ReadExecute"] = 5] = "ReadExecute";
-	MemoryProtection[MemoryProtection["ReadWriteExecute"] = 7] = "ReadWriteExecute";
-	MemoryProtection[MemoryProtection["Guard"] = 8] = "Guard";
-	MemoryProtection[MemoryProtection["WriteCopy"] = 16] = "WriteCopy";
-	return MemoryProtection;
-}({});
-//#endregion
 //#region src/native/platform/win32/Win32MemoryProvider.ts
 const handleMap$1 = /* @__PURE__ */ new WeakMap();
 function getWin32Handle(handle) {
@@ -25,28 +10,28 @@ function getWin32Handle(handle) {
 	return h;
 }
 function win32ProtToMemoryProtection(prot) {
-	let flags = MemoryProtection.NoAccess;
-	if (prot & PAGE.READONLY) flags |= MemoryProtection.Read;
-	if (prot & PAGE.READWRITE) flags |= MemoryProtection.ReadWrite;
-	if (prot & PAGE.WRITECOPY) flags |= MemoryProtection.Read | MemoryProtection.WriteCopy;
-	if (prot & PAGE.EXECUTE) flags |= MemoryProtection.Execute;
-	if (prot & PAGE.EXECUTE_READ) flags |= MemoryProtection.ReadExecute;
-	if (prot & PAGE.EXECUTE_READWRITE) flags |= MemoryProtection.ReadWriteExecute;
-	if (prot & PAGE.EXECUTE_WRITECOPY) flags |= MemoryProtection.Execute | MemoryProtection.Read | MemoryProtection.WriteCopy;
-	if (prot & PAGE.GUARD) flags |= MemoryProtection.Guard;
+	let flags = 0;
+	if (prot & PAGE.READONLY) flags |= 1;
+	if (prot & PAGE.READWRITE) flags |= 3;
+	if (prot & PAGE.WRITECOPY) flags |= 17;
+	if (prot & PAGE.EXECUTE) flags |= 4;
+	if (prot & PAGE.EXECUTE_READ) flags |= 5;
+	if (prot & PAGE.EXECUTE_READWRITE) flags |= 7;
+	if (prot & PAGE.EXECUTE_WRITECOPY) flags |= 21;
+	if (prot & PAGE.GUARD) flags |= 8;
 	return flags;
 }
 function memoryProtectionToWin32Prot(prot) {
-	const hasRead = (prot & MemoryProtection.Read) !== 0;
-	const hasWrite = (prot & MemoryProtection.Write) !== 0;
-	const hasExec = (prot & MemoryProtection.Execute) !== 0;
+	const hasRead = (prot & 1) !== 0;
+	const hasWrite = (prot & 2) !== 0;
+	const hasExec = (prot & 4) !== 0;
 	let page = PAGE.NOACCESS;
 	if (hasRead && hasWrite && hasExec) page = PAGE.EXECUTE_READWRITE;
 	else if (hasRead && hasExec) page = PAGE.EXECUTE_READ;
 	else if (hasRead && hasWrite) page = PAGE.READWRITE;
 	else if (hasExec) page = PAGE.EXECUTE;
 	else if (hasRead) page = PAGE.READONLY;
-	if ((prot & MemoryProtection.Guard) !== 0) page |= PAGE.GUARD;
+	if ((prot & 8) !== 0) page |= PAGE.GUARD;
 	return page;
 }
 function win32StateToState(state) {
@@ -110,9 +95,9 @@ var Win32MemoryProvider = class {
 			protection,
 			state: win32StateToState(info.State),
 			type: win32TypeToType(info.Type),
-			isReadable: (protection & MemoryProtection.Read) !== 0,
-			isWritable: (protection & MemoryProtection.Write) !== 0,
-			isExecutable: (protection & MemoryProtection.Execute) !== 0
+			isReadable: (protection & 1) !== 0,
+			isWritable: (protection & 2) !== 0,
+			isExecutable: (protection & 4) !== 0
 		};
 	}
 	changeProtection(handle, address, size, newProtection) {
@@ -161,10 +146,10 @@ function getDarwinHandle(handle) {
 * Map Mach VM_PROT_* flags → platform-agnostic MemoryProtection
 */
 function machProtToMemoryProtection(prot) {
-	let flags = MemoryProtection.NoAccess;
-	if (prot & VM_PROT.READ) flags |= MemoryProtection.Read;
-	if (prot & VM_PROT.WRITE) flags |= MemoryProtection.Write;
-	if (prot & VM_PROT.EXECUTE) flags |= MemoryProtection.Execute;
+	let flags = 0;
+	if (prot & VM_PROT.READ) flags |= 1;
+	if (prot & VM_PROT.WRITE) flags |= 2;
+	if (prot & VM_PROT.EXECUTE) flags |= 4;
 	return flags;
 }
 /**
@@ -172,9 +157,9 @@ function machProtToMemoryProtection(prot) {
 */
 function memoryProtectionToMachProt(prot) {
 	let machProt = VM_PROT.NONE;
-	if (prot & MemoryProtection.Read) machProt |= VM_PROT.READ;
-	if (prot & MemoryProtection.Write) machProt |= VM_PROT.WRITE;
-	if (prot & MemoryProtection.Execute) machProt |= VM_PROT.EXECUTE;
+	if (prot & 1) machProt |= VM_PROT.READ;
+	if (prot & 2) machProt |= VM_PROT.WRITE;
+	if (prot & 4) machProt |= VM_PROT.EXECUTE;
 	return machProt;
 }
 /**
@@ -264,16 +249,16 @@ var DarwinMemoryProvider = class {
 			protection,
 			state: "committed",
 			type: darwinShareModeToType(info.behavior),
-			isReadable: (protection & MemoryProtection.Read) !== 0,
-			isWritable: (protection & MemoryProtection.Write) !== 0,
-			isExecutable: (protection & MemoryProtection.Execute) !== 0
+			isReadable: (protection & 1) !== 0,
+			isWritable: (protection & 2) !== 0,
+			isExecutable: (protection & 4) !== 0
 		};
 	}
 	changeProtection(handle, address, size, newProtection) {
 		const h = getDarwinHandle(handle);
 		const machProt = memoryProtectionToMachProt(newProtection);
 		const { kr: queryKr, info } = machVmRegion(h.task, address);
-		const oldProtection = queryKr === KERN.SUCCESS ? machProtToMemoryProtection(info.protection) : MemoryProtection.NoAccess;
+		const oldProtection = queryKr === KERN.SUCCESS ? machProtToMemoryProtection(info.protection) : 0;
 		if ((machProt & VM_PROT.WRITE) !== 0 && (machProt & VM_PROT.EXECUTE) !== 0) {
 			const maxKr = machVmProtect(h.task, address, BigInt(size), true, VM_PROT.ALL);
 			if (maxKr !== KERN.SUCCESS) throw new Error(`mach_vm_protect (set_maximum) failed at 0x${address.toString(16)}: ${kernReturnName(maxKr)} (${maxKr})`);
@@ -389,10 +374,10 @@ function isLinuxRuntime() {
 	return process.platform === "linux";
 }
 function toProtection(perms) {
-	let protection = MemoryProtection.NoAccess;
-	if (perms.includes("r")) protection |= MemoryProtection.Read;
-	if (perms.includes("w")) protection |= MemoryProtection.Write;
-	if (perms.includes("x")) protection |= MemoryProtection.Execute;
+	let protection = 0;
+	if (perms.includes("r")) protection |= 1;
+	if (perms.includes("w")) protection |= 2;
+	if (perms.includes("x")) protection |= 4;
 	return protection;
 }
 function toRegionInfo(region) {
@@ -403,9 +388,9 @@ function toRegionInfo(region) {
 		protection,
 		state: "committed",
 		type: region.path ? "mapped" : "private",
-		isReadable: (protection & MemoryProtection.Read) !== 0,
-		isWritable: (protection & MemoryProtection.Write) !== 0,
-		isExecutable: (protection & MemoryProtection.Execute) !== 0
+		isReadable: (protection & 1) !== 0,
+		isWritable: (protection & 2) !== 0,
+		isExecutable: (protection & 4) !== 0
 	};
 }
 function normalizePattern(pattern) {
@@ -587,4 +572,4 @@ function createPlatformProvider() {
 	return cachedProvider;
 }
 //#endregion
-export { MemoryProtection as a, parseProcMaps as i, factory_exports as n, formatLinuxProtection as r, createPlatformProvider as t };
+export { parseProcMaps as i, factory_exports as n, formatLinuxProtection as r, createPlatformProvider as t };