it-tools-mcp 3.0.8 → 3.0.10

package/README.dockerhub.md

@@ -4,7 +4,7 @@
 [![Docker Image Size](https://img.shields.io/docker/image-size/wrenchpilot/it-tools-mcp/latest?refresh=1)](https://hub.docker.com/r/wrenchpilot/it-tools-mcp)
 [![Build Status](https://github.com/wrenchpilot/it-tools-mcp/workflows/Build%20and%20Push%20to%20Docker%20Hub/badge.svg)](https://github.com/wrenchpilot/it-tools-mcp/actions)
 
-A comprehensive Model Context Protocol (MCP) server that provides access to **75 IT tools and utilities** commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
+A comprehensive Model Context Protocol (MCP) server that provides access to **86 IT tools and utilities** commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
 
 ## Using with VS Code
 
@@ -56,7 +56,7 @@ Add to your VS Code `settings.json`:
 }
 ```
 
-See the complete list of all 75 tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
+See the complete list of all 86 tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
 
 ## 📸 Examples in Action
 
@@ -76,7 +76,7 @@ Built with **TypeScript**, **Zod** validation, and **MCP SDK** for robust, type-
 
 This project was developed using **VS Code**, **Copilot Chat Agent**, **Playwright MCP**, and the **Claude Sonnet 4 Model**, showcasing modern AI-assisted software development:
 
-- 🔧 **All 75 tools** designed and implemented with AI assistance
+- 🔧 **All 86 tools** designed and implemented with AI assistance
 - 📦 **Complete Docker setup** with GitHub Actions CI/CD pipeline
 - 🔍 **Schema optimization** with systematic validation cleanup
 - 📚 **Comprehensive documentation** and tool catalogs
@@ -86,6 +86,7 @@ This project was developed using **VS Code**, **Copilot Chat Agent**, **Playwrig
 ```text
 src/
 ├── index.ts              # Main MCP server
+├── security.ts           # Security settings
 └── tools/                # Tool modules by category
     ├── encoding.ts       # Base64, URL, HTML encoding
     ├── crypto.ts         # Hashing, JWT, passwords

package/README.md

@@ -6,7 +6,7 @@
 
 > **📝 Note**: A condensed version of this README is automatically synced to [Docker Hub](https://hub.docker.com/r/wrenchpilot/it-tools-mcp) due to character limits.
 
-A comprehensive Model Context Protocol (MCP) server that provides access to 75 IT tools and utilities commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
+A comprehensive Model Context Protocol (MCP) server that provides access to 86 IT tools and utilities commonly used by developers, system administrators, and IT professionals. This server exposes a complete set of tools for encoding/decoding, text manipulation, hashing, network utilities, and many other common development and IT tasks.
 
 ## 📦 Installation & Setup
 
@@ -80,16 +80,16 @@ echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"base64-enc
 
 ## 🛠️ Tool Categories
 
-This MCP server provides **75 tools** across **8 categories**:
+This MCP server provides **86 tools** across **8 categories**:
 
 - **🔧 Encoding & Decoding** (9 tools): Base64, URL, HTML entities, text-to-binary, Unicode
 - **📝 Data Format** (11 tools): JSON, XML, YAML, SQL, TOML, Markdown ↔ HTML conversion
 - **🔐 Security & Crypto** (12 tools): Hashing (MD5, SHA1-512), HMAC, JWT, bcrypt, passwords, tokens
 - **✨ Text Processing** (16 tools): Case conversion, stats, diff, ASCII art, NATO alphabet, slugify
-- **🌐 Network & Web** (8 tools): IPv4/IPv6 subnets, URL parsing, MAC addresses, phone formatting
+- **🌐 Network & System** (19 tools): IPv4/IPv6 subnets, URL parsing, MAC addresses, phone formatting, ps, top, cat, head, tail, grep, ping, nslookup, telnet, dig, ssh, random-port, mac-address-generate, ip/ipv6 calculators
 - **🔢 Math & Calculations** (6 tools): Expression evaluation, base conversion, temperature, percentages
-- **🆔 ID & Code Generators** (4 tools): UUID, ULID, QR codes, SVG placeholders
-- **🔧 Development & Utilities** (9 tools): Regex testing, cron expressions, color conversion, MIME types
+- **🆔 ID & Code Generators** (4 tools: UUID, ULID, QR codes, SVG placeholders
+- **🛠️ Utility Tools** (9 tools): Color, MIME, HTTP, device info, email normalization, etc.
 
 ## 📸 Screenshot Examples
 
@@ -159,14 +159,25 @@ This MCP server provides **75 tools** across **8 categories**:
 | `lorem-ipsum-generator`     | Generate Lorem Ipsum                   | `type?: 'words' \| 'sentences' \| 'paragraphs'`, `count?: number`                                                                                                                                         |
 | `numeronym-generator`       | Generate numeronyms                    | `text: string`                                                                                                                                                                                            |
 | `emoji-search`              | Search emojis                          | `query: string`                                                                                                                                                                                           |
-| **Network & Web**           |                                        |                                                                                                                                                                                                           |
+| **Network & System**        |                                        |                                                                                                                                                                                                           |
+| `ps`                        | List running processes                 | None                                                                                                                                                                                                      |
+| `top`                       | Show top processes (by CPU)            | None                                                                                                                                                                                                      |
+| `cat`                       | Display file content                   | `file: string`                                                                                                                                                                                            |
+| `head`                      | Show first N lines of file             | `file: string`, `lines?: number`                                                                                                                                                                          |
+| `tail`                      | Show last N lines of file              | `file: string`, `lines?: number`                                                                                                                                                                          |
+| `grep`                      | Search for pattern in file             | `file: string`, `pattern: string`                                                                                                                                                                         |
+| `ping`                      | Ping a host                            | `target: string`, `count?: number`                                                                                                                                                                        |
+| `nslookup`                  | DNS lookup (A/AAAA/CNAME)              | `target: string`                                                                                                                                                                                          |
+| `telnet`                    | Test TCP connectivity                  | `target: string`, `port: number`                                                                                                                                                                          |
+| `dig`                       | DNS query (custom type)                | `target: string`, `type?: string`                                                                                                                                                                         |
+| `ssh`                       | SSH command execution                  | `target: string`, `user: string`, `command: string`                                                                                                                                                       |
 | `ip-subnet-calculator`      | Calculate IPv4 subnet                  | `ip: string`, `cidr: number`                                                                                                                                                                              |
 | `ipv4-subnet-calc`          | Enhanced IPv4 subnet calc              | `cidr: string`                                                                                                                                                                                            |
 | `ipv6-ula-generator`        | Generate IPv6 ULA                      | `globalId?: string`                                                                                                                                                                                       |
 | `url-parse`                 | Parse URL components                   | `url: string`                                                                                                                                                                                             |
 | `random-port`               | Generate random ports                  | `count?: number`, `min?: number`, `max?: number`, `exclude?: number[]`                                                                                                                                    |
-| `mac-address-generate`      | Generate MAC address                   | `prefix?: string`, `separator?: ':' \| '-'`                                                                                                                                                               |
-| `phone-format`              | Format phone numbers                   | `phoneNumber: string`, `countryCode?: string`                                                                                                                                                             |
+| `mac-address-generate`      | Generate MAC address                   | `prefix?: string`, `separator?: ':' | '-'`                                                                                                                                                                |
+| `phone-format`              | Parse and format phone numbers         | `phoneNumber: string`, `countryCode?: string`                                                                                                                                                             |
 | `iban-validate`             | Validate IBAN                          | `iban: string`                                                                                                                                                                                            |
 | **Math & Calculations**     |                                        |                                                                                                                                                                                                           |
 | `math-evaluate`             | Evaluate expressions                   | `expression: string`                                                                                                                                                                                      |
@@ -260,6 +271,7 @@ This showcases how AI can accelerate development while maintaining code quality,
 ```text
 src/
 ├── index.ts              # Main MCP server
+├── security.ts           # Security settings
 └── tools/                # Tool modules by category
     ├── encoding.ts       # Base64, URL, HTML encoding
     ├── crypto.ts         # Hashing, JWT, passwords

package/build/tools/dataFormat.js

@@ -504,4 +504,37 @@ ${differences.map((diff, i) => `${i + 1}. ${diff}`).join('\n')}`,
             };
         }
     });
+    // Phone number formatter
+    server.tool("phone-format", "Parse and format phone numbers", {
+        phoneNumber: z.string().describe("Phone number to parse and format"),
+        countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
+    }, async ({ phoneNumber, countryCode }) => {
+        try {
+            const { isValidPhoneNumber, parsePhoneNumber } = await import("libphonenumber-js");
+            // First check if it's a valid phone number
+            if (!isValidPhoneNumber(phoneNumber, countryCode)) {
+                throw new Error("Invalid phone number format");
+            }
+            // Parse the phone number
+            const parsedNumber = parsePhoneNumber(phoneNumber, countryCode);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Phone Number Formatting:\n\nOriginal: ${phoneNumber}\nCountry: ${parsedNumber.country || 'Unknown'}\nNational: ${parsedNumber.formatNational()}\nInternational: ${parsedNumber.formatInternational()}\nE.164: ${parsedNumber.format('E.164')}\nURI: ${parsedNumber.getURI()}\n\nDetails:\nType: ${parsedNumber.getType() || 'Unknown'}\nCountry Code: +${parsedNumber.countryCallingCode}\nNational Number: ${parsedNumber.nationalNumber}\nValid: ${parsedNumber.isValid()}\n\n✅ Formatted using libphonenumber-js library for accuracy.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error formatting phone number: ${error instanceof Error ? error.message : 'Unknown error'}\n\n💡 Tips:\n• Include country code (e.g., +1 555-123-4567)\n• Use standard formats (e.g., (555) 123-4567)\n• Specify country code parameter if needed\n• Examples: "+1-555-123-4567", "555-123-4567" with countryCode="US"`,
+                    },
+                ],
+            };
+        }
+    });
 }

package/build/tools/network.js

@@ -1,4 +1,13 @@
 import { z } from "zod";
+import { Client as SSHClient } from "ssh2";
+import ping from "ping";
+import dns from "dns";
+import Telnet from "telnet-client";
+import psList from "ps-list";
+import fs from "fs";
+import readLastLines from "read-last-lines";
+// For Telnet import (telnet-client exports as an object, not a class)
+const TelnetClient = Telnet.Telnet || Telnet;
 export function registerNetworkTools(server) {
     // IP address tools
     server.tool("ip-subnet-calculator", "Calculate subnet information for IPv4", {
@@ -440,60 +449,7 @@ ${prefix ? `Used prefix: ${prefix}` : 'Randomly generated'}`,
             };
         }
     });
-    // Phone number formatter
-    server.tool("phone-format", "Parse and format phone numbers", {
-        phoneNumber: z.string().describe("Phone number to parse and format"),
-        countryCode: z.string().optional().describe("Country code (e.g., 'US', 'GB', 'FR')"),
-    }, async ({ phoneNumber, countryCode }) => {
-        try {
-            const { isValidPhoneNumber, parsePhoneNumber } = await import("libphonenumber-js");
-            // First check if it's a valid phone number
-            if (!isValidPhoneNumber(phoneNumber, countryCode)) {
-                throw new Error("Invalid phone number format");
-            }
-            // Parse the phone number
-            const parsedNumber = parsePhoneNumber(phoneNumber, countryCode);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Phone Number Formatting:
-
-Original: ${phoneNumber}
-Country: ${parsedNumber.country || 'Unknown'}
-National: ${parsedNumber.formatNational()}
-International: ${parsedNumber.formatInternational()}
-E.164: ${parsedNumber.format('E.164')}
-URI: ${parsedNumber.getURI()}
-
-Details:
-Type: ${parsedNumber.getType() || 'Unknown'}
-Country Code: +${parsedNumber.countryCallingCode}
-National Number: ${parsedNumber.nationalNumber}
-Valid: ${parsedNumber.isValid()}
-
-✅ Formatted using libphonenumber-js library for accuracy.`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error formatting phone number: ${error instanceof Error ? error.message : 'Unknown error'}
-
-💡 Tips:
-• Include country code (e.g., +1 555-123-4567)
-• Use standard formats (e.g., (555) 123-4567)
-• Specify country code parameter if needed
-• Examples: "+1-555-123-4567", "555-123-4567" with countryCode="US"`,
-                    },
-                ],
-            };
-        }
-    });
+    // Phone number formatter tool moved to dataFormat.ts
     // IBAN validator (using iban library)
     server.tool("iban-validate", "Validate and parse IBAN (International Bank Account Number)", {
         iban: z.string().describe("IBAN to validate and parse"),
@@ -575,4 +531,194 @@ Common issues:
             };
         }
     });
+    // SSH Tool (using ssh2)
+    server.tool("ssh", "Connect to a target via SSH", {
+        target: z.string().describe("Target host"),
+        user: z.string().describe("Username"),
+        command: z.string().describe("Command to run on remote host"),
+        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional)")
+    }, async ({ target, user, command, privateKey }) => {
+        return new Promise((resolve) => {
+            const conn = new SSHClient();
+            let output = "";
+            conn.on("ready", () => {
+                conn.exec(command, (err, stream) => {
+                    if (err) {
+                        resolve({ content: [{ type: "text", text: `SSH error: ${err.message}` }] });
+                        conn.end();
+                        return;
+                    }
+                    stream.on("close", () => {
+                        conn.end();
+                        resolve({ content: [{ type: "text", text: output }] });
+                    }).on("data", (data) => {
+                        output += data.toString();
+                    }).stderr.on("data", (data) => {
+                        output += data.toString();
+                    });
+                });
+            }).on("error", (err) => {
+                resolve({ content: [{ type: "text", text: `SSH connection error: ${err.message}` }] });
+            }).connect({
+                host: target,
+                username: user,
+                ...(privateKey ? { privateKey } : {})
+            });
+        });
+    });
+    // Ping Tool (using ping)
+    server.tool("ping", "Ping a host to check connectivity", {
+        target: z.string().describe("Host to ping"),
+        count: z.number().default(4).describe("Number of ping attempts")
+    }, async ({ target, count }) => {
+        try {
+            const res = await ping.promise.probe(target, { min_reply: count });
+            return {
+                content: [
+                    { type: "text", text: `Ping to ${target}:\nAlive: ${res.alive}\nTime: ${res.time} ms\nOutput: ${res.output}` }
+                ]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // nslookup Tool (using dns)
+    server.tool("nslookup", "Perform DNS lookup on a hostname or IP address", {
+        target: z.string().describe("Hostname or IP address")
+    }, async ({ target }) => {
+        return new Promise((resolve) => {
+            dns.lookup(target, (err, address, family) => {
+                if (err) {
+                    resolve({ content: [{ type: "text", text: `nslookup failed: ${err.message}` }] });
+                }
+                else {
+                    resolve({ content: [{ type: "text", text: `Address: ${address}\nFamily: IPv${family}` }] });
+                }
+            });
+        });
+    });
+    // telnet Tool (using telnet-client)
+    server.tool("telnet", "Test TCP connectivity to a host and port", {
+        target: z.string().describe("Host to connect to"),
+        port: z.number().describe("Port number")
+    }, async ({ target, port }) => {
+        const connection = new TelnetClient();
+        const params = {
+            host: target,
+            port: port,
+            shellPrompt: /[$%#>]$/,
+            timeout: 1500,
+        };
+        try {
+            await connection.connect(params);
+            await connection.end();
+            return { content: [{ type: "text", text: `Telnet to ${target}:${port} succeeded.` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Telnet failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // dig Tool (using dns.resolve)
+    server.tool("dig", "Perform DNS lookup with dig command", {
+        target: z.string().describe("Hostname or IP address"),
+        type: z.string().default("A").describe("DNS record type")
+    }, async ({ target, type }) => {
+        return new Promise((resolve) => {
+            dns.resolve(target, type, (err, addresses) => {
+                if (err) {
+                    resolve({ content: [{ type: "text", text: `dig failed: ${err.message}` }] });
+                }
+                else {
+                    resolve({ content: [{ type: "text", text: `${type} records for ${target}:\n${JSON.stringify(addresses, null, 2)}` }] });
+                }
+            });
+        });
+    });
+    // ps Tool (using ps-list)
+    server.tool("ps", "List running processes", {}, async () => {
+        try {
+            const processes = await psList();
+            // Defensive: handle missing properties and filter out bad entries
+            const output = processes
+                .map(p => {
+                const pid = p.pid ?? 'N/A';
+                const name = p.name ?? 'N/A';
+                return `${pid}\t${name}`;
+            })
+                .join("\n");
+            return { content: [{ type: "text", text: output || 'No processes found.' }] };
+        }
+        catch (error) {
+            // Log error for debugging
+            console.error('ps error:', error);
+            return { content: [{ type: "text", text: `ps failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // cat Tool (using fs)
+    server.tool("cat", "Display content of a file", {
+        file: z.string().describe("File path")
+    }, async ({ file }) => {
+        try {
+            const data = fs.readFileSync(file, "utf8");
+            return { content: [{ type: "text", text: data }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `cat failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // top Tool (using ps-list, show top 10 by CPU)
+    server.tool("top", "Display system processes (snapshot)", {}, async () => {
+        try {
+            const processes = await psList();
+            const sorted = processes.sort((a, b) => (b.cpu || 0) - (a.cpu || 0)).slice(0, 10);
+            const output = sorted.map(p => `${p.pid}\t${p.name}\tCPU: ${p.cpu || 0}%\tMEM: ${p.memory || 0}`).join("\n");
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `top failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // grep Tool (using grep-js)
+    server.tool("grep", "Search for patterns in files", {
+        pattern: z.string().describe("Pattern to search for"),
+        file: z.string().describe("File path")
+    }, async ({ pattern, file }) => {
+        try {
+            const data = fs.readFileSync(file, "utf8");
+            const lines = data.split("\n");
+            const matches = lines.filter(line => line.includes(pattern));
+            return { content: [{ type: "text", text: matches.join("\n") }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `grep failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // head Tool (using fs)
+    server.tool("head", "Display the beginning of a file", {
+        file: z.string().describe("File path"),
+        lines: z.number().default(10).describe("Number of lines")
+    }, async ({ file, lines }) => {
+        try {
+            const data = fs.readFileSync(file, "utf8");
+            const out = data.split("\n").slice(0, lines).join("\n");
+            return { content: [{ type: "text", text: out }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `head failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+    // tail Tool (using read-last-lines)
+    server.tool("tail", "Display the end of a file", {
+        file: z.string().describe("File path"),
+        lines: z.number().default(10).describe("Number of lines")
+    }, async ({ file, lines }) => {
+        try {
+            const out = await readLastLines.read(file, lines);
+            return { content: [{ type: "text", text: out }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `tail failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "it-tools-mcp",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "description": "MCP server providing access to various IT tools and utilities for developers",
   "type": "module",
   "main": "./build/index.js",
@@ -13,9 +13,8 @@
     "start:node": "node build/index.js",
     "dev": "tsc && node build/index.js",
     "test": "node tests/test-server.mjs",
-    "test:math": "node tests/math-tool-test.mjs",
+    "test:all": "node tests/all-tools-test.mjs",
     "test:security": "node tests/security-test.mjs",
-    "test:all": "npm run test && npm run test:security && npm run test:math",
     "docker:build": "docker buildx build --platform linux/amd64,linux/arm64 --provenance=true --sbom=true -t it-tools-mcp .",
     "docker:build:local": "docker build -t it-tools-mcp .",
     "docker:run": "docker-compose up --build",
@@ -56,7 +55,10 @@
     "@types/marked": "^5.0.2",
     "@types/mime-types": "^3.0.1",
     "@types/node": "^22.15.32",
+    "@types/ping": "^0.4.4",
+    "@types/shell-escape": "^0.2.3",
     "@types/speakeasy": "^2.0.10",
+    "@types/ssh2": "^1.15.5",
     "@types/turndown": "^5.0.5",
     "@types/validator": "^13.15.2",
     "@types/xml-formatter": "^1.2.0",
@@ -82,11 +84,16 @@
     "marked": "^15.0.12",
     "mathjs": "^14.5.2",
     "mime-types": "^3.0.1",
-    "node-fetch": "^3.3.2",
     "papaparse": "^5.5.3",
+    "ping": "^0.4.4",
+    "ps-list": "^8.1.1",
     "qrcode": "^1.5.4",
+    "read-last-lines": "^1.8.0",
+    "shell-escape": "^0.2.0",
     "speakeasy": "^2.0.0",
     "sql-formatter": "^15.6.5",
+    "ssh2": "^1.16.0",
+    "telnet-client": "^2.2.5",
     "turndown": "^7.2.0",
     "ulid": "^3.0.1",
     "validator": "^13.15.15",