@leanmcp/core 0.3.3 → 0.3.4

package/dist/index.js

@@ -63,7 +63,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);
@@ -312,7 +312,7 @@ var init_schema_generator = __esm({
 });
 
 // src/logger.ts
-var LogLevel, Logger, defaultLogger;
+var LogLevel, COLORS, levelStyles, Logger, defaultLogger;
 var init_logger = __esm({
   "src/logger.ts"() {
     "use strict";
@@ -324,6 +324,35 @@ var init_logger = __esm({
       LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
       return LogLevel2;
     })({});
+    COLORS = {
+      reset: "\x1B[0m",
+      gray: "\x1B[38;5;244m",
+      blue: "\x1B[1;34m",
+      amber: "\x1B[38;5;214m",
+      red: "\x1B[1;31m"
+    };
+    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
+      }
+    };
     Logger = class {
       static {
         __name(this, "Logger");
@@ -331,38 +360,61 @@ var init_logger = __esm({
       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;
@@ -448,7 +500,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([
@@ -521,7 +574,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",
@@ -539,21 +592,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());
-  console.log("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";
@@ -616,9 +689,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 {
@@ -773,6 +905,7 @@ var init_index = __esm({
         if (options.autoDiscover !== false) {
           await this.autoDiscoverServices(options.mcpDir, options.serviceFactories);
         }
+        await this.loadUIManifest();
       }
       /**
       * Wait for initialization to complete
@@ -854,14 +987,18 @@ var init_index = __esm({
         this.server.setRequestHandler(import_types.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
@@ -892,7 +1029,7 @@ var init_index = __esm({
             } else {
               formattedResult = String(result);
             }
-            return {
+            const response = {
               content: [
                 {
                   type: "text",
@@ -900,6 +1037,10 @@ var init_index = __esm({
                 }
               ]
             };
+            if (tool._meta && Object.keys(tool._meta).length > 0) {
+              response._meta = tool._meta;
+            }
+            return response;
           } catch (error) {
             return {
               content: [
@@ -938,12 +1079,20 @@ var init_index = __esm({
           }
           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
                 }
               ]
             };
@@ -1089,16 +1238,19 @@ var init_index = __esm({
           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");
@@ -1151,6 +1303,53 @@ var init_index = __esm({
         }
       }
       /**
+      * 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 = import_path.default.join(process.cwd(), "dist", "ui-manifest.json");
+          if (!import_fs.default.existsSync(manifestPath)) {
+            return;
+          }
+          const manifest = JSON.parse(import_fs.default.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 (!import_fs.default.existsSync(htmlPath)) {
+              if (this.logging) {
+                this.logger.warn(`UI HTML file not found: ${htmlPath}`);
+              }
+              continue;
+            }
+            const html = import_fs.default.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
       */