@livedesk/hub 0.1.13 → 0.1.14

package/src/server.js

@@ -1542,11 +1542,11 @@ function sendJson(ws, payload) {
   return safeWebSocketSend(ws, JSON.stringify(payload));
 }
 
-function forgetWebSocketClient(ws) {
-  unregisterFrameClient(ws);
-  frameClients.delete(ws);
-  audioClients.delete(ws);
-  inputClients.delete(ws);
+function forgetWebSocketClient(ws) {
+  unregisterFrameClient(ws);
+  frameClients.delete(ws);
+  releaseAudioClient(ws, 'websocket-forgotten');
+  inputClients.delete(ws);
   try {
     ws.terminate?.();
   } catch {
@@ -1647,14 +1647,34 @@ function scheduleFrameStreamStop(deviceId, streamId, streamPurpose) {
     if (hasOtherFrameStreamOwner(null, deviceId, streamId, streamPurpose)) {
       return;
     }
-    const result = remoteHub.stopLiveStream(deviceId, {
-      streamId,
-      streamPurpose,
-      reason: 'frame-client-closed'
-    });
-    if (result?.ok && !result.alreadyStopped) {
-      console.log(`[LiveDesk Hub] stopped ${streamPurpose} stream after frame client closed device=${deviceId} stream=${streamId}`);
-    }
+    const result = remoteHub.stopLiveStream(deviceId, {
+      streamId,
+      streamPurpose,
+      reason: 'frame-client-closed'
+    });
+    if (result?.stopPromise) {
+      void result.stopPromise.then(confirmation => {
+        if (confirmation?.captureStopConfirmed === true) {
+          console.log(`[LiveDesk Hub] confirmed ${streamPurpose} capture stopped after frame client closed device=${deviceId} stream=${streamId}`);
+          return;
+        }
+        if (!hasOtherFrameStreamOwner(null, deviceId, streamId, streamPurpose)) {
+          console.warn(
+            `[LiveDesk Hub] ${streamPurpose} capture stop was not confirmed device=${deviceId} `
+            + `stream=${streamId}: ${confirmation?.error || 'capture-stop-unconfirmed'}. `
+            + 'Disconnecting the Agent so its final capture drain runs before reconnect.'
+          );
+          remoteHub.disconnectDevice(deviceId, 'frame-capture-stop-unconfirmed');
+        }
+      }).catch(error => {
+        if (!hasOtherFrameStreamOwner(null, deviceId, streamId, streamPurpose)) {
+          console.warn(`[LiveDesk Hub] ${streamPurpose} capture stop confirmation failed device=${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+          remoteHub.disconnectDevice(deviceId, 'frame-capture-stop-confirmation-failed');
+        }
+      });
+    } else if (result?.ok && !result.alreadyStopped) {
+      console.log(`[LiveDesk Hub] queued ${streamPurpose} capture stop after frame client closed device=${deviceId} stream=${streamId}`);
+    }
   }, frameStreamStopGraceMs);
   pendingFrameStreamStops.set(key, { timer });
 }
@@ -2003,10 +2023,19 @@ function restartFrameSubscriptionLive(ws, payload = {}) {
   }
 }
 
-function updateAudioSubscription(ws, payload = {}) {
-  const deviceIds = normalizeDeviceIds(payload.deviceIds ?? payload.devices ?? payload.deviceId);
-  ws.liveDeskAudioDeviceIds = new Set(deviceIds);
-  sendJson(ws, {
+function updateAudioSubscription(ws, payload = {}) {
+  const previousDeviceIds = ws.liveDeskAudioDeviceIds instanceof Set
+    ? new Set(ws.liveDeskAudioDeviceIds)
+    : null;
+  const deviceIds = normalizeDeviceIds(payload.deviceIds ?? payload.devices ?? payload.deviceId);
+  ws.liveDeskAudioDeviceIds = new Set(deviceIds);
+  if (previousDeviceIds) {
+    const releasedDeviceIds = previousDeviceIds.size === 0
+      ? activeRemoteAudioDeviceIds().filter(deviceId => !ws.liveDeskAudioDeviceIds.has(deviceId))
+      : [...previousDeviceIds].filter(deviceId => !ws.liveDeskAudioDeviceIds.has(deviceId));
+    stopUnsubscribedAudioDevices(releasedDeviceIds, 'audio-subscription-changed');
+  }
+  sendJson(ws, {
     type: 'RemoteAudioSubscription',
     timestamp: new Date().toISOString(),
     deviceIds
@@ -2469,6 +2498,90 @@ function startMode4AtlasInput(ws, deviceId, reason = 'atlas-configure', { forceR
     restartReason: reason
   });
 }
+
+function activeRemoteAudioDeviceIds() {
+  return remoteHub.listDevices({ includeDataUrl: false })
+    .filter(device => device?.activeAudioStream?.active === true)
+    .map(device => String(device.deviceId || '').trim())
+    .filter(Boolean);
+}
+
+function hasRemoteAudioSubscriber(deviceId) {
+  for (const client of audioClients) {
+    if (client.readyState !== 1) {
+      continue;
+    }
+    const subscribedDeviceIds = client.liveDeskAudioDeviceIds;
+    if (!(subscribedDeviceIds instanceof Set)
+      || subscribedDeviceIds.size === 0
+      || subscribedDeviceIds.has(deviceId)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function stopUnsubscribedAudioDevices(deviceIds, reason) {
+  const activeDevices = new Map(
+    remoteHub.listDevices({ includeDataUrl: false })
+      .filter(device => device?.activeAudioStream?.active === true)
+      .map(device => [String(device.deviceId || '').trim(), device])
+  );
+  for (const deviceId of new Set(normalizeDeviceIds(deviceIds))) {
+    if (!deviceId || hasRemoteAudioSubscriber(deviceId)) {
+      continue;
+    }
+    const device = activeDevices.get(deviceId);
+    if (!device) {
+      continue;
+    }
+    const result = remoteHub.stopAudioStream(deviceId, {
+      streamId: String(device.activeAudioStream?.streamId || ''),
+      reason
+    });
+    if (result?.stopPromise) {
+      void result.stopPromise.then(confirmation => {
+        if (confirmation?.captureStopConfirmed === true) {
+          return;
+        }
+        if (!hasRemoteAudioSubscriber(deviceId)) {
+          console.warn(
+            `[LiveDesk Hub] audio capture stop was not confirmed device=${deviceId} reason=${reason}: `
+            + `${confirmation?.error || 'audio-stop-unconfirmed'}. Disconnecting the Agent for a final drain.`
+          );
+          remoteHub.disconnectDevice(deviceId, 'audio-capture-stop-unconfirmed');
+        }
+      }).catch(error => {
+        if (!hasRemoteAudioSubscriber(deviceId)) {
+          console.warn(`[LiveDesk Hub] audio capture stop confirmation failed device=${deviceId}: ${error instanceof Error ? error.message : String(error)}`);
+          remoteHub.disconnectDevice(deviceId, 'audio-capture-stop-confirmation-failed');
+        }
+      });
+    }
+    if (result?.ok === false
+      && !['device-not-found', 'device-not-connected', 'device-audio-unavailable'].includes(String(result.error || ''))) {
+      console.warn(`[LiveDesk Hub] Could not stop unused remote audio capture device=${deviceId} reason=${reason}: ${result.error || 'unknown-error'}`);
+    }
+  }
+}
+
+function releaseAudioClient(ws, reason = 'audio-subscriber-closed') {
+  if (!ws
+    || (!audioClients.has(ws) && !ws.liveDeskAudioClientId)
+    || ws.liveDeskAudioCleanupComplete === true) {
+    return;
+  }
+  ws.liveDeskAudioCleanupComplete = true;
+  const subscribedDeviceIds = ws.liveDeskAudioDeviceIds instanceof Set
+    ? ws.liveDeskAudioDeviceIds
+    : new Set();
+  const releasedDeviceIds = subscribedDeviceIds.size === 0
+    ? activeRemoteAudioDeviceIds()
+    : [...subscribedDeviceIds];
+  audioClients.delete(ws);
+  ws.liveDeskAudioDeviceIds = new Set();
+  stopUnsubscribedAudioDevices(releasedDeviceIds, reason);
+}
 
 function hasOtherAtlasInputOwner(ws, deviceId) {
   for (const candidate of atlasClients.keys()) {
@@ -4087,9 +4200,32 @@ app.post('/api/remote/devices/:deviceId/live/start', requireHubFeatureAccess, (r
   res.json(remoteHub.startLiveStream(req.params.deviceId, req.body || {}));
 });
 
-app.post('/api/remote/devices/:deviceId/live/stop', (req, res) => {
+async function resolveConfirmedMediaStop(result, kind) {
+  if (!result?.stopPromise) {
+    return result;
+  }
+  const confirmation = await result.stopPromise;
+  const confirmed = confirmation?.captureStopConfirmed === true;
+  return {
+    ...result,
+    ok: confirmed,
+    captureStopConfirmed: confirmed,
+    stopPending: false,
+    stopError: confirmed ? '' : String(confirmation?.error || `${kind}-capture-stop-unconfirmed`),
+    error: confirmed ? undefined : `${kind.toUpperCase()}_CAPTURE_STOP_UNCONFIRMED`
+  };
+}
+
+app.post('/api/remote/devices/:deviceId/live/stop', async (req, res, next) => {
   noStore(res);
-  res.json(remoteHub.stopLiveStream(req.params.deviceId, req.body || {}));
+  try {
+    res.json(await resolveConfirmedMediaStop(
+      remoteHub.stopLiveStream(req.params.deviceId, req.body || {}),
+      'video'
+    ));
+  } catch (error) {
+    next(error);
+  }
 });
 
 app.post('/api/remote/devices/:deviceId/live/pause', async (req, res, next) => {
@@ -4111,10 +4247,17 @@ app.post('/api/remote/devices/:deviceId/audio/start', requireHubFeatureAccess, (
   res.json(remoteHub.startAudioStream(req.params.deviceId, req.body || {}));
 });
 
-app.post('/api/remote/devices/:deviceId/audio/stop', (req, res) => {
-  noStore(res);
-  res.json(remoteHub.stopAudioStream(req.params.deviceId, req.body || {}));
-});
+app.post('/api/remote/devices/:deviceId/audio/stop', async (req, res, next) => {
+  noStore(res);
+  try {
+    res.json(await resolveConfirmedMediaStop(
+      remoteHub.stopAudioStream(req.params.deviceId, req.body || {}),
+      'audio'
+    ));
+  } catch (error) {
+    next(error);
+  }
+});
 
 if (existsSync(webIndexPath)) {
   app.use(express.static(webDistPath, {
@@ -4241,9 +4384,10 @@ atlasWss.on('connection', ws => {
   });
 });
 
-audioWss.on('connection', (ws, req) => {
-  audioClients.add(ws);
-  ws.liveDeskAudioClientId = `raws-${++audioClientSeq}`;
+audioWss.on('connection', (ws, req) => {
+  audioClients.add(ws);
+  ws.liveDeskAudioClientId = `raws-${++audioClientSeq}`;
+  ws.liveDeskAudioCleanupComplete = false;
   try {
     const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
     updateAudioSubscription(ws, { deviceIds: parsed.searchParams.get('devices') || '' });
@@ -4260,8 +4404,9 @@ audioWss.on('connection', (ws, req) => {
       sendJson(ws, { type: 'RemoteAudioSubscriptionError', error: 'invalid-message' });
     }
   });
-  ws.on('close', () => audioClients.delete(ws));
-  ws.on('error', () => audioClients.delete(ws));
+  const cleanup = () => releaseAudioClient(ws);
+  ws.on('close', cleanup);
+  ws.on('error', cleanup);
   sendJson(ws, {
     type: 'RemoteAudioSocketReady',
     protocol: 'livedesk.remote.audio.binary.v1',