rmux-server 0.10.0

Tokio daemon and request dispatcher for the RMUX terminal multiplexer.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::*;

const KITTY_SET: &[u8] = b"\x1b[=8u";
const KITTY_PUSH: &[u8] = b"\x1b[>1u";
const KITTY_POP: &[u8] = b"\x1b[<u";

async fn append_pane_output(
    handler: &RequestHandler,
    session: &rmux_proto::SessionName,
    bytes: &[u8],
) {
    let mut state = handler.state.lock().await;
    state
        .append_bytes_to_pane_transcript_for_test(session, 0, 0, bytes)
        .expect("pane transcript update");
}

async fn assert_activation_request_keeps_standard_encoding(request: &[u8], session_label: &str) {
    let handler = RequestHandler::new();
    let session = session_name(session_label);
    let requester_pid = std::process::id();

    create_send_keys_test_session(&handler, &session).await;
    append_pane_output(&handler, &session, request).await;

    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let _attach_id = handler
        .register_attach(requester_pid, session.clone(), control_tx)
        .await;

    let csi_u_shift_enter = b"\x1b[13;2u";
    let expected = b"\n";
    let capture = RawPaneInputProbe::start(
        &handler,
        &session,
        "ignored-kitty-activation",
        expected.len(),
    )
    .await;

    handler
        .handle_attached_live_input_for_test(requester_pid, csi_u_shift_enter)
        .await
        .expect("live attach Shift+Enter input");

    capture.finish(&handler, &session).await;
    capture.assert_contents(&handler, expected).await;
}

#[tokio::test]
async fn live_attach_kitty_set_and_push_do_not_enable_partial_key_encoding() {
    assert_activation_request_keeps_standard_encoding(KITTY_SET, "kitty-set-noop").await;
    assert_activation_request_keeps_standard_encoding(KITTY_PUSH, "kitty-push-noop").await;
}

#[tokio::test]
async fn live_attach_kitty_pop_does_not_clear_xterm_extended_key_mode() {
    let handler = RequestHandler::new();
    let session = session_name("kitty-pop-noop");
    let requester_pid = std::process::id();

    create_send_keys_test_session(&handler, &session).await;
    append_pane_output(&handler, &session, b"\x1b[>4;2m").await;
    append_pane_output(&handler, &session, KITTY_POP).await;

    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let _attach_id = handler
        .register_attach(requester_pid, session.clone(), control_tx)
        .await;

    let csi_u_shift_enter = b"\x1b[13;2u";
    let expected = b"\x1b[27;2;13~";
    let capture =
        RawPaneInputProbe::start(&handler, &session, "ignored-kitty-pop", expected.len()).await;

    handler
        .handle_attached_live_input_for_test(requester_pid, csi_u_shift_enter)
        .await
        .expect("live attach Shift+Enter input");

    capture.finish(&handler, &session).await;
    capture.assert_contents(&handler, expected).await;
}

#[tokio::test]
async fn live_attach_ignored_kitty_request_preserves_legacy_escape_and_backspace() {
    let handler = RequestHandler::new();
    let session = session_name("kitty-legacy-keys");
    let requester_pid = std::process::id();

    create_send_keys_test_session(&handler, &session).await;
    append_pane_output(&handler, &session, KITTY_SET).await;

    let (control_tx, _control_rx) = mpsc::unbounded_channel();
    let _attach_id = handler
        .register_attach(requester_pid, session.clone(), control_tx)
        .await;

    let expected = b"\x1b\x7f";
    let capture = RawPaneInputProbe::start(
        &handler,
        &session,
        "ignored-kitty-legacy-keys",
        expected.len(),
    )
    .await;

    let mut pending_input = Vec::new();
    handler
        .handle_attached_live_input(requester_pid, &mut pending_input, b"\x1b")
        .await
        .expect("standalone escape input");
    assert_eq!(pending_input, b"\x1b");
    assert!(handler
        .flush_attached_pending_escape_input(requester_pid, &mut pending_input)
        .await
        .expect("standalone escape flush"));
    assert!(pending_input.is_empty());

    handler
        .handle_attached_live_input(requester_pid, &mut pending_input, b"\x7f")
        .await
        .expect("legacy backspace input");
    assert!(pending_input.is_empty());

    capture.finish(&handler, &session).await;
    capture.assert_contents(&handler, expected).await;
}