cowork-os 0.3.21

package/dist/electron/electron/control-plane/node-manager.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * Node Manager
+ *
+ * High-level interface for managing mobile companion nodes.
+ * Provides methods for listing, describing, and invoking commands on nodes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeManager = void 0;
+exports.getNodeManager = getNodeManager;
+exports.initNodeManager = initNodeManager;
+exports.shutdownNodeManager = shutdownNodeManager;
+const events_1 = require("events");
+const protocol_1 = require("./protocol");
+/**
+ * Node Manager class
+ *
+ * Provides high-level operations for mobile companion nodes.
+ */
+class NodeManager extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.server = null;
+        this.eventHandlersRegistered = false;
+    }
+    /**
+     * Attach to a Control Plane server
+     */
+    attach(server) {
+        this.server = server;
+        this.setupEventHandlers();
+    }
+    /**
+     * Detach from the Control Plane server
+     */
+    detach() {
+        this.server = null;
+        this.eventHandlersRegistered = false;
+    }
+    /**
+     * Check if attached to a server
+     */
+    get isAttached() {
+        return this.server !== null && this.server.isRunning;
+    }
+    /**
+     * Set up event handlers for node events
+     */
+    setupEventHandlers() {
+        if (this.eventHandlersRegistered || !this.server)
+            return;
+        // The server broadcasts events through the client registry
+        // We don't need to do anything special here since the server
+        // handles broadcasting node events to operators
+        this.eventHandlersRegistered = true;
+    }
+    /**
+     * Get all connected nodes
+     */
+    getNodes() {
+        if (!this.server)
+            return [];
+        return this.server.clients.getNodeInfoList();
+    }
+    /**
+     * Get node count
+     */
+    get nodeCount() {
+        if (!this.server)
+            return 0;
+        return this.server.clients.nodeCount;
+    }
+    /**
+     * Get a node by ID or display name
+     */
+    getNode(idOrName) {
+        if (!this.server)
+            return null;
+        const client = this.server.clients.getNodeByIdOrName(idOrName);
+        return client?.getNodeInfo() || null;
+    }
+    /**
+     * Check if a node exists
+     */
+    hasNode(idOrName) {
+        return this.getNode(idOrName) !== null;
+    }
+    /**
+     * Get nodes by capability
+     */
+    getNodesByCapability(capability) {
+        return this.getNodes().filter((n) => n.capabilities.includes(capability));
+    }
+    /**
+     * Get nodes by platform
+     */
+    getNodesByPlatform(platform) {
+        return this.getNodes().filter((n) => n.platform === platform);
+    }
+    /**
+     * Get nodes that support a specific command
+     */
+    getNodesByCommand(command) {
+        return this.getNodes().filter((n) => n.commands.includes(command));
+    }
+    /**
+     * Get the first available node (for single-node setups)
+     */
+    getDefaultNode() {
+        const nodes = this.getNodes();
+        return nodes.length > 0 ? nodes[0] : null;
+    }
+    /**
+     * Invoke a command on a node
+     */
+    async invoke(params) {
+        if (!this.server) {
+            return {
+                ok: false,
+                error: { code: 'SERVER_NOT_RUNNING', message: 'Control Plane server is not running' },
+            };
+        }
+        const { nodeId, command, params: commandParams, timeoutMs = 30000 } = params;
+        // Find the node
+        const client = this.server.clients.getNodeByIdOrName(nodeId);
+        if (!client) {
+            return {
+                ok: false,
+                error: { code: protocol_1.ErrorCodes.NODE_NOT_FOUND, message: `Node not found: ${nodeId}` },
+            };
+        }
+        const nodeInfo = client.getNodeInfo();
+        if (!nodeInfo) {
+            return {
+                ok: false,
+                error: { code: protocol_1.ErrorCodes.NODE_NOT_FOUND, message: `Node not found: ${nodeId}` },
+            };
+        }
+        // Check if node supports the command
+        if (!nodeInfo.commands.includes(command)) {
+            return {
+                ok: false,
+                error: {
+                    code: protocol_1.ErrorCodes.NODE_COMMAND_FAILED,
+                    message: `Node does not support command: ${command}`,
+                },
+            };
+        }
+        // Check foreground requirement for certain commands
+        const foregroundRequiredCommands = ['camera.snap', 'camera.clip', 'screen.record'];
+        if (!nodeInfo.isForeground && foregroundRequiredCommands.includes(command)) {
+            return {
+                ok: false,
+                error: {
+                    code: protocol_1.ErrorCodes.NODE_BACKGROUND_UNAVAILABLE,
+                    message: 'Node app must be in foreground for this command',
+                },
+            };
+        }
+        // Forward to the server's internal method
+        try {
+            const result = await this.server.invokeNodeCommand(client, command, commandParams, timeoutMs);
+            return result;
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: {
+                    code: protocol_1.ErrorCodes.NODE_COMMAND_FAILED,
+                    message: error.message || 'Command invocation failed',
+                },
+            };
+        }
+    }
+    /**
+     * Take a photo using a node's camera
+     */
+    async cameraSnap(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'camera.snap',
+            params: options,
+        });
+    }
+    /**
+     * Record video using a node's camera
+     */
+    async cameraClip(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'camera.clip',
+            params: options,
+        });
+    }
+    /**
+     * Get location from a node
+     */
+    async locationGet(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'location.get',
+            params: options,
+        });
+    }
+    /**
+     * Record screen from a node
+     */
+    async screenRecord(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'screen.record',
+            params: options,
+        });
+    }
+    /**
+     * Send SMS from a node (Android only)
+     */
+    async smsSend(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'sms.send',
+            params: options,
+        });
+    }
+    /**
+     * Send system notification to a node
+     */
+    async systemNotify(nodeId, options) {
+        return this.invoke({
+            nodeId,
+            command: 'system.notify',
+            params: options,
+        });
+    }
+}
+exports.NodeManager = NodeManager;
+// Singleton instance
+let nodeManagerInstance = null;
+/**
+ * Get the global NodeManager instance
+ */
+function getNodeManager() {
+    if (!nodeManagerInstance) {
+        nodeManagerInstance = new NodeManager();
+    }
+    return nodeManagerInstance;
+}
+/**
+ * Initialize the NodeManager with a Control Plane server
+ */
+function initNodeManager(server) {
+    const manager = getNodeManager();
+    manager.attach(server);
+    return manager;
+}
+/**
+ * Shutdown the NodeManager
+ */
+function shutdownNodeManager() {
+    if (nodeManagerInstance) {
+        nodeManagerInstance.detach();
+        nodeManagerInstance = null;
+    }
+}

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

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * WebSocket Control Plane Protocol
+ *
+ * Defines the frame types for communication over the WebSocket control plane.
+ * Uses a tagged union pattern for type-safe message handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Methods = exports.Events = exports.ErrorCodes = exports.FrameType = void 0;
+exports.parseFrame = parseFrame;
+exports.serializeFrame = serializeFrame;
+exports.createRequestFrame = createRequestFrame;
+exports.createResponseFrame = createResponseFrame;
+exports.createErrorResponse = createErrorResponse;
+exports.createEventFrame = createEventFrame;
+const crypto_1 = require("crypto");
+/**
+ * Frame type discriminator
+ */
+exports.FrameType = {
+    Request: 'req',
+    Response: 'res',
+    Event: 'event',
+};
+/**
+ * Error codes
+ */
+exports.ErrorCodes = {
+    // Connection errors
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    CONNECTION_CLOSED: 'CONNECTION_CLOSED',
+    HANDSHAKE_TIMEOUT: 'HANDSHAKE_TIMEOUT',
+    // Request errors
+    INVALID_FRAME: 'INVALID_FRAME',
+    UNKNOWN_METHOD: 'UNKNOWN_METHOD',
+    INVALID_PARAMS: 'INVALID_PARAMS',
+    METHOD_FAILED: 'METHOD_FAILED',
+    // Node errors (Mobile Companions)
+    NODE_NOT_FOUND: 'NODE_NOT_FOUND',
+    NODE_UNAVAILABLE: 'NODE_UNAVAILABLE',
+    NODE_TIMEOUT: 'NODE_TIMEOUT',
+    NODE_PERMISSION_DENIED: 'NODE_PERMISSION_DENIED',
+    NODE_COMMAND_FAILED: 'NODE_COMMAND_FAILED',
+    NODE_BACKGROUND_UNAVAILABLE: 'NODE_BACKGROUND_UNAVAILABLE',
+    // Internal errors
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+};
+/**
+ * Validate and parse a frame from JSON
+ *
+ * Note: String fields (id, method, event) are validated to be non-empty after trimming.
+ * This prevents whitespace-only values from being accepted.
+ */
+function parseFrame(data) {
+    try {
+        const parsed = JSON.parse(data);
+        // Check frame type
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const type = parsed.type;
+        if (type === exports.FrameType.Request) {
+            if (typeof parsed.id !== 'string' || !parsed.id.trim())
+                return null;
+            if (typeof parsed.method !== 'string' || !parsed.method.trim())
+                return null;
+            return parsed;
+        }
+        if (type === exports.FrameType.Response) {
+            if (typeof parsed.id !== 'string' || !parsed.id.trim())
+                return null;
+            if (typeof parsed.ok !== 'boolean')
+                return null;
+            return parsed;
+        }
+        if (type === exports.FrameType.Event) {
+            if (typeof parsed.event !== 'string' || !parsed.event.trim())
+                return null;
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Serialize a frame to JSON
+ */
+function serializeFrame(frame) {
+    return JSON.stringify(frame);
+}
+/**
+ * Create a request frame
+ */
+function createRequestFrame(method, params) {
+    return {
+        type: exports.FrameType.Request,
+        id: (0, crypto_1.randomUUID)(),
+        method,
+        params,
+    };
+}
+/**
+ * Create a success response frame
+ */
+function createResponseFrame(requestId, payload) {
+    return {
+        type: exports.FrameType.Response,
+        id: requestId,
+        ok: true,
+        payload,
+    };
+}
+/**
+ * Create an error response frame
+ */
+function createErrorResponse(requestId, code, message, details) {
+    return {
+        type: exports.FrameType.Response,
+        id: requestId,
+        ok: false,
+        error: { code, message, details },
+    };
+}
+/**
+ * Create an event frame
+ */
+function createEventFrame(event, payload, seq, stateVersion) {
+    const frame = {
+        type: exports.FrameType.Event,
+        event,
+    };
+    if (payload !== undefined)
+        frame.payload = payload;
+    if (seq !== undefined)
+        frame.seq = seq;
+    if (stateVersion !== undefined)
+        frame.stateVersion = stateVersion;
+    return frame;
+}
+/**
+ * Standard event names
+ */
+exports.Events = {
+    // Connection events
+    CONNECT_CHALLENGE: 'connect.challenge',
+    CONNECT_SUCCESS: 'connect.success',
+    // Task events
+    TASK_CREATED: 'task.created',
+    TASK_UPDATED: 'task.updated',
+    TASK_COMPLETED: 'task.completed',
+    TASK_FAILED: 'task.failed',
+    TASK_EVENT: 'task.event',
+    // Node events (Mobile Companions)
+    NODE_CONNECTED: 'node.connected',
+    NODE_DISCONNECTED: 'node.disconnected',
+    NODE_CAPABILITIES_CHANGED: 'node.capabilities_changed',
+    NODE_EVENT: 'node.event',
+    // System events
+    HEARTBEAT: 'heartbeat',
+    CONFIG_CHANGED: 'config.changed',
+    SHUTDOWN: 'shutdown',
+};
+/**
+ * Standard method names
+ */
+exports.Methods = {
+    // Connection
+    CONNECT: 'connect',
+    PING: 'ping',
+    HEALTH: 'health',
+    // Task operations
+    TASK_CREATE: 'task.create',
+    TASK_GET: 'task.get',
+    TASK_LIST: 'task.list',
+    TASK_CANCEL: 'task.cancel',
+    TASK_SEND_MESSAGE: 'task.sendMessage',
+    // Agent operations
+    AGENT_WAKE: 'agent.wake',
+    AGENT_SEND: 'agent.send',
+    // Node operations (Mobile Companions)
+    NODE_LIST: 'node.list',
+    NODE_DESCRIBE: 'node.describe',
+    NODE_INVOKE: 'node.invoke',
+    NODE_EVENT: 'node.event',
+    // System operations
+    STATUS: 'status',
+    CONFIG_GET: 'config.get',
+    CONFIG_SET: 'config.set',
+    // Workspace operations
+    WORKSPACE_LIST: 'workspace.list',
+    WORKSPACE_GET: 'workspace.get',
+};