mcp-devutils 1.3.1 → 1.5.0

package/README.md

@@ -1,4 +1,62 @@
+# mcp-devutils
 
+MCP server with **35 developer utilities** for Claude Desktop, Cursor, and any MCP-compatible AI assistant.
+
+## Install
+
+```json
+{
+  "mcpServers": {
+    "devutils": {
+      "command": "npx",
+      "args": ["-y", "mcp-devutils"]
+    }
+  }
+}
+```
+
+## Tools (35)
+
+| Tool | Description |
+|------|-------------|
+| `uuid` | Generate UUID v4 (batch support) |
+| `hash` | Hash text (md5, sha1, sha256) |
+| `base64` | Encode/decode base64 |
+| `timestamp` | Convert Unix ↔ ISO 8601 dates |
+| `jwt_decode` | Decode JWT tokens (header + payload) |
+| `random_string` | Generate random strings/passwords |
+| `url_encode` | URL encode/decode |
+| `json_format` | Pretty-print or minify JSON |
+| `regex_test` | Test regex patterns with match details |
+| `cron_explain` | Explain cron expressions + next run times |
+| `hmac` | Generate HMAC signatures |
+| `color_convert` | Convert hex ↔ RGB ↔ HSL colors |
+| `semver_compare` | Compare semantic versions |
+| `http_status` | Look up HTTP status code meanings |
+| `slug` | Generate URL-safe slugs |
+| `escape_html` | Escape/unescape HTML entities |
+| `chmod_calc` | Convert numeric ↔ symbolic permissions |
+| `diff` | Compare two text strings |
+| `number_base` | Convert decimal/hex/octal/binary |
+| `lorem_ipsum` | Generate placeholder text |
+| `word_count` | Count chars, words, lines, bytes |
+| `cidr` | Parse CIDR notation (network, broadcast, hosts) |
+| `case_convert` | Convert camelCase/snake_case/PascalCase/kebab-case |
+| `markdown_toc` | Generate table of contents from markdown |
+| `env_parse` | Parse and validate .env files |
+| `ip_info` | Analyze IP addresses (type, class, private/public) |
+| `password_strength` | Analyze password entropy and strength |
+| `data_size` | Convert between bytes/KB/MB/GB/TB (SI + IEC) |
+| `string_escape` | Escape strings for JSON/CSV/regex/SQL/shell |
+| `nanoid` | Generate compact, URL-safe unique IDs |
+| `csv_json` | Convert between CSV and JSON |
+| `hex_encode` | Hex encode/decode text |
+| `char_info` | Unicode character info (codepoint, UTF-8 bytes, HTML entity) |
+| `byte_count` | Count string bytes in UTF-8/UTF-16/ASCII |
+
+## Zero dependencies
+
+Only requires `@modelcontextprotocol/sdk`. All tools use Node.js built-ins.
 
 ## Support
 
@@ -6,3 +64,7 @@ If this tool saves you time, consider supporting development:
 
 - [Buy me a coffee](https://buymeacoffee.com/gl89tu25lp)
 - [Tip via Stripe ($3)](https://buy.stripe.com/dRm8wP8R295Z9VyeN59Zm00)
+
+## License
+
+MIT

package/index.js

@@ -5,7 +5,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 import crypto from "crypto";
 
 const server = new Server(
-  { name: "mcp-devutils", version: "1.3.0" },
+  { name: "mcp-devutils", version: "1.5.0" },
   { capabilities: { tools: {} } }
 );
 
@@ -335,6 +335,135 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ["markdown"]
         }
+      },
+      {
+        name: "env_parse",
+        description: "Parse and validate .env file contents — shows keys, detects issues like missing values, duplicate keys, or invalid lines",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: ".env file content to parse and validate" }
+          },
+          required: ["content"]
+        }
+      },
+      {
+        name: "ip_info",
+        description: "Parse and analyze an IP address — shows type (IPv4/IPv6), class, whether private/public/loopback/link-local",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ip: { type: "string", description: "IP address to analyze (e.g. '192.168.1.1' or '::1')" }
+          },
+          required: ["ip"]
+        }
+      },
+      {
+        name: "password_strength",
+        description: "Analyze password strength — calculates entropy, checks length, character diversity, and common patterns",
+        inputSchema: {
+          type: "object",
+          properties: {
+            password: { type: "string", description: "Password to analyze" }
+          },
+          required: ["password"]
+        }
+      },
+      {
+        name: "data_size",
+        description: "Convert between data size units (bytes, KB, MB, GB, TB, PB) with both decimal (SI) and binary (IEC) representations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: { type: "number", description: "Numeric value to convert" },
+            unit: {
+              type: "string",
+              enum: ["B", "KB", "MB", "GB", "TB", "PB", "KiB", "MiB", "GiB", "TiB", "PiB"],
+              description: "Source unit (default: B for bytes)"
+            }
+          },
+          required: ["value"]
+        }
+      },
+      {
+        name: "string_escape",
+        description: "Escape or unescape strings for various contexts: JSON, CSV, regex, SQL, or shell",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to escape or unescape" },
+            format: {
+              type: "string",
+              enum: ["json", "csv", "regex", "sql", "shell"],
+              description: "Target format to escape for"
+            },
+            action: {
+              type: "string",
+              enum: ["escape", "unescape"],
+              description: "Action: escape or unescape (default: escape)"
+            }
+          },
+          required: ["text", "format"]
+        }
+      },
+      {
+        name: "nanoid",
+        description: "Generate compact, URL-safe unique IDs (like UUID but shorter). Customizable length and alphabet.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            length: { type: "number", description: "ID length (default: 21)" },
+            alphabet: { type: "string", description: "Custom alphabet (default: A-Za-z0-9_-)" },
+            count: { type: "number", description: "Number of IDs to generate (default: 1, max: 10)" }
+          }
+        }
+      },
+      {
+        name: "csv_json",
+        description: "Convert between CSV and JSON. CSV→JSON parses CSV text into an array of objects. JSON→CSV converts an array of objects to CSV.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: { type: "string", description: "CSV text or JSON string to convert" },
+            direction: { type: "string", enum: ["csv_to_json", "json_to_csv"], description: "Conversion direction" },
+            delimiter: { type: "string", description: "CSV delimiter (default: comma)" }
+          },
+          required: ["input", "direction"]
+        }
+      },
+      {
+        name: "hex_encode",
+        description: "Encode text to hexadecimal or decode hex back to text",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to encode or hex string to decode" },
+            action: { type: "string", enum: ["encode", "decode"], description: "Action (default: encode)" }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "char_info",
+        description: "Get Unicode character info — codepoint, name category, UTF-8 bytes, HTML entity for each character in the input",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Characters to analyze (1-20 chars)" }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "byte_count",
+        description: "Count the byte length of a string in UTF-8, UTF-16, and ASCII. Useful for checking API payload sizes and database field limits.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Text to measure" }
+          },
+          required: ["text"]
+        }
       }
     ]
   };
@@ -1032,6 +1161,294 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: "text", text: toc.join("\n") }] };
       }
 
+      case "env_parse": {
+        const { content } = args;
+        const lines = content.split("\n");
+        const keys = [];
+        const issues = [];
+        const seen = new Set();
+        lines.forEach((line, i) => {
+          const num = i + 1;
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) return;
+          const eqIdx = trimmed.indexOf("=");
+          if (eqIdx === -1) {
+            issues.push(`Line ${num}: Invalid format (no '=' found): ${trimmed}`);
+            return;
+          }
+          const key = trimmed.substring(0, eqIdx).trim();
+          const val = trimmed.substring(eqIdx + 1).trim();
+          if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            issues.push(`Line ${num}: Invalid key name '${key}'`);
+          }
+          if (seen.has(key)) {
+            issues.push(`Line ${num}: Duplicate key '${key}'`);
+          }
+          seen.add(key);
+          if (!val) {
+            issues.push(`Line ${num}: Empty value for '${key}'`);
+          }
+          keys.push({ key, value: val.length > 50 ? val.substring(0, 50) + "..." : val, line: num });
+        });
+        const output = [`Parsed ${keys.length} key(s) from ${lines.length} line(s)`];
+        if (keys.length > 0) {
+          output.push("\nKeys:");
+          keys.forEach(k => output.push(`  ${k.key} = ${k.value} (line ${k.line})`));
+        }
+        if (issues.length > 0) {
+          output.push(`\n⚠ ${issues.length} issue(s):`);
+          issues.forEach(i => output.push(`  ${i}`));
+        } else {
+          output.push("\n✓ No issues found");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "ip_info": {
+        const { ip } = args;
+        const trimmed = ip.trim();
+        const output = [];
+        if (trimmed.includes(":")) {
+          output.push(`IP: ${trimmed}`);
+          output.push(`Version: IPv6`);
+          if (trimmed === "::1") output.push("Type: Loopback");
+          else if (trimmed.startsWith("fe80:")) output.push("Type: Link-local");
+          else if (trimmed.startsWith("fc") || trimmed.startsWith("fd")) output.push("Type: Unique local (private)");
+          else if (trimmed.startsWith("ff")) output.push("Type: Multicast");
+          else if (trimmed === "::") output.push("Type: Unspecified");
+          else output.push("Type: Global unicast (public)");
+        } else {
+          const parts = trimmed.split(".");
+          if (parts.length !== 4 || parts.some(p => isNaN(p) || +p < 0 || +p > 255)) {
+            throw new Error(`Invalid IPv4 address: ${trimmed}`);
+          }
+          const octets = parts.map(Number);
+          output.push(`IP: ${trimmed}`);
+          output.push(`Version: IPv4`);
+          output.push(`Binary: ${octets.map(o => o.toString(2).padStart(8, "0")).join(".")}`);
+          if (octets[0] === 127) output.push("Type: Loopback");
+          else if (octets[0] === 10) output.push("Type: Private (10.0.0.0/8, Class A)");
+          else if (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) output.push("Type: Private (172.16.0.0/12, Class B)");
+          else if (octets[0] === 192 && octets[1] === 168) output.push("Type: Private (192.168.0.0/16, Class C)");
+          else if (octets[0] === 169 && octets[1] === 254) output.push("Type: Link-local (APIPA)");
+          else if (octets[0] >= 224 && octets[0] <= 239) output.push("Type: Multicast");
+          else if (octets[0] >= 240) output.push("Type: Reserved");
+          else output.push("Type: Public");
+          if (octets[0] < 128) output.push("Class: A");
+          else if (octets[0] < 192) output.push("Class: B");
+          else if (octets[0] < 224) output.push("Class: C");
+          else if (octets[0] < 240) output.push("Class: D (Multicast)");
+          else output.push("Class: E (Reserved)");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "password_strength": {
+        const { password } = args;
+        const len = password.length;
+        let charsetSize = 0;
+        if (/[a-z]/.test(password)) charsetSize += 26;
+        if (/[A-Z]/.test(password)) charsetSize += 26;
+        if (/[0-9]/.test(password)) charsetSize += 10;
+        if (/[^a-zA-Z0-9]/.test(password)) charsetSize += 32;
+        const entropy = Math.round(len * Math.log2(charsetSize || 1) * 100) / 100;
+        const issues = [];
+        if (len < 8) issues.push("Too short (< 8 characters)");
+        if (!/[A-Z]/.test(password)) issues.push("No uppercase letters");
+        if (!/[a-z]/.test(password)) issues.push("No lowercase letters");
+        if (!/[0-9]/.test(password)) issues.push("No digits");
+        if (!/[^a-zA-Z0-9]/.test(password)) issues.push("No special characters");
+        if (/(.)\1{2,}/.test(password)) issues.push("Contains repeated characters (3+)");
+        if (/^(123|abc|qwerty|password|admin|letmein)/i.test(password)) issues.push("Starts with common pattern");
+        let strength;
+        if (entropy < 28) strength = "Very Weak";
+        else if (entropy < 36) strength = "Weak";
+        else if (entropy < 60) strength = "Moderate";
+        else if (entropy < 80) strength = "Strong";
+        else strength = "Very Strong";
+        const output = [
+          `Password length: ${len}`,
+          `Charset size: ${charsetSize}`,
+          `Entropy: ${entropy} bits`,
+          `Strength: ${strength}`,
+        ];
+        if (issues.length > 0) {
+          output.push(`\nIssues (${issues.length}):`);
+          issues.forEach(i => output.push(`  - ${i}`));
+        } else {
+          output.push("\n✓ No issues detected");
+        }
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "data_size": {
+        const { value, unit = "B" } = args;
+        const units = {
+          B: 1, KB: 1e3, MB: 1e6, GB: 1e9, TB: 1e12, PB: 1e15,
+          KiB: 1024, MiB: 1048576, GiB: 1073741824, TiB: 1099511627776, PiB: 1125899906842624
+        };
+        if (!units[unit]) throw new Error(`Unknown unit: ${unit}. Use: ${Object.keys(units).join(", ")}`);
+        const bytes = value * units[unit];
+        const fmt = (n) => n < 0.01 ? n.toExponential(2) : (n % 1 === 0 ? n.toString() : n.toFixed(2));
+        const output = [
+          `Input: ${value} ${unit} = ${fmt(bytes)} bytes`,
+          "",
+          "Decimal (SI):",
+          `  ${fmt(bytes)} B`,
+          `  ${fmt(bytes / 1e3)} KB`,
+          `  ${fmt(bytes / 1e6)} MB`,
+          `  ${fmt(bytes / 1e9)} GB`,
+          `  ${fmt(bytes / 1e12)} TB`,
+          `  ${fmt(bytes / 1e15)} PB`,
+          "",
+          "Binary (IEC):",
+          `  ${fmt(bytes)} B`,
+          `  ${fmt(bytes / 1024)} KiB`,
+          `  ${fmt(bytes / 1048576)} MiB`,
+          `  ${fmt(bytes / 1073741824)} GiB`,
+          `  ${fmt(bytes / 1099511627776)} TiB`,
+          `  ${fmt(bytes / 1125899906842624)} PiB`,
+        ];
+        return { content: [{ type: "text", text: output.join("\n") }] };
+      }
+
+      case "string_escape": {
+        const { text, format, action = "escape" } = args;
+        let result;
+        if (action === "escape") {
+          switch (format) {
+            case "json":
+              result = JSON.stringify(text).slice(1, -1);
+              break;
+            case "csv":
+              result = text.includes(",") || text.includes('"') || text.includes("\n")
+                ? '"' + text.replace(/"/g, '""') + '"'
+                : text;
+              break;
+            case "regex":
+              result = text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+              break;
+            case "sql":
+              result = text.replace(/'/g, "''");
+              break;
+            case "shell":
+              result = "'" + text.replace(/'/g, "'\\''") + "'";
+              break;
+            default:
+              throw new Error(`Unknown format: ${format}`);
+          }
+        } else {
+          switch (format) {
+            case "json":
+              result = JSON.parse(`"${text}"`);
+              break;
+            case "csv":
+              result = text.startsWith('"') && text.endsWith('"')
+                ? text.slice(1, -1).replace(/""/g, '"')
+                : text;
+              break;
+            case "regex":
+              result = text.replace(/\\([.*+?^${}()|[\]\\])/g, "$1");
+              break;
+            case "sql":
+              result = text.replace(/''/g, "'");
+              break;
+            case "shell":
+              result = text.startsWith("'") && text.endsWith("'")
+                ? text.slice(1, -1).replace(/'\\''/g, "'")
+                : text;
+              break;
+            default:
+              throw new Error(`Unknown format: ${format}`);
+          }
+        }
+        return { content: [{ type: "text", text: result }] };
+      }
+
+      case "nanoid": {
+        const len = Math.min(Math.max(args.length || 21, 1), 128);
+        const alphabet = args.alphabet || "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+        const count = Math.min(Math.max(args.count || 1, 1), 10);
+        const ids = [];
+        for (let i = 0; i < count; i++) {
+          const bytes = crypto.randomBytes(len);
+          let id = "";
+          for (let j = 0; j < len; j++) {
+            id += alphabet[bytes[j] % alphabet.length];
+          }
+          ids.push(id);
+        }
+        return { content: [{ type: "text", text: ids.join("\n") }] };
+      }
+
+      case "csv_json": {
+        const { input, direction, delimiter = "," } = args;
+        if (direction === "csv_to_json") {
+          const lines = input.split("\n").filter(l => l.trim());
+          if (lines.length < 1) throw new Error("CSV must have at least a header row");
+          const headers = lines[0].split(delimiter).map(h => h.trim().replace(/^"|"$/g, ""));
+          const rows = lines.slice(1).map(line => {
+            const vals = line.split(delimiter).map(v => v.trim().replace(/^"|"$/g, ""));
+            const obj = {};
+            headers.forEach((h, i) => { obj[h] = vals[i] || ""; });
+            return obj;
+          });
+          return { content: [{ type: "text", text: JSON.stringify(rows, null, 2) }] };
+        } else {
+          const arr = JSON.parse(input);
+          if (!Array.isArray(arr) || arr.length === 0) throw new Error("Input must be a non-empty JSON array");
+          const headers = Object.keys(arr[0]);
+          const csvLines = [headers.join(delimiter)];
+          for (const row of arr) {
+            csvLines.push(headers.map(h => {
+              const val = String(row[h] ?? "");
+              return val.includes(delimiter) || val.includes('"') || val.includes("\n")
+                ? `"${val.replace(/"/g, '""')}"` : val;
+            }).join(delimiter));
+          }
+          return { content: [{ type: "text", text: csvLines.join("\n") }] };
+        }
+      }
+
+      case "hex_encode": {
+        const action = args.action || "encode";
+        if (action === "encode") {
+          return { content: [{ type: "text", text: Buffer.from(args.text, "utf-8").toString("hex") }] };
+        } else {
+          const hex = args.text.replace(/\s/g, "");
+          return { content: [{ type: "text", text: Buffer.from(hex, "hex").toString("utf-8") }] };
+        }
+      }
+
+      case "char_info": {
+        const chars = [...args.text].slice(0, 20);
+        const info = chars.map(ch => {
+          const cp = ch.codePointAt(0);
+          const hex = cp.toString(16).toUpperCase().padStart(4, "0");
+          const utf8Bytes = Buffer.from(ch, "utf-8");
+          const htmlEntity = cp < 128 ? `&#${cp};` : `&#x${hex};`;
+          return `'${ch}'  U+${hex}  decimal: ${cp}  UTF-8: ${[...utf8Bytes].map(b => b.toString(16).padStart(2, "0")).join(" ")}  HTML: ${htmlEntity}`;
+        });
+        return { content: [{ type: "text", text: info.join("\n") }] };
+      }
+
+      case "byte_count": {
+        const text = args.text;
+        const utf8 = Buffer.byteLength(text, "utf-8");
+        const utf16 = Buffer.byteLength(text, "utf-16le");
+        const ascii = text.length; // JS string length
+        const chars = [...text].length; // actual character count (handles surrogate pairs)
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            characters: chars,
+            js_length: text.length,
+            utf8_bytes: utf8,
+            utf16_bytes: utf16,
+            ascii_bytes: ascii
+          }, null, 2) }]
+        };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-devutils",
-  "version": "1.3.1",
-  "description": "MCP server with 25 developer utilities - UUID, hash, HMAC, base64, timestamps, JWT decode, random strings, URL encode/decode, JSON format, regex test, cron explain, color convert, semver compare, HTTP status codes, slugify, HTML escape, chmod calculator, text diff, number base converter, lorem ipsum, word count, CIDR calculator, case converter, markdown TOC",
+  "version": "1.5.0",
+  "description": "MCP server with 35 developer utilities - UUID, nanoid, hash, HMAC, base64, hex encode, timestamps, JWT decode, random strings, URL encode/decode, JSON format, CSV/JSON convert, regex test, cron explain, color convert, semver compare, HTTP status codes, slugify, HTML escape, chmod calculator, text diff, number base converter, lorem ipsum, word count, byte count, CIDR calculator, case converter, markdown TOC, env parser, IP info, password strength, data size converter, string escape, char info",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -36,7 +36,17 @@
     "word-count",
     "cidr",
     "case-convert",
-    "markdown-toc"
+    "markdown-toc",
+    "env-parser",
+    "ip-address",
+    "password-strength",
+    "data-size",
+    "string-escape",
+    "nanoid",
+    "csv-json",
+    "hex-encode",
+    "unicode",
+    "byte-count"
   ],
   "author": "Hong Teoh",
   "license": "MIT",