Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

feat(client): find and join shares, and keep slow viewers current

RoversXf8481e540617
diff --git a/Cargo.lock b/Cargo.lock
index 5b08b460..e6908924 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11822,6 +11822,7 @@ dependencies = [
"log",
"metrics",
"mux",
+ "nix 0.29.0",
"openssl",
"parking_lot",
"portable-pty",
diff --git a/wezterm-client/Cargo.toml b/wezterm-client/Cargo.toml
index b229c1ad..23870105 100644
--- a/wezterm-client/Cargo.toml
+++ b/wezterm-client/Cargo.toml
@@ -42,6 +42,9 @@ wezterm-uds.workspace = true
[dev-dependencies]
tempfile.workspace = true
+[target."cfg(unix)".dependencies]
+nix = { workspace = true, features = ["user"] }
+
[target."cfg(windows)".dependencies]
winapi = { workspace=true, features = [
"winbase",
diff --git a/wezterm-client/src/client.rs b/wezterm-client/src/client.rs
index 017bae84..fc95d76e 100644
--- a/wezterm-client/src/client.rs
+++ b/wezterm-client/src/client.rs
@@ -573,8 +573,26 @@ async fn process_unilateral_inner_async(
/// Where a client without a domain of its own -- the CLI -- sends what the
/// server pushes, once it has asked to hear it, and which of the pushes it
/// wants. See `tap_unilateral_pdus`.
-static UNILATERAL_TAP: std::sync::Mutex<Option<(Sender<Pdu>, fn(&Pdu) -> bool)>> =
- std::sync::Mutex::new(None);
+static UNILATERAL_TAP: std::sync::Mutex<Option<UnilateralSink>> = std::sync::Mutex::new(None);
+
+enum UnilateralSink {
+ Channel(Sender<Pdu>, fn(&Pdu) -> bool),
+ Share(crate::share_queue::Sender),
+}
+
+impl UnilateralSink {
+ fn send(&self, pdu: Pdu) -> anyhow::Result<()> {
+ match self {
+ Self::Channel(tap, wanted) => {
+ if wanted(&pdu) && tap.try_send(pdu).is_err() {
+ log::warn!("dropping a server push nobody is reading");
+ }
+ Ok(())
+ }
+ Self::Share(tap) => tap.send(pdu),
+ }
+ }
+}
/// Hand every PDU the server pushes to a client without a local domain
/// (the CLI's own connection) to the returned receiver, rather than drop
@@ -588,10 +606,47 @@ pub fn tap_unilateral_pdus(capacity: usize) -> Receiver<Pdu> {
/// however many, cannot crowd them out.
pub fn tap_unilateral_pdus_where(capacity: usize, wanted: fn(&Pdu) -> bool) -> Receiver<Pdu> {
let (tx, rx) = smol::channel::bounded(capacity);
- *UNILATERAL_TAP.lock().unwrap() = Some((tx, wanted));
+ *UNILATERAL_TAP.lock().unwrap() = Some(UnilateralSink::Channel(tx, wanted));
rx
}
+/// Share viewers may skip intermediate screen updates, but must always learn
+/// the current control state and why their watch ended.
+pub fn tap_share_updates() -> ShareUpdateTap {
+ let (sender, receiver) = crate::share_queue::channel();
+ *UNILATERAL_TAP.lock().unwrap() = Some(UnilateralSink::Share(sender));
+ ShareUpdateTap { receiver }
+}
+
+pub struct ShareUpdateTap {
+ receiver: crate::share_queue::Receiver,
+}
+
+impl ShareUpdateTap {
+ pub async fn recv(&self) -> Result<crate::share_queue::Update, smol::channel::RecvError> {
+ self.receiver.recv().await
+ }
+
+ pub fn try_recv(&self) -> Result<crate::share_queue::Update, smol::channel::TryRecvError> {
+ self.receiver.try_recv()
+ }
+
+ fn release(&self, installed: &mut Option<UnilateralSink>) {
+ self.receiver.close();
+ if installed.as_ref().is_some_and(
+ |tap| matches!(tap, UnilateralSink::Share(tap) if tap.same_channel(&self.receiver)),
+ ) {
+ *installed = None;
+ }
+ }
+}
+
+impl Drop for ShareUpdateTap {
+ fn drop(&mut self) {
+ self.release(&mut UNILATERAL_TAP.lock().unwrap());
+ }
+}
+
fn process_unilateral(
local_domain_id: Option<DomainId>,
connection_generation: u64,
@@ -603,11 +658,8 @@ fn process_unilateral(
None => {
// No panes to update here. A caller that asked for the
// server's pushes gets them; anyone else ignores them.
- if let Some((tap, wanted)) = UNILATERAL_TAP.lock().unwrap().as_ref() {
- if wanted(&decoded.pdu) && tap.try_send(decoded.pdu).is_err() {
- log::warn!("dropping a server push nobody is reading");
- }
- return Ok(());
+ if let Some(tap) = UNILATERAL_TAP.lock().unwrap().as_ref() {
+ return tap.send(decoded.pdu);
}
log::trace!(
"client doesn't have a real local domain, \
@@ -1073,6 +1125,7 @@ async fn client_thread_registered(
};
let mut stream = reconnectable.take_stream().unwrap();
+ let incoming_payload_limit = reconnectable.incoming_payload_limit;
// Application-level keepalive: a transport that died without an RST
// (VPN egress rotation, sleepy NAT) otherwise hangs silently until the
@@ -1182,16 +1235,31 @@ async fn client_thread_registered(
};
let read = with_progress(&bytes, IO_STALL_LIMIT, async {
if registration.is_complete() {
- return Pdu::decode_async(&mut counted, Some(next_serial))
- .await
- .map(Some);
+ return match incoming_payload_limit {
+ Some(limit) => {
+ Pdu::decode_async_bounded(&mut counted, Some(next_serial), limit)
+ .await
+ }
+ None => Pdu::decode_async(&mut counted, Some(next_serial)).await,
+ }
+ .map(Some);
}
- let deferred = DeferredPdu::read_async(
- &mut counted,
- Some(next_serial),
- REGISTRATION_BYTES.saturating_sub(deferred_bytes),
- )
- .await?;
+ let push_budget = REGISTRATION_BYTES.saturating_sub(deferred_bytes);
+ let deferred = match incoming_payload_limit {
+ Some(limit) => {
+ DeferredPdu::read_async_bounded(
+ &mut counted,
+ Some(next_serial),
+ push_budget,
+ limit,
+ )
+ .await?
+ }
+ None => {
+ DeferredPdu::read_async(&mut counted, Some(next_serial), push_budget)
+ .await?
+ }
+ };
if !deferred.is_push() {
return deferred.decode().map(Some);
}
@@ -1509,6 +1577,7 @@ struct Reconnectable {
config: ClientDomainConfig,
stream: Option<Box<dyn AsyncReadAndWrite>>,
tls_creds: Option<GetTlsCredsResponse>,
+ incoming_payload_limit: Option<usize>,
}
struct SshStream {
@@ -1573,6 +1642,7 @@ impl Reconnectable {
config,
stream,
tls_creds: None,
+ incoming_payload_limit: None,
}
}
@@ -2240,7 +2310,18 @@ impl Client {
&abort_rx,
) {
*reader_abort.lock().unwrap() = None;
- log::warn!(
+ // A client let go of on purpose ends so: nothing to warn
+ // of, however often a command asks and lets go.
+ let let_go = matches!(
+ e.root_cause().downcast_ref::<NotReconnectableError>(),
+ Some(NotReconnectableError::ClientWasDestroyed)
+ );
+ log::log!(
+ if let_go {
+ log::Level::Debug
+ } else {
+ log::Level::Warn
+ },
"mux connection generation {generation} ended in {:?}: {e:#}",
ClientConnectionPhase::from_u8(
reader_connection_phase.load(Ordering::Acquire)
@@ -2782,6 +2863,37 @@ impl Client {
Ok(Self::new(local_domain_id, reconnectable))
}
+ /// A client on a socket the caller has connected to `unix_dom`'s
+ /// server, for one it does not reconnect to: a server it only asks
+ /// things of, or watches until it is gone.
+ pub fn new_unix_stream(unix_dom: &UnixDomain, stream: UnixStream) -> anyhow::Result<Self> {
+ Self::new_unix_stream_with_limit(unix_dom, stream, None)
+ }
+
+ /// A socket owned by another account gets a limit before even the
+ /// version handshake is read; ordinary mux connections keep theirs.
+ pub fn new_unix_stream_bounded(
+ unix_dom: &UnixDomain,
+ stream: UnixStream,
+ payload_limit: usize,
+ ) -> anyhow::Result<Self> {
+ Self::new_unix_stream_with_limit(unix_dom, stream, Some(payload_limit))
+ }
+
+ fn new_unix_stream_with_limit(
+ unix_dom: &UnixDomain,
+ stream: UnixStream,
+ payload_limit: Option<usize>,
+ ) -> anyhow::Result<Self> {
+ stream.set_read_timeout(Some(unix_dom.read_timeout))?;
+ stream.set_write_timeout(Some(unix_dom.write_timeout))?;
+ let stream: Box<dyn AsyncReadAndWrite> = Box::new(Async::new(stream)?);
+ let mut reconnectable =
+ Reconnectable::new(ClientDomainConfig::Unix(unix_dom.clone()), Some(stream));
+ reconnectable.incoming_payload_limit = payload_limit;
+ Ok(Self::new(None, reconnectable))
+ }
+
pub fn new_tls(
local_domain_id: DomainId,
tls_client: &TlsDomainClient,
@@ -2984,6 +3096,23 @@ impl Client {
rpc!(web_token_mint, WebTokenMint, WebTokenMintResponse);
rpc!(web_token_list, WebTokenList = (), WebTokenListResponse);
rpc!(web_token_revoke, WebTokenRevoke, WebTokenRevokeResponse);
+ rpc!(share_start, ShareStart, ShareListResponse);
+ rpc!(share_list, ShareList = (), ShareListResponse);
+ rpc!(share_stop, ShareStop, UnitResponse);
+ rpc!(share_kick, ShareKick, UnitResponse);
+ rpc!(share_grant, ShareGrant, UnitResponse);
+ rpc!(share_revoke, ShareRevoke, UnitResponse);
+ rpc!(share_deny, ShareDeny, UnitResponse);
+ rpc!(
+ share_candidates,
+ ShareCandidates = (),
+ ShareCandidatesResponse
+ );
+ rpc!(share_incoming, ShareIncoming = (), ShareIncomingResponse);
+ rpc!(share_discover, ShareDiscover = (), ShareDiscoverResponse);
+ rpc!(share_join, ShareJoin, ShareJoinResponse);
+ rpc!(share_request_control, ShareRequestControl, UnitResponse);
+ rpc!(share_release_control, ShareReleaseControl, UnitResponse);
rpc!(
get_web_server_status,
GetWebServerStatus = (),
@@ -3043,6 +3172,56 @@ mod tests {
use crate::domain::ClientDomainConfig;
use std::time::{Duration, Instant};
+ #[test]
+ fn releasing_a_share_tap_drops_payloads_without_removing_its_replacement() {
+ use super::{ShareUpdateTap, UnilateralSink};
+ use codec::{Pdu, ShareStateChanged};
+
+ for replaced in [false, true] {
+ let (sender, receiver) = crate::share_queue::channel();
+ sender
+ .send(Pdu::ShareStateChanged(ShareStateChanged {
+ share_id: 1,
+ controlling: true,
+ requested: false,
+ controller: None,
+ ended: None,
+ }))
+ .unwrap();
+ let (replacement, next) = crate::share_queue::channel();
+ let mut installed = Some(UnilateralSink::Share(if replaced {
+ replacement
+ } else {
+ sender
+ }));
+ let tap = ShareUpdateTap { receiver };
+ tap.release(&mut installed);
+ assert!(matches!(
+ tap.try_recv(),
+ Err(smol::channel::TryRecvError::Closed)
+ ));
+ if replaced {
+ installed
+ .as_ref()
+ .unwrap()
+ .send(Pdu::ShareStateChanged(ShareStateChanged {
+ share_id: 1,
+ controlling: false,
+ requested: false,
+ controller: None,
+ ended: Some("stopped".into()),
+ }))
+ .unwrap();
+ assert!(matches!(
+ next.try_recv(),
+ Ok(crate::share_queue::Update::Ended(reason)) if reason == "stopped"
+ ));
+ } else {
+ assert!(installed.is_none());
+ }
+ }
+ }
+
#[test]
fn a_tls_address_splits_into_host_and_port() {
assert_eq!(split_host_port("server-a:8080"), Some(("server-a", 8080)));
@@ -3270,6 +3449,112 @@ mod connection_regression_tests {
.await
}
+ #[test]
+ fn a_bounded_connection_limits_replies_and_pushes_before_and_after_registration() {
+ block_on(async {
+ for registered in [false, true] {
+ for push in [false, true] {
+ for link in [codec::Link::SameMachine, codec::Link::Network] {
+ let (mut connection, mut peer) = pair();
+ connection.incoming_payload_limit = Some(1024);
+ let (sender, mut receiver) = unbounded();
+ if registered {
+ sender
+ .try_send(ReaderMessage::RegistrationComplete {
+ connection_generation: 1,
+ })
+ .unwrap();
+ }
+ let (promise, _reply) = bounded(1);
+ sender
+ .try_send(ReaderMessage::SendPdu {
+ pdu: Pdu::Ping(Ping {}),
+ promise,
+ registration_required: false,
+ })
+ .unwrap();
+ let result = within(smol::future::or(
+ client_thread_async(&mut connection, None, 1, &mut receiver),
+ async {
+ let request = Pdu::decode_async(&mut peer, None).await.unwrap();
+ Pdu::WindowTitleChanged(WindowTitleChanged {
+ window_id: 0,
+ title: "x".repeat(8192),
+ })
+ .encode_async_over(
+ &mut peer,
+ if push { 0 } else { request.serial },
+ link,
+ )
+ .await
+ .unwrap();
+ std::future::pending().await
+ },
+ ))
+ .await;
+ assert!(
+ format!("{:#}", result.unwrap_err())
+ .contains("more than this connection takes"),
+ "registered={}, push={}, link={:?}",
+ registered,
+ push,
+ link
+ );
+ }
+ }
+ }
+ });
+ }
+
+ #[test]
+ fn bounded_clients_keep_small_replies_and_ordinary_clients_keep_larger_ones() {
+ block_on(async {
+ for registered in [false, true] {
+ for (limit, bytes) in [(Some(1024), 200), (None, 8192)] {
+ for link in [codec::Link::SameMachine, codec::Link::Network] {
+ let (mut connection, mut peer) = pair();
+ assert_eq!(connection.incoming_payload_limit, None);
+ connection.incoming_payload_limit = limit;
+ let (sender, mut receiver) = unbounded();
+ if registered {
+ sender
+ .try_send(ReaderMessage::RegistrationComplete {
+ connection_generation: 1,
+ })
+ .unwrap();
+ }
+ let (promise, reply) = bounded(1);
+ sender
+ .try_send(ReaderMessage::SendPdu {
+ pdu: Pdu::Ping(Ping {}),
+ promise,
+ registration_required: false,
+ })
+ .unwrap();
+ let reader = async {
+ let result =
+ client_thread_async(&mut connection, None, 1, &mut receiver).await;
+ panic!("connection ended: {:?}", result);
+ };
+ let server = async {
+ let request = Pdu::decode_async(&mut peer, None).await.unwrap();
+ let response = Pdu::WindowTitleChanged(WindowTitleChanged {
+ window_id: 0,
+ title: "x".repeat(bytes),
+ });
+ response
+ .encode_async_over(&mut peer, request.serial, link)
+ .await
+ .unwrap();
+ assert_eq!(reply.recv().await.unwrap().unwrap(), response);
+ };
+ within(smol::future::or(reader, server)).await;
+ }
+ }
+ }
+ });
+ }
+
#[test]
fn retaining_a_refused_client_does_not_retain_its_connection() {
block_on(async {
diff --git a/wezterm-client/src/lib.rs b/wezterm-client/src/lib.rs
index 9dcca869..daca0d5b 100644
--- a/wezterm-client/src/lib.rs
+++ b/wezterm-client/src/lib.rs
@@ -5,3 +5,5 @@ pub mod domain;
pub mod local_update;
pub mod pane;
pub mod remote_update;
+pub mod share;
+pub mod share_queue;
diff --git a/wezterm-client/src/share.rs b/wezterm-client/src/share.rs
new file mode 100644
index 00000000..01e230bf
--- /dev/null
+++ b/wezterm-client/src/share.rs
@@ -0,0 +1,224 @@
+//! Finding the panes other accounts on this machine share with this one.
+//!
+//! Each account that shares listens on its own socket,
+//! `/tmp/thinkterm-share-<uid>/share.sock` (`codec::share_socket_dir`), and
+//! answers there, for whoever connects, with the shares meant for them: it
+//! reads who connected from the socket. A socket is believed to be an
+//! account's only when the directory it is in belongs to that account and
+//! nobody else may write to it.
+
+use crate::client::Client;
+use anyhow::{anyhow, Context as _};
+use codec::ShareIncomingResponse;
+use config::UnixDomain;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+use wezterm_uds::UnixStream;
+
+/// An account that shares panes from this machine, by its share socket.
+#[derive(Debug, Clone)]
+pub struct Owner {
+ pub uid: u32,
+ pub socket: PathBuf,
+}
+
+/// At most this many entries of `/tmp` are looked at for share sockets.
+const MAX_TMP_ENTRIES: usize = 65536;
+
+/// How long one account's server gets to answer before it is passed over.
+pub const ANSWER_WITHIN: Duration = Duration::from_secs(3);
+
+/// A reply or push from another account, before and after decompression.
+pub const MAX_RESPONSE_BYTES: usize = 4 * 1024 * 1024;
+
+/// The accounts sharing panes on this machine: the share directories in
+/// `/tmp` that belong to the account they are named for and nobody else
+/// can write to, with a socket in them.
+pub fn owners() -> Vec<Owner> {
+ owners_in(Path::new("/tmp"))
+}
+
+fn owners_in(root: &Path) -> Vec<Owner> {
+ let Ok(entries) = std::fs::read_dir(root) else {
+ return vec![];
+ };
+ let mut owners: Vec<Owner> = entries
+ .take(MAX_TMP_ENTRIES)
+ .flatten()
+ .filter_map(|entry| {
+ let name = entry.file_name();
+ let uid = name
+ .to_str()?
+ .strip_prefix(codec::SHARE_SOCKET_DIR_PREFIX)?
+ .parse::<u32>()
+ .ok()?;
+ let dir = root.join(format!("{}{uid}", codec::SHARE_SOCKET_DIR_PREFIX));
+ // An alias entry must not send us to another entry's directory.
+ if entry.path() != dir {
+ return None;
+ }
+ let socket = dir.join(codec::SHARE_SOCKET_NAME);
+ (trusted_dir(&dir, uid) && socket.exists()).then_some(Owner { uid, socket })
+ })
+ .collect();
+ owners.sort_by_key(|owner| owner.uid);
+ owners
+}
+
+#[cfg(unix)]
+fn trusted_dir(dir: &Path, uid: u32) -> bool {
+ use std::os::unix::fs::MetadataExt as _;
+ std::fs::symlink_metadata(dir).is_ok_and(|meta| {
+ meta.file_type().is_dir() && meta.uid() == uid && meta.mode() & 0o022 == 0
+ })
+}
+
+#[cfg(not(unix))]
+fn trusted_dir(_dir: &Path, _uid: u32) -> bool {
+ false
+}
+
+/// `work`, or an error once `limit` has passed without an answer.
+pub async fn within<T>(
+ limit: Duration,
+ work: impl std::future::Future<Output = anyhow::Result<T>>,
+) -> anyhow::Result<T> {
+ smol::future::or(work, async {
+ smol::Timer::after(limit).await;
+ Err(anyhow!("no answer within {limit:?}"))
+ })
+ .await
+}
+
+/// A connection to `owner`'s share socket, past the version handshake. A
+/// socket with no room for another connection is passed over at once: a
+/// server that has stopped accepting never makes room, no deadline cuts
+/// that wait short, and the accounts after it wait their turn.
+pub async fn connect(owner: &Owner) -> anyhow::Result<Client> {
+ let domain = UnixDomain {
+ name: format!("share-{}", owner.uid),
+ socket_path: Some(owner.socket.clone()),
+ no_serve_automatically: true,
+ // Not ours: `owners` has checked who the directory belongs to.
+ skip_permissions_check: true,
+ ..Default::default()
+ };
+ let stream = UnixStream::connect_without_waiting(&owner.socket)
+ .with_context(|| format!("connecting to {}", owner.socket.display()))?;
+ let client = Client::new_unix_stream_bounded(&domain, stream, MAX_RESPONSE_BYTES)?;
+ let ui = mux::connui::ConnectionUI::new_headless();
+ within(ANSWER_WITHIN, client.verify_version_compat(&ui))
+ .await
+ .context("the other account's ThinkTerm did not answer as this version does")?;
+ Ok(client)
+}
+
+/// The name this machine gives `uid`, which is what a sharing account is
+/// called here: not the name its server gives itself, which any account
+/// could make up.
+#[cfg(unix)]
+pub fn account_name(uid: u32) -> String {
+ match nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid)) {
+ Ok(Some(user)) => user.name,
+ _ => format!("uid{uid}"),
+ }
+}
+
+#[cfg(not(unix))]
+pub fn account_name(uid: u32) -> String {
+ format!("uid{uid}")
+}
+
+/// What asking every account came to.
+#[derive(Default)]
+pub struct Incoming {
+ /// Each account that shares panes with this one, with its shares.
+ pub found: Vec<(Owner, ShareIncomingResponse)>,
+ /// The accounts whose ThinkTerm is another version: what they share
+ /// cannot be read from this one.
+ pub other_version: Vec<String>,
+}
+
+/// Every account's shares for this one, asked one account at a time. An
+/// account whose server does not answer, or answers with nothing for us,
+/// is left out; one that runs another version is named.
+pub async fn incoming() -> Incoming {
+ let mut incoming = Incoming::default();
+ for owner in owners() {
+ let answer = async {
+ let client = connect(&owner).await?;
+ within(ANSWER_WITHIN, client.share_incoming()).await
+ };
+ match answer.await {
+ Ok(mut response) if !response.shares.is_empty() => {
+ response.owner = account_name(owner.uid);
+ incoming.found.push((owner, response));
+ }
+ Ok(_) => {}
+ Err(err) if is_other_version(&err) => {
+ incoming.other_version.push(account_name(owner.uid));
+ }
+ Err(err) => log::debug!("uid {}: {err:#}", owner.uid),
+ }
+ }
+ incoming
+}
+
+fn is_other_version(err: &anyhow::Error) -> bool {
+ err.chain()
+ .any(|cause| cause.is::<crate::client::IncompatibleVersionError>())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use anyhow::Context as _;
+
+ #[cfg(unix)]
+ #[test]
+ fn aliases_do_not_repeat_a_sharing_account() {
+ use std::os::unix::fs::{MetadataExt as _, PermissionsExt as _};
+ let root = tempfile::tempdir().unwrap();
+ let uid = std::fs::metadata(root.path()).unwrap().uid();
+ let name = format!("{}{uid}", codec::SHARE_SOCKET_DIR_PREFIX);
+ let dir = root.path().join(&name);
+ std::fs::create_dir(&dir).unwrap();
+ std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o711)).unwrap();
+ std::fs::write(dir.join(codec::SHARE_SOCKET_NAME), []).unwrap();
+ assert_eq!(owners_in(root.path()).len(), 1);
+
+ for suffix in [format!("0{uid}"), format!("+{uid}"), format!("+00{uid}")] {
+ let alias = root
+ .path()
+ .join(format!("{}{suffix}", codec::SHARE_SOCKET_DIR_PREFIX));
+ std::fs::write(alias, []).unwrap();
+ }
+ let found = owners_in(root.path());
+ assert_eq!(found.len(), 1);
+ assert_eq!(found[0].uid, uid);
+ assert_eq!(found[0].socket, dir.join(codec::SHARE_SOCKET_NAME));
+
+ std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o777)).unwrap();
+ assert!(owners_in(root.path()).is_empty());
+
+ let moved = root.path().join("original");
+ std::fs::rename(&dir, &moved).unwrap();
+ std::fs::set_permissions(&moved, std::fs::Permissions::from_mode(0o711)).unwrap();
+ std::os::unix::fs::symlink(&moved, &dir).unwrap();
+ assert!(owners_in(root.path()).is_empty());
+ }
+
+ #[test]
+ fn another_version_is_told_from_other_failures() {
+ let refused: anyhow::Result<()> = Err(crate::client::IncompatibleVersionError {
+ version: "older".into(),
+ codec_vers: 1,
+ }
+ .into());
+ let err = refused
+ .context("the other account's ThinkTerm did not answer as this version does")
+ .unwrap_err();
+ assert!(is_other_version(&err));
+ assert!(!is_other_version(&anyhow!("no answer within 3s")));
+ }
+}
diff --git a/wezterm-client/src/share_queue.rs b/wezterm-client/src/share_queue.rs
new file mode 100644
index 00000000..8976782c
--- /dev/null
+++ b/wezterm-client/src/share_queue.rs
@@ -0,0 +1,567 @@
+//! A slow share viewer keeps the latest screen update and control state.
+
+use codec::{GetPaneRenderChangesResponse, Pdu, ShareStateChanged};
+use smol::channel::{RecvError, TryRecvError};
+use std::collections::BTreeMap;
+use std::ops::Range;
+use std::sync::{Arc, Mutex};
+use wezterm_term::{Line, StableRowIndex};
+
+/// Rows that skipped updates brought, kept for a viewer that fell behind;
+/// past this, the furthest back count as changed instead.
+const CARRIED_ROWS: usize = 1000;
+/// Separate runs of changed rows kept; past this, one run spans them all.
+const CHANGED_RUNS: usize = 64;
+
+pub struct RenderUpdate {
+ pub changes: Box<GetPaneRenderChangesResponse>,
+ /// Rows that updates merged into this one brought and it does not:
+ /// they go in after its dirty rows go, before its bonus rows.
+ pub carried: BTreeMap<StableRowIndex, Line>,
+ pub screen_changed: bool,
+ pub generation: u64,
+}
+
+impl RenderUpdate {
+ pub fn new(changes: GetPaneRenderChangesResponse, generation: u64) -> anyhow::Result<Self> {
+ anyhow::ensure!(
+ changes.dimensions.is_plausible(),
+ "the share sent invalid terminal dimensions"
+ );
+ Ok(Self {
+ changes: Box::new(changes),
+ carried: BTreeMap::new(),
+ screen_changed: false,
+ generation,
+ })
+ }
+
+ /// Keep the newer payload as if the server had sent both as one: rows
+ /// only this one brought are carried, rows it changed without bringing
+ /// stay changed, and the rows between are left alone.
+ pub fn merge(&mut self, mut newer: Self) {
+ if newer.screen_changed || self.changes.alt_screen != newer.changes.alt_screen {
+ // The other screen numbers its rows afresh: nothing said of
+ // this one's rows holds there.
+ newer.screen_changed = true;
+ *self = newer;
+ return;
+ }
+ newer.screen_changed = self.screen_changed;
+ let (brought, _) = std::mem::take(&mut self.changes.bonus_lines).extract_data();
+ let mut carried = std::mem::take(&mut self.carried);
+ carried.extend(brought);
+ // What the newer one brings or changed is newer than these.
+ for row in newer.changes.bonus_lines.rows() {
+ carried.remove(&row);
+ }
+ for range in &newer.changes.dirty_lines {
+ if carried.is_empty() {
+ break;
+ }
+ if range.is_empty() {
+ continue;
+ }
+ let stale: Vec<_> = carried.range(range.clone()).map(|(row, _)| *row).collect();
+ for row in stale {
+ carried.remove(&row);
+ }
+ }
+ carried.append(&mut newer.carried);
+ let mut changed = std::mem::take(&mut self.changes.dirty_lines);
+ while carried.len() > CARRIED_ROWS {
+ if let Some((row, _)) = carried.pop_first() {
+ changed.push(row..row.saturating_add(1));
+ }
+ }
+ changed.append(&mut newer.changes.dirty_lines);
+ newer.changes.dirty_lines = runs(changed);
+ newer.carried = carried;
+ *self = newer;
+ }
+}
+
+/// `ranges` in order, with overlapping and touching ones joined and empty
+/// ones gone; more than `CHANGED_RUNS` become one from first to last.
+fn runs(mut ranges: Vec<Range<StableRowIndex>>) -> Vec<Range<StableRowIndex>> {
+ ranges.retain(|range| range.start < range.end);
+ ranges.sort_unstable_by_key(|range| range.start);
+ let mut runs: Vec<Range<StableRowIndex>> = Vec::with_capacity(ranges.len());
+ for range in ranges {
+ match runs.last_mut() {
+ Some(last) if range.start <= last.end => last.end = last.end.max(range.end),
+ _ => runs.push(range),
+ }
+ }
+ if runs.len() > CHANGED_RUNS {
+ let span = runs[0].start..runs[runs.len() - 1].end;
+ runs = vec![span];
+ }
+ runs
+}
+
+pub enum Update {
+ Render(RenderUpdate),
+ State(ShareStateChanged),
+ Ended(String),
+}
+
+#[derive(Default)]
+struct Pending {
+ render: Option<RenderUpdate>,
+ state: Option<ShareStateChanged>,
+ ended: Option<String>,
+ terminal: bool,
+ closed: bool,
+ generation: u64,
+}
+
+impl Pending {
+ fn end(&mut self, reason: String) {
+ if !self.terminal {
+ self.render = None;
+ self.state = None;
+ self.ended = Some(reason);
+ self.terminal = true;
+ }
+ }
+
+ fn take(&mut self) -> Option<Update> {
+ if let Some(reason) = self.ended.take() {
+ return Some(Update::Ended(reason));
+ }
+ if let Some(state) = self.state.take() {
+ return Some(Update::State(state));
+ }
+ self.render.take().map(Update::Render)
+ }
+}
+
+pub(crate) struct Sender {
+ pending: Arc<Mutex<Pending>>,
+ wake: smol::channel::Sender<()>,
+}
+
+pub(crate) struct Receiver {
+ pending: Arc<Mutex<Pending>>,
+ wake: smol::channel::Receiver<()>,
+}
+
+pub(crate) fn channel() -> (Sender, Receiver) {
+ let (wake_tx, wake_rx) = smol::channel::bounded(1);
+ let pending = Arc::new(Mutex::new(Pending::default()));
+ (
+ Sender {
+ pending: Arc::clone(&pending),
+ wake: wake_tx,
+ },
+ Receiver {
+ pending,
+ wake: wake_rx,
+ },
+ )
+}
+
+impl Sender {
+ pub(crate) fn same_channel(&self, receiver: &Receiver) -> bool {
+ Arc::ptr_eq(&self.pending, &receiver.pending)
+ }
+
+ pub(crate) fn send(&self, pdu: Pdu) -> anyhow::Result<()> {
+ let mut pending = self.pending.lock().unwrap();
+ anyhow::ensure!(!pending.closed, "the viewer closed");
+ if pending.terminal {
+ return Ok(());
+ }
+ let result = match pdu {
+ Pdu::GetPaneRenderChangesResponse(changes) => {
+ let generation = pending.generation.checked_add(1);
+ match generation {
+ Some(generation) => {
+ pending.generation = generation;
+ match RenderUpdate::new(changes, generation) {
+ Ok(update) => match pending.render.as_mut() {
+ Some(previous) => previous.merge(update),
+ None => pending.render = Some(update),
+ },
+ Err(err) => {
+ pending.end(err.to_string());
+ self.wake.close();
+ return Err(err);
+ }
+ }
+ Ok(())
+ }
+ None => {
+ pending.end("the share sent too many screen updates".into());
+ self.wake.close();
+ anyhow::bail!("the share sent too many screen updates")
+ }
+ }
+ }
+ Pdu::ShareStateChanged(mut state) => {
+ if let Some(reason) = state.ended.take() {
+ pending.end(reason);
+ } else {
+ pending.state = Some(state);
+ }
+ Ok(())
+ }
+ Pdu::PaneRemoved(_) | Pdu::PaneExited(_) => {
+ pending.end(codec::share_end::CLOSED.into());
+ Ok(())
+ }
+ _ => return Ok(()),
+ };
+ if pending.terminal {
+ self.wake.close();
+ } else {
+ // A wake carries no payload and never blocks the network reader.
+ let _ = self.wake.try_send(());
+ }
+ result
+ }
+}
+
+impl Receiver {
+ #[cfg(test)]
+ pub(crate) fn generation(&self) -> u64 {
+ self.pending.lock().unwrap().generation
+ }
+
+ pub(crate) fn try_recv(&self) -> Result<Update, TryRecvError> {
+ let mut pending = self.pending.lock().unwrap();
+ if let Some(update) = pending.take() {
+ return Ok(update);
+ }
+ if pending.closed || pending.terminal || self.wake.is_closed() {
+ Err(TryRecvError::Closed)
+ } else {
+ Err(TryRecvError::Empty)
+ }
+ }
+
+ pub(crate) async fn recv(&self) -> Result<Update, RecvError> {
+ loop {
+ match self.try_recv() {
+ Ok(update) => return Ok(update),
+ Err(TryRecvError::Closed) => return Err(RecvError),
+ Err(TryRecvError::Empty) => {}
+ }
+ // After a close, inspect the slots once more for the final reason.
+ let _ = self.wake.recv().await;
+ }
+ }
+
+ pub(crate) fn close(&self) {
+ let mut pending = self.pending.lock().unwrap();
+ pending.closed = true;
+ pending.render = None;
+ pending.state = None;
+ pending.ended = None;
+ self.wake.close();
+ }
+}
+
+impl Drop for Receiver {
+ fn drop(&mut self) {
+ self.close();
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use mux::renderable::{RenderableDimensions, StableCursorPosition};
+ use wezterm_term::Line;
+
+ fn changes(alt_screen: bool, row: StableRowIndex) -> GetPaneRenderChangesResponse {
+ GetPaneRenderChangesResponse {
+ pane_id: 1,
+ mouse_grabbed: false,
+ alt_screen,
+ keyboard_encoding: Default::default(),
+ cursor_position: StableCursorPosition::default(),
+ dimensions: RenderableDimensions {
+ cols: 80,
+ viewport_rows: 24,
+ ..Default::default()
+ },
+ dirty_lines: vec![],
+ title: row.to_string(),
+ bonus_lines: vec![(row, Line::from_text("screen", &Default::default(), 0, None))]
+ .into(),
+ working_dir: None,
+ input_serial: None,
+ seqno: 0,
+ }
+ }
+
+ fn state(controlling: bool, ended: Option<&str>) -> Pdu {
+ Pdu::ShareStateChanged(ShareStateChanged {
+ share_id: 1,
+ controlling,
+ requested: false,
+ controller: None,
+ ended: ended.map(str::to_string),
+ })
+ }
+
+ async fn send_over_wire(sender: &Sender, pdu: Pdu) {
+ let mut bytes = Vec::new();
+ pdu.encode(&mut bytes, 0).unwrap();
+ let length = bytes.len() as u64;
+ let mut reader = futures::io::Cursor::new(bytes);
+ let decoded =
+ Pdu::decode_async_bounded(&mut reader, Some(1), crate::share::MAX_RESPONSE_BYTES)
+ .await
+ .unwrap();
+ assert_eq!(decoded.serial, 0);
+ assert_eq!(reader.position(), length);
+ sender.send(decoded.pdu).unwrap();
+ }
+
+ #[test]
+ #[allow(clippy::single_range_in_vec_init)]
+ fn decoded_output_bursts_preserve_the_latest_screen_revoke_and_end() {
+ smol::block_on(async {
+ let (sender, receiver) = channel();
+ send_over_wire(&sender, state(true, None)).await;
+ for row in 0..4096 {
+ let mut update = changes((1024..2048).contains(&row), row);
+ update.dimensions.physical_top = row.saturating_sub(23).max(0);
+ update.cursor_position.y = row;
+ update.dirty_lines = vec![row - 1..row];
+ send_over_wire(&sender, Pdu::GetPaneRenderChangesResponse(update)).await;
+ }
+ send_over_wire(&sender, state(false, None)).await;
+
+ assert_eq!(receiver.generation(), 4096);
+ assert_eq!(sender.wake.len(), 1);
+ assert!(!sender.wake.is_closed());
+ assert!(matches!(
+ receiver.try_recv(),
+ Ok(Update::State(state)) if !state.controlling
+ ));
+ let Ok(Update::Render(update)) = receiver.try_recv() else {
+ panic!("expected the latest decoded screen");
+ };
+ assert_eq!(update.changes.title, "4095");
+ assert_eq!(update.changes.dimensions.physical_top, 4072);
+ // Each row was changed by the next update; those before the last
+ // trip to the other screen are gone with it.
+ assert_eq!(update.changes.dirty_lines, vec![2047..4095]);
+ assert!(update.carried.is_empty());
+ assert!(update.screen_changed);
+ let (rows, _) = update.changes.bonus_lines.extract_data();
+ assert_eq!(rows.len(), 1);
+ assert_eq!(rows[0].0, 4095);
+ assert_eq!(rows[0].1.as_str(), "screen");
+
+ send_over_wire(
+ &sender,
+ Pdu::GetPaneRenderChangesResponse(changes(false, 4096)),
+ )
+ .await;
+ send_over_wire(&sender, state(false, Some(codec::share_end::STOPPED))).await;
+ send_over_wire(&sender, state(true, None)).await;
+ send_over_wire(
+ &sender,
+ Pdu::GetPaneRenderChangesResponse(changes(false, 4097)),
+ )
+ .await;
+
+ {
+ let pending = sender.pending.lock().unwrap();
+ assert!(pending.render.is_none());
+ assert!(pending.state.is_none());
+ }
+ assert!(matches!(
+ receiver.recv().await,
+ Ok(Update::Ended(reason)) if reason == codec::share_end::STOPPED
+ ));
+ assert!(matches!(receiver.try_recv(), Err(TryRecvError::Closed)));
+ });
+ }
+
+ #[test]
+ #[allow(clippy::single_range_in_vec_init)]
+ fn thousands_of_updates_keep_one_payload_and_the_latest_control_state() {
+ let (sender, receiver) = channel();
+ for row in 0..5000 {
+ sender
+ .send(Pdu::GetPaneRenderChangesResponse(changes(false, row)))
+ .unwrap();
+ sender.send(state(row % 2 == 0, None)).unwrap();
+ }
+ let pending = sender.pending.lock().unwrap();
+ assert!(pending.render.is_some());
+ assert!(pending.state.is_some());
+ assert!(pending.ended.is_none());
+ assert_eq!(sender.wake.len(), 1);
+ drop(pending);
+ assert_eq!(receiver.generation(), 5000);
+ assert!(matches!(receiver.try_recv(), Ok(Update::State(state)) if !state.controlling));
+ let Ok(Update::Render(update)) = receiver.try_recv() else {
+ panic!("expected the latest screen");
+ };
+ assert_eq!(update.changes.title, "4999");
+ // The rows they brought, as many as are kept; those further back
+ // count as changed.
+ assert_eq!(update.carried.len(), CARRIED_ROWS);
+ assert_eq!(update.carried.keys().next(), Some(&3999));
+ assert_eq!(update.carried[&4998].as_str(), "screen");
+ assert_eq!(update.changes.dirty_lines, vec![0..3999]);
+ assert_eq!(update.generation, 5000);
+ assert!(matches!(receiver.try_recv(), Err(TryRecvError::Empty)));
+ }
+
+ #[test]
+ #[allow(clippy::reversed_empty_ranges, clippy::single_range_in_vec_init)]
+ fn merging_keeps_changed_runs_and_carried_rows_without_overflow() {
+ let mut first = changes(false, StableRowIndex::MAX);
+ first.dirty_lines = vec![StableRowIndex::MIN..-4, 10..10, 30..20];
+ let mut update = RenderUpdate::new(first, 1).unwrap();
+ let mut newer = changes(false, 7);
+ newer.dirty_lines = vec![-3..10];
+ update.merge(RenderUpdate::new(newer, 2).unwrap());
+ assert_eq!(
+ update.changes.dirty_lines,
+ vec![StableRowIndex::MIN..-4, -3..10]
+ );
+ assert_eq!(
+ update.carried.keys().copied().collect::<Vec<_>>(),
+ vec![StableRowIndex::MAX]
+ );
+ assert_eq!(
+ update.changes.bonus_lines.rows().collect::<Vec<_>>(),
+ vec![7]
+ );
+ assert_eq!(update.generation, 2);
+
+ // Too many separate runs become one.
+ let runs = CHANGED_RUNS as StableRowIndex + 1;
+ let mut sparse = changes(false, 0);
+ sparse.dirty_lines = (0..runs).map(|run| run * 2..run * 2 + 1).collect();
+ let mut update = RenderUpdate::new(sparse, 3).unwrap();
+ update.merge(RenderUpdate::new(changes(false, 1000), 4).unwrap());
+ assert_eq!(update.changes.dirty_lines, vec![0..runs * 2 - 1]);
+ }
+
+ fn line(text: &str) -> Line {
+ Line::from_text(text, &Default::default(), 0, None)
+ }
+
+ #[test]
+ fn rows_between_those_skipped_updates_changed_are_left_alone() {
+ // A clock on the top row and the cursor's row at the bottom.
+ let screen = |generation: u64, clock: &str| {
+ let mut update = changes(false, 0);
+ update.bonus_lines = vec![(0, line(clock)), (23, line("$ "))].into();
+ RenderUpdate::new(update, generation).unwrap()
+ };
+ let mut update = screen(1, "12:00:01");
+ for generation in 2..6 {
+ update.merge(screen(generation, "12:00:02"));
+ }
+ assert!(update.changes.dirty_lines.is_empty());
+ assert!(update.carried.is_empty());
+ }
+
+ #[test]
+ #[allow(clippy::single_range_in_vec_init)]
+ fn rows_skipped_updates_brought_are_kept_until_changed() {
+ let screen = |generation: u64, top: StableRowIndex, row: StableRowIndex, text: &str| {
+ let mut update = changes(false, 0);
+ update.dimensions.physical_top = top;
+ update.bonus_lines = vec![(row, line(text))].into();
+ RenderUpdate::new(update, generation).unwrap()
+ };
+ // The cursor at the top, at the bottom, and then the screen moves
+ // on a row: the top row is history now, and was seen.
+ let mut update = screen(1, 100, 100, "seen");
+ update.merge(screen(2, 100, 123, "$ "));
+ update.merge(screen(3, 101, 124, "new"));
+ assert!(update.changes.dirty_lines.is_empty());
+ assert_eq!(
+ update.carried.keys().copied().collect::<Vec<_>>(),
+ vec![100, 123]
+ );
+ assert_eq!(update.carried[&100].as_str(), "seen");
+
+ let mut changed = screen(4, 101, 125, "later");
+ changed.changes.dirty_lines = vec![100..101];
+ update.merge(changed);
+ assert_eq!(
+ update.carried.keys().copied().collect::<Vec<_>>(),
+ vec![123, 124]
+ );
+ assert_eq!(update.changes.dirty_lines, vec![100..101]);
+ }
+
+ #[test]
+ fn a_round_trip_through_the_other_screen_stays_recorded() {
+ let mut update = RenderUpdate::new(changes(false, 1), 1).unwrap();
+ update.merge(RenderUpdate::new(changes(true, 0), 2).unwrap());
+ update.merge(RenderUpdate::new(changes(false, 1), 3).unwrap());
+ assert!(!update.changes.alt_screen);
+ assert!(update.screen_changed);
+ }
+
+ #[test]
+ fn an_end_dominates_queued_and_later_screen_and_control_updates() {
+ let (sender, receiver) = channel();
+ sender
+ .send(Pdu::GetPaneRenderChangesResponse(changes(false, 1)))
+ .unwrap();
+ sender.send(state(true, None)).unwrap();
+ sender.send(state(false, Some("removed"))).unwrap();
+ sender.send(state(true, None)).unwrap();
+ sender
+ .send(Pdu::GetPaneRenderChangesResponse(changes(false, 2)))
+ .unwrap();
+ assert!(matches!(receiver.try_recv(), Ok(Update::Ended(reason)) if reason == "removed"));
+ assert!(matches!(receiver.try_recv(), Err(TryRecvError::Closed)));
+ let pending = sender.pending.lock().unwrap();
+ assert!(pending.render.is_none());
+ assert!(pending.state.is_none());
+ }
+
+ #[test]
+ fn a_bad_frame_cannot_be_erased_by_a_later_valid_frame() {
+ let (sender, receiver) = channel();
+ let mut bad = changes(false, 1);
+ bad.dimensions.viewport_rows = usize::MAX;
+ assert!(sender.send(Pdu::GetPaneRenderChangesResponse(bad)).is_err());
+ sender
+ .send(Pdu::GetPaneRenderChangesResponse(changes(false, 2)))
+ .unwrap();
+ assert!(
+ matches!(receiver.try_recv(), Ok(Update::Ended(reason)) if reason.contains("dimensions"))
+ );
+ assert!(matches!(receiver.try_recv(), Err(TryRecvError::Closed)));
+ }
+
+ #[test]
+ fn closing_releases_unread_payloads_and_wakes_a_waiter() {
+ let (sender, receiver) = channel();
+ let allocation = Arc::downgrade(&sender.pending);
+ sender
+ .send(Pdu::GetPaneRenderChangesResponse(changes(false, 1)))
+ .unwrap();
+ sender.send(state(true, None)).unwrap();
+ drop(receiver);
+ let pending = sender.pending.lock().unwrap();
+ assert!(pending.render.is_none());
+ assert!(pending.state.is_none());
+ assert!(pending.ended.is_none());
+ drop(pending);
+ assert!(sender.send(state(false, None)).is_err());
+ drop(sender);
+ assert!(allocation.upgrade().is_none());
+
+ let (sender, receiver) = channel();
+ drop(sender);
+ assert!(smol::block_on(receiver.recv()).is_err());
+ }
+}