xiaoxue_admin
/
herdr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test: update protocol fixtures

This commit is contained in:
Ogulcan Celik 2026-05-13 14:51:47 +03:00
parent f7b6467afe
commit 4da250ad17
9 changed files with 89 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/api/schema.rs
View File

@ -994,7 +994,7 @@ mod tests {
id: "req_1".into(),
result: ResponseResult::Pong {
version: "0.1.2".into(),
protocol: 4,
protocol: 5,
},
};

6
tests/cli_wrapper.rs
View File

@ -938,7 +938,7 @@ fn status_commands_report_client_and_server_versions() {
"stdout: {full_stdout}"
);
assert!(
full_stdout.contains(" protocol: 4"),
full_stdout.contains(" protocol: 5"),
"stdout: {full_stdout}"
);
assert!(full_stdout.contains("server:\n"), "stdout: {full_stdout}");
@ -971,7 +971,7 @@ fn status_commands_report_client_and_server_versions() {
"stdout: {server_stdout}"
);
assert!(
server_stdout.contains("protocol: 4"),
server_stdout.contains("protocol: 5"),
"stdout: {server_stdout}"
);
@ -983,7 +983,7 @@ fn status_commands_report_client_and_server_versions() {
"stdout: {client_stdout}"
);
assert!(
client_stdout.contains("protocol: 4"),
client_stdout.contains("protocol: 5"),
"stdout: {client_stdout}"
);
assert!(

57
tests/client_mode.rs
View File

@ -167,6 +167,7 @@ struct FrameWire {
height: u16,
cursor: Option<CursorWire>,
hyperlinks: Vec<String>,
graphics: Vec<u8>,
}
#[allow(dead_code)]
@ -219,7 +220,7 @@ fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool {
}
text.push('\n');
}
let _ = frame.height;
let _ = (frame.height, frame.graphics.len());
if let Some(cursor) = frame.cursor.as_ref() {
let _ = (cursor.x, cursor.y, cursor.visible);
}
@ -250,8 +251,8 @@ fn client_connects_and_receives_frame() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4, "server should report protocol version 4");
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5, "server should report protocol version 5");
assert!(
error.is_none(),
"handshake should not have error: {:?}",
@ -330,8 +331,8 @@ fn client_sees_headless_startup_config_diagnostic() {
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
stream
@ -379,8 +380,8 @@ fn client_input_forwarded_to_pane() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Send an Input message containing "echo hello\n".
@ -433,8 +434,8 @@ fn client_resize_sends_message() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain the initial frame(s).
@ -443,11 +444,13 @@ fn client_resize_sends_message() {
.unwrap();
while read_server_message(&mut stream).is_ok() {}
// Send a Resize message: ClientMessage::Resize is variant 2: { cols: u16, rows: u16 }
// Send a Resize message: ClientMessage::Resize is variant 2.
let resize_payload = {
let mut buf = encode_varint_u32(2); // variant 2 = Resize
buf.extend_from_slice(&encode_varint_u16(120)); // cols
buf.extend_from_slice(&encode_varint_u16(40)); // rows
buf.extend_from_slice(&encode_varint_u32(8)); // cell_width_px
buf.extend_from_slice(&encode_varint_u32(16)); // cell_height_px
buf
};
let framed = frame_message(&resize_payload);
@ -490,8 +493,8 @@ fn server_shutdown_sends_message_to_client() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Send SIGINT so the server takes the graceful shutdown path and
@ -718,8 +721,8 @@ fn client_receives_frame_after_pane_output() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Read the initial frame (server renders immediately on client connect).
@ -772,8 +775,8 @@ fn navigate_mode_keybind_dispatch_in_server() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -890,8 +893,8 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frame(s).
@ -907,7 +910,7 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
}
}
// The client should receive a ServerShutdown message (variant 3)
// The client should receive a ServerShutdown message (variant 4)
// before the connection is closed, not just an abrupt EOF.
stream
.set_read_timeout(Some(Duration::from_secs(5)))
@ -916,8 +919,8 @@ fn graceful_shutdown_sends_server_shutdown_to_client() {
match result {
Ok((variant, _payload)) => {
assert_eq!(
variant, 3,
"expected ServerShutdown (variant 3), got variant {variant}"
variant, 4,
"expected ServerShutdown (variant 4), got variant {variant}"
);
}
Err(e) => {
@ -988,8 +991,8 @@ fn client_receives_notify_on_agent_state_change() {
// Connect as a client and perform handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frame(s).
@ -1040,8 +1043,8 @@ fn client_receives_notify_on_agent_state_change() {
let mut report_response = String::new();
report_reader.read_line(&mut report_response).unwrap();
// Read messages from the client stream and look for Notify (variant 4).
// Notify = ServerMessage variant index 4 (after Welcome=0, Frame=1, Terminal=2, ServerShutdown=3).
// Read messages from the client stream and look for Notify (variant 5).
// Notify = ServerMessage variant index 5.
stream
.set_read_timeout(Some(Duration::from_secs(5)))
.unwrap();
@ -1050,7 +1053,7 @@ fn client_receives_notify_on_agent_state_change() {
while Instant::now() < deadline {
match read_server_message(&mut stream) {
Ok((variant, _payload)) => {
if variant == 4 {
if variant == 5 {
// ServerMessage::Notify — found it!
found_notify = true;
break;
@ -1136,7 +1139,7 @@ fn client_receives_notify_on_agent_state_change() {
while Instant::now() < deadline {
match read_server_message(&mut stream) {
Ok((variant, _payload)) => {
if variant == 4 {
if variant == 5 {
// Found a Notify message — that's good enough.
// The test already verified the Blocked→Notify path above.
found_done_notify = true;

21
tests/cross_area.rs
View File

@ -417,6 +417,8 @@ fn client_handshake(stream: &mut UnixStream, version: u32, cols: u16, rows: u16)
payload.extend_from_slice(&encode_varint_u32(version));
payload.extend_from_slice(&encode_varint_u16(cols));
payload.extend_from_slice(&encode_varint_u16(rows));
payload.extend_from_slice(&encode_varint_u32(8)); // cell_width_px
payload.extend_from_slice(&encode_varint_u32(16)); // cell_height_px
payload.extend_from_slice(&encode_varint_u32(0)); // RenderEncoding::SemanticFrame
stream
@ -497,6 +499,7 @@ struct FrameWire {
height: u16,
cursor: Option<CursorWire>,
hyperlinks: Vec<String>,
graphics: Vec<u8>,
}
#[allow(dead_code)]
@ -549,7 +552,7 @@ fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool {
}
text.push('\n');
}
let _ = frame.height;
let _ = (frame.height, frame.graphics.len());
if let Some(cursor) = frame.cursor.as_ref() {
let _ = (cursor.x, cursor.y, cursor.visible);
}
@ -674,7 +677,7 @@ fn cross_area_detach_and_reattach_preserves_state() {
// Local attach (client A).
let mut client_a = UnixStream::connect(&client_socket).expect("client A should connect");
client_handshake(&mut client_a, 4, 100, 30);
client_handshake(&mut client_a, 5, 100, 30);
assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
// Use herdr: create a workspace and write output into its pane.
@ -711,7 +714,7 @@ fn cross_area_detach_and_reattach_preserves_state() {
// 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, 4, 80, 24);
client_handshake(&mut client_b, 5, 80, 24);
assert!(
wait_for_frame(&mut client_b, Duration::from_secs(5)),
"reattached client should receive frame"
@ -767,7 +770,7 @@ fn cross_area_agent_process_survives_detach_and_reattach() {
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, 4, 100, 30);
client_handshake(&mut client_a, 5, 100, 30);
assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
let created = workspace_create(&api_socket, "agent-persist");
@ -820,7 +823,7 @@ fn cross_area_agent_process_survives_detach_and_reattach() {
// 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, 4, 80, 24);
client_handshake(&mut client_b, 5, 80, 24);
let saw_working_on_client =
wait_for_frame_matching(&mut client_b, Duration::from_secs(5), |frame| {
frame_contains_text(frame, "working")
@ -865,7 +868,7 @@ fn cross_area_client_and_api_workspace_views_are_consistent() {
wait_for_socket(&client_socket, Duration::from_secs(10));
let mut client = UnixStream::connect(&client_socket).expect("client should connect");
client_handshake(&mut client, 4, 100, 30);
client_handshake(&mut client, 5, 100, 30);
assert!(wait_for_frame(&mut client, Duration::from_secs(2)));
drain_server_messages(&mut client, Duration::from_millis(300));
@ -928,9 +931,9 @@ fn cross_area_two_clients_shared_view_and_single_detach_stability() {
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, 4, 110, 30);
client_handshake(&mut client_a, 5, 110, 30);
let mut client_b = UnixStream::connect(&client_socket).expect("client B should connect");
client_handshake(&mut client_b, 4, 100, 30);
client_handshake(&mut client_b, 5, 100, 30);
assert!(wait_for_frame(&mut client_a, Duration::from_secs(2)));
assert!(wait_for_frame(&mut client_b, Duration::from_secs(2)));
@ -1096,7 +1099,7 @@ fn cross_area_server_kill_then_restart_and_reconnect() {
let mut reconnect_client =
UnixStream::connect(&client_socket).expect("new client should connect after restart");
client_handshake(&mut reconnect_client, 4, 80, 24);
client_handshake(&mut reconnect_client, 5, 80, 24);
assert!(
wait_for_frame(&mut reconnect_client, Duration::from_secs(5)),
"new client should receive frame after restart"

44
tests/detach_reattach.rs
View File

@ -276,8 +276,8 @@ fn navigate_q_detaches_client_and_server_persists() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -338,8 +338,8 @@ fn explicit_detach_message_causes_clean_disconnect() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -397,8 +397,8 @@ fn reattach_after_detach_shows_current_state() {
// --- Client A ---
let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
let (version, error) =
client_handshake(&mut stream_a, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_a, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -436,8 +436,8 @@ fn reattach_after_detach_shows_current_state() {
// --- Client B (reattach) ---
let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
let (version, error) =
client_handshake(&mut stream_b, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_b, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(
error.is_none(),
"reattach handshake should succeed: {:?}",
@ -516,8 +516,8 @@ fn processes_survive_during_and_after_detach() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -555,8 +555,8 @@ fn processes_survive_during_and_after_detach() {
// Reattach — verify we can connect and receive a frame.
let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
let (version, error) =
client_handshake(&mut stream_b, 4, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_b, 5, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Verify the reattached client receives a frame.
@ -604,8 +604,8 @@ fn server_persists_after_client_connection_drop() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@ -631,8 +631,8 @@ fn server_persists_after_client_connection_drop() {
// Reattach — verify we can connect and handshake again.
let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
let (version, error) =
client_handshake(&mut stream_b, 4, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_b, 5, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "reattach should succeed: {:?}", error);
cleanup_spawned_herdr(spawned, base);
@ -653,8 +653,8 @@ fn detached_output_preserves_last_attached_pty_size() {
let mut stream = UnixStream::connect(&client_socket).expect("client should connect");
let (version, error) =
client_handshake(&mut stream, 4, 120, 40).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream, 5, 120, 40).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
drain_messages(&mut stream);
@ -722,8 +722,8 @@ fn output_accumulated_while_detached_visible_on_reattach() {
// Connect and handshake client A.
let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
let (version, error) =
client_handshake(&mut stream_a, 4, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_a, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Detach client A immediately.
@ -780,8 +780,8 @@ fn output_accumulated_while_detached_visible_on_reattach() {
// --- Client B (reattach) ---
let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
let (version, error) =
client_handshake(&mut stream_b, 4, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 4);
client_handshake(&mut stream_b, 5, 80, 24).expect("reattach handshake should succeed");
assert_eq!(version, 5);
assert!(error.is_none(), "{:?}", error);
// Client B should receive a frame with the current state.

9
tests/multi_client.rs
View File

@ -496,7 +496,9 @@ fn client_handshake(
&encode_varint_u32(version),
&encode_varint_u16(cols),
&encode_varint_u16(rows),
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
&encode_varint_u32(8), // cell_width_px
&encode_varint_u32(16), // cell_height_px
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
],
);
stream
@ -547,7 +549,7 @@ fn client_handshake(
fn connect_raw_client(client_socket: &Path, cols: u16, rows: u16) -> UnixStream {
let mut stream = UnixStream::connect(client_socket).expect("should connect to client socket");
client_handshake(&mut stream, 4, cols, rows).expect("handshake should succeed");
client_handshake(&mut stream, 5, cols, rows).expect("handshake should succeed");
stream
}
@ -578,6 +580,7 @@ struct FrameWire {
height: u16,
cursor: Option<CursorWire>,
hyperlinks: Vec<String>,
graphics: Vec<u8>,
}
#[allow(dead_code)]
@ -709,7 +712,7 @@ fn frame_contains_text(frame: &FrameWire, needle: &str) -> bool {
full_text.push('\n');
}
let _ = frame.height;
let _ = (frame.height, frame.graphics.len());
if let Some(cursor) = frame.cursor.as_ref() {
let _ = (cursor.x, cursor.y, cursor.visible);
}

20
tests/server_headless.rs
View File

@ -169,7 +169,9 @@ fn client_handshake(
&encode_varint_u32(version),
&encode_varint_u16(cols),
&encode_varint_u16(rows),
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
&encode_varint_u32(8), // cell_width_px
&encode_varint_u32(16), // cell_height_px
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
],
);
let framed = frame_message(&hello_payload);
@ -581,11 +583,11 @@ fn client_handshake_succeeds() {
// Connect to the client socket and perform a handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
// Send Hello with version 4, 80 cols, 24 rows.
// Send Hello with version 5, 80 cols, 24 rows.
let (version, error) =
client_handshake(&mut stream, 4, 80, 24).expect("handshake should succeed");
client_handshake(&mut stream, 5, 80, 24).expect("handshake should succeed");
assert_eq!(version, 4, "server should report protocol version 4");
assert_eq!(version, 5, "server should report protocol version 5");
assert!(
error.is_none(),
"handshake should not have an error: {:?}",
@ -614,7 +616,7 @@ fn client_handshake_rejects_incompatible_version() {
let (version, error) = client_handshake(&mut stream, 0, 80, 24)
.expect("should read Welcome response even on rejection");
assert_eq!(version, 4, "server should report its version 4");
assert_eq!(version, 5, "server should report its version 5");
assert!(
error.is_some(),
"version 0 should be rejected with an error"
@ -639,10 +641,10 @@ fn client_handshake_clamps_small_terminal_size() {
// Send Hello with 0x0 terminal size — should be clamped.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) = client_handshake(&mut stream, 4, 0, 0)
let (version, error) = client_handshake(&mut stream, 5, 0, 0)
.expect("handshake with 0x0 should succeed (server clamps)");
assert_eq!(version, 4);
assert_eq!(version, 5);
assert!(
error.is_none(),
"0x0 size should be accepted (clamped): {:?}",
@ -702,9 +704,9 @@ fn no_hello_client_closed_within_five_seconds() {
// Verify the server is still healthy — a proper client can still connect.
let mut good_stream =
UnixStream::connect(&client_socket).expect("should connect after no-hello client");
let (version, error) = client_handshake(&mut good_stream, 4, 80, 24)
let (version, error) = client_handshake(&mut good_stream, 5, 80, 24)
.expect("proper handshake should still work after no-hello client");
assert_eq!(version, 4);
assert_eq!(version, 5);
assert!(error.is_none());
// API should still work.

4
tests/support/mod.rs
View File

@ -220,7 +220,9 @@ pub fn client_handshake(
&encode_varint_u32(version),
&encode_varint_u16(cols),
&encode_varint_u16(rows),
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
&encode_varint_u32(8), // cell_width_px
&encode_varint_u32(16), // cell_height_px
&encode_varint_u32(0), // RenderEncoding::SemanticFrame
],
);
let framed = frame_message(&hello_payload);

2
website/latest.json
View File

@ -1,6 +1,6 @@
{
"version": "0.5.8",
"protocol": 4,
"protocol": 5,
"notes": "### Added\n- Added manual pane labels through `herdr pane rename`, the `pane.rename` socket API, an optional `keys.rename_pane` binding, and the right-click pane menu.\n- Added `ui.show_agent_labels_on_pane_borders`, which can show detected or reported agent names in split pane borders when no manual pane label is set.\n- Added `herdr integration status [--outdated-only]` so installed agent integrations can be checked for legacy or outdated versions.\n- Added an optional `keys.open_notification_target` binding for jumping to the pane behind the current notification.\n- Added optional `keys.previous_agent` and `keys.next_agent` bindings for cycling through sidebar agent entries.\n\n### Changed\n- Scrolling over the tab bar now switches tabs directly, including overflowing tab bars.\n\n### Fixed\n- Indexed terminal palette colors now render correctly for 256-color terminal apps.\n- Hook-based agent integrations now reject stale out-of-order reports and base notifications on effective agent state, reducing duplicate or stuck state changes.\n- Background tabs now resize when the outer terminal size changes, preventing stale pane dimensions when switching back to them.\n- Client shutdown now drains queued control messages more reliably.\n- Pane cursors are now hidden while scrolled back, and omitted while the mobile switcher is open.\n- Mobile agent switcher entries now include tab context, making agents easier to identify on narrow terminals.\n- macOS foreground job detection now uses process groups, improving agent state tracking for foreground commands.\n- Remote SSH no longer fails before connecting when macOS temporary bridge socket paths exceed Unix socket length limits. (#103, thanks @moonsphere)\n- Nix-wrapped agent commands are now detected by their underlying agent entrypoint.\n- Pane renames made through the socket API now rerender immediately.",
"assets": {
"linux-x86_64": "https://github.com/ogulcancelik/herdr/releases/download/v0.5.8/herdr-linux-x86_64",