mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## What changed - Remove feature-flag checks from managed worktree creation and repository-aware session discovery, while retaining local workspace and trust checks. - Make TUI voice availability follow platform support instead of `features.realtime_conversation`. - Ignore `features.worktrees` and `features.realtime_conversation` configuration overrides, warn when managed requirements reference them, and hide both flags from `/experimental`, including catalogs from older servers. ## Testing Add coverage for ignored configuration overrides and managed requirements, and update session filtering, worktree grouping, and experimental feature discovery tests for the retired flags. GitOrigin-RevId: 1d64e890e6e2f8a78926a9ea163126c0890b068e
391 lines
15 KiB
Rust
391 lines
15 KiB
Rust
//! Worktree choices for local session commands.
|
|
//!
|
|
//! Shared picker presentation preserves request identity and action safety checks.
|
|
|
|
use super::*;
|
|
use crate::app_event::ManagedWorktreeMode;
|
|
use crate::bottom_pane::PickerSurface;
|
|
use crate::worktree_browser::Action;
|
|
use crate::worktree_browser::Entry;
|
|
use crate::worktree_browser::Owner;
|
|
use crate::worktree_browser::Request;
|
|
|
|
const BROWSER_VIEW_ID: &str = "managed-worktrees";
|
|
|
|
impl ChatWidget {
|
|
pub(super) fn managed_worktree_available(&self) -> bool {
|
|
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<String>,
|
|
) {
|
|
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.into()),
|
|
items: vec![
|
|
SelectionItem {
|
|
name: "Use current Git worktree".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: "Create new Git worktree".to_string(),
|
|
description: Some(
|
|
"Create a separate checkout of this repository in another directory"
|
|
.to_string(),
|
|
),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::StartManagedWorktree {
|
|
mode,
|
|
name: name.clone(),
|
|
});
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
},
|
|
],
|
|
..SelectionViewParams::picker()
|
|
});
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(super) fn show_managed_worktree_picker(&mut self) {
|
|
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("Worktrees".into()),
|
|
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()
|
|
},
|
|
SelectionItem {
|
|
name: "Browse worktrees".to_string(),
|
|
description: Some(
|
|
"Resume an owner thread or copy a working directory".to_string(),
|
|
),
|
|
actions: vec![Box::new(|tx| tx.send(AppEvent::BrowseManagedWorktrees))],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
},
|
|
],
|
|
..SelectionViewParams::picker()
|
|
});
|
|
self.request_redraw();
|
|
}
|
|
|
|
pub(crate) fn request_managed_worktrees(&mut self) -> Option<Request> {
|
|
if !self.managed_worktree_available() {
|
|
return None;
|
|
}
|
|
let request = Request {
|
|
id: uuid::Uuid::new_v4(),
|
|
cwd: self.config.cwd.to_path_buf(),
|
|
thread_id: self.thread_id,
|
|
};
|
|
self.bottom_pane.dismiss_view_by_id(BROWSER_VIEW_ID);
|
|
self.worktree_popup_request_id = Some(request.id);
|
|
self.bottom_pane.show_selection_view(SelectionViewParams {
|
|
view_id: Some(BROWSER_VIEW_ID),
|
|
picker_surface: PickerSurface::Panel,
|
|
title: Some("Managed worktrees".into()),
|
|
items: vec![SelectionItem {
|
|
name: "Loading worktrees…".to_string(),
|
|
is_disabled: true,
|
|
..Default::default()
|
|
}],
|
|
..Default::default()
|
|
});
|
|
Some(request)
|
|
}
|
|
|
|
pub(crate) fn worktree_request_is_current(&self, request: &Request) -> bool {
|
|
self.worktree_popup_request_id == Some(request.id)
|
|
&& request.cwd == self.config.cwd.as_path()
|
|
&& request.thread_id == self.thread_id
|
|
&& self.managed_worktree_available()
|
|
}
|
|
|
|
pub(crate) fn on_managed_worktrees_loaded(
|
|
&mut self,
|
|
request: Request,
|
|
result: Result<Vec<Entry>, String>,
|
|
) {
|
|
if self.worktree_popup_request_id != Some(request.id) {
|
|
return;
|
|
}
|
|
if !self.worktree_request_is_current(&request)
|
|
|| !self.bottom_pane.dismiss_active_view_if_id(BROWSER_VIEW_ID)
|
|
{
|
|
self.worktree_popup_request_id = None;
|
|
self.bottom_pane.dismiss_view_by_id(BROWSER_VIEW_ID);
|
|
return;
|
|
}
|
|
let entries = match result {
|
|
Ok(entries) => entries,
|
|
Err(error) => {
|
|
self.worktree_popup_request_id = None;
|
|
self.add_error_message(format!("Cannot list managed worktrees: {error}"));
|
|
return;
|
|
}
|
|
};
|
|
self.bottom_pane.show_selection_view(SelectionViewParams {
|
|
title: Some("Managed worktrees".to_string()),
|
|
subtitle: Some(
|
|
if entries.is_empty() {
|
|
"No worktrees in this repository's configured pool"
|
|
} else {
|
|
"Select a worktree to resume, copy its path, or delete it"
|
|
}
|
|
.to_string(),
|
|
),
|
|
is_searchable: true,
|
|
items: entries
|
|
.into_iter()
|
|
.map(|entry| {
|
|
let request = request.clone();
|
|
let (name, description) = match &entry.owner {
|
|
Owner::None | Owner::Unavailable(_) => {
|
|
let status = if matches!(entry.owner, Owner::None) {
|
|
"No attached thread"
|
|
} else {
|
|
"Owner thread unavailable"
|
|
};
|
|
(
|
|
entry.cwd.display().to_string(),
|
|
format!("{status} · {}", entry.cwd.display()),
|
|
)
|
|
}
|
|
Owner::Archived(thread) | Owner::Resumable(thread) => {
|
|
let status = match &entry.owner {
|
|
Owner::Archived(_) => "Archived · ",
|
|
Owner::Resumable(_) => "",
|
|
Owner::None | Owner::Unavailable(_) => unreachable!(),
|
|
};
|
|
(
|
|
thread.title.clone(),
|
|
format!(
|
|
"{status}updated {} · {}",
|
|
worktree_updated_ago(
|
|
thread.updated_at,
|
|
chrono::Utc::now().timestamp()
|
|
),
|
|
entry.cwd.display()
|
|
),
|
|
)
|
|
}
|
|
};
|
|
SelectionItem {
|
|
name: name.clone(),
|
|
search_value: Some(format!("{name} {}", entry.cwd.display())),
|
|
description: Some(description),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::ShowManagedWorktreeActions {
|
|
request: request.clone(),
|
|
entry: entry.clone(),
|
|
})
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
}
|
|
})
|
|
.collect(),
|
|
..SelectionViewParams::picker()
|
|
});
|
|
}
|
|
|
|
pub(crate) fn managed_worktree_action(
|
|
&self,
|
|
request: &Request,
|
|
action: Action,
|
|
) -> Option<AppEvent> {
|
|
if !self.worktree_request_is_current(request) {
|
|
return None;
|
|
}
|
|
Some(match action {
|
|
Action::Resume(owner) => AppEvent::ResumeSessionByIdOrName(owner.to_string()),
|
|
Action::Copy(cwd) => AppEvent::CopySelection {
|
|
text: cwd.to_str()?.into(),
|
|
label: "Worktree working directory".to_string(),
|
|
format: crate::clipboard_copy::CopyFormat::PlainText,
|
|
},
|
|
Action::Remove(root) => AppEvent::RemoveManagedWorktree {
|
|
request: request.clone(),
|
|
root,
|
|
},
|
|
})
|
|
}
|
|
|
|
pub(crate) fn show_managed_worktree_actions(&mut self, request: Request, entry: Entry) {
|
|
if !self.worktree_request_is_current(&request) {
|
|
return;
|
|
}
|
|
let mut items = Vec::new();
|
|
if let Owner::Resumable(thread) = &entry.owner {
|
|
let owner = thread.id;
|
|
let request = request.clone();
|
|
items.push(SelectionItem {
|
|
name: "Resume owner thread".to_string(),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::ManagedWorktreeAction {
|
|
request: request.clone(),
|
|
action: Action::Resume(owner),
|
|
})
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
});
|
|
}
|
|
let cwd = entry.cwd.clone();
|
|
let copy_request = request.clone();
|
|
items.push(SelectionItem {
|
|
name: "Copy working directory".to_string(),
|
|
is_disabled: entry.cwd.to_str().is_none(),
|
|
disabled_reason: entry
|
|
.cwd
|
|
.to_str()
|
|
.is_none()
|
|
.then(|| "Path is not valid UTF-8".to_string()),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::ManagedWorktreeAction {
|
|
request: copy_request.clone(),
|
|
action: Action::Copy(cwd.clone()),
|
|
})
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
});
|
|
let can_delete = !request.cwd.starts_with(&entry.root);
|
|
let root = entry.root.clone();
|
|
let delete_request = request;
|
|
items.push(SelectionItem {
|
|
name: "Delete worktree".to_string(),
|
|
is_disabled: !can_delete,
|
|
disabled_reason: (!can_delete)
|
|
.then(|| "Switch to another checkout before deleting this one".to_string()),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::ConfirmManagedWorktreeRemoval {
|
|
request: delete_request.clone(),
|
|
root: root.clone(),
|
|
})
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
});
|
|
let title = match &entry.owner {
|
|
Owner::Archived(thread) | Owner::Resumable(thread) => {
|
|
format!("Worktree: {}", thread.title)
|
|
}
|
|
Owner::None | Owner::Unavailable(_) => "Worktree".to_string(),
|
|
};
|
|
self.bottom_pane.show_selection_view(SelectionViewParams {
|
|
title: Some(title),
|
|
subtitle: Some(entry.cwd.display().to_string()),
|
|
items,
|
|
..SelectionViewParams::picker()
|
|
});
|
|
}
|
|
|
|
pub(crate) fn confirm_managed_worktree_removal(&mut self, request: Request, root: PathBuf) {
|
|
if !self.worktree_request_is_current(&request) || request.cwd.starts_with(&root) {
|
|
return;
|
|
}
|
|
self.bottom_pane.show_selection_view(SelectionViewParams {
|
|
title: Some("Delete this worktree?".to_string()),
|
|
subtitle: Some(root.display().to_string()),
|
|
items: vec![
|
|
SelectionItem {
|
|
name: "Cancel".to_string(),
|
|
actions: vec![],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
},
|
|
SelectionItem {
|
|
name: "Delete worktree".to_string(),
|
|
description: Some(
|
|
"Keeps thread history; may disrupt other sessions".to_string(),
|
|
),
|
|
actions: vec![Box::new(move |tx| {
|
|
tx.send(AppEvent::ManagedWorktreeAction {
|
|
request: request.clone(),
|
|
action: Action::Remove(root.clone()),
|
|
})
|
|
})],
|
|
dismiss_on_select: true,
|
|
..Default::default()
|
|
},
|
|
],
|
|
..SelectionViewParams::confirmation()
|
|
});
|
|
}
|
|
}
|
|
|
|
fn worktree_updated_ago(updated_at: i64, now: i64) -> String {
|
|
let seconds = now.saturating_sub(updated_at).max(0);
|
|
if seconds < 60 {
|
|
"just now".to_string()
|
|
} else if seconds < 3_600 {
|
|
format!("{}m ago", seconds / 60)
|
|
} else if seconds < 86_400 {
|
|
format!("{}h ago", seconds / 3_600)
|
|
} else {
|
|
format!("{}d ago", seconds / 86_400)
|
|
}
|
|
}
|