mcphosting-cli 0.1.0 → 0.1.1

package/src/index.ts

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-{
-  "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

@@ -1,14 +0,0 @@
-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'
-  }
-});