cowork-os 0.3.21

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

@@ -0,0 +1,329 @@
+"use strict";
+/**
+ * WebSocketTransport - MCP transport over WebSocket
+ *
+ * Provides full-duplex bidirectional communication for real-time
+ * MCP server interactions. Supports automatic reconnection and
+ * ping/pong keepalive.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketTransport = void 0;
+const events_1 = require("events");
+const ws_1 = __importDefault(require("ws"));
+class WebSocketTransport extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.ws = null;
+        this.messageHandler = null;
+        this.closeHandler = null;
+        this.errorHandler = null;
+        this.pendingRequests = new Map();
+        this.connected = false;
+        this.requestId = 0;
+        this.pingInterval = null;
+        this.pongTimeout = null;
+        // Ping/pong settings
+        this.PING_INTERVAL = 30000; // 30 seconds
+        this.PONG_TIMEOUT = 10000; // 10 seconds
+        this.config = config;
+    }
+    /**
+     * Connect to the MCP server via WebSocket
+     */
+    async connect() {
+        if (this.connected || this.ws) {
+            throw new Error('Already connected');
+        }
+        const { url } = this.config;
+        if (!url) {
+            throw new Error('No URL specified for WebSocket 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 {
+                // Convert http(s) URL to ws(s) if needed
+                const wsUrl = this.buildWebSocketUrl(url);
+                console.log(`[MCP WebSocketTransport] Connecting to: ${wsUrl}`);
+                // Build headers with auth
+                const headers = {
+                    ...this.config.headers,
+                };
+                this.addAuthHeaders(headers);
+                // Create WebSocket connection
+                this.ws = new ws_1.default(wsUrl, {
+                    headers,
+                    handshakeTimeout: this.config.connectionTimeout || 30000,
+                });
+                this.ws.on('open', () => {
+                    clearTimeout(timeout);
+                    this.connected = true;
+                    console.log(`[MCP WebSocketTransport] Connected successfully`);
+                    // Start ping/pong keepalive
+                    this.startPingPong();
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data.toString());
+                });
+                this.ws.on('error', (error) => {
+                    console.error(`[MCP WebSocketTransport] WebSocket error:`, error);
+                    this.errorHandler?.(error);
+                    if (!this.connected) {
+                        clearTimeout(timeout);
+                        reject(error);
+                    }
+                });
+                this.ws.on('close', (code, reason) => {
+                    const message = `WebSocket closed: code=${code}, reason=${reason?.toString() || 'unknown'}`;
+                    console.log(`[MCP WebSocketTransport] ${message}`);
+                    if (this.connected) {
+                        this.closeHandler?.(code !== 1000 ? new Error(message) : undefined);
+                    }
+                    else if (!this.connected) {
+                        clearTimeout(timeout);
+                        reject(new Error(message));
+                    }
+                    this.cleanup();
+                });
+                this.ws.on('pong', () => {
+                    // Clear pong timeout - connection is alive
+                    if (this.pongTimeout) {
+                        clearTimeout(this.pongTimeout);
+                        this.pongTimeout = null;
+                    }
+                });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                console.error(`[MCP WebSocketTransport] Failed to connect:`, error);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Disconnect from the MCP server
+     */
+    async disconnect() {
+        console.log(`[MCP WebSocketTransport] Disconnecting...`);
+        // Stop ping/pong
+        this.stopPingPong();
+        // Reject all pending requests
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Transport disconnected'));
+        }
+        this.pendingRequests.clear();
+        // Close WebSocket gracefully
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            return new Promise((resolve) => {
+                const forceCloseTimeout = setTimeout(() => {
+                    if (this.ws) {
+                        this.ws.terminate();
+                    }
+                    this.cleanup();
+                    resolve();
+                }, 5000);
+                this.ws.once('close', () => {
+                    clearTimeout(forceCloseTimeout);
+                    this.cleanup();
+                    resolve();
+                });
+                this.ws.close(1000, 'Client disconnect');
+            });
+        }
+        this.cleanup();
+    }
+    /**
+     * Send a JSON-RPC request and wait for response
+     */
+    async sendRequest(method, params) {
+        if (!this.connected || !this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            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 {
+                this.ws.send(JSON.stringify(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 || !this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            throw new Error('Not connected');
+        }
+        try {
+            this.ws.send(JSON.stringify(message));
+        }
+        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.ws?.readyState === ws_1.default.OPEN;
+    }
+    /**
+     * Handle incoming WebSocket message
+     */
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            // 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);
+        }
+        catch (error) {
+            console.error(`[MCP WebSocketTransport] Failed to parse message: ${data}`);
+        }
+    }
+    /**
+     * Convert HTTP URL to WebSocket URL
+     */
+    buildWebSocketUrl(url) {
+        const parsed = new URL(url);
+        // Convert protocol
+        if (parsed.protocol === 'http:') {
+            parsed.protocol = 'ws:';
+        }
+        else if (parsed.protocol === 'https:') {
+            parsed.protocol = 'wss:';
+        }
+        // Append /ws path if not already present
+        if (!parsed.pathname.includes('/ws')) {
+            parsed.pathname = parsed.pathname.replace(/\/$/, '') + '/ws';
+        }
+        return parsed.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;
+        }
+    }
+    /**
+     * Start ping/pong keepalive
+     */
+    startPingPong() {
+        this.pingInterval = setInterval(() => {
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                // Set pong timeout - if we don't get pong, connection is dead
+                this.pongTimeout = setTimeout(() => {
+                    console.warn(`[MCP WebSocketTransport] Pong timeout - connection may be dead`);
+                    this.errorHandler?.(new Error('WebSocket ping timeout'));
+                    this.ws?.terminate();
+                }, this.PONG_TIMEOUT);
+                // Send ping
+                this.ws.ping();
+            }
+        }, this.PING_INTERVAL);
+    }
+    /**
+     * Stop ping/pong keepalive
+     */
+    stopPingPong() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        if (this.pongTimeout) {
+            clearTimeout(this.pongTimeout);
+            this.pongTimeout = null;
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        this.connected = false;
+        this.stopPingPong();
+        // Clear all pending requests
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+        }
+        this.pendingRequests.clear();
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws = null;
+        }
+    }
+}
+exports.WebSocketTransport = WebSocketTransport;

package/dist/electron/electron/mcp/host/MCPHostServer.js

@@ -0,0 +1,354 @@
+"use strict";
+/**
+ * MCPHostServer - Exposes CoWork's tools as an MCP server
+ *
+ * This allows external clients (like Claude Code, other AI agents, or MCP clients)
+ * to connect to CoWork and use its tools via the MCP protocol over stdio.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPHostServer = void 0;
+const events_1 = require("events");
+const readline = __importStar(require("readline"));
+const types_1 = require("../types");
+// Protocol version we support
+const PROTOCOL_VERSION = '2024-11-05';
+// Server info
+const SERVER_INFO = {
+    name: 'CoWork-OS',
+    version: '1.0.0',
+    protocolVersion: PROTOCOL_VERSION,
+    capabilities: {
+        tools: {
+            listChanged: false,
+        },
+    },
+};
+class MCPHostServer extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.running = false;
+        this.initialized = false;
+        this.toolProvider = null;
+        this.rl = null;
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!MCPHostServer.instance) {
+            MCPHostServer.instance = new MCPHostServer();
+        }
+        return MCPHostServer.instance;
+    }
+    /**
+     * Set the tool provider (typically ToolRegistry)
+     */
+    setToolProvider(provider) {
+        this.toolProvider = provider;
+    }
+    /**
+     * Start the MCP host server on stdio
+     */
+    async startStdio() {
+        if (this.running) {
+            console.log('[MCPHostServer] Already running');
+            return;
+        }
+        if (!this.toolProvider) {
+            throw new Error('Tool provider not set');
+        }
+        console.log('[MCPHostServer] Starting stdio server...');
+        this.running = true;
+        this.initialized = false;
+        // Create readline interface for reading from stdin
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false,
+        });
+        // Listen for lines (JSON-RPC messages)
+        this.rl.on('line', (line) => {
+            this.handleLine(line);
+        });
+        this.rl.on('close', () => {
+            console.log('[MCPHostServer] Stdin closed');
+            this.stop();
+        });
+        console.log('[MCPHostServer] Listening on stdio');
+        this.emit('started');
+    }
+    /**
+     * Stop the MCP host server
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        console.log('[MCPHostServer] Stopping...');
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+        this.running = false;
+        this.initialized = false;
+        this.emit('stopped');
+        console.log('[MCPHostServer] Stopped');
+    }
+    /**
+     * Check if the server is running
+     */
+    isRunning() {
+        return this.running;
+    }
+    /**
+     * Check if a tool provider has been set
+     */
+    hasToolProvider() {
+        return this.toolProvider !== null;
+    }
+    /**
+     * Handle an incoming line (JSON-RPC message)
+     */
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            const message = JSON.parse(trimmed);
+            this.handleMessage(message);
+        }
+        catch (error) {
+            console.error('[MCPHostServer] Failed to parse message:', error);
+            this.sendError(null, types_1.MCP_ERROR_CODES.PARSE_ERROR, 'Parse error');
+        }
+    }
+    /**
+     * Handle a parsed JSON-RPC message
+     */
+    async handleMessage(message) {
+        // Check if it's a request (has id) or notification (no id)
+        if ('id' in message && message.id !== null) {
+            await this.handleRequest(message);
+        }
+        else if ('method' in message) {
+            await this.handleNotification(message);
+        }
+    }
+    /**
+     * Handle a JSON-RPC request
+     */
+    async handleRequest(request) {
+        const { id, method, params } = request;
+        try {
+            let result;
+            switch (method) {
+                case types_1.MCP_METHODS.INITIALIZE:
+                    result = this.handleInitialize(params);
+                    break;
+                case types_1.MCP_METHODS.TOOLS_LIST:
+                    this.requireInitialized();
+                    result = this.handleToolsList();
+                    break;
+                case types_1.MCP_METHODS.TOOLS_CALL:
+                    this.requireInitialized();
+                    result = await this.handleToolsCall(params);
+                    break;
+                case types_1.MCP_METHODS.SHUTDOWN:
+                    result = this.handleShutdown();
+                    break;
+                default:
+                    throw this.createError(types_1.MCP_ERROR_CODES.METHOD_NOT_FOUND, `Method not found: ${method}`);
+            }
+            this.sendResult(id, result);
+        }
+        catch (error) {
+            if (error.code !== undefined) {
+                this.sendError(id, error.code, error.message, error.data);
+            }
+            else {
+                this.sendError(id, types_1.MCP_ERROR_CODES.INTERNAL_ERROR, error.message);
+            }
+        }
+    }
+    /**
+     * Handle a JSON-RPC notification
+     */
+    async handleNotification(notification) {
+        const { method, params } = notification;
+        switch (method) {
+            case types_1.MCP_METHODS.INITIALIZED:
+                this.handleInitialized();
+                break;
+            default:
+                console.log(`[MCPHostServer] Unhandled notification: ${method}`);
+        }
+    }
+    /**
+     * Handle the initialize request
+     */
+    handleInitialize(params) {
+        if (this.initialized) {
+            throw this.createError(types_1.MCP_ERROR_CODES.INVALID_REQUEST, 'Already initialized');
+        }
+        console.log('[MCPHostServer] Initialize request from client:', params?.clientInfo);
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: SERVER_INFO.capabilities,
+            serverInfo: SERVER_INFO,
+        };
+    }
+    /**
+     * Handle the initialized notification
+     */
+    handleInitialized() {
+        console.log('[MCPHostServer] Client sent initialized notification');
+        this.initialized = true;
+        this.emit('initialized');
+    }
+    /**
+     * Handle tools/list request
+     */
+    handleToolsList() {
+        if (!this.toolProvider) {
+            return { tools: [] };
+        }
+        const tools = this.toolProvider.getTools();
+        console.log(`[MCPHostServer] Listing ${tools.length} tools`);
+        return { tools };
+    }
+    /**
+     * Handle tools/call request
+     */
+    async handleToolsCall(params) {
+        if (!this.toolProvider) {
+            throw this.createError(types_1.MCP_ERROR_CODES.INTERNAL_ERROR, 'Tool provider not available');
+        }
+        const { name, arguments: args } = params || {};
+        if (!name) {
+            throw this.createError(types_1.MCP_ERROR_CODES.INVALID_PARAMS, 'Tool name is required');
+        }
+        console.log(`[MCPHostServer] Calling tool: ${name}`);
+        try {
+            const result = await this.toolProvider.executeTool(name, args || {});
+            // Format result as MCP content
+            if (typeof result === 'string') {
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            else if (result && typeof result === 'object') {
+                // Check if result is already in MCP format
+                if (result.content && Array.isArray(result.content)) {
+                    return result;
+                }
+                // Convert to text
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            else {
+                return {
+                    content: [{ type: 'text', text: String(result) }],
+                };
+            }
+        }
+        catch (error) {
+            console.error(`[MCPHostServer] Tool call failed:`, error);
+            return {
+                content: [{ type: 'text', text: `Error: ${error.message}` }],
+                isError: true,
+            };
+        }
+    }
+    /**
+     * Handle shutdown request
+     */
+    handleShutdown() {
+        console.log('[MCPHostServer] Shutdown request received');
+        // Schedule stop after response is sent
+        setImmediate(() => this.stop());
+        return {};
+    }
+    /**
+     * Send a successful result
+     */
+    sendResult(id, result) {
+        const response = {
+            jsonrpc: '2.0',
+            id,
+            result,
+        };
+        this.sendMessage(response);
+    }
+    /**
+     * Send an error response
+     */
+    sendError(id, code, message, data) {
+        const response = {
+            jsonrpc: '2.0',
+            id: id ?? 0,
+            error: {
+                code,
+                message,
+                data,
+            },
+        };
+        this.sendMessage(response);
+    }
+    /**
+     * Send a message to stdout
+     */
+    sendMessage(message) {
+        const json = JSON.stringify(message);
+        process.stdout.write(json + '\n');
+    }
+    /**
+     * Require that the server is initialized
+     */
+    requireInitialized() {
+        if (!this.initialized) {
+            throw this.createError(types_1.MCP_ERROR_CODES.SERVER_NOT_INITIALIZED, 'Server not initialized');
+        }
+    }
+    /**
+     * Create an error object
+     */
+    createError(code, message, data) {
+        return { code, message, data };
+    }
+}
+exports.MCPHostServer = MCPHostServer;
+MCPHostServer.instance = null;