mcphosting-cli 0.1.0

package/src/index.ts

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import { createAuthCommands, createLegacyAuthCommands } from './commands/auth.js';
+import { 
+  createConnectCommands, 
+  createDisconnectCommand, 
+  createListCommand 
+} from './commands/connect.js';
+import { createImportCommand } from './commands/import.js';
+import { createProxyCommand } from './commands/proxy.js';
+import { createSearchCommand, createInfoCommand } from './commands/search.js';
+import { 
+  createServersCommand, 
+  createKeysCommand, 
+  createPublishCommand 
+} from './commands/servers.js';
+import { Logger } from './lib/logger.js';
+import chalk from 'chalk';
+
+const program = new Command();
+
+program
+  .name('mcphost')
+  .description('Connect AI agents to MCP servers. Browse, install, and manage Model Context Protocol servers.')
+  .version('0.1.0')
+  .configureOutput({
+    outputError: (str, write) => {
+      // Ensure errors go to stderr
+      write(chalk.red(str));
+    }
+  });
+
+// Add the main commands
+program.addCommand(createConnectCommands());
+program.addCommand(createDisconnectCommand());
+program.addCommand(createListCommand());
+program.addCommand(createImportCommand());
+program.addCommand(createProxyCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createInfoCommand());
+
+// Add server management commands
+program.addCommand(createServersCommand());
+program.addCommand(createKeysCommand());
+program.addCommand(createPublishCommand());
+
+// Add auth commands both as subcommands and top-level (backwards compatibility)
+program.addCommand(createAuthCommands());
+const [login, logout, whoami] = createLegacyAuthCommands();
+program.addCommand(login);
+program.addCommand(logout);
+program.addCommand(whoami);
+
+// Custom help
+program.configureHelp({
+  subcommandTerm: (cmd) => chalk.cyan(cmd.name()),
+  commandUsage: (cmd) => {
+    const usage = cmd.usage();
+    return chalk.yellow(usage);
+  },
+  commandDescription: (cmd) => {
+    return chalk.dim(cmd.description());
+  }
+});
+
+// Add custom help examples
+program.addHelpText('after', `
+${chalk.bold('Examples:')}
+  ${chalk.cyan('mcphost connect github')}                    ${chalk.dim('Connect to GitHub MCP server')}
+  ${chalk.cyan('mcphost connect https://my-mcp.example.com')}  ${chalk.dim('Connect to custom MCP server')}
+  ${chalk.cyan('mcphost connect slack --client claude')}      ${chalk.dim('Connect Slack MCP only to Claude')}
+  ${chalk.cyan('mcphost list')}                             ${chalk.dim('List all connected MCP servers')}
+  ${chalk.cyan('mcphost search github')}                    ${chalk.dim('Search marketplace for MCP servers')}
+  ${chalk.cyan('mcphost info notion')}                      ${chalk.dim('Get details about Notion MCP')}
+  ${chalk.cyan('mcphost import --from smithery')}           ${chalk.dim('Import connections from Smithery')}
+  ${chalk.cyan('mcphost disconnect github')}               ${chalk.dim('Remove GitHub MCP connection')}
+
+${chalk.bold('Supported AI Clients:')}
+  • ${chalk.green('Claude Desktop')} - Auto-configured via claude_desktop_config.json
+  • ${chalk.green('Cursor')} - Auto-configured via .cursor/mcp.json  
+  • ${chalk.green('VS Code')} - Configured via .vscode/mcp.json
+  • ${chalk.green('OpenClaw')} - Auto-configured via ~/.openclaw/mcp.json
+  • ${chalk.green('ChatGPT')} - Manual setup with web instructions
+
+${chalk.bold('Get Started:')}
+  ${chalk.dim('1.')} ${chalk.cyan('mcphost search <topic>')}     ${chalk.dim('Find MCP servers')}
+  ${chalk.dim('2.')} ${chalk.cyan('mcphost connect <slug>')}     ${chalk.dim('Connect to your AI clients')}
+  ${chalk.dim('3.')} ${chalk.cyan('mcphost list')}              ${chalk.dim('View your connections')}
+
+${chalk.yellow('⭐ Star us:')} ${chalk.blue('https://github.com/gorlomi-enzo/mcphosting-cli')}
+${chalk.yellow('📚 Docs:')} ${chalk.blue('https://mcphosting.com/docs')}
+`);
+
+// Global error handling
+process.on('uncaughtException', (error) => {
+  Logger.error(`Uncaught error: ${error.message}`);
+  if (process.env.DEBUG) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  Logger.error(`Unhandled rejection: ${reason}`);
+  if (process.env.DEBUG) {
+    console.error(reason);
+  }
+  process.exit(1);
+});
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n');
+  Logger.info('Goodbye! 👋');
+  process.exit(0);
+});
+
+// Parse CLI arguments
+async function main() {
+  try {
+    await program.parseAsync();
+  } catch (error) {
+    Logger.error(`Command failed: ${error}`);
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/src/lib/api.ts

@@ -0,0 +1,137 @@
+import { MCPServer } from '../types.js';
+
+export class MCPHostingAPI {
+  private baseUrl = 'https://mcphosting.com/api';
+  private token?: string;
+
+  constructor(token?: string) {
+    this.token = token;
+  }
+
+  private async request(endpoint: string, options: RequestInit = {}): Promise<any> {
+    // For MVP, always throw to use static fallback
+    // In production, this would make actual HTTP requests
+    throw new Error(`API not available - using static fallback`);
+    
+    // Commented out for MVP - uncomment for production API calls
+    /*
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      ...options.headers as Record<string, string>
+    };
+
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+    }
+
+    return await response.json();
+    */
+  }
+
+  async searchMCPs(query: string): Promise<MCPServer[]> {
+    try {
+      const results = await this.request(`/marketplace/search?q=${encodeURIComponent(query)}`);
+      return results.mcps || [];
+    } catch (error) {
+      // Always fallback to static data for now
+      const staticMCPs = this.getStaticMCPs();
+      return staticMCPs.filter(mcp => 
+        mcp.name.toLowerCase().includes(query.toLowerCase()) ||
+        mcp.description.toLowerCase().includes(query.toLowerCase()) ||
+        mcp.tools.some(tool => tool.toLowerCase().includes(query.toLowerCase()))
+      );
+    }
+  }
+
+  async getMCPInfo(slug: string): Promise<MCPServer | null> {
+    try {
+      const result = await this.request(`/marketplace/mcp/${slug}`);
+      return result.mcp || null;
+    } catch {
+      // Fallback to static data
+      const staticMCPs = this.getStaticMCPs();
+      return staticMCPs.find(mcp => mcp.slug === slug) || null;
+    }
+  }
+
+  async whoami(): Promise<{ email: string; org?: string } | null> {
+    if (!this.token) return null;
+    
+    try {
+      const result = await this.request('/auth/whoami');
+      return result.user;
+    } catch {
+      return null;
+    }
+  }
+
+  private getStaticMCPs(): MCPServer[] {
+    // Curated list of popular MCP servers for fallback
+    return [
+      {
+        slug: 'github',
+        name: 'GitHub MCP',
+        description: 'Access GitHub repositories, issues, and pull requests',
+        url: 'https://github.mcphost.dev',
+        tools: ['read_file', 'list_repos', 'create_issue', 'list_issues'],
+        installs: 15420,
+        author: 'MCPHosting'
+      },
+      {
+        slug: 'slack',
+        name: 'Slack MCP',
+        description: 'Send messages and manage Slack workspaces',
+        url: 'https://slack.mcphost.dev', 
+        tools: ['send_message', 'list_channels', 'get_history'],
+        installs: 8930,
+        author: 'MCPHosting'
+      },
+      {
+        slug: 'notion',
+        name: 'Notion MCP',
+        description: 'Read and write Notion pages and databases',
+        url: 'https://notion.mcphost.dev',
+        tools: ['read_page', 'create_page', 'query_database'],
+        installs: 12450,
+        author: 'MCPHosting'
+      },
+      {
+        slug: 'stripe',
+        name: 'Stripe MCP',
+        description: 'Access Stripe payment and customer data',
+        url: 'https://stripe.mcphost.dev',
+        tools: ['get_customer', 'list_payments', 'create_invoice'],
+        installs: 6720,
+        author: 'MCPHosting'
+      },
+      {
+        slug: 'postgres',
+        name: 'PostgreSQL MCP',
+        description: 'Query PostgreSQL databases safely',
+        url: 'https://postgres.mcphost.dev',
+        tools: ['query', 'describe_table', 'list_tables'],
+        installs: 9180,
+        author: 'MCPHosting'
+      },
+      {
+        slug: 'filesystem',
+        name: 'Filesystem MCP',
+        description: 'Read and write files securely',
+        url: 'https://filesystem.mcphost.dev',
+        tools: ['read_file', 'write_file', 'list_directory'],
+        installs: 18950,
+        author: 'MCPHosting'
+      }
+    ];
+  }
+}

package/src/lib/clients.ts

@@ -0,0 +1,188 @@
+import { readFile, writeFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { mkdir } from 'fs/promises';
+import { ClientConfig, ClaudeConfig, CursorConfig, MCPServerEntry, SupportedClient } from '../types.js';
+import { Logger } from './logger.js';
+
+export class ClientManager {
+  private static getClientPaths(): Record<SupportedClient, string> {
+    const home = homedir();
+    const platform = process.platform;
+    
+    const paths: Record<SupportedClient, string> = {
+      claude: platform === 'win32' 
+        ? join(process.env.APPDATA || '', 'Claude', 'claude_desktop_config.json')
+        : join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+      cursor: join(home, '.cursor', 'mcp.json'),
+      vscode: join(process.cwd(), '.vscode', 'mcp.json'),
+      openclaw: join(home, '.openclaw', 'mcp.json'),
+      chatgpt: '' // Web-based, no local config
+    };
+
+    return paths;
+  }
+
+  static async detectInstalledClients(): Promise<ClientConfig[]> {
+    const paths = this.getClientPaths();
+    const clients: ClientConfig[] = [];
+
+    for (const [name, path] of Object.entries(paths)) {
+      if (name === 'chatgpt') continue; // Skip web-based clients
+      
+      try {
+        await access(path);
+        clients.push({ name, configPath: path, exists: true });
+      } catch {
+        clients.push({ name, configPath: path, exists: false });
+      }
+    }
+
+    return clients;
+  }
+
+  static async addToClient(
+    client: SupportedClient,
+    slug: string,
+    url: string
+  ): Promise<boolean> {
+    if (client === 'chatgpt') {
+      Logger.info('ChatGPT Setup Instructions:');
+      console.log(`
+1. Open ChatGPT in your browser
+2. Go to Settings → Apps → Connect an app
+3. Enter this URL: ${url}
+4. Follow the prompts to authorize the MCP server
+      `);
+      return true;
+    }
+
+    const paths = this.getClientPaths();
+    const configPath = paths[client];
+    
+    if (!configPath) {
+      throw new Error(`Unsupported client: ${client}`);
+    }
+
+    const serverEntry: MCPServerEntry = {
+      command: 'npx',
+      args: ['-y', '@mcphosting/cli', 'proxy', url],
+      env: {}
+    };
+
+    try {
+      // Ensure directory exists
+      await mkdir(dirname(configPath), { recursive: true });
+
+      let config: ClaudeConfig | CursorConfig = { mcpServers: {} };
+
+      // Read existing config if it exists
+      try {
+        const configContent = await readFile(configPath, 'utf-8');
+        config = JSON.parse(configContent);
+        if (!config.mcpServers) {
+          config.mcpServers = {};
+        }
+      } catch {
+        // File doesn't exist or is invalid, use default config
+      }
+
+      // Add the MCP server
+      config.mcpServers[slug] = serverEntry;
+
+      // Write back to file
+      await writeFile(configPath, JSON.stringify(config, null, 2));
+      return true;
+    } catch (error) {
+      Logger.error(`Failed to configure ${client}: ${error}`);
+      return false;
+    }
+  }
+
+  static async removeFromClient(
+    client: SupportedClient,
+    slug: string
+  ): Promise<boolean> {
+    if (client === 'chatgpt') {
+      Logger.info('To remove from ChatGPT:');
+      console.log(`
+1. Open ChatGPT in your browser
+2. Go to Settings → Apps
+3. Find and disconnect the MCP server: ${slug}
+      `);
+      return true;
+    }
+
+    const paths = this.getClientPaths();
+    const configPath = paths[client];
+    
+    if (!configPath) {
+      throw new Error(`Unsupported client: ${client}`);
+    }
+
+    try {
+      const configContent = await readFile(configPath, 'utf-8');
+      const config: ClaudeConfig | CursorConfig = JSON.parse(configContent);
+
+      if (config.mcpServers && config.mcpServers[slug]) {
+        delete config.mcpServers[slug];
+        await writeFile(configPath, JSON.stringify(config, null, 2));
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      Logger.error(`Failed to remove from ${client}: ${error}`);
+      return false;
+    }
+  }
+
+  static async removeFromAllClients(slug: string): Promise<string[]> {
+    const clients = await this.detectInstalledClients();
+    const removed: string[] = [];
+
+    for (const client of clients) {
+      if (!client.exists) continue;
+      
+      try {
+        const success = await this.removeFromClient(client.name as SupportedClient, slug);
+        if (success) {
+          removed.push(client.name);
+        }
+      } catch (error) {
+        Logger.warning(`Failed to remove from ${client.name}: ${error}`);
+      }
+    }
+
+    return removed;
+  }
+
+  static resolveUrl(urlOrSlug: string): string {
+    // If it's already a full URL, return as-is
+    if (urlOrSlug.startsWith('http://') || urlOrSlug.startsWith('https://')) {
+      return urlOrSlug;
+    }
+
+    // Otherwise, assume it's a slug and construct the mcphost.dev URL
+    return `https://${urlOrSlug}.mcphost.dev`;
+  }
+
+  static extractSlug(url: string): string {
+    // Extract slug from URLs like https://myserver.mcphost.dev
+    if (url.includes('.mcphost.dev')) {
+      const match = url.match(/https?:\/\/([^.]+)\.mcphost\.dev/);
+      if (match) {
+        return match[1];
+      }
+    }
+
+    // For other URLs, use the hostname or a hash of the URL
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname.replace(/\./g, '-');
+    } catch {
+      // If URL parsing fails, create a simple hash
+      return url.replace(/[^a-zA-Z0-9]/g, '-').slice(0, 20);
+    }
+  }
+}

package/src/lib/config.ts

@@ -0,0 +1,90 @@
+import Conf from 'conf';
+import { MCPConfig, MCPConnection } from '../types.js';
+
+export class Config {
+  private conf: Conf<MCPConfig>;
+  private connectionsConf: Conf<{ connections: MCPConnection[] }>;
+
+  constructor() {
+    this.conf = new Conf<MCPConfig>({
+      projectName: 'mcphosting',
+      defaults: {}
+    });
+    
+    this.connectionsConf = new Conf<{ connections: MCPConnection[] }>({
+      projectName: 'mcphosting',
+      configName: 'connections',
+      defaults: { connections: [] }
+    });
+  }
+
+  get token(): string | undefined {
+    return this.conf.get('token');
+  }
+
+  set token(value: string | undefined) {
+    if (value) {
+      this.conf.set('token', value);
+    } else {
+      this.conf.delete('token');
+    }
+  }
+
+  get user() {
+    return this.conf.get('user');
+  }
+
+  set user(value: { email: string; org?: string } | undefined) {
+    if (value) {
+      this.conf.set('user', value);
+    } else {
+      this.conf.delete('user');
+    }
+  }
+
+  get connections(): MCPConnection[] {
+    return this.connectionsConf.get('connections', []);
+  }
+
+  addConnection(connection: Omit<MCPConnection, 'id' | 'addedAt'>): MCPConnection {
+    const connections = this.connections;
+    const newConnection: MCPConnection = {
+      ...connection,
+      id: Math.random().toString(36).substr(2, 9),
+      addedAt: Date.now()
+    };
+    
+    connections.push(newConnection);
+    this.connectionsConf.set('connections', connections);
+    return newConnection;
+  }
+
+  removeConnection(id: string): boolean {
+    const connections = this.connections;
+    const index = connections.findIndex(c => c.id === id || c.slug === id);
+    if (index === -1) return false;
+    
+    connections.splice(index, 1);
+    this.connectionsConf.set('connections', connections);
+    return true;
+  }
+
+  findConnection(slugOrId: string): MCPConnection | undefined {
+    return this.connections.find(c => c.id === slugOrId || c.slug === slugOrId);
+  }
+
+  updateConnection(id: string, updates: Partial<MCPConnection>): boolean {
+    const connections = this.connections;
+    const index = connections.findIndex(c => c.id === id);
+    if (index === -1) return false;
+    
+    connections[index] = { ...connections[index], ...updates };
+    this.connectionsConf.set('connections', connections);
+    return true;
+  }
+
+  clear(): void {
+    this.conf.clear();
+    this.connectionsConf.clear();
+  }
+}

package/src/lib/logger.ts

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import ora, { Ora } from 'ora';
+
+export class Logger {
+  static info(message: string): void {
+    console.log(chalk.blue('ℹ'), message);
+  }
+
+  static success(message: string): void {
+    console.log(chalk.green('✓'), message);
+  }
+
+  static warning(message: string): void {
+    console.log(chalk.yellow('⚠'), message);
+  }
+
+  static error(message: string): void {
+    console.error(chalk.red('✗'), message);
+  }
+
+  static dim(message: string): void {
+    console.log(chalk.dim(message));
+  }
+
+  static bold(message: string): void {
+    console.log(chalk.bold(message));
+  }
+
+  static spinner(text: string): Ora {
+    return ora(text).start();
+  }
+
+  static table(data: Array<Record<string, any>>, headers?: string[]): void {
+    if (data.length === 0) {
+      Logger.dim('No data to display');
+      return;
+    }
+
+    const keys = headers || Object.keys(data[0]);
+    const maxWidths = keys.map(key => 
+      Math.max(key.length, ...data.map(row => String(row[key] || '').length))
+    );
+
+    // Header
+    const headerRow = keys.map((key, i) => 
+      chalk.bold(key.padEnd(maxWidths[i]))
+    ).join(' | ');
+    console.log(headerRow);
+    console.log(keys.map((_, i) => '-'.repeat(maxWidths[i])).join('-|-'));
+
+    // Data rows
+    data.forEach(row => {
+      const dataRow = keys.map((key, i) => 
+        String(row[key] || '').padEnd(maxWidths[i])
+      ).join(' | ');
+      console.log(dataRow);
+    });
+  }
+
+  static json(data: any): void {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}

package/src/types.ts

@@ -0,0 +1,47 @@
+export interface MCPConfig {
+  token?: string;
+  user?: {
+    email: string;
+    org?: string;
+  };
+}
+
+export interface MCPConnection {
+  id: string;
+  slug: string;
+  url: string;
+  clients: string[];
+  addedAt: number;
+}
+
+export interface ClientConfig {
+  name: string;
+  configPath: string;
+  exists: boolean;
+}
+
+export interface MCPServer {
+  slug: string;
+  name: string;
+  description: string;
+  url?: string;
+  tools: string[];
+  installs: number;
+  author: string;
+}
+
+export interface MCPServerEntry {
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+}
+
+export interface ClaudeConfig {
+  mcpServers: Record<string, MCPServerEntry>;
+}
+
+export interface CursorConfig {
+  mcpServers: Record<string, MCPServerEntry>;
+}
+
+export type SupportedClient = 'claude' | 'cursor' | 'vscode' | 'openclaw' | 'chatgpt';

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  shims: true,
+  banner: {
+    js: '#!/usr/bin/env node'
+  }
+});