@leanmcp/core 0.3.18 → 0.4.0

package/dist/index.mjs

@@ -1,5 +1,12 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import {
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore,
+  LogLevel,
+  Logger,
+  __name,
+  defaultLogger
+} from "./chunk-7SU7UAUW.mjs";
 
 // src/index.ts
 import "reflect-metadata";
@@ -285,119 +292,6 @@ __name(classToJsonSchemaWithConstraints, "classToJsonSchemaWithConstraints");
 // src/http-server.ts
 import { randomUUID } from "crypto";
 
-// src/logger.ts
-var LogLevel = /* @__PURE__ */ (function(LogLevel2) {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  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");
-  }
-  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) {
-    const style = levelStyles[level];
-    const timestamp = this.timestamps ? `[${(/* @__PURE__ */ new Date()).toISOString()}]` : "";
-    const prefix = this.prefix ? `[${this.prefix}]` : "";
-    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 && 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) {
-    this.emit(0, message, console.debug, ...args);
-  }
-  info(message, ...args) {
-    this.emit(1, message, console.info, ...args);
-  }
-  warn(message, ...args) {
-    this.emit(2, message, console.warn, ...args);
-  }
-  error(message, ...args) {
-    this.emit(3, message, console.error, ...args);
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  getLevel() {
-    return this.level;
-  }
-};
-var defaultLogger = new Logger({
-  level: 1,
-  prefix: "LeanMCP"
-});
-
 // src/validation.ts
 function validatePort(port) {
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
@@ -520,7 +414,7 @@ async function createHTTPServer(serverInput, options) {
       auth: serverOptions.auth
     };
   }
-  const [express, { StreamableHTTPServerTransport }, cors] = await Promise.all([
+  const [express, { StreamableHTTPServerTransport: StreamableHTTPServerTransport2 }, cors] = await Promise.all([
     // @ts-ignore
     import("express").catch(() => {
       throw new Error("Express not found. Install with: npm install express @types/express");
@@ -635,6 +529,19 @@ async function createHTTPServer(serverInput, options) {
   app.use(express.json());
   const isStateless = httpOptions.stateless !== false;
   console.log(`Starting LeanMCP HTTP Server (${isStateless ? "STATELESS" : "STATEFUL"})...`);
+  if (!isStateless && !httpOptions.sessionStore) {
+    if (process.env.LEANMCP_LAMBDA === "true") {
+      try {
+        const { DynamoDBSessionStore: DynamoDBSessionStore2 } = await import("./dynamodb-session-store-WJ2ALBES.mjs");
+        httpOptions.sessionStore = new DynamoDBSessionStore2({
+          logging: httpOptions.logging
+        });
+        logger.info("Auto-configured DynamoDB session store for LeanMCP Lambda");
+      } catch (e) {
+        logger.warn(`Running on LeanMCP Lambda but failed to initialize DynamoDB session store: ${e.message}`);
+      }
+    }
+  }
   const DASHBOARD_URL = process.env.DASHBOARD_URL || "https://s3-dashboard-build.s3.us-west-2.amazonaws.com/out/index.html";
   let cachedDashboard = null;
   let cacheTimestamp = 0;
@@ -776,19 +683,72 @@ async function createHTTPServer(serverInput, options) {
       if (sessionId && transports[sessionId]) {
         transport = transports[sessionId];
         logger.debug(`Reusing session: ${sessionId}`);
+      } else if (sessionId && !isInitializeRequest(req.body)) {
+        logger.info(`Transport missing for session ${sessionId}, checking session store...`);
+        if (httpOptions.sessionStore) {
+          const exists = await httpOptions.sessionStore.sessionExists(sessionId);
+          if (!exists) {
+            res.status(404).json({
+              jsonrpc: "2.0",
+              error: {
+                code: -32001,
+                message: "Session not found"
+              },
+              id: req.body?.id || null
+            });
+            return;
+          }
+          transport = new StreamableHTTPServerTransport2({
+            sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
+            onsessioninitialized: /* @__PURE__ */ __name((sid) => {
+              transports[sid] = transport;
+              logger.info(`Transport recreated for session: ${sid}`);
+            }, "onsessioninitialized")
+          });
+          transport.onclose = async () => {
+            if (transport.sessionId) {
+              delete transports[transport.sessionId];
+              logger.debug(`Session cleaned up: ${transport.sessionId}`);
+              if (httpOptions.sessionStore) {
+                await httpOptions.sessionStore.deleteSession(transport.sessionId);
+              }
+            }
+          };
+          const freshServer = await serverFactory();
+          if (freshServer && typeof freshServer.waitForInit === "function") {
+            await freshServer.waitForInit();
+          }
+          await freshServer.connect(transport);
+        } else {
+          res.status(400).json({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Session expired (no session store configured)"
+            },
+            id: req.body?.id || null
+          });
+          return;
+        }
       } else if (!sessionId && isInitializeRequest(req.body)) {
         logger.info("Creating new MCP session...");
-        transport = new StreamableHTTPServerTransport({
+        transport = new StreamableHTTPServerTransport2({
           sessionIdGenerator: /* @__PURE__ */ __name(() => randomUUID(), "sessionIdGenerator"),
-          onsessioninitialized: /* @__PURE__ */ __name((newSessionId) => {
+          onsessioninitialized: /* @__PURE__ */ __name(async (newSessionId) => {
             transports[newSessionId] = transport;
             logger.info(`Session initialized: ${newSessionId}`);
+            if (httpOptions.sessionStore) {
+              await httpOptions.sessionStore.createSession(newSessionId);
+            }
           }, "onsessioninitialized")
         });
-        transport.onclose = () => {
+        transport.onclose = async () => {
           if (transport.sessionId) {
             delete transports[transport.sessionId];
             logger.debug(`Session cleaned up: ${transport.sessionId}`);
+            if (httpOptions.sessionStore) {
+              await httpOptions.sessionStore.deleteSession(transport.sessionId);
+            }
           }
         };
         if (!mcpServer) {
@@ -844,7 +804,7 @@ async function createHTTPServer(serverInput, options) {
       if (freshServer && typeof freshServer.waitForInit === "function") {
         await freshServer.waitForInit();
       }
-      const transport = new StreamableHTTPServerTransport({
+      const transport = new StreamableHTTPServerTransport2({
         sessionIdGenerator: void 0
       });
       await freshServer.connect(transport);
@@ -1030,6 +990,129 @@ function createProtectedResourceMetadata(options) {
 }
 __name(createProtectedResourceMetadata, "createProtectedResourceMetadata");
 
+// src/session-provider.ts
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var LeanMCPSessionProvider = class {
+  static {
+    __name(this, "LeanMCPSessionProvider");
+  }
+  transports = /* @__PURE__ */ new Map();
+  sessionStore;
+  constructor(options) {
+    if (options?.sessionStore) {
+      this.sessionStore = options.sessionStore;
+    } else {
+      this.sessionStore = new DynamoDBSessionStore({
+        tableName: options?.tableName,
+        region: options?.region,
+        ttlSeconds: options?.ttlSeconds,
+        logging: options?.logging
+      });
+    }
+  }
+  /**
+  * Get transport from memory
+  */
+  get(sessionId) {
+    return this.transports.get(sessionId);
+  }
+  /**
+  * Check if session exists (memory or DynamoDB)
+  */
+  async has(sessionId) {
+    if (this.transports.has(sessionId)) return true;
+    return this.sessionStore.sessionExists(sessionId);
+  }
+  /**
+  * Store transport and create session in DynamoDB
+  */
+  async set(sessionId, transport) {
+    this.transports.set(sessionId, transport);
+    await this.sessionStore.createSession(sessionId);
+  }
+  /**
+  * Delete transport and session
+  */
+  async delete(sessionId) {
+    this.transports.delete(sessionId);
+    await this.sessionStore.deleteSession(sessionId);
+  }
+  /**
+  * Get or recreate transport for a session
+  * This is the key method for Lambda support - handles container recycling
+  * 
+  * @param sessionId - Session ID to get or recreate
+  * @param serverFactory - Factory function to create fresh MCP server instances
+  * @param transportOptions - Optional callbacks for transport lifecycle events
+  * @returns Transport instance or null if session doesn't exist
+  */
+  async getOrRecreate(sessionId, serverFactory, transportOptions) {
+    const existing = this.transports.get(sessionId);
+    if (existing) return existing;
+    const exists = await this.sessionStore.sessionExists(sessionId);
+    if (!exists) return null;
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
+      onsessioninitialized: /* @__PURE__ */ __name((sid) => {
+        this.transports.set(sid, transport);
+        transportOptions?.onsessioninitialized?.(sid);
+      }, "onsessioninitialized")
+    });
+    transport.onclose = () => {
+      this.transports.delete(sessionId);
+      transportOptions?.onclose?.();
+    };
+    const server = await serverFactory();
+    await server.connect(transport);
+    return transport;
+  }
+  /**
+  * Get session data from DynamoDB
+  */
+  async getSessionData(sessionId) {
+    const session = await this.sessionStore.getSession(sessionId);
+    return session?.data || null;
+  }
+  /**
+  * Update session data in DynamoDB
+  */
+  async updateSessionData(sessionId, data) {
+    await this.sessionStore.updateSession(sessionId, {
+      data
+    });
+  }
+  /**
+  * Get number of in-memory transports
+  */
+  get size() {
+    return this.transports.size;
+  }
+  /**
+  * Get all session IDs in memory
+  */
+  keys() {
+    return this.transports.keys();
+  }
+  /**
+  * Get all transports in memory
+  */
+  values() {
+    return this.transports.values();
+  }
+  /**
+  * Iterate over all sessions in memory
+  */
+  entries() {
+    return this.transports.entries();
+  }
+  /**
+  * Clear all in-memory transports (does not affect DynamoDB)
+  */
+  clear() {
+    this.transports.clear();
+  }
+};
+
 // src/index.ts
 var ajv = new Ajv();
 var MCPServer = class {
@@ -2031,7 +2114,11 @@ async function startMCPServer(options) {
 __name(startMCPServer, "startMCPServer");
 export {
   Auth,
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
   Deprecated,
+  DynamoDBSessionStore,
+  LeanMCPSessionProvider,
   LogLevel,
   Logger,
   MCPServer,