@livedesk/hub 0.1.47 → 0.1.49

package/src/server.js

@@ -8,7 +8,12 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
 import { WebSocketServer } from 'ws';
-import { createRemoteHub } from './remote-hub.js';
+import { createRemoteHub } from './remote-hub.js';
+import {
+  REMOTE_CLIPBOARD_INPUT_ACTIONS,
+  RemoteClipboardContractError,
+  normalizeRemoteClipboardRequest
+} from './remote-clipboard-contract.mjs';
 import { createHubConsoleRelay } from './console-relay.js';
 import {
   buildImmutableRemoteFramePacket,
@@ -1162,9 +1167,11 @@ async function dispatchAgentMcpTool(session, name, args = {}) {
     'livedesk.close_application': 'application.close',
     'livedesk.read_file': 'file.read',
     'livedesk.write_file': 'file.write',
-    'livedesk.delete_file': 'file.delete',
-    'livedesk.list_directory': 'file.list',
-    'livedesk.run_command': 'command.run',
+    'livedesk.delete_file': 'file.delete',
+    'livedesk.list_directory': 'file.list',
+    'livedesk.search_files': 'file.search',
+    'livedesk.create_directory': 'directory.create',
+    'livedesk.run_command': 'command.run',
     'livedesk.run_script': 'script.run',
     'livedesk.install_software': 'software.install',
     'livedesk.get_network_status': 'network.status',
@@ -1754,12 +1761,40 @@ function normalizeLiveOptions(payload = {}) {
   };
 }
 
-function sendJson(ws, payload) {
+function sendJson(ws, payload) {
   if (!ws || ws.readyState !== 1) {
     return false;
   }
   return safeWebSocketSend(ws, JSON.stringify(payload));
-}
+}
+
+function findLiveRemoteInputClient(hubConnectionId) {
+  const requestedId = String(hubConnectionId || '').trim();
+  if (!requestedId) {
+    return null;
+  }
+  for (const ws of inputClients) {
+    if (ws.readyState === 1 && ws.liveDeskInputClientId === requestedId) {
+      return ws;
+    }
+  }
+  return null;
+}
+
+function clipboardHttpStatus(error) {
+  const code = String(error || '');
+  if (code.includes('blocked-by-settings') || code === 'remote-access-blocked-by-settings') return 403;
+  if (code.includes('too-large')) return 413;
+  if (code.includes('unavailable') || code === 'device-not-connected') return 503;
+  if (code.startsWith('STALE_')
+    || code.includes('owner')
+    || code.includes('not-ready')
+    || code.includes('not-found')
+    || code.includes('already-exists')
+    || code.includes('busy')
+    || code.includes('capacity')) return 409;
+  return 400;
+}
 
 function forgetWebSocketClient(ws) {
   unregisterFrameClient(ws);
@@ -1846,6 +1881,26 @@ function hasOtherFrameStreamOwner(ws, deviceId, streamId, streamPurpose = '') {
   return false;
 }
 
+function hasOtherFrameStreamDemand(ws, deviceId, streamPurpose = '') {
+  const normalizedPurpose = String(streamPurpose || '').trim().toLowerCase();
+  if (!deviceId || !normalizedPurpose) {
+    return false;
+  }
+  for (const candidate of frameClients) {
+    if (candidate === ws || candidate.readyState !== candidate.OPEN) {
+      continue;
+    }
+    if (candidate.liveDeskAutoStart === true
+      && candidate.liveDeskDeviceIds instanceof Set
+      && candidate.liveDeskDeviceIds.has(deviceId)
+      && String(candidate.liveDeskLiveOptions?.streamPurpose || '').trim().toLowerCase()
+        === normalizedPurpose) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function frameStreamStopKey(deviceId, streamId, streamPurpose) {
   return `${deviceId}\u0000${streamId}\u0000${streamPurpose}`;
 }
@@ -2147,6 +2202,15 @@ function snapshotFrameLaneResourceHealth() {
           .map(binding => String(binding?.streamPurpose || '').trim().toLowerCase())
           .filter(Boolean))]
           .slice(0, 4),
+        requestedProfile: ws.liveDeskLiveOptions ? {
+          frameMode: String(ws.liveDeskLiveOptions.frameMode || ws.liveDeskLiveOptions.mode || ''),
+          streamPurpose: String(ws.liveDeskLiveOptions.streamPurpose || ''),
+          fps: Math.max(0, Number(ws.liveDeskLiveOptions.fps || 0)),
+          maxWidth: Math.max(0, Number(ws.liveDeskLiveOptions.maxWidth || 0)),
+          maxHeight: Math.max(0, Number(ws.liveDeskLiveOptions.maxHeight || 0)),
+          quality: Math.max(0, Number(ws.liveDeskLiveOptions.quality || 0))
+        } : null,
+        sharedProfileReuseCount: Math.max(0, Number(ws.liveDeskSharedProfileReuseCount || 0)),
         queueDepth: Math.max(0, Number(lane?.queue?.length || 0)),
         queueLimit: frameClientQueueLimit(ws),
         queueHighWaterPackets: Math.max(0, Number(lane?.queuedPacketsHighWater || 0)),
@@ -2939,9 +3003,23 @@ function startFrameSubscriptionLive(
       monitorIndex,
       reuseExisting: liveOptions.forceRestart !== true
         && (liveOptions.reuseExisting === true || reason === 'subscribe' || reason === 'watchdog'),
+      // Wall capture is one shared native encoder per device. Two open browser
+      // views may ask for different soft profiles (for example mobile 5 fps at
+      // 1080p and desktop 20 fps at 540p). Once a healthy shared owner exists,
+      // those preferences must bind to that owner instead of replacing it back
+      // and forth every time either view refreshes its subscription.
+      reuseSharedExisting: liveOptions.forceRestart !== true
+        && String(liveOptions.streamPurpose || '').trim().toLowerCase() === 'wall'
+        && hasOtherFrameStreamDemand(ws, deviceId, 'wall'),
       silentReuse: reason === 'watchdog' && liveOptions.forceRestart !== true
     });
     if (result?.ok) {
+      if (result.sharedProfileReused === true) {
+        ws.liveDeskSharedProfileReuseCount = Math.max(
+          0,
+          Number(ws.liveDeskSharedProfileReuseCount || 0)
+        ) + 1;
+      }
       frameCaptureTransitionRetries.complete(ws, deviceId, intentGeneration, 'capture-started');
       const expectedBinding = {
         deviceId,
@@ -5106,12 +5184,64 @@ app.post('/api/remote/devices/:deviceId/status-diagnostic', (req, res) => {
   }));
 });
 
-app.post('/api/remote/devices/:deviceId/input', requireHubFeatureAccess, (req, res) => {
-  noStore(res);
-  res.json(remoteHub.sendInputControl(req.params.deviceId, req.body || {}));
-});
-
-app.get('/api/remote/filesystem/roots', requireHubFeatureAccess, async (req, res) => {
+app.post('/api/remote/devices/:deviceId/input', requireHubFeatureAccess, (req, res) => {
+  noStore(res);
+  res.json(remoteHub.sendInputControl(req.params.deviceId, req.body || {}));
+});
+
+app.post('/api/remote/devices/:deviceId/clipboard', requireHubFeatureAccess, async (req, res) => {
+  noStore(res);
+  try {
+    const request = normalizeRemoteClipboardRequest(req.body || {});
+    const inputClient = findLiveRemoteInputClient(request.hubConnectionId);
+    if (!inputClient) {
+      res.status(409).json({ ok: false, error: 'clipboard-input-owner-not-live' });
+      return;
+    }
+    const deviceId = String(req.params.deviceId || '').trim();
+    inputClient.liveDeskInputDeviceIds?.add?.(deviceId);
+
+    if (REMOTE_CLIPBOARD_INPUT_ACTIONS.has(request.action)) {
+      const result = remoteHub.sendInputControl(deviceId, {
+        type: request.action,
+        clipboardOperationId: request.operationId,
+        operationId: request.operationId,
+        clipboardDirection: request.clipboardDirection,
+        manifest: request.payload.manifest || null,
+        contentKind: request.payload.contentKind || request.payload.manifest?.contentKind || '',
+        controlSessionId: request.binding.controlSessionId,
+        controlCommandId: request.binding.controlCommandId,
+        captureGeneration: request.binding.captureGeneration,
+        monitorIndex: request.binding.monitorIndex,
+        hubConnectionId: request.hubConnectionId,
+        requestAck: true
+      });
+      res.status(result.ok ? 200 : clipboardHttpStatus(result.error)).json({
+        ok: result.ok === true,
+        action: request.action,
+        operationId: request.operationId,
+        input: result,
+        ...(result.ok ? {} : { error: result.error || 'clipboard-input-failed' })
+      });
+      return;
+    }
+
+    const result = await remoteHub.sendClipboardCommand(deviceId, request);
+    res.status(result.ok ? 200 : clipboardHttpStatus(result.error)).json(result);
+  } catch (error) {
+    const status = error instanceof RemoteClipboardContractError
+      ? error.status
+      : 500;
+    res.status(status).json({
+      ok: false,
+      error: error instanceof RemoteClipboardContractError
+        ? error.code
+        : 'clipboard-request-failed'
+    });
+  }
+});
+
+app.get('/api/remote/filesystem/roots', requireHubFeatureAccess, async (req, res) => {
   noStore(res);
   try {
     res.json(await hubFilesystem.getRoots({ refresh: /^(1|true|yes|on)$/i.test(String(req.query?.refresh || '')) }));

package/src/settings/effective-device-policy.js

@@ -1,14 +1,36 @@
-import { effectiveDevicePolicy } from './settings-schema.js';
+import { effectiveDevicePolicy } from './settings-schema.js';
+import { REMOTE_CLIPBOARD_LIMITS } from '../remote-clipboard-contract.mjs';
 
-export function buildEffectiveDevicePolicy(settings, { deviceId = '', capabilities = {} } = {}) {
-  const policy = effectiveDevicePolicy(settings);
-  return {
+export function buildEffectiveDevicePolicy(settings, { deviceId = '', capabilities = {} } = {}) {
+  const policy = effectiveDevicePolicy(settings);
+  const clipboardV1 = capabilities.clipboardProtocol === 'livedesk.clipboard.v1';
+  const clipboardCommonLimits = clipboardV1
+    && capabilities.sessionBoundSideChannels === true
+    && Number.isSafeInteger(Number(capabilities.clipboardMaxTextBytes))
+    && Number(capabilities.clipboardMaxTextBytes) > 0
+    && Number.isSafeInteger(Number(capabilities.clipboardMaxTotalBytes))
+    && Number(capabilities.clipboardMaxTotalBytes) > 0
+    && Number.isSafeInteger(Number(capabilities.clipboardMaxChunkBytes))
+    && Number(capabilities.clipboardMaxChunkBytes) >= REMOTE_CLIPBOARD_LIMITS.maxChunkBytes;
+  const clipboardMaxImageBytes = Number(
+    capabilities.clipboardMaxImageBytes ?? capabilities.clipboardMaxPngBytes);
+  return {
     ...policy,
-    deviceId: String(deviceId || ''),
-    supported: {
-      control: capabilities.control !== false,
-      clipboardText: capabilities.clipboardText !== false,
-      fileTransfer: capabilities.fileTransfer !== false,
+    deviceId: String(deviceId || ''),
+    supported: {
+      control: capabilities.control !== false,
+      clipboardText: clipboardCommonLimits && capabilities.clipboardText === true,
+      clipboardImage: clipboardCommonLimits
+        && capabilities.clipboardImage === true
+        && Number.isSafeInteger(clipboardMaxImageBytes)
+        && clipboardMaxImageBytes > 0,
+      clipboardFiles: clipboardCommonLimits
+        && capabilities.clipboardFiles === true
+        && Number.isSafeInteger(Number(capabilities.clipboardMaxFiles))
+        && Number(capabilities.clipboardMaxFiles) > 0,
+      clipboardCopy: clipboardCommonLimits && capabilities.clipboardCopy === true,
+      clipboardPaste: clipboardCommonLimits && capabilities.clipboardPaste === true,
+      fileTransfer: capabilities.fileTransfer !== false,
       remoteAudio: capabilities.audio === true || capabilities.remoteAudio === true,
       agent: Array.isArray(capabilities.agentTools) && capabilities.agentTools.length > 0
     }