livedesk 0.1.459 → 0.1.461

package/diagnostics/livedesk-mode3-capture-smoke.mjs

@@ -132,6 +132,7 @@ const verifyMonitorPixels = process.argv.includes('--verify-monitor-pixels') ||
 const windowsInputAck = process.argv.includes('--windows-input-ack');
 const windowsInputHookLateStart = process.argv.includes('--windows-input-hook-late-start');
 const legacyFfmpegFirst = process.argv.includes('--legacy-ffmpeg-first');
+const captureLifecycleProbe = process.argv.includes('--capture-lifecycle') || isMacPhysicalGate;
 if (windowsInputAck && !isWindows) {
   throw new Error('The Windows native input ACK diagnostic requires Windows hardware.');
 }
@@ -192,6 +193,46 @@ async function waitFor(getValue, timeoutMs, label) {
   throw new Error(`Timed out waiting for ${label}.`);
 }
 
+async function requestLocalHubJson(route, options = {}) {
+  return runMacDiagnosticAbortableAttempt(
+    async signal => {
+      const response = await fetch(`${baseUrl}${route}`, {
+        ...options,
+        cache: 'no-store',
+        signal
+      });
+      const text = await response.text();
+      let payload = {};
+      try {
+        payload = text ? JSON.parse(text) : {};
+      } catch {
+        throw new Error(
+          `${route} returned non-JSON HTTP ${response.status}: ${text.slice(0, 300)}`
+        );
+      }
+      if (!response.ok) {
+        throw new Error(
+          `${route} returned HTTP ${response.status}: ${JSON.stringify(payload)}`
+        );
+      }
+      return payload;
+    },
+    {
+      abortState: isMacPhysicalGate ? macDiagnosticAbort : undefined,
+      timeoutMs: 20_000,
+      label: `Hub request ${route}`
+    }
+  );
+}
+
+function postLocalHubJson(route, payload) {
+  return requestLocalHubJson(route, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+}
+
 function waitForWebSocketJson(
   socket,
   predicate,
@@ -768,8 +809,35 @@ let macDeliveredFps = 0;
 let macFirstFrameMs = 0;
 let macSwitchFirstFrameMs = 0;
 let macTelemetry = {};
+let macCaptureStages = { initial: null, switched: null };
 let macTransport = {};
 let macPlatformProfile = '';
+let macInitialDisplayId = 0;
+let macNextDisplayId = 0;
+let macCaptureLifecycle = {
+  order: [],
+  wallGeneration: 0,
+  controlGeneration: 0,
+  resumedControlGeneration: 0,
+  restoredWallGeneration: 0,
+  wallHelperCount: -1,
+  controlHelperCount: -1,
+  pausedHelperCount: -1,
+  resumedControlHelperCount: -1,
+  controlStoppedHelperCount: -1,
+  restoredWallHelperCount: -1,
+  finalHelperCount: -1,
+  registryMaxConcurrent: -1,
+  registryFinalHelperCount: -1,
+  completedAt: '',
+  registrySampledAt: '',
+  pauseStopConfirmed: false,
+  pauseStopAcknowledged: false,
+  blockedWhilePaused: false,
+  resumeAccepted: false,
+  controlStopConfirmed: false,
+  finalStopConfirmed: false
+};
 let macReportPath = '';
 let macReportClassification;
 let macRunError = '';
@@ -834,6 +902,287 @@ const sampleMacHelpers = async () => {
     .map(record => ({ pid: record.pid }));
 };
 
+async function waitForCaptureHelperCount(expectedCount, label) {
+  if (!isMacPhysicalGate) return -1;
+  const helpers = await waitFor(async () => {
+    const current = await sampleMacHelpers();
+    return current.length === expectedCount ? current : null;
+  }, 10_000, label);
+  return helpers.length;
+}
+
+async function waitForFreshCaptureRegistry(connectedDeviceId, completedAtEpochMs) {
+  if (!isMacPhysicalGate) return -1;
+  return waitFor(async signal => {
+    const response = await fetch(`${baseUrl}/api/remote/devices`, {
+      cache: 'no-store',
+      signal
+    });
+    if (!response.ok) return null;
+    const payload = await response.json();
+    const device = payload.devices?.find(item =>
+      item.deviceId === connectedDeviceId || item.id === connectedDeviceId
+    );
+    const capture = device?.status?.capture;
+    const maximum = Number(capture?.helperMaxConcurrent);
+    const helperCount = Number(capture?.helperCount);
+    const sampledAt = String(capture?.sampledAt || '');
+    const sampledAtEpochMs = Date.parse(sampledAt);
+    if (
+      !Number.isInteger(maximum)
+      || maximum < 1
+      || !Number.isInteger(helperCount)
+      || helperCount < 0
+      || !Number.isFinite(sampledAtEpochMs)
+      || sampledAtEpochMs < completedAtEpochMs
+    ) {
+      return null;
+    }
+    return {
+      maximum,
+      helperCount,
+      sampledAt
+    };
+  }, 20_000, 'fresh RemoteFast capture registry after lifecycle completion');
+}
+
+async function waitForLifecycleFrame(connectedDeviceId, captureGeneration, streamPurpose) {
+  return waitFor(async signal => {
+    const response = await fetch(`${baseUrl}/api/remote/devices`, {
+      cache: 'no-store',
+      signal
+    });
+    if (!response.ok) return null;
+    const payload = await response.json();
+    const device = payload.devices?.find(item =>
+      item.deviceId === connectedDeviceId || item.id === connectedDeviceId
+    );
+    const frame = device?.latestLiveFrame;
+    const stream = device?.activeLiveStream;
+    if (
+      Number(frame?.captureGeneration || 0) !== Number(captureGeneration)
+      || String(frame?.streamPurpose || '') !== streamPurpose
+      || String(frame?.frameMode || '') !== 'mode3-h264-hw'
+      || frame?.currentGenerationVerified !== true
+      || Number(stream?.captureGeneration || 0) !== Number(captureGeneration)
+      || String(stream?.streamPurpose || '') !== streamPurpose
+      || stream?.readyFrameReceived !== true
+    ) {
+      return null;
+    }
+    return { frame, stream, device };
+  }, 20_000, `${streamPurpose} lifecycle generation ${captureGeneration}`);
+}
+
+function lifecycleStartPayload(streamPurpose, reason) {
+  const control = streamPurpose === 'control';
+  return {
+    mode: 'mode3-h264-hw',
+    frameMode: 'mode3-h264-hw',
+    fps: 30,
+    maxWidth: control ? requestedWidth : Math.min(requestedWidth, 1280),
+    maxHeight: control ? requestedHeight : Math.min(requestedHeight, 720),
+    quality: 75,
+    monitorIndex: requestedMonitorIndex,
+    streamPurpose,
+    forceRestart: true,
+    restartToken: `capture-lifecycle-${streamPurpose}-${Date.now()}`,
+    restartReason: reason
+  };
+}
+
+async function runCaptureLifecycleProbe(connectedDeviceId) {
+  const route = `/api/remote/devices/${encodeURIComponent(connectedDeviceId)}/live`;
+  const evidence = {
+    order: [],
+    wallGeneration: 0,
+    controlGeneration: 0,
+    resumedControlGeneration: 0,
+    restoredWallGeneration: 0,
+    wallHelperCount: -1,
+    controlHelperCount: -1,
+    pausedHelperCount: -1,
+    resumedControlHelperCount: -1,
+    controlStoppedHelperCount: -1,
+    restoredWallHelperCount: -1,
+    finalHelperCount: -1,
+    registryMaxConcurrent: -1,
+    registryFinalHelperCount: -1,
+    completedAt: '',
+    registrySampledAt: '',
+    pauseStopConfirmed: false,
+    pauseStopAcknowledged: false,
+    blockedWhilePaused: false,
+    resumeAccepted: false,
+    controlStopConfirmed: false,
+    finalStopConfirmed: false
+  };
+
+  const wallStart = await postLocalHubJson(
+    `${route}/start`,
+    lifecycleStartPayload('wall', 'physical-lifecycle-wall')
+  );
+  assert.equal(wallStart.ok, true, `Wall lifecycle start failed: ${JSON.stringify(wallStart)}`);
+  await waitForLifecycleFrame(connectedDeviceId, wallStart.captureGeneration, 'wall');
+  evidence.wallGeneration = Number(wallStart.captureGeneration || 0);
+  evidence.wallHelperCount = await waitForCaptureHelperCount(1, 'one Wall capture helper');
+  evidence.order.push('wall');
+
+  const controlStart = await postLocalHubJson(
+    `${route}/start`,
+    lifecycleStartPayload('control', 'physical-lifecycle-control')
+  );
+  assert.equal(
+    controlStart.ok,
+    true,
+    `Control lifecycle start failed: ${JSON.stringify(controlStart)}`
+  );
+  assert.ok(
+    Number(controlStart.captureGeneration) > evidence.wallGeneration,
+    'Control must replace Wall with a newer capture generation.'
+  );
+  await waitForLifecycleFrame(connectedDeviceId, controlStart.captureGeneration, 'control');
+  evidence.controlGeneration = Number(controlStart.captureGeneration || 0);
+  evidence.controlHelperCount = await waitForCaptureHelperCount(
+    1,
+    'one Control capture helper'
+  );
+  evidence.order.push('control');
+
+  const paused = await postLocalHubJson(`${route}/pause`, {
+    reason: 'physical-lifecycle-user-pause'
+  });
+  assert.equal(paused.ok, true, `Capture lifecycle pause failed: ${JSON.stringify(paused)}`);
+  assert.ok(paused.pauseToken, 'Capture lifecycle pause did not return an owner token.');
+  assert.equal(paused.phase, 'paused');
+  assert.equal(paused.captureStopConfirmed, true);
+  assert.ok(paused.stopCommandId, 'Pause did not identify its acknowledged stop command.');
+  evidence.pauseStopConfirmed = true;
+  evidence.pauseStopAcknowledged = true;
+  evidence.pausedHelperCount = await waitForCaptureHelperCount(
+    0,
+    'capture helper drain during pause'
+  );
+  evidence.order.push('paused');
+
+  const blocked = await postLocalHubJson(
+    `${route}/start`,
+    lifecycleStartPayload('control', 'physical-lifecycle-paused-watchdog')
+  );
+  assert.equal(blocked.ok, false, 'Paused capture unexpectedly restarted.');
+  assert.equal(blocked.error, 'LIVE_CAPTURE_PAUSED');
+  evidence.blockedWhilePaused = true;
+  if (isMacPhysicalGate) {
+    await delay(200);
+    evidence.pausedHelperCount = await waitForCaptureHelperCount(
+      0,
+      'paused watchdog helper suppression'
+    );
+  }
+  evidence.order.push('blocked');
+
+  const resumed = await postLocalHubJson(`${route}/resume`, {
+    pauseToken: paused.pauseToken
+  });
+  assert.equal(resumed.ok, true, `Capture lifecycle resume failed: ${JSON.stringify(resumed)}`);
+  evidence.resumeAccepted = true;
+  evidence.order.push('resumed');
+
+  const resumedControl = await postLocalHubJson(
+    `${route}/start`,
+    lifecycleStartPayload('control', 'physical-lifecycle-control-resume')
+  );
+  assert.equal(
+    resumedControl.ok,
+    true,
+    `Resumed Control lifecycle start failed: ${JSON.stringify(resumedControl)}`
+  );
+  assert.ok(
+    Number(resumedControl.captureGeneration) > evidence.controlGeneration,
+    'Resumed Control must own a newer capture generation.'
+  );
+  await waitForLifecycleFrame(
+    connectedDeviceId,
+    resumedControl.captureGeneration,
+    'control'
+  );
+  evidence.resumedControlGeneration = Number(resumedControl.captureGeneration || 0);
+  evidence.resumedControlHelperCount = await waitForCaptureHelperCount(
+    1,
+    'one resumed Control capture helper'
+  );
+  evidence.order.push('control-resumed');
+
+  const controlStopped = await postLocalHubJson(`${route}/stop`, {
+    streamId: resumedControl.streamId,
+    streamPurpose: 'control',
+    reason: 'physical-lifecycle-control-leave'
+  });
+  assert.equal(
+    controlStopped.ok,
+    true,
+    `Resumed Control stop failed: ${JSON.stringify(controlStopped)}`
+  );
+  assert.equal(
+    controlStopped.captureStopConfirmed,
+    true,
+    'Control leave did not confirm native capture shutdown.'
+  );
+  evidence.controlStopConfirmed = true;
+  evidence.controlStoppedHelperCount = await waitForCaptureHelperCount(
+    0,
+    'capture helper drain after Control leave'
+  );
+  evidence.order.push('control-stopped');
+
+  const restoredWall = await postLocalHubJson(
+    `${route}/start`,
+    lifecycleStartPayload('wall', 'physical-lifecycle-wall-restore')
+  );
+  assert.equal(
+    restoredWall.ok,
+    true,
+    `Restored Wall lifecycle start failed: ${JSON.stringify(restoredWall)}`
+  );
+  assert.ok(
+    Number(restoredWall.captureGeneration) > evidence.resumedControlGeneration,
+    'Restored Wall must own a newer capture generation than resumed Control.'
+  );
+  await waitForLifecycleFrame(connectedDeviceId, restoredWall.captureGeneration, 'wall');
+  evidence.restoredWallGeneration = Number(restoredWall.captureGeneration || 0);
+  evidence.restoredWallHelperCount = await waitForCaptureHelperCount(
+    1,
+    'one restored Wall capture helper'
+  );
+  evidence.order.push('wall-restored');
+
+  const stopped = await postLocalHubJson(`${route}/stop`, {
+    streamId: restoredWall.streamId,
+    streamPurpose: 'wall',
+    reason: 'physical-lifecycle-complete'
+  });
+  assert.equal(stopped.ok, true, `Restored Wall stop failed: ${JSON.stringify(stopped)}`);
+  assert.equal(stopped.captureStopConfirmed, true, 'Final Wall stop was not confirmed.');
+  evidence.finalStopConfirmed = true;
+  evidence.finalHelperCount = await waitForCaptureHelperCount(
+    0,
+    'capture helper drain after lifecycle'
+  );
+  evidence.order.push('stopped');
+  if (isMacPhysicalGate) {
+    const completedAtEpochMs = Date.now();
+    evidence.completedAt = new Date(completedAtEpochMs).toISOString();
+    const registry = await waitForFreshCaptureRegistry(
+      connectedDeviceId,
+      completedAtEpochMs
+    );
+    evidence.registryMaxConcurrent = registry.maximum;
+    evidence.registryFinalHelperCount = registry.helperCount;
+    evidence.registrySampledAt = registry.sampledAt;
+  }
+  return evidence;
+}
+
 async function stopMacAgentAndSampleDrain() {
   if (!isMacPhysicalGate) return;
   if (helperSampleTimer) {
@@ -897,7 +1246,7 @@ async function writeMacPhysicalGateReport() {
       afterCleanup: summarizeMacDiagnosticResourceSamples(macResourceSamples.afterCleanup)
     };
     snapshot = {
-      schemaVersion: 2,
+      schemaVersion: 3,
       generatedAt,
       runtimeId: clientRuntimeId,
       requestedFps: 30,
@@ -915,10 +1264,14 @@ async function writeMacPhysicalGateReport() {
         count: macMonitorCount,
         initialGeneration: macInitialGeneration,
         nextGeneration: macNextGeneration,
+        initialDisplayId: macInitialDisplayId,
+        nextDisplayId: macNextDisplayId,
         initialHash: macInitialPixelHash,
         nextHash: macNextPixelHash
       },
       modifier: macModifierProbe,
+      lifecycle: macCaptureLifecycle,
+      stages: macCaptureStages,
       transport: macTransport,
       resources,
       diagnostic,
@@ -953,12 +1306,26 @@ async function writeMacPhysicalGateReport() {
   );
   console.log(
     `Mac physical gate monitor: count=${macMonitorCount}, generation=${macInitialGeneration}->${macNextGeneration}, `
+    + `display=${macInitialDisplayId || '-'}->${macNextDisplayId || '-'}, `
     + `pixels=${macInitialPixelHash.slice(0, 12) || '-'}->${macNextPixelHash.slice(0, 12) || '-'}.`
   );
   console.log(
     `Mac physical gate input/transport: modifiers=${macModifierProbe.appliedAcks}/${macModifierProbe.expectedAcks}, `
     + `transport=${macTransport.active || '-'}/${macTransport.protocol || '-'}/${macTransport.state || '-'}.`
   );
+  console.log(
+    `Mac physical gate lifecycle: ${macCaptureLifecycle.order.join(' -> ') || '-'}, `
+    + `helpers=${macCaptureLifecycle.wallHelperCount}`
+    + `/${macCaptureLifecycle.controlHelperCount}`
+    + `/${macCaptureLifecycle.pausedHelperCount}`
+    + `/${macCaptureLifecycle.resumedControlHelperCount}`
+    + `/${macCaptureLifecycle.controlStoppedHelperCount}`
+    + `/${macCaptureLifecycle.restoredWallHelperCount}`
+    + `/${macCaptureLifecycle.finalHelperCount}, `
+    + `registry-max=${macCaptureLifecycle.registryMaxConcurrent}, `
+    + `registry-final=${macCaptureLifecycle.registryFinalHelperCount}, `
+    + `registry-sampled=${macCaptureLifecycle.registrySampledAt || '-'}.`
+  );
   for (const gateCheck of macReportClassification.checks) {
     console.log(`[${gateCheck.ok ? 'PASS' : 'FAIL'}] ${gateCheck.id}: ${gateCheck.detail}`);
   }
@@ -1218,9 +1585,20 @@ try {
     });
     const payload = await response.json();
     const device = payload.devices?.find(item => item.deviceId === deviceId || item.id === deviceId);
-    return device?.deviceId || device?.id || '';
-  }, 15_000, 'Mode 3 smoke client');
-
+    return device?.deviceId || device?.id || '';
+  }, 15_000, 'Mode 3 smoke client');
+
+  if (captureLifecycleProbe) {
+    macCaptureLifecycle = await runCaptureLifecycleProbe(connectedDeviceId);
+    console.log(
+      `Capture lifecycle OK: ${macCaptureLifecycle.order.join(' -> ')}, `
+      + `generation ${macCaptureLifecycle.wallGeneration}`
+      + ` -> ${macCaptureLifecycle.controlGeneration}`
+      + ` -> ${macCaptureLifecycle.resumedControlGeneration}`
+      + ` -> ${macCaptureLifecycle.restoredWallGeneration}.`
+    );
+  }
+
   frameSocket = new WebSocket(`ws://127.0.0.1:${httpPort}/api/remote/frames/ws?devices=${encodeURIComponent(connectedDeviceId)}`);
   await waitForWebSocketOpen(frameSocket);
 
@@ -1345,6 +1723,7 @@ try {
       version: Number(telemetryFrame.metadata.nativeCaptureTelemetryVersion || 0),
       ageMs: Number(telemetryFrame.metadata.nativeCaptureTelemetryAgeMs),
       hardwareAccelerated: telemetryFrame.metadata.nativeEncoderHardwareAccelerated === true,
+      displayId: Number(telemetryFrame.metadata.nativeCaptureDisplayId || 0),
       captureFps: Number(telemetryFrame.metadata.nativeCaptureFps || 0),
       compressionFps: Number(telemetryFrame.metadata.nativeCompressionFps || 0),
       stdoutFps: Number(telemetryFrame.metadata.nativeEncodedFps || 0),
@@ -1361,6 +1740,12 @@ try {
       reason: String(telemetryFrame.metadata.frameTransportReason || ''),
       p2pReady: telemetryFrame.metadata.frameTransportP2pReady === true
     };
+    macInitialDisplayId = Number(macTelemetry.displayId || 0);
+    macCaptureStages.initial = {
+      deliveredFps,
+      telemetry: { ...macTelemetry },
+      transport: { ...macTransport }
+    };
   }
   console.log(`Mode 3 control capture OK: first ${firstFrameMs.toFixed(0)}ms, ${deliveredFps.toFixed(1)} fps, native age ${averageFrameAgeMs.toFixed(1)}ms avg/${maxFrameAgeMs.toFixed(1)}ms max, ${frames[0].metadata.width}x${frames[0].metadata.height}, ${frames[0].metadata.hardwareEncoder}/${frames[0].metadata.platformProfile}.`);
   if (process.argv.includes('--logs')) {
@@ -1453,6 +1838,15 @@ try {
     const firstSwitchedFrame = switchedFrames[0];
     activeInputBindingFrame = switchedFrames.at(-1);
     const switchedFirstFrameMs = firstSwitchedFrame.receivedAt - switchedAt;
+    const switchedSteadyFrames = switchedFrames.slice(
+      Math.min(10, Math.max(0, switchedFrames.length - 2))
+    );
+    const switchedElapsedMs = switchedSteadyFrames.length > 1
+      ? switchedSteadyFrames.at(-1).receivedAt - switchedSteadyFrames[0].receivedAt
+      : 0;
+    const switchedDeliveredFps = switchedSteadyFrames.length > 1
+      ? (switchedSteadyFrames.length - 1) * 1000 / Math.max(1, switchedElapsedMs)
+      : 0;
     assert.equal(firstSwitchedFrame.metadata.isKeyFrame, true, 'Mode 3 monitor transition did not start on a key frame.');
     assert.notEqual(String(firstSwitchedFrame.metadata.commandId || ''), previousCommandId, 'Mode 3 monitor transition reused the previous command binding.');
     if (!isMacPhysicalGate) {
@@ -1531,6 +1925,7 @@ try {
           version: Number(switchedTelemetryFrame.metadata.nativeCaptureTelemetryVersion || 0),
           ageMs: Number(switchedTelemetryFrame.metadata.nativeCaptureTelemetryAgeMs),
           hardwareAccelerated: switchedTelemetryFrame.metadata.nativeEncoderHardwareAccelerated === true,
+          displayId: Number(switchedTelemetryFrame.metadata.nativeCaptureDisplayId || 0),
           captureFps: Number(switchedTelemetryFrame.metadata.nativeCaptureFps || 0),
           compressionFps: Number(switchedTelemetryFrame.metadata.nativeCompressionFps || 0),
           stdoutFps: Number(switchedTelemetryFrame.metadata.nativeEncodedFps || 0),
@@ -1547,6 +1942,13 @@ try {
           reason: String(switchedTelemetryFrame.metadata.frameTransportReason || ''),
           p2pReady: switchedTelemetryFrame.metadata.frameTransportP2pReady === true
         };
+        macDeliveredFps = switchedDeliveredFps;
+        macNextDisplayId = Number(macTelemetry.displayId || 0);
+        macCaptureStages.switched = {
+          deliveredFps: switchedDeliveredFps,
+          telemetry: { ...macTelemetry },
+          transport: { ...macTransport }
+        };
       }
       macModifierProbe = await runMacModifierProbe({
         deviceId: connectedDeviceId,