@leanmcp/core 0.3.19 → 0.4.0

package/dist/chunk-7SU7UAUW.mjs

@@ -0,0 +1,272 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/dynamodb-session-store.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, DeleteCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
+
+// 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/dynamodb-session-store.ts
+var DEFAULT_TABLE_NAME = "leanmcp-sessions";
+var DEFAULT_TTL_SECONDS = 86400;
+var 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 DynamoDBClient({
+      region: options?.region || process.env.AWS_REGION || "us-east-1"
+    });
+    this.client = 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 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 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 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 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 DeleteCommand({
+        TableName: this.tableName,
+        Key: {
+          sessionId
+        }
+      }));
+      this.logger.info(`Deleted session: ${sessionId}`);
+    } catch (error) {
+      this.logger.error(`Error deleting session ${sessionId}: ${error.message}`);
+    }
+  }
+};
+
+export {
+  __name,
+  LogLevel,
+  Logger,
+  defaultLogger,
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+};

package/dist/chunk-LPEX4YW6.mjs

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __name,
+  __require
+};

package/dist/dynamodb-session-store-WJ2ALBES.mjs

@@ -0,0 +1,10 @@
+import {
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+} from "./chunk-7SU7UAUW.mjs";
+export {
+  DEFAULT_TABLE_NAME,
+  DEFAULT_TTL_SECONDS,
+  DynamoDBSessionStore
+};

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 
 /**
  * Simple configurable logger for LeanMCP SDK
@@ -58,6 +59,43 @@ declare class Logger {
 }
 declare const defaultLogger: Logger;
 
+/**
+ * Session data stored in persistent storage (e.g., DynamoDB)
+ */
+interface SessionData {
+    sessionId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    ttl?: number;
+    data?: Record<string, any>;
+}
+/**
+ * Interface for session storage backends
+ * Implementations can use DynamoDB, Redis, or other persistent stores
+ */
+interface ISessionStore {
+    /**
+     * Check if a session exists in the store
+     */
+    sessionExists(sessionId: string): Promise<boolean>;
+    /**
+     * Create a new session in the store
+     */
+    createSession(sessionId: string, data?: Record<string, any>): Promise<void>;
+    /**
+     * Get session data from the store
+     */
+    getSession(sessionId: string): Promise<SessionData | null>;
+    /**
+     * Update session data in the store
+     */
+    updateSession(sessionId: string, data: Partial<SessionData>): Promise<void>;
+    /**
+     * Delete a session from the store
+     */
+    deleteSession(sessionId: string): Promise<void>;
+}
+
 interface HTTPServerOptions {
     port?: number;
     cors?: boolean | {
@@ -71,6 +109,8 @@ interface HTTPServerOptions {
     dashboard?: boolean;
     /** OAuth/Auth configuration (MCP authorization spec) */
     auth?: HTTPServerAuthOptions;
+    /** Session store for stateful mode (enables session persistence across Lambda container recycling) */
+    sessionStore?: ISessionStore;
 }
 /**
  * OAuth/Auth configuration for MCP server
@@ -530,6 +570,127 @@ declare function createProtectedResourceMetadata(options: {
     documentationUrl?: string;
 }): ProtectedResourceMetadata;
 
+interface LeanMCPSessionProviderOptions {
+    tableName?: string;
+    region?: string;
+    ttlSeconds?: number;
+    logging?: boolean;
+    sessionStore?: ISessionStore;
+}
+/**
+ * Drop-in replacement for Map<string, StreamableHTTPServerTransport>
+ * Provides automatic session persistence for Lambda deployments
+ *
+ * @example
+ * // Before: const transports = new Map<string, StreamableHTTPServerTransport>();
+ * // After:  const sessions = new LeanMCPSessionProvider();
+ *
+ * // Then use sessions.get(), sessions.set(), sessions.getOrRecreate()
+ */
+declare class LeanMCPSessionProvider {
+    private transports;
+    private sessionStore;
+    constructor(options?: LeanMCPSessionProviderOptions);
+    /**
+     * Get transport from memory
+     */
+    get(sessionId: string): StreamableHTTPServerTransport | undefined;
+    /**
+     * Check if session exists (memory or DynamoDB)
+     */
+    has(sessionId: string): Promise<boolean>;
+    /**
+     * Store transport and create session in DynamoDB
+     */
+    set(sessionId: string, transport: StreamableHTTPServerTransport): Promise<void>;
+    /**
+     * Delete transport and session
+     */
+    delete(sessionId: string): Promise<void>;
+    /**
+     * 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
+     */
+    getOrRecreate(sessionId: string, serverFactory: () => Server | Promise<Server>, transportOptions?: {
+        onsessioninitialized?: (sid: string) => void;
+        onclose?: () => void;
+    }): Promise<StreamableHTTPServerTransport | null>;
+    /**
+     * Get session data from DynamoDB
+     */
+    getSessionData(sessionId: string): Promise<Record<string, any> | null>;
+    /**
+     * Update session data in DynamoDB
+     */
+    updateSessionData(sessionId: string, data: Record<string, any>): Promise<void>;
+    /**
+     * Get number of in-memory transports
+     */
+    get size(): number;
+    /**
+     * Get all session IDs in memory
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Get all transports in memory
+     */
+    values(): IterableIterator<StreamableHTTPServerTransport>;
+    /**
+     * Iterate over all sessions in memory
+     */
+    entries(): IterableIterator<[string, StreamableHTTPServerTransport]>;
+    /**
+     * Clear all in-memory transports (does not affect DynamoDB)
+     */
+    clear(): void;
+}
+
+declare const DEFAULT_TABLE_NAME = "leanmcp-sessions";
+declare const DEFAULT_TTL_SECONDS = 86400;
+interface DynamoDBSessionStoreOptions {
+    tableName?: string;
+    region?: string;
+    ttlSeconds?: number;
+    logging?: boolean;
+}
+/**
+ * DynamoDB-backed session store for stateful Lambda MCP servers
+ * Automatically handles session persistence across Lambda container recycling
+ */
+declare class DynamoDBSessionStore implements ISessionStore {
+    private client;
+    private tableName;
+    private ttlSeconds;
+    private logger;
+    constructor(options?: DynamoDBSessionStoreOptions);
+    /**
+     * Check if a session exists in DynamoDB
+     */
+    sessionExists(sessionId: string): Promise<boolean>;
+    /**
+     * Create a new session in DynamoDB
+     */
+    createSession(sessionId: string, data?: Record<string, any>): Promise<void>;
+    /**
+     * Get session data from DynamoDB
+     */
+    getSession(sessionId: string): Promise<SessionData | null>;
+    /**
+     * Update session data in DynamoDB
+     * Automatically refreshes TTL on each update
+     */
+    updateSession(sessionId: string, updates: Partial<SessionData>): Promise<void>;
+    /**
+     * Delete a session from DynamoDB
+     */
+    deleteSession(sessionId: string): Promise<void>;
+}
+
 interface MCPServerOptions {
     servicesDir: string;
     port?: number;
@@ -673,16 +834,10 @@ declare class MCPServer {
         method: string;
         params?: {
             [x: string]: unknown;
-            task?: {
-                [x: string]: unknown;
-                ttl?: number | null | undefined;
-                pollInterval?: number | undefined;
-            } | undefined;
             _meta?: {
                 [x: string]: unknown;
                 progressToken?: string | number | undefined;
                 "io.modelcontextprotocol/related-task"?: {
-                    [x: string]: unknown;
                     taskId: string;
                 } | undefined;
             } | undefined;
@@ -693,8 +848,8 @@ declare class MCPServer {
             [x: string]: unknown;
             _meta?: {
                 [x: string]: unknown;
+                progressToken?: string | number | undefined;
                 "io.modelcontextprotocol/related-task"?: {
-                    [x: string]: unknown;
                     taskId: string;
                 } | undefined;
             } | undefined;
@@ -703,8 +858,8 @@ declare class MCPServer {
         [x: string]: unknown;
         _meta?: {
             [x: string]: unknown;
+            progressToken?: string | number | undefined;
             "io.modelcontextprotocol/related-task"?: {
-                [x: string]: unknown;
                 taskId: string;
             } | undefined;
         } | undefined;
@@ -734,16 +889,10 @@ declare class MCPServerRuntime {
         method: string;
         params?: {
             [x: string]: unknown;
-            task?: {
-                [x: string]: unknown;
-                ttl?: number | null | undefined;
-                pollInterval?: number | undefined;
-            } | undefined;
             _meta?: {
                 [x: string]: unknown;
                 progressToken?: string | number | undefined;
                 "io.modelcontextprotocol/related-task"?: {
-                    [x: string]: unknown;
                     taskId: string;
                 } | undefined;
             } | undefined;
@@ -754,8 +903,8 @@ declare class MCPServerRuntime {
             [x: string]: unknown;
             _meta?: {
                 [x: string]: unknown;
+                progressToken?: string | number | undefined;
                 "io.modelcontextprotocol/related-task"?: {
-                    [x: string]: unknown;
                     taskId: string;
                 } | undefined;
             } | undefined;
@@ -764,8 +913,8 @@ declare class MCPServerRuntime {
         [x: string]: unknown;
         _meta?: {
             [x: string]: unknown;
+            progressToken?: string | number | undefined;
             "io.modelcontextprotocol/related-task"?: {
-                [x: string]: unknown;
                 taskId: string;
             } | undefined;
         } | undefined;
@@ -779,4 +928,4 @@ declare class MCPServerRuntime {
  */
 declare function startMCPServer(options: MCPServerOptions): Promise<MCPServerRuntime>;
 
-export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, Deprecated, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };
+export { Auth, type AuthErrorOptions, type AuthErrorResult, type AuthOptions, DEFAULT_TABLE_NAME, DEFAULT_TTL_SECONDS, Deprecated, DynamoDBSessionStore, type HTTPServerAuthOptions, type HTTPServerInput, type HTTPServerOptions, type ISessionStore, LeanMCPSessionProvider, type LeanMCPSessionProviderOptions, LogLevel, type LogPayload, Logger, type LoggerHandler, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, type ProtectedResourceMetadata, Render, Resource, type ResourceOptions, SchemaConstraint, type SecurityScheme, type SessionData, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createAuthError, createHTTPServer, createProtectedResourceMetadata, defaultLogger, extractBearerToken, getDecoratedMethods, getMethodMetadata, isAuthError, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };