Preserve background processes after print completion

Author: lijiuyang.5137

src/pty.rs

@@ -85,6 +85,34 @@ impl PtyProcess {
             std::thread::sleep(Duration::from_millis(25));
         }
     }
+
+    pub fn finish(&mut self, timeout: Duration) {
+        if self.pid <= 0 {
+            return;
+        }
+        let pid = self.pid;
+        unsafe {
+            libc::kill(pid, libc::SIGTERM);
+        }
+        let started = Instant::now();
+        loop {
+            let mut status = 0;
+            let result = unsafe { libc::waitpid(pid, &mut status, libc::WNOHANG) };
+            if result == pid || result < 0 {
+                self.pid = 0;
+                return;
+            }
+            if started.elapsed() >= timeout {
+                unsafe {
+                    libc::kill(pid, libc::SIGKILL);
+                    libc::waitpid(pid, &mut status, 0);
+                }
+                self.pid = 0;
+                return;
+            }
+            std::thread::sleep(Duration::from_millis(25));
+        }
+    }
 }
 
 impl Drop for PtyProcess {

src/runner.rs

@@ -196,7 +196,7 @@ async fn run_print(invocation: Invocation) -> Result<i32> {
         }
     }
 
-    process.terminate(PTY_TERMINATE_TIMEOUT);
+    process.finish(PTY_TERMINATE_TIMEOUT);
     if invocation.no_session_persistence {
         tail.remove_current_transcript()?;
     }

tests/cctty_cli.rs

@@ -91,6 +91,48 @@ fn stream_json_text_prompt_uses_tty_transcript() {
     assert_eq!(lines[3]["result"], "FAKE_RESPONSE: Say OK");
 }
 
+#[test]
+#[cfg(unix)]
+fn normal_print_completion_preserves_hup_immune_background_process() {
+    let fixture = FakeClaude::new();
+    let workspace = tempfile::tempdir().unwrap();
+    let config_dir = tempfile::tempdir().unwrap();
+    let background_pid_path = workspace.path().join("background.pid");
+
+    let output = Command::cargo_bin("cctty")
+        .unwrap()
+        .env("CCTTY_CLAUDE_PATH", fixture.path())
+        .env("CLAUDE_CONFIG_DIR", config_dir.path())
+        .env("FAKE_CLAUDE_BACKGROUND_PID_PATH", &background_pid_path)
+        .current_dir(workspace.path())
+        .args([
+            "--print",
+            "--output-format",
+            "stream-json",
+            "START_BACKGROUND_SERVICE",
+        ])
+        .output()
+        .unwrap();
+
+    assert!(
+        output.status.success(),
+        "stderr:\n{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let pid = std::fs::read_to_string(&background_pid_path)
+        .unwrap()
+        .trim()
+        .parse::<u32>()
+        .unwrap();
+    let _guard = BackgroundPidGuard { pid };
+
+    std::thread::sleep(Duration::from_millis(250));
+    assert!(
+        process_exists(pid),
+        "user-started background process {pid} should survive normal cctty completion"
+    );
+}
+
 #[test]
 fn stream_json_remote_control_active_screen_accepts_prompt() {
     let fixture = FakeClaude::new();
@@ -2641,3 +2683,28 @@ fn json_types(lines: &[Value]) -> Vec<&str> {
         .map(|line| line["type"].as_str().unwrap())
         .collect()
 }
+
+#[cfg(unix)]
+struct BackgroundPidGuard {
+    pid: u32,
+}
+
+#[cfg(unix)]
+impl Drop for BackgroundPidGuard {
+    fn drop(&mut self) {
+        unsafe {
+            libc::kill(self.pid as libc::pid_t, libc::SIGTERM);
+        }
+        std::thread::sleep(Duration::from_millis(50));
+        if process_exists(self.pid) {
+            unsafe {
+                libc::kill(self.pid as libc::pid_t, libc::SIGKILL);
+            }
+        }
+    }
+}
+
+#[cfg(unix)]
+fn process_exists(pid: u32) -> bool {
+    unsafe { libc::kill(pid as libc::pid_t, 0) == 0 }
+}

tests/support/mod.rs

@@ -245,6 +245,17 @@ while True:
     raw_prompt = buf[start + len(b"\x1b[200~"):end] if start >= 0 else buf[:end]
     prompt = raw_prompt.decode("utf-8", errors="replace")
     response = "FAKE_RESPONSE: " + prompt
+    if "START_BACKGROUND_SERVICE" in prompt:
+        pid_path = os.environ.get("FAKE_CLAUDE_BACKGROUND_PID_PATH")
+        if not pid_path:
+            raise RuntimeError("missing FAKE_CLAUDE_BACKGROUND_PID_PATH")
+        child = subprocess.Popen(
+            ["sh", "-c", "trap '' HUP; exec sleep 600"],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        Path(pid_path).write_text(str(child.pid), encoding="utf-8")
     if "USE_TTY_FIRST_FAKE_ASK_USER_QUESTION" in prompt:
         question_input = {
             "questions": [