cowork-os 0.3.21

package/dist/electron/electron/mcp/client/transports/SSETransport.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * SSETransport - MCP transport over Server-Sent Events (SSE)
+ *
+ * Uses SSE (EventSource) for server-to-client messages and
+ * HTTP POST requests for client-to-server messages.
+ * This enables web-based MCP servers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSETransport = void 0;
+const events_1 = require("events");
+const eventsource_1 = require("eventsource");
+class SSETransport extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.eventSource = null;
+        this.messageHandler = null;
+        this.closeHandler = null;
+        this.errorHandler = null;
+        this.pendingRequests = new Map();
+        this.connected = false;
+        this.requestId = 0;
+        this.abortController = null;
+        this.config = config;
+    }
+    /**
+     * Connect to the MCP server via SSE
+     */
+    async connect() {
+        if (this.connected || this.eventSource) {
+            throw new Error('Already connected');
+        }
+        const { url } = this.config;
+        if (!url) {
+            throw new Error('No URL specified for SSE transport');
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.cleanup();
+                reject(new Error(`Connection timeout: server did not respond within ${this.config.connectionTimeout || 30000}ms`));
+            }, this.config.connectionTimeout || 30000);
+            try {
+                // Build SSE URL with auth headers if needed
+                const sseUrl = this.buildUrl(url, '/sse');
+                console.log(`[MCP SSETransport] Connecting to: ${sseUrl}`);
+                // Create EventSource for server-to-client messages
+                // Note: EventSource doesn't support custom headers, so we use URL params for auth
+                this.eventSource = new eventsource_1.EventSource(sseUrl);
+                this.eventSource.onopen = () => {
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    console.log(`[MCP SSETransport] Connected successfully`);
+                    resolve();
+                };
+                this.eventSource.onmessage = (event) => {
+                    this.handleMessage(event.data);
+                };
+                this.eventSource.onerror = (error) => {
+                    console.error(`[MCP SSETransport] EventSource error:`, error);
+                    if (!this.connected) {
+                        clearTimeout(timeout);
+                        reject(new Error('Failed to connect to SSE endpoint'));
+                    }
+                    else {
+                        this.errorHandler?.(new Error('SSE connection error'));
+                        this.closeHandler?.(new Error('SSE connection lost'));
+                    }
+                    this.cleanup();
+                };
+                // Handle named events (some servers use event types)
+                this.eventSource.addEventListener('message', (event) => {
+                    this.handleMessage(event.data);
+                });
+                this.eventSource.addEventListener('error', () => {
+                    if (this.connected) {
+                        this.closeHandler?.(new Error('SSE stream closed'));
+                        this.cleanup();
+                    }
+                });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                console.error(`[MCP SSETransport] Failed to connect:`, error);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Disconnect from the MCP server
+     */
+    async disconnect() {
+        console.log(`[MCP SSETransport] Disconnecting...`);
+        // Abort any pending requests
+        this.abortController?.abort();
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Transport disconnected'));
+        }
+        this.pendingRequests.clear();
+        this.cleanup();
+    }
+    /**
+     * Send a JSON-RPC request via HTTP POST and wait for response
+     */
+    async sendRequest(method, params) {
+        if (!this.connected) {
+            throw new Error('Not connected');
+        }
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout for method: ${method}`));
+            }, this.config.requestTimeout || 60000);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            // Send via HTTP POST
+            this.postMessage(request).catch((error) => {
+                this.pendingRequests.delete(id);
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Send a JSON-RPC message (request or notification)
+     */
+    async send(message) {
+        if (!this.connected) {
+            throw new Error('Not connected');
+        }
+        await this.postMessage(message);
+    }
+    /**
+     * Post a message to the server via HTTP
+     */
+    async postMessage(message) {
+        const { url } = this.config;
+        if (!url) {
+            throw new Error('No URL configured');
+        }
+        const postUrl = this.buildUrl(url, '/message');
+        this.abortController = new AbortController();
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                ...this.config.headers,
+            };
+            // Add auth headers
+            this.addAuthHeaders(headers);
+            const response = await fetch(postUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(message),
+                signal: this.abortController.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // Some servers return the response in the HTTP response body
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                const responseData = await response.json();
+                if (responseData && typeof responseData === 'object' && 'id' in responseData) {
+                    this.handleJsonRpcResponse(responseData);
+                }
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                throw new Error('Request aborted');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Register message handler
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Register close handler
+     */
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    /**
+     * Register error handler
+     */
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    /**
+     * Check if transport is connected
+     */
+    isConnected() {
+        // EventSource readyState: 0=CONNECTING, 1=OPEN, 2=CLOSED
+        return this.connected && this.eventSource?.readyState === 1;
+    }
+    /**
+     * Handle incoming SSE message
+     */
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            this.handleJsonRpcResponse(message);
+        }
+        catch (error) {
+            console.error(`[MCP SSETransport] Failed to parse message: ${data}`);
+        }
+    }
+    /**
+     * Handle a parsed JSON-RPC message
+     */
+    handleJsonRpcResponse(message) {
+        // Check if this is a response to a pending request
+        if ('id' in message && message.id !== null) {
+            const pending = this.pendingRequests.get(message.id);
+            if (pending) {
+                this.pendingRequests.delete(message.id);
+                clearTimeout(pending.timeout);
+                if ('error' in message && message.error) {
+                    pending.reject(new Error(message.error.message || 'Unknown error'));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+                return;
+            }
+        }
+        // Otherwise, pass to message handler (notifications)
+        this.messageHandler?.(message);
+    }
+    /**
+     * Build URL with optional path
+     */
+    buildUrl(baseUrl, path) {
+        const url = new URL(baseUrl);
+        // Append path if base URL doesn't already have it
+        if (!url.pathname.endsWith(path)) {
+            url.pathname = url.pathname.replace(/\/$/, '') + path;
+        }
+        // Add auth params for SSE (since EventSource doesn't support headers)
+        if (this.config.auth) {
+            if (this.config.auth.type === 'bearer' && this.config.auth.token) {
+                url.searchParams.set('token', this.config.auth.token);
+            }
+            else if (this.config.auth.type === 'api-key' && this.config.auth.apiKey) {
+                url.searchParams.set('api_key', this.config.auth.apiKey);
+            }
+        }
+        return url.toString();
+    }
+    /**
+     * Add authentication headers
+     */
+    addAuthHeaders(headers) {
+        if (!this.config.auth)
+            return;
+        switch (this.config.auth.type) {
+            case 'bearer':
+                if (this.config.auth.token) {
+                    headers['Authorization'] = `Bearer ${this.config.auth.token}`;
+                }
+                break;
+            case 'api-key':
+                if (this.config.auth.apiKey) {
+                    const headerName = this.config.auth.headerName || 'X-API-Key';
+                    headers[headerName] = this.config.auth.apiKey;
+                }
+                break;
+            case 'basic':
+                if (this.config.auth.username && this.config.auth.password) {
+                    const credentials = Buffer.from(`${this.config.auth.username}:${this.config.auth.password}`).toString('base64');
+                    headers['Authorization'] = `Basic ${credentials}`;
+                }
+                break;
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        this.connected = false;
+        // Clear all pending requests
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+        }
+        this.pendingRequests.clear();
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        this.abortController = null;
+    }
+}
+exports.SSETransport = SSETransport;

package/dist/electron/electron/mcp/client/transports/StdioTransport.js

@@ -0,0 +1,307 @@
+"use strict";
+/**
+ * StdioTransport - MCP transport over stdio (stdin/stdout)
+ *
+ * This is the primary transport for MCP servers that are launched as
+ * child processes and communicate via JSON-RPC over stdin/stdout.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdioTransport = void 0;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+class StdioTransport extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.process = null;
+        this.messageHandler = null;
+        this.closeHandler = null;
+        this.errorHandler = null;
+        this.pendingRequests = new Map();
+        this.buffer = '';
+        this.stderrBuffer = ''; // Capture stderr for better error messages
+        this.connected = false;
+        this.requestId = 0;
+        this.config = config;
+    }
+    /**
+     * Connect to the MCP server by spawning the process
+     */
+    async connect() {
+        if (this.connected || this.process) {
+            throw new Error('Already connected');
+        }
+        const { command, args = [], env, cwd } = this.config;
+        if (!command) {
+            throw new Error('No command specified for stdio transport');
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.cleanup();
+                reject(new Error(`Connection timeout: server did not respond within ${this.config.connectionTimeout || 30000}ms`));
+            }, this.config.connectionTimeout || 30000);
+            try {
+                // Merge environment variables
+                const processEnv = {
+                    ...process.env,
+                    ...env,
+                };
+                console.log(`[MCP StdioTransport] Spawning: ${command} ${args.join(' ')}`);
+                this.process = (0, child_process_1.spawn)(command, args, {
+                    cwd: cwd || process.cwd(),
+                    env: processEnv,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    shell: false,
+                });
+                // Handle stdout (JSON-RPC messages from server)
+                this.process.stdout?.on('data', (data) => {
+                    this.handleData(data);
+                });
+                // Handle stderr (logging/errors from server)
+                this.process.stderr?.on('data', (data) => {
+                    const text = data.toString();
+                    console.log(`[MCP StdioTransport] Server stderr: ${text}`);
+                    // Capture stderr for better error messages (limit to last 1000 chars)
+                    this.stderrBuffer += text;
+                    if (this.stderrBuffer.length > 1000) {
+                        this.stderrBuffer = this.stderrBuffer.slice(-1000);
+                    }
+                });
+                // Handle process errors
+                this.process.on('error', (error) => {
+                    clearTimeout(timeout);
+                    console.error(`[MCP StdioTransport] Process error:`, error);
+                    this.errorHandler?.(error);
+                    if (!this.connected) {
+                        reject(error);
+                    }
+                    this.cleanup();
+                });
+                // Handle process exit
+                this.process.on('exit', (code, signal) => {
+                    clearTimeout(timeout);
+                    // Build error message including stderr output for better diagnostics
+                    let message = `Process exited with code ${code}`;
+                    if (signal) {
+                        message += `, signal ${signal}`;
+                    }
+                    // Include stderr in error message if there was an error exit
+                    if (code !== 0 && this.stderrBuffer.trim()) {
+                        const stderrSnippet = this.stderrBuffer.trim().slice(-500); // Last 500 chars
+                        message += `: ${stderrSnippet}`;
+                    }
+                    console.log(`[MCP StdioTransport] ${message}`);
+                    if (!this.connected) {
+                        reject(new Error(message));
+                    }
+                    else {
+                        this.closeHandler?.(code !== 0 ? new Error(message) : undefined);
+                    }
+                    this.cleanup();
+                });
+                // Handle process close
+                this.process.on('close', (code) => {
+                    if (this.connected) {
+                        let message = `Process closed with code ${code}`;
+                        if (code !== 0 && this.stderrBuffer.trim()) {
+                            const stderrSnippet = this.stderrBuffer.trim().slice(-500);
+                            message += `: ${stderrSnippet}`;
+                        }
+                        this.closeHandler?.(code !== 0 ? new Error(message) : undefined);
+                    }
+                    this.cleanup();
+                });
+                // Mark as connected once process is spawned
+                // The actual MCP handshake will be done by MCPServerConnection
+                this.connected = true;
+                clearTimeout(timeout);
+                console.log(`[MCP StdioTransport] Process spawned successfully`);
+                resolve();
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                console.error(`[MCP StdioTransport] Failed to spawn process:`, error);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Disconnect from the MCP server
+     */
+    async disconnect() {
+        if (!this.process) {
+            return;
+        }
+        console.log(`[MCP StdioTransport] Disconnecting...`);
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Transport disconnected'));
+        }
+        this.pendingRequests.clear();
+        // Try graceful shutdown first
+        if (this.process.stdin?.writable) {
+            try {
+                this.process.stdin.end();
+            }
+            catch {
+                // Ignore errors during shutdown
+            }
+        }
+        // Give process time to exit gracefully
+        await new Promise((resolve) => {
+            const forceKillTimeout = setTimeout(() => {
+                if (this.process && !this.process.killed) {
+                    console.log(`[MCP StdioTransport] Force killing process`);
+                    this.process.kill('SIGKILL');
+                }
+                resolve();
+            }, 5000);
+            if (this.process) {
+                this.process.once('exit', () => {
+                    clearTimeout(forceKillTimeout);
+                    resolve();
+                });
+                // Send SIGTERM first
+                this.process.kill('SIGTERM');
+            }
+            else {
+                clearTimeout(forceKillTimeout);
+                resolve();
+            }
+        });
+        this.cleanup();
+    }
+    /**
+     * Send a JSON-RPC request and wait for response
+     */
+    async sendRequest(method, params) {
+        if (!this.connected || !this.process?.stdin?.writable) {
+            throw new Error('Not connected');
+        }
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout for method: ${method}`));
+            }, this.config.requestTimeout || 60000);
+            this.pendingRequests.set(id, { resolve, reject, timeout });
+            try {
+                const message = JSON.stringify(request) + '\n';
+                this.process.stdin.write(message);
+            }
+            catch (error) {
+                this.pendingRequests.delete(id);
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Send a JSON-RPC message (request or notification)
+     */
+    async send(message) {
+        if (!this.connected || !this.process?.stdin?.writable) {
+            throw new Error('Not connected');
+        }
+        try {
+            const data = JSON.stringify(message) + '\n';
+            this.process.stdin.write(data);
+        }
+        catch (error) {
+            throw new Error(`Failed to send message: ${error}`);
+        }
+    }
+    /**
+     * Register message handler
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Register close handler
+     */
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    /**
+     * Register error handler
+     */
+    onError(handler) {
+        this.errorHandler = handler;
+    }
+    /**
+     * Check if transport is connected
+     */
+    isConnected() {
+        return this.connected && !!this.process && !this.process.killed;
+    }
+    /**
+     * Handle incoming data from stdout
+     */
+    handleData(data) {
+        this.buffer += data.toString();
+        // Process complete lines (JSON-RPC messages are newline-delimited)
+        let newlineIndex;
+        while ((newlineIndex = this.buffer.indexOf('\n')) !== -1) {
+            const line = this.buffer.slice(0, newlineIndex).trim();
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            if (line) {
+                try {
+                    const message = JSON.parse(line);
+                    this.handleMessage(message);
+                }
+                catch (error) {
+                    console.error(`[MCP StdioTransport] Failed to parse message: ${line}`);
+                }
+            }
+        }
+    }
+    /**
+     * Handle a parsed JSON-RPC message
+     */
+    handleMessage(message) {
+        // Check if this is a response to a pending request
+        if ('id' in message && message.id !== null) {
+            const pending = this.pendingRequests.get(message.id);
+            if (pending) {
+                this.pendingRequests.delete(message.id);
+                clearTimeout(pending.timeout);
+                if ('error' in message && message.error) {
+                    pending.reject(new Error(message.error.message || 'Unknown error'));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+                return;
+            }
+        }
+        // Otherwise, pass to message handler (notifications)
+        this.messageHandler?.(message);
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        this.connected = false;
+        this.buffer = '';
+        this.stderrBuffer = '';
+        // Clear all pending requests
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+        }
+        this.pendingRequests.clear();
+        if (this.process) {
+            this.process.removeAllListeners();
+            this.process.stdout?.removeAllListeners();
+            this.process.stderr?.removeAllListeners();
+            this.process = null;
+        }
+    }
+}
+exports.StdioTransport = StdioTransport;