codetyper-cli 0.2.0 → 0.2.1

package/README.md

@@ -284,11 +284,31 @@ CodeTyper has access to these built-in tools:
 Connect external MCP (Model Context Protocol) servers for extended capabilities:
 
 ```bash
-# In the TUI
-/mcp
-# Then add a new server
+# Browse and search available servers
+/mcp browse        # Interactive browser
+/mcp search <query> # Search by keyword
+/mcp popular       # Show popular servers
+/mcp categories    # List all categories
+
+# Install a server
+/mcp install sqlite
+/mcp install github
+
+# Manage servers
+/mcp status        # Show connected servers
+/mcp connect       # Connect all servers
+/mcp disconnect    # Disconnect all servers
+/mcp tools         # List available tools
+/mcp add           # Add custom server
 ```
 
+**MCP Browser Features:**
+- Search by name, description, or tags
+- Filter by category (database, web, AI, etc.)
+- View server details and required environment variables
+- One-click installation and connection
+- 15+ verified servers from Anthropic
+
 ## Extensibility
 
 ### Hooks System

package/dist/index.js

@@ -73666,14 +73666,565 @@ var init_semantic_search = __esm(() => {
 var version_default;
 var init_version = __esm(() => {
   version_default = {
-    version: "0.2.0"
+    version: "0.2.1"
+  };
+});
+
+// src/constants/mcp-registry.ts
+var MCP_REGISTRY_SOURCES, MCP_REGISTRY_CACHE, MCP_CATEGORY_LABELS, MCP_CATEGORY_ICONS, MCP_SEARCH_DEFAULTS, MCP_CURATED_SERVERS, MCP_REGISTRY_ERRORS;
+var init_mcp_registry = __esm(() => {
+  MCP_REGISTRY_SOURCES = {
+    OFFICIAL: "https://raw.githubusercontent.com/modelcontextprotocol/servers/main/README.md",
+    SMITHERY: "https://registry.smithery.ai/servers"
+  };
+  MCP_REGISTRY_CACHE = {
+    DURATION_MS: 60 * 60 * 1000,
+    FILE_NAME: "mcp-registry-cache.json"
+  };
+  MCP_CATEGORY_LABELS = {
+    database: "Database",
+    filesystem: "File System",
+    web: "Web & Browser",
+    ai: "AI & ML",
+    "dev-tools": "Developer Tools",
+    productivity: "Productivity",
+    communication: "Communication",
+    cloud: "Cloud Services",
+    security: "Security",
+    other: "Other"
+  };
+  MCP_CATEGORY_ICONS = {
+    database: "\uD83D\uDDC4️",
+    filesystem: "\uD83D\uDCC1",
+    web: "\uD83C\uDF10",
+    ai: "\uD83E\uDD16",
+    "dev-tools": "\uD83D\uDEE0️",
+    productivity: "\uD83D\uDCCB",
+    communication: "\uD83D\uDCAC",
+    cloud: "☁️",
+    security: "\uD83D\uDD12",
+    other: "\uD83D\uDCE6"
+  };
+  MCP_SEARCH_DEFAULTS = {
+    LIMIT: 20,
+    SORT_BY: "popularity"
+  };
+  MCP_CURATED_SERVERS = [
+    {
+      id: "filesystem",
+      name: "Filesystem",
+      description: "Read, write, and manage files on the local filesystem",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-filesystem",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
+      category: "filesystem",
+      tags: ["files", "read", "write", "directory"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 100,
+      verified: true,
+      installHint: "Replace /path/to/dir with the directory you want to access",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "sqlite",
+      name: "SQLite",
+      description: "Query and manage SQLite databases",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-sqlite",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/db.sqlite"],
+      category: "database",
+      tags: ["sql", "database", "query", "sqlite"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 95,
+      verified: true,
+      installHint: "Replace /path/to/db.sqlite with your database file path",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "postgres",
+      name: "PostgreSQL",
+      description: "Connect to and query PostgreSQL databases",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-postgres",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-postgres"],
+      category: "database",
+      tags: ["sql", "database", "query", "postgres", "postgresql"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 90,
+      verified: true,
+      envVars: ["POSTGRES_CONNECTION_STRING"],
+      installHint: "Set POSTGRES_CONNECTION_STRING environment variable",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "github",
+      name: "GitHub",
+      description: "Interact with GitHub repositories, issues, and pull requests",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-github",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-github"],
+      category: "dev-tools",
+      tags: ["github", "git", "repository", "issues", "pr"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 92,
+      verified: true,
+      envVars: ["GITHUB_PERSONAL_ACCESS_TOKEN"],
+      installHint: "Set GITHUB_PERSONAL_ACCESS_TOKEN environment variable",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "gitlab",
+      name: "GitLab",
+      description: "Interact with GitLab repositories and CI/CD",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-gitlab",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-gitlab"],
+      category: "dev-tools",
+      tags: ["gitlab", "git", "repository", "ci", "cd"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 75,
+      verified: true,
+      envVars: ["GITLAB_PERSONAL_ACCESS_TOKEN", "GITLAB_API_URL"],
+      installHint: "Set GITLAB_PERSONAL_ACCESS_TOKEN and optionally GITLAB_API_URL",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "slack",
+      name: "Slack",
+      description: "Send messages and interact with Slack workspaces",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-slack",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-slack"],
+      category: "communication",
+      tags: ["slack", "messaging", "chat", "team"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 80,
+      verified: true,
+      envVars: ["SLACK_BOT_TOKEN", "SLACK_TEAM_ID"],
+      installHint: "Set SLACK_BOT_TOKEN and SLACK_TEAM_ID environment variables",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "google-drive",
+      name: "Google Drive",
+      description: "Access and manage files in Google Drive",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-gdrive",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-gdrive"],
+      category: "cloud",
+      tags: ["google", "drive", "cloud", "storage", "files"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 78,
+      verified: true,
+      installHint: "Requires Google OAuth credentials setup",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "memory",
+      name: "Memory",
+      description: "Persistent memory and knowledge graph for context",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-memory",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-memory"],
+      category: "ai",
+      tags: ["memory", "knowledge", "graph", "context", "persistent"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 85,
+      verified: true,
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "brave-search",
+      name: "Brave Search",
+      description: "Search the web using Brave Search API",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-brave-search",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-brave-search"],
+      category: "web",
+      tags: ["search", "web", "brave", "internet"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 82,
+      verified: true,
+      envVars: ["BRAVE_API_KEY"],
+      installHint: "Set BRAVE_API_KEY environment variable",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "puppeteer",
+      name: "Puppeteer",
+      description: "Browser automation and web scraping with Puppeteer",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-puppeteer",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+      category: "web",
+      tags: ["browser", "automation", "scraping", "puppeteer", "chrome"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 76,
+      verified: true,
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "fetch",
+      name: "Fetch",
+      description: "Make HTTP requests and fetch web content",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-fetch",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-fetch"],
+      category: "web",
+      tags: ["http", "fetch", "api", "request", "web"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 88,
+      verified: true,
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "sequential-thinking",
+      name: "Sequential Thinking",
+      description: "Step-by-step reasoning and problem-solving",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-sequential-thinking",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+      category: "ai",
+      tags: ["thinking", "reasoning", "chain-of-thought", "problem-solving"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 70,
+      verified: true,
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "everart",
+      name: "EverArt",
+      description: "AI image generation with EverArt",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-everart",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-everart"],
+      category: "ai",
+      tags: ["image", "generation", "ai", "art", "creative"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 65,
+      verified: true,
+      envVars: ["EVERART_API_KEY"],
+      installHint: "Set EVERART_API_KEY environment variable",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "sentry",
+      name: "Sentry",
+      description: "Access Sentry error tracking and monitoring",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-sentry",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-sentry"],
+      category: "dev-tools",
+      tags: ["sentry", "errors", "monitoring", "debugging"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 72,
+      verified: true,
+      envVars: ["SENTRY_AUTH_TOKEN", "SENTRY_ORG"],
+      installHint: "Set SENTRY_AUTH_TOKEN and SENTRY_ORG environment variables",
+      updatedAt: "2024-12-01"
+    },
+    {
+      id: "aws-kb-retrieval",
+      name: "AWS Knowledge Base",
+      description: "Retrieve information from AWS Bedrock Knowledge Bases",
+      author: "Anthropic",
+      repository: "https://github.com/modelcontextprotocol/servers",
+      package: "@modelcontextprotocol/server-aws-kb-retrieval",
+      command: "npx",
+      args: ["-y", "@modelcontextprotocol/server-aws-kb-retrieval"],
+      category: "cloud",
+      tags: ["aws", "bedrock", "knowledge-base", "retrieval", "rag"],
+      transport: "stdio",
+      version: "latest",
+      popularity: 68,
+      verified: true,
+      envVars: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"],
+      installHint: "Set AWS credentials environment variables",
+      updatedAt: "2024-12-01"
+    }
+  ];
+  MCP_REGISTRY_ERRORS = {
+    FETCH_FAILED: "Failed to fetch MCP registry",
+    PARSE_FAILED: "Failed to parse registry data",
+    NOT_FOUND: "No servers found matching your search",
+    INSTALL_FAILED: "Failed to install MCP server",
+    ALREADY_INSTALLED: "Server is already installed"
+  };
+});
+
+// src/services/mcp/registry.ts
+import { homedir as homedir4 } from "os";
+import { join as join13 } from "path";
+var registryCache = null, getCacheFilePath = () => {
+  return join13(homedir4(), ".codetyper", MCP_REGISTRY_CACHE.FILE_NAME);
+}, loadCache = async () => {
+  try {
+    const cachePath = getCacheFilePath();
+    const file2 = Bun.file(cachePath);
+    if (await file2.exists()) {
+      const data = await file2.json();
+      return data;
+    }
+  } catch {}
+  return null;
+}, saveCache = async (cache) => {
+  try {
+    const cachePath = getCacheFilePath();
+    await Bun.write(cachePath, JSON.stringify(cache, null, 2));
+  } catch {}
+}, isCacheValid2 = (cache) => {
+  const now = Date.now();
+  return now - cache.updatedAt < MCP_REGISTRY_CACHE.DURATION_MS;
+}, fetchFromSmithery = async () => {
+  try {
+    const response2 = await fetch(MCP_REGISTRY_SOURCES.SMITHERY);
+    if (!response2.ok) {
+      return [];
+    }
+    const data = await response2.json();
+    if (Array.isArray(data)) {
+      return data.map((server) => ({
+        id: String(server.name || server.id || ""),
+        name: String(server.displayName || server.name || ""),
+        description: String(server.description || ""),
+        author: String(server.author || server.vendor || "Community"),
+        repository: String(server.homepage || server.repository || ""),
+        package: String(server.qualifiedName || server.package || ""),
+        command: "npx",
+        args: ["-y", String(server.qualifiedName || server.package || "")],
+        category: mapCategory(String(server.category || "other")),
+        tags: Array.isArray(server.tags) ? server.tags.map(String) : [],
+        transport: "stdio",
+        version: String(server.version || "latest"),
+        popularity: Number(server.downloads || server.useCount || 0),
+        verified: Boolean(server.verified || server.isOfficial),
+        installHint: String(server.installHint || ""),
+        envVars: Array.isArray(server.environmentVariables) ? server.environmentVariables.map(String) : undefined,
+        updatedAt: String(server.updatedAt || new Date().toISOString())
+      }));
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}, mapCategory = (category) => {
+  const categoryMap = {
+    database: "database",
+    databases: "database",
+    db: "database",
+    filesystem: "filesystem",
+    files: "filesystem",
+    file: "filesystem",
+    web: "web",
+    browser: "web",
+    http: "web",
+    ai: "ai",
+    ml: "ai",
+    "machine-learning": "ai",
+    "dev-tools": "dev-tools",
+    developer: "dev-tools",
+    development: "dev-tools",
+    tools: "dev-tools",
+    productivity: "productivity",
+    communication: "communication",
+    chat: "communication",
+    messaging: "communication",
+    cloud: "cloud",
+    aws: "cloud",
+    gcp: "cloud",
+    azure: "cloud",
+    security: "security"
+  };
+  const normalized = category.toLowerCase().trim();
+  return categoryMap[normalized] || "other";
+}, getAllServers = async (forceRefresh = false) => {
+  if (!forceRefresh && registryCache && isCacheValid2(registryCache)) {
+    return registryCache.servers;
+  }
+  if (!forceRefresh) {
+    const diskCache = await loadCache();
+    if (diskCache && isCacheValid2(diskCache)) {
+      registryCache = diskCache;
+      return diskCache.servers;
+    }
+  }
+  const externalServers = await fetchFromSmithery();
+  const curatedIds = new Set(MCP_CURATED_SERVERS.map((s) => s.id));
+  const filteredExternal = externalServers.filter((s) => !curatedIds.has(s.id));
+  const allServers = [...MCP_CURATED_SERVERS, ...filteredExternal];
+  registryCache = {
+    servers: allServers,
+    updatedAt: Date.now(),
+    source: MCP_REGISTRY_SOURCES.SMITHERY
+  };
+  await saveCache(registryCache);
+  return allServers;
+}, searchServers = async (options2 = {}) => {
+  const {
+    query = "",
+    category,
+    tags,
+    verifiedOnly = false,
+    sortBy = MCP_SEARCH_DEFAULTS.SORT_BY,
+    limit = MCP_SEARCH_DEFAULTS.LIMIT,
+    offset = 0
+  } = options2;
+  const allServers = await getAllServers();
+  let filtered = allServers;
+  if (query) {
+    const lowerQuery = query.toLowerCase();
+    filtered = filtered.filter((server) => {
+      const searchableText = [
+        server.name,
+        server.description,
+        server.author,
+        ...server.tags
+      ].join(" ").toLowerCase();
+      return searchableText.includes(lowerQuery);
+    });
+  }
+  if (category) {
+    filtered = filtered.filter((server) => server.category === category);
+  }
+  if (tags && tags.length > 0) {
+    filtered = filtered.filter((server) => tags.some((tag) => server.tags.some((serverTag) => serverTag.toLowerCase().includes(tag.toLowerCase()))));
+  }
+  if (verifiedOnly) {
+    filtered = filtered.filter((server) => server.verified);
+  }
+  const sortFunctions = {
+    popularity: (a2, b2) => b2.popularity - a2.popularity,
+    name: (a2, b2) => a2.name.localeCompare(b2.name),
+    updated: (a2, b2) => new Date(b2.updatedAt).getTime() - new Date(a2.updatedAt).getTime()
   };
+  filtered.sort(sortFunctions[sortBy] || sortFunctions.popularity);
+  const total = filtered.length;
+  const paginated = filtered.slice(offset, offset + limit);
+  return {
+    servers: paginated,
+    total,
+    query,
+    category
+  };
+}, getServerById = async (id) => {
+  const allServers = await getAllServers();
+  return allServers.find((server) => server.id === id);
+}, isServerInstalled = (serverId) => {
+  const instances = getServerInstances();
+  return instances.some((instance) => instance.config.name === serverId || instance.config.name.toLowerCase() === serverId.toLowerCase());
+}, installServer = async (server, options2 = {}) => {
+  const { global: global3 = false, connect = true, customArgs } = options2;
+  if (isServerInstalled(server.id)) {
+    return {
+      success: false,
+      serverName: server.id,
+      error: MCP_REGISTRY_ERRORS.ALREADY_INSTALLED,
+      connected: false
+    };
+  }
+  try {
+    await addServer({
+      name: server.id,
+      command: server.command,
+      args: customArgs || server.args,
+      transport: server.transport,
+      enabled: true
+    }, global3);
+    let connected = false;
+    if (connect) {
+      try {
+        await connectServer(server.id);
+        connected = true;
+      } catch {}
+    }
+    return {
+      success: true,
+      serverName: server.id,
+      connected
+    };
+  } catch (error49) {
+    return {
+      success: false,
+      serverName: server.id,
+      error: error49 instanceof Error ? error49.message : MCP_REGISTRY_ERRORS.INSTALL_FAILED,
+      connected: false
+    };
+  }
+}, installServerById = async (serverId, options2 = {}) => {
+  const server = await getServerById(serverId);
+  if (!server) {
+    return {
+      success: false,
+      serverName: serverId,
+      error: MCP_REGISTRY_ERRORS.NOT_FOUND,
+      connected: false
+    };
+  }
+  return installServer(server, options2);
+}, getPopularServers = async (limit = 10) => {
+  const allServers = await getAllServers();
+  return allServers.sort((a2, b2) => b2.popularity - a2.popularity).slice(0, limit);
+}, getCategoriesWithCounts = async () => {
+  const allServers = await getAllServers();
+  const counts = new Map;
+  for (const server of allServers) {
+    const current = counts.get(server.category) || 0;
+    counts.set(server.category, current + 1);
+  }
+  return Array.from(counts.entries()).map(([category, count]) => ({ category, count })).sort((a2, b2) => b2.count - a2.count);
+};
+var init_registry2 = __esm(() => {
+  init_mcp_registry();
+  init_manager();
 });
 
 // src/services/mcp/index.ts
 var init_mcp = __esm(() => {
   init_client();
   init_manager();
+  init_registry2();
 });
 
 // src/services/upgrade.ts
@@ -105890,6 +106441,7 @@ ${basePrompt}`;
 // src/commands/components/chat/mcp/handle-mcp.ts
 init_source();
 init_mcp();
+init_mcp_registry();
 
 // src/commands/components/chat/mcp/show-mcp-status.ts
 init_source();
@@ -105953,12 +106505,17 @@ var handleMCP = async (args) => {
     connect: handleConnect,
     disconnect: handleDisconnect,
     tools: handleTools,
-    add: handleAdd
+    add: handleAdd,
+    search: handleSearch,
+    browse: handleBrowse,
+    install: handleInstall,
+    popular: handlePopular,
+    categories: handleCategories
   };
   const handler = handlers[subcommand];
   if (!handler) {
     console.log(source_default.yellow(`Unknown MCP command: ${subcommand}`));
-    console.log(source_default.gray("Available: status, connect, disconnect, tools, add"));
+    console.log(source_default.gray("Available: status, connect, disconnect, tools, add, search, browse, install, popular, categories"));
     return;
   }
   await handler(args.slice(1));
@@ -106035,6 +106592,122 @@ MCP Tools
 var handleAdd = async (_args) => {
   appStore.setMode("mcp_add");
 };
+var handleSearch = async (args) => {
+  const query = args.join(" ");
+  if (!query) {
+    console.log(source_default.yellow(`
+Usage: /mcp search <query>`));
+    console.log(source_default.gray("Example: /mcp search database"));
+    console.log(source_default.gray("Or use /mcp browse for interactive browser"));
+    console.log();
+    return;
+  }
+  console.log(source_default.gray(`
+Searching for "${query}"...`));
+  try {
+    const result = await searchServers({ query, limit: 10 });
+    if (result.servers.length === 0) {
+      console.log(source_default.yellow(`
+No servers found matching your search.`));
+      console.log(source_default.gray("Try /mcp popular to see popular servers"));
+      console.log();
+      return;
+    }
+    console.log(source_default.bold(`
+Found ${result.total} servers:
+`));
+    for (const server of result.servers) {
+      const icon = MCP_CATEGORY_ICONS[server.category];
+      const verified = server.verified ? source_default.green(" ✓") : "";
+      console.log(`${icon} ${source_default.white(server.name)}${verified}`);
+      console.log(`   ${source_default.gray(server.description)}`);
+      console.log(`   ${source_default.cyan("Install:")} /mcp install ${server.id}`);
+      console.log();
+    }
+  } catch (error49) {
+    console.log(source_default.red(`
+Search failed: ${error49}`));
+    console.log();
+  }
+};
+var handleBrowse = async (_args) => {
+  appStore.setMode("mcp_browse");
+};
+var handleInstall = async (args) => {
+  const serverId = args[0];
+  if (!serverId) {
+    console.log(source_default.yellow(`
+Usage: /mcp install <server-id>`));
+    console.log(source_default.gray("Example: /mcp install sqlite"));
+    console.log(source_default.gray("Use /mcp search to find server IDs"));
+    console.log();
+    return;
+  }
+  console.log(source_default.gray(`
+Installing ${serverId}...`));
+  try {
+    const result = await installServerById(serverId, { connect: true });
+    if (result.success) {
+      console.log(source_default.green(`
+✓ Installed ${result.serverName}`));
+      if (result.connected) {
+        console.log(source_default.gray("  Server is now connected"));
+      }
+    } else {
+      console.log(source_default.red(`
+✗ Installation failed: ${result.error}`));
+    }
+    console.log();
+  } catch (error49) {
+    console.log(source_default.red(`
+Installation failed: ${error49}`));
+    console.log();
+  }
+};
+var handlePopular = async (_args) => {
+  console.log(source_default.gray(`
+Fetching popular servers...`));
+  try {
+    const servers = await getPopularServers(10);
+    console.log(source_default.bold(`
+Popular MCP Servers:
+`));
+    for (const server of servers) {
+      const icon = MCP_CATEGORY_ICONS[server.category];
+      const verified = server.verified ? source_default.green(" ✓") : "";
+      console.log(`${icon} ${source_default.white(server.name)}${verified}`);
+      console.log(`   ${source_default.gray(server.description)}`);
+      console.log(`   ${source_default.cyan("Install:")} /mcp install ${server.id}`);
+      console.log();
+    }
+  } catch (error49) {
+    console.log(source_default.red(`
+Failed to fetch servers: ${error49}`));
+    console.log();
+  }
+};
+var handleCategories = async (_args) => {
+  console.log(source_default.gray(`
+Fetching categories...`));
+  try {
+    const categories = await getCategoriesWithCounts();
+    console.log(source_default.bold(`
+MCP Server Categories:
+`));
+    for (const { category, count } of categories) {
+      const icon = MCP_CATEGORY_ICONS[category];
+      const label = MCP_CATEGORY_LABELS[category];
+      console.log(`${icon} ${source_default.white(label)} ${source_default.gray(`(${count} servers)`)}`);
+    }
+    console.log();
+    console.log(source_default.gray("Use /mcp search <category> to filter by category"));
+    console.log();
+  } catch (error49) {
+    console.log(source_default.red(`
+Failed to fetch categories: ${error49}`));
+    console.log();
+  }
+};
 
 // src/commands/components/chat/commands/commandsRegistry.ts
 init_terminal2();
@@ -108272,4 +108945,4 @@ ${plan.steps.map((s) => `${s.id}. ${s.description}`).join(`
 });
 program2.parse(process.argv);
 
-//# debugId=3CA4B0CE347FC5A364756E2164756E21
+//# debugId=A668908B12C6E01864756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codetyper-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CodeTyper AI Agent - Standalone CLI for autonomous code generation",
   "main": "dist/index.js",
   "bin": {

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.2.0"
+  "version": "0.2.1"
 }