it-tools-mcp 3.0.24 → 3.1.1

package/build/tools/network/ipv6-subnet-calculator/index.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+export function registerIpv6SubnetCalculator(server) {
+    server.tool("ipv6-subnet-calculator", "Calculate IPv6 subnet information", {
+        ipv6: z.string().describe("IPv6 address and prefix (e.g., 2001:db8::/32)"),
+        newPrefix: z.number().optional().describe("New prefix length for subnetting")
+    }, async ({ ipv6, newPrefix }) => {
+        try {
+            const [address, prefixStr] = ipv6.split('/');
+            if (!address || !prefixStr) {
+                throw new Error("Invalid IPv6 format. Use format: address/prefix");
+            }
+            const prefix = parseInt(prefixStr);
+            if (prefix < 0 || prefix > 128) {
+                throw new Error("Prefix length must be between 0 and 128");
+            }
+            // Expand IPv6 address to full form
+            const expandIPv6 = (addr) => {
+                // Handle :: notation
+                const parts = addr.split('::');
+                if (parts.length === 2) {
+                    const left = parts[0] ? parts[0].split(':') : [];
+                    const right = parts[1] ? parts[1].split(':') : [];
+                    const missing = 8 - left.length - right.length;
+                    const middle = Array(missing).fill('0000');
+                    return [...left, ...middle, ...right].map(part => part.padStart(4, '0')).join(':');
+                }
+                else {
+                    return addr.split(':').map(part => part.padStart(4, '0')).join(':');
+                }
+            };
+            const fullAddress = expandIPv6(address);
+            const parts = fullAddress.split(':');
+            if (parts.length !== 8) {
+                throw new Error("Invalid IPv6 address format");
+            }
+            // Calculate network portion
+            const networkBits = prefix;
+            const hostBits = 128 - prefix;
+            // Create network address
+            const networkParts = [...parts];
+            const bytesToClear = Math.floor((128 - prefix) / 16);
+            const partialBits = (128 - prefix) % 16;
+            // Clear host portion
+            for (let i = 8 - bytesToClear; i < 8; i++) {
+                networkParts[i] = '0000';
+            }
+            if (partialBits > 0) {
+                const partIndex = 8 - bytesToClear - 1;
+                const mask = (0xFFFF << partialBits) & 0xFFFF;
+                const value = parseInt(networkParts[partIndex], 16) & mask;
+                networkParts[partIndex] = value.toString(16).padStart(4, '0');
+            }
+            const networkAddr = networkParts.join(':');
+            // Calculate some common subnet sizes if newPrefix is provided
+            let subnetInfo = '';
+            if (newPrefix && newPrefix > prefix) {
+                const subnetBits = newPrefix - prefix;
+                const numSubnets = Math.pow(2, subnetBits);
+                const hostsPerSubnet = Math.pow(2, 128 - newPrefix);
+                subnetInfo = `\nSubnetting to /${newPrefix}:
+• Subnet bits borrowed: ${subnetBits}
+• Number of subnets: ${numSubnets.toLocaleString()}
+• Hosts per subnet: ${hostsPerSubnet.toExponential(2)}`;
+            }
+            const totalHosts = Math.pow(2, hostBits);
+            return {
+                content: [{
+                        type: "text",
+                        text: `IPv6 Subnet Calculator Results:
+
+Input: ${ipv6}
+Full Address: ${fullAddress}
+
+Network Information:
+• Network Address: ${networkAddr}/${prefix}
+• Prefix Length: /${prefix}
+• Network Bits: ${networkBits}
+• Host Bits: ${hostBits}
+• Total Addresses: 2^${hostBits} (${totalHosts.toExponential(2)})
+
+Address Format:
+• Compressed: ${networkAddr.replace(/(:0000)+/g, '::').replace(/^0+|:0+/g, ':').replace(/^:/, '').replace(/:$/, '') || '::'}/${prefix}
+• Full: ${networkAddr}/${prefix}
+
+${subnetInfo}
+
+IPv6 Address Types:
+• Global Unicast: 2000::/3
+• Link-Local: fe80::/10
+• Unique Local: fc00::/7
+• Multicast: ff00::/8`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error calculating IPv6 subnet: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/network/ipv6-ula-generator/index.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export function registerIpv6UlaGenerator(server) {
+    server.tool("ipv6-ula-generator", "Generate IPv6 Unique Local Address (ULA) prefix", {
+        globalId: z.string().optional().describe("Global ID (40 bits in hex, auto-generated if not provided)"),
+    }, async ({ globalId }) => {
+        try {
+            // Generate random 40-bit Global ID if not provided
+            let gid = globalId;
+            if (!gid) {
+                const randomBytes = [];
+                for (let i = 0; i < 5; i++) {
+                    randomBytes.push(Math.floor(Math.random() * 256).toString(16).padStart(2, '0'));
+                }
+                gid = randomBytes.join('');
+            }
+            // Validate Global ID
+            if (!/^[0-9a-fA-F]{10}$/.test(gid)) {
+                throw new Error("Global ID must be exactly 10 hexadecimal characters (40 bits)");
+            }
+            // Format the ULA prefix
+            const prefix = `fd${gid.substring(0, 2)}:${gid.substring(2, 6)}:${gid.substring(6, 10)}`;
+            const fullPrefix = `${prefix}::/48`;
+            // Generate some example subnets
+            const subnets = [];
+            for (let i = 0; i < 5; i++) {
+                const subnetId = Math.floor(Math.random() * 65536).toString(16).padStart(4, '0');
+                subnets.push(`${prefix}:${subnetId}::/64`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `IPv6 ULA (Unique Local Address) Generated:
+
+ULA Prefix: ${fullPrefix}
+Global ID: ${gid}
+
+Example Subnets:
+${subnets.map((subnet, i) => `${i + 1}. ${subnet}`).join('\n')}
+
+Properties:
+- Scope: Local (not routed on the internet)
+- Prefix: fd00::/8 (ULA)
+- Global ID: ${gid} (40 bits)
+- Subnet ID: 16 bits available
+- Interface ID: 64 bits available
+
+Note: ULAs are designed for local communications within a site.
+They are not expected to be routable on the global Internet.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating IPv6 ULA: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/network/mac-address-generate/index.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export function registerMacAddressGenerate(server) {
+    server.tool("mac-address-generate", "Generate random MAC address", {
+        prefix: z.string().optional().describe("MAC address prefix (e.g., '00:1B:44')"),
+        separator: z.enum([":", "-"]).describe("Separator character").optional(),
+    }, async ({ prefix, separator = ":" }) => {
+        try {
+            let macParts = [];
+            if (prefix) {
+                // Validate and use provided prefix
+                const prefixParts = prefix.split(/[:-]/);
+                if (prefixParts.length > 6) {
+                    throw new Error("Prefix cannot have more than 6 parts");
+                }
+                for (const part of prefixParts) {
+                    if (!/^[0-9-A-Fa-f]{2}$/.test(part)) {
+                        throw new Error(`Invalid MAC address part: ${part}`);
+                    }
+                    macParts.push(part.toUpperCase());
+                }
+            }
+            // Generate remaining parts
+            while (macParts.length < 6) {
+                const randomByte = Math.floor(Math.random() * 256).toString(16).padStart(2, '0').toUpperCase();
+                macParts.push(randomByte);
+            }
+            // Ensure first octet indicates locally administered unicast
+            if (!prefix) {
+                const firstOctet = parseInt(macParts[0], 16);
+                // Set locally administered bit (bit 1) and clear multicast bit (bit 0)
+                macParts[0] = ((firstOctet | 0x02) & 0xFE).toString(16).padStart(2, '0').toUpperCase();
+            }
+            const macAddress = macParts.join(separator);
+            // Analyze the MAC address
+            const firstOctet = parseInt(macParts[0], 16);
+            const isMulticast = (firstOctet & 0x01) !== 0;
+            const isLocallyAdministered = (firstOctet & 0x02) !== 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Generated MAC Address: ${macAddress}
+
+Properties:
+Type: ${isMulticast ? 'Multicast' : 'Unicast'}
+Administration: ${isLocallyAdministered ? 'Locally Administered' : 'Universally Administered'}
+Format: ${separator === ':' ? 'Colon notation' : 'Hyphen notation'}
+
+Binary representation:
+${macParts.map(part => parseInt(part, 16).toString(2).padStart(8, '0')).join(' ')}
+
+${prefix ? `Used prefix: ${prefix}` : 'Randomly generated'}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating MAC address: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/network/nslookup/index.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import dns from "dns";
+export function registerNslookup(server) {
+    server.tool("nslookup", "Perform DNS lookup on a hostname or IP address", {
+        target: z.string().describe("Hostname or IP address")
+    }, async ({ target }) => {
+        return new Promise((resolve) => {
+            dns.lookup(target, (err, address, family) => {
+                if (err) {
+                    resolve({ content: [{ type: "text", text: `nslookup failed: ${err.message}` }] });
+                }
+                else {
+                    resolve({ content: [{ type: "text", text: `Address: ${address}\nFamily: IPv${family}` }] });
+                }
+            });
+        });
+    });
+}

package/build/tools/network/ping/index.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import ping from "ping";
+export function registerPing(server) {
+    server.tool("ping", "Ping a host to check connectivity", {
+        target: z.string().describe("Host to ping"),
+        count: z.number().default(4).describe("Number of ping attempts")
+    }, async ({ target, count }) => {
+        try {
+            const res = await ping.promise.probe(target, { min_reply: count });
+            return {
+                content: [
+                    { type: "text", text: `Ping to ${target}:\nAlive: ${res.alive}\nTime: ${res.time} ms\nOutput: ${res.output}` }
+                ]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Ping failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+}

package/build/tools/network/ps/index.js

@@ -0,0 +1,22 @@
+import psList from "ps-list";
+export function registerPs(server) {
+    server.tool("ps", "List running processes", {}, async () => {
+        try {
+            const processes = await psList();
+            // Defensive: handle missing properties and filter out bad entries
+            const output = processes
+                .map(p => {
+                const pid = p.pid ?? 'N/A';
+                const name = p.name ?? 'N/A';
+                return `${pid}\t${name}`;
+            })
+                .join("\n");
+            return { content: [{ type: "text", text: output || 'No processes found.' }] };
+        }
+        catch (error) {
+            // Log error for debugging
+            console.error('ps error:', error);
+            return { content: [{ type: "text", text: `ps failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+}

package/build/tools/network/random-port/index.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export function registerRandomPort(server) {
+    server.tool("random-port", "Generate random port numbers", {
+        count: z.number().describe("Number of ports to generate").optional(),
+        min: z.number().describe("Minimum port number").optional(),
+        max: z.number().describe("Maximum port number").optional(),
+        exclude: z.array(z.number()).optional().describe("Ports to exclude"),
+    }, async ({ count = 1, min = 1024, max = 65535, exclude = [] }) => {
+        try {
+            const ports = [];
+            const excludeSet = new Set(exclude);
+            // Well-known ports to avoid by default
+            const wellKnownPorts = [22, 23, 25, 53, 80, 110, 143, 443, 993, 995];
+            wellKnownPorts.forEach(port => excludeSet.add(port));
+            for (let i = 0; i < count; i++) {
+                let port;
+                let attempts = 0;
+                do {
+                    port = Math.floor(Math.random() * (max - min + 1)) + min;
+                    attempts++;
+                    if (attempts > 1000) {
+                        throw new Error("Could not generate unique port after 1000 attempts");
+                    }
+                } while (excludeSet.has(port) || ports.includes(port));
+                ports.push(port);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Random Ports Generated:
+
+${ports.map((port, i) => `${i + 1}. ${port}`).join('\n')}
+
+Range: ${min} - ${max}
+Excluded well-known ports: ${wellKnownPorts.join(', ')}
+${exclude.length > 0 ? `Custom excluded: ${exclude.join(', ')}` : ''}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error generating random ports: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/network/scp/index.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+import os from "os";
+function resolvePrivateKey(privateKeyArg) {
+    // If not provided, try default keys
+    if (!privateKeyArg) {
+        const home = os.homedir();
+        const defaultKeys = [
+            path.join(home, '.ssh', 'id_rsa'),
+            path.join(home, '.ssh', 'id_ed25519'),
+        ];
+        for (const keyPath of defaultKeys) {
+            if (fs.existsSync(keyPath)) {
+                return fs.readFileSync(keyPath, 'utf8');
+            }
+        }
+        return undefined;
+    }
+    // If it looks like a path, try to read it
+    if (privateKeyArg.startsWith('/') ||
+        privateKeyArg.startsWith('~') ||
+        privateKeyArg.endsWith('.pem') ||
+        privateKeyArg.endsWith('.key')) {
+        let keyPath = privateKeyArg;
+        if (keyPath.startsWith('~')) {
+            keyPath = path.join(os.homedir(), keyPath.slice(1));
+        }
+        if (fs.existsSync(keyPath)) {
+            return fs.readFileSync(keyPath, 'utf8');
+        }
+        else {
+            throw new Error('Private key file not found: ' + keyPath);
+        }
+    }
+    // Otherwise, assume it's the key content
+    return privateKeyArg;
+}
+export function registerScp(server) {
+    server.tool("scp", "Copy files to or from a remote host using SFTP (SCP-like)", {
+        target: z.string().describe("Target host"),
+        user: z.string().describe("Username"),
+        direction: z.enum(["upload", "download"]).describe("Direction: upload (local to remote) or download (remote to local)"),
+        localPath: z.string().describe("Local file path (source for upload, destination for download)"),
+        remotePath: z.string().describe("Remote file path (destination for upload, source for download)"),
+        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    }, async ({ target, user, direction, localPath, remotePath, privateKey }) => {
+        try {
+            const { Client } = await import("ssh2");
+            const fs = await import("fs");
+            let resolvedKey;
+            try {
+                resolvedKey = resolvePrivateKey(privateKey);
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `SCP key error: ${err.message}` }] };
+            }
+            return await new Promise((resolve) => {
+                const conn = new Client();
+                let finished = false;
+                const finish = (msg) => {
+                    if (!finished) {
+                        finished = true;
+                        try {
+                            conn.end();
+                        }
+                        catch { }
+                        resolve({ content: [{ type: "text", text: msg }] });
+                    }
+                };
+                // Connection timeout (20s)
+                const timeout = setTimeout(() => {
+                    finish(`SCP connection timed out after 20 seconds`);
+                }, 20000);
+                conn.on("ready", () => {
+                    clearTimeout(timeout);
+                    conn.sftp((err, sftp) => {
+                        if (err) {
+                            finish(`SFTP error: ${err.message}`);
+                            return;
+                        }
+                        if (direction === "upload") {
+                            let readStream, writeStream;
+                            try {
+                                readStream = fs.createReadStream(localPath);
+                                writeStream = sftp.createWriteStream(remotePath);
+                            }
+                            catch (streamErr) {
+                                finish(`Upload failed: ${streamErr.message}`);
+                                return;
+                            }
+                            writeStream.on("close", () => finish(`Upload complete: ${localPath} → ${user}@${target}:${remotePath}`));
+                            writeStream.on("error", (err) => finish(`Upload failed: ${err.message}`));
+                            readStream.on("error", (err) => finish(`Upload failed: ${err.message}`));
+                            readStream.pipe(writeStream);
+                        }
+                        else {
+                            let readStream, writeStream;
+                            try {
+                                readStream = sftp.createReadStream(remotePath);
+                                writeStream = fs.createWriteStream(localPath);
+                            }
+                            catch (streamErr) {
+                                finish(`Download failed: ${streamErr.message}`);
+                                return;
+                            }
+                            writeStream.on("close", () => finish(`Download complete: ${user}@${target}:${remotePath} → ${localPath}`));
+                            writeStream.on("error", (err) => finish(`Download failed: ${err.message}`));
+                            readStream.on("error", (err) => finish(`Download failed: ${err.message}`));
+                            readStream.pipe(writeStream);
+                        }
+                    });
+                }).on("error", (err) => {
+                    clearTimeout(timeout);
+                    finish(`SCP connection error: ${err.message}`);
+                });
+                try {
+                    conn.connect({
+                        host: target,
+                        username: user,
+                        ...(resolvedKey ? { privateKey: resolvedKey } : {})
+                    });
+                }
+                catch (err) {
+                    clearTimeout(timeout);
+                    finish(`SCP connect threw: ${err.message}`);
+                }
+            });
+        }
+        catch (fatalErr) {
+            return { content: [{ type: "text", text: `SCP fatal error: ${fatalErr.message || fatalErr}` }] };
+        }
+    });
+}

package/build/tools/network/ssh/index.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { Client as SSHClient } from "ssh2";
+import fs from "fs";
+import path from "path";
+import os from "os";
+function resolvePrivateKey(privateKeyArg) {
+    // If not provided, try default keys
+    if (!privateKeyArg) {
+        const home = os.homedir();
+        const defaultKeys = [
+            path.join(home, '.ssh', 'id_rsa'),
+            path.join(home, '.ssh', 'id_ed25519'),
+        ];
+        for (const keyPath of defaultKeys) {
+            if (fs.existsSync(keyPath)) {
+                return fs.readFileSync(keyPath, 'utf8');
+            }
+        }
+        return undefined;
+    }
+    // If it looks like a path, try to read it
+    if (privateKeyArg.startsWith('/') ||
+        privateKeyArg.startsWith('~') ||
+        privateKeyArg.endsWith('.pem') ||
+        privateKeyArg.endsWith('.key')) {
+        let keyPath = privateKeyArg;
+        if (keyPath.startsWith('~')) {
+            keyPath = path.join(os.homedir(), keyPath.slice(1));
+        }
+        if (fs.existsSync(keyPath)) {
+            return fs.readFileSync(keyPath, 'utf8');
+        }
+        else {
+            throw new Error('Private key file not found: ' + keyPath);
+        }
+    }
+    // Otherwise, assume it's the key content
+    return privateKeyArg;
+}
+export function registerSsh(server) {
+    server.tool("ssh", "Connect to a target via SSH", {
+        target: z.string().describe("Target host"),
+        user: z.string().describe("Username"),
+        command: z.string().describe("Command to run on remote host"),
+        privateKey: z.string().optional().describe("Private key for authentication (PEM format, optional, or path to key file)")
+    }, async ({ target, user, command, privateKey }) => {
+        return new Promise((resolve) => {
+            let resolvedKey;
+            try {
+                resolvedKey = resolvePrivateKey(privateKey);
+            }
+            catch (err) {
+                resolve({ content: [{ type: "text", text: `SSH key error: ${err.message}` }] });
+                return;
+            }
+            const conn = new SSHClient();
+            let output = "";
+            conn.on("ready", () => {
+                conn.exec(command, (err, stream) => {
+                    if (err) {
+                        resolve({ content: [{ type: "text", text: `SSH error: ${err.message}` }] });
+                        conn.end();
+                        return;
+                    }
+                    stream.on("close", () => {
+                        conn.end();
+                        resolve({ content: [{ type: "text", text: output }] });
+                    }).on("data", (data) => {
+                        output += data.toString();
+                    }).stderr.on("data", (data) => {
+                        output += data.toString();
+                    });
+                });
+            }).on("error", (err) => {
+                resolve({ content: [{ type: "text", text: `SSH connection error: ${err.message}` }] });
+            }).connect({
+                host: target,
+                username: user,
+                ...(resolvedKey ? { privateKey: resolvedKey } : {})
+            });
+        });
+    });
+}

package/build/tools/network/tail/index.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import readLastLines from "read-last-lines";
+export function registerTail(server) {
+    server.tool("tail", "Display the end of a file", {
+        file: z.string().describe("File path"),
+        lines: z.number().default(10).describe("Number of lines")
+    }, async ({ file, lines }) => {
+        try {
+            const out = await readLastLines.read(file, lines);
+            return { content: [{ type: "text", text: out }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `tail failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+}

package/build/tools/network/telnet/index.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export function registerTelnet(server) {
+    server.tool("telnet", "Test TCP connectivity to a host and port", {
+        target: z.string().describe("Host to connect to"),
+        port: z.number().describe("Port number")
+    }, async ({ target, port }) => {
+        return new Promise(async (resolve) => {
+            try {
+                const net = (await import('net')).default;
+                const socket = new net.Socket();
+                let connected = false;
+                let banner = '';
+                socket.setTimeout(2000);
+                socket.connect(port, target, () => {
+                    connected = true;
+                });
+                socket.on('data', (data) => {
+                    banner += data.toString();
+                    // If we get a banner, close immediately
+                    socket.end();
+                });
+                socket.on('timeout', () => {
+                    socket.destroy();
+                    if (!connected) {
+                        resolve({ content: [{ type: "text", text: `Telnet failed: Connection timed out` }] });
+                    }
+                    else {
+                        resolve({ content: [{ type: "text", text: `Telnet to ${target}:${port} succeeded.${banner ? '\nBanner: ' + banner.trim() : ''}` }] });
+                    }
+                });
+                socket.on('error', (err) => {
+                    resolve({ content: [{ type: "text", text: `Telnet failed: ${err.message}` }] });
+                });
+                socket.on('close', (hadError) => {
+                    if (connected) {
+                        resolve({ content: [{ type: "text", text: `Telnet to ${target}:${port} succeeded.${banner ? '\nBanner: ' + banner.trim() : ''}` }] });
+                    }
+                });
+            }
+            catch (error) {
+                resolve({ content: [{ type: "text", text: `Telnet failed: ${error instanceof Error ? error.message : error}` }] });
+            }
+        });
+    });
+}

package/build/tools/network/top/index.js

@@ -0,0 +1,14 @@
+import psList from "ps-list";
+export function registerTop(server) {
+    server.tool("top", "Display system processes (snapshot)", {}, async () => {
+        try {
+            const processes = await psList();
+            const sorted = processes.sort((a, b) => (b.cpu || 0) - (a.cpu || 0)).slice(0, 10);
+            const output = sorted.map(p => `${p.pid}\t${p.name}\tCPU: ${p.cpu || 0}%\tMEM: ${p.memory || 0}`).join("\n");
+            return { content: [{ type: "text", text: output }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `top failed: ${error instanceof Error ? error.message : error}` }] };
+        }
+    });
+}