@leanmcp/cli 0.2.6 → 0.2.8

package/dist/index.d.ts

@@ -1 +1,2 @@
-#!/usr/bin/env node
+
+export {  }

package/dist/index.js

@@ -1,51 +1,415 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// src/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import fs5 from "fs-extra";
+import path5 from "path";
+import ora3 from "ora";
+import { createRequire } from "module";
+import { confirm } from "@inquirer/prompts";
+import { spawn as spawn3 } 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 chokidar from "chokidar";
+
+// src/vite/scanUIApp.ts
+import fs from "fs-extra";
+import path from "path";
+import { glob } from "glob";
+async function scanUIApp(projectDir) {
+  const mcpDir = path.join(projectDir, "mcp");
+  if (!await fs.pathExists(mcpDir)) {
+    return [];
+  }
+  const tsFiles = await glob("**/*.ts", {
+    cwd: mcpDir,
+    absolute: false,
+    ignore: [
+      "**/*.d.ts",
+      "**/node_modules/**"
+    ]
+  });
+  const results = [];
+  for (const relativeFile of tsFiles) {
+    const filePath = path.join(mcpDir, relativeFile);
+    const content = await fs.readFile(filePath, "utf-8");
+    if (!content.includes("@UIApp") || !content.includes("@leanmcp/ui")) {
+      continue;
+    }
+    const uiApps = parseUIAppDecorators(content, filePath);
+    results.push(...uiApps);
   }
-  return to;
+  return results;
+}
+__name(scanUIApp, "scanUIApp");
+function parseUIAppDecorators(content, filePath) {
+  const results = [];
+  const classMatch = content.match(/export\s+class\s+(\w+)/);
+  const serviceName = classMatch ? classMatch[1] : "Unknown";
+  const importMap = parseImports(content, filePath);
+  const uiAppRegex = /@UIApp\s*\(\s*\{([^}]+)\}\s*\)\s*(?:async\s+)?(\w+)/g;
+  let match;
+  while ((match = uiAppRegex.exec(content)) !== null) {
+    const decoratorBody = match[1];
+    const methodName = match[2];
+    const componentMatch = decoratorBody.match(/component\s*:\s*(\w+)/);
+    if (!componentMatch) continue;
+    const componentName = componentMatch[1];
+    const componentPath = importMap[componentName];
+    if (!componentPath) {
+      console.warn(`[scanUIApp] Could not resolve import for component: ${componentName}`);
+      continue;
+    }
+    const servicePrefix = serviceName.replace(/Service$/i, "").toLowerCase();
+    const resourceUri = `ui://${servicePrefix}/${methodName}`;
+    results.push({
+      servicePath: filePath,
+      componentPath,
+      componentName,
+      resourceUri,
+      methodName,
+      serviceName
+    });
+  }
+  return results;
+}
+__name(parseUIAppDecorators, "parseUIAppDecorators");
+function parseImports(content, filePath) {
+  const importMap = {};
+  const dir = path.dirname(filePath);
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[2];
+    if (!importPath.startsWith(".")) continue;
+    const names = match[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim());
+    let resolvedPath = path.resolve(dir, importPath);
+    if (!resolvedPath.endsWith(".tsx") && !resolvedPath.endsWith(".ts")) {
+      if (fs.existsSync(resolvedPath + ".tsx")) {
+        resolvedPath += ".tsx";
+      } else if (fs.existsSync(resolvedPath + ".ts")) {
+        resolvedPath += ".ts";
+      }
+    }
+    for (const name of names) {
+      importMap[name] = resolvedPath;
+    }
+  }
+  return importMap;
+}
+__name(parseImports, "parseImports");
+
+// src/vite/buildUI.ts
+import * as vite from "vite";
+import react from "@vitejs/plugin-react";
+import { viteSingleFile } from "vite-plugin-singlefile";
+import fs2 from "fs-extra";
+import path2 from "path";
+async function buildUIComponent(uiApp, projectDir, isDev = false) {
+  const { componentPath, componentName, resourceUri } = uiApp;
+  const safeFileName = resourceUri.replace("ui://", "").replace(/\//g, "-") + ".html";
+  const outDir = path2.join(projectDir, "dist", "ui");
+  const htmlPath = path2.join(outDir, safeFileName);
+  await fs2.ensureDir(outDir);
+  const tempDir = path2.join(projectDir, ".leanmcp-temp");
+  await fs2.ensureDir(tempDir);
+  const entryHtml = path2.join(tempDir, "index.html");
+  const entryJs = path2.join(tempDir, "entry.tsx");
+  await fs2.writeFile(entryHtml, `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MCP App</title>
+</head>
+<body>
+    <div id="root"></div>
+    <script type="module" src="./entry.tsx"></script>
+</body>
+</html>`);
+  const relativeComponentPath = path2.relative(tempDir, componentPath).replace(/\\/g, "/");
+  await fs2.writeFile(entryJs, `
+import React, { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { AppProvider } from '@leanmcp/ui';
+import { ${componentName} } from '${relativeComponentPath.replace(/\.tsx?$/, "")}';
+
+const APP_INFO = {
+    name: '${componentName}',
+    version: '1.0.0'
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+
+function App() {
+    return (
+        <AppProvider appInfo={APP_INFO}>
+            <${componentName} />
+        </AppProvider>
+    );
+}
+
+createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+        <App />
+    </StrictMode>
+);
+`);
+  try {
+    await vite.build({
+      root: tempDir,
+      plugins: [
+        react(),
+        viteSingleFile()
+      ],
+      build: {
+        outDir,
+        emptyOutDir: false,
+        sourcemap: isDev ? "inline" : false,
+        minify: !isDev,
+        rollupOptions: {
+          input: entryHtml,
+          output: {
+            entryFileNames: `[name].js`
+          }
+        }
+      },
+      logLevel: "warn"
+    });
+    const builtHtml = path2.join(outDir, "index.html");
+    if (await fs2.pathExists(builtHtml)) {
+      await fs2.move(builtHtml, htmlPath, {
+        overwrite: true
+      });
+    }
+    await fs2.remove(entryHtml);
+    await fs2.remove(entryJs);
+    return {
+      success: true,
+      htmlPath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      htmlPath: "",
+      error: error.message
+    };
+  }
+}
+__name(buildUIComponent, "buildUIComponent");
+async function writeUIManifest(manifest, projectDir) {
+  const manifestPath = path2.join(projectDir, "dist", "ui-manifest.json");
+  await fs2.ensureDir(path2.dirname(manifestPath));
+  await fs2.writeJson(manifestPath, manifest, {
+    spaces: 2
+  });
+}
+__name(writeUIManifest, "writeUIManifest");
+
+// src/commands/dev.ts
+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."));
+    process.exit(1);
+  }
+  console.log(chalk.cyan("\n\u{1F680} LeanMCP Development Server\n"));
+  const scanSpinner = ora("Scanning for @UIApp components...").start();
+  const uiApps = await scanUIApp(cwd);
+  if (uiApps.length === 0) {
+    scanSpinner.succeed("No @UIApp components found");
+  } else {
+    scanSpinner.succeed(`Found ${uiApps.length} @UIApp component(s)`);
+    for (const app of uiApps) {
+      console.log(chalk.gray(`   \u2022 ${app.componentName} \u2192 ${app.resourceUri}`));
+    }
+  }
+  const manifest = {};
+  if (uiApps.length > 0) {
+    const buildSpinner = ora("Building UI components...").start();
+    const errors = [];
+    for (const app of uiApps) {
+      const result = await buildUIComponent(app, cwd, true);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+      } else {
+        errors.push(`${app.componentName}: ${result.error}`);
+      }
+    }
+    await writeUIManifest(manifest, cwd);
+    if (errors.length > 0) {
+      buildSpinner.warn("Built with warnings");
+      for (const error of errors) {
+        console.error(chalk.yellow(`   \u26A0 ${error}`));
+      }
+    } else {
+      buildSpinner.succeed("UI components built");
+    }
+  }
+  console.log(chalk.cyan("\nStarting development server...\n"));
+  const devServer = spawn("npx", [
+    "tsx",
+    "watch",
+    "main.ts"
+  ], {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  let watcher = null;
+  if (uiApps.length > 0) {
+    const componentPaths = uiApps.map((app) => app.componentPath);
+    watcher = chokidar.watch(componentPaths, {
+      ignoreInitial: true
+    });
+    watcher.on("change", async (changedPath) => {
+      const app = uiApps.find((a) => a.componentPath === changedPath);
+      if (!app) return;
+      console.log(chalk.cyan(`
+[UI] Rebuilding ${app.componentName}...`));
+      const result = await buildUIComponent(app, cwd, true);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+        await writeUIManifest(manifest, cwd);
+        console.log(chalk.green(`[UI] ${app.componentName} rebuilt successfully`));
+      } else {
+        console.log(chalk.yellow(`[UI] ${app.componentName} build failed: ${result.error}`));
+      }
+    });
+  }
+  const cleanup = /* @__PURE__ */ __name(() => {
+    console.log(chalk.gray("\nShutting down..."));
+    if (watcher) watcher.close();
+    devServer.kill();
+    process.exit(0);
+  }, "cleanup");
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  devServer.on("exit", (code) => {
+    if (watcher) watcher.close();
+    process.exit(code ?? 0);
+  });
+}
+__name(devCommand, "devCommand");
+
+// src/commands/start.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 startCommand() {
+  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."));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\n\u{1F680} LeanMCP Production Build\n"));
+  const scanSpinner = ora2("Scanning for @UIApp components...").start();
+  const uiApps = await scanUIApp(cwd);
+  if (uiApps.length === 0) {
+    scanSpinner.succeed("No @UIApp components found");
+  } else {
+    scanSpinner.succeed(`Found ${uiApps.length} @UIApp component(s)`);
+  }
+  const manifest = {};
+  if (uiApps.length > 0) {
+    const buildSpinner = ora2("Building UI components...").start();
+    const errors = [];
+    for (const app of uiApps) {
+      const result = await buildUIComponent(app, cwd, false);
+      if (result.success) {
+        manifest[app.resourceUri] = result.htmlPath;
+      } else {
+        errors.push(`${app.componentName}: ${result.error}`);
+      }
+    }
+    await writeUIManifest(manifest, cwd);
+    if (errors.length > 0) {
+      buildSpinner.fail("Build failed");
+      for (const error of errors) {
+        console.error(chalk2.red(`   \u2717 ${error}`));
+      }
+      process.exit(1);
+    }
+    buildSpinner.succeed("UI components built");
+  }
+  const tscSpinner = ora2("Compiling TypeScript...").start();
+  try {
+    await new Promise((resolve, reject) => {
+      const tsc = spawn2("npx", [
+        "tsc"
+      ], {
+        cwd,
+        stdio: "pipe",
+        shell: true
+      });
+      let stderr = "";
+      tsc.stderr?.on("data", (data) => {
+        stderr += data;
+      });
+      tsc.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(stderr || `tsc exited with code ${code}`));
+      });
+      tsc.on("error", reject);
+    });
+    tscSpinner.succeed("TypeScript compiled");
+  } catch (error) {
+    tscSpinner.fail("TypeScript compilation failed");
+    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\nStarting production server...\n"));
+  const server = spawn2("node", [
+    "dist/main.js"
+  ], {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  const cleanup = /* @__PURE__ */ __name(() => {
+    console.log(chalk2.gray("\nShutting down..."));
+    server.kill();
+    process.exit(0);
+  }, "cleanup");
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  server.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+__name(startCommand, "startCommand");
 
 // src/index.ts
-var import_commander = require("commander");
-var import_chalk = __toESM(require("chalk"));
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = __toESM(require("path"));
-var import_ora = __toESM(require("ora"));
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 __name(capitalize, "capitalize");
-var program = new import_commander.Command();
-program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version("0.1.0");
-program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").action(async (projectName) => {
-  const spinner = (0, import_ora.default)(`Creating project ${projectName}...`).start();
-  const targetDir = import_path.default.join(process.cwd(), projectName);
-  if (import_fs_extra.default.existsSync(targetDir)) {
+var program = new Command();
+program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version(pkg.version).addHelpText("after", `
+Examples:
+  $ leanmcp create my-app --allow-all    # Scaffold without interactive prompts
+`);
+program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").option("--allow-all", "Skip interactive confirmations and assume Yes").action(async (projectName, options) => {
+  const spinner = ora3(`Creating project ${projectName}...`).start();
+  const targetDir = path5.join(process.cwd(), projectName);
+  if (fs5.existsSync(targetDir)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await import_fs_extra.default.mkdirp(targetDir);
-  await import_fs_extra.default.mkdirp(import_path.default.join(targetDir, "mcp"));
-  const pkg = {
+  await fs5.mkdirp(targetDir);
+  await fs5.mkdirp(path5.join(targetDir, "mcp", "example"));
+  const pkg2 = {
     name: projectName,
     version: "1.0.0",
     description: "MCP Server with Streamable HTTP Transport and LeanMCP SDK",
@@ -66,21 +430,16 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     author: "",
     license: "MIT",
     dependencies: {
-      "@leanmcp/core": "^0.1.0",
-      "@modelcontextprotocol/sdk": "^1.0.0",
-      "cors": "^2.8.5",
-      "dotenv": "^16.5.0",
-      "express": "^5.1.0"
+      "@leanmcp/core": "^0.3.5",
+      "dotenv": "^16.5.0"
     },
     devDependencies: {
-      "@types/cors": "^2.8.19",
-      "@types/express": "^5.0.3",
       "@types/node": "^20.0.0",
       "tsx": "^4.20.3",
       "typescript": "^5.6.3"
     }
   };
-  await import_fs_extra.default.writeJSON(import_path.default.join(targetDir, "package.json"), pkg, {
+  await fs5.writeJSON(path5.join(targetDir, "package.json"), pkg2, {
     spaces: 2
   });
   const tsconfig = {
@@ -103,12 +462,11 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       "dist"
     ]
   };
-  await import_fs_extra.default.writeJSON(import_path.default.join(targetDir, "tsconfig.json"), tsconfig, {
+  await fs5.writeJSON(path5.join(targetDir, "tsconfig.json"), tsconfig, {
     spaces: 2
   });
   const mainTs = `import dotenv from "dotenv";
 import { createHTTPServer, MCPServer } from "@leanmcp/core";
-import { ExampleService } from "./mcp/example.js";
 
 // Load environment variables
 dotenv.config();
@@ -117,27 +475,29 @@ const PORT = Number(process.env.PORT) || 3001;
 
 /**
  * Create and configure the MCP server
+ * Services are automatically discovered from ./mcp directory
  */
-function createMCPServer() {
+const serverFactory = async () => {
   const server = new MCPServer({ 
     name: "${projectName}", 
-    version: "1.0.0" 
+    version: "1.0.0",
+    logging: true
   });
 
-  // Register your services here
-  server.registerService(new ExampleService());
-
+  // Services are automatically discovered and registered from ./mcp
   return server.getServer();
-}
+};
 
 // Start the HTTP server
-await createHTTPServer(createMCPServer, {
+await createHTTPServer(serverFactory, {
   port: PORT,
   cors: true,
-  logging: true
+  logging: true  // Log HTTP requests
 });
+
+console.log(\`\\n${projectName} MCP Server\`);
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "main.ts"), mainTs);
+  await fs5.writeFile(path5.join(targetDir, "main.ts"), mainTs);
   const exampleServiceTs = `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
 
 /**
@@ -163,27 +523,38 @@ class CalculateInput {
   operation?: string;
 }
 
+class EchoInput {
+  @SchemaConstraint({ 
+    description: "Message to echo back",
+    minLength: 1
+  })
+  message!: string;
+}
+
 export class ExampleService {
   @Tool({ 
     description: "Perform arithmetic operations with automatic schema validation",
     inputClass: CalculateInput
   })
   async calculate(input: CalculateInput) {
+    // Ensure numerical operations by explicitly converting to numbers
+    const a = Number(input.a);
+    const b = Number(input.b);
     let result: number;
     
     switch (input.operation || "add") {
       case "add":
-        result = input.a + input.b;
+        result = a + b;
         break;
       case "subtract":
-        result = input.a - input.b;
+        result = a - b;
         break;
       case "multiply":
-        result = input.a * input.b;
+        result = a * b;
         break;
       case "divide":
-        if (input.b === 0) throw new Error("Cannot divide by zero");
-        result = input.a / input.b;
+        if (b === 0) throw new Error("Cannot divide by zero");
+        result = a / b;
         break;
       default:
         throw new Error("Invalid operation");
@@ -201,8 +572,11 @@ export class ExampleService {
     };
   }
 
-  @Tool({ description: "Echo a message back" })
-  async echo(input: { message: string }) {
+  @Tool({ 
+    description: "Echo a message back",
+    inputClass: EchoInput
+  })
+  async echo(input: EchoInput) {
     return {
       content: [{
         type: "text" as const,
@@ -243,7 +617,7 @@ export class ExampleService {
   }
 }
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "mcp", "example.ts"), exampleServiceTs);
+  await fs5.writeFile(path5.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
   const gitignore = `node_modules
 dist
 .env
@@ -256,8 +630,8 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, ".gitignore"), gitignore);
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, ".env"), env);
+  await fs5.writeFile(path5.join(targetDir, ".gitignore"), gitignore);
+  await fs5.writeFile(path5.join(targetDir, ".env"), env);
   const readme = `# ${projectName}
 
 MCP Server with Streamable HTTP Transport built with LeanMCP SDK
@@ -283,22 +657,36 @@ npm start
 \`\`\`
 ${projectName}/
 \u251C\u2500\u2500 main.ts              # Server entry point
-\u251C\u2500\u2500 mcp/
-\u2502   \u2514\u2500\u2500 example.ts       # Example service
+\u251C\u2500\u2500 mcp/                 # Services directory (auto-discovered)
+\u2502   \u2514\u2500\u2500 example/
+\u2502       \u2514\u2500\u2500 index.ts     # Example service
 \u251C\u2500\u2500 .env                 # Environment variables
 \u2514\u2500\u2500 package.json
 \`\`\`
 
 ## Adding New Services
 
-Create a new service file in \`mcp/\`:
+Create a new service directory in \`mcp/\`:
 
 \`\`\`typescript
-import { Tool } from "@leanmcp/core";
+// mcp/myservice/index.ts
+import { Tool, SchemaConstraint } from "@leanmcp/core";
+
+// Define input schema
+class MyToolInput {
+  @SchemaConstraint({ 
+    description: "Message to process",
+    minLength: 1
+  })
+  message!: string;
+}
 
 export class MyService {
-  @Tool({ description: "My awesome tool" })
-  async myTool(input: { message: string }) {
+  @Tool({ 
+    description: "My awesome tool",
+    inputClass: MyToolInput
+  })
+  async myTool(input: MyToolInput) {
     return {
       content: [{
         type: "text",
@@ -309,12 +697,15 @@ export class MyService {
 }
 \`\`\`
 
-Then register it in \`main.ts\`:
+Services are automatically discovered and registered - no need to modify \`main.ts\`!
 
-\`\`\`typescript
-import { MyService } from "./mcp/my-service.js";
-server.registerService(new MyService());
-\`\`\`
+## Features
+
+- **Zero-config auto-discovery** - Services automatically registered from \`./mcp\` directory
+- **Type-safe decorators** - \`@Tool\`, \`@Prompt\`, \`@Resource\` with full TypeScript support
+- **Schema validation** - Automatic input validation with \`@SchemaConstraint\`
+- **HTTP transport** - Production-ready HTTP server with session management
+- **Hot reload** - Development mode with automatic restart on file changes
 
 ## Testing with MCP Inspector
 
@@ -326,28 +717,88 @@ npx @modelcontextprotocol/inspector http://localhost:3001/mcp
 
 MIT
 `;
-  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "README.md"), readme);
+  await fs5.writeFile(path5.join(targetDir, "README.md"), readme);
   spinner.succeed(`Project ${projectName} created!`);
-  console.log(import_chalk.default.green("\\nSuccess! Your MCP server is ready.\\n"));
-  console.log(import_chalk.default.cyan("Next steps:"));
-  console.log(import_chalk.default.gray(`  cd ${projectName}`));
-  console.log(import_chalk.default.gray(`  npm install`));
-  console.log(import_chalk.default.gray(`  npm run dev`));
-  console.log(import_chalk.default.gray(`\\nServer will run on http://localhost:3001`));
+  console.log(chalk3.green("\nSuccess! Your MCP server is ready.\n"));
+  console.log(chalk3.cyan(`Next, navigate to your project:
+  cd ${projectName}
+`));
+  const shouldInstall = options.allowAll ? true : await confirm({
+    message: "Would you like to install dependencies now?",
+    default: true
+  });
+  if (shouldInstall) {
+    const installSpinner = ora3("Installing dependencies...").start();
+    try {
+      await new Promise((resolve, reject) => {
+        const npmInstall = spawn3("npm", [
+          "install"
+        ], {
+          cwd: targetDir,
+          stdio: "pipe",
+          shell: true
+        });
+        npmInstall.on("close", (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`npm install failed with code ${code}`));
+          }
+        });
+        npmInstall.on("error", reject);
+      });
+      installSpinner.succeed("Dependencies installed successfully!");
+      const shouldStartDev = options.allowAll ? true : await confirm({
+        message: "Would you like to start the development server?",
+        default: true
+      });
+      if (shouldStartDev) {
+        console.log(chalk3.cyan("\nStarting development server...\n"));
+        const devServer = spawn3("npm", [
+          "run",
+          "dev"
+        ], {
+          cwd: targetDir,
+          stdio: "inherit",
+          shell: true
+        });
+        process.on("SIGINT", () => {
+          devServer.kill();
+          process.exit(0);
+        });
+      } else {
+        console.log(chalk3.cyan("\nTo start the development server later:"));
+        console.log(chalk3.gray(`  cd ${projectName}`));
+        console.log(chalk3.gray(`  npm run dev`));
+      }
+    } catch (error) {
+      installSpinner.fail("Failed to install dependencies");
+      console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+      console.log(chalk3.cyan("\nYou can install dependencies manually:"));
+      console.log(chalk3.gray(`  cd ${projectName}`));
+      console.log(chalk3.gray(`  npm install`));
+    }
+  } else {
+    console.log(chalk3.cyan("\nTo get started:"));
+    console.log(chalk3.gray(`  cd ${projectName}`));
+    console.log(chalk3.gray(`  npm install`));
+    console.log(chalk3.gray(`  npm run dev`));
+  }
 });
 program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
   const cwd = process.cwd();
-  const mcpDir = import_path.default.join(cwd, "mcp");
-  if (!import_fs_extra.default.existsSync(import_path.default.join(cwd, "main.ts"))) {
-    console.error(import_chalk.default.red("ERROR: Not a LeanMCP project (main.ts missing)."));
+  const mcpDir = path5.join(cwd, "mcp");
+  if (!fs5.existsSync(path5.join(cwd, "main.ts"))) {
+    console.error(chalk3.red("ERROR: Not a LeanMCP project (main.ts missing)."));
     process.exit(1);
   }
-  await import_fs_extra.default.mkdirp(mcpDir);
-  const serviceFile = import_path.default.join(mcpDir, `${serviceName}.ts`);
-  if (import_fs_extra.default.existsSync(serviceFile)) {
-    console.error(import_chalk.default.red(`ERROR: Service ${serviceName} already exists.`));
+  const serviceDir = path5.join(mcpDir, serviceName);
+  const serviceFile = path5.join(serviceDir, "index.ts");
+  if (fs5.existsSync(serviceDir)) {
+    console.error(chalk3.red(`ERROR: Service ${serviceName} already exists.`));
     process.exit(1);
   }
+  await fs5.mkdirp(serviceDir);
   const indexTs = `import { Tool, Resource, Prompt, Optional, SchemaConstraint } from "@leanmcp/core";
 
 // Input schema for greeting
@@ -407,34 +858,14 @@ export class ${capitalize(serviceName)}Service {
   }
 }
 `;
-  await import_fs_extra.default.writeFile(serviceFile, indexTs);
-  const mainTsPath = import_path.default.join(cwd, "main.ts");
-  let mainTsContent = await import_fs_extra.default.readFile(mainTsPath, "utf-8");
-  const serviceClassName = `${capitalize(serviceName)}Service`;
-  const importStatement = `import { ${serviceClassName} } from "./mcp/${serviceName}.js";`;
-  const registerStatement = `  server.registerService(new ${serviceClassName}());`;
-  const lastImportMatch = mainTsContent.match(/import .* from .*;\n/g);
-  if (lastImportMatch) {
-    const lastImport = lastImportMatch[lastImportMatch.length - 1];
-    const lastImportIndex = mainTsContent.lastIndexOf(lastImport);
-    const afterLastImport = lastImportIndex + lastImport.length;
-    mainTsContent = mainTsContent.slice(0, afterLastImport) + importStatement + "\n" + mainTsContent.slice(afterLastImport);
-  }
-  const registerPattern = /server\.registerService\(new \w+\(\)\);/g;
-  const matches = [
-    ...mainTsContent.matchAll(registerPattern)
-  ];
-  if (matches.length > 0) {
-    const lastMatch = matches[matches.length - 1];
-    const insertPosition = lastMatch.index + lastMatch[0].length;
-    mainTsContent = mainTsContent.slice(0, insertPosition) + "\n" + registerStatement + mainTsContent.slice(insertPosition);
-  }
-  await import_fs_extra.default.writeFile(mainTsPath, mainTsContent);
-  console.log(import_chalk.default.green(`\\nCreated new service: ${import_chalk.default.bold(serviceName)}`));
-  console.log(import_chalk.default.gray(`   File: mcp/${serviceName}.ts`));
-  console.log(import_chalk.default.gray(`   Tool: greet`));
-  console.log(import_chalk.default.gray(`   Prompt: welcomePrompt`));
-  console.log(import_chalk.default.gray(`   Resource: getStatus`));
-  console.log(import_chalk.default.green(`\\nService automatically registered in main.ts!`));
+  await fs5.writeFile(serviceFile, indexTs);
+  console.log(chalk3.green(`\\nCreated new service: ${chalk3.bold(serviceName)}`));
+  console.log(chalk3.gray(`   File: mcp/${serviceName}/index.ts`));
+  console.log(chalk3.gray(`   Tool: greet`));
+  console.log(chalk3.gray(`   Prompt: welcomePrompt`));
+  console.log(chalk3.gray(`   Resource: getStatus`));
+  console.log(chalk3.green(`\\nService will be automatically discovered on next server start!`));
 });
+program.command("dev").description("Start development server with UI hot-reload (builds @UIApp components)").action(devCommand);
+program.command("start").description("Build UI components and start production server").action(startCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/cli",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Command-line interface for scaffolding LeanMCP projects",
   "bin": {
     "leanmcp": "bin/leanmcp.js"
@@ -35,11 +35,12 @@
     "fs-extra": "^11.2.0",
     "glob": "^11.0.0",
     "ora": "^8.1.0",
-    "vite": "^7.3.0",
+    "vite": "^5.4.0",
     "vite-plugin-singlefile": "^2.3.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.2",
     "rimraf": "^6.1.2"
   },
   "repository": {

package/dist/index.d.mts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/index.mjs

@@ -1,418 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/index.ts
-import { Command } from "commander";
-import chalk from "chalk";
-import fs from "fs-extra";
-import path from "path";
-import ora from "ora";
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-__name(capitalize, "capitalize");
-var program = new Command();
-program.name("leanmcp").description("LeanMCP CLI \u2014 create production-ready MCP servers with Streamable HTTP").version("0.1.0");
-program.command("create <projectName>").description("Create a new LeanMCP project with Streamable HTTP transport").action(async (projectName) => {
-  const spinner = ora(`Creating project ${projectName}...`).start();
-  const targetDir = path.join(process.cwd(), projectName);
-  if (fs.existsSync(targetDir)) {
-    spinner.fail(`Folder ${projectName} already exists.`);
-    process.exit(1);
-  }
-  await fs.mkdirp(targetDir);
-  await fs.mkdirp(path.join(targetDir, "mcp"));
-  const pkg = {
-    name: projectName,
-    version: "1.0.0",
-    description: "MCP Server with Streamable HTTP Transport and LeanMCP SDK",
-    main: "dist/main.js",
-    type: "module",
-    scripts: {
-      dev: "tsx watch main.ts",
-      build: "tsc",
-      start: "node dist/main.js",
-      clean: "rm -rf dist"
-    },
-    keywords: [
-      "mcp",
-      "model-context-protocol",
-      "streamable-http",
-      "leanmcp"
-    ],
-    author: "",
-    license: "MIT",
-    dependencies: {
-      "@leanmcp/core": "^0.1.0",
-      "@modelcontextprotocol/sdk": "^1.0.0",
-      "cors": "^2.8.5",
-      "dotenv": "^16.5.0",
-      "express": "^5.1.0"
-    },
-    devDependencies: {
-      "@types/cors": "^2.8.19",
-      "@types/express": "^5.0.3",
-      "@types/node": "^20.0.0",
-      "tsx": "^4.20.3",
-      "typescript": "^5.6.3"
-    }
-  };
-  await fs.writeJSON(path.join(targetDir, "package.json"), pkg, {
-    spaces: 2
-  });
-  const tsconfig = {
-    compilerOptions: {
-      module: "ESNext",
-      target: "ES2022",
-      moduleResolution: "Node",
-      esModuleInterop: true,
-      strict: true,
-      skipLibCheck: true,
-      outDir: "dist",
-      experimentalDecorators: true,
-      emitDecoratorMetadata: true
-    },
-    include: [
-      "**/*.ts"
-    ],
-    exclude: [
-      "node_modules",
-      "dist"
-    ]
-  };
-  await fs.writeJSON(path.join(targetDir, "tsconfig.json"), tsconfig, {
-    spaces: 2
-  });
-  const mainTs = `import dotenv from "dotenv";
-import { createHTTPServer, MCPServer } from "@leanmcp/core";
-import { ExampleService } from "./mcp/example.js";
-
-// Load environment variables
-dotenv.config();
-
-const PORT = Number(process.env.PORT) || 3001;
-
-/**
- * Create and configure the MCP server
- */
-function createMCPServer() {
-  const server = new MCPServer({ 
-    name: "${projectName}", 
-    version: "1.0.0" 
-  });
-
-  // Register your services here
-  server.registerService(new ExampleService());
-
-  return server.getServer();
-}
-
-// Start the HTTP server
-await createHTTPServer(createMCPServer, {
-  port: PORT,
-  cors: true,
-  logging: true
-});
-`;
-  await fs.writeFile(path.join(targetDir, "main.ts"), mainTs);
-  const exampleServiceTs = `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
-
-/**
- * Example service demonstrating LeanMCP SDK decorators
- * 
- * This is a simple example to get you started. Add your own tools, resources, and prompts here!
- */
-
-// Input schema with validation decorators
-class CalculateInput {
-  @SchemaConstraint({ description: "First number" })
-  a!: number;
-
-  @SchemaConstraint({ description: "Second number" })
-  b!: number;
-
-  @Optional()
-  @SchemaConstraint({ 
-    description: "Operation to perform",
-    enum: ["add", "subtract", "multiply", "divide"],
-    default: "add"
-  })
-  operation?: string;
-}
-
-export class ExampleService {
-  @Tool({ 
-    description: "Perform arithmetic operations with automatic schema validation",
-    inputClass: CalculateInput
-  })
-  async calculate(input: CalculateInput) {
-    let result: number;
-    
-    switch (input.operation || "add") {
-      case "add":
-        result = input.a + input.b;
-        break;
-      case "subtract":
-        result = input.a - input.b;
-        break;
-      case "multiply":
-        result = input.a * input.b;
-        break;
-      case "divide":
-        if (input.b === 0) throw new Error("Cannot divide by zero");
-        result = input.a / input.b;
-        break;
-      default:
-        throw new Error("Invalid operation");
-    }
-
-    return {
-      content: [{
-        type: "text" as const,
-        text: JSON.stringify({
-          operation: input.operation || "add",
-          operands: { a: input.a, b: input.b },
-          result
-        }, null, 2)
-      }]
-    };
-  }
-
-  @Tool({ description: "Echo a message back" })
-  async echo(input: { message: string }) {
-    return {
-      content: [{
-        type: "text" as const,
-        text: JSON.stringify({
-          echoed: input.message,
-          timestamp: new Date().toISOString()
-        }, null, 2)
-      }]
-    };
-  }
-
-  @Resource({ description: "Get server information" })
-  async serverInfo() {
-    return {
-      contents: [{
-        uri: "server://info",
-        mimeType: "application/json",
-        text: JSON.stringify({
-          name: "${projectName}",
-          version: "1.0.0",
-          uptime: process.uptime()
-        }, null, 2)
-      }]
-    };
-  }
-
-  @Prompt({ description: "Generate a greeting prompt" })
-  async greeting(args: { name?: string }) {
-    return {
-      messages: [{
-        role: "user" as const,
-        content: {
-          type: "text" as const,
-          text: \`Hello \${args.name || 'there'}! Welcome to ${projectName}.\`
-        }
-      }]
-    };
-  }
-}
-`;
-  await fs.writeFile(path.join(targetDir, "mcp", "example.ts"), exampleServiceTs);
-  const gitignore = `node_modules
-dist
-.env
-.env.local
-*.log
-`;
-  const env = `# Server Configuration
-PORT=3001
-NODE_ENV=development
-
-# Add your environment variables here
-`;
-  await fs.writeFile(path.join(targetDir, ".gitignore"), gitignore);
-  await fs.writeFile(path.join(targetDir, ".env"), env);
-  const readme = `# ${projectName}
-
-MCP Server with Streamable HTTP Transport built with LeanMCP SDK
-
-## Quick Start
-
-\`\`\`bash
-# Install dependencies
-npm install
-
-# Start development server (hot reload)
-npm run dev
-
-# Build for production
-npm run build
-
-# Run production server
-npm start
-\`\`\`
-
-## Project Structure
-
-\`\`\`
-${projectName}/
-\u251C\u2500\u2500 main.ts              # Server entry point
-\u251C\u2500\u2500 mcp/
-\u2502   \u2514\u2500\u2500 example.ts       # Example service
-\u251C\u2500\u2500 .env                 # Environment variables
-\u2514\u2500\u2500 package.json
-\`\`\`
-
-## Adding New Services
-
-Create a new service file in \`mcp/\`:
-
-\`\`\`typescript
-import { Tool } from "@leanmcp/core";
-
-export class MyService {
-  @Tool({ description: "My awesome tool" })
-  async myTool(input: { message: string }) {
-    return {
-      content: [{
-        type: "text",
-        text: \`You said: \${input.message}\`
-      }]
-    };
-  }
-}
-\`\`\`
-
-Then register it in \`main.ts\`:
-
-\`\`\`typescript
-import { MyService } from "./mcp/my-service.js";
-server.registerService(new MyService());
-\`\`\`
-
-## Testing with MCP Inspector
-
-\`\`\`bash
-npx @modelcontextprotocol/inspector http://localhost:3001/mcp
-\`\`\`
-
-## License
-
-MIT
-`;
-  await fs.writeFile(path.join(targetDir, "README.md"), readme);
-  spinner.succeed(`Project ${projectName} created!`);
-  console.log(chalk.green("\\nSuccess! Your MCP server is ready.\\n"));
-  console.log(chalk.cyan("Next steps:"));
-  console.log(chalk.gray(`  cd ${projectName}`));
-  console.log(chalk.gray(`  npm install`));
-  console.log(chalk.gray(`  npm run dev`));
-  console.log(chalk.gray(`\\nServer will run on http://localhost:3001`));
-});
-program.command("add <serviceName>").description("Add a new MCP service to your project").action(async (serviceName) => {
-  const cwd = process.cwd();
-  const mcpDir = path.join(cwd, "mcp");
-  if (!fs.existsSync(path.join(cwd, "main.ts"))) {
-    console.error(chalk.red("ERROR: Not a LeanMCP project (main.ts missing)."));
-    process.exit(1);
-  }
-  await fs.mkdirp(mcpDir);
-  const serviceFile = path.join(mcpDir, `${serviceName}.ts`);
-  if (fs.existsSync(serviceFile)) {
-    console.error(chalk.red(`ERROR: Service ${serviceName} already exists.`));
-    process.exit(1);
-  }
-  const indexTs = `import { Tool, Resource, Prompt, Optional, SchemaConstraint } from "@leanmcp/core";
-
-// Input schema for greeting
-class GreetInput {
-  @SchemaConstraint({
-    description: "Name to greet",
-    minLength: 1
-  })
-  name!: string;
-}
-
-/**
- * ${capitalize(serviceName)} Service
- * 
- * This service demonstrates the three types of MCP primitives:
- * - Tools: Callable functions (like API endpoints)
- * - Prompts: Reusable prompt templates
- * - Resources: Data sources/endpoints
- */
-export class ${capitalize(serviceName)}Service {
-  // TOOL - Callable function
-  // Tool name: "greet" (from function name)
-  @Tool({ 
-    description: "Greet a user by name",
-    inputClass: GreetInput
-  })
-  greet(args: GreetInput) {
-    return { message: \`Hello, \${args.name}! from ${serviceName}\` };
-  }
-
-  // PROMPT - Prompt template
-  // Prompt name: "welcomePrompt" (from function name)
-  @Prompt({ description: "Welcome message prompt template" })
-  welcomePrompt(args: { userName?: string }) {
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: \`Welcome \${args.userName || 'user'}! How can I help you with ${serviceName}?\`
-          }
-        }
-      ]
-    };
-  }
-
-  // RESOURCE - Data endpoint
-  // Resource URI auto-generated from class and method name
-  @Resource({ description: "${capitalize(serviceName)} service status" })
-  getStatus() {
-    return { 
-      service: "${serviceName}", 
-      status: "active",
-      timestamp: new Date().toISOString()
-    };
-  }
-}
-`;
-  await fs.writeFile(serviceFile, indexTs);
-  const mainTsPath = path.join(cwd, "main.ts");
-  let mainTsContent = await fs.readFile(mainTsPath, "utf-8");
-  const serviceClassName = `${capitalize(serviceName)}Service`;
-  const importStatement = `import { ${serviceClassName} } from "./mcp/${serviceName}.js";`;
-  const registerStatement = `  server.registerService(new ${serviceClassName}());`;
-  const lastImportMatch = mainTsContent.match(/import .* from .*;\n/g);
-  if (lastImportMatch) {
-    const lastImport = lastImportMatch[lastImportMatch.length - 1];
-    const lastImportIndex = mainTsContent.lastIndexOf(lastImport);
-    const afterLastImport = lastImportIndex + lastImport.length;
-    mainTsContent = mainTsContent.slice(0, afterLastImport) + importStatement + "\n" + mainTsContent.slice(afterLastImport);
-  }
-  const registerPattern = /server\.registerService\(new \w+\(\)\);/g;
-  const matches = [
-    ...mainTsContent.matchAll(registerPattern)
-  ];
-  if (matches.length > 0) {
-    const lastMatch = matches[matches.length - 1];
-    const insertPosition = lastMatch.index + lastMatch[0].length;
-    mainTsContent = mainTsContent.slice(0, insertPosition) + "\n" + registerStatement + mainTsContent.slice(insertPosition);
-  }
-  await fs.writeFile(mainTsPath, mainTsContent);
-  console.log(chalk.green(`\\nCreated new service: ${chalk.bold(serviceName)}`));
-  console.log(chalk.gray(`   File: mcp/${serviceName}.ts`));
-  console.log(chalk.gray(`   Tool: greet`));
-  console.log(chalk.gray(`   Prompt: welcomePrompt`));
-  console.log(chalk.gray(`   Resource: getStatus`));
-  console.log(chalk.green(`\\nService automatically registered in main.ts!`));
-});
-program.parse();