retach 0.10.0

Persistent terminal sessions with native scrollback passthrough
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

//! retach — terminal multiplexer with native scrollback passthrough.
//!
//! Instead of intercepting scrollback (like tmux/screen), retach sends completed
//! lines directly to stdout, letting the client terminal handle scrolling natively.

mod cli;
mod client;
mod protocol;
mod pty;
mod server;
mod session;

use clap::Parser;
use cli::{Cli, Command};
use tracing_subscriber::EnvFilter;

fn init_tracing() {
    tracing_subscriber::fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("retach=info")),
        )
        .with_writer(std::io::stderr)
        .init();
}

fn main() -> anyhow::Result<()> {
    init_tracing();
    let cli = Cli::parse();

    let rt = tokio::runtime::Runtime::new()?;

    // `client::connect` returns the session child's exit code (when the process
    // exited while attached) so we can mirror it as our own process exit status.
    let mut child_exit_code: Option<i32> = None;
    let result = match cli.command {
        Command::Open { name, history } => rt
            .block_on(client::connect(
                &name,
                history,
                protocol::ConnectMode::CreateOrAttach,
            ))
            .map(|code| child_exit_code = code),
        Command::New { name, history } => {
            let name = name.unwrap_or_else(generate_name);
            rt.block_on(client::connect(
                &name,
                history,
                protocol::ConnectMode::CreateOnly,
            ))
            .map(|code| child_exit_code = code)
        }
        Command::Attach { name } => rt
            .block_on(client::connect(&name, 0, protocol::ConnectMode::AttachOnly))
            .map(|code| child_exit_code = code),
        Command::List => rt.block_on(client::list_sessions()),
        Command::Kill { name } => rt.block_on(client::kill_session(&name)),
        Command::Server => rt.block_on(server::run_server()),
    };

    // Shut down runtime with timeout to avoid hanging on blocked stdin thread
    rt.shutdown_timeout(std::time::Duration::from_millis(100));

    result?;

    // Propagate the session child's exit code so scripts checking $? see the
    // real status. RAII guards in connect() have already run by this point.
    if let Some(code) = child_exit_code {
        std::process::exit(code);
    }
    Ok(())
}

fn generate_name() -> String {
    use std::hash::{BuildHasher, Hasher};
    // RandomState::new() seeds from OS randomness, giving real uniqueness
    // without adding external dependencies.
    let hash = std::collections::hash_map::RandomState::new()
        .build_hasher()
        .finish();
    format!("s-{:016x}", hash)
}