@leanmcp/cli 0.4.2 → 0.4.3

package/dist/index.js

@@ -3,7 +3,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { Command } from "commander";
-import chalk7 from "chalk";
 import fs8 from "fs-extra";
 import path8 from "path";
 import ora7 from "ora";
@@ -13,11 +12,10 @@ import { spawn as spawn4 } from "child_process";
 
 // src/commands/dev.ts
 import { spawn } from "child_process";
-import chalk from "chalk";
 import ora from "ora";
 import path3 from "path";
 import fs3 from "fs-extra";
-import crypto from "crypto";
+import crypto2 from "crypto";
 import chokidar from "chokidar";
 
 // src/vite/scanUIApp.ts
@@ -469,10 +467,199 @@ async function deleteUIComponent(uri, projectDir) {
 }
 __name(deleteUIComponent, "deleteUIComponent");
 
+// src/logger.ts
+import chalk from "chalk";
+import os from "os";
+import crypto from "crypto";
+import { execSync } from "child_process";
+var POSTHOG_API_KEY = "phc_EoMHKFbx6j2wUFsf8ywqgHntY4vEXC3ZzLFoPJVjRRT";
+var POSTHOG_API_HOST = "https://d18m0xvdtnkibr.cloudfront.net";
+var DEBUG_MODE = false;
+function setDebugMode(enabled) {
+  DEBUG_MODE = enabled;
+}
+__name(setDebugMode, "setDebugMode");
+function isDebugMode() {
+  return DEBUG_MODE;
+}
+__name(isDebugMode, "isDebugMode");
+function debug(message, ...args) {
+  if (DEBUG_MODE) {
+    console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+  }
+}
+__name(debug, "debug");
+var isTelemetryDisabled = /* @__PURE__ */ __name(() => {
+  return process.env.LEANMCP_DISABLE_TELEMETRY === "true";
+}, "isTelemetryDisabled");
+var getAnonymousId = /* @__PURE__ */ __name(() => {
+  const identifier = `${os.hostname()}-${os.userInfo().username}`;
+  return crypto.createHash("sha256").update(identifier).digest("hex").substring(0, 16);
+}, "getAnonymousId");
+var cachedNpmVersion = null;
+var getNpmVersion = /* @__PURE__ */ __name(() => {
+  if (cachedNpmVersion) return cachedNpmVersion;
+  try {
+    cachedNpmVersion = execSync("npm --version", {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    cachedNpmVersion = "unknown";
+  }
+  return cachedNpmVersion;
+}, "getNpmVersion");
+var getSystemInfo = /* @__PURE__ */ __name(() => {
+  return {
+    $os: os.platform(),
+    $os_version: os.release(),
+    arch: os.arch(),
+    node_version: process.version,
+    npm_version: getNpmVersion(),
+    cpu_count: os.cpus().length,
+    cpu_model: os.cpus()[0]?.model || "unknown",
+    ram_total_gb: Math.round(os.totalmem() / (1024 * 1024 * 1024) * 10) / 10,
+    ram_free_gb: Math.round(os.freemem() / (1024 * 1024 * 1024) * 10) / 10,
+    hostname_hash: getAnonymousId()
+  };
+}, "getSystemInfo");
+var systemInfoSent = false;
+var sendToPostHog = /* @__PURE__ */ __name((eventName, properties = {}) => {
+  if (isTelemetryDisabled()) {
+    debug("[PostHog] Telemetry disabled, skipping event:", eventName);
+    return;
+  }
+  setImmediate(() => {
+    try {
+      const systemProps = !systemInfoSent ? getSystemInfo() : {};
+      systemInfoSent = true;
+      const payload = {
+        api_key: POSTHOG_API_KEY,
+        event: eventName,
+        properties: {
+          distinct_id: getAnonymousId(),
+          $lib: "leanmcp-cli",
+          ...systemProps,
+          ...properties
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const url = `${POSTHOG_API_HOST}/capture/`;
+      debug(`[PostHog] POST ${url}`);
+      debug(`[PostHog] Event: ${eventName}`);
+      debug(`[PostHog] Payload:`, JSON.stringify(payload, null, 2));
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      }).then((response) => {
+        clearTimeout(timeoutId);
+        debug(`[PostHog] Response: ${response.status} ${response.statusText}`);
+      }).catch((err) => {
+        clearTimeout(timeoutId);
+        debug(`[PostHog] Error: ${err.message || err}`);
+      });
+    } catch (err) {
+      debug(`[PostHog] Exception: ${err.message || err}`);
+    }
+  });
+}, "sendToPostHog");
+var LoggerClass = class LoggerClass2 {
+  static {
+    __name(this, "LoggerClass");
+  }
+  /**
+  * Log a message to console and send cli_log event to PostHog
+  * @param text - The text to log
+  * @param styleFn - Optional chalk style function (e.g., chalk.cyan, chalk.green)
+  */
+  log(text, styleFn) {
+    if (styleFn) {
+      console.log(styleFn(text));
+    } else {
+      console.log(text);
+    }
+    sendToPostHog("cli_log", {
+      message: text,
+      level: "log"
+    });
+  }
+  /**
+  * Log a warning to console and send cli_warn event to PostHog
+  * @param text - The warning text
+  * @param styleFn - Optional chalk style function (defaults to chalk.yellow)
+  */
+  warn(text, styleFn) {
+    const style = styleFn || chalk.yellow;
+    console.log(style(text));
+    sendToPostHog("cli_warn", {
+      message: text,
+      level: "warn"
+    });
+  }
+  /**
+  * Log an error to console and send cli_error event to PostHog
+  * @param text - The error text
+  * @param styleFn - Optional chalk style function (defaults to chalk.red)
+  */
+  error(text, styleFn) {
+    const style = styleFn || chalk.red;
+    console.error(style(text));
+    sendToPostHog("cli_error", {
+      message: text,
+      level: "error"
+    });
+  }
+  /**
+  * Log an info message (alias for log with cyan styling)
+  * @param text - The info text
+  */
+  info(text) {
+    console.log(chalk.cyan(text));
+    sendToPostHog("cli_log", {
+      message: text,
+      level: "info"
+    });
+  }
+  /**
+  * Log a success message (green styling)
+  * @param text - The success text
+  */
+  success(text) {
+    console.log(chalk.green(text));
+    sendToPostHog("cli_log", {
+      message: text,
+      level: "success"
+    });
+  }
+  /**
+  * Log a gray/muted message
+  * @param text - The text to log
+  */
+  gray(text) {
+    console.log(chalk.gray(text));
+    sendToPostHog("cli_log", {
+      message: text,
+      level: "gray"
+    });
+  }
+};
+var logger = new LoggerClass();
+var trackCommand = /* @__PURE__ */ __name((command, options = {}) => {
+  sendToPostHog("cli_command", {
+    command,
+    options
+  });
+}, "trackCommand");
+
 // src/commands/dev.ts
 function computeHash(filePath) {
   const content = fs3.readFileSync(filePath, "utf-8");
-  return crypto.createHash("md5").update(content).digest("hex");
+  return crypto2.createHash("md5").update(content).digest("hex");
 }
 __name(computeHash, "computeHash");
 function computeDiff(previousUIApps, currentUIApps, hashCache) {
@@ -506,11 +693,11 @@ __name(computeDiff, "computeDiff");
 async function devCommand() {
   const cwd = process.cwd();
   if (!await fs3.pathExists(path3.join(cwd, "main.ts"))) {
-    console.error(chalk.red("ERROR: Not a LeanMCP project (main.ts not found)."));
-    console.error(chalk.gray("Run this command from your project root."));
+    logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
+    logger.gray("Run this command from your project root.");
     process.exit(1);
   }
-  console.log(chalk.cyan("\nLeanMCP Development Server\n"));
+  logger.info("\nLeanMCP Development Server\n");
   const scanSpinner = ora("Scanning for @UIApp components...").start();
   const uiApps = await scanUIApp(cwd);
   if (uiApps.length === 0) {
@@ -542,13 +729,13 @@ async function devCommand() {
     if (errors.length > 0) {
       buildSpinner.warn("Built with warnings");
       for (const error of errors) {
-        console.error(chalk.yellow(`   ${error}`));
+        logger.warn(`   ${error}`);
       }
     } else {
       buildSpinner.info("UI components built");
     }
   }
-  console.log(chalk.cyan("\nStarting development server...\n"));
+  logger.info("\nStarting development server...\n");
   const devServer = spawn("npx", [
     "tsx",
     "watch",
@@ -589,14 +776,14 @@ async function devCommand() {
         return;
       }
       for (const uri of diff.removed) {
-        console.log(chalk.yellow(`Removing ${uri}...`));
+        logger.warn(`Removing ${uri}...`);
         await deleteUIComponent(uri, cwd);
         delete manifest[uri];
         componentHashCache.delete(uri);
       }
       for (const app of diff.addedOrChanged) {
         const action = diff.added.has(app.resourceUri) ? "Building" : "Rebuilding";
-        console.log(chalk.cyan(`${action} ${app.componentName}...`));
+        logger.info(`${action} ${app.componentName}...`);
         const result = await buildUIComponent(app, cwd, true);
         if (result.success) {
           if (app.isGPTApp) {
@@ -611,9 +798,9 @@ async function devCommand() {
           if (await fs3.pathExists(app.componentPath)) {
             componentHashCache.set(app.resourceUri, computeHash(app.componentPath));
           }
-          console.log(chalk.green(`${app.componentName} ${action.toLowerCase()} complete`));
+          logger.success(`${app.componentName} ${action.toLowerCase()} complete`);
         } else {
-          console.log(chalk.yellow(`Build failed: ${result.error}`));
+          logger.warn(`Build failed: ${result.error}`);
         }
       }
       await writeUIManifest(manifest, cwd);
@@ -625,7 +812,7 @@ async function devCommand() {
   const cleanup = /* @__PURE__ */ __name(() => {
     if (isCleaningUp) return;
     isCleaningUp = true;
-    console.log(chalk.gray("\nShutting down..."));
+    logger.gray("\nShutting down...");
     if (watcher) {
       watcher.close();
       watcher = null;
@@ -653,18 +840,17 @@ __name(devCommand, "devCommand");
 
 // src/commands/build.ts
 import { spawn as spawn2 } from "child_process";
-import chalk2 from "chalk";
 import ora2 from "ora";
 import path4 from "path";
 import fs4 from "fs-extra";
 async function buildCommand() {
   const cwd = process.cwd();
   if (!await fs4.pathExists(path4.join(cwd, "main.ts"))) {
-    console.error(chalk2.red("ERROR: Not a LeanMCP project (main.ts not found)."));
-    console.error(chalk2.gray("Run this command from your project root."));
+    logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
+    logger.gray("Run this command from your project root.");
     process.exit(1);
   }
-  console.log(chalk2.cyan("\n\u{1F528} LeanMCP Build\n"));
+  logger.info("\n\u{1F528} LeanMCP Build\n");
   const scanSpinner = ora2("Scanning for @UIApp components...").start();
   const uiApps = await scanUIApp(cwd);
   if (uiApps.length === 0) {
@@ -692,7 +878,7 @@ async function buildCommand() {
     if (errors.length > 0) {
       buildSpinner.fail("Build failed");
       for (const error of errors) {
-        console.error(chalk2.red(`   \u2717 ${error}`));
+        logger.error(`   \u2717 ${error}`);
       }
       process.exit(1);
     }
@@ -721,29 +907,28 @@ async function buildCommand() {
     tscSpinner.succeed("TypeScript compiled");
   } catch (error) {
     tscSpinner.fail("TypeScript compilation failed");
-    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
-  console.log(chalk2.green("\nBuild complete!"));
-  console.log(chalk2.gray("\nTo start the server:"));
-  console.log(chalk2.cyan("  npm run start:node\n"));
+  logger.success("\nBuild complete!");
+  logger.gray("\nTo start the server:");
+  logger.info("  npm run start:node\n");
 }
 __name(buildCommand, "buildCommand");
 
 // src/commands/start.ts
 import { spawn as spawn3 } from "child_process";
-import chalk3 from "chalk";
 import ora3 from "ora";
 import path5 from "path";
 import fs5 from "fs-extra";
 async function startCommand() {
   const cwd = process.cwd();
   if (!await fs5.pathExists(path5.join(cwd, "main.ts"))) {
-    console.error(chalk3.red("ERROR: Not a LeanMCP project (main.ts not found)."));
-    console.error(chalk3.gray("Run this command from your project root."));
+    logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
+    logger.gray("Run this command from your project root.");
     process.exit(1);
   }
-  console.log(chalk3.cyan("\n\u{1F680} LeanMCP Production Build\n"));
+  logger.info("\n\u{1F680} LeanMCP Production Build\n");
   const scanSpinner = ora3("Scanning for @UIApp components...").start();
   const uiApps = await scanUIApp(cwd);
   if (uiApps.length === 0) {
@@ -775,7 +960,7 @@ async function startCommand() {
     if (errors.length > 0) {
       buildSpinner.fail("Build failed");
       for (const error of errors) {
-        console.error(chalk3.red(`   \u2717 ${error}`));
+        logger.error(`   \u2717 ${error}`);
       }
       process.exit(1);
     }
@@ -804,10 +989,10 @@ async function startCommand() {
     tscSpinner.succeed("TypeScript compiled");
   } catch (error) {
     tscSpinner.fail("TypeScript compilation failed");
-    console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+    logger.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
-  console.log(chalk3.cyan("\nStarting production server...\n"));
+  logger.info("\nStarting production server...\n");
   const server = spawn3("node", [
     "dist/main.js"
   ], {
@@ -820,7 +1005,7 @@ async function startCommand() {
   const cleanup = /* @__PURE__ */ __name(() => {
     if (isCleaningUp) return;
     isCleaningUp = true;
-    console.log(chalk3.gray("\nShutting down..."));
+    logger.gray("\nShutting down...");
     if (!isWindows && !server.killed) {
       server.kill("SIGTERM");
     }
@@ -828,7 +1013,7 @@ async function startCommand() {
   process.once("SIGINT", cleanup);
   process.once("SIGTERM", cleanup);
   server.on("error", (err) => {
-    console.error(chalk3.red(`Server error: ${err.message}`));
+    console.error(chalk.red(`Server error: ${err.message}`));
   });
   server.on("exit", (code, signal) => {
     setImmediate(() => {
@@ -839,24 +1024,23 @@ async function startCommand() {
 __name(startCommand, "startCommand");
 
 // src/commands/login.ts
-import chalk4 from "chalk";
 import ora4 from "ora";
 import path6 from "path";
 import fs6 from "fs-extra";
-import os from "os";
+import os2 from "os";
 import { input, confirm } from "@inquirer/prompts";
-var DEBUG_MODE = false;
-function setDebugMode(enabled) {
-  DEBUG_MODE = enabled;
+var DEBUG_MODE2 = false;
+function setDebugMode2(enabled) {
+  DEBUG_MODE2 = enabled;
 }
-__name(setDebugMode, "setDebugMode");
-function debug(message, ...args) {
-  if (DEBUG_MODE) {
-    console.log(chalk4.gray(`[DEBUG] ${message}`), ...args);
+__name(setDebugMode2, "setDebugMode");
+function debug2(message, ...args) {
+  if (DEBUG_MODE2 || isDebugMode()) {
+    console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
   }
 }
-__name(debug, "debug");
-var CONFIG_DIR = path6.join(os.homedir(), ".leanmcp");
+__name(debug2, "debug");
+var CONFIG_DIR = path6.join(os2.homedir(), ".leanmcp");
 var CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
 async function loadConfig() {
   try {
@@ -908,24 +1092,24 @@ Allowed URLs:
 }
 __name(getApiUrl, "getApiUrl");
 async function loginCommand() {
-  console.log(chalk4.cyan("\nLeanMCP Login\n"));
+  logger.info("\nLeanMCP Login\n");
   const existingConfig = await loadConfig();
   if (existingConfig.apiKey) {
-    console.log(chalk4.yellow("You are already logged in."));
+    logger.warn("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(chalk4.gray("\nLogin cancelled. Existing API key preserved."));
+      logger.gray("\nLogin cancelled. Existing API key preserved.");
       return;
     }
   }
-  console.log(chalk4.white("To authenticate, you need an API key from LeanMCP.\n"));
-  console.log(chalk4.cyan("Steps:"));
-  console.log(chalk4.gray("  1. Go to: ") + chalk4.blue.underline("https://ship.leanmcp.com/api-keys"));
-  console.log(chalk4.gray('  2. Create a new API key with "BUILD_AND_DEPLOY" scope'));
-  console.log(chalk4.gray("  3. Copy the API key and paste it below\n"));
+  logger.log("To authenticate, you need an API key from LeanMCP.\n", chalk.white);
+  logger.info("Steps:");
+  logger.log("  1. Go to: " + chalk.blue.underline("https://ship.leanmcp.com/api-keys"), chalk.gray);
+  logger.gray('  2. Create a new API key with "BUILD_AND_DEPLOY" scope');
+  logger.gray("  3. Copy the API key and paste it below\n");
   const apiKey = await input({
     message: "Enter your API key:",
     validate: /* @__PURE__ */ __name((value) => {
@@ -942,9 +1126,9 @@ async function loginCommand() {
   try {
     const apiUrl = await getApiUrl();
     const validateUrl = `${apiUrl}/api-keys/validate`;
-    debug("API URL:", apiUrl);
-    debug("Validate URL:", validateUrl);
-    debug("Making validation request...");
+    debug2("API URL:", apiUrl);
+    debug2("Validate URL:", validateUrl);
+    debug2("Making validation request...");
     const response = await fetch(validateUrl, {
       method: "GET",
       headers: {
@@ -952,16 +1136,16 @@ async function loginCommand() {
         "Content-Type": "application/json"
       }
     });
-    debug("Response status:", response.status);
-    debug("Response ok:", response.ok);
+    debug2("Response status:", response.status);
+    debug2("Response ok:", response.ok);
     if (!response.ok) {
       const errorText = await response.text();
-      debug("Error response:", errorText);
+      debug2("Error response:", errorText);
       spinner.fail("Invalid API key");
-      console.error(chalk4.red("\nThe API key is invalid or has expired."));
-      console.log(chalk4.gray("Please check your API key and try again."));
-      if (DEBUG_MODE) {
-        console.log(chalk4.gray(`Debug: Status ${response.status}, Response: ${errorText}`));
+      logger.error("\nThe API key is invalid or has expired.");
+      logger.gray("Please check your API key and try again.");
+      if (DEBUG_MODE2 || isDebugMode()) {
+        logger.gray(`Debug: Status ${response.status}, Response: ${errorText}`);
       }
       process.exit(1);
     }
@@ -971,35 +1155,35 @@ async function loginCommand() {
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     });
     spinner.succeed("API key validated and saved");
-    console.log(chalk4.green("\nLogin successful!"));
-    console.log(chalk4.gray(`   Config saved to: ${CONFIG_FILE}
-`));
-    console.log(chalk4.cyan("You can now use:"));
-    console.log(chalk4.gray("  leanmcp deploy <folder>   - Deploy your MCP server"));
-    console.log(chalk4.gray("  leanmcp logout            - Remove your API key"));
+    logger.success("\nLogin successful!");
+    logger.gray(`   Config saved to: ${CONFIG_FILE}
+`);
+    logger.info("You can now use:");
+    logger.gray("  leanmcp deploy <folder>   - Deploy your MCP server");
+    logger.gray("  leanmcp logout            - Remove your API key");
   } catch (error) {
     spinner.fail("Failed to validate API key");
-    debug("Error:", error);
+    debug2("Error:", error);
     if (error instanceof Error && error.message.includes("fetch")) {
-      console.error(chalk4.red("\nCould not connect to LeanMCP servers."));
-      console.log(chalk4.gray("Please check your internet connection and try again."));
+      logger.error("\nCould not connect to LeanMCP servers.");
+      logger.gray("Please check your internet connection and try again.");
     } else {
-      console.error(chalk4.red(`
-Error: ${error instanceof Error ? error.message : String(error)}`));
+      logger.error(`
+Error: ${error instanceof Error ? error.message : String(error)}`);
     }
-    if (DEBUG_MODE) {
-      console.log(chalk4.gray(`
-Debug: Full error: ${error}`));
+    if (DEBUG_MODE2 || isDebugMode()) {
+      logger.gray(`
+Debug: Full error: ${error}`);
     }
     process.exit(1);
   }
 }
 __name(loginCommand, "loginCommand");
 async function logoutCommand() {
-  console.log(chalk4.cyan("\nLeanMCP Logout\n"));
+  logger.info("\nLeanMCP Logout\n");
   const config = await loadConfig();
   if (!config.apiKey) {
-    console.log(chalk4.yellow("You are not currently logged in."));
+    logger.warn("You are not currently logged in.");
     return;
   }
   const shouldLogout = await confirm({
@@ -1007,7 +1191,7 @@ async function logoutCommand() {
     default: false
   });
   if (!shouldLogout) {
-    console.log(chalk4.gray("\nLogout cancelled."));
+    logger.gray("\nLogout cancelled.");
     return;
   }
   await saveConfig({
@@ -1015,34 +1199,71 @@ async function logoutCommand() {
     apiKey: void 0,
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   });
-  console.log(chalk4.green("\nLogged out successfully!"));
-  console.log(chalk4.gray(`   API key removed from: ${CONFIG_FILE}`));
+  logger.success("\nLogged out successfully!");
+  logger.gray(`   API key removed from: ${CONFIG_FILE}`);
 }
 __name(logoutCommand, "logoutCommand");
 async function whoamiCommand() {
   const config = await loadConfig();
   if (!config.apiKey) {
-    console.log(chalk4.yellow("\nYou are not logged in."));
-    console.log(chalk4.gray("Run `leanmcp login` to authenticate.\n"));
+    logger.warn("\nYou are not logged in.");
+    logger.gray("Run `leanmcp login` to authenticate.\n");
     return;
   }
-  console.log(chalk4.cyan("\nLeanMCP Authentication Status\n"));
-  console.log(chalk4.green("Logged in"));
-  console.log(chalk4.gray(`  API Key: ${config.apiKey.substring(0, 15)}...`));
-  console.log(chalk4.gray(`  API URL: ${config.apiUrl || "https://ship.leanmcp.com"}`));
-  if (config.lastUpdated) {
-    console.log(chalk4.gray(`  Last updated: ${new Date(config.lastUpdated).toLocaleString()}`));
+  const spinner = ora4("Fetching account info...").start();
+  try {
+    const apiUrl = await getApiUrl();
+    const whoamiUrl = `${apiUrl}/api-keys/whoami`;
+    debug2("API URL:", apiUrl);
+    debug2("Whoami URL:", whoamiUrl);
+    const response = await fetch(whoamiUrl, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    debug2("Response status:", response.status);
+    if (!response.ok) {
+      spinner.fail("Failed to fetch account info");
+      if (response.status === 401) {
+        logger.error("\nYour API key is invalid or has expired.");
+        logger.gray("Run `leanmcp login` to re-authenticate.\n");
+      } else {
+        logger.error(`
+Error: ${response.status} ${response.statusText}`);
+      }
+      return;
+    }
+    const user = await response.json();
+    spinner.succeed("Account info retrieved");
+    logger.info("\nLeanMCP Account\n");
+    logger.log(`  ${chalk.bold("Name:")}     ${user.displayName || user.username}`);
+    logger.log(`  ${chalk.bold("Email:")}    ${user.email}`);
+    logger.log(`  ${chalk.bold("Username:")} ${user.username}`);
+    logger.log(`  ${chalk.bold("Tier:")}     ${user.userTier || "free"}`);
+    logger.gray(`
+  API Key: ${config.apiKey.substring(0, 20)}...`);
+    logger.log("");
+  } catch (error) {
+    spinner.fail("Failed to fetch account info");
+    debug2("Error:", error);
+    if (error instanceof Error && error.message.includes("fetch")) {
+      logger.error("\nCould not connect to LeanMCP servers.");
+      logger.gray("Please check your internet connection and try again.");
+    } else {
+      logger.error(`
+Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
-  console.log();
 }
 __name(whoamiCommand, "whoamiCommand");
 
 // src/commands/deploy.ts
-import chalk5 from "chalk";
 import ora5 from "ora";
 import path7 from "path";
 import fs7 from "fs-extra";
-import os2 from "os";
+import os3 from "os";
 import archiver from "archiver";
 import { input as input2, confirm as confirm2, select } from "@inquirer/prompts";
 
@@ -1224,31 +1445,31 @@ function generateProjectName() {
 __name(generateProjectName, "generateProjectName");
 
 // src/commands/deploy.ts
-var DEBUG_MODE2 = false;
+var DEBUG_MODE3 = false;
 function setDeployDebugMode(enabled) {
-  DEBUG_MODE2 = enabled;
+  DEBUG_MODE3 = enabled;
 }
 __name(setDeployDebugMode, "setDeployDebugMode");
-function debug2(message, ...args) {
-  if (DEBUG_MODE2) {
-    console.log(chalk5.gray(`[DEBUG] ${message}`), ...args);
+function debug3(message, ...args) {
+  if (DEBUG_MODE3) {
+    console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
   }
 }
-__name(debug2, "debug");
+__name(debug3, "debug");
 async function debugFetch(url, options = {}) {
-  debug2(`HTTP ${options.method || "GET"} ${url}`);
+  debug3(`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));
+      debug3("Request body:", JSON.stringify(body, null, 2));
     } catch {
-      debug2("Request body:", options.body);
+      debug3("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)`);
+  debug3(`Response: ${response.status} ${response.statusText} (${duration}ms)`);
   return response;
 }
 __name(debugFetch, "debugFetch");
@@ -1266,6 +1487,32 @@ var API_ENDPOINTS = {
   checkSubdomain: "/api/lambda-mapping/check",
   createMapping: "/api/lambda-mapping"
 };
+var LEANMCP_CONFIG_DIR = ".leanmcp";
+var LEANMCP_CONFIG_FILE = "config.json";
+async function readLeanMCPConfig(projectPath) {
+  const configPath = path7.join(projectPath, LEANMCP_CONFIG_DIR, LEANMCP_CONFIG_FILE);
+  try {
+    if (await fs7.pathExists(configPath)) {
+      const config = await fs7.readJSON(configPath);
+      debug3("Found existing .leanmcp config:", config);
+      return config;
+    }
+  } catch (e) {
+    debug3("Could not read .leanmcp config:", e);
+  }
+  return null;
+}
+__name(readLeanMCPConfig, "readLeanMCPConfig");
+async function writeLeanMCPConfig(projectPath, config) {
+  const configDir = path7.join(projectPath, LEANMCP_CONFIG_DIR);
+  const configPath = path7.join(configDir, LEANMCP_CONFIG_FILE);
+  await fs7.ensureDir(configDir);
+  await fs7.writeJSON(configPath, config, {
+    spaces: 2
+  });
+  debug3("Saved .leanmcp config:", config);
+}
+__name(writeLeanMCPConfig, "writeLeanMCPConfig");
 async function createZipArchive(folderPath, outputPath) {
   return new Promise((resolve, reject) => {
     const output = fs7.createWriteStream(outputPath);
@@ -1282,6 +1529,7 @@ async function createZipArchive(folderPath, outputPath) {
       ignore: [
         "node_modules/**",
         ".git/**",
+        ".leanmcp/**",
         "dist/**",
         ".next/**",
         ".nuxt/**",
@@ -1355,64 +1603,45 @@ async function waitForDeployment(apiUrl, apiKey, deploymentId, spinner) {
 __name(waitForDeployment, "waitForDeployment");
 async function deployCommand(folderPath, options = {}) {
   const deployStartTime = Date.now();
-  console.log(chalk5.cyan("\nLeanMCP Deploy\n"));
-  debug2("Starting deployment...");
+  logger.info("\nLeanMCP Deploy\n");
+  debug3("Starting deployment...");
   const apiKey = await getApiKey();
   if (!apiKey) {
-    console.error(chalk5.red("Not logged in."));
-    console.log(chalk5.gray("Run `leanmcp login` first to authenticate.\n"));
+    logger.error("Not logged in.");
+    logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
   const apiUrl = await getApiUrl();
-  debug2("API URL:", apiUrl);
+  debug3("API URL:", apiUrl);
   const absolutePath = path7.resolve(process.cwd(), folderPath);
   if (!await fs7.pathExists(absolutePath)) {
-    console.error(chalk5.red(`Folder not found: ${absolutePath}`));
+    logger.error(`Folder not found: ${absolutePath}`);
     process.exit(1);
   }
   const hasMainTs = await fs7.pathExists(path7.join(absolutePath, "main.ts"));
   const hasPackageJson = await fs7.pathExists(path7.join(absolutePath, "package.json"));
   if (!hasMainTs && !hasPackageJson) {
-    console.error(chalk5.red("Not a valid project folder."));
-    console.log(chalk5.gray("Expected main.ts or package.json in the folder.\n"));
+    logger.error("Not a valid project folder.");
+    logger.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");
-  }
+  const existingConfig = await readLeanMCPConfig(absolutePath);
   let projectName;
   let existingProject = null;
   let isUpdate = false;
-  let folderName = path7.basename(absolutePath);
-  if (hasPackageJson) {
-    try {
-      const pkg2 = await fs7.readJSON(path7.join(absolutePath, "package.json"));
-      folderName = pkg2.name || folderName;
-    } catch (e) {
-    }
-  }
-  const matchingProject = existingProjects.find((p) => p.name === folderName);
-  if (matchingProject) {
-    console.log(chalk5.yellow(`Project '${folderName}' already exists.
-`));
+  let subdomain = options.subdomain;
+  if (existingConfig) {
+    logger.info(`Found existing deployment config for '${existingConfig.projectName}'`);
+    logger.gray(`  Project ID: ${existingConfig.projectId}`);
+    logger.gray(`  URL: ${existingConfig.url}`);
+    logger.gray(`  Last deployed: ${existingConfig.lastDeployedAt}
+`);
     const choice = await select({
       message: "What would you like to do?",
       choices: [
         {
           value: "update",
-          name: `Update existing project '${folderName}'`
+          name: `Update existing deployment '${existingConfig.projectName}'`
         },
         {
           value: "new",
@@ -1425,28 +1654,93 @@ async function deployCommand(folderPath, options = {}) {
       ]
     });
     if (choice === "cancel") {
-      console.log(chalk5.gray("\nDeployment cancelled.\n"));
+      logger.gray("\nDeployment cancelled.\n");
       return;
     }
     if (choice === "update") {
-      existingProject = matchingProject;
-      projectName = matchingProject.name;
+      existingProject = {
+        id: existingConfig.projectId,
+        name: existingConfig.projectName
+      };
+      projectName = existingConfig.projectName;
+      subdomain = existingConfig.subdomain;
       isUpdate = true;
-      console.log(chalk5.yellow("\nWARNING: This will replace the existing deployment."));
-      console.log(chalk5.gray("The previous version will be overwritten.\n"));
+      logger.warn("\nUpdating existing deployment...");
+      logger.gray("The previous version will be replaced.\n");
     } else {
       projectName = generateProjectName();
-      console.log(chalk5.cyan(`
-Generated project name: ${chalk5.bold(projectName)}
-`));
+      logger.info(`
+Generated project name: ${chalk.bold(projectName)}
+`);
     }
   } else {
-    projectName = generateProjectName();
-    console.log(chalk5.cyan(`Generated project name: ${chalk5.bold(projectName)}`));
+    debug3("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();
+        debug3(`Found ${existingProjects.length} existing projects`);
+      }
+    } catch (e) {
+      debug3("Could not fetch existing projects");
+    }
+    let folderName = path7.basename(absolutePath);
+    if (hasPackageJson) {
+      try {
+        const pkg2 = await fs7.readJSON(path7.join(absolutePath, "package.json"));
+        folderName = pkg2.name || folderName;
+      } catch (e) {
+      }
+    }
+    const matchingProject = existingProjects.find((p) => p.name === folderName);
+    if (matchingProject) {
+      logger.warn(`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") {
+        logger.gray("\nDeployment cancelled.\n");
+        return;
+      }
+      if (choice === "update") {
+        existingProject = matchingProject;
+        projectName = matchingProject.name;
+        isUpdate = true;
+        logger.warn("\nWARNING: This will replace the existing deployment.");
+        logger.gray("The previous version will be overwritten.\n");
+      } else {
+        projectName = generateProjectName();
+        logger.info(`
+Generated project name: ${chalk.bold(projectName)}
+`);
+      }
+    } else {
+      projectName = generateProjectName();
+      logger.info(`Generated project name: ${chalk.bold(projectName)}`);
+    }
   }
-  console.log(chalk5.gray(`Path: ${absolutePath}
-`));
-  let subdomain = options.subdomain;
+  logger.gray(`Path: ${absolutePath}
+`);
   if (!subdomain) {
     const suggestedSubdomain = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
     subdomain = await input2({
@@ -1468,7 +1762,7 @@ Generated project name: ${chalk5.bold(projectName)}
   }
   const checkSpinner = ora5("Checking subdomain availability...").start();
   try {
-    debug2("Checking subdomain:", subdomain);
+    debug3("Checking subdomain:", subdomain);
     const checkResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.checkSubdomain}/${subdomain}`, {
       headers: {
         "Authorization": `Bearer ${apiKey}`
@@ -1476,40 +1770,53 @@ Generated project name: ${chalk5.bold(projectName)}
     });
     if (checkResponse.ok) {
       const result = await checkResponse.json();
+      debug3("Subdomain check result:", result);
       if (!result.available) {
-        checkSpinner.fail(`Subdomain '${subdomain}' is already taken`);
-        console.log(chalk5.gray("\nPlease choose a different subdomain.\n"));
-        process.exit(1);
+        const ourProjectId = isUpdate && existingProject ? existingProject.id : null;
+        if (ourProjectId && result.ownedByProject === ourProjectId) {
+          checkSpinner.succeed(`Subdomain '${subdomain}' is yours - will update existing mapping`);
+        } else if (result.ownedByCurrentUser) {
+          checkSpinner.fail(`Subdomain '${subdomain}' is used by your other project`);
+          logger.gray(`
+This subdomain is associated with project: ${result.ownedByProject?.substring(0, 8)}...`);
+          logger.gray("Please choose a different subdomain or update that project instead.\n");
+          process.exit(1);
+        } else {
+          checkSpinner.fail(`Subdomain '${subdomain}' is not available`);
+          logger.gray("\nThis subdomain is taken by another user. Please choose a different subdomain.\n");
+          process.exit(1);
+        }
+      } else {
+        checkSpinner.succeed(`Subdomain '${subdomain}' is available`);
       }
     }
-    checkSpinner.succeed(`Subdomain '${subdomain}' is available`);
   } catch (error) {
     checkSpinner.warn("Could not verify subdomain availability");
   }
   if (!options.skipConfirm) {
-    console.log(chalk5.cyan("\nDeployment Details:"));
-    console.log(chalk5.gray(`  Project: ${projectName}`));
-    console.log(chalk5.gray(`  Subdomain: ${subdomain}`));
-    console.log(chalk5.gray(`  URL: https://${subdomain}.leanmcp.dev
-`));
+    logger.info("\nDeployment Details:");
+    logger.gray(`  Project: ${projectName}`);
+    logger.gray(`  Subdomain: ${subdomain}`);
+    logger.gray(`  URL: https://${subdomain}.leanmcp.app
+`);
     const shouldDeploy = await confirm2({
       message: "Proceed with deployment?",
       default: true
     });
     if (!shouldDeploy) {
-      console.log(chalk5.gray("\nDeployment cancelled.\n"));
+      logger.gray("\nDeployment cancelled.\n");
       return;
     }
   }
-  console.log();
+  logger.log("");
   let projectId;
   if (isUpdate && existingProject) {
     projectId = existingProject.id;
-    console.log(chalk5.gray(`Using existing project: ${projectId.substring(0, 8)}...`));
+    logger.gray(`Using existing project: ${projectId.substring(0, 8)}...`);
   } else {
     const projectSpinner = ora5("Creating project...").start();
     try {
-      debug2("Step 1: Creating project:", projectName);
+      debug3("Step 1: Creating project:", projectName);
       const createResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}`, {
         method: "POST",
         headers: {
@@ -1529,17 +1836,17 @@ Generated project name: ${chalk5.bold(projectName)}
       projectSpinner.succeed(`Project created: ${projectId.substring(0, 8)}...`);
     } catch (error) {
       projectSpinner.fail("Failed to create project");
-      console.error(chalk5.red(`
-${error instanceof Error ? error.message : String(error)}`));
+      logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
       process.exit(1);
     }
   }
   const uploadSpinner = ora5("Packaging and uploading...").start();
   try {
-    const tempZip = path7.join(os2.tmpdir(), `leanmcp-${Date.now()}.zip`);
+    const tempZip = path7.join(os3.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);
+    debug3("Step 2a: Getting upload URL for project:", projectId);
     const uploadUrlResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}/${projectId}/upload-url`, {
       method: "POST",
       headers: {
@@ -1558,11 +1865,11 @@ ${error instanceof Error ? error.message : String(error)}`));
     const uploadResult = await uploadUrlResponse.json();
     const uploadUrl = uploadResult.url || uploadResult.uploadUrl;
     const s3Location = uploadResult.s3Location;
-    debug2("Upload URL response:", JSON.stringify(uploadResult));
+    debug3("Upload URL response:", JSON.stringify(uploadResult));
     if (!uploadUrl) {
       throw new Error("Backend did not return upload URL");
     }
-    debug2("Step 2b: Uploading to S3...");
+    debug3("Step 2b: Uploading to S3...");
     const zipBuffer = await fs7.readFile(tempZip);
     const s3Response = await fetch(uploadUrl, {
       method: "PUT",
@@ -1571,11 +1878,11 @@ ${error instanceof Error ? error.message : String(error)}`));
         "Content-Type": "application/zip"
       }
     });
-    debug2("S3 upload response:", s3Response.status);
+    debug3("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);
+    debug3("Step 2c: Updating project with S3 location:", s3Location);
     await debugFetch(`${apiUrl}${API_ENDPOINTS.projects}/${projectId}`, {
       method: "PATCH",
       headers: {
@@ -1590,8 +1897,8 @@ ${error instanceof Error ? error.message : String(error)}`));
     uploadSpinner.succeed("Project uploaded");
   } catch (error) {
     uploadSpinner.fail("Failed to upload");
-    console.error(chalk5.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
   const buildSpinner = ora5("Building...").start();
@@ -1599,7 +1906,7 @@ ${error instanceof Error ? error.message : String(error)}`));
   let buildId;
   let imageUri;
   try {
-    debug2("Step 3: Triggering build for project:", projectId);
+    debug3("Step 3: Triggering build for project:", projectId);
     const buildResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.triggerBuild}/${projectId}`, {
       method: "POST",
       headers: {
@@ -1618,15 +1925,15 @@ ${error instanceof Error ? error.message : String(error)}`));
     buildSpinner.succeed(`Build complete (${buildDuration}s)`);
   } catch (error) {
     buildSpinner.fail("Build failed");
-    console.error(chalk5.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
   const deploySpinner = ora5("Deploying to LeanMCP...").start();
   let deploymentId;
   let functionUrl;
   try {
-    debug2("Step 4: Creating deployment for build:", buildId);
+    debug3("Step 4: Creating deployment for build:", buildId);
     const deployResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.createDeployment}`, {
       method: "POST",
       headers: {
@@ -1648,13 +1955,13 @@ ${error instanceof Error ? error.message : String(error)}`));
     deploySpinner.succeed("Deployed");
   } catch (error) {
     deploySpinner.fail("Deployment failed");
-    console.error(chalk5.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
   const mappingSpinner = ora5("Configuring subdomain...").start();
   try {
-    debug2("Step 5: Creating subdomain mapping:", subdomain);
+    debug3("Step 5: Creating subdomain mapping:", subdomain);
     const mappingResponse = await debugFetch(`${apiUrl}${API_ENDPOINTS.createMapping}`, {
       method: "POST",
       headers: {
@@ -1676,40 +1983,54 @@ ${error instanceof Error ? error.message : String(error)}`));
   } catch (error) {
     mappingSpinner.warn("Subdomain mapping may need manual setup");
   }
-  console.log(chalk5.green("\n" + "=".repeat(60)));
-  console.log(chalk5.green.bold("  DEPLOYMENT SUCCESSFUL!"));
-  console.log(chalk5.green("=".repeat(60) + "\n"));
-  console.log(chalk5.white("  Your MCP server is now live:\n"));
-  console.log(chalk5.cyan(`  URL:  `) + chalk5.white.bold(`https://${subdomain}.leanmcp.dev`));
-  console.log();
-  console.log(chalk5.gray("  Test endpoints:"));
-  console.log(chalk5.gray(`    curl https://${subdomain}.leanmcp.dev/health`));
-  console.log(chalk5.gray(`    curl https://${subdomain}.leanmcp.dev/mcp`));
-  console.log();
+  const deploymentUrl = `https://${subdomain}.leanmcp.app`;
+  try {
+    await writeLeanMCPConfig(absolutePath, {
+      projectId,
+      projectName,
+      subdomain,
+      url: deploymentUrl,
+      lastDeployedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      buildId,
+      deploymentId
+    });
+    debug3("Saved .leanmcp config");
+  } catch (e) {
+    debug3("Could not save .leanmcp config:", e);
+  }
+  logger.success("\n" + "=".repeat(60));
+  logger.log("  DEPLOYMENT SUCCESSFUL!", chalk.green.bold);
+  logger.success("=".repeat(60) + "\n");
+  logger.log("  Your MCP server is now live:\n", chalk.white);
+  logger.log(`  URL:  ${chalk.white.bold(`https://${subdomain}.leanmcp.app`)}`, chalk.cyan);
+  logger.log("");
+  logger.gray("  Test endpoints:");
+  logger.gray(`    curl https://${subdomain}.leanmcp.app/health`);
+  logger.gray(`    curl https://${subdomain}.leanmcp.app/mcp`);
+  logger.log("");
   const totalDuration = Math.round((Date.now() - deployStartTime) / 1e3);
-  console.log(chalk5.gray(`  Total time: ${totalDuration}s`));
-  console.log();
+  logger.gray(`  Total time: ${totalDuration}s`);
+  logger.log("");
   const dashboardBaseUrl = "https://ship.leanmcp.com";
-  console.log(chalk5.cyan("  Dashboard links:"));
-  console.log(chalk5.gray(`    Project:    ${dashboardBaseUrl}/projects/${projectId}`));
-  console.log(chalk5.gray(`    Build:      ${dashboardBaseUrl}/builds/${buildId}`));
-  console.log(chalk5.gray(`    Deployment: ${dashboardBaseUrl}/deployments/${deploymentId}`));
-  console.log();
-  console.log(chalk5.cyan("  Need help? Join our Discord:"));
-  console.log(chalk5.blue("    https://discord.com/invite/DsRcA3GwPy"));
-  console.log();
+  logger.info("  Dashboard links:");
+  logger.gray(`    Project:    ${dashboardBaseUrl}/projects/${projectId}`);
+  logger.gray(`    Build:      ${dashboardBaseUrl}/builds/${buildId}`);
+  logger.gray(`    Deployment: ${dashboardBaseUrl}/deployments/${deploymentId}`);
+  logger.log("");
+  logger.info("  Need help? Join our Discord:");
+  logger.log("    https://discord.com/invite/DsRcA3GwPy", chalk.blue);
+  logger.log("");
 }
 __name(deployCommand, "deployCommand");
 
 // src/commands/projects.ts
-import chalk6 from "chalk";
 import ora6 from "ora";
 var API_ENDPOINT = "/api/projects";
 async function projectsListCommand() {
   const apiKey = await getApiKey();
   if (!apiKey) {
-    console.error(chalk6.red("\nNot logged in."));
-    console.log(chalk6.gray("Run `leanmcp login` first to authenticate.\n"));
+    logger.error("\nNot logged in.");
+    logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
   const spinner = ora6("Fetching projects...").start();
@@ -1726,26 +2047,26 @@ async function projectsListCommand() {
     const projects = await response.json();
     spinner.stop();
     if (projects.length === 0) {
-      console.log(chalk6.yellow("\nNo projects found."));
-      console.log(chalk6.gray("Create one with: leanmcp deploy <folder>\n"));
+      logger.warn("\nNo projects found.");
+      logger.gray("Create one with: leanmcp deploy <folder>\n");
       return;
     }
-    console.log(chalk6.cyan(`
+    logger.info(`
 Your Projects (${projects.length})
-`));
-    console.log(chalk6.gray("\u2500".repeat(60)));
+`);
+    logger.gray("\u2500".repeat(60));
     for (const project of projects) {
-      const statusColor = project.status === "ACTIVE" ? chalk6.green : chalk6.yellow;
-      console.log(chalk6.white.bold(`  ${project.name}`));
-      console.log(chalk6.gray(`    ID: ${project.id}`));
-      console.log(chalk6.gray(`    Status: `) + statusColor(project.status));
-      console.log(chalk6.gray(`    Created: ${new Date(project.createdAt).toLocaleDateString()}`));
-      console.log();
+      const statusColor = project.status === "ACTIVE" ? chalk.green : chalk.yellow;
+      logger.log(`  ${project.name}`, chalk.white.bold);
+      logger.gray(`    ID: ${project.id}`);
+      logger.log(`    Status: ${statusColor(project.status)}`, chalk.gray);
+      logger.gray(`    Created: ${new Date(project.createdAt).toLocaleDateString()}`);
+      logger.log("");
     }
   } catch (error) {
     spinner.fail("Failed to fetch projects");
-    console.error(chalk6.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
@@ -1753,8 +2074,8 @@ __name(projectsListCommand, "projectsListCommand");
 async function projectsGetCommand(projectId) {
   const apiKey = await getApiKey();
   if (!apiKey) {
-    console.error(chalk6.red("\nNot logged in."));
-    console.log(chalk6.gray("Run `leanmcp login` first to authenticate.\n"));
+    logger.error("\nNot logged in.");
+    logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
   const spinner = ora6("Fetching project...").start();
@@ -1773,23 +2094,23 @@ async function projectsGetCommand(projectId) {
     }
     const project = await response.json();
     spinner.stop();
-    console.log(chalk6.cyan("\nProject Details\n"));
-    console.log(chalk6.gray("\u2500".repeat(60)));
-    console.log(chalk6.white.bold(`  Name: ${project.name}`));
-    console.log(chalk6.gray(`  ID: ${project.id}`));
-    console.log(chalk6.gray(`  Status: ${project.status}`));
+    logger.info("\nProject Details\n");
+    logger.gray("\u2500".repeat(60));
+    logger.log(`  Name: ${project.name}`, chalk.white.bold);
+    logger.gray(`  ID: ${project.id}`);
+    logger.gray(`  Status: ${project.status}`);
     if (project.s3Location) {
-      console.log(chalk6.gray(`  S3 Location: ${project.s3Location}`));
+      logger.gray(`  S3 Location: ${project.s3Location}`);
     }
-    console.log(chalk6.gray(`  Created: ${new Date(project.createdAt).toLocaleString()}`));
+    logger.gray(`  Created: ${new Date(project.createdAt).toLocaleString()}`);
     if (project.updatedAt) {
-      console.log(chalk6.gray(`  Updated: ${new Date(project.updatedAt).toLocaleString()}`));
+      logger.gray(`  Updated: ${new Date(project.updatedAt).toLocaleString()}`);
     }
-    console.log();
+    logger.log("");
   } catch (error) {
     spinner.fail("Failed to fetch project");
-    console.error(chalk6.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
@@ -1797,8 +2118,8 @@ __name(projectsGetCommand, "projectsGetCommand");
 async function projectsDeleteCommand(projectId, options = {}) {
   const apiKey = await getApiKey();
   if (!apiKey) {
-    console.error(chalk6.red("\nNot logged in."));
-    console.log(chalk6.gray("Run `leanmcp login` first to authenticate.\n"));
+    logger.error("\nNot logged in.");
+    logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
   if (!options.force) {
@@ -1808,7 +2129,7 @@ async function projectsDeleteCommand(projectId, options = {}) {
       default: false
     });
     if (!shouldDelete) {
-      console.log(chalk6.gray("\nDeletion cancelled.\n"));
+      logger.gray("\nDeletion cancelled.\n");
       return;
     }
   }
@@ -1828,18 +2149,56 @@ async function projectsDeleteCommand(projectId, options = {}) {
       throw new Error(`Failed to delete project: ${response.statusText}`);
     }
     spinner.succeed("Project deleted successfully");
-    console.log();
+    logger.log("");
   } catch (error) {
     spinner.fail("Failed to delete project");
-    console.error(chalk6.red(`
-${error instanceof Error ? error.message : String(error)}`));
+    logger.error(`
+${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }
 __name(projectsDeleteCommand, "projectsDeleteCommand");
 
 // src/templates/readme_v1.ts
-var getReadmeTemplate = /* @__PURE__ */ __name((projectName) => `# ${projectName}
+var getReadmeTemplate = /* @__PURE__ */ __name((projectName) => `<p align="center">
+  <img
+    src="https://raw.githubusercontent.com/LeanMCP/leanmcp-sdk/refs/heads/main/assets/logo.svg"
+    alt="LeanMCP Logo"
+    width="500"
+  />
+</p>
+
+<p align="center">
+  <a href="https://ship.leanmcp.com">
+    <img src="https://raw.githubusercontent.com/LeanMCP/leanmcp-sdk/refs/heads/main/badges/deploy.svg" alt="Deploy on LeanMCP" height="30">
+  </a>
+  <a href="https://ship.leanmcp.com/playground">
+    <img src="https://raw.githubusercontent.com/LeanMCP/leanmcp-sdk/refs/heads/main/badges/test.svg" alt="Test on LeanMCP" height="30">
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@leanmcp/core">
+    <img src="https://img.shields.io/npm/v/@leanmcp/core" alt="npm version" />
+  </a>
+  <a href="https://www.npmjs.com/package/@leanmcp/cli">
+    <img src="https://img.shields.io/npm/dm/@leanmcp/cli" alt="npm downloads" />
+  </a>
+  <a href="https://leanmcp.com/">
+    <img src="https://img.shields.io/badge/Website-leanmcp-0A66C2?" />
+  </a>
+  <a href="https://discord.com/invite/DsRcA3GwPy">
+    <img src="https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white" />
+  </a>
+  <a href="https://x.com/LeanMcp">
+    <img src="https://img.shields.io/badge/@LeanMCP-f5f5f5?logo=x&logoColor=000000" />
+  </a>
+  <a href="https://deepwiki.com/LeanMCP/leanmcp-sdk">
+    <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki" />
+  </a>
+</p>
+
+# ${projectName}
 
 MCP Server with Streamable HTTP Transport built with LeanMCP SDK
 
@@ -1914,19 +2273,51 @@ Services are automatically discovered and registered - no need to modify \`main.
 - **HTTP transport** - Production-ready HTTP server with session management
 - **Hot reload** - Development mode with automatic restart on file changes
 
+## Deploy to LeanMCP Cloud
+
+Deploy your MCP server to LeanMCP's global edge network with a single command:
+
+\`\`\`bash
+# Login to LeanMCP (first time only)
+leanmcp login
+
+# Deploy your server
+leanmcp deploy .
+\`\`\`
+
+After deployment, your server will be available at:
+- **URL**: \`https://your-project.leanmcp.app\`
+- **Health**: \`https://your-project.leanmcp.app/health\`
+- **MCP Endpoint**: \`https://your-project.leanmcp.app/mcp\`
+
+Manage your deployments at [ship.leanmcp.com](https://ship.leanmcp.com)
+
 ## Testing with MCP Inspector
 
 \`\`\`bash
+# Test locally
 npx @modelcontextprotocol/inspector http://localhost:3001/mcp
+
+# Test deployed server
+npx @modelcontextprotocol/inspector https://your-project.leanmcp.app/mcp
 \`\`\`
 
+## Support
+
+-  [Documentation](https://docs.leanmcp.com)
+-  [Discord Community](https://discord.com/invite/DsRcA3GwPy)
+-  [Report Issues](https://github.com/leanmcp/leanmcp-sdk/issues)
+
 ## License
 
 MIT
 `, "getReadmeTemplate");
 
 // src/templates/gitignore_v1.ts
-var gitignoreTemplate = `# Logs
+var gitignoreTemplate = `# LeanMCP deployment config (contains project-specific IDs)
+.leanmcp/
+
+# Logs
 logs
 *.log
 npm-debug.log*
@@ -2278,10 +2669,21 @@ function capitalize(str) {
 }
 __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", `
+function enableDebugIfNeeded() {
+  const args = process.argv;
+  if (args.includes("--debug") || args.includes("-d")) {
+    setDebugMode(true);
+    setDebugMode2(true);
+    setDeployDebugMode(true);
+    debug("Debug mode enabled globally");
+  }
+}
+__name(enableDebugIfNeeded, "enableDebugIfNeeded");
+enableDebugIfNeeded();
+program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version(pkg.version, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command").option("-d, --debug", "Enable debug logging for all commands").addHelpText("after", `
 Examples:
   $ leanmcp create my-app                # Create new project (interactive)
-  $ leanmcp create my-app --install      # Create and install deps (non-interactive)
+  $ leanmcp create my-app -i             # Create and install deps (non-interactive)
   $ leanmcp create my-app --no-install   # Create without installing deps
   $ leanmcp dev                          # Start development server
   $ leanmcp build                        # Build UI components and compile TypeScript
@@ -2290,8 +2692,17 @@ Examples:
   $ leanmcp deploy ./my-app              # Deploy to LeanMCP cloud
   $ leanmcp projects list                # List your cloud projects
   $ leanmcp projects delete <id>         # Delete a cloud project
+
+Global Options:
+  -v, --version    Output the current version
+  -h, --help       Display help for command
+  -d, --debug      Enable debug logging for all commands
 `);
-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) => {
+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("-i, --install", "Install dependencies automatically (non-interactive, no dev server)").option("--no-install", "Skip dependency installation (non-interactive)").action(async (projectName, options) => {
+  trackCommand("create", {
+    projectName,
+    ...options
+  });
   const spinner = ora7(`Creating project ${projectName}...`).start();
   const targetDir = path8.join(process.cwd(), projectName);
   if (fs8.existsSync(targetDir)) {
@@ -2310,6 +2721,7 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       dev: "leanmcp dev",
       build: "leanmcp build",
       start: "leanmcp start",
+      inspect: "npx @modelcontextprotocol/inspector node dist/main.js",
       "start:node": "node dist/main.js",
       clean: "rm -rf dist"
     },
@@ -2322,13 +2734,13 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     author: "",
     license: "MIT",
     dependencies: {
-      "@leanmcp/core": "^0.3.9",
+      "@leanmcp/core": "^0.3.14",
       "@leanmcp/ui": "^0.2.1",
-      "@leanmcp/auth": "^0.3.2",
+      "@leanmcp/auth": "^0.4.0",
       "dotenv": "^16.5.0"
     },
     devDependencies: {
-      "@leanmcp/cli": "^0.3.0",
+      "@leanmcp/cli": "^0.4.0",
       "@types/node": "^20.0.0",
       "tsx": "^4.20.3",
       "typescript": "^5.6.3"
@@ -2378,23 +2790,23 @@ NODE_ENV=development
   const readme = getReadmeTemplate(projectName);
   await fs8.writeFile(path8.join(targetDir, "README.md"), readme);
   spinner.succeed(`Project ${projectName} created!`);
-  console.log(chalk7.green("\nSuccess! Your MCP server is ready.\n"));
-  console.log(chalk7.cyan("To deploy to LeanMCP cloud:"));
-  console.log(chalk7.gray(`  cd ${projectName}`));
-  console.log(chalk7.gray(`  leanmcp deploy .
-`));
-  console.log(chalk7.cyan("Need help? Join our Discord:"));
-  console.log(chalk7.blue("  https://discord.com/invite/DsRcA3GwPy\n"));
+  logger.log("\nSuccess! Your MCP server is ready.\n", chalk.green);
+  logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
+  logger.log(`  cd ${projectName}`, chalk.gray);
+  logger.log(`  leanmcp deploy .
+`, chalk.gray);
+  logger.log("Need help? Join our Discord:", chalk.cyan);
+  logger.log("  https://discord.com/invite/DsRcA3GwPy\n", chalk.blue);
   const isNonInteractive = options.install !== void 0 || options.allowAll;
   if (options.install === false) {
-    console.log(chalk7.cyan("To get started:"));
-    console.log(chalk7.gray(`  cd ${projectName}`));
-    console.log(chalk7.gray(`  npm install`));
-    console.log(chalk7.gray(`  npm run dev`));
-    console.log();
-    console.log(chalk7.cyan("To deploy to LeanMCP cloud:"));
-    console.log(chalk7.gray(`  cd ${projectName}`));
-    console.log(chalk7.gray(`  leanmcp deploy .`));
+    logger.log("To get started:", chalk.cyan);
+    logger.log(`  cd ${projectName}`, chalk.gray);
+    logger.log(`  npm install`, chalk.gray);
+    logger.log(`  npm run dev`, chalk.gray);
+    logger.log("");
+    logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
+    logger.log(`  cd ${projectName}`, chalk.gray);
+    logger.log(`  leanmcp deploy .`, chalk.gray);
     return;
   }
   const shouldInstall = isNonInteractive ? true : await confirm3({
@@ -2423,13 +2835,13 @@ NODE_ENV=development
       });
       installSpinner.succeed("Dependencies installed successfully!");
       if (options.install === true) {
-        console.log(chalk7.cyan("\nTo start the development server:"));
-        console.log(chalk7.gray(`  cd ${projectName}`));
-        console.log(chalk7.gray(`  npm run dev`));
-        console.log();
-        console.log(chalk7.cyan("To deploy to LeanMCP cloud:"));
-        console.log(chalk7.gray(`  cd ${projectName}`));
-        console.log(chalk7.gray(`  leanmcp deploy .`));
+        logger.log("\nTo start the development server:", chalk.cyan);
+        logger.log(`  cd ${projectName}`, chalk.gray);
+        logger.log(`  npm run dev`, chalk.gray);
+        logger.log("");
+        logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
+        logger.log(`  cd ${projectName}`, chalk.gray);
+        logger.log(`  leanmcp deploy .`, chalk.gray);
         return;
       }
       const shouldStartDev = options.allowAll ? true : await confirm3({
@@ -2437,7 +2849,7 @@ NODE_ENV=development
         default: true
       });
       if (shouldStartDev) {
-        console.log(chalk7.cyan("\nStarting development server...\n"));
+        logger.log("\nStarting development server...\n", chalk.cyan);
         const devServer = spawn4("npm", [
           "run",
           "dev"
@@ -2451,71 +2863,86 @@ NODE_ENV=development
           process.exit(0);
         });
       } else {
-        console.log(chalk7.cyan("\nTo start the development server later:"));
-        console.log(chalk7.gray(`  cd ${projectName}`));
-        console.log(chalk7.gray(`  npm run dev`));
-        console.log();
-        console.log(chalk7.cyan("To deploy to LeanMCP cloud:"));
-        console.log(chalk7.gray(`  cd ${projectName}`));
-        console.log(chalk7.gray(`  leanmcp deploy .`));
+        logger.log("\nTo start the development server later:", chalk.cyan);
+        logger.log(`  cd ${projectName}`, chalk.gray);
+        logger.log(`  npm run dev`, chalk.gray);
+        logger.log("");
+        logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
+        logger.log(`  cd ${projectName}`, chalk.gray);
+        logger.log(`  leanmcp deploy .`, chalk.gray);
       }
     } catch (error) {
       installSpinner.fail("Failed to install dependencies");
-      console.error(chalk7.red(error instanceof Error ? error.message : String(error)));
-      console.log(chalk7.cyan("\nYou can install dependencies manually:"));
-      console.log(chalk7.gray(`  cd ${projectName}`));
-      console.log(chalk7.gray(`  npm install`));
+      logger.log(error instanceof Error ? error.message : String(error), chalk.red);
+      logger.log("\nYou can install dependencies manually:", chalk.cyan);
+      logger.log(`  cd ${projectName}`, chalk.gray);
+      logger.log(`  npm install`, chalk.gray);
     }
   } else {
-    console.log(chalk7.cyan("\nTo get started:"));
-    console.log(chalk7.gray(`  cd ${projectName}`));
-    console.log(chalk7.gray(`  npm install`));
-    console.log(chalk7.gray(`  npm run dev`));
-    console.log();
-    console.log(chalk7.cyan("To deploy to LeanMCP cloud:"));
-    console.log(chalk7.gray(`  cd ${projectName}`));
-    console.log(chalk7.gray(`  leanmcp deploy .`));
+    logger.log("\nTo get started:", chalk.cyan);
+    logger.log(`  cd ${projectName}`, chalk.gray);
+    logger.log(`  npm install`, chalk.gray);
+    logger.log(`  npm run dev`, chalk.gray);
+    logger.log("");
+    logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
+    logger.log(`  cd ${projectName}`, chalk.gray);
+    logger.log(`  leanmcp deploy .`, chalk.gray);
   }
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
   const mcpDir = path8.join(cwd, "mcp");
   if (!fs8.existsSync(path8.join(cwd, "main.ts"))) {
-    console.error(chalk7.red("ERROR: Not a LeanMCP project (main.ts missing)."));
+    logger.log("ERROR: Not a LeanMCP project (main.ts missing).", chalk.red);
     process.exit(1);
   }
   const serviceDir = path8.join(mcpDir, serviceName);
   const serviceFile = path8.join(serviceDir, "index.ts");
   if (fs8.existsSync(serviceDir)) {
-    console.error(chalk7.red(`ERROR: Service ${serviceName} already exists.`));
+    logger.log(`ERROR: Service ${serviceName} already exists.`, chalk.red);
     process.exit(1);
   }
   await fs8.mkdirp(serviceDir);
   const indexTs = getServiceIndexTemplate(serviceName, capitalize(serviceName));
   await fs8.writeFile(serviceFile, indexTs);
-  console.log(chalk7.green(`\\nCreated new service: ${chalk7.bold(serviceName)}`));
-  console.log(chalk7.gray(`   File: mcp/${serviceName}/index.ts`));
-  console.log(chalk7.gray(`   Tool: greet`));
-  console.log(chalk7.gray(`   Prompt: welcomePrompt`));
-  console.log(chalk7.gray(`   Resource: getStatus`));
-  console.log(chalk7.green(`\\nService will be automatically discovered on next server start!`));
+  logger.log(`\\nCreated new service: ${chalk.bold(serviceName)}`, chalk.green);
+  logger.log(`   File: mcp/${serviceName}/index.ts`, chalk.gray);
+  logger.log(`   Tool: greet`, chalk.gray);
+  logger.log(`   Prompt: welcomePrompt`, chalk.gray);
+  logger.log(`   Resource: getStatus`, chalk.gray);
+  logger.log(`\\nService will be automatically discovered on next server start!`, chalk.green);
+});
+program.command("dev").description("Start development server with UI hot-reload (builds @UIApp components)").action(() => {
+  trackCommand("dev");
+  devCommand();
+});
+program.command("build").description("Compile TypeScript to JavaScript").action(() => {
+  trackCommand("build");
+  buildCommand();
 });
-program.command("dev").description("Start development server with UI hot-reload (builds @UIApp components)").action(devCommand);
 program.command("build").description("Build UI components and compile TypeScript for production").action(buildCommand);
-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);
-  }
+program.command("start").description("Build UI components and start production server").action(() => {
+  trackCommand("start");
+  startCommand();
+});
+program.command("login").description("Authenticate with LeanMCP cloud using an API key").action(async () => {
+  trackCommand("login");
   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);
-  }
+program.command("logout").description("Remove stored API key and logout from LeanMCP cloud").action(() => {
+  trackCommand("logout");
+  logoutCommand();
+});
+program.command("whoami").description("Show current authentication status").action(() => {
+  trackCommand("whoami");
+  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").action(async (folder, options) => {
+  trackCommand("deploy", {
+    folder,
+    subdomain: options.subdomain,
+    yes: options.yes
+  });
   const targetFolder = folder || ".";
   await deployCommand(targetFolder, {
     subdomain: options.subdomain,
@@ -2523,7 +2950,21 @@ program.command("deploy [folder]").description("Deploy an MCP server to LeanMCP
   });
 });
 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));
+projectsCmd.command("list").alias("ls").description("List all your projects").action(() => {
+  trackCommand("projects_list");
+  projectsListCommand();
+});
+projectsCmd.command("get <projectId>").description("Get details of a specific project").action((projectId) => {
+  trackCommand("projects_get", {
+    projectId
+  });
+  projectsGetCommand(projectId);
+});
+projectsCmd.command("delete <projectId>").alias("rm").description("Delete a project").option("-f, --force", "Skip confirmation prompt").action((projectId, options) => {
+  trackCommand("projects_delete", {
+    projectId,
+    force: options.force
+  });
+  projectsDeleteCommand(projectId, options);
+});
 program.parse();