it-tools-mcp 3.0.24 → 3.1.1

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'}`
+                    }
+                ]
+            };
+        }
+    });
+}

package/build/tools/math/percentage-calculator/index.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export function registerPercentageCalculator(server) {
+    server.tool("percentage-calculator", "Calculate percentages, percentage of a number, or percentage change", {
+        operation: z.enum(["percentage-of", "what-percentage", "percentage-change"]).describe("Type of percentage calculation"),
+        value1: z.number().describe("First value"),
+        value2: z.number().describe("Second value")
+    }, async ({ operation, value1, value2 }) => {
+        try {
+            let result;
+            let explanation;
+            switch (operation) {
+                case "percentage-of":
+                    // value1% of value2
+                    result = (value1 / 100) * value2;
+                    explanation = `${value1}% of ${value2} = ${result}`;
+                    break;
+                case "what-percentage":
+                    // value1 is what percentage of value2
+                    result = (value1 / value2) * 100;
+                    explanation = `${value1} is ${result.toFixed(2)}% of ${value2}`;
+                    break;
+                case "percentage-change":
+                    // percentage change from value1 to value2
+                    result = ((value2 - value1) / value1) * 100;
+                    explanation = `Percentage change from ${value1} to ${value2} = ${result.toFixed(2)}%`;
+                    break;
+                default:
+                    throw new Error("Invalid operation");
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: explanation
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error calculating percentage: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }
+                ]
+            };
+        }
+    });
+}

package/build/tools/math/roman-numeral-converter/index.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export function registerRomanNumeralConverter(server) {
+    server.tool("roman-numeral-converter", "Convert between Arabic numbers and Roman numerals", {
+        input: z.string().describe("Number to convert (Arabic number 1-3999 or Roman numeral)")
+    }, async ({ input }) => {
+        try {
+            // Auto-detect if input is a number or Roman numeral
+            const isNumber = /^\d+$/.test(input.trim());
+            if (isNumber) {
+                // Convert number to Roman numeral
+                const num = parseInt(input);
+                if (isNaN(num) || num < 1 || num > 3999) {
+                    throw new Error("Number must be between 1 and 3999");
+                }
+                const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+                const symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
+                let result = "";
+                let remaining = num;
+                for (let i = 0; i < values.length; i++) {
+                    while (remaining >= values[i]) {
+                        result += symbols[i];
+                        remaining -= values[i];
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${num} = ${result} in Roman numerals`
+                        }
+                    ]
+                };
+            }
+            else {
+                // Convert Roman numeral to number
+                const roman = input.toUpperCase();
+                const romanMap = {
+                    I: 1, V: 5, X: 10, L: 50, C: 100, D: 500, M: 1000
+                };
+                let result = 0;
+                let prev = 0;
+                for (let i = roman.length - 1; i >= 0; i--) {
+                    const current = romanMap[roman[i]];
+                    if (!current) {
+                        throw new Error(`Invalid Roman numeral character: ${roman[i]}`);
+                    }
+                    if (current < prev) {
+                        result -= current;
+                    }
+                    else {
+                        result += current;
+                    }
+                    prev = current;
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `${roman} = ${result} in decimal`
+                        }
+                    ]
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting Roman numeral: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }
+                ]
+            };
+        }
+    });
+}

package/build/tools/math/temperature-converter/index.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export function registerTemperatureConverter(server) {
+    server.tool("temperature-converter", "Convert temperatures between Celsius, Fahrenheit, and Kelvin", {
+        temperature: z.number().describe("Temperature value to convert"),
+        from: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Source temperature unit"),
+        to: z.enum(["celsius", "fahrenheit", "kelvin"]).describe("Target temperature unit")
+    }, async ({ temperature, from, to }) => {
+        try {
+            // Convert to Celsius first
+            let celsius;
+            switch (from) {
+                case "celsius":
+                    celsius = temperature;
+                    break;
+                case "fahrenheit":
+                    celsius = (temperature - 32) * 5 / 9;
+                    break;
+                case "kelvin":
+                    celsius = temperature - 273.15;
+                    break;
+                default:
+                    throw new Error("Invalid source unit");
+            }
+            // Convert from Celsius to target unit
+            let result;
+            switch (to) {
+                case "celsius":
+                    result = celsius;
+                    break;
+                case "fahrenheit":
+                    result = celsius * 9 / 5 + 32;
+                    break;
+                case "kelvin":
+                    result = celsius + 273.15;
+                    break;
+                default:
+                    throw new Error("Invalid target unit");
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${temperature}° ${from} = ${result.toFixed(2)}° ${to}`
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error converting temperature: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }
+                ]
+            };
+        }
+    });
+}