@livedesk/client 0.1.196 → 0.1.198

package/bin/livedesk-client.js

@@ -4102,11 +4102,17 @@ function spawnAgent(command, args, env = process.env, onStart = null) {
         agentPid: 0,
         restartVerified: false
     });
+    const ownsProcessGroup = process.platform !== 'win32';
     const child = spawn(command, args, {
         env,
         stdio: 'inherit',
+        // A dedicated Unix process group lets Ctrl+C, replacement startup, and
+        // forced shutdown terminate RemoteFast together with its SCK/FFmpeg
+        // descendants without touching npm, the terminal, or unrelated jobs.
+        detached: ownsProcessGroup,
         windowsHide: true
     });
+    child.livedeskOwnsProcessGroup = ownsProcessGroup;
     activeAgentProcess = child;
     if (typeof onStart === 'function') {
         onStart(child);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -41,10 +41,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.403",
-    "@livedesk/fast-osx-arm64": "0.1.403",
-    "@livedesk/fast-osx-x64": "0.1.403",
-    "@livedesk/fast-win-x64": "0.1.403"
+    "@livedesk/fast-linux-x64": "0.1.405",
+    "@livedesk/fast-osx-arm64": "0.1.405",
+    "@livedesk/fast-osx-x64": "0.1.405",
+    "@livedesk/fast-win-x64": "0.1.405"
   },
   "publishConfig": {
     "access": "public"

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

@@ -1,9 +1,76 @@
+import { execFile } from 'node:child_process';
+
 const SIGNAL_EXIT_CODES = Object.freeze({ SIGINT: 130, SIGTERM: 143 });
 
+function terminateWindowsProcessTree(processId) {
+    return new Promise(resolve => {
+        execFile(
+            'taskkill.exe',
+            ['/PID', String(processId), '/T', '/F'],
+            {
+                windowsHide: true,
+                timeout: 10000,
+                killSignal: 'SIGKILL'
+            },
+            error => resolve({ ok: !error, error: error || null })
+        );
+    });
+}
+
+function isOwnedUnixProcessGroupAlive(child, platform, signalProcess) {
+    const processId = Number(child?.pid || 0);
+    if (platform === 'win32'
+        || child?.livedeskOwnsProcessGroup !== true
+        || !Number.isInteger(processId)
+        || processId <= 1) {
+        return false;
+    }
+    try {
+        signalProcess(-processId, 0);
+        return true;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
+function isProcessIdAlive(processId, signalProcess) {
+    if (!Number.isInteger(processId) || processId <= 1) {
+        return false;
+    }
+    try {
+        signalProcess(processId, 0);
+        return true;
+    } catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+
+function signalAgentTree(child, signal, platform, signalProcess) {
+    const processId = Number(child?.pid || 0);
+    if (platform !== 'win32'
+        && child?.livedeskOwnsProcessGroup === true
+        && Number.isInteger(processId)
+        && processId > 1) {
+        try {
+            signalProcess(-processId, signal);
+            return;
+        } catch (error) {
+            if (error?.code !== 'ESRCH') throw error;
+        }
+    }
+    child.kill(signal);
+}
+
 export function installAgentTerminationHandlers({
     hostProcess = process,
     getAgentProcess,
-    shutdownTimeoutMs = 3000,
+    shutdownTimeoutMs = 8000,
+    platform = process.platform,
+    signalProcess = (pid, signal) => process.kill(pid, signal),
+    terminateWindowsTree = terminateWindowsProcessTree,
+    windowsTerminateAttemptLimit = 3,
+    windowsTerminateRetryMs = 100,
+    reportTerminationFailure = message => console.error(message),
     exitProcess = code => hostProcess.exit(code)
 } = {}) {
     if (typeof getAgentProcess !== 'function') {
@@ -18,32 +85,110 @@ export function installAgentTerminationHandlers({
             terminating = true;
             const exitCode = SIGNAL_EXIT_CODES[signal] || 1;
             const child = getAgentProcess();
-            if (!child || child.exitCode !== null || child.killed === true) {
+            if (!child || child.exitCode !== null) {
                 exitProcess(exitCode);
                 return;
             }
 
             let finished = false;
+            let poll = null;
+            let timeout = null;
+            let hardStop = null;
+            let windowsRetryTimer = null;
             const finish = () => {
                 if (finished) return;
                 finished = true;
+                if (poll) clearInterval(poll);
+                if (timeout) clearTimeout(timeout);
+                if (hardStop) clearTimeout(hardStop);
+                if (windowsRetryTimer) clearTimeout(windowsRetryTimer);
                 exitProcess(exitCode);
             };
-            child.once('exit', finish);
+            const processId = Number(child?.pid || 0);
+            if (platform === 'win32') {
+                if (!Number.isInteger(processId) || processId <= 1) {
+                    finish();
+                    return;
+                }
+                // On Windows child.kill() only gives us the Agent leader's
+                // lifecycle. It does not provide an authoritative contract
+                // that FFmpeg descendants have stopped. Keep the launcher
+                // alive until taskkill has completed against this exact,
+                // launcher-owned process tree. Never search for or terminate
+                // unrelated ffmpeg.exe processes globally.
+                const attemptLimit = Math.max(1, Number(windowsTerminateAttemptLimit) || 3);
+                const retryMs = Math.max(25, Number(windowsTerminateRetryMs) || 100);
+                let attempt = 0;
+                let failureReported = false;
+                const terminateOwnedTree = () => {
+                    if (finished) return;
+                    attempt += 1;
+                    let treeTermination;
+                    try {
+                        treeTermination = terminateWindowsTree(processId);
+                    } catch (error) {
+                        treeTermination = { ok: false, error };
+                    }
+                    Promise.resolve(treeTermination)
+                        .catch(error => ({ ok: false, error }))
+                        .then(result => {
+                            if (finished) return;
+                            if (result?.ok !== false) {
+                                finish();
+                                return;
+                            }
+                            if (!isProcessIdAlive(processId, signalProcess)) {
+                                finish();
+                                return;
+                            }
+
+                            const burstExhausted = attempt >= attemptLimit;
+                            if (burstExhausted && !failureReported) {
+                                failureReported = true;
+                                const reason = result?.error?.message || 'taskkill returned an error';
+                                reportTerminationFailure(
+                                    `[LiveDesk Client] Agent tree pid=${processId} is still alive after `
+                                    + `${attemptLimit} exact-PID taskkill attempts (${reason}). `
+                                    + 'The launcher will remain alive and keep retrying so capture descendants are not orphaned.'
+                                );
+                            }
+                            if (burstExhausted) {
+                                attempt = 0;
+                            }
+                            windowsRetryTimer = setTimeout(
+                                terminateOwnedTree,
+                                burstExhausted ? Math.max(1000, retryMs) : retryMs
+                            );
+                        });
+                };
+                terminateOwnedTree();
+                return;
+            }
+            const finishWhenTreeStops = () => {
+                const ownsUnixGroup = child?.livedeskOwnsProcessGroup === true
+                    && Number(child?.pid || 0) > 1;
+                const childAlive = child.exitCode === null && child.signalCode == null;
+                const groupAlive = ownsUnixGroup
+                    && isOwnedUnixProcessGroupAlive(child, platform, signalProcess);
+                if (!childAlive && !groupAlive) {
+                    finish();
+                }
+            };
+            child.once('exit', finishWhenTreeStops);
             try {
-                child.kill(signal);
+                signalAgentTree(child, signal, platform, signalProcess);
             } catch {
                 finish();
                 return;
             }
-            const timeout = setTimeout(() => {
+            poll = setInterval(finishWhenTreeStops, 50);
+            timeout = setTimeout(() => {
                 try {
-                    if (child.exitCode === null) child.kill('SIGKILL');
+                    signalAgentTree(child, 'SIGKILL', platform, signalProcess);
                 } catch {
                 }
-                finish();
+                hardStop = setTimeout(finish, 250);
             }, Math.max(100, Number(shutdownTimeoutMs) || 3000));
-            timeout.unref?.();
         };
         handlers.set(signal, handler);
         hostProcess.once(signal, handler);