@livedesk/hub 0.1.67 → 0.1.69

package/package.json

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

package/src/remote-hub.js

@@ -75,6 +75,8 @@ const LIVE_STREAM_MIN_FRESH_MS = 3000;
 const LIVE_STREAM_MAX_FRESH_MS = 12000;
 const TASK_BATCH_OWNER = Symbol('remote-hub-task-batch-owner');
 const DEFAULT_REMOTE_INPUT_ACK_TIMEOUT_MS = 5000;
+const REMOTE_INPUT_FAILURE_LOG_INTERVAL_MS = 5000;
+const REMOTE_INPUT_FAILURE_LOG_KEY_LIMIT = 32;
 // RemoteFast owns a shared 7s native stop deadline. Keep four seconds for a
 // priority command.result to cross either Direct or encrypted Relay transport.
 const DEFAULT_LIVE_CAPTURE_STOP_ACK_TIMEOUT_MS = 11000;
@@ -1531,7 +1533,7 @@ function readCapabilityFlag(capabilities, key) {
     return /^(1|true|yes|on)$/i.test(String(value || '').trim());
 }
 
-function createDeviceCounters(overrides = {}) {
+function createDeviceCounters(overrides = {}) {
     return {
         messagesReceived: 0,
         statusReceived: 0,
@@ -1547,8 +1549,10 @@ function createDeviceCounters(overrides = {}) {
         audioStreamsStopped: 0,
         audioFramesReceived: 0,
         audioFramesDropped: 0,
-        audioStatusReceived: 0,
-        tasksQueued: 0,
+        audioStatusReceived: 0,
+        remoteInputsApplied: 0,
+        remoteInputsRejected: 0,
+        tasksQueued: 0,
         taskResultsReceived: 0,
         taskResultsFailed: 0,
         taskResultsTimedOut: 0,
@@ -1816,6 +1820,38 @@ function serializeDeviceTask(task) {
     };
 }
 
+function createRemoteInputDiagnostics() {
+    return {
+        appliedCount: 0,
+        rejectedCount: 0,
+        lastOutcome: null,
+        lastApplied: null,
+        lastFailure: null
+    };
+}
+
+function serializeRemoteInputDiagnostics(diagnostics) {
+    const source = diagnostics && typeof diagnostics === 'object'
+        ? diagnostics
+        : createRemoteInputDiagnostics();
+    return {
+        appliedCount: Math.max(0, Number(source.appliedCount) || 0),
+        rejectedCount: Math.max(0, Number(source.rejectedCount) || 0),
+        lastOutcome: source.lastOutcome ? { ...source.lastOutcome } : null,
+        lastApplied: source.lastApplied ? { ...source.lastApplied } : null,
+        lastFailure: source.lastFailure ? { ...source.lastFailure } : null
+    };
+}
+
+function firstOptionalBoolean(...values) {
+    for (const value of values) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return null;
+}
+
 function serializeDevice(device, options = {}) {
     if (!device) {
         return null;
@@ -1896,8 +1932,9 @@ function serializeDevice(device, options = {}) {
         recentTasks: Array.isArray(device.recentTasks)
             ? device.recentTasks.map(serializeDeviceTask).filter(Boolean)
             : [],
-        status: { ...device.status },
-        counters: { ...device.counters }
+        status: { ...device.status },
+        remoteInputDiagnostics: serializeRemoteInputDiagnostics(device.remoteInputDiagnostics),
+        counters: { ...device.counters }
     };
 }
 
@@ -4943,9 +4980,11 @@ export function createRemoteHub(options = {}) {
                 latestAudioStatus: null,
                 latestTask,
                 recentTasks: latestTask ? [latestTask] : [],
-                pendingTaskCommands: new Map(),
-                pendingTaskTimers: new Map(),
-                counters: createDeviceCounters({
+                pendingTaskCommands: new Map(),
+                pendingTaskTimers: new Map(),
+                remoteInputDiagnostics: createRemoteInputDiagnostics(),
+                remoteInputFailureLogAt: new Map(),
+                counters: createDeviceCounters({
                     messagesReceived: 1,
                     statusReceived: 1,
                     tasksQueued: latestTask ? 1 : 0,
@@ -5240,9 +5279,11 @@ export function createRemoteHub(options = {}) {
             },
             latestTask: null,
             recentTasks: [],
-            pendingTaskCommands: new Map(),
-            pendingTaskTimers: new Map(),
-            synthetic: false,
+            pendingTaskCommands: new Map(),
+            pendingTaskTimers: new Map(),
+            remoteInputDiagnostics: createRemoteInputDiagnostics(),
+            remoteInputFailureLogAt: new Map(),
+            synthetic: false,
             counters: createDeviceCounters({ messagesReceived: 1 })
         };
 
@@ -5980,9 +6021,10 @@ export function createRemoteHub(options = {}) {
     function acknowledgePendingDedicatedInput(device, message = {}) {
         const state = device?.pendingDedicatedInputAckState;
         if (!state?.current) {
-            return false;
+            return null;
         }
         if (dedicatedInputAckMatches(state.current, message)) {
+            const acknowledged = state.current;
             if (state.timeoutTimer) {
                 clearTimeout(state.timeoutTimer);
                 state.timeoutTimer = null;
@@ -5990,15 +6032,16 @@ export function createRemoteHub(options = {}) {
             state.current = state.next;
             state.next = null;
             armPendingDedicatedInputAck(device);
-            return true;
+            return acknowledged;
         }
         if (dedicatedInputAckMatches(state.next, message)) {
             // A later ordered acknowledgement proves that the input reader is
             // still draining, even if an earlier diagnostic response vanished.
+            const acknowledged = state.next;
             clearPendingDedicatedInputAcks(device);
-            return true;
+            return acknowledged;
         }
-        return false;
+        return null;
     }
 
     function pruneCompletedInputFallbacks(device, now = Date.now()) {
@@ -6105,14 +6148,39 @@ export function createRemoteHub(options = {}) {
                 || pending?.inputEventId,
                 128),
             inputSeq,
-            inputType: safeString(
+            inputType: safeString(
                 message.inputType
                 || message.InputType
                 || result.inputType
                 || result.InputType
                 || pending?.inputType,
-                48),
-            monitorIndex: Number(
+                48),
+            controlSessionId: safeString(
+                message.controlSessionId
+                || message.ControlSessionId
+                || result.controlSessionId
+                || result.ControlSessionId
+                || pending?.controlSessionId
+                || device.sessionId,
+                160),
+            controlCommandId: safeString(
+                message.controlCommandId
+                || message.ControlCommandId
+                || result.controlCommandId
+                || result.ControlCommandId
+                || pending?.controlCommandId,
+                128),
+            captureGeneration: Math.max(0, Number(
+                message.captureGeneration
+                ?? message.CaptureGeneration
+                ?? result.captureGeneration
+                ?? result.CaptureGeneration
+                ?? pending?.captureGeneration
+                ?? 0) || 0),
+            inputSocketConnectionId: safeString(
+                pending?.inputSocketConnectionId,
+                128),
+            monitorIndex: Number(
                 message.monitorIndex
                 ?? message.MonitorIndex
                 ?? result.monitorIndex
@@ -6178,27 +6246,144 @@ export function createRemoteHub(options = {}) {
                 || message.FocusChanged === true
                 || result.focusChanged === true
                 || result.FocusChanged === true,
-            inputDiagnostic: message.inputDiagnostic === true
+            inputDiagnostic: message.inputDiagnostic === true
                 || message.InputDiagnostic === true
-                || result.inputDiagnostic === true
-                || result.InputDiagnostic === true,
-            fallback: pending?.fallback === true,
-            hubAcknowledgedAtEpochMs: Date.now()
-        };
-    }
-
-    function emitRemoteInputApplied(device, message = {}, pending = null) {
-        const outcome = buildRemoteInputOutcome(device, message, pending);
-        emitEvent('RemoteInputApplied', {
-            ...outcome,
-            agentApplyMs: Number(
-                message.agentApplyMs
-                ?? message.AgentApplyMs
-                ?? message.result?.agentApplyMs
-                ?? message.result?.AgentApplyMs
-                ?? 0) || 0
-        });
-    }
+                || result.inputDiagnostic === true
+                || result.InputDiagnostic === true,
+            failureStage: safeString(
+                message.failureStage
+                || message.FailureStage
+                || result.failureStage
+                || result.FailureStage,
+                40),
+            exceptionType: safeString(
+                message.exceptionType
+                || message.ExceptionType
+                || result.exceptionType
+                || result.ExceptionType,
+                80),
+            permissionSupported: firstOptionalBoolean(
+                message.permissionSupported,
+                message.PermissionSupported,
+                result.permissionSupported,
+                result.PermissionSupported),
+            permissionGranted: firstOptionalBoolean(
+                message.permissionGranted,
+                message.PermissionGranted,
+                result.permissionGranted,
+                result.PermissionGranted),
+            macAccessibilityTrusted: firstOptionalBoolean(
+                message.macAccessibilityTrusted,
+                message.MacAccessibilityTrusted,
+                result.macAccessibilityTrusted,
+                result.MacAccessibilityTrusted),
+            macPostEventAccess: firstOptionalBoolean(
+                message.macPostEventAccess,
+                message.MacPostEventAccess,
+                result.macPostEventAccess,
+                result.MacPostEventAccess),
+            fallback: pending?.fallback === true,
+            hubAcknowledgedAtEpochMs: Date.now()
+        };
+    }
+
+    function rememberRemoteInputOutcome(device, outcome, state) {
+        const diagnostics = device.remoteInputDiagnostics
+            || (device.remoteInputDiagnostics = createRemoteInputDiagnostics());
+        const record = {
+            state,
+            receivedAt: new Date(outcome.hubAcknowledgedAtEpochMs).toISOString(),
+            inputType: safeString(outcome.inputType, 48),
+            inputSeq: Math.max(0, Number(outcome.inputSeq) || 0),
+            monitorIndex: Math.max(0, Number(outcome.monitorIndex) || 0),
+            sessionId: safeString(outcome.controlSessionId || device.sessionId, 160),
+            controlCommandId: safeString(outcome.controlCommandId, 128),
+            captureGeneration: Math.max(0, Number(outcome.captureGeneration) || 0),
+            inputSocketConnectionId: safeString(outcome.inputSocketConnectionId, 128),
+            fallback: outcome.fallback === true
+        };
+        if (state === 'applied') {
+            diagnostics.appliedCount += 1;
+            device.counters.remoteInputsApplied += 1;
+            const applied = {
+                ...record,
+                duplicate: outcome.duplicate === true,
+                agentApplyMs: Math.max(0, Number(outcome.agentApplyMs) || 0),
+                nativeInputBackend: safeString(outcome.nativeInputBackend, 80)
+            };
+            diagnostics.lastApplied = applied;
+            diagnostics.lastOutcome = applied;
+            return applied;
+        }
+
+        diagnostics.rejectedCount += 1;
+        device.counters.remoteInputsRejected += 1;
+        const failed = {
+            ...record,
+            errorKind: outcome.errorKind === 'native-apply' ? 'native-apply' : 'route',
+            failureStage: safeString(outcome.failureStage, 40) || 'unknown',
+            exceptionType: safeString(outcome.exceptionType, 80),
+            permissionSupported: firstOptionalBoolean(outcome.permissionSupported),
+            permissionGranted: firstOptionalBoolean(outcome.permissionGranted),
+            macAccessibilityTrusted: firstOptionalBoolean(outcome.macAccessibilityTrusted),
+            macPostEventAccess: firstOptionalBoolean(outcome.macPostEventAccess),
+            error: safeDiagnosticText(outcome.error, 600) || 'remote-input-failed',
+            failedAtEpochMs: Math.max(0, Number(outcome.failedAtEpochMs) || 0)
+        };
+        diagnostics.lastFailure = failed;
+        diagnostics.lastOutcome = failed;
+        return failed;
+    }
+
+    function logRemoteInputFailure(device, failure) {
+        const rateLimits = device.remoteInputFailureLogAt
+            || (device.remoteInputFailureLogAt = new Map());
+        const key = `${failure.errorKind}:${failure.failureStage}:${failure.exceptionType}:${failure.error}`;
+        const now = Date.now();
+        const lastAt = Number(rateLimits.get(key) || 0);
+        if (lastAt > 0 && now - lastAt < REMOTE_INPUT_FAILURE_LOG_INTERVAL_MS) {
+            return;
+        }
+        rateLimits.delete(key);
+        rateLimits.set(key, now);
+        while (rateLimits.size > REMOTE_INPUT_FAILURE_LOG_KEY_LIMIT) {
+            const oldestKey = rateLimits.keys().next().value;
+            if (!oldestKey) break;
+            rateLimits.delete(oldestKey);
+        }
+        const shortId = value => safeString(value, 128).slice(0, 12) || 'unknown';
+        const optionalFlag = value => typeof value === 'boolean' ? String(value) : 'unknown';
+        logWarn(
+            'remote',
+            `input rejected device=${device.deviceName} (${device.deviceId})`
+                + ` session=${shortId(failure.sessionId)}`
+                + ` command=${shortId(failure.controlCommandId)}`
+                + ` generation=${failure.captureGeneration}`
+                + ` monitor=${failure.monitorIndex}`
+                + ` type=${failure.inputType || 'unknown'}`
+                + ` seq=${failure.inputSeq}`
+                + ` kind=${failure.errorKind}`
+                + ` stage=${failure.failureStage}`
+                + ` exception=${failure.exceptionType || 'unknown'}`
+                + ` permission=${optionalFlag(failure.permissionGranted)}`
+                + ` accessibility=${optionalFlag(failure.macAccessibilityTrusted)}`
+                + ` postEvent=${optionalFlag(failure.macPostEventAccess)}`
+                + ` error=${failure.error}`);
+    }
+
+    function emitRemoteInputApplied(device, message = {}, pending = null) {
+        const outcome = {
+            ...buildRemoteInputOutcome(device, message, pending),
+            agentApplyMs: Number(
+                message.agentApplyMs
+                ?? message.AgentApplyMs
+                ?? message.result?.agentApplyMs
+                ?? message.result?.AgentApplyMs
+                ?? 0) || 0
+        };
+        rememberRemoteInputOutcome(device, outcome, 'applied');
+        emitEvent('RemoteInputApplied', outcome);
+    }
 
     function emitRemoteInputError(
         device,
@@ -6207,29 +6392,37 @@ export function createRemoteHub(options = {}) {
         fallbackError = 'remote-input-failed',
         errorKind = 'route') {
         const outcome = buildRemoteInputOutcome(device, message, pending);
-        emitEvent('RemoteInputError', {
+        const failure = {
             ...outcome,
             errorKind: errorKind === 'native-apply' ? 'native-apply' : 'route',
-            error: safeString(
-                message.error
-                || message.Error
-                || message.result?.error
-                || message.result?.Error
-                || fallbackError,
+            error: safeDiagnosticText(
+                message.error
+                || message.Error
+                || message.result?.error
+                || message.result?.Error
+                || fallbackError,
                 600) || fallbackError,
             failedAtEpochMs: Number(
                 message.failedAtEpochMs
                 ?? message.FailedAtEpochMs
                 ?? message.result?.failedAtEpochMs
-                ?? message.result?.FailedAtEpochMs
-                ?? 0) || 0
-        });
-    }
-
-    function handleRemoteInputOutcome(device, message = {}, source = 'input') {
+                ?? message.result?.FailedAtEpochMs
+                ?? 0) || 0
+        };
+        const persistentFailure = rememberRemoteInputOutcome(device, failure, 'rejected');
+        logRemoteInputFailure(device, persistentFailure);
+        emitEvent('RemoteInputError', failure);
+    }
+
+    function handleRemoteInputOutcome(
+        device,
+        message = {},
+        source = 'input',
+        acknowledgedPending = null) {
         const commandId = safeString(message.commandId || message.CommandId, 128);
         const inputSeq = Number(message.inputSeq ?? message.InputSeq ?? 0) || 0;
-        const pending = takePendingInputFallback(device, commandId, inputSeq);
+        const pending = acknowledgedPending
+            || takePendingInputFallback(device, commandId, inputSeq);
         if (!pending
             && source === 'main'
             && wasInputFallbackCompleted(device, commandId, inputSeq)) {
@@ -8572,12 +8765,12 @@ export function createRemoteHub(options = {}) {
         if (state.inputOnly) {
             device.inputLastSeenAt = new Date().toISOString();
             if (message.type === 'input.applied' || message.type === 'input.error') {
-                acknowledgePendingDedicatedInput(device, message);
+                const acknowledgedPending = acknowledgePendingDedicatedInput(device, message);
                 handleRemoteInputOutcome(device, {
-                    ...message,
-                    agentApplyMs: Number(message.agentApplyMs || 0) || 0
-                }, 'input');
-            }
+                    ...message,
+                    agentApplyMs: Number(message.agentApplyMs || 0) || 0
+                }, 'input', acknowledgedPending);
+            }
             return;
         }
         if (state.frameOnly) {

package/src/transport/relay-hub-control.js

@@ -420,7 +420,7 @@ export function createHubRelayControl({
     const host = safeText(
         env.LIVEDESK_RELAY_HOST
             || env.LIVEDESK_UDP_RENDEZVOUS_HOST
-            || 'www.gnsoftech.com',
+            || 'p2p.gnsoftech.com',
         253);
     const port = boundedInteger(
         env.LIVEDESK_RELAY_PORT || env.LIVEDESK_UDP_RENDEZVOUS_PORT,

package/src/transport/udp-hub-transport.js

@@ -67,7 +67,7 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
     const bindHost = safeText(env.LIVEDESK_UDP_BIND_HOST || '0.0.0.0', 128) || '0.0.0.0';
     const requestedPort = numberEnv(env.LIVEDESK_UDP_PORT, 0, 65535, 0);
     const advertiseHost = safeText(env.LIVEDESK_UDP_ADVERTISE_HOST || env.LIVEDESK_REMOTE_PUBLIC_HOST || '', 128);
-    const rendezvousHost = safeText(env.LIVEDESK_UDP_RENDEZVOUS_HOST || 'www.gnsoftech.com', 128);
+    const rendezvousHost = safeText(env.LIVEDESK_UDP_RENDEZVOUS_HOST || 'p2p.gnsoftech.com', 128);
     const rendezvousPort = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_PORT, 1, 65535, 5199);
     const rendezvousRefreshMs = numberEnv(env.LIVEDESK_UDP_RENDEZVOUS_REFRESH_MS, 1000, 50_000, 25_000);
     const punchTimeoutMs = numberEnv(env.LIVEDESK_UDP_PUNCH_TIMEOUT_MS, 500, 10_000, 3000);