cowork-os 0.3.21

package/dist/electron/electron/control-plane/remote-client.js

@@ -0,0 +1,437 @@
+"use strict";
+/**
+ * Remote Gateway Client
+ *
+ * WebSocket client for connecting to a remote Control Plane server.
+ * Supports SSH tunnel, Tailscale, or direct network connections.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteGatewayClient = void 0;
+exports.getRemoteGatewayClient = getRemoteGatewayClient;
+exports.initRemoteGatewayClient = initRemoteGatewayClient;
+exports.shutdownRemoteGatewayClient = shutdownRemoteGatewayClient;
+const ws_1 = __importDefault(require("ws"));
+const crypto_1 = __importDefault(require("crypto"));
+const protocol_1 = require("./protocol");
+/**
+ * Create a request frame with numeric ID for tracking
+ */
+function createRequest(id, method, params) {
+    return {
+        type: protocol_1.FrameType.Request,
+        id: String(id),
+        method,
+        params,
+    };
+}
+/**
+ * Remote Gateway Client
+ * Connects to a Control Plane server hosted elsewhere
+ */
+class RemoteGatewayClient {
+    constructor(options) {
+        this.ws = null;
+        this.state = 'disconnected';
+        this.clientId = null;
+        this.scopes = [];
+        this.connectedAt = null;
+        this.lastActivityAt = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.requestId = 0;
+        this.pendingRequests = new Map();
+        this.config = {
+            autoReconnect: true,
+            reconnectIntervalMs: 5000,
+            maxReconnectAttempts: 10,
+            deviceName: 'CoWork Remote Client',
+            ...options,
+        };
+    }
+    /**
+     * Get current connection status
+     */
+    getStatus() {
+        return {
+            state: this.state,
+            url: this.config.url,
+            connectedAt: this.connectedAt ?? undefined,
+            clientId: this.clientId ?? undefined,
+            scopes: this.scopes.length > 0 ? this.scopes : undefined,
+            error: this.state === 'error' ? 'Connection failed' : undefined,
+            reconnectAttempts: this.reconnectAttempts > 0 ? this.reconnectAttempts : undefined,
+            lastActivityAt: this.lastActivityAt ?? undefined,
+        };
+    }
+    /**
+     * Connect to the remote gateway
+     */
+    async connect() {
+        if (this.state === 'connected' || this.state === 'connecting' || this.state === 'authenticating') {
+            console.log('[RemoteGateway] Already connected or connecting');
+            return;
+        }
+        this.setState('connecting');
+        this.reconnectAttempts = 0;
+        return this.doConnect();
+    }
+    /**
+     * Disconnect from the remote gateway
+     */
+    disconnect() {
+        this.clearReconnectTimer();
+        this.clearHeartbeatTimer();
+        this.clearPendingRequests();
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            if (this.ws.readyState === ws_1.default.OPEN || this.ws.readyState === ws_1.default.CONNECTING) {
+                this.ws.close(1000, 'Client disconnecting');
+            }
+            this.ws = null;
+        }
+        this.clientId = null;
+        this.scopes = [];
+        this.connectedAt = null;
+        this.setState('disconnected');
+        console.log('[RemoteGateway] Disconnected');
+    }
+    /**
+     * Send a request to the remote gateway
+     */
+    async request(method, params, timeoutMs = 30000) {
+        if (this.state !== 'connected') {
+            throw new Error('Not connected to remote gateway');
+        }
+        const id = ++this.requestId;
+        const frame = createRequest(id, method, params);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Request timeout: ${method}`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+            });
+            this.send(frame);
+        });
+    }
+    /**
+     * Test connection to the remote gateway
+     */
+    async testConnection() {
+        const startTime = Date.now();
+        try {
+            // Create a temporary connection for testing
+            const testWs = new ws_1.default(this.config.url, {
+                handshakeTimeout: 10000,
+            });
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    testWs.close();
+                    resolve({ success: false, error: 'Connection timeout' });
+                }, 15000);
+                testWs.on('open', async () => {
+                    try {
+                        // Send connect request
+                        const connectFrame = createRequest(1, protocol_1.Methods.CONNECT, {
+                            token: this.config.token,
+                            deviceName: `${this.config.deviceName} (test)`,
+                        });
+                        testWs.send((0, protocol_1.serializeFrame)(connectFrame));
+                        // Wait for response
+                        testWs.once('message', (data) => {
+                            clearTimeout(timeout);
+                            const frame = (0, protocol_1.parseFrame)(data.toString());
+                            if (frame?.type === protocol_1.FrameType.Response) {
+                                const response = frame;
+                                if (!response.ok || response.error) {
+                                    testWs.close();
+                                    resolve({ success: false, error: response.error?.message || 'Authentication failed' });
+                                }
+                                else {
+                                    const latencyMs = Date.now() - startTime;
+                                    testWs.close();
+                                    resolve({ success: true, latencyMs });
+                                }
+                            }
+                            else {
+                                testWs.close();
+                                resolve({ success: false, error: 'Invalid response' });
+                            }
+                        });
+                    }
+                    catch (error) {
+                        clearTimeout(timeout);
+                        testWs.close();
+                        resolve({ success: false, error: error.message });
+                    }
+                });
+                testWs.on('error', (error) => {
+                    clearTimeout(timeout);
+                    resolve({ success: false, error: error.message });
+                });
+            });
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    // ===== Private Methods =====
+    async doConnect() {
+        return new Promise((resolve, reject) => {
+            try {
+                // Validate TLS fingerprint requirement
+                if (this.config.tlsFingerprint && !this.config.url.startsWith('wss://')) {
+                    const error = new Error('TLS fingerprint requires wss:// URL');
+                    this.setState('error', error.message);
+                    reject(error);
+                    return;
+                }
+                console.log(`[RemoteGateway] Connecting to ${this.config.url}`);
+                this.ws = new ws_1.default(this.config.url, {
+                    handshakeTimeout: 10000,
+                    // TODO: Add TLS fingerprint validation for wss:// connections
+                });
+                const connectionTimeout = setTimeout(() => {
+                    if (this.state === 'connecting') {
+                        this.ws?.close();
+                        const error = new Error('Connection timeout');
+                        this.setState('error', error.message);
+                        reject(error);
+                    }
+                }, 15000);
+                this.ws.on('open', () => {
+                    clearTimeout(connectionTimeout);
+                    console.log('[RemoteGateway] WebSocket connected, authenticating...');
+                    this.setState('authenticating');
+                    this.authenticate()
+                        .then(() => resolve())
+                        .catch((error) => {
+                        this.setState('error', error.message);
+                        reject(error);
+                    });
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data.toString());
+                });
+                this.ws.on('close', (code, reason) => {
+                    clearTimeout(connectionTimeout);
+                    console.log(`[RemoteGateway] Connection closed: ${code} - ${reason}`);
+                    this.handleDisconnect(code, reason.toString());
+                });
+                this.ws.on('error', (error) => {
+                    clearTimeout(connectionTimeout);
+                    console.error('[RemoteGateway] WebSocket error:', error);
+                    this.setState('error', error.message);
+                    reject(error);
+                });
+            }
+            catch (error) {
+                this.setState('error', error.message);
+                reject(error);
+            }
+        });
+    }
+    async authenticate() {
+        return new Promise((resolve, reject) => {
+            if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+                reject(new Error('WebSocket not connected'));
+                return;
+            }
+            const authTimeout = setTimeout(() => {
+                reject(new Error('Authentication timeout'));
+            }, 10000);
+            // Wait for challenge (or direct auth for simpler servers)
+            const handleAuthResponse = (data) => {
+                const frame = (0, protocol_1.parseFrame)(data.toString());
+                if (!frame)
+                    return;
+                if (frame.type === protocol_1.FrameType.Response) {
+                    const response = frame;
+                    clearTimeout(authTimeout);
+                    this.ws?.off('message', handleAuthResponse);
+                    if (!response.ok || response.error) {
+                        reject(new Error(response.error?.message || 'Authentication failed'));
+                    }
+                    else {
+                        const result = response.payload;
+                        this.clientId = result?.clientId || crypto_1.default.randomUUID();
+                        this.scopes = result?.scopes || ['admin'];
+                        this.connectedAt = Date.now();
+                        this.lastActivityAt = Date.now();
+                        this.setState('connected');
+                        this.startHeartbeat();
+                        console.log(`[RemoteGateway] Authenticated as ${this.clientId}`);
+                        resolve();
+                    }
+                }
+                else if (frame.type === protocol_1.FrameType.Event) {
+                    // Challenge or other event
+                    const event = frame;
+                    if (event.event === 'challenge') {
+                        // Send authentication
+                        this.sendAuthRequest();
+                    }
+                }
+            };
+            this.ws.on('message', handleAuthResponse);
+            // Send connect request immediately (server may or may not send challenge first)
+            this.sendAuthRequest();
+        });
+    }
+    sendAuthRequest() {
+        const frame = createRequest(++this.requestId, protocol_1.Methods.CONNECT, {
+            token: this.config.token,
+            deviceName: this.config.deviceName,
+        });
+        this.send(frame);
+    }
+    handleMessage(message) {
+        this.lastActivityAt = Date.now();
+        const frame = (0, protocol_1.parseFrame)(message);
+        if (!frame) {
+            console.warn('[RemoteGateway] Invalid frame received');
+            return;
+        }
+        switch (frame.type) {
+            case protocol_1.FrameType.Response: {
+                const response = frame;
+                const numericId = parseInt(response.id, 10);
+                const pending = this.pendingRequests.get(numericId);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    this.pendingRequests.delete(numericId);
+                    if (!response.ok || response.error) {
+                        pending.reject(new Error(response.error?.message || 'Request failed'));
+                        this.config.onResponse?.(numericId, null, response.error);
+                    }
+                    else {
+                        pending.resolve(response.payload);
+                        this.config.onResponse?.(numericId, response.payload, undefined);
+                    }
+                }
+                break;
+            }
+            case protocol_1.FrameType.Event: {
+                const event = frame;
+                console.log(`[RemoteGateway] Event: ${event.event}`);
+                this.config.onEvent?.(event.event, event.payload);
+                // Handle shutdown event
+                if (event.event === 'shutdown') {
+                    console.log('[RemoteGateway] Server shutting down');
+                    this.handleDisconnect(1001, 'Server shutdown');
+                }
+                break;
+            }
+        }
+    }
+    handleDisconnect(code, reason) {
+        this.clearHeartbeatTimer();
+        this.clearPendingRequests();
+        this.ws = null;
+        this.clientId = null;
+        this.scopes = [];
+        this.connectedAt = null;
+        // Attempt reconnection if configured
+        if (this.config.autoReconnect &&
+            code !== 1000 && // Normal close
+            code !== 4001 && // Auth failure
+            (this.config.maxReconnectAttempts === 0 ||
+                this.reconnectAttempts < (this.config.maxReconnectAttempts || 10))) {
+            this.scheduleReconnect();
+        }
+        else {
+            this.setState('disconnected');
+        }
+    }
+    scheduleReconnect() {
+        this.setState('reconnecting');
+        this.reconnectAttempts++;
+        const delay = Math.min((this.config.reconnectIntervalMs || 5000) * Math.pow(1.5, this.reconnectAttempts - 1), 30000 // Max 30 seconds
+        );
+        console.log(`[RemoteGateway] Reconnecting in ${Math.round(delay / 1000)}s (attempt ${this.reconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.doConnect().catch((error) => {
+                console.error('[RemoteGateway] Reconnection failed:', error);
+                if (this.config.maxReconnectAttempts !== 0 &&
+                    this.reconnectAttempts >= (this.config.maxReconnectAttempts || 10)) {
+                    this.setState('error', 'Max reconnection attempts reached');
+                }
+            });
+        }, delay);
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            if (this.state === 'connected' && this.ws?.readyState === ws_1.default.OPEN) {
+                this.request(protocol_1.Methods.PING).catch((error) => {
+                    console.warn('[RemoteGateway] Heartbeat failed:', error);
+                });
+            }
+        }, 30000);
+    }
+    send(frame) {
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send((0, protocol_1.serializeFrame)(frame));
+        }
+    }
+    setState(state, error) {
+        if (this.state !== state) {
+            this.state = state;
+            console.log(`[RemoteGateway] State: ${state}${error ? ` (${error})` : ''}`);
+            this.config.onStateChange?.(state, error);
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    clearHeartbeatTimer() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    clearPendingRequests() {
+        for (const [id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Connection closed'));
+        }
+        this.pendingRequests.clear();
+    }
+}
+exports.RemoteGatewayClient = RemoteGatewayClient;
+// Singleton instance for the app
+let remoteGatewayClient = null;
+/**
+ * Get or create the remote gateway client
+ */
+function getRemoteGatewayClient() {
+    return remoteGatewayClient;
+}
+/**
+ * Initialize the remote gateway client with config
+ */
+function initRemoteGatewayClient(options) {
+    if (remoteGatewayClient) {
+        remoteGatewayClient.disconnect();
+    }
+    remoteGatewayClient = new RemoteGatewayClient(options);
+    return remoteGatewayClient;
+}
+/**
+ * Shutdown the remote gateway client
+ */
+function shutdownRemoteGatewayClient() {
+    if (remoteGatewayClient) {
+        remoteGatewayClient.disconnect();
+        remoteGatewayClient = null;
+    }
+}