@livedesk/hub 0.1.47 → 0.1.49

package/src/remote-hub.js

@@ -3,10 +3,18 @@ import os from 'os';
 import crypto from 'crypto';
 import { createHubRelayControl } from './transport/relay-hub-control.js';
 import { parseExactLiveStreamMonitorIndex } from './live-stream-monitor-contract.js';
-import {
-    BoundedSegmentedBuffer,
-    createBoundedAgentBinaryIngressLane
-} from './transport/agent-binary-ingress.js';
+import {
+    BoundedSegmentedBuffer,
+    createBoundedAgentBinaryIngressLane
+} from './transport/agent-binary-ingress.js';
+import {
+    REMOTE_CLIPBOARD_FILE_ACTIONS,
+    REMOTE_CLIPBOARD_LIMITS,
+    REMOTE_CLIPBOARD_PROTOCOL,
+    normalizeRemoteClipboardCommandResult,
+    normalizeRemoteClipboardManifest,
+    remoteClipboardContentNeedsFileTransfer
+} from './remote-clipboard-contract.mjs';
 
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
@@ -228,12 +236,13 @@ const REMOTE_FRAME_MODE_ALIASES = new Map([
 ]);
 const MAX_SYNTHETIC_DEVICES = 1000;
 const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
-const DEFAULT_PUBLIC_IP_REFRESH_MS = 5 * 60 * 1000;
-const DEFAULT_PUBLIC_IP_TIMEOUT_MS = 1800;
-const DUPLICATE_DEVICE_ACTIVE_REJECT_MS = 15000;
-const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
-const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
-const AGENT_BINARY_INGRESS_QUEUE_PACKETS = 16;
+const DEFAULT_PUBLIC_IP_REFRESH_MS = 5 * 60 * 1000;
+const DEFAULT_PUBLIC_IP_TIMEOUT_MS = 1800;
+const DEFAULT_DEVICE_CONNECTION_STALE_MS = 20000;
+const DEFAULT_DEVICE_CONNECTION_SWEEP_MS = 5000;
+const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
+const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
+const AGENT_BINARY_INGRESS_QUEUE_PACKETS = 16;
 const AGENT_BINARY_INGRESS_QUEUE_MAX_BYTES = 12 * 1024 * 1024;
 const AGENT_BINARY_INGRESS_QUEUE_MAX_AGE_MS = 120;
 const MODE5_AGENT_BINARY_INGRESS_QUEUE_PACKETS = 2;
@@ -797,6 +806,25 @@ function normalizeIncomingFrameModeProfile(value) {
     };
 }
 
+function deviceExplicitlyRejectsFrameMode(device, frameMode) {
+    const requestedMode = safeString(frameMode, 80).toLowerCase();
+    if (!requestedMode) {
+        return false;
+    }
+
+    const advertisedModes = [
+        ...(Array.isArray(device?.frameModes) ? device.frameModes : []),
+        ...(Array.isArray(device?.frameProtocol?.modes) ? device.frameProtocol.modes : []),
+        ...(Array.isArray(device?.capabilities?.frameModes) ? device.capabilities.frameModes : []),
+        ...(Array.isArray(device?.capabilities?.frameProtocol?.modes)
+            ? device.capabilities.frameProtocol.modes
+            : [])
+    ];
+    return advertisedModes.some(profile =>
+        safeString(profile?.mode || profile?.frameMode, 80).toLowerCase() === requestedMode
+        && profile?.implemented === false);
+}
+
 function isLoopbackHost(value) {
     const host = String(value || '').trim().toLowerCase();
     return host === 'localhost'
@@ -1164,12 +1192,12 @@ function normalizeRemoteKeyboardKey(value) {
     return raw === ' ' ? ' ' : safeString(raw, 80);
 }
 
-function normalizeRemoteKeyboardText(value) {
-    const raw = String(value ?? '').replace(/\0/g, '');
-    // Remote text is input data, not a label. Preserve leading/trailing spaces
-    // and IME whitespace while keeping every ordered message bounded.
-    return raw.slice(0, 256);
-}
+function normalizeRemoteKeyboardText(value) {
+    const raw = String(value ?? '').replace(/\0/g, '');
+    // Remote text is input data, not a label. Preserve leading/trailing spaces
+    // and IME whitespace while keeping every ordered message bounded.
+    return raw.slice(0, 256);
+}
 
 function safeTaskData(value) {
     if (value === undefined || value === null) return undefined;
@@ -1216,9 +1244,11 @@ const SUPPORTED_AGENT_OPERATIONS = new Set([
     'application.close',
     'file.read',
     'file.write',
-    'file.delete',
-    'file.list',
-    'command.run',
+    'file.delete',
+    'file.list',
+    'file.search',
+    'directory.create',
+    'command.run',
     'script.run',
     'software.install',
     'network.status',
@@ -1250,7 +1280,7 @@ function readRawRemoteInputMonitorIndex(input) {
     return undefined;
 }
 
-function normalizeRemoteInputEvent(value = {}) {
+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);
@@ -1271,7 +1301,14 @@ function normalizeRemoteInputEvent(value = {}) {
             .filter(Boolean))]
             .slice(0, 64)
         : null;
-    const key = normalizeRemoteKeyboardKey(input.key ?? input.Key);
+    const key = normalizeRemoteKeyboardKey(input.key ?? input.Key);
+    const clipboardOperationId = safeString(
+        input.clipboardOperationId || input.operationId || input.ClipboardOperationId || input.OperationId,
+        128);
+    const clipboardDirection = safeString(
+        input.clipboardDirection || input.ClipboardDirection,
+        16).toLowerCase();
+    const clipboardManifest = input.clipboardManifest || input.manifest || input.ClipboardManifest || input.Manifest;
     let code = safeString(input.code ?? input.Code, 80);
     if ((!code || code === 'Unidentified') && (key === ' ' || key === 'Spacebar' || keyCode === 32)) {
         code = 'Space';
@@ -1296,7 +1333,13 @@ function normalizeRemoteInputEvent(value = {}) {
         shiftKey: input.shiftKey === true || input.ShiftKey === true,
         ctrlKey: input.ctrlKey === true || input.ControlKey === true || input.CtrlKey === true,
         altKey: input.altKey === true || input.AltKey === true,
-        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
+        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
+        clipboardOperationId,
+        operationId: clipboardOperationId,
+        clipboardDirection,
+        manifest: clipboardManifest && typeof clipboardManifest === 'object' && !Array.isArray(clipboardManifest)
+            ? clipboardManifest
+            : null,
         controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
         controlSessionId: safeString(input.controlSessionId || input.sessionId || input.ControlSessionId || input.SessionId, 160),
         controlCommandId: safeString(input.controlCommandId || input.commandId || input.ControlCommandId || input.CommandId, 128),
@@ -1718,6 +1761,26 @@ function writeJsonLine(socket, payload) {
     return true;
 }
 
+function writeJsonLineAndClose(socket, payload) {
+    if (!socket || socket.destroyed) {
+        return false;
+    }
+
+    if (socket.__remoteHubWebSocket === true) {
+        const written = writeJsonLine(socket, payload);
+        socket.destroy();
+        return written;
+    }
+
+    try {
+        socket.end(`${JSON.stringify(payload)}\n`);
+        return true;
+    } catch {
+        socket.destroy();
+        return false;
+    }
+}
+
 function isRemoteHubWebSocketUpgradeStart(buffer) {
     if (!Buffer.isBuffer(buffer) || buffer.length < 4) {
         return false;
@@ -2268,12 +2331,29 @@ export function createRemoteHub(options = {}) {
 
     const enabled = isEnabledValue(env.LIVEDESK_REMOTE_HUB ?? env.MINDEXEC_REMOTE_HUB ?? env.REMOTE_HUB_ENABLED, true)
         && !isDisabledValue(env.REMOTE_HUB_DISABLED);
-    const host = safeString(env.REMOTE_HUB_HOST || DEFAULT_REMOTE_HUB_HOST, 128);
-    const requestedPort = normalizePort(env.REMOTE_HUB_PORT || DEFAULT_REMOTE_HUB_PORT);
-    const heartbeatMs = clampNumber(env.REMOTE_HUB_HEARTBEAT_MS, 1000, 60000, DEFAULT_HEARTBEAT_MS);
-    const taskTimeoutMs = clampNumber(
-        options.taskTimeoutMs ?? env.REMOTE_HUB_TASK_TIMEOUT_MS,
-        50,
+    const host = safeString(env.REMOTE_HUB_HOST || DEFAULT_REMOTE_HUB_HOST, 128);
+    const requestedPort = normalizePort(env.REMOTE_HUB_PORT || DEFAULT_REMOTE_HUB_PORT);
+    const heartbeatMs = clampNumber(env.REMOTE_HUB_HEARTBEAT_MS, 1000, 60000, DEFAULT_HEARTBEAT_MS);
+    const defaultDeviceConnectionStaleMs = Math.max(
+        DEFAULT_DEVICE_CONNECTION_STALE_MS,
+        heartbeatMs * 4);
+    const deviceConnectionStaleMs = Number.isFinite(Number(options.deviceConnectionStaleMs))
+        ? clampNumber(options.deviceConnectionStaleMs, 100, 10 * 60 * 1000, defaultDeviceConnectionStaleMs)
+        : clampNumber(
+            env.REMOTE_HUB_DEVICE_CONNECTION_STALE_MS,
+            defaultDeviceConnectionStaleMs,
+            10 * 60 * 1000,
+            defaultDeviceConnectionStaleMs);
+    const deviceConnectionSweepMs = Number.isFinite(Number(options.deviceConnectionSweepMs))
+        ? clampNumber(options.deviceConnectionSweepMs, 25, 60000, DEFAULT_DEVICE_CONNECTION_SWEEP_MS)
+        : clampNumber(
+            env.REMOTE_HUB_DEVICE_CONNECTION_SWEEP_MS,
+            1000,
+            60000,
+            Math.min(DEFAULT_DEVICE_CONNECTION_SWEEP_MS, heartbeatMs));
+    const taskTimeoutMs = clampNumber(
+        options.taskTimeoutMs ?? env.REMOTE_HUB_TASK_TIMEOUT_MS,
+        50,
         30 * 60 * 1000,
         DEFAULT_AGENT_TASK_TIMEOUT_MS);
     const inputAckTimeoutMs = clampNumber(
@@ -2336,16 +2416,18 @@ export function createRemoteHub(options = {}) {
     const audioSockets = new Map();
     const fileSockets = new Map();
     const allSockets = new Set();
-    const agentBinaryIngressStates = new Set();
-    const pendingCommandResultWaiters = new Map();
+    const agentBinaryIngressStates = new Set();
+    const pendingCommandResultWaiters = new Map();
+    const clipboardOperations = new Map();
     const transportDiagnostics = new Map();
     const transportDiagnosticStartingDevices = new Set();
-    const duplicateDeviceLogAt = new Map();
-    let server = null;
-    let started = false;
-    let boundPort = requestedPort;
-    let lastError = '';
-    let hostTarget = null;
+    const duplicateDeviceLogAt = new Map();
+    let server = null;
+    let started = false;
+    let deviceConnectionSweepTimer = null;
+    let boundPort = requestedPort;
+    let lastError = '';
+    let hostTarget = null;
     let publicIPv4Cache = {
         address: safeString(env.LIVEDESK_REMOTE_PUBLIC_IPV4 || env.LIVEDESK_PUBLIC_IPV4 || env.REMOTE_HUB_PUBLIC_IPV4, 64),
         updatedAt: 0,
@@ -2666,12 +2748,14 @@ export function createRemoteHub(options = {}) {
             protocol: 'tcp-jsonl',
             protocolVersion: REMOTE_PROTOCOL_VERSION,
             agentProtocol: REMOTE_AGENT_PROTOCOL,
-            frameProtocol: buildRemoteFrameProtocolDescriptor(),
-            frameModes: getSupportedRemoteFrameModeProfiles(),
-            heartbeatMs,
-            taskTimeoutMs,
-            managerPackage,
-            managerVersion,
+            frameProtocol: buildRemoteFrameProtocolDescriptor(),
+            frameModes: getSupportedRemoteFrameModeProfiles(),
+            heartbeatMs,
+            deviceConnectionStaleMs,
+            deviceConnectionSweepMs,
+            taskTimeoutMs,
+            managerPackage,
+            managerVersion,
             hostInstanceId,
             agentPackage: '@livedesk/client',
             agentEndpoint: routeInfo.endpoint,
@@ -2934,7 +3018,7 @@ export function createRemoteHub(options = {}) {
         return true;
     }
 
-    function failPendingCommandResultWaiters(device, error = 'device-disconnected') {
+    function failPendingCommandResultWaiters(device, error = 'device-disconnected') {
         if (!device?.deviceId) {
             return;
         }
@@ -2951,10 +3035,31 @@ export function createRemoteHub(options = {}) {
                 result: null,
                 error: safeString(error, 500) || 'command-result-unavailable'
             });
-        }
-    }
-
-    function failPendingCommandResultWaiter(device, commandId, error = 'command-not-sent') {
+        }
+    }
+
+    function failPendingFileCommandResultWaiters(device, error = 'file-channel-disconnected') {
+        if (!device?.deviceId) {
+            return;
+        }
+        for (const [waiterKey, waiter] of pendingCommandResultWaiters) {
+            if (waiter.deviceId !== device.deviceId
+                || waiter.sessionId !== device.sessionId
+                || waiter.channel !== 'file') {
+                continue;
+            }
+            pendingCommandResultWaiters.delete(waiterKey);
+            clearPendingCommandResultWaiterDeadline(waiter);
+            waiter.resolve({
+                ok: false,
+                commandId: waiter.commandId,
+                result: null,
+                error: safeString(error, 500) || 'file-channel-disconnected'
+            });
+        }
+    }
+
+    function failPendingCommandResultWaiter(device, commandId, error = 'command-not-sent') {
         const normalizedCommandId = safeString(commandId, 128);
         const waiterKey = buildPendingCommandResultWaiterKey(
             device?.deviceId,
@@ -2975,7 +3080,7 @@ export function createRemoteHub(options = {}) {
         return true;
     }
 
-    function waitForCommandResult(device, commandId, timeoutMs = liveCaptureStopAckTimeoutMs) {
+    function waitForCommandResult(device, commandId, timeoutMs = liveCaptureStopAckTimeoutMs, metadata = {}) {
         const normalizedCommandId = safeString(commandId, 128);
         const waiterKey = buildPendingCommandResultWaiterKey(
             device?.deviceId,
@@ -3001,11 +3106,13 @@ export function createRemoteHub(options = {}) {
                     error: 'command-result-wait-replaced'
                 });
             }
-            const waiterRecord = {
-                deviceId: device.deviceId,
-                sessionId: device.sessionId,
-                commandId: normalizedCommandId,
-                timer: null,
+            const waiterRecord = {
+                deviceId: device.deviceId,
+                sessionId: device.sessionId,
+                commandId: normalizedCommandId,
+                channel: safeString(metadata.channel, 24),
+                operationId: safeString(metadata.operationId, 128),
+                timer: null,
                 deadlineImmediate: null,
                 resolve
             };
@@ -3038,9 +3145,246 @@ export function createRemoteHub(options = {}) {
                 });
             }, timeoutMs);
             waiterRecord.timer.unref?.();
-            pendingCommandResultWaiters.set(waiterKey, waiterRecord);
-        });
-    }
+            pendingCommandResultWaiters.set(waiterKey, waiterRecord);
+        });
+    }
+
+    function buildClipboardOperationKey(deviceId, sessionId, operationId) {
+        const normalizedDeviceId = safeString(deviceId, 160);
+        const normalizedSessionId = safeString(sessionId, 160);
+        const normalizedOperationId = safeString(operationId, 128);
+        return normalizedDeviceId && normalizedSessionId && normalizedOperationId
+            ? `${normalizedDeviceId.length}:${normalizedDeviceId}`
+                + `${normalizedSessionId.length}:${normalizedSessionId}`
+                + `${normalizedOperationId.length}:${normalizedOperationId}`
+            : '';
+    }
+
+    function queueClipboardAgentCleanup(device, operation, reason) {
+        if (operation?.inFlight || !device?.fileSocket || device.fileSocket.destroyed) {
+            return false;
+        }
+        const cleanupCommand = operation.direction === 'paste'
+            ? 'clipboard.paste.cancel'
+            : 'clipboard.copy.end';
+        const commandId = crypto.randomUUID();
+        try {
+            writeJsonLine(device.fileSocket, {
+                type: 'command',
+                commandId,
+                command: cleanupCommand,
+                payload: {
+                    operationId: operation.operationId,
+                    reason: safeString(reason, 120) || 'clipboard-owner-closed'
+                },
+                issuedAt: new Date().toISOString()
+            });
+            device.counters.commandsSent += 1;
+            emitRemoteEvent('RemoteCommandQueued', device, {
+                commandId,
+                command: cleanupCommand,
+                channel: 'file',
+                operationId: operation.operationId,
+                cleanup: true
+            });
+            return true;
+        } catch {
+            // The exact side channel is already closing. Native session
+            // teardown remains the authoritative cleanup.
+            return false;
+        }
+    }
+
+    function clearClipboardOperationsForDevice(device, reason = 'clipboard-owner-closed', ownerConnectionId = '') {
+        const requestedOwner = safeString(ownerConnectionId, 128);
+        let cleared = 0;
+        for (const [key, operation] of clipboardOperations) {
+            if (operation.deviceId !== device?.deviceId
+                || operation.sessionId !== device?.sessionId
+                || (requestedOwner && operation.hubConnectionId !== requestedOwner)) {
+                continue;
+            }
+            queueClipboardAgentCleanup(device, operation, reason);
+            clipboardOperations.delete(key);
+            cleared += 1;
+        }
+        if (cleared > 0) {
+            emitRemoteEvent('RemoteClipboardOperationsCleared', device, {
+                reason,
+                ownerConnectionId: requestedOwner,
+                count: cleared
+            });
+        }
+        return cleared;
+    }
+
+    function pruneClipboardOperations(nowMs = Date.now()) {
+        for (const [key, operation] of clipboardOperations) {
+            const currentDevice = devices.get(operation.deviceId);
+            const expired = nowMs - Number(operation.touchedAt || 0)
+                > REMOTE_CLIPBOARD_LIMITS.operationIdleTimeoutMs;
+            const staleOwner = !currentDevice
+                || currentDevice.sessionId !== operation.sessionId
+                || safeString(currentDevice.inputOwnerConnectionId, 128) !== operation.hubConnectionId;
+            if (expired || staleOwner) {
+                if (currentDevice?.sessionId === operation.sessionId) {
+                    queueClipboardAgentCleanup(
+                        currentDevice,
+                        operation,
+                        expired ? 'clipboard-operation-expired' : 'clipboard-owner-stale');
+                }
+                clipboardOperations.delete(key);
+            }
+        }
+    }
+
+    function clipboardCapabilityError(device, direction, contentKind = 'text') {
+        const capabilities = device?.capabilities || {};
+        if (capabilities.clipboardProtocol !== REMOTE_CLIPBOARD_PROTOCOL
+            || capabilities.clipboardText !== true) {
+            return 'device-clipboard-text-unavailable';
+        }
+        if (capabilities.sessionBoundSideChannels !== true) {
+            return 'device-clipboard-session-bound-channel-unavailable';
+        }
+        if (direction === 'copy' && capabilities.clipboardCopy !== true) {
+            return 'device-clipboard-copy-unavailable';
+        }
+        if (direction === 'paste' && capabilities.clipboardPaste !== true) {
+            return 'device-clipboard-paste-unavailable';
+        }
+        if (contentKind === 'image' && capabilities.clipboardImage !== true) {
+            return 'device-clipboard-image-unavailable';
+        }
+        if (contentKind === 'files' && capabilities.clipboardFiles !== true) {
+            return 'device-clipboard-files-unavailable';
+        }
+        for (const key of ['clipboardMaxTextBytes', 'clipboardMaxTotalBytes', 'clipboardMaxChunkBytes']) {
+            if (!Number.isSafeInteger(Number(capabilities[key])) || Number(capabilities[key]) <= 0) {
+                return 'device-clipboard-limits-unavailable';
+            }
+        }
+        if (Number(capabilities.clipboardMaxChunkBytes) < REMOTE_CLIPBOARD_LIMITS.maxChunkBytes) {
+            return 'device-clipboard-chunk-limit-unavailable';
+        }
+        if (contentKind === 'image'
+            && (!Number.isSafeInteger(Number(
+                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes))
+                || Number(capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes) <= 0)) {
+            return 'device-clipboard-limits-unavailable';
+        }
+        if (contentKind === 'files'
+            && (!Number.isSafeInteger(Number(capabilities.clipboardMaxFiles))
+                || Number(capabilities.clipboardMaxFiles) <= 0)) {
+            return 'device-clipboard-limits-unavailable';
+        }
+        return '';
+    }
+
+    function clipboardManifestCapabilityError(device, manifest) {
+        if (!manifest) {
+            return '';
+        }
+        const capabilities = device?.capabilities || {};
+        if (manifest.totalBytes > Number(capabilities.clipboardMaxTotalBytes || 0)) {
+            return 'device-clipboard-total-limit-exceeded';
+        }
+        if (manifest.contentKind === 'text'
+            && manifest.totalBytes > Number(capabilities.clipboardMaxTextBytes || 0)) {
+            return 'device-clipboard-text-limit-exceeded';
+        }
+        if (manifest.contentKind === 'image'
+            && manifest.totalBytes > Number(
+                capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes ?? 0)) {
+            return 'device-clipboard-image-limit-exceeded';
+        }
+        if (manifest.contentKind === 'files'
+            && manifest.items.length > Number(capabilities.clipboardMaxFiles || 0)) {
+            return 'device-clipboard-file-count-limit-exceeded';
+        }
+        return '';
+    }
+
+    function validateCurrentClipboardBinding(deviceId, request = {}, contentKind = 'text', options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic === true) {
+            return { ok: false, error: 'device-clipboard-unavailable' };
+        }
+        if (device.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected || !device.socket || device.socket.destroyed) {
+            return { ok: false, error: 'device-not-connected' };
+        }
+
+        const policy = getDevicePolicy(device);
+        if (policy.accessMode === 'block-remote-access') {
+            return { ok: false, error: 'remote-access-blocked-by-settings' };
+        }
+        if (policy.allowControl !== true) {
+            return { ok: false, error: 'allowControl-blocked-by-settings' };
+        }
+        if (policy.allowClipboardText !== true) {
+            return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
+        }
+        if (remoteClipboardContentNeedsFileTransfer(contentKind)
+            && policy.allowFileTransfer !== true) {
+            return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
+        }
+
+        const direction = request.clipboardDirection
+            || (String(request.action || '').includes('.paste') ? 'paste' : 'copy');
+        const capabilityError = clipboardCapabilityError(device, direction, contentKind);
+        if (capabilityError) {
+            return { ok: false, error: capabilityError };
+        }
+        const manifestCapabilityError = clipboardManifestCapabilityError(
+            device,
+            request.payload?.manifest || request.manifest);
+        if (manifestCapabilityError) {
+            return { ok: false, error: manifestCapabilityError };
+        }
+
+        const controlStream = getActiveControlStream(device);
+        if (!controlStream
+            || !liveStreamHasCurrentFrame(controlStream)
+            || !safeString(controlStream.commandId, 128)
+            || Number(controlStream.captureGeneration || 0) <= 0) {
+            return { ok: false, error: 'CONTROL_NOT_READY' };
+        }
+        if (getPendingLiveStreamDescriptor(controlStream)) {
+            return { ok: false, error: 'CAPTURE_TRANSITION_IN_PROGRESS' };
+        }
+        const binding = request.binding || request;
+        if (safeString(binding.controlSessionId || binding.sessionId, 160)
+            !== safeString(device.sessionId, 160)
+            || safeString(binding.controlCommandId || binding.commandId, 128)
+            !== safeString(controlStream.commandId, 128)) {
+            return { ok: false, error: 'STALE_CONTROL_SESSION' };
+        }
+        if (Number(binding.captureGeneration || 0)
+            !== Number(controlStream.captureGeneration || 0)) {
+            return { ok: false, error: 'STALE_CAPTURE_GENERATION' };
+        }
+        const activeMonitorIndex = normalizeMonitorIndex(controlStream.monitorIndex);
+        if (Number(binding.monitorIndex) !== activeMonitorIndex) {
+            return { ok: false, error: 'STALE_CONTROL_MONITOR' };
+        }
+        const hubConnectionId = safeString(request.hubConnectionId, 128);
+        if (!hubConnectionId
+            || hubConnectionId !== safeString(device.inputOwnerConnectionId, 128)) {
+            return { ok: false, error: 'input-owner-not-current' };
+        }
+        if (options.requireFileSocket === true
+            && (!device.fileSocket || device.fileSocket.destroyed)) {
+            return { ok: false, error: 'clipboard-file-channel-unavailable' };
+        }
+        return { ok: true, device, controlStream, activeMonitorIndex, policy };
+    }
 
     function inspectAnnexBH264(payload) {
         if (!Buffer.isBuffer(payload) || payload.length < 5) {
@@ -3922,13 +4266,15 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function closeFileSocket(device, reason = 'file-socket-closed') {
-        const socket = device?.fileSocket;
-        if (!socket) {
-            return;
-        }
-
-        device.fileSocket = null;
+    function closeFileSocket(device, reason = 'file-socket-closed') {
+        const socket = device?.fileSocket;
+        if (!socket) {
+            return;
+        }
+
+        clearClipboardOperationsForDevice(device, reason);
+        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
+        device.fileSocket = null;
         fileSockets.delete(socket);
         try {
             writeJsonLine(socket, { type: 'disconnect', channel: 'file', reason });
@@ -3942,13 +4288,14 @@ 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;
+        clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
         device.inputSocketConnectionId = '';
@@ -3968,7 +4315,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) {
@@ -3980,7 +4327,8 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
+        const writeOwner = device.inputWriteOwner;
+        clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
         device.inputSocketConnectionId = '';
@@ -4025,7 +4373,7 @@ export function createRemoteHub(options = {}) {
         emitRemoteEvent('RemoteAudioSocketDisconnected', device, { reason });
     }
 
-    function detachFileSocket(socket, reason = 'file-socket-closed') {
+    function detachFileSocket(socket, reason = 'file-socket-closed') {
         const deviceId = fileSockets.get(socket);
         fileSockets.delete(socket);
         if (!deviceId) {
@@ -4033,38 +4381,107 @@ export function createRemoteHub(options = {}) {
         }
 
         const device = devices.get(deviceId);
-        if (!device || device.fileSocket !== socket) {
-            return;
-        }
-
-        device.fileSocket = null;
+        if (!device || device.fileSocket !== socket) {
+            return;
+        }
+
+        clearClipboardOperationsForDevice(device, reason);
+        failPendingFileCommandResultWaiters(device, 'clipboard-file-channel-disconnected');
+        device.fileSocket = null;
         device.fileLastSeenAt = new Date().toISOString();
-        emitRemoteEvent('RemoteFileSocketDisconnected', device, { reason });
-    }
-
-    function getDeviceActivityMs(device) {
-        return Math.max(
-            Date.parse(device?.lastSeenAt || '') || 0,
-            Date.parse(device?.lastStatusAt || '') || 0,
-            Date.parse(device?.connectedAt || '') || 0
-        );
-    }
-
-    function isDeviceConnectionFresh(device, nowMs = Date.now()) {
+        emitRemoteEvent('RemoteFileSocketDisconnected', device, { reason });
+    }
+
+    function getDeviceConnectionHeartbeatMs(device) {
+        return Date.parse(device?.lastStatusAt || '')
+            || Date.parse(device?.connectedAt || '')
+            || 0;
+    }
+
+    function isDeviceConnectionFresh(device, nowMs = Date.now()) {
         if (!device?.connected || !device.socket || device.socket.destroyed) {
-            return false;
-        }
-
-        const lastActivityMs = getDeviceActivityMs(device);
-        if (!lastActivityMs) {
-            return true;
-        }
-
-        const freshnessMs = Math.max(DUPLICATE_DEVICE_ACTIVE_REJECT_MS, heartbeatMs * 3);
-        return nowMs - lastActivityMs <= freshnessMs;
-    }
-
-    function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
+            return false;
+        }
+
+        const lastHeartbeatMs = getDeviceConnectionHeartbeatMs(device);
+        if (!lastHeartbeatMs) {
+            return true;
+        }
+
+        return nowMs - lastHeartbeatMs <= deviceConnectionStaleMs;
+    }
+
+    function retireStaleDeviceConnection(device, reason = 'status-heartbeat-timeout') {
+        const deviceId = safeString(device?.deviceId, 160);
+        const sessionId = safeString(device?.sessionId, 160);
+        const socket = device?.socket;
+        if (!deviceId
+            || !sessionId
+            || !socket
+            || socket.destroyed
+            || devices.get(deviceId) !== device
+            || device.socket !== socket
+            || device.sessionId !== sessionId) {
+            return false;
+        }
+
+        closeInputSocket(device, reason);
+        closeFrameSocket(device, reason);
+        closeAudioSocket(device, reason);
+        closeFileSocket(device, reason);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', reason, sessionId });
+        } catch {
+            // The stale connection is retired below even if the final notice fails.
+        }
+        detachSocket(socket, reason);
+        try {
+            socket.destroy?.();
+        } catch {
+            // detachSocket already made the exact session terminal.
+        }
+        return true;
+    }
+
+    function sweepStaleDeviceConnections(nowMs = Date.now()) {
+        pruneClipboardOperations(nowMs);
+        let retired = 0;
+        for (const device of devices.values()) {
+            if (device?.synthetic === true || isDeviceConnectionFresh(device, nowMs)) {
+                continue;
+            }
+            if (!device?.connected || !device.socket || device.socket.destroyed) {
+                continue;
+            }
+            const ageMs = Math.max(0, nowMs - getDeviceConnectionHeartbeatMs(device));
+            if (retireStaleDeviceConnection(device, 'status-heartbeat-timeout')) {
+                retired += 1;
+                logWarn(
+                    'remote',
+                    `retired stale device session ${device.deviceName} (${device.deviceId}) `
+                        + `session=${device.sessionId} heartbeatAgeMs=${ageMs} `
+                        + `staleAfterMs=${deviceConnectionStaleMs}`);
+            }
+        }
+        return retired;
+    }
+
+    function scheduleDeviceConnectionSweep() {
+        if (!started || deviceConnectionSweepTimer) {
+            return;
+        }
+        deviceConnectionSweepTimer = setTimeout(() => {
+            deviceConnectionSweepTimer = null;
+            if (!started) {
+                return;
+            }
+            sweepStaleDeviceConnections();
+            scheduleDeviceConnectionSweep();
+        }, deviceConnectionSweepMs);
+        deviceConnectionSweepTimer.unref?.();
+    }
+
+    function rejectDuplicateActiveDevice(socket, existing, attemptedSessionId) {
         const retryAfterMs = Math.max(heartbeatMs, duplicateDeviceRetryAfterMs);
         writeJsonLine(socket, {
             type: 'disconnect',
@@ -4516,16 +4933,20 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
-    function attachInputSocket(socket, hello) {
-        const deviceId = normalizeDeviceId(hello.deviceId);
-        const device = devices.get(deviceId);
+    function attachInputSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
         if (!device || !device.connected || !device.socket || device.socket.destroyed) {
             writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
             socket.destroy();
-            return null;
-        }
-
-        closeInputSocket(device, 'replaced-by-new-input-socket');
+            return null;
+        }
+        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
+            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
+            return null;
+        }
+
+        closeInputSocket(device, 'replaced-by-new-input-socket');
 
         const now = new Date().toISOString();
         const inputSocketConnectionId = crypto.randomUUID();
@@ -4639,16 +5060,20 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
-    function attachFileSocket(socket, hello) {
-        const deviceId = normalizeDeviceId(hello.deviceId);
-        const device = devices.get(deviceId);
+    function attachFileSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
         if (!device || !device.connected || !device.socket || device.socket.destroyed) {
             writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
             socket.destroy();
-            return null;
-        }
-
-        closeFileSocket(device, 'replaced-by-new-file-socket');
+            return null;
+        }
+        if (safeString(hello.parentSessionId, 160) !== safeString(device.sessionId, 160)) {
+            writeJsonLineAndClose(socket, { type: 'error', error: 'side-channel-parent-session-stale' });
+            return null;
+        }
+
+        closeFileSocket(device, 'replaced-by-new-file-socket');
         const now = new Date().toISOString();
         device.fileSocket = socket;
         device.fileConnectedAt = now;
@@ -7971,12 +8396,13 @@ export function createRemoteHub(options = {}) {
             await listenOnPort(requestedPort);
             try {
                 await relayControl?.start?.();
-            } catch {
-                logWarn('relay', 'Encrypted relay control could not start; direct TCP remains available.');
-            }
-        } catch (error) {
-            if (error?.code === 'EADDRINUSE') {
-                const conflict = new Error(
+            } catch {
+                logWarn('relay', 'Encrypted relay control could not start; direct TCP remains available.');
+            }
+            scheduleDeviceConnectionSweep();
+        } catch (error) {
+            if (error?.code === 'EADDRINUSE') {
+                const conflict = new Error(
                     `LiveDesk Hub requires client endpoint TCP ${requestedPort}, but that port is already in use. Close the owning process or start Hub with an explicit --remote-port value.`);
                 conflict.code = 'EADDRINUSE';
                 conflict.port = requestedPort;
@@ -7988,12 +8414,16 @@ export function createRemoteHub(options = {}) {
         }
 
         return getStatus({ includeSecrets: false });
-    }
-
-    async function close() {
-        for (const state of [...agentBinaryIngressStates]) {
-            closeAgentBinaryIngress(state, 'hub-shutdown');
-        }
+    }
+
+    async function close() {
+        if (deviceConnectionSweepTimer) {
+            clearTimeout(deviceConnectionSweepTimer);
+            deviceConnectionSweepTimer = null;
+        }
+        for (const state of [...agentBinaryIngressStates]) {
+            closeAgentBinaryIngress(state, 'hub-shutdown');
+        }
 
         for (const device of devices.values()) {
             abortTransportDiagnosticsForDevice(device, 'hub-shutdown');
@@ -8128,9 +8558,12 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function sendCommand(deviceId, command) {
-        const device = devices.get(String(deviceId || ''));
-        const commandName = safeString(command?.command || 'ping', 80);
+    function sendCommand(deviceId, command) {
+        const device = devices.get(String(deviceId || ''));
+        const commandName = safeString(command?.command || 'ping', 80);
+        if (REMOTE_CLIPBOARD_FILE_ACTIONS.has(commandName)) {
+            return { ok: false, error: 'clipboard-command-requires-awaited-file-channel' };
+        }
         const requiredPermission = commandName === 'input.control'
             ? 'allowControl'
             : commandName === 'system.power'
@@ -8166,12 +8599,16 @@ export function createRemoteHub(options = {}) {
                 result: { ok: true, synthetic: true },
                 error: ''
             });
-            return { ok: true, commandId, synthetic: true };
-        }
-
-        if (!device?.socket || device.socket.destroyed || !device.connected) {
-            return { ok: false, error: 'device-not-connected' };
-        }
+            return { ok: true, commandId, synthetic: true };
+        }
+
+        if (device?.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device?.socket || device.socket.destroyed || !device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
 
         const commandId = safeString(command?.commandId, 128) || crypto.randomUUID();
         const payload = {
@@ -8184,29 +8621,300 @@ export function createRemoteHub(options = {}) {
 
         const dedicatedFileSocket = commandName.startsWith('file.transfer')
             && device.fileSocket
-            && !device.fileSocket.destroyed
-            ? device.fileSocket
-            : null;
-        writeJsonLine(dedicatedFileSocket || device.socket, payload);
-        device.counters.commandsSent += 1;
-        emitRemoteEvent('RemoteCommandQueued', device, {
-            commandId,
+            && !device.fileSocket.destroyed
+            ? device.fileSocket
+            : null;
+        try {
+            writeJsonLine(dedicatedFileSocket || device.socket, payload);
+        } catch {
+            retireStaleDeviceConnection(device, 'command-channel-write-failed');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        device.counters.commandsSent += 1;
+        emitRemoteEvent('RemoteCommandQueued', device, {
+            commandId,
             command: payload.command,
             channel: dedicatedFileSocket ? 'file' : 'control'
         });
-        return { ok: true, commandId };
-    }
-
-    function refreshDevicePolicies(deviceIds = undefined) {
+        return { ok: true, commandId };
+    }
+
+    async function sendClipboardCommand(deviceId, request = {}) {
+        pruneClipboardOperations();
+        const action = safeString(request.action, 80).toLowerCase();
+        if (!REMOTE_CLIPBOARD_FILE_ACTIONS.has(action)) {
+            return { ok: false, error: 'clipboard-file-action-invalid' };
+        }
+        const operationId = safeString(request.operationId, 128);
+        if (!operationId) {
+            return { ok: false, error: 'clipboard-operation-id-invalid' };
+        }
+
+        const direction = action.startsWith('clipboard.paste.')
+            ? 'paste'
+            : action.startsWith('clipboard.copy.')
+                ? 'copy'
+                : '';
+        const operationKey = buildClipboardOperationKey(deviceId, request.binding?.controlSessionId, operationId);
+        let operation = clipboardOperations.get(operationKey);
+        const beginsOperation = action === 'clipboard.copy.begin' || action === 'clipboard.paste.begin';
+        const endsOperation = action === 'clipboard.copy.end' || action === 'clipboard.paste.cancel';
+        const requestedManifest = request.payload?.manifest || null;
+
+        if (beginsOperation) {
+            if (operation) {
+                return { ok: false, error: 'clipboard-operation-already-exists' };
+            }
+            const activeForDevice = [...clipboardOperations.values()].filter(candidate =>
+                candidate.deviceId === String(deviceId || '')
+                && candidate.sessionId === request.binding?.controlSessionId);
+            if (activeForDevice.some(candidate => candidate.direction === direction)) {
+                return { ok: false, error: 'clipboard-operation-direction-busy' };
+            }
+            if (activeForDevice.length >= REMOTE_CLIPBOARD_LIMITS.maxOperationsPerDevice) {
+                return { ok: false, error: 'clipboard-operation-capacity-reached' };
+            }
+            operation = {
+                deviceId: String(deviceId || ''),
+                sessionId: safeString(request.binding?.controlSessionId, 160),
+                operationId,
+                direction,
+                hubConnectionId: safeString(request.hubConnectionId, 128),
+                controlCommandId: safeString(request.binding?.controlCommandId, 128),
+                captureGeneration: Number(request.binding?.captureGeneration || 0),
+                monitorIndex: Number(request.binding?.monitorIndex),
+                contentKind: requestedManifest?.contentKind || 'text',
+                manifest: requestedManifest,
+                offsets: new Map(),
+                status: action === 'clipboard.paste.begin' ? 'preparing' : 'copying',
+                inFlight: false,
+                touchedAt: Date.now()
+            };
+            clipboardOperations.set(operationKey, operation);
+        } else {
+            if (!operation) {
+                return { ok: false, error: 'clipboard-operation-not-found' };
+            }
+            const requestedDirection = direction || operation.direction;
+            if (operation.direction !== requestedDirection
+                || operation.hubConnectionId !== safeString(request.hubConnectionId, 128)
+                || operation.controlCommandId !== safeString(request.binding?.controlCommandId, 128)
+                || operation.captureGeneration !== Number(request.binding?.captureGeneration || 0)
+                || operation.monitorIndex !== Number(request.binding?.monitorIndex)) {
+                return { ok: false, error: 'clipboard-operation-owner-stale' };
+            }
+        }
+
+        if (operation.inFlight) {
+            return { ok: false, error: 'clipboard-operation-busy' };
+        }
+
+        const contentKind = operation.contentKind || requestedManifest?.contentKind || 'text';
+        const bindingResult = validateCurrentClipboardBinding(
+            deviceId,
+            { ...request, clipboardDirection: operation.direction },
+            contentKind,
+            { requireFileSocket: true });
+        if (!bindingResult.ok) {
+            if (beginsOperation || bindingResult.error?.startsWith('STALE_') || bindingResult.error === 'input-owner-not-current') {
+                clipboardOperations.delete(operationKey);
+            }
+            return bindingResult;
+        }
+
+        const { device } = bindingResult;
+        const fileSocket = device.fileSocket;
+        const itemIndex = request.payload?.itemIndex;
+        const expectedOffset = Number.isInteger(itemIndex)
+            ? Number(operation.offsets.get(itemIndex) || 0)
+            : 0;
+        let outgoingChunkBytes = 0;
+        if (action === 'clipboard.copy.chunk' || action === 'clipboard.paste.chunk') {
+            const item = operation.manifest?.items?.[itemIndex];
+            if (!item) {
+                return { ok: false, error: 'clipboard-item-not-found' };
+            }
+            if (request.payload.offset !== expectedOffset) {
+                return { ok: false, error: 'clipboard-chunk-offset-stale', expectedOffset };
+            }
+            if (action === 'clipboard.copy.chunk'
+                && request.payload.maxBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+            }
+            if (action === 'clipboard.paste.chunk') {
+                outgoingChunkBytes = Buffer.from(request.payload.dataBase64, 'base64').length;
+                if (outgoingChunkBytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+                }
+                const nextOffset = expectedOffset + outgoingChunkBytes;
+                if (outgoingChunkBytes === 0
+                    && !(item.size === 0 && expectedOffset === 0 && request.payload.final === true)) {
+                    return { ok: false, error: 'clipboard-empty-chunk-invalid' };
+                }
+                if (nextOffset > item.size
+                    || request.payload.final !== (nextOffset === item.size)) {
+                    return { ok: false, error: 'clipboard-chunk-boundary-invalid' };
+                }
+            }
+        }
+
+        operation.inFlight = true;
+        operation.touchedAt = Date.now();
+        let commandCompleted = false;
+        const commandId = crypto.randomUUID();
+        const resultPromise = waitForCommandResult(
+            device,
+            commandId,
+            REMOTE_CLIPBOARD_LIMITS.commandTimeoutMs,
+            { channel: 'file', operationId });
+        const commandPayload = {
+            type: 'command',
+            commandId,
+            command: action,
+            payload: {
+                operationId,
+                controlSessionId: operation.sessionId,
+                controlCommandId: operation.controlCommandId,
+                captureGeneration: operation.captureGeneration,
+                monitorIndex: operation.monitorIndex,
+                hubConnectionId: operation.hubConnectionId,
+                ...(request.payload || {})
+            },
+            issuedAt: new Date().toISOString()
+        };
+
+        try {
+            try {
+                // Clipboard payloads are never allowed onto the concurrent
+                // main command socket. The dedicated file side channel owns
+                // the one bounded command and its exact-session waiter.
+                writeJsonLine(fileSocket, commandPayload);
+            } catch {
+                failPendingCommandResultWaiter(device, commandId, 'clipboard-file-channel-write-failed');
+                if (device.fileSocket === fileSocket) {
+                    closeFileSocket(device, 'clipboard-file-channel-write-failed');
+                }
+                return { ok: false, error: 'clipboard-file-channel-unavailable' };
+            }
+            device.counters.commandsSent += 1;
+            emitRemoteEvent('RemoteCommandQueued', device, {
+                commandId,
+                command: action,
+                channel: 'file',
+                operationId
+            });
+
+            const awaited = await resultPromise;
+            if (!awaited.ok) {
+                return {
+                    ok: false,
+                    error: awaited.error || 'clipboard-command-failed',
+                    commandId
+                };
+            }
+            if (device.fileSocket !== fileSocket) {
+                return { ok: false, error: 'clipboard-file-channel-owner-changed' };
+            }
+            const currentBinding = validateCurrentClipboardBinding(
+                deviceId,
+                { ...request, clipboardDirection: operation.direction },
+                operation.contentKind || 'text',
+                { requireFileSocket: true });
+            if (!currentBinding.ok) {
+                return currentBinding;
+            }
+
+            let response;
+            try {
+                response = normalizeRemoteClipboardCommandResult(action, operationId, awaited.result);
+            } catch (error) {
+                return {
+                    ok: false,
+                    error: safeString(error?.code || error?.message, 160) || 'clipboard-response-invalid'
+                };
+            }
+            if (response.manifest) {
+                const responseManifestLimitError = clipboardManifestCapabilityError(device, response.manifest);
+                if (responseManifestLimitError) {
+                    clipboardOperations.delete(operationKey);
+                    return { ok: false, error: responseManifestLimitError };
+                }
+                const responsePolicy = validateCurrentClipboardBinding(
+                    deviceId,
+                    { ...request, clipboardDirection: operation.direction },
+                    response.manifest.contentKind,
+                    { requireFileSocket: true });
+                if (!responsePolicy.ok) {
+                    clipboardOperations.delete(operationKey);
+                    return responsePolicy;
+                }
+                operation.manifest = response.manifest;
+                operation.contentKind = response.manifest.contentKind;
+            }
+            if (action === 'clipboard.copy.chunk') {
+                const item = operation.manifest?.items?.[response.itemIndex];
+                const nextOffset = response.offset + response.bytes;
+                if (!item
+                    || response.itemIndex !== itemIndex
+                    || response.offset !== expectedOffset
+                    || (response.bytes === 0
+                        && !(item.size === 0 && response.offset === 0 && response.final === true))
+                    || nextOffset > item.size
+                    || response.final !== (nextOffset === item.size)) {
+                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
+                }
+                if (response.bytes > Number(device.capabilities?.clipboardMaxChunkBytes || 0)) {
+                    return { ok: false, error: 'device-clipboard-chunk-limit-exceeded' };
+                }
+                operation.offsets.set(response.itemIndex, nextOffset);
+            } else if (action === 'clipboard.paste.chunk') {
+                if (response.itemIndex !== itemIndex
+                    || response.offset !== expectedOffset
+                    || response.bytes !== outgoingChunkBytes
+                    || response.totalBytes !== operation.manifest.items[itemIndex].size
+                    || response.final !== request.payload.final) {
+                    return { ok: false, error: 'clipboard-chunk-response-boundary-invalid' };
+                }
+                operation.offsets.set(itemIndex, expectedOffset + outgoingChunkBytes);
+            }
+            operation.status = response.status || operation.status;
+            operation.touchedAt = Date.now();
+            if (action === 'clipboard.operation.status' && operation.status === 'not-found') {
+                clipboardOperations.delete(operationKey);
+                return { ok: false, error: 'clipboard-operation-not-found' };
+            }
+            if (action === 'clipboard.operation.status'
+                && ['completed', 'complete', 'applied', 'pasted', 'cancelled', 'cleaned', 'failed', 'expired', 'already-ended']
+                    .includes(operation.status)) {
+                clipboardOperations.delete(operationKey);
+            }
+            commandCompleted = true;
+            return response;
+        } finally {
+            const currentOperation = clipboardOperations.get(operationKey);
+            if (currentOperation === operation) {
+                operation.inFlight = false;
+                if (endsOperation || (beginsOperation && !commandCompleted)) {
+                    clipboardOperations.delete(operationKey);
+                }
+            }
+        }
+    }
+
+    function refreshDevicePolicies(deviceIds = undefined) {
         const requestedIds = Array.isArray(deviceIds) && deviceIds.length > 0
             ? new Set(deviceIds.map(deviceId => safeString(deviceId, 160)).filter(Boolean))
             : null;
         let updated = 0;
         let total = 0;
-        for (const device of devices.values()) {
-            if (requestedIds && !requestedIds.has(device.deviceId)) continue;
-            if (!device?.socket || device.socket.destroyed || !device.connected) continue;
-            total += 1;
+        for (const device of devices.values()) {
+            if (requestedIds && !requestedIds.has(device.deviceId)) continue;
+            if (!device?.socket || device.socket.destroyed || !device.connected) continue;
+            if (device.synthetic !== true && !isDeviceConnectionFresh(device)) {
+                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+                continue;
+            }
+            total += 1;
             const effectivePolicy = getDevicePolicy(device);
             if (writeJsonLine(device.socket, {
                 type: 'policy.update',
@@ -8225,8 +8933,14 @@ export function createRemoteHub(options = {}) {
         const device = devices.get(String(deviceId || ''));
         const denied = policyError(device);
         if (denied) return { ok: false, error: denied };
-        if (!device) return { ok: false, error: 'device-not-found' };
-        if (!device.socket || device.socket.destroyed || !device.connected) {
+        if (!device) return { ok: false, error: 'device-not-found' };
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
 
@@ -8322,15 +9036,21 @@ export function createRemoteHub(options = {}) {
         return device.inputWriteOwner;
     }
 
-    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' };
-        }
+    function sendInputControl(deviceId, input = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
+            return { ok: false, error: 'device-not-connected' };
+        }
 
         const normalized = normalizeRemoteInputEvent(input);
         if (!normalized.type) {
@@ -8396,9 +9116,51 @@ export function createRemoteHub(options = {}) {
             || device.capabilities?.accessibilityPermission === false) {
             return { ok: false, error: 'INPUT_PERMISSION_DENIED' };
         }
-        if (!readCapabilityFlag(device.capabilities, 'control')) {
-            return { ok: false, error: 'device-input-control-unavailable' };
-        }
+        if (!readCapabilityFlag(device.capabilities, 'control')) {
+            return { ok: false, error: 'device-input-control-unavailable' };
+        }
+
+        const normalizedInputType = normalized.type.toLowerCase();
+        const isClipboardInput = normalizedInputType === 'clipboard.prepare'
+            || normalizedInputType === 'clipboard.copy'
+            || normalizedInputType === 'clipboard.paste';
+        let clipboardManifest = null;
+        if (isClipboardInput) {
+            if (!normalized.clipboardOperationId) {
+                return { ok: false, error: 'clipboard-operation-id-invalid' };
+            }
+            if (!['copy', 'paste'].includes(normalized.clipboardDirection)) {
+                return { ok: false, error: 'clipboard-direction-required' };
+            }
+            if ((normalizedInputType === 'clipboard.copy' && normalized.clipboardDirection !== 'copy')
+                || (normalizedInputType === 'clipboard.paste' && normalized.clipboardDirection !== 'paste')) {
+                return { ok: false, error: 'clipboard-direction-mismatch' };
+            }
+            try {
+                clipboardManifest = normalized.manifest
+                    ? normalizeRemoteClipboardManifest(normalized.manifest, normalized.clipboardOperationId)
+                    : null;
+            } catch (error) {
+                return { ok: false, error: safeString(error?.code || error?.message, 160) || 'clipboard-manifest-invalid' };
+            }
+            const clipboardPolicy = getDevicePolicy(device);
+            if (clipboardPolicy.allowClipboardText !== true) {
+                return { ok: false, error: 'allowClipboardText-blocked-by-settings' };
+            }
+            const contentKind = clipboardManifest?.contentKind || normalized.contentKind || 'text';
+            if (remoteClipboardContentNeedsFileTransfer(contentKind)
+                && clipboardPolicy.allowFileTransfer !== true) {
+                return { ok: false, error: 'allowFileTransfer-blocked-by-settings' };
+            }
+            const clipboardCapabilityDenied = clipboardCapabilityError(
+                device,
+                normalized.clipboardDirection,
+                contentKind);
+            if (clipboardCapabilityDenied) {
+                return { ok: false, error: clipboardCapabilityDenied };
+            }
+            normalized.manifest = clipboardManifest;
+        }
 
         const controlStream = getActiveControlStream(device);
         if (!controlStream
@@ -8434,14 +9196,32 @@ export function createRemoteHub(options = {}) {
             };
         }
         const activeMonitorIndex = normalizeMonitorIndex(controlStream.monitorIndex);
-        if (!Number.isInteger(normalized.monitorIndex)
-            || normalized.monitorIndex !== activeMonitorIndex) {
+        if (!Number.isInteger(normalized.monitorIndex)
+            || normalized.monitorIndex !== activeMonitorIndex) {
             return {
                 ok: false,
                 error: 'STALE_CONTROL_MONITOR',
-                activeMonitorIndex
-            };
-        }
+                activeMonitorIndex
+            };
+        }
+
+        let clipboardOperationKey = '';
+        if (normalizedInputType === 'clipboard.paste') {
+            clipboardOperationKey = buildClipboardOperationKey(
+                device.deviceId,
+                device.sessionId,
+                normalized.clipboardOperationId);
+            const operation = clipboardOperations.get(clipboardOperationKey);
+            if (!operation
+                || operation.direction !== 'paste'
+                || operation.hubConnectionId !== normalized.hubConnectionId
+                || operation.controlCommandId !== normalized.controlCommandId
+                || operation.captureGeneration !== normalized.captureGeneration
+                || operation.monitorIndex !== normalized.monitorIndex
+                || operation.status !== 'ready') {
+                return { ok: false, error: 'clipboard-paste-not-ready' };
+            }
+        }
 
         const inputSocket = device.inputSocket;
         const inputWriteOwner = getCurrentInputWriteOwner(device);
@@ -8458,9 +9238,17 @@ export function createRemoteHub(options = {}) {
                 && normalized.hubConnectionId !== previousOwnerConnectionId;
             const bindingChanged = previousInputBindingKey
                 && previousInputBindingKey !== activeInputBindingKey;
-            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
-            if (ownerChanged || bindingChanged || writeBindingChanged) {
-                const resetSent = inputWriteOwner.replaceBinding(
+            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
+            if (ownerChanged || bindingChanged || writeBindingChanged) {
+                if (ownerChanged) {
+                    clearClipboardOperationsForDevice(
+                        device,
+                        'browser-input-owner-changed',
+                        previousOwnerConnectionId);
+                } else if (bindingChanged || writeBindingChanged) {
+                    clearClipboardOperationsForDevice(device, 'control-input-binding-changed');
+                }
+                const resetSent = inputWriteOwner.replaceBinding(
                     activeInputBindingKey,
                     buildRemoteInputResetMessage(
                         device,
@@ -8490,9 +9278,16 @@ export function createRemoteHub(options = {}) {
                     device.inputOwnerConnectionId = normalized.hubConnectionId;
                 }
                 device.inputOwnerBindingKey = activeInputBindingKey;
-                device.counters.commandsSent += 1;
-                device.inputLastSeenAt = new Date().toISOString();
-                return {
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                if (clipboardOperationKey) {
+                    const operation = clipboardOperations.get(clipboardOperationKey);
+                    if (operation) {
+                        operation.status = 'pasting';
+                        operation.touchedAt = Date.now();
+                    }
+                }
+                return {
                     ok: true,
                     inputSocket: true,
                     sessionId: device.sessionId,
@@ -8527,7 +9322,7 @@ export function createRemoteHub(options = {}) {
                 issuedAt: normalized.issuedAt || new Date().toISOString()
             }
         });
-        if (fallback.ok && normalized.requestAck && normalized.inputSeq > 0) {
+        if (fallback.ok && normalized.requestAck && normalized.inputSeq > 0) {
             schedulePendingInputFallback(device, {
                 commandId: fallback.commandId,
                 inputSeq: normalized.inputSeq,
@@ -8539,9 +9334,16 @@ export function createRemoteHub(options = {}) {
                 hubReceivedAtEpochMs: normalized.hubReceivedAtEpochMs,
                 hubForwardedAtEpochMs,
                 fallback: true,
-                timeoutTimer: null
-            });
-        }
+                timeoutTimer: null
+            });
+        }
+        if (fallback.ok && clipboardOperationKey) {
+            const operation = clipboardOperations.get(clipboardOperationKey);
+            if (operation) {
+                operation.status = 'pasting';
+                operation.touchedAt = Date.now();
+            }
+        }
         return fallback.ok
             ? {
                 ...fallback,
@@ -8561,14 +9363,15 @@ export function createRemoteHub(options = {}) {
             };
     }
 
-    function releaseInputOwner(deviceId, ownerConnectionId, reason = 'browser-input-owner-closed') {
+    function releaseInputOwner(deviceId, ownerConnectionId, reason = 'browser-input-owner-closed') {
         const device = devices.get(String(deviceId || ''));
         const owner = safeString(ownerConnectionId, 128);
-        if (!device || !owner || safeString(device.inputOwnerConnectionId, 128) !== owner) {
-            return { ok: false, error: 'input-owner-not-current' };
-        }
-
-        device.inputOwnerConnectionId = '';
+        if (!device || !owner || safeString(device.inputOwnerConnectionId, 128) !== owner) {
+            return { ok: false, error: 'input-owner-not-current' };
+        }
+
+        clearClipboardOperationsForDevice(device, reason, owner);
+        device.inputOwnerConnectionId = '';
         device.inputOwnerBindingKey = '';
         const inputSocket = device.inputSocket;
         const inputWriteOwner = getCurrentInputWriteOwner(device);
@@ -8612,8 +9415,12 @@ export function createRemoteHub(options = {}) {
         };
         const results = targets.map(deviceId => {
             const device = devices.get(deviceId);
-            if (device?.synthetic === true && device.connected) return { deviceId, ok: true, synthetic: true };
-            if (!device?.connected || !device.socket || device.socket.destroyed) {
+            if (device?.synthetic === true && device.connected) return { deviceId, ok: true, synthetic: true };
+            if (device?.connected && !isDeviceConnectionFresh(device)) {
+                retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+                return { deviceId, ok: false, error: 'device-not-connected' };
+            }
+            if (!device?.connected || !device.socket || device.socket.destroyed) {
                 return { deviceId, ok: false, error: 'device-not-connected' };
             }
             return writeJsonLine(device.socket, payload)
@@ -8645,7 +9452,7 @@ export function createRemoteHub(options = {}) {
         const denied = policyError(device, 'allowAgent');
         if (denied) return { ok: false, error: denied };
 
-        if (device?.synthetic === true && device.connected) {
+        if (device?.synthetic === true && device.connected) {
             const instruction = safeText(options.instruction, MAX_AGENT_TASK_CHARS);
             if (!instruction) {
                 return { ok: false, error: 'missing-instruction' };
@@ -8705,10 +9512,14 @@ export function createRemoteHub(options = {}) {
                 error: '',
                 synthetic: true
             });
-            return { ok: true, commandId, taskId, approvalLevel, synthetic: true };
-        }
-
-        if (!device?.socket || device.socket.destroyed || !device.connected) {
+            return { ok: true, commandId, taskId, approvalLevel, synthetic: true };
+        }
+
+        if (device.connected && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device?.socket || device.socket.destroyed || !device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
 
@@ -9528,11 +10339,58 @@ export function createRemoteHub(options = {}) {
                 === normalized.streamPurpose;
     }
 
-    function startLiveStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        const denied = policyError(device);
-        if (denied) return { ok: false, error: denied };
-        if (device?.liveCapturePause?.token) {
+    function liveStreamMatchesOwnerIdentity(activeLiveStream, normalized) {
+        if (!activeLiveStream) {
+            return false;
+        }
+        return activeLiveStream.frameMode === normalized.transfer.frameMode
+            && Number(activeLiveStream.monitorIndex || 0) === normalized.monitorIndex
+            && (safeString(activeLiveStream.streamPurpose, 24).toLowerCase() || 'wall')
+                === normalized.streamPurpose;
+    }
+
+    function sharedLiveProfileResult(device, activeLiveStream, normalized, extra = {}) {
+        return {
+            ok: true,
+            commandId: activeLiveStream.commandId,
+            sessionId: device.sessionId,
+            streamId: activeLiveStream.streamId,
+            streamPurpose: safeString(activeLiveStream.streamPurpose, 24) || normalized.streamPurpose,
+            fps: Number(activeLiveStream.fps || normalized.fps),
+            mode: activeLiveStream.mode || normalized.transfer.mode,
+            frameMode: activeLiveStream.frameMode || normalized.transfer.frameMode,
+            monitorIndex: Number(activeLiveStream.monitorIndex ?? normalized.monitorIndex),
+            captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+            ready: liveStreamHasCurrentFrame(activeLiveStream),
+            reused: true,
+            sharedProfileReused: true,
+            requestedProfile: {
+                fps: normalized.fps,
+                maxWidth: normalized.maxWidth,
+                maxHeight: normalized.maxHeight,
+                quality: normalized.quality
+            },
+            effectiveProfile: {
+                fps: Number(activeLiveStream.fps || normalized.fps),
+                maxWidth: Number(activeLiveStream.maxWidth || normalized.maxWidth),
+                maxHeight: Number(activeLiveStream.maxHeight || normalized.maxHeight),
+                quality: Number(activeLiveStream.quality || normalized.quality)
+            },
+            ...extra
+        };
+    }
+
+    function startLiveStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        const denied = policyError(device);
+        if (denied) return { ok: false, error: denied };
+        if (device?.synthetic !== true
+            && device?.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (device?.liveCapturePause?.token) {
             return {
                 ok: false,
                 error: 'LIVE_CAPTURE_PAUSED',
@@ -9664,6 +10522,13 @@ export function createRemoteHub(options = {}) {
         const modePolicyError = liveStreamModePolicyError(normalized);
         if (modePolicyError) return { ok: false, error: modePolicyError };
         const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
+        if (deviceExplicitlyRejectsFrameMode(device, transfer.frameMode)) {
+            return {
+                ok: false,
+                error: 'device-frame-mode-unavailable',
+                frameMode: transfer.frameMode
+            };
+        }
         const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
         if (!reserveDeviceLiveStreamDescriptor(device, streamId)) {
             return {
@@ -9678,13 +10543,24 @@ export function createRemoteHub(options = {}) {
         const pendingDescriptor = getPendingLiveStreamDescriptor(activeLiveStream);
         if (pendingDescriptor?.commandId) {
             const pendingMatchesRequest = liveStreamMatchesOptions(pendingDescriptor, normalized);
-            if (pendingMatchesRequest && liveStreamReplacementStillPending(activeLiveStream)) {
+            const pendingMatchesSharedOwner = options.forceRestart !== true
+                && options.reuseExisting === true
+                && options.reuseSharedExisting === true
+                && liveStreamMatchesOwnerIdentity(pendingDescriptor, normalized);
+            if ((pendingMatchesRequest || pendingMatchesSharedOwner)
+                && liveStreamReplacementStillPending(activeLiveStream)) {
                 emitRemoteEvent('RemoteLiveStreamRestartPending', device, {
                     streamId,
                     commandId: pendingDescriptor.commandId,
                     activeCommandId: activeLiveStream.commandId,
                     reason: safeString(options.restartReason || 'duplicate-restart', 128)
                 });
+                if (pendingMatchesSharedOwner && !pendingMatchesRequest) {
+                    return sharedLiveProfileResult(device, pendingDescriptor, normalized, {
+                        ready: false,
+                        pending: true
+                    });
+                }
                 return {
                     ok: true,
                     commandId: pendingDescriptor.commandId,
@@ -9758,6 +10634,25 @@ export function createRemoteHub(options = {}) {
                 reused: true
             };
         }
+        if (activeLiveStream
+            && options.forceRestart !== true
+            && options.reuseExisting === true
+            && options.reuseSharedExisting === true
+            && liveStreamMatchesOwnerIdentity(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
+            emitRemoteEvent('RemoteLiveStreamSharedProfileReused', device, {
+                streamId,
+                commandId: activeLiveStream.commandId,
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                requestedFps: normalized.fps,
+                effectiveFps: Number(activeLiveStream.fps || normalized.fps),
+                requestedMaxWidth: normalized.maxWidth,
+                requestedMaxHeight: normalized.maxHeight,
+                effectiveMaxWidth: Number(activeLiveStream.maxWidth || normalized.maxWidth),
+                effectiveMaxHeight: Number(activeLiveStream.maxHeight || normalized.maxHeight)
+            });
+            return sharedLiveProfileResult(device, activeLiveStream, normalized);
+        }
         if (activeLiveStream
             && options.forceRestart !== true
             && liveStreamMatchesOptions(activeLiveStream, normalized)
@@ -9926,9 +10821,15 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function stopLiveStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        const stopAll = options.stopAll === true;
+    function stopLiveStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (device?.synthetic !== true
+            && device?.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        const stopAll = options.stopAll === true;
         const streamPurpose = safeString(options.streamPurpose || options.purpose, 24).toLowerCase();
         const requestedStreamId = safeString(options.streamId, 128);
         const purposeStreams = !stopAll && !requestedStreamId && streamPurpose && device
@@ -10529,12 +11430,18 @@ export function createRemoteHub(options = {}) {
         };
     }
 
-    function startAudioStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
-        }
-        if (!device.connected) {
+    function startAudioStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
         const denied = policyError(device, 'allowRemoteAudio');
@@ -10611,12 +11518,18 @@ export function createRemoteHub(options = {}) {
         return { ok: true, commandId, streamId };
     }
 
-    function stopAudioStream(deviceId, options = {}) {
-        const device = devices.get(String(deviceId || ''));
-        if (!device) {
-            return { ok: false, error: 'device-not-found' };
-        }
-        if (!device.connected) {
+    function stopAudioStream(deviceId, options = {}) {
+        const device = devices.get(String(deviceId || ''));
+        if (!device) {
+            return { ok: false, error: 'device-not-found' };
+        }
+        if (device.synthetic !== true
+            && device.connected
+            && !isDeviceConnectionFresh(device)) {
+            retireStaleDeviceConnection(device, 'status-heartbeat-timeout');
+            return { ok: false, error: 'device-not-connected' };
+        }
+        if (!device.connected) {
             return { ok: false, error: 'device-not-connected' };
         }
         if (device.synthetic === true || !device.socket || device.socket.destroyed) {
@@ -10829,10 +11742,14 @@ export function createRemoteHub(options = {}) {
                 replacementTimerCount: device.liveStreamReplacementTimers instanceof Map
                     ? device.liveStreamReplacementTimers.size
                     : 0,
-                commandResultWaiterCount: [...pendingCommandResultWaiters.values()]
-                    .filter(waiter => waiter.deviceId === device.deviceId
-                        && waiter.sessionId === device.sessionId)
-                    .length,
+                commandResultWaiterCount: [...pendingCommandResultWaiters.values()]
+                    .filter(waiter => waiter.deviceId === device.deviceId
+                        && waiter.sessionId === device.sessionId)
+                    .length,
+                clipboardOperationCount: [...clipboardOperations.values()]
+                    .filter(operation => operation.deviceId === device.deviceId
+                        && operation.sessionId === device.sessionId)
+                    .length,
                 retainedPayloadCount: retainedPayloads.size,
                 retainedPayloadBytes: [...retainedPayloads].reduce(
                     (total, payload) => total + payload.length,
@@ -10842,8 +11759,9 @@ export function createRemoteHub(options = {}) {
                 && snapshot.stopPendingCount === 0
                 && snapshot.pendingStartCount === 0
                 && snapshot.pendingStopPromiseCount === 0
-                && snapshot.replacementTimerCount === 0
-                && snapshot.commandResultWaiterCount === 0
+                && snapshot.replacementTimerCount === 0
+                && snapshot.commandResultWaiterCount === 0
+                && snapshot.clipboardOperationCount === 0
                 && snapshot.retainedPayloadCount === 0
                 && snapshot.retainedPayloadBytes === 0;
             return snapshot;
@@ -10855,8 +11773,9 @@ export function createRemoteHub(options = {}) {
                 'stopPendingCount',
                 'pendingStartCount',
                 'pendingStopPromiseCount',
-                'replacementTimerCount',
-                'commandResultWaiterCount',
+                'replacementTimerCount',
+                'commandResultWaiterCount',
+                'clipboardOperationCount',
                 'retainedPayloadCount',
                 'retainedPayloadBytes'
             ]) {
@@ -10869,9 +11788,10 @@ export function createRemoteHub(options = {}) {
             stopPendingCount: 0,
             pendingStartCount: 0,
             pendingStopPromiseCount: 0,
-            replacementTimerCount: 0,
-            commandResultWaiterCount: 0,
-            retainedPayloadCount: 0,
+            replacementTimerCount: 0,
+            commandResultWaiterCount: 0,
+            clipboardOperationCount: 0,
+            retainedPayloadCount: 0,
             retainedPayloadBytes: 0
         });
         return {
@@ -10911,8 +11831,9 @@ export function createRemoteHub(options = {}) {
         listDeviceFrames,
         disconnectDevice,
         assignDeviceSlot,
-        sendCommand,
-        refreshDevicePolicies,
+        sendCommand,
+        sendClipboardCommand,
+        refreshDevicePolicies,
         sendLegacyClientUpdate,
         sendInputControl,
         releaseInputOwner,