@leanmcp/cli 0.2.4 → 0.2.6

package/bin/leanmcp.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-
-// Always prefer ESM build
-import('../dist/index.js');
+
+// Always prefer ESM build
+import('../dist/index.js');

package/dist/index.d.mts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,33 +1,51 @@
+#!/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 });
+  }
+  return to;
+};
+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
+));
 
 // src/index.ts
-import { Command } from "commander";
-import chalk from "chalk";
-import fs from "fs-extra";
-import path from "path";
-import ora from "ora";
-import { createRequire } from "module";
-import { confirm } from "@inquirer/prompts";
-import { spawn } from "child_process";
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
+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"));
 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(pkg.version);
+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 = ora(`Creating project ${projectName}...`).start();
-  const targetDir = path.join(process.cwd(), projectName);
-  if (fs.existsSync(targetDir)) {
+  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)) {
     spinner.fail(`Folder ${projectName} already exists.`);
     process.exit(1);
   }
-  await fs.mkdirp(targetDir);
-  await fs.mkdirp(path.join(targetDir, "mcp", "example"));
-  const pkg2 = {
+  await import_fs_extra.default.mkdirp(targetDir);
+  await import_fs_extra.default.mkdirp(import_path.default.join(targetDir, "mcp"));
+  const pkg = {
     name: projectName,
     version: "1.0.0",
     description: "MCP Server with Streamable HTTP Transport and LeanMCP SDK",
@@ -48,16 +66,21 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
     author: "",
     license: "MIT",
     dependencies: {
-      "@leanmcp/core": "^0.3.2",
-      "dotenv": "^16.5.0"
+      "@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"), pkg2, {
+  await import_fs_extra.default.writeJSON(import_path.default.join(targetDir, "package.json"), pkg, {
     spaces: 2
   });
   const tsconfig = {
@@ -80,11 +103,12 @@ program.command("create <projectName>").description("Create a new LeanMCP projec
       "dist"
     ]
   };
-  await fs.writeJSON(path.join(targetDir, "tsconfig.json"), tsconfig, {
+  await import_fs_extra.default.writeJSON(import_path.default.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();
@@ -93,29 +117,27 @@ const PORT = Number(process.env.PORT) || 3001;
 
 /**
  * Create and configure the MCP server
- * Services are automatically discovered from ./mcp directory
  */
-const serverFactory = async () => {
+function createMCPServer() {
   const server = new MCPServer({ 
     name: "${projectName}", 
-    version: "1.0.0",
-    logging: true
+    version: "1.0.0" 
   });
 
-  // Services are automatically discovered and registered from ./mcp
+  // Register your services here
+  server.registerService(new ExampleService());
+
   return server.getServer();
-};
+}
 
 // Start the HTTP server
-await createHTTPServer(serverFactory, {
+await createHTTPServer(createMCPServer, {
   port: PORT,
   cors: true,
-  logging: true  // Log HTTP requests
+  logging: true
 });
-
-console.log(\`\\n${projectName} MCP Server\`);
 `;
-  await fs.writeFile(path.join(targetDir, "main.ts"), mainTs);
+  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "main.ts"), mainTs);
   const exampleServiceTs = `import { Tool, Resource, Prompt, SchemaConstraint, Optional } from "@leanmcp/core";
 
 /**
@@ -141,38 +163,27 @@ 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 = a + b;
+        result = input.a + input.b;
         break;
       case "subtract":
-        result = a - b;
+        result = input.a - input.b;
         break;
       case "multiply":
-        result = a * b;
+        result = input.a * input.b;
         break;
       case "divide":
-        if (b === 0) throw new Error("Cannot divide by zero");
-        result = a / b;
+        if (input.b === 0) throw new Error("Cannot divide by zero");
+        result = input.a / input.b;
         break;
       default:
         throw new Error("Invalid operation");
@@ -190,11 +201,8 @@ export class ExampleService {
     };
   }
 
-  @Tool({ 
-    description: "Echo a message back",
-    inputClass: EchoInput
-  })
-  async echo(input: EchoInput) {
+  @Tool({ description: "Echo a message back" })
+  async echo(input: { message: string }) {
     return {
       content: [{
         type: "text" as const,
@@ -235,7 +243,7 @@ export class ExampleService {
   }
 }
 `;
-  await fs.writeFile(path.join(targetDir, "mcp", "example", "index.ts"), exampleServiceTs);
+  await import_fs_extra.default.writeFile(import_path.default.join(targetDir, "mcp", "example.ts"), exampleServiceTs);
   const gitignore = `node_modules
 dist
 .env
@@ -248,8 +256,8 @@ NODE_ENV=development
 
 # Add your environment variables here
 `;
-  await fs.writeFile(path.join(targetDir, ".gitignore"), gitignore);
-  await fs.writeFile(path.join(targetDir, ".env"), env);
+  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);
   const readme = `# ${projectName}
 
 MCP Server with Streamable HTTP Transport built with LeanMCP SDK
@@ -275,36 +283,22 @@ npm start
 \`\`\`
 ${projectName}/
 \u251C\u2500\u2500 main.ts              # Server entry point
-\u251C\u2500\u2500 mcp/                 # Services directory (auto-discovered)
-\u2502   \u2514\u2500\u2500 example/
-\u2502       \u2514\u2500\u2500 index.ts     # Example service
+\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 directory in \`mcp/\`:
+Create a new service file in \`mcp/\`:
 
 \`\`\`typescript
-// mcp/myservice/index.ts
-import { Tool, SchemaConstraint } from "@leanmcp/core";
-
-// Define input schema
-class MyToolInput {
-  @SchemaConstraint({ 
-    description: "Message to process",
-    minLength: 1
-  })
-  message!: string;
-}
+import { Tool } from "@leanmcp/core";
 
 export class MyService {
-  @Tool({ 
-    description: "My awesome tool",
-    inputClass: MyToolInput
-  })
-  async myTool(input: MyToolInput) {
+  @Tool({ description: "My awesome tool" })
+  async myTool(input: { message: string }) {
     return {
       content: [{
         type: "text",
@@ -315,15 +309,12 @@ export class MyService {
 }
 \`\`\`
 
-Services are automatically discovered and registered - no need to modify \`main.ts\`!
+Then register it in \`main.ts\`:
 
-## 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
+\`\`\`typescript
+import { MyService } from "./mcp/my-service.js";
+server.registerService(new MyService());
+\`\`\`
 
 ## Testing with MCP Inspector
 
@@ -335,88 +326,28 @@ npx @modelcontextprotocol/inspector http://localhost:3001/mcp
 
 MIT
 `;
-  await fs.writeFile(path.join(targetDir, "README.md"), readme);
+  await import_fs_extra.default.writeFile(import_path.default.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, navigate to your project:
-  cd ${projectName}
-`));
-  const shouldInstall = await confirm({
-    message: "Would you like to install dependencies now?",
-    default: true
-  });
-  if (shouldInstall) {
-    const installSpinner = ora("Installing dependencies...").start();
-    try {
-      await new Promise((resolve, reject) => {
-        const npmInstall = spawn("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 = await confirm({
-        message: "Would you like to start the development server?",
-        default: true
-      });
-      if (shouldStartDev) {
-        console.log(chalk.cyan("\nStarting development server...\n"));
-        const devServer = spawn("npm", [
-          "run",
-          "dev"
-        ], {
-          cwd: targetDir,
-          stdio: "inherit",
-          shell: true
-        });
-        process.on("SIGINT", () => {
-          devServer.kill();
-          process.exit(0);
-        });
-      } else {
-        console.log(chalk.cyan("\nTo start the development server later:"));
-        console.log(chalk.gray(`  cd ${projectName}`));
-        console.log(chalk.gray(`  npm run dev`));
-      }
-    } catch (error) {
-      installSpinner.fail("Failed to install dependencies");
-      console.error(chalk.red(error instanceof Error ? error.message : String(error)));
-      console.log(chalk.cyan("\nYou can install dependencies manually:"));
-      console.log(chalk.gray(`  cd ${projectName}`));
-      console.log(chalk.gray(`  npm install`));
-    }
-  } else {
-    console.log(chalk.cyan("\nTo get started:"));
-    console.log(chalk.gray(`  cd ${projectName}`));
-    console.log(chalk.gray(`  npm install`));
-    console.log(chalk.gray(`  npm run dev`));
-  }
+  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`));
 });
 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)."));
+  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)."));
     process.exit(1);
   }
-  const serviceDir = path.join(mcpDir, serviceName);
-  const serviceFile = path.join(serviceDir, "index.ts");
-  if (fs.existsSync(serviceDir)) {
-    console.error(chalk.red(`ERROR: Service ${serviceName} already exists.`));
+  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.`));
     process.exit(1);
   }
-  await fs.mkdirp(serviceDir);
   const indexTs = `import { Tool, Resource, Prompt, Optional, SchemaConstraint } from "@leanmcp/core";
 
 // Input schema for greeting
@@ -476,12 +407,34 @@ export class ${capitalize(serviceName)}Service {
   }
 }
 `;
-  await fs.writeFile(serviceFile, indexTs);
-  console.log(chalk.green(`\\nCreated new service: ${chalk.bold(serviceName)}`));
-  console.log(chalk.gray(`   File: mcp/${serviceName}/index.ts`));
-  console.log(chalk.gray(`   Tool: greet`));
-  console.log(chalk.gray(`   Prompt: welcomePrompt`));
-  console.log(chalk.gray(`   Resource: getStatus`));
-  console.log(chalk.green(`\\nService will be automatically discovered on next server start!`));
+  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!`));
 });
 program.parse();