mirror of
https://github.com/openai/codex.git
synced 2026-04-24 22:54:54 +00:00
0d12380c3b
this is in preparation for adding more separate "modes" to the tui, in particular, a "transcript mode" to view a full history once #2316 lands. 1. split apart "tui events" from "app events". 2. remove onboarding-related events from AppEvent. 3. move several general drawing tools out of App and into a new Tui class
336 lines
13 KiB
Rust
336 lines
13 KiB
Rust
use crate::app_event::AppEvent;
|
||
use crate::app_event_sender::AppEventSender;
|
||
use crate::chatwidget::ChatWidget;
|
||
use crate::file_search::FileSearchManager;
|
||
use crate::get_git_diff::get_git_diff;
|
||
use crate::slash_command::SlashCommand;
|
||
use crate::tui;
|
||
use crate::tui::TuiEvent;
|
||
use codex_core::ConversationManager;
|
||
use codex_core::config::Config;
|
||
use codex_core::protocol::Event;
|
||
use codex_core::protocol::Op;
|
||
use codex_core::protocol::TokenUsage;
|
||
use color_eyre::eyre::Result;
|
||
use crossterm::event::KeyCode;
|
||
use crossterm::event::KeyEvent;
|
||
use crossterm::event::KeyEventKind;
|
||
use crossterm::terminal::supports_keyboard_enhancement;
|
||
use std::path::PathBuf;
|
||
use std::sync::Arc;
|
||
use std::sync::atomic::AtomicBool;
|
||
use std::sync::atomic::Ordering;
|
||
use std::thread;
|
||
use std::time::Duration;
|
||
use tokio::select;
|
||
use tokio::sync::mpsc::unbounded_channel;
|
||
|
||
pub(crate) struct App {
|
||
server: Arc<ConversationManager>,
|
||
app_event_tx: AppEventSender,
|
||
chat_widget: ChatWidget,
|
||
|
||
/// Config is stored here so we can recreate ChatWidgets as needed.
|
||
config: Config,
|
||
|
||
file_search: FileSearchManager,
|
||
|
||
enhanced_keys_supported: bool,
|
||
|
||
/// Controls the animation thread that sends CommitTick events.
|
||
commit_anim_running: Arc<AtomicBool>,
|
||
}
|
||
|
||
impl App {
|
||
pub async fn run(
|
||
tui: &mut tui::Tui,
|
||
config: Config,
|
||
initial_prompt: Option<String>,
|
||
initial_images: Vec<PathBuf>,
|
||
) -> Result<TokenUsage> {
|
||
use tokio_stream::StreamExt;
|
||
let (app_event_tx, mut app_event_rx) = unbounded_channel();
|
||
let app_event_tx = AppEventSender::new(app_event_tx);
|
||
|
||
let conversation_manager = Arc::new(ConversationManager::default());
|
||
|
||
let enhanced_keys_supported = supports_keyboard_enhancement().unwrap_or(false);
|
||
|
||
let chat_widget = ChatWidget::new(
|
||
config.clone(),
|
||
conversation_manager.clone(),
|
||
tui.frame_requester(),
|
||
app_event_tx.clone(),
|
||
initial_prompt,
|
||
initial_images,
|
||
enhanced_keys_supported,
|
||
);
|
||
|
||
let file_search = FileSearchManager::new(config.cwd.clone(), app_event_tx.clone());
|
||
|
||
let mut app = Self {
|
||
server: conversation_manager,
|
||
app_event_tx,
|
||
chat_widget,
|
||
config,
|
||
file_search,
|
||
enhanced_keys_supported,
|
||
commit_anim_running: Arc::new(AtomicBool::new(false)),
|
||
};
|
||
|
||
let tui_events = tui.event_stream();
|
||
tokio::pin!(tui_events);
|
||
|
||
tui.frame_requester().schedule_frame();
|
||
|
||
while select! {
|
||
Some(event) = app_event_rx.recv() => {
|
||
app.handle_event(tui, event)?
|
||
}
|
||
Some(event) = tui_events.next() => {
|
||
app.handle_tui_event(tui, event).await?
|
||
}
|
||
} {}
|
||
tui.terminal.clear()?;
|
||
Ok(app.token_usage())
|
||
}
|
||
|
||
pub(crate) async fn handle_tui_event(
|
||
&mut self,
|
||
tui: &mut tui::Tui,
|
||
event: TuiEvent,
|
||
) -> Result<bool> {
|
||
match event {
|
||
TuiEvent::Key(key_event) => {
|
||
self.handle_key_event(key_event).await;
|
||
}
|
||
TuiEvent::Paste(pasted) => {
|
||
// Many terminals convert newlines to \r when pasting (e.g., iTerm2),
|
||
// but tui-textarea expects \n. Normalize CR to LF.
|
||
// [tui-textarea]: https://github.com/rhysd/tui-textarea/blob/4d18622eeac13b309e0ff6a55a46ac6706da68cf/src/textarea.rs#L782-L783
|
||
// [iTerm2]: https://github.com/gnachman/iTerm2/blob/5d0c0d9f68523cbd0494dad5422998964a2ecd8d/sources/iTermPasteHelper.m#L206-L216
|
||
let pasted = pasted.replace("\r", "\n");
|
||
self.chat_widget.handle_paste(pasted);
|
||
}
|
||
TuiEvent::Draw => {
|
||
tui.draw(
|
||
self.chat_widget.desired_height(tui.terminal.size()?.width),
|
||
|frame| {
|
||
frame.render_widget_ref(&self.chat_widget, frame.area());
|
||
if let Some((x, y)) = self.chat_widget.cursor_pos(frame.area()) {
|
||
frame.set_cursor_position((x, y));
|
||
}
|
||
},
|
||
)?;
|
||
}
|
||
#[cfg(unix)]
|
||
TuiEvent::ResumeFromSuspend => {
|
||
let cursor_pos = tui.terminal.get_cursor_position()?;
|
||
tui.terminal
|
||
.set_viewport_area(ratatui::layout::Rect::new(0, cursor_pos.y, 0, 0));
|
||
}
|
||
}
|
||
Ok(true)
|
||
}
|
||
|
||
fn handle_event(&mut self, tui: &mut tui::Tui, event: AppEvent) -> Result<bool> {
|
||
match event {
|
||
AppEvent::InsertHistory(lines) => {
|
||
tui.insert_history_lines(lines);
|
||
}
|
||
AppEvent::StartCommitAnimation => {
|
||
if self
|
||
.commit_anim_running
|
||
.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
|
||
.is_ok()
|
||
{
|
||
let tx = self.app_event_tx.clone();
|
||
let running = self.commit_anim_running.clone();
|
||
thread::spawn(move || {
|
||
while running.load(Ordering::Relaxed) {
|
||
thread::sleep(Duration::from_millis(50));
|
||
tx.send(AppEvent::CommitTick);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
AppEvent::StopCommitAnimation => {
|
||
self.commit_anim_running.store(false, Ordering::Release);
|
||
}
|
||
AppEvent::CommitTick => {
|
||
self.chat_widget.on_commit_tick();
|
||
}
|
||
AppEvent::CodexEvent(event) => {
|
||
self.chat_widget.handle_codex_event(event);
|
||
}
|
||
AppEvent::ExitRequest => {
|
||
return Ok(false);
|
||
}
|
||
AppEvent::CodexOp(op) => self.chat_widget.submit_op(op),
|
||
AppEvent::DiffResult(text) => {
|
||
self.chat_widget.add_diff_output(text);
|
||
}
|
||
AppEvent::DispatchCommand(command) => match command {
|
||
SlashCommand::New => {
|
||
// User accepted – switch to chat view.
|
||
let new_widget = ChatWidget::new(
|
||
self.config.clone(),
|
||
self.server.clone(),
|
||
tui.frame_requester(),
|
||
self.app_event_tx.clone(),
|
||
None,
|
||
Vec::new(),
|
||
self.enhanced_keys_supported,
|
||
);
|
||
self.chat_widget = new_widget;
|
||
tui.frame_requester().schedule_frame();
|
||
}
|
||
SlashCommand::Init => {
|
||
// Guard: do not run if a task is active.
|
||
const INIT_PROMPT: &str = include_str!("../prompt_for_init_command.md");
|
||
self.chat_widget
|
||
.submit_text_message(INIT_PROMPT.to_string());
|
||
}
|
||
SlashCommand::Compact => {
|
||
self.chat_widget.clear_token_usage();
|
||
self.app_event_tx.send(AppEvent::CodexOp(Op::Compact));
|
||
}
|
||
SlashCommand::Model => {
|
||
self.chat_widget.open_model_popup();
|
||
}
|
||
SlashCommand::Approvals => {
|
||
self.chat_widget.open_approvals_popup();
|
||
}
|
||
SlashCommand::Quit => {
|
||
return Ok(false);
|
||
}
|
||
SlashCommand::Logout => {
|
||
if let Err(e) = codex_login::logout(&self.config.codex_home) {
|
||
tracing::error!("failed to logout: {e}");
|
||
}
|
||
return Ok(false);
|
||
}
|
||
SlashCommand::Diff => {
|
||
self.chat_widget.add_diff_in_progress();
|
||
let tx = self.app_event_tx.clone();
|
||
tokio::spawn(async move {
|
||
let text = match get_git_diff().await {
|
||
Ok((is_git_repo, diff_text)) => {
|
||
if is_git_repo {
|
||
diff_text
|
||
} else {
|
||
"`/diff` — _not inside a git repository_".to_string()
|
||
}
|
||
}
|
||
Err(e) => format!("Failed to compute diff: {e}"),
|
||
};
|
||
tx.send(AppEvent::DiffResult(text));
|
||
});
|
||
}
|
||
SlashCommand::Mention => {
|
||
self.chat_widget.insert_str("@");
|
||
}
|
||
SlashCommand::Status => {
|
||
self.chat_widget.add_status_output();
|
||
}
|
||
SlashCommand::Mcp => {
|
||
self.chat_widget.add_mcp_output();
|
||
}
|
||
#[cfg(debug_assertions)]
|
||
SlashCommand::TestApproval => {
|
||
use codex_core::protocol::EventMsg;
|
||
use std::collections::HashMap;
|
||
|
||
use codex_core::protocol::ApplyPatchApprovalRequestEvent;
|
||
use codex_core::protocol::FileChange;
|
||
|
||
self.app_event_tx.send(AppEvent::CodexEvent(Event {
|
||
id: "1".to_string(),
|
||
// msg: EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
|
||
// call_id: "1".to_string(),
|
||
// command: vec!["git".into(), "apply".into()],
|
||
// cwd: self.config.cwd.clone(),
|
||
// reason: Some("test".to_string()),
|
||
// }),
|
||
msg: EventMsg::ApplyPatchApprovalRequest(ApplyPatchApprovalRequestEvent {
|
||
call_id: "1".to_string(),
|
||
changes: HashMap::from([
|
||
(
|
||
PathBuf::from("/tmp/test.txt"),
|
||
FileChange::Add {
|
||
content: "test".to_string(),
|
||
},
|
||
),
|
||
(
|
||
PathBuf::from("/tmp/test2.txt"),
|
||
FileChange::Update {
|
||
unified_diff: "+test\n-test2".to_string(),
|
||
move_path: None,
|
||
},
|
||
),
|
||
]),
|
||
reason: None,
|
||
grant_root: Some(PathBuf::from("/tmp")),
|
||
}),
|
||
}));
|
||
}
|
||
},
|
||
AppEvent::StartFileSearch(query) => {
|
||
if !query.is_empty() {
|
||
self.file_search.on_user_query(query);
|
||
}
|
||
}
|
||
AppEvent::FileSearchResult { query, matches } => {
|
||
self.chat_widget.apply_file_search_result(query, matches);
|
||
}
|
||
AppEvent::UpdateReasoningEffort(effort) => {
|
||
self.chat_widget.set_reasoning_effort(effort);
|
||
}
|
||
AppEvent::UpdateModel(model) => {
|
||
self.chat_widget.set_model(model);
|
||
}
|
||
AppEvent::UpdateAskForApprovalPolicy(policy) => {
|
||
self.chat_widget.set_approval_policy(policy);
|
||
}
|
||
AppEvent::UpdateSandboxPolicy(policy) => {
|
||
self.chat_widget.set_sandbox_policy(policy);
|
||
}
|
||
}
|
||
Ok(true)
|
||
}
|
||
|
||
pub(crate) fn token_usage(&self) -> codex_core::protocol::TokenUsage {
|
||
self.chat_widget.token_usage().clone()
|
||
}
|
||
|
||
async fn handle_key_event(&mut self, key_event: KeyEvent) {
|
||
match key_event {
|
||
KeyEvent {
|
||
code: KeyCode::Char('c'),
|
||
modifiers: crossterm::event::KeyModifiers::CONTROL,
|
||
kind: KeyEventKind::Press,
|
||
..
|
||
} => {
|
||
self.chat_widget.on_ctrl_c();
|
||
}
|
||
KeyEvent {
|
||
code: KeyCode::Char('d'),
|
||
modifiers: crossterm::event::KeyModifiers::CONTROL,
|
||
kind: KeyEventKind::Press,
|
||
..
|
||
} if self.chat_widget.composer_is_empty() => {
|
||
self.app_event_tx.send(AppEvent::ExitRequest);
|
||
}
|
||
KeyEvent {
|
||
kind: KeyEventKind::Press | KeyEventKind::Repeat,
|
||
..
|
||
} => {
|
||
self.chat_widget.handle_key_event(key_event);
|
||
}
|
||
_ => {
|
||
// Ignore Release key events.
|
||
}
|
||
};
|
||
}
|
||
}
|