mcphosting-cli 0.1.1 → 0.3.1

package/dist/index.cjs

@@ -24,9 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander7 = require("commander");
+var import_commander17 = require("commander");
+var import_chalk16 = __toESM(require("chalk"), 1);
 
-// src/commands/auth.ts
+// src/commands/login.ts
 var import_commander = require("commander");
 var import_http = require("http");
 var import_open = __toESM(require("open"), 1);
@@ -47,8 +48,11 @@ var Config = class {
       defaults: { connections: [] }
     });
   }
+  /**
+   * Token resolution: env var MCPHOSTING_TOKEN takes priority over config file.
+   */
   get token() {
-    return this.conf.get("token");
+    return process.env.MCPHOSTING_TOKEN || this.conf.get("token");
   }
   set token(value) {
     if (value) {
@@ -57,6 +61,16 @@ var Config = class {
       this.conf.delete("token");
     }
   }
+  get refreshToken() {
+    return this.conf.get("refresh_token");
+  }
+  set refreshToken(value) {
+    if (value) {
+      this.conf.set("refresh_token", value);
+    } else {
+      this.conf.delete("refresh_token");
+    }
+  }
   get user() {
     return this.conf.get("user");
   }
@@ -67,6 +81,12 @@ var Config = class {
       this.conf.delete("user");
     }
   }
+  /**
+   * Check if token came from environment variable.
+   */
+  get isEnvToken() {
+    return !!process.env.MCPHOSTING_TOKEN;
+  }
   get connections() {
     return this.connectionsConf.get("connections", []);
   }
@@ -107,20 +127,220 @@ var Config = class {
 };
 
 // src/lib/api.ts
+var import_axios = __toESM(require("axios"), 1);
+var API_BASE = process.env.MCPHOSTING_API_URL || "https://mcphosting.com";
 var MCPHostingAPI = class {
-  baseUrl = "https://mcphosting.com/api";
-  token;
+  token = null;
   constructor(token) {
+    this.token = token || null;
+  }
+  setToken(token) {
     this.token = token;
   }
-  async request(endpoint, options = {}) {
-    throw new Error(`API not available - using static fallback`);
+  get headers() {
+    const h = {
+      "Content-Type": "application/json",
+      "User-Agent": "mcphosting-cli/1.0.0"
+    };
+    if (this.token) {
+      h["Authorization"] = `Bearer ${this.token}`;
+    }
+    return h;
   }
-  async searchMCPs(query) {
+  handleError(error) {
+    if (error instanceof import_axios.AxiosError) {
+      const status = error.response?.status;
+      const message = error.response?.data?.error || error.response?.data?.message || error.message;
+      if (status === 401) {
+        throw new Error("Authentication required. Run `mcphosting login` first.");
+      }
+      if (status === 403) {
+        throw new Error("Access denied. Check your permissions.");
+      }
+      if (status === 404) {
+        throw new Error("Not found. Check the server slug or ID.");
+      }
+      if (status === 429) {
+        throw new Error("Rate limited. Please wait a moment and try again.");
+      }
+      throw new Error(`API error (${status}): ${message}`);
+    }
+    throw error;
+  }
+  // --- Auth ---
+  async login(email, password) {
+    try {
+      const { data } = await import_axios.default.post(`${API_BASE}/api/auth/cli-login`, { email, password });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async refreshToken(refreshToken) {
+    try {
+      const { data } = await import_axios.default.post(`${API_BASE}/api/auth/cli-login/refresh`, { refresh_token: refreshToken });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async githubDeviceStart() {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/auth/github/device`);
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async githubDevicePoll(deviceCode) {
+    try {
+      const { data } = await import_axios.default.post(
+        `${API_BASE}/api/auth/github/device`,
+        { device_code: deviceCode },
+        { validateStatus: (status) => status < 500 }
+        // Don't throw on 202/400
+      );
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async whoami() {
+    if (!this.token) return null;
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/auth/whoami`, { headers: this.headers });
+      return data.user || null;
+    } catch {
+      return null;
+    }
+  }
+  // --- Deploy ---
+  async deploy(params) {
+    try {
+      if (params.githubUrl) {
+        const { data: data2 } = await import_axios.default.post(`${API_BASE}/api/cli/github/deploy`, {
+          repo_url: params.githubUrl,
+          auto_detect: true
+        }, { headers: this.headers });
+        return data2;
+      }
+      const { data } = await import_axios.default.post(`${API_BASE}/api/cli/deploy`, params, { headers: this.headers });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- Server Management ---
+  async listServers() {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/mcp/projects`, { headers: this.headers });
+      return data.projects || [];
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async getServer(idOrSlug) {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/mcp/projects/${idOrSlug}`, { headers: this.headers });
+      return data.project || data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async getServerLogs(idOrSlug, lines = 50) {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/mcp/projects/${idOrSlug}/logs?lines=${lines}`, { headers: this.headers });
+      return data.logs || [];
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- Connection Info ---
+  async connect(slug) {
+    try {
+      const { data } = await import_axios.default.post(`${API_BASE}/api/mcp/connect`, { slug }, { headers: this.headers });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async getConnectionInfo(slug) {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/cli/info/${slug}`, { headers: this.headers });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- Env Vars ---
+  async listEnvVars(projectId) {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/mcp/projects/${projectId}/env-vars`, { headers: this.headers });
+      return data.envVars || [];
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async addEnvVar(projectId, key, value) {
+    try {
+      await import_axios.default.post(
+        `${API_BASE}/api/mcp/projects/${projectId}/env-vars`,
+        { key, value },
+        { headers: this.headers }
+      );
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async removeEnvVar(projectId, key) {
+    try {
+      await import_axios.default.delete(
+        `${API_BASE}/api/mcp/projects/${projectId}/env-vars/${key}`,
+        { headers: this.headers }
+      );
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- One-Click Deploy ---
+  async oneClickDeploy(params) {
     try {
-      const results = await this.request(`/marketplace/search?q=${encodeURIComponent(query)}`);
-      return results.mcps || [];
+      const { data } = await import_axios.default.post(`${API_BASE}/api/cli/deploy/one-click`, params, { headers: this.headers });
+      return data;
     } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- API Keys ---
+  async getAPIKeys() {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/keys`, { headers: this.headers });
+      return data.keys || [];
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async createAPIKey(name) {
+    try {
+      const { data } = await import_axios.default.post(`${API_BASE}/api/keys`, { name }, { headers: this.headers });
+      return data;
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  async deleteAPIKey(id) {
+    try {
+      await import_axios.default.delete(`${API_BASE}/api/keys/${id}`, { headers: this.headers });
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  // --- Marketplace (static fallback for MVP) ---
+  async searchMCPs(query) {
+    try {
+      const { data } = await import_axios.default.get(`${API_BASE}/api/marketplace/search?q=${encodeURIComponent(query)}`, { headers: this.headers });
+      return data.mcps || [];
+    } catch {
       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()))
@@ -129,22 +349,13 @@ var MCPHostingAPI = class {
   }
   async getMCPInfo(slug) {
     try {
-      const result = await this.request(`/marketplace/mcp/${slug}`);
-      return result.mcp || null;
+      const { data } = await import_axios.default.get(`${API_BASE}/api/marketplace/mcp/${slug}`, { headers: this.headers });
+      return data.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 [
       {
@@ -208,26 +419,66 @@ var MCPHostingAPI = class {
 // src/lib/logger.ts
 var import_chalk = __toESM(require("chalk"), 1);
 var import_ora = __toESM(require("ora"), 1);
+var _silent = false;
+var _jsonMode = false;
 var Logger = class _Logger {
+  static get isSilent() {
+    return _silent;
+  }
+  static set silent(value) {
+    _silent = value;
+  }
+  static get isJsonMode() {
+    return _jsonMode;
+  }
+  static set jsonMode(value) {
+    _jsonMode = value;
+  }
   static info(message) {
+    if (_silent || _jsonMode) return;
     console.log(import_chalk.default.blue("\u2139"), message);
   }
   static success(message) {
+    if (_silent || _jsonMode) return;
     console.log(import_chalk.default.green("\u2713"), message);
   }
   static warning(message) {
+    if (_silent || _jsonMode) return;
     console.log(import_chalk.default.yellow("\u26A0"), message);
   }
   static error(message) {
+    if (_jsonMode) {
+      console.error(JSON.stringify({ success: false, error: message }));
+      return;
+    }
+    if (_silent) return;
     console.error(import_chalk.default.red("\u2717"), message);
   }
   static dim(message) {
+    if (_silent || _jsonMode) return;
     console.log(import_chalk.default.dim(message));
   }
   static bold(message) {
+    if (_silent || _jsonMode) return;
     console.log(import_chalk.default.bold(message));
   }
   static spinner(text) {
+    if (_silent || _jsonMode || !process.stderr.isTTY) {
+      return {
+        start: () => (0, import_ora.default)(text),
+        stop: () => {
+        },
+        succeed: () => {
+        },
+        fail: () => {
+        },
+        warn: () => {
+        },
+        info: () => {
+        },
+        text: ""
+      };
+    }
     return (0, import_ora.default)(text).start();
   }
   static table(data, headers) {
@@ -256,26 +507,196 @@ var Logger = class _Logger {
   }
 };
 
-// src/commands/auth.ts
-function createAuthCommands() {
-  const auth = new import_commander.Command("auth");
-  auth.command("login").description("Authenticate with MCPHosting").option("--token <token>", "Provide API token directly").action(async (options) => {
+// src/commands/login.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+var readline = __toESM(require("readline"), 1);
+function prompt(question, hidden = false) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hidden) {
+      const originalWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = ((str) => {
+        if (typeof str === "string" && str !== question && str !== "\n" && str !== "\r\n") {
+          return originalWrite("*");
+        }
+        return originalWrite(str);
+      });
+      rl.question(question, (answer) => {
+        process.stdout.write = originalWrite;
+        console.log();
+        rl.close();
+        resolve(answer);
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function loginWithGitHub(config) {
+  const api = new MCPHostingAPI();
+  const spinner = Logger.spinner("Starting GitHub login...");
+  try {
+    const deviceFlow = await api.githubDeviceStart();
+    spinner.stop();
+    console.log("");
+    console.log(import_chalk2.default.bold("  \u{1F510} GitHub Login"));
+    console.log("");
+    console.log(`  ${import_chalk2.default.dim("1.")} Open ${import_chalk2.default.cyan.underline(deviceFlow.verification_uri)}`);
+    console.log(`  ${import_chalk2.default.dim("2.")} Enter code: ${import_chalk2.default.bold.yellow(deviceFlow.user_code)}`);
+    console.log("");
+    try {
+      await (0, import_open.default)(deviceFlow.verification_uri);
+      Logger.dim("  Browser opened automatically.");
+    } catch {
+      Logger.dim("  Open the URL above in your browser.");
+    }
+    console.log("");
+    const pollSpinner = Logger.spinner("Waiting for GitHub authorization...");
+    const pollInterval = (deviceFlow.interval || 5) * 1e3;
+    const maxAttempts = Math.ceil((deviceFlow.expires_in || 900) / (deviceFlow.interval || 5));
+    let currentInterval = pollInterval;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      await sleep(currentInterval);
+      const result = await api.githubDevicePoll(deviceFlow.device_code);
+      if (result.token && result.user) {
+        config.token = result.token;
+        config.refreshToken = result.refresh_token;
+        config.user = { email: result.user.email, org: result.user.github_username };
+        pollSpinner.succeed(
+          result.is_new_user ? `Account created and logged in as ${import_chalk2.default.bold(result.user.github_username || result.user.email)}` : `Logged in as ${import_chalk2.default.bold(result.user.github_username || result.user.email)}`
+        );
+        console.log("");
+        Logger.info(`Token stored in ${import_chalk2.default.dim("~/.config/mcphosting/")}`);
+        Logger.info(`Run ${import_chalk2.default.cyan("mcphosting deploy")} to deploy your first MCP server!`);
+        return;
+      }
+      if (result.error === "authorization_pending") {
+        continue;
+      }
+      if (result.error === "slow_down") {
+        currentInterval = (result.interval || 10) * 1e3;
+        continue;
+      }
+      pollSpinner.fail("GitHub login failed");
+      Logger.error(result.error || "Unknown error during GitHub authorization");
+      process.exit(1);
+    }
+    pollSpinner.fail("GitHub login timed out");
+    Logger.error("Authorization expired. Please try again.");
+    process.exit(1);
+  } catch (error) {
+    spinner.fail("GitHub login failed");
+    Logger.error(error.message || "Failed to start GitHub device flow");
+    process.exit(1);
+  }
+}
+function createLoginCommand() {
+  return new import_commander.Command("login").description("Authenticate with MCPHosting").option("--email <email>", "Email address").option("--token <token>", "Provide API token directly").option("--github", "Login with GitHub (recommended)").option("--browser", "Use browser-based login").option("--json", "Output as JSON").action(async (options) => {
     const config = new Config();
+    const isJson = options.json || Logger.isJsonMode;
+    if (process.env.MCPHOSTING_TOKEN && !options.token && !options.github && !options.email) {
+      const api = new MCPHostingAPI(process.env.MCPHOSTING_TOKEN);
+      const user = await api.whoami();
+      if (isJson) {
+        console.log(JSON.stringify({
+          success: true,
+          email: user?.email || "unknown",
+          token_source: "environment"
+        }));
+      } else {
+        Logger.success(`Authenticated via MCPHOSTING_TOKEN env var`);
+        if (user) Logger.info(`  User: ${import_chalk2.default.bold(user.email)}`);
+      }
+      return;
+    }
+    if (options.github) {
+      await loginWithGitHub(config);
+      return;
+    }
     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})` : ""}`);
+        if (isJson) {
+          console.log(JSON.stringify({ success: true, email: user.email }));
+        } else {
+          Logger.success(`Logged in as ${import_chalk2.default.bold(user.email)}`);
+        }
       } else {
-        Logger.warning("Token saved, but could not verify user info");
+        if (isJson) {
+          console.log(JSON.stringify({ success: true, warning: "Token saved but could not verify identity" }));
+        } else {
+          Logger.warning("Token saved, but could not verify identity.");
+        }
+      }
+      return;
+    }
+    if (!process.stdin.isTTY && !options.email) {
+      if (isJson) {
+        console.log(JSON.stringify({
+          success: false,
+          error: "Interactive login requires a TTY. Use --token or MCPHOSTING_TOKEN env var for scripted usage."
+        }));
+      } else {
+        Logger.error("Interactive login requires a TTY.");
+        Logger.info("Use one of:");
+        Logger.dim(`  ${import_chalk2.default.cyan("mcphosting login --token <token>")}`);
+        Logger.dim(`  ${import_chalk2.default.cyan("export MCPHOSTING_TOKEN=<token>")}`);
+      }
+      process.exit(1);
+    }
+    if (options.email || !process.stdout.isTTY) {
+      const email = options.email || await prompt(import_chalk2.default.cyan("Email: "));
+      const password = await prompt(import_chalk2.default.cyan("Password: "), true);
+      if (!email || !password) {
+        Logger.error("Email and password are required.");
+        process.exit(1);
+      }
+      const spinner2 = Logger.spinner("Logging in...");
+      try {
+        const api = new MCPHostingAPI();
+        const result = await api.login(email, password);
+        config.token = result.token;
+        config.refreshToken = result.refresh_token;
+        config.user = result.user;
+        spinner2.succeed(`Logged in as ${import_chalk2.default.bold(result.user.email)}`);
+        console.log("");
+        Logger.info(`Token stored in ${import_chalk2.default.dim("~/.config/mcphosting/")}`);
+        Logger.info(`Run ${import_chalk2.default.cyan("mcphosting deploy")} to deploy your first MCP server!`);
+      } catch (error) {
+        spinner2.fail("Login failed");
+        Logger.error(error.message || "Invalid email or password.");
+        process.exit(1);
       }
       return;
     }
-    const spinner = Logger.spinner("Starting login flow...");
+    if (process.stdout.isTTY) {
+      console.log("");
+      console.log(import_chalk2.default.bold("  \u{1F680} MCPHosting Login"));
+      console.log("");
+      console.log(`  ${import_chalk2.default.cyan("mcphosting login --github")}     ${import_chalk2.default.dim("Login with GitHub (recommended)")}`);
+      console.log(`  ${import_chalk2.default.cyan("mcphosting login --email")}      ${import_chalk2.default.dim("Login with email/password")}`);
+      console.log(`  ${import_chalk2.default.cyan("mcphosting login --browser")}    ${import_chalk2.default.dim("Login via browser")}`);
+      console.log(`  ${import_chalk2.default.cyan("mcphosting login --token")}      ${import_chalk2.default.dim("Use existing API token")}`);
+      console.log("");
+      Logger.info("Starting GitHub login (use --email for email/password)...");
+      console.log("");
+      await loginWithGitHub(config);
+      return;
+    }
+    const spinner = Logger.spinner("Opening browser for login...");
     let server;
-    let resolved = false;
     try {
       const authPromise = new Promise((resolve, reject) => {
         server = (0, import_http.createServer)((req, res) => {
@@ -286,9 +707,9 @@ function createAuthCommands() {
               res.writeHead(200, { "Content-Type": "text/html" });
               res.end(`
                   <html>
-                    <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                    <body style="font-family: system-ui; text-align: center; padding: 50px; background: #0a0a0a; color: #fff;">
                       <h2>\u2705 Login Successful!</h2>
-                      <p>You can now close this window and return to your terminal.</p>
+                      <p style="color: #888;">You can close this window and return to your terminal.</p>
                     </body>
                   </html>
                 `);
@@ -297,9 +718,9 @@ function createAuthCommands() {
               res.writeHead(400, { "Content-Type": "text/html" });
               res.end(`
                   <html>
-                    <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                    <body style="font-family: system-ui; text-align: center; padding: 50px; background: #0a0a0a; color: #fff;">
                       <h2>\u274C Login Failed</h2>
-                      <p>No token received. Please try again.</p>
+                      <p style="color: #888;">No token received. Please try again.</p>
                     </body>
                   </html>
                 `);
@@ -314,29 +735,32 @@ function createAuthCommands() {
           const port = server.address().port;
           const callbackUrl = `http://localhost:${port}/callback`;
           const authUrl = `https://mcphosting.com/cli/auth?callback=${encodeURIComponent(callbackUrl)}`;
+          spinner.text = "Waiting for browser login...";
           setTimeout(() => {
-            if (!resolved) {
-              reject(new Error("Login timeout - please try again"));
-            }
+            reject(new Error("Login timed out after 2 minutes. Try again."));
           }, 12e4);
           (0, import_open.default)(authUrl).catch(() => {
-            Logger.warning(`Could not open browser automatically. Please visit: ${authUrl}`);
+            spinner.info("Could not open browser automatically.");
+            Logger.info(`Open this URL manually: ${import_chalk2.default.blue(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})` : ""}`);
+        Logger.success(`Logged in as ${import_chalk2.default.bold(user.email)}`);
       }
+      console.log("");
+      Logger.info(`Run ${import_chalk2.default.cyan("mcphosting deploy")} to deploy your first MCP server!`);
     } catch (error) {
       spinner.fail("Login failed");
-      Logger.error(`Login error: ${error}`);
+      Logger.error(error.message);
+      console.log("");
+      Logger.info(`Alternative: ${import_chalk2.default.cyan("mcphosting login --github")}`);
       process.exit(1);
     } finally {
       if (server) {
@@ -344,69 +768,184 @@ function createAuthCommands() {
       }
     }
   });
-  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 () => {
+}
+
+// src/commands/logout.ts
+var import_commander2 = require("commander");
+function createLogoutCommand() {
+  return new import_commander2.Command("logout").description("Log out and remove stored credentials").option("--json", "Output as JSON").action((options) => {
     const config = new Config();
-    const token = config.token;
-    if (!token) {
-      Logger.warning("Not logged in. Use `mcphost auth login` to authenticate.");
+    const isJson = options.json || Logger.isJsonMode;
+    if (!config.token) {
+      if (isJson) {
+        console.log(JSON.stringify({ success: true, message: "Already logged out" }));
+      } else {
+        Logger.info("Already logged out.");
+      }
       return;
     }
-    const user = config.user;
-    if (user) {
-      Logger.info(`Logged in as: ${user.email}${user.org ? ` (${user.org})` : ""}`);
+    const email = config.user?.email;
+    config.token = void 0;
+    config.user = void 0;
+    if (isJson) {
+      console.log(JSON.stringify({ success: true, email: email || void 0 }));
+    } else if (email) {
+      Logger.success(`Logged out from ${email}`);
     } else {
-      Logger.warning("User info not available. Try logging in again.");
+      Logger.success("Logged out successfully.");
     }
   });
-  return auth;
 }
-function createLegacyAuthCommands() {
+
+// src/commands/deploy.ts
+var import_commander3 = require("commander");
+var import_promises4 = require("fs/promises");
+var import_path3 = require("path");
+
+// src/lib/auth.ts
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const json = Buffer.from(base64, "base64").toString("utf-8");
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function isTokenExpiringSoon(token, thresholdSeconds = 300) {
+  const payload = decodeJwtPayload(token);
+  if (!payload || !payload.exp) return false;
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  return payload.exp - nowSeconds < thresholdSeconds;
+}
+function getAuthenticatedAPI() {
   const config = new Config();
-  const login2 = new import_commander.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 import_commander.Command("logout").description("Remove stored authentication").action(() => {
-    config.token = void 0;
-    config.user = void 0;
-    Logger.success("Logged out successfully");
-  });
-  const whoami2 = new import_commander.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();
+  let token = config.token;
+  if (!token) {
+    Logger.error("Not logged in.");
+    Logger.info("Run `mcphosting login` to authenticate.");
+    process.exit(1);
+  }
+  if (isTokenExpiringSoon(token) && !config.isEnvToken) {
+    if (config.refreshToken) {
+      Logger.warning("Token expiring soon. Use async auth for auto-refresh, or run `mcphosting login`.");
+    } else {
+      Logger.warning("Token is expiring soon. Run `mcphosting login` to re-authenticate.");
     }
-  });
-  return [login2, logout2, whoami2];
+  }
+  const api = new MCPHostingAPI(token);
+  return { api, config };
+}
+function isAuthenticated() {
+  const config = new Config();
+  return !!config.token;
 }
 
-// src/commands/connect.ts
-var import_commander2 = require("commander");
-
-// src/lib/clients.ts
+// src/lib/detector.ts
 var import_promises = require("fs/promises");
 var import_path = require("path");
-var import_os = require("os");
+async function detectMCP(dir) {
+  try {
+    const files = await (0, import_promises.readdir)(dir);
+    const configFiles = files.filter(
+      (f) => ["mcp.json", "mcp.config.json", "mcp.yaml", ".mcprc", "mcp.config.ts", "mcp.config.js"].includes(f)
+    );
+    let packageJson = null;
+    let hasMcpSdk = false;
+    let runtime = "unknown";
+    let entryPoint;
+    if (files.includes("package.json")) {
+      try {
+        const content = await (0, import_promises.readFile)((0, import_path.join)(dir, "package.json"), "utf-8");
+        packageJson = JSON.parse(content);
+        hasMcpSdk = !!(packageJson?.dependencies?.["@modelcontextprotocol/sdk"] || packageJson?.devDependencies?.["@modelcontextprotocol/sdk"]);
+        if (hasMcpSdk || packageJson?.dependencies?.["@modelcontextprotocol/sdk"]) {
+          runtime = "node";
+        }
+        if (packageJson?.main) {
+          entryPoint = packageJson.main;
+        } else if (packageJson?.bin) {
+          const bins = typeof packageJson.bin === "string" ? packageJson.bin : Object.values(packageJson.bin)[0];
+          entryPoint = bins;
+        }
+      } catch {
+      }
+    }
+    if (files.includes("pyproject.toml") || files.includes("requirements.txt") || files.includes("setup.py")) {
+      try {
+        let pythonDeps = "";
+        if (files.includes("requirements.txt")) {
+          pythonDeps = await (0, import_promises.readFile)((0, import_path.join)(dir, "requirements.txt"), "utf-8");
+        } else if (files.includes("pyproject.toml")) {
+          pythonDeps = await (0, import_promises.readFile)((0, import_path.join)(dir, "pyproject.toml"), "utf-8");
+        }
+        if (pythonDeps.includes("mcp") || pythonDeps.includes("modelcontextprotocol")) {
+          hasMcpSdk = true;
+          runtime = "python";
+        }
+      } catch {
+      }
+      if (files.includes("server.py")) entryPoint = "server.py";
+      else if (files.includes("main.py")) entryPoint = "main.py";
+      else if (files.includes("app.py")) entryPoint = "app.py";
+    }
+    if (!hasMcpSdk && configFiles.length === 0) {
+      const sourceFiles = files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+      for (const sf of sourceFiles.slice(0, 5)) {
+        try {
+          const content = await (0, import_promises.readFile)((0, import_path.join)(dir, sf), "utf-8");
+          if (content.includes("@modelcontextprotocol/sdk") || content.includes("McpServer") || content.includes("mcp.server")) {
+            hasMcpSdk = true;
+            runtime = sf.endsWith(".py") ? "python" : "node";
+            if (!entryPoint) entryPoint = sf;
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!hasMcpSdk && configFiles.length === 0) {
+      return null;
+    }
+    let mcpConfig = null;
+    if (configFiles.length > 0) {
+      try {
+        const configContent = await (0, import_promises.readFile)((0, import_path.join)(dir, configFiles[0]), "utf-8");
+        mcpConfig = JSON.parse(configContent);
+      } catch {
+      }
+    }
+    const name = packageJson?.name || (0, import_path.basename)(dir);
+    return {
+      name,
+      hasMcpSdk,
+      configFiles,
+      packageJson,
+      mcpConfig,
+      runtime,
+      entryPoint
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/clients.ts
 var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_os = require("os");
+var import_promises3 = require("fs/promises");
 var ClientManager = class {
   static getClientPaths() {
     const home = (0, import_os.homedir)();
     const platform = process.platform;
     const paths = {
-      claude: platform === "win32" ? (0, import_path.join)(process.env.APPDATA || "", "Claude", "claude_desktop_config.json") : (0, import_path.join)(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-      cursor: (0, import_path.join)(home, ".cursor", "mcp.json"),
-      vscode: (0, import_path.join)(process.cwd(), ".vscode", "mcp.json"),
-      openclaw: (0, import_path.join)(home, ".openclaw", "mcp.json"),
+      claude: platform === "win32" ? (0, import_path2.join)(process.env.APPDATA || "", "Claude", "claude_desktop_config.json") : (0, import_path2.join)(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      cursor: (0, import_path2.join)(home, ".cursor", "mcp.json"),
+      vscode: (0, import_path2.join)(process.cwd(), ".vscode", "mcp.json"),
+      openclaw: (0, import_path2.join)(home, ".openclaw", "mcp.json"),
       chatgpt: ""
       // Web-based, no local config
     };
@@ -418,7 +957,7 @@ var ClientManager = class {
     for (const [name, path] of Object.entries(paths)) {
       if (name === "chatgpt") continue;
       try {
-        await (0, import_promises.access)(path);
+        await (0, import_promises2.access)(path);
         clients.push({ name, configPath: path, exists: true });
       } catch {
         clients.push({ name, configPath: path, exists: false });
@@ -444,14 +983,14 @@ var ClientManager = class {
     }
     const serverEntry = {
       command: "npx",
-      args: ["-y", "@mcphosting/cli", "proxy", url],
+      args: ["-y", "mcphosting-cli", "proxy", url],
       env: {}
     };
     try {
-      await (0, import_promises2.mkdir)((0, import_path.dirname)(configPath), { recursive: true });
+      await (0, import_promises3.mkdir)((0, import_path2.dirname)(configPath), { recursive: true });
       let config = { mcpServers: {} };
       try {
-        const configContent = await (0, import_promises.readFile)(configPath, "utf-8");
+        const configContent = await (0, import_promises2.readFile)(configPath, "utf-8");
         config = JSON.parse(configContent);
         if (!config.mcpServers) {
           config.mcpServers = {};
@@ -459,7 +998,7 @@ var ClientManager = class {
       } catch {
       }
       config.mcpServers[slug] = serverEntry;
-      await (0, import_promises.writeFile)(configPath, JSON.stringify(config, null, 2));
+      await (0, import_promises2.writeFile)(configPath, JSON.stringify(config, null, 2));
       return true;
     } catch (error) {
       Logger.error(`Failed to configure ${client}: ${error}`);
@@ -482,11 +1021,11 @@ var ClientManager = class {
       throw new Error(`Unsupported client: ${client}`);
     }
     try {
-      const configContent = await (0, import_promises.readFile)(configPath, "utf-8");
+      const configContent = await (0, import_promises2.readFile)(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.mcpServers && config.mcpServers[slug]) {
         delete config.mcpServers[slug];
-        await (0, import_promises.writeFile)(configPath, JSON.stringify(config, null, 2));
+        await (0, import_promises2.writeFile)(configPath, JSON.stringify(config, null, 2));
         return true;
       }
       return false;
@@ -533,21 +1072,360 @@ var ClientManager = class {
   }
 };
 
-// src/commands/connect.ts
-var import_chalk2 = __toESM(require("chalk"), 1);
-function createConnectCommands() {
-  const connect = new import_commander2.Command("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;
+// src/commands/deploy.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+var TEMPLATES = ["weather", "crypto", "notion", "postgres", "blank"];
+function createDeployCommand() {
+  return new import_commander3.Command("deploy").description("Deploy an MCP server to MCPHosting (one command)").option("--github <url>", "Deploy from a GitHub repository URL").option("--name <name>", "Server name (auto-detected if not provided)").option("--template <name>", "Deploy from a template (weather, crypto, notion, postgres, blank)").option("--api-url <url>", "Your MCP server's API URL (for external servers)").option("--auth <type>", "Auth type: none, api_key, or oauth", "none").option("--auto-key", "Automatically create an API key", true).option("--no-auto-key", "Skip automatic API key creation").option("--configure", "Automatically configure detected AI clients", false).option("--json", "Output result as JSON").option("--silent", "Suppress interactive output").action(async (options) => {
+    const isJson = options.json || Logger.isJsonMode;
+    const isSilent = options.silent || Logger.isSilent;
+    const { api, config } = getAuthenticatedAPI();
+    if (!isJson && !isSilent) {
+      console.log("");
+      console.log(import_chalk3.default.bold("\u{1F680} MCPHosting Deploy"));
+      console.log(import_chalk3.default.dim("   One command. Your MCP server goes live."));
+      console.log("");
+    }
+    if (options.template) {
+      const template = options.template.toLowerCase();
+      if (!TEMPLATES.includes(template)) {
+        Logger.error(`Unknown template: ${template}`);
+        console.log("");
+        Logger.info("Available templates:");
+        for (const t of TEMPLATES) {
+          console.log(`  ${import_chalk3.default.cyan(t)}`);
+        }
+        process.exit(1);
+      }
+      const name2 = options.name || `mcp-${template}`;
+      const spinner2 = Logger.spinner(`Deploying template ${import_chalk3.default.cyan(template)}...`);
+      try {
+        const result = await api.oneClickDeploy({
+          name: name2,
+          template,
+          authType: options.auth,
+          autoKey: options.autoKey
+        });
+        spinner2.succeed(`Template ${import_chalk3.default.cyan(template)} deployed!`);
+        if (isJson) {
+          Logger.json(result);
+        } else {
+          printOneClickResult(result, options.configure);
+        }
+        if (options.configure && result.connectionUrl) {
+          await autoConfigureClients(result.slug, result.connectionUrl);
+        }
+      } catch (error) {
+        spinner2.fail("Deploy failed");
+        Logger.error(error.message);
+        process.exit(1);
+      }
+      return;
+    }
+    if (options.github) {
+      const githubUrl2 = options.github;
+      const name2 = options.name || extractRepoName(githubUrl2);
+      const spinner2 = Logger.spinner(`Deploying from ${import_chalk3.default.cyan(githubUrl2)}...`);
+      try {
+        const result = await api.oneClickDeploy({
+          name: name2,
+          githubUrl: githubUrl2,
+          authType: options.auth,
+          autoKey: options.autoKey
+        });
+        spinner2.succeed("Deployed from GitHub!");
+        if (isJson) {
+          Logger.json(result);
+        } else {
+          printOneClickResult(result, options.configure);
+        }
+        if (options.configure && result.connectionUrl) {
+          await autoConfigureClients(result.slug, result.connectionUrl);
+        }
+      } catch (error) {
+        spinner2.fail("Deploy failed");
+        Logger.error(error.message);
+        process.exit(1);
+      }
+      return;
+    }
+    if (options.apiUrl) {
+      const name2 = options.name || new URL(options.apiUrl).hostname;
+      const spinner2 = Logger.spinner(`Registering ${import_chalk3.default.cyan(name2)}...`);
+      try {
+        const result = await api.oneClickDeploy({
+          name: name2,
+          baseApiUrl: options.apiUrl,
+          authType: options.auth,
+          autoKey: options.autoKey
+        });
+        spinner2.succeed("Registered successfully!");
+        if (isJson) {
+          Logger.json(result);
+        } else {
+          printOneClickResult(result, options.configure);
+        }
+        if (options.configure && result.connectionUrl) {
+          await autoConfigureClients(result.slug, result.connectionUrl);
+        }
+      } catch (error) {
+        spinner2.fail("Registration failed");
+        Logger.error(error.message);
+        process.exit(1);
+      }
+      return;
+    }
+    const dir = process.cwd();
+    let mcphostingConfig = null;
+    try {
+      const configContent = await (0, import_promises4.readFile)((0, import_path3.join)(dir, "mcphosting.json"), "utf-8");
+      mcphostingConfig = JSON.parse(configContent);
+    } catch {
+    }
+    const spinner = Logger.spinner("Detecting MCP server...");
+    const detected = await detectMCP(dir);
+    if (!detected && !mcphostingConfig) {
+      spinner.fail("No MCP server detected");
+      console.log("");
+      Logger.info("This directory doesn't look like an MCP server project.");
+      console.log("");
+      Logger.info(import_chalk3.default.bold("Quick options:"));
+      console.log(`  ${import_chalk3.default.cyan("mcphosting deploy --template weather")}   Deploy a template`);
+      console.log(`  ${import_chalk3.default.cyan("mcphosting deploy --github <url>")}       Deploy from GitHub`);
+      console.log(`  ${import_chalk3.default.cyan("mcphosting deploy --api-url <url>")}      Register external server`);
+      console.log(`  ${import_chalk3.default.cyan("mcphosting init")}                        Create mcphosting.json`);
+      console.log("");
+      process.exit(1);
+    }
+    const name = options.name || mcphostingConfig?.name || detected?.name || "my-mcp-server";
+    spinner.succeed(`Detected: ${import_chalk3.default.bold(name)}`);
+    if (detected) {
+      Logger.info(`  SDK: ${detected.hasMcpSdk ? import_chalk3.default.green("\u2713") : import_chalk3.default.yellow("\u25CB")} @modelcontextprotocol/sdk`);
+      if (detected.runtime !== "unknown") {
+        Logger.info(`  Runtime: ${detected.runtime}`);
+      }
+    }
+    let githubUrl = mcphostingConfig?.github || null;
+    if (!githubUrl) {
+      try {
+        const { execSync } = await import("child_process");
+        const remoteUrl = execSync("git remote get-url origin", { cwd: dir, encoding: "utf-8" }).trim();
+        if (remoteUrl.includes("github.com")) {
+          githubUrl = remoteUrl.replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
+        }
+      } catch {
+      }
+    }
+    if (githubUrl) {
+      Logger.info(`  GitHub: ${import_chalk3.default.dim(githubUrl)}`);
+    }
+    console.log("");
+    const deploySpinner = Logger.spinner(`Deploying ${import_chalk3.default.bold(name)}...`);
+    try {
+      const result = await api.oneClickDeploy({
+        name,
+        slug: mcphostingConfig?.slug,
+        githubUrl: githubUrl || void 0,
+        authType: options.auth,
+        autoKey: options.autoKey,
+        vercelProjectUrl: mcphostingConfig?.vercelUrl
+      });
+      deploySpinner.succeed("Deployed successfully!");
+      if (mcphostingConfig) {
+        try {
+          mcphostingConfig.connectionUrl = result.connectionUrl;
+          mcphostingConfig.projectId = result.projectId;
+          mcphostingConfig.slug = result.slug;
+          await (0, import_promises4.writeFile)((0, import_path3.join)(dir, "mcphosting.json"), JSON.stringify(mcphostingConfig, null, 2) + "\n");
+        } catch {
+        }
+      }
+      if (isJson) {
+        Logger.json(result);
+      } else {
+        printOneClickResult(result, options.configure);
+      }
+      if (options.configure && result.connectionUrl) {
+        await autoConfigureClients(result.slug, result.connectionUrl);
+      }
+    } catch (error) {
+      deploySpinner.fail("Deploy failed");
+      Logger.error(error.message);
+      if (error.message.includes("Authentication") || error.message.includes("Unauthorized")) {
+        Logger.info(`Run ${import_chalk3.default.cyan("mcphosting login")} first.`);
+      }
+      process.exit(1);
+    }
+  });
+}
+function extractRepoName(url) {
+  const parts = url.replace(/\.git$/, "").split("/");
+  return parts[parts.length - 1] || "mcp-server";
+}
+function printOneClickResult(result, showConfigureHint = false) {
+  console.log("");
+  console.log(import_chalk3.default.green.bold("  \u2705 Your MCP server is live!"));
+  console.log("");
+  Logger.info(`  ${import_chalk3.default.dim("Endpoint:")}  ${import_chalk3.default.blue(result.connectionUrl)}`);
+  if (result.slug) {
+    Logger.info(`  ${import_chalk3.default.dim("Slug:")}      ${import_chalk3.default.cyan(result.slug)}`);
+  }
+  if (result.status) {
+    const statusColor = result.status === "deployed" ? import_chalk3.default.green : import_chalk3.default.yellow;
+    Logger.info(`  ${import_chalk3.default.dim("Status:")}    ${statusColor(result.status)}`);
+  }
+  if (result.apiKey?.key) {
+    console.log("");
+    console.log(import_chalk3.default.bold("  \u{1F511} API Key (save this \u2014 shown only once):"));
+    console.log(`     ${import_chalk3.default.green(result.apiKey.key)}`);
+  }
+  if (result.vercelDeployUrl) {
+    console.log("");
+    console.log(import_chalk3.default.bold("  \u{1F310} Hosted on mcphosting.com infrastructure"));
+    console.log(import_chalk3.default.dim("     Your server is live and managed by MCPHosting."));
+  }
+  if (result.clientConfig) {
+    console.log("");
+    console.log(import_chalk3.default.bold("  \u{1F4CB} Add to your AI client:"));
+    console.log("");
+    console.log(import_chalk3.default.dim("  Claude Desktop (claude_desktop_config.json):"));
+    console.log(import_chalk3.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(import_chalk3.default.white(`  ${JSON.stringify(result.clientConfig.claude, null, 2).split("\n").join("\n  ")}`));
+    console.log("");
+    console.log(import_chalk3.default.dim("  Cursor / VS Code (.cursor/mcp.json):"));
+    console.log(import_chalk3.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(import_chalk3.default.white(`  ${JSON.stringify(result.clientConfig.cursor, null, 2).split("\n").join("\n  ")}`));
+  }
+  console.log("");
+  console.log(import_chalk3.default.dim("  Quick connect:"));
+  console.log(import_chalk3.default.cyan(`  mcphosting connect ${result.slug}`));
+  if (showConfigureHint) {
+    console.log("");
+    console.log(import_chalk3.default.dim("  Auto-configure AI clients:"));
+    console.log(import_chalk3.default.cyan(`  mcphosting deploy --configure`));
+  }
+  console.log("");
+  Logger.info(`Manage at ${import_chalk3.default.blue(`https://mcphosting.com/dashboard/servers/${result.projectId || result.slug}`)}`);
+  console.log("");
+}
+async function autoConfigureClients(slug, url) {
+  const clients = await ClientManager.detectInstalledClients();
+  const installed = clients.filter((c) => c.exists);
+  if (installed.length === 0) {
+    Logger.info("No AI clients detected. Add the config manually (shown above).");
+    return;
+  }
+  for (const client of installed) {
+    try {
+      const success = await ClientManager.addToClient(client.name, slug, url);
+      if (success) {
+        Logger.success(`Configured ${import_chalk3.default.bold(client.name)}`);
+      }
+    } catch (error) {
+      Logger.warning(`Failed to configure ${client.name}: ${error.message}`);
+    }
+  }
+}
+
+// src/commands/init.ts
+var import_commander4 = require("commander");
+var import_promises5 = require("fs/promises");
+var import_path4 = require("path");
+var import_chalk4 = __toESM(require("chalk"), 1);
+var TEMPLATES2 = [
+  { name: "weather", description: "Weather data MCP server", repo: "gorlomi-enzo/mcp-template-weather" },
+  { name: "crypto", description: "Crypto prices & portfolio MCP", repo: "gorlomi-enzo/mcp-template-crypto" },
+  { name: "notion", description: "Notion integration MCP", repo: "gorlomi-enzo/mcp-template-notion" },
+  { name: "postgres", description: "PostgreSQL query MCP", repo: "gorlomi-enzo/mcp-template-postgres" },
+  { name: "blank", description: "Minimal MCP server scaffold", repo: "gorlomi-enzo/mcp-template-blank" }
+];
+function createInitCommand() {
+  return new import_commander4.Command("init").description("Initialize mcphosting.json in the current directory").option("--name <name>", "Project name").option("--template <template>", "Initialize from a template").option("--list-templates", "List available templates").action(async (options) => {
+    console.log("");
+    console.log(import_chalk4.default.bold("\u{1F4E6} MCPHosting Init"));
+    console.log("");
+    if (options.listTemplates) {
+      console.log(import_chalk4.default.bold("Available templates:"));
+      console.log("");
+      for (const t of TEMPLATES2) {
+        console.log(`  ${import_chalk4.default.cyan(t.name.padEnd(12))} ${import_chalk4.default.dim(t.description)}`);
+        console.log(`  ${import_chalk4.default.dim(`             github.com/${t.repo}`)}`);
+        console.log("");
+      }
+      console.log(import_chalk4.default.dim(`Usage: mcphosting init --template <name>`));
+      return;
+    }
+    const dir = process.cwd();
+    const configPath = (0, import_path4.join)(dir, "mcphosting.json");
+    try {
+      await (0, import_promises5.access)(configPath);
+      Logger.warning("mcphosting.json already exists in this directory.");
+      Logger.info(`Edit it manually or delete it and run ${import_chalk4.default.cyan("mcphosting init")} again.`);
+      return;
+    } catch {
+    }
+    const detected = await detectMCP(dir);
+    const projectName = options.name || detected?.name || (0, import_path4.basename)(dir);
+    const slug = projectName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+    let githubUrl = null;
+    try {
+      const { execSync } = await import("child_process");
+      const remoteUrl = execSync("git remote get-url origin", { cwd: dir, encoding: "utf-8" }).trim();
+      if (remoteUrl.includes("github.com")) {
+        githubUrl = remoteUrl.replace(/^git@github\.com:/, "https://github.com/").replace(/\.git$/, "");
+      }
+    } catch {
+    }
+    const config = {
+      $schema: "https://mcphosting.com/schema/mcphosting.json",
+      name: projectName,
+      slug,
+      version: "1.0.0",
+      server: {
+        transport: "streamable-http",
+        port: 3e3,
+        path: "/mcp"
+      }
+    };
+    if (githubUrl) {
+      config.github = githubUrl;
+    }
+    if (options.template) {
+      config.template = options.template;
+    }
+    await (0, import_promises5.writeFile)(configPath, JSON.stringify(config, null, 2) + "\n");
+    Logger.success(`Created ${import_chalk4.default.bold("mcphosting.json")}`);
+    console.log("");
+    console.log(import_chalk4.default.dim(JSON.stringify(config, null, 2)));
+    console.log("");
+    if (detected?.hasMcpSdk) {
+      Logger.info(`Detected MCP SDK (${detected.runtime})`);
+    }
+    if (githubUrl) {
+      Logger.info(`GitHub: ${import_chalk4.default.blue(githubUrl)}`);
+    }
+    console.log("");
+    Logger.info(`Next: ${import_chalk4.default.cyan("mcphosting deploy")} to deploy your MCP server`);
+    console.log("");
+  });
+}
+
+// src/commands/connect.ts
+var import_commander5 = require("commander");
+var import_chalk5 = __toESM(require("chalk"), 1);
+function createConnectCommand() {
+  return new import_commander5.Command("connect").description("Connect an MCP server to your AI clients").argument("<url-or-slug>", "MCP server URL or slug (e.g. github, notion, https://my-mcp.com)").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 ${import_chalk5.default.cyan(slug)}`);
+        Logger.info(`Use ${import_chalk5.default.cyan(`mcphosting disconnect ${slug}`)} to remove first`);
+        return;
       }
       const clients = [];
       if (options.client) {
@@ -555,7 +1433,7 @@ function createConnectCommands() {
         const success = await ClientManager.addToClient(clientName, slug, url);
         if (success) {
           clients.push(clientName);
-          spinner.succeed(`Connected to ${clientName}`);
+          spinner.succeed(`Connected ${import_chalk5.default.bold(name)} to ${import_chalk5.default.green(clientName)}`);
         } else {
           spinner.fail(`Failed to connect to ${clientName}`);
           process.exit(1);
@@ -564,9 +1442,9 @@ function createConnectCommands() {
         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");
+          spinner.warn("No supported AI clients detected");
+          Logger.info("Supported: Claude Desktop, Cursor, VS Code, OpenClaw");
+          Logger.info(`Use ${import_chalk5.default.cyan("--client chatgpt")} for web-based setup`);
           return;
         }
         spinner.text = `Configuring ${availableClients.length} client${availableClients.length > 1 ? "s" : ""}...`;
@@ -584,86 +1462,470 @@ function createConnectCommands() {
             Logger.warning(`Failed to configure ${client.name}: ${error}`);
           }
         }
-        spinner.succeed(`Connected to ${clients.length} client${clients.length > 1 ? "s" : ""}`);
+        spinner.succeed(`Connected ${import_chalk5.default.bold(name)} 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" + import_chalk2.default.green("\u{1F389} Connected! Share with your team:"));
-      console.log(import_chalk2.default.cyan(`npx @mcphosting/cli connect ${urlOrSlug}`));
-      console.log("\n" + import_chalk2.default.yellow("\u2B50 Star us: ") + import_chalk2.default.blue("https://github.com/gorlomi-enzo/mcphosting-cli"));
+      config.addConnection({ slug, url, clients });
+      console.log("");
+      Logger.info(`  URL: ${import_chalk5.default.dim(url)}`);
+      Logger.info(`  Clients: ${import_chalk5.default.dim(clients.join(", "))}`);
+      console.log("");
+      console.log(import_chalk5.default.green("\u{1F389} Share with your team:"));
+      console.log(import_chalk5.default.cyan(`   npx mcphosting-cli connect ${urlOrSlug}`));
       console.log("");
     } catch (error) {
       spinner.fail("Connection failed");
-      Logger.error(`Error: ${error}`);
+      Logger.error(error.message);
       process.exit(1);
     }
   });
-  return connect;
 }
 function createDisconnectCommand() {
-  return new import_commander2.Command("disconnect").description("Disconnect an MCP server").argument("<slug-or-id>", "MCP server slug or connection ID").action(async (slugOrId) => {
+  return new import_commander5.Command("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");
+      Logger.info(`Use ${import_chalk5.default.cyan("mcphosting 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}`);
+      spinner.succeed(`Disconnected ${import_chalk5.default.bold(connection.slug)}`);
       if (removedFrom.length > 0) {
         Logger.info(`Removed from: ${removedFrom.join(", ")}`);
       }
     } catch (error) {
       spinner.fail("Disconnect failed");
-      Logger.error(`Error: ${error}`);
+      Logger.error(error.message);
     }
   });
 }
+
+// src/commands/list.ts
+var import_commander6 = require("commander");
+var import_chalk6 = __toESM(require("chalk"), 1);
 function createListCommand() {
-  return new import_commander2.Command("list").description("List connected MCP servers").option("--json", "Output as JSON").action(async (options) => {
+  return new import_commander6.Command("list").description("List your MCP servers").option("--local", "Show locally connected servers only").option("--remote", "Show deployed servers only (requires login)").option("--json", "Output as JSON").action(async (options) => {
+    const isJson = options.json || Logger.isJsonMode;
+    const showLocal = options.local || !options.local && !options.remote;
+    const showRemote = options.remote || !options.local && !options.remote;
+    if (showLocal) {
+      const config = new Config();
+      const connections = config.connections;
+      if (connections.length > 0) {
+        if (isJson && !showRemote) {
+          Logger.json(connections);
+          return;
+        }
+        console.log("");
+        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("");
+      } else if (!showRemote) {
+        Logger.info("No local MCP connections.");
+        Logger.dim(`Use ${import_chalk6.default.cyan("mcphosting connect <slug>")} to connect one.`);
+        return;
+      }
+    }
+    if (showRemote && isAuthenticated()) {
+      const { api } = getAuthenticatedAPI();
+      const spinner = Logger.spinner("Fetching deployed servers...");
+      try {
+        const servers = await api.listServers();
+        spinner.stop();
+        if (servers.length === 0) {
+          if (!showLocal) {
+            Logger.info("No deployed servers yet.");
+            Logger.dim(`Use ${import_chalk6.default.cyan("mcphosting deploy")} to deploy your first MCP server.`);
+          }
+          return;
+        }
+        if (isJson) {
+          Logger.json(servers);
+          return;
+        }
+        Logger.bold(`\u{1F5A5}\uFE0F  Deployed Servers (${servers.length})`);
+        console.log("");
+        const tableData = servers.map((s) => ({
+          Name: s.name || s.slug,
+          Status: s.status === "active" ? import_chalk6.default.green("\u25CF active") : s.status === "deploying" ? import_chalk6.default.yellow("\u25D0 deploying") : s.status === "stopped" ? import_chalk6.default.dim("\u25CB stopped") : import_chalk6.default.red("\u2717 " + s.status),
+          Slug: s.slug,
+          URL: (s.url || "").length > 45 ? (s.url || "").slice(0, 42) + "..." : s.url || ""
+        }));
+        Logger.table(tableData);
+        console.log("");
+      } catch (error) {
+        spinner.fail("Failed to fetch servers");
+        Logger.error(error.message);
+      }
+    } else if (showRemote && !isAuthenticated()) {
+      Logger.dim(`Log in to see deployed servers: ${import_chalk6.default.cyan("mcphosting login")}`);
+      console.log("");
+    }
+  });
+}
+
+// src/commands/status.ts
+var import_commander7 = require("commander");
+var import_chalk7 = __toESM(require("chalk"), 1);
+function createStatusCommand() {
+  return new import_commander7.Command("status").description("Check the status of a deployed MCP server").argument("<slug-or-id>", "Server slug or ID").option("--json", "Output as JSON").action(async (slugOrId, options) => {
+    const isJson = options.json || Logger.isJsonMode;
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner(`Checking status of ${import_chalk7.default.cyan(slugOrId)}...`);
+    try {
+      const server = await api.getServer(slugOrId);
+      spinner.stop();
+      if (isJson) {
+        Logger.json(server);
+        return;
+      }
+      console.log("");
+      console.log(import_chalk7.default.bold(`\u{1F4E1} ${server.name || server.slug}`));
+      console.log("");
+      const statusIcon = server.status === "active" ? import_chalk7.default.green("\u25CF Active") : server.status === "deploying" ? import_chalk7.default.yellow("\u25D0 Deploying") : server.status === "stopped" ? import_chalk7.default.dim("\u25CB Stopped") : import_chalk7.default.red("\u2717 " + server.status);
+      const info = [
+        { Property: "Status", Value: statusIcon },
+        { Property: "Slug", Value: server.slug },
+        { Property: "URL", Value: server.url || "\u2014" }
+      ];
+      if (server.sseUrl) {
+        info.push({ Property: "SSE URL", Value: server.sseUrl });
+      }
+      if (server.streamableUrl) {
+        info.push({ Property: "Streamable", Value: server.streamableUrl });
+      }
+      if (server.githubUrl) {
+        info.push({ Property: "GitHub", Value: server.githubUrl });
+      }
+      info.push(
+        { Property: "Created", Value: server.createdAt ? new Date(server.createdAt).toLocaleString() : "\u2014" },
+        { Property: "Updated", Value: server.updatedAt ? new Date(server.updatedAt).toLocaleString() : "\u2014" }
+      );
+      Logger.table(info);
+      if (server.tools && server.tools.length > 0) {
+        console.log("");
+        console.log(import_chalk7.default.yellow("\u{1F527} Tools:"));
+        server.tools.forEach((tool) => {
+          console.log(`  \u2022 ${tool}`);
+        });
+      }
+      if (server.envVars && server.envVars.length > 0) {
+        console.log("");
+        console.log(import_chalk7.default.yellow("\u{1F511} Environment Variables:"));
+        server.envVars.forEach((env) => {
+          console.log(`  ${env.key} = ${env.masked ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : "(set)"}`);
+        });
+      }
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to get status");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/logs.ts
+var import_commander8 = require("commander");
+var import_chalk8 = __toESM(require("chalk"), 1);
+function createLogsCommand() {
+  return new import_commander8.Command("logs").description("View logs for a deployed MCP server").argument("<slug-or-id>", "Server slug or ID").option("-n, --lines <number>", "Number of log lines to show", "50").option("--json", "Output as JSON").action(async (slugOrId, options) => {
+    const isJson = options.json || Logger.isJsonMode;
+    const { api } = getAuthenticatedAPI();
+    const lines = parseInt(options.lines);
+    const spinner = Logger.spinner(`Fetching logs for ${import_chalk8.default.cyan(slugOrId)}...`);
+    try {
+      const logs = await api.getServerLogs(slugOrId, lines);
+      spinner.stop();
+      if (logs.length === 0) {
+        if (isJson) {
+          console.log(JSON.stringify({ success: true, logs: [] }));
+        } else {
+          Logger.info("No logs available yet.");
+        }
+        return;
+      }
+      if (isJson) {
+        Logger.json(logs);
+        return;
+      }
+      console.log("");
+      console.log(import_chalk8.default.bold(`\u{1F4DC} Logs: ${slugOrId}`));
+      console.log(import_chalk8.default.dim("\u2500".repeat(60)));
+      console.log("");
+      for (const entry of logs) {
+        const time = import_chalk8.default.dim(new Date(entry.timestamp).toLocaleTimeString());
+        const level = entry.level === "error" ? import_chalk8.default.red("ERR") : entry.level === "warn" ? import_chalk8.default.yellow("WRN") : entry.level === "debug" ? import_chalk8.default.dim("DBG") : import_chalk8.default.blue("INF");
+        console.log(`${time} ${level} ${entry.message}`);
+      }
+      console.log("");
+      console.log(import_chalk8.default.dim(`Showing last ${logs.length} entries`));
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to fetch logs");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/env.ts
+var import_commander9 = require("commander");
+var import_chalk9 = __toESM(require("chalk"), 1);
+function createEnvCommand() {
+  const env = new import_commander9.Command("env").description("Manage environment variables for a deployed MCP server");
+  env.command("list").description("List environment variables").argument("<slug-or-id>", "Server slug or ID").option("--json", "Output as JSON").action(async (slugOrId, options) => {
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner("Fetching environment variables...");
+    try {
+      const envVars = await api.listEnvVars(slugOrId);
+      spinner.stop();
+      if (envVars.length === 0) {
+        Logger.info("No environment variables set.");
+        Logger.dim(`Add one: ${import_chalk9.default.cyan(`mcphosting env set ${slugOrId} KEY=value`)}`);
+        return;
+      }
+      if (options.json) {
+        Logger.json(envVars);
+        return;
+      }
+      console.log("");
+      Logger.bold(`\u{1F511} Environment Variables: ${slugOrId}`);
+      console.log("");
+      envVars.forEach((env2) => {
+        console.log(`  ${import_chalk9.default.cyan(env2.key)} = ${env2.masked ? import_chalk9.default.dim("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022") : import_chalk9.default.dim("(set)")}`);
+      });
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to fetch environment variables");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  env.command("set").description("Set an environment variable (KEY=value)").argument("<slug-or-id>", "Server slug or ID").argument("<key-value>", "Environment variable in KEY=value format").action(async (slugOrId, keyValue) => {
+    const eqIndex = keyValue.indexOf("=");
+    if (eqIndex === -1) {
+      Logger.error("Invalid format. Use KEY=value");
+      Logger.dim(`Example: ${import_chalk9.default.cyan(`mcphosting env set ${slugOrId} API_KEY=sk-abc123`)}`);
+      process.exit(1);
+    }
+    const key = keyValue.substring(0, eqIndex);
+    const value = keyValue.substring(eqIndex + 1);
+    if (!key) {
+      Logger.error("Key cannot be empty.");
+      process.exit(1);
+    }
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner(`Setting ${import_chalk9.default.cyan(key)}...`);
+    try {
+      await api.addEnvVar(slugOrId, key, value);
+      spinner.succeed(`Set ${import_chalk9.default.bold(key)} on ${import_chalk9.default.cyan(slugOrId)}`);
+    } catch (error) {
+      spinner.fail(`Failed to set ${key}`);
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  env.command("remove").description("Remove an environment variable").argument("<slug-or-id>", "Server slug or ID").argument("<key>", "Environment variable key to remove").action(async (slugOrId, key) => {
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner(`Removing ${import_chalk9.default.cyan(key)}...`);
+    try {
+      await api.removeEnvVar(slugOrId, key);
+      spinner.succeed(`Removed ${import_chalk9.default.bold(key)} from ${import_chalk9.default.cyan(slugOrId)}`);
+    } catch (error) {
+      spinner.fail(`Failed to remove ${key}`);
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  return env;
+}
+
+// src/commands/keys.ts
+var import_commander10 = require("commander");
+var import_chalk10 = __toESM(require("chalk"), 1);
+function createKeysCommand() {
+  const keys = new import_commander10.Command("keys").description("Manage API keys");
+  keys.command("list").description("List your API keys").option("--json", "Output as JSON").action(async (options) => {
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner("Fetching API keys...");
+    try {
+      const apiKeys = await api.getAPIKeys();
+      spinner.stop();
+      if (apiKeys.length === 0) {
+        Logger.info("No API keys found.");
+        Logger.dim(`Create one: ${import_chalk10.default.cyan('mcphosting keys create "My Key"')}`);
+        return;
+      }
+      if (options.json) {
+        Logger.json(apiKeys);
+        return;
+      }
+      console.log("");
+      Logger.bold(`\u{1F511} API Keys (${apiKeys.length})`);
+      console.log("");
+      const tableData = apiKeys.map((key) => ({
+        Name: key.name,
+        Prefix: key.prefix + "...",
+        Created: new Date(key.createdAt).toLocaleDateString(),
+        "Last Used": key.lastUsedAt ? new Date(key.lastUsedAt).toLocaleDateString() : "Never"
+      }));
+      Logger.table(tableData);
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to fetch API keys");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  keys.command("create").description("Create a new API key").argument("<name>", "Name for the API key").action(async (name) => {
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner("Creating API key...");
+    try {
+      const key = await api.createAPIKey(name);
+      spinner.succeed("API key created!");
+      console.log("");
+      Logger.bold("\u{1F511} New API Key");
+      console.log("");
+      Logger.info(`  Name:   ${import_chalk10.default.bold(key.name)}`);
+      Logger.info(`  Key:    ${import_chalk10.default.green(key.key || key.prefix + "...")}`);
+      Logger.info(`  ID:     ${import_chalk10.default.dim(key.id)}`);
+      console.log("");
+      Logger.warning("Save this key now \u2014 it won't be shown again!");
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to create API key");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  keys.command("delete").description("Delete an API key").argument("<id>", "API key ID").action(async (id) => {
+    const { api } = getAuthenticatedAPI();
+    const spinner = Logger.spinner("Deleting API key...");
+    try {
+      await api.deleteAPIKey(id);
+      spinner.succeed(`API key ${import_chalk10.default.dim(id)} deleted.`);
+    } catch (error) {
+      spinner.fail("Failed to delete API key");
+      Logger.error(error.message);
+      process.exit(1);
+    }
+  });
+  return keys;
+}
+
+// src/commands/search.ts
+var import_commander11 = require("commander");
+var import_chalk11 = __toESM(require("chalk"), 1);
+function createSearchCommand() {
+  return new import_commander11.Command("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 connections = config.connections;
-    if (connections.length === 0) {
-      Logger.info("No MCP connections found");
-      Logger.dim("Use `mcphost connect <url>` to add one");
-      return;
+    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.");
+        Logger.dim("Try: 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} Marketplace Results");
+      console.log("");
+      limitedResults.forEach((server, index) => {
+        console.log(import_chalk11.default.cyan(`${index + 1}. ${server.name}`));
+        console.log(`   ${import_chalk11.default.dim(server.description)}`);
+        console.log(`   ${import_chalk11.default.yellow("Slug:")} ${server.slug} | ${import_chalk11.default.yellow("Installs:")} ${server.installs.toLocaleString()} | ${import_chalk11.default.yellow("By:")} ${server.author}`);
+        console.log(`   ${import_chalk11.default.green("Tools:")} ${server.tools.join(", ")}`);
+        console.log(`   ${import_chalk11.default.blue("Connect:")} ${import_chalk11.default.dim(`mcphosting connect ${server.slug}`)}`);
+        console.log("");
+      });
+      if (results.length > limit) {
+        Logger.dim(`Showing ${limit} of ${results.length}. Use --limit for more.`);
+      }
+    } catch (error) {
+      spinner.fail("Search failed");
+      Logger.error(error.message);
+      process.exit(1);
     }
-    if (options.json) {
-      Logger.json(connections);
-      return;
+  });
+}
+function createInfoCommand() {
+  return new import_commander11.Command("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(`Not found: ${slug}`);
+        Logger.info(`Use ${import_chalk11.default.cyan("mcphosting search <query>")} to find servers`);
+        return;
+      }
+      spinner.stop();
+      if (options.json) {
+        Logger.json(server);
+        return;
+      }
+      console.log("");
+      console.log(import_chalk11.default.bold.cyan(`\u{1F4E6} ${server.name}`));
+      console.log(import_chalk11.default.dim(server.description));
+      console.log("");
+      const info = [
+        { 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) {
+        info.push({ Property: "URL", Value: server.url });
+      }
+      Logger.table(info);
+      console.log("");
+      console.log(import_chalk11.default.yellow("\u{1F527} Available Tools:"));
+      server.tools.forEach((tool) => console.log(`  \u2022 ${tool}`));
+      console.log("");
+      console.log(import_chalk11.default.green("\u{1F4A1} Quick Start:"));
+      console.log(import_chalk11.default.dim(`  mcphosting connect ${server.slug}`));
+      const connection = config.findConnection(slug);
+      if (connection) {
+        console.log("");
+        console.log(import_chalk11.default.blue("\u2139\uFE0F  Already connected to:"), connection.clients.join(", "));
+      }
+      console.log("");
+    } catch (error) {
+      spinner.fail("Failed to get info");
+      Logger.error(error.message);
+      process.exit(1);
     }
-    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
-var import_commander3 = require("commander");
-var import_promises3 = require("fs/promises");
-var import_path2 = require("path");
+var import_commander12 = require("commander");
+var import_promises6 = require("fs/promises");
+var import_path5 = require("path");
 var import_os2 = require("os");
-var import_chalk3 = __toESM(require("chalk"), 1);
+var import_chalk12 = __toESM(require("chalk"), 1);
 function createImportCommand() {
-  return new import_commander3.Command("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) => {
+  return new import_commander12.Command("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");
@@ -678,16 +1940,16 @@ async function importFromSmitery(options) {
   try {
     const smitheryPaths = [
       options.configPath,
-      (0, import_path2.join)((0, import_os2.homedir)(), ".smithery", "config.json"),
-      (0, import_path2.join)((0, import_os2.homedir)(), ".config", "smithery", "config.json"),
-      (0, import_path2.join)((0, import_os2.homedir)(), "Library", "Application Support", "smithery", "config.json"),
-      (0, import_path2.join)(process.cwd(), "smithery.json"),
-      (0, import_path2.join)(process.cwd(), ".smithery.json")
+      (0, import_path5.join)((0, import_os2.homedir)(), ".smithery", "config.json"),
+      (0, import_path5.join)((0, import_os2.homedir)(), ".config", "smithery", "config.json"),
+      (0, import_path5.join)((0, import_os2.homedir)(), "Library", "Application Support", "smithery", "config.json"),
+      (0, import_path5.join)(process.cwd(), "smithery.json"),
+      (0, import_path5.join)(process.cwd(), ".smithery.json")
     ].filter(Boolean);
     let smitheryConfigPath = null;
     for (const path of smitheryPaths) {
       try {
-        await (0, import_promises3.access)(path);
+        await (0, import_promises6.access)(path);
         smitheryConfigPath = path;
         break;
       } catch {
@@ -703,7 +1965,7 @@ async function importFromSmitery(options) {
     }
     spinner.succeed(`Found Smithery config: ${smitheryConfigPath}`);
     const loadSpinner = Logger.spinner("Reading Smithery config...");
-    const configContent = await (0, import_promises3.readFile)(smitheryConfigPath, "utf-8");
+    const configContent = await (0, import_promises6.readFile)(smitheryConfigPath, "utf-8");
     const smitheryConfig = JSON.parse(configContent);
     const servers = {
       ...smitheryConfig.servers,
@@ -716,14 +1978,14 @@ async function importFromSmitery(options) {
     const serverEntries = Object.entries(servers);
     loadSpinner.succeed(`Found ${serverEntries.length} MCP server(s) in Smithery config`);
     if (options.dryRun) {
-      console.log("\n" + import_chalk3.default.bold("\u{1F50D} Preview: Would import the following MCP servers:"));
+      console.log("\n" + import_chalk12.default.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 ${import_chalk3.default.cyan(slug)}`);
-        console.log(`  URL: ${import_chalk3.default.dim(url)}`);
+        console.log(`\u2022 ${import_chalk12.default.cyan(slug)}`);
+        console.log(`  URL: ${import_chalk12.default.dim(url)}`);
         if (serverConfig.command) {
-          console.log(`  Command: ${import_chalk3.default.dim(serverConfig.command + " " + (serverConfig.args?.join(" ") || ""))}`);
+          console.log(`  Command: ${import_chalk12.default.dim(serverConfig.command + " " + (serverConfig.args?.join(" ") || ""))}`);
         }
         console.log("");
       });
@@ -743,7 +2005,7 @@ async function importFromSmitery(options) {
         }
         let url = serverConfig.url;
         if (!url) {
-          if (serverConfig.command === "npx" && serverConfig.args?.[0] === "@mcphosting/cli") {
+          if (serverConfig.command === "npx" && serverConfig.args?.[0] === "mcphosting-cli") {
             url = serverConfig.args[2];
           } else {
             url = `https://${slug}.mcphost.dev`;
@@ -788,9 +2050,9 @@ async function importFromSmitery(options) {
     }
     console.log("");
     Logger.info("Use `mcphost list` to see your imported connections");
-    console.log("\n" + import_chalk3.default.green("\u{1F389} Welcome to MCPHosting! Share with your team:"));
-    console.log(import_chalk3.default.cyan("npx @mcphosting/cli import --from smithery"));
-    console.log("\n" + import_chalk3.default.yellow("\u2B50 Star us: ") + import_chalk3.default.blue("https://github.com/gorlomi-enzo/mcphosting-cli"));
+    console.log("\n" + import_chalk12.default.green("\u{1F389} Welcome to MCPHosting! Share with your team:"));
+    console.log(import_chalk12.default.cyan("npx mcphosting-cli import --from smithery"));
+    console.log("\n" + import_chalk12.default.yellow("\u2B50 Star us: ") + import_chalk12.default.blue("https://github.com/gorlomi-enzo/mcphosting-cli"));
     console.log("");
   } catch (error) {
     spinner.fail("Import failed");
@@ -803,9 +2065,9 @@ async function importFromSmitery(options) {
 }
 
 // src/commands/proxy.ts
-var import_commander4 = require("commander");
+var import_commander13 = require("commander");
 function createProxyCommand() {
-  return new import_commander4.Command("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) => {
+  return new import_commander13.Command("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}`);
@@ -872,7 +2134,7 @@ async function forwardMessage(url, message, quiet) {
       headers: {
         "Content-Type": "application/json",
         "Accept": "application/json",
-        "User-Agent": "@mcphosting/cli-proxy"
+        "User-Agent": "mcphosting-cli-proxy"
       },
       body: message
     });
@@ -902,279 +2164,478 @@ async function forwardMessage(url, message, quiet) {
   }
 }
 
-// src/commands/search.ts
-var import_commander5 = require("commander");
-var import_chalk4 = __toESM(require("chalk"), 1);
-function createSearchCommand() {
-  return new import_commander5.Command("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) => {
+// src/commands/whoami.ts
+var import_commander14 = require("commander");
+var import_chalk13 = __toESM(require("chalk"), 1);
+function createWhoamiCommand() {
+  return new import_commander14.Command("whoami").description("Show current logged-in user").option("--json", "Output as JSON").action(async (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 token = config.token;
+    if (!token) {
+      if (options.json || Logger.isJsonMode) {
+        console.log(JSON.stringify({ success: false, logged_in: false, error: "Not logged in" }));
+      } else {
+        Logger.info("Not logged in.");
+        Logger.dim(`Run ${import_chalk13.default.cyan("mcphosting login")} to authenticate.`);
       }
-      const limit = parseInt(options.limit);
-      const limitedResults = results.slice(0, limit);
-      if (options.json) {
-        Logger.json(limitedResults);
-        return;
+      return;
+    }
+    const api = new MCPHostingAPI(token);
+    const user = await api.whoami();
+    if (!user && token) {
+      if (options.json || Logger.isJsonMode) {
+        console.log(JSON.stringify({
+          success: false,
+          logged_in: false,
+          error: "Token expired",
+          cached_email: config.user?.email
+        }));
+      } else {
+        Logger.warning("Token expired. Run `mcphosting login` to re-authenticate.");
+        if (config.user?.email) {
+          Logger.dim(`  Cached email: ${config.user.email}`);
+        }
       }
+      return;
+    }
+    const result = {
+      success: true,
+      logged_in: true,
+      email: user?.email || config.user?.email || "unknown",
+      org: user?.org || config.user?.org || void 0,
+      token_source: config.isEnvToken ? "environment" : "config"
+    };
+    if (options.json || Logger.isJsonMode) {
+      console.log(JSON.stringify(result));
+    } else {
       console.log("");
-      Logger.bold(`\u{1F50D} MCP Marketplace Search Results`);
-      console.log("");
-      limitedResults.forEach((server, index) => {
-        console.log(import_chalk4.default.cyan(`${index + 1}. ${server.name}`));
-        console.log(`   ${import_chalk4.default.dim(server.description)}`);
-        console.log(`   ${import_chalk4.default.yellow("Slug:")} ${server.slug} | ${import_chalk4.default.yellow("Installs:")} ${server.installs.toLocaleString()} | ${import_chalk4.default.yellow("Author:")} ${server.author}`);
-        console.log(`   ${import_chalk4.default.green("Tools:")} ${server.tools.join(", ")}`);
-        if (server.url) {
-          console.log(`   ${import_chalk4.default.blue("Connect:")} ${import_chalk4.default.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.success(`Logged in as ${import_chalk13.default.bold(result.email)}${result.org ? ` (${result.org})` : ""}`);
+      if (config.isEnvToken) {
+        Logger.dim("  Token source: MCPHOSTING_TOKEN environment variable");
       }
-      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);
+      console.log("");
     }
   });
 }
-function createInfoCommand() {
-  return new import_commander5.Command("info").description("Show detailed information about an MCP server").argument("<slug>", "MCP server slug").option("--json", "Output as JSON").action(async (slug, options) => {
+
+// src/commands/account-status.ts
+var import_commander15 = require("commander");
+var import_chalk14 = __toESM(require("chalk"), 1);
+function createAccountCommand() {
+  return new import_commander15.Command("account").description("Show MCPHosting account status, plan, and servers").option("--json", "Output as JSON").action(async (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;
+    if (!isAuthenticated()) {
+      if (options.json || Logger.isJsonMode) {
+        console.log(JSON.stringify({
+          success: false,
+          logged_in: false,
+          error: "Not logged in"
+        }));
+      } else {
+        Logger.error("Not logged in.");
+        Logger.info(`Run ${import_chalk14.default.cyan("mcphosting login")} to authenticate.`);
       }
-      spinner.succeed("Found server info");
-      if (options.json) {
-        Logger.json(server);
+      return;
+    }
+    const { api } = getAuthenticatedAPI();
+    try {
+      const [user, servers] = await Promise.all([
+        api.whoami(),
+        api.listServers().catch(() => [])
+      ]);
+      const result = {
+        success: true,
+        logged_in: true,
+        email: user?.email || config.user?.email || "unknown",
+        org: user?.org || config.user?.org || void 0,
+        plan: user?.plan || "free",
+        token_source: config.isEnvToken ? "environment" : "config",
+        servers: servers.map((s) => ({
+          name: s.name || s.slug,
+          slug: s.slug,
+          url: s.url || "",
+          status: s.status || "unknown"
+        }))
+      };
+      if (options.json || Logger.isJsonMode) {
+        console.log(JSON.stringify(result));
         return;
       }
       console.log("");
-      console.log(import_chalk4.default.bold.cyan(`\u{1F4E6} ${server.name}`));
-      console.log(import_chalk4.default.dim(server.description));
+      Logger.bold("\u{1F4CA} MCPHosting Account");
       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.info(`  ${import_chalk14.default.dim("Email:")}   ${import_chalk14.default.bold(result.email)}`);
+      if (result.org) {
+        Logger.info(`  ${import_chalk14.default.dim("Org:")}     ${result.org}`);
       }
-      Logger.table(infoTable);
+      Logger.info(`  ${import_chalk14.default.dim("Plan:")}    ${import_chalk14.default.cyan(result.plan)}`);
+      Logger.info(`  ${import_chalk14.default.dim("Servers:")} ${result.servers.length}`);
       console.log("");
-      console.log(import_chalk4.default.yellow("\u{1F527} Available Tools:"));
-      server.tools.forEach((tool) => {
-        console.log(`  \u2022 ${tool}`);
-      });
-      console.log("");
-      console.log(import_chalk4.default.green("\u{1F4A1} Quick Start:"));
-      console.log(import_chalk4.default.dim(`  mcphost connect ${server.slug}`));
-      const connection = config.findConnection(slug);
-      if (connection) {
+      if (result.servers.length > 0) {
+        Logger.bold("\u{1F5A5}\uFE0F  Your MCP Servers");
         console.log("");
-        console.log(import_chalk4.default.blue("\u2139\uFE0F  Already connected to:"), connection.clients.join(", "));
+        const tableData = result.servers.map((s) => ({
+          Name: s.name,
+          Status: s.status === "active" ? import_chalk14.default.green("\u25CF active") : s.status === "deploying" ? import_chalk14.default.yellow("\u25D0 deploying") : s.status === "stopped" ? import_chalk14.default.dim("\u25CB stopped") : import_chalk14.default.red("\u2717 " + s.status),
+          URL: s.url.length > 40 ? s.url.slice(0, 37) + "..." : s.url
+        }));
+        Logger.table(tableData);
+      } else {
+        Logger.dim("  No servers deployed yet.");
+        Logger.dim(`  Run ${import_chalk14.default.cyan("mcphosting deploy --template weather")} to get started.`);
       }
+      console.log("");
     } catch (error) {
-      spinner.fail("Failed to get server info");
-      Logger.error(`Error: ${error}`);
-      process.exit(1);
+      if (options.json || Logger.isJsonMode) {
+        console.log(JSON.stringify({ success: false, error: error.message }));
+      } else {
+        Logger.error(error.message);
+      }
     }
   });
 }
 
-// src/commands/servers.ts
-var import_commander6 = require("commander");
-function createServersCommand() {
-  const servers = new import_commander6.Command("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;
+// src/commands/completions.ts
+var import_commander16 = require("commander");
+var import_chalk15 = __toESM(require("chalk"), 1);
+var BASH_COMPLETIONS = `
+# mcphosting bash completions
+_mcphosting_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local commands="login logout deploy init connect disconnect list status logs env keys search info import proxy whoami account completions"
+  local templates="weather crypto notion postgres blank runescape reminder search"
+  local global_opts="--help --version --json --silent"
+
+  case "\${prev}" in
+    mcphosting|mcphost)
+      COMPREPLY=( $(compgen -W "\${commands} \${global_opts}" -- "\${cur}") )
+      return 0
+      ;;
+    deploy)
+      COMPREPLY=( $(compgen -W "--template --github --api-url --name --auth --json --silent --configure --no-auto-key" -- "\${cur}") )
+      return 0
+      ;;
+    --template)
+      COMPREPLY=( $(compgen -W "\${templates}" -- "\${cur}") )
+      return 0
+      ;;
+    --auth)
+      COMPREPLY=( $(compgen -W "none api_key oauth" -- "\${cur}") )
+      return 0
+      ;;
+    --shell)
+      COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") )
+      return 0
+      ;;
+    env)
+      COMPREPLY=( $(compgen -W "list set remove" -- "\${cur}") )
+      return 0
+      ;;
+    keys)
+      COMPREPLY=( $(compgen -W "list create delete" -- "\${cur}") )
+      return 0
+      ;;
+    login)
+      COMPREPLY=( $(compgen -W "--github --email --token --browser --json" -- "\${cur}") )
+      return 0
+      ;;
+    list)
+      COMPREPLY=( $(compgen -W "--local --remote --json" -- "\${cur}") )
+      return 0
+      ;;
+    status|logs)
+      COMPREPLY=( $(compgen -W "--json" -- "\${cur}") )
+      return 0
+      ;;
+    *)
+      COMPREPLY=( $(compgen -W "\${global_opts}" -- "\${cur}") )
+      return 0
+      ;;
+  esac
 }
-function createKeysCommand() {
-  const keys = new import_commander6.Command("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;
+complete -F _mcphosting_completions mcphosting
+complete -F _mcphosting_completions mcphost
+`.trim();
+var ZSH_COMPLETIONS = `
+#compdef mcphosting mcphost
+
+_mcphosting() {
+  local -a commands templates global_opts
+
+  commands=(
+    'login:Authenticate with MCPHosting'
+    'logout:Log out and remove stored credentials'
+    'deploy:Deploy an MCP server to MCPHosting'
+    'init:Initialize mcphosting.json in the current directory'
+    'connect:Connect an MCP server to your AI clients'
+    'disconnect:Disconnect an MCP server'
+    'list:List your MCP servers'
+    'status:Check the status of a deployed MCP server'
+    'logs:View logs for a deployed MCP server'
+    'env:Manage environment variables'
+    'keys:Manage API keys'
+    'search:Search MCP servers in the marketplace'
+    'info:Show detailed information about an MCP server'
+    'import:Import MCP connections from other tools'
+    'proxy:Start a local STDIO MCP proxy'
+    'whoami:Show current logged-in user'
+    'account:Show MCPHosting account status'
+    'completions:Generate shell completions'
+  )
+
+  templates=(weather crypto notion postgres blank runescape reminder search)
+  global_opts=(--help --version --json --silent)
+
+  _arguments -C \\
+    '1:command:->cmd' \\
+    '*::arg:->args'
+
+  case "$state" in
+    cmd)
+      _describe -t commands 'mcphosting commands' commands
+      _values 'global options' $global_opts
+      ;;
+    args)
+      case "$words[1]" in
+        deploy)
+          _arguments \\
+            '--template[Deploy from template]:template:(weather crypto notion postgres blank runescape reminder search)' \\
+            '--github[Deploy from GitHub URL]:url:' \\
+            '--api-url[External server URL]:url:' \\
+            '--name[Server name]:name:' \\
+            '--auth[Auth type]:auth:(none api_key oauth)' \\
+            '--json[Output as JSON]' \\
+            '--silent[Suppress interactive output]' \\
+            '--configure[Auto-configure AI clients]' \\
+            '--no-auto-key[Skip API key creation]'
+          ;;
+        completions)
+          _arguments '--shell[Shell type]:shell:(bash zsh fish)'
+          ;;
+        login)
+          _arguments '--github' '--email:email:' '--token:token:' '--browser' '--json'
+          ;;
+        *)
+          _arguments '--json[Output as JSON]'
+          ;;
+      esac
+      ;;
+  esac
 }
-function createPublishCommand() {
-  return new import_commander6.Command("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}`);
+
+_mcphosting "$@"
+`.trim();
+var FISH_COMPLETIONS = `
+# mcphosting fish completions
+set -l commands login logout deploy init connect disconnect list status logs env keys search info import proxy whoami account completions
+set -l templates weather crypto notion postgres blank runescape reminder search
+
+complete -c mcphosting -f
+complete -c mcphost -f
+
+# Commands
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a login -d "Authenticate with MCPHosting"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a logout -d "Log out"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a deploy -d "Deploy an MCP server"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a init -d "Initialize mcphosting.json"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a connect -d "Connect MCP to AI clients"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a disconnect -d "Disconnect MCP server"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a list -d "List servers"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a status -d "Check server status"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a logs -d "View logs"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a env -d "Manage env vars"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a keys -d "Manage API keys"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a search -d "Search marketplace"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a info -d "MCP server info"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a import -d "Import connections"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a proxy -d "STDIO proxy"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a whoami -d "Show current user"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a account -d "Account status"
+complete -c mcphosting -n "not __fish_seen_subcommand_from $commands" -a completions -d "Generate completions"
+
+# Global
+complete -c mcphosting -l json -d "Output as JSON"
+complete -c mcphosting -l silent -d "Suppress interactive output"
+complete -c mcphosting -l help -d "Show help"
+complete -c mcphosting -l version -d "Show version"
+
+# Deploy options
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l template -xa "$templates" -d "Template name"
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l github -d "GitHub URL"
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l api-url -d "API URL"
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l name -d "Server name"
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l auth -xa "none api_key oauth" -d "Auth type"
+complete -c mcphosting -n "__fish_seen_subcommand_from deploy" -l configure -d "Auto-configure clients"
+
+# Completions options
+complete -c mcphosting -n "__fish_seen_subcommand_from completions" -l shell -xa "bash zsh fish" -d "Shell type"
+`.trim();
+function createCompletionsCommand() {
+  return new import_commander16.Command("completions").description("Generate shell completions (bash, zsh, fish)").option("--shell <shell>", "Shell type: bash, zsh, or fish").action((options) => {
+    const shell = options.shell?.toLowerCase() || detectShell();
+    switch (shell) {
+      case "bash":
+        console.log(BASH_COMPLETIONS);
+        if (!options.shell) {
+          console.error("");
+          console.error(import_chalk15.default.dim("# Add to ~/.bashrc:"));
+          console.error(import_chalk15.default.cyan("#   mcphosting completions --shell=bash >> ~/.bashrc"));
+        }
+        break;
+      case "zsh":
+        console.log(ZSH_COMPLETIONS);
+        if (!options.shell) {
+          console.error("");
+          console.error(import_chalk15.default.dim("# Save to a file in your fpath:"));
+          console.error(import_chalk15.default.cyan("#   mcphosting completions --shell=zsh > ~/.zfunc/_mcphosting"));
+        }
+        break;
+      case "fish":
+        console.log(FISH_COMPLETIONS);
+        if (!options.shell) {
+          console.error("");
+          console.error(import_chalk15.default.dim("# Save to completions dir:"));
+          console.error(import_chalk15.default.cyan("#   mcphosting completions --shell=fish > ~/.config/fish/completions/mcphosting.fish"));
+        }
+        break;
+      default:
+        Logger.error(`Unknown shell: ${shell}`);
+        Logger.info("Supported shells: bash, zsh, fish");
+        Logger.info("Usage: mcphosting completions --shell=bash");
+        process.exit(1);
     }
   });
 }
+function detectShell() {
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("fish")) return "fish";
+  return "bash";
+}
 
 // src/index.ts
-var import_chalk5 = __toESM(require("chalk"), 1);
-var program = new import_commander7.Command();
-program.name("mcphost").description("Connect AI agents to MCP servers. Browse, install, and manage Model Context Protocol servers.").version("0.1.0").configureOutput({
+var program = new import_commander17.Command();
+program.name("mcphosting").description("Deploy and manage MCP servers from the terminal").version("1.0.0").option("--json", "Output all results as JSON (agent-friendly)").option("--silent", "Suppress interactive output and prompts").configureOutput({
   outputError: (str, write) => {
-    write(import_chalk5.default.red(str));
+    if (Logger.isJsonMode) {
+      write(JSON.stringify({ success: false, error: str.trim() }));
+    } else {
+      write(import_chalk16.default.red(str));
+    }
+  }
+}).hook("preAction", (thisCommand) => {
+  const rootOpts = program.opts();
+  if (rootOpts.json) {
+    Logger.jsonMode = true;
+  }
+  if (rootOpts.silent) {
+    Logger.silent = true;
   }
 });
-program.addCommand(createConnectCommands());
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createDeployCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createConnectCommand());
 program.addCommand(createDisconnectCommand());
 program.addCommand(createListCommand());
-program.addCommand(createImportCommand());
-program.addCommand(createProxyCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createLogsCommand());
+program.addCommand(createEnvCommand());
+program.addCommand(createKeysCommand());
 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.addCommand(createWhoamiCommand());
+program.addCommand(createAccountCommand());
+program.addCommand(createImportCommand());
+program.addCommand(createProxyCommand());
+program.addCommand(createCompletionsCommand());
 program.configureHelp({
-  subcommandTerm: (cmd) => import_chalk5.default.cyan(cmd.name()),
-  commandUsage: (cmd) => {
-    const usage = cmd.usage();
-    return import_chalk5.default.yellow(usage);
-  },
-  commandDescription: (cmd) => {
-    return import_chalk5.default.dim(cmd.description());
-  }
+  subcommandTerm: (cmd) => import_chalk16.default.cyan(cmd.name()),
+  commandUsage: (cmd) => import_chalk16.default.yellow(cmd.usage()),
+  commandDescription: (cmd) => import_chalk16.default.dim(cmd.description())
 });
 program.addHelpText("after", `
-${import_chalk5.default.bold("Examples:")}
-  ${import_chalk5.default.cyan("mcphost connect github")}                    ${import_chalk5.default.dim("Connect to GitHub MCP server")}
-  ${import_chalk5.default.cyan("mcphost connect https://my-mcp.example.com")}  ${import_chalk5.default.dim("Connect to custom MCP server")}
-  ${import_chalk5.default.cyan("mcphost connect slack --client claude")}      ${import_chalk5.default.dim("Connect Slack MCP only to Claude")}
-  ${import_chalk5.default.cyan("mcphost list")}                             ${import_chalk5.default.dim("List all connected MCP servers")}
-  ${import_chalk5.default.cyan("mcphost search github")}                    ${import_chalk5.default.dim("Search marketplace for MCP servers")}
-  ${import_chalk5.default.cyan("mcphost info notion")}                      ${import_chalk5.default.dim("Get details about Notion MCP")}
-  ${import_chalk5.default.cyan("mcphost import --from smithery")}           ${import_chalk5.default.dim("Import connections from Smithery")}
-  ${import_chalk5.default.cyan("mcphost disconnect github")}               ${import_chalk5.default.dim("Remove GitHub MCP connection")}
+${import_chalk16.default.bold("Quick Start (one command!):")}
+  ${import_chalk16.default.dim("1.")} ${import_chalk16.default.cyan("mcphosting login")}                              ${import_chalk16.default.dim("Authenticate")}
+  ${import_chalk16.default.dim("2.")} ${import_chalk16.default.cyan("mcphosting deploy --template weather")}          ${import_chalk16.default.dim("Deploy a template")}
+  ${import_chalk16.default.dim("   ")} ${import_chalk16.default.dim("Done! URL returned. API key created. Config ready.")}
 
-${import_chalk5.default.bold("Supported AI Clients:")}
-  \u2022 ${import_chalk5.default.green("Claude Desktop")} - Auto-configured via claude_desktop_config.json
-  \u2022 ${import_chalk5.default.green("Cursor")} - Auto-configured via .cursor/mcp.json  
-  \u2022 ${import_chalk5.default.green("VS Code")} - Configured via .vscode/mcp.json
-  \u2022 ${import_chalk5.default.green("OpenClaw")} - Auto-configured via ~/.openclaw/mcp.json
-  \u2022 ${import_chalk5.default.green("ChatGPT")} - Manual setup with web instructions
+${import_chalk16.default.bold("Global Flags:")}
+  ${import_chalk16.default.cyan("--json")}                                         ${import_chalk16.default.dim("Output as JSON (agent-friendly)")}
+  ${import_chalk16.default.cyan("--silent")}                                       ${import_chalk16.default.dim("Suppress interactive output")}
 
-${import_chalk5.default.bold("Get Started:")}
-  ${import_chalk5.default.dim("1.")} ${import_chalk5.default.cyan("mcphost search <topic>")}     ${import_chalk5.default.dim("Find MCP servers")}
-  ${import_chalk5.default.dim("2.")} ${import_chalk5.default.cyan("mcphost connect <slug>")}     ${import_chalk5.default.dim("Connect to your AI clients")}
-  ${import_chalk5.default.dim("3.")} ${import_chalk5.default.cyan("mcphost list")}              ${import_chalk5.default.dim("View your connections")}
+${import_chalk16.default.bold("Environment Variables:")}
+  ${import_chalk16.default.cyan("MCPHOSTING_TOKEN")}                               ${import_chalk16.default.dim("Auth token (overrides config)")}
+  ${import_chalk16.default.cyan("MCPHOSTING_API_URL")}                             ${import_chalk16.default.dim("API base URL (default: mcphosting.com)")}
 
-${import_chalk5.default.yellow("\u2B50 Star us:")} ${import_chalk5.default.blue("https://github.com/gorlomi-enzo/mcphosting-cli")}
-${import_chalk5.default.yellow("\u{1F4DA} Docs:")} ${import_chalk5.default.blue("https://mcphosting.com/docs")}
+${import_chalk16.default.bold("Deploy Options:")}
+  ${import_chalk16.default.cyan("mcphosting deploy")}                              ${import_chalk16.default.dim("Deploy from current directory")}
+  ${import_chalk16.default.cyan("mcphosting deploy --template crypto")}            ${import_chalk16.default.dim("Deploy from template")}
+  ${import_chalk16.default.cyan("mcphosting deploy --github <url>")}               ${import_chalk16.default.dim("Deploy from GitHub repo")}
+  ${import_chalk16.default.cyan("mcphosting deploy --api-url <url>")}              ${import_chalk16.default.dim("Register external server")}
+  ${import_chalk16.default.cyan("mcphosting deploy --configure")}                  ${import_chalk16.default.dim("Auto-configure AI clients")}
+
+${import_chalk16.default.bold("Templates:")}
+  ${import_chalk16.default.cyan("weather")}  ${import_chalk16.default.cyan("crypto")}  ${import_chalk16.default.cyan("notion")}  ${import_chalk16.default.cyan("postgres")}  ${import_chalk16.default.cyan("blank")}
+
+${import_chalk16.default.bold("Agent Usage:")}
+  ${import_chalk16.default.cyan("mcphosting deploy --template crypto --json")}     ${import_chalk16.default.dim("Deploy + JSON output")}
+  ${import_chalk16.default.cyan("mcphosting whoami --json")}                       ${import_chalk16.default.dim("Check auth status")}
+  ${import_chalk16.default.cyan("mcphosting account --json")}                      ${import_chalk16.default.dim("Account + servers")}
+  ${import_chalk16.default.cyan("mcphosting list --json")}                         ${import_chalk16.default.dim("List all servers")}
+
+${import_chalk16.default.bold("More Commands:")}
+  ${import_chalk16.default.cyan("mcphosting init")}                                ${import_chalk16.default.dim("Create mcphosting.json")}
+  ${import_chalk16.default.cyan("mcphosting connect <slug>")}                      ${import_chalk16.default.dim("Connect MCP to AI clients")}
+  ${import_chalk16.default.cyan("mcphosting list")}                                ${import_chalk16.default.dim("List all servers")}
+  ${import_chalk16.default.cyan("mcphosting status <server>")}                     ${import_chalk16.default.dim("Check server status")}
+  ${import_chalk16.default.cyan('mcphosting keys create "Key Name"')}              ${import_chalk16.default.dim("Create API key")}
+  ${import_chalk16.default.cyan("mcphosting search <query>")}                      ${import_chalk16.default.dim("Search marketplace")}
+  ${import_chalk16.default.cyan("mcphosting completions --shell=zsh")}             ${import_chalk16.default.dim("Shell completions")}
+
+${import_chalk16.default.bold("Supported AI Clients:")}
+  \u2022 ${import_chalk16.default.green("Claude Desktop")}  \u2022 ${import_chalk16.default.green("Cursor")}  \u2022 ${import_chalk16.default.green("VS Code")}  \u2022 ${import_chalk16.default.green("OpenClaw")}  \u2022 ${import_chalk16.default.green("ChatGPT")}
+
+${import_chalk16.default.yellow("\u{1F4DA} Docs:")} ${import_chalk16.default.blue("https://mcphosting.com/docs")}
+${import_chalk16.default.yellow("\u2B50 GitHub:")} ${import_chalk16.default.blue("https://github.com/gorlomi-enzo/mcphosting-cli")}
 `);
 process.on("uncaughtException", (error) => {
-  Logger.error(`Uncaught error: ${error.message}`);
-  if (process.env.DEBUG) {
-    console.error(error.stack);
+  if (Logger.isJsonMode) {
+    console.error(JSON.stringify({ success: false, error: error.message }));
+  } else {
+    Logger.error(`Unexpected 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);
+  if (Logger.isJsonMode) {
+    console.error(JSON.stringify({ success: false, error: String(reason) }));
+  } else {
+    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}");
+  if (!Logger.isSilent && !Logger.isJsonMode) {
+    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);
+    if (Logger.isJsonMode) {
+      console.error(JSON.stringify({ success: false, error: error.message }));
+    } else {
+      Logger.error(`Command failed: ${error.message}`);
     }
+    if (process.env.DEBUG) console.error(error);
     process.exit(1);
   }
 }