@leanmcp/cli 0.5.6 → 0.5.8

package/dist/index.js

@@ -3,9 +3,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { Command } from "commander";
-import fs11 from "fs-extra";
-import path11 from "path";
-import ora8 from "ora";
+import fs13 from "fs-extra";
+import path13 from "path";
+import ora9 from "ora";
 import { createRequire } from "module";
 import { confirm as confirm4 } from "@inquirer/prompts";
 import { spawn as spawn4 } from "child_process";
@@ -13,8 +13,8 @@ import { spawn as spawn4 } from "child_process";
 // src/commands/dev.ts
 import { spawn } from "child_process";
 import ora from "ora";
-import path3 from "path";
-import fs3 from "fs-extra";
+import path4 from "path";
+import fs4 from "fs-extra";
 import crypto2 from "crypto";
 import chokidar from "chokidar";
 
@@ -471,6 +471,8 @@ __name(deleteUIComponent, "deleteUIComponent");
 import chalk from "chalk";
 import os from "os";
 import crypto from "crypto";
+import path3 from "path";
+import fs3 from "fs-extra";
 import { execSync } from "child_process";
 var POSTHOG_API_KEY = "phc_EoMHKFbx6j2wUFsf8ywqgHntY4vEXC3ZzLFoPJVjRRT";
 var POSTHOG_API_HOST = "https://d18m0xvdtnkibr.cloudfront.net";
@@ -568,12 +570,40 @@ var sendToPostHog = /* @__PURE__ */ __name((eventName, properties = {}) => {
     }
   });
 }, "sendToPostHog");
+var LOG_DIR = path3.join(os.homedir(), ".leanmcp", "logs");
+try {
+  fs3.ensureDirSync(LOG_DIR);
+} catch (err) {
+}
+function getTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+__name(getTimestamp, "getTimestamp");
+function getLogFilePath() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return path3.join(LOG_DIR, `cli-${date}.log`);
+}
+__name(getLogFilePath, "getLogFilePath");
+function redactSensitive(text) {
+  if (!text) return text;
+  return text.replace(/(leanmcp_|airtain_)[a-zA-Z0-9]{20,}/g, "$1********************");
+}
+__name(redactSensitive, "redactSensitive");
 var LoggerClass = class LoggerClass2 {
   static {
     __name(this, "LoggerClass");
   }
+  writeToFile(level, message) {
+    try {
+      const timestamp = getTimestamp();
+      const logLine = `[${timestamp}] [${level.toUpperCase()}] ${redactSensitive(message)}
+`;
+      fs3.appendFileSync(getLogFilePath(), logLine);
+    } catch (err) {
+    }
+  }
   /**
-  * Log a message to console and send cli_log event to PostHog
+  * Log a message to console, file, 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)
   */
@@ -583,32 +613,35 @@ var LoggerClass = class LoggerClass2 {
     } else {
       console.log(text);
     }
+    this.writeToFile("log", text);
     sendToPostHog("cli_log", {
       message: text,
       level: "log"
     });
   }
   /**
-  * Log a warning to console and send cli_warn event to PostHog
+  * Log a warning to console, file, 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));
+    this.writeToFile("warn", text);
     sendToPostHog("cli_warn", {
       message: text,
       level: "warn"
     });
   }
   /**
-  * Log an error to console and send cli_error event to PostHog
+  * Log an error to console, file, 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));
+    this.writeToFile("error", text);
     sendToPostHog("cli_error", {
       message: text,
       level: "error"
@@ -620,6 +653,7 @@ var LoggerClass = class LoggerClass2 {
   */
   info(text) {
     console.log(chalk.cyan(text));
+    this.writeToFile("info", text);
     sendToPostHog("cli_log", {
       message: text,
       level: "info"
@@ -631,6 +665,7 @@ var LoggerClass = class LoggerClass2 {
   */
   success(text) {
     console.log(chalk.green(text));
+    this.writeToFile("success", text);
     sendToPostHog("cli_log", {
       message: text,
       level: "success"
@@ -642,6 +677,7 @@ var LoggerClass = class LoggerClass2 {
   */
   gray(text) {
     console.log(chalk.gray(text));
+    this.writeToFile("debug", text);
     sendToPostHog("cli_log", {
       message: text,
       level: "gray"
@@ -658,7 +694,7 @@ var trackCommand = /* @__PURE__ */ __name((command, options = {}) => {
 
 // src/commands/dev.ts
 function computeHash(filePath) {
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   return crypto2.createHash("md5").update(content).digest("hex");
 }
 __name(computeHash, "computeHash");
@@ -675,7 +711,7 @@ function computeDiff(previousUIApps, currentUIApps, hashCache) {
     } else {
       const oldHash = hashCache.get(app.resourceUri);
       let newHash;
-      if (fs3.existsSync(app.componentPath)) {
+      if (fs4.existsSync(app.componentPath)) {
         newHash = computeHash(app.componentPath);
       }
       if (oldHash !== newHash) {
@@ -692,7 +728,7 @@ function computeDiff(previousUIApps, currentUIApps, hashCache) {
 __name(computeDiff, "computeDiff");
 async function devCommand() {
   const cwd = process.cwd();
-  if (!await fs3.pathExists(path3.join(cwd, "main.ts"))) {
+  if (!await fs4.pathExists(path4.join(cwd, "main.ts"))) {
     logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
     logger.gray("Run this command from your project root.");
     process.exit(1);
@@ -748,12 +784,12 @@ async function devCommand() {
   let watcher = null;
   const componentHashCache = /* @__PURE__ */ new Map();
   for (const app of uiApps) {
-    if (await fs3.pathExists(app.componentPath)) {
+    if (await fs4.pathExists(app.componentPath)) {
       componentHashCache.set(app.resourceUri, computeHash(app.componentPath));
     }
   }
   let previousUIApps = uiApps;
-  const mcpPath = path3.join(cwd, "mcp");
+  const mcpPath = path4.join(cwd, "mcp");
   watcher = chokidar.watch(mcpPath, {
     ignoreInitial: true,
     ignored: [
@@ -795,7 +831,7 @@ async function devCommand() {
           } else {
             manifest[app.resourceUri] = result.htmlPath;
           }
-          if (await fs3.pathExists(app.componentPath)) {
+          if (await fs4.pathExists(app.componentPath)) {
             componentHashCache.set(app.resourceUri, computeHash(app.componentPath));
           }
           logger.success(`${app.componentName} ${action.toLowerCase()} complete`);
@@ -841,12 +877,12 @@ __name(devCommand, "devCommand");
 // src/commands/build.ts
 import { spawn as spawn2 } from "child_process";
 import ora2 from "ora";
-import path5 from "path";
-import fs5 from "fs-extra";
+import path6 from "path";
+import fs6 from "fs-extra";
 
 // src/schema-extractor.ts
-import path4 from "path";
-import fs4 from "fs-extra";
+import path5 from "path";
+import fs5 from "fs-extra";
 import { Project, Node } from "ts-morph";
 async function generateSchemaMetadata(projectDir) {
   const metadata = {};
@@ -921,9 +957,9 @@ async function generateSchemaMetadata(projectDir) {
     }
     processedClasses.add(className);
   }
-  const outputPath = path4.join(projectDir, "dist", "schema-metadata.json");
-  await fs4.ensureDir(path4.dirname(outputPath));
-  await fs4.writeJSON(outputPath, metadata, {
+  const outputPath = path5.join(projectDir, "dist", "schema-metadata.json");
+  await fs5.ensureDir(path5.dirname(outputPath));
+  await fs5.writeJSON(outputPath, metadata, {
     spaces: 2
   });
 }
@@ -958,11 +994,11 @@ __name(extractBaseClassName, "extractBaseClassName");
 async function findTsFiles(dir) {
   const files = [];
   async function scan(currentDir) {
-    const entries = await fs4.readdir(currentDir, {
+    const entries = await fs5.readdir(currentDir, {
       withFileTypes: true
     });
     for (const entry of entries) {
-      const fullPath = path4.join(currentDir, entry.name);
+      const fullPath = path5.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if ([
           "node_modules",
@@ -1028,7 +1064,7 @@ __name(mapPrimitiveType, "mapPrimitiveType");
 // src/commands/build.ts
 async function buildCommand() {
   const cwd = process.cwd();
-  if (!await fs5.pathExists(path5.join(cwd, "main.ts"))) {
+  if (!await fs6.pathExists(path6.join(cwd, "main.ts"))) {
     logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
     logger.gray("Run this command from your project root.");
     process.exit(1);
@@ -1110,11 +1146,11 @@ __name(buildCommand, "buildCommand");
 // src/commands/start.ts
 import { spawn as spawn3 } from "child_process";
 import ora3 from "ora";
-import path6 from "path";
-import fs6 from "fs-extra";
+import path7 from "path";
+import fs7 from "fs-extra";
 async function startCommand() {
   const cwd = process.cwd();
-  if (!await fs6.pathExists(path6.join(cwd, "main.ts"))) {
+  if (!await fs7.pathExists(path7.join(cwd, "main.ts"))) {
     logger.error("ERROR: Not a LeanMCP project (main.ts not found).");
     logger.gray("Run this command from your project root.");
     process.exit(1);
@@ -1216,8 +1252,8 @@ __name(startCommand, "startCommand");
 
 // src/commands/login.ts
 import ora4 from "ora";
-import path7 from "path";
-import fs7 from "fs-extra";
+import path8 from "path";
+import fs8 from "fs-extra";
 import os2 from "os";
 import { input, confirm } from "@inquirer/prompts";
 var DEBUG_MODE2 = false;
@@ -1231,12 +1267,12 @@ function debug2(message, ...args) {
   }
 }
 __name(debug2, "debug");
-var CONFIG_DIR = path7.join(os2.homedir(), ".leanmcp");
-var CONFIG_FILE = path7.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path8.join(os2.homedir(), ".leanmcp");
+var CONFIG_FILE = path8.join(CONFIG_DIR, "config.json");
 async function loadConfig() {
   try {
-    if (await fs7.pathExists(CONFIG_FILE)) {
-      return await fs7.readJSON(CONFIG_FILE);
+    if (await fs8.pathExists(CONFIG_FILE)) {
+      return await fs8.readJSON(CONFIG_FILE);
     }
   } catch (error) {
   }
@@ -1244,8 +1280,8 @@ async function loadConfig() {
 }
 __name(loadConfig, "loadConfig");
 async function saveConfig(config) {
-  await fs7.ensureDir(CONFIG_DIR);
-  await fs7.writeJSON(CONFIG_FILE, config, {
+  await fs8.ensureDir(CONFIG_DIR);
+  await fs8.writeJSON(CONFIG_FILE, config, {
     spaces: 2
   });
 }
@@ -1452,8 +1488,8 @@ __name(whoamiCommand, "whoamiCommand");
 
 // src/commands/deploy.ts
 import ora5 from "ora";
-import path9 from "path";
-import fs9 from "fs-extra";
+import path10 from "path";
+import fs10 from "fs-extra";
 import os3 from "os";
 import archiver from "archiver";
 import { input as input2, confirm as confirm2, select } from "@inquirer/prompts";
@@ -1636,8 +1672,8 @@ function generateProjectName() {
 __name(generateProjectName, "generateProjectName");
 
 // src/utils/env-parser.ts
-import fs8 from "fs-extra";
-import path8 from "path";
+import fs9 from "fs-extra";
+import path9 from "path";
 var RESERVED_ENV_KEYS = [
   "AWS_REGION",
   "AWS_ACCESS_KEY_ID",
@@ -1700,16 +1736,16 @@ function parseEnvFile(content) {
 }
 __name(parseEnvFile, "parseEnvFile");
 async function loadEnvFile(filePath) {
-  const absolutePath = path8.resolve(filePath);
-  if (!await fs8.pathExists(absolutePath)) {
+  const absolutePath = path9.resolve(filePath);
+  if (!await fs9.pathExists(absolutePath)) {
     throw new Error(`Env file not found: ${absolutePath}`);
   }
-  const content = await fs8.readFile(absolutePath, "utf-8");
+  const content = await fs9.readFile(absolutePath, "utf-8");
   return parseEnvFile(content);
 }
 __name(loadEnvFile, "loadEnvFile");
 async function writeEnvFile(filePath, vars) {
-  const absolutePath = path8.resolve(filePath);
+  const absolutePath = path9.resolve(filePath);
   const lines = [
     "# Environment variables",
     `# Generated by leanmcp CLI at ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -1725,7 +1761,7 @@ async function writeEnvFile(filePath, vars) {
     }
   }
   lines.push("");
-  await fs8.writeFile(absolutePath, lines.join("\n"));
+  await fs9.writeFile(absolutePath, lines.join("\n"));
 }
 __name(writeEnvFile, "writeEnvFile");
 function isValidEnvKey(key) {
@@ -1839,10 +1875,10 @@ var API_ENDPOINTS = {
 var LEANMCP_CONFIG_DIR = ".leanmcp";
 var LEANMCP_CONFIG_FILE = "config.json";
 async function readLeanMCPConfig(projectPath) {
-  const configPath = path9.join(projectPath, LEANMCP_CONFIG_DIR, LEANMCP_CONFIG_FILE);
+  const configPath = path10.join(projectPath, LEANMCP_CONFIG_DIR, LEANMCP_CONFIG_FILE);
   try {
-    if (await fs9.pathExists(configPath)) {
-      const config = await fs9.readJSON(configPath);
+    if (await fs10.pathExists(configPath)) {
+      const config = await fs10.readJSON(configPath);
       debug3("Found existing .leanmcp config:", config);
       return config;
     }
@@ -1853,10 +1889,10 @@ async function readLeanMCPConfig(projectPath) {
 }
 __name(readLeanMCPConfig, "readLeanMCPConfig");
 async function writeLeanMCPConfig(projectPath, config) {
-  const configDir = path9.join(projectPath, LEANMCP_CONFIG_DIR);
-  const configPath = path9.join(configDir, LEANMCP_CONFIG_FILE);
-  await fs9.ensureDir(configDir);
-  await fs9.writeJSON(configPath, config, {
+  const configDir = path10.join(projectPath, LEANMCP_CONFIG_DIR);
+  const configPath = path10.join(configDir, LEANMCP_CONFIG_FILE);
+  await fs10.ensureDir(configDir);
+  await fs10.writeJSON(configPath, config, {
     spaces: 2
   });
   debug3("Saved .leanmcp config:", config);
@@ -1864,7 +1900,7 @@ async function writeLeanMCPConfig(projectPath, config) {
 __name(writeLeanMCPConfig, "writeLeanMCPConfig");
 async function createZipArchive(folderPath, outputPath) {
   return new Promise((resolve, reject) => {
-    const output = fs9.createWriteStream(outputPath);
+    const output = fs10.createWriteStream(outputPath);
     const archive = archiver("zip", {
       zlib: {
         level: 9
@@ -1982,16 +2018,16 @@ async function deployCommand(folderPath, options = {}) {
   }
   const apiUrl = await getApiUrl();
   debug3("API URL:", apiUrl);
-  const absolutePath = path9.resolve(process.cwd(), folderPath);
-  if (!await fs9.pathExists(absolutePath)) {
+  const absolutePath = path10.resolve(process.cwd(), folderPath);
+  if (!await fs10.pathExists(absolutePath)) {
     logger.error(`Folder not found: ${absolutePath}`);
     process.exit(1);
   }
-  const hasMainTs = await fs9.pathExists(path9.join(absolutePath, "main.ts"));
-  const hasPackageJson = await fs9.pathExists(path9.join(absolutePath, "package.json"));
-  const hasMainPy = await fs9.pathExists(path9.join(absolutePath, "main.py"));
-  const hasRequirementsTxt = await fs9.pathExists(path9.join(absolutePath, "requirements.txt"));
-  const hasPyprojectToml = await fs9.pathExists(path9.join(absolutePath, "pyproject.toml"));
+  const hasMainTs = await fs10.pathExists(path10.join(absolutePath, "main.ts"));
+  const hasPackageJson = await fs10.pathExists(path10.join(absolutePath, "package.json"));
+  const hasMainPy = await fs10.pathExists(path10.join(absolutePath, "main.py"));
+  const hasRequirementsTxt = await fs10.pathExists(path10.join(absolutePath, "requirements.txt"));
+  const hasPyprojectToml = await fs10.pathExists(path10.join(absolutePath, "pyproject.toml"));
   const isNodeProject = hasMainTs || hasPackageJson;
   const isPythonProject = hasMainPy || hasRequirementsTxt || hasPyprojectToml;
   if (!isNodeProject && !isPythonProject) {
@@ -2063,10 +2099,10 @@ Generated project name: ${chalk.bold(projectName)}
     } catch (e) {
       debug3("Could not fetch existing projects");
     }
-    let folderName = path9.basename(absolutePath);
+    let folderName = path10.basename(absolutePath);
     if (hasPackageJson) {
       try {
-        const pkg2 = await fs9.readJSON(path9.join(absolutePath, "package.json"));
+        const pkg2 = await fs10.readJSON(path10.join(absolutePath, "package.json"));
         folderName = pkg2.name || folderName;
       } catch (e) {
       }
@@ -2217,7 +2253,7 @@ ${error instanceof Error ? error.message : String(error)}`);
   }
   const uploadSpinner = ora5("Packaging and uploading...").start();
   try {
-    const tempZip = path9.join(os3.tmpdir(), `leanmcp-${Date.now()}.zip`);
+    const tempZip = path10.join(os3.tmpdir(), `leanmcp-${Date.now()}.zip`);
     const zipSize = await createZipArchive(absolutePath, tempZip);
     uploadSpinner.text = `Packaging... (${Math.round(zipSize / 1024)}KB)`;
     debug3("Step 2a: Getting upload URL for project:", projectId);
@@ -2244,7 +2280,7 @@ ${error instanceof Error ? error.message : String(error)}`);
       throw new Error("Backend did not return upload URL");
     }
     debug3("Step 2b: Uploading to S3...");
-    const zipBuffer = await fs9.readFile(tempZip);
+    const zipBuffer = await fs10.readFile(tempZip);
     const s3Response = await fetch(uploadUrl, {
       method: "PUT",
       body: zipBuffer,
@@ -2267,7 +2303,7 @@ ${error instanceof Error ? error.message : String(error)}`);
         s3Location
       })
     });
-    await fs9.remove(tempZip);
+    await fs10.remove(tempZip);
     uploadSpinner.succeed("Project uploaded");
   } catch (error) {
     uploadSpinner.fail("Failed to upload");
@@ -2404,8 +2440,273 @@ ${error instanceof Error ? error.message : String(error)}`);
 }
 __name(deployCommand, "deployCommand");
 
-// src/commands/projects.ts
+// src/commands/feedback.ts
 import ora6 from "ora";
+import fs11 from "fs-extra";
+import path11 from "path";
+import os4 from "os";
+var DEBUG_MODE4 = false;
+function debug4(message, ...args) {
+  if (DEBUG_MODE4) {
+    console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+  }
+}
+__name(debug4, "debug");
+async function readFileAsBase64(filePath) {
+  try {
+    const absolutePath = path11.resolve(filePath);
+    const stats = await fs11.stat(absolutePath);
+    if (!stats.isFile()) {
+      throw new Error(`${filePath} is not a file`);
+    }
+    const content = await fs11.readFile(absolutePath, "base64");
+    const ext = path11.extname(absolutePath).toLowerCase();
+    let mimeType = "application/octet-stream";
+    switch (ext) {
+      case ".txt":
+      case ".log":
+        mimeType = "text/plain";
+        break;
+      case ".json":
+        mimeType = "application/json";
+        break;
+      case ".js":
+        mimeType = "application/javascript";
+        break;
+      case ".ts":
+        mimeType = "application/typescript";
+        break;
+      case ".md":
+        mimeType = "text/markdown";
+        break;
+    }
+    return {
+      content,
+      size: stats.size,
+      type: mimeType
+    };
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+__name(readFileAsBase64, "readFileAsBase64");
+async function collectLogFiles() {
+  const attachments = [];
+  const logLocations = [
+    path11.join(os4.homedir(), ".leanmcp", "logs"),
+    path11.join(process.cwd(), "logs"),
+    path11.join(process.cwd(), ".leanmcp", "logs")
+  ];
+  for (const logDir of logLocations) {
+    try {
+      if (await fs11.pathExists(logDir)) {
+        const files = await fs11.readdir(logDir);
+        const logFiles = [];
+        for (const file of files) {
+          if (!file.endsWith(".log")) continue;
+          try {
+            const filePath = path11.join(logDir, file);
+            const stats = await fs11.stat(filePath);
+            logFiles.push({
+              file,
+              filePath,
+              mtime: stats.mtimeMs
+            });
+          } catch (e) {
+          }
+        }
+        const recentLogs = logFiles.sort((a, b) => b.mtime - a.mtime).slice(0, 3);
+        for (const log of recentLogs) {
+          try {
+            const fileData = await readFileAsBase64(log.filePath);
+            if (!attachments.some((a) => a.name === log.file)) {
+              attachments.push({
+                name: log.file,
+                ...fileData
+              });
+            }
+          } catch (error) {
+            debug4(`Failed to read log file ${log.filePath}: ${error}`);
+          }
+        }
+      }
+    } catch (error) {
+      debug4(`Failed to scan log directory ${logDir}: ${error}`);
+    }
+  }
+  const npmDebugLog = path11.join(os4.homedir(), ".npm", "_logs");
+  try {
+    if (await fs11.pathExists(npmDebugLog)) {
+      const logFiles = await fs11.readdir(npmDebugLog);
+      const latestLog = logFiles.filter((file) => file.endsWith(".log")).sort().pop();
+      if (latestLog) {
+        const filePath = path11.join(npmDebugLog, latestLog);
+        try {
+          const fileData = await readFileAsBase64(filePath);
+          attachments.push({
+            name: `npm-${latestLog}`,
+            ...fileData
+          });
+        } catch (error) {
+          debug4(`Failed to read npm debug log: ${error}`);
+        }
+      }
+    }
+  } catch (error) {
+    debug4(`Failed to collect npm debug logs: ${error}`);
+  }
+  return attachments;
+}
+__name(collectLogFiles, "collectLogFiles");
+async function sendFeedbackToApi(message, attachments = [], isAnonymous = false) {
+  const apiUrl = await getApiUrl();
+  const endpoint = isAnonymous ? "/feedback/anonymous" : "/feedback";
+  const url = `${apiUrl}${endpoint}`;
+  debug4("API URL:", apiUrl);
+  debug4("Endpoint:", endpoint);
+  debug4("Message length:", message.length);
+  debug4("Attachments count:", attachments.length);
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (!isAnonymous) {
+    const apiKey = await getApiKey();
+    if (!apiKey) {
+      throw new Error("Not authenticated. Please run `leanmcp login` first.");
+    }
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const payload = {
+    message,
+    attachments: attachments.map((att) => ({
+      name: att.name,
+      content: att.content,
+      size: att.size,
+      type: att.type
+    }))
+  };
+  debug4("Sending feedback request...");
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload)
+  });
+  debug4("Response status:", response.status);
+  debug4("Response ok:", response.ok);
+  if (!response.ok) {
+    const errorText = await response.text();
+    debug4("Error response:", errorText);
+    if (response.status === 401) {
+      throw new Error("Authentication failed. Please run `leanmcp login` to re-authenticate.");
+    } else if (response.status === 413) {
+      throw new Error("Attachments too large. Please try again without log files.");
+    } else {
+      throw new Error(`Failed to send feedback: ${response.status} ${response.statusText}`);
+    }
+  }
+  return await response.json();
+}
+__name(sendFeedbackToApi, "sendFeedbackToApi");
+async function sendFeedbackCommand(message, options) {
+  logger.info("\nLeanMCP Feedback\n");
+  const isAnonymous = options.anon || false;
+  const includeLogs = options.includeLogs || false;
+  debug4("Feedback options:", {
+    isAnonymous,
+    includeLogs
+  });
+  let feedbackMessage = message;
+  if (!feedbackMessage && !process.stdin.isTTY) {
+    debug4("Reading feedback message from stdin...");
+    feedbackMessage = await new Promise((resolve) => {
+      let data = "";
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => {
+        resolve(data.trim());
+      });
+    });
+  }
+  if (!feedbackMessage || feedbackMessage.trim().length === 0) {
+    logger.error("Feedback message cannot be empty.");
+    logger.info("Usage examples:");
+    logger.info('  leanmcp send-feedback "Your message"');
+    logger.gray("  leanmcp send-feedback << EOF");
+    logger.gray("    multi-line");
+    logger.gray("    message");
+    logger.gray("  EOF");
+    logger.info('  leanmcp send-feedback --anon "Anonymous feedback"');
+    logger.info('  leanmcp send-feedback "Issue with deploy" --include-logs');
+    process.exit(1);
+  }
+  if (feedbackMessage.length > 5e3) {
+    logger.error("Feedback message is too long (max 5000 characters).");
+    process.exit(1);
+  }
+  if (!isAnonymous) {
+    const apiKey = await getApiKey();
+    if (!apiKey) {
+      logger.error("need to login");
+      logger.info("Please run `leanmcp login` to authenticate, or use `--anon` for anonymous feedback.");
+      process.exit(1);
+    }
+  }
+  let attachments = [];
+  if (includeLogs) {
+    const spinner2 = ora6("Collecting log files...").start();
+    try {
+      attachments = await collectLogFiles();
+      spinner2.succeed(`Collected ${attachments.length} log file(s)`);
+      if (attachments.length > 0) {
+        logger.log("Log files:", chalk.gray);
+        attachments.forEach((att) => {
+          logger.log(`  - ${att.name} (${(att.size / 1024).toFixed(1)} KB)`, chalk.gray);
+        });
+        logger.log("");
+      } else {
+        logger.log("No log files found.", chalk.gray);
+        logger.log("");
+      }
+    } catch (error) {
+      spinner2.fail("Failed to collect log files");
+      debug4("Log collection error:", error);
+      logger.warn("Continuing without log files...");
+    }
+  }
+  const spinner = ora6("Sending feedback...").start();
+  try {
+    const result = await sendFeedbackToApi(feedbackMessage, attachments, isAnonymous);
+    spinner.succeed("Feedback sent successfully!");
+    logger.success("\nThank you for your feedback!");
+    logger.log(`Feedback ID: ${result.id}`, chalk.gray);
+    if (isAnonymous) {
+      logger.log("Type: Anonymous", chalk.gray);
+    } else {
+      logger.log("Type: Authenticated", chalk.gray);
+    }
+    if (attachments.length > 0) {
+      logger.log(`Attachments: ${attachments.length}`, chalk.gray);
+    }
+    logger.log("\nWe appreciate your input and will review it soon.", chalk.cyan);
+  } catch (error) {
+    spinner.fail("Failed to send feedback");
+    if (error instanceof Error) {
+      logger.error(`
+${error.message}`);
+    } else {
+      logger.error("\nAn unknown error occurred.");
+    }
+    if (DEBUG_MODE4) {
+      debug4("Full error:", error);
+    }
+    process.exit(1);
+  }
+}
+__name(sendFeedbackCommand, "sendFeedbackCommand");
+
+// src/commands/projects.ts
+import ora7 from "ora";
 var API_ENDPOINT = "/api/projects";
 async function projectsListCommand() {
   const apiKey = await getApiKey();
@@ -2414,7 +2715,7 @@ async function projectsListCommand() {
     logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
-  const spinner = ora6("Fetching projects...").start();
+  const spinner = ora7("Fetching projects...").start();
   try {
     const apiUrl = await getApiUrl();
     const response = await fetch(`${apiUrl}${API_ENDPOINT}`, {
@@ -2459,7 +2760,7 @@ async function projectsGetCommand(projectId) {
     logger.gray("Run `leanmcp login` first to authenticate.\n");
     process.exit(1);
   }
-  const spinner = ora6("Fetching project...").start();
+  const spinner = ora7("Fetching project...").start();
   try {
     const apiUrl = await getApiUrl();
     const response = await fetch(`${apiUrl}${API_ENDPOINT}/${projectId}`, {
@@ -2514,7 +2815,7 @@ async function projectsDeleteCommand(projectId, options = {}) {
       return;
     }
   }
-  const spinner = ora6("Deleting project...").start();
+  const spinner = ora7("Deleting project...").start();
   try {
     const apiUrl = await getApiUrl();
     const response = await fetch(`${apiUrl}${API_ENDPOINT}/${projectId}`, {
@@ -2541,50 +2842,50 @@ ${error instanceof Error ? error.message : String(error)}`);
 __name(projectsDeleteCommand, "projectsDeleteCommand");
 
 // src/commands/env.ts
-import ora7 from "ora";
-import path10 from "path";
-import fs10 from "fs-extra";
+import ora8 from "ora";
+import path12 from "path";
+import fs12 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
-var DEBUG_MODE4 = false;
+var DEBUG_MODE5 = false;
 function setEnvDebugMode(enabled) {
-  DEBUG_MODE4 = enabled;
+  DEBUG_MODE5 = enabled;
 }
 __name(setEnvDebugMode, "setEnvDebugMode");
-function debug4(message, ...args) {
-  if (DEBUG_MODE4) {
+function debug5(message, ...args) {
+  if (DEBUG_MODE5) {
     console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
   }
 }
-__name(debug4, "debug");
+__name(debug5, "debug");
 async function debugFetch2(url, options = {}) {
-  debug4(`HTTP ${options.method || "GET"} ${url}`);
+  debug5(`HTTP ${options.method || "GET"} ${url}`);
   if (options.body && typeof options.body === "string") {
     try {
       const body = JSON.parse(options.body);
-      debug4("Request body:", JSON.stringify(body, null, 2));
+      debug5("Request body:", JSON.stringify(body, null, 2));
     } catch {
-      debug4("Request body:", options.body);
+      debug5("Request body:", options.body);
     }
   }
   const startTime = Date.now();
   const response = await fetch(url, options);
   const duration = Date.now() - startTime;
-  debug4(`Response: ${response.status} ${response.statusText} (${duration}ms)`);
+  debug5(`Response: ${response.status} ${response.statusText} (${duration}ms)`);
   return response;
 }
 __name(debugFetch2, "debugFetch");
 var LEANMCP_CONFIG_DIR2 = ".leanmcp";
 var LEANMCP_CONFIG_FILE2 = "config.json";
 async function readLeanMCPConfig2(projectPath) {
-  const configPath = path10.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
+  const configPath = path12.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
   try {
-    if (await fs10.pathExists(configPath)) {
-      const config = await fs10.readJSON(configPath);
-      debug4("Found existing .leanmcp config:", config);
+    if (await fs12.pathExists(configPath)) {
+      const config = await fs12.readJSON(configPath);
+      debug5("Found existing .leanmcp config:", config);
       return config;
     }
   } catch (e) {
-    debug4("Could not read .leanmcp config:", e);
+    debug5("Could not read .leanmcp config:", e);
   }
   return null;
 }
@@ -2597,7 +2898,7 @@ async function getDeploymentContext(folderPath) {
     return null;
   }
   const apiUrl = await getApiUrl();
-  const absolutePath = path10.resolve(process.cwd(), folderPath);
+  const absolutePath = path12.resolve(process.cwd(), folderPath);
   const config = await readLeanMCPConfig2(absolutePath);
   if (!config) {
     logger.error("No deployment found.");
@@ -2624,7 +2925,7 @@ async function envListCommand(folderPath, options = {}) {
     process.exit(1);
   }
   const { apiKey, apiUrl, config } = context;
-  const spinner = ora7("Fetching environment variables...").start();
+  const spinner = ora8("Fetching environment variables...").start();
   try {
     const reveal = options.reveal ? "?reveal=true" : "";
     const response = await debugFetch2(`${apiUrl}/api/lambda-deploy/${config.deploymentId}/env${reveal}`, {
@@ -2665,7 +2966,7 @@ async function envSetCommand(keyValue, folderPath, options = {}) {
   const { apiKey, apiUrl, config } = context;
   let variables = {};
   if (options.file) {
-    const spinner2 = ora7(`Loading from ${options.file}...`).start();
+    const spinner2 = ora8(`Loading from ${options.file}...`).start();
     try {
       variables = await loadEnvFile(options.file);
       spinner2.succeed(`Loaded ${Object.keys(variables).length} variable(s) from ${options.file}`);
@@ -2706,7 +3007,7 @@ ${error instanceof Error ? error.message : String(error)}`);
     logger.warn("No variables to set.\n");
     return;
   }
-  const spinner = ora7("Updating environment variables...").start();
+  const spinner = ora8("Updating environment variables...").start();
   try {
     const response = await debugFetch2(`${apiUrl}/api/lambda-deploy/${config.deploymentId}/env`, {
       method: "PUT",
@@ -2791,7 +3092,7 @@ async function envRemoveCommand(key, folderPath, options = {}) {
       return;
     }
   }
-  const spinner = ora7(`Removing ${key}...`).start();
+  const spinner = ora8(`Removing ${key}...`).start();
   try {
     const response = await debugFetch2(`${apiUrl}/api/lambda-deploy/${config.deploymentId}/env/${key}`, {
       method: "DELETE",
@@ -2820,7 +3121,7 @@ async function envPullCommand(folderPath, options = {}) {
   }
   const { apiKey, apiUrl, config } = context;
   const outputFile = options.file || ".env.remote";
-  const spinner = ora7("Fetching environment variables...").start();
+  const spinner = ora8("Fetching environment variables...").start();
   try {
     const response = await debugFetch2(`${apiUrl}/api/lambda-deploy/${config.deploymentId}/env?reveal=true`, {
       headers: {
@@ -2859,7 +3160,7 @@ async function envPushCommand(folderPath, options = {}) {
   }
   const { apiKey, apiUrl, config } = context;
   const inputFile = options.file || ".env";
-  const loadSpinner = ora7(`Loading from ${inputFile}...`).start();
+  const loadSpinner = ora8(`Loading from ${inputFile}...`).start();
   let variables;
   try {
     variables = await loadEnvFile(inputFile);
@@ -2886,7 +3187,7 @@ ${error instanceof Error ? error.message : String(error)}`);
       return;
     }
   }
-  const pushSpinner = ora7("Pushing environment variables...").start();
+  const pushSpinner = ora8("Pushing environment variables...").start();
   try {
     const response = await debugFetch2(`${apiUrl}/api/lambda-deploy/${config.deploymentId}/env`, {
       method: "PUT",
@@ -3733,30 +4034,30 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     projectName,
     ...options
   });
-  const spinner = ora8(`Creating project ${projectName}...`).start();
-  const targetDir = path11.join(process.cwd(), projectName);
-  if (fs11.existsSync(targetDir)) {
+  const spinner = ora9(`Creating project ${projectName}...`).start();
+  const targetDir = path13.join(process.cwd(), projectName);
+  if (fs13.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await fs11.mkdirp(targetDir);
+  await fs13.mkdirp(targetDir);
   const isPython = options.python === true;
   if (isPython) {
     const requirements = getPythonRequirementsTemplate();
-    await fs11.writeFile(path11.join(targetDir, "requirements.txt"), requirements);
+    await fs13.writeFile(path13.join(targetDir, "requirements.txt"), requirements);
     const mainPy = getPythonMainTemplate(projectName);
-    await fs11.writeFile(path11.join(targetDir, "main.py"), mainPy);
-    await fs11.writeFile(path11.join(targetDir, ".gitignore"), pythonGitignoreTemplate);
+    await fs13.writeFile(path13.join(targetDir, "main.py"), mainPy);
+    await fs13.writeFile(path13.join(targetDir, ".gitignore"), pythonGitignoreTemplate);
     const env = `# Server Configuration
 PORT=3001
 
 # Add your environment variables here
 `;
-    await fs11.writeFile(path11.join(targetDir, ".env"), env);
+    await fs13.writeFile(path13.join(targetDir, ".env"), env);
     const readme = getPythonReadmeTemplate(projectName);
-    await fs11.writeFile(path11.join(targetDir, "README.md"), readme);
+    await fs13.writeFile(path13.join(targetDir, "README.md"), readme);
   } else {
-    await fs11.mkdirp(path11.join(targetDir, "mcp", "example"));
+    await fs13.mkdirp(path13.join(targetDir, "mcp", "example"));
     const pkg2 = {
       name: projectName,
       version: "1.0.0",
@@ -3792,7 +4093,7 @@ PORT=3001
         typescript: "^5.6.3"
       }
     };
-    await fs11.writeJSON(path11.join(targetDir, "package.json"), pkg2, {
+    await fs13.writeJSON(path13.join(targetDir, "package.json"), pkg2, {
       spaces: 2
     });
     const tsconfig = {
@@ -3815,15 +4116,15 @@ PORT=3001
         "dist"
       ]
     };
-    await fs11.writeJSON(path11.join(targetDir, "tsconfig.json"), tsconfig, {
+    await fs13.writeJSON(path13.join(targetDir, "tsconfig.json"), tsconfig, {
       spaces: 2
     });
     const dashboardLine = options.dashboard === false ? `
   dashboard: false,  // Dashboard disabled via --no-dashboard` : "";
     const mainTs = getMainTsTemplate(projectName, dashboardLine);
-    await fs11.writeFile(path11.join(targetDir, "main.ts"), mainTs);
+    await fs13.writeFile(path13.join(targetDir, "main.ts"), mainTs);
     const exampleServiceTs = getExampleServiceTemplate(projectName);
-    await fs11.writeFile(path11.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
+    await fs13.writeFile(path13.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
     const gitignore = gitignoreTemplate;
     const env = `# Server Configuration
 PORT=3001
@@ -3831,10 +4132,10 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-    await fs11.writeFile(path11.join(targetDir, ".gitignore"), gitignore);
-    await fs11.writeFile(path11.join(targetDir, ".env"), env);
+    await fs13.writeFile(path13.join(targetDir, ".gitignore"), gitignore);
+    await fs13.writeFile(path13.join(targetDir, ".env"), env);
     const readme = getReadmeTemplate(projectName);
-    await fs11.writeFile(path11.join(targetDir, "README.md"), readme);
+    await fs13.writeFile(path13.join(targetDir, "README.md"), readme);
   }
   spinner.succeed(`Project ${projectName} created!`);
   logger.log("\nSuccess! Your MCP server is ready.\n", chalk.green);
@@ -3881,7 +4182,7 @@ NODE_ENV=development
     default: true
   });
   if (shouldInstall) {
-    const installSpinner = ora8("Installing dependencies...").start();
+    const installSpinner = ora9("Installing dependencies...").start();
     try {
       await new Promise((resolve, reject) => {
         const npmInstall = spawn4("npm", [
@@ -3954,24 +4255,33 @@ NODE_ENV=development
     logger.log("To deploy to LeanMCP cloud:", chalk.cyan);
     logger.log(`  cd ${projectName}`, chalk.gray);
     logger.log(`  leanmcp deploy .`, chalk.gray);
+    logger.log("\nSend us feedback:", chalk.cyan);
+    logger.log('  leanmcp send-feedback "Great tool!"\n', chalk.gray);
   }
 });
+program.command("send-feedback [message]").description("Send feedback to the LeanMCP team").option("--anon", "Send feedback anonymously").option("--include-logs", "Include local log files with feedback").action(async (message, options) => {
+  trackCommand("send-feedback", {
+    hasMessage: !!message,
+    ...options
+  });
+  await sendFeedbackCommand(message, options);
+});
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = path11.join(cwd, "mcp");
-  if (!fs11.existsSync(path11.join(cwd, "main.ts"))) {
+  const mcpDir = path13.join(cwd, "mcp");
+  if (!fs13.existsSync(path13.join(cwd, "main.ts"))) {
     logger.log("ERROR: Not a LeanMCP project (main.ts missing).", chalk.red);
     process.exit(1);
   }
-  const serviceDir = path11.join(mcpDir, serviceName);
-  const serviceFile = path11.join(serviceDir, "index.ts");
-  if (fs11.existsSync(serviceDir)) {
+  const serviceDir = path13.join(mcpDir, serviceName);
+  const serviceFile = path13.join(serviceDir, "index.ts");
+  if (fs13.existsSync(serviceDir)) {
     logger.log(`ERROR: Service ${serviceName} already exists.`, chalk.red);
     process.exit(1);
   }
-  await fs11.mkdirp(serviceDir);
+  await fs13.mkdirp(serviceDir);
   const indexTs = getServiceIndexTemplate(serviceName, capitalize(serviceName));
-  await fs11.writeFile(serviceFile, indexTs);
+  await fs13.writeFile(serviceFile, indexTs);
   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);