@livedesk/hub 0.1.52 → 0.1.54

package/package.json

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

package/src/remote-clipboard-contract.mjs

@@ -465,8 +465,10 @@ export function normalizeRemoteClipboardCommandResult(action, operationId, value
     response.manifest = normalizeRemoteClipboardManifest(result.manifest, operationId);
     response.kind = response.manifest.contentKind;
   } else {
-    const kind = result.contentKind || result.kind;
-    if (kind) response.kind = normalizeContentKind(kind);
+    const explicitContentKind = String(result.contentKind || '').trim().toLowerCase();
+    const legacyKind = String(result.kind || '').trim().toLowerCase();
+    if (explicitContentKind) response.kind = normalizeContentKind(explicitContentKind);
+    else if (['text', 'image', 'files'].includes(legacyKind)) response.kind = legacyKind;
   }
   for (const key of ['receivedBytes', 'totalBytes']) {
     if (result[key] !== undefined) {

package/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()) {
@@ -1319,9 +1334,10 @@ function normalizeRemoteInputEvent(value = {}) {
         // input must prove the exact monitor owned by its capture generation.
         monitorIndex,
         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,
+        normalizedY: Number.isFinite(normalizedY) ? Math.max(0, Math.min(1, normalizedY)) : undefined,
+        button: safeString(input.button || input.Button, 24),
+        inputSource: safeString(input.inputSource || input.InputSource, 48).toLowerCase(),
+        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,
         code,
@@ -4982,22 +4998,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 +5789,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 +5829,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 +5851,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 +9502,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/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,