cprime-supergateway 3.4.3

package/dist/gateways/stdioToSse.js

@@ -0,0 +1,147 @@
+import express from 'express';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import { spawn } from 'child_process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { getVersion } from '../lib/getVersion.js';
+import { onSignals } from '../lib/onSignals.js';
+import { serializeCorsOrigin } from '../lib/serializeCorsOrigin.js';
+import { EncryptionService } from '../services/encryptionService.js';
+const encryptionService = new EncryptionService('env');
+const plaintext = await encryptionService.decryptText(process.env.ENCRYPTED_ENV ?? '', process.env.AAD_JSON ? JSON.parse(process.env.AAD_JSON) : {});
+let decryptedEnvs = {};
+try {
+    const asObj = JSON.parse(plaintext);
+    decryptedEnvs = asObj;
+}
+catch {
+    console.error('Failed to parse decrypted envs', plaintext);
+}
+const setResponseHeaders = ({ res, headers, }) => Object.entries(headers).forEach(([key, value]) => {
+    res.setHeader(key, value);
+});
+export async function stdioToSse(args) {
+    const { stdioCmd, port, baseUrl, ssePath, messagePath, logger, corsOrigin, healthEndpoints, headers, } = args;
+    logger.info(`  - Headers: ${Object(headers).length ? JSON.stringify(headers) : '(none)'}`);
+    logger.info(`  - port: ${port}`);
+    logger.info(`  - stdio: ${stdioCmd}`);
+    if (baseUrl) {
+        logger.info(`  - baseUrl: ${baseUrl}`);
+    }
+    logger.info(`  - ssePath: ${ssePath}`);
+    logger.info(`  - messagePath: ${messagePath}`);
+    logger.info(`  - CORS: ${corsOrigin ? `enabled (${serializeCorsOrigin({ corsOrigin })})` : 'disabled'}`);
+    logger.info(`  - Health endpoints: ${healthEndpoints.length ? healthEndpoints.join(', ') : '(none)'}`);
+    onSignals({ logger });
+    const child = spawn(stdioCmd, {
+        shell: true,
+        env: { ...process.env, ...decryptedEnvs },
+    });
+    child.on('exit', (code, signal) => {
+        logger.error(`Child exited: code=${code}, signal=${signal}`);
+        process.exit(code ?? 1);
+    });
+    const server = new Server({ name: 'supergateway', version: getVersion() }, { capabilities: {} });
+    const sessions = {};
+    const app = express();
+    if (corsOrigin) {
+        app.use(cors({ origin: corsOrigin }));
+    }
+    app.use((req, res, next) => {
+        if (req.path === messagePath)
+            return next();
+        return bodyParser.json()(req, res, next);
+    });
+    for (const ep of healthEndpoints) {
+        app.get(ep, (_req, res) => {
+            setResponseHeaders({
+                res,
+                headers,
+            });
+            res.send('ok');
+        });
+    }
+    app.get(ssePath, async (req, res) => {
+        logger.info(`New SSE connection from ${req.ip}`);
+        setResponseHeaders({
+            res,
+            headers,
+        });
+        const sseTransport = new SSEServerTransport(`${baseUrl}${messagePath}`, res);
+        await server.connect(sseTransport);
+        const sessionId = sseTransport.sessionId;
+        if (sessionId) {
+            sessions[sessionId] = { transport: sseTransport, response: res };
+        }
+        sseTransport.onmessage = (msg) => {
+            logger.info(`SSE → Child (session ${sessionId}): ${JSON.stringify(msg)}`);
+            child.stdin.write(JSON.stringify(msg) + '\n');
+        };
+        sseTransport.onclose = () => {
+            logger.info(`SSE connection closed (session ${sessionId})`);
+            delete sessions[sessionId];
+        };
+        sseTransport.onerror = (err) => {
+            logger.error(`SSE error (session ${sessionId}):`, err);
+            delete sessions[sessionId];
+        };
+        req.on('close', () => {
+            logger.info(`Client disconnected (session ${sessionId})`);
+            delete sessions[sessionId];
+        });
+    });
+    // @ts-ignore
+    app.post(messagePath, async (req, res) => {
+        const sessionId = req.query.sessionId;
+        setResponseHeaders({
+            res,
+            headers,
+        });
+        if (!sessionId) {
+            return res.status(400).send('Missing sessionId parameter');
+        }
+        const session = sessions[sessionId];
+        if (session?.transport?.handlePostMessage) {
+            logger.info(`POST to SSE transport (session ${sessionId})`);
+            await session.transport.handlePostMessage(req, res);
+        }
+        else {
+            res.status(503).send(`No active SSE connection for session ${sessionId}`);
+        }
+    });
+    app.listen(port, () => {
+        logger.info(`Listening on port ${port}`);
+        logger.info(`SSE endpoint: http://localhost:${port}${ssePath}`);
+        logger.info(`POST messages: http://localhost:${port}${messagePath}`);
+    });
+    let buffer = '';
+    child.stdout.on('data', (chunk) => {
+        buffer += chunk.toString('utf8');
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? '';
+        lines.forEach((line) => {
+            if (!line.trim())
+                return;
+            try {
+                const jsonMsg = JSON.parse(line);
+                logger.info('Child → SSE:', jsonMsg);
+                for (const [sid, session] of Object.entries(sessions)) {
+                    try {
+                        session.transport.send(jsonMsg);
+                    }
+                    catch (err) {
+                        logger.error(`Failed to send to session ${sid}:`, err);
+                        delete sessions[sid];
+                    }
+                }
+            }
+            catch {
+                logger.error(`Child non-JSON: ${line}`);
+            }
+        });
+    });
+    child.stderr.on('data', (chunk) => {
+        logger.error(`Child stderr: ${chunk.toString('utf8')}`);
+    });
+}

package/dist/gateways/stdioToStatefulStreamableHttp.js

@@ -0,0 +1,188 @@
+import express from 'express';
+import cors from 'cors';
+import { spawn } from 'child_process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { getVersion } from '../lib/getVersion.js';
+import { onSignals } from '../lib/onSignals.js';
+import { serializeCorsOrigin } from '../lib/serializeCorsOrigin.js';
+import { randomUUID } from 'node:crypto';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { SessionAccessCounter } from '../lib/sessionAccessCounter.js';
+const setResponseHeaders = ({ res, headers, }) => Object.entries(headers).forEach(([key, value]) => {
+    res.setHeader(key, value);
+});
+export async function stdioToStatefulStreamableHttp(args) {
+    const { stdioCmd, port, streamableHttpPath, logger, corsOrigin, healthEndpoints, headers, sessionTimeout, } = args;
+    logger.info(`  - Headers: ${Object(headers).length ? JSON.stringify(headers) : '(none)'}`);
+    logger.info(`  - port: ${port}`);
+    logger.info(`  - stdio: ${stdioCmd}`);
+    logger.info(`  - streamableHttpPath: ${streamableHttpPath}`);
+    logger.info(`  - CORS: ${corsOrigin ? `enabled (${serializeCorsOrigin({ corsOrigin })})` : 'disabled'}`);
+    logger.info(`  - Health endpoints: ${healthEndpoints.length ? healthEndpoints.join(', ') : '(none)'}`);
+    logger.info(`  - Session timeout: ${sessionTimeout ? `${sessionTimeout}ms` : 'disabled'}`);
+    onSignals({ logger });
+    const app = express();
+    app.use(express.json());
+    if (corsOrigin) {
+        app.use(cors({
+            origin: corsOrigin,
+            exposedHeaders: ['Mcp-Session-Id'],
+        }));
+    }
+    for (const ep of healthEndpoints) {
+        app.get(ep, (_req, res) => {
+            setResponseHeaders({
+                res,
+                headers,
+            });
+            res.send('ok');
+        });
+    }
+    // Map to store transports by session ID
+    const transports = {};
+    // Session access counter for timeout management
+    const sessionCounter = sessionTimeout
+        ? new SessionAccessCounter(sessionTimeout, (sessionId) => {
+            logger.info(`Session ${sessionId} timed out, cleaning up`);
+            const transport = transports[sessionId];
+            if (transport) {
+                transport.close();
+            }
+            delete transports[sessionId];
+        }, logger)
+        : null;
+    // Handle POST requests for client-to-server communication
+    app.post(streamableHttpPath, async (req, res) => {
+        // Check for existing session ID
+        const sessionId = req.headers['mcp-session-id'];
+        let transport;
+        if (sessionId && transports[sessionId]) {
+            // Reuse existing transport
+            transport = transports[sessionId];
+            // Increment session access count
+            sessionCounter?.inc(sessionId, 'POST request for existing session');
+        }
+        else if (!sessionId && isInitializeRequest(req.body)) {
+            // New initialization request
+            const server = new Server({ name: 'supergateway', version: getVersion() }, { capabilities: {} });
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (sessionId) => {
+                    // Store the transport by session ID
+                    transports[sessionId] = transport;
+                    // Initialize session access count
+                    sessionCounter?.inc(sessionId, 'session initialization');
+                },
+            });
+            await server.connect(transport);
+            const child = spawn(stdioCmd, { shell: true });
+            child.on('exit', (code, signal) => {
+                logger.error(`Child exited: code=${code}, signal=${signal}`);
+                transport.close();
+            });
+            let buffer = '';
+            child.stdout.on('data', (chunk) => {
+                buffer += chunk.toString('utf8');
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? '';
+                lines.forEach((line) => {
+                    if (!line.trim())
+                        return;
+                    try {
+                        const jsonMsg = JSON.parse(line);
+                        logger.info('Child → StreamableHttp:', line);
+                        try {
+                            transport.send(jsonMsg);
+                        }
+                        catch (e) {
+                            logger.error(`Failed to send to StreamableHttp`, e);
+                        }
+                    }
+                    catch {
+                        logger.error(`Child non-JSON: ${line}`);
+                    }
+                });
+            });
+            child.stderr.on('data', (chunk) => {
+                logger.error(`Child stderr: ${chunk.toString('utf8')}`);
+            });
+            transport.onmessage = (msg) => {
+                logger.info(`StreamableHttp → Child: ${JSON.stringify(msg)}`);
+                child.stdin.write(JSON.stringify(msg) + '\n');
+            };
+            transport.onclose = () => {
+                logger.info(`StreamableHttp connection closed (session ${sessionId})`);
+                if (transport.sessionId) {
+                    sessionCounter?.clear(transport.sessionId, false, 'transport being closed');
+                    delete transports[transport.sessionId];
+                }
+                child.kill();
+            };
+            transport.onerror = (err) => {
+                logger.error(`StreamableHttp error (session ${sessionId}):`, err);
+                if (transport.sessionId) {
+                    sessionCounter?.clear(transport.sessionId, false, 'transport emitting error');
+                    delete transports[transport.sessionId];
+                }
+                child.kill();
+            };
+        }
+        else {
+            // Invalid request
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        // Decrement session access count when response ends
+        let responseEnded = false;
+        const handleResponseEnd = (event) => {
+            if (!responseEnded && transport.sessionId) {
+                responseEnded = true;
+                logger.info(`Response ${event}`, transport.sessionId);
+                sessionCounter?.dec(transport.sessionId, `POST response ${event}`);
+            }
+        };
+        res.on('finish', () => handleResponseEnd('finished'));
+        res.on('close', () => handleResponseEnd('closed'));
+        // Handle the request
+        await transport.handleRequest(req, res, req.body);
+    });
+    // Reusable handler for GET and DELETE requests
+    const handleSessionRequest = async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send('Invalid or missing session ID');
+            return;
+        }
+        // Increment session access count
+        sessionCounter?.inc(sessionId, `${req.method} request for existing session`);
+        // Decrement session access count when response ends
+        let responseEnded = false;
+        const handleResponseEnd = (event) => {
+            if (!responseEnded) {
+                responseEnded = true;
+                logger.info(`Response ${event}`, sessionId);
+                sessionCounter?.dec(sessionId, `${req.method} response ${event}`);
+            }
+        };
+        res.on('finish', () => handleResponseEnd('finished'));
+        res.on('close', () => handleResponseEnd('closed'));
+        const transport = transports[sessionId];
+        await transport.handleRequest(req, res);
+    };
+    // Handle GET requests for server-to-client notifications via SSE
+    app.get(streamableHttpPath, handleSessionRequest);
+    // Handle DELETE requests for session termination
+    app.delete(streamableHttpPath, handleSessionRequest);
+    app.listen(port, () => {
+        logger.info(`Listening on port ${port}`);
+        logger.info(`StreamableHttp endpoint: http://localhost:${port}${streamableHttpPath}`);
+    });
+}

package/dist/gateways/stdioToStatelessStreamableHttp.js

@@ -0,0 +1,208 @@
+import express from 'express';
+import cors from 'cors';
+import { spawn } from 'child_process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest, } from '@modelcontextprotocol/sdk/types.js';
+import { getVersion } from '../lib/getVersion.js';
+import { onSignals } from '../lib/onSignals.js';
+import { serializeCorsOrigin } from '../lib/serializeCorsOrigin.js';
+const setResponseHeaders = ({ res, headers, }) => Object.entries(headers).forEach(([key, value]) => {
+    res.setHeader(key, value);
+});
+// Helper function to create initialize request
+const createInitializeRequest = (id, protocolVersion) => ({
+    jsonrpc: '2.0',
+    id,
+    method: 'initialize',
+    params: {
+        protocolVersion,
+        capabilities: {
+            roots: {
+                listChanged: true,
+            },
+            sampling: {},
+        },
+        clientInfo: {
+            name: 'supergateway',
+            version: getVersion(),
+        },
+    },
+});
+// Helper function to create initialized notification
+const createInitializedNotification = () => ({
+    jsonrpc: '2.0',
+    method: 'notifications/initialized',
+});
+export async function stdioToStatelessStreamableHttp(args) {
+    const { stdioCmd, port, streamableHttpPath, logger, corsOrigin, healthEndpoints, headers, protocolVersion, } = args;
+    logger.info(`  - Headers: ${Object(headers).length ? JSON.stringify(headers) : '(none)'}`);
+    logger.info(`  - port: ${port}`);
+    logger.info(`  - stdio: ${stdioCmd}`);
+    logger.info(`  - streamableHttpPath: ${streamableHttpPath}`);
+    logger.info(`  - protocolVersion: ${protocolVersion}`);
+    logger.info(`  - CORS: ${corsOrigin ? `enabled (${serializeCorsOrigin({ corsOrigin })})` : 'disabled'}`);
+    logger.info(`  - Health endpoints: ${healthEndpoints.length ? healthEndpoints.join(', ') : '(none)'}`);
+    onSignals({ logger });
+    const app = express();
+    app.use(express.json());
+    if (corsOrigin) {
+        app.use(cors({ origin: corsOrigin }));
+    }
+    for (const ep of healthEndpoints) {
+        app.get(ep, (_req, res) => {
+            setResponseHeaders({
+                res,
+                headers,
+            });
+            res.send('ok');
+        });
+    }
+    app.post(streamableHttpPath, async (req, res) => {
+        // In stateless mode, create a new instance of transport and server for each request
+        // to ensure complete isolation. A single instance would cause request ID collisions
+        // when multiple clients connect concurrently.
+        try {
+            const server = new Server({ name: 'supergateway', version: getVersion() }, { capabilities: {} });
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            await server.connect(transport);
+            const child = spawn(stdioCmd, { shell: true });
+            child.on('exit', (code, signal) => {
+                logger.error(`Child exited: code=${code}, signal=${signal}`);
+                transport.close();
+            });
+            // State tracking for initialization flow
+            let isInitialized = false;
+            let initializeRequestId = null; // Current initialize request ID
+            let isAutoInitializing = false; // Flag to indicate if we're auto-initializing
+            let pendingOriginalMessage = null;
+            let buffer = '';
+            child.stdout.on('data', (chunk) => {
+                buffer += chunk.toString('utf8');
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? '';
+                lines.forEach((line) => {
+                    if (!line.trim())
+                        return;
+                    try {
+                        const jsonMsg = JSON.parse(line);
+                        logger.info('Child → StreamableHttp:', line);
+                        // Handle initialize response (both auto and client initiated)
+                        if (initializeRequestId && jsonMsg.id === initializeRequestId) {
+                            logger.info('Initialize response received');
+                            isInitialized = true;
+                            // If this was our auto-initialization, send initialized notification and pending message
+                            if (isAutoInitializing) {
+                                // Send initialized notification
+                                const initializedNotification = createInitializedNotification();
+                                logger.info(`StreamableHttp → Child (initialized): ${JSON.stringify(initializedNotification)}`);
+                                child.stdin.write(JSON.stringify(initializedNotification) + '\n');
+                                // Now send the original message
+                                if (pendingOriginalMessage) {
+                                    logger.info(`StreamableHttp → Child (original): ${JSON.stringify(pendingOriginalMessage)}`);
+                                    child.stdin.write(JSON.stringify(pendingOriginalMessage) + '\n');
+                                    pendingOriginalMessage = null;
+                                }
+                                // Reset auto-initialize tracking
+                                isAutoInitializing = false;
+                                initializeRequestId = null;
+                                // Don't forward our auto-initialize response to the client
+                                return;
+                            }
+                            else {
+                                // Client-initiated initialize response, just reset tracking
+                                initializeRequestId = null;
+                            }
+                        }
+                        try {
+                            transport.send(jsonMsg);
+                        }
+                        catch (e) {
+                            logger.error(`Failed to send to StreamableHttp`, e);
+                        }
+                    }
+                    catch {
+                        logger.error(`Child non-JSON: ${line}`);
+                    }
+                });
+            });
+            child.stderr.on('data', (chunk) => {
+                logger.error(`Child stderr: ${chunk.toString('utf8')}`);
+            });
+            transport.onmessage = (msg) => {
+                logger.info(`StreamableHttp → Child: ${JSON.stringify(msg)}`);
+                // Check if we need to auto-initialize first
+                if (!isInitialized && !isInitializeRequest(msg)) {
+                    // Store the original message and send initialize first
+                    pendingOriginalMessage = msg;
+                    initializeRequestId = `init_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                    isAutoInitializing = true;
+                    logger.info('Non-initialize message detected, sending auto-initialize request first');
+                    const initRequest = createInitializeRequest(initializeRequestId, protocolVersion);
+                    logger.info(`StreamableHttp → Child (auto-initialize): ${JSON.stringify(initRequest)}`);
+                    child.stdin.write(JSON.stringify(initRequest) + '\n');
+                    // Don't send the original message yet - it will be sent after initialization
+                    return;
+                }
+                // Track initialize request ID (both client and auto)
+                if (isInitializeRequest(msg) && 'id' in msg && msg.id !== undefined) {
+                    initializeRequestId = msg.id;
+                    isAutoInitializing = false; // This is client-initiated
+                    logger.info(`Tracking initialize request ID: ${msg.id}`);
+                }
+                // Send all messages to child process normally
+                child.stdin.write(JSON.stringify(msg) + '\n');
+            };
+            transport.onclose = () => {
+                logger.info('StreamableHttp connection closed');
+                child.kill();
+            };
+            transport.onerror = (err) => {
+                logger.error(`StreamableHttp error:`, err);
+                child.kill();
+            };
+            await transport.handleRequest(req, res, req.body);
+        }
+        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,
+                });
+            }
+        }
+    });
+    app.get(streamableHttpPath, async (req, res) => {
+        logger.info('Received GET MCP request');
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+                code: -32000,
+                message: 'Method not allowed.',
+            },
+            id: null,
+        }));
+    });
+    app.delete(streamableHttpPath, async (req, res) => {
+        logger.info('Received DELETE MCP request');
+        res.writeHead(405).end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+                code: -32000,
+                message: 'Method not allowed.',
+            },
+            id: null,
+        }));
+    });
+    app.listen(port, () => {
+        logger.info(`Listening on port ${port}`);
+        logger.info(`StreamableHttp endpoint: http://localhost:${port}${streamableHttpPath}`);
+    });
+}

package/dist/gateways/stdioToWs.js

@@ -0,0 +1,113 @@
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+import { spawn } from 'child_process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { getVersion } from '../lib/getVersion.js';
+import { WebSocketServerTransport } from '../server/websocket.js';
+import { onSignals } from '../lib/onSignals.js';
+import { serializeCorsOrigin } from '../lib/serializeCorsOrigin.js';
+export async function stdioToWs(args) {
+    const { stdioCmd, port, messagePath, logger, healthEndpoints, corsOrigin } = args;
+    logger.info(`  - port: ${port}`);
+    logger.info(`  - stdio: ${stdioCmd}`);
+    logger.info(`  - messagePath: ${messagePath}`);
+    logger.info(`  - CORS: ${corsOrigin ? `enabled (${serializeCorsOrigin({ corsOrigin })})` : 'disabled'}`);
+    logger.info(`  - Health endpoints: ${healthEndpoints.length ? healthEndpoints.join(', ') : '(none)'}`);
+    let wsTransport = null;
+    let child = null;
+    let isReady = false;
+    const cleanup = () => {
+        if (wsTransport) {
+            wsTransport.close().catch((err) => {
+                logger.error(`Error stopping WebSocket server: ${err.message}`);
+            });
+        }
+        if (child) {
+            child.kill();
+        }
+    };
+    onSignals({
+        logger,
+        cleanup,
+    });
+    try {
+        child = spawn(stdioCmd, { shell: true });
+        child.on('exit', (code, signal) => {
+            logger.error(`Child exited: code=${code}, signal=${signal}`);
+            cleanup();
+            process.exit(code ?? 1);
+        });
+        const server = new Server({ name: 'supergateway', version: getVersion() }, { capabilities: {} });
+        // Handle child process output
+        let buffer = '';
+        child.stdout.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? '';
+            lines.forEach((line) => {
+                if (!line.trim())
+                    return;
+                try {
+                    const jsonMsg = JSON.parse(line);
+                    logger.info(`Child → WebSocket: ${JSON.stringify(jsonMsg)}`);
+                    // Broadcast to all connected clients
+                    wsTransport?.send(jsonMsg, jsonMsg.id).catch((err) => {
+                        logger.error('Failed to broadcast message:', err);
+                    });
+                }
+                catch {
+                    logger.error(`Child non-JSON: ${line}`);
+                }
+            });
+        });
+        child.stderr.on('data', (chunk) => {
+            logger.info(`Child stderr: ${chunk.toString('utf8')}`);
+        });
+        const app = express();
+        if (corsOrigin) {
+            app.use(cors({ origin: corsOrigin }));
+        }
+        for (const ep of healthEndpoints) {
+            app.get(ep, (_req, res) => {
+                if (child?.killed) {
+                    res.status(500).send('Child process has been killed');
+                }
+                if (!isReady) {
+                    res.status(500).send('Server is not ready');
+                }
+                res.send('ok');
+            });
+        }
+        const httpServer = createServer(app);
+        wsTransport = new WebSocketServerTransport({
+            path: messagePath,
+            server: httpServer,
+        });
+        await server.connect(wsTransport);
+        wsTransport.onmessage = (msg) => {
+            const line = JSON.stringify(msg);
+            logger.info(`WebSocket → Child: ${line}`);
+            child.stdin.write(line + '\n');
+        };
+        wsTransport.onconnection = (clientId) => {
+            logger.info(`New WebSocket connection: ${clientId}`);
+        };
+        wsTransport.ondisconnection = (clientId) => {
+            logger.info(`WebSocket connection closed: ${clientId}`);
+        };
+        wsTransport.onerror = (err) => {
+            logger.error(`WebSocket error: ${err.message}`);
+        };
+        isReady = true;
+        httpServer.listen(port, () => {
+            logger.info(`Listening on port ${port}`);
+            logger.info(`WebSocket endpoint: ws://localhost:${port}${messagePath}`);
+        });
+    }
+    catch (err) {
+        logger.error(`Failed to start: ${err.message}`);
+        cleanup();
+        process.exit(1);
+    }
+}