@smithery/cli 0.0.9 → 0.0.10

package/dist/utils/config.js

@@ -1,74 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const execAsync = promisify(exec);
-export const VALID_CLIENTS = ["claude"];
-function getPackageRuntime(packageName) {
-    const packageListPath = path.join(dirname(__dirname), "../packages/package-list.json");
-    if (!fs.existsSync(packageListPath)) {
-        return "node"; // Default to node if package list doesn't exist
-    }
-    const packageList = JSON.parse(fs.readFileSync(packageListPath, "utf8"));
-    const pkg = packageList.find((p) => p.name === packageName);
-    return pkg?.runtime || "node";
-}
-export function getConfigPath() {
-    if (process.platform === "win32") {
-        return path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json");
-    }
-    const configDir = path.join(os.homedir(), "Library", "Application Support", "Claude");
-    return path.join(configDir, "claude_desktop_config.json");
-}
-export function readConfig() {
-    const configPath = getConfigPath();
-    if (!fs.existsSync(configPath)) {
-        return {};
-    }
-    return JSON.parse(fs.readFileSync(configPath, "utf8"));
-}
-export function writeConfig(config) {
-    const configPath = getConfigPath();
-    const configDir = path.dirname(configPath);
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
-    }
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-export async function installMCPServer(packageName, envVars, runtime) {
-    const config = readConfig();
-    const serverName = packageName.replace(/\//g, "-");
-    const effectiveRuntime = runtime || getPackageRuntime(packageName);
-    if (!config.mcpServers) {
-        config.mcpServers = {};
-    }
-    let command = "npx";
-    if (effectiveRuntime === "python") {
-        try {
-            const { stdout } = await execAsync("which uvx");
-            command = stdout.trim();
-        }
-        catch (error) {
-            command = "uvx"; // Fallback to just 'uvx' if which fails
-        }
-    }
-    const serverConfig = {
-        runtime: effectiveRuntime,
-        env: envVars,
-        command,
-        args: effectiveRuntime === "python" ? [packageName] : ["-y", packageName],
-    };
-    config.mcpServers[serverName] = serverConfig;
-    writeConfig(config);
-}
-export function envVarsToArgs(envVars) {
-    return Object.entries(envVars).flatMap(([key, value]) => {
-        const argName = key.toLowerCase().replace(/_/g, "-");
-        return [`--${argName}`, value];
-    });
-}

package/dist/utils/display.js

@@ -1,39 +0,0 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
-export async function displayPackageDetailsWithActions(pkg) {
-    console.log(`\n${chalk.bold.cyan("Package Details:")}`);
-    console.log(chalk.bold("ID:          ") + pkg.id);
-    console.log(chalk.bold("Name:        ") + pkg.name);
-    console.log(chalk.bold("Description: ") + pkg.description);
-    console.log(chalk.bold("Vendor:      ") + pkg.vendor);
-    console.log(chalk.bold("License:     ") + pkg.license);
-    // console.log(chalk.bold('Runtime:     ') + (pkg.runtime || 'node'));
-    console.log(chalk.bold("Source:      ") + (pkg.sourceUrl || "Not available"));
-    console.log(chalk.bold("Homepage:    ") + (pkg.homepage || "Not available"));
-    console.log(chalk.bold("Status:      ") +
-        (pkg.isInstalled ? chalk.green("Installed") : "Not installed") +
-        (pkg.isVerified ? "" : chalk.yellow(" (Unverified package)")));
-    const choices = [
-        {
-            name: pkg.isInstalled
-                ? "🔄 Reinstall this package"
-                : "📦 Install this package",
-            value: "install",
-        },
-        ...(pkg.isInstalled
-            ? [{ name: "🗑️  Uninstall this package", value: "uninstall" }]
-            : []),
-        ...(pkg.sourceUrl ? [{ name: "🔗 Open source URL", value: "open" }] : []),
-        { name: "⬅️  Back to list", value: "back" },
-        { name: "❌ Exit", value: "exit" },
-    ];
-    const { action } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "action",
-            message: "What would you like to do?",
-            choices,
-        },
-    ]);
-    return action;
-}

package/dist/utils/package-actions.js

@@ -1,52 +0,0 @@
-import chalk from "chalk";
-import { displayPackageDetailsWithActions } from "./display.js";
-import { installPackage, uninstallPackage } from "./package-management.js";
-import { confirmUninstall } from "./ui.js";
-export async function handlePackageAction(pkg, action, handlers, showActionsAfter = true) {
-    switch (action) {
-        case "install":
-            console.log(chalk.cyan(`\nPreparing to install ${pkg.name}...`));
-            await installPackage(pkg);
-            pkg.isInstalled = true;
-            if (handlers.onInstall) {
-                await handlers.onInstall(pkg);
-            }
-            break;
-        case "uninstall":
-            if (await confirmUninstall(pkg.name)) {
-                await uninstallPackage(pkg.name);
-                console.log(chalk.green(`Successfully uninstalled ${pkg.name}`));
-                pkg.isInstalled = false;
-                if (handlers.onUninstall) {
-                    await handlers.onUninstall(pkg);
-                    return; // Don't show actions after uninstall if handler provided
-                }
-            }
-            else {
-                console.log("Uninstallation cancelled.");
-            }
-            break;
-        case "open":
-            if (pkg.sourceUrl) {
-                const open = (await import("open")).default;
-                await open(pkg.sourceUrl);
-                console.log(chalk.green(`\nOpened ${pkg.sourceUrl} in your browser`));
-            }
-            else {
-                console.log(chalk.yellow("\nNo source URL available for this package"));
-            }
-            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 displayPackageDetailsWithActions(pkg);
-        await handlePackageAction(pkg, nextAction, handlers);
-    }
-}

package/dist/utils/package-management.js

@@ -1,217 +0,0 @@
-import { exec } from "node:child_process";
-import inquirer from "inquirer";
-import { promisify } from "node:util";
-import { ConfigManager } from "./config-manager.js";
-import { analytics } from "./analytics.js";
-const execAsync = promisify(exec);
-async function checkAnalyticsConsent() {
-    const prefs = ConfigManager.readPreferences();
-    if (typeof prefs.allowAnalytics === "boolean") {
-        return prefs.allowAnalytics;
-    }
-    const { allowAnalytics } = await inquirer.prompt([
-        {
-            type: "confirm",
-            name: "allowAnalytics",
-            message: "Would you like to help improve @smithery/cli by sharing anonymous installation analytics?",
-            default: true,
-        },
-    ]);
-    ConfigManager.writePreferences({ ...prefs, allowAnalytics });
-    return allowAnalytics;
-}
-async function trackInstallation(packageName, client) {
-    return analytics.trackInstallation(packageName, client);
-}
-async function promptForPlaceholder(key, message) {
-    const { value } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "value",
-            message: message || `Please enter value for ${key}:`,
-            validate: (input) => (input ? true : `${key} is required`),
-        },
-    ]);
-    return value;
-}
-async function promptForEnvVars(pkg) {
-    const connection = pkg.connections?.[0];
-    if (!connection?.stdio) {
-        return undefined;
-    }
-    const envVars = {};
-    const placeholderPattern = /\${(\w+)}/;
-    // Handle env variables
-    if (connection.stdio.env) {
-        for (const [key, value] of Object.entries(connection.stdio.env)) {
-            const match = String(value).match(placeholderPattern);
-            if (!match)
-                continue;
-            const varName = match[1];
-            const existingEnvVar = process.env[key];
-            if (existingEnvVar) {
-                const { reuseExisting } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "reuseExisting",
-                        message: `Found ${key} in your environment variables. Would you like to use it?`,
-                        default: true,
-                    },
-                ]);
-                if (reuseExisting) {
-                    envVars[key] = existingEnvVar;
-                    continue;
-                }
-            }
-            envVars[key] = await promptForPlaceholder(key);
-        }
-    }
-    // Handle args placeholders
-    if (connection.stdio.args) {
-        for (let i = 0; i < connection.stdio.args.length; i++) {
-            const arg = connection.stdio.args[i];
-            const match = String(arg).match(placeholderPattern);
-            if (!match)
-                continue;
-            const varName = match[1];
-            const value = await promptForPlaceholder(varName);
-            connection.stdio.args[i] = arg.replace(placeholderPattern, value);
-        }
-    }
-    return Object.keys(envVars).length > 0 ? envVars : undefined;
-}
-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);
-    }
-}
-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;
-}
-export async function installPackage(pkg) {
-    try {
-        // Temporarily bypass UV check for Python packages
-        /* if (pkg.runtime === 'python') {
-      const hasUV = await checkUVInstalled();
-      if (!hasUV) {
-        const installed = await promptForUVInstall(inquirer);
-        if (!installed) {
-          console.log('Proceeding with installation, but uvx commands may fail...');
-        }
-      }
-    } */
-        const envVars = await promptForEnvVars(pkg);
-        // Use the connection stdio config directly
-        const connection = pkg.connections?.[0];
-        const serverConfig = {
-            command: connection.stdio.command,
-            args: connection.stdio.args,
-            env: {
-                ...(envVars || {}),
-            },
-        };
-        // Install package with client-specific configuration
-        await ConfigManager.installPackage(pkg.id, serverConfig, pkg.client);
-        console.log(`Updated ${pkg.client || "default"} configuration`);
-        if (await checkAnalyticsConsent()) {
-            await trackInstallation(pkg.id, pkg.client);
-        }
-        await promptForRestart(pkg.client);
-    }
-    catch (error) {
-        console.error("Failed to install package:", error);
-        throw error;
-    }
-}
-export async function uninstallPackage(packageName, client) {
-    try {
-        await ConfigManager.uninstallPackage(packageName);
-        console.log(`\nUninstalled ${packageName}`);
-        await promptForRestart(client);
-    }
-    catch (error) {
-        console.error("Failed to uninstall package:", error);
-        throw error;
-    }
-}

package/dist/utils/package-resolver.js

@@ -1,133 +0,0 @@
-import { ConfigManager } from "./config-manager.js";
-// import path from 'path';
-// import fs from 'fs';
-// import { dirname } from 'path';
-// import { fileURLToPath } from 'url';
-import dotenv from "dotenv";
-dotenv.config();
-export const REGISTRY_ENDPOINT = process.env.REGISTRY_ENDPOINT || "https://registry.smithery.ai";
-export function isPackageInstalled(packageName) {
-    return ConfigManager.isPackageInstalled(packageName);
-}
-export async function resolvePackages(client) {
-    try {
-        // Updated API endpoint
-        const response = await fetch(`${REGISTRY_ENDPOINT}/servers/`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch packages: ${response.statusText} (${response.status})`);
-        }
-        // Add text validation before JSON parsing
-        const text = await response.text();
-        if (!text) {
-            throw new Error("Empty response received from registry");
-        }
-        let packages;
-        try {
-            packages = JSON.parse(text);
-        }
-        catch (parseError) {
-            const errorMessage = parseError instanceof Error
-                ? parseError.message
-                : "Unknown parsing error";
-            throw new Error(`Invalid JSON response from registry: ${errorMessage}`);
-        }
-        const resolvedPackages = new Map();
-        // Add packages from registry
-        for (const pkg of packages) {
-            resolvedPackages.set(pkg.id, {
-                id: pkg.id || "",
-                name: pkg.name || "",
-                description: pkg.description || "",
-                vendor: pkg.vendor || "",
-                sourceUrl: pkg.sourceUrl || "",
-                license: pkg.license || "",
-                connections: pkg.connections || [],
-                homepage: pkg.homepage || "",
-                isInstalled: false,
-                isVerified: true,
-                client: client,
-            });
-        }
-        // Process installed packages
-        const config = ConfigManager.readConfig();
-        const installedIds = Object.keys(config.mcpServers || {});
-        const installedServers = config.mcpServers || {};
-        for (const id of installedIds) {
-            const installedServer = installedServers[id];
-            const existingPkg = resolvedPackages.get(id);
-            if (existingPkg) {
-                resolvedPackages.set(id, {
-                    ...existingPkg,
-                    isInstalled: true,
-                    client: client || existingPkg.client,
-                });
-            }
-            else {
-                resolvedPackages.set(id, {
-                    ...installedServer,
-                    id: id || "",
-                    name: id || "",
-                    description: "Local package",
-                    vendor: "Local",
-                    sourceUrl: "",
-                    license: "",
-                    connections: [],
-                    homepage: "",
-                    isInstalled: true,
-                    isVerified: false,
-                    client: client,
-                });
-            }
-        }
-        return Array.from(resolvedPackages.values());
-    }
-    catch (error) {
-        throw new Error(`Failed to resolve packages: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export async function resolvePackage(packageId, client) {
-    try {
-        // Updated API endpoint
-        const response = await fetch(`${REGISTRY_ENDPOINT}/servers/${packageId}`);
-        if (!response.ok) {
-            // Check if it's an installed package
-            const config = ConfigManager.readConfig();
-            const installedServer = config.mcpServers?.[packageId];
-            if (installedServer) {
-                return {
-                    id: packageId,
-                    name: packageId,
-                    description: "Local package",
-                    vendor: "Local",
-                    sourceUrl: "",
-                    license: "",
-                    connections: [],
-                    homepage: "",
-                    isInstalled: true,
-                    isVerified: false,
-                    client: client,
-                };
-            }
-            return null;
-        }
-        const registryPackage = await response.json();
-        const resolvedPackage = {
-            id: registryPackage.id,
-            name: registryPackage.name,
-            description: registryPackage.description,
-            vendor: registryPackage.vendor,
-            sourceUrl: registryPackage.sourceUrl,
-            license: registryPackage.license,
-            connections: registryPackage.connections,
-            homepage: registryPackage.homepage,
-            isInstalled: isPackageInstalled(registryPackage.id),
-            isVerified: true,
-            client: client,
-        };
-        return resolvedPackage;
-    }
-    catch (error) {
-        console.error("Error resolving package:", error);
-        return null;
-    }
-}

package/dist/utils/runtime-utils.js

@@ -1,37 +0,0 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-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;
-    }
-}

package/dist/utils/ui.js

@@ -1,65 +0,0 @@
-import inquirer from "inquirer";
-import fuzzy from "fuzzy";
-import chalk from "chalk";
-export function formatPackageChoice(pkg, showInstallStatus = false) {
-    const prefix = showInstallStatus ? (pkg.isInstalled ? "✓ " : "  ") : "";
-    const name = (pkg.name || "").toString();
-    const description = (pkg.description || "").toString();
-    const vendor = (pkg.vendor || "").toString();
-    const id = (pkg.id || "").toString();
-    // Adjust column widths (removed license column)
-    const nameWidth = 20;
-    const idWidth = 15;
-    const descWidth = 45; // Increased description width
-    const vendorWidth = 15;
-    // Truncation function remains the same
-    const truncateText = (text, width) => {
-        if (text.length <= width) {
-            return text.padEnd(width);
-        }
-        return `${text.slice(0, width - 3).padEnd(width - 3)}...`;
-    };
-    // Apply truncation (removed license)
-    const truncatedName = truncateText(name, nameWidth);
-    const truncatedId = truncateText(id, idWidth);
-    const truncatedDesc = truncateText(description, descWidth);
-    const truncatedVendor = truncateText(vendor, vendorWidth);
-    return {
-        name: `${prefix}${truncatedName} │ ${truncatedId} │ ${truncatedDesc} │ ${truncatedVendor}`,
-        value: pkg,
-        short: name,
-    };
-}
-export function createPackagePrompt(packages, options = {}) {
-    const choices = packages.map((pkg) => formatPackageChoice(pkg, options.showInstallStatus));
-    return {
-        type: "autocomplete",
-        name: "selectedPackage",
-        message: options.message || "Search and select a package:",
-        source: async (_answersSoFar, input) => {
-            if (!input)
-                return choices;
-            return fuzzy
-                .filter(input.toLowerCase(), choices, {
-                extract: (choice) => `${choice.value.name} ${choice.value.description} ${choice.value.vendor}`.toLowerCase(),
-            })
-                .map((result) => result.original);
-        },
-        pageSize: 10,
-    };
-}
-export async function confirmUninstall(packageName) {
-    const { confirmUninstall } = await inquirer.prompt([
-        {
-            type: "confirm",
-            name: "confirmUninstall",
-            message: `Are you sure you want to uninstall ${packageName}?`,
-            default: false,
-        },
-    ]);
-    return confirmUninstall;
-}
-export function printPackageListHeader(count, type = "all") {
-    console.log(chalk.bold.cyan(`\n📦 ${type === "installed" ? "Installed Packages" : "Available Packages"}`));
-    console.log(chalk.gray(`Found ${count} ${type === "installed" ? "installed " : ""}packages\n`));
-}