it-tools-mcp 3.0.24 → 3.1.0

package/build/tools/text/text-to-unicode-names/index.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export function registerTextToUnicodeNames(server) {
+    server.tool("text-to-unicode-names", "Convert text to Unicode character names", {
+        text: z.string().describe("Text to convert to Unicode names")
+    }, async ({ text }) => {
+        const unicodeNames = [...text].map(char => {
+            const codePoint = char.codePointAt(0);
+            if (!codePoint)
+                return char;
+            const hex = codePoint.toString(16).toUpperCase().padStart(4, '0');
+            // Basic Unicode character name mapping for common characters
+            const basicNames = {
+                32: 'SPACE',
+                33: 'EXCLAMATION MARK',
+                63: 'QUESTION MARK',
+                64: 'COMMERCIAL AT',
+                65: 'LATIN CAPITAL LETTER A',
+                66: 'LATIN CAPITAL LETTER B',
+                97: 'LATIN SMALL LETTER A',
+                98: 'LATIN SMALL LETTER B',
+                // Add more as needed
+            };
+            const name = basicNames[codePoint] || 'UNKNOWN CHARACTER';
+            return `${char} (U+${hex}: ${name})`;
+        }).join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Unicode Character Names:
+${unicodeNames}`
+                }]
+        };
+    });
+}

package/build/tools/text/text-uppercase/index.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function registerTextUppercase(server) {
+    server.tool("text-uppercase", "Convert text to uppercase", {
+        text: z.string().describe("Text to convert to uppercase"),
+    }, async ({ text }) => {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Uppercase: ${text.toUpperCase()}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/utility/css-prettifier/index.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export function registerCssPrettifier(server) {
+    server.tool("css-prettifier", "Format and prettify CSS code", {
+        css: z.string().describe("CSS code to format"),
+        indentSize: z.number().optional().describe("Number of spaces for indentation (default: 2)")
+    }, async ({ css, indentSize = 2 }) => {
+        try {
+            // Basic CSS prettifier implementation
+            let formatted = css
+                // Remove extra whitespace
+                .replace(/\s+/g, ' ')
+                .trim()
+                // Add newlines and indentation
+                .replace(/\{/g, ' {\n' + ' '.repeat(indentSize))
+                .replace(/\}/g, '\n}\n')
+                .replace(/;/g, ';\n' + ' '.repeat(indentSize))
+                .replace(/,/g, ',\n')
+                // Clean up extra newlines
+                .replace(/\n\s*\n/g, '\n')
+                .replace(/\n\s*\}/g, '\n}')
+                // Fix selectors
+                .replace(/\n([^{]+)\{/g, '\n\n$1 {')
+                .trim();
+            // Add some basic formatting rules
+            formatted = formatted
+                .replace(/:\s*/g, ': ')
+                .replace(/,\s*/g, ', ')
+                .replace(/\s*{\s*/g, ' {\n' + ' '.repeat(indentSize))
+                .replace(/;\s*}/g, ';\n}');
+            // Count some metrics
+            const selectors = (css.match(/[^{}]+(?=\s*\{)/g) || []).length;
+            const properties = (css.match(/[^{}:;]+\s*:\s*[^{}:;]+/g) || []).length;
+            const lines = formatted.split('\n').length;
+            const originalLines = css.split('\n').length;
+            return {
+                content: [{
+                        type: "text",
+                        text: `CSS Prettifier Results:
+
+Original CSS (${css.length} characters, ${originalLines} lines):
+${css}
+
+Formatted CSS (${formatted.length} characters, ${lines} lines):
+${formatted}
+
+Statistics:
+• Selectors: ${selectors}
+• Properties: ${properties}
+• Size change: ${css.length} → ${formatted.length} characters
+• Lines: ${originalLines} → ${lines}
+• Indentation: ${indentSize} spaces
+
+Formatting Applied:
+• Proper indentation and spacing
+• Consistent selector formatting
+• Property alignment
+• Clean line breaks`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error prettifying CSS: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/utility/device-info/index.js

@@ -0,0 +1,44 @@
+export function registerDeviceInfo(server) {
+    server.tool("device-info", "Get basic device/system information", {}, async () => {
+        try {
+            const info = {
+                platform: process.platform,
+                arch: process.arch,
+                nodeVersion: process.version,
+                userAgent: 'IT Tools MCP Server',
+                timestamp: new Date().toISOString(),
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+                language: 'en-US' // Default for server environment
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Device Information:
+
+Platform: ${info.platform}
+Architecture: ${info.arch}
+Node.js Version: ${info.nodeVersion}
+User Agent: ${info.userAgent}
+Current Time: ${info.timestamp}
+Timezone: ${info.timezone}
+Language: ${info.language}
+
+Note: This is basic server environment information.
+For detailed client device info, use a browser-based tool.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting device info: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/utility/email-normalizer/index.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export function registerEmailNormalizer(server) {
+    server.tool("email-normalizer", "Normalize email addresses (remove dots, plus aliases, etc.)", {
+        email: z.string().describe("Email address to normalize"),
+    }, async ({ email }) => {
+        try {
+            // Basic email validation
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(email)) {
+                throw new Error("Invalid email format");
+            }
+            const [localPart, domain] = email.toLowerCase().split('@');
+            let normalizedLocal = localPart;
+            let notes = [];
+            // Handle Gmail-specific rules
+            if (domain === 'gmail.com' || domain === 'googlemail.com') {
+                // Remove dots from Gmail addresses
+                const withoutDots = normalizedLocal.replace(/\./g, '');
+                if (withoutDots !== normalizedLocal) {
+                    notes.push(`Removed dots: ${normalizedLocal} → ${withoutDots}`);
+                    normalizedLocal = withoutDots;
+                }
+                // Remove everything after + (alias)
+                const plusIndex = normalizedLocal.indexOf('+');
+                if (plusIndex !== -1) {
+                    const withoutAlias = normalizedLocal.substring(0, plusIndex);
+                    notes.push(`Removed alias: ${normalizedLocal} → ${withoutAlias}`);
+                    normalizedLocal = withoutAlias;
+                }
+            }
+            // Handle other common plus aliasing
+            const plusIndex = normalizedLocal.indexOf('+');
+            if (plusIndex !== -1 && domain !== 'gmail.com' && domain !== 'googlemail.com') {
+                const withoutAlias = normalizedLocal.substring(0, plusIndex);
+                notes.push(`Removed plus alias: ${normalizedLocal} → ${withoutAlias}`);
+                normalizedLocal = withoutAlias;
+            }
+            const normalizedEmail = `${normalizedLocal}@${domain}`;
+            const isChanged = normalizedEmail !== email.toLowerCase();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Email Normalization:
+
+Original: ${email}
+Normalized: ${normalizedEmail}
+Changed: ${isChanged ? 'Yes' : 'No'}
+
+${notes.length > 0 ? `Transformations applied:
+${notes.map(note => `• ${note}`).join('\n')}` : 'No transformations needed'}
+
+Domain: ${domain}
+Local part: ${normalizedLocal}
+
+Note: This normalization helps identify duplicate email addresses
+that would be delivered to the same inbox.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error normalizing email: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/utility/http-status-codes/index.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+function getStatusCategory(code) {
+    if (code >= 100 && code < 200)
+        return '1xx Informational';
+    if (code >= 200 && code < 300)
+        return '2xx Success';
+    if (code >= 300 && code < 400)
+        return '3xx Redirection';
+    if (code >= 400 && code < 500)
+        return '4xx Client Error';
+    if (code >= 500 && code < 600)
+        return '5xx Server Error';
+    return 'Unknown Category';
+}
+function getUsageHint(code) {
+    if (code >= 100 && code < 200)
+        return 'the request is being processed';
+    if (code >= 200 && code < 300)
+        return 'the request was successful';
+    if (code >= 300 && code < 400)
+        return 'the client needs to take additional action';
+    if (code >= 400 && code < 500)
+        return 'there was an error with the client request';
+    if (code >= 500 && code < 600)
+        return 'there was an error on the server side';
+    return 'an unknown status';
+}
+export function registerHttpStatusCodes(server) {
+    server.tool("http-status-codes", "Get information about HTTP status codes", {
+        code: z.number().optional().describe("HTTP status code to look up (optional)"),
+    }, async ({ code }) => {
+        try {
+            const statusCodes = {
+                // 1xx Informational
+                100: "Continue",
+                101: "Switching Protocols",
+                102: "Processing",
+                // 2xx Success
+                200: "OK",
+                201: "Created",
+                202: "Accepted",
+                204: "No Content",
+                206: "Partial Content",
+                // 3xx Redirection
+                300: "Multiple Choices",
+                301: "Moved Permanently",
+                302: "Found",
+                304: "Not Modified",
+                307: "Temporary Redirect",
+                308: "Permanent Redirect",
+                // 4xx Client Error
+                400: "Bad Request",
+                401: "Unauthorized",
+                403: "Forbidden",
+                404: "Not Found",
+                405: "Method Not Allowed",
+                409: "Conflict",
+                410: "Gone",
+                422: "Unprocessable Entity",
+                429: "Too Many Requests",
+                // 5xx Server Error
+                500: "Internal Server Error",
+                501: "Not Implemented",
+                502: "Bad Gateway",
+                503: "Service Unavailable",
+                504: "Gateway Timeout",
+                505: "HTTP Version Not Supported"
+            };
+            const descriptions = {
+                100: "The server has received the request headers and the client should proceed to send the request body.",
+                101: "The requester has asked the server to switch protocols and the server has agreed to do so.",
+                102: "The server has received and is processing the request, but no response is available yet.",
+                200: "The request has succeeded.",
+                201: "The request has been fulfilled and resulted in a new resource being created.",
+                202: "The request has been accepted for processing, but the processing has not been completed.",
+                204: "The server successfully processed the request and is not returning any content.",
+                206: "The server is delivering only part of the resource due to a range header sent by the client.",
+                300: "The request has more than one possible response.",
+                301: "The URL of the requested resource has been changed permanently.",
+                302: "The resource is temporarily located at a different URL.",
+                304: "The response has not been modified since the last request.",
+                307: "The request should be repeated with another URI, but future requests should still use the original URI.",
+                308: "The request and all future requests should be repeated using another URI.",
+                400: "The server could not understand the request due to invalid syntax.",
+                401: "The client must authenticate itself to get the requested response.",
+                403: "The client does not have access rights to the content.",
+                404: "The server can not find the requested resource.",
+                405: "The request method is known by the server but is not supported by the target resource.",
+                409: "The request conflicts with the current state of the server.",
+                410: "The content has been permanently deleted from server.",
+                422: "The request was well-formed but was unable to be followed due to semantic errors.",
+                429: "The user has sent too many requests in a given amount of time.",
+                500: "The server has encountered a situation it doesn't know how to handle.",
+                501: "The request method is not supported by the server and cannot be handled.",
+                502: "The server got an invalid response while working as a gateway.",
+                503: "The server is not ready to handle the request.",
+                504: "The server is acting as a gateway and cannot get a response in time.",
+                505: "The HTTP version used in the request is not supported by the server."
+            };
+            if (code !== undefined) {
+                const message = statusCodes[code];
+                const description = descriptions[code];
+                if (!message) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `HTTP Status Code: ${code}
+
+Status: Unknown/Custom status code
+
+Common status codes:
+${Object.entries(statusCodes).slice(0, 10).map(([c, m]) => `• ${c}: ${m}`).join('\n')}`,
+                            },
+                        ],
+                    };
+                }
+                const category = getStatusCategory(code);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `HTTP Status Code: ${code}
+
+Message: ${message}
+Category: ${category}
+
+Description: ${description || 'No detailed description available.'}
+
+Usage: This status code indicates ${getUsageHint(code)}.`,
+                        },
+                    ],
+                };
+            }
+            else {
+                // Return overview of all status codes
+                const byCategory = {
+                    '1xx (Informational)': Object.entries(statusCodes).filter(([c]) => c.startsWith('1')),
+                    '2xx (Success)': Object.entries(statusCodes).filter(([c]) => c.startsWith('2')),
+                    '3xx (Redirection)': Object.entries(statusCodes).filter(([c]) => c.startsWith('3')),
+                    '4xx (Client Error)': Object.entries(statusCodes).filter(([c]) => c.startsWith('4')),
+                    '5xx (Server Error)': Object.entries(statusCodes).filter(([c]) => c.startsWith('5'))
+                };
+                let result = 'HTTP Status Codes Reference:\n\n';
+                for (const [category, codes] of Object.entries(byCategory)) {
+                    result += `${category}:\n`;
+                    for (const [code, message] of codes) {
+                        result += `• ${code}: ${message}\n`;
+                    }
+                    result += '\n';
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result.trim(),
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error looking up HTTP status code: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/utility/mime-types/index.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import mimeTypes from 'mime-types';
+function getMimeCategory(mimeType) {
+    if (mimeType.startsWith('text/'))
+        return 'Text';
+    if (mimeType.startsWith('image/'))
+        return 'Image';
+    if (mimeType.startsWith('audio/'))
+        return 'Audio';
+    if (mimeType.startsWith('video/'))
+        return 'Video';
+    if (mimeType.startsWith('application/'))
+        return 'Application';
+    if (mimeType.startsWith('font/'))
+        return 'Font';
+    return 'Other';
+}
+function getMimeDescription(mimeType) {
+    const descriptions = {
+        'text/plain': 'Plain text file',
+        'text/html': 'HTML document',
+        'text/css': 'Cascading Style Sheets',
+        'text/javascript': 'JavaScript code',
+        'application/json': 'JSON data',
+        'image/jpeg': 'JPEG image',
+        'image/png': 'PNG image',
+        'image/gif': 'GIF image',
+        'application/pdf': 'PDF document',
+        'application/zip': 'ZIP archive',
+        'audio/mpeg': 'MP3 audio file',
+        'video/mp4': 'MP4 video file'
+    };
+    return descriptions[mimeType] || 'No description available';
+}
+export function registerMimeTypes(server) {
+    server.tool("mime-types", "Look up MIME types for file extensions", {
+        input: z.string().describe("File extension (e.g., 'txt') or MIME type (e.g., 'text/plain')"),
+        lookupType: z.enum(["extension-to-mime", "mime-to-extension"]).describe("Lookup direction").optional(),
+    }, async ({ input, lookupType = "extension-to-mime" }) => {
+        try {
+            if (lookupType === "extension-to-mime") {
+                const ext = input.toLowerCase().replace(/^\./, ''); // Remove leading dot if present
+                const mimeType = mimeTypes.lookup(ext);
+                if (!mimeType) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `MIME Type Lookup:
+
+Extension: .${ext}
+Result: Not found
+
+Note: This extension is not recognized in the MIME types database.`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `MIME Type Lookup:
+
+Extension: .${ext}
+MIME Type: ${mimeType}
+
+Category: ${getMimeCategory(mimeType)}
+Description: ${getMimeDescription(mimeType)}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                // mime-to-extension
+                const mimeType = input.toLowerCase();
+                const extension = mimeTypes.extension(mimeType);
+                if (!extension) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Extension Lookup:
+
+MIME Type: ${input}
+Result: Not found
+
+Note: This MIME type is not recognized or has no standard extension.`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Extension Lookup:
+
+MIME Type: ${mimeType}
+Extension: .${extension}
+Primary: .${extension}
+
+Category: ${getMimeCategory(mimeType)}
+Description: ${getMimeDescription(mimeType)}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error looking up MIME type: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/utility/port-numbers/index.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export function registerPortNumbers(server) {
+    server.tool("port-numbers", "Look up common TCP/UDP port numbers and their services", {
+        query: z.string().describe("Port number or service name to look up")
+    }, async ({ query }) => {
+        try {
+            const ports = {
+                // Well-known ports (0-1023)
+                "21": "FTP (File Transfer Protocol)",
+                "22": "SSH (Secure Shell)",
+                "23": "Telnet",
+                "25": "SMTP (Simple Mail Transfer Protocol)",
+                "53": "DNS (Domain Name System)",
+                "80": "HTTP (Hypertext Transfer Protocol)",
+                "110": "POP3 (Post Office Protocol v3)",
+                "143": "IMAP (Internet Message Access Protocol)",
+                "443": "HTTPS (HTTP Secure)",
+                "993": "IMAPS (IMAP Secure)",
+                "995": "POP3S (POP3 Secure)",
+                // Registered ports (1024-49151)
+                "1433": "Microsoft SQL Server",
+                "1521": "Oracle Database",
+                "3306": "MySQL",
+                "3389": "RDP (Remote Desktop Protocol)",
+                "5432": "PostgreSQL",
+                "5672": "AMQP (Advanced Message Queuing Protocol)",
+                "5984": "CouchDB",
+                "6379": "Redis",
+                "8080": "HTTP Alternate",
+                "8443": "HTTPS Alternate",
+                "9200": "Elasticsearch",
+                "27017": "MongoDB",
+                // Development ports
+                "3000": "Node.js Development Server",
+                "3001": "React Development Server",
+                "4200": "Angular Development Server",
+                "5173": "Vite Development Server",
+                "8000": "Python HTTP Server",
+                "8888": "Jupyter Notebook"
+            };
+            const isNumber = /^\d+$/.test(query);
+            let results = [];
+            if (isNumber) {
+                // Look up by port number
+                const port = query;
+                if (ports[port]) {
+                    results.push(`Port ${port}: ${ports[port]}`);
+                }
+                else {
+                    results.push(`Port ${port}: No standard service found`);
+                }
+                // Add range information
+                const portNum = parseInt(port);
+                if (portNum <= 1023) {
+                    results.push("Range: Well-known ports (0-1023) - requires root privileges");
+                }
+                else if (portNum <= 49151) {
+                    results.push("Range: Registered ports (1024-49151) - assigned by IANA");
+                }
+                else {
+                    results.push("Range: Dynamic/Private ports (49152-65535) - available for applications");
+                }
+            }
+            else {
+                // Search by service name
+                const searchTerm = query.toLowerCase();
+                for (const [port, service] of Object.entries(ports)) {
+                    if (service.toLowerCase().includes(searchTerm)) {
+                        results.push(`Port ${port}: ${service}`);
+                    }
+                }
+                if (results.length === 0) {
+                    results.push(`No ports found matching "${query}"`);
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Port Number Lookup Results:
+
+Query: "${query}"
+
+${results.join('\n')}
+
+Common Port Ranges:
+• 0-1023: Well-known ports (system/root required)
+• 1024-49151: Registered ports (IANA assigned)
+• 49152-65535: Dynamic/Private ports (ephemeral)
+
+Security Notes:
+• Always check firewall rules before opening ports
+• Use non-standard ports for additional security
+• Monitor open ports with netstat/ss commands`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error looking up port: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}