mcphosting-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1159 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command7 } from "commander";
+
+// src/commands/auth.ts
+import { Command } from "commander";
+import { createServer } from "http";
+import open from "open";
+
+// src/lib/config.ts
+import Conf from "conf";
+var Config = class {
+  conf;
+  connectionsConf;
+  constructor() {
+    this.conf = new Conf({
+      projectName: "mcphosting",
+      defaults: {}
+    });
+    this.connectionsConf = new Conf({
+      projectName: "mcphosting",
+      configName: "connections",
+      defaults: { connections: [] }
+    });
+  }
+  get token() {
+    return this.conf.get("token");
+  }
+  set token(value) {
+    if (value) {
+      this.conf.set("token", value);
+    } else {
+      this.conf.delete("token");
+    }
+  }
+  get user() {
+    return this.conf.get("user");
+  }
+  set user(value) {
+    if (value) {
+      this.conf.set("user", value);
+    } else {
+      this.conf.delete("user");
+    }
+  }
+  get connections() {
+    return this.connectionsConf.get("connections", []);
+  }
+  addConnection(connection) {
+    const connections = this.connections;
+    const newConnection = {
+      ...connection,
+      id: Math.random().toString(36).substr(2, 9),
+      addedAt: Date.now()
+    };
+    connections.push(newConnection);
+    this.connectionsConf.set("connections", connections);
+    return newConnection;
+  }
+  removeConnection(id) {
+    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) {
+    return this.connections.find((c) => c.id === slugOrId || c.slug === slugOrId);
+  }
+  updateConnection(id, updates) {
+    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() {
+    this.conf.clear();
+    this.connectionsConf.clear();
+  }
+};
+
+// src/lib/api.ts
+var MCPHostingAPI = class {
+  baseUrl = "https://mcphosting.com/api";
+  token;
+  constructor(token) {
+    this.token = token;
+  }
+  async request(endpoint, options = {}) {
+    throw new Error(`API not available - using static fallback`);
+  }
+  async searchMCPs(query) {
+    try {
+      const results = await this.request(`/marketplace/search?q=${encodeURIComponent(query)}`);
+      return results.mcps || [];
+    } catch (error) {
+      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) {
+    try {
+      const result = await this.request(`/marketplace/mcp/${slug}`);
+      return result.mcp || null;
+    } catch {
+      const staticMCPs = this.getStaticMCPs();
+      return staticMCPs.find((mcp) => mcp.slug === slug) || null;
+    }
+  }
+  async whoami() {
+    if (!this.token) return null;
+    try {
+      const result = await this.request("/auth/whoami");
+      return result.user;
+    } catch {
+      return null;
+    }
+  }
+  getStaticMCPs() {
+    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"
+      }
+    ];
+  }
+};
+
+// src/lib/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var Logger = class _Logger {
+  static info(message) {
+    console.log(chalk.blue("\u2139"), message);
+  }
+  static success(message) {
+    console.log(chalk.green("\u2713"), message);
+  }
+  static warning(message) {
+    console.log(chalk.yellow("\u26A0"), message);
+  }
+  static error(message) {
+    console.error(chalk.red("\u2717"), message);
+  }
+  static dim(message) {
+    console.log(chalk.dim(message));
+  }
+  static bold(message) {
+    console.log(chalk.bold(message));
+  }
+  static spinner(text) {
+    return ora(text).start();
+  }
+  static table(data, headers) {
+    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))
+    );
+    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.forEach((row) => {
+      const dataRow = keys.map(
+        (key, i) => String(row[key] || "").padEnd(maxWidths[i])
+      ).join(" | ");
+      console.log(dataRow);
+    });
+  }
+  static json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+};
+
+// src/commands/auth.ts
+function createAuthCommands() {
+  const auth = new Command("auth");
+  auth.command("login").description("Authenticate with MCPHosting").option("--token <token>", "Provide API token directly").action(async (options) => {
+    const config = new Config();
+    if (options.token) {
+      config.token = options.token;
+      const api = new MCPHostingAPI(options.token);
+      const user = await api.whoami();
+      if (user) {
+        config.user = user;
+        Logger.success(`Logged in as ${user.email}${user.org ? ` (${user.org})` : ""}`);
+      } else {
+        Logger.warning("Token saved, but could not verify user info");
+      }
+      return;
+    }
+    const spinner = Logger.spinner("Starting login flow...");
+    let server;
+    let resolved = false;
+    try {
+      const authPromise = new Promise((resolve, reject) => {
+        server = createServer((req, res) => {
+          if (req.url?.startsWith("/callback")) {
+            const url = new URL(req.url, "http://localhost");
+            const token2 = url.searchParams.get("token");
+            if (token2) {
+              res.writeHead(200, { "Content-Type": "text/html" });
+              res.end(`
+                  <html>
+                    <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                      <h2>\u2705 Login Successful!</h2>
+                      <p>You can now close this window and return to your terminal.</p>
+                    </body>
+                  </html>
+                `);
+              resolve(token2);
+            } else {
+              res.writeHead(400, { "Content-Type": "text/html" });
+              res.end(`
+                  <html>
+                    <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                      <h2>\u274C Login Failed</h2>
+                      <p>No token received. Please try again.</p>
+                    </body>
+                  </html>
+                `);
+              reject(new Error("No token received"));
+            }
+          } else {
+            res.writeHead(404);
+            res.end("Not found");
+          }
+        });
+        server.listen(0, () => {
+          const port = server.address().port;
+          const callbackUrl = `http://localhost:${port}/callback`;
+          const authUrl = `https://mcphosting.com/cli/auth?callback=${encodeURIComponent(callbackUrl)}`;
+          setTimeout(() => {
+            if (!resolved) {
+              reject(new Error("Login timeout - please try again"));
+            }
+          }, 12e4);
+          open(authUrl).catch(() => {
+            Logger.warning(`Could not open browser automatically. Please visit: ${authUrl}`);
+          });
+        });
+      });
+      const token = await authPromise;
+      resolved = true;
+      spinner.succeed("Login successful!");
+      config.token = token;
+      const api = new MCPHostingAPI(token);
+      const user = await api.whoami();
+      if (user) {
+        config.user = user;
+        Logger.success(`Logged in as ${user.email}${user.org ? ` (${user.org})` : ""}`);
+      }
+    } catch (error) {
+      spinner.fail("Login failed");
+      Logger.error(`Login error: ${error}`);
+      process.exit(1);
+    } finally {
+      if (server) {
+        server.close();
+      }
+    }
+  });
+  auth.command("logout").description("Remove stored authentication").action(() => {
+    const config = new Config();
+    config.token = void 0;
+    config.user = void 0;
+    Logger.success("Logged out successfully");
+  });
+  auth.command("whoami").description("Show current user information").action(async () => {
+    const config = new Config();
+    const token = config.token;
+    if (!token) {
+      Logger.warning("Not logged in. Use `mcphost auth login` to authenticate.");
+      return;
+    }
+    const user = config.user;
+    if (user) {
+      Logger.info(`Logged in as: ${user.email}${user.org ? ` (${user.org})` : ""}`);
+    } else {
+      Logger.warning("User info not available. Try logging in again.");
+    }
+  });
+  return auth;
+}
+function createLegacyAuthCommands() {
+  const config = new Config();
+  const login2 = new Command("login").description("Authenticate with MCPHosting").option("--token <token>", "Provide API token directly").action(async (options) => {
+    const authCmd = createAuthCommands();
+    const loginCmd = authCmd.commands.find((cmd) => cmd.name() === "login");
+    if (loginCmd) {
+      await loginCmd.action(options);
+    }
+  });
+  const logout2 = new Command("logout").description("Remove stored authentication").action(() => {
+    config.token = void 0;
+    config.user = void 0;
+    Logger.success("Logged out successfully");
+  });
+  const whoami2 = new Command("whoami").description("Show current user information").action(async () => {
+    const authCmd = createAuthCommands();
+    const whoamiCmd = authCmd.commands.find((cmd) => cmd.name() === "whoami");
+    if (whoamiCmd) {
+      await whoamiCmd.action();
+    }
+  });
+  return [login2, logout2, whoami2];
+}
+
+// src/commands/connect.ts
+import { Command as Command2 } from "commander";
+
+// src/lib/clients.ts
+import { readFile, writeFile, access } from "fs/promises";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { mkdir } from "fs/promises";
+var ClientManager = class {
+  static getClientPaths() {
+    const home = homedir();
+    const platform = process.platform;
+    const paths = {
+      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() {
+    const paths = this.getClientPaths();
+    const clients = [];
+    for (const [name, path] of Object.entries(paths)) {
+      if (name === "chatgpt") continue;
+      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, slug, url) {
+    if (client === "chatgpt") {
+      Logger.info("ChatGPT Setup Instructions:");
+      console.log(`
+1. Open ChatGPT in your browser
+2. Go to Settings \u2192 Apps \u2192 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 = {
+      command: "npx",
+      args: ["-y", "@mcphosting/cli", "proxy", url],
+      env: {}
+    };
+    try {
+      await mkdir(dirname(configPath), { recursive: true });
+      let config = { mcpServers: {} };
+      try {
+        const configContent = await readFile(configPath, "utf-8");
+        config = JSON.parse(configContent);
+        if (!config.mcpServers) {
+          config.mcpServers = {};
+        }
+      } catch {
+      }
+      config.mcpServers[slug] = serverEntry;
+      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, slug) {
+    if (client === "chatgpt") {
+      Logger.info("To remove from ChatGPT:");
+      console.log(`
+1. Open ChatGPT in your browser
+2. Go to Settings \u2192 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 = 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) {
+    const clients = await this.detectInstalledClients();
+    const removed = [];
+    for (const client of clients) {
+      if (!client.exists) continue;
+      try {
+        const success = await this.removeFromClient(client.name, slug);
+        if (success) {
+          removed.push(client.name);
+        }
+      } catch (error) {
+        Logger.warning(`Failed to remove from ${client.name}: ${error}`);
+      }
+    }
+    return removed;
+  }
+  static resolveUrl(urlOrSlug) {
+    if (urlOrSlug.startsWith("http://") || urlOrSlug.startsWith("https://")) {
+      return urlOrSlug;
+    }
+    return `https://${urlOrSlug}.mcphost.dev`;
+  }
+  static extractSlug(url) {
+    if (url.includes(".mcphost.dev")) {
+      const match = url.match(/https?:\/\/([^.]+)\.mcphost\.dev/);
+      if (match) {
+        return match[1];
+      }
+    }
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname.replace(/\./g, "-");
+    } catch {
+      return url.replace(/[^a-zA-Z0-9]/g, "-").slice(0, 20);
+    }
+  }
+};
+
+// src/commands/connect.ts
+import chalk2 from "chalk";
+function createConnectCommands() {
+  const connect = new Command2("connect").description("Connect an MCP server to AI clients").argument("<url-or-slug>", "MCP server URL or slug").option("--client <client>", "Target specific client (claude, cursor, vscode, openclaw, chatgpt)").option("--name <name>", "Custom name for the connection").action(async (urlOrSlug, options) => {
+    const config = new Config();
+    const spinner = Logger.spinner("Setting up MCP connection...");
+    try {
+      const url = ClientManager.resolveUrl(urlOrSlug);
+      const slug = ClientManager.extractSlug(url);
+      const name = options.name || slug;
+      const existing = config.findConnection(slug);
+      if (existing) {
+        spinner.warn(`Already connected to ${slug}`);
+        Logger.info(`Use \`mcphost disconnect ${slug}\` to remove first`);
+        return;
+      }
+      const clients = [];
+      if (options.client) {
+        const clientName = options.client;
+        const success = await ClientManager.addToClient(clientName, slug, url);
+        if (success) {
+          clients.push(clientName);
+          spinner.succeed(`Connected to ${clientName}`);
+        } else {
+          spinner.fail(`Failed to connect to ${clientName}`);
+          process.exit(1);
+        }
+      } else {
+        const detectedClients = await ClientManager.detectInstalledClients();
+        const availableClients = detectedClients.filter((c) => c.exists);
+        if (availableClients.length === 0) {
+          spinner.warn("No supported clients found");
+          Logger.info("Supported clients: Claude Desktop, Cursor, VS Code, OpenClaw");
+          Logger.info("Install a client and try again, or use --client chatgpt for web setup");
+          return;
+        }
+        spinner.text = `Configuring ${availableClients.length} client${availableClients.length > 1 ? "s" : ""}...`;
+        for (const client of availableClients) {
+          try {
+            const success = await ClientManager.addToClient(
+              client.name,
+              slug,
+              url
+            );
+            if (success) {
+              clients.push(client.name);
+            }
+          } catch (error) {
+            Logger.warning(`Failed to configure ${client.name}: ${error}`);
+          }
+        }
+        spinner.succeed(`Connected to ${clients.length} client${clients.length > 1 ? "s" : ""}`);
+      }
+      config.addConnection({
+        slug,
+        url,
+        clients
+      });
+      Logger.success(`\u{1F517} ${name} connected successfully!`);
+      Logger.dim(`   URL: ${url}`);
+      Logger.dim(`   Clients: ${clients.join(", ")}`);
+      console.log("\n" + chalk2.green("\u{1F389} Connected! Share with your team:"));
+      console.log(chalk2.cyan(`npx @mcphosting/cli connect ${urlOrSlug}`));
+      console.log("\n" + chalk2.yellow("\u2B50 Star us: ") + chalk2.blue("https://github.com/gorlomi-enzo/mcphosting-cli"));
+      console.log("");
+    } catch (error) {
+      spinner.fail("Connection failed");
+      Logger.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  });
+  return connect;
+}
+function createDisconnectCommand() {
+  return new Command2("disconnect").description("Disconnect an MCP server").argument("<slug-or-id>", "MCP server slug or connection ID").action(async (slugOrId) => {
+    const config = new Config();
+    const connection = config.findConnection(slugOrId);
+    if (!connection) {
+      Logger.error(`Connection not found: ${slugOrId}`);
+      Logger.info("Use `mcphost list` to see active connections");
+      return;
+    }
+    const spinner = Logger.spinner(`Disconnecting ${connection.slug}...`);
+    try {
+      const removedFrom = await ClientManager.removeFromAllClients(connection.slug);
+      config.removeConnection(connection.id);
+      spinner.succeed(`Disconnected ${connection.slug}`);
+      if (removedFrom.length > 0) {
+        Logger.info(`Removed from: ${removedFrom.join(", ")}`);
+      }
+    } catch (error) {
+      spinner.fail("Disconnect failed");
+      Logger.error(`Error: ${error}`);
+    }
+  });
+}
+function createListCommand() {
+  return new Command2("list").description("List connected MCP servers").option("--json", "Output as JSON").action(async (options) => {
+    const config = new Config();
+    const connections = config.connections;
+    if (connections.length === 0) {
+      Logger.info("No MCP connections found");
+      Logger.dim("Use `mcphost connect <url>` to add one");
+      return;
+    }
+    if (options.json) {
+      Logger.json(connections);
+      return;
+    }
+    Logger.bold(`\u{1F4CB} Connected MCP Servers (${connections.length})`);
+    console.log("");
+    const tableData = connections.map((conn) => ({
+      Slug: conn.slug,
+      URL: conn.url.length > 50 ? conn.url.slice(0, 47) + "..." : conn.url,
+      Clients: conn.clients.join(", "),
+      Added: new Date(conn.addedAt).toLocaleDateString()
+    }));
+    Logger.table(tableData);
+    console.log("");
+    Logger.dim("Use `mcphost disconnect <slug>` to remove a connection");
+  });
+}
+
+// src/commands/import.ts
+import { Command as Command3 } from "commander";
+import { readFile as readFile2, access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import chalk3 from "chalk";
+function createImportCommand() {
+  return new Command3("import").description("Import MCP connections from other tools").option("--from <tool>", "Import from: smithery", "smithery").option("--dry-run", "Show what would be imported without actually importing").option("--config-path <path>", "Custom config file path").action(async (options) => {
+    if (options.from !== "smithery") {
+      Logger.error("Only Smithery import is currently supported");
+      Logger.info("Usage: mcphost import --from smithery");
+      return;
+    }
+    await importFromSmitery(options);
+  });
+}
+async function importFromSmitery(options) {
+  const config = new Config();
+  const spinner = Logger.spinner("Looking for Smithery config...");
+  try {
+    const smitheryPaths = [
+      options.configPath,
+      join2(homedir2(), ".smithery", "config.json"),
+      join2(homedir2(), ".config", "smithery", "config.json"),
+      join2(homedir2(), "Library", "Application Support", "smithery", "config.json"),
+      join2(process.cwd(), "smithery.json"),
+      join2(process.cwd(), ".smithery.json")
+    ].filter(Boolean);
+    let smitheryConfigPath = null;
+    for (const path of smitheryPaths) {
+      try {
+        await access2(path);
+        smitheryConfigPath = path;
+        break;
+      } catch {
+      }
+    }
+    if (!smitheryConfigPath) {
+      spinner.fail("Smithery config not found");
+      Logger.warning("Searched locations:");
+      smitheryPaths.forEach((path) => Logger.dim(`  ${path}`));
+      Logger.info("\nIf Smithery is installed, you can specify the config path:");
+      Logger.info("  mcphost import --from smithery --config-path /path/to/smithery/config.json");
+      return;
+    }
+    spinner.succeed(`Found Smithery config: ${smitheryConfigPath}`);
+    const loadSpinner = Logger.spinner("Reading Smithery config...");
+    const configContent = await readFile2(smitheryConfigPath, "utf-8");
+    const smitheryConfig = JSON.parse(configContent);
+    const servers = {
+      ...smitheryConfig.servers,
+      ...smitheryConfig.mcpServers
+    };
+    if (!servers || Object.keys(servers).length === 0) {
+      loadSpinner.warn("No MCP servers found in Smithery config");
+      return;
+    }
+    const serverEntries = Object.entries(servers);
+    loadSpinner.succeed(`Found ${serverEntries.length} MCP server(s) in Smithery config`);
+    if (options.dryRun) {
+      console.log("\n" + chalk3.bold("\u{1F50D} Preview: Would import the following MCP servers:"));
+      console.log("");
+      serverEntries.forEach(([slug, serverConfig]) => {
+        const url = serverConfig.url || `https://${slug}.mcphost.dev`;
+        console.log(`\u2022 ${chalk3.cyan(slug)}`);
+        console.log(`  URL: ${chalk3.dim(url)}`);
+        if (serverConfig.command) {
+          console.log(`  Command: ${chalk3.dim(serverConfig.command + " " + (serverConfig.args?.join(" ") || ""))}`);
+        }
+        console.log("");
+      });
+      Logger.info("Run without --dry-run to perform the import");
+      return;
+    }
+    const importSpinner = Logger.spinner("Importing MCP servers...");
+    let imported = 0;
+    let skipped = 0;
+    for (const [slug, serverConfig] of serverEntries) {
+      try {
+        const existing = config.findConnection(slug);
+        if (existing) {
+          Logger.warning(`Skipping ${slug} - already connected`);
+          skipped++;
+          continue;
+        }
+        let url = serverConfig.url;
+        if (!url) {
+          if (serverConfig.command === "npx" && serverConfig.args?.[0] === "@mcphosting/cli") {
+            url = serverConfig.args[2];
+          } else {
+            url = `https://${slug}.mcphost.dev`;
+          }
+        }
+        if (!url) {
+          Logger.warning(`Skipping ${slug} - no URL found`);
+          skipped++;
+          continue;
+        }
+        const detectedClients = await ClientManager.detectInstalledClients();
+        const availableClients = detectedClients.filter((c) => c.exists);
+        const connectedClients = [];
+        for (const client of availableClients) {
+          try {
+            const success = await ClientManager.addToClient(
+              client.name,
+              slug,
+              url
+            );
+            if (success) {
+              connectedClients.push(client.name);
+            }
+          } catch (error) {
+          }
+        }
+        config.addConnection({
+          slug,
+          url,
+          clients: connectedClients
+        });
+        imported++;
+      } catch (error) {
+        Logger.warning(`Failed to import ${slug}: ${error}`);
+        skipped++;
+      }
+    }
+    importSpinner.succeed("Import completed");
+    Logger.success(`\u2705 Imported ${imported} MCP server(s)`);
+    if (skipped > 0) {
+      Logger.warning(`\u26A0\uFE0F  Skipped ${skipped} server(s)`);
+    }
+    console.log("");
+    Logger.info("Use `mcphost list` to see your imported connections");
+    console.log("\n" + chalk3.green("\u{1F389} Welcome to MCPHosting! Share with your team:"));
+    console.log(chalk3.cyan("npx @mcphosting/cli import --from smithery"));
+    console.log("\n" + chalk3.yellow("\u2B50 Star us: ") + chalk3.blue("https://github.com/gorlomi-enzo/mcphosting-cli"));
+    console.log("");
+  } catch (error) {
+    spinner.fail("Import failed");
+    Logger.error(`Error: ${error}`);
+    if (error instanceof SyntaxError) {
+      Logger.warning("Invalid JSON in Smithery config file");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/proxy.ts
+import { Command as Command4 } from "commander";
+function createProxyCommand() {
+  return new Command4("proxy").description("Start a local STDIO MCP proxy to a remote server").argument("<url>", "Remote MCP server URL").option("--quiet", "Suppress startup messages").action(async (url, options) => {
+    if (!options.quiet) {
+      console.error("\u{1F517} Proxying via mcphosting.com");
+      console.error(`\u{1F4E1} Remote server: ${url}`);
+    }
+    try {
+      await startProxy(url, options.quiet);
+    } catch (error) {
+      if (!options.quiet) {
+        console.error(`\u274C Proxy error: ${error}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+async function startProxy(url, quiet = false) {
+  let buffer = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", async (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          await forwardMessage(url, line, quiet);
+        } catch (error) {
+          if (!quiet) {
+            console.error(`Proxy error: ${error}`);
+          }
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              code: -32603,
+              message: "Proxy error",
+              data: error.toString()
+            }
+          };
+          process.stdout.write(JSON.stringify(errorResponse) + "\n");
+        }
+      }
+    }
+  });
+  process.stdin.on("end", () => {
+    if (!quiet) {
+      console.error("\u{1F4F4} Proxy connection closed");
+    }
+    process.exit(0);
+  });
+  process.stdin.on("error", (error) => {
+    if (!quiet) {
+      console.error(`Stdin error: ${error}`);
+    }
+    process.exit(1);
+  });
+  await new Promise(() => {
+  });
+}
+async function forwardMessage(url, message, quiet) {
+  try {
+    const jsonrpcMessage = JSON.parse(message);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "User-Agent": "@mcphosting/cli-proxy"
+      },
+      body: message
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const responseData = await response.text();
+    process.stdout.write(responseData);
+    if (!responseData.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      const errorResponse = {
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: "Parse error",
+          data: "Invalid JSON-RPC message"
+        }
+      };
+      process.stdout.write(JSON.stringify(errorResponse) + "\n");
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/commands/search.ts
+import { Command as Command5 } from "commander";
+import chalk4 from "chalk";
+function createSearchCommand() {
+  return new Command5("search").description("Search MCP servers in the marketplace").argument("<query>", "Search query").option("--limit <number>", "Maximum number of results", "10").option("--json", "Output as JSON").action(async (query, options) => {
+    const config = new Config();
+    const api = new MCPHostingAPI(config.token);
+    const spinner = Logger.spinner(`Searching for "${query}"...`);
+    try {
+      const results = await api.searchMCPs(query);
+      spinner.succeed(`Found ${results.length} MCP server(s)`);
+      if (results.length === 0) {
+        Logger.info("No MCP servers found matching your query");
+        Logger.dim("Try searching for: github, slack, notion, stripe, postgres, filesystem");
+        return;
+      }
+      const limit = parseInt(options.limit);
+      const limitedResults = results.slice(0, limit);
+      if (options.json) {
+        Logger.json(limitedResults);
+        return;
+      }
+      console.log("");
+      Logger.bold(`\u{1F50D} MCP Marketplace Search Results`);
+      console.log("");
+      limitedResults.forEach((server, index) => {
+        console.log(chalk4.cyan(`${index + 1}. ${server.name}`));
+        console.log(`   ${chalk4.dim(server.description)}`);
+        console.log(`   ${chalk4.yellow("Slug:")} ${server.slug} | ${chalk4.yellow("Installs:")} ${server.installs.toLocaleString()} | ${chalk4.yellow("Author:")} ${server.author}`);
+        console.log(`   ${chalk4.green("Tools:")} ${server.tools.join(", ")}`);
+        if (server.url) {
+          console.log(`   ${chalk4.blue("Connect:")} ${chalk4.dim(`mcphost connect ${server.slug}`)}`);
+        }
+        console.log("");
+      });
+      if (results.length > limit) {
+        Logger.dim(`Showing ${limit} of ${results.length} results. Use --limit to see more.`);
+      }
+      Logger.info("Use `mcphost info <slug>` for detailed information");
+      Logger.info("Use `mcphost connect <slug>` to install");
+    } catch (error) {
+      spinner.fail("Search failed");
+      Logger.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  });
+}
+function createInfoCommand() {
+  return new Command5("info").description("Show detailed information about an MCP server").argument("<slug>", "MCP server slug").option("--json", "Output as JSON").action(async (slug, options) => {
+    const config = new Config();
+    const api = new MCPHostingAPI(config.token);
+    const spinner = Logger.spinner(`Getting info for ${slug}...`);
+    try {
+      const server = await api.getMCPInfo(slug);
+      if (!server) {
+        spinner.fail(`MCP server not found: ${slug}`);
+        Logger.info("Use `mcphost search <query>` to find servers");
+        return;
+      }
+      spinner.succeed("Found server info");
+      if (options.json) {
+        Logger.json(server);
+        return;
+      }
+      console.log("");
+      console.log(chalk4.bold.cyan(`\u{1F4E6} ${server.name}`));
+      console.log(chalk4.dim(server.description));
+      console.log("");
+      const infoTable = [
+        { Property: "Slug", Value: server.slug },
+        { Property: "Author", Value: server.author },
+        { Property: "Installs", Value: server.installs.toLocaleString() },
+        { Property: "Tools", Value: server.tools.length.toString() }
+      ];
+      if (server.url) {
+        infoTable.push({ Property: "URL", Value: server.url });
+      }
+      Logger.table(infoTable);
+      console.log("");
+      console.log(chalk4.yellow("\u{1F527} Available Tools:"));
+      server.tools.forEach((tool) => {
+        console.log(`  \u2022 ${tool}`);
+      });
+      console.log("");
+      console.log(chalk4.green("\u{1F4A1} Quick Start:"));
+      console.log(chalk4.dim(`  mcphost connect ${server.slug}`));
+      const connection = config.findConnection(slug);
+      if (connection) {
+        console.log("");
+        console.log(chalk4.blue("\u2139\uFE0F  Already connected to:"), connection.clients.join(", "));
+      }
+    } catch (error) {
+      spinner.fail("Failed to get server info");
+      Logger.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/servers.ts
+import { Command as Command6 } from "commander";
+function createServersCommand() {
+  const servers = new Command6("servers");
+  servers.description("Manage your hosted MCP servers");
+  servers.command("list").description("List your MCP servers").action(async () => {
+    const config = new Config();
+    if (!config.token) {
+      Logger.warning("Authentication required");
+      Logger.info("Use `mcphost login` to authenticate with MCPHosting");
+      return;
+    }
+    Logger.info("\u{1F6A7} Server management coming soon!");
+    console.log("");
+    console.log("This feature will let you:");
+    console.log("\u2022 List your hosted MCP servers");
+    console.log("\u2022 View usage analytics");
+    console.log("\u2022 Manage API keys");
+    console.log("\u2022 Publish to marketplace");
+    console.log("");
+    Logger.info("Visit https://mcphosting.com to manage servers in the web dashboard");
+  });
+  return servers;
+}
+function createKeysCommand() {
+  const keys = new Command6("keys");
+  keys.description("Manage API keys for your MCP servers");
+  keys.command("list").argument("[server-id]", "Server ID").description("List API keys").action(async (serverId) => {
+    const config = new Config();
+    if (!config.token) {
+      Logger.warning("Authentication required");
+      Logger.info("Use `mcphost login` to authenticate");
+      return;
+    }
+    Logger.info("\u{1F6A7} API key management coming soon!");
+    Logger.info("Visit https://mcphosting.com to manage keys in the web dashboard");
+  });
+  keys.command("create").argument("<server-id>", "Server ID").option("--name <name>", "Key name", "CLI Key").description("Create a new API key").action(async (serverId, options) => {
+    const config = new Config();
+    if (!config.token) {
+      Logger.warning("Authentication required");
+      Logger.info("Use `mcphost login` to authenticate");
+      return;
+    }
+    Logger.info("\u{1F6A7} API key creation coming soon!");
+    Logger.info("Visit https://mcphosting.com to create keys in the web dashboard");
+  });
+  keys.command("revoke").argument("<key-id>", "API key ID").description("Revoke an API key").action(async (keyId) => {
+    const config = new Config();
+    if (!config.token) {
+      Logger.warning("Authentication required");
+      Logger.info("Use `mcphost login` to authenticate");
+      return;
+    }
+    Logger.info("\u{1F6A7} API key revocation coming soon!");
+    Logger.info("Visit https://mcphosting.com to revoke keys in the web dashboard");
+  });
+  return keys;
+}
+function createPublishCommand() {
+  return new Command6("publish").description("Publish MCP server to marketplace").argument("[server-id]", "Server ID to publish").option("--private", "Keep server private").option("--description <desc>", "Server description").option("--tags <tags>", "Comma-separated tags").action(async (serverId, options = {}) => {
+    const config = new Config();
+    if (!config.token) {
+      Logger.warning("Authentication required");
+      Logger.info("Use `mcphost login` to authenticate");
+      return;
+    }
+    Logger.info("\u{1F6A7} Marketplace publishing coming soon!");
+    console.log("");
+    console.log("This feature will let you:");
+    console.log("\u2022 Publish your MCP servers to the marketplace");
+    console.log("\u2022 Set descriptions and tags");
+    console.log("\u2022 Configure public/private visibility");
+    console.log("\u2022 Track usage analytics");
+    console.log("");
+    Logger.info("Visit https://mcphosting.com to publish servers via the web dashboard");
+    if (serverId) {
+      Logger.dim(`Would publish server: ${serverId}`);
+    }
+    if (options.description) {
+      Logger.dim(`Description: ${options.description}`);
+    }
+    if (options.tags) {
+      Logger.dim(`Tags: ${options.tags}`);
+    }
+  });
+}
+
+// src/index.ts
+import chalk5 from "chalk";
+var program = new Command7();
+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) => {
+    write(chalk5.red(str));
+  }
+});
+program.addCommand(createConnectCommands());
+program.addCommand(createDisconnectCommand());
+program.addCommand(createListCommand());
+program.addCommand(createImportCommand());
+program.addCommand(createProxyCommand());
+program.addCommand(createSearchCommand());
+program.addCommand(createInfoCommand());
+program.addCommand(createServersCommand());
+program.addCommand(createKeysCommand());
+program.addCommand(createPublishCommand());
+program.addCommand(createAuthCommands());
+var [login, logout, whoami] = createLegacyAuthCommands();
+program.addCommand(login);
+program.addCommand(logout);
+program.addCommand(whoami);
+program.configureHelp({
+  subcommandTerm: (cmd) => chalk5.cyan(cmd.name()),
+  commandUsage: (cmd) => {
+    const usage = cmd.usage();
+    return chalk5.yellow(usage);
+  },
+  commandDescription: (cmd) => {
+    return chalk5.dim(cmd.description());
+  }
+});
+program.addHelpText("after", `
+${chalk5.bold("Examples:")}
+  ${chalk5.cyan("mcphost connect github")}                    ${chalk5.dim("Connect to GitHub MCP server")}
+  ${chalk5.cyan("mcphost connect https://my-mcp.example.com")}  ${chalk5.dim("Connect to custom MCP server")}
+  ${chalk5.cyan("mcphost connect slack --client claude")}      ${chalk5.dim("Connect Slack MCP only to Claude")}
+  ${chalk5.cyan("mcphost list")}                             ${chalk5.dim("List all connected MCP servers")}
+  ${chalk5.cyan("mcphost search github")}                    ${chalk5.dim("Search marketplace for MCP servers")}
+  ${chalk5.cyan("mcphost info notion")}                      ${chalk5.dim("Get details about Notion MCP")}
+  ${chalk5.cyan("mcphost import --from smithery")}           ${chalk5.dim("Import connections from Smithery")}
+  ${chalk5.cyan("mcphost disconnect github")}               ${chalk5.dim("Remove GitHub MCP connection")}
+
+${chalk5.bold("Supported AI Clients:")}
+  \u2022 ${chalk5.green("Claude Desktop")} - Auto-configured via claude_desktop_config.json
+  \u2022 ${chalk5.green("Cursor")} - Auto-configured via .cursor/mcp.json  
+  \u2022 ${chalk5.green("VS Code")} - Configured via .vscode/mcp.json
+  \u2022 ${chalk5.green("OpenClaw")} - Auto-configured via ~/.openclaw/mcp.json
+  \u2022 ${chalk5.green("ChatGPT")} - Manual setup with web instructions
+
+${chalk5.bold("Get Started:")}
+  ${chalk5.dim("1.")} ${chalk5.cyan("mcphost search <topic>")}     ${chalk5.dim("Find MCP servers")}
+  ${chalk5.dim("2.")} ${chalk5.cyan("mcphost connect <slug>")}     ${chalk5.dim("Connect to your AI clients")}
+  ${chalk5.dim("3.")} ${chalk5.cyan("mcphost list")}              ${chalk5.dim("View your connections")}
+
+${chalk5.yellow("\u2B50 Star us:")} ${chalk5.blue("https://github.com/gorlomi-enzo/mcphosting-cli")}
+${chalk5.yellow("\u{1F4DA} Docs:")} ${chalk5.blue("https://mcphosting.com/docs")}
+`);
+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);
+});
+process.on("SIGINT", () => {
+  console.log("\n");
+  Logger.info("Goodbye! \u{1F44B}");
+  process.exit(0);
+});
+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();
+//# sourceMappingURL=index.js.map