@smithery/cli 0.0.3 → 0.0.7

package/README.md

@@ -1,4 +1,4 @@
-# smithery/get
+# smithery/cli
 
 A lightweight registry and package manager for Model Context Protocol (MCP) servers, designed to be client-agnostic.
 
@@ -35,10 +35,11 @@ npx .
 
 ### Common Commands
 
-Note: yet to fix 'npx . list' to list all packages
-
 Test specific functionality:
 ```bash
+# List all packages
+npx . list
+
 # Get details about a specific package
 npx . get <package-id>
 

package/dist/commands/install.js

@@ -2,6 +2,7 @@ import { installPackage as installPkg } from "../utils/package-management.js";
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { resolvePackage } from "../utils/package-resolver.js";
+import { VALID_CLIENTS } from "../utils/config.js";
 async function promptForRuntime() {
     const { runtime } = await inquirer.prompt([
         {
@@ -16,7 +17,7 @@ async function promptForRuntime() {
     ]);
     return runtime;
 }
-function createUnknownPackage(id, runtime) {
+function createUnknownPackage(id, runtime, client) {
     return {
         id,
         name: id,
@@ -28,6 +29,7 @@ function createUnknownPackage(id, runtime) {
         license: "",
         isInstalled: false,
         isVerified: false,
+        client: client,
         connections: [
             {
                 stdio: {
@@ -42,10 +44,14 @@ function createUnknownPackage(id, runtime) {
 export async function installPackage(pkg) {
     return installPkg(pkg);
 }
-export async function install(packageId) {
-    const pkg = await resolvePackage(packageId);
+export async function install(packageId, client) {
+    if (client && !VALID_CLIENTS.includes(client)) {
+        console.error(chalk.red(`Invalid client: ${client}\nValid clients are: ${VALID_CLIENTS.join(", ")}`));
+        process.exit(1);
+    }
+    const pkg = await resolvePackage(packageId, client);
     if (!pkg) {
-        console.warn(chalk.yellow(`Package ${packageId} not found in the curated list.`));
+        console.warn(chalk.yellow(`Package ${packageId} not found in registry.`));
         const { proceedWithInstall } = await inquirer.prompt([
             {
                 type: "confirm",
@@ -57,7 +63,7 @@ export async function install(packageId) {
         if (proceedWithInstall) {
             console.log(chalk.cyan(`Proceeding with installation of ${packageId}...`));
             const runtime = await promptForRuntime();
-            const unknownPkg = createUnknownPackage(packageId, runtime);
+            const unknownPkg = createUnknownPackage(packageId, runtime, client);
             await installPkg(unknownPkg);
         }
         else {

package/dist/index.js

@@ -6,6 +6,8 @@ import { listInstalledPackages } from "./commands/installed.js";
 import { get } from "./commands/get.js";
 const command = process.argv[2];
 const packageName = process.argv[3];
+const clientFlag = process.argv.indexOf("--client");
+const client = clientFlag !== -1 ? process.argv[clientFlag + 1] : undefined;
 async function main() {
     switch (command) {
         case "list":
@@ -16,7 +18,7 @@ async function main() {
                 console.error("Please provide a package name to install");
                 process.exit(1);
             }
-            await install(packageName);
+            await install(packageName, client);
             break;
         case "uninstall":
             await uninstall(packageName);
@@ -35,6 +37,7 @@ async function main() {
             console.log("Available commands:");
             console.log("  list                  List all available packages");
             console.log("  install <package>     Install a package");
+            console.log("    --client <name>     Specify the AI client");
             console.log("  uninstall [package]   Uninstall a package");
             console.log("  installed             List installed packages");
             console.log("  get <package>         Get details for a specific package");

package/dist/types/analytics.js

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

package/dist/utils/analytics.js

@@ -0,0 +1,44 @@
+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,17 +1,26 @@
 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() {
-        return ConfigManager.configPath;
+    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() {
+    static readConfig(client) {
         try {
-            if (!fs.existsSync(ConfigManager.configPath)) {
+            const configPath = ConfigManager.getConfigPath(client);
+            if (!fs.existsSync(configPath)) {
                 return { mcpServers: {} };
             }
-            const rawConfig = JSON.parse(fs.readFileSync(ConfigManager.configPath, "utf8"));
-            // Ensure we have the correct structure
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
             return {
                 mcpServers: rawConfig.mcpServers || {},
             };
@@ -21,17 +30,17 @@ export class ConfigManager {
             return { mcpServers: {} };
         }
     }
-    static writeConfig(config) {
+    static writeConfig(config, client) {
         try {
-            const configDir = path.dirname(ConfigManager.configPath);
+            const configPath = ConfigManager.getConfigPath(client);
+            const configDir = path.dirname(configPath);
             if (!fs.existsSync(configDir)) {
                 fs.mkdirSync(configDir, { recursive: true });
             }
-            // Validate config structure before writing
             if (!config.mcpServers || typeof config.mcpServers !== "object") {
                 throw new Error("Invalid config structure");
             }
-            fs.writeFileSync(ConfigManager.configPath, JSON.stringify(config, null, 2));
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
         }
         catch (error) {
             console.error("Error writing config:", error);
@@ -62,32 +71,32 @@ export class ConfigManager {
             throw error;
         }
     }
-    static isPackageInstalled(id) {
-        const config = ConfigManager.readConfig();
+    static isPackageInstalled(id, client) {
+        const config = ConfigManager.readConfig(client);
         return id in config.mcpServers;
     }
-    static async installPackage(id, serverConfig) {
+    static async installPackage(id, serverConfig, client) {
         try {
-            const config = ConfigManager.readConfig();
+            const config = ConfigManager.readConfig(client);
             config.mcpServers[id] = serverConfig;
-            ConfigManager.writeConfig(config);
+            ConfigManager.writeConfig(config, client);
         }
         catch (error) {
             console.error("Error installing server:", error);
             throw error;
         }
     }
-    static async uninstallPackage(id) {
-        const config = ConfigManager.readConfig();
+    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);
+        ConfigManager.writeConfig(config, client);
     }
-    static getServerConfig(id) {
-        const config = ConfigManager.readConfig();
+    static getServerConfig(id, client) {
+        const config = ConfigManager.readConfig(client);
         return config.mcpServers[id] || null;
     }
 }

package/dist/utils/config.js

@@ -8,6 +8,7 @@ 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)) {

package/dist/utils/display.js

@@ -2,6 +2,7 @@ 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);

package/dist/utils/package-management.js

@@ -2,6 +2,7 @@ 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();
@@ -19,9 +20,8 @@ async function checkAnalyticsConsent() {
     ConfigManager.writePreferences({ ...prefs, allowAnalytics });
     return allowAnalytics;
 }
-async function trackInstallation(packageName) {
-    // Analytics tracking disabled for now
-    return;
+async function trackInstallation(packageName, client) {
+    return analytics.trackInstallation(packageName, client);
 }
 async function promptForPlaceholder(key, message) {
     const { value } = await inquirer.prompt([
@@ -80,72 +80,92 @@ async function promptForEnvVars(pkg) {
     }
     return Object.keys(envVars).length > 0 ? envVars : undefined;
 }
-async function isClaudeRunning() {
+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 Claude.exe" /NH');
-            return stdout.includes("Claude.exe");
+            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 "Claude"');
+            const { stdout } = await execAsync(`pgrep -x "${clientProcess}"`);
             return !!stdout.trim();
         }
         else if (platform === "linux") {
-            const { stdout } = await execAsync('pgrep -f "claude"');
+            const { stdout } = await execAsync(`pgrep -f "${clientProcess.toLowerCase()}"`);
             return !!stdout.trim();
         }
         return false;
     }
     catch (error) {
-        // If the command fails, assume Claude is not running
+        // If the command fails, assume client is not running
         return false;
     }
 }
-async function promptForRestart() {
-    // Check if Claude is running first
-    const claudeRunning = await isClaudeRunning();
-    if (!claudeRunning) {
+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 Claude desktop app to apply changes?",
+            message: `Would you like to restart the ${client} app to apply changes?`,
             default: true,
         },
     ]);
     if (shouldRestart) {
-        console.log("Restarting Claude desktop app...");
-        try {
-            const platform = process.platform;
-            if (platform === "win32") {
-                await execAsync('taskkill /F /IM "Claude.exe" && start "" "Claude.exe"');
-            }
-            else if (platform === "darwin") {
-                await execAsync('killall "Claude" && open -a "Claude"');
-            }
-            else if (platform === "linux") {
-                await execAsync('pkill -f "claude" && claude');
-            }
-            // 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 "" "Claude.exe"');
-            }
-            else if (platform === "darwin") {
-                await execAsync('open -a "Claude"');
-            }
-            else if (platform === "linux") {
-                await execAsync("claude");
-            }
-            console.log("Claude desktop app has been restarted.");
-        }
-        catch (error) {
-            console.error("Failed to restart Claude desktop app:", error);
-        }
+        console.log(`Restarting ${client} app...`);
+        await restartClient(client);
     }
     return shouldRestart;
 }
@@ -163,32 +183,32 @@ export async function installPackage(pkg) {
     } */
         const envVars = await promptForEnvVars(pkg);
         // Use the connection stdio config directly
-        const connection = pkg.connections?.[0]; // Take first connection
+        const connection = pkg.connections?.[0];
         const serverConfig = {
             command: connection.stdio.command,
             args: connection.stdio.args,
-            env: envVars || {}, // Use our prompted env vars
-            // runtime: pkg.runtime
+            env: {
+                ...(envVars || {}),
+            },
         };
-        await ConfigManager.installPackage(pkg.id, serverConfig);
-        console.log("Updated Claude desktop configuration");
-        // Check analytics consent and track if allowed
-        const analyticsAllowed = await checkAnalyticsConsent();
-        if (analyticsAllowed) {
-            await trackInstallation(pkg.name);
+        // 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();
+        await promptForRestart(pkg.client);
     }
     catch (error) {
         console.error("Failed to install package:", error);
         throw error;
     }
 }
-export async function uninstallPackage(packageName) {
+export async function uninstallPackage(packageName, client) {
     try {
         await ConfigManager.uninstallPackage(packageName);
         console.log(`\nUninstalled ${packageName}`);
-        await promptForRestart();
+        await promptForRestart(client);
     }
     catch (error) {
         console.error("Failed to uninstall package:", error);

package/dist/utils/package-resolver.js

@@ -3,13 +3,16 @@ import { ConfigManager } from "./config-manager.js";
 // 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() {
+export async function resolvePackages(client) {
     try {
-        // Fetch all packages from registry
-        const response = await fetch("https://registry.smithery.ai/packages");
+        // Updated API endpoint
+        const response = await fetch(`${REGISTRY_ENDPOINT}/servers/`);
         if (!response.ok) {
             throw new Error(`Failed to fetch packages: ${response.statusText} (${response.status})`);
         }
@@ -28,64 +31,51 @@ export async function resolvePackages() {
                 : "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',
+                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 = packageMap.get(id);
+            const existingPkg = resolvedPackages.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',
+                    ...existingPkg,
                     isInstalled: true,
-                    isVerified: true,
+                    client: client || existingPkg.client,
                 });
             }
             else {
                 resolvedPackages.set(id, {
                     ...installedServer,
-                    id,
-                    name: id,
+                    id: id || "",
+                    name: id || "",
                     description: "Local package",
                     vendor: "Local",
                     sourceUrl: "",
                     license: "",
                     connections: [],
                     homepage: "",
-                    // runtime: installedServer?.runtime || 'node',
                     isInstalled: true,
                     isVerified: false,
+                    client: client,
                 });
             }
         }
@@ -95,10 +85,10 @@ export async function resolvePackages() {
         throw new Error(`Failed to resolve packages: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-export async function resolvePackage(packageId) {
+export async function resolvePackage(packageId, client) {
     try {
-        // Replace file reading with registry fetch
-        const response = await fetch(`https://registry.smithery.ai/${packageId}`);
+        // 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();
@@ -113,9 +103,9 @@ export async function resolvePackage(packageId) {
                     license: "",
                     connections: [],
                     homepage: "",
-                    // runtime: installedServer.runtime || 'node',
                     isInstalled: true,
                     isVerified: false,
+                    client: client,
                 };
             }
             return null;
@@ -130,9 +120,9 @@ export async function resolvePackage(packageId) {
             license: registryPackage.license,
             connections: registryPackage.connections,
             homepage: registryPackage.homepage,
-            // runtime: 'node',
             isInstalled: isPackageInstalled(registryPackage.id),
             isVerified: true,
+            client: client,
         };
         return resolvedPackage;
     }

package/dist/utils/ui.js

@@ -3,12 +3,31 @@ 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}${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)}`,
+        name: `${prefix}${truncatedName} │ ${truncatedId} │ ${truncatedDesc} │ ${truncatedVendor}`,
         value: pkg,
-        short: pkg.name,
+        short: name,
     };
 }
 export function createPackagePrompt(packages, options = {}) {

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@smithery/cli",
-	"version": "0.0.3",
+	"version": "0.0.7",
+	"private": false,
 	"homepage": "https://smithery.ai/",
 	"description": "A NPX command to install and list Model Context Protocols",
 	"main": "dist/index.js",