@ebowwa/mcp-nm 2.0.0 → 2.0.1

package/dist/index.js

@@ -13965,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}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/mcp-nm",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "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

@@ -537,17 +537,9 @@ async function handleXxdFindPattern(args: {
   patternFormat?: "hex" | "text";
   maxLength?: number;
 }) {
-  // Read file as hex
-  const result = await runXxd(args.filePath, {
-    plainHex: true,
-    length: args.maxLength,
-  });
-
-  const fileHex = result.output.replace(/\s/g, "").toLowerCase();
+  // Convert pattern to hex if text
   let searchPattern: string;
-
   if (args.patternFormat === "text" || !args.patternFormat) {
-    // Convert text to hex
     searchPattern = args.pattern
       .split("")
       .map((c) => c.charCodeAt(0).toString(16).padStart(2, "0"))
@@ -556,24 +548,119 @@ async function handleXxdFindPattern(args: {
     searchPattern = args.pattern.replace(/\s/g, "").toLowerCase();
   }
 
+  // Get file size to determine approach
+  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; // 50MB default limit
+
   const matches: { offset: number; context: string }[] = [];
-  let idx = 0;
-  while ((idx = fileHex.indexOf(searchPattern, idx)) !== -1) {
-    const byteOffset = Math.floor(idx / 2);
-    // Get context (10 bytes before and after)
-    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) {
+    // Small file: use in-memory approach
+    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; // Limit matches
+    }
+  } else {
+    // Large file: use streaming grep approach
+    // Use grep -abo for byte offset (Linux) or grep -b with binary mode (macOS)
+    try {
+      // Try using grep with binary pattern
+      // Convert hex pattern to escaped bytes for grep
+      const patternBytes = searchPattern.match(/.{2}/g) ?? [];
+      const escapedPattern = patternBytes.map(b => `\\x${b}`).join("");
+
+      // Use grep -b to get byte offsets, with binary search
+      const { stdout: grepResult } = await execAsync(
+        `grep -abo "${escapedPattern}" "${args.filePath}" 2>/dev/null | head -1000`,
+        { maxBuffer: 10 * 1024 * 1024 }
+      );
+
+      const lines = grepResult.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        const match = line.match(/^(\d+):/);
+        if (match) {
+          const offset = parseInt(match[1], 10);
+          // Get context using dd
+          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 {
+      // grep failed, try alternative: use strings with offset
+      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("\n").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 {
+        // Last resort: chunked reading
+        const chunkSize = 10 * 1024 * 1024; // 10MB chunks
+        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 {
+            // Skip failed chunk
+          }
+        }
+      }
+    }
   }
 
   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}`,