@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/MemoryScanner-Bcpml6II.mjs

@@ -1,425 +0,0 @@
-import { _n as SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES, dn as SCAN_DISPLAY_RESULTS_LIMIT, fn as SCAN_GROUP_MAX_PATTERN_SIZE, mn as SCAN_POINTER_MAX_RESULTS, pn as SCAN_MAX_RESULTS_PER_SCAN } from "./constants-B0OANIBL.mjs";
-import { t as createPlatformProvider } from "./factory-DxlGh9Xf.mjs";
-import { i as parsePattern } from "./NativeMemoryManager.utils-B-FjA2mJ.mjs";
-import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-dZtA1ZGn.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-DVkj9kpI.mjs";
-import { n as getDefaultAlignment, r as getValueSize, scanSessionManager, t as compareScanValues } from "./MemoryScanSession-BsDZbLYm.mjs";
-//#region src/native/MemoryScanner.ts
-/**
-* Memory Scanner — orchestrates iterative scan workflows.
-*
-* Provides CE-style scanning: first-scan → next-scan → narrow down → find target.
-* Plus AI-native features: pointer scan, group scan, unknown initial value scan.
-*
-* Uses PlatformMemoryAPI for cross-platform memory operations.
-*
-* Performance: addresses stored as bigint internally; only converted to hex
-* strings at API boundaries. This eliminates ~40K+ short-lived string objects
-* and repeated BigInt↔string round-trips during next-scan operations.
-*
-* @module MemoryScanner
-*/
-var MemoryScanner = class {
-	nmm;
-	_provider = null;
-	get provider() {
-		if (!this._provider) this._provider = createPlatformProvider();
-		return this._provider;
-	}
-	constructor(nmm) {
-		this.nmm = nmm;
-	}
-	/**
-	* First scan: scan entire process memory for a value.
-	* Creates a new session, stores matching addresses + values.
-	*/
-	async firstScan(pid, value, options) {
-		const start = performance.now();
-		const valueType = options.valueType;
-		const valueSize = getValueSize(valueType);
-		const alignment = options.alignment ?? getDefaultAlignment(valueType);
-		const maxResults = options.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-		if (valueSize === 0) return this.patternFirstScan(pid, value, valueType, options);
-		const { patternBytes } = parsePattern(value, valueType === "pointer" ? "uint64" : valueType);
-		if (patternBytes.length === 0) throw new Error(`Invalid pattern for type ${valueType}: "${value}"`);
-		const targetBuf = Buffer.from(patternBytes);
-		const sessionId = scanSessionManager.createSession(pid, options);
-		const addresses = [];
-		const values = /* @__PURE__ */ new Map();
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			const regions = this.getFilteredRegions(handle, options);
-			const totalRegions = regions.length;
-			let regionsProcessed = 0;
-			for (const region of regions) {
-				if (options.onProgress) options.onProgress(regionsProcessed, totalRegions);
-				regionsProcessed++;
-				if (addresses.length >= maxResults) break;
-				const regionBase = region.baseAddress;
-				const regionSize = region.size;
-				const chunkSize = 16 * 1024 * 1024;
-				for (let offset = 0; offset < regionSize && addresses.length < maxResults; 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;
-					}
-					if (alignment === valueSize && valueSize > 0) {
-						const alignStep = this.getAlignStep(alignment);
-						let searchFrom = this.getAlignedChunkStart(chunkAddr, alignStep);
-						while (searchFrom <= chunk.length - valueSize && addresses.length < maxResults) {
-							const hit = chunk.indexOf(targetBuf, searchFrom);
-							if (hit === -1) break;
-							if (!this.isAlignedAddress(chunkAddr + BigInt(hit), alignStep)) {
-								searchFrom = hit + 1;
-								continue;
-							}
-							const addr = chunkAddr + BigInt(hit);
-							addresses.push(addr);
-							values.set(addr, Buffer.from(chunk.subarray(hit, hit + valueSize)));
-							searchFrom = hit + alignStep;
-						}
-					} else {
-						const alignStep = this.getAlignStep(alignment);
-						const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
-						for (let i = chunkStart; i <= chunk.length - valueSize; i += alignStep) if (Buffer.compare(chunk.subarray(i, i + valueSize), targetBuf) === 0) {
-							const addr = chunkAddr + BigInt(i);
-							addresses.push(addr);
-							values.set(addr, Buffer.from(chunk.subarray(i, i + valueSize)));
-							if (addresses.length >= maxResults) break;
-						}
-					}
-				}
-			}
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-		scanSessionManager.updateSession(sessionId, addresses, values);
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		const displayAddresses = addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress);
-		return {
-			sessionId,
-			matchCount: addresses.length,
-			scanNumber: 1,
-			addresses: displayAddresses,
-			totalMatches: addresses.length,
-			truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-			elapsed
-		};
-	}
-	/**
-	* Next scan: re-read stored addresses, filter using comparator.
-	*/
-	async nextScan(sessionId, mode, value, value2) {
-		const start = performance.now();
-		const session = scanSessionManager.getSession(sessionId);
-		const { pid, valueType, addresses: prevAddresses, previousValues } = session;
-		const valueSize = getValueSize(valueType);
-		if (valueSize === 0) throw new Error("Next-scan is not supported for variable-length types (hex/string)");
-		let targetBuf = null;
-		let target2Buf = null;
-		if (value !== void 0) {
-			const { patternBytes } = parsePattern(value, valueType === "pointer" ? "uint64" : valueType);
-			targetBuf = Buffer.from(patternBytes);
-		}
-		if (value2 !== void 0) {
-			const { patternBytes } = parsePattern(value2, valueType === "pointer" ? "uint64" : valueType);
-			target2Buf = Buffer.from(patternBytes);
-		}
-		const newAddresses = [];
-		const newValues = /* @__PURE__ */ new Map();
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			for (const addr of prevAddresses) {
-				let currentBuf;
-				try {
-					currentBuf = this.provider.readMemory(handle, addr, valueSize).data;
-				} catch {
-					continue;
-				}
-				const prevBuf = previousValues.get(addr) ?? null;
-				if (compareScanValues(currentBuf, prevBuf, targetBuf, target2Buf, mode, valueType)) {
-					newAddresses.push(addr);
-					newValues.set(addr, Buffer.from(currentBuf));
-				}
-			}
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-		scanSessionManager.updateSession(sessionId, newAddresses, newValues);
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		const displayAddresses = newAddresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress);
-		return {
-			sessionId,
-			matchCount: newAddresses.length,
-			scanNumber: session.scanCount,
-			addresses: displayAddresses,
-			totalMatches: newAddresses.length,
-			truncated: newAddresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-			elapsed
-		};
-	}
-	/**
-	* Unknown initial value scan: captures all readable memory addresses
-	* of the given type, then next-scan narrows.
-	*/
-	async unknownInitialScan(pid, options) {
-		const start = performance.now();
-		const valueType = options.valueType;
-		const valueSize = getValueSize(valueType);
-		const alignment = options.alignment ?? getDefaultAlignment(valueType);
-		const maxAddresses = options.maxResults ?? SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES;
-		if (valueSize === 0) throw new Error("Unknown initial scan is not supported for variable-length types");
-		const sessionId = scanSessionManager.createSession(pid, options);
-		const addresses = [];
-		const values = /* @__PURE__ */ new Map();
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			const regions = this.getFilteredRegions(handle, options);
-			const totalRegions = regions.length;
-			let regionsProcessed = 0;
-			for (const region of regions) {
-				if (options.onProgress) options.onProgress(regionsProcessed, totalRegions);
-				regionsProcessed++;
-				if (addresses.length >= maxAddresses) break;
-				const regionBase = region.baseAddress;
-				const regionSize = region.size;
-				const chunkSize = 16 * 1024 * 1024;
-				for (let offset = 0; offset < regionSize && addresses.length < maxAddresses; 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;
-					}
-					const alignStep = this.getAlignStep(alignment);
-					const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
-					for (let i = chunkStart; i <= chunk.length - valueSize; i += alignStep) {
-						const addr = chunkAddr + BigInt(i);
-						addresses.push(addr);
-						values.set(addr, Buffer.from(chunk.subarray(i, i + valueSize)));
-						if (addresses.length >= maxAddresses) break;
-					}
-				}
-			}
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-		scanSessionManager.updateSession(sessionId, addresses, values);
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		return {
-			sessionId,
-			matchCount: addresses.length,
-			scanNumber: 1,
-			addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-			totalMatches: addresses.length,
-			truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-			elapsed
-		};
-	}
-	/**
-	* Pointer scan: find addresses whose value points to a valid target address.
-	*/
-	async pointerScan(pid, targetAddress, options = {}) {
-		const start = performance.now();
-		const maxResults = options.maxResults ?? SCAN_POINTER_MAX_RESULTS;
-		const targetAddr = parseAddress(targetAddress);
-		const scanOptions = {
-			valueType: "pointer",
-			alignment: 8,
-			regionFilter: { moduleOnly: options.moduleOnly }
-		};
-		const sessionId = scanSessionManager.createSession(pid, scanOptions);
-		const pointers = [];
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			const regions = this.getFilteredRegions(handle, scanOptions);
-			for (const region of regions) {
-				if (options.moduleOnly) {}
-				if (pointers.length >= maxResults) break;
-				const regionBase = region.baseAddress;
-				const regionSize = region.size;
-				const chunkSize = 16 * 1024 * 1024;
-				for (let offset = 0; offset < regionSize && pointers.length < maxResults; 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 += 8) {
-						const ptrValue = chunk.readBigUInt64LE(i);
-						if ((ptrValue > targetAddr ? Number(ptrValue - targetAddr) : Number(targetAddr - ptrValue)) <= 4096) {
-							const addr = chunkAddr + BigInt(i);
-							const offsetFromTarget = ptrValue >= targetAddr ? Number(ptrValue - targetAddr) : -Number(targetAddr - ptrValue);
-							pointers.push({
-								address: formatAddress(addr),
-								value: formatAddress(ptrValue),
-								offsetFromTarget
-							});
-							if (pointers.length >= maxResults) break;
-						}
-					}
-				}
-			}
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-		const addresses = pointers.map((p) => parseAddress(p.address));
-		scanSessionManager.updateSession(sessionId, addresses, /* @__PURE__ */ new Map());
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		return {
-			sessionId,
-			pointers: pointers.slice(0, SCAN_DISPLAY_RESULTS_LIMIT),
-			totalFound: pointers.length,
-			elapsed
-		};
-	}
-	/**
-	* Group scan: search for N values at known offsets simultaneously.
-	*/
-	async groupScan(pid, pattern, options) {
-		const start = performance.now();
-		if (pattern.length === 0) throw new Error("Group scan requires at least one value pattern");
-		const maxOffset = Math.max(...pattern.map((p) => p.offset + getValueSize(p.type)));
-		if (maxOffset > SCAN_GROUP_MAX_PATTERN_SIZE) throw new Error(`Group pattern too large: ${maxOffset} bytes (max ${SCAN_GROUP_MAX_PATTERN_SIZE})`);
-		const compositePattern = Array.from({ length: maxOffset }, () => 0);
-		const compositeMask = Array.from({ length: maxOffset }, () => 0);
-		for (const entry of pattern) {
-			const effectiveType = entry.type === "pointer" ? "uint64" : entry.type;
-			const { patternBytes, mask } = parsePattern(entry.value, effectiveType);
-			for (let i = 0; i < patternBytes.length; i++) {
-				compositePattern[entry.offset + i] = patternBytes[i];
-				compositeMask[entry.offset + i] = mask[i];
-			}
-		}
-		const alignment = options?.alignment ?? 4;
-		const maxResults = options?.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-		const scanOptions = {
-			valueType: "int32",
-			alignment
-		};
-		const sessionId = scanSessionManager.createSession(pid, scanOptions);
-		const addresses = [];
-		const handle = this.provider.openProcess(pid, false);
-		try {
-			const regions = this.getFilteredRegions(handle, scanOptions);
-			for (const region of regions) {
-				if (addresses.length >= maxResults) break;
-				const regionBase = region.baseAddress;
-				const regionSize = region.size;
-				const chunkSize = 16 * 1024 * 1024;
-				const overlap = maxOffset - 1;
-				for (let chunkOffset = 0; chunkOffset < regionSize && addresses.length < maxResults; chunkOffset += chunkSize) {
-					const readSize = Math.min(chunkSize + overlap, regionSize - chunkOffset);
-					const chunkAddr = regionBase + BigInt(chunkOffset);
-					let chunk;
-					try {
-						chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-					} catch {
-						break;
-					}
-					const alignStep = this.getAlignStep(alignment);
-					const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
-					for (let i = chunkStart; i <= chunk.length - maxOffset; i += alignStep) {
-						let match = true;
-						for (let j = 0; j < maxOffset; j++) if (compositeMask[j] === 1 && chunk[i + j] !== compositePattern[j]) {
-							match = false;
-							break;
-						}
-						if (match) {
-							const addr = chunkAddr + BigInt(i);
-							addresses.push(addr);
-							if (addresses.length >= maxResults) break;
-						}
-					}
-				}
-			}
-		} finally {
-			this.provider.closeProcess(handle);
-		}
-		scanSessionManager.updateSession(sessionId, addresses, /* @__PURE__ */ new Map());
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		return {
-			sessionId,
-			matchCount: addresses.length,
-			scanNumber: 1,
-			addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-			totalMatches: addresses.length,
-			truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-			elapsed
-		};
-	}
-	getAlignStep(alignment) {
-		return alignment > 0 ? alignment : 1;
-	}
-	getAlignedChunkStart(chunkAddr, alignStep) {
-		const align = BigInt(alignStep);
-		const remainder = chunkAddr % align;
-		return remainder === 0n ? 0 : Number(align - remainder);
-	}
-	isAlignedAddress(address, alignStep) {
-		return address % BigInt(alignStep) === 0n;
-	}
-	/**
-	* Pattern-based first scan for variable-length types (hex/string).
-	* Delegates to existing NativeMemoryManager.scanMemory.
-	*/
-	async patternFirstScan(pid, value, valueType, options) {
-		const start = performance.now();
-		const patternType = valueType === "pointer" ? "uint64" : valueType;
-		const result = await this.nmm.scanMemory(pid, value, patternType);
-		if (!result.success) throw new Error(result.error ?? "Scan failed");
-		const sessionId = scanSessionManager.createSession(pid, options);
-		const maxResultCount = options.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-		const addresses = result.addresses.slice(0, maxResultCount).map(parseAddress);
-		scanSessionManager.updateSession(sessionId, addresses, /* @__PURE__ */ new Map());
-		const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-		return {
-			sessionId,
-			matchCount: addresses.length,
-			scanNumber: 1,
-			addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-			totalMatches: result.addresses.length,
-			truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-			elapsed
-		};
-	}
-	/**
-	* Get readable memory regions, applying region filters.
-	* Uses PlatformMemoryAPI.queryRegion() for cross-platform support.
-	*/
-	getFilteredRegions(handle, options) {
-		const regions = [];
-		let address = 0n;
-		const maxAddress = BigInt("0x7FFFFFFF0000");
-		const filter = options.regionFilter;
-		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) {
-				let include = true;
-				if (filter?.writable && !regionInfo.isWritable) include = false;
-				if (filter?.executable && !regionInfo.isExecutable) include = false;
-				if (filter?.moduleOnly && regionInfo.type !== "image") include = false;
-				if (include) regions.push({
-					baseAddress: regionInfo.baseAddress,
-					size: regionSize
-				});
-			}
-			address = regionInfo.baseAddress + BigInt(regionInfo.size);
-		}
-		return regions;
-	}
-};
-const memoryScanner = new MemoryScanner(nativeMemoryManager);
-//#endregion
-export { MemoryScanner, memoryScanner };