@ebowwa/mcp-nm 2.0.1 → 2.0.2

package/dist/index.js

@@ -14069,6 +14069,112 @@ async function handleXxdFindPattern(args) {
 `);
   return { content: [{ type: "text", text: summary }] };
 }
+async function handleConvertNumber(args) {
+  let num;
+  const value = args.value.trim().toLowerCase();
+  try {
+    switch (args.fromFormat) {
+      case "hex":
+        num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        break;
+      case "decimal":
+        num = BigInt(value);
+        break;
+      case "binary":
+        num = BigInt(value.startsWith("0b") ? value.slice(2) : value, 2);
+        break;
+      case "octal":
+        num = BigInt(value.startsWith("0o") ? value.slice(2) : value, 8);
+        break;
+      case "auto":
+      default:
+        if (value.startsWith("0x") || /^[0-9a-f]+$/i.test(value) && value.length > 4) {
+          num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        } else if (value.startsWith("0b")) {
+          num = BigInt(value.slice(2), 2);
+        } else if (value.startsWith("0o")) {
+          num = BigInt(value.slice(2), 8);
+        } else {
+          num = BigInt(value);
+        }
+        break;
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: `Error: Invalid number format "${args.value}"` }],
+      isError: true
+    };
+  }
+  let signedNum = num;
+  if (args.signed && args.byteSize) {
+    const bits = args.byteSize;
+    const maxUnsigned = (1n << BigInt(bits)) - 1n;
+    const signBit = 1n << BigInt(bits - 1);
+    if (num & signBit) {
+      signedNum = num - (1n << BigInt(bits));
+    }
+  }
+  const toFormat = args.toFormat ?? "all";
+  const results = [];
+  if (toFormat === "all" || toFormat === "decimal") {
+    results.push(`Decimal: ${num.toString()}`);
+    if (args.signed && args.byteSize && signedNum !== num) {
+      results.push(`Signed:  ${signedNum.toString()}`);
+    }
+  }
+  if (toFormat === "all" || toFormat === "hex") {
+    const hexStr = num.toString(16).toUpperCase();
+    const paddedHex = args.byteSize ? hexStr.padStart(args.byteSize / 4, "0") : hexStr;
+    results.push(`Hex:     0x${paddedHex}`);
+  }
+  if (toFormat === "all" || toFormat === "binary") {
+    const binStr = num.toString(2);
+    const paddedBin = args.byteSize ? binStr.padStart(args.byteSize, "0") : binStr;
+    const formattedBin = paddedBin.match(/.{1,8}/g)?.join(" ") ?? paddedBin;
+    results.push(`Binary:  0b${formattedBin}`);
+  }
+  if (toFormat === "all" || toFormat === "octal") {
+    results.push(`Octal:   0o${num.toString(8)}`);
+  }
+  if (toFormat === "all" || toFormat === "ascii") {
+    let asciiStr = "";
+    let tempNum = num;
+    while (tempNum > 0n) {
+      const charCode = Number(tempNum & 0xffn);
+      if (charCode >= 32 && charCode <= 126) {
+        asciiStr = String.fromCharCode(charCode) + asciiStr;
+      } else {
+        asciiStr = `\\x${charCode.toString(16).padStart(2, "0")}` + asciiStr;
+      }
+      tempNum = tempNum >> 8n;
+    }
+    results.push(`ASCII:   ${asciiStr || "(non-printable)"}`);
+  }
+  if (args.byteSize) {
+    results.push("");
+    results.push(`Size:    ${args.byteSize}-bit (${args.byteSize / 8} bytes)`);
+  }
+  if (toFormat === "all" && num > 0xffn) {
+    const bytes = [];
+    let tempNum = num;
+    while (tempNum > 0n) {
+      bytes.unshift(tempNum & 0xffn);
+      tempNum = tempNum >> 8n;
+    }
+    results.push("");
+    results.push("Bytes (big-endian):");
+    results.push(`  ${bytes.map((b, i) => `[${i}] 0x${b.toString(16).padStart(2, "0")} (${b})`).join(`
+  `)}`);
+  }
+  const summary = [
+    `Number Conversion: ${args.value}`,
+    `From: ${args.fromFormat}`,
+    "",
+    ...results
+  ].join(`
+`);
+  return { content: [{ type: "text", text: summary }] };
+}
 var SYMBOL_TYPE_DESCRIPTIONS = {
   A: "Global absolute symbol",
   B: "Global BSS (uninitialized data)",
@@ -15092,6 +15198,33 @@ var TOOLS = [
       required: ["filePath", "pattern"]
     }
   },
+  {
+    name: "bin_convert",
+    description: "Convert numbers between hex, decimal, binary, octal, and ASCII formats",
+    inputSchema: {
+      type: "object",
+      properties: {
+        value: { type: "string", description: "Number value to convert" },
+        fromFormat: {
+          type: "string",
+          enum: ["hex", "decimal", "binary", "octal", "auto"],
+          description: "Input format (default: auto-detect)"
+        },
+        toFormat: {
+          type: "string",
+          enum: ["all", "hex", "decimal", "binary", "octal", "ascii"],
+          description: "Output format (default: all)"
+        },
+        byteSize: {
+          type: "number",
+          enum: [8, 16, 32, 64],
+          description: "Byte size for padding (8/16/32/64-bit)"
+        },
+        signed: { type: "boolean", description: "Treat as signed integer" }
+      },
+      required: ["value"]
+    }
+  },
   {
     name: "bin_strings",
     description: "Extract readable strings (ASCII, Unicode) from a binary file",
@@ -15381,6 +15514,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleNopSled(args);
       case "bin_hex_editor":
         return await handleHexEditor(args);
+      case "bin_convert":
+        return await handleConvertNumber(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/mcp-nm",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Comprehensive binary analysis MCP server - symbols (nm), hex dumps (xxd), strings, disassembly, security audit, entropy analysis, ELF/Mach-O inspection, and binary patching",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -674,6 +674,147 @@ async function handleXxdFindPattern(args: {
   return { content: [{ type: "text", text: summary }] };
 }
 
+// ============================================================================
+// Number Format Conversion Utility
+// ============================================================================
+
+async function handleConvertNumber(args: {
+  value: string;
+  fromFormat: "hex" | "decimal" | "binary" | "octal" | "auto";
+  toFormat?: "all" | "hex" | "decimal" | "binary" | "octal" | "ascii";
+  byteSize?: 8 | 16 | 32 | 64;
+  signed?: boolean;
+}) {
+  let num: bigint;
+
+  // Parse input value
+  const value = args.value.trim().toLowerCase();
+
+  try {
+    switch (args.fromFormat) {
+      case "hex":
+        num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        break;
+      case "decimal":
+        num = BigInt(value);
+        break;
+      case "binary":
+        num = BigInt(value.startsWith("0b") ? value.slice(2) : value, 2);
+        break;
+      case "octal":
+        num = BigInt(value.startsWith("0o") ? value.slice(2) : value, 8);
+        break;
+      case "auto":
+      default:
+        // Auto-detect format
+        if (value.startsWith("0x") || /^[0-9a-f]+$/i.test(value) && value.length > 4) {
+          num = BigInt(value.startsWith("0x") ? value : `0x${value}`);
+        } else if (value.startsWith("0b")) {
+          num = BigInt(value.slice(2), 2);
+        } else if (value.startsWith("0o")) {
+          num = BigInt(value.slice(2), 8);
+        } else {
+          num = BigInt(value);
+        }
+        break;
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: `Error: Invalid number format "${args.value}"` }],
+      isError: true,
+    };
+  }
+
+  // Handle signed conversion if requested
+  let signedNum: bigint = num;
+  if (args.signed && args.byteSize) {
+    const bits = args.byteSize;
+    const maxUnsigned = (1n << BigInt(bits)) - 1n;
+    const signBit = 1n << BigInt(bits - 1);
+
+    if (num & signBit) {
+      signedNum = num - (1n << BigInt(bits));
+    }
+  }
+
+  // Format outputs
+  const toFormat = args.toFormat ?? "all";
+  const results: string[] = [];
+
+  if (toFormat === "all" || toFormat === "decimal") {
+    results.push(`Decimal: ${num.toString()}`);
+    if (args.signed && args.byteSize && signedNum !== num) {
+      results.push(`Signed:  ${signedNum.toString()}`);
+    }
+  }
+
+  if (toFormat === "all" || toFormat === "hex") {
+    const hexStr = num.toString(16).toUpperCase();
+    const paddedHex = args.byteSize
+      ? hexStr.padStart(args.byteSize / 4, "0")
+      : hexStr;
+    results.push(`Hex:     0x${paddedHex}`);
+  }
+
+  if (toFormat === "all" || toFormat === "binary") {
+    const binStr = num.toString(2);
+    const paddedBin = args.byteSize
+      ? binStr.padStart(args.byteSize, "0")
+      : binStr;
+    // Add spaces every 8 bits for readability
+    const formattedBin = paddedBin.match(/.{1,8}/g)?.join(" ") ?? paddedBin;
+    results.push(`Binary:  0b${formattedBin}`);
+  }
+
+  if (toFormat === "all" || toFormat === "octal") {
+    results.push(`Octal:   0o${num.toString(8)}`);
+  }
+
+  if (toFormat === "all" || toFormat === "ascii") {
+    // Try to convert to ASCII string
+    let asciiStr = "";
+    let tempNum = num;
+    while (tempNum > 0n) {
+      const charCode = Number(tempNum & 0xffn);
+      if (charCode >= 32 && charCode <= 126) {
+        asciiStr = String.fromCharCode(charCode) + asciiStr;
+      } else {
+        asciiStr = `\\x${charCode.toString(16).padStart(2, "0")}` + asciiStr;
+      }
+      tempNum = tempNum >> 8n;
+    }
+    results.push(`ASCII:   ${asciiStr || "(non-printable)"}`);
+  }
+
+  // Add byte size info
+  if (args.byteSize) {
+    results.push("");
+    results.push(`Size:    ${args.byteSize}-bit (${args.byteSize / 8} bytes)`);
+  }
+
+  // Add byte breakdown for multi-byte values
+  if (toFormat === "all" && num > 0xffn) {
+    const bytes: string[] = [];
+    let tempNum = num;
+    while (tempNum > 0n) {
+      bytes.unshift(tempNum & 0xffn);
+      tempNum = tempNum >> 8n;
+    }
+    results.push("");
+    results.push("Bytes (big-endian):");
+    results.push(`  ${bytes.map((b, i) => `[${i}] 0x${b.toString(16).padStart(2, "0")} (${b})`).join("\n  ")}`);
+  }
+
+  const summary = [
+    `Number Conversion: ${args.value}`,
+    `From: ${args.fromFormat}`,
+    "",
+    ...results,
+  ].join("\n");
+
+  return { content: [{ type: "text", text: summary }] };
+}
+
 // ============================================================================
 // Symbol type descriptions
 // ============================================================================
@@ -1986,6 +2127,34 @@ const TOOLS = [
       required: ["filePath", "pattern"],
     },
   },
+  // Number Format Conversion
+  {
+    name: "bin_convert",
+    description: "Convert numbers between hex, decimal, binary, octal, and ASCII formats",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        value: { type: "string", description: "Number value to convert" },
+        fromFormat: {
+          type: "string",
+          enum: ["hex", "decimal", "binary", "octal", "auto"],
+          description: "Input format (default: auto-detect)",
+        },
+        toFormat: {
+          type: "string",
+          enum: ["all", "hex", "decimal", "binary", "octal", "ascii"],
+          description: "Output format (default: all)",
+        },
+        byteSize: {
+          type: "number",
+          enum: [8, 16, 32, 64],
+          description: "Byte size for padding (8/16/32/64-bit)",
+        },
+        signed: { type: "boolean", description: "Treat as signed integer" },
+      },
+      required: ["value"],
+    },
+  },
   // Extended Binary Analysis Tools
   {
     name: "bin_strings",
@@ -2322,6 +2491,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleNopSled(args as { filePath: string; offset: number; count: number; createBackup?: boolean });
       case "bin_hex_editor":
         return await handleHexEditor(args as { filePath: string; offset: number; length: number; newHex?: string });
+      // Number conversion utility
+      case "bin_convert":
+        return await handleConvertNumber(args as {
+          value: string;
+          fromFormat: "hex" | "decimal" | "binary" | "octal" | "auto";
+          toFormat?: "all" | "hex" | "decimal" | "binary" | "octal" | "ascii";
+          byteSize?: 8 | 16 | 32 | 64;
+          signed?: boolean;
+        });
       default:
         throw new Error(`Unknown tool: ${name}`);
     }