livedesk 0.1.445 → 0.1.447

package/hub/src/transport/udp-rendezvous.js

@@ -296,6 +296,7 @@ export function createUdpRendezvousServer({
         if (!hub || !client) return;
         send({
             type: 'rendezvous.peer',
+            protocol: UDP_P2P_PROTOCOL,
             roomId,
             role: 'client',
             host: client.address,
@@ -303,6 +304,7 @@ export function createUdpRendezvousServer({
         }, hub.address, hub.port);
         send({
             type: 'rendezvous.peer',
+            protocol: UDP_P2P_PROTOCOL,
             roomId,
             role: 'hub',
             host: hub.address,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "livedesk",
-  "version": "0.1.445",
-  "livedeskClientVersion": "0.1.200",
+  "version": "0.1.447",
+  "livedeskClientVersion": "0.1.202",
   "buildFlavor": "production",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
@@ -50,10 +50,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.407",
-    "@livedesk/fast-osx-arm64": "0.1.407",
-    "@livedesk/fast-osx-x64": "0.1.407",
-    "@livedesk/fast-win-x64": "0.1.407"
+    "@livedesk/fast-linux-x64": "0.1.410",
+    "@livedesk/fast-osx-arm64": "0.1.410",
+    "@livedesk/fast-osx-x64": "0.1.410",
+    "@livedesk/fast-win-x64": "0.1.410"
   },
   "publishConfig": {
     "access": "public"

package/runtime-core/src/role-transition-supervisor.js

@@ -1,4 +1,4 @@
-import { execFile, spawn } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import {
   appendFileSync,
   closeSync,
@@ -13,6 +13,10 @@ import {
 import net from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  registerOwnedWindowsChild,
+  terminateExactRegisteredWindowsTreeUntilStopped
+} from './windows-owned-process-tree.js';
 
 const ROLE_TRANSITION_SUPERVISOR_FLAG = '--run-livedesk-role-transition-supervisor';
 const SUPERVISOR_CLAIM_TIMEOUT_MS = 5_000;
@@ -148,20 +152,14 @@ async function verifyReplacement({ child, role, previousPid, runtimePort, remote
   throw new Error(`replacement-health-timeout:${role}`);
 }
 
-async function terminateOwnedProcessTree(pid) {
-  const processId = positiveInteger(pid);
-  if (processId <= 1 || !processIsAlive(processId)) return;
+async function terminateOwnedProcessTree(child) {
+  const processId = positiveInteger(child?.pid);
+  if (processId <= 1) return;
   if (process.platform === 'win32') {
-    await new Promise(resolveKill => {
-      execFile(
-        'taskkill.exe',
-        ['/PID', String(processId), '/T', '/F'],
-        { windowsHide: true, timeout: 10_000 },
-        () => resolveKill()
-      );
-    });
+    await terminateExactRegisteredWindowsTreeUntilStopped(child);
     return;
   }
+  if (!processIsAlive(processId)) return;
   try { process.kill(-processId, 'SIGTERM'); } catch {
     try { process.kill(processId, 'SIGTERM'); } catch { /* already stopped */ }
   }
@@ -234,6 +232,7 @@ async function runRoleTransitionSupervisor(env = process.env) {
     let child = null;
     try {
       logDescriptor = openSync(settings.logPath, 'a');
+      const replacementSpawnedAtMs = Date.now();
       child = spawn(
         process.execPath,
         [settings.launcherEntry, '--force-role', settings.role, '--no-open'],
@@ -245,15 +244,17 @@ async function runRoleTransitionSupervisor(env = process.env) {
           windowsHide: true
         }
       );
+      child.livedeskWindowsSpawnedAtMs = replacementSpawnedAtMs;
       await new Promise((resolveSpawn, rejectSpawn) => {
         child.once('spawn', resolveSpawn);
         child.once('error', rejectSpawn);
       });
+      await registerOwnedWindowsChild(child);
     } catch (error) {
       lastError = error;
       appendDiagnostic(settings.logPath, `attempt=${attempt} launch-failed error=${error?.message || error}`);
-      if (child?.pid && processIsAlive(child.pid)) {
-        await terminateOwnedProcessTree(child.pid);
+      if (child?.pid) {
+        await terminateOwnedProcessTree(child);
       }
       await wait(350);
       continue;
@@ -287,9 +288,7 @@ async function runRoleTransitionSupervisor(env = process.env) {
     } catch (error) {
       lastError = error;
       appendDiagnostic(settings.logPath, `attempt=${attempt} failed error=${error?.message || error}`);
-      if (processIsAlive(child.pid)) {
-        await terminateOwnedProcessTree(child.pid);
-      }
+      await terminateOwnedProcessTree(child);
       await wait(350);
     }
   }
@@ -312,6 +311,7 @@ export async function startRoleTransitionSupervisor(options = {}) {
   const logPath = join(stateDir, 'role-transition.log');
   const transitionId = `role-${role}-${Date.now()}-${process.pid}`;
   rmSync(statePath, { force: true });
+  const supervisorSpawnedAtMs = Date.now();
   const child = spawn(
     process.execPath,
     [fileURLToPath(import.meta.url), ROLE_TRANSITION_SUPERVISOR_FLAG],
@@ -334,10 +334,12 @@ export async function startRoleTransitionSupervisor(options = {}) {
       windowsHide: true
     }
   );
+  child.livedeskWindowsSpawnedAtMs = supervisorSpawnedAtMs;
   await new Promise((resolveSpawn, rejectSpawn) => {
     child.once('spawn', resolveSpawn);
     child.once('error', rejectSpawn);
   });
+  await registerOwnedWindowsChild(child);
   child.unref();
 
   const deadline = Date.now() + SUPERVISOR_CLAIM_TIMEOUT_MS;
@@ -353,7 +355,7 @@ export async function startRoleTransitionSupervisor(options = {}) {
     }
     await wait(50);
   }
-  await terminateOwnedProcessTree(child.pid);
+  await terminateOwnedProcessTree(child);
   throw new Error(`role-transition-supervisor-claim-timeout:${child.pid || 0}`);
 }
 

package/runtime-core/src/windows-owned-process-tree.js

@@ -0,0 +1,432 @@
+import { execFile } from 'node:child_process';
+
+const WINDOWS_EPOCH_TICKS = 621_355_968_000_000_000n;
+const SPAWN_CLOCK_TOLERANCE_MS = 250;
+
+function positivePid(value) {
+  const pid = Number(value || 0);
+  return Number.isInteger(pid) && pid > 1 ? pid : 0;
+}
+
+function normalizeRecord(value, depth = 0) {
+  const pid = positivePid(value?.pid ?? value?.ProcessId);
+  const parentPid = Number(value?.parentPid ?? value?.ParentProcessId ?? 0);
+  const startOrder = String(value?.startOrder ?? value?.CreationUtcTicks ?? '').trim();
+  if (!pid || !/^\d+$/.test(startOrder)) return null;
+  return {
+    pid,
+    parentPid: Number.isInteger(parentPid) && parentPid >= 0 ? parentPid : 0,
+    startOrder,
+    depth: Math.max(0, Number(depth) || 0)
+  };
+}
+
+function sameRecord(left, right) {
+  return positivePid(left?.pid) === positivePid(right?.pid)
+    && String(left?.startOrder || '') === String(right?.startOrder || '');
+}
+
+function windowsTicksForMilliseconds(milliseconds) {
+  return BigInt(Math.trunc(Number(milliseconds) || 0)) * 10_000n + WINDOWS_EPOCH_TICKS;
+}
+
+function collectRootAbsentWindowsTree(rootPid, snapshot, {
+  spawnedAtMs,
+  exitedAtMs
+} = {}) {
+  const processId = positivePid(rootPid);
+  if (!processId || !Number.isFinite(Number(exitedAtMs)) || Number(exitedAtMs) <= 0) return [];
+  const records = (Array.isArray(snapshot) ? snapshot : [])
+    .map(record => normalizeRecord(record))
+    .filter(Boolean);
+  const lowerBound = windowsTicksForMilliseconds(
+    Math.max(0, Number(spawnedAtMs || 0) - SPAWN_CLOCK_TOLERANCE_MS)
+  );
+  const upperBound = windowsTicksForMilliseconds(exitedAtMs);
+  const childrenByParent = new Map();
+  for (const record of records) {
+    if (!childrenByParent.has(record.parentPid)) childrenByParent.set(record.parentPid, []);
+    childrenByParent.get(record.parentPid).push(record);
+  }
+  const result = [];
+  const queue = [{ pid: processId, startOrder: String(lowerBound), depth: 0, virtualRoot: true }];
+  const seen = new Set([processId]);
+  while (queue.length > 0) {
+    const parent = queue.shift();
+    for (const child of childrenByParent.get(parent.pid) || []) {
+      if (seen.has(child.pid)) continue;
+      try {
+        const childStart = BigInt(child.startOrder);
+        if (childStart < BigInt(parent.startOrder)) continue;
+        if (parent.virtualRoot && (childStart < lowerBound || childStart > upperBound)) continue;
+      } catch {
+        continue;
+      }
+      seen.add(child.pid);
+      const descendant = { ...child, depth: parent.depth + 1 };
+      result.push(descendant);
+      queue.push({ ...descendant, virtualRoot: false });
+    }
+  }
+  return result;
+}
+
+function runPowerShell(script, {
+  execFileImpl = execFile,
+  timeoutMs = 10_000
+} = {}) {
+  return new Promise(resolveRun => {
+    execFileImpl(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script],
+      {
+        windowsHide: true,
+        timeout: timeoutMs,
+        killSignal: 'SIGKILL',
+        maxBuffer: 4 * 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        resolveRun({
+          ok: !error,
+          error: error || null,
+          stdout: String(stdout || '').trim(),
+          stderr: String(stderr || '').trim()
+        });
+      }
+    );
+  });
+}
+
+export async function queryExactWindowsProcessSnapshot(options = {}) {
+  const script = [
+    '$ErrorActionPreference = "Stop";',
+    '$records = @(Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate | ForEach-Object {',
+    '  $ticks = if ($_.CreationDate) { [string]$_.CreationDate.ToUniversalTime().Ticks } else { "" };',
+    '  [pscustomobject]@{ ProcessId = [int]$_.ProcessId; ParentProcessId = [int]$_.ParentProcessId; CreationUtcTicks = $ticks }',
+    '});',
+    '[pscustomobject]@{ Records = $records } | ConvertTo-Json -Compress -Depth 4'
+  ].join(' ');
+  const result = await runPowerShell(script, options);
+  if (!result.ok || !result.stdout) {
+    throw new Error(
+      `windows-process-snapshot-failed:${result.stderr || result.error?.message || 'empty-cim-result'}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout);
+  } catch (error) {
+    throw new Error(`windows-process-snapshot-invalid-json:${error?.message || error}`);
+  }
+  const values = parsed?.Records == null
+    ? []
+    : Array.isArray(parsed.Records) ? parsed.Records : [parsed.Records];
+  return values.map(value => normalizeRecord(value)).filter(Boolean);
+}
+
+export async function captureExactWindowsProcessIdentity(pid, options = {}) {
+  const processId = positivePid(pid);
+  if (!processId) return null;
+  const snapshot = await (options.querySnapshotImpl || queryExactWindowsProcessSnapshot)(options);
+  return snapshot.find(record => record.pid === processId) || null;
+}
+
+export function registerOwnedWindowsChild(child, {
+  platform = process.platform,
+  querySnapshotImpl = queryExactWindowsProcessSnapshot,
+  execFileImpl = execFile,
+  captureTimeoutMs = 2_500,
+  retryMs = 50
+} = {}) {
+  if (platform !== 'win32' || !positivePid(child?.pid)) return Promise.resolve(null);
+  if (child.livedeskWindowsIdentityPromise) return child.livedeskWindowsIdentityPromise;
+  child.livedeskWindowsSpawnedAtMs ||= Date.now();
+  child.livedeskWindowsTrackedRecords ||= new Map();
+  if (!child.livedeskWindowsExitListenerRegistered) {
+    child.livedeskWindowsExitListenerRegistered = true;
+    child.once?.('exit', () => {
+      if (!child.livedeskWindowsExitedAtMs) child.livedeskWindowsExitedAtMs = Date.now();
+    });
+  }
+  child.livedeskWindowsIdentityPromise = (async () => {
+    const deadline = Date.now() + Math.max(50, Number(captureTimeoutMs) || 2_500);
+    let lastError = null;
+    do {
+      if ((child.exitCode !== null && child.exitCode !== undefined)
+        || child.signalCode
+        || child.livedeskWindowsExitedAtMs) {
+        child.livedeskWindowsExitedAtMs ||= Date.now();
+      }
+      try {
+        const snapshot = await querySnapshotImpl({ execFileImpl });
+        const identity = snapshot.find(record => record.pid === positivePid(child.pid)) || null;
+        if (identity && !child.livedeskWindowsExitedAtMs) return identity;
+        lastError = null;
+        if (child.livedeskWindowsExitedAtMs) {
+          for (const record of collectRootAbsentWindowsTree(child.pid, snapshot, {
+            spawnedAtMs: child.livedeskWindowsSpawnedAtMs,
+            exitedAtMs: child.livedeskWindowsExitedAtMs
+          })) {
+            child.livedeskWindowsTrackedRecords.set(`${record.pid}:${record.startOrder}`, record);
+          }
+          child.livedeskWindowsSafeExitSnapshot = true;
+          return null;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) break;
+      await new Promise(resolveWait => setTimeout(
+        resolveWait,
+        Math.min(Math.max(1, Number(retryMs) || 50), remainingMs)
+      ));
+    } while (Date.now() < deadline);
+    throw lastError || new Error(`windows-owned-process-identity-timeout:${child.pid}`);
+  })().then(identity => {
+    child.livedeskWindowsIdentity = identity;
+    child.livedeskWindowsIdentityError = null;
+    return identity;
+  }).catch(error => {
+    child.livedeskWindowsIdentityError = error;
+    return null;
+  });
+  return child.livedeskWindowsIdentityPromise;
+}
+
+export function collectExactWindowsProcessTree(rootIdentity, snapshot, {
+  rootExitedAtMs = null
+} = {}) {
+  const root = normalizeRecord(rootIdentity, 0);
+  if (!root) return [];
+  const records = (Array.isArray(snapshot) ? snapshot : [])
+    .map(record => normalizeRecord(record))
+    .filter(Boolean);
+  const currentByPid = new Map(records.map(record => [record.pid, record]));
+  const currentRoot = currentByPid.get(root.pid) || null;
+  const exactRootAlive = sameRecord(currentRoot, root);
+  let directChildUpperBound = null;
+  if (!exactRootAlive) {
+    if (currentRoot) {
+      directChildUpperBound = BigInt(currentRoot.startOrder) - 1n;
+    } else if (Number.isFinite(Number(rootExitedAtMs)) && Number(rootExitedAtMs) > 0) {
+      directChildUpperBound = windowsTicksForMilliseconds(rootExitedAtMs);
+    } else {
+      return [];
+    }
+  }
+
+  const childrenByParent = new Map();
+  for (const record of records) {
+    if (!childrenByParent.has(record.parentPid)) childrenByParent.set(record.parentPid, []);
+    childrenByParent.get(record.parentPid).push(record);
+  }
+  const result = exactRootAlive ? [{ ...currentRoot, depth: 0 }] : [];
+  const queue = [{ record: root, depth: 0, virtualRoot: true }];
+  const seen = new Set([root.pid]);
+  while (queue.length > 0) {
+    const parent = queue.shift();
+    for (const child of childrenByParent.get(parent.record.pid) || []) {
+      if (seen.has(child.pid)) continue;
+      let childStart;
+      try {
+        childStart = BigInt(child.startOrder);
+        if (childStart < BigInt(parent.record.startOrder)) continue;
+        if (parent.virtualRoot
+          && directChildUpperBound !== null
+          && childStart > directChildUpperBound) continue;
+      } catch {
+        continue;
+      }
+      seen.add(child.pid);
+      const descendant = { ...child, depth: parent.depth + 1 };
+      result.push(descendant);
+      queue.push({ record: descendant, depth: descendant.depth, virtualRoot: false });
+    }
+  }
+  return result;
+}
+
+async function stopExactWindowsRecords(records, options = {}) {
+  const targets = (Array.isArray(records) ? records : [])
+    .map(record => normalizeRecord(record, record?.depth))
+    .filter(Boolean);
+  if (targets.length === 0) return { ok: true };
+  const encoded = Buffer.from(JSON.stringify(targets.map(target => ({
+    pid: target.pid,
+    startOrder: target.startOrder
+  }))), 'utf8').toString('base64');
+  const script = [
+    '$ErrorActionPreference = "Stop";',
+    `$json = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("${encoded}"));`,
+    '$targets = ConvertFrom-Json -InputObject $json;',
+    '$failures = [System.Collections.Generic.List[string]]::new();',
+    'foreach ($item in $targets) {',
+    '  $targetPid = [int]$item.pid;',
+    '  $expectedTicks = [string]$item.startOrder;',
+    '  try {',
+    '    $target = Get-CimInstance Win32_Process -Filter "ProcessId = $targetPid" -Property ProcessId,CreationDate -ErrorAction SilentlyContinue | Select-Object -First 1;',
+    '    if (-not $target) { continue };',
+    '    $actualTicks = if ($target.CreationDate) { [string]$target.CreationDate.ToUniversalTime().Ticks } else { "" };',
+    '    if ($actualTicks -ne $expectedTicks) { continue };',
+    '    Stop-Process -Id $targetPid -Force -ErrorAction Stop;',
+    '  } catch { $failures.Add("pid=$targetPid $($_.Exception.Message)") }',
+    '}',
+    'if ($failures.Count -gt 0) { [Console]::Error.WriteLine(($failures -join "; ")); exit 1 }'
+  ].join(' ');
+  return runPowerShell(script, { ...options, timeoutMs: 15_000 });
+}
+
+export async function terminateExactRegisteredWindowsTree(child, {
+  platform = process.platform,
+  querySnapshotImpl = queryExactWindowsProcessSnapshot,
+  stopRecordsImpl = stopExactWindowsRecords,
+  execFileImpl = execFile,
+  maxAttempts = 4,
+  retryMs = 100
+} = {}) {
+  if (platform !== 'win32' || !positivePid(child?.pid)) return;
+  const identity = child.livedeskWindowsIdentity
+    || await registerOwnedWindowsChild(child, { platform, querySnapshotImpl, execFileImpl });
+  if (!identity) {
+    if (child.livedeskWindowsIdentityError) throw child.livedeskWindowsIdentityError;
+    if (!child.livedeskWindowsSafeExitSnapshot) {
+      throw new Error(`windows-owned-process-exit-snapshot-unavailable:${child.pid}`);
+    }
+    if (!child.livedeskWindowsTrackedRecords?.size) return;
+  }
+
+  const tracked = new Map(child.livedeskWindowsTrackedRecords || []);
+  const trackedExitBoundaries = new Map();
+  let rootExitedAtMs = Number(child.livedeskWindowsExitedAtMs || 0) || null;
+  let latestStopAtMs = rootExitedAtMs;
+  let lastError = null;
+  const mergeTracked = (record, depth = record?.depth) => {
+    const normalized = normalizeRecord(record, depth);
+    if (!normalized) return;
+    const key = `${normalized.pid}:${normalized.startOrder}`;
+    const previous = tracked.get(key);
+    if (!previous || normalized.depth > previous.depth) tracked.set(key, normalized);
+  };
+  const mergeSnapshot = snapshot => {
+    const currentByPid = new Map(snapshot.map(record => [record.pid, record]));
+    if (identity) {
+      for (const record of collectExactWindowsProcessTree(identity, snapshot, { rootExitedAtMs })) {
+        mergeTracked(record);
+      }
+    } else {
+      for (const record of collectRootAbsentWindowsTree(child.pid, snapshot, {
+        spawnedAtMs: child.livedeskWindowsSpawnedAtMs,
+        exitedAtMs: rootExitedAtMs
+      })) {
+        mergeTracked(record);
+      }
+    }
+    for (const parent of [...tracked.values()]) {
+      const parentKey = `${parent.pid}:${parent.startOrder}`;
+      const parentAlive = sameRecord(currentByPid.get(parent.pid), parent);
+      if (!parentAlive && !trackedExitBoundaries.has(parentKey)) {
+        trackedExitBoundaries.set(parentKey, Date.now());
+      }
+      for (const record of collectExactWindowsProcessTree(parent, snapshot, {
+        rootExitedAtMs: parentAlive
+          ? null
+          : trackedExitBoundaries.get(parentKey) || latestStopAtMs
+      })) {
+        mergeTracked(record, Number(parent.depth || 0) + Number(record.depth || 0));
+      }
+    }
+  };
+  const attempts = Math.max(1, Number(maxAttempts) || 4);
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    let snapshot;
+    try {
+      snapshot = await querySnapshotImpl({ execFileImpl });
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts) {
+        await new Promise(resolveWait => setTimeout(
+          resolveWait,
+          Math.max(25, Number(retryMs) || 100)
+        ));
+        continue;
+      }
+      break;
+    }
+    const currentByPid = new Map(snapshot.map(record => [record.pid, record]));
+    if (identity && !sameRecord(currentByPid.get(identity.pid), identity) && rootExitedAtMs === null) {
+      rootExitedAtMs = Date.now();
+    }
+    mergeSnapshot(snapshot);
+    const remaining = [...tracked.values()]
+      .filter(record => sameRecord(currentByPid.get(record.pid), record))
+      .sort((left, right) => Number(right.depth || 0) - Number(left.depth || 0));
+    if (remaining.length === 0) return;
+    const result = await stopRecordsImpl(remaining, { execFileImpl });
+    if (result?.ok === false) {
+      lastError = result.error || new Error(result.stderr || 'exact-windows-stop-failed');
+    }
+    latestStopAtMs = Date.now();
+    for (const record of remaining) {
+      const key = `${record.pid}:${record.startOrder}`;
+      if (!trackedExitBoundaries.has(key)) trackedExitBoundaries.set(key, latestStopAtMs);
+    }
+    if (identity && remaining.some(record => sameRecord(record, identity)) && rootExitedAtMs === null) {
+      rootExitedAtMs = Date.now();
+    }
+    if (attempt < attempts) {
+      await new Promise(resolveWait => setTimeout(resolveWait, Math.max(25, Number(retryMs) || 100)));
+    }
+  }
+
+  let finalSnapshot;
+  try {
+    finalSnapshot = await querySnapshotImpl({ execFileImpl });
+  } catch (error) {
+    throw lastError || error;
+  }
+  const finalByPid = new Map(finalSnapshot.map(record => [record.pid, record]));
+  mergeSnapshot(finalSnapshot);
+  const remaining = [...tracked.values()].filter(record => (
+    sameRecord(finalByPid.get(record.pid), record)
+  ));
+  if (remaining.length > 0) {
+    throw new Error(
+      `exact-windows-owned-tree-still-alive:${remaining.map(record => record.pid).join(',')}`
+      + `${lastError?.message ? `:${lastError.message}` : ''}`
+    );
+  }
+}
+
+export async function terminateExactRegisteredWindowsTreeUntilStopped(child, {
+  retryForeverMs = 500,
+  onRetry = () => undefined,
+  ...options
+} = {}) {
+  if ((options.platform || process.platform) !== 'win32' || !positivePid(child?.pid)) return;
+  if (child.livedeskWindowsDrainUntilStoppedPromise) {
+    return child.livedeskWindowsDrainUntilStoppedPromise;
+  }
+  child.livedeskWindowsDrainUntilStoppedPromise = (async () => {
+    let attempt = 0;
+    while (true) {
+      attempt += 1;
+      try {
+        await terminateExactRegisteredWindowsTree(child, options);
+        return;
+      } catch (error) {
+        onRetry(error, attempt);
+        if (!child.livedeskWindowsIdentity) {
+          child.livedeskWindowsIdentityPromise = null;
+          child.livedeskWindowsIdentityError = null;
+          child.livedeskWindowsSafeExitSnapshot = false;
+        }
+        await new Promise(resolveWait => setTimeout(
+          resolveWait,
+          Math.max(50, Number(retryForeverMs) || 500)
+        ));
+      }
+    }
+  })();
+  return child.livedeskWindowsDrainUntilStoppedPromise;
+}