@leanmcp/cli 0.5.7 → 0.5.8

package/dist/index.js

@@ -3,8 +3,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 import { Command } from "commander";
-import fs12 from "fs-extra";
-import path12 from "path";
+import fs13 from "fs-extra";
+import path13 from "path";
 import ora9 from "ora";
 import { createRequire } from "module";
 import { confirm as confirm4 } from "@inquirer/prompts";
@@ -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");
@@ -2406,8 +2442,8 @@ __name(deployCommand, "deployCommand");
 
 // src/commands/feedback.ts
 import ora6 from "ora";
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs11 from "fs-extra";
+import path11 from "path";
 import os4 from "os";
 var DEBUG_MODE4 = false;
 function debug4(message, ...args) {
@@ -2418,13 +2454,13 @@ function debug4(message, ...args) {
 __name(debug4, "debug");
 async function readFileAsBase64(filePath) {
   try {
-    const absolutePath = path10.resolve(filePath);
-    const stats = await fs10.stat(absolutePath);
+    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 fs10.readFile(absolutePath, "base64");
-    const ext = path10.extname(absolutePath).toLowerCase();
+    const content = await fs11.readFile(absolutePath, "base64");
+    const ext = path11.extname(absolutePath).toLowerCase();
     let mimeType = "application/octet-stream";
     switch (ext) {
       case ".txt":
@@ -2457,24 +2493,40 @@ __name(readFileAsBase64, "readFileAsBase64");
 async function collectLogFiles() {
   const attachments = [];
   const logLocations = [
-    path10.join(os4.homedir(), ".leanmcp", "logs"),
-    path10.join(process.cwd(), "logs"),
-    path10.join(process.cwd(), ".leanmcp", "logs")
+    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 fs10.pathExists(logDir)) {
-        const files = await fs10.readdir(logDir);
+      if (await fs11.pathExists(logDir)) {
+        const files = await fs11.readdir(logDir);
+        const logFiles = [];
         for (const file of files) {
-          const filePath = path10.join(logDir, file);
+          if (!file.endsWith(".log")) continue;
           try {
-            const fileData = await readFileAsBase64(filePath);
-            attachments.push({
-              name: file,
-              ...fileData
+            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 ${filePath}: ${error}`);
+            debug4(`Failed to read log file ${log.filePath}: ${error}`);
           }
         }
       }
@@ -2482,13 +2534,13 @@ async function collectLogFiles() {
       debug4(`Failed to scan log directory ${logDir}: ${error}`);
     }
   }
-  const npmDebugLog = path10.join(os4.homedir(), ".npm", "_logs");
+  const npmDebugLog = path11.join(os4.homedir(), ".npm", "_logs");
   try {
-    if (await fs10.pathExists(npmDebugLog)) {
-      const logFiles = await fs10.readdir(npmDebugLog);
+    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 = path10.join(npmDebugLog, latestLog);
+        const filePath = path11.join(npmDebugLog, latestLog);
         try {
           const fileData = await readFileAsBase64(filePath);
           attachments.push({
@@ -2791,8 +2843,8 @@ __name(projectsDeleteCommand, "projectsDeleteCommand");
 
 // src/commands/env.ts
 import ora8 from "ora";
-import path11 from "path";
-import fs11 from "fs-extra";
+import path12 from "path";
+import fs12 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 var DEBUG_MODE5 = false;
 function setEnvDebugMode(enabled) {
@@ -2825,10 +2877,10 @@ __name(debugFetch2, "debugFetch");
 var LEANMCP_CONFIG_DIR2 = ".leanmcp";
 var LEANMCP_CONFIG_FILE2 = "config.json";
 async function readLeanMCPConfig2(projectPath) {
-  const configPath = path11.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
+  const configPath = path12.join(projectPath, LEANMCP_CONFIG_DIR2, LEANMCP_CONFIG_FILE2);
   try {
-    if (await fs11.pathExists(configPath)) {
-      const config = await fs11.readJSON(configPath);
+    if (await fs12.pathExists(configPath)) {
+      const config = await fs12.readJSON(configPath);
       debug5("Found existing .leanmcp config:", config);
       return config;
     }
@@ -2846,7 +2898,7 @@ async function getDeploymentContext(folderPath) {
     return null;
   }
   const apiUrl = await getApiUrl();
-  const absolutePath = path11.resolve(process.cwd(), folderPath);
+  const absolutePath = path12.resolve(process.cwd(), folderPath);
   const config = await readLeanMCPConfig2(absolutePath);
   if (!config) {
     logger.error("No deployment found.");
@@ -3983,29 +4035,29 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     ...options
   });
   const spinner = ora9(`Creating project ${projectName}...`).start();
-  const targetDir = path12.join(process.cwd(), projectName);
-  if (fs12.existsSync(targetDir)) {
+  const targetDir = path13.join(process.cwd(), projectName);
+  if (fs13.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await fs12.mkdirp(targetDir);
+  await fs13.mkdirp(targetDir);
   const isPython = options.python === true;
   if (isPython) {
     const requirements = getPythonRequirementsTemplate();
-    await fs12.writeFile(path12.join(targetDir, "requirements.txt"), requirements);
+    await fs13.writeFile(path13.join(targetDir, "requirements.txt"), requirements);
     const mainPy = getPythonMainTemplate(projectName);
-    await fs12.writeFile(path12.join(targetDir, "main.py"), mainPy);
-    await fs12.writeFile(path12.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 fs12.writeFile(path12.join(targetDir, ".env"), env);
+    await fs13.writeFile(path13.join(targetDir, ".env"), env);
     const readme = getPythonReadmeTemplate(projectName);
-    await fs12.writeFile(path12.join(targetDir, "README.md"), readme);
+    await fs13.writeFile(path13.join(targetDir, "README.md"), readme);
   } else {
-    await fs12.mkdirp(path12.join(targetDir, "mcp", "example"));
+    await fs13.mkdirp(path13.join(targetDir, "mcp", "example"));
     const pkg2 = {
       name: projectName,
       version: "1.0.0",
@@ -4041,7 +4093,7 @@ PORT=3001
         typescript: "^5.6.3"
       }
     };
-    await fs12.writeJSON(path12.join(targetDir, "package.json"), pkg2, {
+    await fs13.writeJSON(path13.join(targetDir, "package.json"), pkg2, {
       spaces: 2
     });
     const tsconfig = {
@@ -4064,15 +4116,15 @@ PORT=3001
         "dist"
       ]
     };
-    await fs12.writeJSON(path12.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 fs12.writeFile(path12.join(targetDir, "main.ts"), mainTs);
+    await fs13.writeFile(path13.join(targetDir, "main.ts"), mainTs);
     const exampleServiceTs = getExampleServiceTemplate(projectName);
-    await fs12.writeFile(path12.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
@@ -4080,10 +4132,10 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-    await fs12.writeFile(path12.join(targetDir, ".gitignore"), gitignore);
-    await fs12.writeFile(path12.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 fs12.writeFile(path12.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);
@@ -4216,20 +4268,20 @@ program.command("send-feedback [message]").description("Send feedback to the Lea
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = path12.join(cwd, "mcp");
-  if (!fs12.existsSync(path12.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 = path12.join(mcpDir, serviceName);
-  const serviceFile = path12.join(serviceDir, "index.ts");
-  if (fs12.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 fs12.mkdirp(serviceDir);
+  await fs13.mkdirp(serviceDir);
   const indexTs = getServiceIndexTemplate(serviceName, capitalize(serviceName));
-  await fs12.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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/cli",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Command-line interface for scaffolding LeanMCP projects",
   "bin": {
     "leanmcp": "bin/leanmcp.js"