From f6976ab0369921a59e23416083587149807d8f93 Mon Sep 17 00:00:00 2001 From: Benjamin Carlsson Date: Sat, 5 Sep 2026 22:33:33 +0000 Subject: [PATCH] Add managed worktree creation to TUI session commands (#43120) ## What changed - Add `/worktree` to start a fresh conversation or fork the current conversation into a new managed checkout. - Offer current-checkout and new-worktree choices for `/new` and `/fork`, preserving optional conversation names. Enable these choices for local Git repositories when the `worktrees` feature is enabled. - Load destination configuration, bind the checkout to the replacement thread, and inherit conversation history only when forking. - Reject creation from explicitly untrusted sources and require an idle primary session without queued input. Refuse forks when developer instructions differ, with guidance for removing the unused checkout. ## Testing Add picker snapshots and tests for command availability, named selections, fresh versus forked history, destination configuration, worktree ownership, and feature and trust checks. GitOrigin-RevId: d6c83e00217660aacf2a6d92acad50b506607e0b --- codex-rs/tui/src/app/event_dispatch.rs | 7 + codex-rs/tui/src/app/reconnect.rs | 6 + codex-rs/tui/src/app/session_lifecycle.rs | 1 + codex-rs/tui/src/app/startup.rs | 4 + .../app/tests/session_lifecycle_requests.rs | 281 ++++++++++++++++++ codex-rs/tui/src/app/tests/turn_submission.rs | 109 +++++++ codex-rs/tui/src/app/working_directory.rs | 191 +++++++++++- codex-rs/tui/src/app_event.rs | 13 + codex-rs/tui/src/bottom_pane/chat_composer.rs | 17 +- .../bottom_pane/chat_composer/slash_input.rs | 20 ++ codex-rs/tui/src/bottom_pane/command_popup.rs | 5 + codex-rs/tui/src/bottom_pane/mod.rs | 5 + .../tui/src/bottom_pane/slash_commands.rs | 15 + codex-rs/tui/src/chatwidget.rs | 2 + codex-rs/tui/src/chatwidget/constructor.rs | 2 + codex-rs/tui/src/chatwidget/session_flow.rs | 1 + codex-rs/tui/src/chatwidget/settings.rs | 14 + codex-rs/tui/src/chatwidget/slash_dispatch.rs | 32 +- ...idget__tests__worktrees_command_local.snap | 8 + ...dget__tests__worktrees_command_remote.snap | 8 + ...tests__worktrees_conversation_choices.snap | 12 + ...widget__tests__worktrees_fork_choices.snap | 10 + ...twidget__tests__worktrees_new_choices.snap | 10 + codex-rs/tui/src/chatwidget/tests.rs | 2 + .../src/chatwidget/tests/slash_commands.rs | 20 +- .../chatwidget/tests/worktree_picker_tests.rs | 91 ++++++ .../tui/src/chatwidget/worktree_picker.rs | 121 ++++++++ codex-rs/tui/src/slash_command.rs | 3 + 28 files changed, 980 insertions(+), 30 deletions(-) create mode 100644 codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap create mode 100644 codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap create mode 100644 codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap create mode 100644 codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap create mode 100644 codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap create mode 100644 codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs create mode 100644 codex-rs/tui/src/chatwidget/worktree_picker.rs diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs index b651273350..88b2316662 100644 --- a/codex-rs/tui/src/app/event_dispatch.rs +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -50,6 +50,10 @@ impl App { | AppEvent::SelectAgentThread(_) | AppEvent::StartSide { .. } | AppEvent::ForkCurrentSession { .. } + | AppEvent::StartManagedWorktree { + mode: crate::app_event::ManagedWorktreeMode::Fork, + .. + } | AppEvent::ForkSessionForPromptEdit { .. } | AppEvent::SetThreadGoalDraft { .. } | AppEvent::SetThreadGoalStatus { @@ -86,6 +90,9 @@ impl App { self.chat_widget.show_misalignment_policy_precaution(); } } + AppEvent::StartManagedWorktree { mode, name } => { + self.start_managed_worktree(tui, app_server, mode, name).await; + } AppEvent::ChangeWorkingDirectory { thread_id, requested_cwd, diff --git a/codex-rs/tui/src/app/reconnect.rs b/codex-rs/tui/src/app/reconnect.rs index 7fee661b1e..8266534006 100644 --- a/codex-rs/tui/src/app/reconnect.rs +++ b/codex-rs/tui/src/app/reconnect.rs @@ -244,6 +244,12 @@ impl App { self.rate_limit_refresh_state.invalidate_recovery(); session.inherit_task_tool_capabilities(app_server); *app_server = session; + self.chat_widget.set_local_worktree_operations( + !crate::uses_remote_workspace_or_environment( + &self.app_server_target, + self.environment_manager.as_ref(), + ), + ); self.chat_widget.cyber_policy_notice = Default::default(); self.chat_widget.requires_openai_auth = bootstrap.requires_openai_auth; self.chat_widget.remote_connection = diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs index bef1726422..a5b143e6b2 100644 --- a/codex-rs/tui/src/app/session_lifecycle.rs +++ b/codex-rs/tui/src/app/session_lifecycle.rs @@ -486,6 +486,7 @@ impl App { chat_widget.last_terminal_title = previous_terminal_title; } chat_widget.remote_connection = self.chat_widget.remote_connection.clone(); + chat_widget.set_local_worktree_operations(self.chat_widget.local_worktree_operations); chat_widget.set_agents_navigation_enabled(matches!( self.app_server_target, AppServerTarget::LocalDaemon { .. } diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs index ae32424052..9dae22c9fe 100644 --- a/codex-rs/tui/src/app/startup.rs +++ b/codex-rs/tui/src/app/startup.rs @@ -505,6 +505,10 @@ impl App { }; chat_widget.note_rendered_width(tui.terminal.last_known_screen_size.width); chat_widget.remote_connection = remote_connection; + chat_widget.set_local_worktree_operations(!crate::uses_remote_workspace_or_environment( + &app_server_target, + environment_manager.as_ref(), + )); chat_widget.set_agents_navigation_enabled(matches!( app_server_target, AppServerTarget::LocalDaemon { .. } diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs index 50352de947..9e3be95ce9 100644 --- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs +++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs @@ -2762,6 +2762,287 @@ async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history() Ok(()) } +#[tokio::test] +async fn managed_worktree_transitions_bind_owner_and_preserve_only_fork_history() -> Result<()> { + use crate::app_event::ManagedWorktreeMode; + use std::fs; + use std::process::Command; + + let (mut app, mut events, _op_rx) = make_test_app_with_channels().await; + let root = tempdir()?; + let home = dunce::canonicalize(root.path())?.join("home"); + let source = dunce::canonicalize(root.path())?.join("source"); + let project_pool = dunce::canonicalize(root.path())?.join("project-pool"); + fs::create_dir_all(&home)?; + fs::create_dir_all(source.join(".codex"))?; + fs::write(home.join("config.toml"), "[features]\nworktrees = true\n")?; + crate::legacy_core::config::set_project_trust_level( + &home, + &source, + codex_protocol::config_types::TrustLevel::Trusted, + ) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?; + let destination = format!( + r#"developer_instructions = "committed policy" +model = "gpt-5.2" +model_reasoning_effort = "high" +[desktop] +git-worktree-root = {} +"#, + toml::Value::String(project_pool.display().to_string()), + ); + fs::write(source.join(".codex/config.toml"), destination)?; + fs::write(source.join("AGENTS.md"), "committed worktree instructions")?; + for args in [ + vec!["init", "--quiet"], + vec!["add", "."], + vec!["commit", "--quiet", "--no-gpg-sign", "-m", "initial"], + ] { + let result = Command::new("git") + .current_dir(&source) + .args([ + "-c", + "user.name=Worktree Test", + "-c", + "user.email=test@example.invalid", + ]) + .args(args) + .output()?; + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + } + fs::write( + source.join(".codex/config.toml"), + r#"developer_instructions = "dirty policy" +model = "gpt-5.4" +model_reasoning_effort = "low" +"#, + )?; + fs::write(source.join("AGENTS.md"), "dirty source instructions")?; + app.config.codex_home = home.clone().abs(); + app.config.sqlite = SqliteConfig::new_for_testing(home.clone().abs()); + app.config.cwd = source.clone().abs(); + app.harness_overrides.permission_profile = Some(PermissionProfile::workspace_write()); + app.config = app.rebuild_config_for_cwd(source.clone()).await?; + app.chat_widget + .handle_thread_session_quiet(test_thread_session(ThreadId::new(), source.clone())); + let (mut server, requests, proxy) = start_recording_app_server( + &app.config, + /*blocked_thread_list*/ None, + /*failed_thread_name*/ None, + ) + .await?; + let mut tui = crate::tui::test_support::make_test_tui()?; + app.start_fresh_session_with_summary_hint( + &mut tui, + &mut server, + /*session_start_source*/ None, + /*initial_user_message*/ None, + /*new_thread_name*/ None, + ) + .await; + assert_eq!( + ( + app.chat_widget.current_model(), + app.config.model_provider_id.as_str(), + app.chat_widget.current_reasoning_effort() + ), + ("gpt-5.4", "openai", Some(ReasoningEffortConfig::Low)) + ); + // Provider selection belongs to host config, not project config. + let host_config = home.join("config.toml"); + let contents = fs::read_to_string(&host_config)?; + fs::write( + host_config, + format!("model_provider = \"ollama\"\n{contents}"), + )?; + let original = app.chat_widget.thread_id().expect("original thread"); + server.thread_inject_items(original, vec![serde_json::from_value(serde_json::json!({ + "type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "managed fork history"}] + }))?]).await?; + let manager = codex_worktree::WorktreeManager::new( + codex_worktree::WorktreeSettings::for_cli(&home, /*desktop*/ None) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?, + ); + requests.lock().expect("request recorder lock").clear(); + app.handle_event( + &mut tui, + &mut server, + AppEvent::StartManagedWorktree { + mode: ManagedWorktreeMode::Fork, + name: None, + }, + ) + .await?; + assert_eq!(app.chat_widget.thread_id(), Some(original)); + assert!(recorded_params(&requests, "thread/fork").is_empty()); + let unused = manager + .list(&source) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))? + .pop() + .expect("unused checkout"); + assert_eq!( + manager + .owner(&unused.root) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?, + None + ); + let error = std::iter::from_fn(|| events.try_recv().ok()) + .filter_map(|event| match event { + AppEvent::InsertHistoryCell(cell) => { + Some(lines_to_single_string(&cell.display_lines(/*width*/ 500))) + } + _ => None, + }) + .find(|message| message.contains("Cannot fork into this worktree")) + .expect("fork refusal"); + let (_, with_path) = error + .split_once("An unused checkout was created at ") + .expect("checkout marker"); + let (path, _) = with_path + .split_once("; remove it with") + .expect("cleanup marker"); + insta::assert_snapshot!(error.replace(path, ""), @"■ Cannot fork into this worktree because developer instructions differ. Start a new conversation instead. An unused checkout was created at ; remove it with `git worktree remove ` from the source repository."); + fs::write( + source.join(".codex/config.toml"), + r#"developer_instructions = "committed policy" +[features] +terminal_visualization_instructions = true +"#, + )?; + app.config = app.rebuild_config_for_cwd(source.clone()).await?; + requests.lock().expect("request recorder lock").clear(); + app.handle_event( + &mut tui, + &mut server, + AppEvent::StartManagedWorktree { + mode: ManagedWorktreeMode::Fork, + name: None, + }, + ) + .await?; + assert_eq!(app.chat_widget.thread_id(), Some(original)); + assert!(recorded_params(&requests, "thread/fork").is_empty()); + for mode in [ManagedWorktreeMode::New, ManagedWorktreeMode::Fork] { + requests.lock().expect("request recorder lock").clear(); + let previous = app.chat_widget.thread_id(); + let previous_rollout = app.chat_widget.rollout_path().expect("previous rollout"); + app.handle_event( + &mut tui, + &mut server, + AppEvent::StartManagedWorktree { + mode, + name: Some(format!("{mode:?} worktree")), + }, + ) + .await?; + let replacement = app.chat_widget.thread_id().expect("replacement thread"); + assert_ne!(Some(replacement), previous); + assert_eq!( + app.chat_widget.thread_name(), + Some(format!("{mode:?} worktree")) + ); + let cwd = app.config.cwd.as_path().canonicalize()?; + let checkouts = manager + .list(&source) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?; + let checkout = checkouts + .iter() + .find(|checkout| checkout.cwd.canonicalize().ok().as_ref() == Some(&cwd)) + .expect("managed checkout"); + assert!(checkout.root.starts_with(home.join("worktrees"))); + assert!(!project_pool.exists()); + assert_eq!( + manager + .owner(&checkout.root) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?, + Some(replacement.to_string()) + ); + assert_eq!( + app.config.developer_instructions.as_deref(), + Some("committed policy") + ); + assert_eq!( + fs::read_to_string(checkout.cwd.join("AGENTS.md"))?, + "committed worktree instructions" + ); + let fork = matches!(mode, ManagedWorktreeMode::Fork); + let method = if fork { "thread/fork" } else { "thread/start" }; + let params = recorded_params(&requests, method); + assert_eq!(params.len(), 1); + assert_eq!( + [ + params[0]["model"].as_str(), + params[0]["modelProvider"].as_str(), + params[0]["config"]["model_reasoning_effort"].as_str(), + ], + [Some("gpt-5.2"), Some("ollama"), Some("high")] + ); + // Injection flushes and materializes a new thread's otherwise lazy rollout. + server.thread_inject_items(replacement, vec![serde_json::from_value(serde_json::json!({ + "type": "message", "role": "assistant", "content": [{"type": "output_text", "text": format!("replacement persistence probe {mode:?}")}] + }))?]).await?; + let rollout = app.chat_widget.rollout_path().expect("replacement rollout"); + let mut history = fs::read(&rollout)?; + let metadata = codex_rollout::read_session_meta_line(&rollout).await?; + assert_eq!(metadata.meta.history_base.is_some(), fork); + if let Some(base) = metadata.meta.history_base { + assert!(fork, "New must not inherit history"); + assert_eq!(Some(base.thread_id), previous); + let parent = fs::read(&previous_rollout)?; + history.extend_from_slice( + parent + .get(..usize::try_from(base.end_byte_offset)?) + .expect("valid inherited prefix"), + ); + } + let history = String::from_utf8(history)?; + assert!(!history.contains("managed fork history")); + if fork { + assert!(history.contains("replacement persistence probe New")); + } + let attached = server + .thread_read(replacement, /*include_turns*/ false) + .await?; + assert_eq!(attached.cwd.as_path().canonicalize()?, cwd); + } + app.start_fresh_session_with_summary_hint( + &mut tui, + &mut server, + /*session_start_source*/ None, + /*initial_user_message*/ None, + /*new_thread_name*/ None, + ) + .await; + let unsaved = app.chat_widget.thread_id().expect("unsaved thread"); + let path = app.chat_widget.rollout_path(); + assert!(path.is_none_or(|path| !rollout_path_is_resumable(&path))); + let completed = test_turn("completed-unsaved-turn", TurnStatus::Completed, Vec::new()); + app.thread_event_channels[&unsaved] + .store + .lock() + .await + .set_turns(vec![completed]); + for mode in [ManagedWorktreeMode::Fork, ManagedWorktreeMode::New] { + requests.lock().expect("request recorder lock").clear(); + app.handle_event( + &mut tui, + &mut server, + AppEvent::StartManagedWorktree { mode, name: None }, + ) + .await?; + let is_new = mode == ManagedWorktreeMode::New; + assert_eq!(app.chat_widget.thread_id() != Some(unsaved), is_new); + assert_eq!(recorded_params(&requests, "thread/fork").len(), 0); + } + server.shutdown().await?; + proxy.await??; + Ok(()) +} + #[tokio::test] async fn changing_directory_preserves_project_trust_permissions_history_and_hooks() -> Result<()> { use codex_protocol::config_types::TrustLevel as T; diff --git a/codex-rs/tui/src/app/tests/turn_submission.rs b/codex-rs/tui/src/app/tests/turn_submission.rs index 60342fd081..606ccaeb62 100644 --- a/codex-rs/tui/src/app/tests/turn_submission.rs +++ b/codex-rs/tui/src/app/tests/turn_submission.rs @@ -11,6 +11,84 @@ use codex_protocol::permissions::FileSystemSpecialPath; use codex_protocol::permissions::NetworkSandboxPolicy; use pretty_assertions::assert_eq; +#[tokio::test] +async fn worktree_creation_event_requires_feature() -> Result<()> { + let (mut app, mut events, _op_rx) = make_test_app_with_channels().await; + let mut tui = crate::tui::test_support::make_test_tui()?; + let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + while events.try_recv().is_ok() {} + app.handle_event( + &mut tui, + &mut app_server, + AppEvent::StartManagedWorktree { + mode: crate::app_event::ManagedWorktreeMode::New, + name: None, + }, + ) + .await?; + let message = std::iter::from_fn(|| events.try_recv().ok()) + .find_map(|event| match event { + AppEvent::InsertHistoryCell(cell) => { + Some(lines_to_single_string(&cell.display_lines(/*width*/ 100))) + } + _ => None, + }) + .expect("disabled feature message"); + insta::assert_snapshot!(message, @"■ Enable worktrees in /experimental to create a worktree."); + assert!(!app.config.codex_home.join("worktrees").exists()); + app_server.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn worktree_creation_rejects_untrusted_source_before_allocation() -> Result<()> { + use crate::app_event::ManagedWorktreeMode; + + let (mut app, mut events, _op_rx) = make_test_app_with_channels().await; + app.config.features.enable(Feature::Worktrees)?; + app.config.active_project.trust_level = + Some(codex_protocol::config_types::TrustLevel::Untrusted); + let thread_id = ThreadId::new(); + app.primary_thread_id = Some(thread_id); + app.chat_widget + .handle_thread_session_quiet(test_thread_session(thread_id, app.config.cwd.to_path_buf())); + let mut tui = crate::tui::test_support::make_test_tui()?; + let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?; + for mode in [ManagedWorktreeMode::New, ManagedWorktreeMode::Fork] { + if mode == ManagedWorktreeMode::Fork { + app.config.active_project.trust_level = + Some(codex_protocol::config_types::TrustLevel::Trusted); + crate::legacy_core::config::set_project_trust_level( + &app.config.codex_home, + app.config.cwd.as_path(), + codex_protocol::config_types::TrustLevel::Untrusted, + ) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?; + } + while events.try_recv().is_ok() {} + app.handle_event( + &mut tui, + &mut app_server, + AppEvent::StartManagedWorktree { mode, name: None }, + ) + .await?; + let message = std::iter::from_fn(|| events.try_recv().ok()) + .find_map(|event| match event { + AppEvent::InsertHistoryCell(cell) => { + Some(lines_to_single_string(&cell.display_lines(/*width*/ 100))) + } + _ => None, + }) + .expect("source trust error"); + insta::allow_duplicates! { + insta::assert_snapshot!(message, @"■ Cannot create a worktree from an explicitly untrusted source."); + } + assert!(!app.config.codex_home.join("worktrees").exists()); + } + app_server.shutdown().await?; + Ok(()) +} + #[tokio::test] async fn turn_start_failure_is_shown_without_exiting() -> Result<()> { let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; @@ -64,6 +142,32 @@ async fn turn_start_failure_is_shown_without_exiting() -> Result<()> { #[tokio::test] async fn misalignment_policy_blocks_queued_turns_and_goal_resumption() -> Result<()> { let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let checkout = tempfile::tempdir()?; + app.config.cwd = AbsolutePathBuf::from_absolute_path(checkout.path())?; + for args in [ + vec!["init", "--quiet"], + vec![ + "-c", + "user.name=Test", + "-c", + "user.email=test@example.com", + "-c", + "commit.gpgsign=false", + "commit", + "--quiet", + "--allow-empty", + "-m", + "initial", + ], + ] { + assert!( + std::process::Command::new("git") + .args(args) + .current_dir(checkout.path()) + .status()? + .success() + ); + } let mut tui = crate::tui::test_support::make_test_tui()?; let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; let started = app_server.start_thread(&app.config).await?; @@ -126,12 +230,17 @@ async fn misalignment_policy_blocks_queued_turns_and_goal_resumption() -> Result user_message: Some("Do not fork this stopped thread".into()), }, AppEvent::ForkCurrentSession { name: None }, + AppEvent::StartManagedWorktree { + mode: crate::app_event::ManagedWorktreeMode::Fork, + name: None, + }, AppEvent::OpenAgentPicker, AppEvent::SelectAgentThread(thread_id), ] { app.handle_event(&mut tui, &mut app_server, event).await?; } + assert!(!app.config.codex_home.join("worktrees").exists()); assert_eq!( app_server.next_request_id(), AppServerRequestId::Integer(next_request_id + 1) diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rs index 09ec332341..481b2867ce 100644 --- a/codex-rs/tui/src/app/working_directory.rs +++ b/codex-rs/tui/src/app/working_directory.rs @@ -1,22 +1,141 @@ -//! Local working-directory changes that preserve conversation history. +//! Local directory transitions and managed worktrees with fresh or preserved conversation history. use super::session_lifecycle::ThreadAttachPresentation; use super::*; use crate::app_server_session::ForkGoalContinuation::DeferUntilNextTurn; use crate::history_cell::McpInventoryLoadingCell as LoadingCell; +use crate::terminal_visualization_instructions::with_terminal_visualization_instructions; use codex_app_server_protocol::ThreadBackgroundTerminalsListParams; use codex_app_server_protocol::ThreadBackgroundTerminalsListResponse as ListResponse; impl App { + pub(super) async fn start_managed_worktree( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + mode: crate::app_event::ManagedWorktreeMode, + name: Option, + ) { + if !self.config.features.enabled(Feature::Worktrees) { + self.chat_widget.add_error_message( + "Enable worktrees in /experimental to create a worktree.".to_string(), + ); + } else if self.config.active_project.is_untrusted() { + self.chat_widget.add_error_message( + "Cannot create a worktree from an explicitly untrusted source.".to_string(), + ); + } else if crate::uses_remote_workspace_or_environment( + &self.app_server_target, + self.environment_manager.as_ref(), + ) { + self.chat_widget.add_error_message( + "Managed worktrees are only supported for local sessions.".to_string(), + ); + } else if self + .primary_thread_id + .is_none_or(|thread_id| !self.chat_widget.can_change_working_directory(thread_id)) + { + self.chat_widget.add_error_message( + "Creating a worktree requires an idle primary session without queued input." + .to_string(), + ); + } else { + let setup = async { + let source = self + .rebuild_config_for_cwd(self.config.cwd.to_path_buf()) + .await + .map_err(|error| anyhow::anyhow!(error.to_string()))?; + anyhow::ensure!( + !source.active_project.is_untrusted(), + "Cannot create a worktree from an explicitly untrusted source." + ); + let host = crate::legacy_core::config::load_config_toml_with_layer_stack( + &self.config.codex_home, + /*cwd*/ None, + Vec::new(), + codex_config::ConfigLoadOptions::default(), + ) + .await?; + let settings = codex_worktree::WorktreeSettings::for_cli( + &self.config.codex_home, + host.config_toml.desktop.as_ref(), + )?; + let manager = codex_worktree::WorktreeManager::new(settings); + let checkout = manager.create(&codex_worktree::CreateWorktree { + source_cwd: self.config.cwd.to_path_buf(), + base: None, + })?; + anyhow::Ok((manager, checkout)) + } + .await; + match setup { + Ok((manager, checkout)) => { + if let Err(error) = self + .switch_to_managed_worktree(tui, app_server, manager, checkout, mode, name) + .await + { + self.chat_widget.add_error_message(error.to_string()); + } + } + Err(error) => self.chat_widget.add_error_message(error.to_string()), + } + } + } + fn working_directory_error(&mut self, message: impl Into) { self.chat_widget.add_error_message(message.into()); } + pub(super) async fn switch_to_managed_worktree( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + manager: codex_worktree::WorktreeManager, + checkout: codex_worktree::ManagedWorktree, + mode: crate::app_event::ManagedWorktreeMode, + name: Option, + ) -> Result<()> { + let previous_thread_id = self.chat_widget.thread_id(); + let cwd = AbsolutePathBuf::from_absolute_path(checkout.cwd.clone()) + .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?; + self.change_working_directory_with_managed( + tui, + app_server, + cwd, + Some((manager, checkout, mode, name)), + ) + .await; + if self.chat_widget.thread_id() == previous_thread_id { + return Err(color_eyre::eyre::eyre!( + "Could not start a session in the managed worktree" + )); + } + Ok(()) + } + pub(super) async fn change_working_directory( &mut self, tui: &mut tui::Tui, app_server: &mut AppServerSession, cwd: AbsolutePathBuf, + ) { + self.change_working_directory_with_managed( + tui, app_server, cwd, /*managed_worktree*/ None, + ) + .await; + } + + async fn change_working_directory_with_managed( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + cwd: AbsolutePathBuf, + managed_worktree: Option<( + codex_worktree::WorktreeManager, + codex_worktree::ManagedWorktree, + crate::app_event::ManagedWorktreeMode, + Option, + )>, ) { if self.config.ephemeral || !cwd.as_path().is_dir() { return self.working_directory_error("This task cannot be safely replaced."); @@ -55,6 +174,21 @@ impl App { if config.active_project.trust_level.is_none() { return self.working_directory_error("This directory is not trusted; run Codex there."); } + if let Some((_, checkout, crate::app_event::ManagedWorktreeMode::Fork, _)) = + managed_worktree.as_ref() + && with_terminal_visualization_instructions( + &self.config, + self.config.developer_instructions.clone(), + ) != with_terminal_visualization_instructions( + &config, + config.developer_instructions.clone(), + ) + { + return self.working_directory_error(format!( + "Cannot fork into this worktree because developer instructions differ. Start a new conversation instead. An unused checkout was created at {}; remove it with `git worktree remove ` from the source repository.", + checkout.root.display() + )); + } if let Some(profile) = self.runtime_permission_profile_override.as_ref() && profile.active_permission_profile.is_some() && (!profile.matches_config(&config) @@ -98,10 +232,15 @@ impl App { Err(error) => return self.chat_widget.add_error_message(error), }; config.service_tier = self.chat_widget.configured_service_tier(); + let is_new_worktree = matches!( + managed_worktree.as_ref().map(|(_, _, mode, _)| mode), + Some(crate::app_event::ManagedWorktreeMode::New) + ); let rollout = self.chat_widget.rollout_path(); let has_rollout = rollout.as_deref().is_some_and(rollout_path_is_resumable); let channels = &self.thread_event_channels; if !has_rollout + && !is_new_worktree && (!self.chat_widget.token_usage().is_zero() || channels.get(&thread_id).is_some_and(|channel| { channel.store.try_lock().map_or(/*default*/ true, |store| { @@ -142,7 +281,16 @@ impl App { return self.working_directory_error("Active background terminals block /cd."); } } - let transitioned = if has_rollout { + if is_new_worktree { + apply_managed_new_thread_defaults( + &mut config, + app_server.managed_new_thread_defaults(), + &self.cli_kv_overrides, + &self.harness_overrides, + ); + } + let preserve_history = has_rollout && !is_new_worktree; + let transitioned = if preserve_history { app_server .fork_thread_at( &local_settings, @@ -163,7 +311,7 @@ impl App { ) .await }; - let transitioned = match transitioned { + let mut transitioned = match transitioned { Ok(value) => value, Err(e) => return self.working_directory_error(format!("Failed to change: {e}")), }; @@ -177,16 +325,46 @@ impl App { { if session.thread_id != thread_id { let _ = app_server.thread_unsubscribe(session.thread_id).await; - if has_rollout { + if preserve_history { let _ = app_server.thread_archive(session.thread_id).await; } } return self.working_directory_error("Requested directory or permissions not applied."); } + if let Some((manager, checkout, _, _)) = managed_worktree.as_ref() + && let Err(error) = + manager.bind_thread(&checkout.root, &transitioned.session.thread_id.to_string()) + { + let replacement_id = transitioned.session.thread_id; + let _ = app_server.thread_unsubscribe(replacement_id).await; + if preserve_history { + let _ = app_server.thread_archive(replacement_id).await; + } + return self.working_directory_error(format!( + "Cannot register managed worktree ownership: {error}" + )); + } + let name_error = if let Some(name) = managed_worktree + .as_ref() + .and_then(|(_, _, _, name)| name.as_ref()) + { + match app_server + .thread_set_name(transitioned.session.thread_id, name.clone()) + .await + { + Ok(()) => { + transitioned.session.thread_name = Some(name.clone()); + None + } + Err(error) => Some(format!("Failed to name the worktree session: {error}")), + } + } else { + None + }; if let Err(error) = app_server.thread_unsubscribe(thread_id).await { let replacement_id = transitioned.session.thread_id; let _ = app_server.thread_unsubscribe(replacement_id).await; - if has_rollout { + if preserve_history { let _ = app_server.thread_archive(replacement_id).await; } return self.working_directory_error(format!("Cannot change directories: {error}")); @@ -210,6 +388,9 @@ impl App { if let Err(error) = attach(self, tui, transitioned, lineage, message).await { return self.working_directory_error(format!("Could not restore session: {error}")); } + if let Some(error) = name_error { + self.chat_widget.add_error_message(error); + } self.cancel_pending_key_chord(); self.keymap = keymap; self.merge_startup_warnings(tui, &history_cell::StartupWarningsCell::default()); diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs index 1ac727a8c2..0a7fb54d85 100644 --- a/codex-rs/tui/src/app_event.rs +++ b/codex-rs/tui/src/app_event.rs @@ -66,6 +66,13 @@ use codex_protocol::models::ActivePermissionProfile; use crate::history_cell::HistoryCell; +/// Whether a managed checkout starts fresh or preserves the current conversation. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum ManagedWorktreeMode { + New, + Fork, +} + #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum ThreadGoalSetMode { ConfirmIfExists, @@ -388,6 +395,12 @@ pub(crate) enum AppEvent { name: Option, }, + /// Create a managed checkout and start or fork a session into it. + StartManagedWorktree { + mode: ManagedWorktreeMode, + name: Option, + }, + /// Change the working directory of the originating idle primary thread. ChangeWorkingDirectory { thread_id: ThreadId, diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs index df82fdee71..967c712fe9 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs @@ -279,7 +279,6 @@ use super::paste_burst::PasteBurst; use super::prompt_args::parse_slash_name; use super::skill_popup::MentionItem; use super::skill_popup::SkillPopup; -use super::slash_commands::BuiltinCommandFlags; use super::slash_commands::ServiceTierCommand; use super::slash_commands::SlashCommandItem; use crate::bottom_pane::paste_burst::FlushResult; @@ -555,6 +554,7 @@ pub(crate) struct ChatComposer { mentions_v2_enabled: bool, goal_command_enabled: bool, personality_command_enabled: bool, + worktrees_enabled: bool, windows_degraded_sandbox_active: bool, side_conversation_active: bool, history_search: Option, @@ -611,20 +611,6 @@ impl ChatComposer { ) } - fn builtin_command_flags(&self) -> BuiltinCommandFlags { - BuiltinCommandFlags { - collaboration_modes_enabled: self.collaboration_modes_enabled, - connectors_enabled: self.connectors_enabled, - plugins_command_enabled: self.plugins_command_enabled, - token_activity_command_enabled: self.token_activity_command_enabled, - service_tier_commands_enabled: self.service_tier_commands_enabled, - goal_command_enabled: self.goal_command_enabled, - personality_command_enabled: self.personality_command_enabled, - allow_elevate_sandbox: self.windows_degraded_sandbox_active, - side_conversation_active: self.side_conversation_active, - } - } - pub fn new( has_input_focus: bool, app_event_tx: AppEventSender, @@ -732,6 +718,7 @@ impl ChatComposer { mentions_v2_enabled: false, goal_command_enabled: false, personality_command_enabled: false, + worktrees_enabled: false, windows_degraded_sandbox_active: false, side_conversation_active: false, history_search: None, diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs index 81734f2d08..22fce854f4 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs @@ -178,6 +178,7 @@ impl<'a> SlashInput<'a> { service_tier_commands_enabled: self.command_flags.service_tier_commands_enabled, goal_command_enabled: self.command_flags.goal_command_enabled, personality_command_enabled: self.command_flags.personality_command_enabled, + worktrees_enabled: self.command_flags.worktrees_enabled, windows_degraded_sandbox_active: self.command_flags.allow_elevate_sandbox, side_conversation_active: self.command_flags.side_conversation_active, }, @@ -206,6 +207,25 @@ pub(super) fn queued_input_action( } impl ChatComposer { + pub(super) fn builtin_command_flags(&self) -> BuiltinCommandFlags { + BuiltinCommandFlags { + collaboration_modes_enabled: self.collaboration_modes_enabled, + connectors_enabled: self.connectors_enabled, + plugins_command_enabled: self.plugins_command_enabled, + token_activity_command_enabled: self.token_activity_command_enabled, + service_tier_commands_enabled: self.service_tier_commands_enabled, + goal_command_enabled: self.goal_command_enabled, + personality_command_enabled: self.personality_command_enabled, + worktrees_enabled: self.worktrees_enabled, + allow_elevate_sandbox: self.windows_degraded_sandbox_active, + side_conversation_active: self.side_conversation_active, + } + } + + pub fn set_worktrees_enabled(&mut self, enabled: bool) { + self.worktrees_enabled = enabled; + } + /// Handle key event when the slash-command popup is visible. pub(super) fn handle_key_event_with_slash_popup( &mut self, diff --git a/codex-rs/tui/src/bottom_pane/command_popup.rs b/codex-rs/tui/src/bottom_pane/command_popup.rs index f613e5ee3f..81cc8013d8 100644 --- a/codex-rs/tui/src/bottom_pane/command_popup.rs +++ b/codex-rs/tui/src/bottom_pane/command_popup.rs @@ -48,6 +48,7 @@ pub(crate) struct CommandPopupFlags { pub(crate) service_tier_commands_enabled: bool, pub(crate) goal_command_enabled: bool, pub(crate) personality_command_enabled: bool, + pub(crate) worktrees_enabled: bool, pub(crate) windows_degraded_sandbox_active: bool, pub(crate) side_conversation_active: bool, } @@ -62,6 +63,7 @@ impl From for BuiltinCommandFlags { service_tier_commands_enabled: value.service_tier_commands_enabled, goal_command_enabled: value.goal_command_enabled, personality_command_enabled: value.personality_command_enabled, + worktrees_enabled: value.worktrees_enabled, allow_elevate_sandbox: value.windows_degraded_sandbox_active, side_conversation_active: value.side_conversation_active, } @@ -535,6 +537,7 @@ mod tests { service_tier_commands_enabled: false, goal_command_enabled: false, personality_command_enabled: true, + worktrees_enabled: true, windows_degraded_sandbox_active: false, side_conversation_active: false, }, @@ -562,6 +565,7 @@ mod tests { service_tier_commands_enabled: false, goal_command_enabled: false, personality_command_enabled: false, + worktrees_enabled: false, windows_degraded_sandbox_active: false, side_conversation_active: false, }, @@ -594,6 +598,7 @@ mod tests { service_tier_commands_enabled: false, goal_command_enabled: false, personality_command_enabled: true, + worktrees_enabled: true, windows_degraded_sandbox_active: false, side_conversation_active: false, }, diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rs index c1cd7db9f3..aeff6e1f2e 100644 --- a/codex-rs/tui/src/bottom_pane/mod.rs +++ b/codex-rs/tui/src/bottom_pane/mod.rs @@ -516,6 +516,11 @@ impl BottomPane { self.request_redraw(); } + pub fn set_worktrees_enabled(&mut self, enabled: bool) { + self.composer.set_worktrees_enabled(enabled); + self.request_redraw(); + } + pub fn set_personality_command_enabled(&mut self, enabled: bool) { self.composer.set_personality_command_enabled(enabled); self.request_redraw(); diff --git a/codex-rs/tui/src/bottom_pane/slash_commands.rs b/codex-rs/tui/src/bottom_pane/slash_commands.rs index 52b980e93f..61393648e7 100644 --- a/codex-rs/tui/src/bottom_pane/slash_commands.rs +++ b/codex-rs/tui/src/bottom_pane/slash_commands.rs @@ -62,6 +62,7 @@ pub(crate) struct BuiltinCommandFlags { pub(crate) service_tier_commands_enabled: bool, pub(crate) goal_command_enabled: bool, pub(crate) personality_command_enabled: bool, + pub(crate) worktrees_enabled: bool, pub(crate) allow_elevate_sandbox: bool, pub(crate) side_conversation_active: bool, } @@ -76,6 +77,7 @@ pub(crate) fn builtins_for_input(flags: BuiltinCommandFlags) -> Vec<(&'static st .filter(|(_, cmd)| flags.plugins_command_enabled || *cmd != SlashCommand::Plugins) .filter(|(_, cmd)| flags.token_activity_command_enabled || *cmd != SlashCommand::Usage) .filter(|(_, cmd)| flags.goal_command_enabled || *cmd != SlashCommand::Goal) + .filter(|(_, cmd)| flags.worktrees_enabled || *cmd != SlashCommand::Worktree) .filter(|(_, cmd)| flags.personality_command_enabled || *cmd != SlashCommand::Personality) .filter(|(_, cmd)| !flags.side_conversation_active || cmd.available_in_side_conversation()) .collect() @@ -171,11 +173,24 @@ mod tests { service_tier_commands_enabled: true, goal_command_enabled: true, personality_command_enabled: true, + worktrees_enabled: true, allow_elevate_sandbox: true, side_conversation_active: false, } } + #[test] + fn worktree_command_lookup_requires_feature() { + assert_eq!( + find_builtin_command("worktree", BuiltinCommandFlags::default()), + None + ); + assert_eq!( + find_builtin_command("worktree", all_enabled_flags()), + Some(SlashCommand::Worktree) + ); + } + #[test] fn debug_command_still_resolves_for_dispatch() { let cmd = find_builtin_command("debug-config", all_enabled_flags()); diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index 38f078b876..bbd1a13cea 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -366,6 +366,7 @@ mod hooks; mod interaction; mod skills; mod slash_dispatch; +mod worktree_picker; use self::skills::collect_tool_mentions; use self::skills::find_app_mentions; use self::skills::find_skill_mentions_with_tool_mentions; @@ -582,6 +583,7 @@ pub(crate) struct ChatWidget { status_account_display: Option, runtime_model_provider_base_url: Option, pub(crate) remote_connection: Option, + pub(crate) local_worktree_operations: bool, token_info: Option, token_usage_pending: bool, // Status and polling use account usage reads; response streams may identify meters differently. diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rs index 945d85496a..8d4d956a29 100644 --- a/codex-rs/tui/src/chatwidget/constructor.rs +++ b/codex-rs/tui/src/chatwidget/constructor.rs @@ -135,6 +135,7 @@ impl ChatWidget { status_account_display, runtime_model_provider_base_url, remote_connection: None, + local_worktree_operations: true, token_info: None, token_usage_pending: false, rate_limit_snapshots_by_limit_id: BTreeMap::new(), @@ -287,6 +288,7 @@ impl ChatWidget { .set_collaboration_modes_enabled(/*enabled*/ true); widget.sync_service_tier_commands(); widget.sync_personality_command_enabled(); + widget.sync_worktrees_enabled(); widget.sync_plugins_command_enabled(); widget.sync_goal_command_enabled(); widget.sync_mentions_v2_enabled(); diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rs index 8ff0c58383..d62db38b6d 100644 --- a/codex-rs/tui/src/chatwidget/session_flow.rs +++ b/codex-rs/tui/src/chatwidget/session_flow.rs @@ -132,6 +132,7 @@ impl ChatWidget { } self.sync_service_tier_commands(); self.sync_personality_command_enabled(); + self.sync_worktrees_enabled(); self.sync_plugins_command_enabled(); self.sync_goal_command_enabled(); self.refresh_plugin_mentions(); diff --git a/codex-rs/tui/src/chatwidget/settings.rs b/codex-rs/tui/src/chatwidget/settings.rs index 374d30d9b1..8fbf653e46 100644 --- a/codex-rs/tui/src/chatwidget/settings.rs +++ b/codex-rs/tui/src/chatwidget/settings.rs @@ -80,6 +80,9 @@ impl ChatWidget { self.refresh_effective_service_tier(); self.sync_service_tier_commands(); } + if feature == Feature::Worktrees { + self.sync_worktrees_enabled(); + } if feature == Feature::Personality { self.sync_personality_command_enabled(); } @@ -296,6 +299,17 @@ impl ChatWidget { .unwrap_or_else(|| self.current_collaboration_mode.model()) } + pub(crate) fn set_local_worktree_operations(&mut self, enabled: bool) { + self.local_worktree_operations = enabled; + self.sync_worktrees_enabled(); + } + + pub(super) fn sync_worktrees_enabled(&mut self) { + self.bottom_pane.set_worktrees_enabled( + self.config.features.enabled(Feature::Worktrees) && self.local_worktree_operations, + ); + } + pub(super) fn sync_personality_command_enabled(&mut self) { self.bottom_pane .set_personality_command_enabled(self.config.features.enabled(Feature::Personality)); diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs index c7dec771fb..b8db07ee74 100644 --- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs +++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs @@ -6,6 +6,7 @@ //! slash-command recall follows the same submitted-input rule as ordinary text. use super::*; +use crate::app_event::ManagedWorktreeMode; use crate::app_event::ThreadGoalSetMode; use crate::bottom_pane::prompt_args::parse_slash_name; use crate::bottom_pane::slash_commands::BuiltinCommandFlags; @@ -181,7 +182,7 @@ impl ChatWidget { self.request_redraw(); } SlashCommand::New => { - self.app_event_tx.send(AppEvent::NewSession { name: None }); + self.show_session_checkout_picker(ManagedWorktreeMode::New, /*name*/ None); } SlashCommand::Archive => { self.bottom_pane.show_selection_view(SelectionViewParams { @@ -247,8 +248,10 @@ impl ChatWidget { self.app_event_tx.send(AppEvent::OpenResumePicker); } SlashCommand::Fork => { - self.app_event_tx - .send(AppEvent::ForkCurrentSession { name: None }); + self.show_session_checkout_picker(ManagedWorktreeMode::Fork, /*name*/ None); + } + SlashCommand::Worktree => { + self.show_managed_worktree_picker(); } SlashCommand::App => { let Some(thread_id) = self.thread_id else { @@ -800,9 +803,10 @@ impl ChatWidget { self.app_event_tx.set_thread_name(name); } SlashCommand::New if !trimmed.is_empty() => { - self.app_event_tx.send(AppEvent::NewSession { - name: Some(trimmed.to_string()), - }); + self.show_session_checkout_picker( + ManagedWorktreeMode::New, + Some(trimmed.to_string()), + ); } SlashCommand::Clear if !trimmed.is_empty() => { self.app_event_tx.send(AppEvent::ClearUi { @@ -810,9 +814,10 @@ impl ChatWidget { }); } SlashCommand::Fork if !trimmed.is_empty() => { - self.app_event_tx.send(AppEvent::ForkCurrentSession { - name: Some(trimmed.to_string()), - }); + self.show_session_checkout_picker( + ManagedWorktreeMode::Fork, + Some(trimmed.to_string()), + ); } SlashCommand::Plan if !trimmed.is_empty() => { let plan_available = self.apply_plan_slash_command(); @@ -1139,6 +1144,8 @@ impl ChatWidget { goal_command_enabled: self.config.features.enabled(Feature::Goals), service_tier_commands_enabled: self.fast_mode_enabled(), personality_command_enabled: self.config.features.enabled(Feature::Personality), + worktrees_enabled: self.config.features.enabled(Feature::Worktrees) + && self.local_worktree_operations, allow_elevate_sandbox, side_conversation_active: self.active_side_conversation, } @@ -1182,6 +1189,13 @@ impl ChatWidget { Some(thread_id) if self.can_change_working_directory(thread_id) => QueueDrain::Stop, _ => QueueDrain::Continue, }, + SlashCommand::Worktree => { + if self.managed_worktree_available() { + QueueDrain::Stop + } else { + QueueDrain::Continue + } + } SlashCommand::Feedback | SlashCommand::Export | SlashCommand::New diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap new file mode 100644 index 0000000000..50f75113a6 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap @@ -0,0 +1,8 @@ +--- +source: tui/src/chatwidget/tests/slash_commands.rs +assertion_line: 3091 +expression: popup +--- +› /work + + /worktree start or continue a conversation in a new worktree diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap new file mode 100644 index 0000000000..38b1765f69 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap @@ -0,0 +1,8 @@ +--- +source: tui/src/chatwidget/tests/slash_commands.rs +assertion_line: 3091 +expression: popup +--- +› /work + + gpt-5.6-sol default · /tmp/project diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap new file mode 100644 index 0000000000..a91fc16b17 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap @@ -0,0 +1,12 @@ +--- +source: tui/src/chatwidget/tests/slash_commands.rs +expression: popup +--- + Create a new worktree + +› 1. Continue current conversation Preserve this conversation in the new + checkout + 2. Start new conversation Open a fresh conversation in the new + checkout + + Press enter to confirm or esc to go back diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap new file mode 100644 index 0000000000..e8cdf06c77 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap @@ -0,0 +1,10 @@ +--- +source: tui/src/chatwidget/tests/slash_commands.rs +expression: popup +--- + Where should the forked conversation run? + +› 1. Current checkout Keep using the current working directory + 2. New worktree Create an isolated managed checkout + + Press enter to confirm or esc to go back diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap new file mode 100644 index 0000000000..db7c23de4d --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap @@ -0,0 +1,10 @@ +--- +source: tui/src/chatwidget/tests/slash_commands.rs +expression: popup +--- + Where should the new conversation run? + +› 1. Current checkout Keep using the current working directory + 2. New worktree Create an isolated managed checkout + + Press enter to confirm or esc to go back diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rs index 0435b3d554..6fe9ad42d0 100644 --- a/codex-rs/tui/src/chatwidget/tests.rs +++ b/codex-rs/tui/src/chatwidget/tests.rs @@ -273,6 +273,8 @@ mod status_command_tests; mod status_surface_previews; mod terminal_title; mod usage; +#[path = "tests/worktree_picker_tests.rs"] +mod worktree_picker; pub(crate) use helpers::make_chatwidget_manual_with_sender; pub(crate) use helpers::set_chatgpt_auth; diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs index 71dc31a3bb..e84f8fb136 100644 --- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs +++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs @@ -621,7 +621,7 @@ async fn queued_inline_rename_does_not_drain_again_before_turn_started() { #[tokio::test] async fn queued_unknown_slash_reports_error_when_dequeued() { - let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await; chat.thread_id = Some(ThreadId::new()); handle_turn_started(&mut chat, "turn-1"); @@ -642,6 +642,24 @@ async fn queued_unknown_slash_reports_error_when_dequeued() { "expected delayed slash error, got {rendered:?}" ); assert!(chat.input_queue.queued_user_messages.is_empty()); + + chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true); + chat.set_local_worktree_operations(/*enabled*/ false); + let drain = chat.submit_queued_slash_prompt(UserMessage::from("/worktree extra").into()); + assert_matches!(drain, QueueDrain::Continue); + assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty)); + assert!(drain_insert_history(&mut rx).iter().any(|lines| { + lines_to_single_string(lines).contains("Unrecognized command '/worktree'") + })); + + chat.set_local_worktree_operations(/*enabled*/ true); + let non_git = tempfile::tempdir().unwrap(); + chat.config.cwd = non_git.path().to_path_buf().abs(); + let drain = chat.submit_queued_slash_prompt(UserMessage::from("/worktree").into()); + assert_matches!(drain, QueueDrain::Continue); + assert!(drain_insert_history(&mut rx).iter().any(|lines| { + lines_to_single_string(lines).contains("Managed worktrees require a local Git repository.") + })); } #[tokio::test] diff --git a/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs b/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs new file mode 100644 index 0000000000..d6fc917381 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs @@ -0,0 +1,91 @@ +//! Worktree picker behavior and rendered choices. + +use super::*; +use pretty_assertions::assert_eq; + +#[tokio::test] +async fn slash_new_and_fork_offer_checkout_choices_inside_local_git_repository() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let checkout = tempdir().expect("temporary checkout"); + std::fs::create_dir(checkout.path().join(".git")).expect("git directory"); + std::fs::write(checkout.path().join(".git/HEAD"), "ref: refs/heads/main\n").expect("git HEAD"); + chat.config.cwd = + AbsolutePathBuf::from_absolute_path(checkout.path()).expect("absolute checkout"); + + chat.dispatch_command(SlashCommand::Fork); + assert_matches!( + rx.try_recv(), + Ok(AppEvent::ForkCurrentSession { name: None }) + ); + chat.dispatch_command(SlashCommand::New); + assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: None })); + + chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true); + chat.dispatch_command(SlashCommand::Fork); + + let popup = render_bottom_popup(&chat, /*width*/ 80); + assert_chatwidget_snapshot!("worktrees_fork_choices", popup); + chat.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)); + chat.dispatch_command(SlashCommand::New); + let popup = render_bottom_popup(&chat, /*width*/ 80); + assert_chatwidget_snapshot!("worktrees_new_choices", popup); + assert!(popup.contains("Current checkout"), "popup: {popup}"); + assert!(popup.contains("New worktree"), "popup: {popup}"); + assert_matches!(rx.try_recv(), Err(TryRecvError::Empty)); + chat.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)); + chat.bottom_pane + .set_composer_text("/new named".into(), Vec::new(), Vec::new()); + chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + chat.handle_key_event(KeyEvent::new(KeyCode::Char('1'), KeyModifiers::NONE)); + assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: Some(name) }) if name == "named"); + chat.bottom_pane + .set_composer_text("/fork named".into(), Vec::new(), Vec::new()); + chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + chat.handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE)); + assert_matches!(rx.try_recv(), Ok(AppEvent::StartManagedWorktree { + mode: crate::app_event::ManagedWorktreeMode::Fork, + name: Some(name), + }) if name == "named"); + chat.set_local_worktree_operations(/*enabled*/ false); + chat.dispatch_command(SlashCommand::New); + assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: None })); + chat.dispatch_command(SlashCommand::Fork); + assert_matches!( + rx.try_recv(), + Ok(AppEvent::ForkCurrentSession { name: None }) + ); + for (available, snapshot) in [ + (false, "worktrees_command_remote"), + (true, "worktrees_command_local"), + ] { + chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true); + chat.set_local_worktree_operations(available); + chat.bottom_pane + .set_composer_text("/work".into(), Vec::new(), Vec::new()); + let popup = normalize_snapshot_paths(render_bottom_popup(&chat, /*width*/ 80)); + assert_chatwidget_snapshot!(snapshot, popup); + assert_eq!(popup.contains("/worktree"), available); + } +} + +#[tokio::test] +async fn slash_worktree_offers_current_or_new_conversation() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let checkout = tempdir().expect("temporary checkout"); + std::fs::create_dir(checkout.path().join(".git")).expect("git directory"); + std::fs::write(checkout.path().join(".git/HEAD"), "ref: refs/heads/main\n").expect("git HEAD"); + chat.config.cwd = + AbsolutePathBuf::from_absolute_path(checkout.path()).expect("absolute checkout"); + + chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true); + chat.dispatch_command(SlashCommand::Worktree); + + let popup = render_bottom_popup(&chat, /*width*/ 80); + assert_chatwidget_snapshot!("worktrees_conversation_choices", popup); + assert!( + popup.contains("Continue current conversation"), + "popup: {popup}" + ); + assert!(popup.contains("Start new conversation"), "popup: {popup}"); + assert_matches!(rx.try_recv(), Err(TryRecvError::Empty)); +} diff --git a/codex-rs/tui/src/chatwidget/worktree_picker.rs b/codex-rs/tui/src/chatwidget/worktree_picker.rs new file mode 100644 index 0000000000..31359aa8eb --- /dev/null +++ b/codex-rs/tui/src/chatwidget/worktree_picker.rs @@ -0,0 +1,121 @@ +//! Worktree choices for local, feature-enabled session commands. + +use super::*; +use crate::app_event::ManagedWorktreeMode; + +impl ChatWidget { + pub(super) fn managed_worktree_available(&self) -> bool { + self.config.features.enabled(Feature::Worktrees) + && self.local_worktree_operations + && get_git_repo_root(self.config.cwd.as_path()).is_some() + } + + pub(super) fn show_session_checkout_picker( + &mut self, + mode: ManagedWorktreeMode, + name: Option, + ) { + if !self.managed_worktree_available() { + match mode { + ManagedWorktreeMode::New => { + self.app_event_tx.send(AppEvent::NewSession { name }); + } + ManagedWorktreeMode::Fork => { + self.app_event_tx + .send(AppEvent::ForkCurrentSession { name }); + } + } + return; + } + + let title = match mode { + ManagedWorktreeMode::New => "Where should the new conversation run?", + ManagedWorktreeMode::Fork => "Where should the forked conversation run?", + }; + let current_name = name.clone(); + self.bottom_pane.show_selection_view(SelectionViewParams { + title: Some(title.to_string()), + footer_hint: Some(standard_popup_hint_line()), + items: vec![ + SelectionItem { + name: "Current checkout".to_string(), + description: Some("Keep using the current working directory".to_string()), + actions: vec![Box::new(move |tx| match mode { + ManagedWorktreeMode::New => { + tx.send(AppEvent::NewSession { + name: current_name.clone(), + }); + } + ManagedWorktreeMode::Fork => { + tx.send(AppEvent::ForkCurrentSession { + name: current_name.clone(), + }); + } + })], + dismiss_on_select: true, + ..Default::default() + }, + SelectionItem { + name: "New worktree".to_string(), + description: Some("Create an isolated managed checkout".to_string()), + actions: vec![Box::new(move |tx| { + tx.send(AppEvent::StartManagedWorktree { + mode, + name: name.clone(), + }); + })], + dismiss_on_select: true, + ..Default::default() + }, + ], + ..Default::default() + }); + self.request_redraw(); + } + + pub(super) fn show_managed_worktree_picker(&mut self) { + if !self.config.features.enabled(Feature::Worktrees) { + self.add_error_message( + "Enable worktrees in /experimental to create a worktree.".to_string(), + ); + return; + } + if !self.managed_worktree_available() { + self.add_error_message("Managed worktrees require a local Git repository.".to_string()); + return; + } + + self.bottom_pane.show_selection_view(SelectionViewParams { + title: Some("Create a new worktree".to_string()), + footer_hint: Some(standard_popup_hint_line()), + items: vec![ + SelectionItem { + name: "Continue current conversation".to_string(), + description: Some("Preserve this conversation in the new checkout".to_string()), + actions: vec![Box::new(|tx| { + tx.send(AppEvent::StartManagedWorktree { + mode: ManagedWorktreeMode::Fork, + name: None, + }); + })], + dismiss_on_select: true, + ..Default::default() + }, + SelectionItem { + name: "Start new conversation".to_string(), + description: Some("Open a fresh conversation in the new checkout".to_string()), + actions: vec![Box::new(|tx| { + tx.send(AppEvent::StartManagedWorktree { + mode: ManagedWorktreeMode::New, + name: None, + }); + })], + dismiss_on_select: true, + ..Default::default() + }, + ], + ..Default::default() + }); + self.request_redraw(); + } +} diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rs index 97b4b9897b..ca83861bdb 100644 --- a/codex-rs/tui/src/slash_command.rs +++ b/codex-rs/tui/src/slash_command.rs @@ -35,6 +35,7 @@ pub enum SlashCommand { Delete, Resume, Fork, + Worktree, App, Init, Compact, @@ -99,6 +100,7 @@ impl SlashCommand { SlashCommand::Delete => "permanently delete this session and exit", SlashCommand::Clear => "clear the terminal and start a new chat", SlashCommand::Fork => "fork the current chat", + SlashCommand::Worktree => "start or continue a conversation in a new worktree", SlashCommand::App => "continue this session in the Desktop app", SlashCommand::Quit | SlashCommand::Exit => "exit Codex", SlashCommand::Copy => "copy the last response or part of it", @@ -210,6 +212,7 @@ impl SlashCommand { | SlashCommand::Archive | SlashCommand::Delete | SlashCommand::Fork + | SlashCommand::Worktree | SlashCommand::Init | SlashCommand::Compact | SlashCommand::Recap