@mcp-use/cli 2.2.1 → 2.2.2-canary.0

package/dist/index.js

@@ -24,17 +24,1100 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_config = require("dotenv/config");
+var import_config4 = require("dotenv/config");
 var import_commander = require("commander");
-var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
+var import_node_child_process3 = require("child_process");
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"));
-var import_open = __toESM(require("open"));
+var import_node_path3 = __toESM(require("path"));
+var import_open3 = __toESM(require("open"));
+var import_chalk3 = __toESM(require("chalk"));
+
+// src/commands/auth.ts
 var import_chalk = __toESM(require("chalk"));
+var import_node_http = require("http");
+var import_open = __toESM(require("open"));
+
+// src/utils/config.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var import_node_os = __toESM(require("os"));
+var CONFIG_DIR = import_node_path.default.join(import_node_os.default.homedir(), ".mcp-use");
+var CONFIG_FILE = import_node_path.default.join(CONFIG_DIR, "config.json");
+var DEFAULT_API_URL = process.env.MCP_API_URL ? process.env.MCP_API_URL.replace(/\/api\/v1$/, "") + "/api/v1" : "https://cloud.mcp-use.com/api/v1";
+var DEFAULT_WEB_URL = process.env.MCP_WEB_URL ? process.env.MCP_WEB_URL : "https://mcp-use.com";
+async function ensureConfigDir() {
+  try {
+    await import_node_fs.promises.mkdir(CONFIG_DIR, { recursive: true });
+  } catch (error) {
+  }
+}
+async function readConfig() {
+  try {
+    const content = await import_node_fs.promises.readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await ensureConfigDir();
+  await import_node_fs.promises.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+async function deleteConfig() {
+  try {
+    await import_node_fs.promises.unlink(CONFIG_FILE);
+  } catch (error) {
+  }
+}
+async function getApiUrl() {
+  const config = await readConfig();
+  return config.apiUrl || DEFAULT_API_URL;
+}
+async function getApiKey() {
+  const config = await readConfig();
+  return config.apiKey || null;
+}
+async function isLoggedIn() {
+  const apiKey = await getApiKey();
+  return !!apiKey;
+}
+async function getWebUrl() {
+  return DEFAULT_WEB_URL;
+}
+
+// src/utils/api.ts
+var McpUseAPI = class _McpUseAPI {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl || "";
+    this.apiKey = apiKey;
+  }
+  /**
+   * Initialize API client with config
+   */
+  static async create() {
+    const baseUrl = await getApiUrl();
+    const apiKey = await getApiKey();
+    return new _McpUseAPI(baseUrl, apiKey ?? void 0);
+  }
+  /**
+   * Make authenticated request
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API request failed: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Create API key using JWT token
+   */
+  async createApiKey(jwtToken, name = "CLI") {
+    const url = `${this.baseUrl}/api-key`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${jwtToken}`
+      },
+      body: JSON.stringify({ name })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to create API key: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Test authentication
+   */
+  async testAuth() {
+    return this.request("/test-auth");
+  }
+  /**
+   * Create deployment
+   */
+  async createDeployment(request) {
+    return this.request("/deployments", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Get deployment by ID
+   */
+  async getDeployment(deploymentId) {
+    return this.request(`/deployments/${deploymentId}`);
+  }
+  /**
+   * Stream deployment logs
+   */
+  async *streamDeploymentLogs(deploymentId) {
+    const url = `${this.baseUrl}/deployments/${deploymentId}/logs/stream`;
+    const headers = {};
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to stream logs: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.log) {
+                yield parsed.log;
+              } else if (parsed.error) {
+                throw new Error(parsed.error);
+              }
+            } catch (e) {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Upload source code tarball
+   */
+  async uploadSource(filePath) {
+    const { readFile } = await import("fs/promises");
+    const { basename } = await import("path");
+    const fileBuffer = await readFile(filePath);
+    const filename = basename(filePath);
+    const formData = new FormData();
+    const blob = new Blob([fileBuffer], { type: "application/gzip" });
+    formData.append("file", blob, filename);
+    const url = `${this.baseUrl}/uploads`;
+    const headers = {};
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: formData
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Upload failed: ${error}`);
+    }
+    return response.json();
+  }
+};
+
+// src/commands/auth.ts
+var LOGIN_TIMEOUT = 3e5;
+async function findAvailablePort(startPort = 8765) {
+  for (let port = startPort; port < startPort + 100; port++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const server = (0, import_node_http.createServer)();
+        server.once("error", reject);
+        server.once("listening", () => {
+          server.close();
+          resolve();
+        });
+        server.listen(port);
+      });
+      return port;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("No available ports found");
+}
+async function startCallbackServer(port) {
+  return new Promise((resolve, reject) => {
+    let tokenResolver = null;
+    const tokenPromise = new Promise((res) => {
+      tokenResolver = res;
+    });
+    const server = (0, import_node_http.createServer)((req, res) => {
+      if (req.url?.startsWith("/callback")) {
+        const url = new URL(req.url, `http://localhost:${port}`);
+        const token = url.searchParams.get("token");
+        if (token && tokenResolver) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+              <!DOCTYPE html>
+              <html>
+                <head>
+                  <title>Login Successful</title>
+                  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                  <style>
+                    * {
+                      margin: 0;
+                      padding: 0;
+                      box-sizing: border-box;
+                    }
+                    body {
+                      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                      display: flex;
+                      justify-content: center;
+                      align-items: center;
+                      min-height: 100vh;
+                      background: #000;
+                      padding: 1rem;
+                    }
+                    .container {
+                      width: 100%;
+                      max-width: 28rem;
+                      padding: 3rem;
+                      text-align: center;
+                      -webkit-backdrop-filter: blur(40px);
+                      border: 1px solid rgba(255, 255, 255, 0.2);
+                      border-radius: 1.5rem;
+                      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+                    }
+                    .icon-container {
+                      display: inline-flex;
+                      align-items: center;
+                      justify-content: center;
+                      width: 6rem;
+                      height: 6rem;
+                      margin-bottom: 2rem;
+                      background: rgba(255, 255, 255, 0.1);
+                      backdrop-filter: blur(10px);
+                      -webkit-backdrop-filter: blur(10px);
+                      border-radius: 50%;
+                    }
+                    .checkmark {
+                      font-size: 4rem;
+                      color: #fff;
+                      line-height: 1;
+                      animation: scaleIn 0.5s ease-out;
+                    }
+                    @keyframes scaleIn {
+                      from {
+                        transform: scale(0);
+                        opacity: 0;
+                      }
+                      to {
+                        transform: scale(1);
+                        opacity: 1;
+                      }
+                    }
+                    h1 {
+                      color: #fff;
+                      margin: 0 0 1rem 0;
+                      font-size: 2.5rem;
+                      font-weight: 700;
+                      letter-spacing: -0.025em;
+                    }
+                    p {
+                      color: rgba(255, 255, 255, 0.8);
+                      margin: 0 0 2rem 0;
+                      font-size: 1.125rem;
+                      line-height: 1.5;
+                    }
+                    .spinner {
+                      display: inline-block;
+                      width: 2rem;
+                      height: 2rem;
+                      border: 3px solid rgba(255, 255, 255, 0.3);
+                      border-top-color: #fff;
+                      border-radius: 50%;
+                      animation: spin 0.8s linear infinite;
+                    }
+                    @keyframes spin {
+                      to { transform: rotate(360deg); }
+                    }
+                    .footer {
+                      margin-top: 2rem;
+                      color: rgba(255, 255, 255, 0.6);
+                      font-size: 0.875rem;
+                    }
+                  </style>
+                </head>
+                <body>
+                  <div class="container">
+                    <h1>Authentication Successful!</h1>
+                    <p>You can now close this window and return to the CLI.</p>
+                  </div>
+                </body>
+              </html>
+            `);
+          tokenResolver(token);
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`
+              <!DOCTYPE html>
+              <html>
+                <head>
+                  <title>Login Failed</title>
+                  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                  <style>
+                    * {
+                      margin: 0;
+                      padding: 0;
+                      box-sizing: border-box;
+                    }
+                    body {
+                      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                      display: flex;
+                      justify-content: center;
+                      align-items: center;
+                      min-height: 100vh;
+                      background: #000;
+                      padding: 1rem;
+                    }
+                    .container {
+                      width: 100%;
+                      max-width: 28rem;
+                      padding: 3rem;
+                      text-align: center;
+                      background: rgba(255, 255, 255, 0.1);
+                      backdrop-filter: blur(40px);
+                      -webkit-backdrop-filter: blur(40px);
+                      border: 1px solid rgba(255, 255, 255, 0.2);
+                      border-radius: 1.5rem;
+                      box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+                    }
+                    .icon-container {
+                      display: inline-flex;
+                      align-items: center;
+                      justify-content: center;
+                      width: 6rem;
+                      height: 6rem;
+                      margin-bottom: 2rem;
+                      background: rgba(255, 255, 255, 0.1);
+                      backdrop-filter: blur(10px);
+                      -webkit-backdrop-filter: blur(10px);
+                      border-radius: 50%;
+                    }
+                    .cross {
+                      font-size: 4rem;
+                      color: #fff;
+                      line-height: 1;
+                    }
+                    h1 {
+                      color: #fff;
+                      margin: 0 0 1rem 0;
+                      font-size: 2.5rem;
+                      font-weight: 700;
+                      letter-spacing: -0.025em;
+                    }
+                    p {
+                      color: rgba(255, 255, 255, 0.8);
+                      margin: 0;
+                      font-size: 1.125rem;
+                      line-height: 1.5;
+                    }
+                  </style>
+                </head>
+                <body>
+                  <div class="container">
+                    <div class="icon-container">
+                      <div class="cross">\u2717</div>
+                    </div>
+                    <h1>Login Failed</h1>
+                    <p>No token received. Please try again.</p>
+                  </div>
+                </body>
+              </html>
+            `);
+        }
+      }
+    });
+    server.listen(port, () => {
+      resolve({ server, token: tokenPromise });
+    });
+    server.on("error", reject);
+  });
+}
+async function loginCommand() {
+  try {
+    if (await isLoggedIn()) {
+      console.log(
+        import_chalk.default.yellow(
+          "\u26A0\uFE0F  You are already logged in. Run 'mcp-use logout' first if you want to login with a different account."
+        )
+      );
+      return;
+    }
+    console.log(import_chalk.default.cyan.bold("\u{1F510} Logging in to mcp-use cloud...\n"));
+    const port = await findAvailablePort();
+    const redirectUri = `http://localhost:${port}/callback`;
+    console.log(import_chalk.default.gray(`Starting local server on port ${port}...`));
+    const { server, token } = await startCallbackServer(port);
+    const webUrl = await getWebUrl();
+    const loginUrl = `${webUrl}/auth/cli?redirect_uri=${encodeURIComponent(redirectUri)}`;
+    console.log(import_chalk.default.gray(`Opening browser to ${webUrl}/auth/cli...
+`));
+    console.log(
+      import_chalk.default.white(
+        "If the browser doesn't open automatically, please visit:\n" + import_chalk.default.cyan(loginUrl)
+      )
+    );
+    await (0, import_open.default)(loginUrl);
+    console.log(
+      import_chalk.default.gray("\nWaiting for authentication... (this may take a moment)")
+    );
+    const jwtToken = await Promise.race([
+      token,
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error("Login timeout - please try again")),
+          LOGIN_TIMEOUT
+        )
+      )
+    ]);
+    server.close();
+    console.log(
+      import_chalk.default.gray("Received authentication token, creating API key...")
+    );
+    const api = await McpUseAPI.create();
+    const apiKeyResponse = await api.createApiKey(jwtToken, "CLI");
+    await writeConfig({
+      apiKey: apiKeyResponse.api_key
+    });
+    console.log(import_chalk.default.green.bold("\n\u2713 Successfully logged in!"));
+    console.log(
+      import_chalk.default.gray(
+        `
+Your API key has been saved to ${import_chalk.default.white("~/.mcp-use/config.json")}`
+      )
+    );
+    console.log(
+      import_chalk.default.gray(
+        "You can now deploy your MCP servers with " + import_chalk.default.white("mcp-use deploy")
+      )
+    );
+    process.exit(0);
+  } catch (error) {
+    console.error(
+      import_chalk.default.red.bold("\n\u2717 Login failed:"),
+      import_chalk.default.red(error instanceof Error ? error.message : "Unknown error")
+    );
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  try {
+    if (!await isLoggedIn()) {
+      console.log(import_chalk.default.yellow("\u26A0\uFE0F  You are not logged in."));
+      return;
+    }
+    console.log(import_chalk.default.cyan.bold("\u{1F513} Logging out...\n"));
+    await deleteConfig();
+    console.log(import_chalk.default.green.bold("\u2713 Successfully logged out!"));
+    console.log(
+      import_chalk.default.gray(
+        "\nYour local config has been deleted. The API key will remain active until revoked from the web interface."
+      )
+    );
+  } catch (error) {
+    console.error(
+      import_chalk.default.red.bold("\n\u2717 Logout failed:"),
+      import_chalk.default.red(error instanceof Error ? error.message : "Unknown error")
+    );
+    process.exit(1);
+  }
+}
+async function whoamiCommand() {
+  try {
+    if (!await isLoggedIn()) {
+      console.log(import_chalk.default.yellow("\u26A0\uFE0F  You are not logged in."));
+      console.log(
+        import_chalk.default.gray("Run " + import_chalk.default.white("mcp-use login") + " to get started.")
+      );
+      return;
+    }
+    console.log(import_chalk.default.cyan.bold("\u{1F464} Current user:\n"));
+    const api = await McpUseAPI.create();
+    const authInfo = await api.testAuth();
+    console.log(import_chalk.default.white("Email:   ") + import_chalk.default.cyan(authInfo.email));
+    console.log(import_chalk.default.white("User ID: ") + import_chalk.default.gray(authInfo.user_id));
+    const apiKey = await getApiKey();
+    if (apiKey) {
+      const masked = apiKey.substring(0, 8) + "..." + apiKey.substring(apiKey.length - 4);
+      console.log(import_chalk.default.white("API Key: ") + import_chalk.default.gray(masked));
+    }
+  } catch (error) {
+    console.error(
+      import_chalk.default.red.bold("\n\u2717 Failed to get user info:"),
+      import_chalk.default.red(error instanceof Error ? error.message : "Unknown error")
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/deploy.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"));
+var import_node_os2 = __toESM(require("os"));
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+
+// src/utils/git.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+async function gitCommand(command, cwd = process.cwd()) {
+  try {
+    const { stdout } = await execAsync(command, { cwd });
+    return stdout.trim();
+  } catch (error) {
+    return null;
+  }
+}
+async function isGitRepo(cwd = process.cwd()) {
+  const result = await gitCommand("git rev-parse --is-inside-work-tree", cwd);
+  return result === "true";
+}
+async function getRemoteUrl(cwd = process.cwd()) {
+  return gitCommand("git config --get remote.origin.url", cwd);
+}
+function parseGitHubUrl(url) {
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  const httpsMatch = url.match(
+    /https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/
+  );
+  const match = sshMatch || httpsMatch;
+  if (!match) return null;
+  return {
+    owner: match[1],
+    repo: match[2]
+  };
+}
+async function getCurrentBranch(cwd = process.cwd()) {
+  return gitCommand("git rev-parse --abbrev-ref HEAD", cwd);
+}
+async function getCommitSha(cwd = process.cwd()) {
+  return gitCommand("git rev-parse HEAD", cwd);
+}
+async function getCommitMessage(cwd = process.cwd()) {
+  return gitCommand("git log -1 --pretty=%B", cwd);
+}
+async function getGitInfo(cwd = process.cwd()) {
+  const isRepo = await isGitRepo(cwd);
+  if (!isRepo) {
+    return { isGitRepo: false };
+  }
+  const remoteUrl = await getRemoteUrl(cwd);
+  const branch = await getCurrentBranch(cwd);
+  const commitSha = await getCommitSha(cwd);
+  const commitMessage = await getCommitMessage(cwd);
+  let owner;
+  let repo;
+  if (remoteUrl) {
+    const parsed = parseGitHubUrl(remoteUrl);
+    if (parsed) {
+      owner = parsed.owner;
+      repo = parsed.repo;
+    }
+  }
+  return {
+    isGitRepo: true,
+    remoteUrl: remoteUrl || void 0,
+    owner,
+    repo,
+    branch: branch || void 0,
+    commitSha: commitSha || void 0,
+    commitMessage: commitMessage || void 0
+  };
+}
+function isGitHubUrl(url) {
+  return url.includes("github.com");
+}
+
+// src/commands/deploy.ts
+var import_open2 = __toESM(require("open"));
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
+async function isMcpProject(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path2.default.join(cwd, "package.json");
+    const content = await import_node_fs2.promises.readFile(packageJsonPath, "utf-8");
+    const packageJson2 = JSON.parse(content);
+    const hasMcpDeps = packageJson2.dependencies?.["mcp-use"] || packageJson2.dependencies?.["@modelcontextprotocol/sdk"] || packageJson2.devDependencies?.["mcp-use"] || packageJson2.devDependencies?.["@modelcontextprotocol/sdk"];
+    const hasMcpScripts = packageJson2.scripts?.mcp || packageJson2.scripts?.["mcp:dev"];
+    return !!(hasMcpDeps || hasMcpScripts);
+  } catch {
+    return false;
+  }
+}
+async function getProjectName(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path2.default.join(cwd, "package.json");
+    const content = await import_node_fs2.promises.readFile(packageJsonPath, "utf-8");
+    const packageJson2 = JSON.parse(content);
+    if (packageJson2.name) {
+      return packageJson2.name;
+    }
+  } catch {
+  }
+  return import_node_path2.default.basename(cwd);
+}
+async function detectBuildCommand(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path2.default.join(cwd, "package.json");
+    const content = await import_node_fs2.promises.readFile(packageJsonPath, "utf-8");
+    const packageJson2 = JSON.parse(content);
+    if (packageJson2.scripts?.build) {
+      return "npm run build";
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function detectStartCommand(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path2.default.join(cwd, "package.json");
+    const content = await import_node_fs2.promises.readFile(packageJsonPath, "utf-8");
+    const packageJson2 = JSON.parse(content);
+    if (packageJson2.scripts?.start) {
+      return "npm start";
+    }
+    if (packageJson2.main) {
+      return `node ${packageJson2.main}`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function detectRuntime(cwd = process.cwd()) {
+  try {
+    const pythonFiles = ["requirements.txt", "pyproject.toml", "setup.py"];
+    for (const file of pythonFiles) {
+      try {
+        await import_node_fs2.promises.access(import_node_path2.default.join(cwd, file));
+        return "python";
+      } catch {
+        continue;
+      }
+    }
+    try {
+      await import_node_fs2.promises.access(import_node_path2.default.join(cwd, "package.json"));
+      return "node";
+    } catch {
+    }
+  } catch {
+  }
+  return "node";
+}
+async function prompt(question) {
+  const readline = await import("readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function createTarball(cwd) {
+  const tmpDir = import_node_os2.default.tmpdir();
+  const tarballPath = import_node_path2.default.join(tmpDir, `mcp-deploy-${Date.now()}.tar.gz`);
+  const excludePatterns = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".venv",
+    "__pycache__",
+    "*.pyc",
+    ".DS_Store",
+    ".env",
+    ".env.local",
+    "*.log"
+  ];
+  const excludeFlags = excludePatterns.map((pattern) => `--exclude='${pattern}'`).join(" ");
+  const command = `tar ${excludeFlags} -czf "${tarballPath}" -C "${cwd}" .`;
+  try {
+    await execAsync2(command);
+    return tarballPath;
+  } catch (error) {
+    throw new Error(
+      `Failed to create tarball: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+async function displayDeploymentProgress(api, deployment) {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let frameIndex = 0;
+  let spinnerInterval = null;
+  let lastStep = "";
+  const startSpinner = (message) => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+    }
+    process.stdout.write("\r\x1B[K");
+    spinnerInterval = setInterval(() => {
+      const frame = frames[frameIndex];
+      frameIndex = (frameIndex + 1) % frames.length;
+      process.stdout.write(
+        "\r" + import_chalk2.default.cyan(frame) + " " + import_chalk2.default.gray(message)
+      );
+    }, 80);
+  };
+  const stopSpinner = () => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+      spinnerInterval = null;
+      process.stdout.write("\r\x1B[K");
+    }
+  };
+  console.log();
+  startSpinner("Deploying...");
+  try {
+    for await (const log of api.streamDeploymentLogs(deployment.id)) {
+      try {
+        const logData = JSON.parse(log);
+        if (logData.step && logData.step !== lastStep) {
+          lastStep = logData.step;
+          const stepMessages = {
+            clone: "Preparing source code...",
+            analyze: "Analyzing project...",
+            build: "Building container image...",
+            deploy: "Deploying to cloud..."
+          };
+          const message = stepMessages[logData.step] || "Deploying...";
+          startSpinner(message);
+        }
+        if (logData.line) {
+          stopSpinner();
+          const levelColor = logData.level === "error" ? import_chalk2.default.red : logData.level === "warn" ? import_chalk2.default.yellow : import_chalk2.default.gray;
+          const stepPrefix = logData.step ? import_chalk2.default.cyan(`[${logData.step}]`) + " " : "";
+          console.log(stepPrefix + levelColor(logData.line));
+        }
+      } catch {
+      }
+    }
+  } catch (error) {
+    stopSpinner();
+  }
+  let checkCount = 0;
+  const maxChecks = 60;
+  let delay = 3e3;
+  const maxDelay = 1e4;
+  let lastDisplayedLogLength = 0;
+  while (checkCount < maxChecks) {
+    const currentDelay = delay;
+    await new Promise((resolve) => setTimeout(resolve, currentDelay));
+    const finalDeployment = await api.getDeployment(deployment.id);
+    if (finalDeployment.buildLogs && finalDeployment.buildLogs.length > lastDisplayedLogLength) {
+      const newLogs = finalDeployment.buildLogs.substring(
+        lastDisplayedLogLength
+      );
+      const logLines = newLogs.split("\n").filter((l) => l.trim());
+      for (const line of logLines) {
+        try {
+          const logData = JSON.parse(line);
+          if (logData.line) {
+            stopSpinner();
+            const levelColor = logData.level === "error" ? import_chalk2.default.red : logData.level === "warn" ? import_chalk2.default.yellow : import_chalk2.default.gray;
+            const stepPrefix = logData.step ? import_chalk2.default.cyan(`[${logData.step}]`) + " " : "";
+            console.log(stepPrefix + levelColor(logData.line));
+          }
+        } catch {
+        }
+      }
+      lastDisplayedLogLength = finalDeployment.buildLogs.length;
+    }
+    if (finalDeployment.status === "running") {
+      const mcpUrl = `https://${finalDeployment.domain}/mcp`;
+      const inspectorUrl = `https://inspector.mcp-use.com/inspect?autoConnect=${encodeURIComponent(mcpUrl)}`;
+      console.log(import_chalk2.default.green.bold("\u2713 Deployment successful!\n"));
+      console.log(import_chalk2.default.white("\u{1F310} MCP Server URL:"));
+      console.log(import_chalk2.default.cyan.bold(`   ${mcpUrl}
+`));
+      console.log(import_chalk2.default.white("\u{1F50D} Inspector URL:"));
+      console.log(import_chalk2.default.cyan.bold(`   ${inspectorUrl}
+`));
+      if (finalDeployment.customDomain) {
+        const customMcpUrl = `https://${finalDeployment.customDomain}/mcp`;
+        const customInspectorUrl = `https://inspector.mcp-use.com/inspect?autoConnect=${encodeURIComponent(customMcpUrl)}`;
+        console.log(import_chalk2.default.white("\u{1F517} Custom Domain:"));
+        console.log(import_chalk2.default.cyan.bold(`   ${customMcpUrl}
+`));
+        console.log(import_chalk2.default.white("\u{1F50D} Custom Inspector:"));
+        console.log(import_chalk2.default.cyan.bold(`   ${customInspectorUrl}
+`));
+      }
+      console.log(
+        import_chalk2.default.gray("Deployment ID: ") + import_chalk2.default.white(finalDeployment.id)
+      );
+      return;
+    } else if (finalDeployment.status === "failed") {
+      console.log(import_chalk2.default.red.bold("\u2717 Deployment failed\n"));
+      if (finalDeployment.error) {
+        console.log(import_chalk2.default.red("Error: ") + finalDeployment.error);
+      }
+      if (finalDeployment.buildLogs) {
+        console.log(import_chalk2.default.gray("\nBuild logs:"));
+        try {
+          const logs = finalDeployment.buildLogs.split("\n").filter((l) => l.trim());
+          for (const log of logs) {
+            try {
+              const logData = JSON.parse(log);
+              if (logData.line) {
+                console.log(import_chalk2.default.gray(`  ${logData.line}`));
+              }
+            } catch {
+              console.log(import_chalk2.default.gray(`  ${log}`));
+            }
+          }
+        } catch {
+          console.log(import_chalk2.default.gray(finalDeployment.buildLogs));
+        }
+      }
+      process.exit(1);
+    } else if (finalDeployment.status === "building") {
+      startSpinner("Building and deploying...");
+      checkCount++;
+      delay = Math.min(delay * 1.2, maxDelay);
+    } else {
+      console.log(
+        import_chalk2.default.yellow("\u26A0\uFE0F  Deployment status: ") + finalDeployment.status
+      );
+      return;
+    }
+  }
+  stopSpinner();
+  console.log(import_chalk2.default.yellow("\u26A0\uFE0F  Deployment is taking longer than expected."));
+  console.log(
+    import_chalk2.default.gray("Check status with: ") + import_chalk2.default.white(`mcp-use status ${deployment.id}`)
+  );
+}
+async function deployCommand(options) {
+  try {
+    const cwd = process.cwd();
+    if (!await isLoggedIn()) {
+      console.log(import_chalk2.default.red("\u2717 You are not logged in."));
+      console.log(
+        import_chalk2.default.gray("Run " + import_chalk2.default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    console.log(import_chalk2.default.cyan.bold("\u{1F680} Deploying to mcp-use cloud...\n"));
+    const isMcp = await isMcpProject(cwd);
+    if (!isMcp) {
+      console.log(
+        import_chalk2.default.yellow(
+          "\u26A0\uFE0F  This doesn't appear to be an MCP server project (no mcp-use or @modelcontextprotocol/sdk dependency found)."
+        )
+      );
+      const shouldContinue = await prompt(
+        import_chalk2.default.white("Continue anyway? (y/n): ")
+      );
+      if (!shouldContinue) {
+        console.log(import_chalk2.default.gray("Deployment cancelled."));
+        process.exit(0);
+      }
+      console.log();
+    }
+    const gitInfo = await getGitInfo(cwd);
+    if (!options.fromSource && gitInfo.isGitRepo && gitInfo.remoteUrl && isGitHubUrl(gitInfo.remoteUrl)) {
+      if (!gitInfo.owner || !gitInfo.repo) {
+        console.log(
+          import_chalk2.default.red(
+            "\u2717 Could not parse GitHub repository information from remote URL."
+          )
+        );
+        process.exit(1);
+      }
+      console.log(import_chalk2.default.white("GitHub repository detected:"));
+      console.log(
+        import_chalk2.default.gray(`  Repository: `) + import_chalk2.default.cyan(`${gitInfo.owner}/${gitInfo.repo}`)
+      );
+      console.log(
+        import_chalk2.default.gray(`  Branch:     `) + import_chalk2.default.cyan(gitInfo.branch || "main")
+      );
+      if (gitInfo.commitSha) {
+        console.log(
+          import_chalk2.default.gray(`  Commit:     `) + import_chalk2.default.gray(gitInfo.commitSha.substring(0, 7))
+        );
+      }
+      if (gitInfo.commitMessage) {
+        console.log(
+          import_chalk2.default.gray(`  Message:    `) + import_chalk2.default.gray(gitInfo.commitMessage.split("\n")[0])
+        );
+      }
+      console.log();
+      const shouldDeploy = await prompt(
+        import_chalk2.default.white(
+          `Deploy from GitHub repository ${gitInfo.owner}/${gitInfo.repo}? (y/n): `
+        )
+      );
+      if (!shouldDeploy) {
+        console.log(import_chalk2.default.gray("Deployment cancelled."));
+        process.exit(0);
+      }
+      const projectName = options.name || await getProjectName(cwd);
+      const runtime = options.runtime || await detectRuntime(cwd);
+      const port = options.port || 3e3;
+      const buildCommand = await detectBuildCommand(cwd);
+      const startCommand = await detectStartCommand(cwd);
+      console.log();
+      console.log(import_chalk2.default.white("Deployment configuration:"));
+      console.log(import_chalk2.default.gray(`  Name:          `) + import_chalk2.default.cyan(projectName));
+      console.log(import_chalk2.default.gray(`  Runtime:       `) + import_chalk2.default.cyan(runtime));
+      console.log(import_chalk2.default.gray(`  Port:          `) + import_chalk2.default.cyan(port));
+      if (buildCommand) {
+        console.log(import_chalk2.default.gray(`  Build command: `) + import_chalk2.default.cyan(buildCommand));
+      }
+      if (startCommand) {
+        console.log(import_chalk2.default.gray(`  Start command: `) + import_chalk2.default.cyan(startCommand));
+      }
+      console.log();
+      const deploymentRequest = {
+        name: projectName,
+        source: {
+          type: "github",
+          repo: `${gitInfo.owner}/${gitInfo.repo}`,
+          branch: gitInfo.branch || "main",
+          runtime,
+          port,
+          buildCommand,
+          startCommand
+        },
+        healthCheckPath: "/healthz"
+      };
+      console.log(import_chalk2.default.gray("Creating deployment..."));
+      const api = await McpUseAPI.create();
+      const deployment = await api.createDeployment(deploymentRequest);
+      console.log(
+        import_chalk2.default.green("\u2713 Deployment created: ") + import_chalk2.default.gray(deployment.id)
+      );
+      await displayDeploymentProgress(api, deployment);
+      if (options.open && deployment.domain) {
+        console.log();
+        console.log(import_chalk2.default.gray("Opening deployment in browser..."));
+        await (0, import_open2.default)(`https://${deployment.domain}`);
+      }
+    } else {
+      if (options.fromSource) {
+        console.log(
+          import_chalk2.default.white("\u{1F4E6} Deploying from local source code (--from-source)...")
+        );
+      } else {
+        console.log(
+          import_chalk2.default.yellow(
+            "\u26A0\uFE0F  This is not a GitHub repository or no remote is configured."
+          )
+        );
+        console.log(import_chalk2.default.white("Deploying from local source code instead..."));
+      }
+      console.log();
+      const projectName = options.name || await getProjectName(cwd);
+      const runtime = options.runtime || await detectRuntime(cwd);
+      const port = options.port || 3e3;
+      const buildCommand = await detectBuildCommand(cwd);
+      const startCommand = await detectStartCommand(cwd);
+      console.log(import_chalk2.default.white("Deployment configuration:"));
+      console.log(import_chalk2.default.gray(`  Name:          `) + import_chalk2.default.cyan(projectName));
+      console.log(import_chalk2.default.gray(`  Runtime:       `) + import_chalk2.default.cyan(runtime));
+      console.log(import_chalk2.default.gray(`  Port:          `) + import_chalk2.default.cyan(port));
+      if (buildCommand) {
+        console.log(import_chalk2.default.gray(`  Build command: `) + import_chalk2.default.cyan(buildCommand));
+      }
+      if (startCommand) {
+        console.log(import_chalk2.default.gray(`  Start command: `) + import_chalk2.default.cyan(startCommand));
+      }
+      console.log();
+      const shouldDeploy = await prompt(
+        import_chalk2.default.white("Deploy from local source? (y/n): ")
+      );
+      if (!shouldDeploy) {
+        console.log(import_chalk2.default.gray("Deployment cancelled."));
+        process.exit(0);
+      }
+      console.log();
+      console.log(import_chalk2.default.gray("Packaging source code..."));
+      const tarballPath = await createTarball(cwd);
+      const stats = await import_node_fs2.promises.stat(tarballPath);
+      console.log(
+        import_chalk2.default.green("\u2713 Packaged: ") + import_chalk2.default.gray(formatFileSize(stats.size))
+      );
+      console.log(import_chalk2.default.gray("Uploading source code..."));
+      const api = await McpUseAPI.create();
+      const uploadResponse = await api.uploadSource(tarballPath);
+      console.log(
+        import_chalk2.default.green("\u2713 Uploaded: ") + import_chalk2.default.gray(uploadResponse.uploadId)
+      );
+      await import_node_fs2.promises.unlink(tarballPath);
+      const deploymentRequest = {
+        name: projectName,
+        source: {
+          type: "upload",
+          uploadId: uploadResponse.uploadId,
+          runtime,
+          port,
+          buildCommand,
+          startCommand
+        },
+        healthCheckPath: "/healthz"
+      };
+      console.log(import_chalk2.default.gray("Creating deployment..."));
+      const deployment = await api.createDeployment(deploymentRequest);
+      console.log(
+        import_chalk2.default.green("\u2713 Deployment created: ") + import_chalk2.default.gray(deployment.id)
+      );
+      await displayDeploymentProgress(api, deployment);
+      if (options.open && deployment.domain) {
+        console.log();
+        console.log(import_chalk2.default.gray("Opening deployment in browser..."));
+        await (0, import_open2.default)(`https://${deployment.domain}`);
+      }
+    }
+  } catch (error) {
+    console.error(
+      import_chalk2.default.red.bold("\n\u2717 Deployment failed:"),
+      import_chalk2.default.red(error instanceof Error ? error.message : "Unknown error")
+    );
+    process.exit(1);
+  }
+}
+
+// src/index.ts
 var program = new import_commander.Command();
-var packageContent = (0, import_node_fs.readFileSync)(
-  import_node_path.default.join(__dirname, "../package.json"),
+var packageContent = (0, import_node_fs3.readFileSync)(
+  import_node_path3.default.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
@@ -48,7 +1131,7 @@ async function isPortAvailable(port, host = "localhost") {
     return true;
   }
 }
-async function findAvailablePort(startPort, host = "localhost") {
+async function findAvailablePort2(startPort, host = "localhost") {
   for (let port = startPort; port < startPort + 100; port++) {
     if (await isPortAvailable(port, host)) {
       return port;
@@ -70,7 +1153,7 @@ async function waitForServer(port, host = "localhost", maxAttempts = 30) {
   return false;
 }
 function runCommand(command, args, cwd, env, filterStderr = false) {
-  const proc = (0, import_node_child_process.spawn)(command, args, {
+  const proc = (0, import_node_child_process3.spawn)(command, args, {
     cwd,
     stdio: filterStderr ? ["inherit", "inherit", "pipe"] : "inherit",
     shell: false,
@@ -98,8 +1181,8 @@ function runCommand(command, args, cwd, env, filterStderr = false) {
 }
 async function startTunnel(port) {
   return new Promise((resolve, reject) => {
-    console.log(import_chalk.default.gray(`Starting tunnel for port ${port}...`));
-    const proc = (0, import_node_child_process.spawn)("npx", ["--yes", "@mcp-use/tunnel", String(port)], {
+    console.log(import_chalk3.default.gray(`Starting tunnel for port ${port}...`));
+    const proc = (0, import_node_child_process3.spawn)("npx", ["--yes", "@mcp-use/tunnel", String(port)], {
       stdio: ["ignore", "pipe", "pipe"],
       shell: false
     });
@@ -113,7 +1196,7 @@ async function startTunnel(port) {
         const subdomain = url;
         resolved = true;
         clearTimeout(setupTimeout);
-        console.log(import_chalk.default.green.bold(`\u2713 Tunnel established: ${url}/mcp`));
+        console.log(import_chalk3.default.green.bold(`\u2713 Tunnel established: ${url}/mcp`));
         resolve({ url, subdomain, process: proc });
       }
     });
@@ -144,7 +1227,7 @@ async function findServerFile(projectPath) {
   const candidates = ["index.ts", "src/index.ts", "server.ts", "src/server.ts"];
   for (const candidate of candidates) {
     try {
-      await (0, import_promises.access)(import_node_path.default.join(projectPath, candidate));
+      await (0, import_promises.access)(import_node_path3.default.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -153,18 +1236,18 @@ async function findServerFile(projectPath) {
   throw new Error("No server file found");
 }
 async function buildWidgets(projectPath) {
-  const { promises: fs } = await import("fs");
+  const { promises: fs3 } = await import("fs");
   const { build } = await import("vite");
-  const resourcesDir = import_node_path.default.join(projectPath, "resources");
+  const resourcesDir = import_node_path3.default.join(projectPath, "resources");
   const mcpUrl = process.env.MCP_URL;
   if (!mcpUrl) {
     console.log(
-      import_chalk.default.yellow(
+      import_chalk3.default.yellow(
         "\u26A0\uFE0F  MCP_URL not set - using relative paths (widgets may not work correctly)"
       )
     );
     console.log(
-      import_chalk.default.gray(
+      import_chalk3.default.gray(
         "   Set MCP_URL environment variable for production builds (e.g., https://myserver.com)"
       )
     );
@@ -173,39 +1256,39 @@ async function buildWidgets(projectPath) {
     await (0, import_promises.access)(resourcesDir);
   } catch {
     console.log(
-      import_chalk.default.gray("No resources/ directory found - skipping widget build")
+      import_chalk3.default.gray("No resources/ directory found - skipping widget build")
     );
     return [];
   }
   let entries = [];
   try {
-    const files = await fs.readdir(resourcesDir);
-    entries = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => import_node_path.default.join(resourcesDir, f));
+    const files = await fs3.readdir(resourcesDir);
+    entries = files.filter((f) => f.endsWith(".tsx") || f.endsWith(".ts")).map((f) => import_node_path3.default.join(resourcesDir, f));
   } catch (error) {
-    console.log(import_chalk.default.gray("No widgets found in resources/ directory"));
+    console.log(import_chalk3.default.gray("No widgets found in resources/ directory"));
     return [];
   }
   if (entries.length === 0) {
-    console.log(import_chalk.default.gray("No widgets found in resources/ directory"));
+    console.log(import_chalk3.default.gray("No widgets found in resources/ directory"));
     return [];
   }
-  console.log(import_chalk.default.gray(`Building ${entries.length} widget(s)...`));
+  console.log(import_chalk3.default.gray(`Building ${entries.length} widget(s)...`));
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
   const builtWidgets = [];
   for (const entry of entries) {
-    const baseName = import_node_path.default.basename(entry).replace(/\.tsx?$/, "");
+    const baseName = import_node_path3.default.basename(entry).replace(/\.tsx?$/, "");
     const widgetName = baseName;
-    console.log(import_chalk.default.gray(`  - Building ${widgetName}...`));
-    const tempDir = import_node_path.default.join(projectPath, ".mcp-use", widgetName);
-    await fs.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = import_node_path.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    console.log(import_chalk3.default.gray(`  - Building ${widgetName}...`));
+    const tempDir = import_node_path3.default.join(projectPath, ".mcp-use", widgetName);
+    await fs3.mkdir(tempDir, { recursive: true });
+    const relativeResourcesPath = import_node_path3.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
     const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-    await fs.writeFile(import_node_path.default.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs3.writeFile(import_node_path3.default.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -229,9 +1312,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs.writeFile(import_node_path.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs.writeFile(import_node_path.default.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = import_node_path.default.join(
+    await fs3.writeFile(import_node_path3.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs3.writeFile(import_node_path3.default.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = import_node_path3.default.join(
       projectPath,
       "dist",
       "resources",
@@ -241,16 +1324,16 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = import_node_path.default.join(
+      const metadataTempDir = import_node_path3.default.join(
         projectPath,
         ".mcp-use",
         `${widgetName}-metadata`
       );
-      await fs.mkdir(metadataTempDir, { recursive: true });
-      const { createServer } = await import("vite");
-      const metadataServer = await createServer({
+      await fs3.mkdir(metadataTempDir, { recursive: true });
+      const { createServer: createServer2 } = await import("vite");
+      const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: import_node_path.default.join(metadataTempDir, ".vite-cache"),
+        cacheDir: import_node_path3.default.join(metadataTempDir, ".vite-cache"),
         plugins: [tailwindcss(), react()],
         resolve: {
           alias: {
@@ -290,12 +1373,12 @@ if (container && Component) {
         await new Promise((resolve) => setTimeout(resolve, 50));
       } catch (error) {
         console.warn(
-          import_chalk.default.yellow(`    \u26A0 Could not extract metadata for ${widgetName}`)
+          import_chalk3.default.yellow(`    \u26A0 Could not extract metadata for ${widgetName}`)
         );
       } finally {
         await metadataServer.close();
         try {
-          await fs.rm(metadataTempDir, { recursive: true, force: true });
+          await fs3.rm(metadataTempDir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -326,7 +1409,7 @@ if (container && Component) {
           outDir,
           emptyOutDir: true,
           rollupOptions: {
-            input: import_node_path.default.join(tempDir, "index.html")
+            input: import_node_path3.default.join(tempDir, "index.html")
           }
         }
       });
@@ -334,23 +1417,23 @@ if (container && Component) {
         name: widgetName,
         metadata: widgetMetadata
       });
-      console.log(import_chalk.default.green(`    \u2713 Built ${widgetName}`));
+      console.log(import_chalk3.default.green(`    \u2713 Built ${widgetName}`));
     } catch (error) {
-      console.error(import_chalk.default.red(`    \u2717 Failed to build ${widgetName}:`), error);
+      console.error(import_chalk3.default.red(`    \u2717 Failed to build ${widgetName}:`), error);
     }
   }
   return builtWidgets;
 }
 program.command("build").description("Build TypeScript and MCP UI widgets").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--with-inspector", "Include inspector in production build").action(async (options) => {
   try {
-    const projectPath = import_node_path.default.resolve(options.path);
-    const { promises: fs } = await import("fs");
-    console.log(import_chalk.default.cyan.bold(`mcp-use v${packageJson.version}`));
+    const projectPath = import_node_path3.default.resolve(options.path);
+    const { promises: fs3 } = await import("fs");
+    console.log(import_chalk3.default.cyan.bold(`mcp-use v${packageJson.version}`));
     const builtWidgets = await buildWidgets(projectPath);
-    console.log(import_chalk.default.gray("Building TypeScript..."));
+    console.log(import_chalk3.default.gray("Building TypeScript..."));
     await runCommand("npx", ["tsc"], projectPath);
-    console.log(import_chalk.default.green("\u2713 TypeScript build complete!"));
-    const manifestPath = import_node_path.default.join(projectPath, "dist", "mcp-use.json");
+    console.log(import_chalk3.default.green("\u2713 TypeScript build complete!"));
+    const manifestPath = import_node_path3.default.join(projectPath, "dist", "mcp-use.json");
     const widgetsData = {};
     for (const widget of builtWidgets) {
       widgetsData[widget.name] = widget.metadata;
@@ -361,36 +1444,36 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       buildTime: (/* @__PURE__ */ new Date()).toISOString(),
       widgets: widgetsData
     };
-    await fs.mkdir(import_node_path.default.dirname(manifestPath), { recursive: true });
-    await fs.writeFile(
+    await fs3.mkdir(import_node_path3.default.dirname(manifestPath), { recursive: true });
+    await fs3.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
       "utf8"
     );
-    console.log(import_chalk.default.green("\u2713 Build manifest created"));
-    console.log(import_chalk.default.green.bold(`
+    console.log(import_chalk3.default.green("\u2713 Build manifest created"));
+    console.log(import_chalk3.default.green.bold(`
 \u2713 Build complete!`));
     if (builtWidgets.length > 0) {
-      console.log(import_chalk.default.gray(`  ${builtWidgets.length} widget(s) built`));
+      console.log(import_chalk3.default.gray(`  ${builtWidgets.length} widget(s) built`));
     }
     if (options.withInspector) {
-      console.log(import_chalk.default.gray("  Inspector included"));
+      console.log(import_chalk3.default.gray("  Inspector included"));
     }
   } catch (error) {
-    console.error(import_chalk.default.red("Build failed:"), error);
+    console.error(import_chalk3.default.red("Build failed:"), error);
     process.exit(1);
   }
 });
 program.command("dev").description("Run development server with auto-reload and inspector").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--port <port>", "Server port", "3000").option("--host <host>", "Server host", "localhost").option("--no-open", "Do not auto-open inspector").action(async (options) => {
   try {
-    const projectPath = import_node_path.default.resolve(options.path);
+    const projectPath = import_node_path3.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
-    console.log(import_chalk.default.cyan.bold(`mcp-use v${packageJson.version}`));
+    console.log(import_chalk3.default.cyan.bold(`mcp-use v${packageJson.version}`));
     if (!await isPortAvailable(port, host)) {
-      console.log(import_chalk.default.yellow.bold(`\u26A0\uFE0F  Port ${port} is already in use`));
-      const availablePort = await findAvailablePort(port, host);
-      console.log(import_chalk.default.green.bold(`\u2713 Using port ${availablePort} instead`));
+      console.log(import_chalk3.default.yellow.bold(`\u26A0\uFE0F  Port ${port} is already in use`));
+      const availablePort = await findAvailablePort2(port, host);
+      console.log(import_chalk3.default.green.bold(`\u2713 Using port ${availablePort} instead`));
       port = availablePort;
     }
     let mcpUrl;
@@ -422,20 +1505,20 @@ program.command("dev").description("Run development server with auto-reload and
           inspectorUrl += `&tunnelUrl=${encodeURIComponent(mcpUrl)}`;
         }
         const readyTime = Date.now() - startTime;
-        console.log(import_chalk.default.green.bold(`\u2713 Ready in ${readyTime}ms`));
-        console.log(import_chalk.default.whiteBright(`Local:    http://${host}:${port}`));
-        console.log(import_chalk.default.whiteBright(`Network:  http://${host}:${port}`));
+        console.log(import_chalk3.default.green.bold(`\u2713 Ready in ${readyTime}ms`));
+        console.log(import_chalk3.default.whiteBright(`Local:    http://${host}:${port}`));
+        console.log(import_chalk3.default.whiteBright(`Network:  http://${host}:${port}`));
         if (mcpUrl) {
-          console.log(import_chalk.default.whiteBright(`Tunnel:   ${mcpUrl}`));
+          console.log(import_chalk3.default.whiteBright(`Tunnel:   ${mcpUrl}`));
         }
-        console.log(import_chalk.default.whiteBright(`MCP:      ${mcpEndpoint}`));
-        console.log(import_chalk.default.whiteBright(`Inspector: ${inspectorUrl}
+        console.log(import_chalk3.default.whiteBright(`MCP:      ${mcpEndpoint}`));
+        console.log(import_chalk3.default.whiteBright(`Inspector: ${inspectorUrl}
 `));
-        await (0, import_open.default)(inspectorUrl);
+        await (0, import_open3.default)(inspectorUrl);
       }
     }
     const cleanup = () => {
-      console.log(import_chalk.default.gray("\n\nShutting down..."));
+      console.log(import_chalk3.default.gray("\n\nShutting down..."));
       const processesToKill = processes.length;
       let killedCount = 0;
       const checkAndExit = () => {
@@ -466,13 +1549,13 @@ program.command("dev").description("Run development server with auto-reload and
     await new Promise(() => {
     });
   } catch (error) {
-    console.error(import_chalk.default.red("Dev mode failed:"), error);
+    console.error(import_chalk3.default.red("Dev mode failed:"), error);
     process.exit(1);
   }
 });
 program.command("start").description("Start production server").option("-p, --path <path>", "Path to project directory", process.cwd()).option("--port <port>", "Server port", "3000").option("--tunnel", "Expose server through a tunnel").action(async (options) => {
   try {
-    const projectPath = import_node_path.default.resolve(options.path);
+    const projectPath = import_node_path3.default.resolve(options.path);
     const port = parseInt(options.port, 10);
     console.log(
       `\x1B[36m\x1B[1mmcp-use\x1B[0m \x1B[90mVersion: ${packageJson.version}\x1B[0m
@@ -486,13 +1569,13 @@ program.command("start").description("Start production server").option("-p, --pa
         mcpUrl = tunnelInfo.subdomain;
         tunnelProcess = tunnelInfo.process;
       } catch (error) {
-        console.error(import_chalk.default.red("Failed to start tunnel:"), error);
+        console.error(import_chalk3.default.red("Failed to start tunnel:"), error);
         process.exit(1);
       }
     }
     let serverFile = "dist/index.js";
     try {
-      await (0, import_promises.access)(import_node_path.default.join(projectPath, serverFile));
+      await (0, import_promises.access)(import_node_path3.default.join(projectPath, serverFile));
     } catch {
       serverFile = "dist/server.js";
     }
@@ -504,9 +1587,9 @@ program.command("start").description("Start production server").option("-p, --pa
     };
     if (mcpUrl) {
       env.MCP_URL = mcpUrl;
-      console.log(import_chalk.default.whiteBright(`Tunnel:   ${mcpUrl}`));
+      console.log(import_chalk3.default.whiteBright(`Tunnel:   ${mcpUrl}`));
     }
-    const serverProc = (0, import_node_child_process.spawn)("node", [serverFile], {
+    const serverProc = (0, import_node_child_process3.spawn)("node", [serverFile], {
       cwd: projectPath,
       stdio: "inherit",
       env
@@ -549,4 +1632,25 @@ program.command("start").description("Start production server").option("-p, --pa
     process.exit(1);
   }
 });
+program.command("login").description("Login to mcp-use cloud").action(async () => {
+  await loginCommand();
+});
+program.command("logout").description("Logout from mcp-use cloud").action(async () => {
+  await logoutCommand();
+});
+program.command("whoami").description("Show current user information").action(async () => {
+  await whoamiCommand();
+});
+program.command("deploy").description("Deploy MCP server to mcp-use cloud").option("--open", "Open deployment in browser after successful deploy").option("--name <name>", "Custom deployment name").option("--port <port>", "Server port", "3000").option("--runtime <runtime>", "Runtime (node or python)").option(
+  "--from-source",
+  "Deploy from local source code (even for GitHub repos)"
+).action(async (options) => {
+  await deployCommand({
+    open: options.open,
+    name: options.name,
+    port: options.port ? parseInt(options.port, 10) : void 0,
+    runtime: options.runtime,
+    fromSource: options.fromSource
+  });
+});
 program.parse();