@smithery/cli 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@smithery/cli",
-	"version": "1.0.5",
+	"version": "1.0.7",
 	"type": "commonjs",
 	"private": false,
 	"homepage": "https://smithery.ai/",
@@ -22,7 +22,9 @@
 	},
 	"dependencies": {
 		"@modelcontextprotocol/sdk": "^1.0.3",
+		"@smithery/sdk": "^0.0.22",
 		"chalk": "^4.1.2",
+		"eventsource": "^3.0.2",
 		"inquirer": "^8.2.4",
 		"inquirer-autocomplete-prompt": "^2.0.0"
 	},
@@ -47,5 +49,8 @@
 		".": {
 			"import": "./dist/index.js"
 		}
+	},
+	"engines": {
+		"node": ">=18.0.0"
 	}
 }

package/dist/commands/inspect.js

@@ -1,60 +0,0 @@
-import chalk from "chalk";
-import { createServerConnection, inspectServer, } from "../utils/server-inspector.js";
-import { ConfigManager } from "../utils/config-manager.js";
-import { createListChoices } from "../utils/server-display.js";
-import inquirer from "inquirer";
-import { VALID_CLIENTS } from "../constants.js";
-export async function inspect(client) {
-    try {
-        // ensure client is valid
-        if (client && !VALID_CLIENTS.includes(client)) {
-            console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
-            process.exit(1);
-        }
-        const installedIds = ConfigManager.getInstalledServerIds(client);
-        if (installedIds.length === 0) {
-            console.log(chalk.yellow("\nNo MCP servers are currently installed."));
-            return;
-        }
-        const config = ConfigManager.readConfig(client);
-        while (true) {
-            const choices = createListChoices(installedIds.map((id) => ({
-                id,
-                name: ConfigManager.denormalizeServerId(id),
-                isInstalled: true,
-                connections: [],
-            })), false, true);
-            const { selectedId } = await inquirer.prompt([
-                {
-                    type: "list",
-                    name: "selectedId",
-                    message: "Select a server to inspect:",
-                    choices,
-                },
-            ]);
-            if (selectedId === "exit") {
-                process.exit(0);
-            }
-            if (!selectedId) {
-                return;
-            }
-            console.log(chalk.blue("\nConnecting to server..."));
-            const connectionConfig = config.mcpServers[selectedId.id];
-            if ("command" in connectionConfig) {
-                const client = await createServerConnection(selectedId.id, connectionConfig);
-                const result = await inspectServer(client);
-                if (result === "exit") {
-                    process.exit(0);
-                }
-            }
-            else {
-                throw new Error("Only stdio connections are supported");
-            }
-        }
-    }
-    catch (error) {
-        console.error(chalk.red("Error during inspection:"));
-        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
-}

package/dist/commands/install.js

@@ -1,21 +0,0 @@
-import chalk from "chalk";
-import { ServerManager } from "../utils/server-manager.js";
-import { resolveServer } from "../utils/registry-utils.js";
-import { VALID_CLIENTS } from "../constants.js";
-const serverManager = new ServerManager();
-export async function install(serverId, client) {
-    // ensure client is valid
-    if (client && !VALID_CLIENTS.includes(client)) {
-        console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
-        process.exit(1);
-    }
-    // get package details and connection template
-    const server = await resolveServer(serverId, client);
-    if (!server) {
-        console.error(chalk.red(`Server '${serverId}' not found in registry`));
-        process.exit(1);
-    }
-    // install server using the serverManager instance
-    await serverManager.installServer(server, client);
-    console.log(chalk.green(`✓ Successfully installed package '${serverId}' for ${client}`));
-}

package/dist/commands/installed.js

@@ -1,50 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { fetchServers } from "../utils/registry-utils.js";
-import AutocompletePrompt from "inquirer-autocomplete-prompt";
-import { handleServerAction } from "../utils/server-actions.js";
-import { ConfigManager } from "../utils/config-manager.js";
-import { displayServerDetails, printServerListHeader, createListChoices, } from "../utils/server-display.js";
-import { VALID_CLIENTS } from "../constants.js";
-inquirer.registerPrompt("autocomplete", AutocompletePrompt);
-let installedServersCache = null;
-export async function listInstalledServers(client) {
-    // ensure client is valid
-    if (client && !VALID_CLIENTS.includes(client)) {
-        console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
-        process.exit(1);
-    }
-    const installedIds = ConfigManager.getInstalledServerIds(client);
-    if (installedIds.length === 0) {
-        console.log(chalk.yellow("\nNo MCP servers are currently installed."));
-        return;
-    }
-    const denormalizedIds = installedIds.map((id) => ConfigManager.denormalizeServerId(id));
-    if (!installedServersCache ||
-        !areArraysEqual(denormalizedIds, installedServersCache.map((server) => server.id))) {
-        installedServersCache = await fetchServers(client, denormalizedIds);
-        installedServersCache.forEach((server) => {
-            server.isInstalled = true;
-        });
-    }
-    printServerListHeader(installedServersCache.length, "installed");
-    const prompt = {
-        type: "list",
-        name: "selectedServer",
-        message: "Search and select a server:",
-        choices: createListChoices(installedServersCache, false, true),
-    };
-    const answer = await inquirer.prompt([prompt]);
-    if (!answer.selectedServer || answer.selectedServer === "exit") {
-        return;
-    }
-    const action = await displayServerDetails(answer.selectedServer);
-    await handleServerAction(answer.selectedServer, action, {
-        onUninstall: () => listInstalledServers(client),
-        onBack: () => listInstalledServers(client),
-    }, true, client);
-}
-function areArraysEqual(arr1, arr2) {
-    return (arr1.length === arr2.length &&
-        arr1.every((value, index) => value === arr2[index]));
-}

package/dist/commands/uninstall.js

@@ -1,44 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-import { ServerManager } from "../utils/server-manager.js";
-import { VALID_CLIENTS } from "../constants.js";
-const serverManager = new ServerManager();
-export async function uninstall(serverId, client) {
-    try {
-        // ensure client is valid
-        if (client && !VALID_CLIENTS.includes(client)) {
-            console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
-            process.exit(1);
-        }
-        // If no server name provided, show error
-        if (!serverId) {
-            console.error(chalk.red("Error: Server ID is required"));
-            console.log("Usage: @smithery/cli uninstall <server-id>");
-            process.exit(1);
-        }
-        // Confirm uninstallation
-        const { confirmUninstall } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "confirmUninstall",
-                message: `Are you sure you want to uninstall ${serverId}?`,
-                default: false,
-            },
-        ]);
-        if (!confirmUninstall) {
-            console.log("Uninstallation cancelled.");
-            return;
-        }
-        // Perform uninstallation
-        await serverManager.uninstallServer(serverId, client);
-        console.log(chalk.green(`\nSuccessfully uninstalled ${serverId} for ${client}`));
-        if (client === "claude") {
-            console.log(chalk.yellow("\nNote: Please restart Claude for the changes to take effect."));
-        }
-    }
-    catch (error) {
-        console.error(chalk.red("Failed to uninstall server:"));
-        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
-}

package/dist/commands/view.js

@@ -1,31 +0,0 @@
-import chalk from "chalk";
-import { resolveServer } from "../utils/registry-utils.js";
-import { handleServerAction } from "../utils/server-actions.js";
-import { displayServerDetails } from "../utils/server-display.js";
-import { VALID_CLIENTS } from "../constants.js";
-export async function get(serverId, client) {
-    try {
-        // ensure client is valid
-        if (client && !VALID_CLIENTS.includes(client)) {
-            console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
-            process.exit(1);
-        }
-        const server = await resolveServer(serverId, client);
-        if (!server) {
-            console.log(chalk.yellow(`No server found with ID: ${serverId}`));
-            return;
-        }
-        const action = await displayServerDetails(server, false);
-        await handleServerAction(server, action, {}, false, client);
-    }
-    catch (error) {
-        console.error(chalk.red("Error loading server:"));
-        if (error instanceof Error && error.message.includes("fetch")) {
-            console.error(chalk.red("Failed to connect to the registry. Please check your internet connection."));
-        }
-        else {
-            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-        }
-        process.exit(1);
-    }
-}

package/dist/constants.js

@@ -1 +0,0 @@
-export const VALID_CLIENTS = ["claude", "cline", "roo-cline"];

package/dist/types/registry.js

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,93 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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"),
-        "roo-cline": path.join(baseDir, vscodePath, "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json"),
-    };
-    ConfigManager.configPath = clientPaths.claude;
-    ConfigManager.clientPaths = clientPaths;
-})();

package/dist/utils/registry-utils.js

@@ -1,83 +0,0 @@
-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.qualifiedName,
-            name: registryServer.displayName,
-            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),
-        });
-        try {
-            const parsed = await response.json();
-            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;
-    }
-}