@mcp-use/cli 2.6.1 → 2.7.0-canary.1

package/dist/index.cjs

@@ -523,12 +523,12 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // src/index.ts
-var import_commander2 = require("commander");
-var import_config4 = require("dotenv/config");
+var import_commander3 = require("commander");
+var import_config5 = require("dotenv/config");
 var import_node_child_process10 = require("child_process");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 
 // ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
 var import_node_process8 = __toESM(require("process"), 1);
@@ -700,15 +700,15 @@ var wslDefaultBrowser = async () => {
   const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
   return stdout.trim();
 };
-var convertWslPathToWindows = async (path5) => {
-  if (/^[a-z]+:\/\//i.test(path5)) {
-    return path5;
+var convertWslPathToWindows = async (path6) => {
+  if (/^[a-z]+:\/\//i.test(path6)) {
+    return path6;
   }
   try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path5], { encoding: "utf8" });
+    const { stdout } = await execFile2("wslpath", ["-aw", path6], { encoding: "utf8" });
     return stdout.trim();
   } catch {
-    return path5;
+    return path6;
   }
 };
 
@@ -1130,6 +1130,9 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({
 }));
 var open_default = open;
 
+// src/index.ts
+var import_zod = require("zod");
+
 // src/commands/auth.ts
 var import_node_http = require("http");
 
@@ -1209,15 +1212,30 @@ var McpUseAPI = class _McpUseAPI {
     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}`);
+    const timeout = options.timeout || 3e4;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API request failed: ${response.status} ${error}`);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(
+          `Request timeout after ${timeout / 1e3}s. Try using --follow flag to stream logs instead.`
+        );
+      }
+      throw error;
     }
-    return response.json();
   }
   /**
    * Create API key using JWT token
@@ -1360,6 +1378,92 @@ var McpUseAPI = class _McpUseAPI {
     }
     return response.json();
   }
+  /**
+   * List all deployments
+   */
+  async listDeployments() {
+    const response = await this.request("/deployments");
+    return response.deployments;
+  }
+  /**
+   * Delete deployment
+   */
+  async deleteDeployment(deploymentId) {
+    await this.request(`/deployments/${deploymentId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Update deployment
+   */
+  async updateDeployment(deploymentId, updates) {
+    return this.request(`/deployments/${deploymentId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+  }
+  /**
+   * Redeploy deployment
+   */
+  async redeployDeployment(deploymentId, filePath) {
+    if (filePath) {
+      const { readFile: readFile3 } = 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 readFile3(filePath);
+      const formData = new FormData();
+      const blob = new Blob([fileBuffer], { type: "application/gzip" });
+      formData.append("source_file", blob, basename(filePath));
+      const headers = {};
+      if (this.apiKey) headers["x-api-key"] = this.apiKey;
+      const response = await fetch(
+        `${this.baseUrl}/deployments/${deploymentId}/redeploy`,
+        {
+          method: "POST",
+          headers,
+          body: formData
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Redeploy failed: ${error}`);
+      }
+      return response.json();
+    } else {
+      return this.request(`/deployments/${deploymentId}/redeploy`, {
+        method: "POST"
+      });
+    }
+  }
+  /**
+   * Get deployment logs
+   */
+  async getDeploymentLogs(deploymentId) {
+    const response = await this.request(
+      `/deployments/${deploymentId}/logs`,
+      { timeout: 6e4 }
+      // 60 second timeout for logs
+    );
+    return response.data.logs;
+  }
+  /**
+   * Get deployment build logs
+   */
+  async getDeploymentBuildLogs(deploymentId) {
+    const response = await this.request(
+      `/deployments/${deploymentId}/logs/build`,
+      { timeout: 6e4 }
+      // 60 second timeout for logs
+    );
+    return response.data.logs;
+  }
 };
 
 // src/commands/auth.ts
@@ -1699,1557 +1803,2360 @@ async function whoamiCommand() {
   }
 }
 
-// src/commands/deploy.ts
-var import_node_fs5 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_os4 = __toESM(require("os"), 1);
-var import_node_child_process9 = require("child_process");
-var import_node_util8 = require("util");
+// src/commands/client.ts
+var import_commander = require("commander");
+var import_node_readline = require("readline");
+var import_client = require("mcp-use/client");
 
-// src/utils/git.ts
-var import_node_child_process8 = require("child_process");
-var import_node_util7 = require("util");
-var execAsync = (0, import_node_util7.promisify)(import_node_child_process8.exec);
-async function gitCommand(command, cwd = process.cwd()) {
+// src/utils/session-storage.ts
+var import_node_os4 = require("os");
+var import_node_path3 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_fs5 = require("fs");
+var SESSION_FILE_PATH = (0, import_node_path3.join)((0, import_node_os4.homedir)(), ".mcp-use", "cli-sessions.json");
+async function ensureSessionDir() {
+  const dir = (0, import_node_path3.join)((0, import_node_os4.homedir)(), ".mcp-use");
+  if (!(0, import_node_fs5.existsSync)(dir)) {
+    await (0, import_promises4.mkdir)(dir, { recursive: true });
+  }
+}
+async function loadSessions() {
   try {
-    const { stdout } = await execAsync(command, { cwd });
-    return stdout.trim();
+    await ensureSessionDir();
+    if (!(0, import_node_fs5.existsSync)(SESSION_FILE_PATH)) {
+      return { activeSession: null, sessions: {} };
+    }
+    const content = await (0, import_promises4.readFile)(SESSION_FILE_PATH, "utf-8");
+    return JSON.parse(content);
   } catch (error) {
-    return null;
+    return { activeSession: null, sessions: {} };
   }
 }
-async function isGitRepo(cwd = process.cwd()) {
-  const result = await gitCommand("git rev-parse --is-inside-work-tree", cwd);
-  return result === "true";
+async function saveSessions(storage) {
+  await ensureSessionDir();
+  await (0, import_promises4.writeFile)(SESSION_FILE_PATH, JSON.stringify(storage, null, 2), "utf-8");
 }
-async function getRemoteUrl(cwd = process.cwd()) {
-  return gitCommand("git config --get remote.origin.url", cwd);
+async function saveSession(name, config) {
+  const storage = await loadSessions();
+  storage.sessions[name] = {
+    ...config,
+    lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!storage.activeSession) {
+    storage.activeSession = name;
+  }
+  await saveSessions(storage);
 }
-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;
+async function getActiveSession() {
+  const storage = await loadSessions();
+  if (!storage.activeSession || !storage.sessions[storage.activeSession]) {
+    return null;
+  }
   return {
-    owner: match[1],
-    repo: match[2]
+    name: storage.activeSession,
+    config: storage.sessions[storage.activeSession]
   };
 }
-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 getSession(name) {
+  const storage = await loadSessions();
+  return storage.sessions[name] || null;
 }
-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;
-    }
+async function setActiveSession(name) {
+  const storage = await loadSessions();
+  if (!storage.sessions[name]) {
+    throw new Error(`Session '${name}' not found`);
   }
-  return {
-    isGitRepo: true,
-    remoteUrl: remoteUrl || void 0,
-    owner,
-    repo,
-    branch: branch || void 0,
-    commitSha: commitSha || void 0,
-    commitMessage: commitMessage || void 0
-  };
+  storage.activeSession = name;
+  storage.sessions[name].lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+  await saveSessions(storage);
 }
-function isGitHubUrl(url) {
-  try {
-    const parsedUrl = new URL(url);
-    return parsedUrl.hostname === "github.com" || parsedUrl.hostname === "www.github.com";
-  } catch {
-    const sshMatch = url.match(/^git@([^:/]+)[:/]/);
-    if (sshMatch) {
-      const host = sshMatch[1];
-      return host === "github.com" || host === "www.github.com";
-    }
+async function listAllSessions() {
+  const storage = await loadSessions();
+  return Object.entries(storage.sessions).map(([name, config]) => ({
+    name,
+    config,
+    isActive: name === storage.activeSession
+  }));
+}
+async function updateSessionInfo(name, serverInfo, capabilities) {
+  const storage = await loadSessions();
+  if (storage.sessions[name]) {
+    storage.sessions[name].serverInfo = serverInfo;
+    storage.sessions[name].capabilities = capabilities;
+    storage.sessions[name].lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    await saveSessions(storage);
   }
-  return false;
 }
 
-// src/commands/deploy.ts
-var execAsync2 = (0, import_node_util8.promisify)(import_node_child_process9.exec);
-async function isMcpProject(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
-    const content = await import_node_fs5.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;
+// src/utils/format.ts
+function formatTable(data, columns) {
+  if (data.length === 0) {
+    return source_default.gray("No items found");
   }
-}
-async function getProjectName(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
-    const content = await import_node_fs5.promises.readFile(packageJsonPath, "utf-8");
-    const packageJson2 = JSON.parse(content);
-    if (packageJson2.name) {
-      return packageJson2.name;
+  const widths = columns.map((col) => {
+    const maxDataWidth = Math.max(
+      ...data.map((row) => String(row[col.key] || "").length)
+    );
+    const headerWidth = col.header.length;
+    return col.width || Math.max(maxDataWidth, headerWidth, 10);
+  });
+  const createRow = (values, bold = false) => {
+    const cells = values.map((val, i) => {
+      const padded = val.padEnd(widths[i]);
+      return bold ? source_default.bold(padded) : padded;
+    });
+    return `\u2502 ${cells.join(" \u2502 ")} \u2502`;
+  };
+  const separator = (char) => {
+    const parts = widths.map((w) => char.repeat(w + 2));
+    if (char === "\u2500") {
+      return `\u251C${parts.join("\u253C")}\u2524`;
     }
-  } catch {
-  }
-  return import_node_path3.default.basename(cwd);
+    return `\u2514${parts.join("\u2534")}\u2518`;
+  };
+  const lines = [];
+  lines.push(`\u250C${widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C")}\u2510`);
+  lines.push(
+    createRow(
+      columns.map((c) => c.header),
+      true
+    )
+  );
+  lines.push(separator("\u2500"));
+  data.forEach((row) => {
+    lines.push(createRow(columns.map((c) => String(row[c.key] || ""))));
+  });
+  lines.push(separator("\u2500"));
+  return lines.join("\n");
 }
-async function detectBuildCommand(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
-    const content = await import_node_fs5.promises.readFile(packageJsonPath, "utf-8");
-    const packageJson2 = JSON.parse(content);
-    if (packageJson2.scripts?.build) {
-      return "npm run build";
-    }
-  } catch {
+function formatJson(data, pretty = true) {
+  if (pretty) {
+    return JSON.stringify(data, null, 2);
   }
-  return void 0;
+  return JSON.stringify(data);
 }
-async function detectStartCommand(cwd = process.cwd()) {
-  try {
-    const packageJsonPath = import_node_path3.default.join(cwd, "package.json");
-    const content = await import_node_fs5.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 {
+function formatToolCall(result) {
+  const lines = [];
+  if (result.isError) {
+    lines.push(source_default.red("\u2717 Tool execution failed"));
+    lines.push("");
+  } else {
+    lines.push(source_default.green("\u2713 Tool executed successfully"));
+    lines.push("");
   }
-  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_fs5.promises.access(import_node_path3.default.join(cwd, file));
-        return "python";
-      } catch {
-        continue;
+  if (result.content && result.content.length > 0) {
+    result.content.forEach((item, index) => {
+      if (result.content.length > 1) {
+        lines.push(source_default.bold(`Content ${index + 1}:`));
       }
-    }
-    try {
-      await import_node_fs5.promises.access(import_node_path3.default.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");
+      if (item.type === "text") {
+        lines.push(item.text);
+      } else if (item.type === "image") {
+        lines.push(source_default.cyan(`[Image: ${item.mimeType || "unknown type"}]`));
+        if (item.data) {
+          lines.push(source_default.gray(`Data: ${item.data.substring(0, 50)}...`));
+        }
+      } else if (item.type === "resource") {
+        lines.push(source_default.cyan(`[Resource]`));
+        if (item.resource?.uri) {
+          lines.push(source_default.gray(`URI: ${item.resource.uri}`));
+        }
+        if (item.resource && "text" in item.resource && item.resource.text) {
+          lines.push(item.resource.text);
+        }
       } else {
-        resolve(trimmedAnswer === "y" || trimmedAnswer === "yes");
+        lines.push(source_default.gray(`[Unknown content type: ${item.type}]`));
+      }
+      if (index < result.content.length - 1) {
+        lines.push("");
       }
     });
-  });
-}
-async function createTarball(cwd) {
-  const tmpDir = import_node_os4.default.tmpdir();
-  const tarballPath = import_node_path3.default.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"}`
-    );
   }
+  return lines.join("\n");
 }
-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);
+function formatResourceContent(content) {
+  if (!content || !content.contents) {
+    return source_default.gray("No content");
+  }
+  const lines = [];
+  content.contents.forEach((item, index) => {
+    if (content.contents.length > 1) {
+      lines.push(source_default.bold(`Content ${index + 1}:`));
     }
-    process.stdout.write("\r\x1B[K");
-    spinnerInterval = setInterval(() => {
-      const frame = frames[frameIndex];
-      frameIndex = (frameIndex + 1) % frames.length;
-      process.stdout.write(
-        "\r" + source_default.cyan(frame) + " " + source_default.gray(message)
-      );
-    }, 80);
-  };
-  const stopSpinner = () => {
-    if (spinnerInterval) {
-      clearInterval(spinnerInterval);
-      spinnerInterval = null;
-      process.stdout.write("\r\x1B[K");
+    if (item.uri) {
+      lines.push(source_default.gray(`URI: ${item.uri}`));
     }
-  };
-  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" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
-          const stepPrefix = logData.step ? source_default.cyan(`[${logData.step}]`) + " " : "";
-          console.log(stepPrefix + levelColor(logData.line));
-        }
-      } catch {
-      }
+    if (item.mimeType) {
+      lines.push(source_default.gray(`Type: ${item.mimeType}`));
     }
-  } catch (error) {
-    stopSpinner();
+    if ("text" in item && item.text) {
+      lines.push("");
+      lines.push(item.text);
+    } else if ("blob" in item && item.blob) {
+      lines.push("");
+      lines.push(source_default.cyan(`[Binary data: ${item.blob.length} bytes]`));
+    }
+    if (index < content.contents.length - 1) {
+      lines.push("");
+      lines.push(source_default.gray("\u2500".repeat(50)));
+      lines.push("");
+    }
+  });
+  return lines.join("\n");
+}
+function formatSchema(schema, indent = 0) {
+  if (!schema) {
+    return source_default.gray("No schema");
   }
-  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" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
-            const stepPrefix = logData.step ? source_default.cyan(`[${logData.step}]`) + " " : "";
-            console.log(stepPrefix + levelColor(logData.line));
-          }
-        } catch {
+  const lines = [];
+  const pad = "  ".repeat(indent);
+  if (schema.type === "object" && schema.properties) {
+    Object.entries(schema.properties).forEach(([key, value]) => {
+      const required = schema.required?.includes(key);
+      const type = value.type || "any";
+      const desc = value.description || "";
+      const keyStr = required ? source_default.bold(key) : key;
+      const typeStr = source_default.cyan(`(${type})`);
+      const requiredStr = required ? source_default.red(" *required") : "";
+      lines.push(`${pad}${keyStr} ${typeStr}${requiredStr}`);
+      if (desc) {
+        lines.push(`${pad}  ${source_default.gray(desc)}`);
+      }
+      if (value.type === "object" && value.properties) {
+        lines.push(formatSchema(value, indent + 1));
+      }
+      if (value.type === "array" && value.items) {
+        lines.push(`${pad}  ${source_default.gray("Items:")}`);
+        if (value.items.type === "object") {
+          lines.push(formatSchema(value.items, indent + 2));
+        } else {
+          lines.push(
+            `${pad}    ${source_default.cyan(`(${value.items.type || "any"})`)}`
+          );
         }
       }
-      lastDisplayedLogLength = finalDeployment.buildLogs.length;
+    });
+  } else {
+    lines.push(`${pad}${source_default.cyan(`Type: ${schema.type || "any"}`)}`);
+    if (schema.description) {
+      lines.push(`${pad}${source_default.gray(schema.description)}`);
     }
-    if (finalDeployment.status === "running") {
-      const mcpUrl = `https://${finalDeployment.domain}/mcp`;
-      const inspectorUrl = `https://inspector.mcp-use.com/inspector?autoConnect=${encodeURIComponent(mcpUrl)}`;
-      console.log(source_default.green.bold("\u2713 Deployment successful!\n"));
-      console.log(source_default.white("\u{1F310} MCP Server URL:"));
-      console.log(source_default.cyan.bold(`   ${mcpUrl}
-`));
-      console.log(source_default.white("\u{1F50D} Inspector URL:"));
-      console.log(source_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(source_default.white("\u{1F517} Custom Domain:"));
-        console.log(source_default.cyan.bold(`   ${customMcpUrl}
-`));
-        console.log(source_default.white("\u{1F50D} Custom Inspector:"));
-        console.log(source_default.cyan.bold(`   ${customInspectorUrl}
-`));
-      }
-      console.log(
-        source_default.gray("Deployment ID: ") + source_default.white(finalDeployment.id)
-      );
-      return;
-    } else if (finalDeployment.status === "failed") {
-      console.log(source_default.red.bold("\u2717 Deployment failed\n"));
-      if (finalDeployment.error) {
-        console.log(source_default.red("Error: ") + finalDeployment.error);
-      }
-      if (finalDeployment.buildLogs) {
-        console.log(source_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(source_default.gray(`  ${logData.line}`));
-              }
-            } catch {
-              console.log(source_default.gray(`  ${log}`));
-            }
-          }
-        } catch {
-          console.log(source_default.gray(finalDeployment.buildLogs));
+  }
+  return lines.join("\n");
+}
+function formatError(error) {
+  const message = typeof error === "string" ? error : error.message;
+  return source_default.red(`\u2717 Error: ${message}`);
+}
+function formatSuccess(message) {
+  return source_default.green(`\u2713 ${message}`);
+}
+function formatInfo(message) {
+  return source_default.cyan(message);
+}
+function formatWarning(message) {
+  return source_default.yellow(`\u26A0 ${message}`);
+}
+function formatHeader(text) {
+  return source_default.bold.white(text);
+}
+function formatKeyValue(pairs) {
+  const maxKeyLength = Math.max(...Object.keys(pairs).map((k) => k.length), 0);
+  return Object.entries(pairs).map(([key, value]) => {
+    const paddedKey = key.padEnd(maxKeyLength);
+    return `  ${source_default.gray(paddedKey)}: ${value}`;
+  }).join("\n");
+}
+function formatRelativeTime(dateString) {
+  const date = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  const diffWeeks = Math.floor(diffDays / 7);
+  const diffMonths = Math.floor(diffDays / 30);
+  const diffYears = Math.floor(diffDays / 365);
+  if (diffYears > 0) {
+    return `${diffYears} year${diffYears > 1 ? "s" : ""} ago`;
+  } else if (diffMonths > 0) {
+    return `${diffMonths} month${diffMonths > 1 ? "s" : ""} ago`;
+  } else if (diffWeeks > 0) {
+    return `${diffWeeks} week${diffWeeks > 1 ? "s" : ""} ago`;
+  } else if (diffDays > 0) {
+    return `${diffDays} day${diffDays > 1 ? "s" : ""} ago`;
+  } else if (diffHours > 0) {
+    return `${diffHours} hour${diffHours > 1 ? "s" : ""} ago`;
+  } else if (diffMins > 0) {
+    return `${diffMins} minute${diffMins > 1 ? "s" : ""} ago`;
+  } else {
+    return "just now";
+  }
+}
+function formatPromptMessages(messages) {
+  if (!messages || messages.length === 0) {
+    return source_default.gray("No messages");
+  }
+  const lines = [];
+  messages.forEach((msg, index) => {
+    const role = msg.role || "unknown";
+    const roleStr = role === "user" ? source_default.blue("[User]") : role === "assistant" ? source_default.green("[Assistant]") : source_default.gray(`[${role}]`);
+    lines.push(`${roleStr}`);
+    if (msg.content) {
+      if (typeof msg.content === "string") {
+        lines.push(msg.content);
+      } else if (msg.content.type === "text") {
+        lines.push(msg.content.text);
+      } else if (msg.content.type === "image") {
+        lines.push(source_default.cyan(`[Image: ${msg.content.mimeType}]`));
+      } else if (msg.content.type === "resource") {
+        lines.push(source_default.cyan(`[Resource: ${msg.content.resource?.uri}]`));
+        if (msg.content.resource?.text) {
+          lines.push(msg.content.resource.text);
         }
       }
-      process.exit(1);
-    } else if (finalDeployment.status === "building") {
-      startSpinner("Building and deploying...");
-      checkCount++;
-      delay = Math.min(delay * 1.2, maxDelay);
-    } else {
-      console.log(
-        source_default.yellow("\u26A0\uFE0F  Deployment status: ") + finalDeployment.status
+    }
+    if (index < messages.length - 1) {
+      lines.push("");
+    }
+  });
+  return lines.join("\n");
+}
+
+// src/commands/client.ts
+var activeSessions = /* @__PURE__ */ new Map();
+async function getOrRestoreSession(sessionName) {
+  if (!sessionName) {
+    const active = await getActiveSession();
+    if (!active) {
+      console.error(
+        formatError("No active session. Connect to a server first.")
       );
-      return;
+      console.error(
+        formatInfo("Use: npx mcp-use client connect <url> --name <name>")
+      );
+      return null;
     }
+    sessionName = active.name;
+  }
+  if (activeSessions.has(sessionName)) {
+    const { session } = activeSessions.get(sessionName);
+    return { name: sessionName, session };
+  }
+  const config = await getSession(sessionName);
+  if (!config) {
+    console.error(formatError(`Session '${sessionName}' not found`));
+    return null;
+  }
+  try {
+    const client = new import_client.MCPClient();
+    if (config.type === "http") {
+      client.addServer(sessionName, {
+        url: config.url,
+        headers: config.authToken ? { Authorization: `Bearer ${config.authToken}` } : void 0
+      });
+    } else if (config.type === "stdio") {
+      client.addServer(sessionName, {
+        command: config.command,
+        args: config.args || [],
+        env: config.env
+      });
+    } else {
+      console.error(formatError(`Unknown session type: ${config.type}`));
+      return null;
+    }
+    const session = await client.createSession(sessionName);
+    activeSessions.set(sessionName, { client, session });
+    console.error(formatInfo(`Reconnected to session '${sessionName}'`));
+    return { name: sessionName, session };
+  } catch (error) {
+    console.error(formatError(`Failed to restore session: ${error.message}`));
+    return null;
   }
-  stopSpinner();
-  console.log(source_default.yellow("\u26A0\uFE0F  Deployment is taking longer than expected."));
-  console.log(
-    source_default.gray("Check status with: ") + source_default.white(`mcp-use status ${deployment.id}`)
-  );
 }
-async function deployCommand(options) {
+async function connectCommand(urlOrCommand, options) {
   try {
-    const cwd = process.cwd();
-    if (!await isLoggedIn()) {
-      console.log(source_default.red("\u2717 You are not logged in."));
-      console.log(
-        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+    const sessionName = options.name || `session-${Date.now()}`;
+    const client = new import_client.MCPClient();
+    let session;
+    if (options.stdio) {
+      const parts = urlOrCommand.split(" ");
+      const command = parts[0];
+      const args = parts.slice(1);
+      console.error(
+        formatInfo(`Connecting to stdio server: ${command} ${args.join(" ")}`)
       );
-      process.exit(1);
+      client.addServer(sessionName, {
+        command,
+        args
+      });
+      session = await client.createSession(sessionName);
+      await saveSession(sessionName, {
+        type: "stdio",
+        command,
+        args,
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      console.error(formatInfo(`Connecting to ${urlOrCommand}...`));
+      client.addServer(sessionName, {
+        url: urlOrCommand,
+        headers: options.auth ? { Authorization: `Bearer ${options.auth}` } : void 0
+      });
+      session = await client.createSession(sessionName);
+      await saveSession(sessionName, {
+        type: "http",
+        url: urlOrCommand,
+        authToken: options.auth,
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
-    console.log(source_default.cyan.bold("\u{1F680} Deploying to mcp-use cloud...\n"));
-    const isMcp = await isMcpProject(cwd);
-    if (!isMcp) {
+    activeSessions.set(sessionName, { client, session });
+    const serverInfo = session.serverInfo;
+    const capabilities = session.serverCapabilities;
+    if (serverInfo) {
+      await updateSessionInfo(sessionName, serverInfo, capabilities);
+    }
+    console.log(formatSuccess(`Connected to ${sessionName}`));
+    if (serverInfo) {
+      console.log("");
+      console.log(formatHeader("Server Information:"));
       console.log(
-        source_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(
-        source_default.white("Continue anyway? (y/n): ")
+        formatKeyValue({
+          Name: serverInfo.name,
+          Version: serverInfo.version || "unknown"
+        })
       );
-      if (!shouldContinue) {
-        console.log(source_default.gray("Deployment cancelled."));
-        process.exit(0);
+    }
+    if (capabilities) {
+      console.log("");
+      console.log(formatHeader("Capabilities:"));
+      const caps = Object.keys(capabilities).join(", ");
+      console.log(`  ${caps || "none"}`);
+    }
+    const tools = session.tools;
+    console.log("");
+    console.log(
+      formatInfo(
+        `Available: ${tools.length} tool${tools.length !== 1 ? "s" : ""}`
+      )
+    );
+  } catch (error) {
+    console.error(formatError(`Connection failed: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function disconnectCommand(sessionName, options) {
+  try {
+    if (options?.all) {
+      for (const [name, { client }] of activeSessions.entries()) {
+        await client.closeAllSessions();
+        activeSessions.delete(name);
+        console.log(formatSuccess(`Disconnected from ${name}`));
       }
-      console.log();
+      return;
     }
-    const gitInfo = await getGitInfo(cwd);
-    if (!options.fromSource && gitInfo.isGitRepo && gitInfo.remoteUrl && isGitHubUrl(gitInfo.remoteUrl)) {
-      if (!gitInfo.owner || !gitInfo.repo) {
-        console.log(
-          source_default.red(
-            "\u2717 Could not parse GitHub repository information from remote URL."
-          )
-        );
-        process.exit(1);
-      }
-      console.log(source_default.white("GitHub repository detected:"));
-      console.log(
-        source_default.gray(`  Repository: `) + source_default.cyan(`${gitInfo.owner}/${gitInfo.repo}`)
-      );
-      console.log(
-        source_default.gray(`  Branch:     `) + source_default.cyan(gitInfo.branch || "main")
-      );
-      if (gitInfo.commitSha) {
-        console.log(
-          source_default.gray(`  Commit:     `) + source_default.gray(gitInfo.commitSha.substring(0, 7))
-        );
-      }
-      if (gitInfo.commitMessage) {
-        console.log(
-          source_default.gray(`  Message:    `) + source_default.gray(gitInfo.commitMessage.split("\n")[0])
-        );
-      }
-      console.log();
-      const shouldDeploy = await prompt(
-        source_default.white(
-          `Deploy from GitHub repository ${gitInfo.owner}/${gitInfo.repo}? (y/n): `
-        )
-      );
-      if (!shouldDeploy) {
-        console.log(source_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(source_default.white("Deployment configuration:"));
-      console.log(source_default.gray(`  Name:          `) + source_default.cyan(projectName));
-      console.log(source_default.gray(`  Runtime:       `) + source_default.cyan(runtime));
-      console.log(source_default.gray(`  Port:          `) + source_default.cyan(port));
-      if (buildCommand) {
-        console.log(source_default.gray(`  Build command: `) + source_default.cyan(buildCommand));
-      }
-      if (startCommand) {
-        console.log(source_default.gray(`  Start command: `) + source_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(source_default.gray("Creating deployment..."));
-      const api = await McpUseAPI.create();
-      const deployment = await api.createDeployment(deploymentRequest);
-      console.log(
-        source_default.green("\u2713 Deployment created: ") + source_default.gray(deployment.id)
-      );
-      await displayDeploymentProgress(api, deployment);
-      if (options.open && deployment.domain) {
-        console.log();
-        console.log(source_default.gray("Opening deployment in browser..."));
-        await open_default(`https://${deployment.domain}`);
+    if (!sessionName) {
+      const active = await getActiveSession();
+      if (!active) {
+        console.error(formatError("No active session to disconnect"));
+        return;
       }
+      sessionName = active.name;
+    }
+    const sessionData = activeSessions.get(sessionName);
+    if (sessionData) {
+      await sessionData.client.closeAllSessions();
+      activeSessions.delete(sessionName);
+      console.log(formatSuccess(`Disconnected from ${sessionName}`));
     } else {
-      if (options.fromSource) {
-        console.log(
-          source_default.white("\u{1F4E6} Deploying from local source code (--from-source)...")
-        );
-      } else {
-        console.log(
-          source_default.yellow(
-            "\u26A0\uFE0F  This is not a GitHub repository or no remote is configured."
-          )
-        );
-        console.log(source_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(source_default.white("Deployment configuration:"));
-      console.log(source_default.gray(`  Name:          `) + source_default.cyan(projectName));
-      console.log(source_default.gray(`  Runtime:       `) + source_default.cyan(runtime));
-      console.log(source_default.gray(`  Port:          `) + source_default.cyan(port));
-      if (buildCommand) {
-        console.log(source_default.gray(`  Build command: `) + source_default.cyan(buildCommand));
-      }
-      if (startCommand) {
-        console.log(source_default.gray(`  Start command: `) + source_default.cyan(startCommand));
-      }
-      console.log();
-      const shouldDeploy = await prompt(
-        source_default.white("Deploy from local source? (y/n): "),
-        "y"
-      );
-      if (!shouldDeploy) {
-        console.log(source_default.gray("Deployment cancelled."));
-        process.exit(0);
-      }
-      console.log();
-      console.log(source_default.gray("Packaging source code..."));
-      const tarballPath = await createTarball(cwd);
-      const stats = await import_node_fs5.promises.stat(tarballPath);
-      console.log(
-        source_default.green("\u2713 Packaged: ") + source_default.gray(formatFileSize(stats.size))
-      );
-      const maxSize = 2 * 1024 * 1024;
-      if (stats.size > maxSize) {
-        console.log(
-          source_default.red(
-            `\u2717 File size (${formatFileSize(stats.size)}) exceeds maximum of 2MB`
-          )
-        );
-        await import_node_fs5.promises.unlink(tarballPath);
-        process.exit(1);
-      }
-      const deploymentRequest = {
-        name: projectName,
-        source: {
-          type: "upload",
-          runtime,
-          port,
-          buildCommand,
-          startCommand
-        },
-        healthCheckPath: "/healthz"
-      };
-      console.log(source_default.gray("Creating deployment..."));
-      const api = await McpUseAPI.create();
-      const deployment = await api.createDeploymentWithUpload(
-        deploymentRequest,
-        tarballPath
-      );
-      await import_node_fs5.promises.unlink(tarballPath);
+      console.log(formatInfo(`Session '${sessionName}' is not connected`));
+    }
+  } catch (error) {
+    console.error(formatError(`Failed to disconnect: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function listSessionsCommand() {
+  try {
+    const sessions = await listAllSessions();
+    if (sessions.length === 0) {
+      console.log(formatInfo("No saved sessions"));
       console.log(
-        source_default.green("\u2713 Deployment created: ") + source_default.gray(deployment.id)
+        formatInfo("Connect to a server with: npx mcp-use client connect <url>")
       );
-      await displayDeploymentProgress(api, deployment);
-      if (options.open && deployment.domain) {
-        console.log();
-        console.log(source_default.gray("Opening deployment in browser..."));
-        await open_default(`https://${deployment.domain}`);
-      }
+      return;
     }
-  } catch (error) {
-    console.error(
-      source_default.red.bold("\n\u2717 Deployment failed:"),
-      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    console.log(formatHeader("Saved Sessions:"));
+    console.log("");
+    const tableData = sessions.map((s) => ({
+      name: s.isActive ? source_default.green.bold(`${s.name} *`) : s.name,
+      type: s.config.type,
+      target: s.config.type === "http" ? s.config.url || "" : `${s.config.command} ${(s.config.args || []).join(" ")}`,
+      server: s.config.serverInfo?.name || "unknown",
+      status: activeSessions.has(s.name) ? source_default.green("connected") : source_default.gray("disconnected")
+    }));
+    console.log(
+      formatTable(tableData, [
+        { key: "name", header: "Name" },
+        { key: "type", header: "Type" },
+        { key: "target", header: "Target", width: 40 },
+        { key: "server", header: "Server" },
+        { key: "status", header: "Status" }
+      ])
     );
+    console.log("");
+    console.log(source_default.gray("* = active session"));
+  } catch (error) {
+    console.error(formatError(`Failed to list sessions: ${error.message}`));
     process.exit(1);
   }
 }
-
-// src/commands/client.ts
-var import_commander = require("commander");
-var import_node_readline = require("readline");
-var import_client = require("mcp-use/client");
-
-// src/utils/session-storage.ts
-var import_node_os5 = require("os");
-var import_node_path4 = require("path");
-var import_promises4 = require("fs/promises");
-var import_node_fs6 = require("fs");
-var SESSION_FILE_PATH = (0, import_node_path4.join)((0, import_node_os5.homedir)(), ".mcp-use", "cli-sessions.json");
-async function ensureSessionDir() {
-  const dir = (0, import_node_path4.join)((0, import_node_os5.homedir)(), ".mcp-use");
-  if (!(0, import_node_fs6.existsSync)(dir)) {
-    await (0, import_promises4.mkdir)(dir, { recursive: true });
+async function switchSessionCommand(name) {
+  try {
+    await setActiveSession(name);
+    console.log(formatSuccess(`Switched to session '${name}'`));
+  } catch (error) {
+    console.error(formatError(`Failed to switch session: ${error.message}`));
+    process.exit(1);
   }
 }
-async function loadSessions() {
+async function listToolsCommand(options) {
   try {
-    await ensureSessionDir();
-    if (!(0, import_node_fs6.existsSync)(SESSION_FILE_PATH)) {
-      return { activeSession: null, sessions: {} };
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    const tools = await session.listTools();
+    if (options.json) {
+      console.log(formatJson(tools));
+      return;
     }
-    const content = await (0, import_promises4.readFile)(SESSION_FILE_PATH, "utf-8");
-    return JSON.parse(content);
+    if (tools.length === 0) {
+      console.log(formatInfo("No tools available"));
+      return;
+    }
+    console.log(formatHeader(`Available Tools (${tools.length}):`));
+    console.log("");
+    const tableData = tools.map((tool) => ({
+      name: source_default.bold(tool.name),
+      description: tool.description || source_default.gray("No description")
+    }));
+    console.log(
+      formatTable(tableData, [
+        { key: "name", header: "Tool", width: 25 },
+        { key: "description", header: "Description", width: 50 }
+      ])
+    );
   } catch (error) {
-    return { activeSession: null, sessions: {} };
+    console.error(formatError(`Failed to list tools: ${error.message}`));
+    process.exit(1);
   }
 }
-async function saveSessions(storage) {
-  await ensureSessionDir();
-  await (0, import_promises4.writeFile)(SESSION_FILE_PATH, JSON.stringify(storage, null, 2), "utf-8");
-}
-async function saveSession(name, config) {
-  const storage = await loadSessions();
-  storage.sessions[name] = {
-    ...config,
-    lastUsed: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (!storage.activeSession) {
-    storage.activeSession = name;
+async function describeToolCommand(toolName, options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    const tools = session.tools;
+    const tool = tools.find((t) => t.name === toolName);
+    if (!tool) {
+      console.error(formatError(`Tool '${toolName}' not found`));
+      console.log("");
+      console.log(formatInfo("Available tools:"));
+      tools.forEach((t) => console.log(`  \u2022 ${t.name}`));
+      return;
+    }
+    console.log(formatHeader(`Tool: ${tool.name}`));
+    console.log("");
+    if (tool.description) {
+      console.log(tool.description);
+      console.log("");
+    }
+    if (tool.inputSchema) {
+      console.log(formatHeader("Input Schema:"));
+      console.log(formatSchema(tool.inputSchema));
+    }
+  } catch (error) {
+    console.error(formatError(`Failed to describe tool: ${error.message}`));
+    process.exit(1);
   }
-  await saveSessions(storage);
 }
-async function getActiveSession() {
-  const storage = await loadSessions();
-  if (!storage.activeSession || !storage.sessions[storage.activeSession]) {
-    return null;
+async function callToolCommand(toolName, argsJson, options) {
+  try {
+    const result = await getOrRestoreSession(options?.session || null);
+    if (!result) return;
+    const { session } = result;
+    let args = {};
+    if (argsJson) {
+      try {
+        args = JSON.parse(argsJson);
+      } catch (error) {
+        console.error(formatError("Invalid JSON arguments"));
+        return;
+      }
+    } else {
+      const tools = session.tools;
+      const tool = tools.find((t) => t.name === toolName);
+      if (tool?.inputSchema?.required && tool.inputSchema.required.length > 0) {
+        console.error(
+          formatError(
+            "This tool requires arguments. Provide them as a JSON string."
+          )
+        );
+        console.log("");
+        console.log(formatInfo("Example:"));
+        console.log(
+          `  npx mcp-use client tools call ${toolName} '{"param": "value"}'`
+        );
+        console.log("");
+        console.log(formatInfo("Tool schema:"));
+        console.log(formatSchema(tool.inputSchema));
+        return;
+      }
+    }
+    console.error(formatInfo(`Calling tool '${toolName}'...`));
+    const callResult = await session.callTool(toolName, args, {
+      timeout: options?.timeout
+    });
+    if (options?.json) {
+      console.log(formatJson(callResult));
+    } else {
+      console.log(formatToolCall(callResult));
+    }
+  } catch (error) {
+    console.error(formatError(`Failed to call tool: ${error.message}`));
+    process.exit(1);
   }
-  return {
-    name: storage.activeSession,
-    config: storage.sessions[storage.activeSession]
-  };
-}
-async function getSession(name) {
-  const storage = await loadSessions();
-  return storage.sessions[name] || null;
 }
-async function setActiveSession(name) {
-  const storage = await loadSessions();
-  if (!storage.sessions[name]) {
-    throw new Error(`Session '${name}' not found`);
+async function listResourcesCommand(options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    const resourcesResult = await session.listAllResources();
+    const resources = resourcesResult.resources;
+    if (options.json) {
+      console.log(formatJson(resources));
+      return;
+    }
+    if (resources.length === 0) {
+      console.log(formatInfo("No resources available"));
+      return;
+    }
+    console.log(formatHeader(`Available Resources (${resources.length}):`));
+    console.log("");
+    const tableData = resources.map((resource) => ({
+      uri: resource.uri,
+      name: resource.name || source_default.gray("(no name)"),
+      type: resource.mimeType || source_default.gray("unknown")
+    }));
+    console.log(
+      formatTable(tableData, [
+        { key: "uri", header: "URI", width: 40 },
+        { key: "name", header: "Name", width: 20 },
+        { key: "type", header: "Type", width: 15 }
+      ])
+    );
+  } catch (error) {
+    console.error(formatError(`Failed to list resources: ${error.message}`));
+    process.exit(1);
   }
-  storage.activeSession = name;
-  storage.sessions[name].lastUsed = (/* @__PURE__ */ new Date()).toISOString();
-  await saveSessions(storage);
-}
-async function listAllSessions() {
-  const storage = await loadSessions();
-  return Object.entries(storage.sessions).map(([name, config]) => ({
-    name,
-    config,
-    isActive: name === storage.activeSession
-  }));
 }
-async function updateSessionInfo(name, serverInfo, capabilities) {
-  const storage = await loadSessions();
-  if (storage.sessions[name]) {
-    storage.sessions[name].serverInfo = serverInfo;
-    storage.sessions[name].capabilities = capabilities;
-    storage.sessions[name].lastUsed = (/* @__PURE__ */ new Date()).toISOString();
-    await saveSessions(storage);
+async function readResourceCommand(uri, options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    console.error(formatInfo(`Reading resource: ${uri}`));
+    const resource = await session.readResource(uri);
+    if (options.json) {
+      console.log(formatJson(resource));
+    } else {
+      console.log(formatResourceContent(resource));
+    }
+  } catch (error) {
+    console.error(formatError(`Failed to read resource: ${error.message}`));
+    process.exit(1);
   }
 }
-
-// src/utils/format.ts
-function formatTable(data, columns) {
-  if (data.length === 0) {
-    return source_default.gray("No items found");
-  }
-  const widths = columns.map((col) => {
-    const maxDataWidth = Math.max(
-      ...data.map((row) => String(row[col.key] || "").length)
-    );
-    const headerWidth = col.header.length;
-    return col.width || Math.max(maxDataWidth, headerWidth, 10);
-  });
-  const createRow = (values, bold = false) => {
-    const cells = values.map((val, i) => {
-      const padded = val.padEnd(widths[i]);
-      return bold ? source_default.bold(padded) : padded;
+async function subscribeResourceCommand(uri, options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    await session.subscribeToResource(uri);
+    console.log(formatSuccess(`Subscribed to resource: ${uri}`));
+    session.on("notification", async (notification) => {
+      if (notification.method === "notifications/resources/updated") {
+        console.log("");
+        console.log(formatInfo("Resource updated:"));
+        console.log(formatJson(notification.params));
+      }
     });
-    return `\u2502 ${cells.join(" \u2502 ")} \u2502`;
-  };
-  const separator = (char) => {
-    const parts = widths.map((w) => char.repeat(w + 2));
-    if (char === "\u2500") {
-      return `\u251C${parts.join("\u253C")}\u2524`;
-    }
-    return `\u2514${parts.join("\u2534")}\u2518`;
-  };
-  const lines = [];
-  lines.push(`\u250C${widths.map((w) => "\u2500".repeat(w + 2)).join("\u252C")}\u2510`);
-  lines.push(
-    createRow(
-      columns.map((c) => c.header),
-      true
-    )
-  );
-  lines.push(separator("\u2500"));
-  data.forEach((row) => {
-    lines.push(createRow(columns.map((c) => String(row[c.key] || ""))));
-  });
-  lines.push(separator("\u2500"));
-  return lines.join("\n");
-}
-function formatJson(data, pretty = true) {
-  if (pretty) {
-    return JSON.stringify(data, null, 2);
+    console.log(formatInfo("Listening for updates... (Press Ctrl+C to stop)"));
+    await new Promise(() => {
+    });
+  } catch (error) {
+    console.error(
+      formatError(`Failed to subscribe to resource: ${error.message}`)
+    );
+    process.exit(1);
   }
-  return JSON.stringify(data);
 }
-function formatToolCall(result) {
-  const lines = [];
-  if (result.isError) {
-    lines.push(source_default.red("\u2717 Tool execution failed"));
-    lines.push("");
-  } else {
-    lines.push(source_default.green("\u2713 Tool executed successfully"));
-    lines.push("");
+async function unsubscribeResourceCommand(uri, options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    await session.unsubscribeFromResource(uri);
+    console.log(formatSuccess(`Unsubscribed from resource: ${uri}`));
+  } catch (error) {
+    console.error(
+      formatError(`Failed to unsubscribe from resource: ${error.message}`)
+    );
+    process.exit(1);
   }
-  if (result.content && result.content.length > 0) {
-    result.content.forEach((item, index) => {
-      if (result.content.length > 1) {
-        lines.push(source_default.bold(`Content ${index + 1}:`));
-      }
-      if (item.type === "text") {
-        lines.push(item.text);
-      } else if (item.type === "image") {
-        lines.push(source_default.cyan(`[Image: ${item.mimeType || "unknown type"}]`));
-        if (item.data) {
-          lines.push(source_default.gray(`Data: ${item.data.substring(0, 50)}...`));
-        }
-      } else if (item.type === "resource") {
-        lines.push(source_default.cyan(`[Resource]`));
-        if (item.resource?.uri) {
-          lines.push(source_default.gray(`URI: ${item.resource.uri}`));
-        }
-        if (item.resource && "text" in item.resource && item.resource.text) {
-          lines.push(item.resource.text);
-        }
-      } else {
-        lines.push(source_default.gray(`[Unknown content type: ${item.type}]`));
-      }
-      if (index < result.content.length - 1) {
-        lines.push("");
-      }
-    });
-  }
-  return lines.join("\n");
 }
-function formatResourceContent(content) {
-  if (!content || !content.contents) {
-    return source_default.gray("No content");
-  }
-  const lines = [];
-  content.contents.forEach((item, index) => {
-    if (content.contents.length > 1) {
-      lines.push(source_default.bold(`Content ${index + 1}:`));
-    }
-    if (item.uri) {
-      lines.push(source_default.gray(`URI: ${item.uri}`));
-    }
-    if (item.mimeType) {
-      lines.push(source_default.gray(`Type: ${item.mimeType}`));
-    }
-    if ("text" in item && item.text) {
-      lines.push("");
-      lines.push(item.text);
-    } else if ("blob" in item && item.blob) {
-      lines.push("");
-      lines.push(source_default.cyan(`[Binary data: ${item.blob.length} bytes]`));
-    }
-    if (index < content.contents.length - 1) {
-      lines.push("");
-      lines.push(source_default.gray("\u2500".repeat(50)));
-      lines.push("");
+async function listPromptsCommand(options) {
+  try {
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { session } = result;
+    const promptsResult = await session.listPrompts();
+    const prompts = promptsResult.prompts;
+    if (options.json) {
+      console.log(formatJson(prompts));
+      return;
     }
-  });
-  return lines.join("\n");
-}
-function formatSchema(schema, indent = 0) {
-  if (!schema) {
-    return source_default.gray("No schema");
-  }
-  const lines = [];
-  const pad = "  ".repeat(indent);
-  if (schema.type === "object" && schema.properties) {
-    Object.entries(schema.properties).forEach(([key, value]) => {
-      const required = schema.required?.includes(key);
-      const type = value.type || "any";
-      const desc = value.description || "";
-      const keyStr = required ? source_default.bold(key) : key;
-      const typeStr = source_default.cyan(`(${type})`);
-      const requiredStr = required ? source_default.red(" *required") : "";
-      lines.push(`${pad}${keyStr} ${typeStr}${requiredStr}`);
-      if (desc) {
-        lines.push(`${pad}  ${source_default.gray(desc)}`);
-      }
-      if (value.type === "object" && value.properties) {
-        lines.push(formatSchema(value, indent + 1));
-      }
-      if (value.type === "array" && value.items) {
-        lines.push(`${pad}  ${source_default.gray("Items:")}`);
-        if (value.items.type === "object") {
-          lines.push(formatSchema(value.items, indent + 2));
-        } else {
-          lines.push(
-            `${pad}    ${source_default.cyan(`(${value.items.type || "any"})`)}`
-          );
-        }
-      }
-    });
-  } else {
-    lines.push(`${pad}${source_default.cyan(`Type: ${schema.type || "any"}`)}`);
-    if (schema.description) {
-      lines.push(`${pad}${source_default.gray(schema.description)}`);
+    if (prompts.length === 0) {
+      console.log(formatInfo("No prompts available"));
+      return;
     }
+    console.log(formatHeader(`Available Prompts (${prompts.length}):`));
+    console.log("");
+    const tableData = prompts.map((prompt3) => ({
+      name: source_default.bold(prompt3.name),
+      description: prompt3.description || source_default.gray("No description")
+    }));
+    console.log(
+      formatTable(tableData, [
+        { key: "name", header: "Prompt", width: 25 },
+        { key: "description", header: "Description", width: 50 }
+      ])
+    );
+  } catch (error) {
+    console.error(formatError(`Failed to list prompts: ${error.message}`));
+    process.exit(1);
   }
-  return lines.join("\n");
-}
-function formatError(error) {
-  const message = typeof error === "string" ? error : error.message;
-  return source_default.red(`\u2717 Error: ${message}`);
-}
-function formatSuccess(message) {
-  return source_default.green(`\u2713 ${message}`);
-}
-function formatInfo(message) {
-  return source_default.cyan(message);
-}
-function formatWarning(message) {
-  return source_default.yellow(`\u26A0 ${message}`);
-}
-function formatHeader(text) {
-  return source_default.bold.white(text);
-}
-function formatKeyValue(pairs) {
-  const maxKeyLength = Math.max(...Object.keys(pairs).map((k) => k.length), 0);
-  return Object.entries(pairs).map(([key, value]) => {
-    const paddedKey = key.padEnd(maxKeyLength);
-    return `  ${source_default.gray(paddedKey)}: ${value}`;
-  }).join("\n");
 }
-function formatPromptMessages(messages) {
-  if (!messages || messages.length === 0) {
-    return source_default.gray("No messages");
-  }
-  const lines = [];
-  messages.forEach((msg, index) => {
-    const role = msg.role || "unknown";
-    const roleStr = role === "user" ? source_default.blue("[User]") : role === "assistant" ? source_default.green("[Assistant]") : source_default.gray(`[${role}]`);
-    lines.push(`${roleStr}`);
-    if (msg.content) {
-      if (typeof msg.content === "string") {
-        lines.push(msg.content);
-      } else if (msg.content.type === "text") {
-        lines.push(msg.content.text);
-      } else if (msg.content.type === "image") {
-        lines.push(source_default.cyan(`[Image: ${msg.content.mimeType}]`));
-      } else if (msg.content.type === "resource") {
-        lines.push(source_default.cyan(`[Resource: ${msg.content.resource?.uri}]`));
-        if (msg.content.resource?.text) {
-          lines.push(msg.content.resource.text);
-        }
+async function getPromptCommand(promptName, argsJson, options) {
+  try {
+    const result = await getOrRestoreSession(options?.session || null);
+    if (!result) return;
+    const { session } = result;
+    let args = {};
+    if (argsJson) {
+      try {
+        args = JSON.parse(argsJson);
+      } catch (error) {
+        console.error(formatError("Invalid JSON arguments"));
+        return;
       }
     }
-    if (index < messages.length - 1) {
-      lines.push("");
-    }
-  });
-  return lines.join("\n");
-}
-
-// src/commands/client.ts
-var activeSessions = /* @__PURE__ */ new Map();
-async function getOrRestoreSession(sessionName) {
-  if (!sessionName) {
-    const active = await getActiveSession();
-    if (!active) {
-      console.error(
-        formatError("No active session. Connect to a server first.")
-      );
-      console.error(
-        formatInfo("Use: npx mcp-use client connect <url> --name <name>")
-      );
-      return null;
-    }
-    sessionName = active.name;
-  }
-  if (activeSessions.has(sessionName)) {
-    const { session } = activeSessions.get(sessionName);
-    return { name: sessionName, session };
-  }
-  const config = await getSession(sessionName);
-  if (!config) {
-    console.error(formatError(`Session '${sessionName}' not found`));
-    return null;
-  }
-  try {
-    const client = new import_client.MCPClient();
-    if (config.type === "http") {
-      client.addServer(sessionName, {
-        url: config.url,
-        headers: config.authToken ? { Authorization: `Bearer ${config.authToken}` } : void 0
-      });
-    } else if (config.type === "stdio") {
-      client.addServer(sessionName, {
-        command: config.command,
-        args: config.args || [],
-        env: config.env
-      });
+    console.error(formatInfo(`Getting prompt '${promptName}'...`));
+    const prompt3 = await session.getPrompt(promptName, args);
+    if (options?.json) {
+      console.log(formatJson(prompt3));
     } else {
-      console.error(formatError(`Unknown session type: ${config.type}`));
-      return null;
+      console.log(formatHeader(`Prompt: ${promptName}`));
+      console.log("");
+      if (prompt3.description) {
+        console.log(prompt3.description);
+        console.log("");
+      }
+      if (prompt3.messages) {
+        console.log(formatHeader("Messages:"));
+        console.log("");
+        console.log(formatPromptMessages(prompt3.messages));
+      }
     }
-    const session = await client.createSession(sessionName);
-    activeSessions.set(sessionName, { client, session });
-    console.error(formatInfo(`Reconnected to session '${sessionName}'`));
-    return { name: sessionName, session };
   } catch (error) {
-    console.error(formatError(`Failed to restore session: ${error.message}`));
-    return null;
+    console.error(formatError(`Failed to get prompt: ${error.message}`));
+    process.exit(1);
   }
 }
-async function connectCommand(urlOrCommand, options) {
+async function interactiveCommand(options) {
   try {
-    const sessionName = options.name || `session-${Date.now()}`;
-    const client = new import_client.MCPClient();
-    let session;
-    if (options.stdio) {
-      const parts = urlOrCommand.split(" ");
-      const command = parts[0];
-      const args = parts.slice(1);
-      console.error(
-        formatInfo(`Connecting to stdio server: ${command} ${args.join(" ")}`)
+    const result = await getOrRestoreSession(options.session || null);
+    if (!result) return;
+    const { name: sessionName, session } = result;
+    console.log(formatHeader("MCP Interactive Mode"));
+    console.log("");
+    console.log(formatInfo(`Connected to: ${sessionName}`));
+    console.log("");
+    console.log(source_default.gray("Commands:"));
+    console.log(source_default.gray("  tools list              - List available tools"));
+    console.log(
+      source_default.gray(
+        "  tools call <name>       - Call a tool (will prompt for args)"
+      )
+    );
+    console.log(source_default.gray("  tools describe <name>   - Show tool details"));
+    console.log(
+      source_default.gray("  resources list          - List available resources")
+    );
+    console.log(source_default.gray("  resources read <uri>    - Read a resource"));
+    console.log(
+      source_default.gray("  prompts list            - List available prompts")
+    );
+    console.log(source_default.gray("  prompts get <name>      - Get a prompt"));
+    console.log(source_default.gray("  sessions list           - List all sessions"));
+    console.log(
+      source_default.gray("  sessions switch <name>  - Switch to another session")
+    );
+    console.log(
+      source_default.gray("  exit, quit              - Exit interactive mode")
+    );
+    console.log("");
+    const rl = (0, import_node_readline.createInterface)({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: source_default.cyan("mcp> ")
+    });
+    rl.prompt();
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        rl.prompt();
+        return;
+      }
+      if (trimmed === "exit" || trimmed === "quit") {
+        console.log(formatInfo("Goodbye!"));
+        rl.close();
+        process.exit(0);
+      }
+      const parts = trimmed.split(" ");
+      const scope = parts[0];
+      const command = parts[1];
+      const arg = parts[2];
+      try {
+        if (scope === "tools") {
+          if (command === "list") {
+            const tools = await session.listTools();
+            console.log(
+              formatInfo(
+                `Available tools: ${tools.map((t) => t.name).join(", ")}`
+              )
+            );
+          } else if (command === "call" && arg) {
+            rl.question(
+              "Arguments (JSON, or press Enter for none): ",
+              async (argsInput) => {
+                try {
+                  const args = argsInput.trim() ? JSON.parse(argsInput) : {};
+                  const result2 = await session.callTool(arg, args);
+                  console.log(formatToolCall(result2));
+                } catch (error) {
+                  console.error(formatError(error.message));
+                }
+                rl.prompt();
+              }
+            );
+            return;
+          } else if (command === "describe" && arg) {
+            const tools = session.tools;
+            const tool = tools.find((t) => t.name === arg);
+            if (tool) {
+              console.log(formatHeader(`Tool: ${tool.name}`));
+              if (tool.description) console.log(tool.description);
+              if (tool.inputSchema) {
+                console.log("");
+                console.log(formatSchema(tool.inputSchema));
+              }
+            } else {
+              console.error(formatError(`Tool '${arg}' not found`));
+            }
+          } else {
+            console.error(
+              formatError(
+                "Invalid command. Try: tools list, tools call <name>, tools describe <name>"
+              )
+            );
+          }
+        } else if (scope === "resources") {
+          if (command === "list") {
+            const result2 = await session.listAllResources();
+            const resources = result2.resources;
+            console.log(
+              formatInfo(
+                `Available resources: ${resources.map((r) => r.uri).join(", ")}`
+              )
+            );
+          } else if (command === "read" && arg) {
+            const resource = await session.readResource(arg);
+            console.log(formatResourceContent(resource));
+          } else {
+            console.error(
+              formatError(
+                "Invalid command. Try: resources list, resources read <uri>"
+              )
+            );
+          }
+        } else if (scope === "prompts") {
+          if (command === "list") {
+            const result2 = await session.listPrompts();
+            const prompts = result2.prompts;
+            console.log(
+              formatInfo(
+                `Available prompts: ${prompts.map((p) => p.name).join(", ")}`
+              )
+            );
+          } else if (command === "get" && arg) {
+            rl.question(
+              "Arguments (JSON, or press Enter for none): ",
+              async (argsInput) => {
+                try {
+                  const args = argsInput.trim() ? JSON.parse(argsInput) : {};
+                  const prompt3 = await session.getPrompt(arg, args);
+                  console.log(formatPromptMessages(prompt3.messages));
+                } catch (error) {
+                  console.error(formatError(error.message));
+                }
+                rl.prompt();
+              }
+            );
+            return;
+          } else {
+            console.error(
+              formatError(
+                "Invalid command. Try: prompts list, prompts get <name>"
+              )
+            );
+          }
+        } else if (scope === "sessions") {
+          if (command === "list") {
+            await listSessionsCommand();
+          } else if (command === "switch" && arg) {
+            console.log(
+              formatWarning(
+                "Session switching in interactive mode will be available in a future version"
+              )
+            );
+          } else {
+            console.error(formatError("Invalid command. Try: sessions list"));
+          }
+        } else {
+          console.error(
+            formatError(
+              "Unknown command. Type a valid scope: tools, resources, prompts, sessions"
+            )
+          );
+        }
+      } catch (error) {
+        console.error(formatError(error.message));
+      }
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      console.log("");
+      console.log(formatInfo("Goodbye!"));
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error(
+      formatError(`Failed to start interactive mode: ${error.message}`)
+    );
+    process.exit(1);
+  }
+}
+function createClientCommand() {
+  const clientCommand = new import_commander.Command("client").description(
+    "Interactive MCP client for terminal usage"
+  );
+  clientCommand.command("connect <url>").description("Connect to an MCP server").option("--name <name>", "Session name").option("--stdio", "Use stdio connector instead of HTTP").option("--auth <token>", "Authentication token").action(connectCommand);
+  clientCommand.command("disconnect [session]").description("Disconnect from a session").option("--all", "Disconnect all sessions").action(disconnectCommand);
+  const sessionsCommand = new import_commander.Command("sessions").description(
+    "Manage CLI sessions"
+  );
+  sessionsCommand.command("list").description("List all saved sessions").action(listSessionsCommand);
+  sessionsCommand.command("switch <name>").description("Switch to a different session").action(switchSessionCommand);
+  clientCommand.addCommand(sessionsCommand);
+  const toolsCommand = new import_commander.Command("tools").description(
+    "Interact with MCP tools"
+  );
+  toolsCommand.command("list").description("List available tools").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listToolsCommand);
+  toolsCommand.command("call <name> [args]").description("Call a tool with arguments (JSON string)").option("--session <name>", "Use specific session").option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--json", "Output as JSON").action(callToolCommand);
+  toolsCommand.command("describe <name>").description("Show tool details and schema").option("--session <name>", "Use specific session").action(describeToolCommand);
+  clientCommand.addCommand(toolsCommand);
+  const resourcesCommand = new import_commander.Command("resources").description(
+    "Interact with MCP resources"
+  );
+  resourcesCommand.command("list").description("List available resources").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listResourcesCommand);
+  resourcesCommand.command("read <uri>").description("Read a resource by URI").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(readResourceCommand);
+  resourcesCommand.command("subscribe <uri>").description("Subscribe to resource updates").option("--session <name>", "Use specific session").action(subscribeResourceCommand);
+  resourcesCommand.command("unsubscribe <uri>").description("Unsubscribe from resource updates").option("--session <name>", "Use specific session").action(unsubscribeResourceCommand);
+  clientCommand.addCommand(resourcesCommand);
+  const promptsCommand = new import_commander.Command("prompts").description(
+    "Interact with MCP prompts"
+  );
+  promptsCommand.command("list").description("List available prompts").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listPromptsCommand);
+  promptsCommand.command("get <name> [args]").description("Get a prompt with arguments (JSON string)").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(getPromptCommand);
+  clientCommand.addCommand(promptsCommand);
+  clientCommand.command("interactive").description("Start interactive REPL mode").option("--session <name>", "Use specific session").action(interactiveCommand);
+  return clientCommand;
+}
+
+// src/commands/deploy.ts
+var import_node_child_process9 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_util8 = require("util");
+
+// src/utils/git.ts
+var import_node_child_process8 = require("child_process");
+var import_node_util7 = require("util");
+var execAsync = (0, import_node_util7.promisify)(import_node_child_process8.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) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.hostname === "github.com" || parsedUrl.hostname === "www.github.com";
+  } catch {
+    const sshMatch = url.match(/^git@([^:/]+)[:/]/);
+    if (sshMatch) {
+      const host = sshMatch[1];
+      return host === "github.com" || host === "www.github.com";
+    }
+  }
+  return false;
+}
+
+// src/utils/project-link.ts
+var import_node_fs6 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var MCP_USE_DIR = ".mcp-use";
+var MCP_USE_DIR_PROJECT = "project.json";
+function getMcpUseDirectory(cwd) {
+  return import_node_path4.default.join(cwd, MCP_USE_DIR);
+}
+async function getProjectLink(cwd) {
+  try {
+    const linkPath = import_node_path4.default.join(getMcpUseDirectory(cwd), MCP_USE_DIR_PROJECT);
+    const content = await import_node_fs6.promises.readFile(linkPath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function saveProjectLink(cwd, link) {
+  const mcpUseDir = getMcpUseDirectory(cwd);
+  await import_node_fs6.promises.mkdir(mcpUseDir, { recursive: true });
+  const linkPath = import_node_path4.default.join(mcpUseDir, MCP_USE_DIR_PROJECT);
+  await import_node_fs6.promises.writeFile(linkPath, JSON.stringify(link, null, 2), "utf-8");
+  await addToGitIgnore(cwd);
+}
+async function addToGitIgnore(cwd) {
+  const gitignorePath = import_node_path4.default.join(cwd, ".gitignore");
+  try {
+    let content = "";
+    try {
+      content = await import_node_fs6.promises.readFile(gitignorePath, "utf-8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    if (!content.includes(MCP_USE_DIR)) {
+      const newContent = content + (content.endsWith("\n") ? "" : "\n") + `
+# mcp-use deployment
+${MCP_USE_DIR}
+`;
+      await import_node_fs6.promises.writeFile(gitignorePath, newContent, "utf-8");
+    }
+  } catch (err) {
+  }
+}
+
+// src/commands/deploy.ts
+var execAsync2 = (0, import_node_util8.promisify)(import_node_child_process9.exec);
+async function parseEnvFile(filePath) {
+  try {
+    const content = await import_node_fs7.promises.readFile(filePath, "utf-8");
+    const envVars = {};
+    const lines = content.split("\n");
+    let currentKey = null;
+    let currentValue = "";
+    for (let line of lines) {
+      line = line.trim();
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      if (currentKey && !line.includes("=")) {
+        currentValue += "\n" + line;
+        continue;
+      }
+      if (currentKey) {
+        envVars[currentKey] = currentValue.replace(/^["']|["']$/g, "");
+        currentKey = null;
+        currentValue = "";
+      }
+      const equalIndex = line.indexOf("=");
+      if (equalIndex === -1) {
+        continue;
+      }
+      const key = line.substring(0, equalIndex).trim();
+      let value = line.substring(equalIndex + 1).trim();
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        console.log(
+          source_default.yellow(`\u26A0\uFE0F  Skipping invalid environment variable key: ${key}`)
+        );
+        continue;
+      }
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+        envVars[key] = value;
+      } else if (value.startsWith('"') || value.startsWith("'")) {
+        currentKey = key;
+        currentValue = value.slice(1);
+      } else {
+        envVars[key] = value;
+      }
+    }
+    if (currentKey) {
+      envVars[currentKey] = currentValue.replace(/^["']|["']$/g, "");
+    }
+    return envVars;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Environment file not found: ${filePath}`);
+    }
+    throw new Error(
+      `Failed to parse environment file: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function parseEnvVar(envStr) {
+  const equalIndex = envStr.indexOf("=");
+  if (equalIndex === -1) {
+    throw new Error(
+      `Invalid environment variable format: "${envStr}". Expected KEY=VALUE`
+    );
+  }
+  const key = envStr.substring(0, equalIndex).trim();
+  const value = envStr.substring(equalIndex + 1);
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+    throw new Error(
+      `Invalid environment variable key: "${key}". Keys must start with a letter or underscore and contain only letters, numbers, and underscores.`
+    );
+  }
+  return { key, value };
+}
+async function buildEnvVars(options) {
+  const envVars = {};
+  if (options.envFile) {
+    try {
+      const fileEnv = await parseEnvFile(options.envFile);
+      Object.assign(envVars, fileEnv);
+      console.log(
+        source_default.gray(
+          `Loaded ${Object.keys(fileEnv).length} variable(s) from ${options.envFile}`
+        )
+      );
+    } catch (error) {
+      console.log(
+        source_default.red(
+          `\u2717 ${error instanceof Error ? error.message : "Failed to load env file"}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+  if (options.env && options.env.length > 0) {
+    for (const envStr of options.env) {
+      try {
+        const { key, value } = parseEnvVar(envStr);
+        envVars[key] = value;
+      } catch (error) {
+        console.log(
+          source_default.red(
+            `\u2717 ${error instanceof Error ? error.message : "Invalid env variable"}`
+          )
+        );
+        process.exit(1);
+      }
+    }
+  }
+  return envVars;
+}
+async function isMcpProject(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path5.default.join(cwd, "package.json");
+    const content = await import_node_fs7.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_path5.default.join(cwd, "package.json");
+    const content = await import_node_fs7.promises.readFile(packageJsonPath, "utf-8");
+    const packageJson2 = JSON.parse(content);
+    if (packageJson2.name) {
+      return packageJson2.name;
+    }
+  } catch {
+  }
+  return import_node_path5.default.basename(cwd);
+}
+async function detectBuildCommand(cwd = process.cwd()) {
+  try {
+    const packageJsonPath = import_node_path5.default.join(cwd, "package.json");
+    const content = await import_node_fs7.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_path5.default.join(cwd, "package.json");
+    const content = await import_node_fs7.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_fs7.promises.access(import_node_path5.default.join(cwd, file));
+        return "python";
+      } catch {
+        continue;
+      }
+    }
+    try {
+      await import_node_fs7.promises.access(import_node_path5.default.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 = import_node_os5.default.tmpdir();
+  const tarballPath = import_node_path5.default.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" + source_default.cyan(frame) + " " + source_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" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
+          const stepPrefix = logData.step ? source_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" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
+            const stepPrefix = logData.step ? source_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/inspector?autoConnect=${encodeURIComponent(mcpUrl)}`;
+      console.log(source_default.green.bold("\u2713 Deployment successful!\n"));
+      console.log(source_default.white("\u{1F310} MCP Server URL:"));
+      console.log(source_default.cyan.bold(`   ${mcpUrl}
+`));
+      console.log(source_default.white("\u{1F50D} Inspector URL:"));
+      console.log(source_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(source_default.white("\u{1F517} Custom Domain:"));
+        console.log(source_default.cyan.bold(`   ${customMcpUrl}
+`));
+        console.log(source_default.white("\u{1F50D} Custom Inspector:"));
+        console.log(source_default.cyan.bold(`   ${customInspectorUrl}
+`));
+      }
+      console.log(
+        source_default.gray("Deployment ID: ") + source_default.white(finalDeployment.id)
+      );
+      return;
+    } else if (finalDeployment.status === "failed") {
+      console.log(source_default.red.bold("\u2717 Deployment failed\n"));
+      if (finalDeployment.error) {
+        console.log(source_default.red("Error: ") + finalDeployment.error);
+      }
+      if (finalDeployment.buildLogs) {
+        console.log(source_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(source_default.gray(`  ${logData.line}`));
+              }
+            } catch {
+              console.log(source_default.gray(`  ${log}`));
+            }
+          }
+        } catch {
+          console.log(source_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(
+        source_default.yellow("\u26A0\uFE0F  Deployment status: ") + finalDeployment.status
+      );
+      return;
+    }
+  }
+  stopSpinner();
+  console.log(source_default.yellow("\u26A0\uFE0F  Deployment is taking longer than expected."));
+  console.log(
+    source_default.gray("Check status with: ") + source_default.white(`mcp-use status ${deployment.id}`)
+  );
+}
+async function deployCommand(options) {
+  try {
+    const cwd = process.cwd();
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    console.log(source_default.cyan.bold("\u{1F680} Deploying to mcp-use cloud...\n"));
+    const isMcp = await isMcpProject(cwd);
+    if (!isMcp) {
+      console.log(
+        source_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(
+        source_default.white("Continue anyway? (y/n): ")
+      );
+      if (!shouldContinue) {
+        console.log(source_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(
+          source_default.red(
+            "\u2717 Could not parse GitHub repository information from remote URL."
+          )
+        );
+        process.exit(1);
+      }
+      console.log(source_default.white("GitHub repository detected:"));
+      console.log(
+        source_default.gray(`  Repository: `) + source_default.cyan(`${gitInfo.owner}/${gitInfo.repo}`)
+      );
+      console.log(
+        source_default.gray(`  Branch:     `) + source_default.cyan(gitInfo.branch || "main")
+      );
+      if (gitInfo.commitSha) {
+        console.log(
+          source_default.gray(`  Commit:     `) + source_default.gray(gitInfo.commitSha.substring(0, 7))
+        );
+      }
+      if (gitInfo.commitMessage) {
+        console.log(
+          source_default.gray(`  Message:    `) + source_default.gray(gitInfo.commitMessage.split("\n")[0])
+        );
+      }
+      console.log();
+      const shouldDeploy = await prompt(
+        source_default.white(
+          `Deploy from GitHub repository ${gitInfo.owner}/${gitInfo.repo}? (y/n): `
+        )
+      );
+      if (!shouldDeploy) {
+        console.log(source_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);
+      const envVars = await buildEnvVars(options);
+      console.log();
+      console.log(source_default.white("Deployment configuration:"));
+      console.log(source_default.gray(`  Name:          `) + source_default.cyan(projectName));
+      console.log(source_default.gray(`  Runtime:       `) + source_default.cyan(runtime));
+      console.log(source_default.gray(`  Port:          `) + source_default.cyan(port));
+      if (buildCommand) {
+        console.log(source_default.gray(`  Build command: `) + source_default.cyan(buildCommand));
+      }
+      if (startCommand) {
+        console.log(source_default.gray(`  Start command: `) + source_default.cyan(startCommand));
+      }
+      if (envVars && Object.keys(envVars).length > 0) {
+        console.log(
+          source_default.gray(`  Environment:   `) + source_default.cyan(`${Object.keys(envVars).length} variable(s)`)
+        );
+        console.log(
+          source_default.gray(`                 `) + source_default.gray(Object.keys(envVars).join(", "))
+        );
+      }
+      console.log();
+      const api = await McpUseAPI.create();
+      const existingLink = !options.new ? await getProjectLink(cwd) : null;
+      if (existingLink) {
+        try {
+          const existingDeployment = await api.getDeployment(
+            existingLink.deploymentId
+          );
+          if (existingDeployment && existingDeployment.status !== "failed") {
+            console.log(source_default.green(`\u2713 Found linked deployment`));
+            console.log(
+              source_default.gray(`  Redeploying to maintain the same URL...`)
+            );
+            console.log(
+              source_default.cyan(`  URL: https://${existingDeployment.domain}/mcp
+`)
+            );
+            const deployment2 = await api.redeployDeployment(
+              existingLink.deploymentId
+            );
+            await saveProjectLink(cwd, {
+              ...existingLink,
+              linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            await displayDeploymentProgress(api, deployment2);
+            if (options.open && deployment2.domain) {
+              console.log();
+              console.log(source_default.gray("Opening deployment in browser..."));
+              await open_default(`https://${deployment2.domain}`);
+            }
+            return;
+          }
+        } catch (error) {
+          console.log(
+            source_default.yellow(`\u26A0\uFE0F  Linked deployment not found, creating new one...`)
+          );
+        }
+      }
+      const deploymentRequest = {
+        name: projectName,
+        source: {
+          type: "github",
+          repo: `${gitInfo.owner}/${gitInfo.repo}`,
+          branch: gitInfo.branch || "main",
+          runtime,
+          port,
+          buildCommand,
+          startCommand,
+          env: Object.keys(envVars).length > 0 ? envVars : void 0
+        },
+        healthCheckPath: "/healthz"
+      };
+      console.log(source_default.gray("Creating deployment..."));
+      const deployment = await api.createDeployment(deploymentRequest);
+      console.log(
+        source_default.green("\u2713 Deployment created: ") + source_default.gray(deployment.id)
+      );
+      await saveProjectLink(cwd, {
+        deploymentId: deployment.id,
+        deploymentName: projectName,
+        deploymentUrl: deployment.domain,
+        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(
+        source_default.gray(`  Linked to this project (stored in .mcp-use/project.json)`)
+      );
+      console.log(source_default.gray(`  Future deploys will reuse the same URL
+`));
+      await displayDeploymentProgress(api, deployment);
+      if (options.open && deployment.domain) {
+        console.log();
+        console.log(source_default.gray("Opening deployment in browser..."));
+        await open_default(`https://${deployment.domain}`);
+      }
+    } else {
+      if (options.fromSource) {
+        console.log(
+          source_default.white("\u{1F4E6} Deploying from local source code (--from-source)...")
+        );
+      } else {
+        console.log(
+          source_default.yellow(
+            "\u26A0\uFE0F  This is not a GitHub repository or no remote is configured."
+          )
+        );
+        console.log(source_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);
+      const envVars = await buildEnvVars(options);
+      console.log(source_default.white("Deployment configuration:"));
+      console.log(source_default.gray(`  Name:          `) + source_default.cyan(projectName));
+      console.log(source_default.gray(`  Runtime:       `) + source_default.cyan(runtime));
+      console.log(source_default.gray(`  Port:          `) + source_default.cyan(port));
+      if (buildCommand) {
+        console.log(source_default.gray(`  Build command: `) + source_default.cyan(buildCommand));
+      }
+      if (startCommand) {
+        console.log(source_default.gray(`  Start command: `) + source_default.cyan(startCommand));
+      }
+      if (envVars && Object.keys(envVars).length > 0) {
+        console.log(
+          source_default.gray(`  Environment:   `) + source_default.cyan(`${Object.keys(envVars).length} variable(s)`)
+        );
+        console.log(
+          source_default.gray(`                 `) + source_default.gray(Object.keys(envVars).join(", "))
+        );
+      }
+      console.log();
+      const shouldDeploy = await prompt(
+        source_default.white("Deploy from local source? (y/n): "),
+        "y"
+      );
+      if (!shouldDeploy) {
+        console.log(source_default.gray("Deployment cancelled."));
+        process.exit(0);
+      }
+      console.log();
+      console.log(source_default.gray("Packaging source code..."));
+      const tarballPath = await createTarball(cwd);
+      const stats = await import_node_fs7.promises.stat(tarballPath);
+      console.log(
+        source_default.green("\u2713 Packaged: ") + source_default.gray(formatFileSize(stats.size))
+      );
+      const maxSize = 2 * 1024 * 1024;
+      if (stats.size > maxSize) {
+        console.log(
+          source_default.red(
+            `\u2717 File size (${formatFileSize(stats.size)}) exceeds maximum of 2MB`
+          )
+        );
+        await import_node_fs7.promises.unlink(tarballPath);
+        process.exit(1);
+      }
+      const api = await McpUseAPI.create();
+      const existingLink = !options.new ? await getProjectLink(cwd) : null;
+      if (existingLink) {
+        try {
+          const existingDeployment = await api.getDeployment(
+            existingLink.deploymentId
+          );
+          if (existingDeployment && existingDeployment.status !== "failed") {
+            console.log(source_default.green(`\u2713 Found linked deployment`));
+            console.log(
+              source_default.gray(`  Redeploying to maintain the same URL...`)
+            );
+            console.log(
+              source_default.cyan(`  URL: https://${existingDeployment.domain}/mcp
+`)
+            );
+            const deployment2 = await api.redeployDeployment(
+              existingLink.deploymentId,
+              tarballPath
+            );
+            await import_node_fs7.promises.unlink(tarballPath);
+            await saveProjectLink(cwd, {
+              ...existingLink,
+              linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            await displayDeploymentProgress(api, deployment2);
+            if (options.open && deployment2.domain) {
+              console.log();
+              console.log(source_default.gray("Opening deployment in browser..."));
+              await open_default(`https://${deployment2.domain}`);
+            }
+            return;
+          }
+        } catch (error) {
+          console.log(
+            source_default.yellow(`\u26A0\uFE0F  Linked deployment not found, creating new one...`)
+          );
+        }
+      }
+      const deploymentRequest = {
+        name: projectName,
+        source: {
+          type: "upload",
+          runtime,
+          port,
+          buildCommand,
+          startCommand,
+          env: Object.keys(envVars).length > 0 ? envVars : void 0
+        },
+        healthCheckPath: "/healthz"
+      };
+      console.log(source_default.gray("Creating deployment..."));
+      const deployment = await api.createDeploymentWithUpload(
+        deploymentRequest,
+        tarballPath
       );
-      client.addServer(sessionName, {
-        command,
-        args
-      });
-      session = await client.createSession(sessionName);
-      await saveSession(sessionName, {
-        type: "stdio",
-        command,
-        args,
-        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } else {
-      console.error(formatInfo(`Connecting to ${urlOrCommand}...`));
-      client.addServer(sessionName, {
-        url: urlOrCommand,
-        headers: options.auth ? { Authorization: `Bearer ${options.auth}` } : void 0
-      });
-      session = await client.createSession(sessionName);
-      await saveSession(sessionName, {
-        type: "http",
-        url: urlOrCommand,
-        authToken: options.auth,
-        lastUsed: (/* @__PURE__ */ new Date()).toISOString()
+      await import_node_fs7.promises.unlink(tarballPath);
+      console.log(
+        source_default.green("\u2713 Deployment created: ") + source_default.gray(deployment.id)
+      );
+      await saveProjectLink(cwd, {
+        deploymentId: deployment.id,
+        deploymentName: projectName,
+        deploymentUrl: deployment.domain,
+        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-    }
-    activeSessions.set(sessionName, { client, session });
-    const serverInfo = session.serverInfo;
-    const capabilities = session.serverCapabilities;
-    if (serverInfo) {
-      await updateSessionInfo(sessionName, serverInfo, capabilities);
-    }
-    console.log(formatSuccess(`Connected to ${sessionName}`));
-    if (serverInfo) {
-      console.log("");
-      console.log(formatHeader("Server Information:"));
       console.log(
-        formatKeyValue({
-          Name: serverInfo.name,
-          Version: serverInfo.version || "unknown"
-        })
+        source_default.gray(`  Linked to this project (stored in .mcp-use/project.json)`)
       );
+      console.log(source_default.gray(`  Future deploys will reuse the same URL
+`));
+      await displayDeploymentProgress(api, deployment);
+      if (options.open && deployment.domain) {
+        console.log();
+        console.log(source_default.gray("Opening deployment in browser..."));
+        await open_default(`https://${deployment.domain}`);
+      }
     }
-    if (capabilities) {
-      console.log("");
-      console.log(formatHeader("Capabilities:"));
-      const caps = Object.keys(capabilities).join(", ");
-      console.log(`  ${caps || "none"}`);
-    }
-    const tools = session.tools;
-    console.log("");
-    console.log(
-      formatInfo(
-        `Available: ${tools.length} tool${tools.length !== 1 ? "s" : ""}`
-      )
-    );
   } catch (error) {
-    console.error(formatError(`Connection failed: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Deployment failed:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function disconnectCommand(sessionName, options) {
-  try {
-    if (options?.all) {
-      for (const [name, { client }] of activeSessions.entries()) {
-        await client.closeAllSessions();
-        activeSessions.delete(name);
-        console.log(formatSuccess(`Disconnected from ${name}`));
-      }
-      return;
-    }
-    if (!sessionName) {
-      const active = await getActiveSession();
-      if (!active) {
-        console.error(formatError("No active session to disconnect"));
-        return;
-      }
-      sessionName = active.name;
-    }
-    const sessionData = activeSessions.get(sessionName);
-    if (sessionData) {
-      await sessionData.client.closeAllSessions();
-      activeSessions.delete(sessionName);
-      console.log(formatSuccess(`Disconnected from ${sessionName}`));
-    } else {
-      console.log(formatInfo(`Session '${sessionName}' is not connected`));
-    }
-  } catch (error) {
-    console.error(formatError(`Failed to disconnect: ${error.message}`));
-    process.exit(1);
+
+// src/commands/deployments.ts
+var import_commander2 = require("commander");
+async function prompt2(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();
+      const trimmedAnswer = answer.trim().toLowerCase();
+      resolve(trimmedAnswer === "y" || trimmedAnswer === "yes");
+    });
+  });
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "running":
+      return source_default.green;
+    case "building":
+    case "pending":
+      return source_default.yellow;
+    case "failed":
+    case "stopped":
+      return source_default.red;
+    default:
+      return source_default.gray;
   }
 }
-async function listSessionsCommand() {
+function formatId(id) {
+  return id;
+}
+async function listDeploymentsCommand() {
   try {
-    const sessions = await listAllSessions();
-    if (sessions.length === 0) {
-      console.log(formatInfo("No saved sessions"));
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
       console.log(
-        formatInfo("Connect to a server with: npx mcp-use client connect <url>")
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
       );
-      return;
+      process.exit(1);
     }
-    console.log(formatHeader("Saved Sessions:"));
-    console.log("");
-    const tableData = sessions.map((s) => ({
-      name: s.isActive ? source_default.green.bold(`${s.name} *`) : s.name,
-      type: s.config.type,
-      target: s.config.type === "http" ? s.config.url || "" : `${s.config.command} ${(s.config.args || []).join(" ")}`,
-      server: s.config.serverInfo?.name || "unknown",
-      status: activeSessions.has(s.name) ? source_default.green("connected") : source_default.gray("disconnected")
-    }));
-    console.log(
-      formatTable(tableData, [
-        { key: "name", header: "Name" },
-        { key: "type", header: "Type" },
-        { key: "target", header: "Target", width: 40 },
-        { key: "server", header: "Server" },
-        { key: "status", header: "Status" }
-      ])
+    const api = await McpUseAPI.create();
+    const deployments = await api.listDeployments();
+    const sortedDeployments = [...deployments].sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
     );
-    console.log("");
-    console.log(source_default.gray("* = active session"));
-  } catch (error) {
-    console.error(formatError(`Failed to list sessions: ${error.message}`));
-    process.exit(1);
-  }
-}
-async function switchSessionCommand(name) {
-  try {
-    await setActiveSession(name);
-    console.log(formatSuccess(`Switched to session '${name}'`));
-  } catch (error) {
-    console.error(formatError(`Failed to switch session: ${error.message}`));
-    process.exit(1);
-  }
-}
-async function listToolsCommand(options) {
-  try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    const tools = await session.listTools();
-    if (options.json) {
-      console.log(formatJson(tools));
-      return;
-    }
-    if (tools.length === 0) {
-      console.log(formatInfo("No tools available"));
+    if (sortedDeployments.length === 0) {
+      console.log(source_default.yellow("No deployments found."));
+      console.log(
+        source_default.gray(
+          "\nDeploy your first MCP server with " + source_default.white("mcp-use deploy")
+        )
+      );
       return;
     }
-    console.log(formatHeader(`Available Tools (${tools.length}):`));
-    console.log("");
-    const tableData = tools.map((tool) => ({
-      name: source_default.bold(tool.name),
-      description: tool.description || source_default.gray("No description")
-    }));
     console.log(
-      formatTable(tableData, [
-        { key: "name", header: "Tool", width: 25 },
-        { key: "description", header: "Description", width: 50 }
-      ])
+      source_default.cyan.bold(`
+\u{1F4E6} Deployments (${sortedDeployments.length})
+`)
     );
-  } catch (error) {
-    console.error(formatError(`Failed to list tools: ${error.message}`));
-    process.exit(1);
-  }
-}
-async function describeToolCommand(toolName, options) {
-  try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    const tools = session.tools;
-    const tool = tools.find((t) => t.name === toolName);
-    if (!tool) {
-      console.error(formatError(`Tool '${toolName}' not found`));
-      console.log("");
-      console.log(formatInfo("Available tools:"));
-      tools.forEach((t) => console.log(`  \u2022 ${t.name}`));
-      return;
-    }
-    console.log(formatHeader(`Tool: ${tool.name}`));
-    console.log("");
-    if (tool.description) {
-      console.log(tool.description);
-      console.log("");
-    }
-    if (tool.inputSchema) {
-      console.log(formatHeader("Input Schema:"));
-      console.log(formatSchema(tool.inputSchema));
-    }
-  } catch (error) {
-    console.error(formatError(`Failed to describe tool: ${error.message}`));
-    process.exit(1);
-  }
-}
-async function callToolCommand(toolName, argsJson, options) {
-  try {
-    const result = await getOrRestoreSession(options?.session || null);
-    if (!result) return;
-    const { session } = result;
-    let args = {};
-    if (argsJson) {
-      try {
-        args = JSON.parse(argsJson);
-      } catch (error) {
-        console.error(formatError("Invalid JSON arguments"));
-        return;
-      }
-    } else {
-      const tools = session.tools;
-      const tool = tools.find((t) => t.name === toolName);
-      if (tool?.inputSchema?.required && tool.inputSchema.required.length > 0) {
-        console.error(
-          formatError(
-            "This tool requires arguments. Provide them as a JSON string."
-          )
-        );
-        console.log("");
-        console.log(formatInfo("Example:"));
-        console.log(
-          `  npx mcp-use client tools call ${toolName} '{"param": "value"}'`
-        );
-        console.log("");
-        console.log(formatInfo("Tool schema:"));
-        console.log(formatSchema(tool.inputSchema));
-        return;
-      }
-    }
-    console.error(formatInfo(`Calling tool '${toolName}'...`));
-    const callResult = await session.callTool(toolName, args, {
-      timeout: options?.timeout
-    });
-    if (options?.json) {
-      console.log(formatJson(callResult));
-    } else {
-      console.log(formatToolCall(callResult));
+    console.log(
+      source_default.white.bold(
+        `${"ID".padEnd(40)} ${"NAME".padEnd(25)} ${"STATUS".padEnd(12)} ${"DOMAIN".padEnd(35)} ${"CREATED"}`
+      )
+    );
+    console.log(source_default.gray("\u2500".repeat(130)));
+    for (const deployment of sortedDeployments) {
+      const id = formatId(deployment.id).padEnd(40);
+      const name = deployment.name.substring(0, 24).padEnd(25);
+      const statusColor = getStatusColor(deployment.status);
+      const status = statusColor(deployment.status.padEnd(12));
+      const domain = (deployment.domain || "-").substring(0, 34).padEnd(35);
+      const created = formatRelativeTime(deployment.createdAt);
+      console.log(
+        `${source_default.gray(id)} ${name} ${status} ${source_default.cyan(domain)} ${source_default.gray(created)}`
+      );
     }
+    console.log();
   } catch (error) {
-    console.error(formatError(`Failed to call tool: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to list deployments:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function listResourcesCommand(options) {
+async function getDeploymentCommand(deploymentId) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    const resourcesResult = await session.listAllResources();
-    const resources = resourcesResult.resources;
-    if (options.json) {
-      console.log(formatJson(resources));
-      return;
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
     }
-    if (resources.length === 0) {
-      console.log(formatInfo("No resources available"));
-      return;
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
+    console.log(source_default.cyan.bold("\n\u{1F4E6} Deployment Details\n"));
+    console.log(source_default.white("ID:            ") + source_default.gray(deployment.id));
+    console.log(source_default.white("Name:          ") + source_default.cyan(deployment.name));
+    const statusColor = getStatusColor(deployment.status);
+    console.log(
+      source_default.white("Status:        ") + statusColor(deployment.status)
+    );
+    if (deployment.domain) {
+      console.log(
+        source_default.white("Domain:        ") + source_default.cyan(`https://${deployment.domain}`)
+      );
+    }
+    if (deployment.customDomain) {
+      console.log(
+        source_default.white("Custom Domain: ") + source_default.cyan(`https://${deployment.customDomain}`)
+      );
     }
-    console.log(formatHeader(`Available Resources (${resources.length}):`));
-    console.log("");
-    const tableData = resources.map((resource) => ({
-      uri: resource.uri,
-      name: resource.name || source_default.gray("(no name)"),
-      type: resource.mimeType || source_default.gray("unknown")
-    }));
     console.log(
-      formatTable(tableData, [
-        { key: "uri", header: "URI", width: 40 },
-        { key: "name", header: "Name", width: 20 },
-        { key: "type", header: "Type", width: 15 }
-      ])
+      source_default.white("Source:        ") + source_default.gray(deployment.source.type)
+    );
+    if (deployment.source.type === "github") {
+      console.log(
+        source_default.white("Repository:    ") + source_default.gray(deployment.source.repo)
+      );
+      console.log(
+        source_default.white("Branch:        ") + source_default.gray(deployment.source.branch || "main")
+      );
+    }
+    console.log(source_default.white("Port:          ") + source_default.gray(deployment.port));
+    console.log(
+      source_default.white("Runtime:       ") + source_default.gray(deployment.source.runtime || "node")
+    );
+    if (deployment.provider) {
+      console.log(
+        source_default.white("Provider:      ") + source_default.gray(deployment.provider)
+      );
+    }
+    console.log(
+      source_default.white("Created:       ") + source_default.gray(formatRelativeTime(deployment.createdAt))
+    );
+    console.log(
+      source_default.white("Updated:       ") + source_default.gray(formatRelativeTime(deployment.updatedAt))
     );
+    if (deployment.source.env && Object.keys(deployment.source.env).length > 0) {
+      console.log(source_default.white("\nEnvironment Variables:"));
+      for (const [key, value] of Object.entries(deployment.source.env)) {
+        const displayValue = key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("password") || key.toLowerCase().includes("token") ? "***" : value;
+        console.log(source_default.gray(`  ${key}=`) + source_default.white(displayValue));
+      }
+    }
+    if (deployment.status === "failed" && deployment.error) {
+      console.log(source_default.red("\nError:"));
+      console.log(source_default.red(`  ${deployment.error}`));
+    }
+    console.log();
   } catch (error) {
-    console.error(formatError(`Failed to list resources: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to get deployment:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function readResourceCommand(uri, options) {
+async function restartDeploymentCommand(deploymentId, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    console.error(formatInfo(`Reading resource: ${uri}`));
-    const resource = await session.readResource(uri);
-    if (options.json) {
-      console.log(formatJson(resource));
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
+    console.log(
+      source_default.cyan.bold(`
+\u{1F504} Restarting deployment: ${deployment.name}
+`)
+    );
+    const redeployedDeployment = await api.redeployDeployment(deploymentId);
+    console.log(
+      source_default.green("\u2713 Restart initiated: ") + source_default.gray(redeployedDeployment.id)
+    );
+    if (options.follow) {
+      console.log(source_default.gray("\nFollowing deployment logs...\n"));
+      try {
+        for await (const log of api.streamDeploymentLogs(
+          redeployedDeployment.id
+        )) {
+          try {
+            const logData = JSON.parse(log);
+            if (logData.line) {
+              const levelColor = logData.level === "error" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
+              const stepPrefix = logData.step ? source_default.cyan(`[${logData.step}]`) + " " : "";
+              console.log(stepPrefix + levelColor(logData.line));
+            }
+          } catch {
+            console.log(source_default.gray(log));
+          }
+        }
+      } catch (error) {
+        console.log(
+          source_default.gray(
+            "\nLog stream ended. Use " + source_default.white(`mcp-use deployments get ${deploymentId}`) + " to check status."
+          )
+        );
+      }
     } else {
-      console.log(formatResourceContent(resource));
+      console.log(
+        source_default.gray(
+          "\nCheck status with: " + source_default.white(`mcp-use deployments get ${deploymentId}`)
+        )
+      );
     }
+    console.log();
   } catch (error) {
-    console.error(formatError(`Failed to read resource: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to restart deployment:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function subscribeResourceCommand(uri, options) {
+async function deleteDeploymentCommand(deploymentId, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    await session.subscribeToResource(uri);
-    console.log(formatSuccess(`Subscribed to resource: ${uri}`));
-    session.on("notification", async (notification) => {
-      if (notification.method === "notifications/resources/updated") {
-        console.log("");
-        console.log(formatInfo("Resource updated:"));
-        console.log(formatJson(notification.params));
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
+    if (!options.yes) {
+      console.log(
+        source_default.yellow(
+          `
+\u26A0\uFE0F  You are about to delete deployment: ${source_default.white(deployment.name)}`
+        )
+      );
+      console.log(source_default.gray(`   ID: ${deployment.id}`));
+      console.log(source_default.gray(`   Domain: ${deployment.domain || "none"}
+`));
+      const confirmed = await prompt2(
+        source_default.white("Are you sure you want to delete this deployment? (y/N): ")
+      );
+      if (!confirmed) {
+        console.log(source_default.gray("Deletion cancelled."));
+        return;
       }
-    });
-    console.log(formatInfo("Listening for updates... (Press Ctrl+C to stop)"));
-    await new Promise(() => {
-    });
+    }
+    await api.deleteDeployment(deploymentId);
+    console.log(
+      source_default.green.bold(`
+\u2713 Deployment deleted: ${deployment.name}
+`)
+    );
   } catch (error) {
     console.error(
-      formatError(`Failed to subscribe to resource: ${error.message}`)
+      source_default.red.bold("\n\u2717 Failed to delete deployment:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
     );
     process.exit(1);
   }
 }
-async function unsubscribeResourceCommand(uri, options) {
+async function logsCommand(deploymentId, options) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    await session.unsubscribeFromResource(uri);
-    console.log(formatSuccess(`Unsubscribed from resource: ${uri}`));
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    if (options.follow) {
+      console.log(source_default.gray("Streaming logs...\n"));
+      try {
+        for await (const log of api.streamDeploymentLogs(deploymentId)) {
+          try {
+            const logData = JSON.parse(log);
+            if (logData.line) {
+              const levelColor = logData.level === "error" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
+              const stepPrefix = logData.step ? source_default.cyan(`[${logData.step}]`) + " " : "";
+              console.log(stepPrefix + levelColor(logData.line));
+            }
+          } catch {
+            console.log(source_default.gray(log));
+          }
+        }
+      } catch (error) {
+        console.log(source_default.gray("\nLog stream ended."));
+      }
+    } else {
+      const logs = options.build ? await api.getDeploymentBuildLogs(deploymentId) : await api.getDeploymentLogs(deploymentId);
+      if (!logs || logs.trim() === "") {
+        console.log(
+          source_default.yellow(
+            `No ${options.build ? "build " : ""}logs available for this deployment.`
+          )
+        );
+        return;
+      }
+      const logLines = logs.split("\n").filter((l) => l.trim());
+      for (const line of logLines) {
+        try {
+          const logData = JSON.parse(line);
+          if (logData.line) {
+            const levelColor = logData.level === "error" ? source_default.red : logData.level === "warn" ? source_default.yellow : source_default.gray;
+            const stepPrefix = logData.step ? source_default.cyan(`[${logData.step}]`) + " " : "";
+            console.log(stepPrefix + levelColor(logData.line));
+          }
+        } catch {
+          console.log(source_default.gray(line));
+        }
+      }
+    }
+    console.log();
   } catch (error) {
     console.error(
-      formatError(`Failed to unsubscribe from resource: ${error.message}`)
+      source_default.red.bold("\n\u2717 Failed to get logs:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
     );
     process.exit(1);
   }
 }
-async function listPromptsCommand(options) {
+async function listEnvCommand(deploymentId) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { session } = result;
-    const promptsResult = await session.listPrompts();
-    const prompts = promptsResult.prompts;
-    if (options.json) {
-      console.log(formatJson(prompts));
-      return;
-    }
-    if (prompts.length === 0) {
-      console.log(formatInfo("No prompts available"));
-      return;
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
     }
-    console.log(formatHeader(`Available Prompts (${prompts.length}):`));
-    console.log("");
-    const tableData = prompts.map((prompt2) => ({
-      name: source_default.bold(prompt2.name),
-      description: prompt2.description || source_default.gray("No description")
-    }));
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
     console.log(
-      formatTable(tableData, [
-        { key: "name", header: "Prompt", width: 25 },
-        { key: "description", header: "Description", width: 50 }
-      ])
+      source_default.cyan.bold(`
+\u{1F510} Environment Variables: ${deployment.name}
+`)
     );
+    if (!deployment.source.env || Object.keys(deployment.source.env).length === 0) {
+      console.log(source_default.yellow("No environment variables set."));
+      console.log();
+      return;
+    }
+    for (const [key, value] of Object.entries(deployment.source.env)) {
+      const displayValue = key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("password") || key.toLowerCase().includes("token") ? "***" : value;
+      console.log(
+        source_default.white(key) + source_default.gray("=") + source_default.cyan(displayValue)
+      );
+    }
+    console.log();
   } catch (error) {
-    console.error(formatError(`Failed to list prompts: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to list environment variables:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function getPromptCommand(promptName, argsJson, options) {
+async function setEnvCommand(deploymentId, envPairs) {
   try {
-    const result = await getOrRestoreSession(options?.session || null);
-    if (!result) return;
-    const { session } = result;
-    let args = {};
-    if (argsJson) {
-      try {
-        args = JSON.parse(argsJson);
-      } catch (error) {
-        console.error(formatError("Invalid JSON arguments"));
-        return;
-      }
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
     }
-    console.error(formatInfo(`Getting prompt '${promptName}'...`));
-    const prompt2 = await session.getPrompt(promptName, args);
-    if (options?.json) {
-      console.log(formatJson(prompt2));
-    } else {
-      console.log(formatHeader(`Prompt: ${promptName}`));
-      console.log("");
-      if (prompt2.description) {
-        console.log(prompt2.description);
-        console.log("");
-      }
-      if (prompt2.messages) {
-        console.log(formatHeader("Messages:"));
-        console.log("");
-        console.log(formatPromptMessages(prompt2.messages));
+    const env2 = {};
+    for (const pair of envPairs) {
+      const [key, ...valueParts] = pair.split("=");
+      if (!key || valueParts.length === 0) {
+        console.log(source_default.red(`\u2717 Invalid format: ${pair}. Expected KEY=VALUE`));
+        process.exit(1);
       }
+      env2[key.trim()] = valueParts.join("=").trim();
+    }
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
+    const currentEnv = deployment.source.env || {};
+    const mergedEnv = { ...currentEnv, ...env2 };
+    const updated = await api.updateDeployment(deploymentId, {
+      env: mergedEnv
+    });
+    console.log(
+      source_default.green.bold(`
+\u2713 Environment variables updated: ${updated.name}
+`)
+    );
+    for (const key of Object.keys(env2)) {
+      const displayValue = key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("password") || key.toLowerCase().includes("token") ? "***" : env2[key];
+      console.log(
+        source_default.white(key) + source_default.gray("=") + source_default.cyan(displayValue)
+      );
     }
+    console.log();
   } catch (error) {
-    console.error(formatError(`Failed to get prompt: ${error.message}`));
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to set environment variables:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
     process.exit(1);
   }
 }
-async function interactiveCommand(options) {
+async function unsetEnvCommand(deploymentId, keys) {
   try {
-    const result = await getOrRestoreSession(options.session || null);
-    if (!result) return;
-    const { name: sessionName, session } = result;
-    console.log(formatHeader("MCP Interactive Mode"));
-    console.log("");
-    console.log(formatInfo(`Connected to: ${sessionName}`));
-    console.log("");
-    console.log(source_default.gray("Commands:"));
-    console.log(source_default.gray("  tools list              - List available tools"));
-    console.log(
-      source_default.gray(
-        "  tools call <name>       - Call a tool (will prompt for args)"
-      )
-    );
-    console.log(source_default.gray("  tools describe <name>   - Show tool details"));
-    console.log(
-      source_default.gray("  resources list          - List available resources")
-    );
-    console.log(source_default.gray("  resources read <uri>    - Read a resource"));
-    console.log(
-      source_default.gray("  prompts list            - List available prompts")
-    );
-    console.log(source_default.gray("  prompts get <name>      - Get a prompt"));
-    console.log(source_default.gray("  sessions list           - List all sessions"));
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    const deployment = await api.getDeployment(deploymentId);
+    const currentEnv = { ...deployment.source.env || {} };
+    for (const key of keys) {
+      delete currentEnv[key];
+    }
+    const updated = await api.updateDeployment(deploymentId, {
+      env: currentEnv
+    });
     console.log(
-      source_default.gray("  sessions switch <name>  - Switch to another session")
+      source_default.green.bold(`
+\u2713 Environment variables removed: ${updated.name}
+`)
     );
-    console.log(
-      source_default.gray("  exit, quit              - Exit interactive mode")
+    for (const key of keys) {
+      console.log(source_default.gray(`  ${key}`));
+    }
+    console.log();
+  } catch (error) {
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to unset environment variables:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
     );
-    console.log("");
-    const rl = (0, import_node_readline.createInterface)({
-      input: process.stdin,
-      output: process.stdout,
-      prompt: source_default.cyan("mcp> ")
-    });
-    rl.prompt();
-    rl.on("line", async (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        rl.prompt();
-        return;
-      }
-      if (trimmed === "exit" || trimmed === "quit") {
-        console.log(formatInfo("Goodbye!"));
-        rl.close();
-        process.exit(0);
-      }
-      const parts = trimmed.split(" ");
-      const scope = parts[0];
-      const command = parts[1];
-      const arg = parts[2];
-      try {
-        if (scope === "tools") {
-          if (command === "list") {
-            const tools = await session.listTools();
-            console.log(
-              formatInfo(
-                `Available tools: ${tools.map((t) => t.name).join(", ")}`
-              )
-            );
-          } else if (command === "call" && arg) {
-            rl.question(
-              "Arguments (JSON, or press Enter for none): ",
-              async (argsInput) => {
-                try {
-                  const args = argsInput.trim() ? JSON.parse(argsInput) : {};
-                  const result2 = await session.callTool(arg, args);
-                  console.log(formatToolCall(result2));
-                } catch (error) {
-                  console.error(formatError(error.message));
-                }
-                rl.prompt();
-              }
-            );
-            return;
-          } else if (command === "describe" && arg) {
-            const tools = session.tools;
-            const tool = tools.find((t) => t.name === arg);
-            if (tool) {
-              console.log(formatHeader(`Tool: ${tool.name}`));
-              if (tool.description) console.log(tool.description);
-              if (tool.inputSchema) {
-                console.log("");
-                console.log(formatSchema(tool.inputSchema));
-              }
-            } else {
-              console.error(formatError(`Tool '${arg}' not found`));
-            }
-          } else {
-            console.error(
-              formatError(
-                "Invalid command. Try: tools list, tools call <name>, tools describe <name>"
-              )
-            );
-          }
-        } else if (scope === "resources") {
-          if (command === "list") {
-            const result2 = await session.listAllResources();
-            const resources = result2.resources;
-            console.log(
-              formatInfo(
-                `Available resources: ${resources.map((r) => r.uri).join(", ")}`
-              )
-            );
-          } else if (command === "read" && arg) {
-            const resource = await session.readResource(arg);
-            console.log(formatResourceContent(resource));
-          } else {
-            console.error(
-              formatError(
-                "Invalid command. Try: resources list, resources read <uri>"
-              )
-            );
-          }
-        } else if (scope === "prompts") {
-          if (command === "list") {
-            const result2 = await session.listPrompts();
-            const prompts = result2.prompts;
-            console.log(
-              formatInfo(
-                `Available prompts: ${prompts.map((p) => p.name).join(", ")}`
-              )
-            );
-          } else if (command === "get" && arg) {
-            rl.question(
-              "Arguments (JSON, or press Enter for none): ",
-              async (argsInput) => {
-                try {
-                  const args = argsInput.trim() ? JSON.parse(argsInput) : {};
-                  const prompt2 = await session.getPrompt(arg, args);
-                  console.log(formatPromptMessages(prompt2.messages));
-                } catch (error) {
-                  console.error(formatError(error.message));
-                }
-                rl.prompt();
-              }
-            );
-            return;
-          } else {
-            console.error(
-              formatError(
-                "Invalid command. Try: prompts list, prompts get <name>"
-              )
-            );
-          }
-        } else if (scope === "sessions") {
-          if (command === "list") {
-            await listSessionsCommand();
-          } else if (command === "switch" && arg) {
-            console.log(
-              formatWarning(
-                "Session switching in interactive mode will be available in a future version"
-              )
-            );
-          } else {
-            console.error(formatError("Invalid command. Try: sessions list"));
-          }
-        } else {
-          console.error(
-            formatError(
-              "Unknown command. Type a valid scope: tools, resources, prompts, sessions"
-            )
-          );
-        }
-      } catch (error) {
-        console.error(formatError(error.message));
-      }
-      rl.prompt();
+    process.exit(1);
+  }
+}
+async function stopDeploymentCommand(deploymentId) {
+  try {
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    const updated = await api.updateDeployment(deploymentId, {
+      status: "stopped"
     });
-    rl.on("close", () => {
-      console.log("");
-      console.log(formatInfo("Goodbye!"));
-      process.exit(0);
+    console.log(source_default.green.bold(`
+\u2713 Deployment stopped: ${updated.name}
+`));
+  } catch (error) {
+    console.error(
+      source_default.red.bold("\n\u2717 Failed to stop deployment:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
+    );
+    process.exit(1);
+  }
+}
+async function startDeploymentCommand(deploymentId) {
+  try {
+    if (!await isLoggedIn()) {
+      console.log(source_default.red("\u2717 You are not logged in."));
+      console.log(
+        source_default.gray("Run " + source_default.white("mcp-use login") + " to get started.")
+      );
+      process.exit(1);
+    }
+    const api = await McpUseAPI.create();
+    const updated = await api.updateDeployment(deploymentId, {
+      status: "running"
     });
+    console.log(source_default.green.bold(`
+\u2713 Deployment started: ${updated.name}
+`));
   } catch (error) {
     console.error(
-      formatError(`Failed to start interactive mode: ${error.message}`)
+      source_default.red.bold("\n\u2717 Failed to start deployment:"),
+      source_default.red(error instanceof Error ? error.message : "Unknown error")
     );
     process.exit(1);
   }
 }
-function createClientCommand() {
-  const clientCommand = new import_commander.Command("client").description(
-    "Interactive MCP client for terminal usage"
+function createDeploymentsCommand() {
+  const deploymentsCommand = new import_commander2.Command("deployments").description(
+    "Manage cloud deployments"
   );
-  clientCommand.command("connect <url>").description("Connect to an MCP server").option("--name <name>", "Session name").option("--stdio", "Use stdio connector instead of HTTP").option("--auth <token>", "Authentication token").action(connectCommand);
-  clientCommand.command("disconnect [session]").description("Disconnect from a session").option("--all", "Disconnect all sessions").action(disconnectCommand);
-  const sessionsCommand = new import_commander.Command("sessions").description(
-    "Manage CLI sessions"
-  );
-  sessionsCommand.command("list").description("List all saved sessions").action(listSessionsCommand);
-  sessionsCommand.command("switch <name>").description("Switch to a different session").action(switchSessionCommand);
-  clientCommand.addCommand(sessionsCommand);
-  const toolsCommand = new import_commander.Command("tools").description(
-    "Interact with MCP tools"
-  );
-  toolsCommand.command("list").description("List available tools").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listToolsCommand);
-  toolsCommand.command("call <name> [args]").description("Call a tool with arguments (JSON string)").option("--session <name>", "Use specific session").option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--json", "Output as JSON").action(callToolCommand);
-  toolsCommand.command("describe <name>").description("Show tool details and schema").option("--session <name>", "Use specific session").action(describeToolCommand);
-  clientCommand.addCommand(toolsCommand);
-  const resourcesCommand = new import_commander.Command("resources").description(
-    "Interact with MCP resources"
-  );
-  resourcesCommand.command("list").description("List available resources").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listResourcesCommand);
-  resourcesCommand.command("read <uri>").description("Read a resource by URI").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(readResourceCommand);
-  resourcesCommand.command("subscribe <uri>").description("Subscribe to resource updates").option("--session <name>", "Use specific session").action(subscribeResourceCommand);
-  resourcesCommand.command("unsubscribe <uri>").description("Unsubscribe from resource updates").option("--session <name>", "Use specific session").action(unsubscribeResourceCommand);
-  clientCommand.addCommand(resourcesCommand);
-  const promptsCommand = new import_commander.Command("prompts").description(
-    "Interact with MCP prompts"
-  );
-  promptsCommand.command("list").description("List available prompts").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(listPromptsCommand);
-  promptsCommand.command("get <name> [args]").description("Get a prompt with arguments (JSON string)").option("--session <name>", "Use specific session").option("--json", "Output as JSON").action(getPromptCommand);
-  clientCommand.addCommand(promptsCommand);
-  clientCommand.command("interactive").description("Start interactive REPL mode").option("--session <name>", "Use specific session").action(interactiveCommand);
-  return clientCommand;
+  deploymentsCommand.command("list").alias("ls").description("List all deployments").action(listDeploymentsCommand);
+  deploymentsCommand.command("get").argument("<deployment-id>", "Deployment ID").description("Get deployment details").action(getDeploymentCommand);
+  deploymentsCommand.command("restart").argument("<deployment-id>", "Deployment ID").option("-f, --follow", "Follow deployment logs").description("Restart a deployment").action(restartDeploymentCommand);
+  deploymentsCommand.command("delete").alias("rm").argument("<deployment-id>", "Deployment ID").option("-y, --yes", "Skip confirmation prompt").description("Delete a deployment").action(deleteDeploymentCommand);
+  deploymentsCommand.command("logs").argument("<deployment-id>", "Deployment ID").option("-b, --build", "Show build logs instead of runtime logs").option("-f, --follow", "Stream logs in real-time").description("View deployment logs").action(logsCommand);
+  const envCommand = deploymentsCommand.command("env").description("Manage environment variables");
+  envCommand.command("list").argument("<deployment-id>", "Deployment ID").description("List environment variables").action(listEnvCommand);
+  envCommand.command("set").argument("<deployment-id>", "Deployment ID").argument("<pairs...>", "Environment variables in KEY=VALUE format").description("Set environment variables").action(setEnvCommand);
+  envCommand.command("unset").argument("<deployment-id>", "Deployment ID").argument("<keys...>", "Environment variable keys to remove").description("Unset environment variables").action(unsetEnvCommand);
+  deploymentsCommand.command("stop").argument("<deployment-id>", "Deployment ID").description("Stop a deployment").action(stopDeploymentCommand);
+  deploymentsCommand.command("start").argument("<deployment-id>", "Deployment ID").description("Start a stopped deployment").action(startDeploymentCommand);
+  return deploymentsCommand;
 }
 
 // src/index.ts
-var import_zod = require("zod");
-var program = new import_commander2.Command();
-var packageContent = (0, import_node_fs7.readFileSync)(
-  import_node_path5.default.join(__dirname, "../package.json"),
+var program = new import_commander3.Command();
+var packageContent = (0, import_node_fs8.readFileSync)(
+  import_node_path6.default.join(__dirname, "../package.json"),
   "utf-8"
 );
 var packageJson = JSON.parse(packageContent);
@@ -3388,7 +4295,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_promises5.access)(import_node_path5.default.join(projectPath, candidate));
+      await (0, import_promises5.access)(import_node_path6.default.join(projectPath, candidate));
       return candidate;
     } catch {
       continue;
@@ -3397,9 +4304,9 @@ async function findServerFile(projectPath) {
   throw new Error("No server file found");
 }
 async function buildWidgets(projectPath) {
-  const { promises: fs9 } = await import("fs");
+  const { promises: fs10 } = await import("fs");
   const { build } = await import("vite");
-  const resourcesDir = import_node_path5.default.join(projectPath, "resources");
+  const resourcesDir = import_node_path6.default.join(projectPath, "resources");
   const mcpUrl = process.env.MCP_URL;
   try {
     await (0, import_promises5.access)(resourcesDir);
@@ -3411,7 +4318,7 @@ async function buildWidgets(projectPath) {
   }
   const entries = [];
   try {
-    const files = await fs9.readdir(resourcesDir, { withFileTypes: true });
+    const files = await fs10.readdir(resourcesDir, { withFileTypes: true });
     for (const dirent of files) {
       if (dirent.name.startsWith("._") || dirent.name.startsWith(".DS_Store")) {
         continue;
@@ -3419,12 +4326,12 @@ async function buildWidgets(projectPath) {
       if (dirent.isFile() && (dirent.name.endsWith(".tsx") || dirent.name.endsWith(".ts"))) {
         entries.push({
           name: dirent.name.replace(/\.tsx?$/, ""),
-          path: import_node_path5.default.join(resourcesDir, dirent.name)
+          path: import_node_path6.default.join(resourcesDir, dirent.name)
         });
       } else if (dirent.isDirectory()) {
-        const widgetPath = import_node_path5.default.join(resourcesDir, dirent.name, "widget.tsx");
+        const widgetPath = import_node_path6.default.join(resourcesDir, dirent.name, "widget.tsx");
         try {
-          await fs9.access(widgetPath);
+          await fs10.access(widgetPath);
           entries.push({
             name: dirent.name,
             path: widgetPath
@@ -3444,10 +4351,10 @@ async function buildWidgets(projectPath) {
   console.log(source_default.gray(`Building ${entries.length} widget(s)...`));
   const react = (await import("@vitejs/plugin-react")).default;
   const tailwindcss = (await import("@tailwindcss/vite")).default;
-  const packageJsonPath = import_node_path5.default.join(projectPath, "package.json");
+  const packageJsonPath = import_node_path6.default.join(projectPath, "package.json");
   let favicon = "";
   try {
-    const pkgContent = await fs9.readFile(packageJsonPath, "utf-8");
+    const pkgContent = await fs10.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     favicon = pkg.mcpUse?.favicon || "";
   } catch {
@@ -3457,18 +4364,18 @@ async function buildWidgets(projectPath) {
     const widgetName = entry.name;
     const entryPath = entry.path;
     console.log(source_default.gray(`  - Building ${widgetName}...`));
-    const tempDir = import_node_path5.default.join(projectPath, ".mcp-use", widgetName);
-    await fs9.mkdir(tempDir, { recursive: true });
-    const relativeResourcesPath = import_node_path5.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
-    const mcpUsePath = import_node_path5.default.join(projectPath, "node_modules", "mcp-use");
-    const relativeMcpUsePath = import_node_path5.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
+    const tempDir = import_node_path6.default.join(projectPath, ".mcp-use", widgetName);
+    await fs10.mkdir(tempDir, { recursive: true });
+    const relativeResourcesPath = import_node_path6.default.relative(tempDir, resourcesDir).replace(/\\/g, "/");
+    const mcpUsePath = import_node_path6.default.join(projectPath, "node_modules", "mcp-use");
+    const relativeMcpUsePath = import_node_path6.default.relative(tempDir, mcpUsePath).replace(/\\/g, "/");
     const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory and mcp-use package */
 @source "${relativeResourcesPath}";
 @source "${relativeMcpUsePath}/**/*.{ts,tsx,js,jsx}";
 `;
-    await fs9.writeFile(import_node_path5.default.join(tempDir, "styles.css"), cssContent, "utf8");
+    await fs10.writeFile(import_node_path6.default.join(tempDir, "styles.css"), cssContent, "utf8");
     const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -3493,9 +4400,9 @@ if (container && Component) {
     <script type="module" src="/entry.tsx"></script>
   </body>
 </html>`;
-    await fs9.writeFile(import_node_path5.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
-    await fs9.writeFile(import_node_path5.default.join(tempDir, "index.html"), htmlContent, "utf8");
-    const outDir = import_node_path5.default.join(
+    await fs10.writeFile(import_node_path6.default.join(tempDir, "entry.tsx"), entryContent, "utf8");
+    await fs10.writeFile(import_node_path6.default.join(tempDir, "index.html"), htmlContent, "utf8");
+    const outDir = import_node_path6.default.join(
       projectPath,
       "dist",
       "resources",
@@ -3505,12 +4412,12 @@ if (container && Component) {
     const baseUrl = mcpUrl ? `${mcpUrl}/${widgetName}/` : `/mcp-use/widgets/${widgetName}/`;
     let widgetMetadata = {};
     try {
-      const metadataTempDir = import_node_path5.default.join(
+      const metadataTempDir = import_node_path6.default.join(
         projectPath,
         ".mcp-use",
         `${widgetName}-metadata`
       );
-      await fs9.mkdir(metadataTempDir, { recursive: true });
+      await fs10.mkdir(metadataTempDir, { recursive: true });
       const { createServer: createServer2 } = await import("vite");
       const nodeStubsPlugin = {
         name: "node-stubs",
@@ -3540,7 +4447,7 @@ export default PostHog;
       };
       const metadataServer = await createServer2({
         root: metadataTempDir,
-        cacheDir: import_node_path5.default.join(metadataTempDir, ".vite-cache"),
+        cacheDir: import_node_path6.default.join(metadataTempDir, ".vite-cache"),
         plugins: [nodeStubsPlugin, tailwindcss(), react()],
         resolve: {
           alias: {
@@ -3625,7 +4532,7 @@ export default PostHog;
       } finally {
         await metadataServer.close();
         try {
-          await fs9.rm(metadataTempDir, { recursive: true, force: true });
+          await fs10.rm(metadataTempDir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -3748,7 +4655,7 @@ export default {
           outDir,
           emptyOutDir: true,
           rollupOptions: {
-            input: import_node_path5.default.join(tempDir, "index.html"),
+            input: import_node_path6.default.join(tempDir, "index.html"),
             external: (id) => {
               return false;
             }
@@ -3758,8 +4665,8 @@ export default {
       const mcpServerUrl = process.env.MCP_SERVER_URL;
       if (mcpServerUrl) {
         try {
-          const htmlPath = import_node_path5.default.join(outDir, "index.html");
-          let html = await fs9.readFile(htmlPath, "utf8");
+          const htmlPath = import_node_path6.default.join(outDir, "index.html");
+          let html = await fs10.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(
@@ -3780,7 +4687,7 @@ export default {
     <base href="${mcpServerUrl}">`
             );
           }
-          await fs9.writeFile(htmlPath, html, "utf8");
+          await fs10.writeFile(htmlPath, html, "utf8");
           console.log(
             source_default.gray(`    \u2192 Injected MCP_SERVER_URL into ${widgetName}`)
           );
@@ -3806,27 +4713,27 @@ export default {
 }
 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_path5.default.resolve(options.path);
-    const { promises: fs9 } = await import("fs");
+    const projectPath = import_node_path6.default.resolve(options.path);
+    const { promises: fs10 } = await import("fs");
     console.log(source_default.cyan.bold(`mcp-use v${packageJson.version}`));
     const builtWidgets = await buildWidgets(projectPath);
     console.log(source_default.gray("Building TypeScript..."));
     await runCommand("npx", ["tsc"], projectPath);
     console.log(source_default.green("\u2713 TypeScript build complete!"));
-    const publicDir = import_node_path5.default.join(projectPath, "public");
+    const publicDir = import_node_path6.default.join(projectPath, "public");
     try {
-      await fs9.access(publicDir);
+      await fs10.access(publicDir);
       console.log(source_default.gray("Copying public assets..."));
-      await fs9.cp(publicDir, import_node_path5.default.join(projectPath, "dist", "public"), {
+      await fs10.cp(publicDir, import_node_path6.default.join(projectPath, "dist", "public"), {
         recursive: true
       });
       console.log(source_default.green("\u2713 Public assets copied"));
     } catch {
     }
-    const manifestPath = import_node_path5.default.join(projectPath, "dist", "mcp-use.json");
+    const manifestPath = import_node_path6.default.join(projectPath, "dist", "mcp-use.json");
     let existingManifest = {};
     try {
-      const existingContent = await fs9.readFile(manifestPath, "utf-8");
+      const existingContent = await fs10.readFile(manifestPath, "utf-8");
       existingManifest = JSON.parse(existingContent);
     } catch {
     }
@@ -3846,8 +4753,8 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
       buildId,
       widgets: widgetsData
     };
-    await fs9.mkdir(import_node_path5.default.dirname(manifestPath), { recursive: true });
-    await fs9.writeFile(
+    await fs10.mkdir(import_node_path6.default.dirname(manifestPath), { recursive: true });
+    await fs10.writeFile(
       manifestPath,
       JSON.stringify(manifest, null, 2),
       "utf8"
@@ -3868,7 +4775,7 @@ program.command("build").description("Build TypeScript and MCP UI widgets").opti
 });
 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_path5.default.resolve(options.path);
+    const projectPath = import_node_path6.default.resolve(options.path);
     let port = parseInt(options.port, 10);
     const host = options.host;
     console.log(source_default.cyan.bold(`mcp-use v${packageJson.version}`));
@@ -3947,8 +4854,9 @@ program.command("dev").description("Run development server with auto-reload and
 });
 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_path5.default.resolve(options.path);
-    const port = parseInt(options.port, 10);
+    const projectPath = import_node_path6.default.resolve(options.path);
+    const portFlagProvided = process.argv.includes("--port") || process.argv.includes("-p") || process.argv.some((arg) => arg.startsWith("--port=")) || process.argv.some((arg) => arg.startsWith("-p="));
+    const port = portFlagProvided ? parseInt(options.port, 10) : parseInt(process.env.PORT || options.port || "3000", 10);
     console.log(
       `\x1B[36m\x1B[1mmcp-use\x1B[0m \x1B[90mVersion: ${packageJson.version}\x1B[0m
 `
@@ -3958,7 +4866,7 @@ program.command("start").description("Start production server").option("-p, --pa
     let tunnelSubdomain = void 0;
     if (options.tunnel) {
       try {
-        const manifestPath = import_node_path5.default.join(projectPath, "dist", "mcp-use.json");
+        const manifestPath = import_node_path6.default.join(projectPath, "dist", "mcp-use.json");
         let existingSubdomain;
         try {
           const manifestContent = await (0, import_promises5.readFile)(manifestPath, "utf-8");
@@ -3992,7 +4900,7 @@ program.command("start").description("Start production server").option("-p, --pa
             manifest.tunnel = {};
           }
           manifest.tunnel.subdomain = subdomain;
-          await (0, import_promises5.mkdir)(import_node_path5.default.dirname(manifestPath), { recursive: true });
+          await (0, import_promises5.mkdir)(import_node_path6.default.dirname(manifestPath), { recursive: true });
           await (0, import_promises5.writeFile)(
             manifestPath,
             JSON.stringify(manifest, null, 2),
@@ -4012,7 +4920,7 @@ program.command("start").description("Start production server").option("-p, --pa
     }
     let serverFile = "dist/index.js";
     try {
-      await (0, import_promises5.access)(import_node_path5.default.join(projectPath, serverFile));
+      await (0, import_promises5.access)(import_node_path6.default.join(projectPath, serverFile));
     } catch {
       serverFile = "dist/server.js";
     }
@@ -4098,15 +5006,25 @@ program.command("whoami").description("Show current user information").action(as
 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) => {
+).option(
+  "--new",
+  "Force creation of new deployment instead of reusing linked deployment"
+).option(
+  "--env <key=value...>",
+  "Environment variables (can be used multiple times)"
+).option("--env-file <path>", "Path to .env file with environment variables").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
+    fromSource: options.fromSource,
+    new: options.new,
+    env: options.env,
+    envFile: options.envFile
   });
 });
 program.addCommand(createClientCommand());
+program.addCommand(createDeploymentsCommand());
 program.parse();
 //# sourceMappingURL=index.cjs.map