it-tools-mcp 3.2.10 → 3.6.0

package/README.dockerhub.md

@@ -11,7 +11,7 @@
 [![Docker Platform](https://img.shields.io/badge/platform-linux%2Famd64%20%7C%20linux%2Farm64-blue)](https://hub.docker.com/r/wrenchpilot/it-tools-mcp)
 [![GitHub Stars](https://img.shields.io/github/stars/wrenchpilot/it-tools-mcp?style=social)](https://github.com/wrenchpilot/it-tools-mcp/stargazers)
 
-A comprehensive Model Context Protocol (MCP) server that provides access to **112 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 over **100 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
 
@@ -62,7 +62,7 @@ Add to your VS Code `settings.json`:
 }
 ```
 
-See the complete list of all 112 tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
+See the complete list of tools with detailed parameters on [GitHub](https://github.com/wrenchpilot/it-tools-mcp#available-tools)
 
 ## 📸 Examples in Action
 

package/README.md

@@ -14,17 +14,24 @@
 
 > **📝 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 112 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 over 100 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
 
 ### Using with VS Code
 
-**[Install IT Tools MCP in VS Code](vscode:mcp/install?%7B%22name%22%3A%22it-tools-mcp%22%2C%22gallery%22%3Atrue%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22it-tools-mcp%22%5D%7D)**
+**Quick Install:**
 
-*Click the link above in VS Code to install the IT Tools MCP server.*
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=it-tools&config=%7B%22command%22%3A%20%22npx%22%2C%22args%22%3A%20%5B%22it-tools-mcp%22%5D%7D) [![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install_Server-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=it-tools&config=%7B%22command%22%3A%20%22npx%22%2C%22args%22%3A%20%5B%22it-tools-mcp%22%5D%7D&quality=insiders)
 
-Add to your VS Code `settings.json`:
+**Install:**
+
+1. Open VS Code
+2. Press `Ctrl+Shift+P` (or `Cmd+Shift+P` on Mac)
+3. Type "MCP" and select "MCP: Add Server"
+4. Choose "NPM Package" and enter: `it-tools-mcp`
+
+**Or manually add to your VS Code `settings.json`:**
 
 #### Node
 
@@ -89,7 +96,7 @@ echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"base64-enc
 
 ## 🛠️ Tool Categories
 
-This MCP server provides **112 tools** across **14 categories**:
+This MCP server provides over **100 tools** across **14 categories**:
 
 - **� Ansible Tools** (5 tools): Vault encryption/decryption, inventory parser, playbook validator, reference
 - **🎨 Color Tools** (2 tools): Hex ↔ RGB conversion
@@ -258,14 +265,14 @@ 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**, demonstrating the power of AI-assisted software development:
 
 - **Intelligent Code Generation**: Claude Sonnet analyzed requirements and generated comprehensive tool implementations
-- **Schema Validation**: Automatically identified and resolved JSON schema validation issues across 112 tools
+- **Schema Validation**: Automatically identified and resolved JSON schema validation issues across tools
 - **Docker Optimization**: Created production-ready Docker workflows and multi-stage builds
 - **Documentation**: Generated comprehensive README with examples and tool reference tables
 - **Testing**: Implemented robust error handling and validation throughout the codebase
 
 **Key AI Contributions:**
 
-- 🔧 **Tool Implementation**: All 112 tools designed and implemented with AI assistance
+- 🔧 **Tool Implementation**: All tools designed and implemented with AI assistance
 - 📦 **Docker Setup**: Complete containerization with GitHub Actions CI/CD pipeline
 - 🔍 **Schema Cleanup**: Systematic removal of unsupported Zod keywords from all tool definitions
 - 📚 **Documentation**: Comprehensive README with usage examples and tool catalogs

package/build/index.js

@@ -199,29 +199,34 @@ export function getResourceUsage() {
     };
 }
 /**
- * Security headers for responses (if applicable)
+ * Input validation and security utilities
  */
-export const SECURITY_HEADERS = {
-    'X-Content-Type-Options': 'nosniff',
-    'X-Frame-Options': 'DENY',
-    'X-XSS-Protection': '1; mode=block',
-    'Referrer-Policy': 'strict-origin-when-cross-origin',
-};
-// Helper to read version from package.json at runtime (ESM compatible)
-function getPackageVersion() {
-    // Use import.meta.url to get the directory in ESM
+// Get package metadata for enhanced server info
+function getPackageMetadata() {
     const __dirname = path.dirname(new URL(import.meta.url).pathname);
     const pkgPath = path.resolve(__dirname, '../package.json');
     const pkgRaw = fs.readFileSync(pkgPath, 'utf-8');
-    return JSON.parse(pkgRaw).version;
+    const pkg = JSON.parse(pkgRaw);
+    return {
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description,
+        keywords: pkg.keywords,
+        author: pkg.author,
+        repository: pkg.repository,
+        homepage: pkg.homepage
+    };
 }
-// Create server instance
+// Create server instance with enhanced metadata
+const packageInfo = getPackageMetadata();
 const server = new McpServer({
     name: "it-tools-mcp",
-    version: getPackageVersion(),
+    version: packageInfo.version,
     capabilities: {
         resources: {},
         tools: {},
+        prompts: {},
+        logging: {}
     },
 });
 // Helper function to dynamically load modular tools from a category directory
@@ -243,13 +248,14 @@ async function loadModularTools(server, category) {
                 const registerFunction = Object.values(toolModule).find((fn) => typeof fn === 'function' && fn.name.startsWith('register'));
                 if (registerFunction) {
                     registerFunction(server);
+                    console.error(`Loaded tool: ${category}/${toolDir}`);
                 }
                 else {
                     console.warn(`No register function found in ${toolPath}`);
                 }
             }
             catch (error) {
-                console.error(`Failed to load tool ${category}/${toolDir}:`, error);
+                console.error(`Failed to load tool ${category}/${toolDir}:`, error instanceof Error ? error.message : 'Unknown error');
             }
         }
         else {
@@ -257,58 +263,222 @@ async function loadModularTools(server, category) {
         }
     }
 }
-// Register all tool modules (dynamically for faster startup, with per-module timing)
+// Dynamic tool discovery and metadata generation
+async function discoverTools() {
+    const toolsBaseDir = path.join(__dirname, 'tools');
+    if (!fs.existsSync(toolsBaseDir)) {
+        return { toolCategories: {}, totalToolCount: 0 };
+    }
+    // Discover categories dynamically from the filesystem
+    const categories = fs.readdirSync(toolsBaseDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .sort(); // Sort for consistent ordering
+    const toolCategories = {};
+    let totalToolCount = 0;
+    for (const category of categories) {
+        const toolsDir = path.join(toolsBaseDir, category);
+        const toolDirs = fs.readdirSync(toolsDir, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name)
+            .sort(); // Sort tools within category
+        if (toolDirs.length > 0) {
+            toolCategories[category] = {
+                description: await getCategoryDescription(category, toolDirs),
+                tools: toolDirs
+            };
+            totalToolCount += toolDirs.length;
+        }
+    }
+    return { toolCategories, totalToolCount };
+}
+// Generate category description by examining actual tool metadata
+async function getCategoryDescription(category, toolNames) {
+    const toolsDir = path.join(__dirname, 'tools', category);
+    const toolDescriptions = [];
+    // Try to extract descriptions from a few sample tools in the category
+    const samplesToCheck = Math.min(3, toolNames.length); // Check up to 3 tools for description
+    for (let i = 0; i < samplesToCheck; i++) {
+        const toolDir = toolNames[i];
+        const toolPath = path.join(toolsDir, toolDir, 'index.js');
+        if (fs.existsSync(toolPath)) {
+            try {
+                const toolModule = await import(`./${path.relative(__dirname, toolPath).replace(/\\/g, '/')}`);
+                // Look for description in the tool registration
+                const registerFunction = Object.values(toolModule).find((fn) => typeof fn === 'function' && fn.name.startsWith('register'));
+                if (registerFunction) {
+                    // Create a mock server to capture the tool registration
+                    const mockServer = {
+                        registerTool: (name, config) => {
+                            if (config.description && typeof config.description === 'string') {
+                                toolDescriptions.push(config.description);
+                            }
+                        }
+                    };
+                    try {
+                        registerFunction(mockServer);
+                    }
+                    catch (error) {
+                        // Ignore errors in mock registration
+                    }
+                }
+            }
+            catch (error) {
+                // Continue if we can't load a tool
+            }
+        }
+    }
+    // Generate category description based on collected tool descriptions
+    if (toolDescriptions.length > 0) {
+        // Create a summary from the actual tool descriptions
+        const uniqueDescriptions = [...new Set(toolDescriptions)];
+        if (uniqueDescriptions.length === 1) {
+            // If all tools have the same description, use it directly
+            return uniqueDescriptions[0];
+        }
+        else if (uniqueDescriptions.length <= 3) {
+            // If we have 2-3 unique descriptions, combine them
+            return `${category.charAt(0).toUpperCase() + category.slice(1)} tools: ${uniqueDescriptions.join(', ')}`;
+        }
+        else {
+            // If we have many descriptions, provide a generic summary
+            return `${category.charAt(0).toUpperCase() + category.slice(1)} category with ${toolNames.length} tools including: ${uniqueDescriptions.slice(0, 2).join(', ')} and more`;
+        }
+    }
+    // Fallback: generate description from category name and tool count
+    const categoryTitle = category.charAt(0).toUpperCase() + category.slice(1);
+    return `${categoryTitle} tools and utilities (${toolNames.length} tools available)`;
+}
+// Register all tools dynamically by discovering categories from filesystem
 async function registerAllTools(server) {
-    // All categories to load modularly
-    const categories = [
-        'docker', 'ansible', 'color', 'encoding', 'idGenerators',
-        'crypto', 'dataFormat', 'text', 'network', 'math',
-        'utility', 'development', 'forensic', 'physics'
-    ];
+    const toolsBaseDir = path.join(__dirname, 'tools');
+    if (!fs.existsSync(toolsBaseDir)) {
+        console.warn('Tools directory does not exist:', toolsBaseDir);
+        return;
+    }
+    // Discover categories dynamically from the filesystem
+    const categories = fs.readdirSync(toolsBaseDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+        .sort(); // Sort for consistent ordering
     for (const category of categories) {
         await loadModularTools(server, category);
     }
 }
-// Add resource monitoring tool
-server.tool("system-info", "Get system resource usage and server information", {}, async () => {
+// Add comprehensive system and server information tool
+server.registerTool("system-info", {
+    description: "Get comprehensive system information, server details, available tool categories, and resource usage",
+    inputSchema: {
+        include_tools: z.boolean().optional().describe("Include detailed information about all available tools"),
+        category: z.string().optional().describe("Get information about a specific category (dynamically discovered)")
+    }
+}, async (args) => {
+    const { include_tools = false, category } = args;
+    // Discover tools dynamically
+    const { toolCategories, totalToolCount } = await discoverTools();
+    // Get comprehensive system info
     const usage = getResourceUsage();
+    const systemInfo = {
+        timestamp: new Date().toISOString(),
+        platform: process.platform,
+        nodeVersion: process.version,
+        memoryUsage: process.memoryUsage(),
+        uptime: process.uptime(),
+        resourceUsage: usage
+    };
+    // Server metadata from package.json
+    const serverMetadata = {
+        name: "IT Tools MCP Server",
+        version: packageInfo.version,
+        description: packageInfo.description,
+        author: packageInfo.author,
+        repository: packageInfo.repository?.url,
+        homepage: packageInfo.homepage,
+        keywords: packageInfo.keywords,
+        protocol: "Model Context Protocol (MCP)",
+        transport: "stdio"
+    };
+    const baseResult = {
+        server: serverMetadata,
+        system: systemInfo,
+        categories: Object.keys(toolCategories).length,
+        totalTools: totalToolCount,
+        installation: {
+            vscode: "Use VS Code install button in README or manual configuration",
+            claude: "Add to claude_desktop_config.json",
+            npm: `npm install -g ${packageInfo.name}`
+        }
+    };
+    let result = baseResult;
+    // Add category-specific information
+    if (category && toolCategories[category]) {
+        result = {
+            ...result,
+            categoryDetails: {
+                name: category,
+                ...toolCategories[category]
+            }
+        };
+    }
+    else if (!category) {
+        result = {
+            ...result,
+            availableCategories: toolCategories
+        };
+    }
+    // Include detailed tool information if requested
+    if (include_tools) {
+        result = {
+            ...result,
+            toolsBreakdown: Object.entries(toolCategories).map(([cat, info]) => ({
+                category: cat,
+                count: info.tools.length,
+                tools: info.tools
+            }))
+        };
+    }
     return {
-        content: [
-            {
+        content: [{
                 type: "text",
-                text: JSON.stringify({
-                    server: "IT Tools MCP Server",
-                    version: getPackageVersion(),
-                    uptime: `${Math.floor(usage.uptimeSeconds)} seconds`,
-                    memory: usage.memory,
-                    timestamp: new Date().toISOString(),
-                }, null, 2),
-            },
-        ],
+                text: JSON.stringify(result, null, 2)
+            }]
     };
 });
 // Run the server
 async function main() {
-    await registerAllTools(server);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Log startup (stderr only, no resource usage)
-    if (process.env.NODE_ENV === 'test' && process.env.MCP_TEST_MODE === 'true') {
-        console.error("IT Tools MCP Server running on stdio");
-        // Exit after stdin closes (for test automation)
-        process.stdin.on('end', () => {
-            setTimeout(() => process.exit(0), 100);
-        });
+    try {
+        await registerAllTools(server);
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        // Log startup (stderr only, no resource usage)
+        if (process.env.NODE_ENV === 'test' && process.env.MCP_TEST_MODE === 'true') {
+            console.error("IT Tools MCP Server running on stdio");
+            // Exit after stdin closes (for test automation)
+            process.stdin.on('end', () => {
+                setTimeout(() => process.exit(0), 100);
+            });
+        }
+        // Only start periodic monitoring in production, not in tests
+        if (process.env.NODE_ENV !== 'test') {
+            // Periodic resource monitoring (every 5 minutes)
+            setInterval(() => {
+                const usage = getResourceUsage();
+                if (usage.memory.heapUsedBytes > 200 * 1024 * 1024) { // Alert if using more than 200MB
+                    console.error("High memory usage detected:", usage.memory);
+                }
+            }, 5 * 60 * 1000);
+        }
+        // Handle graceful shutdown
+        const shutdown = () => {
+            console.error("Shutting down IT Tools MCP Server...");
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
     }
-    // Only start periodic monitoring in production, not in tests
-    if (process.env.NODE_ENV !== 'test') {
-        // Periodic resource monitoring (every 5 minutes)
-        setInterval(() => {
-            const usage = getResourceUsage();
-            if (usage.memory.heapUsedBytes > 200 * 1024 * 1024) { // Alert if using more than 200MB
-                console.error("High memory usage detected:", usage.memory);
-            }
-        }, 5 * 60 * 1000);
+    catch (error) {
+        console.error("Failed to start MCP server:", error);
+        process.exit(1);
     }
 }
 main().catch((error) => {

package/build/tools/ansible/ansible-inventory-generator/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerAnsibleInventoryParser(server) {
-    server.tool("ansible-inventory-parser", "Parse and validate Ansible inventory files", {
-        inventory: z.string().describe("Ansible inventory content (INI or YAML format)"),
+    server.registerTool("ansible-inventory-parser", {
+        description: "Parse and validate Ansible inventory files",
+        inputSchema: {
+            inventory: z.string().describe("Ansible inventory content (INI or YAML format)"),
+        }
     }, async ({ inventory }) => {
         if (!inventory?.trim()) {
             return {

package/build/tools/ansible/ansible-playbook-validator/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerAnsiblePlaybookValidator(server) {
-    server.tool("ansible-playbook-validator", "Validate Ansible playbook syntax and structure", {
-        playbook: z.string().describe("Ansible playbook YAML content"),
+    server.registerTool("ansible-playbook-validator", {
+        description: "Validate Ansible playbook syntax and structure",
+        inputSchema: {
+            playbook: z.string().describe("Ansible playbook YAML content"),
+        }
     }, async ({ playbook }) => {
         if (!playbook?.trim()) {
             return {

package/build/tools/ansible/ansible-reference/index.js

@@ -1,5 +1,8 @@
 export function registerAnsibleReference(server) {
-    server.tool("ansible-reference", "Get Ansible commands reference and cheatsheet", {}, async () => {
+    server.registerTool("ansible-reference", {
+        description: "Get Ansible commands reference and cheatsheet",
+        inputSchema: {}
+    }, async () => {
         const reference = `# Ansible Quick Reference
 
 ## Installation

package/build/tools/ansible/ansible-vault-decrypt/index.js

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import { pbkdf2Sync } from "crypto";
 export function registerAnsibleVaultDecrypt(server) {
-    server.tool("ansible-vault-decrypt", "Decrypt Ansible Vault encrypted text", {
-        encryptedText: z.string().describe("Ansible Vault encrypted text to decrypt"),
-        password: z.string().describe("Password for decryption"),
+    server.registerTool("ansible-vault-decrypt", {
+        description: "Decrypt Ansible Vault encrypted text",
+        inputSchema: {
+            encryptedText: z.string().describe("Ansible Vault encrypted text to decrypt"),
+            password: z.string().describe("Password for decryption"),
+        }
     }, async ({ encryptedText, password }) => {
         if (!encryptedText?.trim()) {
             return {

package/build/tools/ansible/ansible-vault-encrypt/index.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
 import { pbkdf2Sync, randomBytes } from "crypto";
 export function registerAnsibleVaultEncrypt(server) {
-    server.tool("ansible-vault-encrypt", "Encrypt text using Ansible Vault format", {
-        text: z.string().describe("Text to encrypt"),
-        password: z.string().describe("Password for encryption"),
-        vaultId: z.string().optional().describe("Vault ID for the encrypted content (optional)"),
+    server.registerTool("ansible-vault-encrypt", {
+        description: "Encrypt text using Ansible Vault format",
+        inputSchema: {
+            text: z.string().describe("Text to encrypt"),
+            password: z.string().describe("Password for encryption"),
+            vaultId: z.string().optional().describe("Vault ID for the encrypted content (optional)"),
+        }
     }, async ({ text, password, vaultId }) => {
         if (!text?.trim()) {
             return {

package/build/tools/color/color-hex-to-rgb/index.js

@@ -1,8 +1,11 @@
 import Color from "color";
 import { z } from "zod";
 export function registerColorHexToRgb(server) {
-    server.tool("color-hex-to-rgb", "Convert HEX color to RGB", {
-        hex: z.string().describe("HEX color code (e.g., #FF5733 or FF5733)"),
+    server.registerTool("color-hex-to-rgb", {
+        description: "Convert HEX color to RGB",
+        inputSchema: {
+            hex: z.string().describe("HEX color code (e.g., #FF5733 or FF5733)"),
+        }
     }, async ({ hex }) => {
         try {
             const rgb = Color(hex).rgb().array();

package/build/tools/color/color-rgb-to-hex/index.js

@@ -1,10 +1,13 @@
 import Color from "color";
 import { z } from "zod";
 export function registerColorRgbToHex(server) {
-    server.tool("color-rgb-to-hex", "Convert RGB color to HEX", {
-        r: z.number().describe("Red value (0-255)"),
-        g: z.number().describe("Green value (0-255)"),
-        b: z.number().describe("Blue value (0-255)"),
+    server.registerTool("color-rgb-to-hex", {
+        description: "Convert RGB color to HEX",
+        inputSchema: {
+            r: z.number().describe("Red value (0-255)"),
+            g: z.number().describe("Green value (0-255)"),
+            b: z.number().describe("Blue value (0-255)"),
+        }
     }, async ({ r, g, b }) => {
         try {
             if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {

package/build/tools/crypto/basic-auth-generator/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerBasicAuthGenerator(server) {
-    server.tool("basic-auth-generator", "Generate HTTP Basic Authentication header", {
-        username: z.string().describe("Username"),
-        password: z.string().describe("Password"),
+    server.registerTool("basic-auth-generator", {
+        description: "Generate HTTP Basic Authentication header",
+        inputSchema: {
+            username: z.string().describe("Username"),
+            password: z.string().describe("Password"),
+        }
     }, async ({ username, password }) => {
         try {
             const credentials = `${username}:${password}`;

package/build/tools/crypto/bcrypt-hash/index.js

@@ -1,10 +1,13 @@
 import bcryptjs from "bcryptjs";
 import { z } from "zod";
 export function registerBcryptHash(server) {
-    server.tool("bcrypt-hash", "Generate bcrypt hash or verify password against hash", {
-        password: z.string().describe("Password to hash or verify"),
-        rounds: z.number().describe("Number of salt rounds (4-12, default 10)").optional(),
-        hash: z.string().optional().describe("Existing hash to verify against (for verification)"),
+    server.registerTool("bcrypt-hash", {
+        description: "Generate bcrypt hash or verify password against hash",
+        inputSchema: {
+            password: z.string().describe("Password to hash or verify"),
+            rounds: z.number().describe("Number of salt rounds (4-12, default 10)").optional(),
+            hash: z.string().optional().describe("Existing hash to verify against (for verification)"),
+        }
     }, async ({ password, rounds = 10, hash }) => {
         try {
             if (rounds < 4 || rounds > 12) {

package/build/tools/crypto/bip39-generate/index.js

@@ -1,8 +1,11 @@
 import * as bip39 from "bip39";
 import { z } from "zod";
 export function registerBip39Generate(server) {
-    server.tool("bip39-generate", "Generate BIP39 mnemonic phrases", {
-        wordCount: z.enum(["12", "15", "18", "21", "24"]).describe("Number of words in the mnemonic").optional(),
+    server.registerTool("bip39-generate", {
+        description: "Generate BIP39 mnemonic phrases",
+        inputSchema: {
+            wordCount: z.enum(["12", "15", "18", "21", "24"]).describe("Number of words in the mnemonic").optional(),
+        }
     }, async ({ wordCount = "12" }) => {
         try {
             const count = parseInt(wordCount);

package/build/tools/crypto/hash-md5/index.js

@@ -1,8 +1,11 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashMd5(server) {
-    server.tool("hash-md5", "Generate MD5 hash", {
-        text: z.string().describe("Text to hash with MD5"),
+    server.registerTool("hash-md5", {
+        description: "Generate MD5 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with MD5"),
+        }
     }, async ({ text }) => {
         const hash = createHash('md5');
         hash.update(text);

package/build/tools/crypto/hash-sha1/index.js

@@ -1,8 +1,11 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha1(server) {
-    server.tool("hash-sha1", "Generate SHA1 hash", {
-        text: z.string().describe("Text to hash with SHA1"),
+    server.registerTool("hash-sha1", {
+        description: "Generate SHA1 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA1"),
+        }
     }, async ({ text }) => {
         const hash = createHash('sha1');
         hash.update(text);

package/build/tools/crypto/hash-sha256/index.js

@@ -1,8 +1,11 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha256(server) {
-    server.tool("hash-sha256", "Generate SHA256 hash", {
-        text: z.string().describe("Text to hash with SHA256"),
+    server.registerTool("hash-sha256", {
+        description: 'Generate SHA256 hash of input text. Example: "hello" → "2cf24dba4f21d..."',
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA256"),
+        }
     }, async ({ text }) => {
         const hash = createHash('sha256');
         hash.update(text);

package/build/tools/crypto/hash-sha512/index.js

@@ -1,8 +1,11 @@
 import { createHash } from "crypto";
 import { z } from "zod";
 export function registerHashSha512(server) {
-    server.tool("hash-sha512", "Generate SHA512 hash", {
-        text: z.string().describe("Text to hash with SHA512"),
+    server.registerTool("hash-sha512", {
+        description: "Generate SHA512 hash",
+        inputSchema: {
+            text: z.string().describe("Text to hash with SHA512"),
+        }
     }, async ({ text }) => {
         const hash = createHash('sha512');
         hash.update(text);

package/build/tools/crypto/hmac-generator/index.js

@@ -1,10 +1,13 @@
 import { createHmac } from "crypto";
 import { z } from "zod";
 export function registerHmacGenerator(server) {
-    server.tool("hmac-generator", "Generate HMAC (Hash-based Message Authentication Code)", {
-        message: z.string().describe("Message to authenticate"),
-        key: z.string().describe("Secret key for HMAC"),
-        algorithm: z.enum(["sha1", "sha256", "sha512"]).describe("Hash algorithm").optional(),
+    server.registerTool("hmac-generator", {
+        description: "Generate HMAC (Hash-based Message Authentication Code)",
+        inputSchema: {
+            message: z.string().describe("Message to authenticate"),
+            key: z.string().describe("Secret key for HMAC"),
+            algorithm: z.enum(["sha1", "sha256", "sha512"]).describe("Hash algorithm").optional(),
+        }
     }, async ({ message, key, algorithm = "sha256" }) => {
         try {
             const hmac = createHmac(algorithm, key);