@dotsetlabs/bellwether 0.10.0

package/dist/transport/sse-transport.d.ts

@@ -0,0 +1,88 @@
+import type { JSONRPCMessage } from './types.js';
+import { BaseTransport, type BaseTransportConfig } from './base-transport.js';
+/**
+ * Configuration for SSE Transport.
+ */
+export interface SSETransportConfig extends BaseTransportConfig {
+    /** Base URL of the MCP server (e.g., https://api.example.com/mcp) */
+    baseUrl: string;
+    /** Optional session ID for authenticated connections */
+    sessionId?: string;
+    /** Custom headers to include in requests */
+    headers?: Record<string, string>;
+    /** Reconnect delay in milliseconds (default: 1000) */
+    reconnectDelay?: number;
+    /** Maximum reconnect attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * SSETransport connects to MCP servers over HTTP using Server-Sent Events.
+ *
+ * This transport is used for remote MCP servers that expose an SSE endpoint.
+ * Messages from the server are received via SSE, while requests are sent
+ * via HTTP POST.
+ *
+ * Expected server endpoints:
+ * - GET  {baseUrl}/sse     - SSE endpoint for receiving messages
+ * - POST {baseUrl}/message - Endpoint for sending messages
+ */
+export declare class SSETransport extends BaseTransport {
+    private eventSource;
+    private abortController;
+    private connected;
+    private reconnectAttempts;
+    private readonly baseUrl;
+    private readonly sessionId?;
+    private readonly headers;
+    private readonly reconnectDelay;
+    private readonly maxReconnectAttempts;
+    private readonly timeout;
+    private messageEndpoint;
+    /** Timer ID for reconnection delay - allows cancellation */
+    private reconnectTimer;
+    /** Flag to prevent reconnection after close() is called */
+    private isClosing;
+    /** Maximum backoff delay in milliseconds */
+    private readonly maxBackoffDelay;
+    constructor(config: SSETransportConfig);
+    /**
+     * Connect to the SSE endpoint.
+     */
+    connect(): Promise<void>;
+    /**
+     * Handle an incoming SSE message.
+     */
+    private handleSSEMessage;
+    /**
+     * Handle reconnection after a connection error.
+     *
+     * RELIABILITY IMPROVEMENTS:
+     * - Prevents unbounded recursion with max attempts check
+     * - Uses capped exponential backoff
+     * - Clears reconnect timer on close
+     * - Checks isClosing flag to prevent reconnection after close()
+     * - Explicitly closes EventSource on max attempts
+     */
+    private handleReconnect;
+    /**
+     * Send a JSON-RPC message to the server via HTTP POST.
+     */
+    send(message: JSONRPCMessage): void;
+    /**
+     * Close the SSE connection.
+     *
+     * RELIABILITY: Properly cleans up all resources including:
+     * - EventSource connection
+     * - Pending HTTP requests (via abort controller)
+     * - Reconnection timer
+     * - Sets isClosing flag to prevent reconnection attempts
+     */
+    close(): void;
+    /**
+     * Check if the transport is connected.
+     */
+    isConnected(): boolean;
+}
+//# sourceMappingURL=sse-transport.d.ts.map

package/dist/transport/sse-transport.js

@@ -0,0 +1,316 @@
+import { BaseTransport } from './base-transport.js';
+import { TIME_CONSTANTS, TIMEOUTS } from '../constants.js';
+import { isLocalhost } from '../utils/index.js';
+/**
+ * Validate that a URL uses HTTPS in production contexts.
+ * Allows HTTP only for localhost/127.0.0.1 for local development.
+ */
+function validateSecureUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== 'https:' && !isLocalhost(parsed.hostname)) {
+            throw new Error(`SSE transport requires HTTPS for remote servers. ` +
+                `Got: ${parsed.protocol}//. Use HTTPS to protect session tokens in transit.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('SSE transport')) {
+            throw error;
+        }
+        throw new Error(`Invalid SSE URL: ${url}`);
+    }
+}
+/**
+ * SSETransport connects to MCP servers over HTTP using Server-Sent Events.
+ *
+ * This transport is used for remote MCP servers that expose an SSE endpoint.
+ * Messages from the server are received via SSE, while requests are sent
+ * via HTTP POST.
+ *
+ * Expected server endpoints:
+ * - GET  {baseUrl}/sse     - SSE endpoint for receiving messages
+ * - POST {baseUrl}/message - Endpoint for sending messages
+ */
+export class SSETransport extends BaseTransport {
+    eventSource = null;
+    abortController = null;
+    connected = false;
+    reconnectAttempts = 0;
+    baseUrl;
+    sessionId;
+    headers;
+    reconnectDelay;
+    maxReconnectAttempts;
+    timeout;
+    messageEndpoint = null;
+    /** Timer ID for reconnection delay - allows cancellation */
+    reconnectTimer = null;
+    /** Flag to prevent reconnection after close() is called */
+    isClosing = false;
+    /** Maximum backoff delay in milliseconds */
+    maxBackoffDelay = TIME_CONSTANTS.SSE_MAX_BACKOFF;
+    constructor(config) {
+        super(config);
+        this.baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.sessionId = config.sessionId;
+        this.headers = config.headers ?? {};
+        this.reconnectDelay = config.reconnectDelay ?? TIME_CONSTANTS.SSE_RECONNECT_DELAY;
+        this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+        this.timeout = config.timeout ?? TIMEOUTS.DEFAULT;
+        // Add session ID to headers if provided
+        if (this.sessionId) {
+            this.headers['X-Session-Id'] = this.sessionId;
+        }
+    }
+    /**
+     * Connect to the SSE endpoint.
+     */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        // SECURITY: Validate URL uses HTTPS for remote servers
+        // This protects session tokens that may be passed via URL parameters
+        validateSecureUrl(this.baseUrl);
+        // Reset closing flag on fresh connection
+        this.isClosing = false;
+        // EventSource is available in browsers natively and in Node.js 18+.
+        // We use globalThis to check availability at runtime, requiring `any` cast
+        // because TypeScript's lib.dom.d.ts doesn't type globalThis.EventSource.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const EventSourceImpl = globalThis.EventSource;
+        if (!EventSourceImpl) {
+            throw new Error('EventSource is not available. ' +
+                'SSE transport requires Node.js 18+ or a browser environment. ' +
+                'For older Node.js versions, consider using streamable-http transport instead.');
+        }
+        return new Promise((resolve, reject) => {
+            const sseUrl = `${this.baseUrl}/sse`;
+            this.log('Connecting to SSE endpoint', { url: sseUrl });
+            try {
+                // Create EventSource - headers need to be passed via URL params or custom implementation
+                // Note: Standard EventSource doesn't support custom headers
+                // For authenticated endpoints, session ID should be passed via URL param
+                let url = sseUrl;
+                if (this.sessionId) {
+                    const separator = url.includes('?') ? '&' : '?';
+                    url = `${url}${separator}sessionId=${encodeURIComponent(this.sessionId)}`;
+                }
+                this.eventSource = new EventSourceImpl(url);
+                this.eventSource.onopen = () => {
+                    this.log('SSE connection opened');
+                    this.connected = true;
+                    this.reconnectAttempts = 0;
+                    resolve();
+                };
+                this.eventSource.onmessage = (event) => {
+                    this.handleSSEMessage(event);
+                };
+                // Handle specific event types from MCP SSE protocol
+                this.eventSource.addEventListener('endpoint', (event) => {
+                    // Server tells us where to send messages
+                    const messageEvent = event;
+                    this.messageEndpoint = messageEvent.data;
+                    this.log('Received message endpoint', { endpoint: this.messageEndpoint ?? '' });
+                });
+                this.eventSource.addEventListener('message', (event) => {
+                    this.handleSSEMessage(event);
+                });
+                this.eventSource.onerror = (error) => {
+                    this.log('SSE error', { type: error.type });
+                    if (!this.connected) {
+                        // Connection failed on initial connect
+                        reject(new Error('Failed to connect to SSE endpoint'));
+                        return;
+                    }
+                    // Handle reconnection for established connections
+                    this.handleReconnect();
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Handle an incoming SSE message.
+     */
+    handleSSEMessage(event) {
+        try {
+            const data = event.data;
+            // Skip empty messages or heartbeats
+            if (!data || data === ':') {
+                return;
+            }
+            this.log('Received SSE message', { data });
+            const message = JSON.parse(data);
+            this.emit('message', message);
+        }
+        catch (error) {
+            this.log('Failed to parse SSE message', { error: error instanceof Error ? error.message : String(error) });
+            // Don't emit error for parse failures - just log
+        }
+    }
+    /**
+     * Handle reconnection after a connection error.
+     *
+     * RELIABILITY IMPROVEMENTS:
+     * - Prevents unbounded recursion with max attempts check
+     * - Uses capped exponential backoff
+     * - Clears reconnect timer on close
+     * - Checks isClosing flag to prevent reconnection after close()
+     * - Explicitly closes EventSource on max attempts
+     */
+    handleReconnect() {
+        // Don't reconnect if we're closing
+        if (this.isClosing) {
+            this.log('Reconnection skipped - transport is closing');
+            return;
+        }
+        // Check max attempts BEFORE incrementing
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.log('Max reconnect attempts reached', { attempts: this.reconnectAttempts });
+            this.connected = false;
+            // Explicitly close the EventSource to clean up resources
+            if (this.eventSource) {
+                try {
+                    this.eventSource.close();
+                }
+                catch {
+                    // Ignore close errors
+                }
+                this.eventSource = null;
+            }
+            this.emit('error', new Error(`Max reconnection attempts (${this.maxReconnectAttempts}) exceeded`));
+            this.emit('close');
+            return;
+        }
+        this.reconnectAttempts++;
+        // Exponential backoff with cap
+        const exponentialDelay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        const delay = Math.min(exponentialDelay, this.maxBackoffDelay);
+        this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        // Clear any existing reconnect timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        // Store the timer so it can be cancelled by close()
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            // Double-check we're not closing before attempting reconnect
+            if (this.isClosing) {
+                return;
+            }
+            // Non-recursive approach: use .then/.catch instead of async/await in setTimeout
+            this.connect()
+                .then(() => {
+                this.log('Reconnection successful');
+            })
+                .catch((error) => {
+                this.log('Reconnection failed', { error: error.message });
+                // Schedule next attempt (not recursive - just schedules another timer)
+                this.handleReconnect();
+            });
+        }, delay);
+    }
+    /**
+     * Send a JSON-RPC message to the server via HTTP POST.
+     */
+    send(message) {
+        if (!this.connected) {
+            this.emit('error', new Error('Transport not connected'));
+            return;
+        }
+        // Use the endpoint provided by the server, or default to /message
+        const endpoint = this.messageEndpoint || `${this.baseUrl}/message`;
+        this.log('Sending message', { endpoint, message });
+        // Create a new abort controller for this request
+        this.abortController = new AbortController();
+        const timeoutId = setTimeout(() => {
+            this.abortController?.abort();
+        }, this.timeout);
+        fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.headers,
+            },
+            body: JSON.stringify(message),
+            signal: this.abortController.signal,
+        })
+            .then(async (response) => {
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            // Some servers may return a response directly (for request/response pattern)
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                const responseData = await response.json();
+                if (responseData && typeof responseData === 'object') {
+                    this.emit('message', responseData);
+                }
+            }
+        })
+            .catch((error) => {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                this.emit('error', new Error('Request timeout'));
+            }
+            else {
+                this.emit('error', error);
+            }
+        });
+    }
+    /**
+     * Close the SSE connection.
+     *
+     * RELIABILITY: Properly cleans up all resources including:
+     * - EventSource connection
+     * - Pending HTTP requests (via abort controller)
+     * - Reconnection timer
+     * - Sets isClosing flag to prevent reconnection attempts
+     */
+    close() {
+        this.log('Closing SSE transport');
+        // Set closing flag FIRST to prevent any reconnection attempts
+        this.isClosing = true;
+        this.connected = false;
+        // Cancel any pending reconnection timer
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        // Close the EventSource connection
+        if (this.eventSource) {
+            try {
+                this.eventSource.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+            this.eventSource = null;
+        }
+        // Abort any in-flight HTTP requests
+        if (this.abortController) {
+            try {
+                this.abortController.abort();
+            }
+            catch {
+                // Ignore abort errors
+            }
+            this.abortController = null;
+        }
+        this.messageEndpoint = null;
+        this.reconnectAttempts = 0;
+        this.emit('close');
+    }
+    /**
+     * Check if the transport is connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+}
+//# sourceMappingURL=sse-transport.js.map

package/dist/transport/stdio-transport.d.ts

@@ -0,0 +1,43 @@
+import type { Readable, Writable } from 'stream';
+import type { JSONRPCMessage } from './types.js';
+import { BaseTransport, type BaseTransportConfig } from './base-transport.js';
+/**
+ * Configuration for StdioTransport.
+ */
+export interface StdioTransportConfig extends BaseTransportConfig {
+    /** Maximum message size in bytes (default: 10MB) */
+    maxMessageSize?: number;
+    /** Maximum buffer size in bytes (default: 20MB) */
+    maxBufferSize?: number;
+    /** Maximum header size in bytes (default: 8KB) */
+    maxHeaderSize?: number;
+    /** Use newline-delimited JSON instead of Content-Length framing */
+    useNewlineDelimited?: boolean;
+}
+/**
+ * StdioTransport handles JSON-RPC message framing over stdio streams.
+ * Uses Content-Length header protocol for message boundaries.
+ *
+ * Adapted from Overwatch's MCPTransport for client-side usage.
+ */
+export declare class StdioTransport extends BaseTransport {
+    private input;
+    private output;
+    private buffer;
+    private contentLength;
+    private readonly maxMessageSize;
+    private readonly maxBufferSize;
+    private readonly maxHeaderSize;
+    private readonly useNewlineDelimited;
+    private connected;
+    constructor(input: Readable, output: Writable, config?: StdioTransportConfig);
+    /**
+     * Check if the transport is connected.
+     */
+    isConnected(): boolean;
+    private setupInputHandler;
+    private processBuffer;
+    send(message: JSONRPCMessage): void;
+    close(): void;
+}
+//# sourceMappingURL=stdio-transport.d.ts.map

package/dist/transport/stdio-transport.js

@@ -0,0 +1,238 @@
+import { BaseTransport } from './base-transport.js';
+import { DISPLAY_LIMITS } from '../constants.js';
+const DEFAULT_MAX_MESSAGE_SIZE = 10 * 1024 * 1024; // 10MB
+const DEFAULT_MAX_BUFFER_SIZE = 20 * 1024 * 1024; // 20MB
+const DEFAULT_MAX_HEADER_SIZE = 8 * 1024; // 8KB
+/**
+ * StdioTransport handles JSON-RPC message framing over stdio streams.
+ * Uses Content-Length header protocol for message boundaries.
+ *
+ * Adapted from Overwatch's MCPTransport for client-side usage.
+ */
+export class StdioTransport extends BaseTransport {
+    input;
+    output;
+    buffer = '';
+    contentLength = null;
+    maxMessageSize;
+    maxBufferSize;
+    maxHeaderSize;
+    useNewlineDelimited;
+    connected = true;
+    constructor(input, output, config) {
+        super(config);
+        this.input = input;
+        this.output = output;
+        this.maxMessageSize = config?.maxMessageSize ?? DEFAULT_MAX_MESSAGE_SIZE;
+        this.maxBufferSize = config?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+        this.maxHeaderSize = config?.maxHeaderSize ?? DEFAULT_MAX_HEADER_SIZE;
+        this.useNewlineDelimited = config?.useNewlineDelimited ?? true; // Default to newline-delimited
+        this.setupInputHandler();
+    }
+    /**
+     * Check if the transport is connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    setupInputHandler() {
+        this.input.on('data', (chunk) => {
+            if (this.debug) {
+                this.logger.debug({ preview: chunk.toString('utf-8').substring(0, DISPLAY_LIMITS.TRANSPORT_INPUT_PREVIEW) }, 'Raw input received');
+            }
+            const newSize = this.buffer.length + chunk.length;
+            if (newSize > this.maxBufferSize) {
+                this.emit('error', new Error(`Buffer size limit exceeded: ${newSize} > ${this.maxBufferSize} bytes.`));
+                this.buffer = '';
+                this.contentLength = null;
+                return;
+            }
+            this.buffer += chunk.toString('utf-8');
+            this.processBuffer();
+        });
+        this.input.on('end', () => {
+            this.emit('close');
+        });
+        this.input.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+    processBuffer() {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (this.contentLength === null) {
+                // First, try to find Content-Length header
+                const headerEnd = this.buffer.indexOf('\r\n\r\n');
+                // If no header found, try newline-delimited JSON
+                if (headerEnd === -1) {
+                    // Check if we have a complete line (newline-delimited JSON)
+                    const newlineIndex = this.buffer.indexOf('\n');
+                    if (newlineIndex === -1) {
+                        // No complete message yet
+                        if (this.buffer.length > this.maxHeaderSize) {
+                            this.emit('error', new Error(`Buffer size limit exceeded without finding message boundary`));
+                            this.buffer = '';
+                        }
+                        return;
+                    }
+                    // Process newline-delimited JSON
+                    const line = this.buffer.substring(0, newlineIndex).trim();
+                    this.buffer = this.buffer.substring(newlineIndex + 1);
+                    if (line.length > this.maxMessageSize) {
+                        this.emit('error', new Error(`Message size limit exceeded: ${line.length} > ${this.maxMessageSize} bytes.`));
+                        continue;
+                    }
+                    if (line) {
+                        try {
+                            const message = JSON.parse(line);
+                            this.emit('message', message);
+                        }
+                        catch (error) {
+                            // Emit error for invalid JSON for consistent behavior with Content-Length mode
+                            this.emit('error', new Error(`Invalid JSON in newline-delimited message: ${error instanceof Error ? error.message : String(error)}`));
+                        }
+                    }
+                    continue;
+                }
+                const header = this.buffer.substring(0, headerEnd);
+                const match = header.match(/Content-Length: (\d+)/i);
+                if (!match) {
+                    // Header found but no Content-Length, try as newline-delimited
+                    const newlineIndex = this.buffer.indexOf('\n');
+                    if (newlineIndex === -1)
+                        return;
+                    const line = this.buffer.substring(0, newlineIndex).trim();
+                    this.buffer = this.buffer.substring(newlineIndex + 1);
+                    if (line.length > this.maxMessageSize) {
+                        this.emit('error', new Error(`Message size limit exceeded: ${line.length} > ${this.maxMessageSize} bytes.`));
+                        continue;
+                    }
+                    if (line) {
+                        try {
+                            const message = JSON.parse(line);
+                            this.emit('message', message);
+                        }
+                        catch (error) {
+                            // Emit error for invalid JSON for consistent behavior with Content-Length mode
+                            this.emit('error', new Error(`Invalid JSON in newline-delimited message: ${error instanceof Error ? error.message : String(error)}`));
+                        }
+                    }
+                    continue;
+                }
+                const contentLength = parseInt(match[1], 10);
+                if (!Number.isFinite(contentLength) || contentLength < 0) {
+                    this.emit('error', new Error(`Invalid Content-Length: ${match[1]}. Must be a positive integer.`));
+                    this.buffer = this.buffer.substring(headerEnd + 4);
+                    continue;
+                }
+                if (contentLength > this.maxMessageSize) {
+                    this.emit('error', new Error(`Content-Length ${contentLength} exceeds maximum allowed size of ${this.maxMessageSize} bytes.`));
+                    this.buffer = this.buffer.substring(headerEnd + 4);
+                    if (this.buffer.length >= contentLength) {
+                        this.buffer = this.buffer.substring(contentLength);
+                    }
+                    else {
+                        this.buffer = '';
+                    }
+                    continue;
+                }
+                this.contentLength = contentLength;
+                this.buffer = this.buffer.substring(headerEnd + 4);
+            }
+            if (this.buffer.length < this.contentLength)
+                return;
+            const content = this.buffer.substring(0, this.contentLength);
+            this.buffer = this.buffer.substring(this.contentLength);
+            this.contentLength = null;
+            try {
+                const message = JSON.parse(content);
+                this.emit('message', message);
+            }
+            catch (e) {
+                this.emit('error', new Error(`Invalid JSON: ${e}`));
+            }
+        }
+    }
+    send(message) {
+        const content = JSON.stringify(message);
+        const writeData = (data) => {
+            try {
+                const success = this.output.write(data);
+                if (!success) {
+                    // Handle backpressure - wait for drain event
+                    this.output.once('drain', () => {
+                        this.logger.debug('Output stream drained');
+                    });
+                }
+            }
+            catch (error) {
+                // Emit error for broken pipe (EPIPE) or other write failures
+                this.emit('error', new Error(`Failed to write to output stream: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        };
+        if (this.useNewlineDelimited) {
+            // Newline-delimited JSON format
+            if (this.debug) {
+                this.logger.debug({ format: 'newline', content }, 'Sending message');
+            }
+            writeData(content + '\n');
+        }
+        else {
+            // Content-Length framing
+            const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
+            if (this.debug) {
+                this.logger.debug({ format: 'content-length', content: header + content }, 'Sending message');
+            }
+            writeData(header + content);
+        }
+    }
+    close() {
+        if (!this.connected) {
+            return; // Already closed
+        }
+        this.connected = false;
+        this.buffer = '';
+        this.contentLength = null;
+        // Remove listeners first to prevent further event processing
+        this.input.removeAllListeners();
+        // Destroy input stream to release file descriptor
+        // Use try-catch in case stream is already destroyed or in bad state
+        try {
+            if (!this.input.destroyed) {
+                this.input.destroy();
+                this.logger.debug('Input stream destroyed');
+            }
+        }
+        catch (error) {
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, 'Error destroying input stream');
+        }
+        // End output stream gracefully, then destroy after timeout
+        try {
+            if (!this.output.destroyed && this.output.writable) {
+                // Give output stream time to flush
+                const destroyTimeout = setTimeout(() => {
+                    try {
+                        if (!this.output.destroyed) {
+                            this.output.destroy();
+                            this.logger.debug('Output stream destroyed after timeout');
+                        }
+                    }
+                    catch {
+                        // Ignore errors during forced cleanup
+                    }
+                }, 1000);
+                this.output.end(() => {
+                    clearTimeout(destroyTimeout);
+                    this.logger.debug('Output stream ended gracefully');
+                });
+            }
+        }
+        catch (error) {
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, 'Error ending output stream');
+        }
+        // Emit close before removing listeners so handlers can react
+        this.emit('close');
+        this.removeAllListeners();
+    }
+}
+//# sourceMappingURL=stdio-transport.js.map