@smithery/cli 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Michael Latman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,47 @@
+# smithery/get
+
+A lightweight registry and package manager for Model Context Protocol (MCP) servers, designed to be client-agnostic.
+
+## Development
+
+This guide will help you get started with developing for @smithery/cli.
+
+### Getting Started
+
+#### Initial Setup
+
+1. Clone the repository:
+```bash
+git clone git@github.com:smithery-ai/cli.git
+cd smithery-get
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Build the project:
+```bash
+npm run build
+```
+
+### Testing Locally
+
+To test the CLI tool locally:
+```bash
+npx .
+```
+
+### Common Commands
+
+Note: yet to fix 'npx . list' to list all packages
+
+Test specific functionality:
+```bash
+# Get details about a specific package
+npx . get <package-id>
+
+# Install a package
+npx . install <package-name>
+```

package/dist/auto-update.js

@@ -0,0 +1,33 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+const execAsync = promisify(exec);
+async function getCurrentVersion() {
+    const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+    return packageJson.version;
+}
+async function getLatestVersion() {
+    const { stdout } = await execAsync("npm show @smithery/cli version");
+    return stdout.trim();
+}
+export async function updatePackage() {
+    try {
+        const currentVersion = await getCurrentVersion();
+        const latestVersion = await getLatestVersion();
+        if (currentVersion !== latestVersion) {
+            console.log(chalk.yellow(`\nA new version of @smithery/cli is available: ${latestVersion} (current: ${currentVersion})`));
+            console.log(chalk.cyan("Installing update..."));
+            // Use npx to ensure we get the latest version
+            await execAsync("npx --yes @smithery/cli@latest");
+            console.log(chalk.green("✓ Update complete\n"));
+            // Exit after update to ensure the new version is used
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        // Log update check failure but continue with execution
+        console.log(chalk.yellow("\nFailed to check for updates. Continuing with current version."));
+    }
+}

package/dist/commands/get.js

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+import { displayPackageDetailsWithActions } from "../utils/display.js";
+import { resolvePackage } from "../utils/package-resolver.js";
+import { handlePackageAction } from "../utils/package-actions.js";
+export async function get(packageId) {
+    try {
+        const pkg = await resolvePackage(packageId);
+        if (!pkg) {
+            console.log(chalk.yellow(`No package found with ID: ${packageId}`));
+            return;
+        }
+        const action = await displayPackageDetailsWithActions(pkg);
+        await handlePackageAction(pkg, action, {});
+    }
+    catch (error) {
+        console.error(chalk.red("Error loading package:"));
+        if (error instanceof Error && error.message.includes("fetch")) {
+            console.error(chalk.red("Failed to connect to the package registry. Please check your internet connection."));
+        }
+        else {
+            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/install.js

@@ -0,0 +1,70 @@
+import { installPackage as installPkg } from "../utils/package-management.js";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { resolvePackage } from "../utils/package-resolver.js";
+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(id, runtime) {
+    return {
+        id,
+        name: id,
+        description: "Unverified package",
+        // runtime,
+        vendor: "",
+        sourceUrl: "",
+        homepage: "",
+        license: "",
+        isInstalled: false,
+        isVerified: false,
+        connections: [
+            {
+                stdio: {
+                    command: runtime === "node" ? "npx" : "python",
+                    args: runtime === "node" ? ["-y", id] : ["-m", id],
+                    env: {},
+                },
+            },
+        ],
+    };
+}
+export async function installPackage(pkg) {
+    return installPkg(pkg);
+}
+export async function install(packageId) {
+    const pkg = await resolvePackage(packageId);
+    if (!pkg) {
+        console.warn(chalk.yellow(`Package ${packageId} not found in the curated list.`));
+        const { proceedWithInstall } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "proceedWithInstall",
+                message: `Would you like to try installing ${packageId} anyway? This package hasn't been verified.`,
+                default: false,
+            },
+        ]);
+        if (proceedWithInstall) {
+            console.log(chalk.cyan(`Proceeding with installation of ${packageId}...`));
+            const runtime = await promptForRuntime();
+            const unknownPkg = createUnknownPackage(packageId, runtime);
+            await installPkg(unknownPkg);
+        }
+        else {
+            console.log("Installation cancelled.");
+            process.exit(1);
+        }
+        return;
+    }
+    await installPkg(pkg);
+}

package/dist/commands/installed.js

@@ -0,0 +1,31 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { displayPackageDetailsWithActions } from "../utils/display.js";
+import { resolvePackages } from "../utils/package-resolver.js";
+import AutocompletePrompt from "inquirer-autocomplete-prompt";
+import { createPackagePrompt, printPackageListHeader } from "../utils/ui.js";
+import { handlePackageAction } from "../utils/package-actions.js";
+inquirer.registerPrompt("autocomplete", AutocompletePrompt);
+export async function listInstalledPackages() {
+    const allPackages = await resolvePackages();
+    const installedPackages = allPackages.filter((pkg) => pkg.isInstalled);
+    if (installedPackages.length === 0) {
+        console.log(chalk.yellow("\nNo MCP servers are currently installed."));
+        return;
+    }
+    printPackageListHeader(installedPackages.length, "installed");
+    const prompt = createPackagePrompt(installedPackages, {
+        message: "Search and select a package:",
+    });
+    const answer = await inquirer.prompt([
+        prompt,
+    ]);
+    if (!answer.selectedPackage) {
+        return;
+    }
+    const action = await displayPackageDetailsWithActions(answer.selectedPackage);
+    await handlePackageAction(answer.selectedPackage, action, {
+        onUninstall: () => listInstalledPackages(),
+        onBack: listInstalledPackages,
+    });
+}

package/dist/commands/list.js

@@ -0,0 +1,45 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { displayPackageDetailsWithActions } from "../utils/display.js";
+import { resolvePackages } from "../utils/package-resolver.js";
+import AutocompletePrompt from "inquirer-autocomplete-prompt";
+import { createPackagePrompt, printPackageListHeader } from "../utils/ui.js";
+import { handlePackageAction } from "../utils/package-actions.js";
+// Register the autocomplete prompt
+inquirer.registerPrompt("autocomplete", AutocompletePrompt);
+export async function list() {
+    try {
+        const packages = await resolvePackages();
+        // Add validation check for packages
+        if (!Array.isArray(packages)) {
+            throw new Error("Invalid package list returned");
+        }
+        // Add validation to ensure each package has the required properties
+        if (packages.some((pkg) => !pkg || typeof pkg.id !== "string")) {
+            throw new Error("Invalid package format: each package must have an id property");
+        }
+        printPackageListHeader(packages.length);
+        // Only proceed if we have packages to display
+        if (packages.length === 0) {
+            console.log(chalk.yellow("No packages found."));
+            return;
+        }
+        const prompt = createPackagePrompt(packages, { showInstallStatus: true });
+        const answer = await inquirer.prompt([
+            prompt,
+        ]);
+        // Validate the selected package
+        if (!answer?.selectedPackage) {
+            return;
+        }
+        const action = await displayPackageDetailsWithActions(answer.selectedPackage);
+        await handlePackageAction(answer.selectedPackage, action, {
+            onBack: list,
+        });
+    }
+    catch (error) {
+        console.error(chalk.red("Error loading package list:"));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { resolvePackage } from "../utils/package-resolver.js";
+import { uninstallPackage } from "../utils/package-management.js";
+export async function uninstall(packageName) {
+    console.error("!");
+    try {
+        // If no package name provided, show error
+        if (!packageName) {
+            console.error(chalk.red("Error: Package name is required"));
+            console.log("Usage: @smithery/cli uninstall <package-name>");
+            process.exit(1);
+        }
+        // Resolve the package
+        const pkg = await resolvePackage(packageName);
+        if (!pkg) {
+            console.log(chalk.yellow(`Package ${packageName} not found.`));
+            return;
+        }
+        if (!pkg.isInstalled) {
+            console.log(chalk.yellow(`Package ${packageName} is not installed.`));
+            return;
+        }
+        // Confirm uninstallation
+        const { confirmUninstall } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmUninstall",
+                message: `Are you sure you want to uninstall ${packageName}?`,
+                default: false,
+            },
+        ]);
+        if (!confirmUninstall) {
+            console.log("Uninstallation cancelled.");
+            return;
+        }
+        // Perform uninstallation
+        await uninstallPackage(packageName);
+        console.log(chalk.green(`\nSuccessfully uninstalled ${packageName}`));
+        console.log(chalk.yellow("\nNote: Please restart Claude for the changes to take effect."));
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to uninstall package:"));
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}

package/dist/extractors/modelcontextprotocol-extractor.js

@@ -0,0 +1,209 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import * as TOML from '@iarna/toml';
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const REPOS = [
+    {
+        url: 'https://github.com/modelcontextprotocol/servers.git',
+        branch: 'main',
+        packagePath: 'src',
+        runtime: 'mixed'
+    },
+    {
+        url: 'https://github.com/mcp-get/community-servers.git',
+        branch: 'main',
+        packagePath: 'src',
+        runtime: 'mixed'
+    }
+];
+async function cloneRepo(config, tempDir) {
+    const repoDir = path.join(tempDir, path.basename(config.url, '.git'));
+    console.log(`Cloning ${config.url} into ${repoDir}...`);
+    await execAsync(`git clone --depth 1 --branch ${config.branch} ${config.url} ${repoDir}`, { cwd: tempDir });
+    return;
+}
+async function extractNodePackage(packageJsonPath, repoUrl, subPath) {
+    try {
+        const packageData = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const repoPath = `${repoUrl}/blob/main/${subPath}`;
+        return {
+            name: packageData.name || '',
+            description: packageData.description || '',
+            vendor: packageData.author || '',
+            sourceUrl: repoPath,
+            homepage: packageData.homepage || '',
+            license: packageData.license || '',
+            runtime: 'node'
+        };
+    }
+    catch (error) {
+        console.error(`Error extracting Node package from ${packageJsonPath}:`, error);
+        return null;
+    }
+}
+async function extractPythonPackage(pyprojectPath, repoUrl, subPath) {
+    try {
+        const pyprojectContent = fs.readFileSync(pyprojectPath, 'utf8');
+        const pyproject = TOML.parse(pyprojectContent);
+        if (!pyproject.project) {
+            console.error(`No [project] section found in ${pyprojectPath}`);
+            return null;
+        }
+        const { project } = pyproject;
+        // Set vendor to Anthropic
+        const vendor = 'Anthropic, PBC (https://anthropic.com)';
+        // Set license to MIT
+        const license = 'MIT';
+        return {
+            name: project.name || '',
+            description: project.description || '',
+            vendor,
+            sourceUrl: `${repoUrl}/blob/main/${subPath}`,
+            homepage: project.homepage || project.repository || repoUrl,
+            license,
+            runtime: 'python'
+        };
+    }
+    catch (error) {
+        console.error(`Error extracting Python package from ${pyprojectPath}:`, error);
+        return null;
+    }
+}
+export async function extractPackageInfo() {
+    const tempDir = path.join(__dirname, '../../temp');
+    const outputPath = path.join(__dirname, '../../packages/package-list.json');
+    const commitMsgPath = path.join(__dirname, '../../temp/commit-msg.txt');
+    console.log("Starting package extraction...");
+    try {
+        // Load existing packages
+        let existingPackages = [];
+        if (fs.existsSync(outputPath)) {
+            existingPackages = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+        }
+        // Create temp directory if it doesn't exist
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        // Initialize commit message
+        let commitMsg = "chore(packages): update MCP package list\n\nChanges:\n";
+        let changes = [];
+        // Process each repository
+        const newPackages = [];
+        for (const repo of REPOS) {
+            await cloneRepo(repo, tempDir);
+            const repoDir = path.join(tempDir, path.basename(repo.url, '.git'));
+            const packagePath = path.join(repoDir, repo.packagePath);
+            if (!fs.existsSync(packagePath))
+                continue;
+            const dirs = fs.readdirSync(packagePath);
+            for (const dir of dirs) {
+                const fullPath = path.join(packagePath, dir);
+                if (!fs.statSync(fullPath).isDirectory())
+                    continue;
+                // Try to extract as Node.js package
+                const packageJsonPath = path.join(fullPath, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    const nodePackage = await extractNodePackage(packageJsonPath, repo.url.replace('.git', ''), path.join(repo.packagePath, dir));
+                    if (nodePackage) {
+                        newPackages.push(nodePackage);
+                        continue;
+                    }
+                }
+                // Try to extract as Python package
+                const pyprojectPath = path.join(fullPath, 'pyproject.toml');
+                if (fs.existsSync(pyprojectPath)) {
+                    const pythonPackage = await extractPythonPackage(pyprojectPath, repo.url.replace('.git', ''), path.join(repo.packagePath, dir));
+                    if (pythonPackage) {
+                        newPackages.push(pythonPackage);
+                    }
+                }
+            }
+        }
+        // Merge existing and new packages
+        const mergedPackages = [...existingPackages];
+        let hasChanges = false;
+        for (const newPkg of newPackages) {
+            const existingIndex = mergedPackages.findIndex(pkg => pkg.name === newPkg.name);
+            if (existingIndex >= 0) {
+                // Update existing package if there are changes
+                if (JSON.stringify(mergedPackages[existingIndex]) !== JSON.stringify(newPkg)) {
+                    const oldPkg = mergedPackages[existingIndex];
+                    mergedPackages[existingIndex] = newPkg;
+                    hasChanges = true;
+                    console.log(`Updated package: ${newPkg.name}`);
+                    // Add detailed change information
+                    const changeDetails = [];
+                    if (oldPkg.description !== newPkg.description)
+                        changeDetails.push('description');
+                    if (oldPkg.vendor !== newPkg.vendor)
+                        changeDetails.push('vendor');
+                    if (oldPkg.license !== newPkg.license)
+                        changeDetails.push('license');
+                    if (oldPkg.homepage !== newPkg.homepage)
+                        changeDetails.push('homepage');
+                    if (oldPkg.sourceUrl !== newPkg.sourceUrl)
+                        changeDetails.push('sourceUrl');
+                    if (oldPkg.runtime !== newPkg.runtime)
+                        changeDetails.push('runtime');
+                    changes.push(`- Updated ${newPkg.name} (changed: ${changeDetails.join(', ')})`);
+                }
+            }
+            else {
+                // Add new package
+                mergedPackages.push(newPkg);
+                hasChanges = true;
+                console.log(`Added new package: ${newPkg.name} (${newPkg.runtime})`);
+                changes.push(`- Added new package: ${newPkg.name} (${newPkg.runtime})`);
+            }
+        }
+        // Write updated packages to file if there are changes
+        if (hasChanges) {
+            fs.writeFileSync(outputPath, JSON.stringify(mergedPackages, null, 2));
+            console.log('Package list updated successfully');
+            // Write commit message with total number of changes
+            if (changes.length === 0) {
+                changes.push('- Initial package list creation');
+            }
+            commitMsg = `chore(packages): update MCP package list (${changes.length} packages)\n\nChanges:\n`;
+            commitMsg += changes.join('\n');
+            fs.writeFileSync(commitMsgPath, commitMsg);
+            console.log('Commit message generated');
+        }
+        else {
+            console.log('No changes detected in package list');
+        }
+        // Cleanup (but keep commit-msg.txt if it exists)
+        const filesToKeep = new Set(['commit-msg.txt']);
+        for (const file of fs.readdirSync(tempDir)) {
+            if (!filesToKeep.has(file)) {
+                const filePath = path.join(tempDir, file);
+                fs.rmSync(filePath, { recursive: true, force: true });
+            }
+        }
+        console.log('Temporary files cleaned up');
+        return mergedPackages;
+    }
+    catch (error) {
+        console.error('Error:', error);
+        // Cleanup on error
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        throw error;
+    }
+}
+// Run the function if this file is executed directly
+if (import.meta.url === `file://${__filename}`) {
+    extractPackageInfo()
+        .then(() => console.log('Package extraction completed'))
+        .catch(error => {
+        console.error('Failed to extract packages:', error);
+        process.exit(1);
+    });
+}

package/dist/helpers/index.js

@@ -0,0 +1,94 @@
+export const packageHelpers = {
+    "@modelcontextprotocol/server-brave-search": {
+        requiredEnvVars: {
+            BRAVE_API_KEY: {
+                description: "API key for Brave Search",
+                required: true,
+            },
+        },
+    },
+    "@modelcontextprotocol/server-github": {
+        requiredEnvVars: {
+            GITHUB_PERSONAL_ACCESS_TOKEN: {
+                description: "Personal access token for GitHub API access",
+                required: true,
+            },
+        },
+    },
+    "@modelcontextprotocol/server-gitlab": {
+        requiredEnvVars: {
+            GITLAB_PERSONAL_ACCESS_TOKEN: {
+                description: "Personal access token for GitLab API access",
+                required: true,
+            },
+            GITLAB_API_URL: {
+                description: "GitLab API URL (optional, for self-hosted instances)",
+                required: false,
+            },
+        },
+    },
+    "@modelcontextprotocol/server-google-maps": {
+        requiredEnvVars: {
+            GOOGLE_MAPS_API_KEY: {
+                description: "API key for Google Maps services",
+                required: true,
+            },
+        },
+    },
+    "@modelcontextprotocol/server-slack": {
+        requiredEnvVars: {
+            SLACK_BOT_TOKEN: {
+                description: "Slack Bot User OAuth Token (starts with xoxb-)",
+                required: true,
+            },
+            SLACK_TEAM_ID: {
+                description: "Slack Team/Workspace ID",
+                required: true,
+            },
+        },
+    },
+    "@raygun.io/mcp-server-raygun": {
+        requiredEnvVars: {
+            RAYGUN_PAT_TOKEN: {
+                description: "Personal access token for Raygun API access",
+                required: true,
+            },
+        },
+    },
+    "@kagi/mcp-server-kagi": {
+        requiredEnvVars: {
+            KAGI_API_KEY: {
+                description: "API key for Kagi Search",
+                required: true,
+            },
+        },
+    },
+    "@exa/mcp-server": {
+        requiredEnvVars: {
+            EXA_API_KEY: {
+                description: "API key for Exa AI Search",
+                required: true,
+            },
+        },
+    },
+    "@search1api/mcp-server": {
+        requiredEnvVars: {
+            SEARCH1API_KEY: {
+                description: "API key for Search1API",
+                required: true,
+            },
+        },
+    },
+    "mcp-tinybird": {
+        requiredEnvVars: {
+            TB_API_URL: {
+                description: "API URL for Tinybird",
+                required: true,
+            },
+            TB_ADMIN_TOKEN: {
+                description: "Admin token for Tinybird",
+                required: true,
+            },
+        },
+    },
+};

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { list } from "./commands/list.js";
+import { install } from "./commands/install.js";
+import { uninstall } from "./commands/uninstall.js";
+import { listInstalledPackages } from "./commands/installed.js";
+import { get } from "./commands/get.js";
+const command = process.argv[2];
+const packageName = process.argv[3];
+async function main() {
+    switch (command) {
+        case "list":
+            await list();
+            break;
+        case "install":
+            if (!packageName) {
+                console.error("Please provide a package name to install");
+                process.exit(1);
+            }
+            await install(packageName);
+            break;
+        case "uninstall":
+            await uninstall(packageName);
+            break;
+        case "installed":
+            await listInstalledPackages();
+            break;
+        case "get":
+            if (!packageName) {
+                console.error("Please provide a package ID to get details");
+                process.exit(1);
+            }
+            await get(packageName);
+            break;
+        default:
+            console.log("Available commands:");
+            console.log("  list                  List all available packages");
+            console.log("  install <package>     Install a package");
+            console.log("  uninstall [package]   Uninstall a package");
+            console.log("  installed             List installed packages");
+            console.log("  get <package>         Get details for a specific package");
+            process.exit(1);
+    }
+}
+main();