n8n-mcp 2.19.5 → 2.19.6

package/dist/http-server-single-session.js

@@ -35,7 +35,7 @@ function extractMultiTenantHeaders(req) {
     };
 }
 class SingleSessionHTTPServer {
-    constructor(options = {}) {
+    constructor() {
         this.transports = {};
         this.servers = {};
         this.sessionMetadata = {};
@@ -46,17 +46,7 @@ class SingleSessionHTTPServer {
         this.sessionTimeout = 30 * 60 * 1000;
         this.authToken = null;
         this.cleanupTimer = null;
-        this.cleanupInProgress = new Set();
-        this.isShuttingDown = false;
         this.validateEnvironment();
-        this.onSessionNotFound = options.onSessionNotFound;
-        this.sessionRestorationTimeout = options.sessionRestorationTimeout || 5000;
-        this.sessionEvents = options.sessionEvents;
-        this.sessionRestorationRetries = options.sessionRestorationRetries ?? 0;
-        this.sessionRestorationRetryDelay = options.sessionRestorationRetryDelay || 100;
-        if (options.sessionTimeout) {
-            this.sessionTimeout = options.sessionTimeout;
-        }
         this.startSessionCleanup();
     }
     startSessionCleanup() {
@@ -74,7 +64,7 @@ class SingleSessionHTTPServer {
             sessionTimeout: this.sessionTimeout / 1000 / 60
         });
     }
-    async cleanupExpiredSessions() {
+    cleanupExpiredSessions() {
         const now = Date.now();
         const expiredSessions = [];
         for (const sessionId in this.sessionMetadata) {
@@ -89,100 +79,29 @@ class SingleSessionHTTPServer {
                 logger_1.logger.debug('Cleaned orphaned session context', { sessionId });
             }
         }
-        for (const sessionId in this.transports) {
-            if (!this.sessionMetadata[sessionId]) {
-                logger_1.logger.warn('Orphaned transport detected, cleaning up', { sessionId });
-                try {
-                    await this.removeSession(sessionId, 'orphaned_transport');
-                }
-                catch (err) {
-                    logger_1.logger.error('Error cleaning orphaned transport', {
-                        sessionId,
-                        error: err instanceof Error ? err.message : String(err)
-                    });
-                }
-            }
-        }
-        for (const sessionId in this.servers) {
-            if (!this.sessionMetadata[sessionId]) {
-                logger_1.logger.warn('Orphaned server detected, cleaning up', { sessionId });
-                delete this.servers[sessionId];
-                logger_1.logger.debug('Cleaned orphaned server', { sessionId });
-            }
-        }
-        let successCount = 0;
-        let failureCount = 0;
         for (const sessionId of expiredSessions) {
-            try {
-                await this.emitEvent('onSessionExpired', sessionId);
-                await this.removeSession(sessionId, 'expired');
-                successCount++;
-            }
-            catch (error) {
-                failureCount++;
-                logger_1.logger.error('Failed to cleanup expired session (isolated)', {
-                    sessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined
-                });
-            }
+            this.removeSession(sessionId, 'expired');
         }
         if (expiredSessions.length > 0) {
-            logger_1.logger.info('Expired session cleanup completed', {
-                total: expiredSessions.length,
-                successful: successCount,
-                failed: failureCount,
+            logger_1.logger.info('Cleaned up expired sessions', {
+                removed: expiredSessions.length,
                 remaining: this.getActiveSessionCount()
             });
         }
     }
-    async safeCloseTransport(sessionId) {
-        const transport = this.transports[sessionId];
-        if (!transport)
-            return;
-        try {
-            transport.onclose = undefined;
-            transport.onerror = undefined;
-            const closePromise = transport.close();
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Transport close timeout')), 3000));
-            await Promise.race([closePromise, timeoutPromise]);
-            logger_1.logger.debug('Transport closed safely', { sessionId });
-        }
-        catch (error) {
-            logger_1.logger.warn('Transport close error (non-fatal)', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    }
     async removeSession(sessionId, reason) {
-        if (this.cleanupInProgress.has(sessionId)) {
-            logger_1.logger.debug('Cleanup already in progress, skipping duplicate', {
-                sessionId,
-                reason
-            });
-            return;
-        }
-        this.cleanupInProgress.add(sessionId);
         try {
             if (this.transports[sessionId]) {
-                await this.safeCloseTransport(sessionId);
+                await this.transports[sessionId].close();
                 delete this.transports[sessionId];
             }
             delete this.servers[sessionId];
             delete this.sessionMetadata[sessionId];
             delete this.sessionContexts[sessionId];
-            logger_1.logger.info('Session removed successfully', { sessionId, reason });
+            logger_1.logger.info('Session removed', { sessionId, reason });
         }
         catch (error) {
-            logger_1.logger.warn('Error during session removal', {
-                sessionId,
-                reason,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-        finally {
-            this.cleanupInProgress.delete(sessionId);
+            logger_1.logger.warn('Error removing session', { sessionId, reason, error });
         }
     }
     getActiveSessionCount() {
@@ -192,16 +111,7 @@ class SingleSessionHTTPServer {
         return this.getActiveSessionCount() < MAX_SESSIONS;
     }
     isValidSessionId(sessionId) {
-        if (!sessionId || typeof sessionId !== 'string') {
-            return false;
-        }
-        if (!/^[a-zA-Z0-9_-]+$/.test(sessionId)) {
-            return false;
-        }
-        if (sessionId.length > 100) {
-            return false;
-        }
-        return true;
+        return Boolean(sessionId && sessionId.length > 0);
     }
     sanitizeErrorForClient(error) {
         const isProduction = process.env.NODE_ENV === 'production';
@@ -228,12 +138,6 @@ class SingleSessionHTTPServer {
     updateSessionAccess(sessionId) {
         if (this.sessionMetadata[sessionId]) {
             this.sessionMetadata[sessionId].lastAccess = new Date();
-            this.emitEvent('onSessionAccessed', sessionId).catch(err => {
-                logger_1.logger.error('Failed to emit onSessionAccessed event (non-blocking)', {
-                    sessionId,
-                    error: err instanceof Error ? err.message : String(err)
-                });
-            });
         }
     }
     async switchSessionContext(sessionId, newContext) {
@@ -265,223 +169,6 @@ class SingleSessionHTTPServer {
             }
         }
     }
-    timeout(ms) {
-        return new Promise((_, reject) => {
-            setTimeout(() => {
-                const error = new Error(`Operation timed out after ${ms}ms`);
-                error.name = 'TimeoutError';
-                reject(error);
-            }, ms);
-        });
-    }
-    async emitEvent(eventName, ...args) {
-        const handler = this.sessionEvents?.[eventName];
-        if (!handler)
-            return;
-        try {
-            await Promise.resolve(handler(...args));
-        }
-        catch (error) {
-            logger_1.logger.error(`Session event handler failed: ${eventName}`, {
-                error: error instanceof Error ? error.message : String(error),
-                sessionId: args[0]
-            });
-        }
-    }
-    async restoreSessionWithRetry(sessionId) {
-        if (!this.onSessionNotFound) {
-            throw new Error('onSessionNotFound hook not configured');
-        }
-        const maxRetries = this.sessionRestorationRetries;
-        const retryDelay = this.sessionRestorationRetryDelay;
-        const overallTimeout = this.sessionRestorationTimeout;
-        const startTime = Date.now();
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                const remainingTime = overallTimeout - (Date.now() - startTime);
-                if (remainingTime <= 0) {
-                    const error = new Error(`Session restoration timed out after ${overallTimeout}ms`);
-                    error.name = 'TimeoutError';
-                    throw error;
-                }
-                if (attempt > 0) {
-                    logger_1.logger.debug('Retrying session restoration', {
-                        sessionId,
-                        attempt: attempt,
-                        maxRetries: maxRetries,
-                        remainingTime: remainingTime + 'ms'
-                    });
-                }
-                const context = await Promise.race([
-                    this.onSessionNotFound(sessionId),
-                    this.timeout(remainingTime)
-                ]);
-                if (attempt > 0) {
-                    logger_1.logger.info('Session restoration succeeded after retry', {
-                        sessionId,
-                        attempts: attempt + 1
-                    });
-                }
-                return context;
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === 'TimeoutError') {
-                    logger_1.logger.error('Session restoration timeout (no retry)', {
-                        sessionId,
-                        timeout: overallTimeout
-                    });
-                    throw error;
-                }
-                if (attempt === maxRetries) {
-                    logger_1.logger.error('Session restoration failed after all retries', {
-                        sessionId,
-                        attempts: attempt + 1,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    throw error;
-                }
-                logger_1.logger.warn('Session restoration failed, will retry', {
-                    sessionId,
-                    attempt: attempt + 1,
-                    maxRetries: maxRetries,
-                    error: error instanceof Error ? error.message : String(error),
-                    nextRetryIn: retryDelay + 'ms'
-                });
-                await new Promise(resolve => setTimeout(resolve, retryDelay));
-            }
-        }
-        throw new Error('Unexpected state in restoreSessionWithRetry');
-    }
-    createSession(instanceContext, sessionId, waitForConnection = false) {
-        const id = sessionId || this.generateSessionId(instanceContext);
-        if (this.transports[id]) {
-            logger_1.logger.debug('Session already exists, skipping creation (idempotent)', {
-                sessionId: id
-            });
-            return waitForConnection ? Promise.resolve(id) : id;
-        }
-        if (sessionId && !this.isValidSessionId(sessionId)) {
-            logger_1.logger.error('Invalid session ID format during creation', { sessionId });
-            throw new Error('Invalid session ID format');
-        }
-        if (!this.sessionMetadata[id]) {
-            this.sessionMetadata[id] = {
-                lastAccess: new Date(),
-                createdAt: new Date()
-            };
-            this.sessionContexts[id] = instanceContext;
-        }
-        const server = new server_1.N8NDocumentationMCPServer(instanceContext);
-        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
-            sessionIdGenerator: () => id,
-            onsessioninitialized: (initializedSessionId) => {
-                logger_1.logger.info('Session initialized during explicit creation', {
-                    sessionId: initializedSessionId
-                });
-            }
-        });
-        this.transports[id] = transport;
-        this.servers[id] = server;
-        transport.onclose = () => {
-            if (transport.sessionId) {
-                if (this.isShuttingDown) {
-                    logger_1.logger.debug('Ignoring transport close event during shutdown', {
-                        sessionId: transport.sessionId
-                    });
-                    return;
-                }
-                logger_1.logger.info('Transport closed during createSession, cleaning up', {
-                    sessionId: transport.sessionId
-                });
-                this.removeSession(transport.sessionId, 'transport_closed').catch(err => {
-                    logger_1.logger.error('Error during transport close cleanup', {
-                        sessionId: transport.sessionId,
-                        error: err instanceof Error ? err.message : String(err)
-                    });
-                });
-            }
-        };
-        transport.onerror = (error) => {
-            if (transport.sessionId) {
-                if (this.isShuttingDown) {
-                    logger_1.logger.debug('Ignoring transport error event during shutdown', {
-                        sessionId: transport.sessionId
-                    });
-                    return;
-                }
-                logger_1.logger.error('Transport error during createSession', {
-                    sessionId: transport.sessionId,
-                    error: error.message
-                });
-                this.removeSession(transport.sessionId, 'transport_error').catch(err => {
-                    logger_1.logger.error('Error during transport error cleanup', { error: err });
-                });
-            }
-        };
-        const initializeSession = async () => {
-            try {
-                await server.initialized;
-                await server.connect(transport);
-                if (waitForConnection) {
-                    logger_1.logger.info('Session created and connected successfully', {
-                        sessionId: id,
-                        hasInstanceContext: !!instanceContext,
-                        instanceId: instanceContext?.instanceId
-                    });
-                }
-                else {
-                    logger_1.logger.info('Session created successfully (connecting server to transport)', {
-                        sessionId: id,
-                        hasInstanceContext: !!instanceContext,
-                        instanceId: instanceContext?.instanceId
-                    });
-                }
-            }
-            catch (err) {
-                logger_1.logger.error('Failed to connect server to transport in createSession', {
-                    sessionId: id,
-                    error: err instanceof Error ? err.message : String(err),
-                    waitForConnection
-                });
-                await this.removeSession(id, 'connection_failed').catch(cleanupErr => {
-                    logger_1.logger.error('Error during connection failure cleanup', { error: cleanupErr });
-                });
-                throw err;
-            }
-            this.emitEvent('onSessionCreated', id, instanceContext).catch(eventErr => {
-                logger_1.logger.error('Failed to emit onSessionCreated event (non-blocking)', {
-                    sessionId: id,
-                    error: eventErr instanceof Error ? eventErr.message : String(eventErr)
-                });
-            });
-            return id;
-        };
-        if (waitForConnection) {
-            return initializeSession();
-        }
-        initializeSession().catch(error => {
-            logger_1.logger.error('Async session creation failed in manual restore flow', {
-                sessionId: id,
-                error: error instanceof Error ? error.message : String(error)
-            });
-        });
-        return id;
-    }
-    generateSessionId(instanceContext) {
-        const isMultiTenantEnabled = process.env.ENABLE_MULTI_TENANT === 'true';
-        const sessionStrategy = process.env.MULTI_TENANT_SESSION_STRATEGY || 'instance';
-        if (isMultiTenantEnabled && sessionStrategy === 'instance' && instanceContext?.instanceId) {
-            const configHash = (0, crypto_1.createHash)('sha256')
-                .update(JSON.stringify({
-                url: instanceContext.n8nApiUrl,
-                instanceId: instanceContext.instanceId
-            }))
-                .digest('hex')
-                .substring(0, 8);
-            return `instance-${instanceContext.instanceId}-${configHash}-${(0, uuid_1.v4)()}`;
-        }
-        return (0, uuid_1.v4)();
-    }
     getSessionMetrics() {
         const now = Date.now();
         let expiredCount = 0;
@@ -624,27 +311,14 @@ class SingleSessionHTTPServer {
                     transport.onclose = () => {
                         const sid = transport.sessionId;
                         if (sid) {
-                            if (this.isShuttingDown) {
-                                logger_1.logger.debug('Ignoring transport close event during shutdown', { sessionId: sid });
-                                return;
-                            }
                             logger_1.logger.info('handleRequest: Transport closed, cleaning up', { sessionId: sid });
-                            this.removeSession(sid, 'transport_closed').catch(err => {
-                                logger_1.logger.error('Error during transport close cleanup', {
-                                    sessionId: sid,
-                                    error: err instanceof Error ? err.message : String(err)
-                                });
-                            });
+                            this.removeSession(sid, 'transport_closed');
                         }
                     };
                     transport.onerror = (error) => {
                         const sid = transport.sessionId;
+                        logger_1.logger.error('Transport error', { sessionId: sid, error: error.message });
                         if (sid) {
-                            if (this.isShuttingDown) {
-                                logger_1.logger.debug('Ignoring transport error event during shutdown', { sessionId: sid });
-                                return;
-                            }
-                            logger_1.logger.error('Transport error', { sessionId: sid, error: error.message });
                             this.removeSession(sid, 'transport_error').catch(err => {
                                 logger_1.logger.error('Error during transport error cleanup', { error: err });
                             });
@@ -652,12 +326,6 @@ class SingleSessionHTTPServer {
                     };
                     logger_1.logger.info('handleRequest: Connecting server to new transport');
                     await server.connect(transport);
-                    this.emitEvent('onSessionCreated', sessionIdToUse, instanceContext).catch(eventErr => {
-                        logger_1.logger.error('Failed to emit onSessionCreated event (non-blocking)', {
-                            sessionId: sessionIdToUse,
-                            error: eventErr instanceof Error ? eventErr.message : String(eventErr)
-                        });
-                    });
                 }
                 else if (sessionId && this.transports[sessionId]) {
                     if (!this.isValidSessionId(sessionId)) {
@@ -682,150 +350,29 @@ class SingleSessionHTTPServer {
                     this.updateSessionAccess(sessionId);
                 }
                 else {
-                    if (sessionId) {
-                        if (!this.isValidSessionId(sessionId)) {
-                            logger_1.logger.warn('handleRequest: Invalid session ID format rejected', {
-                                sessionId: sessionId.substring(0, 20)
-                            });
-                            res.status(400).json({
-                                jsonrpc: '2.0',
-                                error: {
-                                    code: -32602,
-                                    message: 'Invalid session ID format'
-                                },
-                                id: req.body?.id || null
-                            });
-                            return;
-                        }
-                        if (this.onSessionNotFound) {
-                            logger_1.logger.info('Attempting session restoration', { sessionId });
-                            try {
-                                const restoredContext = await this.restoreSessionWithRetry(sessionId);
-                                if (restoredContext === null || restoredContext === undefined) {
-                                    logger_1.logger.info('Session restoration declined by hook', {
-                                        sessionId,
-                                        returnValue: restoredContext === null ? 'null' : 'undefined'
-                                    });
-                                    res.status(400).json({
-                                        jsonrpc: '2.0',
-                                        error: {
-                                            code: -32000,
-                                            message: 'Session not found or expired'
-                                        },
-                                        id: req.body?.id || null
-                                    });
-                                    return;
-                                }
-                                const validation = (0, instance_context_1.validateInstanceContext)(restoredContext);
-                                if (!validation.valid) {
-                                    logger_1.logger.error('Invalid context returned from restoration hook', {
-                                        sessionId,
-                                        errors: validation.errors
-                                    });
-                                    res.status(400).json({
-                                        jsonrpc: '2.0',
-                                        error: {
-                                            code: -32000,
-                                            message: 'Invalid session context'
-                                        },
-                                        id: req.body?.id || null
-                                    });
-                                    return;
-                                }
-                                if (this.transports[sessionId]) {
-                                    logger_1.logger.info('Session already restored by concurrent request', { sessionId });
-                                    transport = this.transports[sessionId];
-                                }
-                                else {
-                                    logger_1.logger.info('Session restoration successful, creating session', {
-                                        sessionId,
-                                        instanceId: restoredContext.instanceId
-                                    });
-                                    this.createSession(restoredContext, sessionId, false);
-                                    transport = this.transports[sessionId];
-                                    if (!transport) {
-                                        throw new Error('Transport not found after session creation');
-                                    }
-                                }
-                                this.emitEvent('onSessionRestored', sessionId, restoredContext).catch(err => {
-                                    logger_1.logger.error('Failed to emit onSessionRestored event (non-blocking)', {
-                                        sessionId,
-                                        error: err instanceof Error ? err.message : String(err)
-                                    });
-                                });
-                                logger_1.logger.info('Handling request through restored session transport', { sessionId });
-                                await transport.handleRequest(req, res, req.body);
-                                return;
-                            }
-                            catch (error) {
-                                if (this.transports[sessionId]) {
-                                    logger_1.logger.info('Cleaning up failed session restoration', { sessionId });
-                                    await this.removeSession(sessionId, 'restoration_failed').catch(cleanupErr => {
-                                        logger_1.logger.error('Error during restoration failure cleanup', {
-                                            sessionId,
-                                            error: cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)
-                                        });
-                                    });
-                                }
-                                if (error instanceof Error && error.name === 'TimeoutError') {
-                                    logger_1.logger.error('Session restoration timeout', {
-                                        sessionId,
-                                        timeout: this.sessionRestorationTimeout
-                                    });
-                                    res.status(408).json({
-                                        jsonrpc: '2.0',
-                                        error: {
-                                            code: -32000,
-                                            message: 'Session restoration timeout'
-                                        },
-                                        id: req.body?.id || null
-                                    });
-                                    return;
-                                }
-                                logger_1.logger.error('Session restoration failed', {
-                                    sessionId,
-                                    error: error instanceof Error ? error.message : String(error)
-                                });
-                                res.status(500).json({
-                                    jsonrpc: '2.0',
-                                    error: {
-                                        code: -32603,
-                                        message: 'Session restoration failed'
-                                    },
-                                    id: req.body?.id || null
-                                });
-                                return;
-                            }
-                        }
-                        else {
-                            logger_1.logger.warn('Session not found and no restoration hook configured', {
-                                sessionId
-                            });
-                            res.status(400).json({
-                                jsonrpc: '2.0',
-                                error: {
-                                    code: -32000,
-                                    message: 'Session not found or expired'
-                                },
-                                id: req.body?.id || null
-                            });
-                            return;
-                        }
+                    const errorDetails = {
+                        hasSessionId: !!sessionId,
+                        isInitialize: isInitialize,
+                        sessionIdValid: sessionId ? this.isValidSessionId(sessionId) : false,
+                        sessionExists: sessionId ? !!this.transports[sessionId] : false
+                    };
+                    logger_1.logger.warn('handleRequest: Invalid request - no session ID and not initialize', errorDetails);
+                    let errorMessage = 'Bad Request: No valid session ID provided and not an initialize request';
+                    if (sessionId && !this.isValidSessionId(sessionId)) {
+                        errorMessage = 'Bad Request: Invalid session ID format';
                     }
-                    else {
-                        logger_1.logger.warn('handleRequest: Invalid request - no session ID and not initialize', {
-                            isInitialize
-                        });
-                        res.status(400).json({
-                            jsonrpc: '2.0',
-                            error: {
-                                code: -32000,
-                                message: 'Bad Request: No valid session ID provided and not an initialize request'
-                            },
-                            id: req.body?.id || null
-                        });
-                        return;
+                    else if (sessionId && !this.transports[sessionId]) {
+                        errorMessage = 'Bad Request: Session not found or expired';
                     }
+                    res.status(400).json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32000,
+                            message: errorMessage
+                        },
+                        id: req.body?.id || null
+                    });
+                    return;
                 }
                 logger_1.logger.info('handleRequest: Handling request with transport', {
                     sessionId: isInitialize ? 'new' : sessionId,
@@ -1408,8 +955,6 @@ class SingleSessionHTTPServer {
     }
     async shutdown() {
         logger_1.logger.info('Shutting down Single-Session HTTP server...');
-        this.isShuttingDown = true;
-        logger_1.logger.info('Shutdown flag set - recursive cleanup prevention enabled');
         if (this.cleanupTimer) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = null;
@@ -1417,28 +962,15 @@ class SingleSessionHTTPServer {
         }
         const sessionIds = Object.keys(this.transports);
         logger_1.logger.info(`Closing ${sessionIds.length} active sessions`);
-        let successCount = 0;
-        let failureCount = 0;
         for (const sessionId of sessionIds) {
             try {
                 logger_1.logger.info(`Closing transport for session ${sessionId}`);
                 await this.removeSession(sessionId, 'server_shutdown');
-                successCount++;
             }
             catch (error) {
-                failureCount++;
-                logger_1.logger.warn(`Error closing transport for session ${sessionId}:`, {
-                    error: error instanceof Error ? error.message : String(error)
-                });
+                logger_1.logger.warn(`Error closing transport for session ${sessionId}:`, error);
             }
         }
-        if (sessionIds.length > 0) {
-            logger_1.logger.info('Session shutdown completed', {
-                total: sessionIds.length,
-                successful: successCount,
-                failed: failureCount
-            });
-        }
         if (this.session) {
             try {
                 await this.session.transport.close();
@@ -1486,117 +1018,6 @@ class SingleSessionHTTPServer {
             }
         };
     }
-    getActiveSessions() {
-        return Object.keys(this.sessionMetadata);
-    }
-    getSessionState(sessionId) {
-        const metadata = this.sessionMetadata[sessionId];
-        if (!metadata) {
-            return null;
-        }
-        const instanceContext = this.sessionContexts[sessionId];
-        const expiresAt = new Date(metadata.lastAccess.getTime() + this.sessionTimeout);
-        return {
-            sessionId,
-            instanceContext: instanceContext || {
-                n8nApiUrl: process.env.N8N_API_URL,
-                n8nApiKey: process.env.N8N_API_KEY,
-                instanceId: process.env.N8N_INSTANCE_ID
-            },
-            createdAt: metadata.createdAt,
-            lastAccess: metadata.lastAccess,
-            expiresAt,
-            metadata: instanceContext?.metadata
-        };
-    }
-    getAllSessionStates() {
-        const sessionIds = this.getActiveSessions();
-        const states = [];
-        for (const sessionId of sessionIds) {
-            const state = this.getSessionState(sessionId);
-            if (state) {
-                states.push(state);
-            }
-        }
-        return states;
-    }
-    manuallyRestoreSession(sessionId, instanceContext) {
-        try {
-            if (!this.isValidSessionId(sessionId)) {
-                logger_1.logger.error('Invalid session ID format in manual restoration', { sessionId });
-                return false;
-            }
-            const validation = (0, instance_context_1.validateInstanceContext)(instanceContext);
-            if (!validation.valid) {
-                logger_1.logger.error('Invalid instance context in manual restoration', {
-                    sessionId,
-                    errors: validation.errors
-                });
-                return false;
-            }
-            this.sessionMetadata[sessionId] = {
-                lastAccess: new Date(),
-                createdAt: new Date()
-            };
-            this.sessionContexts[sessionId] = instanceContext;
-            const creationResult = this.createSession(instanceContext, sessionId, false);
-            Promise.resolve(creationResult).catch(error => {
-                logger_1.logger.error('Async session creation failed in manual restoration', {
-                    sessionId,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-                delete this.sessionMetadata[sessionId];
-                delete this.sessionContexts[sessionId];
-            });
-            logger_1.logger.info('Session manually restored', {
-                sessionId,
-                instanceId: instanceContext.instanceId
-            });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Failed to manually restore session', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return false;
-        }
-    }
-    manuallyDeleteSession(sessionId) {
-        if (!this.sessionMetadata[sessionId]) {
-            logger_1.logger.debug('Session not found for manual deletion', { sessionId });
-            return false;
-        }
-        try {
-            if (this.transports[sessionId]) {
-                this.transports[sessionId].close().catch(error => {
-                    logger_1.logger.warn('Error closing transport during manual deletion', {
-                        sessionId,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                });
-            }
-            this.emitEvent('onSessionDeleted', sessionId).catch(err => {
-                logger_1.logger.error('Failed to emit onSessionDeleted event (non-blocking)', {
-                    sessionId,
-                    error: err instanceof Error ? err.message : String(err)
-                });
-            });
-            delete this.transports[sessionId];
-            delete this.servers[sessionId];
-            delete this.sessionMetadata[sessionId];
-            delete this.sessionContexts[sessionId];
-            logger_1.logger.info('Session manually deleted', { sessionId });
-            return true;
-        }
-        catch (error) {
-            logger_1.logger.error('Error during manual session deletion', {
-                sessionId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return false;
-        }
-    }
 }
 exports.SingleSessionHTTPServer = SingleSessionHTTPServer;
 if (require.main === module) {