@mindexec/cli 0.2.152 → 0.2.154

package/server.js

@@ -2125,10 +2125,13 @@ app.get('/api/local-files/:id', async (req, res) => {
 const httpServer = createServer(app);
 const wss = new WebSocketServer({ noServer: true });
 const remoteFrameWss = new WebSocketServer({ noServer: true });
+const remoteInputWss = new WebSocketServer({ noServer: true });
 const wsClients = new Set();
 const remoteFrameClients = new Set();
+const remoteInputClients = new Set();
 const shellJobs = new Map();
 let remoteFrameClientSeq = 0;
+let remoteInputClientSeq = 0;
 const remoteFrameWsDiagnostics = {
     opened: 0,
     closed: 0,
@@ -2157,6 +2160,25 @@ const remoteFrameWsDiagnostics = {
     lastAutoStartStarted: 0,
     lastAutoStartSkipped: 0
 };
+const remoteInputWsDiagnostics = {
+    opened: 0,
+    closed: 0,
+    errors: 0,
+    messagesReceived: 0,
+    messagesInvalid: 0,
+    inputsQueued: 0,
+    inputsFailed: 0,
+    pointerMovesQueued: 0,
+    keyEventsQueued: 0,
+    lastOpenAt: '',
+    lastCloseAt: '',
+    lastErrorAt: '',
+    lastInputAt: '',
+    lastDeviceId: '',
+    lastInputType: '',
+    lastCommandId: '',
+    lastError: ''
+};
 const REMOTE_FRAME_WS_AUTO_START_LIMIT = 120;
 const REMOTE_FRAME_WS_DEFAULT_FPS = 12;
 const REMOTE_FRAME_WS_DEFAULT_MAX_WIDTH = 960;
@@ -2183,6 +2205,14 @@ httpServer.on('upgrade', (req, socket, head) => {
             return;
         }
 
+        if (parsed.pathname === '/api/remote/input/ws'
+            && (!bridgeAuthRequired || token === bridgeToken)) {
+            remoteInputWss.handleUpgrade(req, socket, head, (ws) => {
+                remoteInputWss.emit('connection', ws, req);
+            });
+            return;
+        }
+
         {
             socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
             socket.destroy();
@@ -2552,6 +2582,195 @@ remoteFrameWss.on('connection', (ws, req) => {
     });
 });
 
+function sendRemoteInputClientJson(ws, payload) {
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+        return false;
+    }
+
+    try {
+        ws.send(JSON.stringify(payload));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function normalizeRemoteInputWsPayload(payload = {}) {
+    const outer = payload && typeof payload === 'object' ? payload : {};
+    const inputSource = outer.input && typeof outer.input === 'object'
+        ? outer.input
+        : outer.Input && typeof outer.Input === 'object'
+            ? outer.Input
+            : outer;
+    const input = { ...inputSource };
+    input.type = String(input.type ?? input.Type ?? '').trim();
+    const deviceId = String(
+        outer.deviceId
+        ?? outer.DeviceId
+        ?? input.deviceId
+        ?? input.DeviceId
+        ?? ''
+    ).trim();
+    delete input.deviceId;
+    delete input.DeviceId;
+
+    return {
+        deviceId,
+        input,
+        requestId: String(outer.requestId ?? outer.RequestId ?? '').trim(),
+        ack: outer.ack === true || outer.Ack === true
+    };
+}
+
+function serializeRemoteInputWsDiagnostics() {
+    const clients = [];
+    for (const client of remoteInputClients) {
+        clients.push({
+            id: client.remoteInputClientId || '',
+            readyState: client.readyState,
+            connectedAt: client.remoteInputConnectedAt || '',
+            received: Number(client.remoteInputReceivedCount || 0),
+            queued: Number(client.remoteInputQueuedCount || 0),
+            failed: Number(client.remoteInputFailedCount || 0),
+            bufferedAmount: Number(client.bufferedAmount || 0),
+            lastInputAt: client.remoteInputLastInputAt || '',
+            lastDeviceId: client.remoteInputLastDeviceId || '',
+            lastInputType: client.remoteInputLastInputType || ''
+        });
+    }
+
+    return {
+        protocol: 'mindexec.remote.input.json.v1',
+        path: '/api/remote/input/ws',
+        clientCount: remoteInputClients.size,
+        ...remoteInputWsDiagnostics,
+        clients
+    };
+}
+
+remoteInputWss.on('connection', (ws) => {
+    remoteInputClients.add(ws);
+    ws.remoteInputClientId = `riws-${++remoteInputClientSeq}`;
+    ws.remoteInputConnectedAt = new Date().toISOString();
+    ws.remoteInputReceivedCount = 0;
+    ws.remoteInputQueuedCount = 0;
+    ws.remoteInputFailedCount = 0;
+    remoteInputWsDiagnostics.opened += 1;
+    remoteInputWsDiagnostics.lastOpenAt = ws.remoteInputConnectedAt;
+
+    ws.on('message', data => {
+        const receivedAt = new Date().toISOString();
+        remoteInputWsDiagnostics.messagesReceived += 1;
+        ws.remoteInputReceivedCount = (ws.remoteInputReceivedCount || 0) + 1;
+
+        let payload = null;
+        try {
+            const text = Buffer.isBuffer(data) ? data.toString('utf8') : String(data || '');
+            payload = JSON.parse(text);
+        } catch {
+            remoteInputWsDiagnostics.messagesInvalid += 1;
+            sendRemoteInputClientJson(ws, {
+                type: 'RemoteInputError',
+                timestamp: receivedAt,
+                error: 'invalid-json'
+            });
+            return;
+        }
+
+        const messageType = String(payload?.type || payload?.Type || '').trim().toLowerCase();
+        if (messageType === 'ping') {
+            sendRemoteInputClientJson(ws, {
+                type: 'RemoteInputPong',
+                timestamp: receivedAt
+            });
+            return;
+        }
+
+        if (messageType !== 'input' && messageType !== 'remote.input') {
+            remoteInputWsDiagnostics.messagesInvalid += 1;
+            sendRemoteInputClientJson(ws, {
+                type: 'RemoteInputError',
+                timestamp: receivedAt,
+                error: 'unsupported-message'
+            });
+            return;
+        }
+
+        const normalized = normalizeRemoteInputWsPayload(payload);
+        if (!normalized.deviceId || !normalized.input.type) {
+            remoteInputWsDiagnostics.messagesInvalid += 1;
+            sendRemoteInputClientJson(ws, {
+                type: 'RemoteInputResult',
+                timestamp: receivedAt,
+                ok: false,
+                requestId: normalized.requestId,
+                deviceId: normalized.deviceId,
+                inputType: normalized.input.type,
+                error: !normalized.deviceId ? 'missing-device-id' : 'missing-input-type'
+            });
+            return;
+        }
+
+        const result = remoteHub.sendInputControl(normalized.deviceId, normalized.input);
+        const ok = result?.ok === true;
+        const inputType = String(normalized.input.type || '').trim();
+        remoteInputWsDiagnostics.lastInputAt = receivedAt;
+        remoteInputWsDiagnostics.lastDeviceId = normalized.deviceId;
+        remoteInputWsDiagnostics.lastInputType = inputType;
+        remoteInputWsDiagnostics.lastCommandId = String(result?.commandId || '');
+        ws.remoteInputLastInputAt = receivedAt;
+        ws.remoteInputLastDeviceId = normalized.deviceId;
+        ws.remoteInputLastInputType = inputType;
+
+        if (ok) {
+            remoteInputWsDiagnostics.inputsQueued += 1;
+            ws.remoteInputQueuedCount = (ws.remoteInputQueuedCount || 0) + 1;
+            if (/^pointermove$/i.test(inputType)) {
+                remoteInputWsDiagnostics.pointerMovesQueued += 1;
+            }
+            if (/^key(up|down)$/i.test(inputType)) {
+                remoteInputWsDiagnostics.keyEventsQueued += 1;
+            }
+        } else {
+            remoteInputWsDiagnostics.inputsFailed += 1;
+            remoteInputWsDiagnostics.lastError = String(result?.error || 'input-failed');
+            ws.remoteInputFailedCount = (ws.remoteInputFailedCount || 0) + 1;
+        }
+
+        const shouldAck = normalized.ack === true || !ok || !/^pointermove$/i.test(inputType);
+        if (shouldAck) {
+            sendRemoteInputClientJson(ws, {
+                type: 'RemoteInputResult',
+                timestamp: receivedAt,
+                ok,
+                requestId: normalized.requestId,
+                deviceId: normalized.deviceId,
+                inputType,
+                commandId: result?.commandId || '',
+                error: result?.error || ''
+            });
+        }
+    });
+
+    ws.on('close', () => {
+        remoteInputClients.delete(ws);
+        remoteInputWsDiagnostics.closed += 1;
+        remoteInputWsDiagnostics.lastCloseAt = new Date().toISOString();
+    });
+    ws.on('error', error => {
+        remoteInputClients.delete(ws);
+        remoteInputWsDiagnostics.errors += 1;
+        remoteInputWsDiagnostics.lastErrorAt = new Date().toISOString();
+        remoteInputWsDiagnostics.lastError = String(error?.message || error || 'input-ws-error');
+    });
+    sendRemoteInputClientJson(ws, {
+        type: 'RemoteInputSocketReady',
+        timestamp: new Date().toISOString(),
+        protocol: 'mindexec.remote.input.json.v1',
+        clientId: ws.remoteInputClientId
+    });
+});
+
 // Helper: Validate path is within workspace
 function validatePath(requestedPath) {
     const fullPath = resolveWorkspaceBoundPath(requestedPath);
@@ -10279,11 +10498,13 @@ app.get('/api/status', async (req, res) => {
         wsToken,
         wsPath: '/events',
         remoteFrameWsPath: '/api/remote/frames/ws',
+        remoteInputWsPath: '/api/remote/input/ws',
         bridgeToken,
         bridgeTokenHeader,
         bridgeAuthRequired,
         remoteHub: remoteHub.getStatus({ includeSecrets: false }),
         remoteFrameWs: serializeRemoteFrameWsDiagnostics(),
+        remoteInputWs: serializeRemoteInputWsDiagnostics(),
         remoteAgent: serializeRemoteAgentState(),
         remoteRegistryFollower: serializeRemoteRegistryFollowerState(),
         remoteRegistryRealtime: serializeRemoteRegistryRealtimeState(),
@@ -12127,6 +12348,34 @@ async function shutdownBridge(signal) {
         // Ignore if already closed
     }
 
+    for (const client of remoteFrameClients) {
+        try {
+            client.close();
+        } catch {
+            // Ignore close race
+        }
+    }
+
+    for (const client of remoteInputClients) {
+        try {
+            client.close();
+        } catch {
+            // Ignore close race
+        }
+    }
+
+    try {
+        remoteFrameWss.close();
+    } catch {
+        // Ignore if already closed
+    }
+
+    try {
+        remoteInputWss.close();
+    } catch {
+        // Ignore if already closed
+    }
+
     try {
         stopRemoteRegistryFollower();
     } catch {