@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/MemoryController-DdtnBdD4.mjs

@@ -0,0 +1,167 @@
+import { cr as WRITE_HISTORY_MAX, q as FREEZE_DEFAULT_INTERVAL_MS } from "./constants-CCvsN80K.mjs";
+import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, m as VirtualProtectEx, t as CloseHandle, u as PAGE } from "./Win32API-Bc0QnQsN.mjs";
+import { i as parsePattern } from "./NativeMemoryManager.utils-BML4q1ry.mjs";
+import { randomUUID } from "node:crypto";
+//#region src/native/MemoryController.ts
+/**
+* Memory Controller — freeze, undo/redo writes, memory dump.
+*
+* @module MemoryController
+*/
+var MemoryController = class {
+	freezes = /* @__PURE__ */ new Map();
+	writeHistory = [];
+	undoneStack = [];
+	/** Write a typed value to memory (with undo support) */
+	async writeValue(pid, address, value, valueType) {
+		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
+		const { patternBytes } = parsePattern(value, valueType);
+		const newBuf = Buffer.from(patternBytes);
+		const handle = openProcessForMemory(pid, true);
+		try {
+			const oldBuf = ReadProcessMemory(handle, addr, newBuf.length);
+			const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
+			WriteProcessMemory(handle, addr, newBuf);
+			VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
+			const entry = {
+				id: randomUUID(),
+				pid,
+				address: `0x${addr.toString(16).toUpperCase()}`,
+				oldValue: Array.from(oldBuf),
+				newValue: Array.from(newBuf),
+				timestamp: Date.now(),
+				undone: false
+			};
+			this.writeHistory.push(entry);
+			this.undoneStack = [];
+			if (this.writeHistory.length > WRITE_HISTORY_MAX) this.writeHistory = this.writeHistory.slice(-WRITE_HISTORY_MAX);
+			return entry;
+		} finally {
+			CloseHandle(handle);
+		}
+	}
+	/** Undo last write */
+	async undo() {
+		for (let i = this.writeHistory.length - 1; i >= 0; i--) {
+			const entry = this.writeHistory[i];
+			if (!entry.undone) {
+				const addr = BigInt(entry.address);
+				const oldBuf = Buffer.from(entry.oldValue);
+				const handle = openProcessForMemory(entry.pid, true);
+				try {
+					const { oldProtect } = VirtualProtectEx(handle, addr, oldBuf.length, PAGE.READWRITE);
+					WriteProcessMemory(handle, addr, oldBuf);
+					VirtualProtectEx(handle, addr, oldBuf.length, oldProtect);
+				} finally {
+					CloseHandle(handle);
+				}
+				entry.undone = true;
+				this.undoneStack.push(entry);
+				return entry;
+			}
+		}
+		return null;
+	}
+	/** Redo last undone write */
+	async redo() {
+		const entry = this.undoneStack.pop();
+		if (!entry) return null;
+		const addr = BigInt(entry.address);
+		const newBuf = Buffer.from(entry.newValue);
+		const handle = openProcessForMemory(entry.pid, true);
+		try {
+			const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
+			WriteProcessMemory(handle, addr, newBuf);
+			VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
+		} finally {
+			CloseHandle(handle);
+		}
+		entry.undone = false;
+		return entry;
+	}
+	/** Freeze: continuously write value at interval */
+	async freeze(pid, address, value, valueType, intervalMs) {
+		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
+		const { patternBytes } = parsePattern(value, valueType);
+		const valueBuf = Buffer.from(patternBytes);
+		const interval = intervalMs ?? FREEZE_DEFAULT_INTERVAL_MS;
+		const entry = {
+			id: randomUUID(),
+			pid,
+			address: `0x${addr.toString(16).toUpperCase()}`,
+			value: Array.from(valueBuf),
+			valueType,
+			intervalMs: interval,
+			isActive: true
+		};
+		entry.timer = setInterval(() => {
+			try {
+				const handle = openProcessForMemory(pid, true);
+				try {
+					const { oldProtect } = VirtualProtectEx(handle, addr, valueBuf.length, PAGE.READWRITE);
+					WriteProcessMemory(handle, addr, valueBuf);
+					VirtualProtectEx(handle, addr, valueBuf.length, oldProtect);
+				} finally {
+					CloseHandle(handle);
+				}
+			} catch {
+				entry.isActive = false;
+				if (entry.timer) clearInterval(entry.timer);
+			}
+		}, interval);
+		this.freezes.set(entry.id, entry);
+		return entry;
+	}
+	/** Unfreeze */
+	async unfreeze(freezeId) {
+		const entry = this.freezes.get(freezeId);
+		if (!entry) return false;
+		if (entry.timer) clearInterval(entry.timer);
+		entry.isActive = false;
+		this.freezes.delete(freezeId);
+		return true;
+	}
+	/** Unfreeze all */
+	async unfreezeAll() {
+		let count = 0;
+		for (const [id] of this.freezes) {
+			await this.unfreeze(id);
+			count++;
+		}
+		return count;
+	}
+	/** List all active freezes */
+	listFreezes() {
+		return Array.from(this.freezes.values()).map(({ timer: _timer, ...rest }) => rest);
+	}
+	/** Dump memory region to Buffer */
+	async dumpMemory(pid, address, size) {
+		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
+		const handle = openProcessForMemory(pid, false);
+		try {
+			return ReadProcessMemory(handle, addr, size);
+		} finally {
+			CloseHandle(handle);
+		}
+	}
+	/** Dump memory region as hex string */
+	async dumpMemoryHex(pid, address, size) {
+		const buf = await this.dumpMemory(pid, address, size);
+		const lines = [];
+		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
+		for (let i = 0; i < buf.length; i += 16) {
+			const lineAddr = addr + BigInt(i);
+			const hex = Array.from(buf.subarray(i, Math.min(i + 16, buf.length))).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+			const ascii = Array.from(buf.subarray(i, Math.min(i + 16, buf.length))).map((b) => b >= 32 && b <= 126 ? String.fromCharCode(b) : ".").join("");
+			lines.push(`${lineAddr.toString(16).padStart(12, "0")}  ${hex.padEnd(47)}  |${ascii}|`);
+		}
+		return lines.join("\n");
+	}
+	/** Get write history */
+	getWriteHistory() {
+		return [...this.writeHistory];
+	}
+};
+const memoryController = new MemoryController();
+//#endregion
+export { MemoryController, memoryController };

package/dist/MemoryScanSession-RMixN3bX.mjs

@@ -0,0 +1,275 @@
+import { Gt as SCAN_SESSION_MAX_COUNT, Kt as SCAN_SESSION_TTL_MS } from "./constants-CCvsN80K.mjs";
+import { n as parseAddress, t as formatAddress } from "./formatAddress-ChCSIRWT.mjs";
+import { randomUUID } from "node:crypto";
+//#region src/native/ScanComparators.ts
+const FLOAT_EPSILON = 1e-6;
+const DOUBLE_EPSILON = 1e-12;
+/**
+* Return the byte width for a given scan value type.
+*/
+function getValueSize(type) {
+	switch (type) {
+		case "byte":
+		case "int8": return 1;
+		case "int16":
+		case "uint16": return 2;
+		case "int32":
+		case "uint32":
+		case "float": return 4;
+		case "int64":
+		case "uint64":
+		case "double":
+		case "pointer": return 8;
+		case "hex":
+		case "string": return 0;
+		default: return 4;
+	}
+}
+/**
+* Return the natural alignment for a given value type.
+*/
+function getDefaultAlignment(type) {
+	switch (type) {
+		case "byte":
+		case "int8": return 1;
+		case "int16":
+		case "uint16": return 2;
+		case "int32":
+		case "uint32":
+		case "float": return 4;
+		case "int64":
+		case "uint64":
+		case "double":
+		case "pointer": return 8;
+		default: return 1;
+	}
+}
+/**
+* Read a typed numeric value from a buffer at offset 0.
+*/
+function readTypedValue(buf, type) {
+	switch (type) {
+		case "byte": return buf.readUInt8(0);
+		case "int8": return buf.readInt8(0);
+		case "int16": return buf.readInt16LE(0);
+		case "uint16": return buf.readUInt16LE(0);
+		case "int32": return buf.readInt32LE(0);
+		case "uint32": return buf.readUInt32LE(0);
+		case "int64": return buf.readBigInt64LE(0);
+		case "uint64":
+		case "pointer": return buf.readBigUInt64LE(0);
+		case "float": return buf.readFloatLE(0);
+		case "double": return buf.readDoubleLE(0);
+		default: return buf.readInt32LE(0);
+	}
+}
+/**
+* Check if two numeric values are approximately equal, using epsilon for floats.
+*/
+function approxEqual(a, b, type) {
+	if (typeof a === "bigint" && typeof b === "bigint") return a === b;
+	const na = Number(a);
+	const nb = Number(b);
+	if (type === "float") return Math.abs(na - nb) < FLOAT_EPSILON;
+	if (type === "double") return Math.abs(na - nb) < DOUBLE_EPSILON;
+	return na === nb;
+}
+/**
+* Compare a numeric value against another for ordering.
+* Returns negative if a < b, 0 if equal, positive if a > b.
+*/
+function compareValues(a, b) {
+	if (typeof a === "bigint" && typeof b === "bigint") {
+		if (a < b) return -1;
+		if (a > b) return 1;
+		return 0;
+	}
+	return Number(a) - Number(b);
+}
+/**
+* Compare scan values according to the specified mode.
+*
+* @param current  - Current value buffer read from memory
+* @param previous - Previous value buffer from last scan (null on first scan)
+* @param target   - Target value buffer for exact/greater/less/not_equal comparisons
+* @param target2  - Second target value buffer for 'between' mode (upper bound)
+* @param mode     - Comparison mode
+* @param valueType - Value type for proper reading
+*/
+function compareScanValues(current, previous, target, target2, mode, valueType) {
+	const cur = readTypedValue(current, valueType);
+	switch (mode) {
+		case "exact":
+			if (!target) return false;
+			return approxEqual(cur, readTypedValue(target, valueType), valueType);
+		case "unknown_initial": return true;
+		case "changed":
+			if (!previous) return false;
+			return !approxEqual(cur, readTypedValue(previous, valueType), valueType);
+		case "unchanged":
+			if (!previous) return true;
+			return approxEqual(cur, readTypedValue(previous, valueType), valueType);
+		case "increased":
+			if (!previous) return false;
+			return compareValues(cur, readTypedValue(previous, valueType)) > 0;
+		case "decreased":
+			if (!previous) return false;
+			return compareValues(cur, readTypedValue(previous, valueType)) < 0;
+		case "greater_than":
+			if (!target) return false;
+			return compareValues(cur, readTypedValue(target, valueType)) > 0;
+		case "less_than":
+			if (!target) return false;
+			return compareValues(cur, readTypedValue(target, valueType)) < 0;
+		case "between": {
+			if (!target || !target2) return false;
+			const lo = readTypedValue(target, valueType);
+			const hi = readTypedValue(target2, valueType);
+			return compareValues(cur, lo) >= 0 && compareValues(cur, hi) <= 0;
+		}
+		case "not_equal":
+			if (!target) return false;
+			return !approxEqual(cur, readTypedValue(target, valueType), valueType);
+		default: return false;
+	}
+}
+//#endregion
+//#region src/native/MemoryScanSession.ts
+/**
+* Scan Session Manager — manages in-memory scan sessions for iterative scanning.
+*
+* Sessions persist scan results across multiple scan iterations, allowing
+* the CE-style workflow: first scan → next scan → narrow down → find target.
+*
+* @module MemoryScanSession
+*/
+var MemoryScanSessionManager = class {
+	sessions = /* @__PURE__ */ new Map();
+	maxSessions;
+	sessionTtlMs;
+	constructor(maxSessions = SCAN_SESSION_MAX_COUNT, sessionTtlMs = SCAN_SESSION_TTL_MS) {
+		this.maxSessions = maxSessions;
+		this.sessionTtlMs = sessionTtlMs;
+	}
+	/** Create a new scan session for a given PID and value type. */
+	createSession(pid, options) {
+		this.cleanup();
+		if (this.sessions.size >= this.maxSessions) {
+			let oldestId = null;
+			let oldestTime = Infinity;
+			for (const [id, session] of this.sessions) if (session.createdAt < oldestTime) {
+				oldestTime = session.createdAt;
+				oldestId = id;
+			}
+			if (oldestId) this.sessions.delete(oldestId);
+		}
+		const id = randomUUID();
+		const alignment = options.alignment ?? getDefaultAlignment(options.valueType);
+		const now = Date.now();
+		const session = {
+			id,
+			pid,
+			valueType: options.valueType,
+			alignment,
+			createdAt: now,
+			lastScanAt: now,
+			scanCount: 0,
+			addresses: [],
+			previousValues: /* @__PURE__ */ new Map()
+		};
+		this.sessions.set(id, session);
+		return id;
+	}
+	/** Get session by ID. Throws if not found or expired. */
+	getSession(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) throw new Error(`Scan session not found: ${sessionId}`);
+		if (Date.now() - session.lastScanAt > this.sessionTtlMs) {
+			this.sessions.delete(sessionId);
+			throw new Error(`Scan session expired: ${sessionId}`);
+		}
+		return session;
+	}
+	/** Update session with new scan results (bigint addresses). */
+	updateSession(sessionId, addresses, values) {
+		const session = this.getSession(sessionId);
+		session.addresses = addresses;
+		session.previousValues = values;
+		session.lastScanAt = Date.now();
+		session.scanCount++;
+	}
+	/** List all active sessions. */
+	listSessions() {
+		this.cleanup();
+		const result = [];
+		const now = Date.now();
+		for (const session of this.sessions.values()) {
+			const ageMs = now - session.createdAt;
+			const ageMin = Math.floor(ageMs / 6e4);
+			const ageSec = Math.floor(ageMs % 6e4 / 1e3);
+			result.push({
+				id: session.id,
+				pid: session.pid,
+				valueType: session.valueType,
+				addressCount: session.addresses.length,
+				scanCount: session.scanCount,
+				age: ageMin > 0 ? `${ageMin}m${ageSec}s` : `${ageSec}s`
+			});
+		}
+		return result;
+	}
+	/** Delete a session. */
+	deleteSession(sessionId) {
+		return this.sessions.delete(sessionId);
+	}
+	/** Clean up expired sessions. Returns count of cleaned sessions. */
+	cleanup() {
+		const now = Date.now();
+		let count = 0;
+		for (const [id, session] of this.sessions) if (now - session.lastScanAt > this.sessionTtlMs) {
+			this.sessions.delete(id);
+			count++;
+		}
+		return count;
+	}
+	/** Export session data for persistence (JSON serialization). */
+	exportSession(sessionId) {
+		const session = this.getSession(sessionId);
+		const serializable = {
+			...session,
+			addresses: session.addresses.map((addr) => formatAddress(addr)),
+			previousValues: Array.from(session.previousValues.entries()).map(([addr, buf]) => [formatAddress(addr), buf.toString("hex")])
+		};
+		return JSON.stringify(serializable);
+	}
+	/** Import session from exported JSON data. Returns new session id. */
+	importSession(data) {
+		const parsed = JSON.parse(data);
+		const id = randomUUID();
+		const now = Date.now();
+		const previousValues = /* @__PURE__ */ new Map();
+		if (Array.isArray(parsed.previousValues)) {
+			for (const [addr, hex] of parsed.previousValues) if (typeof addr === "string" && typeof hex === "string") previousValues.set(parseAddress(addr), Buffer.from(hex, "hex"));
+		}
+		const addresses = [];
+		if (Array.isArray(parsed.addresses)) {
+			for (const addr of parsed.addresses) if (typeof addr === "string") addresses.push(parseAddress(addr));
+		}
+		const session = {
+			id,
+			pid: parsed.pid,
+			valueType: parsed.valueType,
+			alignment: parsed.alignment ?? 4,
+			createdAt: now,
+			lastScanAt: now,
+			scanCount: parsed.scanCount ?? 0,
+			addresses,
+			previousValues
+		};
+		this.sessions.set(id, session);
+		return id;
+	}
+};
+const scanSessionManager = new MemoryScanSessionManager();
+//#endregion
+export { MemoryScanSessionManager, getDefaultAlignment as n, getValueSize as r, scanSessionManager, compareScanValues as t };