cowork-os 0.3.21

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

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * WebSocket Control Plane Client Management
+ *
+ * Handles client connection state, authentication, and tracking.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientRegistry = exports.ControlPlaneClient = void 0;
+const ws_1 = require("ws");
+const crypto_1 = require("crypto");
+const protocol_1 = require("./protocol");
+/**
+ * Control plane client wrapper
+ */
+class ControlPlaneClient {
+    constructor(socket, remoteAddress, userAgent, origin) {
+        this.eventSeq = 0;
+        this.info = {
+            id: (0, crypto_1.randomUUID)(),
+            socket,
+            remoteAddress,
+            userAgent,
+            origin,
+            authState: 'pending',
+            scopes: [],
+            connectedAt: Date.now(),
+            lastActivityAt: Date.now(),
+            lastHeartbeatAt: Date.now(),
+            authNonce: (0, crypto_1.randomUUID)(),
+            role: 'operator', // Default role
+        };
+    }
+    /**
+     * Get the client ID
+     */
+    get id() {
+        return this.info.id;
+    }
+    /**
+     * Check if client is authenticated
+     */
+    get isAuthenticated() {
+        return this.info.authState === 'authenticated';
+    }
+    /**
+     * Check if client is connected
+     */
+    get isConnected() {
+        return this.info.socket.readyState === ws_1.WebSocket.OPEN;
+    }
+    /**
+     * Check if client has a specific scope
+     */
+    hasScope(scope) {
+        return this.info.scopes.includes('admin') || this.info.scopes.includes(scope);
+    }
+    /**
+     * Check if client is a node (mobile companion)
+     */
+    get isNode() {
+        return this.info.role === 'node';
+    }
+    /**
+     * Mark client as authenticated with given scopes
+     */
+    authenticate(scopes, deviceName) {
+        this.info.authState = 'authenticated';
+        this.info.scopes = scopes;
+        this.info.deviceName = deviceName;
+        this.updateActivity();
+    }
+    /**
+     * Authenticate as a node with capabilities
+     */
+    authenticateAsNode(options) {
+        this.info.authState = 'authenticated';
+        this.info.role = 'node';
+        this.info.scopes = ['read']; // Nodes have limited scope
+        this.info.deviceName = options.deviceName;
+        this.info.platform = options.platform;
+        this.info.version = options.version;
+        this.info.deviceId = options.deviceId;
+        this.info.modelIdentifier = options.modelIdentifier;
+        this.info.capabilities = options.capabilities;
+        this.info.commands = options.commands;
+        this.info.permissions = options.permissions;
+        this.info.isForeground = true; // Assume foreground on initial connect
+        this.updateActivity();
+    }
+    /**
+     * Update node capabilities (e.g., when permissions change)
+     */
+    updateCapabilities(capabilities, commands, permissions) {
+        if (this.info.role !== 'node')
+            return;
+        this.info.capabilities = capabilities;
+        this.info.commands = commands;
+        this.info.permissions = permissions;
+        this.updateActivity();
+    }
+    /**
+     * Update node foreground state
+     */
+    setForeground(isForeground) {
+        if (this.info.role !== 'node')
+            return;
+        this.info.isForeground = isForeground;
+        this.updateActivity();
+    }
+    /**
+     * Get node info (for node clients only)
+     */
+    getNodeInfo() {
+        if (this.info.role !== 'node')
+            return null;
+        return {
+            id: this.info.id,
+            displayName: this.info.deviceName || 'Unknown Node',
+            platform: this.info.platform || 'ios',
+            version: this.info.version || '0.0.0',
+            deviceId: this.info.deviceId,
+            modelIdentifier: this.info.modelIdentifier,
+            capabilities: this.info.capabilities || [],
+            commands: this.info.commands || [],
+            permissions: this.info.permissions || {},
+            connectedAt: this.info.connectedAt,
+            lastActivityAt: this.info.lastActivityAt,
+            isForeground: this.info.isForeground,
+        };
+    }
+    /**
+     * Mark client as rejected
+     */
+    reject() {
+        this.info.authState = 'rejected';
+    }
+    /**
+     * Update last activity timestamp
+     */
+    updateActivity() {
+        this.info.lastActivityAt = Date.now();
+    }
+    /**
+     * Update heartbeat timestamp
+     */
+    updateHeartbeat() {
+        this.info.lastHeartbeatAt = Date.now();
+        this.updateActivity();
+    }
+    /**
+     * Send a frame to the client
+     */
+    send(frame) {
+        if (!this.isConnected) {
+            return false;
+        }
+        try {
+            this.info.socket.send((0, protocol_1.serializeFrame)(frame));
+            return true;
+        }
+        catch (error) {
+            console.error(`[ControlPlane Client ${this.id}] Send error:`, error);
+            return false;
+        }
+    }
+    /**
+     * Send an event to the client
+     */
+    sendEvent(event, payload, stateVersion) {
+        const seq = this.eventSeq++;
+        const frame = (0, protocol_1.createEventFrame)(event, payload, seq, stateVersion);
+        return this.send(frame);
+    }
+    /**
+     * Send the initial connection challenge
+     */
+    sendChallenge() {
+        this.sendEvent(protocol_1.Events.CONNECT_CHALLENGE, {
+            nonce: this.info.authNonce,
+            ts: Date.now(),
+        });
+    }
+    /**
+     * Close the client connection
+     */
+    close(code, reason) {
+        if (this.isConnected) {
+            this.info.socket.close(code || 1000, reason || 'Connection closed');
+        }
+    }
+    /**
+     * Get client summary for status reports
+     */
+    getSummary() {
+        return {
+            id: this.info.id,
+            remoteAddress: this.info.remoteAddress,
+            deviceName: this.info.deviceName,
+            authenticated: this.isAuthenticated,
+            scopes: this.info.scopes,
+            connectedAt: this.info.connectedAt,
+            lastActivityAt: this.info.lastActivityAt,
+            role: this.info.role,
+            platform: this.info.platform,
+            capabilities: this.info.capabilities,
+        };
+    }
+}
+exports.ControlPlaneClient = ControlPlaneClient;
+/**
+ * Client registry for managing multiple clients
+ */
+class ClientRegistry {
+    constructor() {
+        this.clients = new Map();
+    }
+    /**
+     * Add a client to the registry
+     */
+    add(client) {
+        this.clients.set(client.id, client);
+    }
+    /**
+     * Remove a client from the registry
+     */
+    remove(clientId) {
+        return this.clients.delete(clientId);
+    }
+    /**
+     * Get a client by ID
+     */
+    get(clientId) {
+        return this.clients.get(clientId);
+    }
+    /**
+     * Get all clients
+     */
+    getAll() {
+        return Array.from(this.clients.values());
+    }
+    /**
+     * Get all authenticated clients
+     */
+    getAuthenticated() {
+        return this.getAll().filter((c) => c.isAuthenticated);
+    }
+    /**
+     * Get connected client count
+     */
+    get count() {
+        return this.clients.size;
+    }
+    /**
+     * Get authenticated client count
+     */
+    get authenticatedCount() {
+        return this.getAuthenticated().length;
+    }
+    /**
+     * Broadcast an event to all authenticated clients
+     */
+    broadcast(event, payload, stateVersion) {
+        let sent = 0;
+        for (const client of this.getAuthenticated()) {
+            if (client.sendEvent(event, payload, stateVersion)) {
+                sent++;
+            }
+        }
+        return sent;
+    }
+    /**
+     * Close all client connections
+     */
+    closeAll(code, reason) {
+        for (const client of this.getAll()) {
+            client.close(code, reason);
+        }
+        this.clients.clear();
+    }
+    /**
+     * Clean up disconnected clients
+     */
+    cleanup() {
+        let removed = 0;
+        for (const [id, client] of this.clients) {
+            if (!client.isConnected) {
+                this.clients.delete(id);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Get status summary
+     */
+    getStatus() {
+        const all = this.getAll();
+        return {
+            total: all.length,
+            authenticated: all.filter((c) => c.isAuthenticated).length,
+            pending: all.filter((c) => c.info.authState === 'pending').length,
+            clients: all.map((c) => c.getSummary()),
+        };
+    }
+    // ===== Node (Mobile Companion) Methods =====
+    /**
+     * Get all connected nodes (mobile companions)
+     */
+    getNodes() {
+        return this.getAuthenticated().filter((c) => c.isNode);
+    }
+    /**
+     * Get node count
+     */
+    get nodeCount() {
+        return this.getNodes().length;
+    }
+    /**
+     * Get a node by ID or display name
+     */
+    getNodeByIdOrName(idOrName) {
+        const nodes = this.getNodes();
+        // Try exact ID match first
+        const byId = nodes.find((n) => n.id === idOrName);
+        if (byId)
+            return byId;
+        // Then try display name match (case-insensitive)
+        const lowerName = idOrName.toLowerCase();
+        return nodes.find((n) => n.info.deviceName?.toLowerCase() === lowerName);
+    }
+    /**
+     * Get all node info summaries
+     */
+    getNodeInfoList() {
+        return this.getNodes()
+            .map((n) => n.getNodeInfo())
+            .filter((info) => info !== null);
+    }
+    /**
+     * Broadcast an event to all connected nodes
+     */
+    broadcastToNodes(event, payload, stateVersion) {
+        let sent = 0;
+        for (const client of this.getNodes()) {
+            if (client.sendEvent(event, payload, stateVersion)) {
+                sent++;
+            }
+        }
+        return sent;
+    }
+    /**
+     * Broadcast an event to all non-node (operator) clients
+     */
+    broadcastToOperators(event, payload, stateVersion) {
+        let sent = 0;
+        for (const client of this.getAuthenticated()) {
+            if (!client.isNode && client.sendEvent(event, payload, stateVersion)) {
+                sent++;
+            }
+        }
+        return sent;
+    }
+}
+exports.ClientRegistry = ClientRegistry;