@mindexec/cli 0.2.59 → 0.2.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.59",
+  "version": "0.2.61",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -46,7 +46,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mindexec/remote": "^0.1.12",
+    "@mindexec/remote": "^0.1.13",
     "@openai/codex-sdk": "^0.137.0",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",

package/remote-hub.js

@@ -107,6 +107,29 @@ function normalizeApprovalLevel(value) {
     return level === 'ai-assist' ? 'ai-assist' : 'task-only';
 }
 
+function normalizeRemoteInputEvent(value = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    const type = safeString(input.type || input.Type, 48);
+    const normalizedX = Number(input.normalizedX ?? input.NormalizedX);
+    const normalizedY = Number(input.normalizedY ?? input.NormalizedY);
+    const deltaX = Number(input.deltaX ?? input.DeltaX);
+    const deltaY = Number(input.deltaY ?? input.DeltaY);
+    return {
+        type,
+        normalizedX: Number.isFinite(normalizedX) ? Math.max(0, Math.min(1, normalizedX)) : undefined,
+        normalizedY: Number.isFinite(normalizedY) ? Math.max(0, Math.min(1, normalizedY)) : undefined,
+        button: safeString(input.button || input.Button, 24),
+        deltaX: Number.isFinite(deltaX) ? Math.max(-4096, Math.min(4096, deltaX)) : 0,
+        deltaY: Number.isFinite(deltaY) ? Math.max(-4096, Math.min(4096, deltaY)) : 0,
+        key: safeString(input.key || input.Key, 80),
+        code: safeString(input.code || input.Code, 80),
+        text: safeText(input.text || input.Text, 256),
+        repeat: input.repeat === true || input.Repeat === true,
+        controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
+        issuedAt: safeString(input.issuedAt || input.IssuedAt, 80)
+    };
+}
+
 function readCapabilityFlag(capabilities, key) {
     const value = capabilities?.[key];
     if (typeof value === 'boolean') {
@@ -1722,6 +1745,34 @@ export function createRemoteHub(options = {}) {
         return { ok: true, commandId };
     }
 
+    function sendInputControl(deviceId, input = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+
+        if (!device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
+
+        if (!readCapabilityFlag(device.capabilities, 'control')) {
+            return { ok: false, error: 'device-input-control-unavailable' };
+        }
+
+        const normalized = normalizeRemoteInputEvent(input);
+        if (!normalized.type) {
+            return { ok: false, error: 'missing-input-type' };
+        }
+
+        return sendCommand(deviceId, {
+            command: 'input.control',
+            payload: {
+                ...normalized,
+                issuedAt: normalized.issuedAt || new Date().toISOString()
+            }
+        });
+    }
+
     function requestAgentTask(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
         if (!device) {
@@ -2131,6 +2182,7 @@ export function createRemoteHub(options = {}) {
         listDeviceFrames,
         disconnectDevice,
         sendCommand,
+        sendInputControl,
         requestAgentTask,
         requestAgentTaskBatch,
         setHostTarget,

package/scripts/remote-http-smoke.mjs

@@ -270,6 +270,19 @@ async function runSyntheticEnabledSmoke() {
     assert.equal(devicesResult.payload?.devices?.length, SYNTHETIC_COUNT);
     assert.equal(devicesResult.payload.devices.some(device => device.connected === false), true);
 
+    const noControlTarget = devicesResult.payload.devices.find(device => device.connected);
+    assert.ok(noControlTarget);
+    const inputUnavailable = await fetchJson(`${baseUrl}/api/remote/devices/${encodeURIComponent(noControlTarget.deviceId)}/input`, {
+        method: 'POST',
+        token: BRIDGE_TOKEN,
+        body: JSON.stringify({
+            type: 'noop'
+        })
+    });
+    assert.equal(inputUnavailable.ok, true, JSON.stringify(inputUnavailable.payload));
+    assert.equal(inputUnavailable.payload?.ok, false);
+    assert.equal(inputUnavailable.payload?.error, 'device-input-control-unavailable');
+
     const connectedTargets = devicesResult.payload.devices
         .filter(device => device.connected && device.capabilities?.taskDispatch)
         .slice(0, 500)

package/scripts/remote-hub-smoke.mjs

@@ -73,7 +73,7 @@ try {
         capabilities: {
             status: true,
             thumbnail: false,
-            control: false,
+            control: true,
             liveStream: true,
             computerAgent: true,
             taskDispatch: true,
@@ -99,6 +99,24 @@ try {
     assert.equal(devices[0].connected, true);
     assert.equal(hub.getStatus().deviceCount, 1);
 
+    const inputCommand = hub.sendInputControl('smoke-device', {
+        type: 'noop'
+    });
+    assert.equal(inputCommand.ok, true);
+    writeJsonLine(socket, {
+        type: 'command.result',
+        commandId: inputCommand.commandId,
+        result: {
+            input: true,
+            handled: true
+        }
+    });
+    const inputDevice = await waitFor(() => {
+        const current = hub.listDevices();
+        return current[0]?.counters?.commandResultsReceived === 1 ? current[0] : null;
+    });
+    assert.equal(inputDevice.counters.commandsSent, 1);
+
     const thumbnailCommand = hub.requestThumbnail('smoke-device', {
         streamId: 'smoke-thumb',
         maxWidth: 320,

package/server.js

@@ -7398,6 +7398,10 @@ app.post('/api/remote/devices/:deviceId/ping', (req, res) => {
     }));
 });
 
+app.post('/api/remote/devices/:deviceId/input', (req, res) => {
+    res.json(remoteHub.sendInputControl(req.params.deviceId, req.body || {}));
+});
+
 app.post('/api/remote/devices/:deviceId/tasks', (req, res) => {
     res.json(remoteHub.requestAgentTask(req.params.deviceId, {
         instruction: req.body?.instruction,