livedesk 0.1.444 → 0.1.445

package/client/bin/livedesk-client.js

@@ -11,7 +11,13 @@ import net from 'node:net';
 import os from 'node:os';
 import { formatClientVersionBanner, readClientPackageVersion } from './client-version.js';
 import { createClientRuntimeServer } from '../src/runtime/client-runtime-server.js';
-import { installAgentTerminationHandlers } from '../src/runtime/agent-process-lifecycle.js';
+import {
+    createWindowsProcessTreeTracker,
+    drainOwnedWindowsAgentTree,
+    drainOwnedUnixAgentTree,
+    installAgentTerminationHandlers,
+    signalAgentTree
+} from '../src/runtime/agent-process-lifecycle.js';
 import { createHubWakeListener } from '../src/runtime/hub-wake-listener.js';
 import {
     inspectLinuxVideoAcceleration,
@@ -67,6 +73,22 @@ let networkChangeMonitor = null;
 const sessionRefreshesInFlight = new WeakMap();
 installAgentTerminationHandlers({ getAgentProcess: () => activeAgentProcess });
 
+function requestActiveAgentStop(signal = 'SIGTERM') {
+    const child = activeAgentProcess;
+    if (!child) return false;
+    if (process.platform === 'win32') {
+        // Internal reconnect/slot/role restarts use the same immutable
+        // PID+CreationDate tree contract as unexpected exit and terminal
+        // shutdown. Store the shared proof promise so no replacement can race.
+        if (!child.livedeskTreeStopPromise) {
+            child.livedeskTreeStopPromise = drainOwnedWindowsAgentTree(child);
+        }
+        return true;
+    }
+    signalAgentTree(child, signal);
+    return true;
+}
+
 export function requestLocalDiscoveryWake(reason = 'local-trigger') {
     const previous = discoveryWakeController;
     discoveryWakeController = new AbortController();
@@ -2783,7 +2805,7 @@ async function startConnectionChoiceServer(supabase, options = {}) {
                     res.end(JSON.stringify({ ok: true, restarting: true, role: 'hub', roleVersion: nextRoleVersion }));
                     setTimeout(() => {
                         try {
-                            activeAgentProcess?.kill();
+                            requestActiveAgentStop();
                         } catch {
                         }
                         try {
@@ -3080,7 +3102,7 @@ async function chooseClientConnection(supabase, options = {}) {
                 writeLocalRoleCache(role, options.deviceId, roleVersion);
                 roleRestartRequest = { role, requestedAt: new Date().toISOString() };
                 requestLocalDiscoveryWake('role-change');
-                try { activeAgentProcess?.kill(); } catch { /* the lifecycle loop observes the role request */ }
+                try { requestActiveAgentStop(); } catch { /* the lifecycle loop observes the role request */ }
                 return { ok: true, restarting: true, role, roleVersion };
             },
             videoAcceleration: linuxVideoAccelerationStatus,
@@ -3098,7 +3120,7 @@ async function chooseClientConnection(supabase, options = {}) {
                     requestedAt: new Date().toISOString()
                 };
                 requestLocalDiscoveryWake('linux-video-acceleration-ready');
-                try { activeAgentProcess?.kill(); } catch { /* the lifecycle loop restarts with the new ffmpeg preference */ }
+                try { requestActiveAgentStop(); } catch { /* the lifecycle loop restarts with the new ffmpeg preference */ }
             },
             assignSlot: async request => {
                 const result = await requestHubSlotAssignment(request);
@@ -3113,20 +3135,20 @@ async function chooseClientConnection(supabase, options = {}) {
                 };
                 requestLocalDiscoveryWake('slot-updated');
                 setTimeout(() => {
-                    try { activeAgentProcess?.kill(); } catch { /* the lifecycle loop restarts with the saved slot */ }
+                    try { requestActiveAgentStop(); } catch { /* the lifecycle loop restarts with the saved slot */ }
                 }, 150);
                 return { ...result, slotNumber, saved: true, restarting: true };
             },
             onRestart: () => process.kill(process.pid, 'SIGTERM'),
             onShutdown: () => process.kill(process.pid, 'SIGTERM'),
-            onDisconnect: () => activeAgentProcess?.kill(),
+            onDisconnect: () => requestActiveAgentStop(),
             // Ending the current Agent causes the unified lifecycle loop to
             // discard its old manager/pair token and start Supabase discovery
             // again.  Leaving this empty made the Reconnect button a success
             // response with no actual transport work.
             onReconnect: () => {
                 requestLocalDiscoveryWake('manual-reconnect');
-                activeAgentProcess?.kill();
+                requestActiveAgentStop();
             }
         });
         await connectionPage.start();
@@ -4103,6 +4125,7 @@ function spawnAgent(command, args, env = process.env, onStart = null) {
         restartVerified: false
     });
     const ownsProcessGroup = process.platform !== 'win32';
+    const agentSpawnedAtMs = Date.now();
     const child = spawn(command, args, {
         env,
         stdio: 'inherit',
@@ -4113,24 +4136,78 @@ function spawnAgent(command, args, env = process.env, onStart = null) {
         windowsHide: true
     });
     child.livedeskOwnsProcessGroup = ownsProcessGroup;
+    child.livedeskWindowsTreeTracker = createWindowsProcessTreeTracker(child, {
+        spawnedAtMs: agentSpawnedAtMs
+    });
     activeAgentProcess = child;
     if (typeof onStart === 'function') {
         onStart(child);
     }
 
-    return new Promise(resolve => {
-        child.once('error', error => {
-            console.error(`Failed to launch ${command}: ${error.message}`);
-            resolve({ code: 1, signal: null });
-        });
-        child.once('exit', (code, signal) => {
-            if (activeAgentProcess === child) {
-                activeAgentProcess = null;
-            }
-            resolve({ code: code ?? 0, signal });
-        });
-    });
-}
+    return new Promise(resolve => {
+        let settling = false;
+        child.once('error', error => {
+            if (settling) return;
+            settling = true;
+            child.livedeskWindowsTreeTracker?.stop?.();
+            if (activeAgentProcess === child) {
+                activeAgentProcess = null;
+            }
+            console.error(`Failed to launch ${command}: ${error.message}`);
+            resolve({ code: 1, signal: null });
+        });
+        child.once('exit', (code, signal) => {
+            if (settling) return;
+            settling = true;
+            child.livedeskWindowsTreeTracker?.markRootExited?.();
+            // The Unix Agent is a dedicated process-group leader. Its exit
+            // event proves only that the leader stopped; SCK/FFmpeg capture
+            // descendants can still own that PGID. Keep active ownership and
+            // do not let the lifecycle loop launch a replacement until the
+            // complete group has drained.
+            void (async () => {
+                try {
+                    if (process.platform === 'win32') {
+                        if (!child.livedeskTreeStopPromise) {
+                            child.livedeskTreeStopPromise = drainOwnedWindowsAgentTree(child);
+                        }
+                        const windowsTreeStop = await child.livedeskTreeStopPromise;
+                        if (windowsTreeStop?.ok === false) {
+                            throw new Error(
+                                `exact Windows Agent tree drain failed: `
+                                + `${windowsTreeStop.error?.message || 'bounded immutable-tree cleanup failed'}`
+                            );
+                        }
+                    }
+                    await drainOwnedUnixAgentTree(child);
+                } catch (error) {
+                    console.error(
+                        `[LiveDesk Client] Could not drain exited Agent tree pid=${child.pid || 'unknown'}: `
+                        + `${error?.message || error}`
+                    );
+                    // Block this lifecycle iteration from spawning a
+                    // replacement, but settle explicitly so the launcher
+                    // terminates instead of hanging forever.
+                    child.livedeskWindowsTreeTracker?.stop?.();
+                    if (activeAgentProcess === child) {
+                        activeAgentProcess = null;
+                    }
+                    resolve({
+                        code: 1,
+                        signal: null,
+                        lifecycleFailure: String(error?.message || error)
+                    });
+                    return;
+                }
+                child.livedeskWindowsTreeTracker?.stop?.();
+                if (activeAgentProcess === child) {
+                    activeAgentProcess = null;
+                }
+                resolve({ code: code ?? 0, signal });
+            })();
+        });
+    });
+}
 
 function shouldUseFast(parsed) {
     if (parsed.engine === 'node') {
@@ -4286,9 +4363,36 @@ export async function runClientRuntime(argv = process.argv.slice(2)) {
                     pid: child.pid,
                     startedAt: new Date().toISOString(),
                     state: 'running'
-                });
-            });
-        }
+                });
+            });
+        }
+        // Contract: once the owned Agent exits, the local runtime must stop
+        // advertising its old PID before any restart or Hub rediscovery.
+        // Keeping a dead PID makes status diagnostics lie and causes manual
+        // reconnect to target a process that no longer exists.
+        prepared.connectionPage?.update({
+            agent: {
+                requestedEngine: prepared.engine,
+                state: 'stopped',
+                pid: 0,
+                stoppedAt: new Date().toISOString(),
+                exitCode: Number.isInteger(result?.code) ? result.code : null,
+                exitSignal: result?.signal || ''
+            }
+        });
+        if (result?.lifecycleFailure) {
+            prepared.connectionPage?.update({
+                agent: {
+                    requestedEngine: prepared.engine,
+                    state: 'failed',
+                    pid: 0,
+                    error: result.lifecycleFailure
+                },
+                message: 'LiveDesk stopped because the previous Windows capture tree could not be drained safely.'
+            });
+            connectionPage?.close?.();
+            throw new Error(result.lifecycleFailure);
+        }
         const requestedRoleRestart = connectionPage?.getRoleRestartRequest?.();
         if (requestedRoleRestart?.role) {
             if (isTruthy(process.env.LIVEDESK_DESKTOP_HOST)) process.exit(43);
@@ -4302,7 +4406,8 @@ export async function runClientRuntime(argv = process.argv.slice(2)) {
             connectionPage?.update({
                 agent: {
                     requestedEngine: prepared.engine,
-                    state: 'reconnecting'
+                    state: 'reconnecting',
+                    pid: 0
                 },
                 message: restart.reason === 'slot-updated'
                     ? `Slot ${String(restart.slotNumber || prepared.slot || '').padStart(3, '0')} saved. Restarting the LiveDesk Agent.`
@@ -4331,10 +4436,11 @@ export async function runClientRuntime(argv = process.argv.slice(2)) {
                 ? 'LiveDesk Hub pair token changed. Refreshing Hub discovery now.'
                 : 'LiveDesk Hub connection ended. Looking for the current Hub now.');
             connectionPage?.update({
-                agent: {
-                    requestedEngine: prepared.engine,
-                    state: 'reconnecting'
-                },
+                agent: {
+                    requestedEngine: prepared.engine,
+                    state: 'reconnecting',
+                    pid: 0
+                },
                 manager: '',
                 message: 'The previous Hub is unavailable. LiveDesk is finding the current Hub automatically.'
             });

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.199",
+  "version": "0.1.200",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -41,10 +41,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.406",
-    "@livedesk/fast-osx-arm64": "0.1.406",
-    "@livedesk/fast-osx-x64": "0.1.406",
-    "@livedesk/fast-win-x64": "0.1.406"
+    "@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"
   },
   "publishConfig": {
     "access": "public"