it-tools-mcp 3.0.24 → 3.1.0

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

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export function registerIpSubnetCalculator(server) {
+    server.tool("ip-subnet-calculator", "Calculate subnet information for IPv4", {
+        ip: z.string().describe("IPv4 address (e.g., 192.168.1.1)"),
+        cidr: z.number().describe("CIDR notation (e.g., 24)"),
+    }, async ({ ip, cidr }) => {
+        try {
+            if (cidr < 1 || cidr > 32) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "CIDR must be between 1 and 32.",
+                        },
+                    ],
+                };
+            }
+            const ipParts = ip.split('.').map(part => {
+                const num = parseInt(part);
+                if (isNaN(num) || num < 0 || num > 255) {
+                    throw new Error(`Invalid IP address part: ${part}`);
+                }
+                return num;
+            });
+            if (ipParts.length !== 4) {
+                throw new Error("Invalid IP address format");
+            }
+            // Calculate subnet mask
+            const mask = (0xFFFFFFFF << (32 - cidr)) >>> 0;
+            const maskParts = [
+                (mask >>> 24) & 0xFF,
+                (mask >>> 16) & 0xFF,
+                (mask >>> 8) & 0xFF,
+                mask & 0xFF
+            ];
+            // Calculate network address
+            const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+            const networkNum = (ipNum & mask) >>> 0;
+            const networkParts = [
+                (networkNum >>> 24) & 0xFF,
+                (networkNum >>> 16) & 0xFF,
+                (networkNum >>> 8) & 0xFF,
+                networkNum & 0xFF
+            ];
+            // Calculate broadcast address
+            const broadcastNum = (networkNum | (0xFFFFFFFF >>> cidr)) >>> 0;
+            const broadcastParts = [
+                (broadcastNum >>> 24) & 0xFF,
+                (broadcastNum >>> 16) & 0xFF,
+                (broadcastNum >>> 8) & 0xFF,
+                broadcastNum & 0xFF
+            ];
+            // Calculate first and last usable addresses
+            const firstUsableNum = networkNum + 1;
+            const lastUsableNum = broadcastNum - 1;
+            const firstUsableParts = [
+                (firstUsableNum >>> 24) & 0xFF,
+                (firstUsableNum >>> 16) & 0xFF,
+                (firstUsableNum >>> 8) & 0xFF,
+                firstUsableNum & 0xFF
+            ];
+            const lastUsableParts = [
+                (lastUsableNum >>> 24) & 0xFF,
+                (lastUsableNum >>> 16) & 0xFF,
+                (lastUsableNum >>> 8) & 0xFF,
+                lastUsableNum & 0xFF
+            ];
+            const totalHosts = Math.pow(2, 32 - cidr);
+            const usableHosts = totalHosts - 2;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `IPv4 Subnet Information:
+
+Input: ${ip}/${cidr}
+
+Network Address: ${networkParts.join('.')}
+Subnet Mask: ${maskParts.join('.')}
+Broadcast Address: ${broadcastParts.join('.')}
+First Usable: ${firstUsableParts.join('.')}
+Last Usable: ${lastUsableParts.join('.')}
+
+Total Addresses: ${totalHosts}
+Usable Addresses: ${usableHosts}
+CIDR: /${cidr}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error calculating subnet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/network/ipv4-subnet-calc/index.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+export function registerIpv4SubnetCalc(server) {
+    server.tool("ipv4-subnet-calc", "Calculate IPv4 subnet information", {
+        cidr: z.string().describe("IPv4 CIDR notation (e.g., 192.168.1.0/24)"),
+    }, async ({ cidr }) => {
+        try {
+            const [ip, prefixLength] = cidr.split('/');
+            const prefix = parseInt(prefixLength);
+            if (isNaN(prefix) || prefix < 0 || prefix > 32) {
+                throw new Error("Invalid CIDR prefix length");
+            }
+            const ipParts = ip.split('.').map(part => {
+                const num = parseInt(part);
+                if (isNaN(num) || num < 0 || num > 255) {
+                    throw new Error(`Invalid IP address part: ${part}`);
+                }
+                return num;
+            });
+            if (ipParts.length !== 4) {
+                throw new Error("Invalid IP address format");
+            }
+            // Calculate all subnet information
+            const mask = (0xFFFFFFFF << (32 - prefix)) >>> 0;
+            const inverseMask = (0xFFFFFFFF >>> prefix);
+            const maskOctets = [
+                (mask >>> 24) & 0xFF,
+                (mask >>> 16) & 0xFF,
+                (mask >>> 8) & 0xFF,
+                mask & 0xFF
+            ];
+            const wildcardOctets = [
+                inverseMask >>> 24,
+                (inverseMask >>> 16) & 0xFF,
+                (inverseMask >>> 8) & 0xFF,
+                inverseMask & 0xFF
+            ];
+            const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+            const networkNum = (ipNum & mask) >>> 0;
+            const broadcastNum = (networkNum | inverseMask) >>> 0;
+            const networkOctets = [
+                (networkNum >>> 24) & 0xFF,
+                (networkNum >>> 16) & 0xFF,
+                (networkNum >>> 8) & 0xFF,
+                networkNum & 0xFF
+            ];
+            const broadcastOctets = [
+                (broadcastNum >>> 24) & 0xFF,
+                (broadcastNum >>> 16) & 0xFF,
+                (broadcastNum >>> 8) & 0xFF,
+                broadcastNum & 0xFF
+            ];
+            const totalAddresses = Math.pow(2, 32 - prefix);
+            const usableAddresses = Math.max(0, totalAddresses - 2);
+            // Determine network class
+            let networkClass = 'Unknown';
+            const firstOctet = networkOctets[0];
+            if (firstOctet >= 1 && firstOctet <= 126)
+                networkClass = 'A';
+            else if (firstOctet >= 128 && firstOctet <= 191)
+                networkClass = 'B';
+            else if (firstOctet >= 192 && firstOctet <= 223)
+                networkClass = 'C';
+            else if (firstOctet >= 224 && firstOctet <= 239)
+                networkClass = 'D (Multicast)';
+            else if (firstOctet >= 240 && firstOctet <= 255)
+                networkClass = 'E (Reserved)';
+            // Check if private
+            const isPrivate = (firstOctet === 10) ||
+                (firstOctet === 172 && networkOctets[1] >= 16 && networkOctets[1] <= 31) ||
+                (firstOctet === 192 && networkOctets[1] === 168);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Enhanced IPv4 Subnet Calculation:
+
+Input CIDR: ${cidr}
+
+Network Information:
+Network Address: ${networkOctets.join('.')}
+Broadcast Address: ${broadcastOctets.join('.')}
+Subnet Mask: ${maskOctets.join('.')}
+Wildcard Mask: ${wildcardOctets.join('.')}
+
+Address Range:
+First Host: ${networkOctets[0]}.${networkOctets[1]}.${networkOctets[2]}.${networkOctets[3] + 1}
+Last Host: ${broadcastOctets[0]}.${broadcastOctets[1]}.${broadcastOctets[2]}.${broadcastOctets[3] - 1}
+
+Capacity:
+Total Addresses: ${totalAddresses.toLocaleString()}
+Usable Host Addresses: ${usableAddresses.toLocaleString()}
+
+Network Properties:
+Class: ${networkClass}
+Type: ${isPrivate ? 'Private' : 'Public'}
+CIDR Prefix: /${prefix}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error calculating IPv4 subnet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

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