aboutsummaryrefslogtreecommitdiff
path: root/tests/cross_area.rs
diff options
context:
space:
mode:
Diffstat (limited to 'tests/cross_area.rs')
-rw-r--r--tests/cross_area.rs1103
1 files changed, 1103 insertions, 0 deletions
diff --git a/tests/cross_area.rs b/tests/cross_area.rs
new file mode 100644
index 00000000..5758fdd2
--- /dev/null
+++ b/tests/cross_area.rs
@@ -0,0 +1,1103 @@
+//! Cross-area integration tests for end-to-end persistence flows.
+
+mod support;
+
+use std::fs;
+use std::io::{self, BufRead, BufReader, Read, Write};
+use std::os::unix::net::UnixStream;
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, MutexGuard, OnceLock};
+use std::thread;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize};
+use serde::Deserialize;
+use serde_json::{json, Value};
+use support::{
+ cleanup_test_base, register_runtime_dir, register_spawned_herdr_pid,
+ unregister_spawned_herdr_pid,
+};
+
+fn unique_test_dir() -> PathBuf {
+ let nanos = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map(|d| d.as_nanos())
+ .unwrap_or(0);
+ PathBuf::from(format!(
+ "/tmp/herdr-cross-area-test-{}-{nanos}",
+ std::process::id()
+ ))
+}
+
+struct SpawnedHerdr {
+ _master: Box<dyn MasterPty + Send>,
+ child: Box<dyn Child + Send + Sync>,
+}
+
+impl Drop for SpawnedHerdr {
+ fn drop(&mut self) {
+ let pid = self.child.process_id();
+ let _ = self.child.kill();
+
+ if let Some(pid) = pid {
+ let deadline = Instant::now() + Duration::from_secs(2);
+ while Instant::now() < deadline {
+ let mut status = 0;
+ let result =
+ unsafe { libc::waitpid(pid as libc::pid_t, &mut status, libc::WNOHANG) };
+ if result == pid as libc::pid_t || result == -1 {
+ break;
+ }
+ thread::sleep(Duration::from_millis(20));
+ }
+
+ unregister_spawned_herdr_pid(Some(pid));
+ }
+ }
+}
+
+fn cleanup_spawned_herdr(spawned: SpawnedHerdr, base: PathBuf) {
+ drop(spawned);
+ cleanup_test_base(&base);
+}
+
+fn test_lock() -> MutexGuard<'static, ()> {
+ static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+ LOCK.get_or_init(|| Mutex::new(()))
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+fn wait_for_socket(path: &Path, timeout: Duration) {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ if path.exists() && UnixStream::connect(path).is_ok() {
+ return;
+ }
+ thread::sleep(Duration::from_millis(25));
+ }
+ panic!("socket did not appear at {}", path.display());
+}
+
+fn spawn_server(config_home: &Path, runtime_dir: &Path, api_socket_path: &Path) -> SpawnedHerdr {
+ spawn_server_with_path(config_home, runtime_dir, api_socket_path, None)
+}
+
+fn spawn_server_with_path(
+ config_home: &Path,
+ runtime_dir: &Path,
+ api_socket_path: &Path,
+ path_override: Option<&Path>,
+) -> SpawnedHerdr {
+ fs::create_dir_all(config_home.join("herdr")).unwrap();
+ fs::create_dir_all(runtime_dir).unwrap();
+ register_runtime_dir(runtime_dir);
+ fs::write(
+ config_home.join("herdr/config.toml"),
+ "onboarding = false\n",
+ )
+ .unwrap();
+
+ let pair = native_pty_system()
+ .openpty(PtySize {
+ rows: 24,
+ cols: 80,
+ pixel_width: 0,
+ pixel_height: 0,
+ })
+ .unwrap();
+
+ let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr"));
+ cmd.arg("server");
+ cmd.env("XDG_CONFIG_HOME", config_home);
+ cmd.env("XDG_RUNTIME_DIR", runtime_dir);
+ cmd.env("HERDR_SOCKET_PATH", api_socket_path);
+ cmd.env_remove("HERDR_CLIENT_SOCKET_PATH");
+ cmd.env("SHELL", "/bin/sh");
+ cmd.env_remove("HERDR_ENV");
+ if let Some(path) = path_override {
+ cmd.env("PATH", path);
+ }
+
+ let child = pair.slave.spawn_command(cmd).unwrap();
+ register_spawned_herdr_pid(child.process_id());
+ drop(pair.slave);
+
+ SpawnedHerdr {
+ _master: pair.master,
+ child,
+ }
+}
+
+fn spawn_client_process(
+ config_home: &Path,
+ runtime_dir: &Path,
+ api_socket_path: &Path,
+) -> SpawnedHerdr {
+ register_runtime_dir(runtime_dir);
+ let pair = native_pty_system()
+ .openpty(PtySize {
+ rows: 24,
+ cols: 80,
+ pixel_width: 0,
+ pixel_height: 0,
+ })
+ .unwrap();
+
+ let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_herdr"));
+ cmd.arg("client");
+ cmd.env("XDG_CONFIG_HOME", config_home);
+ cmd.env("XDG_RUNTIME_DIR", runtime_dir);
+ cmd.env("HERDR_SOCKET_PATH", api_socket_path);
+ cmd.env_remove("HERDR_CLIENT_SOCKET_PATH");
+ cmd.env("SHELL", "/bin/sh");
+ cmd.env_remove("HERDR_ENV");
+
+ let child = pair.slave.spawn_command(cmd).unwrap();
+ register_spawned_herdr_pid(child.process_id());
+ drop(pair.slave);
+
+ SpawnedHerdr {
+ _master: pair.master,
+ child,
+ }
+}
+
+fn send_json_request(socket_path: &Path, id: &str, method: &str, params: Value) -> Value {
+ let mut stream = UnixStream::connect(socket_path).expect("should connect to API socket");
+ let request = json!({
+ "id": id,
+ "method": method,
+ "params": params
+ });
+ writeln!(stream, "{}", request).unwrap();
+
+ let mut reader = BufReader::new(stream);
+ let mut response = String::new();
+ reader.read_line(&mut response).unwrap();
+ serde_json::from_str(&response).expect("response should be valid JSON")
+}
+
+fn ping_socket(socket_path: &Path) -> String {
+ let response = send_json_request(socket_path, "ping", "ping", json!({}));
+ response.to_string()
+}
+
+fn workspace_create(socket_path: &Path, label: &str) -> Value {
+ send_json_request(
+ socket_path,
+ "workspace_create",
+ "workspace.create",
+ json!({ "label": label }),
+ )
+}
+
+fn workspace_list(socket_path: &Path) -> Value {
+ send_json_request(socket_path, "workspace_list", "workspace.list", json!({}))
+}
+
+fn workspace_count(socket_path: &Path) -> usize {
+ workspace_list(socket_path)["result"]["workspaces"]
+ .as_array()
+ .map(|workspaces| workspaces.len())
+ .unwrap_or(0)
+}
+
+fn workspace_id_by_label(response: &Value, label: &str) -> String {
+ response["result"]["workspaces"]
+ .as_array()
+ .expect("workspace.list should return workspaces array")
+ .iter()
+ .find(|workspace| workspace["label"] == label)
+ .and_then(|workspace| workspace["workspace_id"].as_str())
+ .expect("workspace with matching label should exist")
+ .to_string()
+}
+
+fn wait_for_child_exit(child: &mut Box<dyn Child + Send + Sync>, timeout: Duration) -> bool {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ if child.try_wait().ok().flatten().is_some() {
+ return true;
+ }
+ thread::sleep(Duration::from_millis(25));
+ }
+ false
+}
+
+fn pane_send_input(socket_path: &Path, pane_id: &str, text: &str) {
+ let response = send_json_request(
+ socket_path,
+ "pane_send_input",
+ "pane.send_input",
+ json!({
+ "pane_id": pane_id,
+ "text": text,
+ "keys": ["Enter"]
+ }),
+ );
+ assert!(
+ response.get("error").is_none(),
+ "pane.send_input should succeed: {response}"
+ );
+}
+
+fn pane_send_text(socket_path: &Path, pane_id: &str, text: &str) {
+ let response = send_json_request(
+ socket_path,
+ "pane_send_text",
+ "pane.send_text",
+ json!({
+ "pane_id": pane_id,
+ "text": text
+ }),
+ );
+ assert!(
+ response.get("error").is_none(),
+ "pane.send_text should succeed: {response}"
+ );
+}
+
+fn pane_read_recent(socket_path: &Path, pane_id: &str) -> String {
+ let response = send_json_request(
+ socket_path,
+ "pane_read",
+ "pane.read",
+ json!({
+ "pane_id": pane_id,
+ "source": "recent",
+ "lines": 200
+ }),
+ );
+
+ response["result"]["read"]["text"]
+ .as_str()
+ .unwrap_or_default()
+ .to_string()
+}
+
+fn pane_read_recent_contains(
+ socket_path: &Path,
+ pane_id: &str,
+ needle: &str,
+ timeout: Duration,
+) -> bool {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ let text = pane_read_recent(socket_path, pane_id);
+ if text.contains(needle) {
+ return true;
+ }
+ thread::sleep(Duration::from_millis(50));
+ }
+ false
+}
+
+fn pane_report_agent(socket_path: &Path, pane_id: &str, agent: &str, state: &str, source: &str) {
+ let response = send_json_request(
+ socket_path,
+ "pane_report_agent",
+ "pane.report_agent",
+ json!({
+ "pane_id": pane_id,
+ "agent": agent,
+ "state": state,
+ "source": source,
+ }),
+ );
+ assert!(
+ response.get("error").is_none(),
+ "pane.report_agent should succeed: {response}"
+ );
+}
+
+fn pane_agent_status(socket_path: &Path, pane_id: &str) -> Option<String> {
+ let response = send_json_request(
+ socket_path,
+ "pane_get",
+ "pane.get",
+ json!({ "pane_id": pane_id }),
+ );
+ response["result"]["pane"]["agent_status"]
+ .as_str()
+ .map(|status| status.to_string())
+}
+
+fn wait_for_agent_status(
+ socket_path: &Path,
+ pane_id: &str,
+ expected: &str,
+ timeout: Duration,
+) -> bool {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ if pane_agent_status(socket_path, pane_id).as_deref() == Some(expected) {
+ return true;
+ }
+ thread::sleep(Duration::from_millis(50));
+ }
+ false
+}
+
+// ---------------------------------------------------------------------------
+// Minimal protocol helpers (bincode v2 varint + framing)
+// ---------------------------------------------------------------------------
+
+fn encode_varint_u32(v: u32) -> Vec<u8> {
+ if v < 251 {
+ vec![v as u8]
+ } else if v < 65_536 {
+ let mut buf = vec![251u8];
+ buf.extend_from_slice(&(v as u16).to_le_bytes());
+ buf
+ } else {
+ let mut buf = vec![252u8];
+ buf.extend_from_slice(&v.to_le_bytes());
+ buf
+ }
+}
+
+fn encode_varint_u16(v: u16) -> Vec<u8> {
+ if v < 251 {
+ vec![v as u8]
+ } else {
+ let mut buf = vec![251u8];
+ buf.extend_from_slice(&v.to_le_bytes());
+ buf
+ }
+}
+
+fn frame_message(payload: &[u8]) -> Vec<u8> {
+ let mut framed = (payload.len() as u32).to_le_bytes().to_vec();
+ framed.extend_from_slice(payload);
+ framed
+}
+
+fn decode_varint_u32(payload: &[u8], offset: usize) -> Result<(u32, usize), String> {
+ if offset >= payload.len() {
+ return Err("payload too short for varint".into());
+ }
+ let first = payload[offset];
+ match first {
+ 0..=250 => Ok((first as u32, 1)),
+ 251 => {
+ if offset + 3 > payload.len() {
+ return Err("payload too short for u16 varint".into());
+ }
+ let v = u16::from_le_bytes(
+ payload[offset + 1..offset + 3]
+ .try_into()
+ .map_err(|e: std::array::TryFromSliceError| e.to_string())?,
+ );
+ Ok((v as u32, 3))
+ }
+ 252 => {
+ if offset + 5 > payload.len() {
+ return Err("payload too short for u32 varint".into());
+ }
+ let v = u32::from_le_bytes(
+ payload[offset + 1..offset + 5]
+ .try_into()
+ .map_err(|e: std::array::TryFromSliceError| e.to_string())?,
+ );
+ Ok((v, 5))
+ }
+ _ => Err(format!("unsupported varint tag: {first}")),
+ }
+}
+
+fn client_handshake(stream: &mut UnixStream, version: u32, cols: u16, rows: u16) {
+ stream
+ .set_read_timeout(Some(Duration::from_secs(5)))
+ .expect("set read timeout");
+
+ // ClientMessage::Hello = variant 0
+ let mut payload = encode_varint_u32(0);
+ payload.extend_from_slice(&encode_varint_u32(version));
+ payload.extend_from_slice(&encode_varint_u16(cols));
+ payload.extend_from_slice(&encode_varint_u16(rows));
+
+ stream
+ .write_all(&frame_message(&payload))
+ .expect("write hello");
+ stream.flush().expect("flush hello");
+
+ let mut len_buf = [0u8; 4];
+ stream
+ .read_exact(&mut len_buf)
+ .expect("read welcome length");
+ let len = u32::from_le_bytes(len_buf) as usize;
+ assert!(len > 0 && len <= 2 * 1024 * 1024, "unexpected welcome size");
+
+ let mut welcome_payload = vec![0u8; len];
+ stream
+ .read_exact(&mut welcome_payload)
+ .expect("read welcome payload");
+
+ let mut offset = 0;
+ let (variant, consumed) = decode_varint_u32(&welcome_payload, offset).expect("decode variant");
+ offset += consumed;
+ assert_eq!(variant, 0, "expected ServerMessage::Welcome variant");
+
+ let (_server_version, consumed) =
+ decode_varint_u32(&welcome_payload, offset).expect("decode version");
+ offset += consumed;
+
+ let option_tag = *welcome_payload
+ .get(offset)
+ .expect("welcome payload should contain Option tag");
+ if option_tag == 1 {
+ let (str_len, consumed) =
+ decode_varint_u32(&welcome_payload, offset + 1).expect("decode error length");
+ let start = offset + 1 + consumed;
+ let end = start + str_len as usize;
+ let err = String::from_utf8(welcome_payload[start..end].to_vec()).expect("utf8 error");
+ panic!("handshake rejected: {err}");
+ }
+}
+
+fn send_client_input(stream: &mut UnixStream, data: &[u8]) {
+ // ClientMessage::Input = variant 1
+ let mut payload = encode_varint_u32(1);
+ payload.extend_from_slice(&encode_varint_u32(data.len() as u32));
+ payload.extend_from_slice(data);
+ stream
+ .write_all(&frame_message(&payload))
+ .expect("write input");
+ stream.flush().expect("flush input");
+}
+
+fn send_client_detach(stream: &mut UnixStream) {
+ // ClientMessage::Detach = variant 3
+ let payload = encode_varint_u32(3);
+ stream
+ .write_all(&frame_message(&payload))
+ .expect("write detach");
+ stream.flush().expect("flush detach");
+}
+
+fn is_timeout(err: &io::Error) -> bool {
+ matches!(
+ err.kind(),
+ io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock
+ )
+}
+
+#[derive(Debug, Deserialize)]
+struct FrameWire {
+ cells: Vec<CellWire>,
+ width: u16,
+ height: u16,
+ cursor: Option<CursorWire>,
+}
+
+#[derive(Debug, Deserialize)]
+struct CellWire {
+ symbol: String,
+ fg: u32,
+ bg: u32,
+ modifier: u16,
+ skip: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct CursorWire {
+ x: u16,
+ y: u16,
+ visible: bool,
+}
+
+fn decode_frame_payload(payload: &[u8]) -> io::Result<FrameWire> {
+ bincode::serde::decode_from_slice(payload, bincode::config::standard())
+ .map(|(frame, consumed)| (frame, consumed))
+ .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err.to_string()))
+ .and_then(|(frame, consumed): (FrameWire, usize)| {
+ if consumed != payload.len() {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ format!(
+ "frame payload had trailing bytes: consumed={}, len={}",
+ consumed,
+ payload.len()
+ ),
+ ));
+ }
+ Ok(frame)
+ })
+}
+
+fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool {
+ if frame.cells.is_empty() {
+ return false;
+ }
+
+ let width = frame.width.max(1) as usize;
+ let mut text = String::new();
+ for row in frame.cells.chunks(width) {
+ for cell in row {
+ let _ = (cell.fg, cell.bg, cell.modifier, cell.skip);
+ text.push_str(&cell.symbol);
+ }
+ text.push('\n');
+ }
+ let _ = frame.height;
+ if let Some(cursor) = frame.cursor.as_ref() {
+ let _ = (cursor.x, cursor.y, cursor.visible);
+ }
+
+ text.contains(needle)
+}
+
+fn read_server_variant(stream: &mut UnixStream, timeout: Duration) -> io::Result<u32> {
+ stream.set_read_timeout(Some(timeout))?;
+
+ let mut len_buf = [0u8; 4];
+ stream.read_exact(&mut len_buf)?;
+ let len = u32::from_le_bytes(len_buf) as usize;
+ if len == 0 {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ "zero-length payload",
+ ));
+ }
+
+ let mut payload = vec![0u8; len];
+ stream.read_exact(&mut payload)?;
+
+ let (variant, _consumed) = decode_varint_u32(&payload, 0)
+ .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+ Ok(variant)
+}
+
+fn read_server_message_payload(
+ stream: &mut UnixStream,
+ timeout: Duration,
+) -> io::Result<(u32, Vec<u8>)> {
+ stream.set_read_timeout(Some(timeout))?;
+
+ let mut len_buf = [0u8; 4];
+ stream.read_exact(&mut len_buf)?;
+ let len = u32::from_le_bytes(len_buf) as usize;
+ if len == 0 {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ "zero-length payload",
+ ));
+ }
+
+ let mut payload = vec![0u8; len];
+ stream.read_exact(&mut payload)?;
+
+ let (variant, consumed) = decode_varint_u32(&payload, 0)
+ .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+ Ok((variant, payload[consumed..].to_vec()))
+}
+
+fn wait_for_frame_matching(
+ stream: &mut UnixStream,
+ timeout: Duration,
+ predicate: impl Fn(&FrameWire) -> bool,
+) -> io::Result<bool> {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ let slice = deadline
+ .saturating_duration_since(Instant::now())
+ .min(Duration::from_millis(80));
+ match read_server_message_payload(stream, slice) {
+ Ok((1, payload)) => {
+ let frame = decode_frame_payload(&payload)?;
+ if predicate(&frame) {
+ return Ok(true);
+ }
+ }
+ Ok((_variant, _payload)) => {}
+ Err(err) if is_timeout(&err) => {}
+ Err(err) => return Err(err),
+ }
+ }
+
+ Ok(false)
+}
+
+fn wait_for_frame(stream: &mut UnixStream, timeout: Duration) -> bool {
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ let slice = deadline
+ .saturating_duration_since(Instant::now())
+ .min(Duration::from_millis(80));
+ match read_server_variant(stream, slice) {
+ Ok(1) => return true, // ServerMessage::Frame
+ Ok(_) => {}
+ Err(err) if is_timeout(&err) => {}
+ Err(_) => return false,
+ }
+ }
+ false
+}
+
+fn drain_server_messages(stream: &mut UnixStream, max_drain: Duration) {
+ let deadline = Instant::now() + max_drain;
+ while Instant::now() < deadline {
+ match read_server_variant(stream, Duration::from_millis(40)) {
+ Ok(_) => {}
+ Err(err) if is_timeout(&err) => break,
+ Err(_) => break,
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Cross-area tests
+// ---------------------------------------------------------------------------
+
+#[test]
+fn cross_area_detach_and_reattach_preserves_state() {
+ let _lock = test_lock();
+ let base = unique_test_dir();
+ let config_home = base.join("config");
+ let runtime_dir = base.join("runtime");
+ let api_socket = runtime_dir.join("herdr.sock");
+ let client_socket = runtime_dir.join("herdr-client.sock");
+
+ let server = spawn_server(&config_home, &runtime_dir, &api_socket);
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ // Local attach (client A).
+ let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect");
+ client_handshake(&mut client_a, 1, 100, 30);
+ assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
+
+ // Use herdr: create a workspace and write output into its pane.
+ let create = workspace_create(&api_socket, "cross-ssh-state");
+ let workspace_id = create["result"]["workspace"]["workspace_id"]
+ .as_str()
+ .expect("workspace id")
+ .to_string();
+ let pane_id = create["result"]["root_pane"]["pane_id"]
+ .as_str()
+ .expect("root pane id")
+ .to_string();
+
+ pane_send_input(&api_socket, &pane_id, "echo LOCAL_BEFORE_DETACH");
+ assert!(pane_read_recent_contains(
+ &api_socket,
+ &pane_id,
+ "LOCAL_BEFORE_DETACH",
+ Duration::from_secs(5)
+ ));
+
+ // Detach local client.
+ send_client_detach(&mut client_a);
+ drop(client_a);
+
+ // Simulate activity while detached.
+ pane_send_text(&api_socket, &pane_id, "echo DETACHED_UPDATE\n");
+ assert!(pane_read_recent_contains(
+ &api_socket,
+ &pane_id,
+ "DETACHED_UPDATE",
+ Duration::from_secs(5)
+ ));
+
+ // Reattach from another terminal/session (client B).
+ let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect");
+ client_handshake(&mut client_b, 1, 80, 24);
+ assert!(
+ wait_for_frame(&mut client_b, Duration::from_secs(5)),
+ "reattached client should receive frame"
+ );
+
+ let listed = workspace_list(&api_socket);
+ assert_eq!(
+ workspace_id,
+ workspace_id_by_label(&listed, "cross-ssh-state"),
+ "reattached session should see same workspace"
+ );
+
+ let readback = pane_read_recent(&api_socket, &pane_id);
+ assert!(
+ readback.contains("DETACHED_UPDATE"),
+ "pane output should include detached-period output: {readback}"
+ );
+
+ cleanup_spawned_herdr(server, base);
+}
+
+#[test]
+fn cross_area_agent_process_survives_detach_and_reattach() {
+ let _lock = test_lock();
+ let base = unique_test_dir();
+ let config_home = base.join("config");
+ let runtime_dir = base.join("runtime");
+ let api_socket = runtime_dir.join("herdr.sock");
+ let client_socket = runtime_dir.join("herdr-client.sock");
+
+ let bin_dir = base.join("bin");
+ fs::create_dir_all(&bin_dir).unwrap();
+ let fake_pi = bin_dir.join("pi");
+ fs::write(&fake_pi, "#!/bin/sh\nprintf 'Working...\\n'\nsleep 8\n").unwrap();
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ let mut perms = fs::metadata(&fake_pi).unwrap().permissions();
+ perms.set_mode(0o755);
+ fs::set_permissions(&fake_pi, perms).unwrap();
+ }
+
+ let inherited_path = std::env::var("PATH").unwrap_or_default();
+ let path_override = format!("{}:{}", bin_dir.display(), inherited_path);
+
+ let server = spawn_server_with_path(
+ &config_home,
+ &runtime_dir,
+ &api_socket,
+ Some(Path::new(&path_override)),
+ );
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect");
+ client_handshake(&mut client_a, 1, 100, 30);
+ assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
+
+ let created = workspace_create(&api_socket, "agent-persist");
+ let pane_id = created["result"]["root_pane"]["pane_id"]
+ .as_str()
+ .expect("root pane id")
+ .to_string();
+
+ // Ensure detected agent surface is populated by running fake `pi`.
+ pane_send_text(&api_socket, &pane_id, "pi");
+ pane_send_input(&api_socket, &pane_id, "");
+ let detected_before_hook = {
+ let deadline = Instant::now() + Duration::from_secs(5);
+ let mut detected = false;
+ while Instant::now() < deadline {
+ let response = send_json_request(
+ &api_socket,
+ "pane_get",
+ "pane.get",
+ json!({ "pane_id": &pane_id }),
+ );
+ if response["result"]["pane"]["agent"].as_str() == Some("pi") {
+ detected = true;
+ break;
+ }
+ thread::sleep(Duration::from_millis(60));
+ }
+ detected
+ };
+ assert!(
+ detected_before_hook,
+ "expected fake pi process to be detected before hook status assertions"
+ );
+
+ // Use agent status surfaces directly instead of a generic sleep command.
+ pane_report_agent(&api_socket, &pane_id, "pi", "working", "cross-area-test");
+ assert!(
+ wait_for_agent_status(&api_socket, &pane_id, "working", Duration::from_secs(3)),
+ "pane agent status should become working before detach"
+ );
+
+ // Detach and ensure status persists through API while detached.
+ send_client_detach(&mut client_a);
+ drop(client_a);
+
+ assert!(
+ wait_for_agent_status(&api_socket, &pane_id, "working", Duration::from_secs(3)),
+ "agent status should remain working while detached"
+ );
+
+ // Reattach and ensure client-side state reflects the persisted working status.
+ let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect");
+ client_handshake(&mut client_b, 1, 80, 24);
+ let saw_working_on_client =
+ wait_for_frame_matching(&mut client_b, Duration::from_secs(5), |frame| {
+ frame_contains_text(frame, "working")
+ })
+ .expect("frame decoding should succeed");
+ assert!(
+ saw_working_on_client,
+ "reattached client frame should expose persisted agent working status"
+ );
+
+ // Transition to idle and verify API + client surfaces both observe it.
+ pane_report_agent(&api_socket, &pane_id, "pi", "idle", "cross-area-test");
+ assert!(
+ wait_for_agent_status(&api_socket, &pane_id, "idle", Duration::from_secs(3)),
+ "pane agent status should transition to idle"
+ );
+
+ let saw_idle_on_client =
+ wait_for_frame_matching(&mut client_b, Duration::from_secs(5), |frame| {
+ frame_contains_text(frame, "idle")
+ })
+ .expect("frame decoding should succeed");
+ assert!(
+ saw_idle_on_client,
+ "reattached client frame should show idle status after transition"
+ );
+
+ cleanup_spawned_herdr(server, base);
+}
+
+#[test]
+fn cross_area_client_and_api_workspace_views_are_consistent() {
+ let _lock = test_lock();
+ let base = unique_test_dir();
+ let config_home = base.join("config");
+ let runtime_dir = base.join("runtime");
+ let api_socket = runtime_dir.join("herdr.sock");
+ let client_socket = runtime_dir.join("herdr-client.sock");
+
+ let server = spawn_server(&config_home, &runtime_dir, &api_socket);
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ let mut client = UnixStream::connect(&client_socket).expect("client should connect");
+ client_handshake(&mut client, 1, 100, 30);
+ assert!(wait_for_frame(&mut client, Duration::from_secs(2)));
+ drain_server_messages(&mut client, Duration::from_millis(300));
+
+ let before = workspace_count(&api_socket);
+
+ // Create a workspace via API while the client is attached.
+ let created = workspace_create(&api_socket, "api-visible-workspace");
+ let created_workspace_id = created["result"]["workspace"]["workspace_id"]
+ .as_str()
+ .expect("workspace.create should return workspace_id")
+ .to_string();
+
+ // The attached client must receive a frame that includes the new workspace
+ // label, proving client-side state reflects the API surface.
+ let saw_workspace_on_client =
+ wait_for_frame_matching(&mut client, Duration::from_secs(3), |frame| {
+ frame_contains_text(frame, "api-visible-workspace")
+ })
+ .expect("frame decoding should succeed");
+ assert!(
+ saw_workspace_on_client,
+ "client-side frame should include the newly created workspace label"
+ );
+
+ let deadline = Instant::now() + Duration::from_secs(5);
+ let mut count_reached = false;
+ while Instant::now() < deadline {
+ if workspace_count(&api_socket) == before + 1 {
+ count_reached = true;
+ break;
+ }
+ thread::sleep(Duration::from_millis(50));
+ }
+ assert!(
+ count_reached,
+ "API workspace list should include the created workspace"
+ );
+
+ let listed = workspace_list(&api_socket);
+ let listed_workspace_id = workspace_id_by_label(&listed, "api-visible-workspace");
+ assert_eq!(
+ listed_workspace_id, created_workspace_id,
+ "API and client-side state should reference the same created workspace"
+ );
+
+ cleanup_spawned_herdr(server, base);
+}
+
+#[test]
+fn cross_area_two_clients_shared_view_and_single_detach_stability() {
+ let _lock = test_lock();
+ let base = unique_test_dir();
+ let config_home = base.join("config");
+ let runtime_dir = base.join("runtime");
+ let api_socket = runtime_dir.join("herdr.sock");
+ let client_socket = runtime_dir.join("herdr-client.sock");
+
+ let server = spawn_server(&config_home, &runtime_dir, &api_socket);
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect");
+ client_handshake(&mut client_a, 1, 110, 30);
+ let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect");
+ client_handshake(&mut client_b, 1, 100, 30);
+
+ assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
+ assert!(wait_for_frame(&mut client_b, Duration::from_secs(2)));
+ drain_server_messages(&mut client_a, Duration::from_millis(250));
+ drain_server_messages(&mut client_b, Duration::from_millis(250));
+
+ let created = workspace_create(&api_socket, "shared-view");
+ let pane_id = created["result"]["root_pane"]["pane_id"]
+ .as_str()
+ .expect("root pane id")
+ .to_string();
+
+ // Input from client A should update shared state visible to client B.
+ send_client_input(&mut client_a, b"echo SHARED_VIEW\n");
+ assert!(
+ wait_for_frame(&mut client_b, Duration::from_secs(2)),
+ "client B should receive update from client A"
+ );
+ assert!(pane_read_recent_contains(
+ &api_socket,
+ &pane_id,
+ "SHARED_VIEW",
+ Duration::from_secs(5)
+ ));
+
+ // Detach client A; client B should keep working.
+ send_client_detach(&mut client_a);
+ drop(client_a);
+
+ send_client_input(&mut client_b, b"echo AFTER_A_DETACH\n");
+ assert!(
+ wait_for_frame(&mut client_b, Duration::from_secs(2)),
+ "remaining client should still receive frames after other client detaches"
+ );
+ assert!(pane_read_recent_contains(
+ &api_socket,
+ &pane_id,
+ "AFTER_A_DETACH",
+ Duration::from_secs(5)
+ ));
+
+ let ping = ping_socket(&api_socket);
+ assert!(
+ ping.contains("pong"),
+ "server and remaining client flow should stay healthy: {ping}"
+ );
+
+ cleanup_spawned_herdr(server, base);
+}
+
+#[test]
+fn cross_area_server_kill_then_restart_and_reconnect() {
+ let _lock = test_lock();
+ let base = unique_test_dir();
+ let config_home = base.join("config");
+ let runtime_dir = base.join("runtime");
+ let api_socket = runtime_dir.join("herdr.sock");
+ let client_socket = runtime_dir.join("herdr-client.sock");
+
+ let mut server = spawn_server(&config_home, &runtime_dir, &api_socket);
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ // Attach a real thin client process and prove it reached attached state
+ // by observing an incoming frame on its PTY stream.
+ let mut thin_client = spawn_client_process(&config_home, &runtime_dir, &api_socket);
+ let mut thin_reader = thin_client
+ ._master
+ .try_clone_reader()
+ .expect("clone thin client reader");
+
+ let attached_before_kill = {
+ let deadline = Instant::now() + Duration::from_secs(8);
+ let mut observed = false;
+ let mut buf = [0u8; 4096];
+ while Instant::now() < deadline {
+ match thin_reader.read(&mut buf) {
+ Ok(n) if n > 0 => {
+ let out = String::from_utf8_lossy(&buf[..n]);
+ if out.contains("\u{2500}")
+ || out.contains("workspace")
+ || out.contains("pane")
+ || out.contains("terminal")
+ {
+ observed = true;
+ break;
+ }
+ }
+ Ok(_) => thread::sleep(Duration::from_millis(30)),
+ Err(_) => thread::sleep(Duration::from_millis(30)),
+ }
+ }
+ observed
+ };
+ assert!(
+ attached_before_kill,
+ "thin client should complete attach before server SIGKILL"
+ );
+
+ // Kill server abruptly and verify thin client exits with lost-connection messaging.
+ let server_pid = server.child.process_id().expect("server pid should exist");
+ unsafe {
+ libc::kill(server_pid as libc::pid_t, libc::SIGKILL);
+ }
+ assert!(
+ wait_for_child_exit(&mut server.child, Duration::from_secs(5)),
+ "server should exit after SIGKILL"
+ );
+ drop(server);
+
+ let mut crash_output = String::new();
+ let thin_exited = {
+ let deadline = Instant::now() + Duration::from_secs(12);
+ let mut exited = false;
+ let mut buf = [0u8; 1024];
+ while Instant::now() < deadline {
+ if thin_client.child.try_wait().ok().flatten().is_some() {
+ exited = true;
+ break;
+ }
+ if let Ok(n) = thin_reader.read(&mut buf) {
+ if n > 0 {
+ crash_output.push_str(&String::from_utf8_lossy(&buf[..n]));
+ }
+ }
+ thread::sleep(Duration::from_millis(50));
+ }
+ exited
+ };
+ assert!(thin_exited, "thin client should exit after server SIGKILL");
+
+ let thin_status = thin_client
+ .child
+ .wait()
+ .expect("wait for thin client exit status");
+ assert!(
+ !thin_status.success(),
+ "thin client should exit non-zero after unexpected server crash"
+ );
+
+ // Drain trailing output and require the explicit user-visible lost-connection message.
+ let deadline = Instant::now() + Duration::from_secs(5);
+ let mut buf = [0u8; 2048];
+ while Instant::now() < deadline {
+ match thin_reader.read(&mut buf) {
+ Ok(n) if n > 0 => crash_output.push_str(&String::from_utf8_lossy(&buf[..n])),
+ Ok(_) => break,
+ Err(_) => break,
+ }
+ thread::sleep(Duration::from_millis(30));
+ }
+
+ let crash_output_lc = crash_output.to_lowercase();
+ assert!(
+ crash_output_lc.contains("lost connection to server"),
+ "thin client output must include explicit lost-connection message after server kill; output: {crash_output:?}"
+ );
+
+ // Restart server and verify new client can connect (stale socket cleaned).
+ let server2 = spawn_server(&config_home, &runtime_dir, &api_socket);
+ wait_for_socket(&api_socket, Duration::from_secs(10));
+ wait_for_socket(&client_socket, Duration::from_secs(10));
+
+ let mut reconnect_client =
+ UnixStream::connect(&client_socket).expect("new client should connect after restart");
+ client_handshake(&mut reconnect_client, 1, 80, 24);
+ assert!(
+ wait_for_frame(&mut reconnect_client, Duration::from_secs(5)),
+ "new client should receive frame after restart"
+ );
+
+ let ping = ping_socket(&api_socket);
+ assert!(
+ ping.contains("pong"),
+ "restarted server should respond over API: {ping}"
+ );
+
+ cleanup_spawned_herdr(server2, base);
+}