@memoryprocess/mcp 0.0.1 → 0.0.3-beta.2

package/README.md

@@ -1,6 +1,6 @@
 # @memoryprocess/mcp
 
-MCP server exposing the memoryprocess toolkit to LLM agents — the primary
+MCP server exposing the memoryprocess toolkit to LLM agents - the primary
 agentic surface. Stdio transport; the agent's MCP client owns the server
 process, so open process handles die with the session.
 
@@ -28,7 +28,7 @@ MEMP_NO_EVAL=1   # same as --no-eval
 ## Session model
 
 There is no implicit "current process". `proc_open` returns a session handle
-(`p1`, `p2`, …); every `mem_*` tool takes it as `session`, so an agent can
+(`p1`, `p2`, ...); every `mem_*` tool takes it as `session`, so an agent can
 hold several targets at once. `proc_close` releases the handle and any
 watches/freezes bound to it.
 
@@ -37,38 +37,38 @@ watches/freezes bound to it.
 | Tool                  | Description                                                                                              |
 | --------------------- | -------------------------------------------------------------------------------------------------------- |
 | `proc_list`           | List running processes `{pid,name}[]`                                                                    |
-| `proc_open`           | Open by `{pid}` or `{name}` → `{session, describe}`. `access:"ro"` = read-only                           |
+| `proc_open`           | Open by `{pid}` or `{name}` -> `{session, describe}`. `access:"ro"` = read-only                          |
 | `proc_close`          | Close a session                                                                                          |
 | `mem_describe`        | `Process.describe()`: arch, modules, writable/exec regions, threads                                      |
-| `mem_read`            | Typed read: `i8…i64/u8…u64`, `f32/f64`, `ptr`, `str`, `wstr`, `bytes[:N]` (+`len`)                       |
-| `mem_write`           | Typed write. `dryRun:true` → `{addr,current,would,bytes}` preview. Journaled                             |
-| `mem_scan`            | CE value scan → `{hits:[{addr,value}],count,truncated}` (`module`/`start`/`end`/`limit`)                 |
+| `mem_read`            | Typed read: `i8...i64/u8...u64`, `f32/f64`, `ptr`, `str`, `wstr`, `bytes[:N]` (+`len`)                   |
+| `mem_write`           | Typed write. `dryRun:true` -> `{addr,current,would,bytes}` preview. Journaled                            |
+| `mem_scan`            | CE value scan -> `{hits:[{addr,value}],count,truncated}` (`module`/`start`/`end`/`limit`)                |
 | `mem_scan_next`       | Refine hits: `exact`/`changed`/`unchanged`/`increased`/`decreased`/`increasedBy`/`decreasedBy`/`between` |
-| `mem_pointer_resolve` | `module`+`rva`+`offsets[]` → resolved address (CE pointer syntax)                                        |
-| `mem_watch`           | Poll an i32 every `ms` → `{watchId}`; changes accumulate                                                 |
+| `mem_pointer_resolve` | `module`+`rva`+`offsets[]` -> resolved address (CE pointer syntax)                                       |
+| `mem_watch`           | Poll an i32 every `ms` -> `{watchId}`; changes accumulate                                                |
 | `mem_watch_poll`      | Drain recorded changes `[{value,ts}]` for a `watchId`                                                    |
 | `mem_unwatch`         | Stop a watch                                                                                             |
-| `mem_freeze`          | Re-write a value every `ms` → `{freezeId}`                                                               |
+| `mem_freeze`          | Re-write a value every `ms` -> `{freezeId}`                                                              |
 | `mem_unfreeze`        | Stop a freeze                                                                                            |
 | `mem_undo`            | Revert last `n` journaled writes (self-correction primitive)                                             |
 | `mem_journal`         | Write-log snapshot `[{index,addr,bytes}]`                                                                |
-| `eval_js`             | Run JS with `proc` (`Process`) in scope — the escape hatch                                               |
+| `eval_js`             | Run JS with `proc` (`Process`) in scope - the escape hatch                                               |
 
 ## Wire format (docs/json-conventions.md)
 
 - Every result is `{ok:true,data}` or `{ok:false,error:{code,message,win32code?}}`
-  — `error.code` is the typed code from `@memoryprocess/core`
-  (`READ_FAILED`, `PROCESS_NOT_FOUND`, …) plus `UNKNOWN_SESSION`,
+- `error.code` is the typed code from `@memoryprocess/core`
+  (`READ_FAILED`, `PROCESS_NOT_FOUND`, ...) plus `UNKNOWN_SESSION`,
   `UNKNOWN_WATCH`, `UNKNOWN_FREEZE`, `MODULE_NOT_FOUND`, `INVALID_ARGS`,
   `EVAL_ERROR`.
-- Addresses/pointers/64-bit values are `"0x…"` hex strings; values that fit
+- Addresses/pointers/64-bit values are `"0x..."` hex strings; values that fit
   in a JS number stay numbers; raw bytes are hex strings.
-- Address args accept `"0x…"`, decimal strings, or `"module+rva"`.
+- Address args accept `"0x..."`, decimal strings, or `"module+rva"`.
 
 ## Safety
 
-All writes are journaled → `mem_journal` + `mem_undo` let an agent preview
+All writes are journaled -> `mem_journal` + `mem_undo` let an agent preview
 (`dryRun`), commit, inspect, and revert. `eval_js` runs arbitrary JS on the
-host — it's on by default (agents already have code execution) and can be
+host - it's on by default (agents already have code execution) and can be
 disabled with `--no-eval` / `MEMP_NO_EVAL=1`, which omits it from
 `tools/list` entirely.

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