chainlesschain 0.164.0 → 0.165.1

package/src/lib/background-session-transport.js

@@ -25,15 +25,18 @@
 
 import net from "node:net";
 import { unlinkSync } from "node:fs";
-import { join } from "node:path";
+import {
+  backgroundAgentSessionPipePath,
+  cleanupBackgroundAgentLocalPipeDirectory,
+  prepareBackgroundAgentLocalPipePath,
+} from "./background-agent-keeper-protocol.js";
 
 const HELLO_TIMEOUT_MS = 5000;
 const MAX_LINE_BYTES = 1024 * 1024;
 
 /** Pipe endpoint for a session id (Windows named pipe / POSIX socket file). */
-export function transportPipePath(id, dir) {
-  if (process.platform === "win32") return `\\\\.\\pipe\\cc-bg-${id}`;
-  return join(dir, `${id}.sock`);
+export function transportPipePath(id, dir, options = {}) {
+  return backgroundAgentSessionPipePath(id, dir, options);
 }
 
 /**
@@ -106,6 +109,7 @@ export function startBackgroundSessionServer(opts) {
     getStatus,
   } = opts;
   const pipePath = opts.pipePath || transportPipePath(id, dir);
+  prepareBackgroundAgentLocalPipePath(pipePath);
   if (process.platform !== "win32") {
     try {
       unlinkSync(pipePath); // stale socket from a crashed prior worker
@@ -259,9 +263,17 @@ export function startBackgroundSessionServer(opts) {
   });
 
   return new Promise((resolve, reject) => {
-    server.once("error", reject);
+    const rejectListen = (error) => {
+      try {
+        cleanupBackgroundAgentLocalPipeDirectory(pipePath);
+      } catch {
+        /* preserve the original listen error */
+      }
+      reject(error);
+    };
+    server.once("error", rejectListen);
     server.listen(pipePath, () => {
-      server.removeListener("error", reject);
+      server.removeListener("error", rejectListen);
       server.on("error", () => {
         /* post-listen errors must not crash the worker */
       });
@@ -299,6 +311,11 @@ export function startBackgroundSessionServer(opts) {
                 } catch {
                   /* already gone */
                 }
+                try {
+                  cleanupBackgroundAgentLocalPipeDirectory(pipePath);
+                } catch {
+                  /* best-effort cleanup after the server has closed */
+                }
               }
               done();
             });

package/src/lib/background-turn-bootstrap-protocol.js

@@ -124,3 +124,67 @@ export function clearBackgroundTurnBootstrapEnvironment(environment) {
     delete environment[key];
   }
 }
+
+/**
+ * Freeze a released POSIX turn in its detached process group when its worker
+ * disappears. The worker's detached-spawn contract makes the positive current
+ * PID the group ID; using its negative form fails with ESRCH if that invariant
+ * is ever broken instead of stopping an unrelated worker/runner group.
+ *
+ * Register the SIGCONT fail-safe before SIGSTOP because Node's process.kill()
+ * can return to JavaScript before the stop is delivered. If the group is ever
+ * resumed, immediately SIGKILL it instead of letting the Agent or one of its
+ * descendants continue without supervision.
+ */
+export function containReleasedBackgroundTurnDisconnect(options = {}) {
+  const released = options.released === true;
+  const platform = options.platform || process.platform;
+  const currentPid = Number(options.currentPid ?? process.pid);
+  const signalProcessGroup =
+    options.signalProcessGroup || process.kill.bind(process);
+  const resumeSignalTarget = options.resumeSignalTarget || process;
+  const onResumedKillFailure =
+    options.onResumedKillFailure || (() => process.exit(1));
+  if (
+    !released ||
+    platform === "win32" ||
+    !Number.isSafeInteger(currentPid) ||
+    currentPid <= 0
+  ) {
+    return false;
+  }
+  const groupPid = -currentPid;
+  const killAfterResume = () => {
+    try {
+      signalProcessGroup(groupPid, "SIGKILL");
+    } catch {
+      onResumedKillFailure();
+    }
+  };
+  try {
+    resumeSignalTarget.once("SIGCONT", killAfterResume);
+  } catch {
+    try {
+      signalProcessGroup(groupPid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    signalProcessGroup(groupPid, "SIGSTOP");
+    return true;
+  } catch {
+    try {
+      resumeSignalTarget.removeListener("SIGCONT", killAfterResume);
+    } catch {
+      // The same group SIGKILL below remains the containment fallback.
+    }
+    try {
+      signalProcessGroup(groupPid, "SIGKILL");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}