mcpstore-cc 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# mcpstore
+
+CLI to install MCPs from [MCP Store](https://www.mcpclaudecode.com) into Claude Code.
+
+## Install
+
+```bash
+npx mcpstore-cc install <slug>
+```
+
+No global install required — just use `npx`.
+
+## Commands
+
+### Install an MCP
+
+```bash
+npx mcpstore-cc install ai-brain
+npx mcpstore-cc install supabase-mcp --env SUPABASE_URL=https://xxx.supabase.co
+```
+
+### Uninstall an MCP
+
+```bash
+npx mcpstore-cc uninstall ai-brain
+```
+
+### List installed MCPs
+
+```bash
+npx mcpstore-cc list
+```
+
+### Search available MCPs
+
+```bash
+npx mcpstore-cc search database
+```
+
+### Save your API key
+
+```bash
+npx mcpstore-cc login <your-api-key>
+```
+
+## How it works
+
+1. Fetches MCP configuration from the MCP Store API
+2. Adds the server entry to `~/.claude/.mcp.json`
+3. Restart Claude Code to activate
+
+## License
+
+MIT

package/dist/commands/install.d.ts

@@ -0,0 +1,3 @@
+export declare function installCommand(slug: string, options: {
+    env?: string[];
+}): Promise<void>;

package/dist/commands/install.js

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import ora from "ora";
+import { fetchMcp } from "../lib/api.js";
+import { addMcpServer, listMcpServers, getMcpConfigPath } from "../lib/config.js";
+export async function installCommand(slug, options) {
+    const spinner = ora(`Fetching "${slug}" from MCP Store...`).start();
+    try {
+        const mcp = await fetchMcp(slug);
+        spinner.succeed(`Found: ${chalk.bold(mcp.name)} v${mcp.version} by ${mcp.author_name}`);
+        // Check if already installed
+        const existing = await listMcpServers();
+        if (slug in existing) {
+            console.log(chalk.yellow(`\n⚠ "${slug}" is already installed in Claude Code.`));
+            console.log(chalk.gray("  Use `mcpstore uninstall " + slug + "` first to reinstall."));
+            return;
+        }
+        // Build server config from config_schema or npm_package
+        let command;
+        let args;
+        let env = {};
+        if (mcp.config_schema && mcp.config_schema.command) {
+            // Use the config_schema from the API
+            command = mcp.config_schema.command;
+            args = mcp.config_schema.args || [];
+            env = mcp.config_schema.env || {};
+        }
+        else if (mcp.npm_package) {
+            // Fallback: use npx with the npm package
+            command = "npx";
+            args = ["-y", mcp.npm_package];
+        }
+        else {
+            console.log(chalk.red("\n✗ This MCP has no installation config. Contact the author."));
+            return;
+        }
+        // Merge env vars from --env flags
+        if (options.env) {
+            for (const pair of options.env) {
+                const eqIdx = pair.indexOf("=");
+                if (eqIdx === -1) {
+                    console.log(chalk.yellow(`\n⚠ Skipping invalid env: "${pair}" (use KEY=VALUE format)`));
+                    continue;
+                }
+                const key = pair.slice(0, eqIdx);
+                const value = pair.slice(eqIdx + 1);
+                env[key] = value;
+            }
+        }
+        // Check if config_schema defines required env vars we're missing
+        if (mcp.config_schema?.env) {
+            const schemaEnv = mcp.config_schema.env;
+            const missingKeys = Object.keys(schemaEnv).filter((k) => !env[k] && schemaEnv[k] !== "");
+            if (missingKeys.length > 0) {
+                console.log(chalk.yellow("\n⚠ This MCP requires environment variables:"));
+                for (const key of missingKeys) {
+                    console.log(chalk.gray(`  ${key}=${schemaEnv[key] || "<your-value>"}`));
+                }
+                console.log(chalk.gray("\n  Pass them with: mcpstore install " + slug + " --env " + missingKeys.map((k) => `${k}=<value>`).join(" --env ")));
+            }
+        }
+        // Write to ~/.claude/.mcp.json
+        const spinner2 = ora("Adding to Claude Code config...").start();
+        const entry = { command, args, ...(Object.keys(env).length > 0 ? { env } : {}) };
+        await addMcpServer(slug, entry);
+        spinner2.succeed("Added to Claude Code config");
+        console.log(chalk.green(`\n✓ ${chalk.bold(mcp.name)} installed successfully!`));
+        console.log(chalk.gray(`  Config: ${getMcpConfigPath()}`));
+        console.log(chalk.gray(`  Restart Claude Code to activate this MCP.\n`));
+    }
+    catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,31 @@
+import chalk from "chalk";
+import { listMcpServers, getMcpConfigPath } from "../lib/config.js";
+export async function listCommand() {
+    try {
+        const servers = await listMcpServers();
+        const names = Object.keys(servers);
+        if (names.length === 0) {
+            console.log(chalk.gray("\nNo MCPs installed in Claude Code."));
+            console.log(chalk.gray("  Browse MCPs at https://www.mcpclaudecode.com/browse"));
+            console.log(chalk.gray("  Install one with: mcpstore install <slug>\n"));
+            return;
+        }
+        console.log(chalk.bold(`\n${names.length} MCP(s) installed in Claude Code:\n`));
+        for (const name of names) {
+            const server = servers[name];
+            const cmdStr = [server.command, ...server.args].join(" ");
+            console.log(`  ${chalk.green("●")} ${chalk.bold(name)}`);
+            console.log(chalk.gray(`    ${cmdStr}`));
+            if (server.env && Object.keys(server.env).length > 0) {
+                const envKeys = Object.keys(server.env);
+                console.log(chalk.gray(`    env: ${envKeys.join(", ")}`));
+            }
+            console.log();
+        }
+        console.log(chalk.gray(`Config: ${getMcpConfigPath()}\n`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+export declare function loginCommand(apiKey: string): Promise<void>;
+export declare function whoamiCommand(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { saveApiKey, getStoredApiKey } from "../lib/config.js";
+export async function loginCommand(apiKey) {
+    try {
+        await saveApiKey(apiKey);
+        console.log(chalk.green("\n✓ API key saved successfully!"));
+        console.log(chalk.gray("  Stored in ~/.mcpstore/config.json\n"));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}
+export async function whoamiCommand() {
+    const key = await getStoredApiKey();
+    if (!key) {
+        console.log(chalk.gray("\nNot logged in."));
+        console.log(chalk.gray("  Run: mcpstore login <your-api-key>\n"));
+        return;
+    }
+    const masked = key.slice(0, 8) + "..." + key.slice(-4);
+    console.log(`\nLogged in with API key: ${chalk.bold(masked)}\n`);
+}

package/dist/commands/search.d.ts

@@ -0,0 +1 @@
+export declare function searchCommand(query?: string): Promise<void>;

package/dist/commands/search.js

@@ -0,0 +1,31 @@
+import chalk from "chalk";
+import ora from "ora";
+import { searchMcps } from "../lib/api.js";
+export async function searchCommand(query) {
+    const spinner = ora(query ? `Searching for "${query}"...` : "Fetching MCPs...").start();
+    try {
+        const mcps = await searchMcps(query);
+        spinner.stop();
+        if (mcps.length === 0) {
+            console.log(chalk.gray("\nNo MCPs found."));
+            if (query) {
+                console.log(chalk.gray(`  Try a different search term or browse at https://www.mcpclaudecode.com/browse\n`));
+            }
+            return;
+        }
+        console.log(chalk.bold(`\n${mcps.length} MCP(s) found:\n`));
+        for (const mcp of mcps) {
+            const badge = mcp.plan_required !== "free" ? chalk.yellow(` [${mcp.plan_required.toUpperCase()}]`) : "";
+            const stars = mcp.rating_avg > 0 ? chalk.yellow(` ★ ${mcp.rating_avg.toFixed(1)}`) : "";
+            const installs = mcp.install_count > 0 ? chalk.gray(` (${mcp.install_count} installs)`) : "";
+            console.log(`  ${chalk.bold(mcp.name)}${badge}${stars}${installs}`);
+            console.log(chalk.gray(`    ${mcp.short_description || mcp.description?.slice(0, 80) || ""}`));
+            console.log(chalk.cyan(`    mcpstore install ${mcp.slug}`));
+            console.log();
+        }
+    }
+    catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}

package/dist/commands/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function uninstallCommand(slug: string): Promise<void>;

package/dist/commands/uninstall.js

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import ora from "ora";
+import { removeMcpServer, getMcpConfigPath } from "../lib/config.js";
+export async function uninstallCommand(slug) {
+    const spinner = ora(`Removing "${slug}" from Claude Code...`).start();
+    try {
+        const removed = await removeMcpServer(slug);
+        if (!removed) {
+            spinner.warn(`"${slug}" is not installed in Claude Code.`);
+            return;
+        }
+        spinner.succeed(`Removed "${slug}" from Claude Code config`);
+        console.log(chalk.green(`\n✓ ${chalk.bold(slug)} uninstalled successfully!`));
+        console.log(chalk.gray(`  Config: ${getMcpConfigPath()}`));
+        console.log(chalk.gray(`  Restart Claude Code to apply changes.\n`));
+    }
+    catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { installCommand } from "./commands/install.js";
+import { uninstallCommand } from "./commands/uninstall.js";
+import { listCommand } from "./commands/list.js";
+import { searchCommand } from "./commands/search.js";
+import { loginCommand, whoamiCommand } from "./commands/login.js";
+const program = new Command();
+program
+    .name("mcpstore")
+    .description("Install MCPs from MCP Store into Claude Code")
+    .version("0.1.0");
+program
+    .command("install <slug>")
+    .description("Install an MCP into Claude Code")
+    .option("-e, --env <KEY=VALUE...>", "Set environment variables", (val, acc) => {
+    acc.push(val);
+    return acc;
+}, [])
+    .action(async (slug, opts) => {
+    await installCommand(slug, { env: opts.env.length > 0 ? opts.env : undefined });
+});
+program
+    .command("uninstall <slug>")
+    .description("Remove an MCP from Claude Code")
+    .action(async (slug) => {
+    await uninstallCommand(slug);
+});
+program
+    .command("list")
+    .description("List all MCPs installed in Claude Code")
+    .action(async () => {
+    await listCommand();
+});
+program
+    .command("search [query]")
+    .description("Search MCPs on MCP Store")
+    .action(async (query) => {
+    await searchCommand(query);
+});
+program
+    .command("login <api-key>")
+    .description("Save your MCP Store API key")
+    .action(async (apiKey) => {
+    await loginCommand(apiKey);
+});
+program
+    .command("whoami")
+    .description("Show current logged-in API key")
+    .action(async () => {
+    await whoamiCommand();
+});
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,22 @@
+export interface McpConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface McpDetail {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    short_description: string;
+    author_name: string;
+    npm_package: string | null;
+    version: string;
+    plan_required: string;
+    install_count: number;
+    rating_avg: number;
+    rating_count: number;
+    config_schema: McpConfig | null;
+}
+export declare function fetchMcp(slug: string): Promise<McpDetail>;
+export declare function searchMcps(query?: string): Promise<McpDetail[]>;

package/dist/lib/api.js

@@ -0,0 +1,24 @@
+const API_BASE = "https://aibrain-mcp-backend.vercel.app/v1";
+export async function fetchMcp(slug) {
+    const res = await fetch(`${API_BASE}/marketplace/mcps/${slug}`);
+    if (!res.ok) {
+        if (res.status === 404) {
+            throw new Error(`MCP "${slug}" not found on MCP Store.`);
+        }
+        throw new Error(`API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.mcp ?? data;
+}
+export async function searchMcps(query) {
+    const params = new URLSearchParams();
+    if (query)
+        params.set("search", query);
+    params.set("limit", "50");
+    const res = await fetch(`${API_BASE}/marketplace/mcps?${params}`);
+    if (!res.ok) {
+        throw new Error(`API error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.mcps ?? data;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,17 @@
+export interface McpServerEntry {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+interface McpConfigFile {
+    mcpServers: Record<string, McpServerEntry>;
+}
+export declare function readMcpConfig(): Promise<McpConfigFile>;
+export declare function writeMcpConfig(config: McpConfigFile): Promise<void>;
+export declare function addMcpServer(name: string, entry: McpServerEntry): Promise<void>;
+export declare function removeMcpServer(name: string): Promise<boolean>;
+export declare function listMcpServers(): Promise<Record<string, McpServerEntry>>;
+export declare function getStoredApiKey(): Promise<string | null>;
+export declare function saveApiKey(apiKey: string): Promise<void>;
+export declare function getMcpConfigPath(): string;
+export {};

package/dist/lib/config.js

@@ -0,0 +1,57 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// ── Claude Code MCP config ──────────────────────────────────────
+const CLAUDE_DIR = join(homedir(), ".claude");
+const MCP_CONFIG_PATH = join(CLAUDE_DIR, ".mcp.json");
+export async function readMcpConfig() {
+    if (!existsSync(MCP_CONFIG_PATH)) {
+        return { mcpServers: {} };
+    }
+    const raw = await readFile(MCP_CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+}
+export async function writeMcpConfig(config) {
+    if (!existsSync(CLAUDE_DIR)) {
+        await mkdir(CLAUDE_DIR, { recursive: true });
+    }
+    await writeFile(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export async function addMcpServer(name, entry) {
+    const config = await readMcpConfig();
+    config.mcpServers[name] = entry;
+    await writeMcpConfig(config);
+}
+export async function removeMcpServer(name) {
+    const config = await readMcpConfig();
+    if (!(name in config.mcpServers)) {
+        return false;
+    }
+    delete config.mcpServers[name];
+    await writeMcpConfig(config);
+    return true;
+}
+export async function listMcpServers() {
+    const config = await readMcpConfig();
+    return config.mcpServers;
+}
+// ── mcpstore CLI config (API key storage) ───────────────────────
+const MCPSTORE_DIR = join(homedir(), ".mcpstore");
+const MCPSTORE_CONFIG = join(MCPSTORE_DIR, "config.json");
+export async function getStoredApiKey() {
+    if (!existsSync(MCPSTORE_CONFIG))
+        return null;
+    const raw = await readFile(MCPSTORE_CONFIG, "utf-8");
+    const data = JSON.parse(raw);
+    return data.apiKey ?? null;
+}
+export async function saveApiKey(apiKey) {
+    if (!existsSync(MCPSTORE_DIR)) {
+        await mkdir(MCPSTORE_DIR, { recursive: true });
+    }
+    await writeFile(MCPSTORE_CONFIG, JSON.stringify({ apiKey }, null, 2) + "\n", "utf-8");
+}
+export function getMcpConfigPath() {
+    return MCP_CONFIG_PATH;
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "mcpstore-cc",
+  "version": "0.1.0",
+  "description": "CLI to install MCPs from MCP Store into Claude Code",
+  "type": "module",
+  "bin": {
+    "mcpstore": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["mcp", "claude-code", "marketplace", "cli"],
+  "author": "MCP Store",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}