Struct Run 

struct Run {
    block_id: String,
    conn: String,
    host: HostSsh,
    session: String,
    size: (u16, u16),
    broker: Option<Arc<Broker>>,
    filestore: Option<Arc<FileStore>>,
    _askpass_grant: Option<Revoke>,
    plain: Arc<AtomicBool>,
    by_default: bool,
}

One durable pane’s connection loop.

Fields

block_id: String

conn: String

host: HostSsh

The host, with askpass for ssh’s prompts.

session: String

size: (u16, u16)

broker: Option<Arc<Broker>>

filestore: Option<Arc<FileStore>>

_askpass_grant: Option<Revoke>

The askpass grant behind host’s prompts (revoked on drop).

plain: Arc<AtomicBool>

Set when the run ends because the helper isn’t to be had (the user declined it, or durable was only the default and it didn’t install): the pane becomes a plain SSH terminal.

by_default: bool

Durable only by default (Mode::Default): without the helper the pane becomes a plain terminal rather than stopping.

Implementations

impl Run

async fn run( self, input_rx: UnboundedReceiver<Frame>, leave_rx: Receiver<Leave>, stopped: Box<dyn FnOnce(Done) + Send>, ) -> Option<Done>

Connect, and reconnect for as long as the pane wants the session. Some when the session (or the attempt to reach it) is over and the pane should show it done; None when the pane left. A refused login shows the pane done through stopped and stays until the pane leaves (see there).

async fn wait_for_user( &mut self, line: &str, leave_rx: &mut Receiver<Leave>, stopped: Box<dyn FnOnce(Done) + Send>, ) -> Option<Done>

Say line, show the pane done without ending the session (a restart reattaches to it), and stay until the pane leaves: closing it still ends the session (one end, best effort, any prompt to the user), as for any durable pane. A restart replaces this run: its leave sender goes, and this returns.

async fn attach_once( &mut self, input_rx: &mut UnboundedReceiver<Frame>, leave_rx: &mut Receiver<Leave>, reconnecting: bool, ) -> Ended

One ssh to the session, until it drops or the pane leaves. reconnecting: the pane said it lost the session, so it says when it has it again.

async fn end_remote(&self)

End the session on the host with one short ssh (agentmux-remote end): a pane closed while disconnected must not leave its shell running there with nothing able to reach it. Best effort, bounded.

async fn host_is_windows(&self) -> Option<bool>

Whether the host is Windows, asked in a way no language changes: from cmd or PowerShell, cmd /c echo %OS% prints Windows_NT; a POSIX host has no cmd. None when there was no answer from the host (ssh failed or timed out), so it can be asked again.

fn ssh_command(&self, remote: &str) -> Command

async fn install_helper(&self) -> Result<(), String>

Put this version’s helper on the host (helper_install::ensure), saying so in the pane, once the user has said yes (helper_consent). Err says why not.

fn read_offset(&self) -> u64

fn write_offset(&self, offset: u64)

async fn append(&self, data: Vec<u8>) -> bool

Append to the pane’s terminal, exactly as a PTY’s output is appended.

async fn note_owned(&self, text: String)

Self::note with an owned line (for a closure’s future).

async fn note(&self, text: &str)

A line from AgentMux in the pane (pane_note).