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(import): add Herdr session handoff and durable RPC receipts

RoversX33851ac244eb
diff --git a/Cargo.lock b/Cargo.lock
index 63a5a687..82a03361 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1137,6 +1137,7 @@ dependencies = [
"serde_bytes",
"serde_json",
"termwiz 0.24.0",
+ "thinkterm-import",
"thinkterm-proto",
"thiserror 1.0.69",
"varbincode",
@@ -8545,6 +8546,33 @@ dependencies = [
"unic-langid",
]
+[[package]]
+name = "thinkterm-import"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "thinkterm-import-herdr"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "config",
+ "log",
+ "nix 0.29.0",
+ "rustix 1.1.2",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "tempfile",
+ "thinkterm-import",
+ "uuid",
+ "wezterm-term",
+]
+
[[package]]
name = "thinkterm-mobile"
version = "0.1.0"
@@ -10620,6 +10648,8 @@ dependencies = [
"thinkterm-core",
"thinkterm-file-index",
"thinkterm-i18n",
+ "thinkterm-import",
+ "thinkterm-import-herdr",
"thinkterm-plugin-channel",
"thinkterm-plugin-panel",
"thinkterm-proto",
@@ -10712,6 +10742,8 @@ dependencies = [
"promise",
"signal-hook",
"smol",
+ "thinkterm-import",
+ "thinkterm-import-herdr",
"umask",
"wezterm-blob-leases 0.1.1",
"wezterm-gui-subcommands",
@@ -10748,6 +10780,7 @@ dependencies = [
"promise",
"rangeset",
"rcgen",
+ "rustix 1.1.2",
"serde",
"serde_json",
"sha1 0.10.6",
@@ -10756,6 +10789,7 @@ dependencies = [
"soketto",
"tempfile",
"termwiz 0.24.0",
+ "thinkterm-import",
"thinkterm-plugin-channel",
"thinkterm-proto",
"url",
diff --git a/Cargo.toml b/Cargo.toml
index 213a906a..37b7b6d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,6 +11,8 @@ members = [
"thinkterm-font-core",
"thinkterm-font-web",
"thinkterm-i18n",
+ "thinkterm-import",
+ "thinkterm-import-herdr",
"thinkterm-proto",
"thinkterm-render",
"thinkterm-mobile",
@@ -186,6 +188,8 @@ thinkterm-file-index = { path = "thinkterm-file-index" }
thinkterm-font-core = { path = "thinkterm-font-core" }
thinkterm-font-web = { path = "thinkterm-font-web" }
thinkterm-i18n = { path = "thinkterm-i18n" }
+thinkterm-import = { path = "thinkterm-import" }
+thinkterm-import-herdr = { path = "thinkterm-import-herdr" }
thinkterm-plugin-channel = { path = "thinkterm-plugin-channel", default-features = false }
thinkterm-plugin-panel = { path = "thinkterm-plugin-panel" }
thinkterm-plugin-sdk = { path = "thinkterm-plugin-sdk" }
diff --git a/codec/Cargo.toml b/codec/Cargo.toml
index d85223ea..09bcc647 100644
--- a/codec/Cargo.toml
+++ b/codec/Cargo.toml
@@ -8,6 +8,7 @@ publish = false
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
+thinkterm-import.workspace = true
anyhow.workspace = true
leb128.workspace = true
log.workspace = true
diff --git a/codec/src/import.rs b/codec/src/import.rs
new file mode 100644
index 00000000..153ab217
--- /dev/null
+++ b/codec/src/import.rs
@@ -0,0 +1,167 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImportSessionRequest {
+ pub request_id: String,
+ pub request: thinkterm_import::ImportRequest,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GetImportSessionStatus {
+ pub request_id: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ImportSessionStatus {
+ NotFound,
+ Running,
+ Completed(ImportSessionResponse),
+ Failed(String),
+ Interrupted { space_id: Option<String> },
+ Expired,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GetImportSessionStatusResponse {
+ pub status: ImportSessionStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImportSessionResponse {
+ pub tree: crate::ThinkTermTree,
+ pub space_id: String,
+ pub workspace: String,
+ pub live: bool,
+ pub pane_count: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ListImportSessions {
+ pub source: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ListImportSessionsResponse {
+ pub sessions: Vec<thinkterm_import::Session>,
+ pub notes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PreviewImportSession {
+ pub source: String,
+ pub session: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct PreviewImportSessionResponse {
+ pub preview: thinkterm_import::Preview,
+ pub notes: Vec<String>,
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{DecodedPdu, Pdu};
+
+ #[test]
+ fn generic_source_request_roundtrips() {
+ let pdu = Pdu::ImportSessionRequest(ImportSessionRequest {
+ request_id: "1-00000000-0000-4000-8000-000000000001".into(),
+ request: thinkterm_import::ImportRequest {
+ source: "example".into(),
+ session: "development".into(),
+ mode: thinkterm_import::ImportMode::Live,
+ fingerprint: "example-fingerprint".into(),
+ space_name: "Imported".into(),
+ },
+ });
+ let mut encoded = Vec::new();
+ pdu.encode(&mut encoded, 7).unwrap();
+ assert_eq!(
+ Pdu::decode(encoded.as_slice()).unwrap(),
+ DecodedPdu { serial: 7, pdu }
+ );
+ }
+ #[test]
+ fn import_result_queries_roundtrip() {
+ let mut pdus = vec![Pdu::GetImportSessionStatus(GetImportSessionStatus {
+ request_id: "1-00000000-0000-4000-8000-000000000001".into(),
+ })];
+ for status in [
+ ImportSessionStatus::NotFound,
+ ImportSessionStatus::Running,
+ ImportSessionStatus::Failed("example failure".into()),
+ ImportSessionStatus::Interrupted {
+ space_id: Some("space-example".into()),
+ },
+ ImportSessionStatus::Expired,
+ ImportSessionStatus::Completed(ImportSessionResponse {
+ tree: crate::ThinkTermTree::default(),
+ space_id: "space-example".into(),
+ workspace: "workspace-example".into(),
+ live: true,
+ pane_count: 1,
+ }),
+ ] {
+ pdus.push(Pdu::GetImportSessionStatusResponse(
+ GetImportSessionStatusResponse { status },
+ ));
+ }
+ for pdu in pdus {
+ let mut bytes = vec![];
+ pdu.encode(&mut bytes, 3).unwrap();
+ assert_eq!(
+ Pdu::decode(bytes.as_slice()).unwrap(),
+ DecodedPdu { serial: 3, pdu }
+ );
+ }
+ }
+
+ #[test]
+ fn remote_discovery_and_preview_roundtrip() {
+ let preview = thinkterm_import::Preview {
+ session: "development".into(),
+ live: true,
+ version: Some("example-version".into()),
+ fingerprint: "example-fingerprint".into(),
+ unavailable: None,
+ projects: vec![thinkterm_import::PreviewProject {
+ name: "example".into(),
+ threads: 1,
+ tabs: 1,
+ panes: 1,
+ terminals: vec![thinkterm_import::PreviewTerminal {
+ title: Some("shell".into()),
+ tab_name: None,
+ cwd: Some("/home/user/example".into()),
+ }],
+ }],
+ };
+ for pdu in vec![
+ Pdu::ListImportSessions(ListImportSessions {
+ source: "example".into(),
+ }),
+ Pdu::ListImportSessionsResponse(ListImportSessionsResponse {
+ sessions: vec![thinkterm_import::Session {
+ name: "development".into(),
+ }],
+ notes: vec![],
+ }),
+ Pdu::PreviewImportSession(PreviewImportSession {
+ source: "example".into(),
+ session: "development".into(),
+ }),
+ Pdu::PreviewImportSessionResponse(PreviewImportSessionResponse {
+ preview,
+ notes: vec!["session-import-requirements-remote".into()],
+ }),
+ ] {
+ let mut bytes = vec![];
+ pdu.encode(&mut bytes, 11).unwrap();
+ assert_eq!(
+ Pdu::decode(bytes.as_slice()).unwrap(),
+ DecodedPdu { serial: 11, pdu }
+ );
+ }
+ }
+}
diff --git a/codec/src/lib.rs b/codec/src/lib.rs
index 3b94595a..6692cd7b 100644
--- a/codec/src/lib.rs
+++ b/codec/src/lib.rs
@@ -43,6 +43,12 @@ use wezterm_term::color::ColorPalette;
use wezterm_term::{Alert, ClipboardSelection, StableRowIndex, TerminalSize};
pub mod thinkterm_tree;
+pub mod import;
+pub use import::{
+ GetImportSessionStatus, GetImportSessionStatusResponse, ImportSessionRequest,
+ ImportSessionResponse, ImportSessionStatus, ListImportSessions, ListImportSessionsResponse,
+ PreviewImportSession, PreviewImportSessionResponse,
+};
pub mod kitty_queue;
pub mod kitty_metadata;
pub use thinkterm_tree::{
@@ -776,7 +782,11 @@ macro_rules! pdu {
/// 74: The mux that owns a pane reports the program leading its terminal
/// (ForegroundProgramChanged), with a request/response pair for
/// cold-start delivery, so a client can show what a remote pane runs.
-pub const CODEC_VERSION: usize = 74;
+/// 75: Import a local session into the owning mux.
+/// 76: Source-independent session import requests with explicit import modes.
+/// 77: Discover and preview import sessions on their owning mux server.
+/// 78: Durable import request identities and reconnectable result queries.
+pub const CODEC_VERSION: usize = 78;
// Defines the Pdu enum.
// Each struct has an explicit identifying number.
@@ -877,6 +887,14 @@ pdu! {
ForegroundProgramChanged: 100,
GetForegroundPrograms: 101,
GetForegroundProgramsResponse: 102,
+ ImportSessionRequest: 103,
+ ImportSessionResponse: 104,
+ ListImportSessions: 105,
+ ListImportSessionsResponse: 106,
+ PreviewImportSession: 107,
+ PreviewImportSessionResponse: 108,
+ GetImportSessionStatus: 109,
+ GetImportSessionStatusResponse: 110,
}
impl Pdu {
@@ -2992,7 +3010,7 @@ mod test {
// The exact assertion is the tripwire: whoever bumps the codec must
// come here, confirm the round-trips still cover the new version,
// and advance it deliberately.
- assert_eq!(CODEC_VERSION, 74);
+ assert_eq!(CODEC_VERSION, 78);
use thinkterm_proto::{AgentEvidence, AgentState, AgentStatus};
fn round_trip(pdu: Pdu) {
@@ -3033,7 +3051,7 @@ mod test {
#[test]
fn foreground_program_protocol_round_trip_at_version_74() {
// Same tripwire as the agent-status test above.
- assert_eq!(CODEC_VERSION, 74);
+ assert_eq!(CODEC_VERSION, 78);
use thinkterm_proto::ForegroundProgram;
fn round_trip(pdu: &Pdu) -> Pdu {
@@ -3135,7 +3153,7 @@ mod test {
fn frame_control_extension_round_trips_without_changing_legacy_version() {
// The extension is asked for, so it needed no bump of its own; 74
// is the foreground program's, which a server sends unasked.
- assert_eq!(CODEC_VERSION, 74);
+ assert_eq!(CODEC_VERSION, 78);
for pdu in [
Pdu::GetKittyImage(GetKittyImage { pane_id: 3, image_id: 7, data_hash: [9; 32], have_frames: 2, image_epoch: Some(4) }),
Pdu::GetKittyFrameSelections(GetKittyFrameSelections { pane_id: 3, subscribe: true }),
diff --git a/thinkterm-import-herdr/Cargo.toml b/thinkterm-import-herdr/Cargo.toml
new file mode 100644
index 00000000..fd03011c
--- /dev/null
+++ b/thinkterm-import-herdr/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "thinkterm-import-herdr"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[target.'cfg(unix)'.dependencies]
+anyhow.workspace = true
+log.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+sha2.workspace = true
+tempfile.workspace = true
+thinkterm-import.workspace = true
+uuid = { workspace = true, features = ["v4"] }
+rustix = { version = "1.1.2", features = ["net", "termios", "fs", "process"] }
+
+[target.'cfg(unix)'.dev-dependencies]
+nix = { workspace = true, features = ["term", "socket"] }
+
+config.workspace = true
+wezterm-term.workspace = true
diff --git a/thinkterm-import-herdr/src/lib.rs b/thinkterm-import-herdr/src/lib.rs
new file mode 100644
index 00000000..0d3c56dc
--- /dev/null
+++ b/thinkterm-import-herdr/src/lib.rs
@@ -0,0 +1,273 @@
+//! Herdr's saved-layout and live-handoff adapter. No mux or GUI dependency.
+#![cfg(unix)]
+
+mod model;
+mod seed;
+mod source;
+mod transport;
+
+use anyhow::{ensure, Context, Result};
+use model::{Runtime, Snapshot};
+use thinkterm_import::{
+ ImportContext, ImportMode, ImportPlan, ImportRequest, ImportSource, LiveTerminal,
+ PreparedImport, Preview, Project, Selection, Session, SourceInfo, TerminalSeed, Thread,
+};
+
+struct Herdr;
+static HERDR: Herdr = Herdr;
+
+pub fn register() -> Result<()> {
+ thinkterm_import::register(&HERDR)
+}
+
+impl ImportSource for Herdr {
+ fn info(&self) -> SourceInfo {
+ SourceInfo {
+ id: "herdr",
+ name: "Herdr",
+ icon: "herdr",
+ }
+ }
+
+ fn discover(&self, context: &ImportContext) -> Result<Vec<Session>> {
+ source::discover(context)
+ }
+
+ fn preview(&self, context: &ImportContext, session: &str) -> Result<Preview> {
+ source::preview(context, session)
+ }
+
+ fn prepare(&self, context: &ImportContext, request: &ImportRequest) -> Result<PreparedImport> {
+ let preview = source::preview(context, &request.session)?;
+ ensure!(
+ preview.live == request.mode.is_live() && preview.fingerprint == request.fingerprint,
+ "Herdr changed since the preview; inspect the session again"
+ );
+ ensure!(
+ preview.unavailable.is_none(),
+ "{}",
+ preview.unavailable.unwrap_or_default()
+ );
+ let dir = source::session_dir(context, &request.session)?;
+ if request.mode == ImportMode::Layout {
+ let (snapshot, fingerprint) = source::saved_snapshot(&dir)?;
+ ensure!(
+ fingerprint == request.fingerprint,
+ "Herdr layout changed; inspect it again"
+ );
+ snapshot.check_working_directories()?;
+ return Ok(PreparedImport {
+ plan: into_plan(snapshot, request.mode),
+ terminals: vec![],
+ handoff: None,
+ });
+ }
+ let mut transfer =
+ transport::receive(&dir, &context.executable).context("Receive Herdr handoff")?;
+ let plan = into_plan(transfer.manifest.snapshot.clone(), request.mode);
+ let terminals = transfer
+ .manifest
+ .panes
+ .iter()
+ .zip(transfer.fds.drain(..))
+ .map(|(runtime, pty)| LiveTerminal {
+ pane_id: runtime.pane_id,
+ seed: terminal_seed(runtime),
+ pty,
+ })
+ .collect();
+ Ok(PreparedImport {
+ plan,
+ terminals,
+ handoff: Some(Box::new(transfer)),
+ })
+ }
+
+ fn notes(&self, mode: Option<ImportMode>) -> Vec<&'static str> {
+ let mut notes = vec![];
+ if mode != Some(ImportMode::Layout) {
+ notes.push("herdr-requirements-live");
+ #[cfg(target_os = "linux")]
+ notes.push("herdr-requirements-linux");
+ }
+ if mode == Some(ImportMode::Live) {
+ notes.push("herdr-live-limits");
+ }
+ notes.push("herdr-keep-state");
+ notes
+ }
+
+ fn result_notes(&self) -> Vec<&'static str> {
+ vec!["herdr-keep-state"]
+ }
+
+ fn error_key(&self, message: &str) -> Option<&'static str> {
+ error_key(message)
+ }
+
+ fn run_helper(&self) -> Option<Result<()>> {
+ transport::maybe_run_relay()
+ }
+}
+
+impl thinkterm_import::Handoff for transport::Transfer {
+ fn commit(&mut self) -> Result<()> {
+ transport::Transfer::commit(self)
+ }
+ fn finish(self: Box<Self>) {
+ transport::Transfer::finish(*self);
+ }
+}
+
+fn terminal_seed(runtime: &Runtime) -> TerminalSeed {
+ TerminalSeed {
+ child_pid: runtime.child_pid,
+ rows: runtime.rows,
+ cols: runtime.cols,
+ cell_width_px: runtime.cell_width_px,
+ cell_height_px: runtime.cell_height_px,
+ title: runtime.terminal_title.clone(),
+ ansi: seed::seed_ansi(runtime),
+ }
+}
+
+fn into_plan(snapshot: Snapshot, mode: ImportMode) -> ImportPlan {
+ let active = Selection {
+ project: snapshot
+ .active
+ .unwrap_or(0)
+ .min(snapshot.workspaces.len().saturating_sub(1)),
+ thread: 0,
+ };
+ let projects = snapshot
+ .workspaces
+ .into_iter()
+ .enumerate()
+ .map(|(index, workspace)| {
+ let name = workspace.display_name(index);
+ let active_tab = workspace
+ .active_tab
+ .min(workspace.tabs.len().saturating_sub(1));
+ let tabs = workspace
+ .tabs
+ .into_iter()
+ .map(|tab| thinkterm_import::Tab {
+ name: tab.custom_name,
+ layout: into_layout(tab.layout),
+ panes: tab
+ .panes
+ .into_iter()
+ .map(|(id, pane)| {
+ (
+ id,
+ thinkterm_import::Pane {
+ cwd: pane.cwd,
+ title: pane.label,
+ },
+ )
+ })
+ .collect(),
+ focused: tab.focused,
+ zoomed: tab.zoomed,
+ })
+ .collect();
+ Project {
+ name: name.clone(),
+ directory: workspace.identity_cwd,
+ threads: vec![Thread {
+ name,
+ tabs,
+ active_tab,
+ }],
+ }
+ })
+ .collect();
+ ImportPlan {
+ mode,
+ projects,
+ active,
+ }
+}
+
+fn into_layout(layout: model::Layout) -> thinkterm_import::Layout {
+ match layout {
+ model::Layout::Pane(id) => thinkterm_import::Layout::Pane(id),
+ model::Layout::Split {
+ direction,
+ ratio,
+ first,
+ second,
+ } => thinkterm_import::Layout::Split {
+ direction: match direction {
+ model::Direction::Horizontal => thinkterm_import::Direction::Horizontal,
+ model::Direction::Vertical => thinkterm_import::Direction::Vertical,
+ },
+ ratio,
+ first: Box::new(into_layout(*first)),
+ second: Box::new(into_layout(*second)),
+ },
+ }
+}
+
+fn error_key(message: &str) -> Option<&'static str> {
+ [
+ (
+ "This running Herdr server does not support live handoff",
+ "herdr-error-live-unsupported",
+ ),
+ ("Herdr session is empty", "session-import-error-empty"),
+ (
+ "Herdr session directory is unavailable",
+ "session-import-error-session-missing",
+ ),
+ (
+ "A saved Herdr working directory is unavailable",
+ "session-import-error-directory-missing",
+ ),
+ (
+ "This Herdr snapshot format is newer than ThinkTerm supports",
+ "session-import-error-layout-newer",
+ ),
+ (
+ "Unsupported Herdr handoff version",
+ "session-import-error-handoff-version",
+ ),
+ (
+ "Herdr changed since the preview; inspect the session again",
+ "session-import-error-changed",
+ ),
+ (
+ "Herdr layout changed; inspect it again",
+ "session-import-error-changed",
+ ),
+ (
+ "Herdr session belongs to a different user",
+ "session-import-error-local-user",
+ ),
+ (
+ "Invalid Herdr socket owner or type",
+ "session-import-error-local-user",
+ ),
+ (
+ "Some Herdr panes have no live terminal; the session was not moved",
+ "session-import-error-terminal-missing",
+ ),
+ ]
+ .iter()
+ .find_map(|(reason, key)| message.ends_with(reason).then_some(*key))
+ .or_else(|| {
+ if message.contains("failed to spawn handoff import server at ")
+ || message.ends_with("Herdr did not start its handoff receiver")
+ || message.ends_with("Herdr ended the handoff without a receiver")
+ {
+ Some("session-import-error-receiver")
+ } else if message.contains("Herdr session directory is unavailable") {
+ Some("session-import-error-session-missing")
+ } else {
+ None
+ }
+ })
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/thinkterm-import-herdr/src/model.rs b/thinkterm-import-herdr/src/model.rs
new file mode 100644
index 00000000..5b3ff969
--- /dev/null
+++ b/thinkterm-import-herdr/src/model.rs
@@ -0,0 +1,309 @@
+use anyhow::{bail, ensure, Context, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashSet};
+
+pub const MAX_PANES: usize = 1024;
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Snapshot {
+ #[serde(default)]
+ pub version: u32,
+ pub workspaces: Vec<Workspace>,
+ #[serde(default)]
+ pub active: Option<usize>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Workspace {
+ #[serde(default)]
+ pub custom_name: Option<String>,
+ pub identity_cwd: String,
+ pub tabs: Vec<Tab>,
+ #[serde(default)]
+ pub active_tab: usize,
+}
+
+impl Workspace {
+ pub fn display_name(&self, index: usize) -> String {
+ self.custom_name
+ .clone()
+ .filter(|name| !name.trim().is_empty())
+ .unwrap_or_else(|| {
+ std::path::Path::new(&self.identity_cwd)
+ .file_name()
+ .map(|name| name.to_string_lossy().into_owned())
+ .unwrap_or_else(|| format!("Project {}", index + 1))
+ })
+ }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Tab {
+ #[serde(default)]
+ pub custom_name: Option<String>,
+ pub layout: Layout,
+ pub panes: BTreeMap<u32, Pane>,
+ #[serde(default)]
+ pub focused: Option<u32>,
+ #[serde(default)]
+ pub zoomed: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Pane {
+ pub cwd: String,
+ #[serde(default)]
+ pub label: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum Layout {
+ Pane(u32),
+ Split {
+ direction: Direction,
+ ratio: f32,
+ first: Box<Layout>,
+ second: Box<Layout>,
+ },
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
+pub enum Direction {
+ Horizontal,
+ Vertical,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Manifest {
+ pub version: u32,
+ pub source_version: String,
+ pub snapshot: Snapshot,
+ pub panes: Vec<Runtime>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Runtime {
+ pub pane_id: u32,
+ pub child_pid: u32,
+ pub rows: u16,
+ pub cols: u16,
+ #[serde(default)]
+ pub cell_width_px: u32,
+ #[serde(default)]
+ pub cell_height_px: u32,
+ #[serde(default)]
+ pub keyboard_protocol_flags: u16,
+ #[serde(default)]
+ pub keyboard_protocol_ansi: Option<String>,
+ #[serde(default)]
+ pub input_state: Option<InputState>,
+ #[serde(default)]
+ pub terminal_title: Option<String>,
+ #[serde(default)]
+ pub initial_history_ansi: Option<String>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(default)]
+pub struct InputState {
+ pub alternate_screen: bool,
+ pub application_cursor: bool,
+ pub bracketed_paste: bool,
+ pub focus_reporting: bool,
+ pub mouse_protocol_mode: String,
+ pub mouse_protocol_encoding: String,
+ pub mouse_alternate_scroll: bool,
+ pub modify_other_keys: bool,
+ pub color_scheme_reporting: bool,
+}
+
+impl Layout {
+ fn validate(
+ &self,
+ depth: usize,
+ panes: &BTreeMap<u32, Pane>,
+ seen: &mut HashSet<u32>,
+ ) -> Result<()> {
+ ensure!(depth <= 64, "Herdr layout is too deeply nested");
+ match self {
+ Self::Pane(id) => {
+ ensure!(
+ panes.contains_key(id),
+ "Herdr layout references missing pane {id}"
+ );
+ ensure!(seen.insert(*id), "Herdr layout repeats pane {id}");
+ ensure!(seen.len() <= MAX_PANES, "Herdr session has too many panes");
+ }
+ Self::Split {
+ ratio,
+ first,
+ second,
+ ..
+ } => {
+ ensure!(
+ ratio.is_finite() && *ratio > 0.0 && *ratio < 1.0,
+ "Invalid Herdr split ratio"
+ );
+ first.validate(depth + 1, panes, seen)?;
+ second.validate(depth + 1, panes, seen)?;
+ }
+ }
+ Ok(())
+ }
+}
+
+impl Snapshot {
+ pub fn parse(bytes: &[u8]) -> Result<Self> {
+ let mut value: serde_json::Value =
+ serde_json::from_slice(bytes).context("Read Herdr session layout")?;
+ // Early snapshots kept one tab directly on each workspace.
+ if let Some(workspaces) = value.get_mut("workspaces").and_then(|v| v.as_array_mut()) {
+ for workspace in workspaces {
+ if workspace.get("tabs").is_none() && workspace.get("layout").is_some() {
+ let tab = serde_json::json!({
+ "layout": workspace["layout"], "panes": workspace["panes"],
+ "focused": workspace.get("focused"), "zoomed": workspace.get("zoomed").and_then(|v| v.as_bool()).unwrap_or(false)
+ });
+ let cwd = workspace["panes"]
+ .as_object()
+ .and_then(|panes| panes.values().next())
+ .and_then(|pane| pane.get("cwd"))
+ .cloned()
+ .context("Legacy Herdr workspace has no directory")?;
+ workspace["identity_cwd"] = cwd;
+ workspace["tabs"] = serde_json::json!([tab]);
+ }
+ }
+ }
+ let snapshot: Self = serde_json::from_value(value).context("Unsupported Herdr layout")?;
+ snapshot.validate()?;
+ Ok(snapshot)
+ }
+
+ pub fn validate(&self) -> Result<()> {
+ ensure!(
+ self.version <= 3,
+ "This Herdr snapshot format is newer than ThinkTerm supports"
+ );
+ ensure!(!self.workspaces.is_empty(), "Herdr session is empty");
+ let mut seen = HashSet::new();
+ for workspace in &self.workspaces {
+ ensure!(!workspace.tabs.is_empty(), "Herdr workspace has no tabs");
+ ensure!(
+ std::path::Path::new(&workspace.identity_cwd).is_absolute(),
+ "Herdr workspace directory must be absolute"
+ );
+ for tab in &workspace.tabs {
+ let before = seen.len();
+ tab.layout.validate(0, &tab.panes, &mut seen)?;
+ ensure!(
+ seen.len() - before == tab.panes.len(),
+ "Herdr tab contains panes outside its layout"
+ );
+ if let Some(focused) = tab.focused {
+ ensure!(
+ tab.panes.contains_key(&focused),
+ "Herdr focused pane is missing"
+ );
+ }
+ for pane in tab.panes.values() {
+ ensure!(
+ std::path::Path::new(&pane.cwd).is_absolute(),
+ "Herdr pane directory must be absolute"
+ );
+ }
+ }
+ }
+ Ok(())
+ }
+
+ pub fn check_working_directories(&self) -> Result<()> {
+ for pane in self
+ .workspaces
+ .iter()
+ .flat_map(|workspace| &workspace.tabs)
+ .flat_map(|tab| tab.panes.values())
+ {
+ ensure!(
+ std::path::Path::new(&pane.cwd).is_dir(),
+ "A saved Herdr working directory is unavailable"
+ );
+ }
+ Ok(())
+ }
+
+ #[cfg(test)]
+ pub fn pane_count(&self) -> usize {
+ self.workspaces
+ .iter()
+ .flat_map(|w| &w.tabs)
+ .map(|t| t.panes.len())
+ .sum()
+ }
+}
+
+impl Manifest {
+ pub fn validate(&self) -> Result<()> {
+ ensure!(self.version == 1, "Unsupported Herdr handoff version");
+ ensure!(
+ !self.source_version.is_empty() && self.source_version.len() <= 128,
+ "Invalid Herdr source version"
+ );
+ self.snapshot.validate()?;
+ ensure!(
+ self.panes.len() <= MAX_PANES,
+ "Herdr session has too many live panes"
+ );
+ let mut ids = HashSet::new();
+ let mut pids = HashSet::new();
+ let mut cells = 0u64;
+ let expected: HashSet<_> = self
+ .snapshot
+ .workspaces
+ .iter()
+ .flat_map(|w| &w.tabs)
+ .flat_map(|t| t.panes.keys().copied())
+ .collect();
+ for pane in &self.panes {
+ ensure!(
+ ids.insert(pane.pane_id) && expected.contains(&pane.pane_id),
+ "Unexpected live Herdr pane"
+ );
+ ensure!(
+ pane.child_pid > 1
+ && pane.child_pid <= i32::MAX as u32
+ && pids.insert(pane.child_pid),
+ "Invalid Herdr process id"
+ );
+ ensure!(
+ pane.rows > 0
+ && pane.cols > 0
+ && pane.rows <= 4096
+ && pane.cols <= 4096
+ && u32::from(pane.rows) * u32::from(pane.cols) <= 1_000_000,
+ "Invalid Herdr terminal size"
+ );
+ cells += u64::from(pane.rows) * u64::from(pane.cols);
+ ensure!(
+ cells <= 16_000_000,
+ "Herdr session exceeds the terminal cell limit"
+ );
+ if pane
+ .initial_history_ansi
+ .as_ref()
+ .is_some_and(|s| s.len() > 8192)
+ || pane
+ .keyboard_protocol_ansi
+ .as_ref()
+ .is_some_and(|s| s.len() > 4096)
+ {
+ bail!("Herdr terminal state is too large");
+ }
+ }
+ ensure!(
+ ids == expected,
+ "Some Herdr panes have no live terminal; the session was not moved"
+ );
+ Ok(())
+ }
+}
diff --git a/thinkterm-import-herdr/src/seed.rs b/thinkterm-import-herdr/src/seed.rs
new file mode 100644
index 00000000..c84a2ef8
--- /dev/null
+++ b/thinkterm-import-herdr/src/seed.rs
@@ -0,0 +1,59 @@
+use crate::model::Runtime;
+
+pub(crate) fn seed_ansi(runtime: &Runtime) -> String {
+ let mut ansi = String::new();
+ if let Some(input) = &runtime.input_state {
+ for (mode, enabled) in [
+ (1049, input.alternate_screen),
+ (1, input.application_cursor),
+ (2004, input.bracketed_paste),
+ (1004, input.focus_reporting),
+ (1007, input.mouse_alternate_scroll),
+ (2031, input.color_scheme_reporting),
+ ] {
+ ansi.push_str(&format!(
+ "\x1b[?{}{}",
+ mode,
+ if enabled { 'h' } else { 'l' }
+ ));
+ }
+ let mouse = match input.mouse_protocol_mode.as_str() {
+ "Press" => 9,
+ "PressRelease" => 1000,
+ "ButtonMotion" => 1002,
+ "AnyMotion" => 1003,
+ _ => 0,
+ };
+ for mode in [9, 1000, 1002, 1003] {
+ ansi.push_str(&format!(
+ "\x1b[?{}{}",
+ mode,
+ if mode == mouse { 'h' } else { 'l' }
+ ));
+ }
+ let encoding = match input.mouse_protocol_encoding.as_str() {
+ "Utf8" => 1005,
+ "Sgr" => 1006,
+ "SgrPixels" => 1016,
+ _ => 0,
+ };
+ for mode in [1005, 1006, 1016] {
+ ansi.push_str(&format!("\x1b[?{}l", mode));
+ }
+ if encoding != 0 {
+ ansi.push_str(&format!("\x1b[?{}h", encoding));
+ }
+ if input.modify_other_keys {
+ ansi.push_str("\x1b[>4;2m");
+ }
+ }
+ if let Some(protocol) = &runtime.keyboard_protocol_ansi {
+ ansi.push_str(protocol);
+ } else if runtime.keyboard_protocol_flags != 0 {
+ ansi.push_str(&format!("\x1b[>{}u", runtime.keyboard_protocol_flags));
+ }
+ if let Some(history) = &runtime.initial_history_ansi {
+ ansi.push_str(history);
+ }
+ ansi
+}
diff --git a/thinkterm-import-herdr/src/source.rs b/thinkterm-import-herdr/src/source.rs
new file mode 100644
index 00000000..b5f74bc5
--- /dev/null
+++ b/thinkterm-import-herdr/src/source.rs
@@ -0,0 +1,337 @@
+use super::model::{Layout, Snapshot, Tab};
+use anyhow::{bail, ensure, Context, Result};
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::io::{Read, Write};
+use std::os::unix::fs::{FileTypeExt, MetadataExt};
+use std::os::unix::net::UnixStream;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+pub const MAX_BYTES: usize = 16 * 1024 * 1024;
+
+use thinkterm_import::ImportContext;
+pub use thinkterm_import::{Preview, PreviewProject, PreviewTerminal, Session};
+
+pub fn config_root(context: &ImportContext) -> Result<PathBuf> {
+ let config = context
+ .config_home
+ .clone()
+ .filter(|path| path.is_absolute())
+ .unwrap_or_else(|| context.home.join(".config"));
+ Ok(config.join("herdr"))
+}
+
+pub fn session_dir(context: &ImportContext, name: &str) -> Result<PathBuf> {
+ ensure!(
+ !name.is_empty()
+ && name.len() <= 128
+ && !name.contains('/')
+ && !name.contains('\\')
+ && name != "."
+ && name != ".."
+ && !name.chars().any(char::is_control),
+ "Invalid Herdr session name"
+ );
+ let root = config_root(context)?;
+ let path = if name == "default" {
+ root
+ } else {
+ root.join("sessions").join(name)
+ };
+ let metadata = fs::symlink_metadata(&path).context("Herdr session directory is unavailable")?;
+ ensure!(
+ metadata.is_dir() && !metadata.file_type().is_symlink(),
+ "Herdr session must be a directory"
+ );
+ ensure!(
+ metadata.uid() == rustix::process::geteuid().as_raw(),
+ "Herdr session belongs to a different user"
+ );
+ Ok(path)
+}
+
+pub fn discover(context: &ImportContext) -> Result<Vec<Session>> {
+ let root = config_root(context)?;
+ let mut sessions = Vec::new();
+ if root.join("session.json").exists() || root.join("herdr.sock").exists() {
+ sessions.push(Session {
+ name: "default".into(),
+ });
+ }
+ match fs::read_dir(root.join("sessions")) {
+ Ok(entries) => {
+ for entry in entries.take(256) {
+ let entry = entry?;
+ if entry.file_type()?.is_dir()
+ && (entry.path().join("session.json").exists()
+ || entry.path().join("herdr.sock").exists())
+ {
+ if let Some(name) = entry.file_name().to_str() {
+ if session_dir(context, name).is_ok() {
+ sessions.push(Session { name: name.into() });
+ }
+ }
+ }
+ }
+ }
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
+ Err(err) => return Err(err.into()),
+ }
+ sessions.sort_by(|a, b| a.name.cmp(&b.name));
+ Ok(sessions)
+}
+
+pub fn read_line(stream: &mut UnixStream, limit: usize) -> Result<Vec<u8>> {
+ let mut bytes = Vec::new();
+ let mut byte = [0];
+ loop {
+ stream.read_exact(&mut byte)?;
+ if byte[0] == b'\n' {
+ return Ok(bytes);
+ }
+ ensure!(bytes.len() < limit, "Herdr response exceeds the size limit");
+ bytes.push(byte[0]);
+ }
+}
+
+fn connect(path: &Path, timeout: Duration) -> Result<UnixStream> {
+ let metadata = fs::symlink_metadata(path)?;
+ ensure!(
+ metadata.file_type().is_socket() && metadata.uid() == rustix::process::geteuid().as_raw(),
+ "Invalid Herdr socket owner or type"
+ );
+ let stream = UnixStream::connect(path)?;
+ stream.set_read_timeout(Some(timeout))?;
+ stream.set_write_timeout(Some(timeout))?;
+ Ok(stream)
+}
+
+pub fn request(dir: &Path, method: &str, params: Value, timeout: Duration) -> Result<Value> {
+ let mut stream = connect(&dir.join("herdr.sock"), timeout)?;
+ serde_json::to_writer(
+ &mut stream,
+ &json!({ "id": "thinkterm:import", "method": method, "params": params }),
+ )?;
+ stream.write_all(b"\n")?;
+ let response: Value = serde_json::from_slice(&read_line(&mut stream, MAX_BYTES)?)?;
+ if let Some(error) = response.get("error") {
+ bail!(
+ "Herdr: {}",
+ error
+ .get("message")
+ .and_then(Value::as_str)
+ .unwrap_or("request failed")
+ );
+ }
+ response
+ .get("result")
+ .cloned()
+ .context("Herdr returned no result")
+}
+
+pub fn saved_snapshot(dir: &Path) -> Result<(Snapshot, String)> {
+ let path = dir.join("session.json");
+ let metadata = fs::symlink_metadata(&path)?;
+ ensure!(
+ metadata.is_file()
+ && !metadata.file_type().is_symlink()
+ && metadata.uid() == rustix::process::geteuid().as_raw(),
+ "Invalid Herdr snapshot owner or type"
+ );
+ let mut bytes = Vec::new();
+ fs::File::open(path)?
+ .take((MAX_BYTES + 1) as u64)
+ .read_to_end(&mut bytes)?;
+ ensure!(bytes.len() <= MAX_BYTES, "Herdr snapshot is too large");
+ let fingerprint = format!("{:x}", Sha256::digest(&bytes));
+ Ok((Snapshot::parse(&bytes)?, fingerprint))
+}
+
+pub(super) fn live_fingerprint(mut identity: Value) -> Result<String> {
+ // GUI and mux builds may enable different serde_json map ordering.
+ identity.sort_all_objects();
+ Ok(format!(
+ "{:x}",
+ Sha256::digest(serde_json::to_vec(&identity)?)
+ ))
+}
+
+fn preview_text(text: &str, limit: usize) -> Option<String> {
+ let text: String = text
+ .chars()
+ .take(limit + 1)
+ .map(|c| if c.is_control() { ' ' } else { c })
+ .collect();
+ let mut chars = text.trim().chars();
+ let mut result: String = chars.by_ref().take(limit).collect();
+ if chars.next().is_some() {
+ result.push('…');
+ }
+ (!result.is_empty()).then_some(result)
+}
+
+pub(super) fn live_projects(
+ workspaces: &[Value],
+ tabs: &[Value],
+ panes: &[Value],
+) -> Vec<PreviewProject> {
+ workspaces
+ .iter()
+ .map(|workspace| {
+ let project_tabs: Vec<_> = tabs
+ .iter()
+ .filter(|tab| tab["workspace_id"] == workspace["workspace_id"])
+ .collect();
+ let terminals: Vec<_> = panes
+ .iter()
+ .filter(|pane| pane["workspace_id"] == workspace["workspace_id"])
+ .map(|pane| PreviewTerminal {
+ title: [
+ "title",
+ "label",
+ "terminal_title_stripped",
+ "terminal_title",
+ "display_agent",
+ "agent",
+ ]
+ .iter()
+ .find_map(|key| pane[*key].as_str().and_then(|s| preview_text(s, 256))),
+ tab_name: project_tabs
+ .iter()
+ .find(|tab| tab["tab_id"] == pane["tab_id"])
+ .and_then(|tab| tab["label"].as_str())
+ .and_then(|s| preview_text(s, 256)),
+ cwd: ["foreground_cwd", "cwd"]
+ .iter()
+ .find_map(|key| pane[*key].as_str().and_then(|s| preview_text(s, 4096))),
+ })
+ .collect();
+ PreviewProject {
+ threads: 1,
+ name: workspace["label"].as_str().unwrap_or("Herdr").into(),
+ tabs: project_tabs.len(),
+ panes: terminals.len(),
+ terminals,
+ }
+ })
+ .collect()
+}
+
+pub(super) fn saved_projects(snapshot: &Snapshot) -> Vec<PreviewProject> {
+ fn collect_terminals(layout: &Layout, tab: &Tab, terminals: &mut Vec<PreviewTerminal>) {
+ match layout {
+ Layout::Pane(id) => {
+ let pane = &tab.panes[id];
+ terminals.push(PreviewTerminal {
+ title: pane.label.as_deref().and_then(|s| preview_text(s, 256)),
+ tab_name: tab
+ .custom_name
+ .as_deref()
+ .and_then(|s| preview_text(s, 256)),
+ cwd: preview_text(&pane.cwd, 4096),
+ });
+ }
+ Layout::Split { first, second, .. } => {
+ collect_terminals(first, tab, terminals);
+ collect_terminals(second, tab, terminals);
+ }
+ }
+ }
+
+ snapshot
+ .workspaces
+ .iter()
+ .enumerate()
+ .map(|(index, workspace)| {
+ let mut terminals = Vec::new();
+ for tab in &workspace.tabs {
+ collect_terminals(&tab.layout, tab, &mut terminals);
+ }
+ PreviewProject {
+ threads: 1,
+ name: workspace.display_name(index),
+ tabs: workspace.tabs.len(),
+ panes: terminals.len(),
+ terminals,
+ }
+ })
+ .collect()
+}
+
+pub fn preview(context: &ImportContext, name: &str) -> Result<Preview> {
+ let dir = session_dir(context, name)?;
+ let ping = request(&dir, "ping", json!({}), Duration::from_secs(3));
+ let ping = match ping {
+ Ok(ping) => Some(ping),
+ Err(error)
+ if error
+ .chain()
+ .filter_map(|e| e.downcast_ref::<std::io::Error>())
+ .any(|e| {
+ matches!(
+ e.kind(),
+ std::io::ErrorKind::NotFound | std::io::ErrorKind::ConnectionRefused
+ )
+ }) =>
+ {
+ None
+ }
+ Err(error) => return Err(error.context("Cannot inspect Herdr; no session was changed")),
+ };
+ if let Some(ping) = ping {
+ let result = request(&dir, "session.snapshot", json!({}), Duration::from_secs(5))?;
+ let snapshot = result
+ .get("snapshot")
+ .context("Herdr did not return its session structure")?;
+ let workspaces = snapshot["workspaces"]
+ .as_array()
+ .context("Missing Herdr workspaces")?;
+ let tabs = snapshot["tabs"].as_array().context("Missing Herdr tabs")?;
+ let panes = snapshot["panes"]
+ .as_array()
+ .context("Missing Herdr panes")?;
+ ensure!(
+ panes.len() <= super::model::MAX_PANES,
+ "Herdr session has too many panes"
+ );
+ let identity = json!({
+ "workspaces": workspaces.iter().map(|w| json!([w["workspace_id"], w["label"]])).collect::<Vec<_>>(),
+ "tabs": tabs.iter().map(|t| json!([t["tab_id"], t["workspace_id"], t["label"]])).collect::<Vec<_>>(),
+ "panes": panes.iter().map(|p| json!([p["pane_id"], p["terminal_id"], p["tab_id"]])).collect::<Vec<_>>()
+ });
+ let projects = live_projects(workspaces, tabs, panes);
+ let available = ping["capabilities"]["live_handoff"]
+ .as_bool()
+ .unwrap_or(false);
+ Ok(Preview {
+ session: name.into(),
+ live: true,
+ version: ping["version"].as_str().map(str::to_string),
+ fingerprint: live_fingerprint(identity)?,
+ projects,
+ unavailable: if panes.is_empty() {
+ Some("Herdr session is empty".into())
+ } else if !available {
+ Some("This running Herdr server does not support live handoff".into())
+ } else {
+ None
+ },
+ })
+ } else {
+ let (snapshot, fingerprint) = saved_snapshot(&dir)?;
+ let unavailable = snapshot
+ .check_working_directories()
+ .err()
+ .map(|error| error.to_string());
+ Ok(Preview {
+ session: name.into(),
+ live: false,
+ version: None,
+ fingerprint,
+ projects: saved_projects(&snapshot),
+ unavailable,
+ })
+ }
+}
diff --git a/thinkterm-import-herdr/src/tests.rs b/thinkterm-import-herdr/src/tests.rs
new file mode 100644
index 00000000..1b24c771
--- /dev/null
+++ b/thinkterm-import-herdr/src/tests.rs
@@ -0,0 +1,387 @@
+use super::*;
+use crate::model::{Direction, Layout};
+use serde_json::json;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::os::unix::net::UnixStream;
+use std::sync::Arc;
+use wezterm_term::{Terminal, TerminalSize};
+
+fn snapshot() -> Snapshot {
+ Snapshot::parse(&serde_json::to_vec(&json!({
+ "version": 3, "active": 0,
+ "workspaces": [{ "custom_name": "example", "identity_cwd": "/home/user/example", "active_tab": 1,
+ "tabs": [{ "custom_name": "build", "focused": 2, "zoomed": true,
+ "layout": {"Split": {"direction": "Horizontal", "ratio": 0.3, "first": {"Pane": 1}, "second": {"Pane": 2}}},
+ "panes": {"1": {"cwd": "/home/user/example", "label": "shell", "launch_argv": ["must-not-run"]},
+ "2": {"cwd": "/home/user/example/sub", "agent_resume": {"argv": ["must-not-resume"]}}}},
+ {"custom_name": "logs", "layout": {"Pane": 3}, "panes": {"3": {"cwd": "/home/user/example"}}}]
+ }]
+ })).unwrap()).unwrap()
+}
+
+#[test]
+fn live_preview_shows_titles_and_current_directories_in_their_projects() {
+ let workspaces = [
+ json!({"workspace_id": "w1", "label": "example"}),
+ json!({"workspace_id": "w2", "label": "other"}),
+ ];
+ let tabs = [
+ json!({"workspace_id": "w2", "tab_id": "t2", "label": "other tab"}),
+ json!({"workspace_id": "w1", "tab_id": "t1", "label": "Development"}),
+ ];
+ let panes = [
+ json!({"workspace_id": "w1", "tab_id": "t1", "title": "Building example", "label": "worker",
+ "cwd": "/home/user/example", "foreground_cwd": "/home/user/example/build"}),
+ json!({"workspace_id": "w2", "tab_id": "t2", "title": "Server logs"}),
+ json!({"workspace_id": "w1", "tab_id": "t1", "title": " ", "label": "shell", "cwd": "/home/user/example"}),
+ ];
+ let projects = source::live_projects(&workspaces, &tabs, &panes);
+ assert_eq!((projects[0].tabs, projects[0].panes), (1, 2));
+ let terminal = &projects[0].terminals[0];
+ assert_eq!(terminal.title.as_deref(), Some("Building example"));
+ assert_eq!(terminal.tab_name.as_deref(), Some("Development"));
+ assert_eq!(terminal.cwd.as_deref(), Some("/home/user/example/build"));
+ assert_eq!(projects[0].terminals[1].title.as_deref(), Some("shell"));
+ assert_eq!(
+ projects[1].terminals[0].title.as_deref(),
+ Some("Server logs")
+ );
+ assert_eq!(
+ projects[1].terminals[0].tab_name.as_deref(),
+ Some("other tab")
+ );
+}
+
+#[test]
+fn live_preview_handles_missing_and_unbounded_terminal_metadata() {
+ let workspaces = [json!({"workspace_id": "w1", "label": "example"})];
+ let panes = [
+ json!({"workspace_id": "w1", "terminal_title_stripped": " Tests\npassed ", "terminal_title": "raw title"}),
+ json!({"workspace_id": "w1", "terminal_title": "x".repeat(300)}),
+ json!({"workspace_id": "w1", "cwd": "/home/user/example"}),
+ ];
+ let projects = source::live_projects(&workspaces, &[], &panes);
+ assert_eq!(projects[0].panes, 3);
+ assert_eq!(
+ projects[0].terminals[0].title.as_deref(),
+ Some("Tests passed")
+ );
+ let long_title = projects[0].terminals[1].title.as_ref().unwrap();
+ assert_eq!(long_title.chars().count(), 257);
+ assert!(long_title.ends_with('…'));
+ assert!(projects[0].terminals[2].title.is_none());
+ assert!(projects[0].terminals[2].tab_name.is_none());
+ assert_eq!(
+ projects[0].terminals[2].cwd.as_deref(),
+ Some("/home/user/example")
+ );
+}
+
+#[test]
+fn saved_preview_preserves_terminal_labels_and_layout_order() {
+ let mut snapshot = snapshot();
+ snapshot.workspaces[0].tabs[0].layout = Layout::Split {
+ direction: Direction::Horizontal,
+ ratio: 0.5,
+ first: Box::new(Layout::Pane(2)),
+ second: Box::new(Layout::Pane(1)),
+ };
+ let projects = source::saved_projects(&snapshot);
+ assert_eq!((projects[0].tabs, projects[0].panes), (2, 3));
+ let terminals = &projects[0].terminals;
+ assert!(terminals[0].title.is_none());
+ assert_eq!(terminals[0].tab_name.as_deref(), Some("build"));
+ assert_eq!(terminals[0].cwd.as_deref(), Some("/home/user/example/sub"));
+ assert_eq!(terminals[1].title.as_deref(), Some("shell"));
+ assert_eq!(terminals[2].tab_name.as_deref(), Some("logs"));
+}
+
+#[test]
+fn saved_working_directories_are_rechecked_after_preview() {
+ let directory = tempfile::tempdir().unwrap();
+ let mut snapshot = snapshot();
+ for pane in snapshot
+ .workspaces
+ .iter_mut()
+ .flat_map(|workspace| &mut workspace.tabs)
+ .flat_map(|tab| tab.panes.values_mut())
+ {
+ pane.cwd = directory.path().to_str().unwrap().to_string();
+ }
+ snapshot.check_working_directories().unwrap();
+ directory.close().unwrap();
+ assert!(snapshot
+ .check_working_directories()
+ .unwrap_err()
+ .to_string()
+ .contains("working directory is unavailable"));
+}
+
+#[test]
+fn legacy_and_invalid_snapshots() {
+ let legacy = json!({"workspaces": [{"layout": {"Pane": 4}, "panes": {"4": {"cwd": "/home/user"}}, "zoomed": false}]});
+ let legacy = Snapshot::parse(&serde_json::to_vec(&legacy).unwrap()).unwrap();
+ assert_eq!(legacy.pane_count(), 1);
+ assert_eq!(legacy.workspaces[0].identity_cwd, "/home/user");
+ let mut snapshot = snapshot();
+ snapshot.version = 99;
+ assert!(snapshot.validate().is_err());
+ snapshot.version = 3;
+ snapshot.workspaces[0].tabs[1].layout = Layout::Pane(1);
+ assert!(snapshot.validate().is_err());
+ snapshot.workspaces[0].tabs[1].layout = Layout::Pane(3);
+ snapshot.workspaces[0].tabs[1]
+ .panes
+ .get_mut(&3)
+ .unwrap()
+ .cwd = "relative".into();
+ assert!(snapshot.validate().is_err());
+}
+
+#[test]
+fn received_fd_batches_include_the_sixty_fifth_pane() {
+ use rustix::net::{sendmsg, SendAncillaryBuffer, SendAncillaryMessage, SendFlags};
+ let pty = nix::pty::openpty(None, None).unwrap();
+ let (sender, receiver) = UnixStream::pair().unwrap();
+ let sending = std::thread::spawn(move || {
+ for count in [64, 1] {
+ let fds: Vec<_> = (0..count).map(|_| pty.master.as_fd()).collect();
+ let mut storage = [std::mem::MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(64))];
+ let mut ancillary = SendAncillaryBuffer::new(&mut storage);
+ assert!(ancillary.push(SendAncillaryMessage::ScmRights(&fds)));
+ sendmsg(
+ &sender,
+ &[std::io::IoSlice::new(b"F")],
+ &mut ancillary,
+ SendFlags::empty(),
+ )
+ .unwrap();
+ }
+ });
+ let fds = transport::receive_fds(&receiver, 65).unwrap();
+ assert_eq!(fds.len(), 65);
+ assert!(fds.iter().all(|fd| rustix::io::fcntl_getfd(fd)
+ .unwrap()
+ .contains(rustix::io::FdFlags::CLOEXEC)));
+ sending.join().unwrap();
+}
+
+#[test]
+fn json_reader_leaves_descriptor_marker_unconsumed() {
+ let (mut sender, mut receiver) = UnixStream::pair().unwrap();
+ sender.write_all(b"{}\nF").unwrap();
+ assert_eq!(source::read_line(&mut receiver, 16).unwrap(), b"{}");
+ let mut marker = [0];
+ receiver.read_exact(&mut marker).unwrap();
+ assert_eq!(marker, [b'F']);
+}
+
+#[test]
+fn source_manifest_requires_every_layout_pane() {
+ let manifest = model::Manifest {
+ version: 1,
+ source_version: "0.9.3".into(),
+ snapshot: snapshot(),
+ panes: vec![],
+ };
+ assert!(manifest
+ .validate()
+ .unwrap_err()
+ .to_string()
+ .contains("no live terminal"));
+}
+
+#[test]
+fn live_fingerprint_is_independent_of_json_map_order() {
+ let first = serde_json::from_str(r#"{"workspaces":[["w1","example"]],"tabs":[["t1","w1","shell"]],"panes":[["p1","term1","t1"]]}"#).unwrap();
+ let reordered = serde_json::from_str(r#"{"panes":[["p1","term1","t1"]],"tabs":[["t1","w1","shell"]],"workspaces":[["w1","example"]]}"#).unwrap();
+ assert_eq!(
+ source::live_fingerprint(first).unwrap(),
+ source::live_fingerprint(reordered).unwrap()
+ );
+}
+
+#[test]
+fn restores_negotiated_keyboard_paste_and_mouse_state() {
+ use wezterm_term::SnapshotKeyboardEncoding;
+ let runtime: Runtime = serde_json::from_value(json!({
+ "pane_id": 1, "child_pid": 123, "rows": 24, "cols": 80,
+ "keyboard_protocol_flags": 3,
+ "input_state": {"alternate_screen": true, "application_cursor": true,
+ "bracketed_paste": true, "focus_reporting": true,
+ "mouse_protocol_mode": "ButtonMotion", "mouse_protocol_encoding": "Sgr"}
+ }))
+ .unwrap();
+ let config = config::ConfigHandle::default_config();
+ assert!(!config.enable_kitty_keyboard);
+ let mut terminal = Terminal::new(
+ TerminalSize {
+ rows: runtime.rows as usize,
+ cols: runtime.cols as usize,
+ ..TerminalSize::default()
+ },
+ seed_config(config),
+ "ThinkTerm",
+ "test",
+ Box::new(std::io::sink()),
+ );
+ terminal.advance_bytes(seed::seed_ansi(&runtime).as_bytes());
+ let state = terminal.snapshot();
+ assert!(state.alt_screen_is_active);
+ assert!(state.modes.application_cursor_keys);
+ assert!(state.modes.bracketed_paste);
+ assert!(state.modes.focus_tracking);
+ assert!(state.modes.button_event_mouse);
+ assert_eq!(
+ state.alt_screen.keyboard_stack.last(),
+ Some(&SnapshotKeyboardEncoding::Kitty(3))
+ );
+ let mut restored = Terminal::new(
+ state.size,
+ Arc::new(config::TermConfig::with_config(
+ config::ConfigHandle::default_config(),
+ )),
+ "ThinkTerm",
+ "test",
+ Box::new(std::io::sink()),
+ );
+ restored.restore(state).unwrap();
+ assert_eq!(
+ SnapshotKeyboardEncoding::from(restored.get_keyboard_encoding()),
+ SnapshotKeyboardEncoding::Kitty(3)
+ );
+ for (ansi, expected) in [
+ ("\x1b[=1u", SnapshotKeyboardEncoding::Kitty(1)),
+ ("\x1b[>3u", SnapshotKeyboardEncoding::Kitty(3)),
+ ("\x1b[<u", SnapshotKeyboardEncoding::Kitty(1)),
+ ("\x1b[<u", SnapshotKeyboardEncoding::Xterm),
+ // Once the imported protocol is finished, the user's default
+ // applies to subsequent programs again.
+ ("\x1b[>3u", SnapshotKeyboardEncoding::Xterm),
+ ] {
+ restored.advance_bytes(ansi);
+ assert_eq!(
+ SnapshotKeyboardEncoding::from(restored.get_keyboard_encoding()),
+ expected
+ );
+ }
+}
+
+#[test]
+fn restores_each_mouse_encoding() {
+ for (source, expected) in [
+ ("Utf8", "Utf8"),
+ ("Sgr", "SGR"),
+ ("SgrPixels", "SgrPixels"),
+ ("X10", "X10"),
+ ] {
+ let runtime: Runtime = serde_json::from_value(json!({
+ "pane_id": 1, "child_pid": 123, "rows": 24, "cols": 80,
+ "input_state": {"mouse_protocol_mode": "ButtonMotion", "mouse_protocol_encoding": source}
+ })).unwrap();
+ let mut terminal = Terminal::new(
+ TerminalSize {
+ rows: runtime.rows as usize,
+ cols: runtime.cols as usize,
+ ..TerminalSize::default()
+ },
+ seed_config(config::ConfigHandle::default_config()),
+ "ThinkTerm",
+ "test",
+ Box::new(std::io::sink()),
+ );
+ terminal.advance_bytes(seed::seed_ansi(&runtime).as_bytes());
+ assert_eq!(
+ serde_json::to_value(terminal.snapshot().modes.mouse_encoding).unwrap(),
+ json!(expected)
+ );
+ }
+}
+
+fn seed_config(config: config::ConfigHandle) -> Arc<config::TermConfig> {
+ Arc::new(config::TermConfig::with_config(
+ config.adjusted(|config| config.enable_kitty_keyboard = true),
+ ))
+}
+
+#[test]
+fn normalized_plan_excludes_source_launch_commands() {
+ let plan = into_plan(snapshot(), ImportMode::Layout);
+ plan.validate().unwrap();
+ let encoded = serde_json::to_string(&plan).unwrap();
+ assert!(!encoded.contains("must-not"));
+ assert_eq!(plan.projects[0].threads[0].active_tab, 1);
+ assert_eq!(plan.pane_count(), 3);
+ assert_eq!(plan.projects[0].threads[0].tabs[0].focused, Some(2));
+ assert!(plan.projects[0].threads[0].tabs[0].zoomed);
+}
+
+#[test]
+fn saved_adapter_discovers_previews_and_rechecks_changed_layout() {
+ let directory = tempfile::tempdir().unwrap();
+ let context = ImportContext {
+ home: directory.path().to_owned(),
+ config_home: None,
+ executable: "/tmp/example".into(),
+ };
+ let root = context.home.join(".config/herdr");
+ std::fs::create_dir_all(&root).unwrap();
+ let mut saved = snapshot();
+ for pane in saved
+ .workspaces
+ .iter_mut()
+ .flat_map(|w| &mut w.tabs)
+ .flat_map(|t| t.panes.values_mut())
+ {
+ pane.cwd = directory.path().to_str().unwrap().into();
+ }
+ std::fs::write(
+ root.join("session.json"),
+ serde_json::to_vec(&saved).unwrap(),
+ )
+ .unwrap();
+ assert_eq!(HERDR.discover(&context).unwrap()[0].name, "default");
+ let preview = HERDR.preview(&context, "default").unwrap();
+ assert!(!preview.live);
+ assert_eq!(preview.pane_count(), 3);
+ let request = ImportRequest {
+ source: "herdr".into(),
+ session: "default".into(),
+ mode: ImportMode::Layout,
+ fingerprint: preview.fingerprint,
+ space_name: "Imported".into(),
+ };
+ let prepared = HERDR.prepare(&context, &request).unwrap();
+ prepared.validate().unwrap();
+ assert_eq!(prepared.plan.pane_count(), 3);
+ assert!(prepared.terminals.is_empty());
+ saved.workspaces[0].custom_name = Some("changed".into());
+ std::fs::write(
+ root.join("session.json"),
+ serde_json::to_vec(&saved).unwrap(),
+ )
+ .unwrap();
+ assert!(HERDR.prepare(&context, &request).is_err());
+}
+
+#[test]
+fn known_failures_are_localized_through_error_contexts() {
+ for (reason, key) in [
+ (
+ "This running Herdr server does not support live handoff",
+ "herdr-error-live-unsupported",
+ ),
+ (
+ "A saved Herdr working directory is unavailable",
+ "session-import-error-directory-missing",
+ ),
+ (
+ "Herdr changed since the preview; inspect the session again",
+ "session-import-error-changed",
+ ),
+ ] {
+ let error = anyhow::anyhow!(reason).context("Import local session");
+ assert_eq!(HERDR.error_key(&format!("{error:#}")), Some(key));
+ }
+}
diff --git a/thinkterm-import-herdr/src/transport.rs b/thinkterm-import-herdr/src/transport.rs
new file mode 100644
index 00000000..3f2ba9d1
--- /dev/null
+++ b/thinkterm-import-herdr/src/transport.rs
@@ -0,0 +1,262 @@
+use super::{model::Manifest, source};
+use anyhow::{ensure, Context, Result};
+use rustix::net::{recvmsg, RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, ReturnFlags};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::io::{IoSliceMut, Read, Write};
+use std::mem::MaybeUninit;
+use std::os::fd::OwnedFd;
+use std::os::unix::fs::PermissionsExt;
+use std::os::unix::net::{UnixListener, UnixStream};
+use std::path::Path;
+use std::sync::mpsc::{self, Receiver};
+use std::time::{Duration, Instant};
+
+pub struct Transfer {
+ pub manifest: Manifest,
+ pub fds: Vec<OwnedFd>,
+ stream: UnixStream,
+ _relay: tempfile::TempDir,
+ response: Receiver<Result<serde_json::Value>>,
+ committed: bool,
+}
+
+#[derive(Deserialize, Serialize)]
+struct Relay {
+ nonce: String,
+ socket: String,
+ token: String,
+}
+
+fn quote(value: &str) -> String {
+ format!("'{}'", value.replace('\'', "'\\''"))
+}
+
+/// Runs before configuration or GUI initialization in both owning binaries.
+pub fn maybe_run_relay() -> Option<Result<()>> {
+ let args: Vec<_> = std::env::args_os().collect();
+ if args.get(1).and_then(|s| s.to_str()) != Some("--herdr-import-relay") {
+ return None;
+ }
+ Some((|| {
+ ensure!(args.len() == 6, "Invalid Herdr import relay arguments");
+ let mut stream = UnixStream::connect(&args[2])?;
+ stream.set_read_timeout(Some(Duration::from_secs(10)))?;
+ stream.set_write_timeout(Some(Duration::from_secs(5)))?;
+ let relay = Relay {
+ nonce: args[3].to_str().context("Invalid nonce")?.into(),
+ socket: args[4].to_str().context("Invalid handoff path")?.into(),
+ token: args[5]
+ .to_str()
+ .context("Invalid handoff authorization")?
+ .into(),
+ };
+ serde_json::to_writer(&mut stream, &relay)?;
+ stream.write_all(b"\n")?;
+ // Keep the socket connected until the owner has read it. On macOS
+ // setting SO_RCVTIMEO on an already-disconnected accepted socket
+ // can fail even though its receive buffer still holds the message.
+ let mut ack = [0];
+ stream.read_exact(&mut ack)?;
+ ensure!(ack == [b'K'], "Herdr relay was not accepted");
+ Ok(())
+ })())
+}
+
+pub fn receive_fds(stream: &UnixStream, expected: usize) -> Result<Vec<OwnedFd>> {
+ let mut fds = Vec::with_capacity(expected);
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ let flags = RecvFlags::CMSG_CLOEXEC;
+ #[cfg(not(any(target_os = "linux", target_os = "android")))]
+ let flags = RecvFlags::empty();
+ while fds.len() < expected {
+ let mut storage = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(64))];
+ let mut ancillary = RecvAncillaryBuffer::new(&mut storage);
+ let mut data = [0u8];
+ let received = recvmsg(
+ stream,
+ &mut [IoSliceMut::new(&mut data)],
+ &mut ancillary,
+ flags,
+ )?;
+ let before = fds.len();
+ for message in ancillary.drain() {
+ if let RecvAncillaryMessage::ScmRights(batch) = message {
+ for fd in batch {
+ rustix::io::fcntl_setfd(&fd, rustix::io::FdFlags::CLOEXEC)?;
+ fds.push(fd);
+ }
+ }
+ }
+ ensure!(
+ !received.flags.contains(ReturnFlags::CTRUNC),
+ "Truncated Herdr descriptor batch"
+ );
+ ensure!(
+ received.bytes == 1 && data[0] == b'F' && fds.len() > before && fds.len() <= expected,
+ "Invalid Herdr descriptor batch"
+ );
+ }
+ for fd in &fds {
+ ensure!(
+ rustix::termios::isatty(fd),
+ "Herdr supplied a non-terminal descriptor"
+ );
+ }
+ Ok(fds)
+}
+
+pub fn receive(dir: &Path, exe: &Path) -> Result<Transfer> {
+ let relay_dir = tempfile::Builder::new()
+ .prefix("tt-hi-")
+ .tempdir_in("/tmp")?;
+ fs::set_permissions(relay_dir.path(), fs::Permissions::from_mode(0o700))?;
+ let rendezvous = relay_dir.path().join("relay.sock");
+ let listener = UnixListener::bind(&rendezvous)?;
+ listener.set_nonblocking(true)?;
+ let nonce = uuid::Uuid::new_v4().to_string();
+ let script = relay_dir.path().join("receive");
+ fs::write(
+ &script,
+ format!(
+ "#!/bin/sh\nexec {} --herdr-import-relay {} {} \"$3\" \"$4\"\n",
+ quote(exe.to_str().context("Executable path is not UTF-8")?),
+ quote(rendezvous.to_str().unwrap()),
+ quote(&nonce)
+ ),
+ )?;
+ fs::set_permissions(&script, fs::Permissions::from_mode(0o700))?;
+ let (sender, response) = mpsc::sync_channel(1);
+ let source_dir = dir.to_owned();
+ std::thread::Builder::new()
+ .name("herdr-handoff-request".into())
+ .spawn(move || {
+ let result = source::request(
+ &source_dir,
+ "server.live_handoff",
+ serde_json::json!({"import_exe": script}),
+ Duration::from_secs(120),
+ );
+ let _ = sender.send(result);
+ })?;
+ let deadline = Instant::now() + Duration::from_secs(30);
+ let mut relay_stream = loop {
+ match listener.accept() {
+ Ok((stream, _)) => break stream,
+ Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => {
+ if let Ok(result) = response.try_recv() {
+ result?;
+ anyhow::bail!("Herdr ended the handoff without a receiver");
+ }
+ ensure!(
+ Instant::now() < deadline,
+ "Herdr did not start its handoff receiver"
+ );
+ std::thread::sleep(Duration::from_millis(10));
+ }
+ Err(err) => return Err(err.into()),
+ }
+ };
+ relay_stream
+ .set_nonblocking(false)
+ .context("Set Herdr relay blocking mode")?;
+ relay_stream
+ .set_read_timeout(Some(Duration::from_secs(5)))
+ .context("Set Herdr relay timeout")?;
+ let relay: Relay = serde_json::from_slice(&source::read_line(&mut relay_stream, 16384)?)?;
+ ensure!(relay.nonce == nonce, "Herdr relay authorization failed");
+ relay_stream.write_all(b"K")?;
+ let socket = Path::new(&relay.socket);
+ ensure!(
+ socket
+ .parent()
+ .context("Invalid Herdr handoff path")?
+ .canonicalize()?
+ == dir.canonicalize()?
+ && socket
+ .file_name()
+ .and_then(|s| s.to_str())
+ .is_some_and(|s| s.starts_with("herdr-handoff-") && s.ends_with(".sock")),
+ "Unexpected Herdr handoff socket"
+ );
+ ensure!(
+ !relay.token.contains(['\n', '\r']) && relay.token.len() <= 256,
+ "Invalid Herdr handoff authorization"
+ );
+ let mut stream = UnixStream::connect(socket).context("Connect to Herdr handoff socket")?;
+ stream.set_read_timeout(Some(Duration::from_secs(30)))?;
+ stream.set_write_timeout(Some(Duration::from_secs(30)))?;
+ writeln!(stream, "{}", relay.token).context("Authorize Herdr handoff")?;
+ let manifest: Manifest =
+ serde_json::from_slice(&source::read_line(&mut stream, source::MAX_BYTES)?)?;
+ manifest.validate()?;
+ stream.write_all(b"validated\n")?;
+ let fds =
+ receive_fds(&stream, manifest.panes.len()).context("Receive Herdr terminal descriptors")?;
+ Ok(Transfer {
+ manifest,
+ fds,
+ stream,
+ _relay: relay_dir,
+ response,
+ committed: false,
+ })
+}
+
+impl Transfer {
+ pub fn commit(&mut self) -> Result<()> {
+ if !self.committed {
+ commit_stream(&mut self.stream)?;
+ self.committed = true;
+ }
+ Ok(())
+ }
+
+ pub fn finish(self) {
+ // The request thread has a finite socket timeout and does not own PTYs.
+ if let Ok(Err(err)) = self.response.try_recv() {
+ log::warn!("Herdr handoff response after commit: {err:#}");
+ }
+ }
+}
+
+fn commit_stream(stream: &mut UnixStream) -> Result<()> {
+ stream.write_all(b"restored\nready\n")?;
+ ensure!(
+ source::read_line(stream, 128)? == b"committed",
+ "Herdr did not commit the transfer"
+ );
+ // Herdr releases its runtimes after sending committed. Losing the final
+ // receipt must not discard the only remaining copies of the PTYs.
+ let _ = stream.write_all(b"owned\n");
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn committed_transfer_survives_lost_final_receipt() {
+ let (mut receiver, mut source) = UnixStream::pair().unwrap();
+ let peer = std::thread::spawn(move || {
+ assert_eq!(source::read_line(&mut source, 128).unwrap(), b"restored");
+ assert_eq!(source::read_line(&mut source, 128).unwrap(), b"ready");
+ source.shutdown(std::net::Shutdown::Read).unwrap();
+ source.write_all(b"committed\n").unwrap();
+ });
+ commit_stream(&mut receiver).unwrap();
+ peer.join().unwrap();
+ }
+
+ #[test]
+ fn source_failure_before_commit_is_not_success() {
+ let (mut receiver, mut source) = UnixStream::pair().unwrap();
+ let peer = std::thread::spawn(move || {
+ assert_eq!(source::read_line(&mut source, 128).unwrap(), b"restored");
+ assert_eq!(source::read_line(&mut source, 128).unwrap(), b"ready");
+ });
+ assert!(commit_stream(&mut receiver).is_err());
+ peer.join().unwrap();
+ }
+}
diff --git a/thinkterm-import/Cargo.toml b/thinkterm-import/Cargo.toml
new file mode 100644
index 00000000..0fb72bd8
--- /dev/null
+++ b/thinkterm-import/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "thinkterm-import"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+anyhow.workspace = true
+serde = { workspace = true, features = ["derive", "std"] }
+
+[dev-dependencies]
+serde_json.workspace = true
diff --git a/thinkterm-import/src/lib.rs b/thinkterm-import/src/lib.rs
new file mode 100644
index 00000000..e5ed2030
--- /dev/null
+++ b/thinkterm-import/src/lib.rs
@@ -0,0 +1,12 @@
+//! Source-independent session import plans and native adapter registration.
+//! The wire model also builds for wasm; adapters never depend on the mux.
+mod model;
+pub use model::*;
+
+#[cfg(unix)]
+mod source;
+#[cfg(unix)]
+pub use source::*;
+
+#[cfg(test)]
+mod tests;
diff --git a/thinkterm-import/src/model.rs b/thinkterm-import/src/model.rs
new file mode 100644
index 00000000..f5ef2974
--- /dev/null
+++ b/thinkterm-import/src/model.rs
@@ -0,0 +1,305 @@
+use anyhow::{ensure, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashSet};
+
+pub type PaneId = u32;
+pub const MAX_PANES: usize = 1024;
+pub const MAX_DEPTH: usize = 64;
+const MAX_TEXT: usize = 4096;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
+pub enum ImportMode {
+ Layout,
+ Live,
+}
+
+impl ImportMode {
+ pub fn is_live(self) -> bool {
+ self == Self::Live
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct ImportRequest {
+ pub source: String,
+ pub session: String,
+ pub mode: ImportMode,
+ pub fingerprint: String,
+ pub space_name: String,
+}
+
+impl ImportRequest {
+ pub fn validate(&self) -> Result<()> {
+ ensure!(valid_source_id(&self.source), "Invalid import source");
+ ensure!(
+ !self.session.is_empty() && self.session.len() <= MAX_TEXT,
+ "Invalid import session"
+ );
+ ensure!(
+ !self.fingerprint.is_empty() && self.fingerprint.len() <= 256,
+ "Invalid import fingerprint"
+ );
+ ensure!(
+ !self.space_name.trim().is_empty() && self.space_name.len() <= 256,
+ "Invalid imported Space name"
+ );
+ Ok(())
+ }
+}
+
+pub fn valid_source_id(id: &str) -> bool {
+ !id.is_empty()
+ && id.len() <= 64
+ && !id.starts_with('-')
+ && !id.ends_with('-')
+ && id
+ .bytes()
+ .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-')
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct Session {
+ pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct PreviewTerminal {
+ pub title: Option<String>,
+ pub tab_name: Option<String>,
+ pub cwd: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct PreviewProject {
+ pub name: String,
+ pub threads: usize,
+ pub tabs: usize,
+ pub panes: usize,
+ pub terminals: Vec<PreviewTerminal>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+pub struct Preview {
+ pub session: String,
+ pub live: bool,
+ pub version: Option<String>,
+ pub fingerprint: String,
+ pub projects: Vec<PreviewProject>,
+ pub unavailable: Option<String>,
+}
+
+impl Preview {
+ pub fn pane_count(&self) -> usize {
+ self.projects.iter().map(|p| p.panes).sum()
+ }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ImportPlan {
+ pub mode: ImportMode,
+ pub projects: Vec<Project>,
+ pub active: Selection,
+}
+
+#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize)]
+pub struct Selection {
+ pub project: usize,
+ pub thread: usize,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Project {
+ pub name: String,
+ pub directory: String,
+ pub threads: Vec<Thread>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Thread {
+ pub name: String,
+ pub tabs: Vec<Tab>,
+ pub active_tab: usize,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Tab {
+ pub name: Option<String>,
+ pub layout: Layout,
+ pub panes: BTreeMap<PaneId, Pane>,
+ pub focused: Option<PaneId>,
+ pub zoomed: bool,
+}
+
+/// Layout imports always start a fresh login shell, never a source command.
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Pane {
+ pub cwd: String,
+ pub title: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum Layout {
+ Pane(PaneId),
+ Stack {
+ panes: Vec<PaneId>,
+ active: usize,
+ },
+ Split {
+ direction: Direction,
+ ratio: f32,
+ first: Box<Layout>,
+ second: Box<Layout>,
+ },
+}
+
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
+pub enum Direction {
+ Horizontal,
+ Vertical,
+}
+
+impl Layout {
+ fn validate(
+ &self,
+ depth: usize,
+ panes: &BTreeMap<PaneId, Pane>,
+ seen: &mut HashSet<PaneId>,
+ selected: &mut HashSet<PaneId>,
+ ) -> Result<()> {
+ ensure!(depth <= MAX_DEPTH, "Import layout is too deeply nested");
+ let mut visit = |id: PaneId| -> Result<()> {
+ ensure!(
+ panes.contains_key(&id),
+ "Import layout references a missing terminal"
+ );
+ ensure!(seen.insert(id), "Import layout repeats a terminal");
+ ensure!(seen.len() <= MAX_PANES, "Import has too many terminals");
+ Ok(())
+ };
+ match self {
+ Self::Pane(id) => {
+ visit(*id)?;
+ selected.insert(*id);
+ }
+ Self::Stack { panes, active } => {
+ ensure!(
+ !panes.is_empty() && panes.len() <= MAX_PANES && *active < panes.len(),
+ "Invalid imported terminal stack"
+ );
+ for id in panes {
+ visit(*id)?;
+ }
+ selected.insert(panes[*active]);
+ }
+ Self::Split {
+ direction: _,
+ ratio,
+ first,
+ second,
+ } => {
+ ensure!(
+ ratio.is_finite() && *ratio > 0.0 && *ratio < 1.0,
+ "Invalid import split ratio"
+ );
+ first.validate(depth + 1, panes, seen, selected)?;
+ second.validate(depth + 1, panes, seen, selected)?;
+ }
+ }
+ Ok(())
+ }
+
+ pub fn first_pane(&self) -> PaneId {
+ match self {
+ Self::Pane(id) => *id,
+ Self::Stack { panes, active } => panes[*active],
+ Self::Split { first, .. } => first.first_pane(),
+ }
+ }
+}
+
+fn text(value: &str) -> Result<()> {
+ ensure!(value.len() <= MAX_TEXT, "Import text is too long");
+ Ok(())
+}
+
+fn directory(value: &str) -> Result<()> {
+ text(value)?;
+ ensure!(
+ !value.contains('\0') && std::path::Path::new(value).is_absolute(),
+ "Imported directory must be absolute"
+ );
+ Ok(())
+}
+
+impl ImportPlan {
+ pub fn tabs(&self) -> impl Iterator<Item = &Tab> {
+ self.projects
+ .iter()
+ .flat_map(|p| &p.threads)
+ .flat_map(|t| &t.tabs)
+ }
+
+ pub fn pane_count(&self) -> usize {
+ self.tabs().map(|tab| tab.panes.len()).sum()
+ }
+
+ pub fn validate(&self) -> Result<()> {
+ ensure!(
+ !self.projects.is_empty() && self.projects.len() <= MAX_PANES,
+ "Invalid imported project count"
+ );
+ ensure!(
+ self.active.project < self.projects.len()
+ && self.active.thread < self.projects[self.active.project].threads.len(),
+ "Invalid import selection"
+ );
+ let mut seen = HashSet::new();
+ let mut tab_count = 0;
+ let mut thread_count = 0;
+ for project in &self.projects {
+ text(&project.name)?;
+ directory(&project.directory)?;
+ ensure!(
+ !project.threads.is_empty(),
+ "Imported project has no threads"
+ );
+ thread_count += project.threads.len();
+ ensure!(thread_count <= MAX_PANES, "Import has too many threads");
+ for thread in &project.threads {
+ text(&thread.name)?;
+ ensure!(
+ !thread.tabs.is_empty() && thread.active_tab < thread.tabs.len(),
+ "Invalid imported tab selection"
+ );
+ tab_count += thread.tabs.len();
+ ensure!(tab_count <= MAX_PANES, "Import has too many tabs");
+ for tab in &thread.tabs {
+ if let Some(name) = &tab.name {
+ text(name)?;
+ }
+ let before = seen.len();
+ let mut selected = HashSet::new();
+ tab.layout
+ .validate(0, &tab.panes, &mut seen, &mut selected)?;
+ ensure!(
+ seen.len() - before == tab.panes.len(),
+ "Imported tab has terminals outside its layout"
+ );
+ if let Some(focused) = tab.focused {
+ ensure!(
+ selected.contains(&focused),
+ "Imported focus is not a visible terminal"
+ );
+ }
+ for pane in tab.panes.values() {
+ directory(&pane.cwd)?;
+ if let Some(title) = &pane.title {
+ text(title)?;
+ }
+ }
+ }
+ }
+ }
+ Ok(())
+ }
+}
diff --git a/thinkterm-import/src/source.rs b/thinkterm-import/src/source.rs
new file mode 100644
index 00000000..c11eecf0
--- /dev/null
+++ b/thinkterm-import/src/source.rs
@@ -0,0 +1,213 @@
+use crate::{ImportMode, ImportPlan, ImportRequest, PaneId, Preview, Session, MAX_PANES};
+use anyhow::{ensure, Context, Result};
+use std::collections::HashSet;
+use std::os::fd::OwnedFd;
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+#[derive(Debug, Clone)]
+pub struct ImportContext {
+ pub home: PathBuf,
+ pub config_home: Option<PathBuf>,
+ pub executable: PathBuf,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct SourceInfo {
+ pub id: &'static str,
+ pub name: &'static str,
+ pub icon: &'static str,
+}
+
+/// Adapters normalize source modes and history to ANSI. The owner parses it
+/// into a temporary terminal with a sink writer before attaching the PTY.
+#[derive(Debug, Clone)]
+pub struct TerminalSeed {
+ pub child_pid: u32,
+ pub rows: u16,
+ pub cols: u16,
+ pub cell_width_px: u32,
+ pub cell_height_px: u32,
+ pub title: Option<String>,
+ pub ansi: String,
+}
+
+pub struct LiveTerminal {
+ pub pane_id: PaneId,
+ pub seed: TerminalSeed,
+ pub pty: OwnedFd,
+}
+
+/// The adapter keeps its source paused until the owner has prepared every
+/// terminal. Dropping an uncommitted transfer must leave the source owning it.
+pub trait Handoff: Send {
+ fn commit(&mut self) -> Result<()>;
+ fn finish(self: Box<Self>);
+}
+
+pub struct PreparedImport {
+ pub plan: ImportPlan,
+ pub terminals: Vec<LiveTerminal>,
+ pub handoff: Option<Box<dyn Handoff>>,
+}
+
+impl PreparedImport {
+ pub fn validate(&self) -> Result<()> {
+ self.plan.validate()?;
+ if self.plan.mode == ImportMode::Layout {
+ ensure!(
+ self.terminals.is_empty() && self.handoff.is_none(),
+ "Layout import contains live resources"
+ );
+ for pane in self.plan.tabs().flat_map(|tab| tab.panes.values()) {
+ ensure!(
+ std::path::Path::new(&pane.cwd).is_dir(),
+ "An imported working directory is unavailable"
+ );
+ }
+ return Ok(());
+ }
+ ensure!(self.handoff.is_some(), "Live import has no handoff");
+ ensure!(
+ self.terminals.len() <= MAX_PANES,
+ "Import has too many live terminals"
+ );
+ let expected: HashSet<_> = self
+ .plan
+ .tabs()
+ .flat_map(|tab| tab.panes.keys().copied())
+ .collect();
+ let mut seen = HashSet::new();
+ let mut pids = HashSet::new();
+ let mut cells = 0u64;
+ for terminal in &self.terminals {
+ ensure!(
+ seen.insert(terminal.pane_id) && expected.contains(&terminal.pane_id),
+ "Unexpected imported terminal"
+ );
+ let seed = &terminal.seed;
+ ensure!(
+ seed.child_pid > 1
+ && seed.child_pid <= i32::MAX as u32
+ && pids.insert(seed.child_pid),
+ "Invalid imported process id"
+ );
+ ensure!(
+ seed.rows > 0
+ && seed.cols > 0
+ && seed.rows <= 4096
+ && seed.cols <= 4096
+ && u32::from(seed.rows) * u32::from(seed.cols) <= 1_000_000,
+ "Invalid imported terminal size"
+ );
+ cells += u64::from(seed.rows) * u64::from(seed.cols);
+ ensure!(
+ cells <= 16_000_000,
+ "Import exceeds the terminal cell limit"
+ );
+ ensure!(
+ seed.ansi.len() <= 16 * 1024
+ && seed.title.as_ref().is_none_or(|title| title.len() <= 4096),
+ "Imported terminal state is too large"
+ );
+ }
+ ensure!(
+ seen == expected,
+ "Some imported panes have no live terminal"
+ );
+ Ok(())
+ }
+}
+
+pub trait ImportSource: Send + Sync {
+ fn info(&self) -> SourceInfo;
+ fn discover(&self, context: &ImportContext) -> Result<Vec<Session>>;
+ fn preview(&self, context: &ImportContext, session: &str) -> Result<Preview>;
+ fn prepare(&self, context: &ImportContext, request: &ImportRequest) -> Result<PreparedImport>;
+ fn notes(&self, _mode: Option<ImportMode>) -> Vec<&'static str> {
+ vec![]
+ }
+ fn result_notes(&self) -> Vec<&'static str> {
+ vec![]
+ }
+ fn error_key(&self, _message: &str) -> Option<&'static str> {
+ None
+ }
+ fn run_helper(&self) -> Option<Result<()>> {
+ None
+ }
+}
+
+/// Composition roots register built-ins before starting the GUI or server.
+/// The mux knows this registry, never the crates implementing its sources.
+pub struct Registry {
+ sources: Vec<&'static dyn ImportSource>,
+}
+
+impl Registry {
+ pub const fn new() -> Self {
+ Self {
+ sources: Vec::new(),
+ }
+ }
+
+ pub fn register(&mut self, source: &'static dyn ImportSource) -> Result<()> {
+ let info = source.info();
+ ensure!(crate::valid_source_id(info.id), "Invalid import source");
+ ensure!(self.sources.len() < 32, "Too many import sources");
+ ensure!(
+ !self.sources.iter().any(|s| s.info().id == info.id),
+ "Import source is already registered"
+ );
+ self.sources.push(source);
+ Ok(())
+ }
+
+ pub fn get(&self, id: &str) -> Option<&'static dyn ImportSource> {
+ self.sources.iter().copied().find(|s| s.info().id == id)
+ }
+}
+
+static SOURCES: Mutex<Registry> = Mutex::new(Registry::new());
+
+pub fn register(source: &'static dyn ImportSource) -> Result<()> {
+ SOURCES.lock().unwrap().register(source)
+}
+
+pub fn sources() -> Vec<SourceInfo> {
+ SOURCES
+ .lock()
+ .unwrap()
+ .sources
+ .iter()
+ .map(|s| s.info())
+ .collect()
+}
+
+pub fn source(id: &str) -> Result<&'static dyn ImportSource> {
+ SOURCES
+ .lock()
+ .unwrap()
+ .get(id)
+ .context("Import source is not registered")
+}
+
+pub fn prepare(context: &ImportContext, request: &ImportRequest) -> Result<PreparedImport> {
+ request.validate()?;
+ let prepared = source(&request.source)?.prepare(context, request)?;
+ ensure!(
+ prepared.plan.mode == request.mode,
+ "Import mode changed after preview"
+ );
+ prepared.validate()?;
+ Ok(prepared)
+}
+
+pub fn maybe_run_helper() -> Option<Result<()>> {
+ for info in sources() {
+ if let Some(result) = source(info.id).ok()?.run_helper() {
+ return Some(result);
+ }
+ }
+ None
+}
diff --git a/thinkterm-import/src/tests.rs b/thinkterm-import/src/tests.rs
new file mode 100644
index 00000000..f184bb8f
--- /dev/null
+++ b/thinkterm-import/src/tests.rs
@@ -0,0 +1,154 @@
+use super::*;
+
+fn plan() -> ImportPlan {
+ ImportPlan {
+ mode: ImportMode::Layout,
+ active: Selection::default(),
+ projects: vec![Project {
+ name: "example".into(),
+ directory: "/home/user/example".into(),
+ threads: vec![Thread {
+ name: "development".into(),
+ active_tab: 0,
+ tabs: vec![Tab {
+ name: None,
+ layout: Layout::Stack {
+ panes: vec![1, 2],
+ active: 1,
+ },
+ focused: Some(2),
+ zoomed: false,
+ panes: [1, 2]
+ .into_iter()
+ .map(|id| {
+ (
+ id,
+ Pane {
+ cwd: "/home/user/example".into(),
+ title: None,
+ },
+ )
+ })
+ .collect(),
+ }],
+ }],
+ }],
+ }
+}
+
+#[test]
+fn validates_visible_focus_and_unique_panes_across_threads() {
+ let mut plan = plan();
+ plan.validate().unwrap();
+ assert_eq!(plan.projects[0].threads[0].tabs[0].layout.first_pane(), 2);
+ plan.projects[0].threads[0].tabs[0].focused = Some(1);
+ assert!(plan.validate().is_err());
+ plan.projects[0].threads[0].tabs[0].focused = None;
+ let duplicate = plan.projects[0].threads[0].clone();
+ plan.projects[0].threads.push(duplicate);
+ assert!(plan.validate().is_err());
+}
+
+#[test]
+fn rejects_invalid_layouts_and_selections() {
+ for layout in [
+ Layout::Pane(9),
+ Layout::Stack {
+ panes: vec![],
+ active: 0,
+ },
+ Layout::Stack {
+ panes: vec![1, 2],
+ active: 2,
+ },
+ Layout::Stack {
+ panes: vec![1, 1],
+ active: 0,
+ },
+ Layout::Split {
+ direction: Direction::Vertical,
+ ratio: f32::NAN,
+ first: Box::new(Layout::Pane(1)),
+ second: Box::new(Layout::Pane(2)),
+ },
+ ] {
+ let mut plan = plan();
+ plan.projects[0].threads[0].tabs[0].layout = layout;
+ assert!(plan.validate().is_err());
+ }
+ let mut plan = plan();
+ plan.active.thread = 1;
+ assert!(plan.validate().is_err());
+ plan.active.thread = 0;
+ plan.projects[0].threads[0].active_tab = 1;
+ assert!(plan.validate().is_err());
+}
+
+#[cfg(unix)]
+mod native {
+ use super::*;
+ use std::sync::{
+ atomic::{AtomicBool, Ordering},
+ Arc,
+ };
+
+ struct Source;
+ impl ImportSource for Source {
+ fn info(&self) -> SourceInfo {
+ SourceInfo {
+ id: "example",
+ name: "Example",
+ icon: "terminal",
+ }
+ }
+ fn discover(&self, _: &ImportContext) -> anyhow::Result<Vec<Session>> {
+ Ok(vec![])
+ }
+ fn preview(&self, _: &ImportContext, _: &str) -> anyhow::Result<Preview> {
+ anyhow::bail!("empty")
+ }
+ fn prepare(&self, _: &ImportContext, _: &ImportRequest) -> anyhow::Result<PreparedImport> {
+ anyhow::bail!("empty")
+ }
+ }
+ static SOURCE: Source = Source;
+
+ #[test]
+ fn registry_resolves_sources_and_rejects_duplicates() {
+ let mut registry = Registry::new();
+ registry.register(&SOURCE).unwrap();
+ assert_eq!(registry.get("example").unwrap().info().name, "Example");
+ assert!(registry.get("missing").is_none());
+ assert!(registry.register(&SOURCE).is_err());
+ }
+
+ struct Transfer(Arc<AtomicBool>);
+ impl Handoff for Transfer {
+ fn commit(&mut self) -> anyhow::Result<()> {
+ panic!("invalid resources must never commit")
+ }
+ fn finish(self: Box<Self>) {
+ panic!("invalid resources must never finish")
+ }
+ }
+ impl Drop for Transfer {
+ fn drop(&mut self) {
+ self.0.store(true, Ordering::SeqCst);
+ }
+ }
+
+ #[test]
+ fn incomplete_live_import_releases_transfer_without_commit() {
+ let released = Arc::new(AtomicBool::new(false));
+ let mut plan = plan();
+ plan.mode = ImportMode::Live;
+ let prepared = PreparedImport {
+ plan,
+ terminals: vec![],
+ handoff: Some(Box::new(Transfer(released.clone()))),
+ };
+ assert!(prepared.validate().is_err());
+ drop(prepared);
+ assert!(released.load(Ordering::SeqCst));
+ }
+}
diff --git a/wezterm-client/src/client.rs b/wezterm-client/src/client.rs
index 112e2c60..dbcc68f6 100644
--- a/wezterm-client/src/client.rs
+++ b/wezterm-client/src/client.rs
@@ -2446,6 +2446,10 @@ impl Client {
MutateThinkTermTree,
ThinkTermTreeState
);
+ rpc!(get_import_session_status, GetImportSessionStatus, GetImportSessionStatusResponse);
+ rpc!(import_session, ImportSessionRequest, ImportSessionResponse);
+ rpc!(list_import_sessions, ListImportSessions, ListImportSessionsResponse);
+ rpc!(preview_import_session, PreviewImportSession, PreviewImportSessionResponse);
rpc!(
get_thinkterm_session_state,
GetThinkTermSessionState = (),
diff --git a/wezterm-client/src/domain.rs b/wezterm-client/src/domain.rs
index 9ef800aa..a62eb3de 100644
--- a/wezterm-client/src/domain.rs
+++ b/wezterm-client/src/domain.rs
@@ -3339,6 +3339,58 @@ impl ClientDomain {
Ok(ResyncOutcome::NoClient)
}
+ pub async fn list_import_sessions(
+ &self,
+ source: String,
+ ) -> anyhow::Result<codec::ListImportSessionsResponse> {
+ let inner = self.inner().ok_or_else(|| anyhow!("domain is not attached"))?;
+ inner
+ .client
+ .list_import_sessions(codec::ListImportSessions { source })
+ .await
+ }
+
+ pub async fn preview_import_session(
+ &self,
+ source: String,
+ session: String,
+ ) -> anyhow::Result<codec::PreviewImportSessionResponse> {
+ let inner = self.inner().ok_or_else(|| anyhow!("domain is not attached"))?;
+ inner
+ .client
+ .preview_import_session(codec::PreviewImportSession { source, session })
+ .await
+ }
+
+ pub async fn get_import_session_status(
+ &self,
+ request_id: String,
+ ) -> anyhow::Result<codec::ImportSessionStatus> {
+ let inner = self.inner().ok_or_else(|| anyhow!("domain is not attached"))?;
+ Ok(inner
+ .client
+ .get_import_session_status(codec::GetImportSessionStatus { request_id })
+ .await?
+ .status)
+ }
+
+ pub async fn import_session(
+ &self,
+ request: codec::ImportSessionRequest,
+ ) -> anyhow::Result<codec::ImportSessionResponse> {
+ let inner = self.inner().ok_or_else(|| anyhow!("domain is not attached"))?;
+ let response = inner.client.import_session(request).await?;
+ // A committed handoff is successful even if a subsequent refresh
+ // loses the connection. Reattaching recovers the owner's new panes.
+ if let Err(err) = self.fetch_thinkterm_tree().await {
+ log::warn!("refreshing the tree after session import: {err:#}");
+ }
+ if let Err(err) = self.resync_after_mutation().await {
+ log::warn!("refreshing panes after session import: {err:#}");
+ }
+ Ok(response)
+ }
+
/// Send mutations of the server's ThinkTerm sidebar tree, hand the
/// authoritative result to the sink and return it to the initiating
/// workflow. Returning the tree lets destructive callers wait for an
diff --git a/wezterm-gui/Cargo.toml b/wezterm-gui/Cargo.toml
index 41bb985f..661264a7 100644
--- a/wezterm-gui/Cargo.toml
+++ b/wezterm-gui/Cargo.toml
@@ -44,6 +44,8 @@ cc.workspace = true
embed-resource.workspace = true
[dependencies]
+thinkterm-import-herdr.workspace = true
+thinkterm-import.workspace = true
anyhow.workspace = true
base64.workspace = true
bitflags.workspace = true
diff --git a/wezterm-mux-server-impl/Cargo.toml b/wezterm-mux-server-impl/Cargo.toml
index 62d4a7fb..36f1a3b3 100644
--- a/wezterm-mux-server-impl/Cargo.toml
+++ b/wezterm-mux-server-impl/Cargo.toml
@@ -8,6 +8,7 @@ publish = false
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
+thinkterm-import.workspace = true
anyhow.workspace = true
async-io.workspace = true
async_ossl.workspace = true
@@ -51,6 +52,7 @@ thinkterm-proto.workspace = true
[target."cfg(unix)".dependencies]
passfd.workspace = true
nix = { workspace = true, features = ["socket"] }
+rustix = { version = "1.1.2", features = ["net", "termios", "fs", "process", "event"] }
[target."cfg(windows)".dependencies]
winapi = { workspace=true, features = [ "winuser" ]}
diff --git a/wezterm-mux-server-impl/src/lib.rs b/wezterm-mux-server-impl/src/lib.rs
index 9534f224..456b9a64 100644
--- a/wezterm-mux-server-impl/src/lib.rs
+++ b/wezterm-mux-server-impl/src/lib.rs
@@ -9,6 +9,8 @@ pub mod connections;
pub mod dispatch;
#[cfg(unix)]
pub mod handoff;
+#[cfg(unix)]
+pub mod session_import;
pub mod local;
pub mod pki;
mod plugin_relay;
diff --git a/wezterm-mux-server-impl/src/session_import/layout.rs b/wezterm-mux-server-impl/src/session_import/layout.rs
new file mode 100644
index 00000000..120cb9c5
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/layout.rs
@@ -0,0 +1,87 @@
+use super::*;
+
+pub(super) fn minimum_size(layout: &Layout) -> (usize, usize) {
+ match layout {
+ Layout::Pane(_) | Layout::Stack { .. } => (2, 2),
+ Layout::Split {
+ direction,
+ first,
+ second,
+ ..
+ } => {
+ let (a, b) = (minimum_size(first), minimum_size(second));
+ match direction {
+ Direction::Horizontal => (a.0 + b.0 + 1, a.1.max(b.1)),
+ Direction::Vertical => (a.0.max(b.0), a.1 + b.1 + 1),
+ }
+ }
+ }
+}
+
+pub(super) fn layout_tree(
+ layout: &Layout,
+ size: TerminalSize,
+ entries: &HashMap<u32, PaneEntry>,
+) -> PaneNode {
+ match layout {
+ Layout::Pane(id) => {
+ let mut entry = entries[id].clone();
+ entry.size = size;
+ PaneNode::Leaf(entry)
+ }
+ Layout::Stack { panes, active } => PaneNode::Stack(thinkterm_proto::PaneStackEntry {
+ active: *active,
+ panes: panes
+ .iter()
+ .map(|id| {
+ let mut entry = entries[id].clone();
+ entry.size = size;
+ entry
+ })
+ .collect(),
+ pane_stack_id: None,
+ }),
+ Layout::Split {
+ direction,
+ ratio,
+ first,
+ second,
+ } => {
+ let (min_a, min_b) = (minimum_size(first), minimum_size(second));
+ let (mut a, mut b) = (size, size);
+ let horizontal = matches!(direction, Direction::Horizontal);
+ let extent = if horizontal { size.cols } else { size.rows };
+ let (min_a, min_b) = if horizontal {
+ (min_a.0, min_b.0)
+ } else {
+ (min_a.1, min_b.1)
+ };
+ let share =
+ (((extent - 1) as f32 * ratio).round() as usize).clamp(min_a, extent - 1 - min_b);
+ if horizontal {
+ a.cols = share;
+ b.cols = extent - 1 - share;
+ } else {
+ a.rows = share;
+ b.rows = extent - 1 - share;
+ }
+ for child in [&mut a, &mut b] {
+ child.pixel_width = size.pixel_width / size.cols * child.cols;
+ child.pixel_height = size.pixel_height / size.rows * child.rows;
+ }
+ PaneNode::Split {
+ left: Box::new(layout_tree(first, a, entries)),
+ right: Box::new(layout_tree(second, b, entries)),
+ node: SplitDirectionAndSize {
+ direction: if horizontal {
+ SplitDirection::Horizontal
+ } else {
+ SplitDirection::Vertical
+ },
+ first: a,
+ second: b,
+ },
+ }
+ }
+ }
+}
diff --git a/wezterm-mux-server-impl/src/session_import/mod.rs b/wezterm-mux-server-impl/src/session_import/mod.rs
new file mode 100644
index 00000000..88d38a0b
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/mod.rs
@@ -0,0 +1,521 @@
+//! Execute validated import plans in their terminal owner. Source adapters
+//! register outside this crate and retain their own discovery and protocols.
+mod layout;
+mod pending;
+mod pty;
+mod receipt;
+#[cfg(test)]
+mod tests;
+
+use anyhow::{ensure, Context, Result};
+use codec::{ImportSessionRequest, ImportSessionResponse, ThinkTermTree, TreeOp};
+use layout::{layout_tree, minimum_size};
+use mux::localpane::LocalPane;
+use mux::pane::{alloc_pane_id, Pane, PaneId};
+use mux::tab::Tab;
+use mux::window::Window;
+use mux::Mux;
+pub(crate) use pending::ensure_not_pending;
+pub use pending::wait_for_workspace;
+use portable_pty::{CommandBuilder, MasterPty};
+use promise::spawn::spawn_into_new_thread;
+use std::collections::HashMap;
+use std::sync::Arc;
+use thinkterm_import::{Direction, Handoff, ImportContext, ImportPlan, Layout, TerminalSeed};
+use thinkterm_proto::{PaneEntry, PaneNode, SplitDirection, SplitDirectionAndSize};
+use wezterm_term::{Terminal, TerminalSize};
+
+static IMPORT: smol::lock::Mutex<()> = smol::lock::Mutex::new(());
+
+struct LivePane {
+ id: PaneId,
+ pid: u32,
+ terminal: Terminal,
+ master: pty::ImportedPty,
+}
+
+struct Prepared {
+ plan: ImportPlan,
+ transfer: Option<Box<dyn Handoff>>,
+ panes: HashMap<u32, LivePane>,
+}
+
+/// Layouts are available before the live handoff commits, including panes
+/// that have not yet been attached to the mux or displayed by a frontend.
+pub struct ImportedThreadLayout {
+ pub thread_id: String,
+ pub active_tab: usize,
+ pub tabs: Vec<PaneNode>,
+}
+
+pub fn context() -> Result<ImportContext> {
+ Ok(ImportContext {
+ home: config::HOME_DIR.to_path_buf(),
+ config_home: std::env::var_os("XDG_CONFIG_HOME").map(Into::into),
+ executable: std::env::current_exe()?,
+ })
+}
+
+pub fn discover(request: codec::ListImportSessions) -> Result<codec::ListImportSessionsResponse> {
+ ensure!(
+ thinkterm_import::valid_source_id(&request.source),
+ "Invalid import source"
+ );
+ let source = thinkterm_import::source(&request.source)?;
+ Ok(codec::ListImportSessionsResponse {
+ sessions: source.discover(&context()?)?,
+ notes: source.notes(None).into_iter().map(str::to_owned).collect(),
+ })
+}
+
+pub fn preview(
+ request: codec::PreviewImportSession,
+) -> Result<codec::PreviewImportSessionResponse> {
+ ensure!(
+ thinkterm_import::valid_source_id(&request.source),
+ "Invalid import source"
+ );
+ ensure!(
+ !request.session.is_empty() && request.session.len() <= 4096,
+ "Invalid import session"
+ );
+ let source = thinkterm_import::source(&request.source)?;
+ let preview = source.preview(&context()?, &request.session)?;
+ let mode = if preview.live {
+ thinkterm_import::ImportMode::Live
+ } else {
+ thinkterm_import::ImportMode::Layout
+ };
+ Ok(codec::PreviewImportSessionResponse {
+ notes: source
+ .notes(Some(mode))
+ .into_iter()
+ .map(str::to_owned)
+ .collect(),
+ preview,
+ })
+}
+
+fn initial_size(seed: &TerminalSeed) -> TerminalSize {
+ TerminalSize {
+ rows: seed.rows as usize,
+ cols: seed.cols as usize,
+ pixel_width: seed.cols as usize * seed.cell_width_px.min(1024) as usize,
+ pixel_height: seed.rows as usize * seed.cell_height_px.min(1024) as usize,
+ dpi: 96,
+ }
+}
+
+fn seed_config(config: config::ConfigHandle) -> Arc<config::TermConfig> {
+ Arc::new(config::TermConfig::with_config(
+ config.adjusted(|config| config.enable_kitty_keyboard = true),
+ ))
+}
+
+fn prepare(request: &thinkterm_import::ImportRequest) -> Result<Prepared> {
+ let imported = thinkterm_import::prepare(&context()?, request)?;
+ let saved: HashMap<_, _> = imported
+ .plan
+ .tabs()
+ .flat_map(|tab| tab.panes.iter())
+ .collect();
+ let mut panes = HashMap::new();
+ for live in imported.terminals {
+ let master = pty::ImportedPty::prepare(live.pty).context("Prepare imported PTY")?;
+ let size = initial_size(&live.seed);
+ // Restoring saved output cannot send a reply to a process still owned
+ // by the source. Only the final terminal receives the live writer.
+ let mut seed_terminal = Terminal::new(
+ size,
+ seed_config(config::configuration()),
+ "ThinkTerm",
+ config::wezterm_version(),
+ Box::new(std::io::sink()),
+ );
+ seed_terminal.advance_bytes(live.seed.ansi.as_bytes());
+ let mut state = seed_terminal.snapshot();
+ state.identity.title = saved[&live.pane_id]
+ .title
+ .clone()
+ .or(live.seed.title)
+ .unwrap_or_default();
+ let mut terminal = Terminal::new(
+ size,
+ Arc::new(config::TermConfig::new()),
+ "ThinkTerm",
+ config::wezterm_version(),
+ master.take_writer()?,
+ );
+ terminal
+ .restore(state)
+ .context("Prepare imported terminal state")?;
+ panes.insert(
+ live.pane_id,
+ LivePane {
+ id: alloc_pane_id(),
+ pid: live.seed.child_pid,
+ terminal,
+ master,
+ },
+ );
+ }
+ Ok(Prepared {
+ plan: imported.plan,
+ transfer: imported.handoff,
+ panes,
+ })
+}
+
+pub fn tree_ops(tree: &ThinkTermTree, add: bool) -> Vec<TreeOp> {
+ let mut ops = Vec::new();
+ for space in &tree.spaces {
+ ops.push(if add {
+ TreeOp::CreateSpace {
+ space_id: space.id.clone(),
+ name: space.name.clone(),
+ }
+ } else {
+ TreeOp::DeleteSpace {
+ space_id: space.id.clone(),
+ }
+ });
+ }
+ if add {
+ for project in &tree.projects {
+ ops.push(TreeOp::CreateProject {
+ project_id: project.id.clone(),
+ space_id: project.space_id.clone(),
+ name: project.name.clone(),
+ path: project.path.clone(),
+ });
+ for thread in &project.threads {
+ ops.push(TreeOp::CreateThread {
+ thread_id: thread.id.clone(),
+ project_id: project.id.clone(),
+ name: thread.name.clone(),
+ workspace: thread.materialized_workspace_name.clone(),
+ created_at: thread.last_active_at,
+ });
+ }
+ }
+ }
+ ops
+}
+
+fn make_tree(plan: &ImportPlan, name: &str) -> ThinkTermTree {
+ let space_id = uuid::Uuid::new_v4().to_string();
+ let mut tree = ThinkTermTree::default();
+ tree.spaces.push(codec::TtSpace {
+ id: space_id.clone(),
+ name: name.into(),
+ });
+ for project in &plan.projects {
+ let project_id = format!("project-{}", uuid::Uuid::new_v4());
+ let threads = project
+ .threads
+ .iter()
+ .map(|thread| {
+ let thread_id = format!("thread-{}", uuid::Uuid::new_v4());
+ let workspace = format!("thinkterm:{}:{}", project_id, thread_id);
+ codec::TtThread {
+ id: thread_id,
+ project_id: project_id.clone(),
+ name: thread.name.clone(),
+ planned_workspace_name: Some(workspace.clone()),
+ materialized_workspace_name: Some(workspace),
+ last_active_at: std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs() as i64,
+ is_pinned: false,
+ is_unread: false,
+ }
+ })
+ .collect();
+ tree.projects.push(codec::TtProject {
+ id: project_id,
+ space_id: space_id.clone(),
+ name: project.name.clone(),
+ path: project.directory.clone(),
+ archived_at: None,
+ threads,
+ });
+ }
+ tree
+}
+
+pub fn status(request_id: &str) -> Result<codec::ImportSessionStatus> {
+ receipt::Store::owner().status(request_id)
+}
+
+/// The owner persists the new rows and their layouts before committing the
+/// handoff. Failed preparation or commit removes those rows and newly spawned
+/// shells without touching any existing session.
+pub async fn execute<F>(request: ImportSessionRequest, persist: F) -> Result<ImportSessionResponse>
+where
+ F: FnMut(&ThinkTermTree, bool, &[ImportedThreadLayout]) -> Result<()>,
+{
+ let _import = IMPORT.lock().await;
+ let attempt = match receipt::Store::owner().start(request.clone())? {
+ receipt::Started::Completed(result) => return Ok(result),
+ receipt::Started::New(attempt) => attempt,
+ };
+ let result = execute_new(request.request, persist, &attempt).await;
+ match result {
+ Ok(result) => {
+ attempt.complete().context(
+ "Save completed import receipt; query the import result before retrying",
+ )?;
+ Ok(result)
+ }
+ Err(err) => {
+ attempt
+ .fail(&format!("{err:#}"))
+ .context("Save failed import receipt; query the import result before retrying")?;
+ Err(err)
+ }
+ }
+}
+
+async fn execute_new<F>(
+ request: thinkterm_import::ImportRequest,
+ mut persist: F,
+ attempt: &receipt::Attempt,
+) -> Result<ImportSessionResponse>
+where
+ F: FnMut(&ThinkTermTree, bool, &[ImportedThreadLayout]) -> Result<()>,
+{
+ let _activity = mux::activity::Activity::new();
+ request.validate()?;
+ let mux = Mux::get();
+ let domain = mux
+ .get_domain_by_name("local")
+ .context("Local terminal domain is unavailable")?;
+ ensure!(
+ domain
+ .downcast_ref::<mux::domain::LocalDomain>()
+ .is_some_and(|d| d.is_plain_local()),
+ "Session import requires a local terminal owner"
+ );
+ let prepare_request = request.clone();
+ let mut prepared = spawn_into_new_thread(move || prepare(&prepare_request)).await?;
+ let tree = make_tree(&prepared.plan, request.space_name.trim());
+ let selected = prepared.plan.active;
+ let response = ImportSessionResponse {
+ space_id: tree.spaces[0].id.clone(),
+ workspace: tree.projects[selected.project].threads[selected.thread]
+ .materialized_workspace_name
+ .clone()
+ .unwrap(),
+ live: request.mode.is_live(),
+ pane_count: prepared.plan.pane_count(),
+ tree: tree.clone(),
+ };
+ attempt
+ .destination(response.clone())
+ .context("Save import destination before handoff")?;
+
+ let mut panes: HashMap<u32, Arc<dyn Pane>> = HashMap::new();
+ if prepared.transfer.is_none() {
+ for tab in prepared.plan.tabs() {
+ for (id, saved) in &tab.panes {
+ // default_prog may be an agent or other saved command. A
+ // layout import only starts a login shell at the saved cwd.
+ let shell = CommandBuilder::new_default_prog().get_shell();
+ let mut command = CommandBuilder::new(&shell);
+ command.arg("-l");
+ command.env("SHELL", &shell);
+ command.set_require_cwd(true);
+ command.cwd(&saved.cwd);
+ match domain
+ .spawn_pane(
+ TerminalSize::default(),
+ Some(command),
+ Some(saved.cwd.clone()),
+ )
+ .await
+ {
+ Ok(pane) => {
+ if let Some(title) = &saved.title {
+ pane.perform_actions(vec![
+ termwiz::escape::Action::OperatingSystemCommand(Box::new(
+ termwiz::escape::OperatingSystemCommand::SetWindowTitle(
+ title.clone(),
+ ),
+ )),
+ ]);
+ }
+ panes.insert(*id, pane);
+ }
+ Err(err) => {
+ for pane in panes.values() {
+ mux.remove_pane(pane.pane_id());
+ }
+ return Err(err.context("Create imported shells"));
+ }
+ }
+ }
+ }
+ }
+ let mut windows = Vec::new();
+ let mut layouts = Vec::new();
+ for (saved_project, project) in prepared.plan.projects.iter().zip(&tree.projects) {
+ for (saved_thread, thread) in saved_project.threads.iter().zip(&project.threads) {
+ let workspace = thread.materialized_workspace_name.as_ref().unwrap();
+ let window = Window::new(Some(workspace.clone()), None, None);
+ let mut tabs = Vec::new();
+ let mut roots = Vec::new();
+ for saved_tab in &saved_thread.tabs {
+ let (min_cols, min_rows) = minimum_size(&saved_tab.layout);
+ let size = TerminalSize {
+ cols: 120.max(min_cols),
+ rows: 36.max(min_rows),
+ ..TerminalSize::default()
+ };
+ let tab = Arc::new(Tab::new(&size));
+ if let Some(title) = &saved_tab.name {
+ tab.set_title(title);
+ }
+ let focused = saved_tab
+ .focused
+ .unwrap_or_else(|| saved_tab.layout.first_pane());
+ let entries = saved_tab
+ .panes
+ .iter()
+ .map(|(id, saved)| {
+ let pane_id = prepared
+ .panes
+ .get(id)
+ .map(|p| p.id)
+ .unwrap_or_else(|| panes[id].pane_id());
+ (
+ *id,
+ PaneEntry {
+ window_id: window.window_id(),
+ tab_id: tab.tab_id(),
+ pane_id,
+ title: saved.title.clone().unwrap_or_default(),
+ size,
+ working_dir: url::Url::from_directory_path(&saved.cwd)
+ .ok()
+ .map(Into::into),
+ is_active_pane: *id == focused,
+ is_zoomed_pane: saved_tab.zoomed && *id == focused,
+ alt_screen: false,
+ workspace: workspace.clone(),
+ cursor_pos: Default::default(),
+ physical_top: 0,
+ top_row: 0,
+ left_col: 0,
+ tty_name: None,
+ },
+ )
+ })
+ .collect();
+ let root = layout_tree(&saved_tab.layout, size, &entries);
+ roots.push(root);
+ tabs.push((tab, size));
+ }
+ layouts.push(ImportedThreadLayout {
+ thread_id: thread.id.clone(),
+ active_tab: saved_thread.active_tab,
+ tabs: roots,
+ });
+ windows.push((window, tabs, saved_thread.active_tab));
+ }
+ }
+ let pending = pending::PendingImport::new(
+ tree.projects
+ .iter()
+ .flat_map(|project| &project.threads)
+ .map(|thread| thread.materialized_workspace_name.clone().unwrap())
+ .collect(),
+ );
+ if let Err(err) = persist(&tree, true, &layouts) {
+ for pane in panes.values() {
+ mux.remove_pane(pane.pane_id());
+ }
+ return Err(err.context("Save imported Space before handoff"));
+ }
+ if prepared.transfer.is_some() {
+ let (returned, committed) = spawn_into_new_thread(move || {
+ let result = prepared.transfer.as_mut().unwrap().commit();
+ if result.is_ok() {
+ let sizes: Vec<_> = prepared
+ .panes
+ .values()
+ .filter_map(|pane| pane.master.get_size().ok().map(|size| (pane, size)))
+ .collect();
+ for (pane, size) in &sizes {
+ let mut smaller = *size;
+ if smaller.rows > 2 {
+ smaller.rows -= 1;
+ } else if smaller.cols > 2 {
+ smaller.cols -= 1;
+ }
+ let _ = pane.master.resize(smaller);
+ }
+ std::thread::sleep(std::time::Duration::from_millis(30));
+ for (pane, size) in sizes {
+ let _ = pane.master.resize(size);
+ }
+ }
+ Ok((prepared, result))
+ })
+ .await?;
+ prepared = returned;
+ let transfer = prepared.transfer.take().unwrap();
+ if let Err(err) = committed {
+ drop(transfer);
+ return Err(match persist(&tree, false, &layouts) {
+ Ok(()) => err.context("Session handoff did not commit"),
+ Err(rollback) => err.context(format!("Session handoff did not commit; removing the empty imported Space also failed: {rollback:#}")),
+ });
+ }
+ for (id, live) in prepared.panes.drain() {
+ let writer = live.terminal.writer_handle();
+ let pane: Arc<dyn Pane> = Arc::new(LocalPane::new(
+ live.id,
+ live.terminal,
+ portable_pty::adopted_child(live.pid),
+ Box::new(live.master),
+ writer,
+ domain.domain_id(),
+ "Imported terminal".into(),
+ ));
+ mux.add_pane(&pane)
+ .expect("reserved imported terminal reader");
+ panes.insert(id, pane);
+ }
+ transfer.finish();
+ }
+ let by_id: HashMap<_, _> = panes
+ .values()
+ .map(|pane| (pane.pane_id(), Arc::clone(pane)))
+ .collect();
+ for ((window, tabs, active), layout) in windows.into_iter().zip(layouts) {
+ let builder = mux.insert_window(window);
+ for ((tab, size), root) in tabs.into_iter().zip(layout.tabs) {
+ for entry in root.entries() {
+ let target = if entry.is_zoomed_pane {
+ size
+ } else {
+ entry.size
+ };
+ if let Err(err) = by_id[&entry.pane_id].resize(target) {
+ log::warn!("resizing an imported terminal: {err:#}");
+ }
+ }
+ tab.sync_with_pane_tree(size, root, |entry| Arc::clone(&by_id[&entry.pane_id]));
+ mux.add_tab_no_panes(&tab);
+ mux.add_tab_to_window(&tab, *builder)
+ .expect("new imported window");
+ }
+ if let Some(mut window) = mux.get_window_mut(*builder) {
+ let active = active.min(window.len().saturating_sub(1));
+ window.set_active_without_saving(active);
+ }
+ }
+ pending.finish();
+ Ok(response)
+}
diff --git a/wezterm-mux-server-impl/src/session_import/pending.rs b/wezterm-mux-server-impl/src/session_import/pending.rs
new file mode 100644
index 00000000..53c6482b
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/pending.rs
@@ -0,0 +1,115 @@
+use anyhow::{ensure, Result};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+struct Completion {
+ done: smol::channel::Receiver<()>,
+ installed: AtomicBool,
+}
+
+lazy_static::lazy_static! {
+ static ref PENDING: Mutex<HashMap<String, Arc<Completion>>> = Mutex::new(HashMap::new());
+}
+
+/// Registered before publishing tree rows, released on success or any early
+/// return. Only the serialized importer registers workspaces; its validated
+/// plan bounds their number by MAX_PANES.
+pub(super) struct PendingImport {
+ workspaces: Vec<String>,
+ completion: Arc<Completion>,
+ _done: smol::channel::Sender<()>,
+}
+
+impl PendingImport {
+ pub(super) fn new(workspaces: Vec<String>) -> Self {
+ let (done, receiver) = smol::channel::bounded(1);
+ let completion = Arc::new(Completion {
+ done: receiver,
+ installed: AtomicBool::new(false),
+ });
+ let mut pending = PENDING.lock().unwrap();
+ assert!(pending.len() + workspaces.len() <= thinkterm_import::MAX_PANES);
+ for workspace in &workspaces {
+ assert!(pending
+ .insert(workspace.clone(), completion.clone())
+ .is_none());
+ }
+ Self {
+ workspaces,
+ completion,
+ _done: done,
+ }
+ }
+
+ pub(super) fn finish(self) {
+ self.completion.installed.store(true, Ordering::Release);
+ }
+}
+
+impl Drop for PendingImport {
+ fn drop(&mut self) {
+ let mut pending = PENDING.lock().unwrap();
+ for workspace in &self.workspaces {
+ pending.remove(workspace);
+ }
+ // Dropping the sole sender wakes every waiter, including on failure.
+ }
+}
+
+pub async fn wait_for_workspace(workspace: &str) -> Result<()> {
+ let completion = PENDING.lock().unwrap().get(workspace).cloned();
+ if let Some(completion) = completion {
+ let _ = completion.done.recv().await;
+ ensure!(
+ completion.installed.load(Ordering::Acquire),
+ "Session import did not finish; reopen the Space after checking the import result"
+ );
+ }
+ Ok(())
+}
+
+pub(crate) fn ensure_not_pending(workspace: &str) -> Result<()> {
+ ensure!(
+ !PENDING.lock().unwrap().contains_key(workspace),
+ "Session import is still in progress; open its Space after it completes"
+ );
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use futures::{pin_mut, poll};
+
+ #[test]
+ fn waits_for_installation_without_blocking_other_workspaces() {
+ smol::block_on(async {
+ let guard = PendingImport::new(vec!["import-wait-example".into()]);
+ let first = wait_for_workspace("import-wait-example");
+ let second = wait_for_workspace("import-wait-example");
+ pin_mut!(first, second);
+ assert!(poll!(&mut first).is_pending());
+ assert!(poll!(&mut second).is_pending());
+ assert!(ensure_not_pending("import-wait-example").is_err());
+ wait_for_workspace("unrelated-example").await.unwrap();
+ guard.finish();
+ first.await.unwrap();
+ second.await.unwrap();
+ ensure_not_pending("import-wait-example").unwrap();
+ });
+ }
+
+ #[test]
+ fn failed_or_cancelled_import_releases_waiters_with_an_error() {
+ smol::block_on(async {
+ let guard = PendingImport::new(vec!["import-failed-example".into()]);
+ let waiting = wait_for_workspace("import-failed-example");
+ pin_mut!(waiting);
+ assert!(poll!(&mut waiting).is_pending());
+ drop(guard);
+ assert!(waiting.await.is_err());
+ ensure_not_pending("import-failed-example").unwrap();
+ });
+ }
+}
diff --git a/wezterm-mux-server-impl/src/session_import/pty.rs b/wezterm-mux-server-impl/src/session_import/pty.rs
new file mode 100644
index 00000000..02095f4b
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/pty.rs
@@ -0,0 +1,158 @@
+use anyhow::{Context, Result};
+use portable_pty::{MasterPty, PtySize};
+use rustix::event::{poll, PollFd, PollFlags};
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::os::fd::{AsFd, AsRawFd, OwnedFd, RawFd};
+use std::path::PathBuf;
+use std::sync::Mutex;
+
+/// Duplicates are reserved before commit; dropping them only closes them.
+/// Unlike UnixMasterWriter, these files never inject EOF when dropped.
+#[derive(Debug)]
+pub struct ImportedPty {
+ master: OwnedFd,
+ reader: Mutex<Option<File>>,
+ writer: Mutex<Option<File>>,
+}
+
+struct ImportedWriter(File);
+
+struct ImportedReader(File);
+
+impl Read for ImportedReader {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ loop {
+ match self.0.read(buf) {
+ Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => {
+ // Preserve the source's shared O_NONBLOCK flag, but keep
+ // Read blocking even if the mux could not allocate its
+ // wake pipe. Poll needs no additional descriptors.
+ let mut fds = [PollFd::new(&self.0, PollFlags::IN)];
+ match poll(&mut fds, None) {
+ Err(rustix::io::Errno::INTR) => continue,
+ Err(err) => return Err(err.into()),
+ Ok(_) => {
+ if fds[0].revents().contains(PollFlags::NVAL) {
+ return Err(io::Error::from_raw_os_error(libc::EBADF));
+ }
+ // Read again on HUP/ERR too: a hung-up PTY can
+ // still have output buffered before its EOF.
+ }
+ }
+ }
+ result => return result,
+ }
+ }
+ }
+}
+
+impl Write for ImportedWriter {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ // The source's duplicates share O_NONBLOCK with the source PTY. Leave
+ // that flag intact for rollback, but complete each queued write.
+ let mut remaining = buf;
+ while !remaining.is_empty() {
+ match self.0.write(remaining) {
+ Ok(0) => return Err(io::ErrorKind::WriteZero.into()),
+ Ok(count) => remaining = &remaining[count..],
+ Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => loop {
+ let mut fds = [PollFd::new(&self.0, PollFlags::OUT)];
+ match poll(&mut fds, None) {
+ Err(rustix::io::Errno::INTR) => continue,
+ Err(err) => return Err(err.into()),
+ Ok(_) => {
+ if fds[0]
+ .revents()
+ .intersects(PollFlags::ERR | PollFlags::HUP | PollFlags::NVAL)
+ {
+ return Err(io::ErrorKind::BrokenPipe.into());
+ }
+ break;
+ }
+ }
+ },
+ Err(err) => return Err(err),
+ }
+ }
+ Ok(buf.len())
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ self.0.flush()
+ }
+}
+
+impl ImportedPty {
+ pub fn prepare(master: OwnedFd) -> Result<Self> {
+ let reader = File::from(master.try_clone()?);
+ let writer = File::from(master.try_clone()?);
+ rustix::termios::tcgetwinsize(&master)?;
+ Ok(Self {
+ master,
+ reader: Mutex::new(Some(reader)),
+ writer: Mutex::new(Some(writer)),
+ })
+ }
+}
+
+impl MasterPty for ImportedPty {
+ fn resize(&self, size: PtySize) -> Result<()> {
+ rustix::termios::tcsetwinsize(
+ &self.master,
+ rustix::termios::Winsize {
+ ws_row: size.rows,
+ ws_col: size.cols,
+ ws_xpixel: size.pixel_width,
+ ws_ypixel: size.pixel_height,
+ },
+ )?;
+ Ok(())
+ }
+
+ fn get_size(&self) -> Result<PtySize> {
+ let size = rustix::termios::tcgetwinsize(&self.master)?;
+ Ok(PtySize {
+ rows: size.ws_row,
+ cols: size.ws_col,
+ pixel_width: size.ws_xpixel,
+ pixel_height: size.ws_ypixel,
+ })
+ }
+
+ fn try_clone_reader(&self) -> Result<Box<dyn Read + Send>> {
+ if let Some(reader) = self.reader.lock().unwrap().take() {
+ return Ok(Box::new(ImportedReader(reader)));
+ }
+ Ok(Box::new(ImportedReader(File::from(
+ self.master.try_clone()?,
+ ))))
+ }
+
+ fn take_writer(&self) -> Result<Box<dyn Write + Send>> {
+ Ok(Box::new(ImportedWriter(
+ self.writer
+ .lock()
+ .unwrap()
+ .take()
+ .context("Imported terminal writer was already taken")?,
+ )))
+ }
+
+ fn as_raw_fd(&self) -> Option<RawFd> {
+ Some(self.master.as_raw_fd())
+ }
+ fn tty_name(&self) -> Option<PathBuf> {
+ None
+ }
+ fn process_group_leader(&self) -> Option<libc::pid_t> {
+ rustix::termios::tcgetpgrp(&self.master)
+ .ok()
+ .map(|pid| pid.as_raw_pid())
+ }
+ fn get_termios(&self) -> Option<nix::sys::termios::Termios> {
+ nix::sys::termios::tcgetattr(self.master.as_fd()).ok()
+ }
+}
diff --git a/wezterm-mux-server-impl/src/session_import/receipt.rs b/wezterm-mux-server-impl/src/session_import/receipt.rs
new file mode 100644
index 00000000..39d03098
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/receipt.rs
@@ -0,0 +1,403 @@
+use anyhow::{bail, ensure, Context, Result};
+use codec::{ImportSessionRequest, ImportSessionResponse, ImportSessionStatus};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashSet};
+use std::io::{Read, Write};
+use std::os::unix::fs::OpenOptionsExt;
+use std::path::PathBuf;
+use std::sync::Mutex;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const RETENTION: u64 = 7 * 24 * 60 * 60;
+const MAX_RECEIPTS: usize = 128;
+const MAX_BYTES: usize = 32 * 1024 * 1024;
+
+lazy_static::lazy_static! {
+ static ref ACTIVE: Mutex<HashSet<(PathBuf, String)>> = Mutex::new(HashSet::new());
+}
+
+#[derive(Serialize, Deserialize)]
+enum Outcome {
+ Running,
+ Completed,
+ Failed(String),
+}
+
+#[derive(Serialize, Deserialize)]
+struct Receipt {
+ request: ImportSessionRequest,
+ outcome: Outcome,
+ destination: Option<ImportSessionResponse>,
+}
+
+type Records = BTreeMap<String, Receipt>;
+
+#[derive(Clone)]
+pub(super) struct Store {
+ path: PathBuf,
+}
+
+pub(super) enum Started {
+ New(Attempt),
+ Completed(ImportSessionResponse),
+}
+
+pub(super) struct Attempt {
+ store: Store,
+ request_id: String,
+}
+
+fn now() -> u64 {
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs()
+}
+
+fn issued_at(id: &str) -> Result<u64> {
+ ensure!(id.len() <= 64, "Invalid import request ID");
+ let (time, uuid) = id.split_once('-').context("Invalid import request ID")?;
+ let timestamp: u64 = time.parse().context("Invalid import request timestamp")?;
+ let parsed = uuid::Uuid::parse_str(uuid).context("Invalid import request UUID")?;
+ ensure!(
+ parsed.get_version_num() == 4
+ && parsed.to_string() == uuid
+ && timestamp.to_string() == time,
+ "Invalid import request ID"
+ );
+ ensure!(
+ timestamp <= now().saturating_add(300),
+ "Import request time is in the future; check the clocks on both machines"
+ );
+ Ok(timestamp)
+}
+
+impl Store {
+ pub(super) fn owner() -> Self {
+ Self {
+ path: config::DATA_DIR.join("import-receipts.json"),
+ }
+ }
+
+ fn locked<T>(&self, action: impl FnOnce(&mut Records) -> Result<(T, bool)>) -> Result<T> {
+ let parent = self
+ .path
+ .parent()
+ .context("Import receipt directory is missing")?;
+ std::fs::create_dir_all(parent)?;
+ let lock = std::fs::OpenOptions::new()
+ .read(true)
+ .write(true)
+ .create(true)
+ .mode(0o600)
+ .open(self.path.with_extension("lock"))?;
+ rustix::fs::flock(&lock, rustix::fs::FlockOperation::LockExclusive)?;
+ let mut records = match std::fs::File::open(&self.path) {
+ Ok(file) => {
+ let mut bytes = Vec::new();
+ file.take((MAX_BYTES + 1) as u64).read_to_end(&mut bytes)?;
+ ensure!(
+ bytes.len() <= MAX_BYTES,
+ "Import receipts exceed the size limit"
+ );
+ let records: Records =
+ serde_json::from_slice(&bytes).context("Read import receipts")?;
+ ensure!(records.len() <= MAX_RECEIPTS, "Too many import receipts");
+ records
+ }
+ Err(err) if err.kind() == std::io::ErrorKind::NotFound => Records::new(),
+ Err(err) => return Err(err.into()),
+ };
+ let (result, changed) = action(&mut records)?;
+ if changed {
+ let bytes = serde_json::to_vec(&records)?;
+ ensure!(
+ bytes.len() <= MAX_BYTES,
+ "Import receipt storage is full; wait for older requests to expire"
+ );
+ let mut file = tempfile::NamedTempFile::new_in(parent)?;
+ file.write_all(&bytes)?;
+ file.as_file().sync_all()?;
+ file.persist(&self.path)?;
+ std::fs::File::open(parent)?.sync_all()?;
+ }
+ Ok(result)
+ }
+
+ pub(super) fn status(&self, id: &str) -> Result<ImportSessionStatus> {
+ if now().saturating_sub(issued_at(id)?) > RETENTION {
+ return Ok(ImportSessionStatus::Expired);
+ }
+ self.locked(|records| {
+ let status = match records.get(id) {
+ None => ImportSessionStatus::NotFound,
+ Some(receipt) => match &receipt.outcome {
+ Outcome::Completed => ImportSessionStatus::Completed(
+ receipt
+ .destination
+ .clone()
+ .context("Completed import receipt has no result")?,
+ ),
+ Outcome::Failed(error) => ImportSessionStatus::Failed(error.clone()),
+ Outcome::Running => {
+ if ACTIVE
+ .lock()
+ .unwrap()
+ .contains(&(self.path.clone(), id.to_owned()))
+ {
+ ImportSessionStatus::Running
+ } else {
+ ImportSessionStatus::Interrupted {
+ space_id: receipt
+ .destination
+ .as_ref()
+ .map(|result| result.space_id.clone()),
+ }
+ }
+ }
+ },
+ };
+ Ok((status, false))
+ })
+ }
+
+ pub(super) fn start(&self, request: ImportSessionRequest) -> Result<Started> {
+ let time = issued_at(&request.request_id)?;
+ ensure!(
+ now().saturating_sub(time) <= RETENTION,
+ "Import request expired; inspect the session before starting a new import"
+ );
+ request.request.validate()?;
+ self.locked(|records| {
+ if let Some(receipt) = records.get(&request.request_id) {
+ ensure!(receipt.request == request, "Import request ID was already used with different contents");
+ return match &receipt.outcome {
+ Outcome::Completed => Ok((Started::Completed(receipt.destination.clone()
+ .context("Completed import receipt has no result")?), false)),
+ Outcome::Failed(error) => bail!("Previous import failed: {}", error),
+ Outcome::Running => bail!("Import was already accepted; query its result before taking further action"),
+ };
+ }
+ records.retain(|id, _| issued_at(id).map_or(true, |time| now().saturating_sub(time) <= RETENTION));
+ ensure!(records.len() < MAX_RECEIPTS, "Import receipt storage is full; wait for older requests to expire");
+ let id = request.request_id.clone();
+ records.insert(id.clone(), Receipt { request, outcome: Outcome::Running, destination: None });
+ ensure!(serde_json::to_vec(records)?.len() <= MAX_BYTES - 16384,
+ "Import receipt storage is full; wait for older requests to expire");
+ Ok((Started::New(Attempt { store: self.clone(), request_id: id }), true))
+ }).map(|started| {
+ if let Started::New(attempt) = &started {
+ ACTIVE.lock().unwrap().insert((self.path.clone(), attempt.request_id.clone()));
+ }
+ started
+ })
+ }
+}
+
+impl Attempt {
+ pub(super) fn destination(&self, result: ImportSessionResponse) -> Result<()> {
+ self.store.locked(|records| {
+ records
+ .get_mut(&self.request_id)
+ .context("Import receipt is missing")?
+ .destination = Some(result);
+ // Check the full result before touching the session and leave room
+ // for its final outcome, including a bounded failure message.
+ ensure!(
+ serde_json::to_vec(records)?.len() <= MAX_BYTES - 16384,
+ "Import receipt storage is full; wait for older requests to expire"
+ );
+ Ok(((), true))
+ })
+ }
+
+ pub(super) fn complete(&self) -> Result<()> {
+ self.update(|receipt| receipt.outcome = Outcome::Completed)
+ }
+
+ pub(super) fn fail(&self, error: &str) -> Result<()> {
+ self.update(|receipt| receipt.outcome = Outcome::Failed(error.chars().take(1024).collect()))
+ }
+
+ fn update(&self, change: impl FnOnce(&mut Receipt)) -> Result<()> {
+ self.store.locked(|records| {
+ let receipt = records
+ .get_mut(&self.request_id)
+ .context("Import receipt is missing")?;
+ change(receipt);
+ Ok(((), true))
+ })
+ }
+}
+
+impl Drop for Attempt {
+ fn drop(&mut self) {
+ ACTIVE
+ .lock()
+ .unwrap()
+ .remove(&(self.store.path.clone(), self.request_id.clone()));
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn request(time: u64) -> ImportSessionRequest {
+ ImportSessionRequest {
+ request_id: format!("{}-{}", time, uuid::Uuid::new_v4()),
+ request: thinkterm_import::ImportRequest {
+ source: "example".into(),
+ session: "development".into(),
+ mode: thinkterm_import::ImportMode::Layout,
+ fingerprint: "example-fingerprint".into(),
+ space_name: "Imported".into(),
+ },
+ }
+ }
+
+ fn destination() -> ImportSessionResponse {
+ ImportSessionResponse {
+ tree: codec::ThinkTermTree::default(),
+ space_id: "space-example".into(),
+ workspace: "workspace-example".into(),
+ live: false,
+ pane_count: 1,
+ }
+ }
+
+ fn begin(store: &Store, request: ImportSessionRequest) -> Attempt {
+ match store.start(request).unwrap() {
+ Started::New(attempt) => attempt,
+ Started::Completed(_) => panic!("unexpected replay"),
+ }
+ }
+
+ #[test]
+ fn completed_result_survives_reload_and_replays_without_starting_an_import() {
+ let dir = tempfile::tempdir().unwrap();
+ let store = Store {
+ path: dir.path().join("receipts.json"),
+ };
+ let request = request(now());
+ assert_eq!(
+ store.status(&request.request_id).unwrap(),
+ ImportSessionStatus::NotFound
+ );
+ let attempt = begin(&store, request.clone());
+ assert_eq!(
+ store.status(&request.request_id).unwrap(),
+ ImportSessionStatus::Running
+ );
+ attempt.destination(destination()).unwrap();
+ attempt.complete().unwrap();
+ drop(attempt);
+ let reloaded = Store {
+ path: store.path.clone(),
+ };
+ assert_eq!(
+ reloaded.status(&request.request_id).unwrap(),
+ ImportSessionStatus::Completed(destination())
+ );
+ assert!(
+ matches!(reloaded.start(request.clone()).unwrap(), Started::Completed(result) if result == destination())
+ );
+ let mut changed = request;
+ changed.request.session = "another-session".into();
+ assert!(reloaded.start(changed).is_err());
+ }
+
+ #[test]
+ fn interrupted_and_failed_attempts_are_never_executed_again() {
+ let dir = tempfile::tempdir().unwrap();
+ let store = Store {
+ path: dir.path().join("receipts.json"),
+ };
+ let interrupted = request(now());
+ let attempt = begin(&store, interrupted.clone());
+ attempt.destination(destination()).unwrap();
+ drop(attempt);
+ assert_eq!(
+ store.status(&interrupted.request_id).unwrap(),
+ ImportSessionStatus::Interrupted {
+ space_id: Some("space-example".into()),
+ }
+ );
+ assert!(store.start(interrupted).is_err());
+ let failed = request(now());
+ let attempt = begin(&store, failed.clone());
+ attempt.fail("example prepare failure").unwrap();
+ drop(attempt);
+ assert_eq!(
+ store.status(&failed.request_id).unwrap(),
+ ImportSessionStatus::Failed("example prepare failure".into())
+ );
+ assert!(store.start(failed).is_err());
+ }
+
+ #[test]
+ fn expiry_frees_storage_without_allowing_old_requests_to_execute_again() {
+ let dir = tempfile::tempdir().unwrap();
+ let store = Store {
+ path: dir.path().join("receipts.json"),
+ };
+ let old = request(now() - RETENTION - 10);
+ store
+ .locked(|records| {
+ records.insert(
+ old.request_id.clone(),
+ Receipt {
+ request: old.clone(),
+ outcome: Outcome::Completed,
+ destination: Some(destination()),
+ },
+ );
+ Ok(((), true))
+ })
+ .unwrap();
+ assert_eq!(
+ store.status(&old.request_id).unwrap(),
+ ImportSessionStatus::Expired
+ );
+ assert!(store.start(old.clone()).is_err());
+ let current = request(now());
+ drop(begin(&store, current));
+ store
+ .locked(|records| {
+ assert!(!records.contains_key(&old.request_id));
+ Ok(((), false))
+ })
+ .unwrap();
+ assert!(store.start(old).is_err());
+ }
+
+ #[test]
+ fn full_or_unreadable_receipts_refuse_new_imports() {
+ let dir = tempfile::tempdir().unwrap();
+ let store = Store {
+ path: dir.path().join("receipts.json"),
+ };
+ store
+ .locked(|records| {
+ for _ in 0..MAX_RECEIPTS {
+ let request = request(now());
+ records.insert(
+ request.request_id.clone(),
+ Receipt {
+ request,
+ outcome: Outcome::Completed,
+ destination: Some(destination()),
+ },
+ );
+ }
+ Ok(((), true))
+ })
+ .unwrap();
+ assert!(store.start(request(now())).is_err());
+ std::fs::write(&store.path, b"invalid receipt data").unwrap();
+ let unknown = request(now());
+ assert!(store.status(&unknown.request_id).is_err());
+ assert!(store.start(unknown).is_err());
+ assert_eq!(std::fs::read(&store.path).unwrap(), b"invalid receipt data");
+ }
+}
diff --git a/wezterm-mux-server-impl/src/session_import/tests.rs b/wezterm-mux-server-impl/src/session_import/tests.rs
new file mode 100644
index 00000000..1b937cbf
--- /dev/null
+++ b/wezterm-mux-server-impl/src/session_import/tests.rs
@@ -0,0 +1,304 @@
+use super::*;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+
+#[test]
+fn imported_readers_wait_for_output_without_a_wake_pipe() {
+ use std::sync::mpsc;
+ use std::time::Duration;
+
+ let pty = nix::pty::openpty(None, None).unwrap();
+ let flags = rustix::fs::fcntl_getfl(&pty.master).unwrap() | rustix::fs::OFlags::NONBLOCK;
+ rustix::fs::fcntl_setfl(&pty.master, flags).unwrap();
+ let mut slave = std::fs::File::from(pty.slave);
+ let master = pty::ImportedPty::prepare(pty.master.try_clone().unwrap()).unwrap();
+ // Exercise both the reserved reader and a later cloned reader directly,
+ // as the mux does when it cannot allocate its poll wake pipe.
+ for _ in 0..2 {
+ let mut reader = master.try_clone_reader().unwrap();
+ let (started, ready) = mpsc::channel();
+ let (sent, received) = mpsc::channel();
+ let worker = std::thread::spawn(move || {
+ started.send(()).unwrap();
+ let mut bytes = [0; 32];
+ let result = reader.read(&mut bytes).map(|count| bytes[..count].to_vec());
+ sent.send(result).ok();
+ });
+ ready.recv_timeout(Duration::from_secs(5)).unwrap();
+ let before_output = received.recv_timeout(Duration::from_millis(50));
+ slave.write_all(b"example output").unwrap();
+ assert!(matches!(
+ before_output,
+ Err(mpsc::RecvTimeoutError::Timeout)
+ ));
+ assert_eq!(
+ received
+ .recv_timeout(Duration::from_secs(5))
+ .unwrap()
+ .unwrap(),
+ b"example output"
+ );
+ worker.join().unwrap();
+ assert_eq!(rustix::fs::fcntl_getfl(&pty.master).unwrap(), flags);
+ }
+ let mut reader = master.try_clone_reader().unwrap();
+ let (sent, received) = mpsc::channel();
+ let worker = std::thread::spawn(move || sent.send(reader.read(&mut [0; 32])).ok());
+ drop(slave);
+ match received.recv_timeout(Duration::from_secs(5)).unwrap() {
+ Ok(0) => {}
+ Err(err) if err.raw_os_error() == Some(libc::EIO) => {}
+ result => panic!("unexpected PTY hangup: {:?}", result),
+ }
+ worker.join().unwrap();
+}
+
+#[test]
+fn rollback_closes_reserved_writers_without_typing_eof() {
+ let pty = nix::pty::openpty(None, None).unwrap();
+ let source_flags = rustix::fs::fcntl_getfl(&pty.master).unwrap() | rustix::fs::OFlags::NONBLOCK;
+ rustix::fs::fcntl_setfl(&pty.master, source_flags).unwrap();
+ let mut slave = std::fs::File::from(pty.slave);
+ let mut modes = rustix::termios::tcgetattr(&slave).unwrap();
+ modes.make_raw();
+ rustix::termios::tcsetattr(&slave, rustix::termios::OptionalActions::Now, &modes).unwrap();
+ let master = pty::ImportedPty::prepare(pty.master.try_clone().unwrap()).unwrap();
+ drop(master.take_writer().unwrap());
+ drop(master);
+ assert_eq!(rustix::fs::fcntl_getfl(&pty.master).unwrap(), source_flags);
+ let flags = rustix::fs::fcntl_getfl(&slave).unwrap();
+ rustix::fs::fcntl_setfl(&slave, flags | rustix::fs::OFlags::NONBLOCK).unwrap();
+ let mut input = [0; 32];
+ assert_eq!(
+ slave.read(&mut input).unwrap_err().kind(),
+ std::io::ErrorKind::WouldBlock
+ );
+ drop(pty.master);
+}
+
+#[test]
+fn imported_writer_delivers_large_queued_input_after_backpressure() {
+ use std::io::ErrorKind;
+ use std::time::{Duration, Instant};
+
+ let pty = nix::pty::openpty(None, None).unwrap();
+ let mut slave = std::fs::File::from(pty.slave);
+ let mut modes = rustix::termios::tcgetattr(&slave).unwrap();
+ modes.make_raw();
+ rustix::termios::tcsetattr(&slave, rustix::termios::OptionalActions::Now, &modes).unwrap();
+ for fd in [pty.master.as_fd(), slave.as_fd()] {
+ let flags = rustix::fs::fcntl_getfl(fd).unwrap();
+ rustix::fs::fcntl_setfl(fd, flags | rustix::fs::OFlags::NONBLOCK).unwrap();
+ }
+ // Fill the input queue before starting the terminal's writer thread.
+ let mut source = std::fs::File::from(pty.master.try_clone().unwrap());
+ let mut expected = Vec::new();
+ loop {
+ match source.write(&[b'x'; 8192]) {
+ Ok(count) => expected.resize(expected.len() + count, b'x'),
+ Err(err) if err.kind() == ErrorKind::WouldBlock => break,
+ result => panic!("fill PTY: {:?}", result),
+ }
+ assert!(expected.len() < 4 * 1024 * 1024);
+ }
+ let master = pty::ImportedPty::prepare(pty.master).unwrap();
+ let terminal = Terminal::new(
+ TerminalSize::default(),
+ Arc::new(config::TermConfig::with_config(
+ config::ConfigHandle::default_config(),
+ )),
+ "ThinkTerm",
+ "test",
+ master.take_writer().unwrap(),
+ );
+ let mut writer = terminal.writer_handle();
+ let payload = vec![b'a'; 1024 * 1024];
+ writer.write_all(&payload).unwrap();
+ writer.write_all(b"queued marker").unwrap();
+ expected.extend_from_slice(&payload);
+ expected.extend_from_slice(b"queued marker");
+ std::thread::sleep(Duration::from_millis(50));
+
+ let mut read_exact_input = |length| {
+ let deadline = Instant::now() + Duration::from_secs(10);
+ let mut received = Vec::new();
+ let mut buf = [0; 16384];
+ while received.len() < length {
+ assert!(
+ Instant::now() < deadline,
+ "input stopped at {} of {} bytes",
+ received.len(),
+ length
+ );
+ match slave.read(&mut buf) {
+ Ok(0) => panic!("PTY closed before all input arrived"),
+ Ok(count) => received.extend_from_slice(&buf[..count]),
+ Err(err) if err.kind() == ErrorKind::WouldBlock => {
+ std::thread::sleep(Duration::from_millis(1));
+ }
+ Err(err) if err.kind() == ErrorKind::Interrupted => continue,
+ Err(err) => panic!("read input: {}", err),
+ }
+ }
+ received
+ };
+ assert_eq!(read_exact_input(expected.len()), expected);
+ writer.write_all(b"still writable").unwrap();
+ assert_eq!(read_exact_input(14), b"still writable");
+}
+
+fn plan() -> ImportPlan {
+ use thinkterm_import::{ImportMode, Project, Selection, Thread};
+ let tab = thinkterm_import::Tab {
+ name: Some("build".into()),
+ layout: Layout::Split {
+ direction: Direction::Horizontal,
+ ratio: 0.3,
+ first: Box::new(Layout::Stack {
+ panes: vec![1, 3],
+ active: 1,
+ }),
+ second: Box::new(Layout::Pane(2)),
+ },
+ panes: [1, 2, 3]
+ .iter()
+ .copied()
+ .map(|id| {
+ (
+ id,
+ thinkterm_import::Pane {
+ cwd: "/home/user/example".into(),
+ title: None,
+ },
+ )
+ })
+ .collect(),
+ focused: Some(2),
+ zoomed: true,
+ };
+ let mut other = tab.clone();
+ other.layout = Layout::Pane(4);
+ other.panes = [(
+ 4,
+ thinkterm_import::Pane {
+ cwd: "/home/user/example".into(),
+ title: None,
+ },
+ )]
+ .into();
+ other.focused = None;
+ other.zoomed = false;
+ ImportPlan {
+ mode: ImportMode::Layout,
+ active: Selection {
+ project: 0,
+ thread: 1,
+ },
+ projects: vec![Project {
+ name: "example".into(),
+ directory: "/home/user/example".into(),
+ threads: vec![
+ Thread {
+ name: "development".into(),
+ tabs: vec![tab],
+ active_tab: 0,
+ },
+ Thread {
+ name: "logs".into(),
+ tabs: vec![other],
+ active_tab: 0,
+ },
+ ],
+ }],
+ }
+}
+#[test]
+fn imports_tree_without_source_launch_commands() {
+ let snapshot = plan();
+ snapshot.validate().unwrap();
+ let encoded = serde_json::to_string(&snapshot).unwrap();
+ assert!(!encoded.contains("must-not"));
+ let tree = make_tree(&snapshot, "Example import");
+ assert_eq!(tree.spaces.len(), 1);
+ assert_eq!(tree.projects.len(), 1);
+ assert_eq!(tree.projects[0].threads.len(), 2);
+ assert_eq!(snapshot.projects[0].threads[0].tabs.len(), 1);
+ assert_eq!(snapshot.pane_count(), 4);
+ let mut current = ThinkTermTree::default();
+ let existing = codec::TtSpace {
+ id: "existing".into(),
+ name: "Existing".into(),
+ };
+ current.spaces.push(existing.clone());
+ for op in tree_ops(&tree, true) {
+ codec::apply_op(&mut current, &op);
+ }
+ assert_eq!(current.spaces.len(), 2);
+ assert_eq!(current.projects.len(), 1);
+ for op in tree_ops(&tree, false) {
+ codec::apply_op(&mut current, &op);
+ }
+ assert_eq!(current.spaces, vec![existing]);
+ assert!(current.projects.is_empty());
+ assert_ne!(
+ tree.spaces[0].id,
+ make_tree(&snapshot, "Example import").spaces[0].id
+ );
+}
+
+#[test]
+fn preserves_split_direction_ratio_focus_and_zoom() {
+ let snapshot = plan();
+ let saved = &snapshot.projects[0].threads[0].tabs[0];
+ let size = TerminalSize {
+ cols: 101,
+ rows: 30,
+ ..TerminalSize::default()
+ };
+ let entries = saved
+ .panes
+ .keys()
+ .map(|id| {
+ (
+ *id,
+ PaneEntry {
+ pane_id: *id as usize + 100,
+ window_id: 1,
+ tab_id: 2,
+ title: String::new(),
+ size,
+ working_dir: None,
+ is_active_pane: *id == 2,
+ is_zoomed_pane: *id == 2,
+ alt_screen: false,
+ workspace: "example".into(),
+ cursor_pos: Default::default(),
+ physical_top: 0,
+ top_row: 0,
+ left_col: 0,
+ tty_name: None,
+ },
+ )
+ })
+ .collect();
+ let tree = layout_tree(&saved.layout, size, &entries);
+ assert!(tree.is_plausible());
+ if let PaneNode::Split { node, left, right } = tree {
+ assert_eq!(node.direction, SplitDirection::Horizontal);
+ assert_eq!((node.first.cols, node.second.cols), (30, 70));
+ assert!(!left.entries()[0].is_active_pane);
+ if let PaneNode::Stack(stack) = *left {
+ assert_eq!(stack.active, 1);
+ assert_eq!(
+ stack.panes.iter().map(|p| p.pane_id).collect::<Vec<_>>(),
+ vec![101, 103]
+ );
+ } else {
+ panic!("missing stack");
+ }
+ assert!(right.entries()[0].is_active_pane);
+ assert!(right.entries()[0].is_zoomed_pane);
+ } else {
+ panic!("missing split");
+ }
+}
diff --git a/wezterm-mux-server-impl/src/sessionhandler.rs b/wezterm-mux-server-impl/src/sessionhandler.rs
index c47f1d4b..af94d74f 100644
--- a/wezterm-mux-server-impl/src/sessionhandler.rs
+++ b/wezterm-mux-server-impl/src/sessionhandler.rs
@@ -1072,6 +1072,12 @@ pub enum ConnectionPeer {
Web(WebPeer),
}
+fn peer_may_import_sessions(peer: &ConnectionPeer) -> bool {
+ // SSH proxies reach the Unix socket as its user; mTLS identifies the
+ // same account. Web tokens retain their narrower RPC allowlist.
+ matches!(peer, ConnectionPeer::Local | ConnectionPeer::Tls)
+}
+
/// A browser connection admitted by `web_auth`. The identity it presents
/// in `SetClientId` is overwritten with this, so `cli list-clients` shows
/// the token that let it in rather than whatever the page claimed.
@@ -2172,6 +2178,97 @@ impl SessionHandler {
.detach();
}
+ Pdu::ListImportSessions(request) => {
+ if !peer_may_import_sessions(&self.peer) {
+ send_response(Err(anyhow!(
+ "Session import requires an authenticated desktop connection"
+ )));
+ return;
+ }
+ #[cfg(unix)]
+ smol::spawn(async move {
+ let result = promise::spawn::spawn_into_new_thread(move || {
+ crate::session_import::discover(request)
+ })
+ .await;
+ send_response(result.map(Pdu::ListImportSessionsResponse));
+ })
+ .detach();
+ #[cfg(not(unix))]
+ {
+ let _ = request;
+ send_response(Err(anyhow!("Session import is supported on macOS and Linux")));
+ }
+ }
+
+ Pdu::PreviewImportSession(request) => {
+ if !peer_may_import_sessions(&self.peer) {
+ send_response(Err(anyhow!(
+ "Session import requires an authenticated desktop connection"
+ )));
+ return;
+ }
+ #[cfg(unix)]
+ smol::spawn(async move {
+ let result = promise::spawn::spawn_into_new_thread(move || {
+ crate::session_import::preview(request)
+ })
+ .await;
+ send_response(result.map(Pdu::PreviewImportSessionResponse));
+ })
+ .detach();
+ #[cfg(not(unix))]
+ {
+ let _ = request;
+ send_response(Err(anyhow!("Session import is supported on macOS and Linux")));
+ }
+ }
+
+ Pdu::GetImportSessionStatus(request) => {
+ if !peer_may_import_sessions(&self.peer) {
+ send_response(Err(anyhow!("Session import requires an authenticated desktop connection")));
+ return;
+ }
+ #[cfg(unix)]
+ spawn_into_main_thread(async move {
+ send_response(crate::session_import::status(&request.request_id).map(|status| {
+ Pdu::GetImportSessionStatusResponse(codec::GetImportSessionStatusResponse { status })
+ }));
+ }).detach();
+ #[cfg(not(unix))]
+ {
+ let _ = request;
+ send_response(Err(anyhow!("Session import is supported on macOS and Linux")));
+ }
+ }
+
+ Pdu::ImportSessionRequest(request) => {
+ if !peer_may_import_sessions(&self.peer) {
+ send_response(Err(anyhow!(
+ "Session import requires an authenticated desktop connection"
+ )));
+ return;
+ }
+ #[cfg(unix)]
+ spawn_into_main_thread(async move {
+ promise::spawn::spawn(async move {
+ let result = crate::session_import::execute(request, |tree, add, _layouts| {
+ crate::thinkterm_tree::mutate(&crate::session_import::tree_ops(tree, add))
+ .map(|_| ())
+ })
+ .await;
+ send_response(result.map(Pdu::ImportSessionResponse));
+ })
+ .detach();
+ })
+ .detach();
+ #[cfg(not(unix))]
+ {
+ let _ = request;
+ send_response(Err(anyhow!("Session import is supported on macOS and Linux")));
+ }
+ }
+
Pdu::MutateThinkTermTree(MutateThinkTermTree { ops }) => {
// mutate() broadcasts to every connection when the batch
// changed something; the direct response here is what lets the
@@ -2793,6 +2890,10 @@ impl SessionHandler {
| Pdu::MovePaneToNewTabResponse { .. }
| Pdu::TabAddedToWindow { .. }
| Pdu::GetPaneRenderableDimensionsResponse { .. }
+ | Pdu::ListImportSessionsResponse { .. }
+ | Pdu::PreviewImportSessionResponse { .. }
+ | Pdu::ImportSessionResponse { .. }
+ | Pdu::GetImportSessionStatusResponse { .. }
| Pdu::ThinkTermTreeState { .. }
| Pdu::ThinkTermSessionState { .. }
| Pdu::EnsureThinkTermThreadResponse { .. }
@@ -2825,13 +2926,15 @@ where
}
async fn ensure_thinkterm_thread(request: EnsureThinkTermThread) -> anyhow::Result<Pdu> {
- let _materialize = THINKTERM_MATERIALIZE.lock().await;
let mux = Mux::get();
// No identity is installed here on purpose: every workspace name on this
// path is explicit (`landing.workspace`), and a guard held across the
// awaits below would leak the requesting identity to unrelated
// main-thread work. See `Mux::with_identity`.
let landing = crate::thinkterm_tree::ensure_landing(request.preferred_thread_id.as_deref())?;
+ #[cfg(unix)]
+ crate::session_import::wait_for_workspace(&landing.workspace).await?;
+ let _materialize = THINKTERM_MATERIALIZE.lock().await;
let has_live_pane = mux
.iter_windows_in_workspace(&landing.workspace)
@@ -3028,6 +3131,8 @@ async fn split_pane(split: SplitPane) -> anyhow::Result<Pdu> {
}
async fn domain_spawn_v2(spawn: SpawnV2) -> anyhow::Result<Pdu> {
+ #[cfg(unix)]
+ crate::session_import::ensure_not_pending(&spawn.workspace)?;
let mux = Mux::get();
// No identity: `spawn.workspace` is an explicit non-optional string on
// the wire, so `spawn_tab_or_window` never falls back to the ambient
diff --git a/wezterm-mux-server-impl/tests/session_import.rs b/wezterm-mux-server-impl/tests/session_import.rs
new file mode 100644
index 00000000..c0e5eda6
--- /dev/null
+++ b/wezterm-mux-server-impl/tests/session_import.rs
@@ -0,0 +1,603 @@
+#![cfg(unix)]
+
+use anyhow::{ensure, Result};
+use codec::{DecodedPdu, Pdu};
+use mux::domain::{Domain, LocalDomain};
+use mux::Mux;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+use thinkterm_import::*;
+use wezterm_mux_server_impl::sessionhandler::{ConnectionPeer, PduSender, SessionHandler, WebPeer};
+
+fn request_id() -> String {
+ format!(
+ "{}-{}",
+ std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap()
+ .as_secs(),
+ uuid::Uuid::new_v4()
+ )
+}
+
+fn identified(request: ImportRequest) -> codec::ImportSessionRequest {
+ codec::ImportSessionRequest {
+ request_id: request_id(),
+ request,
+ }
+}
+
+struct Example;
+static EXAMPLE: Example = Example;
+static LIVE: Mutex<Option<LiveSetup>> = Mutex::new(None);
+
+struct SourceProcess {
+ child: Mutex<std::process::Child>,
+ _slave: std::fs::File,
+}
+
+impl Drop for SourceProcess {
+ fn drop(&mut self) {
+ let child = self.child.get_mut().unwrap();
+ let _ = child.kill();
+ let _ = child.wait();
+ }
+}
+
+struct LiveSetup {
+ master: std::os::fd::OwnedFd,
+ transfer: DelayedHandoff,
+}
+
+struct DelayedHandoff {
+ source: Arc<SourceProcess>,
+ started: smol::channel::Sender<()>,
+ release: std::sync::mpsc::Receiver<bool>,
+}
+
+impl Handoff for DelayedHandoff {
+ fn commit(&mut self) -> Result<()> {
+ self.started.try_send(())?;
+ ensure!(
+ self.release.recv_timeout(Duration::from_secs(10))?,
+ "example handoff failed"
+ );
+ Ok(())
+ }
+
+ fn finish(self: Box<Self>) {}
+}
+
+impl ImportSource for Example {
+ fn info(&self) -> SourceInfo {
+ SourceInfo {
+ id: "example",
+ name: "Example",
+ icon: "terminal",
+ }
+ }
+
+ fn discover(&self, context: &ImportContext) -> Result<Vec<Session>> {
+ ensure!(
+ context.home.join("remote-project").is_dir(),
+ "wrong discovery owner"
+ );
+ Ok(vec![Session {
+ name: "development".into(),
+ }])
+ }
+
+ fn preview(&self, context: &ImportContext, session: &str) -> Result<Preview> {
+ ensure!(
+ session == "development" || session == "development-live",
+ "unknown session"
+ );
+ Ok(Preview {
+ session: session.into(),
+ live: session == "development-live",
+ version: None,
+ fingerprint: "example-fingerprint".into(),
+ unavailable: None,
+ projects: vec![PreviewProject {
+ name: "example".into(),
+ threads: 1,
+ tabs: 1,
+ panes: 1,
+ terminals: vec![PreviewTerminal {
+ title: Some("shell".into()),
+ tab_name: None,
+ cwd: Some(context.home.join("remote-project").to_str().unwrap().into()),
+ }],
+ }],
+ })
+ }
+
+ fn notes(&self, _: Option<ImportMode>) -> Vec<&'static str> {
+ vec!["session-import-requirements-layout"]
+ }
+
+ fn prepare(&self, context: &ImportContext, request: &ImportRequest) -> Result<PreparedImport> {
+ let preview = self.preview(context, &request.session)?;
+ ensure!(
+ request.fingerprint == preview.fingerprint,
+ "preview changed"
+ );
+ let cwd = preview.projects[0].terminals[0].cwd.clone().unwrap();
+ let mut prepared = PreparedImport {
+ plan: ImportPlan {
+ mode: request.mode,
+ active: Selection::default(),
+ projects: vec![Project {
+ name: "example".into(),
+ directory: cwd.clone(),
+ threads: vec![Thread {
+ name: "development".into(),
+ active_tab: 0,
+ tabs: vec![Tab {
+ name: None,
+ layout: Layout::Pane(1),
+ focused: Some(1),
+ zoomed: false,
+ panes: [(
+ 1,
+ Pane {
+ cwd,
+ title: Some("Imported shell".into()),
+ },
+ )]
+ .into(),
+ }],
+ }],
+ }],
+ },
+ terminals: vec![],
+ handoff: None,
+ };
+ if request.mode.is_live() {
+ let setup = LIVE.lock().unwrap().take().unwrap();
+ prepared.terminals.push(LiveTerminal {
+ pane_id: 1,
+ seed: TerminalSeed {
+ child_pid: setup.transfer.source.child.lock().unwrap().id(),
+ rows: 24,
+ cols: 80,
+ cell_width_px: 0,
+ cell_height_px: 0,
+ title: None,
+ ansi: String::new(),
+ },
+ pty: setup.master,
+ });
+ prepared.handoff = Some(Box::new(setup.transfer));
+ }
+ Ok(prepared)
+ }
+}
+
+struct Client {
+ handler: SessionHandler,
+ replies: smol::channel::Receiver<DecodedPdu>,
+ serial: u64,
+}
+
+impl Client {
+ fn new(peer: ConnectionPeer) -> Self {
+ let (tx, replies) = smol::channel::unbounded();
+ Self {
+ handler: SessionHandler::for_peer(
+ PduSender::new(move |pdu| {
+ // Exercise the actual wire encoding in both directions.
+ let mut bytes = vec![];
+ pdu.pdu.encode(&mut bytes, pdu.serial)?;
+ tx.try_send(Pdu::decode(bytes.as_slice())?)?;
+ Ok(())
+ }),
+ peer,
+ ),
+ replies,
+ serial: 0,
+ }
+ }
+
+ fn send(&mut self, pdu: Pdu) -> Result<u64> {
+ self.serial += 1;
+ let mut bytes = vec![];
+ pdu.encode(&mut bytes, self.serial)?;
+ self.handler.process_one(Pdu::decode(bytes.as_slice())?);
+ Ok(self.serial)
+ }
+
+ async fn reply(&self, serial: u64) -> Result<Pdu> {
+ loop {
+ let response = self.replies.recv().await?;
+ if response.serial == serial {
+ return Ok(response.pdu);
+ }
+ }
+ }
+
+ async fn call(&mut self, pdu: Pdu) -> Result<Pdu> {
+ let name = pdu.pdu_name();
+ let serial = self.send(pdu)?;
+ smol::future::or(self.reply(serial), async move {
+ smol::Timer::after(Duration::from_secs(5)).await;
+ anyhow::bail!("{} (serial {}) timed out", name, serial)
+ })
+ .await
+ }
+}
+
+async fn live_scenario(existing_thread: String, succeed: bool) -> Result<()> {
+ use futures::{pin_mut, poll};
+
+ let pty = nix::pty::openpty(None, None)?;
+ let source = Arc::new(SourceProcess {
+ child: Mutex::new(std::process::Command::new("sleep").arg("30").spawn()?),
+ _slave: std::fs::File::from(pty.slave),
+ });
+ let (started, waiting) = smol::channel::bounded(1);
+ let (release, receiver) = std::sync::mpsc::channel();
+ *LIVE.lock().unwrap() = Some(LiveSetup {
+ master: pty.master,
+ transfer: DelayedHandoff {
+ source: source.clone(),
+ started,
+ release: receiver,
+ },
+ });
+ let request = identified(ImportRequest {
+ source: "example".into(),
+ session: "development-live".into(),
+ mode: ImportMode::Live,
+ fingerprint: "example-fingerprint".into(),
+ space_name: "Live import".into(),
+ });
+ let mut disconnected = Client::new(ConnectionPeer::Local);
+ disconnected.send(Pdu::ImportSessionRequest(request.clone()))?;
+ drop(disconnected);
+ waiting.recv().await?;
+ let mut querying = Client::new(ConnectionPeer::Local);
+ assert!(matches!(
+ querying
+ .call(Pdu::GetImportSessionStatus(codec::GetImportSessionStatus {
+ request_id: request.request_id.clone(),
+ }))
+ .await?,
+ Pdu::GetImportSessionStatusResponse(codec::GetImportSessionStatusResponse {
+ status: codec::ImportSessionStatus::Running,
+ })
+ ));
+ let duplicate = request.clone();
+ let import = promise::spawn::spawn(async move {
+ Client::new(ConnectionPeer::Local)
+ .call(Pdu::ImportSessionRequest(duplicate))
+ .await
+ });
+ let tree = wezterm_mux_server_impl::thinkterm_tree::snapshot();
+ let space = tree
+ .spaces
+ .iter()
+ .find(|space| space.name == "Live import")
+ .unwrap();
+ let thread = &tree
+ .projects
+ .iter()
+ .find(|p| p.space_id == space.id)
+ .unwrap()
+ .threads[0];
+ let workspace = thread.materialized_workspace_name.clone().unwrap();
+ let mux = Mux::get();
+ let initial_panes = mux.iter_panes().len();
+ assert!(mux.iter_windows_in_workspace(&workspace).is_empty());
+
+ let mut restoring = Client::new(ConnectionPeer::Local);
+ let serial = restoring.send(Pdu::EnsureThinkTermThread(codec::EnsureThinkTermThread {
+ preferred_thread_id: Some(thread.id.clone()),
+ size: wezterm_term::TerminalSize::default(),
+ }))?;
+ let restored = restoring.reply(serial);
+ pin_mut!(restored);
+ let mut other = Client::new(ConnectionPeer::Local);
+ other
+ .call(Pdu::SetClientId(codec::SetClientId {
+ client_id: mux::client::ClientId {
+ hostname: "server-a".into(),
+ username: "user".into(),
+ pid: 124,
+ epoch: 0,
+ id: 1,
+ ssh_auth_sock: None,
+ },
+ is_proxy: false,
+ }))
+ .await?;
+ let spawn_response = other
+ .call(Pdu::SpawnV2(codec::SpawnV2 {
+ domain: thinkterm_proto::SpawnTabDomain::DefaultDomain,
+ window_id: None,
+ command: None,
+ command_dir: None,
+ size: wezterm_term::TerminalSize::default(),
+ workspace: workspace.clone(),
+ }))
+ .await?;
+ assert!(
+ matches!(&spawn_response,
+ Pdu::ErrorResponse(error) if error.reason.contains("import is still in progress")
+ ),
+ "unexpected spawn response: {:?}",
+ spawn_response
+ );
+ assert!(matches!(
+ other
+ .call(Pdu::EnsureThinkTermThread(codec::EnsureThinkTermThread {
+ preferred_thread_id: Some(existing_thread),
+ size: wezterm_term::TerminalSize::default(),
+ }))
+ .await?,
+ Pdu::EnsureThinkTermThreadResponse(codec::EnsureThinkTermThreadResponse {
+ spawned: false,
+ ..
+ })
+ ));
+ assert!(poll!(&mut restored).is_pending());
+ assert_eq!(mux.iter_panes().len(), initial_panes);
+ release.send(succeed)?;
+ let result = import.await?;
+ let status = querying
+ .call(Pdu::GetImportSessionStatus(codec::GetImportSessionStatus {
+ request_id: request.request_id.clone(),
+ }))
+ .await?;
+ assert!(
+ matches!(&status, Pdu::GetImportSessionStatusResponse(response) if
+ if succeed { matches!(&response.status, codec::ImportSessionStatus::Completed(_)) }
+ else { matches!(&response.status, codec::ImportSessionStatus::Failed(_)) })
+ );
+ let restored = restored.await?;
+ if succeed {
+ assert!(matches!(result, Pdu::ImportSessionResponse(_)));
+ assert!(matches!(
+ restored,
+ Pdu::EnsureThinkTermThreadResponse(codec::EnsureThinkTermThreadResponse {
+ spawned: false,
+ ..
+ })
+ ));
+ assert_eq!(mux.iter_windows_in_workspace(&workspace).len(), 1);
+ assert_eq!(mux.iter_panes().len(), initial_panes + 1);
+ for window_id in mux.iter_windows_in_workspace(&workspace) {
+ let panes: Vec<_> = mux
+ .get_window(window_id)
+ .unwrap()
+ .iter()
+ .flat_map(|tab| tab.iter_all_panes())
+ .map(|pane| pane.pane_id())
+ .collect();
+ for pane_id in panes {
+ mux.remove_pane(pane_id);
+ }
+ }
+ wezterm_mux_server_impl::thinkterm_tree::mutate(&[codec::TreeOp::DeleteSpace {
+ space_id: space.id.clone(),
+ }])?;
+ } else {
+ assert!(matches!(result, Pdu::ErrorResponse(_)));
+ assert!(matches!(restored, Pdu::ErrorResponse(error)
+ if error.reason.contains("import did not finish")));
+ assert!(mux.iter_windows_in_workspace(&workspace).is_empty());
+ assert_eq!(mux.iter_panes().len(), initial_panes);
+ assert!(!wezterm_mux_server_impl::thinkterm_tree::snapshot()
+ .spaces
+ .iter()
+ .any(|s| s.id == space.id));
+ }
+ Ok(())
+}
+
+async fn scenario(local_id: mux::domain::DomainId) -> Result<()> {
+ let mut client = Client::new(ConnectionPeer::Local);
+ // This is how the SSH proxy marks a connection before relaying RPCs.
+ client
+ .call(Pdu::SetClientId(codec::SetClientId {
+ client_id: mux::client::ClientId {
+ hostname: "server-a".into(),
+ username: "user".into(),
+ pid: 123,
+ epoch: 0,
+ id: 0,
+ ssh_auth_sock: None,
+ },
+ is_proxy: true,
+ }))
+ .await?;
+ let listed = client
+ .call(Pdu::ListImportSessions(codec::ListImportSessions {
+ source: "example".into(),
+ }))
+ .await?;
+ match listed {
+ Pdu::ListImportSessionsResponse(response) => {
+ assert_eq!(response.sessions[0].name, "development");
+ assert_eq!(response.notes, vec!["session-import-requirements-layout"]);
+ }
+ other => anyhow::bail!("discovery: {:?}", other),
+ }
+ let preview = client
+ .call(Pdu::PreviewImportSession(codec::PreviewImportSession {
+ source: "example".into(),
+ session: "development".into(),
+ }))
+ .await?;
+ let preview = match preview {
+ Pdu::PreviewImportSessionResponse(response) => response.preview,
+ other => anyhow::bail!("preview: {:?}", other),
+ };
+ assert_eq!(
+ preview.projects[0].terminals[0].cwd.as_deref(),
+ config::HOME_DIR.join("remote-project").to_str()
+ );
+ let request = identified(ImportRequest {
+ source: "example".into(),
+ session: preview.session,
+ mode: ImportMode::Layout,
+ fingerprint: preview.fingerprint,
+ space_name: "Imported".into(),
+ });
+ assert!(matches!(
+ client
+ .call(Pdu::GetImportSessionStatus(codec::GetImportSessionStatus {
+ request_id: request.request_id.clone(),
+ }))
+ .await?,
+ Pdu::GetImportSessionStatusResponse(codec::GetImportSessionStatusResponse {
+ status: codec::ImportSessionStatus::NotFound,
+ })
+ ));
+ let mut stale = request.clone();
+ stale.request_id = request_id();
+ stale.request.fingerprint = "stale".into();
+ assert!(matches!(
+ client.call(Pdu::ImportSessionRequest(stale)).await?,
+ Pdu::ErrorResponse(_)
+ ));
+ assert!(Mux::get().iter_panes().is_empty());
+ assert!(wezterm_mux_server_impl::thinkterm_tree::snapshot()
+ .spaces
+ .is_empty());
+
+ let mut unsaved = request.clone();
+ unsaved.request_id = request_id();
+ let save_error =
+ wezterm_mux_server_impl::session_import::execute(unsaved, |tree, add, layouts| {
+ assert!(add);
+ assert_eq!(layouts.len(), 1);
+ assert_eq!(layouts[0].thread_id, tree.projects[0].threads[0].id);
+ assert_eq!(layouts[0].active_tab, 0);
+ assert_eq!(layouts[0].tabs.len(), 1);
+ let entries = layouts[0].tabs[0].entries();
+ assert_eq!(entries.len(), 1);
+ assert_eq!(entries[0].title, "Imported shell");
+ anyhow::bail!("example disk write failure")
+ })
+ .await
+ .unwrap_err();
+ assert!(format!("{save_error:#}").contains("example disk write failure"));
+ assert!(Mux::get().iter_panes().is_empty());
+
+ let result = client
+ .call(Pdu::ImportSessionRequest(request.clone()))
+ .await?;
+ let result = match result {
+ Pdu::ImportSessionResponse(result) => result,
+ other => anyhow::bail!("import: {:?}", other),
+ };
+ assert_eq!(result.pane_count, 1);
+ assert!(!result.live);
+ let mux = Mux::get();
+ let panes = mux.iter_panes();
+ assert_eq!(panes.len(), 1);
+ assert_eq!(panes[0].domain_id(), local_id);
+ assert!(wezterm_mux_server_impl::thinkterm_tree::snapshot()
+ .spaces
+ .iter()
+ .any(|s| s.id == result.space_id));
+ assert!(wezterm_mux_server_impl::thinkterm_tree::tree_path().is_file());
+
+ let repeated = client
+ .call(Pdu::ImportSessionRequest(request.clone()))
+ .await?;
+ assert!(matches!(repeated, Pdu::ImportSessionResponse(ref cached) if cached == &result));
+ assert_eq!(mux.iter_panes().len(), 1);
+ let mut changed = request.clone();
+ changed.request.space_name = "Changed".into();
+ assert!(matches!(
+ client.call(Pdu::ImportSessionRequest(changed)).await?,
+ Pdu::ErrorResponse(_)
+ ));
+ assert_eq!(mux.iter_panes().len(), 1);
+
+ let mut tls = Client::new(ConnectionPeer::Tls);
+ assert!(matches!(
+ tls.call(Pdu::ListImportSessions(codec::ListImportSessions {
+ source: "example".into()
+ }))
+ .await?,
+ Pdu::ListImportSessionsResponse(_)
+ ));
+ let (_kill, revoked) = smol::channel::bounded(1);
+ let mut browser = Client::new(ConnectionPeer::Web(WebPeer {
+ token_id: "example".into(),
+ label: "example".into(),
+ username: "user".into(),
+ revoked,
+ }));
+ for pdu in vec![
+ Pdu::ListImportSessions(codec::ListImportSessions {
+ source: "example".into(),
+ }),
+ Pdu::PreviewImportSession(codec::PreviewImportSession {
+ source: "example".into(),
+ session: "development".into(),
+ }),
+ Pdu::GetImportSessionStatus(codec::GetImportSessionStatus {
+ request_id: request.request_id.clone(),
+ }),
+ Pdu::ImportSessionRequest(request),
+ ] {
+ assert!(matches!(browser.call(pdu).await?, Pdu::ErrorResponse(_)));
+ }
+ assert_eq!(mux.iter_panes().len(), 1);
+ let existing_thread = result.tree.projects[0].threads[0].id.clone();
+ live_scenario(existing_thread.clone(), true).await?;
+ live_scenario(existing_thread, false).await?;
+ Ok(())
+}
+
+#[test]
+fn remote_import_stays_on_the_owner_and_web_tokens_cannot_invoke_it() {
+ // This integration binary has one test and owns its process environment.
+ let home = tempfile::Builder::new()
+ .prefix("tt-import-")
+ .tempdir_in("/tmp")
+ .unwrap();
+ let path = home.path().canonicalize().unwrap();
+ for key in [
+ "HOME",
+ "XDG_CONFIG_HOME",
+ "XDG_DATA_HOME",
+ "XDG_RUNTIME_DIR",
+ ] {
+ std::env::set_var(key, &path);
+ }
+ std::env::remove_var("SSH_AUTH_SOCK");
+ std::fs::create_dir(path.join("remote-project")).unwrap();
+ config::use_test_configuration();
+ let mut cfg = (*config::configuration()).clone();
+ cfg.mux_enable_ssh_agent = false;
+ config::use_this_configuration(cfg);
+ thinkterm_import::register(&EXAMPLE).unwrap();
+ let local: Arc<dyn Domain> = Arc::new(LocalDomain::new("local").unwrap());
+ let local_id = local.domain_id();
+ let mux = Arc::new(Mux::new(Some(local)));
+ Mux::set_mux(&mux);
+ let executor = promise::spawn::SimpleExecutor::new();
+ let result = Arc::new(Mutex::new(None));
+ let completed = result.clone();
+ promise::spawn::spawn(async move {
+ let outcome = smol::future::or(scenario(local_id), async {
+ smol::Timer::after(Duration::from_secs(20)).await;
+ anyhow::bail!("import RPC test timed out")
+ })
+ .await;
+ *completed.lock().unwrap() = Some(outcome);
+ })
+ .detach();
+ while result.lock().unwrap().is_none() {
+ executor.tick().unwrap();
+ }
+ for pane in mux.iter_panes() {
+ mux.remove_pane(pane.pane_id());
+ }
+ result.lock().unwrap().take().unwrap().unwrap();
+}
diff --git a/wezterm-mux-server/Cargo.toml b/wezterm-mux-server/Cargo.toml
index 3587f47a..c4c39724 100644
--- a/wezterm-mux-server/Cargo.toml
+++ b/wezterm-mux-server/Cargo.toml
@@ -16,6 +16,8 @@ path = "src/main.rs"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
+thinkterm-import-herdr.workspace = true
+thinkterm-import.workspace = true
anyhow.workspace = true
async_ossl.workspace = true
clap.workspace = true
diff --git a/wezterm-mux-server/src/main.rs b/wezterm-mux-server/src/main.rs
index a2229195..bc6203c7 100644
--- a/wezterm-mux-server/src/main.rs
+++ b/wezterm-mux-server/src/main.rs
@@ -92,6 +92,13 @@ struct Opt {
}
fn main() {
+ #[cfg(unix)]
+ {
+ thinkterm_import_herdr::register().expect("register built-in session importer");
+ if let Some(result) = thinkterm_import::maybe_run_helper() {
+ std::process::exit(if result.is_ok() { 0 } else { 1 });
+ }
+ }
if let Err(err) = run() {
wezterm_blob_leases::clear_storage();
log::error!("{:#}", err);