@livedesk/hub 0.1.50 → 0.1.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "VuvoDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@livedesk/runtime-core": "0.1.6",
+    "@livedesk/runtime-core": "0.1.6",
     "@openai/codex-sdk": "0.145.0",
     "cors": "^2.8.5",
     "express": "^4.21.2",

package/src/remote-hub.js

@@ -4288,22 +4288,25 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function closeInputSocket(device, reason = 'input-socket-closed') {
+    function closeInputSocket(device, reason = 'input-socket-closed') {
         const socket = device?.inputSocket;
         if (!socket) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
+        const writeOwner = device.inputWriteOwner;
+        clearPendingDedicatedInputAcks(device);
         clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
         device.inputSocketConnectionId = '';
         device.inputOwnerConnectionId = '';
-        device.inputOwnerBindingKey = '';
-        inputSockets.delete(socket);
-        writeOwner?.close?.(reason);
-        try {
+        device.inputOwnerBindingKey = '';
+        inputSockets.delete(socket);
+        writeOwner?.close?.(reason);
+        device.inputLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
+        try {
             writeJsonLine(socket, { type: 'disconnect', reason });
         } catch {
             // Best-effort notice before closing the side channel.
@@ -4315,7 +4318,7 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function detachInputSocket(socket, reason = 'input-socket-closed') {
+    function detachInputSocket(socket, reason = 'input-socket-closed') {
         const deviceId = inputSockets.get(socket);
         inputSockets.delete(socket);
         if (!deviceId) {
@@ -4327,7 +4330,8 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
+        const writeOwner = device.inputWriteOwner;
+        clearPendingDedicatedInputAcks(device);
         clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
@@ -4946,7 +4950,8 @@ export function createRemoteHub(options = {}) {
             return null;
         }
 
-        closeInputSocket(device, 'replaced-by-new-input-socket');
+        closeInputSocket(device, 'replaced-by-new-input-socket');
+        clearPendingDedicatedInputAcks(device);
 
         const now = new Date().toISOString();
         const inputSocketConnectionId = crypto.randomUUID();
@@ -5390,7 +5395,7 @@ export function createRemoteHub(options = {}) {
         return failed;
     }
 
-    function ensurePendingInputFallbacks(device) {
+    function ensurePendingInputFallbacks(device) {
         if (!(device?.pendingInputFallbacks instanceof Map)) {
             Object.defineProperty(device, 'pendingInputFallbacks', {
                 value: new Map(),
@@ -5407,8 +5412,151 @@ export function createRemoteHub(options = {}) {
                 writable: true
             });
         }
-        return device.pendingInputFallbacks;
-    }
+        return device.pendingInputFallbacks;
+    }
+
+    function ensurePendingDedicatedInputAckState(device) {
+        if (!device?.pendingDedicatedInputAckState) {
+            Object.defineProperty(device, 'pendingDedicatedInputAckState', {
+                value: { current: null, next: null, timeoutTimer: null },
+                enumerable: false,
+                configurable: true,
+                writable: true
+            });
+        }
+        return device.pendingDedicatedInputAckState;
+    }
+
+    function clearPendingDedicatedInputAcks(device) {
+        if (!device?.pendingDedicatedInputAckState) {
+            return;
+        }
+        const state = device.pendingDedicatedInputAckState;
+        if (state.timeoutTimer) {
+            clearTimeout(state.timeoutTimer);
+        }
+        state.timeoutTimer = null;
+        state.current = null;
+        state.next = null;
+    }
+
+    function dedicatedInputAckMatches(pending, message = {}) {
+        if (!pending) {
+            return false;
+        }
+        const result = message?.result && typeof message.result === 'object'
+            ? message.result
+            : {};
+        const inputEventId = safeString(
+            message.inputEventId
+            || message.InputEventId
+            || result.inputEventId
+            || result.InputEventId,
+            128);
+        const hubConnectionId = safeString(
+            message.hubConnectionId
+            || message.HubConnectionId
+            || result.hubConnectionId
+            || result.HubConnectionId,
+            128);
+        const inputSeq = Number(
+            message.inputSeq
+            ?? message.InputSeq
+            ?? result.inputSeq
+            ?? result.InputSeq
+            ?? 0) || 0;
+        if (pending.inputEventId && inputEventId) {
+            return pending.inputEventId === inputEventId
+                && pending.hubConnectionId === hubConnectionId;
+        }
+        return pending.inputSeq > 0
+            && pending.inputSeq === inputSeq
+            && pending.hubConnectionId === hubConnectionId;
+    }
+
+    function armPendingDedicatedInputAck(device) {
+        const state = ensurePendingDedicatedInputAckState(device);
+        if (state.timeoutTimer) {
+            clearTimeout(state.timeoutTimer);
+            state.timeoutTimer = null;
+        }
+        const pending = state.current;
+        if (!pending) {
+            return;
+        }
+        const remainingMs = Math.max(0, pending.deadlineAtEpochMs - Date.now());
+        state.timeoutTimer = setTimeout(() => {
+            state.timeoutTimer = null;
+            if (state.current !== pending) {
+                return;
+            }
+            state.current = null;
+            state.next = null;
+            if (device.inputSocketConnectionId !== pending.inputSocketConnectionId) {
+                return;
+            }
+            emitRemoteInputError(
+                device,
+                { error: 'remote-input-timeout' },
+                pending,
+                'remote-input-timeout');
+            closeInputSocket(device, 'input-ack-timeout');
+        }, remainingMs);
+        state.timeoutTimer.unref?.();
+    }
+
+    function schedulePendingDedicatedInputAck(device, pending) {
+        if (pending?.requestAck !== true
+            || !Number.isSafeInteger(pending.inputSeq)
+            || pending.inputSeq <= 0) {
+            return;
+        }
+        const state = ensurePendingDedicatedInputAckState(device);
+        const record = {
+            ...pending,
+            deadlineAtEpochMs: Date.now() + inputAckTimeoutMs
+        };
+        if (!state.current) {
+            state.current = record;
+            state.next = null;
+            armPendingDedicatedInputAck(device);
+            return;
+        }
+        if (state.current.inputSocketConnectionId !== record.inputSocketConnectionId
+            || state.current.bindingKey !== record.bindingKey) {
+            clearPendingDedicatedInputAcks(device);
+            state.current = record;
+            armPendingDedicatedInputAck(device);
+            return;
+        }
+        // Keep only one later checkpoint. If the current acknowledgement
+        // arrives, this latest sampled input becomes the next exact deadline.
+        state.next = record;
+    }
+
+    function acknowledgePendingDedicatedInput(device, message = {}) {
+        const state = device?.pendingDedicatedInputAckState;
+        if (!state?.current) {
+            return false;
+        }
+        if (dedicatedInputAckMatches(state.current, message)) {
+            if (state.timeoutTimer) {
+                clearTimeout(state.timeoutTimer);
+                state.timeoutTimer = null;
+            }
+            state.current = state.next;
+            state.next = null;
+            armPendingDedicatedInputAck(device);
+            return true;
+        }
+        if (dedicatedInputAckMatches(state.next, message)) {
+            // A later ordered acknowledgement proves that the input reader is
+            // still draining, even if an earlier diagnostic response vanished.
+            clearPendingDedicatedInputAcks(device);
+            return true;
+        }
+        return false;
+    }
 
     function pruneCompletedInputFallbacks(device, now = Date.now()) {
         ensurePendingInputFallbacks(device);
@@ -7864,10 +8012,14 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        if (state.inputOnly) {
-            device.inputLastSeenAt = new Date().toISOString();
-            if (message.type === 'input.applied' || message.type === 'input.error') {
-                handleRemoteInputOutcome(device, {
+        if (state.inputOnly) {
+            if (device.inputSocket !== socket) {
+                return;
+            }
+            device.inputLastSeenAt = new Date().toISOString();
+            if (message.type === 'input.applied' || message.type === 'input.error') {
+                acknowledgePendingDedicatedInput(device, message);
+                handleRemoteInputOutcome(device, {
                     ...message,
                     agentApplyMs: Number(message.agentApplyMs || 0) || 0
                 }, 'input');
@@ -9026,15 +9178,40 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function getCurrentInputWriteOwner(device) {
+    function getCurrentInputWriteOwner(device) {
         if (!device?.inputSocket
             || device.inputSocket.destroyed
             || !device.inputWriteOwner
             || !safeString(device.inputSocketConnectionId, 128)) {
             return null;
         }
-        return device.inputWriteOwner;
-    }
+        return device.inputWriteOwner;
+    }
+
+    function getInputRouteState(deviceId) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            return {
+                deviceId: safeString(deviceId, 160),
+                ready: false,
+                dedicatedInputChannel: false,
+                reason: 'device-not-connected'
+            };
+        }
+
+        const dedicatedInputChannel = readCapabilityFlag(
+            device.capabilities,
+            'dedicatedInputChannel');
+        const ready = dedicatedInputChannel
+            ? !!getCurrentInputWriteOwner(device)
+            : true;
+        return {
+            deviceId: device.deviceId,
+            ready,
+            dedicatedInputChannel,
+            reason: ready ? 'ready' : 'input-channel-not-connected'
+        };
+    }
 
     function sendInputControl(deviceId, input = {}) {
         const device = devices.get(String(deviceId || ''));
@@ -9057,9 +9234,9 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'missing-input-type' };
         }
 
-        // A reset only releases native key state. The current browser input
-        // owner must be able to send it even when its former Control binding
-        // has just become stale during a monitor/capture-generation switch.
+        // A reset releases native mouse-button and keyboard state. The
+        // current browser input owner must be able to send it even when its
+        // former Control binding has just become stale during a monitor/capture-generation switch.
         const currentInputOwner = safeString(device.inputOwnerConnectionId, 128);
         const isCurrentOwnerKeyboardReset = normalized.type.toLowerCase() === 'keyboard.reset'
             && normalized.hubConnectionId
@@ -9238,9 +9415,10 @@ export function createRemoteHub(options = {}) {
                 && normalized.hubConnectionId !== previousOwnerConnectionId;
             const bindingChanged = previousInputBindingKey
                 && previousInputBindingKey !== activeInputBindingKey;
-            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
-            if (ownerChanged || bindingChanged || writeBindingChanged) {
-                if (ownerChanged) {
+            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
+            if (ownerChanged || bindingChanged || writeBindingChanged) {
+                clearPendingDedicatedInputAcks(device);
+                if (ownerChanged) {
                     clearClipboardOperationsForDevice(
                         device,
                         'browser-input-owner-changed',
@@ -9265,11 +9443,12 @@ export function createRemoteHub(options = {}) {
                     return { ok: false, error: 'INPUT_CHANNEL_RECONNECTING' };
                 }
             }
-            const sent = inputWriteOwner.enqueue({
-                type: 'input.control',
-                payload: {
-                    ...normalized,
-                    hubForwardedAtEpochMs: Date.now(),
+            const hubForwardedAtEpochMs = Date.now();
+            const sent = inputWriteOwner.enqueue({
+                type: 'input.control',
+                payload: {
+                    ...normalized,
+                    hubForwardedAtEpochMs,
                     issuedAt: normalized.issuedAt || new Date().toISOString()
                 }
             }, activeInputBindingKey);
@@ -9277,9 +9456,15 @@ export function createRemoteHub(options = {}) {
                 if (normalized.hubConnectionId) {
                     device.inputOwnerConnectionId = normalized.hubConnectionId;
                 }
-                device.inputOwnerBindingKey = activeInputBindingKey;
-                device.counters.commandsSent += 1;
-                device.inputLastSeenAt = new Date().toISOString();
+                device.inputOwnerBindingKey = activeInputBindingKey;
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                schedulePendingDedicatedInputAck(device, {
+                    ...normalized,
+                    inputSocketConnectionId: device.inputSocketConnectionId,
+                    bindingKey: activeInputBindingKey,
+                    hubForwardedAtEpochMs
+                });
                 if (clipboardOperationKey) {
                     const operation = clipboardOperations.get(clipboardOperationKey);
                     if (operation) {
@@ -9370,7 +9555,8 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'input-owner-not-current' };
         }
 
-        clearClipboardOperationsForDevice(device, reason, owner);
+        clearClipboardOperationsForDevice(device, reason, owner);
+        clearPendingDedicatedInputAcks(device);
         device.inputOwnerConnectionId = '';
         device.inputOwnerBindingKey = '';
         const inputSocket = device.inputSocket;
@@ -11835,8 +12021,9 @@ export function createRemoteHub(options = {}) {
         sendClipboardCommand,
         refreshDevicePolicies,
         sendLegacyClientUpdate,
-        sendInputControl,
-        releaseInputOwner,
+        sendInputControl,
+        getInputRouteState,
+        releaseInputOwner,
         notifyAgentProgress,
         requestAgentTask,
         requestAgentTaskBatch,

package/src/server.js

@@ -253,15 +253,35 @@ function readPositiveIntegerEnv(name, fallback) {
   return Number.isFinite(value) && value > 0 ? Math.round(value) : fallback;
 }
 
-function secureExactTestTokenMatches(actual, expected) {
+function secureExactTestTokenMatches(actual, expected) {
   const actualBytes = Buffer.from(String(actual || ''), 'utf8');
   const expectedBytes = Buffer.from(String(expected || ''), 'utf8');
   return actualBytes.length > 0
     && actualBytes.length === expectedBytes.length
-    && crypto.timingSafeEqual(actualBytes, expectedBytes);
-}
-
-function handleRemoteHubEvent(type, event) {
+    && crypto.timingSafeEqual(actualBytes, expectedBytes);
+}
+
+function sendRemoteInputRouteState(ws, deviceId, reason = '') {
+  const route = remoteHub.getInputRouteState(deviceId);
+  sendJson(ws, {
+    type: 'RemoteInputRouteState',
+    ...route,
+    reason: String(reason || route.reason || ''),
+    timestamp: new Date().toISOString()
+  });
+}
+
+function broadcastRemoteInputRouteState(deviceId, reason = '') {
+  const normalizedDeviceId = String(deviceId || '').trim();
+  if (!normalizedDeviceId) return;
+  for (const ws of inputClients) {
+    if (ws.readyState === 1 && ws.liveDeskInputDeviceIds?.has(normalizedDeviceId)) {
+      sendRemoteInputRouteState(ws, normalizedDeviceId, reason);
+    }
+  }
+}
+
+function handleRemoteHubEvent(type, event) {
   liveDeskUpdateManager?.handleRemoteEvent(type, event);
   hubTransferJobs?.handleRemoteEvent(type, event);
   if (traceRemoteTestEventsEnabled
@@ -297,7 +317,7 @@ function handleRemoteHubEvent(type, event) {
     }
     return;
   }
-  if (type === 'RemoteInputError') {
+  if (type === 'RemoteInputError') {
     const targetConnectionId = String(event?.hubConnectionId || '').trim();
     for (const ws of inputClients) {
       if (targetConnectionId && ws.liveDeskInputClientId !== targetConnectionId) {
@@ -308,11 +328,18 @@ function handleRemoteHubEvent(type, event) {
         ...event
       });
     }
-    return;
-  }
-  if (type === 'RemoteDeviceConnected' || type === 'RemoteDeviceDisconnected') {
-    connectedDeviceCount = Number(remoteHub.getStatus({ includeSecrets: false }).connectedDeviceCount || 0);
-  }
+    return;
+  }
+  if (type === 'RemoteInputSocketConnected' || type === 'RemoteInputSocketDisconnected') {
+    const deviceId = String(event?.deviceId || event?.device?.deviceId || '').trim();
+    broadcastRemoteInputRouteState(deviceId, event?.reason || type);
+    return;
+  }
+  if (type === 'RemoteDeviceConnected' || type === 'RemoteDeviceDisconnected') {
+    connectedDeviceCount = Number(remoteHub.getStatus({ includeSecrets: false }).connectedDeviceCount || 0);
+    const deviceId = String(event?.deviceId || event?.device?.deviceId || '').trim();
+    broadcastRemoteInputRouteState(deviceId, event?.reason || type);
+  }
   if (type !== 'RemoteDeviceConnected') {
     return;
   }
@@ -817,16 +844,18 @@ function getLiveDeskUpdateStatus() {
   };
 }
 
-if (process.env.LIVEDESK_DESKTOP_HOST !== '1') {
-  liveDeskUpdateManager = createLiveDeskUpdateManager({
-    remoteHub,
-    currentManagerVersion: process.env.LIVEDESK_MANAGER_VERSION || packageInfo.version,
-    currentClientVersion: process.env.LIVEDESK_CLIENT_PACKAGE_VERSION || '',
-    excludedDeviceIds: [runtimeDeviceId],
-    restartSupported: !!String(process.env.LIVEDESK_HUB_UPDATE_REQUEST_PATH || '').trim(),
-    requestHubRestart
-  });
-}
+const electronDesktopOwnsSelfUpdate = process.env.LIVEDESK_DESKTOP_HOST === '1';
+liveDeskUpdateManager = createLiveDeskUpdateManager({
+  remoteHub,
+  currentManagerVersion: process.env.LIVEDESK_MANAGER_VERSION || packageInfo.version,
+  currentClientVersion: process.env.LIVEDESK_CLIENT_PACKAGE_VERSION || '',
+  excludedDeviceIds: [runtimeDeviceId],
+  // electron-updater owns replacement of the installed desktop application.
+  // The same Hub still needs the fleet manager for connected outdated Clients.
+  restartSupported: !electronDesktopOwnsSelfUpdate
+    && !!String(process.env.LIVEDESK_HUB_UPDATE_REQUEST_PATH || '').trim(),
+  requestHubRestart: electronDesktopOwnsSelfUpdate ? undefined : requestHubRestart
+});
 
 if (process.env.LIVEDESK_UPDATE_CONTINUE === '1') {
   let continueUpdateInFlight = false;
@@ -3860,7 +3889,7 @@ function buildHubHealthPayload({
   };
   return {
     ok: true,
-    product: 'LiveDesk',
+    product: 'LiveDesk',
     timestamp: new Date().toISOString(),
     persistentSessionGc,
     memoryBeforeGc,
@@ -4323,7 +4352,7 @@ app.get('/api/remote/status', (_req, res) => {
   res.json({
     ...remoteHub.getStatus({ includeSecrets: false }),
     pairingPin: secretStatus.pairingPin,
-    product: 'LiveDesk',
+    product: 'LiveDesk',
     runtimeRole,
     deviceId: runtimeDeviceId,
     deviceName: runtimeDeviceName,
@@ -5010,31 +5039,30 @@ app.post('/api/runtime/role', async (req, res) => {
   }
 });
 
-app.get('/api/update/status', (_req, res) => {
-  noStore(res);
-  if (process.env.LIVEDESK_DESKTOP_HOST === '1') {
-    res.json({
-      updateAvailable: false,
-      state: 'electron-managed',
-      canApply: false,
-      disabled: true,
-      restartResult: readHubRestartResult()
-    });
-    return;
-  }
-  res.json(getLiveDeskUpdateStatus());
-});
-
-app.post('/api/update/apply', async (_req, res) => {
-  noStore(res);
-  if (process.env.LIVEDESK_DESKTOP_HOST === '1') {
-    res.status(409).json({ ok: false, error: 'electron-updater-managed', disabled: true });
-    return;
-  }
-  try {
-    liveDeskUpdateManager?.reconcileHubRestartResult(readHubRestartResult());
-    const result = await liveDeskUpdateManager?.startUpdate();
-    res.status(result?.ok === false ? 409 : 200).json(result || { ok: false, error: 'update-manager-unavailable' });
+app.get('/api/update/status', (_req, res) => {
+  noStore(res);
+  res.json({
+    ...getLiveDeskUpdateStatus(),
+    selfUpdateOwner: electronDesktopOwnsSelfUpdate ? 'electron-updater' : 'npm-launcher'
+  });
+});
+
+app.post('/api/update/apply', async (_req, res) => {
+  noStore(res);
+  try {
+    liveDeskUpdateManager?.reconcileHubRestartResult(readHubRestartResult());
+    const updateStatus = liveDeskUpdateManager?.getStatus();
+    if (electronDesktopOwnsSelfUpdate
+      && (updateStatus?.managerUpdateAvailable || updateStatus?.clientPackageUpdateAvailable)) {
+      res.status(409).json({
+        ok: false,
+        error: 'electron-updater-managed',
+        selfUpdateOwner: 'electron-updater'
+      });
+      return;
+    }
+    const result = await liveDeskUpdateManager?.startUpdate();
+    res.status(result?.ok === false ? 409 : 200).json(result || { ok: false, error: 'update-manager-unavailable' });
   } catch (error) {
     res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
   }
@@ -5793,7 +5821,7 @@ frameWss.on('connection', (ws, req) => {
   } catch {
     updateFrameSubscription(ws, {});
   }
-  ws.on('message', data => {
+  ws.on('message', data => {
     try {
       const payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
       if (payload?.type === 'subscribe') {
@@ -5899,11 +5927,29 @@ inputWss.on('connection', ws => {
     try {
       payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
     } catch {
-      sendJson(ws, { type: 'RemoteInputError', error: 'invalid-json' });
-      return;
-    }
-    const deviceId = String(payload?.deviceId || '').trim();
-    const inputEventId = String(
+      sendJson(ws, { type: 'RemoteInputError', error: 'invalid-json' });
+      return;
+    }
+    const deviceId = String(payload?.deviceId || '').trim();
+    if (payload?.type === 'watch') {
+      if (!deviceId) {
+        sendJson(ws, { type: 'RemoteInputError', error: 'device-id-required' });
+        return;
+      }
+      for (const previousDeviceId of ws.liveDeskInputDeviceIds) {
+        if (previousDeviceId !== deviceId) {
+          remoteHub.releaseInputOwner(
+            previousDeviceId,
+            ws.liveDeskInputClientId,
+            'browser-input-target-changed');
+        }
+      }
+      ws.liveDeskInputDeviceIds.clear();
+      ws.liveDeskInputDeviceIds.add(deviceId);
+      sendRemoteInputRouteState(ws, deviceId, 'browser-input-watch');
+      return;
+    }
+    const inputEventId = String(
       payload?.input?.inputEventId
       || payload?.inputEventId
       || payload?.requestId