Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

proc: End on Windows ends what the process started too

yetonebafdf149237f
diff --git a/internal/proc/env.go b/internal/proc/env.go
index bf4ee7295..367916c0b 100644
--- a/internal/proc/env.go
+++ b/internal/proc/env.go
@@ -11,9 +11,10 @@ import (
// SIGTERM where there are signals, on Windows TerminateProcess with exit
// code 0. The Codex app starts its app-server again after an exit 0 and
// shows an error for any other (its AppServerConnection: code === 0 is
-// classifiedAsExpected). ErrDenied when this user may not; nil when pid
-// is gone already.
-func End(pid int) error { return end(pid) }
+// classifiedAsExpected). On Windows what pid started is ended with it,
+// as a program ending on SIGTERM ends its own children (endTree).
+// ErrDenied when this user may not; nil when pid is gone already.
+func End(pid int) error { return endTree(pid) }
// ErrNoEnv is a system that doesn't tell another process's environment
// (Windows here).
diff --git a/internal/proc/killtree_other.go b/internal/proc/killtree_other.go
new file mode 100644
index 000000000..caae6437a
--- /dev/null
+++ b/internal/proc/killtree_other.go
@@ -0,0 +1,6 @@
+//go:build !windows
+
+package proc
+
+// endTree is end: a program that ends on SIGTERM ends its own children.
+func endTree(pid int) error { return end(pid) }
diff --git a/internal/proc/killtree_windows.go b/internal/proc/killtree_windows.go
index 27e591ade..4b1eed483 100644
--- a/internal/proc/killtree_windows.go
+++ b/internal/proc/killtree_windows.go
@@ -24,8 +24,25 @@ func cancelTree(cmd *exec.Cmd) {
// killDescendants ends every process started under pid, at any depth. A
// pid Windows has given again to a later process is told apart by its
// start: a child starts after its parent.
-func killDescendants(pid int) {
- for _, d := range descendants(uint32(pid)) {
+func killDescendants(pid int) { killAll(descendants(uint32(pid))) }
+
+// endTree is end, with every process pid started ended too. TerminateProcess
+// ends pid alone, where a SIGTERM lets a program end its children first: the
+// Codex app's codex.exe app-server, ended so the app starts it again, left
+// the MCP servers it ran (node.exe under npx, uvx…) running with no parent,
+// one set more for every restart (liam_8829, 10-27). Its descendants are
+// listed while it is alive, as descendants needs it to be.
+func endTree(pid int) error {
+ kids := descendants(uint32(pid))
+ if err := end(pid); err != nil {
+ return err
+ }
+ killAll(kids)
+ return nil
+}
+
+func killAll(pids []uint32) {
+ for _, d := range pids {
h, err := windows.OpenProcess(windows.PROCESS_TERMINATE, false, d)
if err != nil {
continue
diff --git a/internal/proc/killtree_windows_test.go b/internal/proc/killtree_windows_test.go
index d0273ad16..6167ee9cb 100644
--- a/internal/proc/killtree_windows_test.go
+++ b/internal/proc/killtree_windows_test.go
@@ -2,6 +2,7 @@ package proc
import (
"context"
+ "os/exec"
"testing"
"time"
@@ -74,3 +75,50 @@ func TestContextEndKillsWhatTheCommandStarted(t *testing.T) {
})
}
}
+
+// The Codex app's codex.exe app-server, ended by End so the app starts it
+// again, left the MCP servers it ran (node.exe under npx) running with no
+// parent, one set more for every restart (liam_8829, 10-27). End ends what
+// pid started too, and pid still exits 0. cmd.exe running ping stands in
+// for codex.exe and an MCP server.
+func TestEndEndsWhatItStarted(t *testing.T) {
+ cmd := exec.Command("cmd.exe", "/c", "ping -n 60 127.0.0.1 >NUL")
+ if err := cmd.Start(); err != nil {
+ t.Fatal(err)
+ }
+ done := make(chan error, 1)
+ go func() { done <- cmd.Wait() }()
+ var kids []uint32
+ for range 100 {
+ if kids = descendants(uint32(cmd.Process.Pid)); len(kids) > 0 {
+ break
+ }
+ time.Sleep(50 * time.Millisecond)
+ }
+ if len(kids) == 0 {
+ t.Fatal("cmd.exe started no ping")
+ }
+ t.Cleanup(func() {
+ _ = cmd.Process.Kill()
+ killAll(kids)
+ })
+ if err := End(cmd.Process.Pid); err != nil {
+ t.Fatal(err)
+ }
+ select {
+ case err := <-done:
+ if err != nil {
+ t.Errorf("cmd.exe ended with %v, want exit code 0", err)
+ }
+ case <-time.After(10 * time.Second):
+ t.Fatal("cmd.exe not ended 10s after End")
+ }
+ for _, k := range kids {
+ for i := 0; alive(k) && i < 100; i++ {
+ time.Sleep(50 * time.Millisecond)
+ }
+ if alive(k) {
+ t.Errorf("process %d that cmd.exe started still runs after End", k)
+ }
+ }
+}