euparliamentmonitor 0.9.19 → 0.9.21

package/scripts/mcp/transport/connection.d.ts

@@ -77,40 +77,34 @@ export declare class MCPConnection {
         connected: boolean;
     };
     /**
-     * Compute the delay before the next connection attempt.
-     * Respects `Retry-After` carried by {@link MCPRateLimitError}; otherwise uses
-     * exponential back-off (`connectionRetryDelay * 2^(attempt - 1)`).
-     *
-     * @param error - The error from the failed attempt
-     * @param attempt - Number of attempts made so far (1-indexed)
-     * @returns Delay in milliseconds
+     * Connect to the MCP server with retry logic
      */
-    private _computeConnectionDelay;
+    connect(): Promise<void>;
     /**
-     * Handle a single connection attempt error: re-throw immediately for non-retriable errors
-     * (e.g. session expiry), increment the attempt counter, and return the delay to wait
-     * before the next attempt. Throws when the maximum attempts have been exhausted.
+     * Advance the attempt counter and compute the next retry delay.
+     * Throws immediately for non-retriable errors or when exhausted.
      *
      * @param error - The error from the failed attempt
      * @returns Delay in milliseconds to wait before the next attempt
      */
-    private _handleConnectionAttemptError;
+    private _nextConnectionDelay;
     /**
-     * Connect to the MCP server with retry logic
+     * Build a {@link GatewayContext} adapter for gateway.ts helpers.
+     *
+     * @returns Context adapter for gateway.ts helpers
      */
-    connect(): Promise<void>;
+    private _gatewayContext;
     /**
-     * Build a {@link GatewayContext} adapter for delegating to gateway helpers.
+     * Build a {@link SpawnContext} adapter for process.ts spawn helpers.
      *
-     * @returns A context adapter exposing the connection-level fields the
-     *   gateway helpers need (URL, API key, session ID accessors, request-ID
-     *   counter, connection-state setter).
+     * @returns Context adapter for stdio spawn helpers
      */
-    private _gatewayContext;
-    /** Attempt a single connection via MCP Gateway (HTTP transport). */
-    private _attemptGatewayConnection;
+    private _spawnContext;
     /**
-     * Attempt a single connection via stdio (spawns server binary)
+     * Attempt a single connection via stdio (spawns server binary).
+     * Delegates to {@link attemptStdioConnection} in process.ts.
+     *
+     * @returns Resolves when the spawn has completed (or rejects on spawn failure)
      */
     private _attemptConnection;
     /**
@@ -118,20 +112,12 @@ export declare class MCPConnection {
      */
     disconnect(): void;
     /**
-     * Handle incoming messages from MCP server (stdio mode only)
+     * Handle incoming messages from MCP server (stdio mode only).
+     * Delegates to {@link handleIncomingMessage} in process.ts.
      *
      * @param line - JSON message line from server
      */
     handleMessage(line: string): void;
-    /**
-     * Send a request via MCP Gateway (HTTP transport). Delegates to the
-     * gateway helper module.
-     *
-     * @param method - RPC method name
-     * @param params - Method parameters
-     * @returns Server response result payload
-     */
-    private _sendGatewayRequest;
     /**
      * Send a request to the MCP server
      *
@@ -155,32 +141,18 @@ export declare class MCPConnection {
      */
     callTool(name: string, args?: object): Promise<MCPToolResult>;
     /**
-     * Attempt to reconnect to the MCP server with exponential back-off.
-     * Concurrent callers await the same in-flight reconnect instead of no-oping,
-     * ensuring the connection is re-established before all waiting callers continue.
-     *
-     * @returns Promise that resolves when reconnection succeeds or all attempts are exhausted
-     */
-    private reconnect;
-    /**
-     * Internal reconnect helper.
-     *
-     * Waits for an exponential back-off delay derived from the current
-     * `reconnectCount`, then delegates to `connect()` which handles its own
-     * retry loop. This avoids composing N×N attempts.
+     * Build a {@link ReconnectOps} adapter for reconnect.ts helpers.
      *
-     * @returns Promise that resolves when reconnection succeeds or logs on failure
+     * @returns Context adapter for reconnect/retry helpers
      */
-    private _doReconnect;
+    private _reconnectOps;
     /**
-     * Log a retry warning and, if disconnected, attempt to reconnect before waiting.
+     * Attempt to reconnect to the MCP server.
+     * Deduplicates concurrent calls — only one reconnect runs at a time.
      *
-     * @param lastError - The error from the failed attempt
-     * @param attempt - Zero-based current attempt index
-     * @param retries - Total retry count
-     * @returns Promise that resolves after logging, optional reconnect, and inter-retry delay
+     * @returns Resolves when reconnect succeeds or all attempts are exhausted
      */
-    private _handleRetryAttempt;
+    reconnect(): Promise<void>;
     /**
      * Call an MCP tool with automatic retry on timeout or connection loss.
      * Reconnects automatically if the connection was lost between attempts.

package/scripts/mcp/transport/connection.js

@@ -1,45 +1,9 @@
 // SPDX-FileCopyrightText: 2024-2026 Hack23 AB
 // SPDX-License-Identifier: Apache-2.0
-/**
- * @module MCP/transport/connection
- * @description MCPConnection — JSON-RPC 2.0 transport over stdio or HTTP gateway.
- * Supports two transport modes:
- * - **stdio**: Spawns the EP MCP server binary as a child process (default)
- * - **gateway**: Connects to an MCP Gateway via HTTP (for agentic workflow environments)
- *
- * Gateway mode is activated when `EP_MCP_GATEWAY_URL` env var is set or
- * `gatewayUrl` is provided in options.
- */
-import { spawn } from 'child_process';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
 import { MCPRateLimitError, MCPSessionExpiredError } from './errors.js';
-import { isRetriableError, RECONNECT_MAX_DELAY_MS } from './retry-policy.js';
 import { attemptGatewayConnection, sendGatewayRequest } from './gateway.js';
-/** npm binary name for the European Parliament MCP server */
-const BINARY_NAME = 'european-parliament-mcp-server';
-/** Platform-specific binary filename (Windows uses .cmd shim) */
-const BINARY_FILE = process.platform === 'win32' ? `${BINARY_NAME}.cmd` : BINARY_NAME;
-/** Default binary resolved from node_modules/.bin relative to this file's compiled location */
-const DEFAULT_SERVER_BINARY = resolve(dirname(fileURLToPath(import.meta.url)), `../../../node_modules/.bin/${BINARY_FILE}`);
-/** Default request timeout in milliseconds — EU Parliament API responses commonly take 30-120+ seconds for large datasets */
-const DEFAULT_REQUEST_TIMEOUT_MS = 180_000;
-/**
- * Effective request timeout, configurable via `EP_REQUEST_TIMEOUT_MS` env var.
- * This keeps the client-side timeout aligned with the MCP server timeout set
- * in workflow configs and copilot-mcp.json.
- */
-const REQUEST_TIMEOUT_MS = (() => {
-    const envVal = process.env['EP_REQUEST_TIMEOUT_MS'];
-    if (envVal) {
-        const parsed = Number(envVal);
-        if (!Number.isNaN(parsed) && parsed > 0)
-            return parsed;
-    }
-    return DEFAULT_REQUEST_TIMEOUT_MS;
-})();
-/** Connection startup delay in milliseconds */
-const CONNECTION_STARTUP_DELAY_MS = 500;
+import { REQUEST_TIMEOUT_MS, DEFAULT_SERVER_BINARY, attemptStdioConnection, handleIncomingMessage, } from './process.js';
+import { performReconnect, runWithRetry } from './reconnect.js';
 /**
  * Base MCP connection managing JSON-RPC 2.0 transport over stdio or HTTP gateway.
  * Extended by domain-specific clients to add tool wrapper methods.
@@ -148,40 +112,6 @@ export class MCPConnection {
             connected: this.connected,
         };
     }
-    /**
-     * Compute the delay before the next connection attempt.
-     * Respects `Retry-After` carried by {@link MCPRateLimitError}; otherwise uses
-     * exponential back-off (`connectionRetryDelay * 2^(attempt - 1)`).
-     *
-     * @param error - The error from the failed attempt
-     * @param attempt - Number of attempts made so far (1-indexed)
-     * @returns Delay in milliseconds
-     */
-    _computeConnectionDelay(error, attempt) {
-        if (error instanceof MCPRateLimitError && error.retryAfterMs > 0) {
-            return error.retryAfterMs;
-        }
-        return this.connectionRetryDelay * Math.pow(2, attempt - 1);
-    }
-    /**
-     * Handle a single connection attempt error: re-throw immediately for non-retriable errors
-     * (e.g. session expiry), increment the attempt counter, and return the delay to wait
-     * before the next attempt. Throws when the maximum attempts have been exhausted.
-     *
-     * @param error - The error from the failed attempt
-     * @returns Delay in milliseconds to wait before the next attempt
-     */
-    _handleConnectionAttemptError(error) {
-        if (error instanceof MCPSessionExpiredError) {
-            throw error;
-        }
-        this.connectionAttempts++;
-        if (this.connectionAttempts >= this.maxConnectionAttempts) {
-            console.error('❌ Failed to connect to MCP server after', this.maxConnectionAttempts, 'attempts');
-            throw error;
-        }
-        return this._computeConnectionDelay(error, this.connectionAttempts);
-    }
     /**
      * Connect to the MCP server with retry logic
      */
@@ -200,7 +130,7 @@ export class MCPConnection {
         while (this.connectionAttempts < this.maxConnectionAttempts) {
             try {
                 if (this.gatewayUrl) {
-                    await this._attemptGatewayConnection();
+                    await attemptGatewayConnection(this._gatewayContext());
                 }
                 else {
                     await this._attemptConnection();
@@ -209,18 +139,36 @@ export class MCPConnection {
                 return;
             }
             catch (error) {
-                const delay = this._handleConnectionAttemptError(error);
+                const delay = this._nextConnectionDelay(error);
                 console.warn(`⚠️ Connection attempt ${this.connectionAttempts} failed. Retrying in ${delay}ms...`);
                 await new Promise((resolve) => setTimeout(resolve, delay));
             }
         }
     }
     /**
-     * Build a {@link GatewayContext} adapter for delegating to gateway helpers.
+     * Advance the attempt counter and compute the next retry delay.
+     * Throws immediately for non-retriable errors or when exhausted.
      *
-     * @returns A context adapter exposing the connection-level fields the
-     *   gateway helpers need (URL, API key, session ID accessors, request-ID
-     *   counter, connection-state setter).
+     * @param error - The error from the failed attempt
+     * @returns Delay in milliseconds to wait before the next attempt
+     */
+    _nextConnectionDelay(error) {
+        if (error instanceof MCPSessionExpiredError)
+            throw error;
+        this.connectionAttempts++;
+        if (this.connectionAttempts >= this.maxConnectionAttempts) {
+            console.error('❌ Failed to connect to MCP server after', this.maxConnectionAttempts, 'attempts');
+            throw error;
+        }
+        if (error instanceof MCPRateLimitError && error.retryAfterMs > 0) {
+            return error.retryAfterMs;
+        }
+        return this.connectionRetryDelay * Math.pow(2, this.connectionAttempts - 1);
+    }
+    /**
+     * Build a {@link GatewayContext} adapter for gateway.ts helpers.
+     *
+     * @returns Context adapter for gateway.ts helpers
      */
     _gatewayContext() {
         return {
@@ -237,72 +185,39 @@ export class MCPConnection {
             },
         };
     }
-    /** Attempt a single connection via MCP Gateway (HTTP transport). */
-    async _attemptGatewayConnection() {
-        await attemptGatewayConnection(this._gatewayContext());
-    }
     /**
-     * Attempt a single connection via stdio (spawns server binary)
+     * Build a {@link SpawnContext} adapter for process.ts spawn helpers.
+     *
+     * @returns Context adapter for stdio spawn helpers
      */
-    async _attemptConnection() {
-        try {
-            const isJavaScriptFile = this.serverPath.toLowerCase().endsWith('.js');
-            const command = isJavaScriptFile ? process.execPath : this.serverPath;
-            const args = isJavaScriptFile ? [this.serverPath] : [];
-            const childEnv = { ...process.env };
-            const effectiveTimeoutMs = childEnv['EP_REQUEST_TIMEOUT_MS']
-                ? Number(childEnv['EP_REQUEST_TIMEOUT_MS'])
-                : REQUEST_TIMEOUT_MS;
-            childEnv['EP_REQUEST_TIMEOUT_MS'] = String(effectiveTimeoutMs);
-            if (!isJavaScriptFile) {
-                args.push('--timeout', String(effectiveTimeoutMs));
-            }
-            this.process = spawn(command, args, {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                env: childEnv,
-            });
-            let buffer = '';
-            let startupError = null;
-            this.process.stdout?.on('data', (data) => {
-                buffer += data.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop() ?? '';
-                for (const line of lines) {
-                    if (line.trim()) {
-                        this.handleMessage(line);
-                    }
-                }
-            });
-            this.process.stderr?.on('data', (data) => {
-                const message = data.toString().trim();
-                if (message) {
-                    console.error(`MCP Server: ${message}`);
-                }
-            });
-            this.process.on('close', (code) => {
-                console.log(`MCP Server exited with code ${code}`);
-                this.connected = false;
+    _spawnContext() {
+        return {
+            serverPath: this.serverPath,
+            serverLabel: this.serverLabel,
+            requestTimeoutMs: REQUEST_TIMEOUT_MS,
+            setProcess: (p) => {
+                this.process = p;
+            },
+            setConnected: (v) => {
+                this.connected = v;
+            },
+            onMessage: (line) => this.handleMessage(line),
+            rejectAllPending: (msg) => {
                 for (const [id, { reject }] of this.pendingRequests.entries()) {
-                    reject(new Error('MCP server connection closed'));
+                    reject(new Error(msg));
                     this.pendingRequests.delete(id);
                 }
-            });
-            this.process.on('error', (err) => {
-                startupError = err;
-                this.connected = false;
-            });
-            await new Promise((resolve) => setTimeout(resolve, CONNECTION_STARTUP_DELAY_MS));
-            if (startupError) {
-                throw startupError;
-            }
-            this.connected = true;
-            console.log(`✅ Connected to ${this.serverLabel}`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error('❌ Failed to spawn MCP server:', message);
-            throw error;
-        }
+            },
+        };
+    }
+    /**
+     * Attempt a single connection via stdio (spawns server binary).
+     * Delegates to {@link attemptStdioConnection} in process.ts.
+     *
+     * @returns Resolves when the spawn has completed (or rejects on spawn failure)
+     */
+    async _attemptConnection() {
+        return attemptStdioConnection(this._spawnContext());
     }
     /**
      * Disconnect from the MCP server
@@ -316,49 +231,13 @@ export class MCPConnection {
         this.mcpSessionId = null;
     }
     /**
-     * Handle incoming messages from MCP server (stdio mode only)
+     * Handle incoming messages from MCP server (stdio mode only).
+     * Delegates to {@link handleIncomingMessage} in process.ts.
      *
      * @param line - JSON message line from server
      */
     handleMessage(line) {
-        try {
-            const message = JSON.parse(line);
-            if (message.id !== null && message.id !== undefined && this.pendingRequests.has(message.id)) {
-                const pending = this.pendingRequests.get(message.id);
-                if (pending) {
-                    this.pendingRequests.delete(message.id);
-                    if (message.error) {
-                        pending.reject(new Error(message.error.message ?? 'MCP server error'));
-                    }
-                    else {
-                        pending.resolve(message.result);
-                    }
-                }
-                else {
-                    this.pendingRequests.delete(message.id);
-                    console.error(`MCP pending request ${String(message.id)} vanished before handling`);
-                }
-            }
-            else if ((message.id === null || message.id === undefined) && message.method) {
-                console.log(`MCP Notification: ${message.method}`);
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error('Error parsing MCP message:', errorMessage);
-            console.error('Problematic line:', line);
-        }
-    }
-    /**
-     * Send a request via MCP Gateway (HTTP transport). Delegates to the
-     * gateway helper module.
-     *
-     * @param method - RPC method name
-     * @param params - Method parameters
-     * @returns Server response result payload
-     */
-    async _sendGatewayRequest(method, params = {}) {
-        return sendGatewayRequest(method, params, this._gatewayContext());
+        handleIncomingMessage(line, this.pendingRequests);
     }
     /**
      * Send a request to the MCP server
@@ -372,7 +251,7 @@ export class MCPConnection {
             throw new Error('Not connected to MCP server');
         }
         if (this.gatewayUrl) {
-            return (await this._sendGatewayRequest(method, params));
+            return (await sendGatewayRequest(method, params, this._gatewayContext()));
         }
         const id = ++this.requestId;
         const request = {
@@ -418,68 +297,43 @@ export class MCPConnection {
         return this.sendRequest('tools/call', { name, arguments: args });
     }
     /**
-     * Attempt to reconnect to the MCP server with exponential back-off.
-     * Concurrent callers await the same in-flight reconnect instead of no-oping,
-     * ensuring the connection is re-established before all waiting callers continue.
-     *
-     * @returns Promise that resolves when reconnection succeeds or all attempts are exhausted
-     */
-    async reconnect() {
-        if (this.reconnectingPromise !== null) {
-            return this.reconnectingPromise;
-        }
-        this.reconnectCount++;
-        console.log(`🔄 Reconnecting to ${this.serverLabel} (attempt ${this.reconnectCount})...`);
-        this.reconnectingPromise = this._doReconnect();
-        try {
-            await this.reconnectingPromise;
-        }
-        finally {
-            this.reconnectingPromise = null;
-        }
-    }
-    /**
-     * Internal reconnect helper.
-     *
-     * Waits for an exponential back-off delay derived from the current
-     * `reconnectCount`, then delegates to `connect()` which handles its own
-     * retry loop. This avoids composing N×N attempts.
+     * Build a {@link ReconnectOps} adapter for reconnect.ts helpers.
      *
-     * @returns Promise that resolves when reconnection succeeds or logs on failure
+     * @returns Context adapter for reconnect/retry helpers
      */
-    async _doReconnect() {
-        const normalizedMaxAttempts = Math.max(1, this.maxConnectionAttempts);
-        const attemptIndex = Math.min(Math.max(0, this.reconnectCount - 1), normalizedMaxAttempts - 1);
-        const delay = Math.min(this.connectionRetryDelay * Math.pow(2, attemptIndex), RECONNECT_MAX_DELAY_MS);
-        await new Promise((r) => setTimeout(r, delay));
-        try {
-            this.connected = false;
-            await this.connect();
-        }
-        catch (error) {
-            console.error(`❌ Reconnection to ${this.serverLabel} failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    _reconnectOps() {
+        return {
+            maxConnectionAttempts: this.maxConnectionAttempts,
+            connectionRetryDelay: this.connectionRetryDelay,
+            serverLabel: this.serverLabel,
+            callTool: (n, a) => this.callTool(n, a),
+            isConnected: () => this.connected,
+            connect: () => this.connect(),
+            setConnected: (v) => {
+                this.connected = v;
+            },
+            getReconnectCount: () => this.reconnectCount,
+            setReconnectCount: (n) => {
+                this.reconnectCount = n;
+            },
+            getReconnectingPromise: () => this.reconnectingPromise,
+            setReconnectingPromise: (p) => {
+                this.reconnectingPromise = p;
+            },
+            getTimeoutCount: () => this.timeoutCount,
+            setTimeoutCount: (n) => {
+                this.timeoutCount = n;
+            },
+        };
     }
     /**
-     * Log a retry warning and, if disconnected, attempt to reconnect before waiting.
+     * Attempt to reconnect to the MCP server.
+     * Deduplicates concurrent calls — only one reconnect runs at a time.
      *
-     * @param lastError - The error from the failed attempt
-     * @param attempt - Zero-based current attempt index
-     * @param retries - Total retry count
-     * @returns Promise that resolves after logging, optional reconnect, and inter-retry delay
+     * @returns Resolves when reconnect succeeds or all attempts are exhausted
      */
-    async _handleRetryAttempt(lastError, attempt, retries) {
-        if (lastError.message.toLowerCase().includes('timeout')) {
-            this.timeoutCount++;
-            console.warn(`⏱️ Request timeout (total: ${this.timeoutCount}), retrying ${attempt + 1}/${retries}...`);
-        }
-        else {
-            console.warn(`⚠️ Request failed, retrying ${attempt + 1}/${retries}: ${lastError.message}`);
-        }
-        if (!this.connected) {
-            await this.reconnect();
-        }
-        await new Promise((r) => setTimeout(r, this.connectionRetryDelay * (attempt + 1)));
+    async reconnect() {
+        return performReconnect(this._reconnectOps());
     }
     /**
      * Call an MCP tool with automatic retry on timeout or connection loss.
@@ -499,21 +353,7 @@ export class MCPConnection {
         if (retries < 0) {
             throw new RangeError(`maxRetries must be >= 0, received ${retries}`);
         }
-        let lastError = new Error(`Failed to call tool '${name}' after ${retries} retries`);
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                return await this.callTool(name, args);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (!isRetriableError(lastError))
-                    throw lastError;
-                if (attempt === retries)
-                    break;
-                await this._handleRetryAttempt(lastError, attempt, retries);
-            }
-        }
-        throw lastError;
+        return runWithRetry(name, args, retries, this._reconnectOps());
     }
 }
 //# sourceMappingURL=connection.js.map

package/scripts/mcp/transport/process.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @module MCP/transport/process
+ * @description Stdio process spawn / teardown helpers and JSON-RPC message routing
+ * for the MCPConnection stdio transport.
+ *
+ * Extracted from `connection.ts` to keep individual file sizes under 400 LOC.
+ * Operates on an explicit {@link SpawnContext} adapter rather than `this`.
+ */
+import { type ChildProcess } from 'child_process';
+import type { PendingRequest } from '../../types/index.js';
+/** npm binary name for the European Parliament MCP server */
+export declare const BINARY_NAME = "european-parliament-mcp-server";
+/** Platform-specific binary filename (Windows uses .cmd shim) */
+export declare const BINARY_FILE: string;
+/** Default binary resolved from node_modules/.bin relative to this file's compiled location */
+export declare const DEFAULT_SERVER_BINARY: string;
+/** Default request timeout in milliseconds — EU Parliament API responses commonly take 30-120+ seconds for large datasets */
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 180000;
+/**
+ * Effective request timeout, configurable via `EP_REQUEST_TIMEOUT_MS` env var.
+ * This keeps the client-side timeout aligned with the MCP server timeout set
+ * in workflow configs and copilot-mcp.json.
+ */
+export declare const REQUEST_TIMEOUT_MS: number;
+/** Connection startup delay in milliseconds */
+export declare const CONNECTION_STARTUP_DELAY_MS = 500;
+/**
+ * Adapter passed by {@link MCPConnection} to stdio spawn helpers.
+ * Lets the helpers read the few connection-level fields they need and
+ * mutate process state without pulling in the whole connection class.
+ */
+export interface SpawnContext {
+    /** Resolved path to the server binary or JS entry-point */
+    readonly serverPath: string;
+    /** Human-readable label for log messages */
+    readonly serverLabel: string;
+    /** Per-request timeout (milliseconds) */
+    readonly requestTimeoutMs: number;
+    /** Store or clear the spawned child process */
+    readonly setProcess: (p: ChildProcess | null) => void;
+    /** Mark the connection as (dis)connected */
+    readonly setConnected: (v: boolean) => void;
+    /** Route an incoming newline-delimited JSON-RPC message line */
+    readonly onMessage: (line: string) => void;
+    /** Reject and clear all in-flight pending requests with an error */
+    readonly rejectAllPending: (message: string) => void;
+}
+/**
+ * Attempt a single connection via stdio (spawns server binary).
+ *
+ * @param ctx - Spawn context adapter from MCPConnection
+ */
+export declare function attemptStdioConnection(ctx: SpawnContext): Promise<void>;
+/**
+ * Handle an incoming newline-delimited JSON-RPC message from the server.
+ * Routes responses to matching in-flight pending requests; logs notifications.
+ *
+ * @param line - Single JSON-RPC message line (no trailing newline)
+ * @param pending - In-flight request map maintained by {@link MCPConnection}
+ */
+export declare function handleIncomingMessage(line: string, pending: Map<number, PendingRequest>): void;
+//# sourceMappingURL=process.d.ts.map