@ricsam/r5d-worker 0.0.29 → 0.0.30

package/dist/cjs/main.cjs

@@ -49,6 +49,7 @@ var import_node_child_process = require("node:child_process");
 var import_cli_update = require("./cli-update.cjs");
 var import_git_identity = require("./git-identity.cjs");
 var import_heartbeat = require("./heartbeat.cjs");
+var import_process_tree = require("./process-tree.cjs");
 var import_supervisor = require("./supervisor.cjs");
 const import_meta = {};
 const DEFAULT_BASE_URL = "https://r5d.dev";
@@ -1817,6 +1818,7 @@ async function executeCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1838,7 +1840,12 @@ async function executeCommand(input) {
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
-        subprocess.kill("SIGTERM");
+        void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out command ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
       }, input.message.timeoutMs);
     }
     const [stdout, stderr, exitCode] = await Promise.all([
@@ -1874,6 +1881,8 @@ async function executeCommand(input) {
 async function executeStreamingCommand(input) {
   const startedAt = Date.now();
   let started = false;
+  let timedOut = false;
+  let timeout;
   try {
     if (cancelledProcessRuns.delete(input.message.runId)) {
       sendWorkerMessage(input.ws, {
@@ -1914,6 +1923,7 @@ async function executeStreamingCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1940,6 +1950,17 @@ async function executeStreamingCommand(input) {
       requestId: input.message.requestId,
       runId: input.message.runId
     });
+    if (input.message.timeoutMs) {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        void (0, import_process_tree.terminateProcessTree)(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out process ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
+      }, input.message.timeoutMs);
+    }
     const [exitCode] = await Promise.all([
       subprocess.exited,
       streamCommandOutput(subprocess.stdout, (data) => {
@@ -1963,7 +1984,8 @@ async function executeStreamingCommand(input) {
       type: "exec_exit",
       runId: input.message.runId,
       exitCode,
-      durationMs: Date.now() - startedAt
+      durationMs: Date.now() - startedAt,
+      ...timedOut ? { timedOut: true } : {}
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1983,6 +2005,9 @@ async function executeStreamingCommand(input) {
       });
     }
   } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
@@ -2545,18 +2570,27 @@ async function startWorker(options) {
       }
       if (message.type === "cancel") {
         const active = activeProcesses.get(message.runId);
+        let cancelled = true;
+        let cancelMessage;
         if (active) {
-          active.process.kill("SIGTERM");
+          try {
+            await (0, import_process_tree.terminateProcessTree)(active.process);
+            cancelMessage = `Stopped ${active.command}`;
+          } catch (error) {
+            cancelled = false;
+            cancelMessage = `Failed to stop ${active.command}: ${error instanceof Error ? error.message : String(error)}`;
+          }
         } else {
           cancelledProcessRuns.add(message.runId);
+          cancelMessage = "Cancellation queued before command start";
         }
         ws.send(
           JSON.stringify({
             type: "cancel_result",
             requestId: message.requestId,
             runId: message.runId,
-            cancelled: true,
-            message: active ? `Sent SIGTERM to ${active.command}` : "Cancellation queued before command start"
+            cancelled,
+            message: cancelMessage
           })
         );
         return;

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "type": "commonjs"
 }

package/dist/cjs/process-tree.cjs

@@ -0,0 +1,117 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var process_tree_exports = {};
+__export(process_tree_exports, {
+  terminateProcessTree: () => terminateProcessTree
+});
+module.exports = __toCommonJS(process_tree_exports);
+const DEFAULT_TERMINATION_GRACE_MS = 2e3;
+const DEFAULT_FORCE_KILL_WAIT_MS = 2e3;
+const PROCESS_GROUP_POLL_INTERVAL_MS = 25;
+const processTerminations = /* @__PURE__ */ new WeakMap();
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPosixProcessGroupRunning(processGroupId) {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch (error) {
+    if (errorCode(error) === "ESRCH") {
+      return false;
+    }
+    if (errorCode(error) === "EPERM") {
+      return true;
+    }
+    throw error;
+  }
+}
+function signalPosixProcessGroup(processGroupId, signal) {
+  try {
+    process.kill(-processGroupId, signal);
+  } catch (error) {
+    if (errorCode(error) !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function waitForPosixProcessGroupExit(processGroupId, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (isPosixProcessGroupRunning(processGroupId)) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await delay(Math.min(PROCESS_GROUP_POLL_INTERVAL_MS, remainingMs));
+  }
+  return true;
+}
+async function runWindowsTaskkill(pid) {
+  const taskkill = Bun.spawn(["taskkill", "/PID", String(pid), "/T", "/F"], {
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    taskkill.exited,
+    taskkill.stderr ? new Response(taskkill.stderr).text() : Promise.resolve("")
+  ]);
+  if (exitCode !== 0 && !/not found|no running instance/i.test(stderr)) {
+    throw new Error(`Failed to terminate process tree ${pid}: ${stderr.trim() || `taskkill exited ${exitCode}`}`);
+  }
+}
+async function terminateProcessTreeOnce(subprocess, options) {
+  if (!Number.isSafeInteger(subprocess.pid) || subprocess.pid <= 0) {
+    throw new Error(`Cannot terminate invalid subprocess PID: ${subprocess.pid}`);
+  }
+  if (process.platform === "win32") {
+    await runWindowsTaskkill(subprocess.pid);
+    return;
+  }
+  const graceMs = options.graceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+  const forceKillWaitMs = options.forceKillWaitMs ?? DEFAULT_FORCE_KILL_WAIT_MS;
+  signalPosixProcessGroup(subprocess.pid, "SIGTERM");
+  if (await waitForPosixProcessGroupExit(subprocess.pid, graceMs)) {
+    return;
+  }
+  signalPosixProcessGroup(subprocess.pid, "SIGKILL");
+  if (!await waitForPosixProcessGroupExit(subprocess.pid, forceKillWaitMs)) {
+    throw new Error(`Process group ${subprocess.pid} remained active after SIGKILL`);
+  }
+}
+function terminateProcessTree(subprocess, options = {}) {
+  const pending = processTerminations.get(subprocess);
+  if (pending) {
+    return pending;
+  }
+  const termination = terminateProcessTreeOnce(subprocess, options).finally(() => {
+    processTerminations.delete(subprocess);
+  });
+  processTerminations.set(subprocess, termination);
+  return termination;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  terminateProcessTree
+});

package/dist/mjs/main.mjs

@@ -7,6 +7,7 @@ import { spawn as spawnChildProcess } from "node:child_process";
 import { installCliUpdate, readInstalledCliVersion } from "./cli-update.mjs";
 import { configureVisibleGitIdentity } from "./git-identity.mjs";
 import { hasWorkerHeartbeatTimedOut, WORKER_HEARTBEAT_INTERVAL_MS } from "./heartbeat.mjs";
+import { terminateProcessTree } from "./process-tree.mjs";
 import { superviseWorkerRuntime, WORKER_RELOAD_EXIT_CODE, WORKER_RUNTIME_ENV } from "./supervisor.mjs";
 const DEFAULT_BASE_URL = "https://r5d.dev";
 const WORKER_PACKAGE_NAME = "@ricsam/r5d-worker";
@@ -1774,6 +1775,7 @@ async function executeCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1795,7 +1797,12 @@ async function executeCommand(input) {
     });
     if (input.message.timeoutMs) {
       timeout = setTimeout(() => {
-        subprocess.kill("SIGTERM");
+        void terminateProcessTree(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out command ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
       }, input.message.timeoutMs);
     }
     const [stdout, stderr, exitCode] = await Promise.all([
@@ -1831,6 +1838,8 @@ async function executeCommand(input) {
 async function executeStreamingCommand(input) {
   const startedAt = Date.now();
   let started = false;
+  let timedOut = false;
+  let timeout;
   try {
     if (cancelledProcessRuns.delete(input.message.runId)) {
       sendWorkerMessage(input.ws, {
@@ -1871,6 +1880,7 @@ async function executeStreamingCommand(input) {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
+      detached: true,
       env: {
         ...process.env,
         ...containerRegistryEnv(),
@@ -1897,6 +1907,17 @@ async function executeStreamingCommand(input) {
       requestId: input.message.requestId,
       runId: input.message.runId
     });
+    if (input.message.timeoutMs) {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        void terminateProcessTree(subprocess).catch((error) => {
+          process.stderr.write(
+            `[r5d-worker] failed to terminate timed-out process ${input.message.runId}: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+        });
+      }, input.message.timeoutMs);
+    }
     const [exitCode] = await Promise.all([
       subprocess.exited,
       streamCommandOutput(subprocess.stdout, (data) => {
@@ -1920,7 +1941,8 @@ async function executeStreamingCommand(input) {
       type: "exec_exit",
       runId: input.message.runId,
       exitCode,
-      durationMs: Date.now() - startedAt
+      durationMs: Date.now() - startedAt,
+      ...timedOut ? { timedOut: true } : {}
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1940,6 +1962,9 @@ async function executeStreamingCommand(input) {
       });
     }
   } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
     activeProcesses.delete(input.message.runId);
     cancelledProcessRuns.delete(input.message.runId);
   }
@@ -2502,18 +2527,27 @@ async function startWorker(options) {
       }
       if (message.type === "cancel") {
         const active = activeProcesses.get(message.runId);
+        let cancelled = true;
+        let cancelMessage;
         if (active) {
-          active.process.kill("SIGTERM");
+          try {
+            await terminateProcessTree(active.process);
+            cancelMessage = `Stopped ${active.command}`;
+          } catch (error) {
+            cancelled = false;
+            cancelMessage = `Failed to stop ${active.command}: ${error instanceof Error ? error.message : String(error)}`;
+          }
         } else {
           cancelledProcessRuns.add(message.runId);
+          cancelMessage = "Cancellation queued before command start";
         }
         ws.send(
           JSON.stringify({
             type: "cancel_result",
             requestId: message.requestId,
             runId: message.runId,
-            cancelled: true,
-            message: active ? `Sent SIGTERM to ${active.command}` : "Cancellation queued before command start"
+            cancelled,
+            message: cancelMessage
           })
         );
         return;

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "type": "module"
 }

package/dist/mjs/process-tree.mjs

@@ -0,0 +1,93 @@
+const DEFAULT_TERMINATION_GRACE_MS = 2e3;
+const DEFAULT_FORCE_KILL_WAIT_MS = 2e3;
+const PROCESS_GROUP_POLL_INTERVAL_MS = 25;
+const processTerminations = /* @__PURE__ */ new WeakMap();
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPosixProcessGroupRunning(processGroupId) {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch (error) {
+    if (errorCode(error) === "ESRCH") {
+      return false;
+    }
+    if (errorCode(error) === "EPERM") {
+      return true;
+    }
+    throw error;
+  }
+}
+function signalPosixProcessGroup(processGroupId, signal) {
+  try {
+    process.kill(-processGroupId, signal);
+  } catch (error) {
+    if (errorCode(error) !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function waitForPosixProcessGroupExit(processGroupId, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (isPosixProcessGroupRunning(processGroupId)) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return false;
+    }
+    await delay(Math.min(PROCESS_GROUP_POLL_INTERVAL_MS, remainingMs));
+  }
+  return true;
+}
+async function runWindowsTaskkill(pid) {
+  const taskkill = Bun.spawn(["taskkill", "/PID", String(pid), "/T", "/F"], {
+    stdout: "ignore",
+    stderr: "pipe"
+  });
+  const [exitCode, stderr] = await Promise.all([
+    taskkill.exited,
+    taskkill.stderr ? new Response(taskkill.stderr).text() : Promise.resolve("")
+  ]);
+  if (exitCode !== 0 && !/not found|no running instance/i.test(stderr)) {
+    throw new Error(`Failed to terminate process tree ${pid}: ${stderr.trim() || `taskkill exited ${exitCode}`}`);
+  }
+}
+async function terminateProcessTreeOnce(subprocess, options) {
+  if (!Number.isSafeInteger(subprocess.pid) || subprocess.pid <= 0) {
+    throw new Error(`Cannot terminate invalid subprocess PID: ${subprocess.pid}`);
+  }
+  if (process.platform === "win32") {
+    await runWindowsTaskkill(subprocess.pid);
+    return;
+  }
+  const graceMs = options.graceMs ?? DEFAULT_TERMINATION_GRACE_MS;
+  const forceKillWaitMs = options.forceKillWaitMs ?? DEFAULT_FORCE_KILL_WAIT_MS;
+  signalPosixProcessGroup(subprocess.pid, "SIGTERM");
+  if (await waitForPosixProcessGroupExit(subprocess.pid, graceMs)) {
+    return;
+  }
+  signalPosixProcessGroup(subprocess.pid, "SIGKILL");
+  if (!await waitForPosixProcessGroupExit(subprocess.pid, forceKillWaitMs)) {
+    throw new Error(`Process group ${subprocess.pid} remained active after SIGKILL`);
+  }
+}
+function terminateProcessTree(subprocess, options = {}) {
+  const pending = processTerminations.get(subprocess);
+  if (pending) {
+    return pending;
+  }
+  const termination = terminateProcessTreeOnce(subprocess, options).finally(() => {
+    processTerminations.delete(subprocess);
+  });
+  processTerminations.set(subprocess, termination);
+  return termination;
+}
+export {
+  terminateProcessTree
+};

package/dist/types/process-tree.d.ts

@@ -0,0 +1,16 @@
+export type KillableSubprocess = {
+    readonly pid: number;
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+};
+type TerminateProcessTreeOptions = {
+    graceMs?: number;
+    forceKillWaitMs?: number;
+};
+/**
+ * Terminates a subprocess spawned with `detached: true` and every descendant
+ * that remains in its process group. Concurrent termination requests share one
+ * cleanup attempt.
+ */
+export declare function terminateProcessTree(subprocess: KillableSubprocess, options?: TerminateProcessTreeOptions): Promise<void>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",