@leanmcp/core 0.3.19 → 0.4.1

package/dist/index.js

@@ -482,6 +482,164 @@ var init_validation = __esm({
   }
 });
 
+// src/dynamodb-session-store.ts
+var dynamodb_session_store_exports = {};
+__export(dynamodb_session_store_exports, {
+  DEFAULT_TABLE_NAME: () => DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS: () => DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore: () => DynamoDBSessionStore
+});
+var import_client_dynamodb, import_lib_dynamodb, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, DynamoDBSessionStore;
+var init_dynamodb_session_store = __esm({
+  "src/dynamodb-session-store.ts"() {
+    "use strict";
+    import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+    import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+    init_logger();
+    DEFAULT_TABLE_NAME = "leanmcp-sessions";
+    DEFAULT_TTL_SECONDS = 86400;
+    DynamoDBSessionStore = class {
+      static {
+        __name(this, "DynamoDBSessionStore");
+      }
+      client;
+      tableName;
+      ttlSeconds;
+      logger;
+      constructor(options) {
+        this.tableName = options?.tableName || process.env.DYNAMODB_TABLE_NAME || DEFAULT_TABLE_NAME;
+        this.ttlSeconds = options?.ttlSeconds || DEFAULT_TTL_SECONDS;
+        this.logger = new Logger({
+          level: options?.logging ? LogLevel.INFO : LogLevel.NONE,
+          prefix: "DynamoDBSessionStore"
+        });
+        const dynamoClient = new import_client_dynamodb.DynamoDBClient({
+          region: options?.region || process.env.AWS_REGION || "us-east-1"
+        });
+        this.client = import_lib_dynamodb.DynamoDBDocumentClient.from(dynamoClient);
+        this.logger.info(`Initialized with table: ${this.tableName}, TTL: ${this.ttlSeconds}s`);
+      }
+      /**
+      * Check if a session exists in DynamoDB
+      */
+      async sessionExists(sessionId) {
+        try {
+          const result = await this.client.send(new import_lib_dynamodb.GetCommand({
+            TableName: this.tableName,
+            Key: {
+              sessionId
+            },
+            ProjectionExpression: "sessionId"
+          }));
+          const exists = !!result.Item;
+          this.logger.debug(`Session ${sessionId} exists: ${exists}`);
+          return exists;
+        } catch (error) {
+          this.logger.error(`Error checking session existence: ${error.message}`);
+          return false;
+        }
+      }
+      /**
+      * Create a new session in DynamoDB
+      */
+      async createSession(sessionId, data) {
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const ttl = Math.floor(Date.now() / 1e3) + this.ttlSeconds;
+          await this.client.send(new import_lib_dynamodb.PutCommand({
+            TableName: this.tableName,
+            Item: {
+              sessionId,
+              createdAt: now.toISOString(),
+              updatedAt: now.toISOString(),
+              ttl,
+              data: data || {}
+            }
+          }));
+          this.logger.info(`Created session: ${sessionId} (TTL: ${new Date(ttl * 1e3).toISOString()})`);
+        } catch (error) {
+          this.logger.error(`Error creating session ${sessionId}: ${error.message}`);
+          throw new Error(`Failed to create session: ${error.message}`);
+        }
+      }
+      /**
+      * Get session data from DynamoDB
+      */
+      async getSession(sessionId) {
+        try {
+          const result = await this.client.send(new import_lib_dynamodb.GetCommand({
+            TableName: this.tableName,
+            Key: {
+              sessionId
+            }
+          }));
+          if (!result.Item) {
+            this.logger.debug(`Session ${sessionId} not found`);
+            return null;
+          }
+          const sessionData = {
+            sessionId: result.Item.sessionId,
+            createdAt: new Date(result.Item.createdAt),
+            updatedAt: new Date(result.Item.updatedAt),
+            ttl: result.Item.ttl,
+            data: result.Item.data
+          };
+          this.logger.debug(`Retrieved session: ${sessionId}`);
+          return sessionData;
+        } catch (error) {
+          this.logger.error(`Error getting session ${sessionId}: ${error.message}`);
+          return null;
+        }
+      }
+      /**
+      * Update session data in DynamoDB
+      * Automatically refreshes TTL on each update
+      */
+      async updateSession(sessionId, updates) {
+        try {
+          const ttl = Math.floor(Date.now() / 1e3) + this.ttlSeconds;
+          await this.client.send(new import_lib_dynamodb.UpdateCommand({
+            TableName: this.tableName,
+            Key: {
+              sessionId
+            },
+            UpdateExpression: "SET updatedAt = :now, #data = :data, #ttl = :ttl",
+            ExpressionAttributeNames: {
+              "#data": "data",
+              "#ttl": "ttl"
+            },
+            ExpressionAttributeValues: {
+              ":now": (/* @__PURE__ */ new Date()).toISOString(),
+              ":data": updates.data || {},
+              ":ttl": ttl
+            }
+          }));
+          this.logger.debug(`Updated session: ${sessionId}`);
+        } catch (error) {
+          this.logger.error(`Error updating session ${sessionId}: ${error.message}`);
+          throw new Error(`Failed to update session: ${error.message}`);
+        }
+      }
+      /**
+      * Delete a session from DynamoDB
+      */
+      async deleteSession(sessionId) {
+        try {
+          await this.client.send(new import_lib_dynamodb.DeleteCommand({
+            TableName: this.tableName,
+            Key: {
+              sessionId
+            }
+          }));
+          this.logger.info(`Deleted session: ${sessionId}`);
+        } catch (error) {
+          this.logger.error(`Error deleting session ${sessionId}: ${error.message}`);
+        }
+      }
+    };
+  }
+});
+
 // src/http-server.ts
 function isInitializeRequest(body) {
   return body && body.method === "initialize";
@@ -558,7 +716,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");
@@ -673,6 +831,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 Promise.resolve().then(() => (init_dynamodb_session_store(), dynamodb_session_store_exports));
+        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;
@@ -814,19 +985,129 @@ 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(`Initialize request with session ${sessionId} - checking for session restoration...`);
+        if (httpOptions.sessionStore) {
+          const exists = await httpOptions.sessionStore.sessionExists(sessionId);
+          if (exists) {
+            logger.info(`Restoring session: ${sessionId}`);
+            transport = new StreamableHTTPServerTransport2({
+              sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
+              onsessioninitialized: /* @__PURE__ */ __name((sid) => {
+                transports[sid] = transport;
+                logger.info(`Session restored: ${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 {
+            logger.info(`Session ${sessionId} not found in store, creating new session`);
+          }
+        }
+        if (!transport) {
+          transport = new StreamableHTTPServerTransport2({
+            sessionIdGenerator: /* @__PURE__ */ __name(() => (0, import_node_crypto.randomUUID)(), "sessionIdGenerator"),
+            onsessioninitialized: /* @__PURE__ */ __name(async (newSessionId) => {
+              transports[newSessionId] = transport;
+              logger.info(`Session initialized: ${newSessionId}`);
+              if (httpOptions.sessionStore) {
+                await httpOptions.sessionStore.createSession(newSessionId);
+              }
+            }, "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);
+              }
+            }
+          };
+          if (!mcpServer) {
+            throw new Error("MCP server not initialized");
+          }
+          await mcpServer.connect(transport);
+        }
+      } 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;
+          }
+          logger.info(`Auto-restoring session: ${sessionId}`);
+          transport = new StreamableHTTPServerTransport2({
+            sessionIdGenerator: /* @__PURE__ */ __name(() => sessionId, "sessionIdGenerator"),
+            onsessioninitialized: /* @__PURE__ */ __name((sid) => {
+              transports[sid] = transport;
+              logger.info(`Session auto-restored: ${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(() => (0, import_node_crypto.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) {
@@ -882,7 +1163,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);
@@ -1084,11 +1365,152 @@ var init_auth_helpers = __esm({
   }
 });
 
+// src/session-store.ts
+var init_session_store = __esm({
+  "src/session-store.ts"() {
+    "use strict";
+  }
+});
+
+// src/session-provider.ts
+var import_streamableHttp, LeanMCPSessionProvider;
+var init_session_provider = __esm({
+  "src/session-provider.ts"() {
+    "use strict";
+    import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    init_dynamodb_session_store();
+    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 import_streamableHttp.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 index_exports = {};
 __export(index_exports, {
   Auth: () => Auth,
+  DEFAULT_TABLE_NAME: () => DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS: () => DEFAULT_TTL_SECONDS,
   Deprecated: () => Deprecated,
+  DynamoDBSessionStore: () => DynamoDBSessionStore,
+  LeanMCPSessionProvider: () => LeanMCPSessionProvider,
   LogLevel: () => LogLevel,
   Logger: () => Logger,
   MCPServer: () => MCPServer,
@@ -1141,6 +1563,9 @@ var init_index = __esm({
     init_logger();
     init_validation();
     init_auth_helpers();
+    init_session_store();
+    init_session_provider();
+    init_dynamodb_session_store();
     init_decorators();
     init_schema_generator();
     init_logger();
@@ -1454,14 +1879,14 @@ var init_index = __esm({
       /**
       * Auto-register all services from the mcp directory
       * Scans the directory recursively and registers all exported classes
-      * 
+      *
       * @param mcpDir - Path to the mcp directory containing service files
       * @param serviceFactories - Optional map of service class names to factory functions for dependency injection
-      * 
+      *
       * @example
       * // Auto-register services with no dependencies
       * await server.autoRegisterServices('./mcp');
-      * 
+      *
       * @example
       * // Auto-register with dependency injection
       * await server.autoRegisterServices('./mcp', {
@@ -1614,7 +2039,7 @@ var init_index = __esm({
       }
       /**
       * Watch UI manifest for changes and reload resources dynamically
-      * 
+      *
       * CRITICAL: Only for stateful mode. In stateless mode, each request
       * creates a fresh server that reads the manifest directly, making
       * watchers both unnecessary and a memory leak source.
@@ -2143,7 +2568,11 @@ init_index();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Auth,
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
   Deprecated,
+  DynamoDBSessionStore,
+  LeanMCPSessionProvider,
   LogLevel,
   Logger,
   MCPServer,