livedesk 0.1.457 → 0.1.459

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import assert from 'node:assert/strict';
-import { spawn, spawnSync } from 'node:child_process';
+import { execFile, spawn, spawnSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
@@ -13,13 +13,15 @@ import { fileURLToPath } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
 import WebSocket from 'ws';
 import {
+  buildMacDiagnosticResourceSample,
   buildMacModifierProbeSteps,
   buildMacModifierReleaseSteps,
   classifyMacPhysicalGate,
+  createAsyncSingleFlightSampler,
   noteMacModifierAfterAppliedAck,
   noteMacModifierBeforeSend,
-  parseMacHelperProcesses,
-  parseMacLiveDeskRuntimeProcesses
+  parseMacLiveDeskRuntimeProcesses,
+  summarizeMacDiagnosticResourceSamples
 } from './livedesk-mac-physical-gate-core.mjs';
 import {
   acquireMacDiagnosticLease,
@@ -38,6 +40,7 @@ const publicMacPhysicalDiagnostic = String(rawArguments[0] || '').toLowerCase()
 const macPhysicalGate = process.argv.includes('--mac-physical-gate') || publicMacPhysicalDiagnostic;
 const isWindows = process.platform === 'win32';
 const isMacPhysicalGate = process.platform === 'darwin' && macPhysicalGate;
+const MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS = 500;
 if (macPhysicalGate && !isMacPhysicalGate) {
   const message = 'Mac physical diagnostic requires macOS hardware; no LiveDesk process was started.';
   if (publicMacPhysicalDiagnostic) {
@@ -126,7 +129,15 @@ const requestedHeight = heightArgumentIndex >= 0
 const transitionToMode5 = process.argv.includes('--transition-mode5');
 const switchMonitor = process.argv.includes('--switch-monitor') || isMacPhysicalGate;
 const verifyMonitorPixels = process.argv.includes('--verify-monitor-pixels') || isMacPhysicalGate;
+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');
+if (windowsInputAck && !isWindows) {
+  throw new Error('The Windows native input ACK diagnostic requires Windows hardware.');
+}
+if (windowsInputHookLateStart && !windowsInputAck) {
+  throw new Error('The Windows hook late-start diagnostic requires --windows-input-ack.');
+}
 const reportArgumentIndex = rawArguments.findIndex(
   argument => argument === '--report' || argument === '--gate-report'
 );
@@ -313,9 +324,28 @@ function readMacProcessSnapshot() {
   return String(result.stdout || '');
 }
 
-function readMacCaptureHelpers() {
-  if (!isMacPhysicalGate) return [];
-  return parseMacHelperProcesses(readMacProcessSnapshot());
+function readMacProcessResourceSnapshot() {
+  return new Promise((resolveSnapshot, rejectSnapshot) => {
+    execFile(
+      '/bin/ps',
+      ['-axo', 'pid=,ppid=,comm=,%cpu=,rss=,args='],
+      {
+        encoding: 'utf8',
+        timeout: 2_000,
+        windowsHide: true,
+        maxBuffer: 4 * 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          rejectSnapshot(new Error(
+            `resource ps failed: ${String(stderr || error.message || error)}`
+          ));
+          return;
+        }
+        resolveSnapshot(String(stdout || ''));
+      }
+    );
+  });
 }
 
 function readConflictingMacLiveDeskRuntimes() {
@@ -446,6 +476,150 @@ async function runMacModifierProbe(binding) {
   };
 }
 
+async function runWindowsInputAckProbe(binding, { expectHookLateStartFailure = false } = {}) {
+  const socket = new WebSocket(`ws://127.0.0.1:${httpPort}/api/remote/input/ws`, {
+    perMessageDeflate: false
+  });
+  const sendInput = async (input, timeoutMs = 5_000) => {
+    const outcome = waitForWebSocketJson(
+      socket,
+      message => (
+        (message.type === 'RemoteInputApplied' || message.type === 'RemoteInputError')
+        && Number(message.inputSeq) === Number(input.inputSeq)
+      ),
+      timeoutMs
+    );
+    socket.send(JSON.stringify({
+      type: 'input',
+      requestId: input.inputEventId,
+      deviceId: binding.deviceId,
+      input: {
+        ...input,
+        requestAck: true,
+        issuedAtEpochMs: Date.now(),
+        monitorIndex: binding.monitorIndex,
+        controlSessionId: binding.sessionId,
+        controlCommandId: binding.commandId,
+        captureGeneration: binding.captureGeneration
+      }
+    }));
+    return outcome;
+  };
+
+  let resetApplied = false;
+  try {
+    const ready = waitForWebSocketJson(socket, message => message.type === 'RemoteInputSocketReady');
+    await Promise.all([waitForWebSocketOpen(socket), ready]);
+    const probe = await sendInput({
+      type: 'keyboard.probe',
+      inputSeq: 1,
+      inputEventId: `windows-physical-probe-${Date.now()}`,
+      pressedCodes: [],
+      shiftKey: false,
+      ctrlKey: false,
+      altKey: false,
+      metaKey: false,
+      repeat: false
+    });
+    if (expectHookLateStartFailure) {
+      assert.equal(
+        probe.type,
+        'RemoteInputError',
+        'The forced late hook start unexpectedly reached native input injection.'
+      );
+      assert.match(
+        String(probe.error || ''),
+        /diagnostic keyboard isolation hook did not become ready/i,
+        'The forced late hook start did not fail at the bounded ready deadline.'
+      );
+      const reset = await sendInput({
+        type: 'keyboard.reset',
+        inputSeq: 2,
+        inputEventId: `windows-late-start-reset-${Date.now()}`,
+        pressedCodes: [],
+        shiftKey: false,
+        ctrlKey: false,
+        altKey: false,
+        metaKey: false,
+        repeat: false,
+        reason: 'windows-hook-late-start-cleanup'
+      });
+      assert.equal(reset.type, 'RemoteInputApplied', String(reset.error || 'Windows late-start reset failed.'));
+      assert.equal(reset.duplicate, false, 'Windows late-start reset was acknowledged as a duplicate.');
+      resetApplied = true;
+      return {
+        lateStartFailure: true,
+        error: String(probe.error || ''),
+        resetApplied
+      };
+    }
+    assert.equal(probe.type, 'RemoteInputApplied', String(probe.error || 'Windows native input probe failed.'));
+    assert.equal(probe.duplicate, false, 'Windows native input probe was acknowledged as a duplicate.');
+    assert.equal(probe.nativeInputBackend, 'win32-sendinput-hook-isolated');
+    assert.equal(Number(probe.nativeEventsRequested), 8);
+    assert.equal(Number(probe.nativeEventsAccepted), 8);
+    assert.equal(Number(probe.hookEventsObserved), 8);
+    assert.equal(Number(probe.hookEventsBlocked), 8);
+    assert.equal(probe.focusChanged, false, 'Windows native input probe changed the foreground window.');
+    assert.equal(probe.inputDiagnostic, true);
+
+    const reset = await sendInput({
+      type: 'keyboard.reset',
+      inputSeq: 2,
+      inputEventId: `windows-physical-reset-${Date.now()}`,
+      pressedCodes: [],
+      shiftKey: false,
+      ctrlKey: false,
+      altKey: false,
+      metaKey: false,
+      repeat: false,
+      reason: 'windows-native-input-diagnostic-cleanup'
+    });
+    assert.equal(reset.type, 'RemoteInputApplied', String(reset.error || 'Windows native input reset failed.'));
+    assert.equal(reset.duplicate, false, 'Windows native input reset was acknowledged as a duplicate.');
+    resetApplied = true;
+    return {
+      backend: String(probe.nativeInputBackend || ''),
+      requested: Number(probe.nativeEventsRequested || 0),
+      accepted: Number(probe.nativeEventsAccepted || 0),
+      hookObserved: Number(probe.hookEventsObserved || 0),
+      hookBlocked: Number(probe.hookEventsBlocked || 0),
+      duplicate: probe.duplicate === true,
+      focusChanged: probe.focusChanged === true,
+      resetApplied
+    };
+  } finally {
+    if (!resetApplied && socket.readyState === WebSocket.OPEN) {
+      try {
+        socket.send(JSON.stringify({
+          type: 'input',
+          deviceId: binding.deviceId,
+          fireAndForget: true,
+          input: {
+            type: 'keyboard.reset',
+            inputSeq: 0,
+            requestAck: false,
+            pressedCodes: [],
+            shiftKey: false,
+            ctrlKey: false,
+            altKey: false,
+            metaKey: false,
+            repeat: false,
+            reason: 'windows-native-input-diagnostic-finally',
+            monitorIndex: binding.monitorIndex,
+            controlSessionId: binding.sessionId,
+            controlCommandId: binding.commandId,
+            captureGeneration: binding.captureGeneration
+          }
+        }));
+      } catch {
+        // Closing the exact input owner also triggers RemoteFast ReleaseAll.
+      }
+    }
+    try { socket.close(); } catch {}
+  }
+}
+
 async function decodeKeyFrame(accessUnit, label) {
   const directory = await mkdtemp(path.join(tmpdir(), `livedesk-${label}-`));
   const inputPath = path.join(directory, 'frame.h264');
@@ -469,6 +643,10 @@ async function decodeKeyFrame(accessUnit, label) {
         windowsHide: true
       });
       ownedDecoders.set(decoder, { directory, label });
+      if (isMacPhysicalGate && Number(decoder?.pid || 0) > 1) {
+        macOwnedDecoderPids.add(Number(decoder.pid));
+        requestMacResourceSample('steadyCapture');
+      }
       let errors = '';
       let settled = false;
       let unsubscribeAbort = () => {};
@@ -566,12 +744,20 @@ let hub;
 let agent;
 let frameSocket;
 const ownedDecoders = new Map();
+const macOwnedDecoderPids = new Set();
 let hubLogs = [];
 let agentLogs = [];
 let helperSampleTimer;
 let helperMaxConcurrent = 0;
 const helperObservedPids = new Set();
 let helperFinalCount = 0;
+let macResourcePhase = '';
+const macResourceSamples = {
+  baseline: [],
+  steadyCapture: [],
+  afterCleanup: []
+};
+const macResourceSamplingErrors = new Set();
 let macModifierProbe = { expectedAcks: 8, appliedAcks: 0, applied: [], errors: [] };
 let macInitialPixelHash = '';
 let macNextPixelHash = '';
@@ -590,12 +776,62 @@ let macRunError = '';
 const macCleanupErrors = [];
 const macSignalHandlers = new Map();
 
-const sampleMacHelpers = () => {
+const collectMacResourceSample = async phase => {
+  if (!isMacPhysicalGate) {
+    return {
+      totalLiveDeskProcessCount: 0,
+      captureHelperCount: 0,
+      unownedLiveDeskPids: [],
+      processes: []
+    };
+  }
+  let sample;
+  try {
+    sample = buildMacDiagnosticResourceSample(
+      await readMacProcessResourceSnapshot(),
+      {
+        diagnosticPid: process.pid,
+        hubPid: hub?.pid,
+        agentPid: agent?.pid,
+        decoderPids: [...ownedDecoders.keys()]
+          .filter(decoder => decoder?.exitCode === null && decoder?.signalCode === null)
+          .map(decoder => decoder?.pid)
+      }
+    );
+  } catch {
+    const safePhase = String(phase || 'unassigned').replace(/[^a-z-]/gi, '') || 'unassigned';
+    macResourceSamplingErrors.add(`${safePhase}:unavailable`);
+    throw new Error(`Mac ${safePhase} process resource telemetry is unavailable.`);
+  }
+  helperMaxConcurrent = Math.max(helperMaxConcurrent, sample.captureHelperCount);
+  for (const helper of sample.processes.filter(record => record.role === 'capture-helper')) {
+    helperObservedPids.add(helper.pid);
+  }
+  if (Object.prototype.hasOwnProperty.call(macResourceSamples, phase)) {
+    const phaseSamples = macResourceSamples[phase];
+    phaseSamples.push(sample);
+    while (phaseSamples.length > 240) phaseSamples.shift();
+  }
+  return sample;
+};
+
+const macResourceSampler = createAsyncSingleFlightSampler(collectMacResourceSample);
+
+const sampleMacResources = phase => macResourceSampler.run(phase);
+
+const requestMacResourceSample = phase => {
+  const pending = macResourceSampler.request(phase);
+  pending?.catch(() => {
+    // A later required sample reports persistent process telemetry failure.
+  });
+};
+
+const sampleMacHelpers = async () => {
   if (!isMacPhysicalGate) return [];
-  const helpers = readMacCaptureHelpers();
-  helperMaxConcurrent = Math.max(helperMaxConcurrent, helpers.length);
-  for (const helper of helpers) helperObservedPids.add(helper.pid);
-  return helpers;
+  const sample = await sampleMacResources(macResourcePhase);
+  return sample.processes
+    .filter(record => record.role === 'capture-helper')
+    .map(record => ({ pid: record.pid }));
 };
 
 async function stopMacAgentAndSampleDrain() {
@@ -614,7 +850,7 @@ async function stopMacAgentAndSampleDrain() {
   } finally {
     const drainDeadline = Date.now() + 5_000;
     do {
-      const helpers = sampleMacHelpers();
+      const helpers = await sampleMacHelpers();
       helperFinalCount = helpers.length;
       if (helperFinalCount === 0) break;
       await delay(100);
@@ -641,8 +877,27 @@ async function writeMacPhysicalGateReport() {
   while (true) {
     const diagnostic = readDiagnosticState();
     const stateToken = diagnosticStateToken(diagnostic);
+    const expectedSteadyProcesses = [
+      { role: 'hub', pid: hub?.pid, ownedByDiagnostic: true },
+      { role: 'remote-fast', pid: agent?.pid, ownedByDiagnostic: true },
+      ...[...macOwnedDecoderPids].map(pid => ({
+        role: 'decoder',
+        pid,
+        ownedByDiagnostic: true
+      }))
+    ];
+    const resources = {
+      sampleIntervalMs: MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS,
+      samplingErrors: [...macResourceSamplingErrors],
+      baseline: summarizeMacDiagnosticResourceSamples(macResourceSamples.baseline),
+      steadyCapture: summarizeMacDiagnosticResourceSamples(
+        macResourceSamples.steadyCapture,
+        { expectedProcesses: expectedSteadyProcesses }
+      ),
+      afterCleanup: summarizeMacDiagnosticResourceSamples(macResourceSamples.afterCleanup)
+    };
     snapshot = {
-      schemaVersion: 1,
+      schemaVersion: 2,
       generatedAt,
       runtimeId: clientRuntimeId,
       requestedFps: 30,
@@ -665,6 +920,7 @@ async function writeMacPhysicalGateReport() {
       },
       modifier: macModifierProbe,
       transport: macTransport,
+      resources,
       diagnostic,
       error: diagnostic.runError
     };
@@ -688,6 +944,13 @@ async function writeMacPhysicalGateReport() {
     `Mac physical gate helper: max=${helperMaxConcurrent}, final=${helperFinalCount}, `
     + `pids=${[...helperObservedPids].join(',') || '-'}.`
   );
+  const resourceEvidence = snapshot.resources;
+  console.log(
+    `Mac physical gate resources: baseline=${resourceEvidence.baseline.totalLiveDeskProcessCount}, `
+    + `steady-peak=${resourceEvidence.steadyCapture.totalLiveDeskProcessCountPeak}, `
+    + `after-cleanup=${resourceEvidence.afterCleanup.totalLiveDeskProcessCount}, `
+    + `samples=${resourceEvidence.steadyCapture.sampleCount}.`
+  );
   console.log(
     `Mac physical gate monitor: count=${macMonitorCount}, generation=${macInitialGeneration}->${macNextGeneration}, `
     + `pixels=${macInitialPixelHash.slice(0, 12) || '-'}->${macNextPixelHash.slice(0, 12) || '-'}.`
@@ -766,6 +1029,12 @@ async function cleanupOwnedDiagnosticResources() {
     }
   }
   if (!isMacPhysicalGate) return;
+  macResourcePhase = 'afterCleanup';
+  try {
+    await sampleMacResources(macResourcePhase);
+  } catch (error) {
+    recordMacCleanupError('resource-snapshot-after-cleanup', error);
+  }
   const teardownPlan = buildMacDiagnosticTeardownPlan({
     agentStopped,
     hubStopped,
@@ -843,14 +1112,12 @@ try {
   macIsolation = await prepareMacDiagnosticIsolation();
   if (isMacPhysicalGate) {
     macDiagnosticAbort.throwIfRequested();
-    sampleMacHelpers();
+    macResourcePhase = 'baseline';
+    await sampleMacResources(macResourcePhase);
+    macResourcePhase = '';
     helperSampleTimer = setInterval(() => {
-      try {
-        sampleMacHelpers();
-      } catch {
-        // The final synchronous sample reports a persistent ps failure.
-      }
-    }, 100);
+      requestMacResourceSample(macResourcePhase);
+    }, MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS);
     helperSampleTimer.unref?.();
   }
   const isolatedHubEnvironment = isMacPhysicalGate
@@ -929,6 +1196,10 @@ try {
         LIVEDESK_UDP_PREFER_P2P: '0',
         LIVEDESK_RELAY_ENABLED: '0'
       } : {}),
+      ...(windowsInputAck ? { LIVEDESK_INPUT_DIAGNOSTIC: '1' } : {}),
+      ...(windowsInputHookLateStart ? {
+        LIVEDESK_INPUT_DIAGNOSTIC_HOOK_START_DELAY_MS: '2500'
+      } : {}),
       LIVEDESK_FFMPEG: legacyFfmpegFirst ? ffmpegPath : ffmpegStaticPath,
       LIVEDESK_FFMPEG_PATHS: (legacyFfmpegFirst
         ? [ffmpegPath, ffmpegStaticPath]
@@ -989,7 +1260,11 @@ try {
     frameSocket.on('message', handleMessage);
   });
 
-  frameSocket.send(JSON.stringify({
+  if (isMacPhysicalGate) {
+    macResourcePhase = 'steadyCapture';
+    await sampleMacResources(macResourcePhase);
+  }
+  frameSocket.send(JSON.stringify({
     type: 'subscribe',
     deviceIds: [connectedDeviceId],
     autoStartLive: true,
@@ -1007,6 +1282,7 @@ try {
   }));
 
   const frames = await withMacDiagnosticAbort(framePromise, cancelFrameWait);
+  let activeInputBindingFrame = frames.at(-1);
   const initialCaptureIdentity = switchMonitor && isWindows
     ? await waitFor(
         () => findWindowsCaptureIdentity(agentLogs, requestedMonitorIndex),
@@ -1175,6 +1451,7 @@ try {
         )
       : null;
     const firstSwitchedFrame = switchedFrames[0];
+    activeInputBindingFrame = switchedFrames.at(-1);
     const switchedFirstFrameMs = firstSwitchedFrame.receivedAt - switchedAt;
     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.');
@@ -1286,6 +1563,31 @@ try {
     console.log(`Mode 3 monitor transition OK: ${requestedMonitorIndex} -> ${nextMonitorIndex}, first frame ${switchedFirstFrameMs.toFixed(0)}ms, generation ${previousCaptureGeneration} -> ${firstSwitchedFrame.metadata.captureGeneration}.`);
   }
 
+  if (windowsInputAck) {
+    const inputProbe = await runWindowsInputAckProbe({
+      deviceId: connectedDeviceId,
+      sessionId: String(activeInputBindingFrame.metadata.sessionId || ''),
+      commandId: String(activeInputBindingFrame.metadata.commandId || ''),
+      captureGeneration: Number(activeInputBindingFrame.metadata.captureGeneration || 0),
+      monitorIndex: Number(activeInputBindingFrame.metadata.monitorIndex || 0)
+    }, {
+      expectHookLateStartFailure: windowsInputHookLateStart
+    });
+    if (windowsInputHookLateStart) {
+      console.log(
+        `Windows diagnostic hook late-start cleanup OK: expected timeout, `
+        + `Agent responsive, reset=${inputProbe.resetApplied}.`
+      );
+    } else {
+      console.log(
+        `Windows native modifier input ACK: ${inputProbe.accepted}/${inputProbe.requested} `
+        + `via ${inputProbe.backend}, hook=${inputProbe.hookObserved}/${inputProbe.hookBlocked}, `
+        + `duplicate=${inputProbe.duplicate}, `
+        + `focusChanged=${inputProbe.focusChanged}, reset=${inputProbe.resetApplied}.`
+      );
+    }
+  }
+
   if (transitionToMode5) {
     const previousFrameSocket = frameSocket;
     frameSocket = new WebSocket(`ws://127.0.0.1:${httpPort}/api/remote/frames/ws?devices=${encodeURIComponent(connectedDeviceId)}`);