@ebowwa/mcp-nm 1.1.0 → 2.0.1

package/dist/index.js

@@ -13642,13 +13642,61 @@ import { exec } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var server = new Server({
-  name: "@ebowwa/nm-mcp",
-  version: "1.1.0"
+  name: "@ebowwa/mcp-nm",
+  version: "2.0.0"
 }, {
   capabilities: {
     tools: {}
   }
 });
+async function analyzeFile(filePath) {
+  try {
+    const { stdout: fileInfo } = await execAsync(`file "${filePath}"`);
+    const info = fileInfo.toLowerCase();
+    let fileType = "unknown";
+    let hasDynamicSymbols = false;
+    if (info.includes("elf")) {
+      if (info.includes("shared object") || info.includes("dynamically linked")) {
+        fileType = info.includes("shared object") ? "elf-shared" : "elf-executable";
+        hasDynamicSymbols = true;
+      } else if (info.includes("statically linked")) {
+        fileType = "elf-executable";
+        hasDynamicSymbols = false;
+      } else if (info.includes("relocatable")) {
+        fileType = "object-file";
+        hasDynamicSymbols = false;
+      }
+    } else if (info.includes("mach-o")) {
+      if (info.includes("dynamically linked") || info.includes("shared library") || info.includes("dylib")) {
+        fileType = "mach-o";
+        hasDynamicSymbols = true;
+      } else if (info.includes("bundle") || info.includes("statically linked")) {
+        fileType = "mach-o";
+        hasDynamicSymbols = false;
+      } else {
+        fileType = "mach-o";
+        hasDynamicSymbols = info.includes("executable");
+      }
+    } else if (info.includes("ar archive") || info.includes("current ar archive")) {
+      fileType = "static-library";
+      hasDynamicSymbols = false;
+    } else if (info.includes("relocatable")) {
+      fileType = "object-file";
+      hasDynamicSymbols = false;
+    }
+    return {
+      hasDynamicSymbols,
+      fileType,
+      format: fileInfo.trim()
+    };
+  } catch {
+    return {
+      hasDynamicSymbols: false,
+      fileType: "unknown",
+      format: "Unable to determine file type"
+    };
+  }
+}
 async function runNm(filePath, options = {}) {
   const args = [];
   if (options.externalOnly)
@@ -13917,32 +13965,100 @@ async function handleXxdExtract(args) {
   return { content: [{ type: "text", text: summary }] };
 }
 async function handleXxdFindPattern(args) {
-  const result = await runXxd(args.filePath, {
-    plainHex: true,
-    length: args.maxLength
-  });
-  const fileHex = result.output.replace(/\s/g, "").toLowerCase();
   let searchPattern;
   if (args.patternFormat === "text" || !args.patternFormat) {
     searchPattern = args.pattern.split("").map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join("");
   } else {
     searchPattern = args.pattern.replace(/\s/g, "").toLowerCase();
   }
+  const { stdout: sizeStr } = await execAsync(`stat -f%z "${args.filePath}" 2>/dev/null || stat -c%s "${args.filePath}"`);
+  const fileSize = parseInt(sizeStr.trim(), 10);
+  const maxInMemory = args.maxLength ?? 50 * 1024 * 1024;
   const matches = [];
-  let idx = 0;
-  while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
-    const byteOffset = Math.floor(idx / 2);
-    const contextStart = Math.max(0, idx - 20);
-    const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
-    const contextHex = fileHex.slice(contextStart, contextEnd);
-    matches.push({
-      offset: byteOffset,
-      context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+  if (fileSize <= maxInMemory) {
+    const result = await runXxd(args.filePath, {
+      plainHex: true,
+      length: args.maxLength
     });
-    idx++;
+    const fileHex = result.output.replace(/\s/g, "").toLowerCase();
+    let idx = 0;
+    while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
+      const byteOffset = Math.floor(idx / 2);
+      const contextStart = Math.max(0, idx - 20);
+      const contextEnd = Math.min(fileHex.length, idx + searchPattern.length + 20);
+      const contextHex = fileHex.slice(contextStart, contextEnd);
+      matches.push({
+        offset: byteOffset,
+        context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+      });
+      idx++;
+      if (matches.length >= 1000)
+        break;
+    }
+  } else {
+    try {
+      const patternBytes = searchPattern.match(/.{2}/g) ?? [];
+      const escapedPattern = patternBytes.map((b) => `\\x${b}`).join("");
+      const { stdout: grepResult } = await execAsync(`grep -abo "${escapedPattern}" "${args.filePath}" 2>/dev/null | head -1000`, { maxBuffer: 10 * 1024 * 1024 });
+      const lines = grepResult.trim().split(`
+`).filter(Boolean);
+      for (const line of lines) {
+        const match = line.match(/^(\d+):/);
+        if (match) {
+          const offset = parseInt(match[1], 10);
+          try {
+            const contextOffset = Math.max(0, offset - 10);
+            const contextLen = searchPattern.length / 2 + 20;
+            const { stdout: contextHex } = await execAsync(`dd if="${args.filePath}" bs=1 skip=${contextOffset} count=${contextLen} 2>/dev/null | xxd -p | tr -d '\\n'`);
+            matches.push({
+              offset,
+              context: contextHex.match(/.{1,2}/g)?.join(" ") || contextHex
+            });
+          } catch {
+            matches.push({ offset, context: "(context unavailable)" });
+          }
+        }
+      }
+    } catch {
+      try {
+        const { stdout: stringsResult } = await execAsync(`strings -t x -n ${Math.floor(searchPattern.length / 2)} "${args.filePath}" | grep -i "${args.pattern}" | head -1000`, { maxBuffer: 10 * 1024 * 1024 });
+        const lines = stringsResult.trim().split(`
+`).filter(Boolean);
+        for (const line of lines) {
+          const match = line.match(/^\s*([0-9a-fA-F]+)\s+(.+)$/);
+          if (match) {
+            matches.push({
+              offset: parseInt(match[1], 16),
+              context: match[2].slice(0, 40)
+            });
+          }
+        }
+      } catch {
+        const chunkSize = 10 * 1024 * 1024;
+        for (let chunkStart = 0;chunkStart < fileSize; chunkStart += chunkSize) {
+          try {
+            const { stdout: chunkHex } = await execAsync(`dd if="${args.filePath}" bs=1 skip=${chunkStart} count=${chunkSize} 2>/dev/null | xxd -p | tr -d '\\n'`);
+            const hex = chunkHex.toLowerCase();
+            let idx = 0;
+            while ((idx = hex.indexOf(searchPattern, idx)) !== -1) {
+              matches.push({
+                offset: chunkStart + Math.floor(idx / 2),
+                context: hex.slice(Math.max(0, idx - 20), idx + searchPattern.length + 20).match(/.{1,2}/g)?.join(" ") || ""
+              });
+              idx++;
+              if (matches.length >= 1000)
+                break;
+            }
+            if (matches.length >= 1000)
+              break;
+          } catch {}
+        }
+      }
+    }
   }
   const summary = [
     `Pattern search in: ${args.filePath}`,
+    `File size: ${(fileSize / 1024 / 1024).toFixed(2)} MB`,
     `Pattern: ${args.pattern} (${args.patternFormat || "text"})`,
     `Hex pattern: ${searchPattern}`,
     `Matches found: ${matches.length}`,
@@ -14066,6 +14182,42 @@ async function handleDefinedSymbols(args) {
   return { content: [{ type: "text", text: summary }] };
 }
 async function handleDynamicSymbols(args) {
+  const analysis = await analyzeFile(args.filePath);
+  if (!analysis.hasDynamicSymbols) {
+    const suggestions = [];
+    switch (analysis.fileType) {
+      case "static-library":
+        suggestions.push("Static libraries (.a) contain object files without dynamic symbols.");
+        suggestions.push("Use nm_list_symbols or nm_defined_symbols to see available symbols.");
+        break;
+      case "object-file":
+        suggestions.push("Object files (.o) are not linked and have no dynamic symbol table.");
+        suggestions.push("Use nm_list_symbols to see symbols in this object file.");
+        break;
+      case "elf-executable":
+        suggestions.push("This appears to be a statically linked executable.");
+        suggestions.push("Use nm_list_symbols or nm_defined_symbols instead.");
+        break;
+      default:
+        suggestions.push("This file type does not have a dynamic symbol table.");
+        suggestions.push("Try nm_list_symbols or nm_defined_symbols instead.");
+    }
+    return {
+      content: [{
+        type: "text",
+        text: [
+          `Error: File has no dynamic symbol table`,
+          "",
+          `File: ${args.filePath}`,
+          `Type: ${analysis.format}`,
+          "",
+          ...suggestions
+        ].join(`
+`)
+      }],
+      isError: true
+    };
+  }
   const result = await runNm(args.filePath, {
     dynamicSymbols: true,
     demangle: args.demangle ?? true,
@@ -14073,6 +14225,7 @@ async function handleDynamicSymbols(args) {
   });
   const summary = [
     `File: ${result.filePath}`,
+    `File type: ${analysis.format}`,
     `Dynamic symbols: ${result.totalCount}`,
     "",
     "Symbols:",
@@ -14193,6 +14346,531 @@ async function handleSummary(args) {
 `);
   return { content: [{ type: "text", text: summary }] };
 }
+async function handleStrings(args) {
+  const minLen = args.minLength ?? 4;
+  const encFlags = {
+    ascii: "-a",
+    unicode: "-e l",
+    all: "-a -e l"
+  };
+  const encFlag = encFlags[args.encoding ?? "all"];
+  try {
+    const { stdout } = await execAsync(`strings ${encFlag} -n ${minLen} "${args.filePath}"`, { maxBuffer: 50 * 1024 * 1024 });
+    const strings = stdout.trim().split(`
+`).filter(Boolean);
+    const summary = [
+      `Strings in: ${args.filePath}`,
+      `Encoding: ${args.encoding ?? "all"}`,
+      `Minimum length: ${minLen}`,
+      `Total strings: ${strings.length}`,
+      "",
+      "Strings:",
+      ...strings.slice(0, 200).map((s) => `  ${s}`),
+      strings.length > 200 ? `  ... and ${strings.length - 200} more` : ""
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`strings command failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleFileInfo(args) {
+  try {
+    const { stdout: mimeInfo } = await execAsync(`file --mime --brief "${args.filePath}"`);
+    const { stdout: detailedInfo } = await execAsync(`file "${args.filePath}"`);
+    const summary = [
+      `File: ${args.filePath}`,
+      "",
+      "MIME Type:",
+      `  ${mimeInfo.trim()}`,
+      "",
+      "Detailed Type:",
+      `  ${detailedInfo.trim()}`
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`file command failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleSectionSizes(args) {
+  try {
+    const { stdout } = await execAsync(`size -A -x "${args.filePath}"`);
+    const lines = stdout.trim().split(`
+`);
+    const summary = [
+      `Section Sizes: ${args.filePath}`,
+      "",
+      ...lines.map((l) => `  ${l}`)
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    try {
+      const { stdout } = await execAsync(`size -m "${args.filePath}"`);
+      return { content: [{ type: "text", text: `Section Sizes:
+${stdout}` }] };
+    } catch {
+      throw new Error(`size command failed: ${error2 instanceof Error ? error2.message : error2}`);
+    }
+  }
+}
+async function handleObjdumpSections(args) {
+  try {
+    const { stdout } = await execAsync(`objdump -h "${args.filePath}"`, {
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const summary = [
+      `Section Headers: ${args.filePath}`,
+      "",
+      stdout
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`objdump -h failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleObjdumpProgramHeaders(args) {
+  try {
+    const { stdout } = await execAsync(`objdump -p "${args.filePath}"`, {
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const summary = [
+      `Program Headers / Imports: ${args.filePath}`,
+      "",
+      stdout
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`objdump -p failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleOtoolLibs(args) {
+  try {
+    const { stdout } = await execAsync(`otool -L "${args.filePath}"`);
+    const lines = stdout.trim().split(`
+`);
+    const summary = [
+      `Dynamic Library Dependencies: ${args.filePath}`,
+      "",
+      ...lines.map((l) => `  ${l}`)
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`otool -L failed (macOS only): ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleReadelf(args) {
+  const sections = args.sections ?? ["all"];
+  const flags = [];
+  if (sections.includes("all")) {
+    flags.push("-a");
+  } else {
+    if (sections.includes("headers"))
+      flags.push("-h");
+    if (sections.includes("sections"))
+      flags.push("-S");
+    if (sections.includes("segments"))
+      flags.push("-l");
+    if (sections.includes("symbols"))
+      flags.push("-s");
+    if (sections.includes("dynamic"))
+      flags.push("-d");
+  }
+  try {
+    const { stdout } = await execAsync(`readelf ${flags.join(" ")} "${args.filePath}"`, {
+      maxBuffer: 20 * 1024 * 1024
+    });
+    const summary = [
+      `ELF Analysis: ${args.filePath}`,
+      `Sections: ${sections.join(", ")}`,
+      "",
+      stdout.slice(0, 50000),
+      stdout.length > 50000 ? `
+... truncated (${stdout.length - 50000} more chars)` : ""
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`readelf failed (Linux ELF only): ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleLdd(args) {
+  try {
+    const { stdout } = await execAsync(`ldd "${args.filePath}"`);
+    const lines = stdout.trim().split(`
+`).filter(Boolean);
+    const summary = [
+      `Shared Library Dependencies: ${args.filePath}`,
+      "",
+      ...lines.map((l) => `  ${l}`)
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`ldd failed (Linux only): ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleDisassembly(args) {
+  let cmd = "objdump -d";
+  if (args.symbol) {
+    cmd += ` --disassemble="${args.symbol}"`;
+  }
+  cmd += ` "${args.filePath}"`;
+  try {
+    const { stdout } = await execAsync(cmd, {
+      maxBuffer: 50 * 1024 * 1024
+    });
+    let output = stdout;
+    if (args.startOffset !== undefined || args.length !== undefined) {
+      const lines = stdout.split(`
+`);
+      const start = args.startOffset ?? 0;
+      const len = args.length ?? 500;
+      output = lines.slice(start, start + len).join(`
+`);
+    }
+    const summary = [
+      `Disassembly: ${args.filePath}`,
+      args.symbol ? `Symbol: ${args.symbol}` : "",
+      "",
+      output.slice(0, 1e5),
+      output.length > 1e5 ? `
+... truncated (${output.length - 1e5} more chars)` : ""
+    ].filter(Boolean).join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`objdump -d failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleSecurityAudit(args) {
+  const results = [];
+  try {
+    const { stdout: fileInfo } = await execAsync(`file "${args.filePath}"`);
+    const info = fileInfo.toLowerCase();
+    if (info.includes("pie") || info.includes("position independent")) {
+      results.push({ check: "PIE", status: "ENABLED", details: "Position Independent Executable" });
+    } else if (info.includes("executable")) {
+      results.push({ check: "PIE", status: "DISABLED", details: "Not a PIE binary" });
+    }
+    try {
+      const { stdout: relro } = await execAsync(`readelf -l "${args.filePath}" 2>/dev/null | grep -i gnu_relro`);
+      if (relro.trim()) {
+        results.push({ check: "RELRO", status: "ENABLED", details: "Read-Only relocations" });
+      }
+    } catch {}
+    try {
+      const { stdout: canary } = await execAsync(`nm "${args.filePath}" 2>/dev/null | grep -i "__stack_chk_fail"`);
+      if (canary.trim()) {
+        results.push({ check: "Stack Canary", status: "ENABLED", details: "Stack smashing detected symbol found" });
+      } else {
+        results.push({ check: "Stack Canary", status: "UNKNOWN", details: "No stack canary symbol found" });
+      }
+    } catch {
+      results.push({ check: "Stack Canary", status: "UNKNOWN", details: "Could not check" });
+    }
+    try {
+      const { stdout: nx } = await execAsync(`readelf -l "${args.filePath}" 2>/dev/null | grep -i "gnu_stack"`);
+      if (nx.toLowerCase().includes("rwe")) {
+        results.push({ check: "NX", status: "DISABLED", details: "Stack is executable (RWE)" });
+      } else if (nx.trim()) {
+        results.push({ check: "NX", status: "ENABLED", details: "Non-executable stack" });
+      }
+    } catch {}
+    try {
+      const { stdout: fortify } = await execAsync(`nm "${args.filePath}" 2>/dev/null | grep -i "_chk@"`);
+      if (fortify.trim()) {
+        results.push({ check: "FORTIFY", status: "ENABLED", details: "Fortified functions detected" });
+      }
+    } catch {}
+    if (info.includes("mach-o")) {
+      try {
+        const { stdout: loadCmds } = await execAsync(`otool -l "${args.filePath}"`);
+        if (loadCmds.toLowerCase().includes("lc_main")) {
+          results.push({ check: "PIE", status: "ENABLED", details: "Mach-O with LC_MAIN (likely PIE)" });
+        }
+      } catch {}
+    }
+  } catch (error2) {
+    results.push({ check: "Error", status: "FAILED", details: error2 instanceof Error ? error2.message : String(error2) });
+  }
+  const summary = [
+    `Security Audit: ${args.filePath}`,
+    "",
+    "Security Features:",
+    ...results.map((r) => `  ${r.check}: ${r.status} - ${r.details}`),
+    "",
+    "Recommendations:",
+    ...results.filter((r) => r.status === "DISABLED" || r.status === "UNKNOWN").map((r) => `  - Consider enabling ${r.check}`)
+  ].join(`
+`);
+  return { content: [{ type: "text", text: summary }] };
+}
+async function handleEntropyAnalysis(args) {
+  const blockSize = args.blockSize ?? 1024;
+  try {
+    const { stdout: hexData } = await execAsync(`xxd -p "${args.filePath}" | tr -d '\\n'`);
+    const bytes = hexData.match(/.{2}/g)?.map((h) => parseInt(h, 16)) ?? [];
+    const results = [];
+    for (let i = 0;i < bytes.length; i += blockSize) {
+      const block = bytes.slice(i, i + blockSize);
+      if (block.length === 0)
+        continue;
+      const freq = {};
+      for (const byte of block) {
+        freq[byte] = (freq[byte] ?? 0) + 1;
+      }
+      let entropy = 0;
+      for (const count of Object.values(freq)) {
+        const p = count / block.length;
+        entropy -= p * Math.log2(p);
+      }
+      const normalizedEntropy = entropy / 8;
+      let status = "normal";
+      if (normalizedEntropy > 0.95)
+        status = "high (possibly encrypted/compressed)";
+      else if (normalizedEntropy < 0.3)
+        status = "low (possibly padding/zeros)";
+      results.push({
+        section: `Block ${Math.floor(i / blockSize)}`,
+        offset: i,
+        entropy: Math.round(entropy * 100) / 100,
+        status
+      });
+    }
+    const avgEntropy = results.reduce((a, b) => a + b.entropy, 0) / results.length;
+    const summary = [
+      `Entropy Analysis: ${args.filePath}`,
+      `Block size: ${blockSize} bytes`,
+      `Total blocks: ${results.length}`,
+      `Average entropy: ${(avgEntropy / 8 * 100).toFixed(1)}% of max`,
+      "",
+      "Blocks with unusual entropy:",
+      ...results.filter((r) => r.status !== "normal").slice(0, 50).map((r) => `  ${r.section} (offset ${r.offset}): ${r.entropy}/8 bits - ${r.status}`),
+      results.filter((r) => r.status !== "normal").length > 50 ? `  ... and ${results.filter((r) => r.status !== "normal").length - 50} more` : ""
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`Entropy analysis failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleImportExport(args) {
+  const analysis = await analyzeFile(args.filePath);
+  const imports = [];
+  const exports = [];
+  try {
+    if (analysis.format.toLowerCase().includes("mach-o")) {
+      const { stdout: importSyms } = await execAsync(`nm -u "${args.filePath}" 2>/dev/null | awk '{print $2}'`);
+      imports.push(...importSyms.trim().split(`
+`).filter(Boolean));
+      const { stdout: exportSyms } = await execAsync(`nm -g "${args.filePath}" 2>/dev/null | grep -v "U " | awk '{print $3}'`);
+      exports.push(...exportSyms.trim().split(`
+`).filter(Boolean));
+    } else {
+      const { stdout: importSyms } = await execAsync(`nm -D -u "${args.filePath}" 2>/dev/null | awk '{print $2}'`);
+      imports.push(...importSyms.trim().split(`
+`).filter(Boolean));
+      const { stdout: exportSyms } = await execAsync(`nm -D --defined-only "${args.filePath}" 2>/dev/null | awk '{print $3}'`);
+      exports.push(...exportSyms.trim().split(`
+`).filter(Boolean));
+    }
+  } catch {
+    try {
+      const { stdout: allSyms } = await execAsync(`nm "${args.filePath}" 2>/dev/null`);
+      for (const line of allSyms.split(`
+`)) {
+        const match = line.match(/^\s*([0-9a-fA-F]+)?\s+([UTDDBRC])\s+(.+)/);
+        if (match) {
+          if (match[2] === "U")
+            imports.push(match[3]);
+          else if (match[1] && match[2] === match[2].toUpperCase())
+            exports.push(match[3]);
+        }
+      }
+    } catch {}
+  }
+  const summary = [
+    `Import/Export Analysis: ${args.filePath}`,
+    `File type: ${analysis.format}`,
+    "",
+    `Imports (${imports.length}):`,
+    ...imports.slice(0, 100).map((s) => `  - ${s}`),
+    imports.length > 100 ? `  ... and ${imports.length - 100} more` : "",
+    "",
+    `Exports (${exports.length}):`,
+    ...exports.slice(0, 100).map((s) => `  + ${s}`),
+    exports.length > 100 ? `  ... and ${exports.length - 100} more` : ""
+  ].join(`
+`);
+  return { content: [{ type: "text", text: summary }] };
+}
+async function handleBinaryDiff(args) {
+  const contextBytes = args.contextBytes ?? 32;
+  try {
+    const { stdout: hex1 } = await execAsync(`xxd -p "${args.file1}" | tr -d '\\n'`);
+    const { stdout: hex2 } = await execAsync(`xxd -p "${args.file2}" | tr -d '\\n'`);
+    const bytes1 = hex1.match(/.{2}/g) ?? [];
+    const bytes2 = hex2.match(/.{2}/g) ?? [];
+    const maxLen = Math.max(bytes1.length, bytes2.length);
+    const diffs = [];
+    for (let i = 0;i < maxLen; i++) {
+      const b1 = bytes1[i] ?? "??";
+      const b2 = bytes2[i] ?? "??";
+      if (b1 !== b2) {
+        diffs.push({ offset: i, file1: b1, file2: b2 });
+      }
+    }
+    const diffPercent = (diffs.length / maxLen * 100).toFixed(2);
+    const summary = [
+      `Binary Diff: ${args.file1} vs ${args.file2}`,
+      "",
+      `File 1 size: ${bytes1.length} bytes`,
+      `File 2 size: ${bytes2.length} bytes`,
+      `Differences: ${diffs.length} bytes (${diffPercent}%)`,
+      "",
+      "Differences (first 200):",
+      ...diffs.slice(0, 200).map((d) => {
+        const ctx1 = bytes1.slice(Math.max(0, d.offset - 4), d.offset + 5).join(" ");
+        const ctx2 = bytes2.slice(Math.max(0, d.offset - 4), d.offset + 5).join(" ");
+        return `  Offset 0x${d.offset.toString(16).padStart(8, "0")}: ${d.file1} -> ${d.file2}
+    Context: [${ctx1}] -> [${ctx2}]`;
+      }),
+      diffs.length > 200 ? `  ... and ${diffs.length - 200} more differences` : ""
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`Binary diff failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleArchiveExtract(args) {
+  const outputDir = args.outputDir ?? `/tmp/archive_${Date.now()}`;
+  try {
+    const { stdout: fileInfo } = await execAsync(`file "${args.filePath}"`);
+    if (!fileInfo.toLowerCase().includes("ar archive") && !fileInfo.toLowerCase().includes("archive")) {
+      return {
+        content: [{ type: "text", text: `Error: ${args.filePath} is not an archive file.
+${fileInfo}` }],
+        isError: true
+      };
+    }
+    const { stdout: contents } = await execAsync(`ar -t "${args.filePath}"`);
+    const files = contents.trim().split(`
+`).filter(Boolean);
+    if (args.listOnly) {
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `Archive Contents: ${args.filePath}`,
+            `Total files: ${files.length}`,
+            "",
+            "Files:",
+            ...files.map((f) => `  - ${f}`)
+          ].join(`
+`)
+        }]
+      };
+    }
+    await execAsync(`mkdir -p "${outputDir}"`);
+    await execAsync(`cd "${outputDir}" && ar -x "${args.filePath}"`);
+    const summary = [
+      `Archive Extracted: ${args.filePath}`,
+      `Output directory: ${outputDir}`,
+      `Files extracted: ${files.length}`,
+      "",
+      "Extracted files:",
+      ...files.map((f) => `  - ${f}`)
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`Archive extraction failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handlePatchBytes(args) {
+  const backup = args.createBackup ?? true;
+  try {
+    const hex = args.hexData.replace(/\s/g, "");
+    if (!/^[0-9a-fA-F]*$/.test(hex) || hex.length % 2 !== 0) {
+      throw new Error("Invalid hex data. Must be even number of hex characters.");
+    }
+    if (backup) {
+      await execAsync(`cp "${args.filePath}" "${args.filePath}.bak"`);
+    }
+    const bytes = hex.match(/.{2}/g)?.map((h) => parseInt(h, 16)) ?? [];
+    const hexBytes = bytes.map((b) => `\\x${b.toString(16).padStart(2, "0")}`).join("");
+    await execAsync(`printf '${hexBytes}' | dd of="${args.filePath}" bs=1 seek=${args.offset} conv=notrunc 2>/dev/null`);
+    const summary = [
+      `Bytes Patched: ${args.filePath}`,
+      `Offset: 0x${args.offset.toString(16)} (${args.offset})`,
+      `Bytes written: ${bytes.length}`,
+      `Hex data: ${hex}`,
+      backup ? `Backup created: ${args.filePath}.bak` : "WARNING: No backup created"
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`Patch failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
+async function handleNopSled(args) {
+  const backup = args.createBackup ?? true;
+  const nopHex = "90".repeat(args.count);
+  return handlePatchBytes({
+    filePath: args.filePath,
+    offset: args.offset,
+    hexData: nopHex,
+    createBackup: backup
+  });
+}
+async function handleHexEditor(args) {
+  try {
+    const { stdout: currentHex } = await execAsync(`xxd -s ${args.offset} -l ${args.length} -p "${args.filePath}" | tr -d '\\n'`);
+    if (args.newHex) {
+      const hex = args.newHex.replace(/\s/g, "");
+      if (!/^[0-9a-fA-F]*$/.test(hex)) {
+        throw new Error("Invalid hex data.");
+      }
+      await execAsync(`cp "${args.filePath}" "${args.filePath}.bak"`);
+      const bytes = hex.match(/.{2}/g)?.map((h) => parseInt(h, 16)) ?? [];
+      const hexBytes = bytes.map((b) => `\\x${b.toString(16).padStart(2, "0")}`).join("");
+      await execAsync(`printf '${hexBytes}' | dd of="${args.filePath}" bs=1 seek=${args.offset} conv=notrunc 2>/dev/null`);
+      return {
+        content: [{
+          type: "text",
+          text: [
+            `Hex Editor: ${args.filePath}`,
+            `Offset: 0x${args.offset.toString(16)}`,
+            "",
+            `Previous: ${currentHex}`,
+            `New:      ${hex}`,
+            `Backup:   ${args.filePath}.bak`
+          ].join(`
+`)
+        }]
+      };
+    }
+    const summary = [
+      `Hex Editor (read mode): ${args.filePath}`,
+      `Offset: 0x${args.offset.toString(16)} (${args.offset})`,
+      `Length: ${args.length} bytes`,
+      "",
+      `Hex: ${currentHex}`,
+      "",
+      "To modify, provide newHex parameter"
+    ].join(`
+`);
+    return { content: [{ type: "text", text: summary }] };
+  } catch (error2) {
+    throw new Error(`Hex editor failed: ${error2 instanceof Error ? error2.message : error2}`);
+  }
+}
 var TOOLS = [
   {
     name: "nm_list_symbols",
@@ -14413,6 +15091,221 @@ var TOOLS = [
       },
       required: ["filePath", "pattern"]
     }
+  },
+  {
+    name: "bin_strings",
+    description: "Extract readable strings (ASCII, Unicode) from a binary file",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        minLength: { type: "number", description: "Minimum string length (default: 4)" },
+        encoding: {
+          type: "string",
+          enum: ["ascii", "unicode", "all"],
+          description: "String encoding to search (default: all)"
+        }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_file_info",
+    description: "Get detailed file type information with MIME type",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_section_sizes",
+    description: "Get section sizes (text, data, bss) of a binary",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_objdump_sections",
+    description: "Get section headers with flags using objdump -h",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_objdump_program_headers",
+    description: "Get program headers and DLL imports using objdump -p",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_otool_libs",
+    description: "Get dynamic library dependencies for Mach-O files (macOS only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the Mach-O file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_readelf",
+    description: "Comprehensive ELF structure analysis using readelf",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the ELF file" },
+        sections: {
+          type: "array",
+          items: { type: "string", enum: ["headers", "sections", "segments", "symbols", "dynamic", "all"] },
+          description: "Sections to analyze (default: all)"
+        }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_ldd",
+    description: "Get shared library dependencies using ldd (Linux only)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_disassembly",
+    description: "Disassemble binary code using objdump -d",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        symbol: { type: "string", description: "Specific symbol to disassemble (optional)" },
+        startOffset: { type: "number", description: "Line offset for output pagination" },
+        length: { type: "number", description: "Number of lines to output" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_security_audit",
+    description: "Check binary security features (ASLR, PIE, RELRO, stack canary, NX bit)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_entropy",
+    description: "Analyze section entropy to detect packed/encrypted sections",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        blockSize: { type: "number", description: "Block size for entropy calculation (default: 1024)" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_import_export",
+    description: "Get detailed import/export table analysis",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_diff",
+    description: "Byte-level comparison between two binary files",
+    inputSchema: {
+      type: "object",
+      properties: {
+        file1: { type: "string", description: "First binary file" },
+        file2: { type: "string", description: "Second binary file" },
+        contextBytes: { type: "number", description: "Bytes of context to show around differences (default: 32)" }
+      },
+      required: ["file1", "file2"]
+    }
+  },
+  {
+    name: "bin_archive_extract",
+    description: "Extract or list contents of static library (.a) archives",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the archive file" },
+        outputDir: { type: "string", description: "Output directory for extraction (optional)" },
+        listOnly: { type: "boolean", description: "Only list contents without extracting (default: false)" }
+      },
+      required: ["filePath"]
+    }
+  },
+  {
+    name: "bin_patch_bytes",
+    description: "Patch bytes at a specific offset in a binary file (DESTRUCTIVE)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        offset: { type: "number", description: "Byte offset to patch" },
+        hexData: { type: "string", description: "Hex bytes to write (e.g., '90 90 90')" },
+        createBackup: { type: "boolean", description: "Create .bak backup before patching (default: true)" }
+      },
+      required: ["filePath", "offset", "hexData"]
+    }
+  },
+  {
+    name: "bin_nop_sled",
+    description: "Insert NOP instructions at a specific offset (DESTRUCTIVE)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the binary file" },
+        offset: { type: "number", description: "Byte offset for NOP sled" },
+        count: { type: "number", description: "Number of NOP instructions to insert" },
+        createBackup: { type: "boolean", description: "Create .bak backup (default: true)" }
+      },
+      required: ["filePath", "offset", "count"]
+    }
+  },
+  {
+    name: "bin_hex_editor",
+    description: "Read or modify bytes at a specific offset (hex editor mode)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Path to the file" },
+        offset: { type: "number", description: "Byte offset" },
+        length: { type: "number", description: "Number of bytes to read/modify" },
+        newHex: { type: "string", description: "New hex bytes to write (optional - read mode if omitted)" }
+      },
+      required: ["filePath", "offset", "length"]
+    }
   }
 ];
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -14454,6 +15347,40 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleXxdExtract(args);
       case "xxd_find_pattern":
         return await handleXxdFindPattern(args);
+      case "bin_strings":
+        return await handleStrings(args);
+      case "bin_file_info":
+        return await handleFileInfo(args);
+      case "bin_section_sizes":
+        return await handleSectionSizes(args);
+      case "bin_objdump_sections":
+        return await handleObjdumpSections(args);
+      case "bin_objdump_program_headers":
+        return await handleObjdumpProgramHeaders(args);
+      case "bin_otool_libs":
+        return await handleOtoolLibs(args);
+      case "bin_readelf":
+        return await handleReadelf(args);
+      case "bin_ldd":
+        return await handleLdd(args);
+      case "bin_disassembly":
+        return await handleDisassembly(args);
+      case "bin_security_audit":
+        return await handleSecurityAudit(args);
+      case "bin_entropy":
+        return await handleEntropyAnalysis(args);
+      case "bin_import_export":
+        return await handleImportExport(args);
+      case "bin_diff":
+        return await handleBinaryDiff(args);
+      case "bin_archive_extract":
+        return await handleArchiveExtract(args);
+      case "bin_patch_bytes":
+        return await handlePatchBytes(args);
+      case "bin_nop_sled":
+        return await handleNopSled(args);
+      case "bin_hex_editor":
+        return await handleHexEditor(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }