ChildProcess: support scoped ownership after the group leader exits successfully #8338

Activity

1. jasonkuhrt commented on Sep 23, 2026

   

   jasonkuhrt

   on Sep 23, 2026

   ContributorAuthor

   More actions

   Update from 4.0.0-rc.117: #8245 (shipped in rc.116) covers the successful-exit case. When a referenced, detached command's leader exits 0 or by a signal, scope release now runs terminateProcessGroup: kill signal, then forceKillAfter, then SIGKILL. We deleted our adapter.

   One exit path still skips escalation: a leader that exits with a non-zero code. On that path, release only calls killProcessGroup with the kill signal, with no wait and no forceKillAfter. The exit listener does the same when the leader exits. Nothing on that path ever sends SIGKILL, so a descendant that ignores SIGTERM outlives the scope.

   packages/platform/node-shared/src/NodeChildProcessSpawner.ts at 34e09be:

   • L549-L550: release after a non-zero exit calls only killProcessGroup(...)
   • L551-L552: release after exit 0 or a signal calls terminateProcessGroup(...)
   • L559: release while the leader is still running calls terminateProcessGroup(...)
   • L564-L567: the exit listener calls killProcessGroupOnExit(...) on a non-zero exit

   Repro (effect and @effect/platform-node 4.0.0-rc.117, Node 22.23.1, macOS; on main after #8354 the import is effect/process):

   import * as NodeServices from "@effect/platform-node/NodeServices"
   import { Effect } from "effect"
   import { ChildProcess } from "effect/unstable/process"
   import * as fs from "node:fs"
   import * as os from "node:os"
   import * as path from "node:path"
   
   const isAlive = (pid) => {
     try {
       process.kill(pid, 0)
       return true
     } catch {
       return false
     }
   }
   
   const run = (leaderExitCode) =>
     Effect.gen(function*() {
       const pidFile = path.join(os.tmpdir(), `repro-8338-${process.pid}-${leaderExitCode}.pid`)
       // The leader starts a same-group child that ignores SIGTERM, records its
       // pid, then exits with `leaderExitCode`.
       const script = `(trap '' TERM; exec sleep 30) & echo $! > ${pidFile}; exit ${leaderExitCode}`
       yield* Effect.scoped(
         Effect.gen(function*() {
           const handle = yield* ChildProcess.make("sh", ["-c", script], { forceKillAfter: "100 millis" })
           yield* handle.exitCode
         })
       )
       // The scope is closed, so the spawner's release has run.
       yield* Effect.sleep("2 seconds")
       const pid = Number(fs.readFileSync(pidFile, "utf8").trim())
       const alive = isAlive(pid)
       if (alive) process.kill(pid, "SIGKILL")
       fs.rmSync(pidFile, { force: true })
       return { leaderExitCode, childAliveTwoSecondsAfterRelease: alive }
     })
   
   const results = await Effect.runPromise(
     Effect.all([run(0), run(1)]).pipe(Effect.provide(NodeServices.layer))
   )
   console.log(JSON.stringify(results))

   Output:

   [{"leaderExitCode":0,"childAliveTwoSecondsAfterRelease":false},{"leaderExitCode":1,"childAliveTwoSecondsAfterRelease":true}]

   Expected: release on the non-zero path escalates the same way as on the other two. forceKillAfter then applies whenever the scope releases the group, whatever the leader's exit, as this issue's "Desired behavior" asks.
2. tim-smart

   closed this as completedin #8736on Oct 4, 2026