it-tools-mcp 3.0.23 → 3.1.0

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

package/build/tools/network/url-parse/index.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export function registerUrlParse(server) {
+    server.tool("url-parse", "Parse URL into components", {
+        url: z.string().describe("URL to parse"),
+    }, async ({ url }) => {
+        try {
+            const urlObj = new URL(url);
+            // Parse query parameters
+            const params = {};
+            urlObj.searchParams.forEach((value, key) => {
+                params[key] = value;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `URL Components:
+
+Original URL: ${url}
+
+Protocol: ${urlObj.protocol}
+Host: ${urlObj.host}
+Hostname: ${urlObj.hostname}
+Port: ${urlObj.port || 'default'}
+Pathname: ${urlObj.pathname}
+Search: ${urlObj.search}
+Hash: ${urlObj.hash}
+Origin: ${urlObj.origin}
+
+Query Parameters:
+${Object.keys(params).length > 0
+                            ? Object.entries(params).map(([key, value]) => `  ${key}: ${value}`).join('\n')
+                            : '  (none)'}
+
+Path Segments:
+${urlObj.pathname.split('/').filter(segment => segment).map((segment, i) => `  ${i + 1}. ${segment}`).join('\n') || '  (none)'}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error parsing URL: ${error instanceof Error ? error.message : 'Invalid URL format'}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/build/tools/physics/angle-converter/index.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export function registerAngleConverter(server) {
+    server.tool("angle-converter", "Convert between different angle units", {
+        value: z.number().describe("Angle value to convert"),
+        fromUnit: z.enum([
+            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+        ]).describe("Source angle unit"),
+        toUnit: z.enum([
+            "degree", "radian", "gradian", "turn", "arcminute", "arcsecond"
+        ]).describe("Target angle unit")
+    }, async ({ value, fromUnit, toUnit }) => {
+        try {
+            // Conversion factors to degrees
+            const toDegrees = {
+                "degree": 1,
+                "radian": 180 / Math.PI,
+                "gradian": 0.9, // 1 gradian = 0.9 degrees
+                "turn": 360, // 1 turn = 360 degrees
+                "arcminute": 1 / 60, // 1 arcminute = 1/60 degree
+                "arcsecond": 1 / 3600 // 1 arcsecond = 1/3600 degree
+            };
+            // Convert to degrees first
+            const degrees = value * toDegrees[fromUnit];
+            // Convert from degrees to target unit
+            const result = degrees / toDegrees[toUnit];
+            const units = {
+                "degree": "°",
+                "radian": "rad",
+                "gradian": "gon",
+                "turn": "tr",
+                "arcminute": "'",
+                "arcsecond": "\""
+            };
+            // Additional conversions for context
+            const inDegrees = degrees;
+            const inRadians = degrees * Math.PI / 180;
+            const inGradians = degrees / 0.9;
+            return {
+                content: [{
+                        type: "text",
+                        text: `Angle Conversion Results:
+
+${value} ${units[fromUnit]} = ${result} ${units[toUnit]}
+
+All Conversions:
+• Degrees: ${inDegrees.toFixed(6)}°
+• Radians: ${inRadians.toFixed(6)} rad
+• Gradians: ${inGradians.toFixed(6)} gon
+• Turns: ${(inDegrees / 360).toFixed(6)} tr
+• Arcminutes: ${(inDegrees * 60).toFixed(2)}'
+• Arcseconds: ${(inDegrees * 3600).toFixed(2)}"
+
+Trigonometric Values:
+• sin: ${Math.sin(inRadians).toFixed(6)}
+• cos: ${Math.cos(inRadians).toFixed(6)}
+• tan: ${Math.tan(inRadians).toFixed(6)}
+
+Reference:
+• π rad = 180° = 200 gon = 0.5 tr
+• 1° = 60' = 3600"`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error converting angle: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/physics/energy-converter/index.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export function registerEnergyConverter(server) {
+    server.tool("energy-converter", "Convert between different energy units", {
+        value: z.number().describe("Energy value to convert"),
+        fromUnit: z.enum([
+            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+        ]).describe("Source energy unit"),
+        toUnit: z.enum([
+            "joule", "kilojoule", "calorie", "kilocalorie", "btu",
+            "watt-hour", "kilowatt-hour", "electronvolt", "foot-pound"
+        ]).describe("Target energy unit")
+    }, async ({ value, fromUnit, toUnit }) => {
+        try {
+            // Conversion factors to joules
+            const toJoules = {
+                "joule": 1,
+                "kilojoule": 1000,
+                "calorie": 4.184,
+                "kilocalorie": 4184,
+                "btu": 1055.06,
+                "watt-hour": 3600,
+                "kilowatt-hour": 3600000,
+                "electronvolt": 1.602176634e-19,
+                "foot-pound": 1.355818
+            };
+            // Convert to joules first
+            const joules = value * toJoules[fromUnit];
+            // Convert from joules to target unit
+            const result = joules / toJoules[toUnit];
+            const units = {
+                "joule": "J",
+                "kilojoule": "kJ",
+                "calorie": "cal",
+                "kilocalorie": "kcal",
+                "btu": "BTU",
+                "watt-hour": "Wh",
+                "kilowatt-hour": "kWh",
+                "electronvolt": "eV",
+                "foot-pound": "ft·lb"
+            };
+            return {
+                content: [{
+                        type: "text",
+                        text: `Energy Conversion Results:
+
+${value} ${units[fromUnit]} = ${result.toExponential(6)} ${units[toUnit]}
+
+Formatted Results:
+• Scientific: ${result.toExponential(6)} ${units[toUnit]}
+• Fixed: ${result.toFixed(6)} ${units[toUnit]}
+• Compact: ${result.toPrecision(6)} ${units[toUnit]}
+
+Intermediate (Joules): ${joules.toExponential(6)} J
+
+Common Energy Equivalents:
+• 1 kWh = 3.6 MJ = 860 kcal
+• 1 BTU = 1055 J = 252 cal
+• 1 eV = 1.602 × 10⁻¹⁹ J`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error converting energy: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/physics/power-converter/index.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export function registerPowerConverter(server) {
+    server.tool("power-converter", "Convert between different power units", {
+        value: z.number().describe("Power value to convert"),
+        fromUnit: z.enum([
+            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+        ]).describe("Source power unit"),
+        toUnit: z.enum([
+            "watt", "kilowatt", "megawatt", "horsepower", "metric-horsepower",
+            "btu-per-hour", "calorie-per-second", "foot-pound-per-second"
+        ]).describe("Target power unit")
+    }, async ({ value, fromUnit, toUnit }) => {
+        try {
+            // Conversion factors to watts
+            const toWatts = {
+                "watt": 1,
+                "kilowatt": 1000,
+                "megawatt": 1000000,
+                "horsepower": 745.7, // Mechanical horsepower
+                "metric-horsepower": 735.5,
+                "btu-per-hour": 0.293071,
+                "calorie-per-second": 4.184,
+                "foot-pound-per-second": 1.355818
+            };
+            // Convert to watts first
+            const watts = value * toWatts[fromUnit];
+            // Convert from watts to target unit
+            const result = watts / toWatts[toUnit];
+            const units = {
+                "watt": "W",
+                "kilowatt": "kW",
+                "megawatt": "MW",
+                "horsepower": "hp",
+                "metric-horsepower": "PS",
+                "btu-per-hour": "BTU/h",
+                "calorie-per-second": "cal/s",
+                "foot-pound-per-second": "ft·lb/s"
+            };
+            return {
+                content: [{
+                        type: "text",
+                        text: `Power Conversion Results:
+
+${value} ${units[fromUnit]} = ${result.toFixed(6)} ${units[toUnit]}
+
+Common Conversions:
+• Watts: ${watts.toFixed(3)} W
+• Kilowatts: ${(watts / 1000).toFixed(6)} kW
+• Horsepower: ${(watts / 745.7).toFixed(6)} hp
+• Metric HP: ${(watts / 735.5).toFixed(6)} PS
+• BTU/hour: ${(watts / 0.293071).toFixed(3)} BTU/h
+
+Energy Relationships:
+• Power × Time = Energy
+• 1 kW for 1 hour = 1 kWh = 3.6 MJ
+• 1 hp ≈ 746 W (mechanical)
+• 1 PS ≈ 736 W (metric)`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error converting power: ${error instanceof Error ? error.message : 'Unknown error'}`
+                    }]
+            };
+        }
+    });
+}

package/build/tools/text/ascii-art-text/index.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+export function registerAsciiArtText(server) {
+    server.tool("ascii-art-text", "Generate ASCII art text", {
+        text: z.string().describe("Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"),
+        font: z.string().describe("ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure.").optional(),
+    }, async ({ text, font = "standard" }) => {
+        try {
+            // Generate ASCII art using figlet
+            const figlet = await import('figlet');
+            // Get list of available fonts
+            const availableFonts = figlet.default.fontsSync();
+            // Check if user wants to list all fonts
+            if (text.toUpperCase() === 'LIST_FONTS') {
+                const sortedFonts = availableFonts.sort();
+                const popularFonts = [
+                    "Standard", "Big", "Small", "Slant", "3-D", "Banner", "Block", "Shadow",
+                    "Larry 3D", "Doom", "Star Wars", "Gothic", "Graffiti", "Bubble", "Digital"
+                ];
+                // Filter popular fonts that are actually available
+                const availablePopularFonts = popularFonts.filter(f => sortedFonts.some(availableFont => availableFont === f));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Available ASCII Art Fonts (${sortedFonts.length} total):
+
+🌟 POPULAR FONTS:
+${availablePopularFonts.join(', ')}
+
+📝 ALL AVAILABLE FONTS:
+${sortedFonts.join(', ')}
+
+💡 Usage: Use any font name above as the 'font' parameter.
+Examples: 'Standard', '3-D', 'Larry 3D', 'Banner', 'Block', etc.`,
+                        },
+                    ],
+                };
+            }
+            // Find the exact font match (case insensitive and flexible matching)
+            let targetFont = "Standard"; // Default fallback
+            const inputFont = font.toLowerCase();
+            // Direct match
+            const exactMatch = availableFonts.find(f => f.toLowerCase() === inputFont);
+            if (exactMatch) {
+                targetFont = exactMatch;
+            }
+            else {
+                // Fuzzy match - look for fonts that contain the input as substring
+                const partialMatch = availableFonts.find(f => f.toLowerCase().includes(inputFont) ||
+                    inputFont.includes(f.toLowerCase()));
+                if (partialMatch) {
+                    targetFont = partialMatch;
+                }
+            }
+            // Generate ASCII art
+            const asciiArt = figlet.default.textSync(text, {
+                font: targetFont,
+                horizontalLayout: 'default',
+                verticalLayout: 'default'
+            });
+            const fontUsed = targetFont === font ? font : `${font} → ${targetFont}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `ASCII Art (${fontUsed}):\n\n${asciiArt}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // Get available fonts for error message
+            try {
+                const figlet = await import('figlet');
+                const availableFonts = figlet.default.fontsSync();
+                const popularFonts = [
+                    "Standard", "Big", "Small", "Slant", "3-D", "Banner", "Block", "Shadow",
+                    "Larry 3D", "Doom", "Star Wars", "Gothic", "Graffiti", "Bubble", "Digital"
+                ];
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error generating ASCII art: ${error instanceof Error ? error.message : 'Unknown error'}
+
+Font '${font}' not found or invalid.
+
+Popular fonts to try: ${popularFonts.join(', ')}
+
+Total available fonts: ${availableFonts.length}
+Some examples: ${availableFonts.slice(0, 10).join(', ')}...
+
+Note: ASCII art generation works best with short text (1-10 characters).`,
+                        },
+                    ],
+                };
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error generating ASCII art: ${error instanceof Error ? error.message : 'Unknown error'}
+
+Note: ASCII art generation works best with short text (1-10 characters).`,
+                        },
+                    ],
+                };
+            }
+        }
+    });
+}