livedesk 0.1.604 → 0.1.606

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.260",
+  "version": "0.1.261",
   "description": "VuvoDesk local remote client",
   "type": "module",
   "bin": {
@@ -42,10 +42,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.457",
-    "@livedesk/fast-osx-arm64": "0.1.457",
-    "@livedesk/fast-osx-x64": "0.1.457",
-    "@livedesk/fast-win-x64": "0.1.457"
+    "@livedesk/fast-linux-x64": "0.1.458",
+    "@livedesk/fast-osx-arm64": "0.1.458",
+    "@livedesk/fast-osx-x64": "0.1.458",
+    "@livedesk/fast-win-x64": "0.1.458"
   },
   "publishConfig": {
     "access": "public"

package/diagnostics/livedesk-mode3-capture-smoke.mjs

@@ -130,7 +130,7 @@ if (!ffmpegStaticPath || !existsSync(ffmpegStaticPath)) {
   throw new Error('The packaged ffmpeg-static decoder is unavailable.');
 }
 let ffmpegPath = ffmpegStaticPath;
-try {
+try {
   ffmpegPath = String(require('@ffmpeg-installer/ffmpeg')?.path || ffmpegStaticPath);
 } catch {
   // ffmpeg-static remains the portable decoder and compatibility fallback.
@@ -554,7 +554,7 @@ async function runWindowsInputAckProbe(binding, { expectHookLateStartFailure = f
   const socket = new WebSocket(`ws://127.0.0.1:${httpPort}/api/remote/input/ws`, {
     perMessageDeflate: false
   });
-  const sendInput = async (input, timeoutMs = 5_000) => {
+  const sendInput = async (input, timeoutMs = 5_000) => {
     const outcome = waitForWebSocketJson(
       socket,
       message => (
@@ -577,17 +577,101 @@ async function runWindowsInputAckProbe(binding, { expectHookLateStartFailure = f
         captureGeneration: binding.captureGeneration
       }
     }));
-    return outcome;
-  };
-
-  let resetApplied = false;
-  try {
-    const ready = waitForWebSocketJson(socket, message => message.type === 'RemoteInputSocketReady');
-    await Promise.all([waitForWebSocketOpen(socket), ready]);
-    const probe = await sendInput({
-      type: 'keyboard.probe',
-      inputSeq: 1,
-      inputEventId: `windows-physical-probe-${Date.now()}`,
+    try {
+      return await outcome;
+    } catch (error) {
+      throw new Error(
+        `Windows input ${input.type} seq=${input.inputSeq} did not return an outcome: `
+        + `${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+
+  const dispatchReset = (reason) => {
+    if (socket.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    socket.send(JSON.stringify({
+      type: 'input',
+      deviceId: binding.deviceId,
+      fireAndForget: true,
+      input: {
+        type: 'keyboard.reset',
+        inputSeq: 0,
+        requestAck: false,
+        pressedCodes: [],
+        shiftKey: false,
+        ctrlKey: false,
+        altKey: false,
+        metaKey: false,
+        repeat: false,
+        reason,
+        monitorIndex: binding.monitorIndex,
+        controlSessionId: binding.sessionId,
+        controlCommandId: binding.commandId,
+        captureGeneration: binding.captureGeneration
+      }
+    }));
+    return true;
+  };
+
+  let resetDispatched = false;
+  try {
+    const ready = waitForWebSocketJson(socket, message => message.type === 'RemoteInputSocketReady');
+    await Promise.all([waitForWebSocketOpen(socket), ready]);
+    const pointer = await sendInput({
+      type: 'pointermove',
+      inputSeq: 1,
+      inputEventId: `windows-physical-pointer-${Date.now()}`,
+      normalizedX: 0.5,
+      normalizedY: 0.5
+    });
+    assert.equal(pointer.type, 'RemoteInputApplied', String(pointer.error || 'Windows pointer input failed.'));
+    assert.equal(pointer.duplicate, false, 'Windows pointer input was acknowledged as a duplicate.');
+    assert.equal(pointer.nativeInputBackend, 'win32-setcursorpos');
+    assert.equal(Number(pointer.nativeEventsRequested), 1);
+    assert.equal(Number(pointer.nativeEventsAccepted), 1);
+
+    const shiftDown = await sendInput({
+      type: 'keydown',
+      inputSeq: 2,
+      inputEventId: `windows-physical-shift-down-${Date.now()}`,
+      key: 'Shift',
+      code: 'ShiftLeft',
+      keyCode: 16,
+      location: 1,
+      pressedCodes: ['ShiftLeft'],
+      shiftKey: true,
+      ctrlKey: false,
+      altKey: false,
+      metaKey: false,
+      repeat: false
+    });
+    assert.equal(shiftDown.type, 'RemoteInputApplied', String(shiftDown.error || 'Windows Shift keydown failed.'));
+    assert.equal(shiftDown.duplicate, false, 'Windows Shift keydown was acknowledged as a duplicate.');
+
+    const shiftUp = await sendInput({
+      type: 'keyup',
+      inputSeq: 3,
+      inputEventId: `windows-physical-shift-up-${Date.now()}`,
+      key: 'Shift',
+      code: 'ShiftLeft',
+      keyCode: 16,
+      location: 1,
+      pressedCodes: [],
+      shiftKey: false,
+      ctrlKey: false,
+      altKey: false,
+      metaKey: false,
+      repeat: false
+    });
+    assert.equal(shiftUp.type, 'RemoteInputApplied', String(shiftUp.error || 'Windows Shift keyup failed.'));
+    assert.equal(shiftUp.duplicate, false, 'Windows Shift keyup was acknowledged as a duplicate.');
+
+    const probe = await sendInput({
+      type: 'keyboard.probe',
+      inputSeq: 4,
+      inputEventId: `windows-physical-probe-${Date.now()}`,
       pressedCodes: [],
       shiftKey: false,
       ctrlKey: false,
@@ -606,26 +690,31 @@ async function runWindowsInputAckProbe(binding, { expectHookLateStartFailure = f
         /diagnostic keyboard isolation hook did not become ready/i,
         'The forced late hook start did not fail at the bounded ready deadline.'
       );
-      const reset = await sendInput({
-        type: 'keyboard.reset',
-        inputSeq: 2,
-        inputEventId: `windows-late-start-reset-${Date.now()}`,
-        pressedCodes: [],
-        shiftKey: false,
-        ctrlKey: false,
-        altKey: false,
-        metaKey: false,
-        repeat: false,
-        reason: 'windows-hook-late-start-cleanup'
-      });
-      assert.equal(reset.type, 'RemoteInputApplied', String(reset.error || 'Windows late-start reset failed.'));
-      assert.equal(reset.duplicate, false, 'Windows late-start reset was acknowledged as a duplicate.');
-      resetApplied = true;
-      return {
-        lateStartFailure: true,
-        error: String(probe.error || ''),
-        resetApplied
-      };
+      const recovery = await sendInput({
+        type: 'pointermove',
+        inputSeq: 5,
+        inputEventId: `windows-late-start-recovery-${Date.now()}`,
+        normalizedX: 0.5,
+        normalizedY: 0.5
+      });
+      assert.equal(
+        recovery.type,
+        'RemoteInputApplied',
+        String(recovery.error || 'Windows input owner did not recover after the bounded hook failure.')
+      );
+      assert.equal(recovery.nativeInputBackend, 'win32-setcursorpos');
+      assert.equal(Number(recovery.nativeEventsRequested), 1);
+      assert.equal(Number(recovery.nativeEventsAccepted), 1);
+      resetDispatched = dispatchReset('windows-hook-late-start-cleanup');
+      assert.equal(resetDispatched, true, 'Windows late-start cleanup reset was not dispatched.');
+      return {
+        lateStartFailure: true,
+        pointerBackend: String(pointer.nativeInputBackend || ''),
+        normalKeyAcks: 2,
+        error: String(probe.error || ''),
+        recoveryApplied: true,
+        resetDispatched
+      };
     }
     assert.equal(probe.type, 'RemoteInputApplied', String(probe.error || 'Windows native input probe failed.'));
     assert.equal(probe.duplicate, false, 'Windows native input probe was acknowledged as a duplicate.');
@@ -637,57 +726,28 @@ async function runWindowsInputAckProbe(binding, { expectHookLateStartFailure = f
     assert.equal(probe.focusChanged, false, 'Windows native input probe changed the foreground window.');
     assert.equal(probe.inputDiagnostic, true);
 
-    const reset = await sendInput({
-      type: 'keyboard.reset',
-      inputSeq: 2,
-      inputEventId: `windows-physical-reset-${Date.now()}`,
-      pressedCodes: [],
-      shiftKey: false,
-      ctrlKey: false,
-      altKey: false,
-      metaKey: false,
-      repeat: false,
-      reason: 'windows-native-input-diagnostic-cleanup'
-    });
-    assert.equal(reset.type, 'RemoteInputApplied', String(reset.error || 'Windows native input reset failed.'));
-    assert.equal(reset.duplicate, false, 'Windows native input reset was acknowledged as a duplicate.');
-    resetApplied = true;
-    return {
-      backend: String(probe.nativeInputBackend || ''),
+    resetDispatched = dispatchReset('windows-native-input-diagnostic-cleanup');
+    assert.equal(resetDispatched, true, 'Windows native input cleanup reset was not dispatched.');
+    return {
+      pointerBackend: String(pointer.nativeInputBackend || ''),
+      pointerRequested: Number(pointer.nativeEventsRequested || 0),
+      pointerAccepted: Number(pointer.nativeEventsAccepted || 0),
+      normalKeyAcks: 2,
+      backend: String(probe.nativeInputBackend || ''),
       requested: Number(probe.nativeEventsRequested || 0),
       accepted: Number(probe.nativeEventsAccepted || 0),
       hookObserved: Number(probe.hookEventsObserved || 0),
       hookBlocked: Number(probe.hookEventsBlocked || 0),
       duplicate: probe.duplicate === true,
       focusChanged: probe.focusChanged === true,
-      resetApplied
-    };
-  } finally {
-    if (!resetApplied && socket.readyState === WebSocket.OPEN) {
-      try {
-        socket.send(JSON.stringify({
-          type: 'input',
-          deviceId: binding.deviceId,
-          fireAndForget: true,
-          input: {
-            type: 'keyboard.reset',
-            inputSeq: 0,
-            requestAck: false,
-            pressedCodes: [],
-            shiftKey: false,
-            ctrlKey: false,
-            altKey: false,
-            metaKey: false,
-            repeat: false,
-            reason: 'windows-native-input-diagnostic-finally',
-            monitorIndex: binding.monitorIndex,
-            controlSessionId: binding.sessionId,
-            controlCommandId: binding.commandId,
-            captureGeneration: binding.captureGeneration
-          }
-        }));
-      } catch {
-        // Closing the exact input owner also triggers RemoteFast ReleaseAll.
+      resetDispatched
+    };
+  } finally {
+    if (!resetDispatched) {
+      try {
+        dispatchReset('windows-native-input-diagnostic-finally');
+      } catch {
+        // Closing the exact input owner also triggers RemoteFast ReleaseAll.
       }
     }
     try { socket.close(); } catch {}
@@ -1704,9 +1764,9 @@ function removeMacDiagnosticSignalHandlers() {
   macSignalHandlers.clear();
 }
 
-installMacDiagnosticSignalHandlers();
-
-try {
+installMacDiagnosticSignalHandlers();
+
+inputDiagnostic: try {
   macIsolation = await prepareMacDiagnosticIsolation();
   if (isMacPhysicalGate) {
     macDiagnosticAbort.throwIfRequested();
@@ -1924,7 +1984,8 @@ try {
       if (metadata.deviceId !== connectedDeviceId || metadata.frameMode !== 'mode3-h264-hw') return;
       const payload = Buffer.from(data.subarray(4 + metadataLength));
       frames.push({ metadata, receivedAt: performance.now(), bytes: payload.length, payload });
-      if (frames.length >= (isMacPhysicalGate ? 75 : 90)) {
+      const requiredFrameCount = windowsInputAck ? 1 : (isMacPhysicalGate ? 75 : 90);
+      if (frames.length >= requiredFrameCount) {
         finish(resolve, frames);
       }
     };
@@ -1953,9 +2014,40 @@ try {
     monitorSelections: { [connectedDeviceId]: requestedMonitorIndex }
   }));
 
-  const frames = await withMacDiagnosticAbort(framePromise, cancelFrameWait);
-  let activeInputBindingFrame = frames.at(-1);
-  const initialCaptureIdentity = switchMonitor && isWindows
+  const frames = await withMacDiagnosticAbort(framePromise, cancelFrameWait);
+  let activeInputBindingFrame = frames.at(-1);
+  if (windowsInputAck) {
+    const inputProbe = await runWindowsInputAckProbe({
+      deviceId: connectedDeviceId,
+      sessionId: String(activeInputBindingFrame.metadata.sessionId || ''),
+      commandId: String(activeInputBindingFrame.metadata.commandId || ''),
+      captureGeneration: Number(activeInputBindingFrame.metadata.captureGeneration || 0),
+      monitorIndex: Number(activeInputBindingFrame.metadata.monitorIndex || 0)
+    }, {
+      expectHookLateStartFailure: windowsInputHookLateStart
+    });
+    if (windowsInputHookLateStart) {
+      console.log(
+        `Windows diagnostic hook late-start cleanup OK: expected timeout, `
+        + `Agent responsive=${inputProbe.recoveryApplied}, reset dispatched=${inputProbe.resetDispatched}.`
+      );
+    } else {
+      console.log(
+        `Windows pointer input ACK: ${inputProbe.pointerAccepted}/${inputProbe.pointerRequested} `
+        + `via ${inputProbe.pointerBackend}; normal key ACK: ${inputProbe.normalKeyAcks}/2; `
+        + `isolated modifier ACK: `
+        + `${inputProbe.accepted}/${inputProbe.requested} via ${inputProbe.backend}, `
+        + `hook=${inputProbe.hookObserved}/${inputProbe.hookBlocked}, `
+        + `duplicate=${inputProbe.duplicate}, `
+        + `focusChanged=${inputProbe.focusChanged}, reset dispatched=${inputProbe.resetDispatched}.`
+      );
+    }
+    // The Windows input gate shares only the minimum current Control binding
+    // setup with the video smoke. Encoder profile and soak assertions belong
+    // to their own commands and must not obscure native input evidence.
+    break inputDiagnostic;
+  }
+  const initialCaptureIdentity = switchMonitor && isWindows
     ? await waitFor(
         () => findWindowsCaptureIdentity(agentLogs, requestedMonitorIndex),
         3_000,
@@ -2426,31 +2518,6 @@ try {
     console.log(`Mode 3 monitor transition OK: ${requestedMonitorIndex} -> ${nextMonitorIndex}, first frame ${switchedFirstFrameMs.toFixed(0)}ms, generation ${previousCaptureGeneration} -> ${firstSwitchedFrame.metadata.captureGeneration}.`);
   }
 
-  if (windowsInputAck) {
-    const inputProbe = await runWindowsInputAckProbe({
-      deviceId: connectedDeviceId,
-      sessionId: String(activeInputBindingFrame.metadata.sessionId || ''),
-      commandId: String(activeInputBindingFrame.metadata.commandId || ''),
-      captureGeneration: Number(activeInputBindingFrame.metadata.captureGeneration || 0),
-      monitorIndex: Number(activeInputBindingFrame.metadata.monitorIndex || 0)
-    }, {
-      expectHookLateStartFailure: windowsInputHookLateStart
-    });
-    if (windowsInputHookLateStart) {
-      console.log(
-        `Windows diagnostic hook late-start cleanup OK: expected timeout, `
-        + `Agent responsive, reset=${inputProbe.resetApplied}.`
-      );
-    } else {
-      console.log(
-        `Windows native modifier input ACK: ${inputProbe.accepted}/${inputProbe.requested} `
-        + `via ${inputProbe.backend}, hook=${inputProbe.hookObserved}/${inputProbe.hookBlocked}, `
-        + `duplicate=${inputProbe.duplicate}, `
-        + `focusChanged=${inputProbe.focusChanged}, reset=${inputProbe.resetApplied}.`
-      );
-    }
-  }
-
   if (transitionToMode5) {
     const previousFrameSocket = frameSocket;
     frameSocket = new WebSocket(`ws://127.0.0.1:${httpPort}/api/remote/frames/ws?devices=${encodeURIComponent(connectedDeviceId)}`);

package/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "VuvoDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",

package/hub/src/remote-hub.js

@@ -320,11 +320,14 @@ function serializeRemoteInputWrite(socket, payload) {
  * - Ordered transitions: keyboard and pointer-button events are never
  *   coalesced. If their bounded queue cannot retain order, the input socket is
  *   closed so the Agent releases native pressed state.
- * - High-rate input: only adjacent pointermove/mousemove/wheel samples from the
- *   same binding may replace an older queued sample.
- * - Bounds: one drain listener, one drain deadline, at most 16 userland items,
- *   32 KiB queued bytes, and 64 KiB socket writableLength.
- */
+ * - High-rate input: only adjacent pointermove/mousemove/wheel samples from the
+ *   same binding may replace an older queued sample.
+ * - Acknowledgement health: an acknowledged sample becomes a deadline
+ *   checkpoint only after that exact message is accepted by the socket write.
+ *   A sample replaced or dropped in the userland queue owns no timer.
+ * - Bounds: one drain listener, one drain deadline, at most 16 userland items,
+ *   32 KiB queued bytes, and 64 KiB socket writableLength.
+ */
 export function createBoundedRemoteInputWriter(options = {}) {
     const socket = options.socket;
     const connectionId = safeString(options.connectionId, 128);
@@ -357,9 +360,12 @@ export function createBoundedRemoteInputWriter(options = {}) {
     const isOwnerCurrent = typeof options.isOwnerCurrent === 'function'
         ? options.isOwnerCurrent
         : () => true;
-    const onFailClosed = typeof options.onFailClosed === 'function'
-        ? options.onFailClosed
-        : () => {};
+    const onFailClosed = typeof options.onFailClosed === 'function'
+        ? options.onFailClosed
+        : () => {};
+    const onAcknowledgedWrite = typeof options.onAcknowledgedWrite === 'function'
+        ? options.onAcknowledgedWrite
+        : () => {};
 
     let closed = false;
     let closeReason = '';
@@ -501,16 +507,23 @@ export function createBoundedRemoteInputWriter(options = {}) {
         if (writableLength() > maxWritableBytes) {
             return failClosed('input-writable-length-exceeded');
         }
-        if (writable === false && !armDrainOwner()) {
-            return {
-                ok: false,
-                error: closeReason || 'INPUT_CHANNEL_RECONNECTING',
-                failClosed: true
-            };
-        }
-        return {
-            ok: true,
-            queued: false,
+        if (writable === false && !armDrainOwner()) {
+            return {
+                ok: false,
+                error: closeReason || 'INPUT_CHANNEL_RECONNECTING',
+                failClosed: true
+            };
+        }
+        if (item.ackRequested) {
+            try {
+                onAcknowledgedWrite(item.payload, item.bindingKey);
+            } catch {
+                return failClosed('input-ack-write-observer-failed');
+            }
+        }
+        return {
+            ok: true,
+            queued: false,
             backpressured: writable === false
         };
     }
@@ -613,12 +626,14 @@ export function createBoundedRemoteInputWriter(options = {}) {
             return failClosed('input-transition-message-too-large');
         }
 
-        const item = {
-            payload,
-            bindingKey: normalizedBindingKey,
-            serialized,
-            coalescible
-        };
+        const item = {
+            payload,
+            bindingKey: normalizedBindingKey,
+            serialized,
+            coalescible,
+            ackRequested: payload?.payload?.requestAck === true
+                || payload?.requestAck === true
+        };
         if (blocked || queue.length > 0 || writableLength() >= maxWritableBytes) {
             const queued = queueItem(item);
             if (queued.ok && !blocked && !armDrainOwner()) {
@@ -4982,22 +4997,38 @@ export function createRemoteHub(options = {}) {
                 && device.inputSocket === socket
                 && device.inputSocketConnectionId === inputSocketConnectionId
                 && device.inputWriteOwner === writeOwner,
-            onFailClosed: reason => {
-                if (device.inputWriteOwner !== writeOwner
-                    || device.inputSocket !== socket
-                    || device.inputSocketConnectionId !== inputSocketConnectionId) {
-                    return;
-                }
-                device.inputWriteOwner = null;
-                device.inputSocket = null;
-                device.inputSocketConnectionId = '';
+            onFailClosed: reason => {
+                if (device.inputWriteOwner !== writeOwner
+                    || device.inputSocket !== socket
+                    || device.inputSocketConnectionId !== inputSocketConnectionId) {
+                    return;
+                }
+                clearPendingDedicatedInputAcks(device);
+                device.inputWriteOwner = null;
+                device.inputSocket = null;
+                device.inputSocketConnectionId = '';
                 device.inputOwnerConnectionId = '';
                 device.inputOwnerBindingKey = '';
                 inputSockets.delete(socket);
-                device.inputLastSeenAt = new Date().toISOString();
-                emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
-            }
-        });
+                device.inputLastSeenAt = new Date().toISOString();
+                emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
+            },
+            onAcknowledgedWrite: (message, bindingKey) => {
+                if (device.inputWriteOwner !== writeOwner
+                    || device.inputSocket !== socket
+                    || device.inputSocketConnectionId !== inputSocketConnectionId) {
+                    return;
+                }
+                const pending = message?.payload && typeof message.payload === 'object'
+                    ? message.payload
+                    : message;
+                schedulePendingDedicatedInputAck(device, {
+                    ...pending,
+                    inputSocketConnectionId,
+                    bindingKey
+                });
+            }
+        });
         device.inputWriteOwner = writeOwner;
 
         emitRemoteEvent('RemoteInputSocketConnected', device);
@@ -5757,11 +5788,17 @@ export function createRemoteHub(options = {}) {
         });
     }
 
-    function emitRemoteInputError(device, message = {}, pending = null, fallbackError = 'remote-input-failed') {
-        const outcome = buildRemoteInputOutcome(device, message, pending);
-        emitEvent('RemoteInputError', {
-            ...outcome,
-            error: safeString(
+    function emitRemoteInputError(
+        device,
+        message = {},
+        pending = null,
+        fallbackError = 'remote-input-failed',
+        errorKind = 'route') {
+        const outcome = buildRemoteInputOutcome(device, message, pending);
+        emitEvent('RemoteInputError', {
+            ...outcome,
+            errorKind: errorKind === 'native-apply' ? 'native-apply' : 'route',
+            error: safeString(
                 message.error
                 || message.Error
                 || message.result?.error
@@ -5791,9 +5828,9 @@ export function createRemoteHub(options = {}) {
         // session cannot acknowledge input from the current control session.
         if (!pending && source === 'main') {
             return false;
-        }
-        if (message.type === 'input.error') {
-            emitRemoteInputError(device, message, pending);
+        }
+        if (message.type === 'input.error') {
+            emitRemoteInputError(device, message, pending, 'remote-input-failed', 'native-apply');
         } else {
             emitRemoteInputApplied(device, message, pending);
         }
@@ -5813,8 +5850,13 @@ export function createRemoteHub(options = {}) {
             || !!error
             || result.ok === false
             || safeString(result.status, 40).toLowerCase() === 'failed';
-        if (failed) {
-            emitRemoteInputError(device, { ...message, error: error || 'remote-input-failed' }, completed);
+        if (failed) {
+            emitRemoteInputError(
+                device,
+                { ...message, error: error || 'remote-input-failed' },
+                completed,
+                'remote-input-failed',
+                'native-apply');
         } else {
             emitRemoteInputApplied(device, message, completed);
         }
@@ -9459,13 +9501,7 @@ export function createRemoteHub(options = {}) {
                 device.inputOwnerBindingKey = activeInputBindingKey;
                 device.counters.commandsSent += 1;
                 device.inputLastSeenAt = new Date().toISOString();
-                schedulePendingDedicatedInputAck(device, {
-                    ...normalized,
-                    inputSocketConnectionId: device.inputSocketConnectionId,
-                    bindingKey: activeInputBindingKey,
-                    hubForwardedAtEpochMs
-                });
-                if (clipboardOperationKey) {
+                if (clipboardOperationKey) {
                     const operation = clipboardOperations.get(clipboardOperationKey);
                     if (operation) {
                         operation.status = 'pasting';

package/hub/src/server.js

@@ -5927,13 +5927,13 @@ inputWss.on('connection', ws => {
     try {
       payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
     } catch {
-      sendJson(ws, { type: 'RemoteInputError', error: 'invalid-json' });
+      sendJson(ws, { type: 'RemoteInputError', errorKind: 'route', error: 'invalid-json' });
       return;
     }
     const deviceId = String(payload?.deviceId || '').trim();
     if (payload?.type === 'watch') {
       if (!deviceId) {
-        sendJson(ws, { type: 'RemoteInputError', error: 'device-id-required' });
+        sendJson(ws, { type: 'RemoteInputError', errorKind: 'route', error: 'device-id-required' });
         return;
       }
       for (const previousDeviceId of ws.liveDeskInputDeviceIds) {
@@ -5970,7 +5970,8 @@ inputWss.on('connection', ws => {
       return;
     }
     sendJson(ws, {
-      type: result?.ok ? 'RemoteInputQueued' : 'RemoteInputError',
+      type: result?.ok ? 'RemoteInputQueued' : 'RemoteInputError',
+      errorKind: result?.ok ? '' : 'route',
       requestId: payload?.requestId || '',
       deviceId,
       inputSeq: Number(input?.inputSeq || 0) || 0,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "livedesk",
-  "version": "0.1.604",
-  "livedeskClientVersion": "0.1.260",
+  "version": "0.1.606",
+  "livedeskClientVersion": "0.1.261",
   "buildFlavor": "production",
   "description": "VuvoDesk Hub and client launcher",
   "type": "module",
@@ -51,10 +51,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.457",
-    "@livedesk/fast-osx-arm64": "0.1.457",
-    "@livedesk/fast-osx-x64": "0.1.457",
-    "@livedesk/fast-win-x64": "0.1.457"
+    "@livedesk/fast-linux-x64": "0.1.458",
+    "@livedesk/fast-osx-arm64": "0.1.458",
+    "@livedesk/fast-osx-x64": "0.1.458",
+    "@livedesk/fast-win-x64": "0.1.458"
   },
   "publishConfig": {
     "access": "public"

package/web/dist/app.webmanifest

@@ -4,7 +4,7 @@
   "short_name": "VuvoDesk",
   "description": "Monitor and control your VuvoDesk computers from your phone.",
   "lang": "en",
-  "start_url": "/app?pwa=0.1.604",
+  "start_url": "/app?pwa=0.1.606",
   "scope": "/",
   "display": "standalone",
   "orientation": "any",