@leanmcp/core 0.3.2 → 0.3.4

package/dist/index.mjs

@@ -46,7 +46,7 @@ function Resource(options = {}) {
   return (target, propertyKey, descriptor) => {
     const resourceName = String(propertyKey);
     const className = target.constructor.name.toLowerCase().replace("service", "");
-    const resourceUri = `${className}://${resourceName}`;
+    const resourceUri = options.uri ?? `ui://${className}/${resourceName}`;
     Reflect.defineMetadata("resource:uri", resourceUri, descriptor.value);
     Reflect.defineMetadata("resource:name", resourceName, descriptor.value);
     Reflect.defineMetadata("resource:description", options.description || "", descriptor.value);
@@ -291,6 +291,35 @@ var LogLevel = /* @__PURE__ */ (function(LogLevel2) {
   LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
   return LogLevel2;
 })({});
+var COLORS = {
+  reset: "\x1B[0m",
+  gray: "\x1B[38;5;244m",
+  blue: "\x1B[1;34m",
+  amber: "\x1B[38;5;214m",
+  red: "\x1B[1;31m"
+};
+var levelStyles = {
+  [0]: {
+    label: "DEBUG",
+    color: COLORS.gray
+  },
+  [1]: {
+    label: "INFO",
+    color: COLORS.blue
+  },
+  [2]: {
+    label: "WARN",
+    color: COLORS.amber
+  },
+  [3]: {
+    label: "ERROR",
+    color: COLORS.red
+  },
+  [4]: {
+    label: "NONE",
+    color: COLORS.gray
+  }
+};
 var Logger = class {
   static {
     __name(this, "Logger");
@@ -298,38 +327,61 @@ var Logger = class {
   level;
   prefix;
   timestamps;
+  colorize;
+  context;
+  handlers;
   constructor(options = {}) {
     this.level = options.level ?? 1;
     this.prefix = options.prefix ?? "";
     this.timestamps = options.timestamps ?? true;
+    this.colorize = options.colorize ?? true;
+    this.context = options.context;
+    this.handlers = options.handlers ?? [];
   }
-  format(level, message, ...args) {
+  format(level, message) {
+    const style = levelStyles[level];
     const timestamp = this.timestamps ? `[${(/* @__PURE__ */ new Date()).toISOString()}]` : "";
     const prefix = this.prefix ? `[${this.prefix}]` : "";
-    return `${timestamp}${prefix}[${level}] ${message}`;
+    const context = this.context ? `[${this.context}]` : "";
+    const label = `[${style.label}]`;
+    const parts = `${timestamp}${prefix}${context}${label} ${message}`;
+    if (!this.colorize) return parts;
+    return `${style.color}${parts}${COLORS.reset}`;
   }
   shouldLog(level) {
-    return level >= this.level;
+    return level >= this.level && this.level !== 4;
+  }
+  emit(level, message, consoleFn, ...args) {
+    if (!this.shouldLog(level)) return;
+    const payload = {
+      level,
+      levelLabel: levelStyles[level].label,
+      message,
+      args,
+      prefix: this.prefix,
+      context: this.context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    consoleFn(this.format(level, message), ...args);
+    this.handlers.forEach((handler) => {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.debug("Logger handler error", err);
+      }
+    });
   }
   debug(message, ...args) {
-    if (this.shouldLog(0)) {
-      console.debug(this.format("DEBUG", message), ...args);
-    }
+    this.emit(0, message, console.debug, ...args);
   }
   info(message, ...args) {
-    if (this.shouldLog(1)) {
-      console.info(this.format("INFO", message), ...args);
-    }
+    this.emit(1, message, console.info, ...args);
   }
   warn(message, ...args) {
-    if (this.shouldLog(2)) {
-      console.warn(this.format("WARN", message), ...args);
-    }
+    this.emit(2, message, console.warn, ...args);
   }
   error(message, ...args) {
-    if (this.shouldLog(3)) {
-      console.error(this.format("ERROR", message), ...args);
-    }
+    this.emit(3, message, console.error, ...args);
   }
   setLevel(level) {
     this.level = level;
@@ -409,7 +461,8 @@ async function createHTTPServer(serverInput, options) {
       port: serverOptions.port,
       cors: serverOptions.cors,
       logging: serverOptions.logging,
-      sessionTimeout: serverOptions.sessionTimeout
+      sessionTimeout: serverOptions.sessionTimeout,
+      stateless: serverOptions.stateless
     };
   }
   const [express, { StreamableHTTPServerTransport }, cors] = await Promise.all([
@@ -434,12 +487,18 @@ async function createHTTPServer(serverInput, options) {
     prefix: "HTTP"
   });
   const logPrimary = /* @__PURE__ */ __name((message) => {
-    console.log(message);
-    logger.info?.(message);
+    if (httpOptions.logging) {
+      logger.info?.(message);
+    } else {
+      console.log(message);
+    }
   }, "logPrimary");
   const warnPrimary = /* @__PURE__ */ __name((message) => {
-    console.warn(message);
-    logger.warn?.(message);
+    if (httpOptions.logging) {
+      logger.warn?.(message);
+    } else {
+      console.warn(message);
+    }
   }, "warnPrimary");
   const startServerWithPortRetry = /* @__PURE__ */ __name(async () => {
     const maxAttempts = 20;
@@ -476,7 +535,7 @@ async function createHTTPServer(serverInput, options) {
   }, "startServerWithPortRetry");
   if (cors && httpOptions.cors) {
     const corsOptions = typeof httpOptions.cors === "object" ? {
-      origin: httpOptions.cors.origin || false,
+      origin: httpOptions.cors.origin || "*",
       methods: [
         "GET",
         "POST",
@@ -494,21 +553,41 @@ async function createHTTPServer(serverInput, options) {
       ],
       credentials: httpOptions.cors.credentials ?? false,
       maxAge: 86400
-    } : false;
-    if (corsOptions) {
-      app.use(cors.default(corsOptions));
-    }
+    } : {
+      // When cors: true, use permissive defaults for development
+      origin: "*",
+      methods: [
+        "GET",
+        "POST",
+        "DELETE",
+        "OPTIONS"
+      ],
+      allowedHeaders: [
+        "Content-Type",
+        "mcp-session-id",
+        "mcp-protocol-version",
+        "Authorization"
+      ],
+      exposedHeaders: [
+        "mcp-session-id"
+      ],
+      credentials: false,
+      maxAge: 86400
+    };
+    app.use(cors.default(corsOptions));
   }
   app.use(express.json());
-  logPrimary("Starting LeanMCP HTTP Server...");
+  const isStateless = httpOptions.stateless !== false;
+  console.log(`Starting LeanMCP HTTP Server (${isStateless ? "STATELESS" : "STATEFUL"})...`);
   app.get("/health", (req, res) => {
     res.json({
       status: "ok",
-      activeSessions: Object.keys(transports).length,
+      mode: isStateless ? "stateless" : "stateful",
+      activeSessions: isStateless ? 0 : Object.keys(transports).length,
       uptime: process.uptime()
     });
   });
-  const handleMCPRequest = /* @__PURE__ */ __name(async (req, res) => {
+  const handleMCPRequestStateful = /* @__PURE__ */ __name(async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     let transport;
     const method = req.body?.method || "unknown";
@@ -571,9 +650,68 @@ async function createHTTPServer(serverInput, options) {
         });
       }
     }
-  }, "handleMCPRequest");
-  app.post("/mcp", handleMCPRequest);
-  app.delete("/mcp", handleMCPRequest);
+  }, "handleMCPRequestStateful");
+  const handleMCPRequestStateless = /* @__PURE__ */ __name(async (req, res) => {
+    const method = req.body?.method || "unknown";
+    const params = req.body?.params;
+    let logMessage = `${req.method} /mcp - ${method}`;
+    if (params?.name) logMessage += ` [${params.name}]`;
+    else if (params?.uri) logMessage += ` [${params.uri}]`;
+    logger.info(logMessage);
+    try {
+      const freshServer = await serverFactory();
+      if (freshServer && typeof freshServer.waitForInit === "function") {
+        await freshServer.waitForInit();
+      }
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0
+      });
+      await freshServer.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      res.on("close", () => {
+        transport.close();
+        freshServer.close();
+      });
+    } catch (error) {
+      logger.error("Error handling MCP request:", error);
+      if (!res.headersSent) {
+        res.status(500).json({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal server error"
+          },
+          id: null
+        });
+      }
+    }
+  }, "handleMCPRequestStateless");
+  if (isStateless) {
+    app.post("/mcp", handleMCPRequestStateless);
+    app.get("/mcp", (_req, res) => {
+      res.status(405).json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "Method not allowed (stateless mode)"
+        },
+        id: null
+      });
+    });
+    app.delete("/mcp", (_req, res) => {
+      res.status(405).json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32e3,
+          message: "Method not allowed (stateless mode)"
+        },
+        id: null
+      });
+    });
+  } else {
+    app.post("/mcp", handleMCPRequestStateful);
+    app.delete("/mcp", handleMCPRequestStateful);
+  }
   return new Promise(async (resolve, reject) => {
     let activeListener;
     try {
@@ -585,9 +723,9 @@ async function createHTTPServer(serverInput, options) {
       activeListener = listener;
       process.env.PORT = String(port);
       listener.port = port;
-      logPrimary(`Server running on http://localhost:${port}`);
-      logPrimary(`MCP endpoint: http://localhost:${port}/mcp`);
-      logPrimary(`Health check: http://localhost:${port}/health`);
+      console.log(`Server running on http://localhost:${port}`);
+      console.log(`MCP endpoint: http://localhost:${port}/mcp`);
+      console.log(`Health check: http://localhost:${port}/health`);
       resolve({
         listener,
         port
@@ -664,6 +802,7 @@ var MCPServer = class {
     if (options.autoDiscover !== false) {
       await this.autoDiscoverServices(options.mcpDir, options.serviceFactories);
     }
+    await this.loadUIManifest();
   }
   /**
   * Wait for initialization to complete
@@ -745,14 +884,18 @@ var MCPServer = class {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       const tools = [];
       for (const [name, tool] of this.tools.entries()) {
-        tools.push({
+        const toolDef = {
           name,
           description: tool.description,
           inputSchema: tool.inputSchema || {
             type: "object",
             properties: {}
           }
-        });
+        };
+        if (tool._meta && Object.keys(tool._meta).length > 0) {
+          toolDef._meta = tool._meta;
+        }
+        tools.push(toolDef);
       }
       return {
         tools
@@ -783,7 +926,7 @@ var MCPServer = class {
         } else {
           formattedResult = String(result);
         }
-        return {
+        const response = {
           content: [
             {
               type: "text",
@@ -791,6 +934,10 @@ var MCPServer = class {
             }
           ]
         };
+        if (tool._meta && Object.keys(tool._meta).length > 0) {
+          response._meta = tool._meta;
+        }
+        return response;
       } catch (error) {
         return {
           content: [
@@ -829,12 +976,20 @@ var MCPServer = class {
       }
       try {
         const result = await resource.method.call(resource.instance);
+        let text;
+        if (typeof result === "string") {
+          text = result;
+        } else if (result && typeof result === "object" && "text" in result) {
+          text = result.text;
+        } else {
+          text = JSON.stringify(result, null, 2);
+        }
         return {
           contents: [
             {
               uri,
               mimeType: resource.mimeType,
-              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+              text
             }
           ]
         };
@@ -980,16 +1135,19 @@ var MCPServer = class {
       if (inputClass) {
         inputSchema = classToJsonSchemaWithConstraints(inputClass);
       }
+      const toolMeta = Reflect.getMetadata?.("tool:meta", method) || {};
       this.tools.set(methodMeta.toolName, {
         name: methodMeta.toolName,
         description: methodMeta.toolDescription || "",
         inputSchema,
         method,
         instance,
-        propertyKey
+        propertyKey,
+        _meta: Object.keys(toolMeta).length > 0 ? toolMeta : void 0
       });
       if (this.logging) {
-        this.logger.debug(`Registered tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}`);
+        const hasUi = toolMeta["ui/resourceUri"] ? " (with UI)" : "";
+        this.logger.debug(`Registered tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}${hasUi}`);
       }
     }
     const promptMethods = getDecoratedMethods(cls, "prompt:name");
@@ -1042,6 +1200,53 @@ var MCPServer = class {
     }
   }
   /**
+  * Load UI manifest and auto-register resources for pre-built @UIApp components.
+  * The manifest is generated by `leanmcp dev` or `leanmcp start` commands.
+  */
+  async loadUIManifest() {
+    try {
+      const manifestPath = path.join(process.cwd(), "dist", "ui-manifest.json");
+      if (!fs.existsSync(manifestPath)) {
+        return;
+      }
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      for (const [uri, htmlPath] of Object.entries(manifest)) {
+        if (this.resources.has(uri)) {
+          if (this.logging) {
+            this.logger.debug(`Skipping UI resource ${uri} - already registered`);
+          }
+          continue;
+        }
+        if (!fs.existsSync(htmlPath)) {
+          if (this.logging) {
+            this.logger.warn(`UI HTML file not found: ${htmlPath}`);
+          }
+          continue;
+        }
+        const html = fs.readFileSync(htmlPath, "utf-8");
+        this.resources.set(uri, {
+          uri,
+          name: uri.replace("ui://", "").replace(/\//g, "-"),
+          description: `Auto-generated UI resource from pre-built HTML`,
+          mimeType: "text/html;profile=mcp-app",
+          inputSchema: void 0,
+          method: /* @__PURE__ */ __name(async () => ({
+            text: html
+          }), "method"),
+          instance: null,
+          propertyKey: "getUI"
+        });
+        if (this.logging) {
+          this.logger.debug(`Registered UI resource from manifest: ${uri}`);
+        }
+      }
+    } catch (error) {
+      if (this.logging) {
+        this.logger.warn(`Failed to load UI manifest: ${error.message}`);
+      }
+    }
+  }
+  /**
   * Get the underlying MCP SDK Server instance
   * Attaches waitForInit method for HTTP server initialization
   */

package/package.json

@@ -1,71 +1,71 @@
-{
-  "name": "@leanmcp/core",
-  "version": "0.3.2",
-  "description": "Core library implementing decorators, reflection, and MCP runtime server",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts",
-    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "ajv": "^8.12.0",
-    "dotenv": "^16.3.1",
-    "reflect-metadata": "^0.2.1"
-  },
-  "peerDependencies": {
-    "cors": "^2.8.5",
-    "express": "^5.0.0"
-  },
-  "peerDependenciesMeta": {
-    "express": {
-      "optional": true
-    },
-    "cors": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.0",
-    "@types/express": "^5.0.0",
-    "@types/node": "^20.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LeanMCP/leanmcp-sdk.git",
-    "directory": "packages/core"
-  },
-  "homepage": "https://github.com/LeanMCP/leanmcp-sdk#readme",
-  "bugs": {
-    "url": "https://github.com/LeanMCP/leanmcp-sdk/issues"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "typescript",
-    "decorators",
-    "server",
-    "runtime"
-  ],
-  "author": "LeanMCP <admin@leanmcp.com>",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@leanmcp/core",
+  "version": "0.3.4",
+  "description": "Core library implementing decorators, reflection, and MCP runtime server",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ajv": "^8.12.0",
+    "dotenv": "^16.3.1",
+    "reflect-metadata": "^0.2.1"
+  },
+  "peerDependencies": {
+    "cors": "^2.8.5",
+    "express": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "cors": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LeanMCP/leanmcp-sdk.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/LeanMCP/leanmcp-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/LeanMCP/leanmcp-sdk/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "typescript",
+    "decorators",
+    "server",
+    "runtime"
+  ],
+  "author": "LeanMCP <admin@leanmcp.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}