c64-debug-mcp 1.0.10 → 1.0.12

package/dist/http.cjs

@@ -3641,14 +3641,23 @@ var readMemoryTool = createViceTool({
     import_zod4.z.object({
       address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       length: import_zod4.z.number().int().positive().max(65535).describe("Number of bytes to read")
+    }).refine((input) => input.address + input.length <= 65536, {
+      message: "address + length must stay within the 64K address space",
+      path: ["length"]
     }),
     import_zod4.z.object({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
+    }).refine((input) => input.end < 65536, {
+      message: "End address must stay within the 64K address space",
+      path: ["end"]
     })
   ]),
   dataSchema: import_zod4.z.object({
-    address: address16Schema.describe("Start address of the returned memory chunk"),
+    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
@@ -3656,19 +3665,11 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
       address = input.start;
       length = input.end - input.start + 1;
-    } else if ("address" in input && "length" in input) {
+    } else {
       address = input.address;
       length = input.length;
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
-    if (address + length > 65536) {
-      throw new Error("address + length must stay within the 64K address space");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3690,7 +3691,7 @@ var writeMemoryTool = createViceTool({
   }),
   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)
@@ -3758,43 +3759,28 @@ var breakpointSetTool = createViceTool({
       label: import_zod4.z.string().optional(),
       temporary: import_zod4.z.boolean().default(false),
       enabled: import_zod4.z.boolean().default(true)
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
     })
   ]),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: address16Schema.nullable(),
+    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    let normalizedInput;
-    if ("start" in input && "end" in input) {
-      if (input.end < input.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,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else if ("address" in input && "length" in input) {
-      normalizedInput = {
-        kind: input.kind,
-        address: input.address,
-        length: input.length,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
+    const normalizedInput = "start" in input && "end" in input ? {
+      kind: input.kind,
+      address: input.start,
+      length: input.end - input.start + 1,
+      condition: input.condition,
+      label: input.label,
+      temporary: input.temporary,
+      enabled: input.enabled
+    } : input;
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/http.js

@@ -3618,14 +3618,23 @@ var readMemoryTool = createViceTool({
     z3.object({
       address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
+    }).refine((input) => input.address + input.length <= 65536, {
+      message: "address + length must stay within the 64K address space",
+      path: ["length"]
     }),
     z3.object({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
+    }).refine((input) => input.end < 65536, {
+      message: "End address must stay within the 64K address space",
+      path: ["end"]
     })
   ]),
   dataSchema: z3.object({
-    address: address16Schema.describe("Start address of the returned memory chunk"),
+    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
@@ -3633,19 +3642,11 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
       address = input.start;
       length = input.end - input.start + 1;
-    } else if ("address" in input && "length" in input) {
+    } else {
       address = input.address;
       length = input.length;
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
-    if (address + length > 65536) {
-      throw new Error("address + length must stay within the 64K address space");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3667,7 +3668,7 @@ var writeMemoryTool = createViceTool({
   }),
   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)
@@ -3735,43 +3736,28 @@ var breakpointSetTool = createViceTool({
       label: z3.string().optional(),
       temporary: z3.boolean().default(false),
       enabled: z3.boolean().default(true)
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
     })
   ]),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: address16Schema.nullable(),
+    programCounter: z3.number().int().min(0).max(65535).nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    let normalizedInput;
-    if ("start" in input && "end" in input) {
-      if (input.end < input.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,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else if ("address" in input && "length" in input) {
-      normalizedInput = {
-        kind: input.kind,
-        address: input.address,
-        length: input.length,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
+    const normalizedInput = "start" in input && "end" in input ? {
+      kind: input.kind,
+      address: input.start,
+      length: input.end - input.start + 1,
+      condition: input.condition,
+      label: input.label,
+      temporary: input.temporary,
+      enabled: input.enabled
+    } : input;
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.cjs

@@ -3638,14 +3638,23 @@ var readMemoryTool = createViceTool({
     import_zod4.z.object({
       address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       length: import_zod4.z.number().int().positive().max(65535).describe("Number of bytes to read")
+    }).refine((input) => input.address + input.length <= 65536, {
+      message: "address + length must stay within the 64K address space",
+      path: ["length"]
     }),
     import_zod4.z.object({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
+    }).refine((input) => input.end < 65536, {
+      message: "End address must stay within the 64K address space",
+      path: ["end"]
     })
   ]),
   dataSchema: import_zod4.z.object({
-    address: address16Schema.describe("Start address of the returned memory chunk"),
+    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
@@ -3653,19 +3662,11 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
       address = input.start;
       length = input.end - input.start + 1;
-    } else if ("address" in input && "length" in input) {
+    } else {
       address = input.address;
       length = input.length;
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
-    if (address + length > 65536) {
-      throw new Error("address + length must stay within the 64K address space");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3687,7 +3688,7 @@ var writeMemoryTool = createViceTool({
   }),
   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)
@@ -3755,43 +3756,28 @@ var breakpointSetTool = createViceTool({
       label: import_zod4.z.string().optional(),
       temporary: import_zod4.z.boolean().default(false),
       enabled: import_zod4.z.boolean().default(true)
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
     })
   ]),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: address16Schema.nullable(),
+    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    let normalizedInput;
-    if ("start" in input && "end" in input) {
-      if (input.end < input.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,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else if ("address" in input && "length" in input) {
-      normalizedInput = {
-        kind: input.kind,
-        address: input.address,
-        length: input.length,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
+    const normalizedInput = "start" in input && "end" in input ? {
+      kind: input.kind,
+      address: input.start,
+      length: input.end - input.start + 1,
+      condition: input.condition,
+      label: input.label,
+      temporary: input.temporary,
+      enabled: input.enabled
+    } : input;
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.js

@@ -3615,14 +3615,23 @@ var readMemoryTool = createViceTool({
     z3.object({
       address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
+    }).refine((input) => input.address + input.length <= 65536, {
+      message: "address + length must stay within the 64K address space",
+      path: ["length"]
     }),
     z3.object({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
+    }).refine((input) => input.end < 65536, {
+      message: "End address must stay within the 64K address space",
+      path: ["end"]
     })
   ]),
   dataSchema: z3.object({
-    address: address16Schema.describe("Start address of the returned memory chunk"),
+    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
@@ -3630,19 +3639,11 @@ var readMemoryTool = createViceTool({
     let address;
     let length;
     if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
       address = input.start;
       length = input.end - input.start + 1;
-    } else if ("address" in input && "length" in input) {
+    } else {
       address = input.address;
       length = input.length;
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
-    if (address + length > 65536) {
-      throw new Error("address + length must stay within the 64K address space");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3664,7 +3665,7 @@ var writeMemoryTool = createViceTool({
   }),
   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)
@@ -3732,43 +3733,28 @@ var breakpointSetTool = createViceTool({
       label: z3.string().optional(),
       temporary: z3.boolean().default(false),
       enabled: z3.boolean().default(true)
+    }).refine((input) => input.start <= input.end, {
+      message: "End address must be greater than or equal to start address",
+      path: ["end"]
     })
   ]),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
     lastStopReason: stopReasonSchema,
-    programCounter: address16Schema.nullable(),
+    programCounter: z3.number().int().min(0).max(65535).nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    let normalizedInput;
-    if ("start" in input && "end" in input) {
-      if (input.end < input.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,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else if ("address" in input && "length" in input) {
-      normalizedInput = {
-        kind: input.kind,
-        address: input.address,
-        length: input.length,
-        condition: input.condition,
-        label: input.label,
-        temporary: input.temporary,
-        enabled: input.enabled
-      };
-    } else {
-      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
-    }
+    const normalizedInput = "start" in input && "end" in input ? {
+      kind: input.kind,
+      address: input.start,
+      length: input.end - input.start + 1,
+      condition: input.condition,
+      label: input.label,
+      temporary: input.temporary,
+      enabled: input.enabled
+    } : input;
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/package.json

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