it-tools-mcp 3.2.12 → 3.6.0

package/build/index.js

@@ -199,15 +199,8 @@ 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)
 // Get package metadata for enhanced server info
 function getPackageMetadata() {
     const __dirname = path.dirname(new URL(import.meta.url).pathname);
@@ -232,6 +225,8 @@ const server = new McpServer({
     capabilities: {
         resources: {},
         tools: {},
+        prompts: {},
+        logging: {}
     },
 });
 // Helper function to dynamically load modular tools from a category directory
@@ -253,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 {
@@ -353,9 +349,25 @@ async function getCategoryDescription(category, toolNames) {
     const categoryTitle = category.charAt(0).toUpperCase() + category.slice(1);
     return `${categoryTitle} tools and utilities (${toolNames.length} tools available)`;
 }
-// Register server info tool with dynamic metadata
-server.registerTool("server-info", {
-    description: "Get comprehensive information about the IT Tools MCP server, including available tool categories, version, and capabilities",
+// Register all tools dynamically by discovering categories from filesystem
+async function registerAllTools(server) {
+    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 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)")
@@ -364,13 +376,15 @@ server.registerTool("server-info", {
     const { include_tools = false, category } = args;
     // Discover tools dynamically
     const { toolCategories, totalToolCount } = await discoverTools();
-    // Get system info
+    // 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()
+        uptime: process.uptime(),
+        resourceUsage: usage
     };
     // Server metadata from package.json
     const serverMetadata = {
@@ -430,62 +444,41 @@ server.registerTool("server-info", {
             }]
     };
 });
-// Register all tools dynamically by discovering categories from filesystem
-async function registerAllTools(server) {
-    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 () => {
-    const usage = getResourceUsage();
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify({
-                    server: "IT Tools MCP Server",
-                    version: packageInfo.version,
-                    uptime: `${Math.floor(usage.uptimeSeconds)} seconds`,
-                    memory: usage.memory,
-                    timestamp: new Date().toISOString(),
-                }, 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);

package/build/tools/crypto/jwt-decode/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerJwtDecode(server) {
-    server.tool("jwt-decode", "Decode JWT token (header and payload only)", {
-        token: z.string().describe("JWT token to decode"),
+    server.registerTool("jwt-decode", {
+        description: "Decode JWT token (header and payload only)",
+        inputSchema: {
+            token: z.string().describe("JWT token to decode"),
+        }
     }, async ({ token }) => {
         try {
             const parts = token.split('.');

package/build/tools/crypto/otp-code-generator/index.js

@@ -1,10 +1,13 @@
 import speakeasy from "speakeasy";
 import { z } from "zod";
 export function registerOtpCodeGenerator(server) {
-    server.tool("otp-code-generator", "Generate Time-based One-Time Password (TOTP) codes", {
-        secret: z.string().describe("Base32 encoded secret key"),
-        digits: z.number().describe("Number of digits in the code").optional(),
-        period: z.number().describe("Time period in seconds").optional(),
+    server.registerTool("otp-code-generator", {
+        description: "Generate Time-based One-Time Password (TOTP) codes",
+        inputSchema: {
+            secret: z.string().describe("Base32 encoded secret key"),
+            digits: z.number().describe("Number of digits in the code").optional(),
+            period: z.number().describe("Time period in seconds").optional(),
+        }
     }, async ({ secret, digits = 6, period = 30 }) => {
         try {
             if (digits < 4 || digits > 10) {

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

@@ -1,11 +1,14 @@
 import { z } from "zod";
 export function registerPasswordGenerate(server) {
-    server.tool("password-generate", "Generate a secure password", {
-        length: z.number().describe("Password length").optional(),
-        includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
-        includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
-        includeNumbers: z.boolean().describe("Include numbers").optional(),
-        includeSymbols: z.boolean().describe("Include symbols").optional(),
+    server.registerTool("password-generate", {
+        description: "Generate a secure password",
+        inputSchema: {
+            length: z.number().describe("Password length").optional(),
+            includeUppercase: z.boolean().describe("Include uppercase letters").optional(),
+            includeLowercase: z.boolean().describe("Include lowercase letters").optional(),
+            includeNumbers: z.boolean().describe("Include numbers").optional(),
+            includeSymbols: z.boolean().describe("Include symbols").optional(),
+        }
     }, async ({ length = 16, includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = true }) => {
         if (length < 4 || length > 128) {
             return {

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

@@ -1,9 +1,12 @@
 import { z } from "zod";
 export function registerTokenGenerator(server) {
-    server.tool("token-generator", "Generate secure random tokens", {
-        length: z.number().describe("Token length").optional(),
-        charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
-        customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+    server.registerTool("token-generator", {
+        description: "Generate secure random tokens",
+        inputSchema: {
+            length: z.number().describe("Token length").optional(),
+            charset: z.enum(["alphanumeric", "hex", "base64", "custom"]).describe("Character set to use").optional(),
+            customChars: z.string().optional().describe("Custom characters (required if charset is 'custom')"),
+        }
     }, async ({ length = 32, charset = "alphanumeric", customChars }) => {
         try {
             if (length < 8 || length > 256) {

package/build/tools/dataFormat/html-to-markdown/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerHtmlToMarkdown(server) {
-    server.tool("html-to-markdown", "Convert HTML to Markdown", {
-        html: z.string().describe("HTML content to convert to Markdown"),
+    server.registerTool("html-to-markdown", {
+        description: "Convert HTML to Markdown",
+        inputSchema: {
+            html: z.string().describe("HTML content to convert to Markdown"),
+        }
     }, async ({ html }) => {
         try {
             const TurndownService = (await import("turndown")).default;

package/build/tools/dataFormat/json-diff/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonDiff(server) {
-    server.tool("json-diff", "Compare two JSON objects and show differences", {
-        json1: z.string().describe("First JSON object"),
-        json2: z.string().describe("Second JSON object"),
+    server.registerTool("json-diff", {
+        description: "Compare two JSON objects and show differences",
+        inputSchema: {
+            json1: z.string().describe("First JSON object"),
+            json2: z.string().describe("Second JSON object"),
+        }
     }, async ({ json1, json2 }) => {
         try {
             const obj1 = JSON.parse(json1);

package/build/tools/dataFormat/json-format/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonFormat(server) {
-    server.tool("json-format", "Format and validate JSON", {
-        json: z.string().describe("JSON string to format"),
-        indent: z.number().describe("Number of spaces for indentation").optional(),
+    server.registerTool("json-format", {
+        description: 'Format and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON',
+        inputSchema: {
+            json: z.string().describe("JSON string to format"),
+            indent: z.number().describe("Number of spaces for indentation").optional(),
+        }
     }, async ({ json, indent = 2 }) => {
         try {
             if (indent < 0 || indent > 10) {
@@ -88,6 +91,7 @@ Examples of supported formats:
         }
         catch (error) {
             return {
+                isError: true,
                 content: [
                     {
                         type: "text",

package/build/tools/dataFormat/json-minify/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerJsonMinify(server) {
-    server.tool("json-minify", "Minify JSON by removing whitespace", {
-        json: z.string().describe("JSON string to minify"),
+    server.registerTool("json-minify", {
+        description: "Minify JSON by removing whitespace",
+        inputSchema: {
+            json: z.string().describe("JSON string to minify"),
+        }
     }, async ({ json }) => {
         try {
             const parsed = JSON.parse(json);

package/build/tools/dataFormat/json-to-csv/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerJsonToCsv(server) {
-    server.tool("json-to-csv", "Convert JSON to CSV format", {
-        json: z.string().describe("JSON string to convert to CSV"),
-        delimiter: z.string().describe("CSV delimiter").optional(),
+    server.registerTool("json-to-csv", {
+        description: "Convert JSON to CSV format",
+        inputSchema: {
+            json: z.string().describe("JSON string to convert to CSV"),
+            delimiter: z.string().describe("CSV delimiter").optional(),
+        }
     }, async ({ json, delimiter = "," }) => {
         try {
             const Papa = (await import("papaparse")).default;

package/build/tools/dataFormat/json-to-toml/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerJsonToToml(server) {
-    server.tool("json-to-toml", "Convert JSON to TOML format", {
-        json: z.string().describe("JSON string to convert"),
+    server.registerTool("json-to-toml", {
+        description: "Convert JSON to TOML format",
+        inputSchema: {
+            json: z.string().describe("JSON string to convert"),
+        }
     }, async ({ json }) => {
         try {
             const toml = await import("@iarna/toml");

package/build/tools/dataFormat/markdown-to-html/index.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 export function registerMarkdownToHtml(server) {
-    server.tool("markdown-to-html", "Convert Markdown to HTML", {
-        markdown: z.string().describe("Markdown content to convert to HTML"),
+    server.registerTool("markdown-to-html", {
+        description: "Convert Markdown to HTML",
+        inputSchema: {
+            markdown: z.string().describe("Markdown content to convert to HTML"),
+        }
     }, async ({ markdown }) => {
         try {
             const { marked } = await import("marked");

package/build/tools/dataFormat/phone-format/index.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 export function registerPhoneFormat(server) {
-    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')"),
+    server.registerTool("phone-format", {
+        description: "Parse and format phone numbers",
+        inputSchema: {
+            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");