fix(cli): forward termination signals to relaunched child process

packages/cli/src/utils/relaunch.test.ts

@@ -345,6 +345,62 @@ describe('relaunchAppInChildProcess', () => {
       // Should default to exit code 1
       expect(processExitSpy).toHaveBeenCalledWith(1);
     });
+
+    it('forwards termination signals to the child and removes them on close (#25590)', async () => {
+      process.argv = ['/usr/bin/node', '/app/cli.js'];
+
+      const mockChild = createMockChildProcess(0, false);
+      mockedSpawn.mockImplementation(() => mockChild);
+
+      const before = process.listenerCount('SIGTERM');
+      const killSpy = mockChild.kill as ReturnType<typeof vi.fn>;
+
+      // Start the relaunch process (does not auto-close, so it awaits).
+      const promise = relaunchAppInChildProcess([], []);
+
+      // Drain microtasks so the spawn + forwarder registration runs.
+      await new Promise((r) => setImmediate(r));
+
+      // A forwarder for SIGTERM was installed on the parent process.
+      expect(process.listenerCount('SIGTERM')).toBe(before + 1);
+
+      // Emulate the OS delivering SIGTERM: invoke the registered handler
+      // directly (process.emit would also fire unrelated listeners).
+      const handler = process.listeners('SIGTERM').at(-1) as
+        | (() => void)
+        | undefined;
+      expect(handler).toBeDefined();
+      handler!();
+      expect(killSpy).toHaveBeenCalledWith('SIGTERM');
+
+      // Closing the child must remove the forwarder (no listener leak).
+      mockChild.emit('close', 0);
+      await expect(promise).rejects.toThrow('PROCESS_EXIT_CALLED');
+      expect(process.listenerCount('SIGTERM')).toBe(before);
+    });
+
+    it('propagates the child signal termination to the parent process (#25590)', async () => {
+      process.argv = ['/usr/bin/node', '/app/cli.js'];
+
+      const mockChild = createMockChildProcess(0, false);
+      mockedSpawn.mockImplementation(() => mockChild);
+
+      // Mock process.kill so the re-raised signal does not terminate the
+      // Vitest runner; assert the parent re-raises the child's exit signal.
+      const processKillSpy = vi
+        .spyOn(process, 'kill')
+        .mockImplementation(() => true);
+
+      const promise = relaunchAppInChildProcess([], []);
+      await new Promise((r) => setImmediate(r));
+
+      // Child exits with a signal: the parent must re-raise it.
+      mockChild.emit('close', null, 'SIGTERM');
+      await expect(promise).rejects.toThrow('PROCESS_EXIT_CALLED');
+      expect(processKillSpy).toHaveBeenCalledWith(process.pid, 'SIGTERM');
+
+      processKillSpy.mockRestore();
+    });
   });
 });
 

packages/cli/src/utils/relaunch.ts

@@ -15,6 +15,23 @@ import {
   type AdminControlsSettings,
 } from '@google/gemini-cli-core';
 
+// Signals a supervising process (ACP client, systemd, container runtime)
+// may send to the bootstrap parent. Without forwarding, the parent dies on
+// its default disposition while the spawned child is reparented to PID 1
+// and keeps running - holding the OAuth session and allocated heap until
+// killed manually. See #25590.
+// SIGINT/SIGQUIT are intentionally NOT forwarded: when running
+// interactively, the TTY delivers them to the whole foreground process
+// group (parent and child), so forwarding would deliver them twice and
+// could interrupt the child's graceful-shutdown handler. Supervisors use
+// SIGTERM for programmatic termination, which is forwarded.
+const FORWARDED_SIGNALS: readonly NodeJS.Signals[] = [
+  'SIGTERM',
+  'SIGHUP',
+  'SIGUSR1',
+  'SIGUSR2',
+];
+
 export async function relaunchOnExitCode(runner: () => Promise<number>) {
   while (true) {
     try {
@@ -71,11 +88,58 @@ export async function relaunchAppInChildProcess(
       }
     });
 
+    // Forward termination signals to the child so a supervised parent
+    // (kill -TERM <bootstrap-pid>) takes the child down with it instead of
+    // orphaning it. Use a Map of {signal -> handler} for precise cleanup on
+    // close/error; removeAllListeners would disturb unrelated subscribers,
+    // and leaking a handler per relaunch iteration trips
+    // MaxListenersExceededWarning after ~10 relaunches. #25590.
+    const forwarders = new Map<NodeJS.Signals, () => void>();
+    for (const sig of FORWARDED_SIGNALS) {
+      const handler = () => {
+        try {
+          child.kill(sig);
+        } catch {
+          // The child may have already exited; ignore the race.
+        }
+      };
+      forwarders.set(sig, handler);
+      // Use on() so that if the child is slow to shut down and a second
+      // signal is received, it is still forwarded rather than killing the
+      // parent immediately and orphaning the child. The listeners are
+      // removed on child close/error anyway. #25590.
+      process.on(sig, handler);
+    }
+    const removeForwarders = () => {
+      for (const [sig, handler] of forwarders) {
+        process.off(sig, handler);
+      }
+      forwarders.clear();
+    };
+
     return new Promise<number>((resolve, reject) => {
-      child.on('error', reject);
-      child.on('close', (code) => {
+      child.on('error', (err) => {
+        removeForwarders();
+        reject(err);
+      });
+      child.on('close', (code, signal) => {
+        removeForwarders();
         // Resume stdin before the parent process exits.
         process.stdin.resume();
+        // Propagate the child's signal termination so supervisors (systemd,
+        // Kubernetes) see a clean signal exit rather than an unexpected code
+        // 1 crash. #25590.
+        if (signal) {
+          try {
+            process.kill(process.pid, signal);
+            // Do NOT return here: a non-fatal signal (e.g. SIGUSR1) does not
+            // terminate this process, so we must still resolve the promise
+            // below. If the signal IS fatal, this process exits before
+            // resolve runs - which is the desired outcome.
+          } catch {
+            // Fall back to exit code 1 if the signal cannot be re-raised.
+          }
+        }
         resolve(code ?? 1);
       });
     });