@smithery/cli 0.0.7 → 0.0.10

package/dist/install.js

@@ -1,79 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
-import { installPackage as installPkg } from "./utils/package-management.js";
-import inquirer from "inquirer";
-import chalk from "chalk";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageListPath = join(__dirname, "../packages/package-list.json");
-async function promptForRuntime() {
-    const { runtime } = await inquirer.prompt([
-        {
-            type: "list",
-            name: "runtime",
-            message: "What runtime does this package use?",
-            choices: [
-                { name: "Node.js", value: "node" },
-                { name: "Python", value: "python" },
-            ],
-        },
-    ]);
-    return runtime;
-}
-function createUnknownPackage(packageName, runtime) {
-    return {
-        id: packageName,
-        name: packageName,
-        description: "Unverified package",
-        // runtime,
-        vendor: "",
-        sourceUrl: "",
-        homepage: "",
-        license: "",
-        isInstalled: false,
-        isVerified: false,
-        connections: [
-            {
-                stdio: {
-                    command: runtime === "node" ? "npx" : "python",
-                    args: runtime === "node" ? ["-y", packageName] : ["-m", packageName],
-                    env: {},
-                },
-            },
-        ],
-    };
-}
-export async function installPackage(pkg) {
-    return installPkg(pkg);
-}
-export async function install(packageName) {
-    const packageList = JSON.parse(readFileSync(packageListPath, "utf-8"));
-    const pkg = packageList.find((p) => p.name === packageName);
-    if (!pkg) {
-        console.warn(chalk.yellow(`Package ${packageName} not found in the curated list.`));
-        const { proceedWithInstall } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "proceedWithInstall",
-                message: `Would you like to try installing ${packageName} anyway? This package hasn't been verified.`,
-                default: false,
-            },
-        ]);
-        if (proceedWithInstall) {
-            console.log(chalk.cyan(`Proceeding with installation of ${packageName}...`));
-            // Prompt for runtime for unverified packages
-            const runtime = await promptForRuntime();
-            // Create a basic package object for unverified packages
-            const unknownPkg = createUnknownPackage(packageName, runtime);
-            await installPkg(unknownPkg);
-        }
-        else {
-            console.log("Installation cancelled.");
-            process.exit(1);
-        }
-        return;
-    }
-    await installPkg(pkg);
-}

package/dist/types/analytics.js

@@ -1 +0,0 @@
-export {};

package/dist/types/index.js

@@ -1 +0,0 @@
-export * from "./package.js";

package/dist/types/package.js

@@ -1 +0,0 @@
-export {};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/analytics.js

@@ -1,44 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { ConfigManager } from "./config-manager.js";
-import { REGISTRY_ENDPOINT } from "./package-resolver.js";
-export class Analytics {
-    constructor() {
-        this.sessionId = randomUUID();
-        const prefs = ConfigManager.readPreferences();
-        if (!prefs.anonUserId) {
-            ConfigManager.writePreferences({ ...prefs, anonUserId: randomUUID() });
-        }
-    }
-    async trackInstallation(packageId, clientType) {
-        const prefs = ConfigManager.readPreferences();
-        try {
-            const event = {
-                anonUserId: prefs.anonUserId,
-                eventType: "package_installation",
-                packageId: packageId,
-                timestamp: new Date().toISOString(),
-                platform: process.platform,
-                nodeVersion: process.version,
-                sessionId: this.sessionId,
-                clientType,
-            };
-            await this.sendEvent(event);
-        }
-        catch (error) {
-            console.error("Failed to track installation:", error);
-        }
-    }
-    async sendEvent(event) {
-        const response = await fetch(`${REGISTRY_ENDPOINT}/install`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(event),
-        });
-        if (!response.ok) {
-            throw new Error(`Analytics request failed: ${response.statusText}`);
-        }
-    }
-}
-export const analytics = new Analytics();

package/dist/utils/config-manager.js

@@ -1,122 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-// biome-ignore lint/complexity/noStaticOnlyClass: <explanation>
-export class ConfigManager {
-    static getConfigPath(client) {
-        const baseDir = path.dirname(ConfigManager.configPath);
-        // Default to Claude if no client specified or if explicitly Claude
-        if (!client || client.toLowerCase() === "claude") {
-            return ConfigManager.configPath;
-        }
-        // Support for future AI clients
-        // Currently only Claude is officially supported
-        // 'jan' and others are placeholders for future integrations
-        return path.join(baseDir, "..", client, `${client.toLowerCase()}_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) {
-            console.error("Error reading config:", error);
-            return { mcpServers: {} };
-        }
-    }
-    static writeConfig(config, client) {
-        try {
-            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));
-        }
-        catch (error) {
-            console.error("Error writing config:", error);
-            throw error;
-        }
-    }
-    static readPreferences() {
-        try {
-            if (!fs.existsSync(ConfigManager.preferencesPath)) {
-                return {};
-            }
-            return JSON.parse(fs.readFileSync(ConfigManager.preferencesPath, "utf8"));
-        }
-        catch (error) {
-            return {};
-        }
-    }
-    static writePreferences(prefs) {
-        try {
-            const prefsDir = path.dirname(ConfigManager.preferencesPath);
-            if (!fs.existsSync(prefsDir)) {
-                fs.mkdirSync(prefsDir, { recursive: true });
-            }
-            fs.writeFileSync(ConfigManager.preferencesPath, JSON.stringify(prefs, null, 2));
-        }
-        catch (error) {
-            console.error("Error writing preferences:", error);
-            throw error;
-        }
-    }
-    static isPackageInstalled(id, client) {
-        const config = ConfigManager.readConfig(client);
-        return id in config.mcpServers;
-    }
-    static async installPackage(id, serverConfig, client) {
-        try {
-            const config = ConfigManager.readConfig(client);
-            config.mcpServers[id] = serverConfig;
-            ConfigManager.writeConfig(config, client);
-        }
-        catch (error) {
-            console.error("Error installing server:", error);
-            throw error;
-        }
-    }
-    static async uninstallPackage(id, client) {
-        const config = ConfigManager.readConfig(client);
-        if (!config.mcpServers[id]) {
-            console.log(`Server ${id} is not installed.`);
-            return;
-        }
-        delete config.mcpServers[id];
-        ConfigManager.writeConfig(config, client);
-    }
-    static getServerConfig(id, client) {
-        const config = ConfigManager.readConfig(client);
-        return config.mcpServers[id] || null;
-    }
-}
-(() => {
-    if (process.platform === "win32") {
-        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
-        ConfigManager.configPath = path.join(appData, "Claude", "claude_desktop_config.json");
-        ConfigManager.preferencesPath = path.join(appData, "smithery-cli", "preferences.json");
-    }
-    else if (process.platform === "darwin") {
-        // macOS
-        const homeDir = os.homedir();
-        ConfigManager.configPath = path.join(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-        ConfigManager.preferencesPath = path.join(homeDir, ".smithery-cli", "preferences.json");
-    }
-    else {
-        // Linux
-        const homeDir = os.homedir();
-        const configDir = process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
-        ConfigManager.configPath = path.join(configDir, "Claude", "claude_desktop_config.json");
-        ConfigManager.preferencesPath = path.join(homeDir, ".smithery-cli", "preferences.json");
-    }
-})();

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;
-    }
-}