@mcp-use/cli 2.5.6 → 2.6.0-canary.11

package/dist/index.mjs

@@ -1,1976 +0,0 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import chalk3 from "chalk";
-import { Command } from "commander";
-import "dotenv/config";
-import { spawn } from "child_process";
-import { readFileSync } from "fs";
-import { access, mkdir, readFile, writeFile } from "fs/promises";
-import path3 from "path";
-import open3 from "open";
-
-// src/commands/auth.ts
-import chalk from "chalk";
-import {
-  createServer
-} from "http";
-import open from "open";
-
-// src/utils/config.ts
-import { promises as fs } from "fs";
-import path from "path";
-import os from "os";
-var CONFIG_DIR = path.join(os.homedir(), ".mcp-use");
-var CONFIG_FILE = path.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 fs.mkdir(CONFIG_DIR, { recursive: true });
-  } catch (error) {
-  }
-}
-async function readConfig() {
-  try {
-    const content = await fs.readFile(CONFIG_FILE, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    return {};
-  }
-}
-async function writeConfig(config) {
-  await ensureConfigDir();
-  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
-}
-async function deleteConfig() {
-  try {
-    await fs.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();
-    }
-  }
-  /**
-   * Create deployment with source code upload
-   */
-  async createDeploymentWithUpload(request, filePath) {
-    const { readFile: readFile2 } = await import("fs/promises");
-    const { basename } = await import("path");
-    const { stat } = await import("fs/promises");
-    const stats = await stat(filePath);
-    const maxSize = 2 * 1024 * 1024;
-    if (stats.size > maxSize) {
-      throw new Error(
-        `File size (${(stats.size / 1024 / 1024).toFixed(2)}MB) exceeds maximum of 2MB`
-      );
-    }
-    const fileBuffer = await readFile2(filePath);
-    const filename = basename(filePath);
-    const formData = new FormData();
-    const blob = new Blob([fileBuffer], { type: "application/gzip" });
-    formData.append("source_file", blob, filename);
-    formData.append("name", request.name);
-    formData.append("source_type", "upload");
-    if (request.source.type === "upload") {
-      formData.append("runtime", request.source.runtime || "node");
-      formData.append("port", String(request.source.port || 3e3));
-      if (request.source.startCommand) {
-        formData.append("startCommand", request.source.startCommand);
-      }
-      if (request.source.buildCommand) {
-        formData.append("buildCommand", request.source.buildCommand);
-      }
-      if (request.source.env && Object.keys(request.source.env).length > 0) {
-        formData.append("env", JSON.stringify(request.source.env));
-      }
-    }
-    if (request.customDomain) {
-      formData.append("customDomain", request.customDomain);
-    }
-    if (request.healthCheckPath) {
-      formData.append("healthCheckPath", request.healthCheckPath);
-    }
-    const url = `${this.baseUrl}/deployments`;
-    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(`Deployment 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 = 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 = 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(
-        chalk.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(chalk.cyan.bold("\u{1F510} Logging in to mcp-use cloud...\n"));
-    const port = await findAvailablePort();
-    const redirectUri = `http://localhost:${port}/callback`;
-    console.log(chalk.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(chalk.gray(`Opening browser to ${webUrl}/auth/cli...
-`));
-    console.log(
-      chalk.white(
-        "If the browser doesn't open automatically, please visit:\n" + chalk.cyan(loginUrl)
-      )
-    );
-    await open(loginUrl);
-    console.log(
-      chalk.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(
-      chalk.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(chalk.green.bold("\n\u2713 Successfully logged in!"));
-    console.log(
-      chalk.gray(
-        `
-Your API key has been saved to ${chalk.white("~/.mcp-use/config.json")}`
-      )
-    );
-    console.log(
-      chalk.gray(
-        "You can now deploy your MCP servers with " + chalk.white("mcp-use deploy")
-      )
-    );
-    process.exit(0);
-  } catch (error) {
-    console.error(
-      chalk.red.bold("\n\u2717 Login failed:"),
-      chalk.red(error instanceof Error ? error.message : "Unknown error")
-    );
-    process.exit(1);
-  }
-}
-async function logoutCommand() {
-  try {
-    if (!await isLoggedIn()) {
-      console.log(chalk.yellow("\u26A0\uFE0F  You are not logged in."));
-      return;
-    }
-    console.log(chalk.cyan.bold("\u{1F513} Logging out...\n"));
-    await deleteConfig();
-    console.log(chalk.green.bold("\u2713 Successfully logged out!"));
-    console.log(
-      chalk.gray(
-        "\nYour local config has been deleted. The API key will remain active until revoked from the web interface."
-      )
-    );
-  } catch (error) {
-    console.error(
-      chalk.red.bold("\n\u2717 Logout failed:"),
-      chalk.red(error instanceof Error ? error.message : "Unknown error")
-    );
-    process.exit(1);
-  }
-}
-async function whoamiCommand() {
-  try {
-    if (!await isLoggedIn()) {
-      console.log(chalk.yellow("\u26A0\uFE0F  You are not logged in."));
-      console.log(
-        chalk.gray("Run " + chalk.white("mcp-use login") + " to get started.")
-      );
-      return;
-    }
-    console.log(chalk.cyan.bold("\u{1F464} Current user:\n"));
-    const api = await McpUseAPI.create();
-    const authInfo = await api.testAuth();
-    console.log(chalk.white("Email:   ") + chalk.cyan(authInfo.email));
-    console.log(chalk.white("User ID: ") + chalk.gray(authInfo.user_id));
-    const apiKey = await getApiKey();
-    if (apiKey) {
-      const masked = apiKey.substring(0, 8) + "..." + apiKey.substring(apiKey.length - 4);
-      console.log(chalk.white("API Key: ") + chalk.gray(masked));
-    }
-  } catch (error) {
-    console.error(
-      chalk.red.bold("\n\u2717 Failed to get user info:"),
-      chalk.red(error instanceof Error ? error.message : "Unknown error")
-    );
-    process.exit(1);
-  }
-}
-
-// src/commands/deploy.ts
-import chalk2 from "chalk";
-import { promises as fs2 } from "fs";
-import path2 from "path";
-import os2 from "os";
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-
-// src/utils/git.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(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
-import open2 from "open";
-var execAsync2 = promisify2(exec2);
-async function isMcpProject(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = path2.join(cwd, "package.json");
-    const content = await fs2.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 = path2.join(cwd, "package.json");
-    const content = await fs2.readFile(packageJsonPath, "utf-8");
-    const packageJson2 = JSON.parse(content);
-    if (packageJson2.name) {
-      return packageJson2.name;
-    }
-  } catch {
-  }
-  return path2.basename(cwd);
-}
-async function detectBuildCommand(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = path2.join(cwd, "package.json");
-    const content = await fs2.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 = path2.join(cwd, "package.json");
-    const content = await fs2.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 fs2.access(path2.join(cwd, file));
-        return "python";
-      } catch {
-        continue;
-      }
-    }
-    try {
-      await fs2.access(path2.join(cwd, "package.json"));
-      return "node";
-    } catch {
-    }
-  } catch {
-  }
-  return "node";
-}
-async function prompt(question, defaultValue = "n") {
-  const readline = await import("readline");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const defaultIndicator = defaultValue === "y" ? "Y/n" : "y/N";
-  const questionWithDefault = question.replace(
-    /(\(y\/n\):)/,
-    `(${defaultIndicator}):`
-  );
-  return new Promise((resolve) => {
-    rl.question(questionWithDefault, (answer) => {
-      rl.close();
-      const trimmedAnswer = answer.trim().toLowerCase();
-      if (trimmedAnswer === "") {
-        resolve(defaultValue === "y");
-      } else {
-        resolve(trimmedAnswer === "y" || trimmedAnswer === "yes");
-      }
-    });
-  });
-}
-async function createTarball(cwd) {
-  const tmpDir = os2.tmpdir();
-  const tarballPath = path2.join(tmpDir, `mcp-deploy-${Date.now()}.tar.gz`);
-  const excludePatterns = [
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    ".next",
-    ".venv",
-    "__pycache__",
-    "*.pyc",
-    ".DS_Store",
-    "._*",
-    // macOS resource fork files
-    ".mcp-use",
-    // Build artifacts directory
-    ".env",
-    ".env.local",
-    "*.log"
-  ];
-  const excludeFlags = excludePatterns.map((pattern) => `--exclude=${pattern}`).join(" ");
-  const command = `tar ${excludeFlags} -czf "${tarballPath}" -C "${cwd}" . 2>&1 || true`;
-  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" + chalk2.cyan(frame) + " " + chalk2.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" ? chalk2.red : logData.level === "warn" ? chalk2.yellow : chalk2.gray;
-          const stepPrefix = logData.step ? chalk2.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" ? chalk2.red : logData.level === "warn" ? chalk2.yellow : chalk2.gray;
-            const stepPrefix = logData.step ? chalk2.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/inspector?autoConnect=${encodeURIComponent(mcpUrl)}`;
-      console.log(chalk2.green.bold("\u2713 Deployment successful!\n"));
-      console.log(chalk2.white("\u{1F310} MCP Server URL:"));
-      console.log(chalk2.cyan.bold(`   ${mcpUrl}
-`));
-      console.log(chalk2.white("\u{1F50D} Inspector URL:"));
-      console.log(chalk2.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(chalk2.white("\u{1F517} Custom Domain:"));
-        console.log(chalk2.cyan.bold(`   ${customMcpUrl}
-`));
-        console.log(chalk2.white("\u{1F50D} Custom Inspector:"));
-        console.log(chalk2.cyan.bold(`   ${customInspectorUrl}
-`));
-      }
-      console.log(
-        chalk2.gray("Deployment ID: ") + chalk2.white(finalDeployment.id)
-      );
-      return;
-    } else if (finalDeployment.status === "failed") {
-      console.log(chalk2.red.bold("\u2717 Deployment failed\n"));
-      if (finalDeployment.error) {
-        console.log(chalk2.red("Error: ") + finalDeployment.error);
-      }
-      if (finalDeployment.buildLogs) {
-        console.log(chalk2.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(chalk2.gray(`  ${logData.line}`));
-              }
-            } catch {
-              console.log(chalk2.gray(`  ${log}`));
-            }
-          }
-        } catch {
-          console.log(chalk2.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(
-        chalk2.yellow("\u26A0\uFE0F  Deployment status: ") + finalDeployment.status
-      );
-      return;
-    }
-  }
-  stopSpinner();
-  console.log(chalk2.yellow("\u26A0\uFE0F  Deployment is taking longer than expected."));
-  console.log(
-    chalk2.gray("Check status with: ") + chalk2.white(`mcp-use status ${deployment.id}`)
-  );
-}
-async function deployCommand(options) {
-  try {
-    const cwd = process.cwd();
-    if (!await isLoggedIn()) {
-      console.log(chalk2.red("\u2717 You are not logged in."));
-      console.log(
-        chalk2.gray("Run " + chalk2.white("mcp-use login") + " to get started.")
-      );
-      process.exit(1);
-    }
-    console.log(chalk2.cyan.bold("\u{1F680} Deploying to mcp-use cloud...\n"));
-    const isMcp = await isMcpProject(cwd);
-    if (!isMcp) {
-      console.log(
-        chalk2.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(
-        chalk2.white("Continue anyway? (y/n): ")
-      );
-      if (!shouldContinue) {
-        console.log(chalk2.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(
-          chalk2.red(
-            "\u2717 Could not parse GitHub repository information from remote URL."
-          )
-        );
-        process.exit(1);
-      }
-      console.log(chalk2.white("GitHub repository detected:"));
-      console.log(
-        chalk2.gray(`  Repository: `) + chalk2.cyan(`${gitInfo.owner}/${gitInfo.repo}`)
-      );
-      console.log(
-        chalk2.gray(`  Branch:     `) + chalk2.cyan(gitInfo.branch || "main")
-      );
-      if (gitInfo.commitSha) {
-        console.log(
-          chalk2.gray(`  Commit:     `) + chalk2.gray(gitInfo.commitSha.substring(0, 7))
-        );
-      }
-      if (gitInfo.commitMessage) {
-        console.log(
-          chalk2.gray(`  Message:    `) + chalk2.gray(gitInfo.commitMessage.split("\n")[0])
-        );
-      }
-      console.log();
-      const shouldDeploy = await prompt(
-        chalk2.white(
-          `Deploy from GitHub repository ${gitInfo.owner}/${gitInfo.repo}? (y/n): `
-        )
-      );
-      if (!shouldDeploy) {
-        console.log(chalk2.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(chalk2.white("Deployment configuration:"));
-      console.log(chalk2.gray(`  Name:          `) + chalk2.cyan(projectName));
-      console.log(chalk2.gray(`  Runtime:       `) + chalk2.cyan(runtime));
-      console.log(chalk2.gray(`  Port:          `) + chalk2.cyan(port));
-      if (buildCommand) {
-        console.log(chalk2.gray(`  Build command: `) + chalk2.cyan(buildCommand));
-      }
-      if (startCommand) {
-        console.log(chalk2.gray(`  Start command: `) + chalk2.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(chalk2.gray("Creating deployment..."));
-      const api = await McpUseAPI.create();
-      const deployment = await api.createDeployment(deploymentRequest);
-      console.log(
-        chalk2.green("\u2713 Deployment created: ") + chalk2.gray(deployment.id)
-      );
-      await displayDeploymentProgress(api, deployment);
-      if (options.open && deployment.domain) {
-        console.log();
-        console.log(chalk2.gray("Opening deployment in browser..."));
-        await open2(`https://${deployment.domain}`);
-      }
-    } else {
-      if (options.fromSource) {
-        console.log(
-          chalk2.white("\u{1F4E6} Deploying from local source code (--from-source)...")
-        );
-      } else {
-        console.log(
-          chalk2.yellow(
-            "\u26A0\uFE0F  This is not a GitHub repository or no remote is configured."
-          )
-        );
-        console.log(chalk2.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(chalk2.white("Deployment configuration:"));
-      console.log(chalk2.gray(`  Name:          `) + chalk2.cyan(projectName));
-      console.log(chalk2.gray(`  Runtime:       `) + chalk2.cyan(runtime));
-      console.log(chalk2.gray(`  Port:          `) + chalk2.cyan(port));
-      if (buildCommand) {
-        console.log(chalk2.gray(`  Build command: `) + chalk2.cyan(buildCommand));
-      }
-      if (startCommand) {
-        console.log(chalk2.gray(`  Start command: `) + chalk2.cyan(startCommand));
-      }
-      console.log();
-      const shouldDeploy = await prompt(
-        chalk2.white("Deploy from local source? (y/n): "),
-        "y"
-      );
-      if (!shouldDeploy) {
-        console.log(chalk2.gray("Deployment cancelled."));
-        process.exit(0);
-      }
-      console.log();
-      console.log(chalk2.gray("Packaging source code..."));
-      const tarballPath = await createTarball(cwd);
-      const stats = await fs2.stat(tarballPath);
-      console.log(
-        chalk2.green("\u2713 Packaged: ") + chalk2.gray(formatFileSize(stats.size))
-      );
-      const maxSize = 2 * 1024 * 1024;
-      if (stats.size > maxSize) {
-        console.log(
-          chalk2.red(
-            `\u2717 File size (${formatFileSize(stats.size)}) exceeds maximum of 2MB`
-          )
-        );
-        await fs2.unlink(tarballPath);
-        process.exit(1);
-      }
-      const deploymentRequest = {
-        name: projectName,
-        source: {
-          type: "upload",
-          runtime,
-          port,
-          buildCommand,
-          startCommand
-        },
-        healthCheckPath: "/healthz"
-      };
-      console.log(chalk2.gray("Creating deployment..."));
-      const api = await McpUseAPI.create();
-      const deployment = await api.createDeploymentWithUpload(
-        deploymentRequest,
-        tarballPath
-      );
-      await fs2.unlink(tarballPath);
-      console.log(
-        chalk2.green("\u2713 Deployment created: ") + chalk2.gray(deployment.id)
-      );
-      await displayDeploymentProgress(api, deployment);
-      if (options.open && deployment.domain) {
-        console.log();
-        console.log(chalk2.gray("Opening deployment in browser..."));
-        await open2(`https://${deployment.domain}`);
-      }
-    }
-  } catch (error) {
-    console.error(
-      chalk2.red.bold("\n\u2717 Deployment failed:"),
-      chalk2.red(error instanceof Error ? error.message : "Unknown error")
-    );
-    process.exit(1);
-  }
-}
-
-// src/index.ts
-var program = new Command();
-var packageContent = readFileSync(
-  path3.join(__dirname, "../package.json"),
-  "utf-8"
-);
-var packageJson = JSON.parse(packageContent);
-var packageVersion = packageJson.version || "unknown";
-program.name("mcp-use").description("Create and run MCP servers with ui resources widgets").version(packageVersion);
-async function isPortAvailable(port, host = "localhost") {
-  try {
-    await fetch(`http://${host}:${port}`);
-    return false;
-  } catch {
-    return true;
-  }
-}
-async function findAvailablePort2(startPort, host = "localhost") {
-  for (let port = startPort; port < startPort + 100; port++) {
-    if (await isPortAvailable(port, host)) {
-      return port;
-    }
-  }
-  throw new Error("No available ports found");
-}
-async function waitForServer(port, host = "localhost", maxAttempts = 30) {
-  for (let i = 0; i < maxAttempts; i++) {
-    const controller = new AbortController();
-    try {
-      const response = await fetch(`http://${host}:${port}/inspector/health`, {
-        signal: controller.signal
-      });
-      if (response.ok) {
-        return true;
-      }
-    } catch {
-    } finally {
-      controller.abort();
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-  }
-  return false;
-}
-function runCommand(command, args, cwd, env, filterStderr = false) {
-  const proc = spawn(command, args, {
-    cwd,
-    stdio: filterStderr ? ["inherit", "inherit", "pipe"] : "inherit",
-    shell: false,
-    env: env ? { ...process.env, ...env } : process.env
-  });
-  if (filterStderr && proc.stderr) {
-    proc.stderr.on("data", (data) => {
-      const text = data.toString();
-      if (!text.includes("Previous process hasn't exited yet") && !text.includes("Force killing")) {
-        process.stderr.write(data);
-      }
-    });
-  }
-  const promise = new Promise((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("exit", (code) => {
-      if (code === 0 || code === 130 || code === 143) {
-        resolve();
-      } else {
-        reject(new Error(`Command failed with exit code ${code}`));
-      }
-    });
-  });
-  return { promise, process: proc };
-}
-async function startTunnel(port, subdomain) {
-  return new Promise((resolve, reject) => {
-    console.log(chalk3.gray(`Starting tunnel for port ${port}...`));
-    const tunnelArgs = ["--yes", "@mcp-use/tunnel", String(port)];
-    if (subdomain) {
-      tunnelArgs.push("--subdomain", subdomain);
-    }
-    const proc = spawn("npx", tunnelArgs, {
-      stdio: ["ignore", "pipe", "pipe"],
-      shell: false
-    });
-    let resolved = false;
-    let isShuttingDown = false;
-    proc.stdout?.on("data", (data) => {
-      const text = data.toString();
-      const isShutdownMessage = text.includes("Shutting down") || text.includes("\u{1F6D1}");
-      if (!isShuttingDown && !isShutdownMessage) {
-        process.stdout.write(text);
-      }
-      const urlMatch = text.match(/https?:\/\/([a-z0-9-]+\.[a-z0-9.-]+)/i);
-      if (urlMatch && !resolved) {
-        const url = urlMatch[0];
-        const fullDomain = urlMatch[1];
-        const subdomainMatch = fullDomain.match(/^([a-z0-9-]+)\./i);
-        let extractedSubdomain = subdomainMatch ? subdomainMatch[1] : fullDomain.split(".")[0];
-        if (!/^[a-z0-9-]+$/i.test(extractedSubdomain)) {
-          console.warn(
-            chalk3.yellow(
-              `Warning: Extracted subdomain "${extractedSubdomain}" does not match expected format.`
-            )
-          );
-          extractedSubdomain = "";
-        }
-        resolved = true;
-        clearTimeout(setupTimeout);
-        console.log(chalk3.green.bold(`\u2713 Tunnel established: ${url}/mcp`));
-        resolve({ url, subdomain: extractedSubdomain, process: proc });
-      }
-    });
-    proc.stderr?.on("data", (data) => {
-      const text = data.toString();
-      if (!isShuttingDown && !text.includes("INFO") && !text.includes("bore_cli") && !text.includes("Shutting down")) {
-        process.stderr.write(data);
-      }
-    });
-    proc.on("error", (error) => {
-      if (!resolved) {
-        clearTimeout(setupTimeout);
-        reject(new Error(`Failed to start tunnel: ${error.message}`));
-      }
-    });
-    proc.on("exit", (code) => {
-      if (code !== 0 && !resolved) {
-        clearTimeout(setupTimeout);
-        reject(new Error(`Tunnel process exited with code ${code}`));
-      }
-    });
-    proc.markShutdown = () => {
-      isShuttingDown = true;
-    };
-    const setupTimeout = setTimeout(() => {
-      if (!resolved) {
-        proc.kill();
-        reject(new Error("Tunnel setup timed out"));
-      }
-    }, 3e4);
-  });
-}
-async function findServerFile(projectPath) {
-  const candidates = ["index.ts", "src/index.ts", "server.ts", "src/server.ts"];
-  for (const candidate of candidates) {
-    try {
-      await access(path3.join(projectPath, candidate));
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  throw new Error("No server file found");
-}
-async function buildWidgets(projectPath) {
-  const { promises: fs3 } = await import("fs");
-  const { build } = await import("vite");
-  const resourcesDir = path3.join(projectPath, "resources");
-  const mcpUrl = process.env.MCP_URL;
-  try {
-    await access(resourcesDir);
-  } catch {
-    console.log(
-      chalk3.gray("No resources/ directory found - skipping widget build")
-    );
-    return [];
-  }
-  const entries = [];
-  try {
-    const files = await fs3.readdir(resourcesDir, { withFileTypes: true });
-    for (const dirent of files) {
-      if (dirent.name.startsWith("._") || dirent.name.startsWith(".DS_Store")) {
-        continue;
-      }
-      if (dirent.isFile() && (dirent.name.endsWith(".tsx") || dirent.name.endsWith(".ts"))) {
-        entries.push({
-          name: dirent.name.replace(/\.tsx?$/, ""),
-          path: path3.join(resourcesDir, dirent.name)
-        });
-      } else if (dirent.isDirectory()) {
-        const widgetPath = path3.join(resourcesDir, dirent.name, "widget.tsx");
-        try {
-          await fs3.access(widgetPath);
-          entries.push({
-            name: dirent.name,
-            path: widgetPath
-          });
-        } catch {
-        }
-      }
-    }
-  } catch (error) {
-    console.log(chalk3.gray("No widgets found in resources/ directory"));
-    return [];
-  }
-  if (entries.length === 0) {
-    console.log(chalk3.gray("No widgets found in resources/ directory"));
-    return [];
-  }
-  console.log(chalk3.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 widgetName = entry.name;
-    const entryPath = entry.path;
-    console.log(chalk3.gray(`  - Building ${widgetName}...`));
-    const tempDir = path3.join(projectPath, ".mcp-use", widgetName);
-    await fs3.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = path3.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const cssContent = `@import "tailwindcss";
-
-/* Configure Tailwind to scan the resources directory */
-@source "${relativeResourcesPath}";
-`;
-    await fs3.writeFile(path3.join(tempDir, "styles.css"), cssContent, "utf8");
-    const entryContent = `import React from 'react'
-import { createRoot } from 'react-dom/client'
-import './styles.css'
-import Component from '${entryPath}'
-
-const container = document.getElementById('widget-root')
-if (container && Component) {
-  const root = createRoot(container)
-  root.render(<Component />)
-}
-`;
-    const htmlContent = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width,initial-scale=1" />
-    <title>${widgetName} Widget</title>
-  </head>
-  <body>
-    <div id="widget-root"></div>
-    <script type="module" src="/entry.tsx"></script>
-  </body>
-</html>`;
-    await fs3.writeFile(path3.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs3.writeFile(path3.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = path3.join(
-      projectPath,
-      "dist",
-      "resources",
-      "widgets",
-      widgetName
-    );
-    const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
-    let widgetMetadata = {};
-    try {
-      const metadataTempDir = path3.join(
-        projectPath,
-        ".mcp-use",
-        `${widgetName}-metadata`
-      );
-      await fs3.mkdir(metadataTempDir, { recursive: true });
-      const { createServer: createServer2 } = await import("vite");
-      const nodeStubsPlugin = {
-        name: "node-stubs",
-        enforce: "pre",
-        resolveId(id) {
-          if (id === "posthog-node" || id.startsWith("posthog-node/")) {
-            return "\0virtual:posthog-node-stub";
-          }
-          return null;
-        },
-        load(id) {
-          if (id === "\0virtual:posthog-node-stub") {
-            return `
-export class PostHog {
-  constructor() {}
-  capture() {}
-  identify() {}
-  alias() {}
-  flush() { return Promise.resolve(); }
-  shutdown() { return Promise.resolve(); }
-}
-export default PostHog;
-`;
-          }
-          return null;
-        }
-      };
-      const metadataServer = await createServer2({
-        root: metadataTempDir,
-        cacheDir: path3.join(metadataTempDir, ".vite-cache"),
-        plugins: [nodeStubsPlugin, tailwindcss(), react()],
-        resolve: {
-          alias: {
-            "@": resourcesDir
-          }
-        },
-        server: {
-          middlewareMode: true
-        },
-        optimizeDeps: {
-          // Exclude Node.js-only packages from browser bundling
-          exclude: ["posthog-node"]
-        },
-        ssr: {
-          // Force Vite to transform these packages in SSR instead of using external requires
-          noExternal: ["@openai/apps-sdk-ui", "react-router"],
-          // Mark Node.js-only packages as external in SSR mode
-          external: ["posthog-node"]
-        },
-        define: {
-          // Define process.env for SSR context
-          "process.env.NODE_ENV": JSON.stringify(
-            process.env.NODE_ENV || "development"
-          ),
-          "import.meta.env.DEV": true,
-          "import.meta.env.PROD": false,
-          "import.meta.env.MODE": JSON.stringify("development"),
-          "import.meta.env.SSR": true
-        },
-        clearScreen: false,
-        logLevel: "silent",
-        customLogger: {
-          info: () => {
-          },
-          warn: () => {
-          },
-          error: () => {
-          },
-          clearScreen: () => {
-          },
-          hasErrorLogged: () => false,
-          hasWarned: false,
-          warnOnce: () => {
-          }
-        }
-      });
-      try {
-        const mod = await metadataServer.ssrLoadModule(entryPath);
-        if (mod.widgetMetadata) {
-          widgetMetadata = {
-            ...mod.widgetMetadata,
-            title: mod.widgetMetadata.title || widgetName,
-            description: mod.widgetMetadata.description,
-            inputs: mod.widgetMetadata.inputs?.shape || {}
-          };
-        }
-        await new Promise((resolve) => setTimeout(resolve, 50));
-      } catch (error) {
-        console.warn(
-          chalk3.yellow(`    \u26A0 Could not extract metadata for ${widgetName}`)
-        );
-      } finally {
-        await metadataServer.close();
-        try {
-          await fs3.rm(metadataTempDir, { recursive: true, force: true });
-        } catch {
-        }
-      }
-    } catch (error) {
-    }
-    try {
-      const buildNodeStubsPlugin = {
-        name: "node-stubs-build",
-        enforce: "pre",
-        resolveId(id) {
-          if (id === "posthog-node" || id.startsWith("posthog-node/")) {
-            return "\0virtual:posthog-node-stub";
-          }
-          if (id === "path" || id === "node:path") {
-            return "\0virtual:path-stub";
-          }
-          return null;
-        },
-        load(id) {
-          if (id === "\0virtual:posthog-node-stub") {
-            return `
-export class PostHog {
-  constructor() {}
-  capture() {}
-  identify() {}
-  alias() {}
-  flush() { return Promise.resolve(); }
-  shutdown() { return Promise.resolve(); }
-}
-export default PostHog;
-`;
-          }
-          if (id === "\0virtual:path-stub") {
-            return `
-export function join(...paths) {
-  return paths.filter(Boolean).join("/").replace(/\\/\\//g, "/").replace(/\\/$/, "");
-}
-export function resolve(...paths) {
-  return join(...paths);
-}
-export function dirname(filepath) {
-  const parts = filepath.split("/");
-  parts.pop();
-  return parts.join("/") || "/";
-}
-export function basename(filepath, ext) {
-  const parts = filepath.split("/");
-  let name = parts[parts.length - 1] || "";
-  if (ext && name.endsWith(ext)) {
-    name = name.slice(0, -ext.length);
-  }
-  return name;
-}
-export function extname(filepath) {
-  const name = basename(filepath);
-  const index = name.lastIndexOf(".");
-  return index > 0 ? name.slice(index) : "";
-}
-export function normalize(filepath) {
-  return filepath.replace(/\\/\\//g, "/");
-}
-export function isAbsolute(filepath) {
-  return filepath.startsWith("/");
-}
-export const sep = "/";
-export const delimiter = ":";
-export const posix = {
-  join,
-  resolve,
-  dirname,
-  basename,
-  extname,
-  normalize,
-  isAbsolute,
-  sep,
-  delimiter,
-};
-export default {
-  join,
-  resolve,
-  dirname,
-  basename,
-  extname,
-  normalize,
-  isAbsolute,
-  sep,
-  delimiter,
-  posix,
-};
-`;
-          }
-          return null;
-        }
-      };
-      await build({
-        root: tempDir,
-        base: baseUrl,
-        plugins: [buildNodeStubsPlugin, tailwindcss(), react()],
-        experimental: {
-          renderBuiltUrl: (filename, { hostType }) => {
-            if (["js", "css"].includes(hostType)) {
-              return {
-                runtime: `window.__getFile(${JSON.stringify(filename)})`
-              };
-            } else {
-              return { relative: true };
-            }
-          }
-        },
-        resolve: {
-          alias: {
-            "@": resourcesDir
-          }
-        },
-        optimizeDeps: {
-          // Exclude Node.js-only packages from browser bundling
-          exclude: ["posthog-node"]
-        },
-        build: {
-          outDir,
-          emptyOutDir: true,
-          rollupOptions: {
-            input: path3.join(tempDir, "index.html"),
-            external: (id) => {
-              return false;
-            }
-          }
-        }
-      });
-      const mcpServerUrl = process.env.MCP_SERVER_URL;
-      if (mcpServerUrl) {
-        try {
-          const htmlPath = path3.join(outDir, "index.html");
-          let html = await fs3.readFile(htmlPath, "utf8");
-          const injectionScript = `<script>window.__getFile = (filename) => { return "${mcpUrl}/${widgetName}/"+filename }; window.__mcpPublicUrl = "${mcpServerUrl}/mcp-use/public"; window.__mcpPublicAssetsUrl = "${mcpUrl}/public";</script>`;
-          if (!html.includes("window.__mcpPublicUrl")) {
-            html = html.replace(
-              /<head[^>]*>/i,
-              `<head>
-    ${injectionScript}`
-            );
-          }
-          if (/<base\s+[^>]*\/?>/i.test(html)) {
-            html = html.replace(
-              /<base\s+[^>]*\/?>/i,
-              `<base href="${mcpServerUrl}">`
-            );
-          } else {
-            html = html.replace(
-              injectionScript,
-              `${injectionScript}
-    <base href="${mcpServerUrl}">`
-            );
-          }
-          await fs3.writeFile(htmlPath, html, "utf8");
-          console.log(
-            chalk3.gray(`    \u2192 Injected MCP_SERVER_URL into ${widgetName}`)
-          );
-        } catch (error) {
-          console.warn(
-            chalk3.yellow(
-              `    \u26A0 Failed to post-process HTML for ${widgetName}:`,
-              error
-            )
-          );
-        }
-      }
-      builtWidgets.push({
-        name: widgetName,
-        metadata: widgetMetadata
-      });
-      console.log(chalk3.green(`    \u2713 Built ${widgetName}`));
-    } catch (error) {
-      console.error(chalk3.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 = path3.resolve(options.path);
-    const { promises: fs3 } = await import("fs");
-    console.log(chalk3.cyan.bold(`mcp-use v${packageJson.version}`));
-    const builtWidgets = await buildWidgets(projectPath);
-    console.log(chalk3.gray("Building TypeScript..."));
-    await runCommand("npx", ["tsc"], projectPath);
-    console.log(chalk3.green("\u2713 TypeScript build complete!"));
-    const publicDir = path3.join(projectPath, "public");
-    try {
-      await fs3.access(publicDir);
-      console.log(chalk3.gray("Copying public assets..."));
-      await fs3.cp(publicDir, path3.join(projectPath, "dist", "public"), {
-        recursive: true
-      });
-      console.log(chalk3.green("\u2713 Public assets copied"));
-    } catch {
-    }
-    const manifestPath = path3.join(projectPath, "dist", "mcp-use.json");
-    let existingManifest = {};
-    try {
-      const existingContent = await fs3.readFile(manifestPath, "utf-8");
-      existingManifest = JSON.parse(existingContent);
-    } catch {
-    }
-    const widgetsData = {};
-    for (const widget of builtWidgets) {
-      widgetsData[widget.name] = widget.metadata;
-    }
-    const includeInspector = !!options.withInspector;
-    const buildTime = (/* @__PURE__ */ new Date()).toISOString();
-    const { createHash } = await import("crypto");
-    const buildId = createHash("sha256").update(buildTime + Math.random().toString()).digest("hex").substring(0, 16);
-    const manifest = {
-      ...existingManifest,
-      // Preserve existing fields like tunnel
-      includeInspector,
-      buildTime,
-      buildId,
-      widgets: widgetsData
-    };
-    await fs3.mkdir(path3.dirname(manifestPath), { recursive: true });
-    await fs3.writeFile(
-      manifestPath,
-      JSON.stringify(manifest, null, 2),
-      "utf8"
-    );
-    console.log(chalk3.green("\u2713 Build manifest created"));
-    console.log(chalk3.green.bold(`
-\u2713 Build complete!`));
-    if (builtWidgets.length > 0) {
-      console.log(chalk3.gray(`  ${builtWidgets.length} widget(s) built`));
-    }
-    if (options.withInspector) {
-      console.log(chalk3.gray("  Inspector included"));
-    }
-  } catch (error) {
-    console.error(chalk3.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 = path3.resolve(options.path);
-    let port = parseInt(options.port, 10);
-    const host = options.host;
-    console.log(chalk3.cyan.bold(`mcp-use v${packageJson.version}`));
-    if (!await isPortAvailable(port, host)) {
-      console.log(chalk3.yellow.bold(`\u26A0\uFE0F  Port ${port} is already in use`));
-      const availablePort = await findAvailablePort2(port, host);
-      console.log(chalk3.green.bold(`\u2713 Using port ${availablePort} instead`));
-      port = availablePort;
-    }
-    const serverFile = await findServerFile(projectPath);
-    const processes = [];
-    const env = {
-      PORT: String(port),
-      HOST: host,
-      NODE_ENV: "development"
-    };
-    const serverCommand = runCommand(
-      "npx",
-      ["tsx", "watch", serverFile],
-      projectPath,
-      env,
-      true
-    );
-    processes.push(serverCommand.process);
-    if (options.open !== false) {
-      const startTime = Date.now();
-      const ready = await waitForServer(port, host);
-      if (ready) {
-        const mcpEndpoint = `http://${host}:${port}/mcp`;
-        const inspectorUrl = `http://${host}:${port}/inspector?autoConnect=${encodeURIComponent(mcpEndpoint)}`;
-        const readyTime = Date.now() - startTime;
-        console.log(chalk3.green.bold(`\u2713 Ready in ${readyTime}ms`));
-        console.log(chalk3.whiteBright(`Local:    http://${host}:${port}`));
-        console.log(chalk3.whiteBright(`Network:  http://${host}:${port}`));
-        console.log(chalk3.whiteBright(`MCP:      ${mcpEndpoint}`));
-        console.log(chalk3.whiteBright(`Inspector: ${inspectorUrl}
-`));
-        await open3(inspectorUrl);
-      }
-    }
-    const cleanup = () => {
-      console.log(chalk3.gray("\n\nShutting down..."));
-      const processesToKill = processes.length;
-      let killedCount = 0;
-      const checkAndExit = () => {
-        killedCount++;
-        if (killedCount >= processesToKill) {
-          process.exit(0);
-        }
-      };
-      processes.forEach((proc) => {
-        if (proc && typeof proc.kill === "function") {
-          proc.on("exit", checkAndExit);
-          proc.kill("SIGINT");
-        } else {
-          checkAndExit();
-        }
-      });
-      setTimeout(() => {
-        processes.forEach((proc) => {
-          if (proc && typeof proc.kill === "function" && proc.exitCode === null) {
-            proc.kill("SIGKILL");
-          }
-        });
-        process.exit(0);
-      }, 1e3);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    await new Promise(() => {
-    });
-  } catch (error) {
-    console.error(chalk3.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 = path3.resolve(options.path);
-    const port = parseInt(options.port, 10);
-    console.log(
-      `\x1B[36m\x1B[1mmcp-use\x1B[0m \x1B[90mVersion: ${packageJson.version}\x1B[0m
-`
-    );
-    let mcpUrl;
-    let tunnelProcess = void 0;
-    let tunnelSubdomain = void 0;
-    if (options.tunnel) {
-      try {
-        const manifestPath = path3.join(projectPath, "dist", "mcp-use.json");
-        let existingSubdomain;
-        try {
-          const manifestContent = await readFile(manifestPath, "utf-8");
-          const manifest = JSON.parse(manifestContent);
-          existingSubdomain = manifest.tunnel?.subdomain;
-          if (existingSubdomain) {
-            console.log(
-              chalk3.gray(`Found existing subdomain: ${existingSubdomain}`)
-            );
-          }
-        } catch (error) {
-          console.debug(
-            chalk3.gray(
-              `Debug: Failed to read or parse mcp-use.json: ${error instanceof Error ? error.message : String(error)}`
-            )
-          );
-        }
-        const tunnelInfo = await startTunnel(port, existingSubdomain);
-        mcpUrl = tunnelInfo.url;
-        tunnelProcess = tunnelInfo.process;
-        const subdomain = tunnelInfo.subdomain;
-        tunnelSubdomain = subdomain;
-        try {
-          let manifest = {};
-          try {
-            const manifestContent = await readFile(manifestPath, "utf-8");
-            manifest = JSON.parse(manifestContent);
-          } catch {
-          }
-          if (!manifest.tunnel) {
-            manifest.tunnel = {};
-          }
-          manifest.tunnel.subdomain = subdomain;
-          await mkdir(path3.dirname(manifestPath), { recursive: true });
-          await writeFile(
-            manifestPath,
-            JSON.stringify(manifest, null, 2),
-            "utf-8"
-          );
-        } catch (error) {
-          console.warn(
-            chalk3.yellow(
-              `\u26A0\uFE0F  Failed to save subdomain to mcp-use.json: ${error instanceof Error ? error.message : "Unknown error"}`
-            )
-          );
-        }
-      } catch (error) {
-        console.error(chalk3.red("Failed to start tunnel:"), error);
-        process.exit(1);
-      }
-    }
-    let serverFile = "dist/index.js";
-    try {
-      await access(path3.join(projectPath, serverFile));
-    } catch {
-      serverFile = "dist/server.js";
-    }
-    console.log("Starting production server...");
-    const env = {
-      ...process.env,
-      PORT: String(port),
-      NODE_ENV: "production"
-    };
-    if (mcpUrl) {
-      env.MCP_URL = mcpUrl;
-      console.log(chalk3.whiteBright(`Tunnel:   ${mcpUrl}/mcp`));
-    }
-    const serverProc = spawn("node", [serverFile], {
-      cwd: projectPath,
-      stdio: "inherit",
-      env
-    });
-    let cleanupInProgress = false;
-    const cleanup = async () => {
-      if (cleanupInProgress) {
-        return;
-      }
-      cleanupInProgress = true;
-      console.log(chalk3.gray("\n\nShutting down..."));
-      if (tunnelProcess && typeof tunnelProcess.markShutdown === "function") {
-        tunnelProcess.markShutdown();
-      }
-      if (tunnelSubdomain) {
-        try {
-          const apiBase = process.env.MCP_USE_API || "https://local.mcp-use.run";
-          await fetch(`${apiBase}/api/tunnels/${tunnelSubdomain}`, {
-            method: "DELETE"
-          });
-        } catch (err) {
-        }
-      }
-      const processesToKill = 1 + (tunnelProcess ? 1 : 0);
-      let killedCount = 0;
-      const checkAndExit = () => {
-        killedCount++;
-        if (killedCount >= processesToKill) {
-          process.exit(0);
-        }
-      };
-      serverProc.on("exit", checkAndExit);
-      serverProc.kill("SIGTERM");
-      if (tunnelProcess && typeof tunnelProcess.kill === "function") {
-        tunnelProcess.on("exit", checkAndExit);
-        tunnelProcess.kill("SIGINT");
-      } else {
-        checkAndExit();
-      }
-      setTimeout(() => {
-        if (serverProc.exitCode === null) {
-          serverProc.kill("SIGKILL");
-        }
-        if (tunnelProcess && tunnelProcess.exitCode === null) {
-          tunnelProcess.kill("SIGKILL");
-        }
-        process.exit(0);
-      }, 2e3);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    serverProc.on("exit", (code) => {
-      process.exit(code || 0);
-    });
-  } catch (error) {
-    console.error("Start failed:", error);
-    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();