@leanmcp/cli 0.2.10 → 0.2.12

package/dist/index.js

@@ -3,12 +3,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
-import fs5 from "fs-extra";
-import path5 from "path";
-import ora3 from "ora";
+import chalk6 from "chalk";
+import fs7 from "fs-extra";
+import path7 from "path";
+import ora6 from "ora";
 import { createRequire } from "module";
-import { confirm } from "@inquirer/prompts";
+import { confirm as confirm3 } from "@inquirer/prompts";
 import { spawn as spawn3 } from "child_process";
 
 // src/commands/dev.ts
@@ -388,6 +388,1001 @@ async function startCommand() {
 }
 __name(startCommand, "startCommand");
 
+// src/commands/login.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+import path5 from "path";
+import fs5 from "fs-extra";
+import os from "os";
+import { input, confirm } from "@inquirer/prompts";
+var DEBUG_MODE = false;
+function setDebugMode(enabled) {
+  DEBUG_MODE = enabled;
+}
+__name(setDebugMode, "setDebugMode");
+function debug(message, ...args) {
+  if (DEBUG_MODE) {
+    console.log(chalk3.gray(`[DEBUG] ${message}`), ...args);
+  }
+}
+__name(debug, "debug");
+var CONFIG_DIR = path5.join(os.homedir(), ".leanmcp");
+var CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
+async function loadConfig() {
+  try {
+    if (await fs5.pathExists(CONFIG_FILE)) {
+      return await fs5.readJSON(CONFIG_FILE);
+    }
+  } catch (error) {
+  }
+  return {};
+}
+__name(loadConfig, "loadConfig");
+async function saveConfig(config) {
+  await fs5.ensureDir(CONFIG_DIR);
+  await fs5.writeJSON(CONFIG_FILE, config, {
+    spaces: 2
+  });
+}
+__name(saveConfig, "saveConfig");
+async function getApiKey() {
+  const config = await loadConfig();
+  return config.apiKey || null;
+}
+__name(getApiKey, "getApiKey");
+var ALLOWED_API_URLS = [
+  "https://api.leanmcp.com",
+  "https://devapi.leanmcp.com",
+  "https://qaapi.leanmcp.com",
+  "http://localhost:3001"
+];
+var DEFAULT_API_URL = "https://api.leanmcp.com";
+function isValidApiUrl(url) {
+  return ALLOWED_API_URLS.includes(url);
+}
+__name(isValidApiUrl, "isValidApiUrl");
+async function getApiUrl() {
+  const config = await loadConfig();
+  if (!config.apiUrl) {
+    return DEFAULT_API_URL;
+  }
+  if (!isValidApiUrl(config.apiUrl)) {
+    throw new Error(`Invalid API URL: ${config.apiUrl}
+Allowed URLs:
+  - https://api.leanmcp.com
+  - https://devapi.leanmcp.com
+  - https://qaapi.leanmcp.com
+  - http://localhost:3001`);
+  }
+  return config.apiUrl;
+}
+__name(getApiUrl, "getApiUrl");
+async function loginCommand() {
+  console.log(chalk3.cyan("\nLeanMCP Login\n"));
+  const existingConfig = await loadConfig();
+  if (existingConfig.apiKey) {
+    console.log(chalk3.yellow("You are already logged in."));
+    const shouldRelogin = await confirm({
+      message: "Do you want to replace the existing API key?",
+      default: false
+    });
+    if (!shouldRelogin) {
+      console.log(chalk3.gray("\nLogin cancelled. Existing API key preserved."));
+      return;
+    }
+  }
+  console.log(chalk3.white("To authenticate, you need an API key from LeanMCP.\n"));
+  console.log(chalk3.cyan("Steps:"));
+  console.log(chalk3.gray("  1. Go to: ") + chalk3.blue.underline("https://ship.leanmcp.com/api-keys"));
+  console.log(chalk3.gray('  2. Create a new API key with "BUILD_AND_DEPLOY" scope'));
+  console.log(chalk3.gray("  3. Copy the API key and paste it below\n"));
+  const apiKey = await input({
+    message: "Enter your API key:",
+    validate: /* @__PURE__ */ __name((value) => {
+      if (!value || value.trim().length === 0) {
+        return "API key is required";
+      }
+      if (!value.startsWith("airtrain_")) {
+        return 'Invalid API key format. API key should start with "airtrain_"';
+      }
+      return true;
+    }, "validate")
+  });
+  const spinner = ora3("Validating API key...").start();
+  try {
+    const apiUrl = await getApiUrl();
+    const validateUrl = `${apiUrl}/api-keys/validate`;
+    debug("API URL:", apiUrl);
+    debug("Validate URL:", validateUrl);
+    debug("Making validation request...");
+    const response = await fetch(validateUrl, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${apiKey.trim()}`,
+        "Content-Type": "application/json"
+      }
+    });
+    debug("Response status:", response.status);
+    debug("Response ok:", response.ok);
+    if (!response.ok) {
+      const errorText = await response.text();
+      debug("Error response:", errorText);
+      spinner.fail("Invalid API key");
+      console.error(chalk3.red("\nThe API key is invalid or has expired."));
+      console.log(chalk3.gray("Please check your API key and try again."));
+      if (DEBUG_MODE) {
+        console.log(chalk3.gray(`Debug: Status ${response.status}, Response: ${errorText}`));
+      }
+      process.exit(1);
+    }
+    await saveConfig({
+      apiKey: apiKey.trim(),
+      apiUrl,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    spinner.succeed("API key validated and saved");
+    console.log(chalk3.green("\nLogin successful!"));
+    console.log(chalk3.gray(`   Config saved to: ${CONFIG_FILE}
+`));
+    console.log(chalk3.cyan("You can now use:"));
+    console.log(chalk3.gray("  leanmcp deploy <folder>   - Deploy your MCP server"));
+    console.log(chalk3.gray("  leanmcp logout            - Remove your API key"));
+  } catch (error) {
+    spinner.fail("Failed to validate API key");
+    debug("Error:", error);
+    if (error instanceof Error && error.message.includes("fetch")) {
+      console.error(chalk3.red("\nCould not connect to LeanMCP servers."));
+      console.log(chalk3.gray("Please check your internet connection and try again."));
+    } else {
+      console.error(chalk3.red(`
+Error: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    if (DEBUG_MODE) {
+      console.log(chalk3.gray(`
+Debug: Full error: ${error}`));
+    }
+    process.exit(1);
+  }
+}
+__name(loginCommand, "loginCommand");
+async function logoutCommand() {
+  console.log(chalk3.cyan("\nLeanMCP Logout\n"));
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.yellow("You are not currently logged in."));
+    return;
+  }
+  const shouldLogout = await confirm({
+    message: "Are you sure you want to logout and remove your API key?",
+    default: false
+  });
+  if (!shouldLogout) {
+    console.log(chalk3.gray("\nLogout cancelled."));
+    return;
+  }
+  await saveConfig({
+    ...config,
+    apiKey: void 0,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(chalk3.green("\nLogged out successfully!"));
+  console.log(chalk3.gray(`   API key removed from: ${CONFIG_FILE}`));
+}
+__name(logoutCommand, "logoutCommand");
+async function whoamiCommand() {
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.yellow("\nYou are not logged in."));
+    console.log(chalk3.gray("Run `leanmcp login` to authenticate.\n"));
+    return;
+  }
+  console.log(chalk3.cyan("\nLeanMCP Authentication Status\n"));
+  console.log(chalk3.green("Logged in"));
+  console.log(chalk3.gray(`  API Key: ${config.apiKey.substring(0, 15)}...`));
+  console.log(chalk3.gray(`  API URL: ${config.apiUrl || "https://ship.leanmcp.com"}`));
+  if (config.lastUpdated) {
+    console.log(chalk3.gray(`  Last updated: ${new Date(config.lastUpdated).toLocaleString()}`));
+  }
+  console.log();
+}
+__name(whoamiCommand, "whoamiCommand");
+
+// src/commands/deploy.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+import path6 from "path";
+import fs6 from "fs-extra";
+import os2 from "os";
+import archiver from "archiver";
+import { input as input2, confirm as confirm2, select } from "@inquirer/prompts";
+
+// src/utils/name-generator.ts
+var ADJECTIVES = [
+  "swift",
+  "bright",
+  "calm",
+  "bold",
+  "cool",
+  "crisp",
+  "dark",
+  "dawn",
+  "deep",
+  "fair",
+  "fast",
+  "fine",
+  "glad",
+  "gold",
+  "good",
+  "gray",
+  "green",
+  "happy",
+  "keen",
+  "kind",
+  "late",
+  "lean",
+  "light",
+  "long",
+  "loud",
+  "mild",
+  "neat",
+  "new",
+  "nice",
+  "old",
+  "pale",
+  "pink",
+  "plain",
+  "prime",
+  "pure",
+  "quick",
+  "quiet",
+  "rare",
+  "red",
+  "rich",
+  "rough",
+  "royal",
+  "safe",
+  "sharp",
+  "shy",
+  "silver",
+  "slim",
+  "slow",
+  "smart",
+  "smooth",
+  "soft",
+  "solid",
+  "still",
+  "sunny",
+  "super",
+  "sweet",
+  "tall",
+  "tidy",
+  "tiny",
+  "true",
+  "warm",
+  "wild",
+  "wise",
+  "young"
+];
+var SCIENTISTS = [
+  // AI & Computer Science
+  "turing",
+  "shannon",
+  "mccarthy",
+  "minsky",
+  "newell",
+  "simon",
+  "dijkstra",
+  "knuth",
+  "hopper",
+  "lovelace",
+  "hinton",
+  "lecun",
+  "bengio",
+  "schmidhuber",
+  "hochreiter",
+  "sutskever",
+  "salakhutdinov",
+  "goodfellow",
+  "vaswani",
+  "bahdanau",
+  "mikolov",
+  "pearl",
+  "jordan",
+  "bishop",
+  "russell",
+  "norvig",
+  "ng",
+  "koller",
+  "murphy",
+  "bottou",
+  "hassabis",
+  "silver",
+  "hopfield",
+  "feifei",
+  "karpathy",
+  "li",
+  // Physics
+  "einstein",
+  "newton",
+  "hawking",
+  "feynman",
+  "bohr",
+  "planck",
+  "dirac",
+  "heisenberg",
+  "schrodinger",
+  "maxwell",
+  "faraday",
+  "curie",
+  "fermi",
+  "tesla",
+  "oppenheimer",
+  "pauli",
+  "born",
+  "yang",
+  "lee",
+  "wu",
+  "chandrasekhar",
+  "raman",
+  "bose",
+  "salam",
+  "weinberg",
+  "gell-mann",
+  "higgs",
+  "penrose",
+  // Mathematics
+  "euler",
+  "gauss",
+  "riemann",
+  "hilbert",
+  "godel",
+  "turing",
+  "nash",
+  "ramanujan",
+  "erdos",
+  "noether",
+  "galois",
+  "cauchy",
+  "laplace",
+  "fourier",
+  "leibniz",
+  "pascal",
+  "fermat",
+  "descartes",
+  "archimedes",
+  "euclid",
+  "pythagoras",
+  "fibonacci",
+  "cantor",
+  "poincare",
+  "kolmogorov",
+  "bayes",
+  "markov",
+  "rao",
+  "tao",
+  "mirzakhani",
+  "grothendieck",
+  "wiles",
+  "perelman"
+];
+function generateProjectName() {
+  const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  const scientist = SCIENTISTS[Math.floor(Math.random() * SCIENTISTS.length)];
+  const num = Math.floor(Math.random() * 100);
+  return `${adj}-${scientist}-${num}`;
+}
+__name(generateProjectName, "generateProjectName");
+
+// src/commands/deploy.ts
+var DEBUG_MODE2 = false;
+function setDeployDebugMode(enabled) {
+  DEBUG_MODE2 = enabled;
+}
+__name(setDeployDebugMode, "setDeployDebugMode");
+function debug2(message, ...args) {
+  if (DEBUG_MODE2) {
+    console.log(chalk4.gray(`[DEBUG] ${message}`), ...args);
+  }
+}
+__name(debug2, "debug");
+async function debugFetch(url, options = {}) {
+  debug2(`HTTP ${options.method || "GET"} ${url}`);
+  if (options.body && typeof options.body === "string") {
+    try {
+      const body = JSON.parse(options.body);
+      debug2("Request body:", JSON.stringify(body, null, 2));
+    } catch {
+      debug2("Request body:", options.body);
+    }
+  }
+  const startTime = Date.now();
+  const response = await fetch(url, options);
+  const duration = Date.now() - startTime;
+  debug2(`Response: ${response.status} ${response.statusText} (${duration}ms)`);
+  return response;
+}
+__name(debugFetch, "debugFetch");
+var API_ENDPOINTS = {
+  // Projects
+  projects: "/api/projects",
+  getUploadUrl: "/api/projects",
+  // Lambda builds
+  triggerBuild: "/api/lambda-builds/trigger",
+  getBuild: "/api/lambda-builds",
+  // Lambda deployments
+  createDeployment: "/api/lambda-deploy",
+  getDeployment: "/api/lambda-deploy",
+  // Lambda mapping
+  checkSubdomain: "/api/lambda-mapping/check",
+  createMapping: "/api/lambda-mapping"
+};
+async function createZipArchive(folderPath, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs6.createWriteStream(outputPath);
+    const archive = archiver("zip", {
+      zlib: {
+        level: 9
+      }
+    });
+    output.on("close", () => resolve(archive.pointer()));
+    archive.on("error", reject);
+    archive.pipe(output);
+    archive.glob("**/*", {
+      cwd: folderPath,
+      ignore: [
+        "node_modules/**",
+        ".git/**",
+        "dist/**",
+        ".next/**",
+        ".nuxt/**",
+        "__pycache__/**",
+        "*.log",
+        ".env.local",
+        ".DS_Store"
+      ]
+    });
+    archive.finalize();
+  });
+}
+__name(createZipArchive, "createZipArchive");
+async function waitForBuild(apiUrl, apiKey, buildId, spinner) {
+  const maxAttempts = 60;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    const response = await debugFetch(`${apiUrl}${API_ENDPOINTS.getBuild}/${buildId}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get build status: ${response.statusText}`);
+    }
+    const build2 = await response.json();
+    spinner.text = `Building... (${build2.status || "pending"})`;
+    if (build2.status === "succeeded" || build2.status === "SUCCEEDED") {
+      return {
+        imageUri: build2.imageUri,
+        status: "succeeded"
+      };
+    }
+    if (build2.status === "failed" || build2.status === "FAILED") {
+      throw new Error(`Build failed: ${build2.errorMessage || "Unknown error"}`);
+    }
+    await new Promise((r) => setTimeout(r, 5e3));
+    attempts++;
+  }
+  throw new Error("Build timed out after 5 minutes");
+}
+__name(waitForBuild, "waitForBuild");
+async function waitForDeployment(apiUrl, apiKey, deploymentId, spinner) {
+  const maxAttempts = 60;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    const response = await debugFetch(`${apiUrl}${API_ENDPOINTS.getDeployment}/${deploymentId}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get deployment status: ${response.statusText}`);
+    }
+    const deployment = await response.json();
+    spinner.text = `Deploying... (${deployment.status || "pending"})`;
+    if (deployment.status === "RUNNING") {
+      return {
+        functionUrl: deployment.functionUrl,
+        status: "running"
+      };
+    }
+    if (deployment.status === "FAILED") {
+      throw new Error(`Deployment failed: ${deployment.errorMessage || "Unknown error"}`);
+    }
+    await new Promise((r) => setTimeout(r, 5e3));
+    attempts++;
+  }
+  throw new Error("Deployment timed out after 5 minutes");
+}
+__name(waitForDeployment, "waitForDeployment");
+async function deployCommand(folderPath, options = {}) {
+  const deployStartTime = Date.now();
+  console.log(chalk4.cyan("\nLeanMCP Deploy\n"));
+  debug2("Starting deployment...");
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(chalk4.red("Not logged in."));
+    console.log(chalk4.gray("Run `leanmcp login` first to authenticate.\n"));
+    process.exit(1);
+  }
+  const apiUrl = await getApiUrl();
+  debug2("API URL:", apiUrl);
+  const absolutePath = path6.resolve(process.cwd(), folderPath);
+  if (!await fs6.pathExists(absolutePath)) {
+    console.error(chalk4.red(`Folder not found: ${absolutePath}`));
+    process.exit(1);
+  }
+  const hasMainTs = await fs6.pathExists(path6.join(absolutePath, "main.ts"));
+  const hasPackageJson = await fs6.pathExists(path6.join(absolutePath, "package.json"));
+  if (!hasMainTs && !hasPackageJson) {
+    console.error(chalk4.red("Not a valid project folder."));
+    console.log(chalk4.gray("Expected main.ts or package.json in the folder.\n"));
+    process.exit(1);
+  }
+  debug2("Fetching existing projects...");
+  let existingProjects = [];
+  try {
+    const projectsResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (projectsResponse.ok) {
+      existingProjects = await projectsResponse.json();
+      debug2(`Found ${existingProjects.length} existing projects`);
+    }
+  } catch (e) {
+    debug2("Could not fetch existing projects");
+  }
+  let projectName;
+  let existingProject = null;
+  let isUpdate = false;
+  let folderName = path6.basename(absolutePath);
+  if (hasPackageJson) {
+    try {
+      const pkg2 = await fs6.readJSON(path6.join(absolutePath, "package.json"));
+      folderName = pkg2.name || folderName;
+    } catch (e) {
+    }
+  }
+  const matchingProject = existingProjects.find((p) => p.name === folderName);
+  if (matchingProject) {
+    console.log(chalk4.yellow(`Project '${folderName}' already exists.
+`));
+    const choice = await select({
+      message: "What would you like to do?",
+      choices: [
+        {
+          value: "update",
+          name: `Update existing project '${folderName}'`
+        },
+        {
+          value: "new",
+          name: "Create a new project with a random name"
+        },
+        {
+          value: "cancel",
+          name: "Cancel deployment"
+        }
+      ]
+    });
+    if (choice === "cancel") {
+      console.log(chalk4.gray("\nDeployment cancelled.\n"));
+      return;
+    }
+    if (choice === "update") {
+      existingProject = matchingProject;
+      projectName = matchingProject.name;
+      isUpdate = true;
+      console.log(chalk4.yellow("\nWARNING: This will replace the existing deployment."));
+      console.log(chalk4.gray("The previous version will be overwritten.\n"));
+    } else {
+      projectName = generateProjectName();
+      console.log(chalk4.cyan(`
+Generated project name: ${chalk4.bold(projectName)}
+`));
+    }
+  } else {
+    projectName = generateProjectName();
+    console.log(chalk4.cyan(`Generated project name: ${chalk4.bold(projectName)}`));
+  }
+  console.log(chalk4.gray(`Path: ${absolutePath}
+`));
+  let subdomain = options.subdomain;
+  if (!subdomain) {
+    const suggestedSubdomain = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    subdomain = await input2({
+      message: "Subdomain for your deployment:",
+      default: suggestedSubdomain,
+      validate: /* @__PURE__ */ __name((value) => {
+        if (!value || value.trim().length === 0) {
+          return "Subdomain is required";
+        }
+        if (!/^[a-z0-9-]+$/.test(value)) {
+          return "Subdomain can only contain lowercase letters, numbers, and hyphens";
+        }
+        if (value.length < 3) {
+          return "Subdomain must be at least 3 characters";
+        }
+        return true;
+      }, "validate")
+    });
+  }
+  const checkSpinner = ora4("Checking subdomain availability...").start();
+  try {
+    debug2("Checking subdomain:", subdomain);
+    const checkResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.checkSubdomain}/${subdomain}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (checkResponse.ok) {
+      const result = await checkResponse.json();
+      if (!result.available) {
+        checkSpinner.fail(`Subdomain '${subdomain}' is already taken`);
+        console.log(chalk4.gray("\nPlease choose a different subdomain.\n"));
+        process.exit(1);
+      }
+    }
+    checkSpinner.succeed(`Subdomain '${subdomain}' is available`);
+  } catch (error) {
+    checkSpinner.warn("Could not verify subdomain availability");
+  }
+  if (!options.skipConfirm) {
+    console.log(chalk4.cyan("\nDeployment Details:"));
+    console.log(chalk4.gray(`  Project: ${projectName}`));
+    console.log(chalk4.gray(`  Subdomain: ${subdomain}`));
+    console.log(chalk4.gray(`  URL: https://${subdomain}.leanmcp.dev
+`));
+    const shouldDeploy = await confirm2({
+      message: "Proceed with deployment?",
+      default: true
+    });
+    if (!shouldDeploy) {
+      console.log(chalk4.gray("\nDeployment cancelled.\n"));
+      return;
+    }
+  }
+  console.log();
+  let projectId;
+  if (isUpdate && existingProject) {
+    projectId = existingProject.id;
+    console.log(chalk4.gray(`Using existing project: ${projectId.substring(0, 8)}...`));
+  } else {
+    const projectSpinner = ora4("Creating project...").start();
+    try {
+      debug2("Step 1: Creating project:", projectName);
+      const createResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          name: projectName
+        })
+      });
+      if (!createResponse.ok) {
+        const error = await createResponse.text();
+        throw new Error(`Failed to create project: ${error}`);
+      }
+      const project = await createResponse.json();
+      projectId = project.id;
+      projectSpinner.succeed(`Project created: ${projectId.substring(0, 8)}...`);
+    } catch (error) {
+      projectSpinner.fail("Failed to create project");
+      console.error(chalk4.red(`
+${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+  }
+  const uploadSpinner = ora4("Packaging and uploading...").start();
+  try {
+    const tempZip = path6.join(os2.tmpdir(), `leanmcp-${Date.now()}.zip`);
+    const zipSize = await createZipArchive(absolutePath, tempZip);
+    uploadSpinner.text = `Packaging... (${Math.round(zipSize / 1024)}KB)`;
+    debug2("Step 2a: Getting upload URL for project:", projectId);
+    const uploadUrlResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}/${projectId}/upload-url`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        fileName: `${subdomain}.zip`,
+        fileType: "application/zip",
+        fileSize: zipSize
+      })
+    });
+    if (!uploadUrlResponse.ok) {
+      throw new Error("Failed to get upload URL");
+    }
+    const uploadResult = await uploadUrlResponse.json();
+    const uploadUrl = uploadResult.url || uploadResult.uploadUrl;
+    const s3Location = uploadResult.s3Location;
+    debug2("Upload URL response:", JSON.stringify(uploadResult));
+    if (!uploadUrl) {
+      throw new Error("Backend did not return upload URL");
+    }
+    debug2("Step 2b: Uploading to S3...");
+    const zipBuffer = await fs6.readFile(tempZip);
+    const s3Response = await fetch(uploadUrl, {
+      method: "PUT",
+      body: zipBuffer,
+      headers: {
+        "Content-Type": "application/zip"
+      }
+    });
+    debug2("S3 upload response:", s3Response.status);
+    if (!s3Response.ok) {
+      throw new Error("Failed to upload to S3");
+    }
+    debug2("Step 2c: Updating project with S3 location:", s3Location);
+    await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}/${projectId}`, {
+      method: "PATCH",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        s3Location
+      })
+    });
+    await fs6.remove(tempZip);
+    uploadSpinner.succeed("Project uploaded");
+  } catch (error) {
+    uploadSpinner.fail("Failed to upload");
+    console.error(chalk4.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+  const buildSpinner = ora4("Building...").start();
+  const buildStartTime = Date.now();
+  let buildId;
+  let imageUri;
+  try {
+    debug2("Step 3: Triggering build for project:", projectId);
+    const buildResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.triggerBuild}/${projectId}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!buildResponse.ok) {
+      const error = await buildResponse.text();
+      throw new Error(`Failed to trigger build: ${error}`);
+    }
+    const build2 = await buildResponse.json();
+    buildId = build2.id;
+    const buildResult = await waitForBuild(apiUrl, apiKey, buildId, buildSpinner);
+    imageUri = buildResult.imageUri;
+    const buildDuration = Math.round((Date.now() - buildStartTime) / 1e3);
+    buildSpinner.succeed(`Build complete (${buildDuration}s)`);
+  } catch (error) {
+    buildSpinner.fail("Build failed");
+    console.error(chalk4.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+  const deploySpinner = ora4("Deploying to LeanMCP...").start();
+  let deploymentId;
+  let functionUrl;
+  try {
+    debug2("Step 4: Creating deployment for build:", buildId);
+    const deployResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.createDeployment}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        buildId
+      })
+    });
+    if (!deployResponse.ok) {
+      const error = await deployResponse.text();
+      throw new Error(`Failed to create deployment: ${error}`);
+    }
+    const deployment = await deployResponse.json();
+    deploymentId = deployment.id;
+    const deployResult = await waitForDeployment(apiUrl, apiKey, deploymentId, deploySpinner);
+    functionUrl = deployResult.functionUrl;
+    deploySpinner.succeed("Deployed");
+  } catch (error) {
+    deploySpinner.fail("Deployment failed");
+    console.error(chalk4.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+  const mappingSpinner = ora4("Configuring subdomain...").start();
+  try {
+    debug2("Step 5: Creating subdomain mapping:", subdomain);
+    const mappingResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.createMapping}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        subdomain,
+        lambdaUrl: functionUrl,
+        projectId,
+        deploymentId
+      })
+    });
+    if (!mappingResponse.ok) {
+      mappingSpinner.warn("Subdomain mapping may need manual setup");
+    } else {
+      mappingSpinner.succeed("Subdomain configured");
+    }
+  } catch (error) {
+    mappingSpinner.warn("Subdomain mapping may need manual setup");
+  }
+  console.log(chalk4.green("\n" + "=".repeat(60)));
+  console.log(chalk4.green.bold("  DEPLOYMENT SUCCESSFUL!"));
+  console.log(chalk4.green("=".repeat(60) + "\n"));
+  console.log(chalk4.white("  Your MCP server is now live:\n"));
+  console.log(chalk4.cyan(`  URL:  `) + chalk4.white.bold(`https://${subdomain}.leanmcp.dev`));
+  console.log();
+  console.log(chalk4.gray("  Test endpoints:"));
+  console.log(chalk4.gray(`    curl https://${subdomain}.leanmcp.dev/health`));
+  console.log(chalk4.gray(`    curl https://${subdomain}.leanmcp.dev/mcp`));
+  console.log();
+  const totalDuration = Math.round((Date.now() - deployStartTime) / 1e3);
+  console.log(chalk4.gray(`  Total time: ${totalDuration}s`));
+  console.log();
+  console.log(chalk4.gray(`  Project ID:    ${projectId}`));
+  console.log(chalk4.gray(`  Build ID:      ${buildId}`));
+  console.log(chalk4.gray(`  Deployment ID: ${deploymentId}`));
+  console.log();
+}
+__name(deployCommand, "deployCommand");
+
+// src/commands/projects.ts
+import chalk5 from "chalk";
+import ora5 from "ora";
+var API_ENDPOINT = "/api/projects";
+async function projectsListCommand() {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(chalk5.red("\nNot logged in."));
+    console.log(chalk5.gray("Run `leanmcp login` first to authenticate.\n"));
+    process.exit(1);
+  }
+  const spinner = ora5("Fetching projects...").start();
+  try {
+    const apiUrl = await getApiUrl();
+    const response = await fetch(`${apiUrl}${API_ENDPOINT}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch projects: ${response.statusText}`);
+    }
+    const projects = await response.json();
+    spinner.stop();
+    if (projects.length === 0) {
+      console.log(chalk5.yellow("\nNo projects found."));
+      console.log(chalk5.gray("Create one with: leanmcp deploy <folder>\n"));
+      return;
+    }
+    console.log(chalk5.cyan(`
+Your Projects (${projects.length})
+`));
+    console.log(chalk5.gray("\u2500".repeat(60)));
+    for (const project of projects) {
+      const statusColor = project.status === "ACTIVE" ? chalk5.green : chalk5.yellow;
+      console.log(chalk5.white.bold(`  ${project.name}`));
+      console.log(chalk5.gray(`    ID: ${project.id}`));
+      console.log(chalk5.gray(`    Status: `) + statusColor(project.status));
+      console.log(chalk5.gray(`    Created: ${new Date(project.createdAt).toLocaleDateString()}`));
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail("Failed to fetch projects");
+    console.error(chalk5.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+__name(projectsListCommand, "projectsListCommand");
+async function projectsGetCommand(projectId) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(chalk5.red("\nNot logged in."));
+    console.log(chalk5.gray("Run `leanmcp login` first to authenticate.\n"));
+    process.exit(1);
+  }
+  const spinner = ora5("Fetching project...").start();
+  try {
+    const apiUrl = await getApiUrl();
+    const response = await fetch(`${apiUrl}${API_ENDPOINT}/${projectId}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Project not found: ${projectId}`);
+      }
+      throw new Error(`Failed to fetch project: ${response.statusText}`);
+    }
+    const project = await response.json();
+    spinner.stop();
+    console.log(chalk5.cyan("\nProject Details\n"));
+    console.log(chalk5.gray("\u2500".repeat(60)));
+    console.log(chalk5.white.bold(`  Name: ${project.name}`));
+    console.log(chalk5.gray(`  ID: ${project.id}`));
+    console.log(chalk5.gray(`  Status: ${project.status}`));
+    if (project.s3Location) {
+      console.log(chalk5.gray(`  S3 Location: ${project.s3Location}`));
+    }
+    console.log(chalk5.gray(`  Created: ${new Date(project.createdAt).toLocaleString()}`));
+    if (project.updatedAt) {
+      console.log(chalk5.gray(`  Updated: ${new Date(project.updatedAt).toLocaleString()}`));
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to fetch project");
+    console.error(chalk5.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+__name(projectsGetCommand, "projectsGetCommand");
+async function projectsDeleteCommand(projectId, options = {}) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.error(chalk5.red("\nNot logged in."));
+    console.log(chalk5.gray("Run `leanmcp login` first to authenticate.\n"));
+    process.exit(1);
+  }
+  if (!options.force) {
+    const { confirm: confirm4 } = await import("@inquirer/prompts");
+    const shouldDelete = await confirm4({
+      message: `Are you sure you want to delete project ${projectId}?`,
+      default: false
+    });
+    if (!shouldDelete) {
+      console.log(chalk5.gray("\nDeletion cancelled.\n"));
+      return;
+    }
+  }
+  const spinner = ora5("Deleting project...").start();
+  try {
+    const apiUrl = await getApiUrl();
+    const response = await fetch(`${apiUrl}${API_ENDPOINT}/${projectId}`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        throw new Error(`Project not found: ${projectId}`);
+      }
+      throw new Error(`Failed to delete project: ${response.statusText}`);
+    }
+    spinner.succeed("Project deleted successfully");
+    console.log();
+  } catch (error) {
+    spinner.fail("Failed to delete project");
+    console.error(chalk5.red(`
+${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+__name(projectsDeleteCommand, "projectsDeleteCommand");
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
@@ -398,17 +1393,24 @@ __name(capitalize, "capitalize");
 var program = new Command();
 program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version(pkg.version).addHelpText("after", `
 Examples:
-  $ leanmcp create my-app --allow-all    # Scaffold without interactive prompts
+  $ leanmcp create my-app                # Create new project (interactive)
+  $ leanmcp create my-app --install      # Create and install deps (non-interactive)
+  $ leanmcp create my-app --no-install   # Create without installing deps
+  $ leanmcp dev                          # Start development server
+  $ leanmcp login                        # Authenticate with LeanMCP cloud
+  $ leanmcp deploy ./my-app              # Deploy to LeanMCP cloud
+  $ leanmcp projects list                # List your cloud projects
+  $ leanmcp projects delete <id>         # Delete a cloud project
 `);
-program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").option("--allow-all", "Skip interactive confirmations and assume Yes").option("--no-dashboard", "Disable dashboard UI at / and /mcp GET endpoints").action(async (projectName, options) => {
-  const spinner = ora3(`Creating project ${projectName}...`).start();
-  const targetDir = path5.join(process.cwd(), projectName);
-  if (fs5.existsSync(targetDir)) {
+program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").option("--allow-all", "Skip interactive confirmations and assume Yes").option("--no-dashboard", "Disable dashboard UI at / and /mcp GET endpoints").option("--install", "Install dependencies automatically (non-interactive, no dev server)").option("--no-install", "Skip dependency installation (non-interactive)").action(async (projectName, options) => {
+  const spinner = ora6(`Creating project ${projectName}...`).start();
+  const targetDir = path7.join(process.cwd(), projectName);
+  if (fs7.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await fs5.mkdirp(targetDir);
-  await fs5.mkdirp(path5.join(targetDir, "mcp", "example"));
+  await fs7.mkdirp(targetDir);
+  await fs7.mkdirp(path7.join(targetDir, "mcp", "example"));
   const pkg2 = {
     name: projectName,
     version: "1.0.0",
@@ -439,7 +1441,7 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       "typescript": "^5.6.3"
     }
   };
-  await fs5.writeJSON(path5.join(targetDir, "package.json"), pkg2, {
+  await fs7.writeJSON(path7.join(targetDir, "package.json"), pkg2, {
     spaces: 2
   });
   const tsconfig = {
@@ -462,7 +1464,7 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       "dist"
     ]
   };
-  await fs5.writeJSON(path5.join(targetDir, "tsconfig.json"), tsconfig, {
+  await fs7.writeJSON(path7.join(targetDir, "tsconfig.json"), tsconfig, {
     spaces: 2
   });
   const dashboardLine = options.dashboard === false ? `
@@ -484,7 +1486,7 @@ await createHTTPServer({
 
 console.log("\\n${projectName} MCP Server");
 `;
-  await fs5.writeFile(path5.join(targetDir, "main.ts"), mainTs);
+  await fs7.writeFile(path7.join(targetDir, "main.ts"), mainTs);
   const exampleServiceTs = `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
 
     /**
@@ -604,7 +1606,7 @@ console.log("\\n${projectName} MCP Server");
   }
 }
 `;
-  await fs5.writeFile(path5.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
+  await fs7.writeFile(path7.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
   const gitignore = `# Logs
 logs
 *.log
@@ -753,8 +1755,8 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-  await fs5.writeFile(path5.join(targetDir, ".gitignore"), gitignore);
-  await fs5.writeFile(path5.join(targetDir, ".env"), env);
+  await fs7.writeFile(path7.join(targetDir, ".gitignore"), gitignore);
+  await fs7.writeFile(path7.join(targetDir, ".env"), env);
   const readme = `# ${projectName}
 
 MCP Server with Streamable HTTP Transport built with LeanMCP SDK
@@ -840,18 +1842,26 @@ npx @modelcontextprotocol/inspector http://localhost:3001/mcp
 
 MIT
 `;
-  await fs5.writeFile(path5.join(targetDir, "README.md"), readme);
+  await fs7.writeFile(path7.join(targetDir, "README.md"), readme);
   spinner.succeed(`Project ${projectName} created!`);
-  console.log(chalk3.green("\nSuccess! Your MCP server is ready.\n"));
-  console.log(chalk3.cyan(`Next, navigate to your project:
+  console.log(chalk6.green("\nSuccess! Your MCP server is ready.\n"));
+  console.log(chalk6.cyan(`Next, navigate to your project:
   cd ${projectName}
 `));
-  const shouldInstall = options.allowAll ? true : await confirm({
+  const isNonInteractive = options.install !== void 0 || options.allowAll;
+  if (options.install === false) {
+    console.log(chalk6.cyan("\nTo get started:"));
+    console.log(chalk6.gray(`  cd ${projectName}`));
+    console.log(chalk6.gray(`  npm install`));
+    console.log(chalk6.gray(`  npm run dev`));
+    return;
+  }
+  const shouldInstall = isNonInteractive ? true : await confirm3({
     message: "Would you like to install dependencies now?",
     default: true
   });
   if (shouldInstall) {
-    const installSpinner = ora3("Installing dependencies...").start();
+    const installSpinner = ora6("Installing dependencies...").start();
     try {
       await new Promise((resolve, reject) => {
         const npmInstall = spawn3("npm", [
@@ -871,12 +1881,18 @@ MIT
         npmInstall.on("error", reject);
       });
       installSpinner.succeed("Dependencies installed successfully!");
-      const shouldStartDev = options.allowAll ? true : await confirm({
+      if (options.install === true) {
+        console.log(chalk6.cyan("\nTo start the development server:"));
+        console.log(chalk6.gray(`  cd ${projectName}`));
+        console.log(chalk6.gray(`  npm run dev`));
+        return;
+      }
+      const shouldStartDev = options.allowAll ? true : await confirm3({
         message: "Would you like to start the development server?",
         default: true
       });
       if (shouldStartDev) {
-        console.log(chalk3.cyan("\nStarting development server...\n"));
+        console.log(chalk6.cyan("\nStarting development server...\n"));
         const devServer = spawn3("npm", [
           "run",
           "dev"
@@ -890,38 +1906,38 @@ MIT
           process.exit(0);
         });
       } else {
-        console.log(chalk3.cyan("\nTo start the development server later:"));
-        console.log(chalk3.gray(`  cd ${projectName}`));
-        console.log(chalk3.gray(`  npm run dev`));
+        console.log(chalk6.cyan("\nTo start the development server later:"));
+        console.log(chalk6.gray(`  cd ${projectName}`));
+        console.log(chalk6.gray(`  npm run dev`));
       }
     } catch (error) {
       installSpinner.fail("Failed to install dependencies");
-      console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
-      console.log(chalk3.cyan("\nYou can install dependencies manually:"));
-      console.log(chalk3.gray(`  cd ${projectName}`));
-      console.log(chalk3.gray(`  npm install`));
+      console.error(chalk6.red(error instanceof Error ? error.message : String(error)));
+      console.log(chalk6.cyan("\nYou can install dependencies manually:"));
+      console.log(chalk6.gray(`  cd ${projectName}`));
+      console.log(chalk6.gray(`  npm install`));
     }
   } else {
-    console.log(chalk3.cyan("\nTo get started:"));
-    console.log(chalk3.gray(`  cd ${projectName}`));
-    console.log(chalk3.gray(`  npm install`));
-    console.log(chalk3.gray(`  npm run dev`));
+    console.log(chalk6.cyan("\nTo get started:"));
+    console.log(chalk6.gray(`  cd ${projectName}`));
+    console.log(chalk6.gray(`  npm install`));
+    console.log(chalk6.gray(`  npm run dev`));
   }
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = path5.join(cwd, "mcp");
-  if (!fs5.existsSync(path5.join(cwd, "main.ts"))) {
-    console.error(chalk3.red("ERROR: Not a LeanMCP project (main.ts missing)."));
+  const mcpDir = path7.join(cwd, "mcp");
+  if (!fs7.existsSync(path7.join(cwd, "main.ts"))) {
+    console.error(chalk6.red("ERROR: Not a LeanMCP project (main.ts missing)."));
     process.exit(1);
   }
-  const serviceDir = path5.join(mcpDir, serviceName);
-  const serviceFile = path5.join(serviceDir, "index.ts");
-  if (fs5.existsSync(serviceDir)) {
-    console.error(chalk3.red(`ERROR: Service ${serviceName} already exists.`));
+  const serviceDir = path7.join(mcpDir, serviceName);
+  const serviceFile = path7.join(serviceDir, "index.ts");
+  if (fs7.existsSync(serviceDir)) {
+    console.error(chalk6.red(`ERROR: Service ${serviceName} already exists.`));
     process.exit(1);
   }
-  await fs5.mkdirp(serviceDir);
+  await fs7.mkdirp(serviceDir);
   const indexTs = `import { Tool, Resource, Prompt, Optional, SchemaConstraint } from "@leanmcp/core";
 
 // Input schema for greeting
@@ -981,14 +1997,37 @@ export class ${capitalize(serviceName)}Service {
   }
 }
 `;
-  await fs5.writeFile(serviceFile, indexTs);
-  console.log(chalk3.green(`\\nCreated new service: ${chalk3.bold(serviceName)}`));
-  console.log(chalk3.gray(`   File: mcp/${serviceName}/index.ts`));
-  console.log(chalk3.gray(`   Tool: greet`));
-  console.log(chalk3.gray(`   Prompt: welcomePrompt`));
-  console.log(chalk3.gray(`   Resource: getStatus`));
-  console.log(chalk3.green(`\\nService will be automatically discovered on next server start!`));
+  await fs7.writeFile(serviceFile, indexTs);
+  console.log(chalk6.green(`\\nCreated new service: ${chalk6.bold(serviceName)}`));
+  console.log(chalk6.gray(`   File: mcp/${serviceName}/index.ts`));
+  console.log(chalk6.gray(`   Tool: greet`));
+  console.log(chalk6.gray(`   Prompt: welcomePrompt`));
+  console.log(chalk6.gray(`   Resource: getStatus`));
+  console.log(chalk6.green(`\\nService will be automatically discovered on next server start!`));
 });
 program.command("dev").description("Start development server with UI hot-reload (builds @UIApp components)").action(devCommand);
 program.command("start").description("Build UI components and start production server").action(startCommand);
+program.command("login").description("Authenticate with LeanMCP cloud using an API key").option("--debug", "Enable debug logging").action(async (options) => {
+  if (options.debug) {
+    setDebugMode(true);
+  }
+  await loginCommand();
+});
+program.command("logout").description("Remove stored API key and logout from LeanMCP cloud").action(logoutCommand);
+program.command("whoami").description("Show current authentication status").action(whoamiCommand);
+program.command("deploy [folder]").description("Deploy an MCP server to LeanMCP cloud").option("-s, --subdomain <subdomain>", "Subdomain for deployment").option("-y, --yes", "Skip confirmation prompts").option("--debug", "Enable debug logging for network calls").action(async (folder, options) => {
+  if (options.debug) {
+    setDebugMode(true);
+    setDeployDebugMode(true);
+  }
+  const targetFolder = folder || ".";
+  await deployCommand(targetFolder, {
+    subdomain: options.subdomain,
+    skipConfirm: options.yes
+  });
+});
+var projectsCmd = program.command("projects").description("Manage LeanMCP cloud projects");
+projectsCmd.command("list").alias("ls").description("List all your projects").action(projectsListCommand);
+projectsCmd.command("get <projectId>").description("Get details of a specific project").action(projectsGetCommand);
+projectsCmd.command("delete <projectId>").alias("rm").description("Delete a project").option("-f, --force", "Skip confirmation prompt").action((projectId, options) => projectsDeleteCommand(projectId, options));
 program.parse();