Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
feat(desktop): open and clean up worktree sessions in the terminal app (#1111)
Elyas Mehtabuddin1d6f64981ae2
diff --git a/crates/switchyard-desktop/src/controller.rs b/crates/switchyard-desktop/src/controller.rsindex d3261b31e..1c1d34510 100644--- a/crates/switchyard-desktop/src/controller.rs+++ b/crates/switchyard-desktop/src/controller.rs@@ -134,6 +134,16 @@ pub enum Action {tool: Harness,name: String,},+ OpenSession {+ id: String,+ },+ PreviewSessionCleanup {+ id: String,+ },+ RemoveSession {+ id: String,+ preview_token: Option<String>,+ },Restart {},PreviewUpdate {},Update {@@ -456,7 +466,7 @@ pub struct Controller {generation: u64,route_reviews: std::collections::HashMap<String, Review>,tool_review: Option<Review>,-+ session_cleanup: Option<(String, String, Value)>,account_archive: Option<(Harness, String, String)>,route_change: Option<Review>,update_review: Option<(String, Value)>,@@ -472,7 +482,7 @@ impl Controller {generation: 0,route_reviews: Default::default(),tool_review: None,-+ session_cleanup: None,account_archive: None,route_change: None,update_review: None,@@ -817,7 +827,13 @@ impl Controller {// Account and session folders open in the editor too, because a terminal may run// over SSH, where `open` would start a file manager on another screen.Action::OpenAccount { tool, name } => account_path(*tool, Some(name)),-+ Action::OpenSession { id } => {+ let receipt = sessions::managed_session(id)?;+ let worktree = receipt["worktree"]+ .as_str()+ .ok_or("Missing session directory.")?;+ Ok(Some(PathBuf::from(worktree)))+ }_ => Ok(None),}}@@ -1293,6 +1309,37 @@ impl Controller {server::command("open", &[&path.display().to_string()])?;Ok(Reply::message("Opened the account folder.".into()))}+ Action::OpenSession { id } => {+ let receipt = sessions::managed_session(&id)?;+ server::command(+ "open",+ &[receipt["worktree"]+ .as_str()+ .ok_or("Missing session directory.")?],+ )?;+ Ok(Reply::message("Opened the session folder.".into()))+ }+ Action::PreviewSessionCleanup { id } => {+ let data = sessions::cleanup_preview(&id)?;+ let token = uuid::Uuid::now_v7().to_string();+ self.session_cleanup = Some((id, token.clone(), data.clone()));+ let mut data = data;+ data["preview_token"] = json!(token);+ Ok(Reply {+ message: String::new(),+ data,+ })+ }+ Action::RemoveSession { id, preview_token } => {+ let (expected_id, token, data) = self+ .session_cleanup+ .as_ref()+ .ok_or("Review session cleanup first.")?;+ if &id != expected_id || preview_token.as_deref() != Some(token.as_str()) {+ return Err("Review session cleanup again.".into());+ }+ sessions::cleanup(&id, data).map(Reply::message)+ }Action::Restart {} => server::restart_checked(&self.config).map(Reply::message),Action::CheckConfig {} => server::check_config(&self.config).map(|()| Reply::message("Server config check passed.".into())),@@ -1750,6 +1797,169 @@ policy = { type = "target_selector", selector = "/target" }}}+ // The subprocess isolates harness discovery and every launch destination.+ #[cfg(unix)]+ #[test]+ fn session_launch_requires_an_unchanged_review_before_creating_files() {+ use std::os::unix::fs::PermissionsExt;+ use std::{fs, process::Command};+ if let Some(home) = std::env::var_os("SWITCHYARD_LAUNCH_REVIEW_FIXTURE") {+ let home = PathBuf::from(home);+ let project = home.join("project");+ let git = |args: &[&str]| {+ let result = Command::new("/usr/bin/git")+ .arg("-C")+ .arg(&project)+ .args(args)+ .output()+ .expect("git");+ assert!(+ result.status.success(),+ "{}",+ String::from_utf8_lossy(&result.stderr)+ );+ };+ fs::create_dir(&project).expect("project");+ git(&["init"]);+ git(&[+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "initial",+ ]);+ let settings = home.join("desktop.toml");+ let server = home.join("server.toml");+ let text = "[llm_clients.c]\n\+ base_url='http://localhost:1234'\n\+ [targets.m]\n\+ id='actual'\n\+ llm_client='c'\n\+ [routes.r]\n\+ id='public'\n\+ type='passthrough'\n\+ target='m'\n";+ fs::write(&server, text).expect("server");+ fs::write(+ &settings,+ format!(+ "config_file={server:?}\nrouting_log={:?}\n",+ home.join("routing.jsonl")+ ),+ )+ .expect("settings");+ let mut controller =+ Controller::new(Config::load(&settings).expect("settings"), settings.clone());+ let preview = |controller: &mut Controller| {+ controller+ .dispatch(Action::PreviewLaunch {+ tool: Harness::CodexCli,+ account: None,+ route: "r".into(),+ id: "public".into(),+ project: project.display().to_string(),+ })+ .expect("preview")+ };+ let launch = |token: Option<String>, path: String| Action::Launch {+ tool: Harness::CodexCli,+ account: None,+ route: "r".into(),+ id: "public".into(),+ project: path,+ preview_token: token,+ };+ let reviewed = preview(&mut controller);+ let token = reviewed.data["preview_token"]+ .as_str()+ .expect("token")+ .to_string();+ for rejected in [+ launch(None, project.display().to_string()),+ launch(Some("wrong".into()), project.display().to_string()),+ launch(Some(token.clone()), home.display().to_string()),+ ] {+ assert!(controller.dispatch(rejected).is_err());+ }+ fs::write(&server, format!("{text}# external edit\n")).expect("edit");+ assert!(+ controller+ .dispatch(launch(Some(token), project.display().to_string()))+ .is_err()+ );+ assert_eq!(+ fs::read_to_string(&server).expect("preserved"),+ format!("{text}# external edit\n")+ );+ let reviewed = preview(&mut controller);+ let token = reviewed.data["preview_token"]+ .as_str()+ .expect("token")+ .to_string();+ let original = fs::read_to_string(&settings).expect("settings");+ fs::write(&settings, format!("{original}# external settings\n")).expect("edit");+ assert!(+ controller+ .dispatch(launch(Some(token), project.display().to_string()))+ .is_err()+ );+ let reviewed = preview(&mut controller);+ let token = reviewed.data["preview_token"]+ .as_str()+ .expect("token")+ .to_string();+ git(&[+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "changed",+ ]);+ assert!(+ controller+ .dispatch(launch(Some(token), project.display().to_string()))+ .err()+ .expect("changed HEAD")+ .contains("project changed")+ );+ assert!(!home.join(".switchyard/worktrees").exists());+ assert!(!home.join("terminal-called").exists());+ assert_eq!(fs::read_dir(&home).expect("files").count(), 4);+ return;+ }+ let home = tempfile::tempdir().expect("fixture");+ let bin = home.path().join("bin");+ fs::create_dir(&bin).expect("bin");+ for name in ["codex", "open", "osascript"] {+ let path = bin.join(name);+ fs::write(+ &path,+ "#!/bin/sh\ntouch \"$HOME/terminal-called\"\nexit 0\n",+ )+ .expect("stub");+ fs::set_permissions(path, fs::Permissions::from_mode(0o755)).expect("executable");+ }+ let output=Command::new(std::env::current_exe().expect("test binary"))+ .args(["--exact", "controller::tests::session_launch_requires_an_unchanged_review_before_creating_files"])+ .env("SWITCHYARD_LAUNCH_REVIEW_FIXTURE",home.path()).env("HOME",home.path())+ .env("PATH",format!("{}:/usr/bin:/bin",bin.display())).output().expect("child");+ assert!(+ output.status.success(),+ "{}\n{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ }#[test]// An algorithm switch must not give stale choices a revision for externally edited bytes.fn algorithm_switches_keep_the_first_revision_and_external_edits_reject_it() {diff --git a/crates/switchyard-desktop/src/sessions.rs b/crates/switchyard-desktop/src/sessions.rsindex 3f7538d94..076d0c32b 100644--- a/crates/switchyard-desktop/src/sessions.rs+++ b/crates/switchyard-desktop/src/sessions.rs@@ -134,6 +134,114 @@ pub fn inventory() -> Result<Vec<serde_json::Value>, String> {Ok(sessions)}+pub fn managed_session(id: &str) -> Result<serde_json::Value, String> {+ let suffix = id.strip_prefix("sy-").ok_or("Choose a managed session.")?;+ uuid::Uuid::parse_str(suffix).map_err(|_| "Choose a managed session.")?;+ let root = session_root()?;+ let private = root.join(format!("{id}-settings"));+ let worktree = root.join(id);+ for path in [&root, &private, &worktree] {+ if std::fs::symlink_metadata(path)+ .map_err(|error| error.to_string())?+ .file_type()+ .is_symlink()+ {+ return Err("Session directories must not be symlinks.".into());+ }+ }+ let receipt: serde_json::Value = serde_json::from_slice(+ &std::fs::read(private.join("session.json")).map_err(|error| error.to_string())?,+ )+ .map_err(|error| error.to_string())?;+ if receipt["id"] != id || receipt["worktree"] != worktree.display().to_string() {+ return Err("The session receipt does not match this worktree.".into());+ }+ Ok(receipt)+}++pub fn cleanup_preview(id: &str) -> Result<serde_json::Value, String> {+ let mut receipt = managed_session(id)?;+ let worktree = receipt["worktree"]+ .as_str()+ .ok_or("Missing session worktree.")?+ .to_string();+ let run = |args: &[&str]| -> Result<String, String> {+ let output = std::process::Command::new("git")+ .args(["-C", &worktree])+ .args(args)+ .output()+ .map_err(|error| error.to_string())?;+ if !output.status.success() {+ return Err(String::from_utf8_lossy(&output.stderr).into_owned());+ }+ Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())+ };+ // Plain `git worktree remove` deletes ignored files, so the review lists them.+ let status = run(&["status", "--porcelain", "--ignored=matching"])?;+ receipt["dirty"] = serde_json::json!(status.lines().any(|line| !line.starts_with("!! ")));+ receipt["ignored"] = serde_json::json!(+ status+ .lines()+ .filter_map(|line| line.strip_prefix("!! "))+ .collect::<Vec<_>>()+ );+ receipt["current_revision"] = serde_json::json!(run(&["rev-parse", "HEAD"])?);+ receipt["current_branch"] = serde_json::json!(run(&["branch", "--show-current"])?);+ receipt["cleanup_notice"] = serde_json::json!(+ "Cleanup removes a clean worktree and its unchanged session branch. \+ It also deletes the Git-ignored files in the worktree, which the ignored list names. \+ Recorded usage stays in the routing log. Unknown private files are preserved."+ );+ Ok(receipt)+}++pub fn cleanup(id: &str, reviewed: &serde_json::Value) -> Result<String, String> {+ let current = cleanup_preview(id)?;+ if ¤t != reviewed {+ return Err("The session changed since review. Review cleanup again.".into());+ }+ if current["dirty"] != false+ || current["current_revision"] != current["revision"]+ || current["current_branch"] != id+ {+ return Err("Save or move the session’s work before cleanup. \+ Cleanup requires a clean worktree with its original commit and branch."+ .into());+ }+ let repository = current["repository"]+ .as_str()+ .ok_or("Missing session repository.")?;+ let worktree = current["worktree"]+ .as_str()+ .ok_or("Missing session worktree.")?;+ let revision = current["revision"]+ .as_str()+ .ok_or("Missing session commit.")?;+ // Receipt path resolution must succeed before cleanup removes the worktree.+ let private = session_root()?.join(format!("{id}-settings"));+ let output = std::process::Command::new("git")+ .args(["-C", repository, "worktree", "remove", worktree])+ .output()+ .map_err(|error| error.to_string())?;+ if !output.status.success() {+ return Err(String::from_utf8_lossy(&output.stderr).into_owned());+ }++ // The worktree is gone, so the receipt goes too; otherwise the inventory keeps the session.+ // Cleanup removes only the receipt because settings can contain later user edits.+ std::fs::remove_file(private.join("session.json")).map_err(|error| error.to_string())?;+ let _ = std::fs::remove_dir(&private);+ if !delete_session_branch(Path::new(repository), id, revision) {+ return Ok(format!(+ "Removed the clean session worktree. Git kept the branch {id}; \+ inspect it before deleting it. Retained private settings and recorded usage."+ ));+ }+ Ok("Removed the clean session worktree and branch. \+ Retained private settings and recorded usage."+ .into())+}+pub fn launch(tool: Harness,project: &Path,@@ -367,3 +475,357 @@ pub fn launch(worktree.display()))}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn failed_session_setup_removes_its_worktree_branch_and_private_settings() {+ let dir = tempfile::tempdir().expect("directory");+ let project = dir.path().join("project");+ std::fs::create_dir(&project).expect("project");+ let git = |args: &[&str]| {+ let output = std::process::Command::new("git")+ .arg("-C")+ .arg(&project)+ .args(args)+ .output()+ .expect("git");+ assert!(+ output.status.success(),+ "{}",+ String::from_utf8_lossy(&output.stderr)+ );+ output+ };+ git(&["init"]);+ git(&[+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "fixture",+ ]);+ let worktree = dir.path().join("worktree");+ let private = dir.path().join("settings");+ git(&[+ "worktree",+ "add",+ "-b",+ "session-fixture",+ worktree.to_str().expect("path"),+ ]);+ std::fs::create_dir(&private).expect("private");+ std::fs::write(private.join("settings.json"), "{}").expect("settings");+ let revision = String::from_utf8_lossy(&git(&["rev-parse", "HEAD"]).stdout)+ .trim()+ .to_string();+ // An unrelated HEAD in the original checkout makes `branch -d` refuse the session branch.+ git(&["checkout", "--orphan", "unrelated"]);+ git(&[+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "unrelated",+ ]);+ drop(PendingSession {+ project: project.clone(),+ worktree: worktree.clone(),+ private: private.clone(),+ branch: "session-fixture".into(),+ revision,+ opened: false,+ });+ assert!(!worktree.exists());+ assert!(!private.exists());+ assert!(+ !String::from_utf8_lossy(&git(&["branch", "--list", "session-fixture"]).stdout)+ .contains("session-fixture")+ );+ }+ // The subprocess isolates HOME and PATH.+ // The Terminal stub injects a conflicting directory when the script must select one.+ // Claude's default case requires an unset CLAUDE_CONFIG_DIR, not an explicit ~/.claude.+ #[cfg(unix)]+ #[test]+ fn generated_sessions_use_explicit_accounts_without_changing_user_defaults() {+ use std::os::unix::fs::PermissionsExt;+ if let Ok(fixture) = std::env::var("SWITCHYARD_SESSION_FIXTURE") {+ let fixture = std::path::PathBuf::from(fixture);+ let tool = if std::env::var("SWITCHYARD_SESSION_TOOL").expect("tool") == "codex" {+ Harness::CodexCli+ } else {+ Harness::Claude+ };+ let account =+ std::env::var_os("SWITCHYARD_SESSION_ACCOUNT").map(std::path::PathBuf::from);+ let revision = preview(&fixture.join("project")).expect("preview")["revision"]+ .as_str()+ .expect("revision")+ .to_string();+ // Advancing the original checkout makes a launch from HEAD differ from the review.+ if tool == Harness::CodexCli && account.is_none() {+ let committed = std::process::Command::new("git")+ .arg("-C")+ .arg(fixture.join("project"))+ .args([+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "advanced",+ ])+ .output()+ .expect("advance HEAD");+ assert!(committed.status.success());+ }+ launch(+ tool,+ &fixture.join("project"),+ "route'$(literal)",+ "http://localhost:4123",+ tool == Harness::Claude,+ account.as_deref(),+ &revision,+ )+ .expect("launch");+ if tool == Harness::CodexCli && account.is_none() {+ let records = inventory().expect("inventory");+ assert_eq!(records.len(), 1);+ assert_eq!(records[0]["revision"], revision);+ assert_ne!(+ preview(&fixture.join("project")).expect("advanced project")["revision"],+ revision+ );+ let id = records[0]["id"].as_str().expect("session id");+ let receipt = session_root()+ .expect("session root")+ .join(format!("{id}-settings/session.json"));+ let original = std::fs::read(&receipt).expect("receipt");+ // Valid JSON roots must still be objects before inventory adds process_status.+ for malformed in ["null", "[]", "false", "42"] {+ std::fs::write(&receipt, malformed).expect("malformed receipt");+ assert!(inventory().is_err());+ assert!(cleanup_preview(id).is_err());+ }+ std::fs::write(&receipt, original).expect("restore receipt");+ let clean = cleanup_preview(id).expect("preview cleanup");+ let worktree = Path::new(records[0]["worktree"].as_str().expect("worktree"));+ let unsaved = worktree.join("unsaved-user-work.txt");+ std::fs::write(&unsaved, "keep this work").expect("user work");+ assert!(cleanup(id, &clean).is_err());+ assert!(unsaved.exists());+ let dirty = cleanup_preview(id).expect("dirty preview");+ assert!(cleanup(id, &dirty).is_err());+ assert!(worktree.exists());+ std::fs::remove_file(&unsaved).expect("save fixture work");+ let clean = cleanup_preview(id).expect("clean preview");+ // Cleanup deletes ignored files, so a new ignored file requires a new review.+ let info = fixture.join("project/.git/info");+ std::fs::create_dir_all(&info).expect("git info");+ std::fs::write(info.join("exclude"), "ignored-notes.txt\n").expect("exclude");+ std::fs::write(worktree.join("ignored-notes.txt"), "notes").expect("notes");+ assert!(cleanup(id, &clean).is_err());+ assert!(worktree.join("ignored-notes.txt").exists());+ let reviewed = cleanup_preview(id).expect("ignored preview");+ assert_eq!(+ reviewed["ignored"],+ serde_json::json!(["ignored-notes.txt"])+ );+ // An unrelated HEAD in the original checkout makes `branch -d` refuse the branch.+ let project_git = |args: &[&str]| {+ let output = std::process::Command::new("git")+ .arg("-C")+ .arg(fixture.join("project"))+ .args(args)+ .output()+ .expect("git");+ assert!(output.status.success());+ output+ };+ project_git(&["checkout", "--orphan", "unrelated"]);+ project_git(&[+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "unrelated",+ ]);+ cleanup(id, &reviewed).expect("safe cleanup");+ assert!(!worktree.exists());+ assert!(inventory().expect("inventory after cleanup").is_empty());+ assert!(project_git(&["branch", "--list", id]).stdout.is_empty());+ }+ return;+ }+ for (name, named, inherited_dir) in [+ ("codex", false, true),+ ("codex", true, true),+ ("claude", false, true),+ ("claude", true, true),+ ("claude", false, false),+ ("claude", true, false),+ ] {+ let fixture = tempfile::tempdir().expect("fixture");+ let home = fixture.path().join("home");+ let bin = fixture.path().join("bin");+ let project = fixture.path().join("project");+ for path in [&home, &bin, &project] {+ std::fs::create_dir(path).expect("directory");+ }+ for args in [+ vec!["init"],+ vec![+ "-c",+ "user.name=Fixture",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--allow-empty",+ "-m",+ "fixture",+ ],+ ] {+ assert!(+ std::process::Command::new("git")+ .arg("-C")+ .arg(&project)+ .args(args)+ .output()+ .expect("git")+ .status+ .success()+ );+ }+ let default = home.join("default-login");+ std::fs::create_dir(&default).expect("default");+ std::fs::write(default.join("settings.json"), "{\"user\":true}").expect("settings");+ let account = home.join(".switchyard/accounts").join(name).join("named");+ if named {+ std::fs::create_dir_all(&account).expect("account");+ }+ let output = fixture.path().join("arguments");+ let captured = fixture.path().join("session.command");+ // macOS runs the script through `open`; Linux runs it through the program in+ // TERMINAL, which receives `-e` before the script path.+ let open = bin.join(if cfg!(target_os = "linux") {+ "terminal"+ } else {+ "open"+ });+ let terminal_claude = if inherited_dir || named {+ "export CLAUDE_CONFIG_DIR=wrong-terminal-login"+ } else {+ "unset CLAUDE_CONFIG_DIR"+ };+ std::fs::write(+ &open,+ format!(+ "#!/bin/bash\n\+ [ \"$1\" = -e ] && shift\n\+ cp -- \"$1\" {}\n\+ export CODEX_HOME=wrong-terminal-login ANTHROPIC_AUTH_TOKEN=wrong-token\n\+ {terminal_claude}\n\+ bash \"$1\"\n",+ quote(&captured.display().to_string())+ ),+ )+ .expect("open");+ let tool = bin.join(name);+ std::fs::write(+ &tool,+ format!(+ "#!/bin/bash\n\+ printf '%s\\n' \"${{CODEX_HOME:-}}\" \"${{CLAUDE_CONFIG_DIR:-}}\" \+ \"${{ANTHROPIC_AUTH_TOKEN:-}}\" \"$@\" > {0}.partial && mv {0}.partial {0}\n",+ quote(&output.display().to_string())+ ),+ )+ .expect("tool");+ for path in [&open, &tool] {+ std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o700))+ .expect("executable");+ }+ let mut child = std::process::Command::new(std::env::current_exe().expect("runner"));+ child+ .args([+ "--exact",+ "sessions::tests::\+ generated_sessions_use_explicit_accounts_without_changing_user_defaults",+ ])+ .env("SWITCHYARD_SESSION_FIXTURE", fixture.path())+ .env("SWITCHYARD_SESSION_TOOL", name)+ .env("HOME", &home)+ .env("CODEX_HOME", &default)+ .env("CLAUDE_CONFIG_DIR", &default)+ .env("PATH", format!("{}:/usr/bin:/bin", bin.display()))+ .env("TERMINAL", &open);+ if named {+ child.env("SWITCHYARD_SESSION_ACCOUNT", &account);+ }+ if !inherited_dir {+ child.env_remove("CLAUDE_CONFIG_DIR");+ }+ let result = child.output().expect("child");+ assert!(+ result.status.success(),+ "{}\n{}",+ String::from_utf8_lossy(&result.stdout),+ String::from_utf8_lossy(&result.stderr)+ );+ // A Linux terminal starts apart from the launch, so the arguments can arrive+ // after the child exits. The tool stub renames the file into place when done.+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);+ while !output.exists() && std::time::Instant::now() < deadline {+ std::thread::sleep(std::time::Duration::from_millis(20));+ }+ let arguments = std::fs::read_to_string(output).expect("arguments");+ let lines: Vec<_> = arguments.lines().collect();+ let expected = if named {+ account.to_str().expect("path")+ } else if inherited_dir {+ default.to_str().expect("path")+ } else {+ ""+ };+ assert_eq!(lines[usize::from(name == "claude")], expected);+ if name == "claude" {+ assert_eq!(lines[2], "");+ }+ assert!(arguments.contains("route'$(literal)"));+ let script = std::fs::read_to_string(captured).expect("script");+ assert!(script.contains("x-switchyard-session-id"));+ if name == "claude" && !named && !inherited_dir {+ assert!(!script.contains("export CLAUDE_CONFIG_DIR="));+ }+ assert_eq!(+ std::fs::read_to_string(default.join("settings.json")).expect("settings"),+ "{\"user\":true}"+ );+ }+ }+}diff --git a/crates/switchyard-desktop/src/tui.rs b/crates/switchyard-desktop/src/tui.rsindex 0a73f9dd4..4882d60ef 100644--- a/crates/switchyard-desktop/src/tui.rs+++ b/crates/switchyard-desktop/src/tui.rs@@ -150,7 +150,7 @@ const SESSIONS_KEYS: &[Key] = &[("s","session",- "Select the next recorded session and show its details.",+ "Select the next recorded session. o opens its folder and d removes it.",),];const SETTINGS_KEYS: &[Key] = &[@@ -323,6 +323,21 @@ const ACTIONS: &[ActionRow] = &["Creates a saved account and opens the harness's login in a new terminal window.",&[ActionKind::AddAccount],),+ (+ Tab::Sessions,+ 'o',+ "open session",+ "Opens the selected session folder in $VISUAL or $EDITOR.",+ &[ActionKind::OpenSession],+ ),+ (+ Tab::Sessions,+ 'd',+ "remove",+ "Shows what cleanup deletes, including Git-ignored files, then removes the clean \+ worktree and its session branch after you type REMOVE.",+ &[ActionKind::PreviewSessionCleanup, ActionKind::RemoveSession],+ ),(Tab::Settings,'o',@@ -977,7 +992,7 @@ impl Form {Action::Restore { .. } => "Restoring the harness settings",Action::ArchiveAccount { .. } => "Archiving the account",Action::Launch { .. } => "Launching the session",-+ Action::RemoveSession { .. } => "Removing the session",_ => "Saving the route",},FormKind::Remove { .. } => "Deleting the route",@@ -1134,7 +1149,7 @@ fn reviewed(previewed: Action, preview: &Value) -> Option<Action> {id,project,},-+ Action::PreviewSessionCleanup { id } => Action::RemoveSession { id, preview_token },_ => return None,})}@@ -1799,6 +1814,17 @@ impl App {)));}}+ (Some(ActionKind::PreviewSessionCleanup), Ok(reply)) if popup_matches => {+ if let Some(remove) = action.and_then(|action| reviewed(action, &reply.data)) {+ self.set_popup(Some(Popup::review(+ cleanup_lines(self.theme, &reply.data),+ "Remove",+ FormKind::Confirm("REMOVE".into(), Box::new(remove)),+ "Remove the session worktree?",+ "Type REMOVE to delete it",+ )));+ }+ }(Some(ActionKind::Models), Ok(reply)) if popup_matches => {let models: Vec<&str> = reply.data["models"].as_array()@@ -2400,6 +2426,19 @@ impl App {vec![("Git project folder", String::new())],))}+ // Controller::editor_target returns the session worktree, so it opens in the editor.+ ActionKind::OpenSession => {+ let id = self.session_id()?;+ request(Action::OpenSession { id }, "Opening the session folder")+ }+ // The review window lists the Git-ignored files that cleanup deletes and submits+ // RemoveSession. The controller rejects the removal when the worktree changed after+ // the review.+ ActionKind::PreviewSessionCleanup | ActionKind::RemoveSession => {+ let id = self.session_id()?;+ let cleanup = Action::PreviewSessionCleanup { id };+ request(cleanup, "Reviewing the session cleanup")+ }ActionKind::OpenConfig => request(Action::OpenConfig {}, "Opening the server config"),ActionKind::CheckConfig => {request(Action::CheckConfig {}, "Checking the server config")@@ -4884,6 +4923,45 @@ fn launch_lines(theme: Theme, preview: &Value) -> Vec<Line<'static>> {lines}+/// This function shows a cleanup preview: the worktree, whether it has uncommitted changes,+/// and the Git-ignored files that cleanup deletes. Like the desktop app, it names at most 20+/// files and counts the rest.+fn cleanup_lines(theme: Theme, preview: &Value) -> Vec<Line<'static>> {+ let field = |name: &str, value: String| labeled(theme, name, 11, value);+ let mut lines = vec![+ Line::from(text(preview, "cleanup_notice")),+ Line::default(),+ field("Directory", text(preview, "worktree")),+ field(+ "Branch",+ text_or(preview, "current_branch", "Detached HEAD"),+ ),+ field("Revision", text(preview, "current_revision")),+ Line::default(),+ if preview["dirty"] == true {+ Line::styled(+ "This worktree has uncommitted changes. Cleanup will refuse to remove it.",+ theme.warn,+ )+ } else {+ Line::styled("The worktree has no uncommitted changes.", theme.ok)+ },+ ];+ let ignored: Vec<&str> = preview["ignored"]+ .as_array()+ .into_iter()+ .flatten()+ .filter_map(Value::as_str)+ .collect();+ if !ignored.is_empty() {+ lines.push(Line::default());+ // The review lists every path the confirmation deletes; the popup scrolls.+ lines.push(Line::from("Cleanup also deletes these Git-ignored files:"));+ lines.extend(ignored.iter().map(|file| Line::from(file.to_string())));+ }+ lines+}+fn update_lines(theme: Theme, preview: &Value) -> Vec<Line<'static>> {// `git status --short` starts some lines with a space, so only trailing space is removed.let field = |name: &str| {