@livedesk/client 0.1.215 → 0.1.217

package/src/runtime/agent-process-lifecycle.js

@@ -1,7 +1,6 @@
 import { execFile } from 'node:child_process';
 
 const SIGNAL_EXIT_CODES = Object.freeze({ SIGINT: 130, SIGTERM: 143 });
-const DEFAULT_WINDOWS_TREE_SNAPSHOT_MS = 10_000;
 const WINDOWS_SPAWN_CLOCK_TOLERANCE_MS = 250;
 
 function normalizeWindowsProcessRecord(value) {
@@ -109,6 +108,52 @@ export async function queryWindowsProcessTable({
         .filter(Boolean);
 }
 
+/**
+ * Captures only the named immutable identities. Normal Agent startup uses this
+ * for the Agent root plus its launcher owner instead of enumerating every
+ * process on the computer. Full-table discovery remains a terminal/recovery
+ * operation where descendants actually need to be found.
+ */
+export async function queryWindowsProcessIdentities(processIds, {
+    execFileImpl = execFile
+} = {}) {
+    const ids = [...new Set((Array.isArray(processIds) ? processIds : [processIds])
+        .map(value => Number(value || 0))
+        .filter(value => Number.isInteger(value) && value > 1))]
+        .slice(0, 8);
+    if (ids.length === 0) return [];
+    const filter = ids.map(pid => `ProcessId = ${pid}`).join(' OR ');
+    const script = [
+        '$ErrorActionPreference = "Stop";',
+        `@(Get-CimInstance Win32_Process -Filter "${filter}" -Property ProcessId,ParentProcessId,CreationDate | ForEach-Object {`,
+        '  $creation = [string]$_.CreationDate;',
+        '  $ticks = if ($_.CreationDate) { [string]$_.CreationDate.ToUniversalTime().Ticks } else { "" };',
+        '  [pscustomobject]@{ ProcessId = [int]$_.ProcessId; ParentProcessId = [int]$_.ParentProcessId; CreationDate = $creation; CreationUtcTicks = $ticks }',
+        '}) | ConvertTo-Json -Compress'
+    ].join(' ');
+    const result = await runExecFile(
+        'powershell.exe',
+        ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script],
+        { windowsHide: true, timeout: 5000, killSignal: 'SIGKILL', maxBuffer: 64 * 1024 },
+        execFileImpl
+    );
+    if (!result.ok || !result.stdout) {
+        throw new Error(
+            `Windows process identity query failed: `
+            + `${result.stderr || result.error?.message || 'CIM query returned no process records'}`
+        );
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    } catch (error) {
+        throw new Error(`Windows process identity query returned invalid JSON: ${error?.message || error}`);
+    }
+    return (Array.isArray(parsed) ? parsed : [parsed])
+        .map(normalizeWindowsProcessRecord)
+        .filter(Boolean);
+}
+
 /**
  * Rechecks CreationDate and force-stops the single PID inside the same
  * PowerShell process. PID reuse therefore becomes a harmless identity mismatch
@@ -157,17 +202,19 @@ export async function terminateExactWindowsProcessTree(recordOrRecords, {
 
 /**
  * Tracks the exact Agent root and only descendants connected through Windows
- * ParentProcessId records. The default 10-second cadence is deliberately low
- * overhead; refreshes are serialized and the timer is unref'd. A final
- * snapshot covers normal direct FFmpeg children even between timer samples.
+ * ParentProcessId records. Startup queries only the Agent and launcher
+ * identities. Full process-table snapshots are serialized and request-driven
+ * by terminal cleanup/recovery; a healthy connected Client owns no recurring
+ * PowerShell/CIM timer.
  */
 export function createWindowsProcessTreeTracker(child, {
     platform = process.platform,
     queryProcessTableImpl = queryWindowsProcessTable,
-    snapshotIntervalMs = DEFAULT_WINDOWS_TREE_SNAPSHOT_MS,
+    queryInitialProcessRecordsImpl = null,
     spawnedAtMs = Date.now(),
-    setIntervalImpl = setInterval,
-    clearIntervalImpl = clearInterval,
+    ownerPid = process.pid,
+    initialRetryDelaysMs = [25, 75, 150],
+    waitImpl = waitMilliseconds,
     publishTrackedRecords = null,
     reportPublisherError = error => console.warn(
         `[LiveDesk Client] Windows owned-process manifest warning: ${error?.message || error}`
@@ -181,7 +228,6 @@ export function createWindowsProcessTreeTracker(child, {
     let lastError = null;
     let inFlight = null;
     let stopped = false;
-    let timer = null;
     let rootExitedAtMs = null;
     let rootCapturedBeforeExit = false;
     let lastSnapshotHadRootPid = false;
@@ -267,11 +313,22 @@ export function createWindowsProcessTreeTracker(child, {
         }
     };
 
-    const refresh = async () => {
+    const initialQuery = typeof queryInitialProcessRecordsImpl === 'function'
+        ? queryInitialProcessRecordsImpl
+        : queryProcessTableImpl === queryWindowsProcessTable
+            ? () => queryWindowsProcessIdentities([rootPid, ownerPid])
+            : queryProcessTableImpl;
+    const boundedInitialRetryDelays = (
+        Array.isArray(initialRetryDelaysMs) ? initialRetryDelaysMs : []
+    )
+        .slice(0, 5)
+        .map(value => Math.min(1000, Math.max(1, Number(value) || 1)));
+
+    const refresh = async ({ initial = false } = {}) => {
         if (!enabled) return { ok: true, records: [] };
         if (inFlight) return inFlight;
         inFlight = Promise.resolve()
-            .then(() => queryProcessTableImpl())
+            .then(() => (initial ? initialQuery() : queryProcessTableImpl()))
             .then(async snapshot => {
                 mergeSnapshot(snapshot);
                 lastError = null;
@@ -290,7 +347,7 @@ export function createWindowsProcessTreeTracker(child, {
                     } catch (error) {
                         // Manifest publication must never break the in-memory
                         // cleanup proof. Keep tracking, surface diagnostics,
-                        // and retry on the next cadence/terminal refresh.
+                        // and retry on the next requested/terminal refresh.
                         lastPublisherError = error;
                         try { reportPublisherError(error); } catch { /* diagnostics cannot own lifecycle */ }
                     }
@@ -311,14 +368,20 @@ export function createWindowsProcessTreeTracker(child, {
         return inFlight;
     };
 
-    const ready = enabled ? refresh() : Promise.resolve({ ok: true, records: [] });
-    if (enabled) {
-        const boundedInterval = Math.max(5000, Number(snapshotIntervalMs) || DEFAULT_WINDOWS_TREE_SNAPSHOT_MS);
-        timer = setIntervalImpl(() => {
-            if (!stopped) void refresh();
-        }, boundedInterval);
-        timer?.unref?.();
-    }
+    const ready = enabled
+        ? (async () => {
+            let result = await refresh({ initial: true });
+            for (const retryDelayMs of boundedInitialRetryDelays) {
+                if (rootRecord || stopped) break;
+                // A just-spawned PID can briefly lag its CIM identity. Retry
+                // only the exact root/launcher filter; never compensate with
+                // a healthy-state full-table timer.
+                await waitImpl(retryDelayMs);
+                result = await refresh({ initial: true });
+            }
+            return result;
+        })()
+        : Promise.resolve({ ok: true, records: [] });
 
     return {
         enabled,
@@ -326,8 +389,6 @@ export function createWindowsProcessTreeTracker(child, {
         refresh,
         stop() {
             stopped = true;
-            if (timer) clearIntervalImpl(timer);
-            timer = null;
         },
         getRootRecord: () => rootRecord ? { ...rootRecord } : null,
         markRootExited(exitedAtMs = Date.now()) {
@@ -629,6 +690,7 @@ export function installAgentTerminationHandlers({
     drainWindowsTree = drainOwnedWindowsAgentTreeUntilStopped,
     windowsTerminateAttemptLimit = 3,
     windowsTerminateRetryMs = 100,
+    windowsRecoveryRetryMs = 1000,
     unixTerminateRetryMs = 1000,
     reportTerminationFailure = message => console.error(message),
     exitProcess = code => hostProcess.exit(code)
@@ -693,7 +755,7 @@ export function installAgentTerminationHandlers({
                             platform,
                             maxAttempts: windowsTerminateAttemptLimit,
                             retryMs: windowsTerminateRetryMs,
-                            retryForeverMs: windowsTerminateRetryMs,
+                            retryForeverMs: windowsRecoveryRetryMs,
                             reportTerminationFailure
                         }));
                     }
@@ -712,7 +774,7 @@ export function installAgentTerminationHandlers({
                             child.livedeskWindowsDrainPromise = null;
                             windowsRetryTimer = setTimeout(
                                 drainUntilStopped,
-                                Math.max(100, Number(windowsTerminateRetryMs) || 100)
+                                Math.max(100, Number(windowsRecoveryRetryMs) || 1000)
                             );
                         });
                 };