@smithery/cli 0.0.25 → 1.0.2

package/dist/types/registry.js

@@ -0,0 +1,29 @@
+/**
+ * Types for entries in the Smithery registry
+ */
+import { z } from "zod";
+export const JSONSchemaSchema = z.lazy(() => z.object({
+    type: z.string().optional(),
+    properties: z.record(JSONSchemaSchema).optional(),
+    items: JSONSchemaSchema.optional(),
+    required: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    default: z.unknown().optional(),
+}));
+export const ConnectionDetailsSchema = z.object({
+    type: z.enum(["stdio"]),
+    configSchema: JSONSchemaSchema.optional(),
+    exampleConfig: z.record(z.any()).optional(),
+});
+// stdio connection
+export const StdioConnectionSchema = z.object({
+    command: z.string().describe("The executable to run to start the server."),
+    args: z
+        .array(z.string())
+        .optional()
+        .describe("Command line arguments to pass to the executable."),
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("The environment to use when spawning the process."),
+});

package/dist/utils/client-utils.js

@@ -0,0 +1,93 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import inquirer from "inquirer";
+const execAsync = promisify(exec);
+async function isClientRunning(client) {
+    if (!client)
+        return false;
+    try {
+        const platform = process.platform;
+        // Map of supported clients to their process names
+        // Currently only Claude is officially supported
+        // Other entries are placeholders for future integrations
+        const clientProcess = {
+            claude: "Claude",
+            // jan: "Jan",  // Placeholder for future client integration
+            // Add more clients here as they become supported
+        }[client] || client;
+        if (platform === "win32") {
+            const { stdout } = await execAsync(`tasklist /FI "IMAGENAME eq ${clientProcess}.exe" /NH`);
+            return stdout.includes(`${clientProcess}.exe`);
+        }
+        else if (platform === "darwin") {
+            const { stdout } = await execAsync(`pgrep -x "${clientProcess}"`);
+            return !!stdout.trim();
+        }
+        else if (platform === "linux") {
+            const { stdout } = await execAsync(`pgrep -f "${clientProcess.toLowerCase()}"`);
+            return !!stdout.trim();
+        }
+        return false;
+    }
+    catch (error) {
+        // If the command fails, assume client is not running
+        return false;
+    }
+}
+async function restartClient(client) {
+    const clientProcess = {
+        claude: "Claude",
+        jan: "Jan",
+        // Add more clients here
+    }[client] || client;
+    try {
+        const platform = process.platform;
+        if (platform === "win32") {
+            await execAsync(`taskkill /F /IM "${clientProcess}.exe" && start "" "${clientProcess}.exe"`);
+        }
+        else if (platform === "darwin") {
+            await execAsync(`killall "${clientProcess}" && open -a "${clientProcess}"`);
+        }
+        else if (platform === "linux") {
+            await execAsync(`pkill -f "${clientProcess.toLowerCase()}" && ${clientProcess.toLowerCase()}`);
+        }
+        // Wait a moment for the app to close before reopening
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        // Reopen the app
+        if (platform === "win32") {
+            await execAsync(`start "" "${clientProcess}.exe"`);
+        }
+        else if (platform === "darwin") {
+            await execAsync(`open -a "${clientProcess}"`);
+        }
+        else if (platform === "linux") {
+            await execAsync(clientProcess.toLowerCase());
+        }
+        console.log(`${clientProcess} has been restarted.`);
+    }
+    catch (error) {
+        console.error(`Failed to restart ${clientProcess}:`, error);
+    }
+}
+export async function promptForRestart(client) {
+    if (!client)
+        return false;
+    // Check if client is running first
+    const isRunning = await isClientRunning(client);
+    if (!isRunning) {
+        return false;
+    }
+    const { shouldRestart } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "shouldRestart",
+            message: `Would you like to restart the ${client} app to apply changes?`,
+            default: true,
+        },
+    ]);
+    if (shouldRestart) {
+        console.log(`Restarting ${client} app...`);
+        await restartClient(client);
+    }
+    return shouldRestart;
+}

package/dist/utils/config-manager.js

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
+export class ConfigManager {
+    static getConfigPath(client) {
+        const normalizedClient = client?.toLowerCase() || "claude";
+        return ConfigManager.clientPaths[normalizedClient] || path.join(path.dirname(ConfigManager.configPath), "..", client || "claude", `${normalizedClient}_config.json`);
+    }
+    static readConfig(client) {
+        try {
+            const configPath = ConfigManager.getConfigPath(client);
+            if (!fs.existsSync(configPath)) {
+                return { mcpServers: {} };
+            }
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            return {
+                mcpServers: rawConfig.mcpServers || {},
+            };
+        }
+        catch (error) {
+            return { mcpServers: {} };
+        }
+    }
+    static writeConfig(config, client) {
+        const configPath = ConfigManager.getConfigPath(client);
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== "object") {
+            throw new Error("Invalid config structure");
+        }
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    static isServerInstalled(id, client) {
+        const config = ConfigManager.readConfig(client);
+        const normalizedId = ConfigManager.normalizeServerId(id);
+        return normalizedId in config.mcpServers;
+    }
+    static async installServer(id, serverConfig, client) {
+        const normalizedId = ConfigManager.normalizeServerId(id);
+        const config = ConfigManager.readConfig(client);
+        config.mcpServers[normalizedId] = serverConfig;
+        ConfigManager.writeConfig(config, client);
+    }
+    static async uninstallServer(id, client) {
+        const normalizedId = ConfigManager.normalizeServerId(id);
+        const config = ConfigManager.readConfig(client);
+        if (!config.mcpServers[normalizedId]) {
+            console.log(`Server ${normalizedId} not found in configuration`);
+            return;
+        }
+        delete config.mcpServers[normalizedId];
+        ConfigManager.writeConfig(config, client);
+    }
+    static getServerConfig(id, client) {
+        const config = ConfigManager.readConfig(client);
+        return config.mcpServers[id] || null;
+    }
+    static envVarsToArgs(envVars) {
+        return Object.entries(envVars).flatMap(([key, value]) => {
+            const argName = key.toLowerCase().replace(/_/g, "-");
+            return [`--${argName}`, value];
+        });
+    }
+    static normalizeServerId(serverId) {
+        if (serverId.startsWith("@")) {
+            const firstSlashIndex = serverId.indexOf("/");
+            if (firstSlashIndex !== -1) {
+                return `${serverId.substring(0, firstSlashIndex)}-${serverId.substring(firstSlashIndex + 1)}`;
+            }
+        }
+        return serverId;
+    }
+    static denormalizeServerId(normalizedId) {
+        if (normalizedId.startsWith("@")) {
+            const dashIndex = normalizedId.indexOf("-");
+            if (dashIndex !== -1) {
+                return `${normalizedId.substring(0, dashIndex)}/${normalizedId.substring(dashIndex + 1)}`;
+            }
+        }
+        return normalizedId;
+    }
+    // get locally installed servers
+    static getInstalledServerIds(client) {
+        const config = ConfigManager.readConfig(client);
+        const ids = Object.keys(config.mcpServers || {});
+        return ids;
+    }
+}
+(() => {
+    const homeDir = os.homedir();
+    // Define platform-specific base directories
+    const platformPaths = {
+        win32: {
+            baseDir: process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+            vscodePath: path.join("Code", "User", "globalStorage")
+        },
+        darwin: {
+            baseDir: path.join(homeDir, "Library", "Application Support"),
+            vscodePath: path.join("Code", "User", "globalStorage")
+        },
+        linux: {
+            baseDir: process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"),
+            vscodePath: path.join("Code/User/globalStorage")
+        }
+    };
+    const platform = process.platform;
+    const { baseDir, vscodePath } = platformPaths[platform];
+    // Define client paths using the platform-specific base directories
+    const clientPaths = {
+        claude: path.join(baseDir, "Claude", "claude_desktop_config.json"),
+        cline: path.join(baseDir, vscodePath, "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+    };
+    ConfigManager.configPath = clientPaths.claude;
+    ConfigManager.clientPaths = clientPaths;
+})();

package/dist/utils/registry-utils.js

@@ -0,0 +1,87 @@
+import dotenv from "dotenv";
+import { ConfigManager } from "./config-manager.js";
+dotenv.config();
+export const REGISTRY_ENDPOINT = process.env.REGISTRY_ENDPOINT || "https://registry.smithery.ai";
+export async function fetchServers(client, serverIds = []) {
+    try {
+        if (serverIds.length === 0) {
+            return [];
+        }
+        // Fetch all servers in parallel
+        const serverPromises = serverIds.map((id) => resolveServer(id, client));
+        const resolvedServers = await Promise.all(serverPromises);
+        // Filter out null results
+        return resolvedServers.filter((server) => server !== null);
+    }
+    catch (error) {
+        throw new Error(`Failed to resolve servers: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// Resolves a single servers by ID from registry or local installation
+// Returns null if server cannot be found in either location
+export async function resolveServer(serverId, client) {
+    try {
+        // Check if server is installed first
+        // const config = ConfigManager.readConfig()
+        const isInstalled = ConfigManager.isServerInstalled(serverId, client);
+        const response = await fetch(`${REGISTRY_ENDPOINT}/servers/${serverId}`);
+        if (!response.ok) {
+            // If server is installed but not in registry, return basic info
+            if (isInstalled) {
+                return {
+                    id: serverId,
+                    name: serverId,
+                    connections: [],
+                    isInstalled: true,
+                    client: client,
+                };
+            }
+            return null;
+        }
+        const registryServer = await response.json();
+        const resolvedServer = {
+            id: registryServer.id,
+            name: registryServer.name,
+            connections: registryServer.connections,
+            isInstalled: isInstalled, // Use the checked installation status
+            client: client,
+        };
+        return resolvedServer;
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function getServerConfiguration(serverId, configValues, connectionType = "stdio") {
+    try {
+        const requestBody = {
+            connectionType,
+            config: configValues,
+        };
+        const response = await fetch(`${REGISTRY_ENDPOINT}/servers/${serverId}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        const text = await response.text();
+        if (!text) {
+            throw new Error("Empty response received from registry");
+        }
+        try {
+            const parsed = JSON.parse(text);
+            return parsed.result;
+        }
+        catch (parseError) {
+            const errorMessage = parseError instanceof Error
+                ? parseError.message
+                : "Unknown parsing error";
+            throw new Error(`Invalid JSON response from registry: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        console.error("Error getting server configuration:", error);
+        return null;
+    }
+}

package/dist/utils/runtime-utils.js

@@ -0,0 +1,141 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import inquirer from "inquirer";
+import chalk from "chalk";
+const execAsync = promisify(exec);
+export async function checkUVInstalled() {
+    try {
+        await execAsync("uvx --version");
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+export async function promptForUVInstall(inquirerInstance) {
+    const { shouldInstall } = await inquirerInstance.prompt([
+        {
+            type: "confirm",
+            name: "shouldInstall",
+            message: "UV package manager is required for Python MCP servers. Would you like to install it?",
+            default: true,
+        },
+    ]);
+    if (!shouldInstall) {
+        console.warn(chalk.yellow("UV installation was declined. You can install it manually from https://astral.sh/uv"));
+        return false;
+    }
+    console.log("Installing uv package manager...");
+    try {
+        await execAsync("curl -LsSf https://astral.sh/uv/install.sh | sh");
+        console.log(chalk.green("✓ UV installed successfully"));
+        return true;
+    }
+    catch (error) {
+        console.warn(chalk.yellow("Failed to install UV. You can install it manually from https://astral.sh/uv"));
+        return false;
+    }
+}
+export async function collectConfigValues(connection) {
+    const promptsMap = new Map();
+    // Process config schema if it exists
+    if (connection.configSchema?.properties) {
+        const required = new Set(connection.configSchema.required || []);
+        Object.entries(connection.configSchema.properties).forEach(([key, prop]) => {
+            const schemaProp = prop;
+            promptsMap.set(key, {
+                key,
+                description: schemaProp.description || `Enter value for ${key}`,
+                required: required.has(key),
+                default: schemaProp.default,
+                type: schemaProp.type,
+            });
+        });
+    }
+    const configValues = {};
+    function convertValueToType(value, type) {
+        if (!type)
+            return value;
+        // Handle empty string inputs
+        if (value === "") {
+            switch (type) {
+                case "array":
+                    return [];
+                case "number":
+                case "integer":
+                    return null;
+                default:
+                    return value;
+            }
+        }
+        if (!value)
+            return value;
+        switch (type) {
+            case "boolean":
+                return String(value).toLowerCase() === "true";
+            case "number":
+                return Number(value);
+            case "integer":
+                return Number.parseInt(String(value), 10);
+            case "array":
+                // Parse comma-separated string into array
+                return String(value)
+                    .split(",")
+                    .map((item) => item.trim())
+                    .filter((item) => item !== ""); // Remove empty items
+            default:
+                return value;
+        }
+    }
+    // Iterate through each configuration prompt
+    for (const prompt of promptsMap.values()) {
+        // If env var exists and setting is optional, ask if user wants to reuse it
+        if (process.env[prompt.key] && !prompt.required) {
+            const { reuseExisting } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "reuseExisting",
+                    message: `Found ${prompt.key} in environment. Use it?`,
+                    default: true,
+                },
+            ]);
+            if (reuseExisting) {
+                configValues[prompt.key] = convertValueToType(process.env[prompt.key], prompt.type);
+                continue;
+            }
+        }
+        const requiredText = prompt.required
+            ? chalk.red(" (required)")
+            : chalk.gray(" (optional)");
+        const promptType = prompt.key.toLowerCase().includes("key")
+            ? "password" // Use password type for any field containing 'key'
+            : prompt.type === "boolean"
+                ? "confirm"
+                : prompt.type === "array"
+                    ? "input"
+                    : prompt.type === "number" || prompt.type === "integer"
+                        ? "number"
+                        : "input";
+        const { value } = await inquirer.prompt([
+            {
+                type: promptType,
+                name: "value",
+                message: `${prompt.description}${requiredText}${prompt.type === "array" ? " (comma-separated)" : ""}`,
+                default: prompt.default,
+                mask: promptType === "password" ? "*" : undefined, // Add masking for password fields
+                validate: (input) => {
+                    if (prompt.required && !input)
+                        return false;
+                    if (prompt.type === "number" || prompt.type === "integer") {
+                        return !Number.isNaN(Number(input)) || "Please enter a valid number";
+                    }
+                    return true;
+                },
+            },
+        ]);
+        if (value !== undefined || prompt.default !== undefined) {
+            configValues[prompt.key] = convertValueToType(value ?? prompt.default, prompt.type);
+        }
+    }
+    return configValues;
+}

package/dist/utils/server-actions.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import { ServerManager } from "./server-manager.js";
+import { displayServerDetails, confirmUninstall } from "./server-display.js";
+const serverManager = new ServerManager();
+export async function handleServerAction(server, action, handlers, showActionsAfter = true, client = "claude") {
+    switch (action) {
+        case "install":
+            console.log(chalk.cyan(`\nPreparing to install ${server.name}...`));
+            await serverManager.installServer(server, client);
+            server.isInstalled = true;
+            if (handlers.onInstall) {
+                await handlers.onInstall(server);
+            }
+            console.log(chalk.green(`\nSuccessfully installed ${server.name}`));
+            return; // Exit after successful installation
+        case "uninstall":
+            if (await confirmUninstall(server.name)) {
+                await serverManager.uninstallServer(server.id, client);
+                console.log(chalk.green(`Successfully uninstalled ${server.name}`));
+                server.isInstalled = false;
+                if (handlers.onUninstall) {
+                    await handlers.onUninstall(server);
+                }
+                return; // Exit after successful uninstallation
+            }
+            else {
+                console.log("Uninstallation cancelled.");
+            }
+            break;
+        case "back":
+            if (handlers.onBack) {
+                await handlers.onBack();
+            }
+            return;
+        case "exit":
+            process.exit(0);
+    }
+    // Show actions again after completing an action (except for exit/back)
+    if (showActionsAfter) {
+        const nextAction = await displayServerDetails(server);
+        await handleServerAction(server, nextAction, handlers, showActionsAfter, client);
+    }
+}

package/dist/utils/server-display.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+export function formatServerChoice(server, showInstallStatus = false) {
+    const prefix = showInstallStatus ? (server.isInstalled ? "✓ " : "  ") : "";
+    return {
+        name: `${prefix}${server.name} | ${server.id}`,
+        value: server,
+        short: server.name,
+    };
+}
+export function createListChoices(servers, includeBack = true, includeExit = true) {
+    const choices = servers.map((server) => formatServerChoice(server, true));
+    if (includeBack || includeExit) {
+        choices.push(new inquirer.Separator());
+    }
+    if (includeBack) {
+        choices.push({
+            name: chalk.yellow("↩ Back"),
+            value: "back",
+            short: "Back",
+        });
+    }
+    if (includeExit) {
+        choices.push({
+            name: chalk.red("✖ Exit"),
+            value: "exit",
+            short: "Exit",
+        });
+    }
+    return choices;
+}
+export function printServerListHeader(count, type = "all") {
+    console.log(chalk.bold.cyan(`\n📦 ${type === "installed" ? "Installed Servers" : "Available Servers"}`));
+    console.log(chalk.gray(`Found ${count} ${type === "installed" ? "installed " : ""}servers\n`));
+}
+export async function displayServerDetails(server, includeBack = true) {
+    console.log(`\n${chalk.bold.cyan("Server Details:")}`);
+    console.log(chalk.bold("ID:          ") + server.id);
+    console.log(chalk.bold("Name:        ") + server.name);
+    const choices = [
+        {
+            name: server.isInstalled
+                ? chalk.yellow("🔄 Reinstall this server")
+                : chalk.yellow("📦 Install this server"),
+            value: "install",
+        },
+        ...(server.isInstalled
+            ? [
+                {
+                    name: chalk.yellow("🗑️  Uninstall this server"),
+                    value: "uninstall",
+                },
+            ]
+            : []),
+        ...(includeBack
+            ? [{ name: chalk.yellow("↩ Back to list"), value: "back" }]
+            : []),
+        { name: chalk.red("✖ Exit"), value: "exit" },
+    ];
+    const { action } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "action",
+            message: "What would you like to do?",
+            choices,
+        },
+    ]);
+    return action;
+}
+export async function confirmUninstall(serverName) {
+    const { confirm } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirm",
+            message: `Are you sure you want to uninstall ${serverName}?`,
+            default: false,
+        },
+    ]);
+    return confirm;
+}