c64-debug-mcp 1.0.10 → 1.0.11

package/dist/http.cjs

@@ -213,7 +213,7 @@ function parseAddress16(input) {
   }
   return parsed;
 }
-var address16Schema = import_zod2.z.preprocess(parseAddress16, import_zod2.z.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
+var address16Schema = import_zod2.z.union([import_zod2.z.number().int().min(0).max(65535), import_zod2.z.string()]).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
@@ -337,7 +337,7 @@ function parseByte(input) {
     }
   ]);
 }
-var byteValueSchema = import_zod2.z.preprocess(parseByte, import_zod2.z.number().int().min(0).max(255)).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
+var byteValueSchema = import_zod2.z.union([import_zod2.z.number().int().min(0).max(255), import_zod2.z.string()]).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
 var byteArraySchema = import_zod2.z.array(byteValueSchema).describe('Array of byte values in mixed formats: [255, "$FF", "%11111111", 42]');
 var c64RegisterValueSchema = import_zod2.z.object(
   Object.fromEntries(
@@ -3656,13 +3656,15 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
-      address = input.start;
-      length = input.end - input.start + 1;
+      address = start;
+      length = end - start + 1;
     } else if ("address" in input && "length" in input) {
-      address = input.address;
+      address = parseAddress16(input.address);
       length = input.length;
     } else {
       throw new Error("Invalid input: must provide either (address, length) or (start, end)");
@@ -3684,16 +3686,20 @@ var writeMemoryTool = createViceTool({
   inputSchema: import_zod4.z.object({
     address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
     data: byteArraySchema.min(1).describe("Bytes to write: decimal (255), hex ($FF, 0xFF), or binary (%11111111, 0b11111111). Mixed formats allowed.")
-  }).refine((input) => input.address + input.data.length - 1 <= 65535, {
-    message: "address + data.length must stay within the 16-bit address space",
-    path: ["data"]
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: address16Schema.describe("Start address where the bytes were written"),
+    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
-  execute: async (input) => await c64Session.writeMemory(input.address, input.data)
+  execute: async (input) => {
+    const address = parseAddress16(input.address);
+    const data = input.data.map((b) => parseByte(b));
+    if (address + data.length - 1 > 65535) {
+      throw new Error("address + data.length must stay within the 16-bit address space");
+    }
+    return await c64Session.writeMemory(address, data);
+  }
 });
 var executeTool = createViceTool({
   id: "execute",
@@ -3770,13 +3776,15 @@ var breakpointSetTool = createViceTool({
   execute: async (input) => {
     let normalizedInput;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
       normalizedInput = {
         kind: input.kind,
-        address: input.start,
-        length: input.end - input.start + 1,
+        address: start,
+        length: end - start + 1,
         condition: input.condition,
         label: input.label,
         temporary: input.temporary,
@@ -3785,7 +3793,7 @@ var breakpointSetTool = createViceTool({
     } else if ("address" in input && "length" in input) {
       normalizedInput = {
         kind: input.kind,
-        address: input.address,
+        address: parseAddress16(input.address),
         length: input.length,
         condition: input.condition,
         label: input.label,

package/dist/http.js

@@ -190,7 +190,7 @@ function parseAddress16(input) {
   }
   return parsed;
 }
-var address16Schema = z2.preprocess(parseAddress16, z2.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
+var address16Schema = z2.union([z2.number().int().min(0).max(65535), z2.string()]).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
@@ -314,7 +314,7 @@ function parseByte(input) {
     }
   ]);
 }
-var byteValueSchema = z2.preprocess(parseByte, z2.number().int().min(0).max(255)).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
+var byteValueSchema = z2.union([z2.number().int().min(0).max(255), z2.string()]).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
 var byteArraySchema = z2.array(byteValueSchema).describe('Array of byte values in mixed formats: [255, "$FF", "%11111111", 42]');
 var c64RegisterValueSchema = z2.object(
   Object.fromEntries(
@@ -3633,13 +3633,15 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
-      address = input.start;
-      length = input.end - input.start + 1;
+      address = start;
+      length = end - start + 1;
     } else if ("address" in input && "length" in input) {
-      address = input.address;
+      address = parseAddress16(input.address);
       length = input.length;
     } else {
       throw new Error("Invalid input: must provide either (address, length) or (start, end)");
@@ -3661,16 +3663,20 @@ var writeMemoryTool = createViceTool({
   inputSchema: z3.object({
     address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
     data: byteArraySchema.min(1).describe("Bytes to write: decimal (255), hex ($FF, 0xFF), or binary (%11111111, 0b11111111). Mixed formats allowed.")
-  }).refine((input) => input.address + input.data.length - 1 <= 65535, {
-    message: "address + data.length must stay within the 16-bit address space",
-    path: ["data"]
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: address16Schema.describe("Start address where the bytes were written"),
+    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
-  execute: async (input) => await c64Session.writeMemory(input.address, input.data)
+  execute: async (input) => {
+    const address = parseAddress16(input.address);
+    const data = input.data.map((b) => parseByte(b));
+    if (address + data.length - 1 > 65535) {
+      throw new Error("address + data.length must stay within the 16-bit address space");
+    }
+    return await c64Session.writeMemory(address, data);
+  }
 });
 var executeTool = createViceTool({
   id: "execute",
@@ -3747,13 +3753,15 @@ var breakpointSetTool = createViceTool({
   execute: async (input) => {
     let normalizedInput;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
       normalizedInput = {
         kind: input.kind,
-        address: input.start,
-        length: input.end - input.start + 1,
+        address: start,
+        length: end - start + 1,
         condition: input.condition,
         label: input.label,
         temporary: input.temporary,
@@ -3762,7 +3770,7 @@ var breakpointSetTool = createViceTool({
     } else if ("address" in input && "length" in input) {
       normalizedInput = {
         kind: input.kind,
-        address: input.address,
+        address: parseAddress16(input.address),
         length: input.length,
         condition: input.condition,
         label: input.label,

package/dist/stdio.cjs

@@ -210,7 +210,7 @@ function parseAddress16(input) {
   }
   return parsed;
 }
-var address16Schema = import_zod2.z.preprocess(parseAddress16, import_zod2.z.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
+var address16Schema = import_zod2.z.union([import_zod2.z.number().int().min(0).max(65535), import_zod2.z.string()]).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
@@ -334,7 +334,7 @@ function parseByte(input) {
     }
   ]);
 }
-var byteValueSchema = import_zod2.z.preprocess(parseByte, import_zod2.z.number().int().min(0).max(255)).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
+var byteValueSchema = import_zod2.z.union([import_zod2.z.number().int().min(0).max(255), import_zod2.z.string()]).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
 var byteArraySchema = import_zod2.z.array(byteValueSchema).describe('Array of byte values in mixed formats: [255, "$FF", "%11111111", 42]');
 var c64RegisterValueSchema = import_zod2.z.object(
   Object.fromEntries(
@@ -3653,13 +3653,15 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
-      address = input.start;
-      length = input.end - input.start + 1;
+      address = start;
+      length = end - start + 1;
     } else if ("address" in input && "length" in input) {
-      address = input.address;
+      address = parseAddress16(input.address);
       length = input.length;
     } else {
       throw new Error("Invalid input: must provide either (address, length) or (start, end)");
@@ -3681,16 +3683,20 @@ var writeMemoryTool = createViceTool({
   inputSchema: import_zod4.z.object({
     address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
     data: byteArraySchema.min(1).describe("Bytes to write: decimal (255), hex ($FF, 0xFF), or binary (%11111111, 0b11111111). Mixed formats allowed.")
-  }).refine((input) => input.address + input.data.length - 1 <= 65535, {
-    message: "address + data.length must stay within the 16-bit address space",
-    path: ["data"]
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: address16Schema.describe("Start address where the bytes were written"),
+    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
-  execute: async (input) => await c64Session.writeMemory(input.address, input.data)
+  execute: async (input) => {
+    const address = parseAddress16(input.address);
+    const data = input.data.map((b) => parseByte(b));
+    if (address + data.length - 1 > 65535) {
+      throw new Error("address + data.length must stay within the 16-bit address space");
+    }
+    return await c64Session.writeMemory(address, data);
+  }
 });
 var executeTool = createViceTool({
   id: "execute",
@@ -3767,13 +3773,15 @@ var breakpointSetTool = createViceTool({
   execute: async (input) => {
     let normalizedInput;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
       normalizedInput = {
         kind: input.kind,
-        address: input.start,
-        length: input.end - input.start + 1,
+        address: start,
+        length: end - start + 1,
         condition: input.condition,
         label: input.label,
         temporary: input.temporary,
@@ -3782,7 +3790,7 @@ var breakpointSetTool = createViceTool({
     } else if ("address" in input && "length" in input) {
       normalizedInput = {
         kind: input.kind,
-        address: input.address,
+        address: parseAddress16(input.address),
         length: input.length,
         condition: input.condition,
         label: input.label,

package/dist/stdio.js

@@ -187,7 +187,7 @@ function parseAddress16(input) {
   }
   return parsed;
 }
-var address16Schema = z2.preprocess(parseAddress16, z2.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
+var address16Schema = z2.union([z2.number().int().min(0).max(65535), z2.string()]).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
@@ -311,7 +311,7 @@ function parseByte(input) {
     }
   ]);
 }
-var byteValueSchema = z2.preprocess(parseByte, z2.number().int().min(0).max(255)).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
+var byteValueSchema = z2.union([z2.number().int().min(0).max(255), z2.string()]).describe("8-bit byte value: decimal (255), hex with prefix ($FF, 0xFF), or binary with prefix (%11111111, 0b11111111)");
 var byteArraySchema = z2.array(byteValueSchema).describe('Array of byte values in mixed formats: [255, "$FF", "%11111111", 42]');
 var c64RegisterValueSchema = z2.object(
   Object.fromEntries(
@@ -3630,13 +3630,15 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
-      address = input.start;
-      length = input.end - input.start + 1;
+      address = start;
+      length = end - start + 1;
     } else if ("address" in input && "length" in input) {
-      address = input.address;
+      address = parseAddress16(input.address);
       length = input.length;
     } else {
       throw new Error("Invalid input: must provide either (address, length) or (start, end)");
@@ -3658,16 +3660,20 @@ var writeMemoryTool = createViceTool({
   inputSchema: z3.object({
     address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
     data: byteArraySchema.min(1).describe("Bytes to write: decimal (255), hex ($FF, 0xFF), or binary (%11111111, 0b11111111). Mixed formats allowed.")
-  }).refine((input) => input.address + input.data.length - 1 <= 65535, {
-    message: "address + data.length must stay within the 16-bit address space",
-    path: ["data"]
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: address16Schema.describe("Start address where the bytes were written"),
+    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
-  execute: async (input) => await c64Session.writeMemory(input.address, input.data)
+  execute: async (input) => {
+    const address = parseAddress16(input.address);
+    const data = input.data.map((b) => parseByte(b));
+    if (address + data.length - 1 > 65535) {
+      throw new Error("address + data.length must stay within the 16-bit address space");
+    }
+    return await c64Session.writeMemory(address, data);
+  }
 });
 var executeTool = createViceTool({
   id: "execute",
@@ -3744,13 +3750,15 @@ var breakpointSetTool = createViceTool({
   execute: async (input) => {
     let normalizedInput;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
+      const start = parseAddress16(input.start);
+      const end = parseAddress16(input.end);
+      if (end < start) {
         throw new Error("End address must be greater than or equal to start address");
       }
       normalizedInput = {
         kind: input.kind,
-        address: input.start,
-        length: input.end - input.start + 1,
+        address: start,
+        length: end - start + 1,
         condition: input.condition,
         label: input.label,
         temporary: input.temporary,
@@ -3759,7 +3767,7 @@ var breakpointSetTool = createViceTool({
     } else if ("address" in input && "length" in input) {
       normalizedInput = {
         kind: input.kind,
-        address: input.address,
+        address: parseAddress16(input.address),
         length: input.length,
         condition: input.condition,
         label: input.label,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c64-debug-mcp",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Model Context Protocol server for C64 debugging via VICE emulator",
   "type": "module",
   "keywords": [