# Fix: propagate Ctrl+C to proxied Go binary without orphaning or losing exit codes ## Why Running long-lived Go-proxied commands (`supabase start`) and hitting Ctrl+C had two bugs: 1. **The Go child was orphaned.** Effect's Node/Bun `ChildProcessSpawner` defaults to `detached: true` on non-Windows, which puts the child in its own process group. The tty-delivered SIGINT only reaches the foreground pgrp, so the Go process never saw it and skipped its own cleanup (docker teardown, context cancellation, etc.). 2. **The real exit code was lost.** Bun/Node's default action on SIGINT is to terminate the *parent* with code 130, racing the child's graceful shutdown. Even after fixing supabase#1, the TS wrapper would exit 130 before it could read and forward the Go binary's exit status. ## Fix (two invariants) Both must hold for Ctrl+C to work end-to-end: 1. **Spawn with `detached: false`** so parent and child share a process group and the child receives the tty signal directly. 2. **Install no-op parent-side listeners** for `SIGINT` / `SIGTERM` / `SIGHUP` *before* the spawn. This disables the runtime's default terminate-the-parent behavior so the wrapper stays blocked on `spawner.exitCode` and forwards the child's real status. Listeners are scoped so they come off on every exit path (success, failure, interrupt). ## Changes ### `shared/runtime/` — new `ProcessControl.holdSignals` primitive A scoped, no-resume signal hold. Not to be confused with `awaitSignal` (which *consumes* a signal once); `holdSignals` only suppresses the runtime default for the lifetime of the surrounding scope. - **`process-control.service.ts`** — add `holdSignals(signals): Effect<void, never, Scope>` to the interface. Extend `CliProcessSignal` to include `SIGHUP`. - **`process-control.layer.ts`** — implement with `Effect.acquireRelease`: on acquire, `process.on(sig, NOOP)` for each signal; on release, `process.off(sig, NOOP)`. - **`process-control.layer.unit.test.ts`** — asserts listener count increases while the scope is open and returns to its original value on close, covering normal completion, failure, and fiber interruption paths. - **`tests/helpers/mocks.ts`** — stub the new method on the existing `ProcessControl` test mock so consumer tests keep compiling. ### `shared/legacy/go-proxy.layer.ts` — wire both invariants into the proxy ```ts Effect.scoped( Effect.gen(function* () { yield* processControl.holdSignals(["SIGINT", "SIGTERM", "SIGHUP"]); // invariant supabase#2 const command = ChildProcess.make(binary, [...globalArgs, ...args], { // ... detached: false, // invariant supabase#1 }); const exitCode = yield* spawner.exitCode(command).pipe(Effect.orDie); if (exitCode !== 0) yield* processControl.exit(exitCode); }), ) ``` Also adds an optional `binary?: string` option to `makeGoProxyLayer` — a pure test seam that bypasses `resolveBinary()` without mutating `process.env`. Production behavior is unchanged (env var, SFE colocation, and workspace package resolution all still honored when `binary` is absent). ### `shared/legacy/go-proxy.layer.unit.test.ts` — new regression suite (334 lines) Pins both invariants against future refactors. Built around two small in-file fakes (`mockSpawner`, `mockProcessControl`) so the tests assert against the service contract rather than the real `process` listener table (which is covered by the `ProcessControl` tests). Cases: | Test | Invariant guarded | |---|---| | passes `detached: false` and inherited stdio to the spawner | supabase#1 | | propagates non-zero exit codes via `ProcessControl.exit` | exit-code forwarding | | does *not* call `ProcessControl.exit` on a zero exit | no spurious exits | | calls `holdSignals` with SIGINT+SIGTERM+SIGHUP **before** spawning | supabase#2 ordering | | releases the hold scope on successful `exec` | scope hygiene | | releases the hold scope when the spawner fails | scope hygiene under error | | releases the hold scope when the fiber is interrupted | scope hygiene under Ctrl+C | | opens and closes a fresh hold scope per sequential `exec` | no listener accumulation | ## Risk & scope - **Public surface:** one new method on `ProcessControl` (additive), one new optional field on `makeGoProxyLayer` options (additive). No call-site migrations. - **Runtime behavior change:** the TS wrapper no longer exits 130 on Ctrl+C during a proxied command — it waits for the Go child and forwards its exit code. This is the intended user-visible fix. - **Scope:** only the legacy Go proxy path. `next/` is untouched. ## How to verify locally ```sh cd apps/cli bun run test:core -- src/shared/legacy/go-proxy.layer.unit.test.ts bun run test:core -- src/shared/runtime/process-control.layer.unit.test.ts # manual smoke test bun run build ./dist/main-legacy.js start # then Ctrl+C → docker should be cleaned up, exit code reflects the Go binary # Wait 10s or so, you will not see the containers stopping and see more output from the orphan go cli on this branch it will properly exit ```

[RFC 0001] MVP #1

Description

Abstract

Activity

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions