Struct Connection 

pub struct Connection { /* private fields */ }

A blocking connection to the RMUX server that exchanges typed frames.

Implementations

impl Connection

pub fn set_buffer( &mut self, name: Option<String>, content: Vec<u8>, append: bool, new_name: Option<String>, set_clipboard: bool, ) -> Result<Response, ClientError>

Sends a set-buffer request over the detached RPC channel.

pub fn show_buffer( &mut self, name: Option<String>, ) -> Result<Response, ClientError>

Sends a show-buffer request over the detached RPC channel.

pub fn paste_buffer( &mut self, name: Option<String>, target: PaneTarget, delete_after: bool, separator: Option<String>, linefeed: bool, raw: bool, bracketed: bool, ) -> Result<Response, ClientError>

Sends a paste-buffer request over the detached RPC channel.

pub fn list_buffers( &mut self, format: Option<String>, filter: Option<String>, sort_order: Option<String>, reversed: bool, ) -> Result<Response, ClientError>

Sends a list-buffers request over the detached RPC channel.

pub fn delete_buffer( &mut self, name: Option<String>, ) -> Result<Response, ClientError>

Sends a delete-buffer request over the detached RPC channel.

pub fn load_buffer( &mut self, path: String, name: Option<String>, set_clipboard: bool, ) -> Result<Response, ClientError>

Sends a load-buffer request over the detached RPC channel.

pub fn save_buffer( &mut self, path: String, name: Option<String>, append: bool, ) -> Result<Response, ClientError>

Sends a save-buffer request over the detached RPC channel.

pub fn capture_pane( &mut self, request: CapturePaneRequest, ) -> Result<Response, ClientError>

Sends a capture-pane request over the detached RPC channel.

pub fn clear_history( &mut self, target: PaneTarget, reset_hyperlinks: bool, ) -> Result<Response, ClientError>

Sends a clear-history request over the detached RPC channel.

impl Connection

pub fn set_option( &mut self, scope: ScopeSelector, option: OptionName, value: String, mode: SetOptionMode, ) -> Result<Response, ClientError>

Sends a set-option request over the detached RPC channel.

pub fn set_option_by_name( &mut self, scope: OptionScopeSelector, name: String, value: Option<String>, mode: SetOptionMode, only_if_unset: bool, unset: bool, unset_pane_overrides: bool, ) -> Result<Response, ClientError>

Sends a string-keyed set-option request over the detached RPC channel.

pub fn set_environment( &mut self, scope: ScopeSelector, name: String, value: String, mode: Option<SetEnvironmentMode>, hidden: bool, format: bool, ) -> Result<Response, ClientError>

Sends a set-environment request over the detached RPC channel.

pub fn set_hook( &mut self, scope: ScopeSelector, hook: HookName, command: String, lifecycle: HookLifecycle, ) -> Result<Response, ClientError>

Sends a set-hook request over the detached RPC channel.

pub fn set_hook_mutation( &mut self, scope: ScopeSelector, hook: HookName, command: Option<String>, lifecycle: HookLifecycle, append: bool, unset: bool, run_immediately: bool, index: Option<u32>, ) -> Result<Response, ClientError>

Sends an extended set-hook mutation over the detached RPC channel.

pub fn show_options( &mut self, scope: OptionScopeSelector, name: Option<String>, value_only: bool, ) -> Result<Response, ClientError>

Sends a show-options request over the detached RPC channel.

pub fn show_environment( &mut self, scope: ScopeSelector, name: Option<String>, hidden: bool, shell_format: bool, ) -> Result<Response, ClientError>

Sends a show-environment request over the detached RPC channel.

pub fn show_hooks( &mut self, scope: ScopeSelector, window: bool, pane: bool, hook: Option<HookName>, ) -> Result<Response, ClientError>

Sends a show-hooks request over the detached RPC channel.

pub fn source_file( &mut self, paths: Vec<String>, quiet: bool, parse_only: bool, verbose: bool, expand_paths: bool, target: Option<PaneTarget>, stdin: Option<String>, ) -> Result<Response, ClientError>

Sends a source-file request over the detached RPC channel.

impl Connection

pub fn bind_key( &mut self, request: BindKeyRequest, ) -> Result<Response, ClientError>

Sends a bind-key request over the detached RPC channel.

pub fn unbind_key( &mut self, request: UnbindKeyRequest, ) -> Result<Response, ClientError>

Sends an unbind-key request over the detached RPC channel.

pub fn list_keys( &mut self, request: ListKeysRequest, ) -> Result<Response, ClientError>

Sends a list-keys request over the detached RPC channel.

impl Connection

pub fn swap_pane( &mut self, source: PaneTarget, target: PaneTarget, detached: bool, preserve_zoom: bool, ) -> Result<Response, ClientError>

Sends a swap-pane request over the detached RPC channel.

pub fn swap_pane_with_next( &mut self, target: PaneTarget, detached: bool, preserve_zoom: bool, ) -> Result<Response, ClientError>

Sends swap-pane -D over the detached RPC channel.

pub fn swap_pane_with_previous( &mut self, target: PaneTarget, detached: bool, preserve_zoom: bool, ) -> Result<Response, ClientError>

Sends swap-pane -U over the detached RPC channel.

pub fn last_pane( &mut self, target: WindowTarget, ) -> Result<Response, ClientError>

Sends a last-pane request over the detached RPC channel.

pub fn join_pane( &mut self, request: JoinPaneRequest, ) -> Result<Response, ClientError>

Sends a join-pane request over the detached RPC channel.

pub fn move_pane( &mut self, request: MovePaneRequest, ) -> Result<Response, ClientError>

Sends a move-pane request over the detached RPC channel.

pub fn break_pane( &mut self, request: BreakPaneRequest, ) -> Result<Response, ClientError>

Sends a break-pane request over the detached RPC channel.

pub fn resize_pane( &mut self, target: PaneTarget, adjustment: ResizePaneAdjustment, ) -> Result<Response, ClientError>

Sends a resize-pane request over the detached RPC channel.

pub fn display_panes( &mut self, target: SessionName, duration_ms: Option<u64>, non_blocking: bool, no_command: bool, template: Option<String>, ) -> Result<Response, ClientError>

Sends a display-panes request over the detached RPC channel.

pub fn pipe_pane( &mut self, target: PaneTarget, stdin: bool, stdout: bool, once: bool, command: Option<String>, ) -> Result<Response, ClientError>

Sends a pipe-pane request over the detached RPC channel.

pub fn respawn_pane( &mut self, request: RespawnPaneRequest, ) -> Result<Response, ClientError>

Sends a respawn-pane request over the detached RPC channel.

pub fn select_pane( &mut self, target: PaneTarget, ) -> Result<Response, ClientError>

Sends a select-pane request over the detached RPC channel.

pub fn select_pane_with_title( &mut self, target: PaneTarget, title: Option<String>, ) -> Result<Response, ClientError>

Sends a select-pane request with an optional title over the detached RPC channel.

pub fn select_pane_adjacent( &mut self, target: PaneTarget, direction: SelectPaneDirection, ) -> Result<Response, ClientError>

Sends a directional select-pane request over the detached RPC channel.

pub fn select_pane_mark( &mut self, target: PaneTarget, clear: bool, ) -> Result<Response, ClientError>

Sends select-pane -m or select-pane -M over the detached RPC channel.

pub fn select_pane_mark_with_title( &mut self, target: PaneTarget, clear: bool, title: Option<String>, ) -> Result<Response, ClientError>

Sends select-pane -m/-M with an optional title over the detached RPC channel.

pub fn kill_pane(&mut self, target: PaneTarget) -> Result<Response, ClientError>

Sends a kill-pane request over the detached RPC channel.

pub fn kill_pane_with_options( &mut self, target: PaneTarget, kill_all_except: bool, ) -> Result<Response, ClientError>

Sends a kill-pane request with extended tmux flags.

pub fn send_keys( &mut self, target: PaneTarget, keys: Vec<String>, ) -> Result<Response, ClientError>

Sends a send-keys request over the detached RPC channel.

pub fn send_keys_extended( &mut self, request: SendKeysExtRequest, ) -> Result<Response, ClientError>

Sends an extended send-keys request over the detached RPC channel.

pub fn send_prefix( &mut self, target: Option<PaneTarget>, secondary: bool, ) -> Result<Response, ClientError>

Sends a send-prefix request over the detached RPC channel.

pub fn copy_mode( &mut self, request: CopyModeRequest, ) -> Result<Response, ClientError>

Sends a copy-mode request over the detached RPC channel.

pub fn clock_mode( &mut self, target: Option<PaneTarget>, ) -> Result<Response, ClientError>

Sends a clock-mode request over the detached RPC channel.

impl Connection

pub fn run_shell( &mut self, command: String, background: bool, as_commands: bool, show_stderr: bool, delay_seconds: Option<f64>, start_directory: Option<PathBuf>, target: Option<PaneTarget>, ) -> Result<Response, ClientError>

Sends a run-shell request over the detached RPC channel without a response read timeout.

pub fn if_shell( &mut self, condition: String, format_mode: bool, then_command: String, else_command: Option<String>, target: Option<Target>, background: bool, ) -> Result<Response, ClientError>

Sends an if-shell request over the detached RPC channel without a response read timeout.

pub fn wait_for( &mut self, channel: String, mode: WaitForMode, ) -> Result<Response, ClientError>

Sends a wait-for request over the detached RPC channel without a response read timeout.

impl Connection

pub fn start_server( socket_path: &Path, no_start_server: bool, config: AutoStartConfig, ) -> Result<Self, StartServerError>

Ensures the server is available, honouring top-level no-start-server behavior.

pub fn kill_server(&mut self) -> Result<Response, ClientError>

Sends a kill-server request over the detached RPC channel.

pub fn lock_server(&mut self) -> Result<Response, ClientError>

Sends a lock-server request over the detached RPC channel.

pub fn lock_session( &mut self, target: SessionName, ) -> Result<Response, ClientError>

Sends a lock-session request over the detached RPC channel.

pub fn lock_client( &mut self, target_client: String, ) -> Result<Response, ClientError>

Sends a lock-client request over the detached RPC channel.

pub fn server_access( &mut self, request: ServerAccessRequest, ) -> Result<Response, ClientError>

Sends a server-access request over the detached RPC channel.

impl Connection

pub fn new_session( &mut self, session_name: SessionName, detached: bool, size: Option<TerminalSize>, ) -> Result<Response, ClientError>

Sends a new-session request over the detached RPC channel.

pub fn new_session_with_environment( &mut self, session_name: SessionName, detached: bool, size: Option<TerminalSize>, environment: Option<Vec<String>>, ) -> Result<Response, ClientError>

Sends a new-session request with explicit spawn environment overrides.

pub fn new_session_extended( &mut self, request: NewSessionExtRequest, ) -> Result<Response, ClientError>

Sends an extended new-session request with grouped-session and attach-if-exists semantics.

pub fn has_session( &mut self, target: SessionName, ) -> Result<Response, ClientError>

Sends a has-session request over the detached RPC channel.

pub fn kill_session( &mut self, request: KillSessionRequest, ) -> Result<Response, ClientError>

Sends a kill-session request over the detached RPC channel.

pub fn rename_session( &mut self, target: SessionName, new_name: SessionName, ) -> Result<Response, ClientError>

Sends a rename-session request over the detached RPC channel.

pub fn list_sessions( &mut self, request: ListSessionsRequest, ) -> Result<Response, ClientError>

Sends a list-sessions request over the detached RPC channel.

pub fn list_panes( &mut self, target: SessionName, format: Option<String>, ) -> Result<Response, ClientError>

Sends a list-panes request over the detached RPC channel.

pub fn list_panes_in_window( &mut self, target: SessionName, target_window_index: Option<u32>, format: Option<String>, ) -> Result<Response, ClientError>

Sends a list-panes request scoped to an optional window index.

pub fn switch_client( &mut self, target: SessionName, ) -> Result<Response, ClientError>

Sends a switch-client request over the detached RPC channel.

pub fn switch_client_extended( &mut self, target: Option<SessionName>, key_table: Option<String>, ) -> Result<Response, ClientError>

Sends an extended switch-client request over the detached RPC channel.

pub fn switch_client_with_session_flags( &mut self, request: SwitchClientExt2Request, ) -> Result<Response, ClientError>

Sends a further-extended switch-client request over the detached RPC channel.

pub fn switch_client_with_target_selector( &mut self, request: SwitchClientExt3Request, ) -> Result<Response, ClientError>

Sends the most recent switch-client request shape over the detached RPC channel.

pub fn detach_client(&mut self) -> Result<Response, ClientError>

Sends a detach-client request over the detached RPC channel.

pub fn detach_client_extended( &mut self, request: DetachClientExtRequest, ) -> Result<Response, ClientError>

Sends an extended detach-client request over the detached RPC channel.

pub fn refresh_client( &mut self, request: RefreshClientRequest, ) -> Result<Response, ClientError>

Sends a refresh-client request over the detached RPC channel.

pub fn list_clients( &mut self, request: ListClientsRequest, ) -> Result<Response, ClientError>

Sends a list-clients request over the detached RPC channel.

pub fn suspend_client( &mut self, request: SuspendClientRequest, ) -> Result<Response, ClientError>

Sends a suspend-client request over the detached RPC channel.

pub fn begin_attach( self, target: SessionName, ) -> Result<AttachTransition, ClientError>

Requests an attach upgrade and, on success, yields the raw Unix stream.

Once this method returns AttachTransition::Upgraded, the detached framing codec is no longer in the data path for the connection.

pub fn begin_attach_extended( self, request: AttachSessionExtRequest, ) -> Result<AttachTransition, ClientError>

Requests an extended attach upgrade and, on success, yields the raw Unix stream.

pub fn begin_attach_with_target_spec( self, request: AttachSessionExt2Request, ) -> Result<AttachTransition, ClientError>

Sends the most recent attach-session request shape over the detached RPC channel.

pub fn attach_session_with_target_spec_detached( &mut self, request: AttachSessionExt2Request, ) -> Result<Response, ClientError>

Sends the most recent attach-session request shape over the detached RPC channel.

impl Connection

pub fn display_message( &mut self, target: Option<Target>, print: bool, message: Option<String>, ) -> Result<Response, ClientError>

Sends a display-message request over the detached RPC channel.

pub fn show_messages( &mut self, jobs: bool, terminals: bool, target_client: Option<String>, ) -> Result<Response, ClientError>

Sends a show-messages request over the detached RPC channel.

impl Connection

pub fn resolve_target( &mut self, target: Option<String>, target_type: ResolveTargetType, window_index: bool, prefer_unattached: bool, ) -> Result<Response, ClientError>

Resolves tmux-style raw target text against live server state.

impl Connection

pub fn new_window( &mut self, target: SessionName, name: Option<String>, detached: bool, ) -> Result<Response, ClientError>

Sends a new-window request over the detached RPC channel.

pub fn new_window_with_environment( &mut self, target: SessionName, name: Option<String>, detached: bool, environment: Option<Vec<String>>, start_directory: Option<PathBuf>, command: Option<Vec<String>>, ) -> Result<Response, ClientError>

Sends a new-window request with explicit spawn environment overrides.

pub fn new_window_at_with_environment( &mut self, target: SessionName, target_window_index: Option<u32>, name: Option<String>, detached: bool, environment: Option<Vec<String>>, start_directory: Option<PathBuf>, command: Option<Vec<String>>, insert_at_target: bool, ) -> Result<Response, ClientError>

Sends a new-window request with an optional destination index.

pub fn kill_window( &mut self, target: WindowTarget, kill_others: bool, ) -> Result<Response, ClientError>

Sends a kill-window request over the detached RPC channel.

pub fn select_window( &mut self, target: WindowTarget, ) -> Result<Response, ClientError>

Sends a select-window request over the detached RPC channel.

pub fn rename_window( &mut self, target: WindowTarget, new_name: String, ) -> Result<Response, ClientError>

Sends a rename-window request over the detached RPC channel.

pub fn next_window( &mut self, target: SessionName, alerts_only: bool, ) -> Result<Response, ClientError>

Sends a next-window request over the detached RPC channel.

pub fn previous_window( &mut self, target: SessionName, alerts_only: bool, ) -> Result<Response, ClientError>

Sends a previous-window request over the detached RPC channel.

pub fn last_window( &mut self, target: SessionName, ) -> Result<Response, ClientError>

Sends a last-window request over the detached RPC channel.

pub fn list_windows( &mut self, target: SessionName, format: Option<String>, ) -> Result<Response, ClientError>

Sends a list-windows request over the detached RPC channel.

pub fn link_window( &mut self, source: WindowTarget, target: WindowTarget, after: bool, before: bool, kill_destination: bool, detached: bool, ) -> Result<Response, ClientError>

Sends a link-window request over the detached RPC channel.

pub fn move_window( &mut self, source: Option<WindowTarget>, target: MoveWindowTarget, renumber: bool, kill_destination: bool, detached: bool, ) -> Result<Response, ClientError>

Sends a move-window request over the detached RPC channel.

pub fn swap_window( &mut self, source: WindowTarget, target: WindowTarget, detached: bool, ) -> Result<Response, ClientError>

Sends a swap-window request over the detached RPC channel.

pub fn rotate_window( &mut self, target: WindowTarget, direction: RotateWindowDirection, ) -> Result<Response, ClientError>

Sends a rotate-window request over the detached RPC channel.

pub fn rotate_window_with_zoom( &mut self, target: WindowTarget, direction: RotateWindowDirection, restore_zoom: bool, ) -> Result<Response, ClientError>

Sends a rotate-window request with zoom save/restore over the detached RPC channel.

pub fn resize_window( &mut self, target: WindowTarget, width: Option<u16>, height: Option<u16>, adjustment: Option<ResizeWindowAdjustment>, ) -> Result<Response, ClientError>

Sends a resize-window request over the detached RPC channel.

pub fn unlink_window( &mut self, target: WindowTarget, kill_if_last: bool, ) -> Result<Response, ClientError>

Sends an unlink-window request over the detached RPC channel.

pub fn respawn_window( &mut self, target: WindowTarget, kill: bool, ) -> Result<Response, ClientError>

Sends a respawn-window request over the detached RPC channel.

pub fn respawn_window_with_environment( &mut self, target: WindowTarget, kill: bool, environment: Option<Vec<String>>, start_directory: Option<PathBuf>, command: Option<Vec<String>>, ) -> Result<Response, ClientError>

Sends a respawn-window request with explicit spawn environment overrides.

pub fn split_window( &mut self, target: SplitWindowTarget, ) -> Result<Response, ClientError>

Sends a split-window request over the detached RPC channel.

pub fn split_window_with_direction( &mut self, target: SplitWindowTarget, direction: SplitDirection, ) -> Result<Response, ClientError>

Sends a split-window request with an explicit direction over the detached RPC channel.

pub fn split_window_with_direction_and_environment( &mut self, target: SplitWindowTarget, direction: SplitDirection, environment: Option<Vec<String>>, ) -> Result<Response, ClientError>

Sends a split-window request with explicit spawn environment overrides.

pub fn split_window_with_spawn( &mut self, target: SplitWindowTarget, direction: SplitDirection, environment: Option<Vec<String>>, command: Option<Vec<String>>, ) -> Result<Response, ClientError>

Sends a split-window request with explicit spawn options.

New pane is inserted after the target. To insert before (tmux -b), use Connection::split_window_with_options.

pub fn split_window_with_options( &mut self, options: SplitWindowOptions, ) -> Result<Response, ClientError>

Sends a split-window request with full options including before.

pub fn select_layout( &mut self, target: SelectLayoutTarget, layout: LayoutName, ) -> Result<Response, ClientError>

Sends a select-layout request over the detached RPC channel.

pub fn select_custom_layout( &mut self, target: SelectLayoutTarget, layout: String, ) -> Result<Response, ClientError>

Sends a select-layout custom layout request over the detached RPC channel.

pub fn next_layout( &mut self, target: WindowTarget, ) -> Result<Response, ClientError>

Sends a next-layout request over the detached RPC channel.

pub fn previous_layout( &mut self, target: WindowTarget, ) -> Result<Response, ClientError>

Sends a previous-layout request over the detached RPC channel.

impl Connection

pub fn roundtrip(&mut self, request: &Request) -> Result<Response, ClientError>

Sends a request and reads the server’s response.

Server-side Response::Error payloads are returned as-is in the Ok variant so callers can pattern-match on them. Only transport and framing failures produce Err.

impl Connection

pub fn begin_control_mode( self, mode: ControlMode, client_terminal: ClientTerminalContext, ) -> Result<ControlTransition, ClientError>

Requests a control-mode upgrade and, on success, yields the raw local stream for tmux-compatible text control traffic.

Trait Implementations

impl Debug for Connection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.