@memoryprocess/mcp 0.0.1 → 0.0.3-beta.1

package/dist/server.mjs

@@ -16,7 +16,7 @@ import { MemoryProcessError, Process } from "@memoryprocess/core";
 *
 * Wire format follows docs/json-conventions.md:
 *  - every result is `{ok:true,data} | {ok:false,error:{code,message,win32code?}}`
-*  - bigints (addresses, pointers, 64-bit values) -> '0x…' strings
+*  - bigints (addresses, pointers, 64-bit values) -> '0x...' strings
 *  - Buffers -> lowercase hex strings
 *  - errors carry the typed `.code` from @memoryprocess/core when available
 */
@@ -57,8 +57,8 @@ function errorEnvelope(e) {
 	};
 }
 /**
-* Parse an address argument: `0x…` hex string, decimal string, or
-* `"module+rva"` (resolved against the session's module table — the rva is
+* Parse an address argument: `0x...` hex string, decimal string, or
+* `"module+rva"` (resolved against the session's module table -- the rva is
 * optional). Returns the absolute address as bigint.
 */
 function parseAddress(proc, v, name = "addr") {
@@ -117,9 +117,9 @@ function parseNumeric(v, wide, name = "value") {
 }
 /** Agent-facing type aliases -> core WriteValueType/ScanValueType. */
 const NUMERIC_TYPES = {
-	i8: "uint8",
+	i8: "int8",
 	u8: "uint8",
-	i16: "uint16",
+	i16: "int16",
 	u16: "uint16",
 	i32: "int32",
 	u32: "uint32",
@@ -345,7 +345,7 @@ function parseHits(raw, type) {
 	});
 }
 const sessionArg = { session: z.string().describe("session handle from proc_open") };
-const addrArg = z.union([z.string(), z.number()]).describe("address: \"0x…\" hex, decimal, or \"module+rva\"");
+const addrArg = z.union([z.string(), z.number()]).describe("address: \"0x...\" hex, decimal, or \"module+rva\"");
 const typeArg = z.string().describe("i8 u8 i16 u16 i32 u32 i64 u64 f32 f64 ptr str wstr bytes[:N]");
 const toolDefs = {
 	proc_list: {
@@ -401,7 +401,7 @@ const toolDefs = {
 		}
 	},
 	mem_write: {
-		description: "Write a typed value (journaled — reversible via mem_undo). dryRun:true returns {addr,current,would,bytes} WITHOUT writing.",
+		description: "Write a typed value (journaled -- reversible via mem_undo). dryRun:true returns {addr,current,would,bytes} WITHOUT writing.",
 		schema: {
 			...sessionArg,
 			addr: addrArg,
@@ -521,6 +521,62 @@ const toolDefs = {
 			};
 		}
 	},
+	mem_scan_pattern: {
+		description: "AOB signature scan: find all matches of a byte pattern like \"48 8B ?? 10\" (\"??\" wildcards). Returns {hits:[hexaddr],count,truncated}.",
+		schema: {
+			...sessionArg,
+			pattern: z.string().describe("byte pattern, hex bytes separated by spaces, \"??\" wildcards"),
+			module: z.string().optional().describe("restrict to a module"),
+			section: z.string().optional().describe("restrict to a PE section of `module` (e.g. \".text\")"),
+			start: addrArg.optional().describe("range start"),
+			end: addrArg.optional().describe("range end"),
+			onlyReadable: z.boolean().optional().describe("only scan readable regions (default true)"),
+			limit: z.number().int().positive().optional().describe("max hits returned (default 1000)")
+		},
+		handler: async (s, a) => {
+			const proc = s.get(a.session);
+			if (typeof a.pattern !== "string" || !a.pattern.trim()) throw fail("INVALID_ARGS", "mem_scan_pattern needs a pattern string");
+			const hits = await proc.scan(a.pattern, {
+				module: a.module,
+				section: a.section,
+				start: a.start !== void 0 ? parseAddress(proc, a.start, "start") : void 0,
+				end: a.end !== void 0 ? parseAddress(proc, a.end, "end") : void 0,
+				onlyReadable: a.onlyReadable
+			});
+			const limit = a.limit ?? 1e3;
+			return {
+				count: hits.length,
+				truncated: hits.length > limit,
+				hits: hits.slice(0, limit).map((h) => hex(h))
+			};
+		}
+	},
+	mem_regions: {
+		description: "VirtualQueryEx map of the target's memory regions: [{base,size,protect,state,type}] -- base/size are hex, protect/state/type are hex flag values. writableOnly/executableOnly filter on protection.",
+		schema: {
+			...sessionArg,
+			writableOnly: z.boolean().optional().describe("only regions whose protection allows writes"),
+			executableOnly: z.boolean().optional().describe("only regions whose protection allows execution")
+		},
+		handler: (s, a) => {
+			const proc = s.get(a.session);
+			const WRITABLE = 204;
+			const EXECUTABLE = 240;
+			let regions = proc.regions();
+			if (a.writableOnly === true) regions = regions.filter((r) => (r.protection & WRITABLE) !== 0);
+			if (a.executableOnly === true) regions = regions.filter((r) => (r.protection & EXECUTABLE) !== 0);
+			return {
+				count: regions.length,
+				regions: regions.map((r) => ({
+					base: hex(r.baseAddress),
+					size: hex(r.size),
+					protect: hex(r.protection),
+					state: hex(4096),
+					type: hex(r.type)
+				}))
+			};
+		}
+	},
 	mem_pointer_resolve: {
 		description: "Resolve module+rva plus a pointer chain: base = module base + rva, then dereference each offset (CE \"module.exe+RVA, offsets\" style).",
 		schema: {
@@ -609,8 +665,19 @@ const toolDefs = {
 			const addr = parseAddress(proc, a.addr);
 			const type = normType(a.type);
 			if (type === "str" || type === "wstr" || type === "bytes") throw fail("INVALID_ARGS", `freeze needs a numeric type, got "${a.type}"`);
-			const coreType = type === "int8" || type === "int16" ? type === "int8" ? "uint8" : "uint16" : type;
-			const stop = proc.freeze(addr, coreType, parseNumeric(a.value, WIDE_TYPES.has(type)), a.ms ?? 50);
+			const ms = a.ms ?? 50;
+			let stop;
+			if (type === "int8" || type === "uint8" || type === "int16" || type === "uint16") {
+				const v = Number(parseNumeric(a.value, false));
+				const write = type === "int8" || type === "uint8" ? () => proc.writeUInt8(addr, v & 255) : () => proc.writeUInt16(addr, v & 65535);
+				const timer = setInterval(() => {
+					try {
+						write();
+					} catch {}
+				}, ms);
+				if (typeof timer.unref === "function") timer.unref();
+				stop = () => clearInterval(timer);
+			} else stop = proc.freeze(addr, type, parseNumeric(a.value, WIDE_TYPES.has(type)), ms);
 			return { freezeId: s.addFreeze(a.session, stop) };
 		}
 	},
@@ -623,7 +690,7 @@ const toolDefs = {
 		}
 	},
 	mem_undo: {
-		description: "Revert the last n journaled writes (default 1), most-recent first — the self-correction primitive.",
+		description: "Revert the last n journaled writes (default 1), most-recent first -- the self-correction primitive.",
 		schema: {
 			...sessionArg,
 			n: z.number().int().positive().optional()
@@ -634,12 +701,12 @@ const toolDefs = {
 		}
 	},
 	mem_journal: {
-		description: "Snapshot of the write journal for this session: [{index,addr,bytes|null}] — bytes is the pre-write hex that undo() restores.",
+		description: "Snapshot of the write journal for this session: [{index,addr,bytes|null}] -- bytes is the pre-write hex that undo() restores.",
 		schema: sessionArg,
 		handler: (s, a) => s.get(a.session).writeLog
 	},
 	eval_js: {
-		description: "Escape hatch: run JS with the bound Process in scope as `proc`. Code is wrapped in an async body — use `return` for a result, `await` is allowed.",
+		description: "Escape hatch: run JS with the bound Process in scope as `proc`. Code is wrapped in an async body -- use `return` for a result, `await` is allowed.",
 		schema: {
 			...sessionArg,
 			code: z.string().describe("JS body; `proc` is the open Process")
@@ -683,7 +750,7 @@ async function callTool(sessions, name, args, opts = {}) {
 }
 // src/server.ts
 /**
-* @memoryprocess/mcp — MCP server exposing the memoryprocess toolkit to
+* @memoryprocess/mcp -- MCP server exposing the memoryprocess toolkit to
 * LLM agents over stdio (the primary agentic surface).
 *
 * Usage:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoryprocess/mcp",
-  "version": "0.0.1",
+  "version": "0.0.3-beta.1",
   "description": "MCP server exposing the memoryprocess toolkit to LLM agents — the primary agentic surface.",
   "type": "module",
   "packageManager": "bun@1.4.4",
@@ -45,7 +45,7 @@
     "agent"
   ],
   "dependencies": {
-    "@memoryprocess/core": "0.0.1",
+    "@memoryprocess/core": "workspace:*",
     "@modelcontextprotocol/sdk": "^1.32.2",
     "zod": "^4.6.7"
   },