it-tools-mcp 3.0.23 → 3.1.0

package/build/tools/encoding/html-entities-extended/index.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export function registerHtmlEntitiesExtended(server) {
+    server.tool("html-entities-extended", "Extended HTML entity encoding/decoding", {
+        text: z.string().describe("Text to encode or decode"),
+        operation: z.enum(["encode", "decode"]).describe("Operation to perform"),
+    }, async ({ text, operation }) => {
+        try {
+            if (operation === "encode") {
+                const encoded = text
+                    .replace(/&/g, '&')
+                    .replace(/</g, '&lt;')
+                    .replace(/>/g, '&gt;')
+                    .replace(/"/g, '&quot;')
+                    .replace(/'/g, '&#39;')
+                    .replace(/©/g, '&copy;')
+                    .replace(/®/g, '&reg;')
+                    .replace(/™/g, '&trade;')
+                    .replace(/€/g, '&euro;')
+                    .replace(/£/g, '&pound;')
+                    .replace(/¥/g, '&yen;')
+                    .replace(/§/g, '&sect;')
+                    .replace(/¶/g, '&para;')
+                    .replace(/†/g, '&dagger;')
+                    .replace(/‡/g, '&Dagger;');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `HTML entities encoded: ${encoded}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                const decoded = text
+                    .replace(/&amp;/g, '&')
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&quot;/g, '"')
+                    .replace(/&#39;/g, "'")
+                    .replace(/&copy;/g, '©')
+                    .replace(/&reg;/g, '®')
+                    .replace(/&trade;/g, '™')
+                    .replace(/&euro;/g, '€')
+                    .replace(/&pound;/g, '£')
+                    .replace(/&yen;/g, '¥')
+                    .replace(/&sect;/g, '§')
+                    .replace(/&para;/g, '¶')
+                    .replace(/&dagger;/g, '†')
+                    .replace(/&Dagger;/g, '‡');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `HTML entities decoded: ${decoded}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error processing HTML entities: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/encoding/text-to-binary/index.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export function registerTextToBinary(server) {
+    server.tool("text-to-binary", "Convert text to binary and vice versa", {
+        input: z.string().describe("Text to convert to binary, or binary to convert to text"),
+        operation: z.enum(["encode", "decode"]).describe("Operation: encode text to binary or decode binary to text"),
+    }, async ({ input, operation }) => {
+        try {
+            if (operation === "encode") {
+                const binary = input
+                    .split('')
+                    .map(char => char.charCodeAt(0).toString(2).padStart(8, '0'))
+                    .join(' ');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Text: ${input}
+Binary: ${binary}`,
+                        },
+                    ],
+                };
+            }
+            else {
+                // Decode binary to text
+                const binaryGroups = input.replace(/\s+/g, ' ').trim().split(' ');
+                const text = binaryGroups
+                    .map(binary => String.fromCharCode(parseInt(binary, 2)))
+                    .join('');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Binary: ${input}
+Text: ${text}`,
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting text/binary: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/encoding/url-decode/index.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export function registerUrlDecode(server) {
+    server.tool("url-decode", "URL decode text", {
+        text: z.string().describe("URL encoded text to decode"),
+    }, async ({ text }) => {
+        try {
+            const decoded = decodeURIComponent(text);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `URL decoded: ${decoded}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error decoding URL: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/encoding/url-encode/index.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export function registerUrlEncode(server) {
+    server.tool("url-encode", "URL encode text", {
+        text: z.string().describe("Text to URL encode"),
+    }, async ({ text }) => {
+        const encoded = encodeURIComponent(text);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `URL encoded: ${encoded}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/forensic/file-type-identifier/index.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { Buffer } from 'buffer';
+export function registerFileTypeIdentifier(server) {
+    server.tool("file-type-identifier", "Identify file type based on magic numbers/file signatures", {
+        data: z.string().describe("Hex data or base64 data of file header"),
+        format: z.enum(["hex", "base64"]).describe("Format of the input data")
+    }, async ({ data, format }) => {
+        try {
+            let buffer;
+            if (format === "hex") {
+                const cleanHex = data.replace(/\s/g, '');
+                buffer = Buffer.from(cleanHex, 'hex');
+            }
+            else {
+                buffer = Buffer.from(data, 'base64');
+            }
+            // Magic number signatures
+            const signatures = [
+                { pattern: [0xFF, 0xD8, 0xFF], type: "JPEG Image", extension: ".jpg" },
+                { pattern: [0x89, 0x50, 0x4E, 0x47], type: "PNG Image", extension: ".png" },
+                { pattern: [0x47, 0x49, 0x46, 0x38], type: "GIF Image", extension: ".gif" },
+                { pattern: [0x50, 0x4B, 0x03, 0x04], type: "ZIP Archive", extension: ".zip" },
+                { pattern: [0x50, 0x4B, 0x05, 0x06], type: "ZIP Archive (empty)", extension: ".zip" },
+                { pattern: [0x50, 0x4B, 0x07, 0x08], type: "ZIP Archive (spanned)", extension: ".zip" },
+                { pattern: [0x25, 0x50, 0x44, 0x46], type: "PDF Document", extension: ".pdf" },
+                { pattern: [0x52, 0x61, 0x72, 0x21], type: "RAR Archive", extension: ".rar" },
+                { pattern: [0x7F, 0x45, 0x4C, 0x46], type: "ELF Executable", extension: "" },
+                { pattern: [0x4D, 0x5A], type: "Windows Executable", extension: ".exe" },
+                { pattern: [0xCA, 0xFE, 0xBA, 0xBE], type: "Java Class File", extension: ".class" },
+                { pattern: [0x1F, 0x8B], type: "GZIP Archive", extension: ".gz" },
+                { pattern: [0x42, 0x5A, 0x68], type: "BZIP2 Archive", extension: ".bz2" },
+                { pattern: [0x37, 0x7A, 0xBC, 0xAF], type: "7-Zip Archive", extension: ".7z" },
+                { pattern: [0x52, 0x49, 0x46, 0x46], type: "RIFF Container (WAV/AVI)", extension: ".wav/.avi" },
+                { pattern: [0x49, 0x44, 0x33], type: "MP3 Audio", extension: ".mp3" },
+                { pattern: [0x66, 0x74, 0x79, 0x70], type: "MP4 Video", extension: ".mp4", offset: 4 },
+            ];
+            let detectedType = "Unknown";
+            let extension = "";
+            let matchDetails = "";
+            for (const sig of signatures) {
+                const offset = sig.offset || 0;
+                if (buffer.length >= offset + sig.pattern.length) {
+                    let matches = true;
+                    for (let i = 0; i < sig.pattern.length; i++) {
+                        if (buffer[offset + i] !== sig.pattern[i]) {
+                            matches = false;
+                            break;
+                        }
+                    }
+                    if (matches) {
+                        detectedType = sig.type;
+                        extension = sig.extension;
+                        matchDetails = `Matched at offset ${offset}: ${sig.pattern.map(b => b.toString(16).padStart(2, '0')).join(' ')}`;
+                        break;
+                    }
+                }
+            }
+            const hexDump = buffer.slice(0, Math.min(32, buffer.length))
+                .toString('hex')
+                .toUpperCase()
+                .replace(/.{2}/g, '$& ')
+                .trim();
+            return {
+                content: [{
+                        type: "text",
+                        text: `File Type Identification Results:
+
+Detected Type: ${detectedType}
+Extension: ${extension || "N/A"}
+Data Size: ${buffer.length} bytes
+
+Hex Dump (first 32 bytes):
+${hexDump}
+
+${matchDetails ? `Match Details: ${matchDetails}` : "No signature match found"}
+
+Note: This is based on magic number detection. Some files may have multiple valid interpretations.`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error identifying file type: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/forensic/safelink-decoder/index.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export function registerSafelinkDecoder(server) {
+    server.tool("safelink-decoder", "Decode Microsoft Outlook SafeLink URLs", {
+        safelink: z.string().describe("SafeLink URL to decode")
+    }, async ({ safelink }) => {
+        try {
+            const url = new URL(safelink);
+            // Check if it's a SafeLink URL
+            if (!url.hostname.includes('safelinks.protection.outlook.com')) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "This doesn't appear to be a SafeLink URL."
+                        }]
+                };
+            }
+            // Extract the actual URL from the 'url' parameter
+            const actualUrl = url.searchParams.get('url');
+            if (!actualUrl) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Could not find the original URL in the SafeLink."
+                        }]
+                };
+            }
+            // Decode the URL
+            const decodedUrl = decodeURIComponent(actualUrl);
+            return {
+                content: [{
+                        type: "text",
+                        text: `SafeLink Decoder Results:
+
+Original SafeLink: ${safelink}
+
+Decoded URL: ${decodedUrl}
+
+Additional Parameters:
+- Data: ${url.searchParams.get('data') || 'N/A'}
+- Reserved: ${url.searchParams.get('reserved') || 'N/A'}
+- Source: ${url.searchParams.get('source') || 'N/A'}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error decoding SafeLink: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/forensic/url-fanger/index.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export function registerUrlFanger(server) {
+    server.tool("url-fanger", "Defang or refang URLs for safe sharing (security analysis)", {
+        text: z.string().describe("Text containing URLs to fang/defang"),
+        operation: z.enum(["defang", "refang"]).describe("Whether to defang (make safe) or refang (restore) URLs")
+    }, async ({ text, operation }) => {
+        try {
+            let result = text;
+            if (operation === "defang") {
+                // Defang URLs to make them safe
+                result = result
+                    .replace(/https?:\/\//g, 'hxxp://') // Replace http/https with hxxp
+                    .replace(/\./g, '[.]') // Replace dots with [.]
+                    .replace(/@/g, '[@]') // Replace @ with [@]
+                    .replace(/:/g, '[:]'); // Replace colons with [:]
+            }
+            else {
+                // Refang URLs to restore them
+                result = result
+                    .replace(/hxxp:\/\//g, 'http://') // Restore http
+                    .replace(/hxxps:\/\//g, 'https://') // Restore https
+                    .replace(/\[\.\]/g, '.') // Restore dots
+                    .replace(/\[@\]/g, '@') // Restore @
+                    .replace(/\[:\]/g, ':'); // Restore colons
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `URL ${operation === "defang" ? "Defanging" : "Refanging"} Results:
+
+Original:
+${text}
+
+${operation === "defang" ? "Defanged" : "Refanged"}:
+${result}
+
+Note: ${operation === "defang"
+                            ? "Defanged URLs are safe to share and won't be clickable."
+                            : "Refanged URLs have been restored to their original form."}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error processing URLs: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/idGenerators/qr-generate/index.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export function registerQrGenerate(server) {
+    server.tool("qr-generate", "Generate QR code for any text including URLs, WiFi networks, contact info, etc.", {
+        text: z.string().describe("Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"),
+        size: z.number().describe("Size multiplier (1-3)").optional(),
+    }, async ({ text, size = 1 }) => {
+        try {
+            const QRCode = (await import("qrcode")).default;
+            if (size < 1 || size > 3) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Size must be between 1 and 3.",
+                        },
+                    ],
+                };
+            }
+            // Generate QR code as base64 data URL
+            console.log(`[DEBUG] Generating QR code for: "${text}" with size: ${size}`);
+            const dataUrl = await QRCode.toDataURL(text, {
+                type: 'image/png',
+                errorCorrectionLevel: 'M',
+                width: Math.max(256, size * 128), // Minimum 256px, scales with size parameter
+                margin: 2,
+                color: {
+                    dark: '#000000', // Black
+                    light: '#FFFFFF' // White
+                }
+            });
+            console.log(`[DEBUG] QR code generated successfully`);
+            // Extract just the base64 data (remove the data:image/png;base64, prefix)
+            const base64Data = dataUrl.split(',')[1];
+            const markdown = `![QR Code](data:image/png;base64,${base64Data})`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📱 QR Code for: "${text}"
+\n📊 Data encoded: "${text}" (${text.length} characters)
+🎯 Error correction: Medium (M)
+📐 Image size: ${Math.max(256, size * 128)}x${Math.max(256, size * 128)} pixels
+\n✅ This QR code can be scanned with any QR code reader app
+💡 Generated using the 'qrcode' npm library!
+\n---\n**Markdown for inline display:**\n${markdown}`,
+                    },
+                    {
+                        type: "image",
+                        data: base64Data,
+                        mimeType: "image/png"
+                    }
+                ],
+            };
+        }
+        catch (error) {
+            console.error(`[DEBUG] QR code generation failed:`, error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating QR code: ${error instanceof Error ? error.message : 'Unknown error'}\n\nDebug info:\n- Text: \"${text}\"\n- Size: ${size}`,
+                    },
+                ],
+            };
+        }
+        // Fallback return in case of unexpected behavior
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Unknown error: No response generated by qr-generate.",
+                },
+            ],
+        };
+    });
+}

package/build/tools/idGenerators/svg-placeholder-generator/index.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export function registerSvgPlaceholderGenerator(server) {
+    server.tool("svg-placeholder-generator", "Generate SVG placeholder images", {
+        width: z.number().describe("Width in pixels").optional(),
+        height: z.number().describe("Height in pixels").optional(),
+        backgroundColor: z.string().describe("Background color (hex)").optional(),
+        textColor: z.string().describe("Text color (hex)").optional(),
+        text: z.string().optional().describe("Custom text (default: dimensions)"),
+    }, async ({ width = 300, height = 200, backgroundColor = "#cccccc", textColor = "#666666", text }) => {
+        try {
+            if (width < 1 || width > 2000 || height < 1 || height > 2000) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Width and height must be between 1 and 2000 pixels.",
+                        },
+                    ],
+                };
+            }
+            const displayText = text || `${width}×${height}`;
+            const fontSize = Math.min(width, height) / 8;
+            const svg = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+  <rect width="100%" height="100%" fill="${backgroundColor}"/>
+  <text x="50%" y="50%" font-family="Arial, sans-serif" font-size="${fontSize}" fill="${textColor}" text-anchor="middle" dy=".3em">${displayText}</text>
+</svg>`;
+            const dataUrl = `data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `SVG Placeholder Generated:
+
+Dimensions: ${width}×${height}
+Background: ${backgroundColor}
+Text Color: ${textColor}
+Text: ${displayText}
+
+SVG Code:
+${svg}
+
+Data URL:
+${dataUrl}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating SVG placeholder: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/idGenerators/ulid-generate/index.js

@@ -0,0 +1,34 @@
+export function registerUlidGenerate(server) {
+    server.tool("ulid-generate", "Generate Universally Unique Lexicographically Sortable Identifier", {}, async () => {
+        try {
+            // Simplified ULID implementation
+            const timestamp = Date.now();
+            const randomPart = Math.random().toString(36).substring(2, 18);
+            const ulid = timestamp.toString(36).toUpperCase() + randomPart.toUpperCase();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Generated ULID: ${ulid}
+
+Timestamp: ${timestamp}
+Generated at: ${new Date(timestamp).toISOString()}
+
+Note: This is a simplified ULID implementation.
+For production use, please use a proper ULID library.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating ULID: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/idGenerators/uuid-generate/index.js

@@ -0,0 +1,14 @@
+import { randomUUID } from "crypto";
+export function registerUuidGenerate(server) {
+    server.tool("uuid-generate", "Generate a random UUID v4", {}, async () => {
+        const uuid = randomUUID();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Generated UUID: ${uuid}`,
+                },
+            ],
+        };
+    });
+}

package/build/tools/math/math-evaluate/index.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export function registerMathEvaluate(server) {
+    server.tool("math-evaluate", "Safely evaluate mathematical expressions", {
+        expression: z.string().describe("Mathematical expression to evaluate (e.g., '2 + 3 * 4')")
+    }, async ({ expression }) => {
+        try {
+            // @ts-ignore: Ignore missing type declarations for mathjs
+            const { compile } = await import("mathjs");
+            const start = Date.now();
+            const code = compile(expression);
+            const result = code.evaluate();
+            const elapsed = Date.now() - start;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Expression: ${expression}\nResult: ${result}\n(evaluated in ${elapsed} ms)`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error evaluating expression: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }
+                ]
+            };
+        }
+    });
+}

package/build/tools/math/number-base-converter/index.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export function registerNumberBaseConverter(server) {
+    server.tool("number-base-converter", "Convert numbers between different bases (binary, octal, decimal, hexadecimal)", {
+        number: z.string().describe("Number to convert"),
+        fromBase: z.number().describe("Source base (2-36)"),
+        toBase: z.number().describe("Target base (2-36)")
+    }, async ({ number, fromBase, toBase }) => {
+        try {
+            if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Base must be between 2 and 36.",
+                        },
+                    ],
+                };
+            }
+            // Parse number from source base to decimal
+            const decimal = parseInt(number, fromBase);
+            if (isNaN(decimal)) {
+                throw new Error("Invalid number for the specified base");
+            }
+            // Convert decimal to target base
+            const result = decimal.toString(toBase);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${number} (base ${fromBase}) = ${result} (base ${toBase})\nDecimal equivalent: ${decimal}`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting number: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }
+                ]
+            };
+        }
+    });
+}