@smithery/cli 0.0.3

package/dist/utils/package-resolver.js

@@ -0,0 +1,143 @@
+import { ConfigManager } from "./config-manager.js";
+// import path from 'path';
+// import fs from 'fs';
+// import { dirname } from 'path';
+// import { fileURLToPath } from 'url';
+export function isPackageInstalled(packageName) {
+    return ConfigManager.isPackageInstalled(packageName);
+}
+export async function resolvePackages() {
+    try {
+        // Fetch all packages from registry
+        const response = await fetch("https://registry.smithery.ai/packages");
+        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 config = ConfigManager.readConfig();
+        const installedServers = config.mcpServers || {};
+        const installedIds = Object.keys(installedServers);
+        // Create a map using IDs
+        const packageMap = new Map();
+        for (const pkg of packages) {
+            packageMap.set(pkg.id, pkg);
+        }
+        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,
+                // runtime: 'node',
+                isInstalled: false,
+                isVerified: true,
+            });
+        }
+        // Process installed packages
+        for (const id of installedIds) {
+            const installedServer = installedServers[id];
+            const existingPkg = packageMap.get(id);
+            if (existingPkg) {
+                resolvedPackages.set(id, {
+                    id: existingPkg.id,
+                    name: existingPkg.name,
+                    description: existingPkg.description,
+                    vendor: existingPkg.vendor,
+                    sourceUrl: existingPkg.sourceUrl,
+                    license: existingPkg.license,
+                    connections: existingPkg.connections,
+                    homepage: existingPkg.homepage,
+                    // runtime: installedServer?.runtime || 'node',
+                    isInstalled: true,
+                    isVerified: true,
+                });
+            }
+            else {
+                resolvedPackages.set(id, {
+                    ...installedServer,
+                    id,
+                    name: id,
+                    description: "Local package",
+                    vendor: "Local",
+                    sourceUrl: "",
+                    license: "",
+                    connections: [],
+                    homepage: "",
+                    // runtime: installedServer?.runtime || 'node',
+                    isInstalled: true,
+                    isVerified: false,
+                });
+            }
+        }
+        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) {
+    try {
+        // Replace file reading with registry fetch
+        const response = await fetch(`https://registry.smithery.ai/${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: "",
+                    // runtime: installedServer.runtime || 'node',
+                    isInstalled: true,
+                    isVerified: false,
+                };
+            }
+            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,
+            // runtime: 'node',
+            isInstalled: isPackageInstalled(registryPackage.id),
+            isVerified: true,
+        };
+        return resolvedPackage;
+    }
+    catch (error) {
+        console.error("Error resolving package:", error);
+        return null;
+    }
+}

package/dist/utils/runtime-utils.js

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

@@ -0,0 +1,46 @@
+import inquirer from "inquirer";
+import fuzzy from "fuzzy";
+import chalk from "chalk";
+export function formatPackageChoice(pkg, showInstallStatus = false) {
+    const prefix = showInstallStatus ? (pkg.isInstalled ? "✓ " : "  ") : "";
+    return {
+        name: `${prefix}${pkg.name.padEnd(showInstallStatus ? 22 : 24)} │ ${pkg.description.length > 47
+            ? `${pkg.description.slice(0, 44)}...`
+            : pkg.description.padEnd(49)} │ ${pkg.vendor.padEnd(19)} │ ${pkg.license.padEnd(14)}`,
+        value: pkg,
+        short: pkg.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`));
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@smithery/cli",
+	"version": "0.0.3",
+	"homepage": "https://smithery.ai/",
+	"description": "A NPX command to install and list Model Context Protocols",
+	"main": "dist/index.js",
+	"scripts": {
+		"build": "tsc && chmod +x dist/index.js",
+		"start": "node dist/index.js",
+		"test:list": "node --loader ts-node/esm src/index.ts list",
+		"test:install": "node --loader ts-node/esm src/index.ts install",
+		"test:installed": "node --loader ts-node/esm src/index.ts installed",
+		"extract": "node --loader ts-node/esm src/extractors/modelcontextprotocol-extractor.ts",
+		"test:uninstall": "node --loader ts-node/esm src/index.ts uninstall",
+		"version:patch": "npm version patch",
+		"version:minor": "npm version minor",
+		"version:major": "npm version major",
+		"publish:npm": "npm run build && npm publish --access public",
+		"pr-check": "node src/scripts/pr-check.js",
+		"test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.mjs --watch",
+		"test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.mjs --coverage",
+		"prepare": "npm run build",
+		"lint": "npx @biomejs/biome lint --write",
+		"format": "npx @biomejs/biome format --write"
+	},
+	"bin": {
+		"@smithery/cli": "dist/index.js"
+	},
+	"dependencies": {
+		"@iarna/toml": "^2.2.5",
+		"@types/iarna__toml": "^2.0.5",
+		"chalk": "^4.1.2",
+		"cli-table3": "^0.6.5",
+		"dotenv": "^16.4.5",
+		"fuzzy": "^0.1.3",
+		"inquirer": "^8.2.4",
+		"inquirer-autocomplete-prompt": "^2.0.0",
+		"open": "^10.1.0",
+		"string-width": "^4.2.3",
+		"typescript": "^4.0.0"
+	},
+	"devDependencies": {
+		"@types/inquirer": "^8.2.4",
+		"@types/inquirer-autocomplete-prompt": "^3.0.3",
+		"@types/jest": "^29.5.14",
+		"@types/node": "^14.0.0",
+		"jest": "^29.7.0",
+		"ts-jest": "^29.2.5",
+		"ts-node": "^10.9.1",
+		"tsx": "^4.19.2"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"package.json",
+		"packages",
+		"LICENSE"
+	],
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./dist/index.js"
+		}
+	},
+	"license": "MIT"
+}