@mindexec/cli 0.2.152 → 0.2.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.152",
+  "version": "0.2.153",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -21,14 +21,15 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
     "test:remote:render": "node scripts/remote-fleet-render-smoke.mjs",
-    "test:remote:http": "node scripts/remote-http-smoke.mjs",
-    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
-    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
+    "test:remote:http": "node scripts/remote-http-smoke.mjs",
+    "test:remote:frame-ws": "node scripts/remote-frame-ws-smoke.mjs",
+    "test:remote:input-ws": "node scripts/remote-input-ws-smoke.mjs",
+    "test:remote:agent-ws": "node scripts/remote-agent-ws-smoke.mjs",
     "test:remote:managed": "node scripts/remote-agent-managed-smoke.mjs",
     "test:remote:registry": "node scripts/remote-registry-follower-smoke.mjs",
     "test:remote:package": "node scripts/remote-agent-package-smoke.mjs",

package/scripts/remote-fleet-render-smoke.mjs

@@ -528,7 +528,8 @@ async function loadCss3DManager() {
                 status: 200,
                 json: async () => ({
                     bridgeToken: 'render-smoke-bridge-token',
-                    remoteFrameWsPath: '/api/remote/frames/ws'
+                    remoteFrameWsPath: '/api/remote/frames/ws',
+                    remoteInputWsPath: '/api/remote/input/ws'
                 })
             };
         },
@@ -1180,21 +1181,44 @@ try {
         code: 'KeyA',
         repeat: false
     });
-    await wait(20);
-    const inputCalls = dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs');
-    assert.ok(inputCalls.length >= 3, 'control popup should send pointer and keyboard input through JS interop');
-    const pointerDown = inputCalls.find(call => call.args[2]?.type === 'pointerDown');
-    const keyDown = inputCalls.find(call => call.args[2]?.type === 'keyDown');
+    controlShell.dispatchEvent({
+        type: 'keyup',
+        key: 'A',
+        code: 'KeyA',
+        repeat: false
+    });
+    await wait(50);
+    const inputWsSends = diagnostics.webSocketSends
+        .filter(send => send.url.includes('/api/remote/input/ws'))
+        .map(send => {
+            try {
+                return JSON.parse(send.payload);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+    assert.ok(inputWsSends.length >= 3, 'control popup should send pointer and keyboard input over the input WebSocket');
+    const pointerDown = inputWsSends.find(message => message.input?.type === 'pointerDown');
+    const keyDown = inputWsSends.find(message => message.input?.type === 'keyDown');
+    const keyUp = inputWsSends.find(message => message.input?.type === 'keyUp');
     assert.ok(pointerDown);
     assert.ok(keyDown);
-    assert.equal(pointerDown.args[0], 'remote-fleet-render-smoke');
-    assert.equal(pointerDown.args[1], patchTarget.DeviceId);
-    assert.equal(pointerDown.args[2].button, 'left');
-    assert.ok(pointerDown.args[2].controlLeaseId);
-    assert.ok(pointerDown.args[2].normalizedX >= 0 && pointerDown.args[2].normalizedX <= 1);
-    assert.ok(pointerDown.args[2].normalizedY >= 0 && pointerDown.args[2].normalizedY <= 1);
-    assert.equal(keyDown.args[2].key, 'A');
-    assert.equal(keyDown.args[2].code, 'KeyA');
+    assert.ok(keyUp);
+    assert.equal(pointerDown.nodeId, 'remote-fleet-render-smoke');
+    assert.equal(pointerDown.deviceId, patchTarget.DeviceId);
+    assert.equal(pointerDown.input.button, 'left');
+    assert.ok(pointerDown.input.controlLeaseId);
+    assert.ok(pointerDown.input.normalizedX >= 0 && pointerDown.input.normalizedX <= 1);
+    assert.ok(pointerDown.input.normalizedY >= 0 && pointerDown.input.normalizedY <= 1);
+    assert.equal(keyDown.input.key, 'A');
+    assert.equal(keyDown.input.code, 'KeyA');
+    assert.equal(keyUp.input.key, 'A');
+    assert.equal(keyUp.input.code, 'KeyA');
+    assert.equal(
+        dotNetCalls.filter(call => call.methodName === 'SendRemoteFleetInputFromJs').length,
+        0,
+        'WebSocket input path should not use the slower DotNet input fallback in the happy path');
     manager.closeRemoteFleetControlPopupForTest('render-smoke');
     await wait(20);
     assert.equal(document.body.querySelector('[data-remote-fleet-control-popup="true"]'), null);

package/scripts/remote-input-ws-smoke.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocket } from 'ws';
+
+const BRIDGE_TOKEN = 'remote-input-ws-smoke-token';
+const PAIR_TOKEN = 'remote-input-ws-pair-token';
+const DEVICE_ID = 'remote-input-ws-device';
+
+function wait(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, timeoutMs = 10000, label = 'condition') {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        const value = await predicate();
+        if (value) {
+            return value;
+        }
+        await wait(50);
+    }
+
+    throw new Error(`Timed out waiting for ${label}.`);
+}
+
+async function findFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+
+async function fetchJson(url, options = {}) {
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+            'X-Bridge-Token': BRIDGE_TOKEN,
+            ...(options.headers || {})
+        }
+    });
+    const payload = await response.json().catch(() => null);
+    return { ok: response.ok, status: response.status, payload };
+}
+
+async function waitForBridge(baseUrl, details) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30000) {
+        try {
+            const result = await fetchJson(`${baseUrl}/api/remote/status`);
+            if (result.ok && result.payload?.started === true) {
+                return result.payload;
+            }
+        } catch {
+            // Server is still starting.
+        }
+        await wait(100);
+    }
+
+    throw new Error(`Timed out waiting for LocalBridge.\n${details()}`);
+}
+
+function spawnBridge({ bridgePort, remoteHubPort }) {
+    const bridgeRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const env = {
+        ...process.env,
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_TOKEN,
+        BRIDGE_REQUIRE_TOKEN: '1',
+        MINDEXEC_REMOTE_HUB: '1',
+        REMOTE_HUB_HOST: '127.0.0.1',
+        REMOTE_HUB_PORT: String(remoteHubPort),
+        REMOTE_HUB_PAIR_TOKEN: PAIR_TOKEN,
+        NO_COLOR: '1'
+    };
+
+    const child = spawn(process.execPath, ['server.js'], {
+        cwd: bridgeRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        env
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', chunk => {
+        stderr += chunk.toString();
+    });
+
+    const exitPromise = new Promise(resolve => child.once('exit', resolve));
+    const stop = async () => {
+        if (child.exitCode === null && !child.killed) {
+            child.kill('SIGTERM');
+            await Promise.race([exitPromise, wait(5000)]);
+            if (child.exitCode === null && !child.killed) {
+                child.kill('SIGKILL');
+            }
+        }
+    };
+
+    return {
+        baseUrl: `http://127.0.0.1:${bridgePort}`,
+        details: () => `stdout=${stdout}\nstderr=${stderr}`,
+        stop
+    };
+}
+
+async function openWebSocket(url) {
+    const ws = new WebSocket(url);
+    await new Promise((resolve, reject) => {
+        ws.once('open', resolve);
+        ws.once('error', reject);
+    });
+    return ws;
+}
+
+async function main() {
+    const bridgePort = await findFreePort();
+    const remoteHubPort = await findFreePort();
+    const bridge = spawnBridge({ bridgePort, remoteHubPort });
+    let agentWs = null;
+    let inputWs = null;
+
+    try {
+        await waitForBridge(bridge.baseUrl, bridge.details);
+
+        const receivedCommands = [];
+        agentWs = await openWebSocket(`ws://127.0.0.1:${remoteHubPort}/remote-agent`);
+        agentWs.on('message', data => {
+            const text = Buffer.isBuffer(data) ? data.toString('utf8') : String(data || '');
+            if (!text.trim().startsWith('{')) {
+                return;
+            }
+
+            const message = JSON.parse(text);
+            if (message.command === 'input.control') {
+                receivedCommands.push(message);
+            }
+        });
+        agentWs.send(JSON.stringify({
+            type: 'hello',
+            pairToken: PAIR_TOKEN,
+            deviceId: DEVICE_ID,
+            deviceName: 'Remote Input WS Smoke',
+            hostname: 'remote-input-ws-smoke',
+            platform: process.platform,
+            arch: process.arch,
+            pid: process.pid,
+            agentVersion: '0.0.0-input-ws-smoke',
+            runtime: 'node-smoke',
+            capabilities: {
+                status: true,
+                thumbnail: true,
+                liveStream: true,
+                binaryFrames: true,
+                control: true,
+                computerAgent: true,
+                taskDispatch: true,
+                aiAssist: false
+            }
+        }));
+        agentWs.send(JSON.stringify({
+            type: 'status',
+            status: {
+                uptimeSec: 1,
+                totalMem: 2,
+                freeMem: 1,
+                timestamp: new Date().toISOString()
+            }
+        }));
+
+        await waitFor(async () => {
+            const result = await fetchJson(`${bridge.baseUrl}/api/remote/devices`);
+            return result.payload?.devices?.find(device => device.deviceId === DEVICE_ID && device.connected === true);
+        }, 10000, 'device registration');
+
+        inputWs = await openWebSocket(`${bridge.baseUrl.replace(/^http:/, 'ws:')}/api/remote/input/ws?token=${encodeURIComponent(BRIDGE_TOKEN)}`);
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'pointer-move',
+            input: {
+                type: 'pointerMove',
+                normalizedX: 0.42,
+                normalizedY: 0.54,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-down',
+            input: {
+                type: 'keyDown',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+        inputWs.send(JSON.stringify({
+            type: 'input',
+            deviceId: DEVICE_ID,
+            requestId: 'key-up',
+            input: {
+                type: 'keyUp',
+                key: 'A',
+                code: 'KeyA',
+                repeat: false,
+                controlLeaseId: 'input-ws-smoke-lease'
+            }
+        }));
+
+        await waitFor(() => receivedCommands.length >= 3, 10000, 'input.control commands');
+        const commandTypes = receivedCommands.map(command => command.payload?.type);
+        assert.deepEqual(commandTypes.slice(0, 3), ['pointerMove', 'keyDown', 'keyUp']);
+        assert.equal(receivedCommands[0].payload.normalizedX, 0.42);
+        assert.equal(receivedCommands[0].payload.normalizedY, 0.54);
+        assert.equal(receivedCommands[1].payload.key, 'A');
+        assert.equal(receivedCommands[1].payload.code, 'KeyA');
+        assert.equal(receivedCommands[2].payload.key, 'A');
+        assert.equal(receivedCommands[2].payload.code, 'KeyA');
+
+        const status = await fetchJson(`${bridge.baseUrl}/api/status?remoteInput=ws`);
+        assert.equal(status.ok, true);
+        assert.equal(status.payload?.remoteInputWsPath, '/api/remote/input/ws');
+        assert.ok(status.payload?.remoteInputWs?.clientCount >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.inputsQueued >= 3, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.pointerMovesQueued >= 1, JSON.stringify(status.payload?.remoteInputWs));
+        assert.ok(status.payload?.remoteInputWs?.keyEventsQueued >= 2, JSON.stringify(status.payload?.remoteInputWs));
+        assert.equal(status.payload?.remoteInputWs?.lastDeviceId, DEVICE_ID);
+        assert.equal(status.payload?.remoteInputWs?.lastInputType, 'keyUp');
+
+        console.log('Remote input WebSocket smoke OK');
+    } finally {
+        if (inputWs && inputWs.readyState === WebSocket.OPEN) {
+            inputWs.close();
+        }
+        if (agentWs && agentWs.readyState === WebSocket.OPEN) {
+            agentWs.close();
+        }
+        await bridge.stop();
+    }
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

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 {

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -13494,6 +13494,8 @@
     const REMOTE_FLEET_LIVE_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_MONITOR_LIVE_FPS);
     const REMOTE_FLEET_CONTROL_LIVE_FPS = 20;
     const REMOTE_FLEET_CONTROL_FRAME_REFRESH_MS = Math.round(1000 / REMOTE_FLEET_CONTROL_LIVE_FPS);
+    const REMOTE_FLEET_CONTROL_INPUT_MOVE_MS = 16;
+    const REMOTE_FLEET_CONTROL_INPUT_QUEUE_LIMIT = 64;
     const REMOTE_FLEET_THUMBNAIL_FRAME_REFRESH_MS = 2000;
     const REMOTE_FLEET_FRAME_CANVAS_MAX_DPR = 2;
     const REMOTE_FLEET_FRAME_BLOB_CACHE_MS = 10000;
@@ -13829,6 +13831,22 @@
         return url.toString();
     }
 
+    function buildRemoteFleetInputWsUrl(status) {
+        const baseUrl = String(status?.__remoteFleetBridgeBaseUrl || window.location?.origin || '').trim();
+        const path = String(status?.remoteInputWsPath || '/api/remote/input/ws').trim() || '/api/remote/input/ws';
+        if (!baseUrl) {
+            return '';
+        }
+
+        const url = new URL(path, baseUrl);
+        url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+        const bridgeToken = String(status?.bridgeToken || '').trim();
+        if (bridgeToken) {
+            url.searchParams.set('token', bridgeToken);
+        }
+        return url.toString();
+    }
+
     async function parseRemoteFleetBinaryFrameMessage(data) {
         let buffer = null;
         if (data instanceof ArrayBuffer) {
@@ -15729,6 +15747,8 @@
         activeRemoteFleetControlPopup = null;
         session.active = false;
         detachRemoteFleetControlBinaryFrameSession(session);
+        closeRemoteFleetControlInputSocket(session, 'close');
+        session.inputCleanup?.();
         if (session.timer) {
             clearTimeout(session.timer);
             session.timer = null;
@@ -15910,34 +15930,268 @@
         }
     }
 
-    function sendRemoteFleetControlInput(session, payload, throttleMove = false) {
-        if (!session?.active || !payload?.type) {
+    function closeRemoteFleetControlInputSocket(session, reason = 'close') {
+        if (!session) {
             return;
         }
 
-        const send = next => {
-            if (!session.active) {
-                return;
+        if (session.inputWsOpenTimer) {
+            clearTimeout(session.inputWsOpenTimer);
+            session.inputWsOpenTimer = null;
+        }
+
+        const ws = session.inputWs;
+        session.inputWs = null;
+        session.inputWsConnecting = false;
+        if (ws && ws.readyState !== 3) {
+            try {
+                ws.close();
+            } catch {
+                // Best-effort input socket cleanup.
             }
-            invokeDotNetAsync('SendRemoteFleetInputFromJs', session.nodeId, session.deviceId, {
-                ...next,
-                controlLeaseId: session.controlLeaseId,
-                issuedAt: new Date().toISOString()
-            }).catch(error => {
+        }
+
+        if (reason === 'close') {
+            session.inputQueue = [];
+        }
+    }
+
+    function createRemoteFleetControlInput(session, payload) {
+        return {
+            ...payload,
+            controlLeaseId: session.controlLeaseId,
+            issuedAt: new Date().toISOString()
+        };
+    }
+
+    function sendRemoteFleetControlInputFallback(session, input) {
+        if (!session?.active || !input?.type) {
+            return;
+        }
+
+        invokeDotNetAsync('SendRemoteFleetInputFromJs', session.nodeId, session.deviceId, {
+            ...input,
+            controlLeaseId: input.controlLeaseId || session.controlLeaseId,
+            issuedAt: input.issuedAt || new Date().toISOString()
+        }).catch(error => {
+            if (session.active) {
                 session.status.textContent = error?.message || 'Input failed';
+            }
+        });
+    }
+
+    function drainRemoteFleetControlInputQueueToFallback(session) {
+        if (!session?.inputQueue?.length) {
+            return;
+        }
+
+        const queued = session.inputQueue.splice(0);
+        queued.forEach(envelope => sendRemoteFleetControlInputFallback(session, envelope.input));
+    }
+
+    function enqueueRemoteFleetControlInput(session, envelope) {
+        if (!session) {
+            return;
+        }
+
+        if (!Array.isArray(session.inputQueue)) {
+            session.inputQueue = [];
+        }
+
+        const inputType = String(envelope?.input?.type || '').toLowerCase();
+        if (inputType === 'pointermove') {
+            for (let i = session.inputQueue.length - 1; i >= 0; i -= 1) {
+                if (String(session.inputQueue[i]?.input?.type || '').toLowerCase() === 'pointermove') {
+                    session.inputQueue.splice(i, 1);
+                }
+            }
+        }
+
+        session.inputQueue.push(envelope);
+        while (session.inputQueue.length > REMOTE_FLEET_CONTROL_INPUT_QUEUE_LIMIT) {
+            const moveIndex = session.inputQueue.findIndex(item =>
+                String(item?.input?.type || '').toLowerCase() === 'pointermove');
+            session.inputQueue.splice(moveIndex >= 0 ? moveIndex : 0, 1);
+        }
+    }
+
+    function flushRemoteFleetControlInputQueue(session) {
+        const ws = session?.inputWs;
+        if (!session?.active || !ws || ws.readyState !== 1 || !session.inputQueue?.length) {
+            return;
+        }
+
+        const queued = session.inputQueue.splice(0);
+        for (const envelope of queued) {
+            if (!sendRemoteFleetControlInputEnvelope(session, envelope)) {
+                enqueueRemoteFleetControlInput(session, envelope);
+                break;
+            }
+        }
+    }
+
+    function sendRemoteFleetControlInputEnvelope(session, envelope) {
+        const ws = session?.inputWs;
+        if (!session?.active || !ws || ws.readyState !== 1) {
+            return false;
+        }
+
+        const inputType = String(envelope?.input?.type || '').toLowerCase();
+        if (inputType === 'pointermove' && Number(ws.bufferedAmount || 0) > 256 * 1024) {
+            window.RuntimeTrace?.emit?.('remote.control.input.drop', {
+                reason: 'ws-buffered',
+                deviceId: session.deviceId,
+                bufferedAmount: Number(ws.bufferedAmount || 0)
             });
+            return true;
+        }
+
+        try {
+            ws.send(JSON.stringify(envelope));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    function handleRemoteFleetControlInputSocketFailure(session) {
+        if (!session?.active) {
+            return;
+        }
+
+        closeRemoteFleetControlInputSocket(session, 'failed');
+        session.inputWsUnavailableUntil = Date.now() + 1000;
+        drainRemoteFleetControlInputQueueToFallback(session);
+    }
+
+    function ensureRemoteFleetControlInputSocket(session) {
+        if (!session?.active || typeof WebSocket !== 'function') {
+            return false;
+        }
+
+        const ws = session.inputWs;
+        if (ws && (ws.readyState === 0 || ws.readyState === 1)) {
+            return true;
+        }
+
+        if (session.inputWsConnecting === true) {
+            return true;
+        }
+
+        if ((session.inputWsUnavailableUntil || 0) > Date.now()) {
+            return false;
+        }
+
+        const connectToken = `input-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        session.inputWsConnecting = true;
+        session.inputWsConnectToken = connectToken;
+        getRemoteFleetBridgeStatusForFrames()
+            .then(status => {
+                if (!session.active || session.inputWsConnectToken !== connectToken) {
+                    return;
+                }
+
+                const wsUrl = buildRemoteFleetInputWsUrl(status);
+                if (!wsUrl) {
+                    throw new Error('input-ws-url-unavailable');
+                }
+
+                const inputWs = new WebSocket(wsUrl);
+                session.inputWs = inputWs;
+                inputWs.onopen = () => {
+                    if (!session.active || session.inputWs !== inputWs) {
+                        return;
+                    }
+
+                    session.inputWsConnecting = false;
+                    session.inputWsUnavailableUntil = 0;
+                    if (session.inputWsOpenTimer) {
+                        clearTimeout(session.inputWsOpenTimer);
+                        session.inputWsOpenTimer = null;
+                    }
+                    flushRemoteFleetControlInputQueue(session);
+                };
+                inputWs.onmessage = event => {
+                    try {
+                        const message = JSON.parse(String(event?.data || ''));
+                        if (message?.ok === false && session.active) {
+                            session.status.textContent = message.error || 'Input failed';
+                        }
+                    } catch {
+                        // Ignore input ack parse errors.
+                    }
+                };
+                inputWs.onerror = () => {
+                    if (session.inputWs === inputWs) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                };
+                inputWs.onclose = () => {
+                    if (session.inputWs === inputWs) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                };
+                session.inputWsOpenTimer = setTimeout(() => {
+                    if (session.active && session.inputWs === inputWs && inputWs.readyState === 0) {
+                        handleRemoteFleetControlInputSocketFailure(session);
+                    }
+                }, 900);
+            })
+            .catch(() => {
+                if (!session.active || session.inputWsConnectToken !== connectToken) {
+                    return;
+                }
+
+                session.inputWsConnecting = false;
+                session.inputWsUnavailableUntil = Date.now() + 1000;
+                drainRemoteFleetControlInputQueueToFallback(session);
+            });
+
+        return true;
+    }
+
+    function sendRemoteFleetControlInputNow(session, payload) {
+        if (!session?.active || !payload?.type) {
+            return;
+        }
+
+        const input = createRemoteFleetControlInput(session, payload);
+        const envelope = {
+            type: 'input',
+            nodeId: session.nodeId,
+            deviceId: session.deviceId,
+            requestId: `input-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+            input
         };
 
+        const wsReady = ensureRemoteFleetControlInputSocket(session);
+        if (wsReady && sendRemoteFleetControlInputEnvelope(session, envelope)) {
+            return;
+        }
+
+        if (wsReady) {
+            enqueueRemoteFleetControlInput(session, envelope);
+            return;
+        }
+
+        sendRemoteFleetControlInputFallback(session, input);
+    }
+
+    function sendRemoteFleetControlInput(session, payload, throttleMove = false) {
+        if (!session?.active || !payload?.type) {
+            return;
+        }
+
         if (!throttleMove) {
-            send(payload);
+            sendRemoteFleetControlInputNow(session, payload);
             return;
         }
 
         const now = performance.now();
         const elapsed = now - (session.lastMoveSentAt || 0);
-        if (elapsed >= 32) {
+        if (elapsed >= REMOTE_FLEET_CONTROL_INPUT_MOVE_MS) {
             session.lastMoveSentAt = now;
-            send(payload);
+            sendRemoteFleetControlInputNow(session, payload);
             return;
         }
 
@@ -15952,9 +16206,9 @@
             session.pendingMove = null;
             if (next) {
                 session.lastMoveSentAt = performance.now();
-                send(next);
+                sendRemoteFleetControlInputNow(session, next);
             }
-        }, Math.max(1, 32 - elapsed));
+        }, Math.max(1, REMOTE_FLEET_CONTROL_INPUT_MOVE_MS - elapsed));
     }
 
     function bindRemoteFleetControlInput(session) {
@@ -15965,6 +16219,40 @@
             overlay.addEventListener(eventName, event => event.stopPropagation(), true);
         });
 
+        const shouldIgnoreKeyboardEvent = event =>
+            event?.target?.closest?.('[data-remote-fleet-control-close="true"]');
+
+        const handleKeyboardEvent = (event, type) => {
+            if (!session.active || shouldIgnoreKeyboardEvent(event) || event.__remoteFleetControlHandled === true) {
+                return;
+            }
+
+            event.__remoteFleetControlHandled = true;
+            event.preventDefault();
+            event.stopPropagation();
+            shell.focus({ preventScroll: true });
+            sendRemoteFleetControlInput(session, {
+                type,
+                key: event.key,
+                code: event.code,
+                repeat: event.repeat === true
+            });
+        };
+
+        const handleWindowKeyDown = event => handleKeyboardEvent(event, 'keyDown');
+        const handleWindowKeyUp = event => handleKeyboardEvent(event, 'keyUp');
+        if (typeof window.addEventListener === 'function') {
+            window.addEventListener('keydown', handleWindowKeyDown, true);
+            window.addEventListener('keyup', handleWindowKeyUp, true);
+        }
+        session.inputCleanup = () => {
+            if (typeof window.removeEventListener === 'function') {
+                window.removeEventListener('keydown', handleWindowKeyDown, true);
+                window.removeEventListener('keyup', handleWindowKeyUp, true);
+            }
+            session.inputCleanup = null;
+        };
+
         stage.addEventListener('pointerdown', event => {
             const point = getRemoteFleetControlPoint(event, canvas, false);
             if (!point) {
@@ -16041,35 +16329,8 @@
             event.stopPropagation();
         });
 
-        shell.addEventListener('keydown', event => {
-            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
-                return;
-            }
-
-            event.preventDefault();
-            event.stopPropagation();
-            sendRemoteFleetControlInput(session, {
-                type: 'keyDown',
-                key: event.key,
-                code: event.code,
-                repeat: event.repeat === true
-            });
-        });
-
-        shell.addEventListener('keyup', event => {
-            if (event.target?.closest?.('[data-remote-fleet-control-close="true"]')) {
-                return;
-            }
-
-            event.preventDefault();
-            event.stopPropagation();
-            sendRemoteFleetControlInput(session, {
-                type: 'keyUp',
-                key: event.key,
-                code: event.code,
-                repeat: event.repeat === true
-            });
-        });
+        shell.addEventListener('keydown', event => handleKeyboardEvent(event, 'keyDown'));
+        shell.addEventListener('keyup', event => handleKeyboardEvent(event, 'keyUp'));
     }
 
     function openRemoteFleetControlPopup(bodyView, nodeModel, deviceId) {
@@ -16233,10 +16494,18 @@
             lastMoveSentAt: 0,
             lastControlFrameAt: 0,
             lastControlFrameSeq: 0,
-            binaryFramePreferred: false
+            binaryFramePreferred: false,
+            inputWs: null,
+            inputWsConnecting: false,
+            inputWsConnectToken: '',
+            inputWsOpenTimer: null,
+            inputWsUnavailableUntil: 0,
+            inputQueue: [],
+            inputCleanup: null
         };
         activeRemoteFleetControlPopup = session;
         bindRemoteFleetControlInput(session);
+        ensureRemoteFleetControlInputSocket(session);
         attachRemoteFleetControlBinaryFrameSession(session, bodyView);
 
         const refresh = async () => {

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "20SB8UIp",
+    "version":  "uSz5Xt0z",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-CXwos9ge49EzJij/kELHzhWSDGBSR3fbqqW7hBxARCI=",
+                       "hash":  "sha256-4BdT/RnBOnh3Mm/hTZilg3zo9az6W9oYf8h3br2aDko=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: 20SB8UIp */
+/* Manifest version: uSz5Xt0z */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.