use anyhow::Result;
use crossterm::event::{
Event, EventStream, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent,
MouseEventKind,
};
use futures_util::StreamExt;
use ratatui::DefaultTerminal;
use ratatui::layout::{Position, Rect};
use tui_textarea::CursorMove;
use crate::app_view::AppView;
use crate::ui;
use dugix_core::app::{AppCommand, AppEvent, ModelPanel, MouseTarget, Popup, WorkMode};
fn edit_file_target(app: &AppView, key: &KeyEvent) -> Option<std::path::PathBuf> {
if !(app.popup == Popup::Space
&& app.space_mode == dugix_core::app::SpaceMode::Browse
&& key.modifiers.contains(KeyModifiers::CONTROL)
&& key.code == KeyCode::Char('e'))
{
return None;
}
app.space_instructions_target()
}
fn memory_edit_target(app: &AppView, key: &KeyEvent) -> Option<String> {
(app.popup == Popup::Space
&& app.space_mode == dugix_core::app::SpaceMode::Browse
&& key.modifiers.contains(KeyModifiers::CONTROL)
&& key.code == KeyCode::Char('k'))
.then(|| app.selected_space_name())
.flatten()
}
fn edit_memory(app: &mut AppView, terminal: &mut DefaultTerminal, space: &str) {
match app.core.memory_edit_file(space) {
Ok(path) => edit_memory_file(app, terminal, space, &path),
Err(error) => app.push_status(format!("memory: {error:#}")),
}
}
fn edit_memory_file(
app: &mut AppView,
terminal: &mut DefaultTerminal,
space: &str,
path: &std::path::Path,
) {
match edit_in_external_editor(terminal, path) {
Ok(()) => {
if let Err(error) = app.core.finish_memory_edit(space, path) {
app.push_status(format!("memory not saved: {error:#}"));
}
}
Err(error) => app.push_status(format!("editor failed: {error}")),
}
}
fn skill_edit_target(app: &AppView, key: &KeyEvent) -> Option<std::path::PathBuf> {
if !(app.popup == Popup::Skills
&& app.skills_mode == dugix_core::app::SkillsMode::Browse
&& key.modifiers.contains(KeyModifiers::CONTROL)
&& key.code == KeyCode::Char('e'))
{
return None;
}
app.skill_edit_path_for_selected()
}
fn system_prompt_edit_target(app: &AppView, key: &KeyEvent) -> Option<std::path::PathBuf> {
if !(app.popup == Popup::Settings
&& key.modifiers.contains(KeyModifiers::CONTROL)
&& key.code == KeyCode::Char('e'))
{
return None;
}
dugix_core::config::system_prompt_path().ok()
}
pub fn run(
mut app: AppView,
terminal: &mut DefaultTerminal,
selection_requests: Option<tokio::sync::mpsc::UnboundedReceiver<String>>,
) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<()>> + '_>> {
Box::pin(async move {
let result = Box::pin(run_loop(&mut app, terminal, selection_requests)).await;
app.cancel_chat_tasks();
app.procs.shutdown().await;
app.stop_local_servers().await;
result
})
}
async fn next_selection_request(
receiver: &mut Option<tokio::sync::mpsc::UnboundedReceiver<String>>,
) -> Option<String> {
match receiver {
Some(receiver) => receiver.recv().await,
None => std::future::pending().await,
}
}
async fn next_shell_completion(
receiver: &mut Option<tokio::sync::oneshot::Receiver<crate::composer::ShellCompletionResult>>,
) -> Option<crate::composer::ShellCompletionResult> {
match receiver {
Some(receiver) => receiver.await.ok(),
None => std::future::pending().await,
}
}
async fn next_reply<T>(receiver: &mut Option<tokio::sync::oneshot::Receiver<T>>) -> Option<T> {
match receiver {
Some(receiver) => receiver.await.ok(),
None => std::future::pending().await,
}
}
#[allow(clippy::too_many_lines)]
async fn run_loop(
app: &mut AppView,
terminal: &mut DefaultTerminal,
mut selection_requests: Option<tokio::sync::mpsc::UnboundedReceiver<String>>,
) -> Result<()> {
let mut reader = EventStream::new();
let mut theme_poll = tokio::time::interval(std::time::Duration::from_secs(2));
let mut jobs_poll = tokio::time::interval(std::time::Duration::from_secs(60));
loop {
crate::interactive::flush_settled(app);
app.sync_approval_popup();
take_proposed_command(app);
while let Some(ev) = app.pop_pending_event() {
app.apply_event(&ev);
}
terminal.draw(|f| ui::render(f, app))?;
if app.should_quit {
crate::interactive::flush(app);
break;
}
let streaming = app.is_streaming() || app.background_running() > 0;
let long_deadline = app.sel.deadline();
let welcome = app.is_welcome();
let status_deadline = app.status_deadline();
let panel_data = app.interactive.data_pending();
let animating = app.interactive.animating();
let images = std::sync::Arc::clone(&app.remote_images);
let studio_wake = app.studio_wake();
let studio_retry = app.studio.has_queued();
let fleet_live = app.popup == Popup::Fleet && app.fleet.live() > 0;
tokio::select! {
() = images.changed() => {}
() = studio_wake.notified() => app.poll_studio(),
() = async {
if studio_retry {
tokio::time::sleep(std::time::Duration::from_millis(400)).await;
} else {
std::future::pending::<()>().await;
}
} => app.poll_studio(),
maybe = reader.next() => match maybe {
Some(Ok(Event::Key(k))) if k.kind == KeyEventKind::Press
|| (k.kind == KeyEventKind::Repeat && app.popup == Popup::InteractiveUi
&& app.interactive.input_focused())
|| (k.kind == KeyEventKind::Repeat && ui::popups::fleet::captures(app)) => {
if let Err(e) = on_key(app, terminal, k) {
app.push_status(format!("error: {e:#}"));
}
}
Some(Ok(Event::FocusGained)) => app.interactive.window_focus(true),
Some(Ok(Event::FocusLost)) => app.interactive.window_focus(false),
Some(Ok(Event::Mouse(m))) => {
let size = terminal.size()?;
if let Err(e) = handle_mouse(app, m, Rect::new(0, 0, size.width, size.height)) {
app.push_status(format!("error: {e:#}"));
}
}
Some(Ok(Event::Paste(text))) => {
if !ui::popups::fleet::paste(app, &text) {
app.paste(&text);
}
}
Some(Ok(_)) => {}
Some(Err(e)) => return Err(e.into()),
None => break,
},
request = next_selection_request(&mut selection_requests) => {
if let Some(prompt) = request {
if let Err(e) = app.execute(dugix_core::app::AppCommand::Send { text: prompt }) {
app.push_status(format!("error: {e:#}"));
}
} else {
selection_requests = None;
}
}
completion = next_shell_completion(&mut app.shell_completion_rx) => {
if let Some(completion) = completion {
app.finish_shell_completion(completion);
} else {
app.shell_completion_rx = None;
}
}
results = next_reply(&mut app.picker_rx) => {
match results {
Some(results) => app.finish_picker_search(results),
None => app.picker_rx = None,
}
}
completion = app.diagrams.next_completion() => {
if let Some(completion) = completion {
app.diagrams.complete(completion);
}
}
completion = app.image_viewer.next_completion() => {
if let Some(completion) = completion {
app.apply_image_completion(completion);
}
}
event = app.core.next_event() => {
app.apply_event(&event);
match event {
AppEvent::Status(_)
| AppEvent::Gate(_)
| AppEvent::Stream(None)
| AppEvent::ComposerSet(_)
| AppEvent::ComposerClear
| AppEvent::ViewportReset
| AppEvent::HistoryInvalidated
| AppEvent::OpenLoginPopup => {}
AppEvent::Stream(Some((task_id, e))) => {
if let Err(e) = app.on_chat_event(task_id, e) {
app.push_status(format!("error: {e:#}"));
}
}
AppEvent::Models(r) => {
app.on_models_result(r);
if !app.core.models.is_empty()
&& app.core.current_model.is_none()
&& app.popup == Popup::None
{
app.open_model_picker();
}
}
AppEvent::Title(t) => app.on_title_result(t),
AppEvent::Compact(c) => app.on_compact_result(c),
AppEvent::SkillInstall(r) => app.on_skill_install_result(r),
AppEvent::Convert(r) => app.on_convert_done(r),
AppEvent::Embed(r) => app.on_embed_done(r),
AppEvent::LocalServers(r) => app.on_local_status(r),
AppEvent::Research(r) => {
app.on_research_done(r);
if app.core.research.rx.is_none() {
app.core.research.live_input.clear();
if app.popup == Popup::ResearchLive {
app.popup = Popup::None;
}
}
}
AppEvent::ResearchTopic(r) => app.on_research_topic_derived(r),
AppEvent::Login(r) => app.on_login_result(r),
AppEvent::UpdateCheck(r) => app.on_update_check(r),
AppEvent::Swarm(r) => app.on_swarm_update(r),
}
}
() = async {
if streaming {
tokio::time::sleep(std::time::Duration::from_millis(120)).await;
} else {
std::future::pending::<()>().await;
}
} => app.tick_spinner(),
() = async {
match long_deadline {
Some(d) => tokio::time::sleep(d.saturating_duration_since(std::time::Instant::now())).await,
None => std::future::pending::<()>().await,
}
} => {
match app.sel.check_long_press() {
Some(crate::selection::LongPress::Code(text)) => app.copy_text(&text),
Some(crate::selection::LongPress::Message(idx)) => app.copy_message(idx),
Some(crate::selection::LongPress::Url(url)) => app.copy_text(&url),
None => {}
}
}
() = async {
match status_deadline {
Some(d) => tokio::time::sleep_until(d.into()).await,
None => std::future::pending::<()>().await,
}
} => app.expire_status(),
() = async {
if welcome {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
} else {
std::future::pending::<()>().await;
}
} => {}
() = async {
if panel_data {
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
} else {
std::future::pending::<()>().await;
}
} => crate::interactive::live::tick(app),
() = async {
if fleet_live {
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
} else {
std::future::pending::<()>().await;
}
} => {}
() = async {
if animating {
tokio::time::sleep(std::time::Duration::from_millis(66)).await;
} else {
std::future::pending::<()>().await;
}
} => {}
_ = jobs_poll.tick() => {
if let Err(error) = app.collect_job_notifications() {
app.push_status(format!("jobs notifications: {error}"));
}
}
_ = theme_poll.tick() => {
let target = crate::theme::source_stamp();
if target != app.theme_link {
let mode = app.background_mode;
app.theme = crate::theme::load();
app.theme.set_background_mode(mode);
app.theme_link = target;
app.theme_gen = app.theme_gen.wrapping_add(1);
app.send_studio_theme();
}
}
}
}
Ok(())
}
fn on_key(app: &mut AppView, terminal: &mut DefaultTerminal, k: KeyEvent) -> Result<()> {
if let Some(path) = edit_file_target(app, &k) {
edit_in_external_editor(terminal, &path)?;
} else if let Some(space) = memory_edit_target(app, &k) {
edit_memory(app, terminal, &space);
} else if let Some(path) = skill_edit_target(app, &k) {
edit_in_external_editor(terminal, &path)?;
app.reload_skills();
} else if let Some(path) = system_prompt_edit_target(app, &k) {
edit_in_external_editor(terminal, &path)?;
app.reload_base_system_prompt();
} else if app.popup == Popup::Context && k.code == KeyCode::Char('v') {
match app.compact_summary_path() {
Some(path) => {
edit_in_external_editor(terminal, &path)?;
app.reload_compact_summary(&path)?;
}
None => app.push_status("session hasn't been compacted yet".to_string()),
}
} else {
handle_key(app, k)?;
if let Some(edit) = app.pending_editor.take() {
match edit {
dugix_core::app::PendingEditor::AppFile(path) => {
if let Err(e) = edit_in_external_editor(terminal, &path) {
app.push_status(format!("editor failed: {e}"));
}
}
dugix_core::app::PendingEditor::Persona(path) => {
match edit_in_external_editor(terminal, &path) {
Ok(()) => app.apply_swarm_persona_editor(&path)?,
Err(e) => app.push_status(format!("editor failed: {e}")),
}
}
dugix_core::app::PendingEditor::ScriptFile(path) => {
if let Err(e) = edit_in_external_editor(terminal, &path) {
app.push_status(format!("editor failed: {e}"));
}
app.refresh_scripts();
}
dugix_core::app::PendingEditor::Memory { space, path } => {
edit_memory_file(app, terminal, &space, &path);
}
dugix_core::app::PendingEditor::UserCommand(cmd) => {
let cwd = app.user_command_cwd();
let shell = std::sync::Arc::clone(&app.user_command.shell);
let data = app.space.root.clone();
let (exit, started, next_dir) =
run_interactive_command(terminal, &cmd, &cwd, shell.get(), &data)?;
if let Some(dir) = next_dir {
app.core.user_command.dir = Some(dir);
}
app.execute(AppCommand::RecordUserCommand { cmd, exit, started })?;
}
}
}
}
Ok(())
}
fn handle_key(app: &mut AppView, key: KeyEvent) -> Result<()> {
if ui::popups::fleet::captures(app) {
return ui::popups::fleet::handle_key(app, key);
}
if key.modifiers.contains(KeyModifiers::CONTROL)
&& !key.modifiers.contains(KeyModifiers::SHIFT)
&& key.code == KeyCode::Char('c')
{
if app.popup == Popup::InteractiveUi && crate::interactive::copy_selection(app, false) {
return Ok(());
}
return ctrl_c(app);
}
app.quit_armed_at = None;
if key.modifiers.contains(KeyModifiers::CONTROL) && key.code == KeyCode::Char('v') {
app.paste_from_clipboard();
return Ok(());
}
match app.popup {
Popup::Model => ui::popups::model::handle_key(app, key)?,
Popup::Session => crate::ui::popups::session::handle_key(app, key)?,
Popup::Key => crate::ui::popups::key::handle_key(app, key),
Popup::Settings => ui::popups::settings::handle_key(app, key)?,
Popup::Copy => crate::ui::popups::copy::handle_key(app, key),
Popup::Approval => ui::popups::approval::handle_key(app, key)?,
Popup::Space => crate::ui::popups::space::handle_key(app, key)?,
Popup::Context => crate::ui::popups::context::handle_key(app, key),
Popup::Skills => crate::ui::popups::skills::handle_key(app, key),
Popup::Files => ui::popups::files::handle_key(app, key)?,
Popup::Apps => ui::popups::apps::handle_key(app, key)?,
Popup::Library => ui::popups::library::handle_key(app, key),
Popup::Subagents => ui::popups::subagents::handle_key(app, key),
Popup::InteractiveUi => crate::interactive::key(app, key),
Popup::ResearchLive => {
ui::popups::research_live::handle_key(app, key);
}
Popup::Swarm => ui::popups::swarm::handle_key(app, key)?,
Popup::Usage => {
ui::popups::usage::handle_key(app, key);
}
Popup::Login => {
ui::popups::login::handle_key(app, key);
}
Popup::Local => {
ui::popups::local::handle_key(app, key);
}
Popup::Jobs => ui::popups::jobs::handle_key(app, key)?,
Popup::Harness => ui::popups::harness::handle_key(app, key)?,
Popup::Procs => ui::popups::procs::handle_key(app, key)?,
Popup::Fleet => ui::popups::fleet::handle_key(app, key)?,
Popup::Help => ui::popups::help::handle_key(app, key),
Popup::ImageViewer => ui::popups::image_viewer::handle_key(app, key),
Popup::Connectors => ui::popups::connectors::handle_key(app, key),
Popup::None => handle_normal(app, key)?,
}
Ok(())
}
const QUIT_CONFIRM_WINDOW: std::time::Duration = std::time::Duration::from_millis(1500);
fn ctrl_c(app: &mut AppView) -> Result<()> {
if app.popup == Popup::ImageViewer {
app.viewer_action(crate::image_viewer_actions::Action::CopyImage);
return Ok(());
}
if app.popup == Popup::Approval {
return app.execute(AppCommand::Approve {
decision: dugix_core::tools::Decision::Deny,
});
}
if app.popup != Popup::None {
if app.popup == Popup::InteractiveUi {
app.interactive.unfocus();
}
app.popup = Popup::None;
} else if app.viewing_stream() {
app.stop_stream()?;
} else if !app.input_text().is_empty() {
app.set_input("");
} else if app
.quit_armed_at
.is_some_and(|at| at.elapsed() < QUIT_CONFIRM_WINDOW)
{
app.should_quit = true;
return Ok(());
} else {
app.quit_armed_at = Some(std::time::Instant::now());
app.push_status("press Ctrl+C again to quit");
return Ok(());
}
app.quit_armed_at = None;
Ok(())
}
fn take_proposed_command(app: &mut AppView) {
let Some(cmd) = app.core.approvals.proposed_command.take() else {
return;
};
if app.input_text().is_empty() {
app.set_input(&cmd);
} else {
app.push_status(format!("proposed: {cmd}"));
}
}
fn with_terminal_suspended<T>(
terminal: &mut DefaultTerminal,
child: impl FnOnce() -> T,
) -> Result<T> {
let _ = crossterm::execute!(
std::io::stdout(),
crossterm::event::DisableMouseCapture,
crossterm::event::DisableBracketedPaste
);
ratatui::restore();
let result = child();
*terminal = ratatui::init();
let _ = crossterm::execute!(
std::io::stdout(),
crossterm::event::EnableMouseCapture,
crossterm::event::EnableBracketedPaste
);
terminal.clear()?;
Ok(result)
}
fn run_interactive_command(
terminal: &mut DefaultTerminal,
cmd: &str,
cwd: &std::path::Path,
setup: Option<&dugix_core::usershell::UserShell>,
data: &std::path::Path,
) -> Result<(Option<i32>, bool, Option<std::path::PathBuf>)> {
let cwd_file = data.join(format!("shell-cwd-{}", uuid::Uuid::new_v4()));
let result = with_terminal_suspended(terminal, || {
let mut command = if let Some(setup) = setup {
let mut command = std::process::Command::new(&setup.shell);
command
.args(["-c", &setup.wrapper(cmd, cwd)])
.env("DUGIX_CWD_FILE", &cwd_file);
command
} else {
let mut command = std::process::Command::new("sh");
command.args(["-c", cmd]);
command
};
let status = command.current_dir(cwd).status();
let started = status.is_ok();
let exit = status.ok().and_then(|status| status.code());
let outcome = dugix_core::app::user_command_outcome_label(exit, started);
print!("\n[{outcome}] press Enter to return to dugix");
let _ = std::io::Write::flush(&mut std::io::stdout());
let _ = std::io::stdin().read_line(&mut String::new());
(exit, started)
});
let next_dir = std::fs::read_to_string(&cwd_file)
.ok()
.map(|text| std::path::PathBuf::from(text.trim_end_matches('\n')))
.filter(|path| path.is_absolute() && path.is_dir());
let _ = std::fs::remove_file(&cwd_file);
let (exit, started) = result?;
Ok((exit, started, next_dir))
}
fn edit_in_external_editor(terminal: &mut DefaultTerminal, path: &std::path::Path) -> Result<()> {
let editor_raw = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
let mut parts = editor_raw.split_whitespace();
let editor = parts.next().unwrap_or("vi");
let status = with_terminal_suspended(terminal, || {
std::process::Command::new(editor)
.args(parts)
.arg(path)
.status()
})?;
match status {
Ok(code) if code.success() => Ok(()),
Ok(code) => {
Err(anyhow::anyhow!(
"editor exited with code {}",
code.code().unwrap_or(-1)
))
}
Err(e) => Err(anyhow::anyhow!("could not launch editor: {e}")),
}
}
fn open_new_session(app: &mut AppView, incognito: bool) -> Result<()> {
app.clear_input();
app.sel.clear();
if app.incognito != incognito {
app.toggle_incognito()?;
}
app.new_session();
Ok(())
}
#[allow(clippy::too_many_lines)]
fn handle_normal(app: &mut AppView, key: KeyEvent) -> Result<()> {
if app.shell_state.is_some() {
match key.code {
KeyCode::Up => {
app.move_shell_selection(-1);
return Ok(());
}
KeyCode::Down => {
app.move_shell_selection(1);
return Ok(());
}
KeyCode::Tab | KeyCode::Enter => {
app.accept_shell_match();
return Ok(());
}
KeyCode::Esc => {
app.shell_state = None;
return Ok(());
}
_ => app.shell_state = None,
}
}
if app.shell_completion_rx.is_some() {
app.shell_completion_rx = None;
if key.code == KeyCode::Esc {
return Ok(());
}
}
if !matches!(key.code, KeyCode::Up | KeyCode::Down) {
app.shell_recall = None;
}
if !app.command_matches().is_empty() {
match key.code {
KeyCode::Up => {
app.move_command_selection(-1);
return Ok(());
}
KeyCode::Down => {
app.move_command_selection(1);
return Ok(());
}
KeyCode::Tab => {
app.accept_command(false)?;
return Ok(());
}
KeyCode::Enter => {
app.accept_command(true)?;
return Ok(());
}
KeyCode::Esc => {
app.set_input("");
return Ok(());
}
_ => {}
}
}
if app.at_state.is_some() {
match key.code {
KeyCode::Up => {
app.move_at_selection(-1);
return Ok(());
}
KeyCode::Down => {
app.move_at_selection(1);
return Ok(());
}
KeyCode::Tab | KeyCode::Enter => {
app.accept_at_match();
return Ok(());
}
KeyCode::Esc => {
app.at_state = None;
return Ok(());
}
_ => {}
}
}
let key = if app.vim_enabled {
match app.vim.key(&mut app.input, key) {
crate::vim::Outcome::Handled => {
app.refresh_at_matches();
return Ok(());
}
crate::vim::Outcome::Submit => KeyEvent::from(KeyCode::Enter),
crate::vim::Outcome::Leave => KeyEvent::from(KeyCode::Esc),
crate::vim::Outcome::Passthrough => key,
}
} else {
key
};
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
let shift = key.modifiers.contains(KeyModifiers::SHIFT);
match key.code {
KeyCode::BackTab => {
let mode = match app.work_mode {
WorkMode::Chat => WorkMode::Agent,
WorkMode::Agent => WorkMode::AgentAuto,
WorkMode::AgentAuto => WorkMode::Chat,
};
let root = app
.workspace
.as_ref()
.map(|workspace| workspace.root().to_string_lossy().into_owned());
app.execute(AppCommand::SetWorkMode { mode, root })?;
}
KeyCode::Tab if app.shell_draft() => {
app.start_shell_completion();
}
KeyCode::Enter if shift || ctrl => app.input.insert_newline(),
KeyCode::Enter if app.survey_gate_targets_current_session() => {
let text = app.input_text();
app.set_input("");
app.reply_to_survey_gate(&text);
}
KeyCode::Enter if app.batch_focus.is_some() && app.input_text().is_empty() => {
ui::history::toggle_focused_batch_row(app);
}
KeyCode::Up | KeyCode::Down
if key.modifiers.is_empty()
&& app.batch_focus.is_some()
&& app.input_text().is_empty() =>
{
ui::history::move_batch_focus(app, key.code == KeyCode::Down);
}
KeyCode::Enter => {
app.batch_focus = None;
app.submit()?;
}
KeyCode::Char('a') if ctrl => app.input.select_all(),
KeyCode::Char('c' | 'C') if ctrl && shift => app.copy_selection(),
KeyCode::Char('x') if ctrl => app.cut_selection(),
KeyCode::Char('r') if ctrl => app.toggle_reasoning_view()?,
KeyCode::Char('t') if ctrl => {
app.show_tool_detail = !app.show_tool_detail;
app.tool_open.clear();
app.batch_open.clear();
app.batch_focus = None;
app.tool_open_gen = app.tool_open_gen.wrapping_add(1);
app.tool_click_anchor = None;
app.pin_viewport_top = true;
}
KeyCode::Char('n' | 'N') if ctrl && shift => open_new_session(app, true)?,
KeyCode::Char('n' | 'N') if ctrl => open_new_session(app, false)?,
KeyCode::Char('o') if ctrl && app.sel.selected_text().is_some() => {
app.open_session_link();
}
KeyCode::Up if ctrl && app.research.rx.is_some() => app.open_research_live(),
KeyCode::Up if ctrl && ui::popups::subagents::has_live(app) => {
ui::popups::subagents::open(app);
}
KeyCode::Up if key.modifiers.contains(KeyModifiers::ALT) => app.recall_prev(),
KeyCode::Down if key.modifiers.contains(KeyModifiers::ALT) => app.recall_next(),
KeyCode::Char('g') if ctrl => app.popup = Popup::Context,
KeyCode::F(1) => app.open_help(),
KeyCode::F(2) => crate::interactive::focus(app),
KeyCode::Char(c @ '1'..='4')
if key.modifiers.contains(KeyModifiers::ALT) && !app.welcome_targets.is_empty() =>
{
app.open_welcome_session(c as usize - '1' as usize)?;
}
KeyCode::Backspace if ctrl => {
app.input.delete_word();
app.refresh_at_matches();
return Ok(());
}
KeyCode::Up
if !shift
&& !ctrl
&& app.input_text().is_empty()
&& !app.queued_messages().is_empty() =>
{
app.execute(AppCommand::Queue {
action: dugix_core::app::QueueAction::Edit(None),
})?;
}
KeyCode::Up if !shift && !ctrl && app.shell_history_mode() => app.recall_prev(),
KeyCode::Down if !shift && !ctrl && app.shell_history_mode() => app.recall_next(),
KeyCode::Up if !shift => {
let before = app.input.cursor();
app.input.move_cursor(CursorMove::Up);
if app.input.cursor() == before {
app.scroll = app.scroll.saturating_add(1).min(app.max_scroll);
}
app.refresh_at_matches();
return Ok(());
}
KeyCode::Down if !shift => {
let before = app.input.cursor();
app.input.move_cursor(CursorMove::Down);
if app.input.cursor() == before {
app.scroll = app.scroll.saturating_sub(1);
}
app.refresh_at_matches();
return Ok(());
}
KeyCode::PageUp => {
app.scroll = app
.scroll
.saturating_add(app.history_page())
.min(app.max_scroll);
}
KeyCode::PageDown => app.scroll = app.scroll.saturating_sub(app.history_page()),
KeyCode::Home if ctrl => app.scroll = app.max_scroll,
KeyCode::End if ctrl => app.scroll = 0,
KeyCode::Esc if app.batch_focus.is_some() => {
app.batch_focus = None;
app.tool_open_gen = app.tool_open_gen.wrapping_add(1);
}
KeyCode::Esc if app.viewing_stream() => app.stop_stream()?,
KeyCode::Esc => {
app.set_input("");
}
_ => {
app.input.input(key);
if app.input.is_selecting() {
app.copy_selection_live();
}
}
}
app.refresh_at_matches();
Ok(())
}
fn handle_input_mouse(app: &mut AppView, m: MouseEvent) {
let over_input = app.input_inner.contains(Position::new(m.column, m.row));
match m.kind {
MouseEventKind::Down(MouseButton::Left) => {
if over_input {
app.mouse_target = MouseTarget::Input;
if app.batch_focus.take().is_some() {
app.tool_open_gen = app.tool_open_gen.wrapping_add(1);
}
app.sel.clear();
let count = app.composer_click_down((m.column, m.row));
composer_jump(app, m);
match count {
2 => app.select_composer_word(),
n if n >= 3 => app.select_composer_line(),
_ => {
app.input.cancel_selection();
app.composer_word_anchor = None;
}
}
} else if let Some(p) = app.sel.pos_at(m.column, m.row) {
app.mouse_target = MouseTarget::History;
app.sel.on_down(p);
} else {
app.mouse_target = MouseTarget::None;
}
}
MouseEventKind::Drag(MouseButton::Left) => match app.mouse_target {
MouseTarget::Input => match app.composer_click_count {
2 => {
composer_jump(app, m);
app.extend_composer_word_selection();
}
n if n >= 3 => {
composer_jump(app, m);
app.extend_composer_line_selection();
}
_ => {
if !app.input.is_selecting() {
app.input.start_selection();
}
composer_jump(app, m);
}
},
MouseTarget::History => {
if let Some(p) = app.sel.pos_at(m.column, m.row) {
app.sel.on_drag(p);
}
}
MouseTarget::None => {}
},
MouseEventKind::Up(MouseButton::Left) => {
match app.mouse_target {
MouseTarget::History => {
let p = app.sel.pos_at(m.column, m.row);
let long_press = app.sel.check_long_press();
let long_press_handled = long_press.is_some() || app.sel.is_long_pressed();
if let Some(long_press) = long_press {
match long_press {
crate::selection::LongPress::Code(text)
| crate::selection::LongPress::Url(text) => app.copy_text(&text),
crate::selection::LongPress::Message(idx) => app.copy_message(idx),
}
}
let plain_click = m.modifiers.is_empty()
&& app.sel.is_plain_click(p)
&& app.sel.line_at_cell(m.column, m.row).is_some();
match app.sel.on_up(p) {
Some(crate::selection::Action::Copy(text)) => app.copy_text(&text),
Some(crate::selection::Action::OpenUrl(url)) => {
let _ = open::that_detached(&url);
app.push_status(format!("opened {url}"));
}
None if !long_press_handled
&& p.is_some_and(|p| app.open_image_at_line(p.0)) => {}
None if plain_click => {
if let Some((line, _)) = p {
ui::history::toggle_tool_at_line(app, line);
}
}
None => {}
}
}
MouseTarget::Input if app.input.is_selecting() => app.copy_selection(),
MouseTarget::Input | MouseTarget::None => {}
}
app.mouse_target = MouseTarget::None;
}
MouseEventKind::ScrollUp => {
app.scroll = app.scroll.saturating_add(3).min(app.max_scroll);
}
MouseEventKind::ScrollDown => app.scroll = app.scroll.saturating_sub(3),
_ => {}
}
}
fn composer_jump(app: &mut AppView, m: MouseEvent) {
let row = m.row.saturating_sub(app.input_inner.y);
let col = m.column.saturating_sub(app.input_inner.x);
app.input.move_cursor(CursorMove::Jump(row, col));
}
fn handle_popup_mouse(app: &mut AppView, m: MouseEvent) -> Result<()> {
let press = |app: &mut AppView, code: KeyCode| handle_key(app, KeyEvent::from(code));
match m.kind {
MouseEventKind::ScrollUp => press(app, KeyCode::Up),
MouseEventKind::ScrollDown => press(app, KeyCode::Down),
MouseEventKind::Down(MouseButton::Left) => {
let Some(hit) = app.list_hit.get() else {
return Ok(());
};
let (Some(index), Some(selected)) = (hit.index_at(m.column, m.row), hit.selected)
else {
return Ok(());
};
if index == selected {
return press(app, KeyCode::Enter);
}
let (code, steps) = if index > selected {
(KeyCode::Down, index - selected)
} else {
(KeyCode::Up, selected - index)
};
for _ in 0..steps {
press(app, code)?;
}
Ok(())
}
_ => Ok(()),
}
}
#[allow(clippy::too_many_lines)]
fn handle_mouse(app: &mut AppView, m: MouseEvent, screen: Rect) -> Result<()> {
if app.popup == Popup::Approval {
let over_panel = app
.approval_area
.get()
.is_some_and(|area| area.contains(Position::new(m.column, m.row)));
match (m.kind, over_panel) {
(MouseEventKind::ScrollUp | MouseEventKind::ScrollDown, true) => {
let code = if m.kind == MouseEventKind::ScrollUp {
KeyCode::Up
} else {
KeyCode::Down
};
for _ in 0..3 {
ui::popups::approval::handle_key(app, KeyEvent::from(code))?;
}
}
(MouseEventKind::ScrollUp, false) => {
app.scroll = app.scroll.saturating_add(3).min(app.max_scroll);
}
(MouseEventKind::ScrollDown, false) => app.scroll = app.scroll.saturating_sub(3),
_ => {}
}
return Ok(());
}
if app.popup == Popup::ImageViewer {
ui::popups::image_viewer::mouse(app, m);
return Ok(());
}
if crate::resize::mouse(app, m, screen) {
return Ok(());
}
if app.popup == Popup::None {
if m.kind == MouseEventKind::Down(MouseButton::Left) {
let pos = Position::new(m.column, m.row);
if let Some((_, index)) = app
.notification_areas
.iter()
.find(|(area, _)| area.contains(pos))
.copied()
{
app.activate_notification(index)?;
return Ok(());
}
if let Some(n) = app
.welcome_targets
.iter()
.position(|(area, _)| area.contains(pos))
{
return app.open_welcome_session(n);
}
}
if crate::interactive::mouse(app, m, screen) {
return Ok(());
}
handle_input_mouse(app, m);
return Ok(());
}
if app.popup == Popup::InteractiveUi {
crate::interactive::mouse(app, m, screen);
return Ok(());
}
if app.popup != Popup::Model {
return handle_popup_mouse(app, m);
}
let (fav_outer, avail_outer) = ui::popups::model::model_popup_areas(app, screen);
let fav_inner = ui::popups::model::list_inner(fav_outer);
let avail_inner = ui::popups::model::list_inner(avail_outer);
let pos = Position::new(m.column, m.row);
let panel = if fav_inner.contains(pos) {
Some((ModelPanel::Favorites, fav_inner, app.fav_offset))
} else if avail_inner.contains(pos) {
Some((ModelPanel::Available, avail_inner, app.avail_offset))
} else {
None
};
match m.kind {
MouseEventKind::Down(MouseButton::Left) => {
if let Some((p, inner, offset)) = panel {
let index = offset + (m.row - inner.y) as usize;
app.pick_model_at(p, index)?;
}
}
MouseEventKind::ScrollDown => {
if let Some((p, ..)) = panel {
app.model_focus = p;
app.move_model_selection(1);
}
}
MouseEventKind::ScrollUp => {
if let Some((p, ..)) = panel {
app.model_focus = p;
app.move_model_selection(-1);
}
}
_ => {}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use dugix_core::app::App;
use dugix_core::db::Db;
use dugix_core::space::Space;
fn test_app() -> AppView {
let root = std::env::temp_dir().join(format!("dugix-events-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(root.join("spaces")).unwrap();
AppView::new(App::new(
Db::open_in_memory().unwrap(),
Some("k"),
Space { root },
))
}
fn ctrl(c: char) -> KeyEvent {
KeyEvent::new(KeyCode::Char(c), KeyModifiers::CONTROL)
}
#[tokio::test]
async fn pending_approval_opens_the_popup_and_allow_resolves_the_tool_call() {
let mut app = test_app();
let root = app.space.root.clone();
let workspace =
std::env::temp_dir().join(format!("dugix-approval-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&workspace).unwrap();
app.run_command(&format!("agent {}", workspace.display()))
.unwrap();
while app.pop_pending_event().is_some() {}
let toolbox = std::sync::Arc::clone(&app.toolbox);
let call = tokio::spawn(async move {
toolbox
.run(
"fs",
r#"{"action":"write","path":"approved","content":"yes"}"#,
)
.await
});
let event = tokio::time::timeout(std::time::Duration::from_secs(5), app.core.next_event())
.await
.unwrap();
assert!(
matches!(event, AppEvent::Status(status) if status == "approval needed · fs write")
);
assert_ne!(app.popup, Popup::Approval);
app.apply_event(&AppEvent::HistoryInvalidated);
assert_eq!(app.popup, Popup::Approval);
assert_eq!(app.approval_request, app.approvals.pending_request);
assert_eq!(
app.approval_request.as_ref().unwrap().summary,
"write approved (+1 −0)\ndiff --git aa/workspace/approved bb/workspace/approved\nindex e69de29..396a0ba 100644\n--- aa/workspace/approved\n+++ bb/workspace/approved\n@@ -0,0 +1 @@\n+yes\n\\ No newline at end of file"
);
assert!(!workspace.join("approved").exists());
handle_key(&mut app, KeyCode::Char('y').into()).unwrap();
assert_ne!(call.await.unwrap().1, "blocked");
assert_eq!(
std::fs::read_to_string(workspace.join("approved")).unwrap(),
"yes"
);
assert_eq!(app.popup, Popup::None);
assert!(app.approvals.pending_request.is_none());
drop(app);
std::fs::remove_dir_all(root).unwrap();
std::fs::remove_dir_all(workspace).unwrap();
}
fn agent_app() -> AppView {
let mut app = test_app();
app.work_mode = WorkMode::Agent;
app
}
#[test]
fn approval_popup_closes_when_its_pending_request_is_gone() {
let mut app = test_app();
let root = app.space.root.clone();
let (sender, receiver) = tokio::sync::oneshot::channel();
app.approvals.pending = Some(sender);
app.approvals.pending_request = Some(dugix_core::tools::ApprovalRequest {
tool: "shell".into(),
class: None,
detail: None,
action: "run".into(),
summary: "$ true".into(),
allow_session: true,
});
app.apply_event(&AppEvent::Status("unrelated status".into()));
assert_eq!(app.popup, Popup::Approval);
drop(receiver);
app.sync_approval_popup();
assert_eq!(app.popup, Popup::None);
assert!(app.approvals.pending.is_none());
assert!(app.approvals.pending_request.is_none());
assert!(app.approval_request.is_none());
drop(app);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn approval_keys_resolve_once_and_other_popups_cannot_replace_the_prompt() {
use dugix_core::tools::{ApprovalRequest, Decision};
let mut app = test_app();
let root = app.space.root.clone();
assert!(app.interactive_approvals);
for (key, decision) in [
(KeyEvent::from(KeyCode::Char('y')), Decision::Allow),
(
KeyEvent::from(KeyCode::Char('a')),
Decision::AllowForSession,
),
(KeyEvent::from(KeyCode::Char('n')), Decision::Deny),
(KeyEvent::from(KeyCode::Esc), Decision::Deny),
(ctrl('c'), Decision::Deny),
] {
let (sender, mut receiver) = tokio::sync::oneshot::channel();
app.approvals.pending = Some(sender);
app.approval_request = Some(ApprovalRequest {
tool: "shell".into(),
class: None,
detail: None,
action: "run".into(),
summary: "$ true".into(),
allow_session: true,
});
app.popup = Popup::Approval;
app.execute(AppCommand::OpenSettings).unwrap();
app.apply_event(&AppEvent::OpenLoginPopup);
assert_eq!(app.popup, Popup::Approval);
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
assert_eq!(app.popup, Popup::Approval);
assert!(receiver.try_recv().is_err());
handle_key(&mut app, key).unwrap();
assert_eq!(receiver.try_recv().unwrap(), decision);
assert_eq!(app.popup, Popup::None);
assert!(app.approvals.pending.is_none());
assert!(app.approval_request.is_none());
}
drop(app);
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn shell_dropdown_uses_tab_arrows_enter_and_escape_without_running() {
let mut app = agent_app();
let root = app.space.root.clone();
let cwd = app.user_command_cwd();
for name in ["alpha", "alps"] {
std::fs::create_dir(cwd.join(name)).unwrap();
}
app.user_command
.shell
.set(dugix_core::usershell::UserShell {
shell: "/bin/sh".into(),
snapshot: None,
path: String::new(),
names: Vec::new(),
warning: None,
})
.unwrap();
app.set_input("!cd al");
handle_normal(&mut app, KeyCode::Tab.into()).unwrap();
let completion = next_shell_completion(&mut app.shell_completion_rx)
.await
.unwrap();
app.finish_shell_completion(completion);
assert_eq!(app.input_text(), "!cd alp");
assert!(app.shell_state.is_some());
handle_normal(&mut app, KeyCode::Down.into()).unwrap();
assert_eq!(app.shell_state.as_ref().unwrap().selected, 1);
handle_normal(&mut app, KeyCode::Up.into()).unwrap();
assert_eq!(app.shell_state.as_ref().unwrap().selected, 0);
handle_normal(&mut app, KeyCode::Enter.into()).unwrap();
assert_eq!(app.input_text(), "!cd alpha/");
assert!(app.shell_state.is_none());
assert!(app.session.is_none());
app.set_input("!cd al");
handle_normal(&mut app, KeyCode::Tab.into()).unwrap();
let completion = next_shell_completion(&mut app.shell_completion_rx)
.await
.unwrap();
app.finish_shell_completion(completion);
handle_normal(&mut app, KeyCode::Down.into()).unwrap();
handle_normal(&mut app, KeyCode::Tab.into()).unwrap();
assert_eq!(app.input_text(), "!cd alps/");
assert!(app.shell_state.is_none());
assert!(app.session.is_none());
app.set_input("!cd al");
handle_normal(&mut app, KeyCode::Tab.into()).unwrap();
let completion = next_shell_completion(&mut app.shell_completion_rx)
.await
.unwrap();
app.finish_shell_completion(completion);
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.input_text(), "!cd alp");
assert!(app.shell_state.is_none());
app.set_input("!ssh nowhere");
app.core.interactive_ui = true;
handle_normal(&mut app, KeyCode::Enter.into()).unwrap();
assert!(matches!(
app.pending_editor,
Some(dugix_core::app::PendingEditor::UserCommand(ref cmd)) if cmd == "ssh nowhere"
));
assert!(app.session.is_none());
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn plain_arrows_recall_bang_commands_and_restore_empty_input() {
let mut app = agent_app();
let root = app.space.root.clone();
let session = app
.db
.create_session("history", "a/one", &app.active_space.id, "chat")
.unwrap();
for cmd in ["first", "second"] {
app.db
.add_user_command_message(&session.id, &serde_json::json!({"cmd": cmd}).to_string())
.unwrap();
}
for expected in ["!second", "!first", "!first"] {
handle_normal(&mut app, KeyCode::Up.into()).unwrap();
assert_eq!(app.input_text(), expected);
}
for expected in ["!second", "", ""] {
handle_normal(&mut app, KeyCode::Down.into()).unwrap();
assert_eq!(app.input_text(), expected);
}
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn queued_messages_show_above_the_composer_and_up_takes_the_newest_back() {
let mut app = test_app();
let root = app.space.root.clone();
app.models = vec![dugix_core::provider::Model {
id: "a/one".into(),
name: "One".into(),
reasoning_efforts: Vec::new(),
context_length: None,
supports_images: false,
supports_image_generation: false,
supports_video_generation: false,
backend: dugix_core::provider::BackendTag::OpenRouter,
pricing: None,
aliases: Vec::new(),
}];
app.core.current_model = Some("a/one".into());
for text in ["first", "then this", "and that"] {
app.set_input(text);
app.submit().unwrap();
}
assert_eq!(app.queued_messages(), ["then this", "and that"]);
assert_eq!(app.input_text(), "", "the composer is free while it waits");
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(90, 20)).unwrap();
terminal.draw(|f| ui::render(f, &mut app)).unwrap();
let buffer = terminal.backend().buffer();
let screen: String = (0..buffer.area.height)
.flat_map(|y| {
(0..buffer.area.width)
.map(move |x| buffer[(x, y)].symbol())
.chain(["\n"])
})
.collect();
assert!(screen.contains("2 queued"), "{screen}");
assert!(screen.contains("1. then this"), "{screen}");
assert!(screen.contains("2. and that"), "{screen}");
handle_normal(&mut app, KeyCode::Up.into()).unwrap();
while let Some(event) = app.pop_pending_event() {
app.apply_event(&event);
}
assert_eq!(app.input_text(), "and that");
assert_eq!(app.queued_messages(), ["then this"]);
app.set_input("");
app.stop_stream().unwrap();
assert_eq!(app.queued_messages(), ["then this"]);
app.submit().unwrap();
assert!(app.queued_messages().is_empty());
assert!(app.viewing_stream());
app.stop_stream().unwrap();
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn chat_mode_bang_draft_ignores_shell_tab_and_history_keys() {
let mut app = test_app();
let root = app.space.root.clone();
assert_eq!(app.work_mode, WorkMode::Chat);
let session = app
.db
.create_session("history", "a/one", &app.active_space.id, "chat")
.unwrap();
app.db
.add_user_command_message(
&session.id,
&serde_json::json!({"cmd": "first"}).to_string(),
)
.unwrap();
app.set_input("!cd al");
handle_normal(&mut app, KeyCode::Tab.into()).unwrap();
assert!(app.shell_completion_rx.is_none());
assert!(app.shell_state.is_none());
assert!(app.input_text().starts_with("!cd al"));
app.set_input("!cd al");
handle_normal(&mut app, KeyCode::Up.into()).unwrap();
assert!(app.shell_recall.is_none());
assert_eq!(app.input_text(), "!cd al");
app.set_input("");
handle_normal(&mut app, KeyCode::Up.into()).unwrap();
assert!(app.shell_recall.is_none());
assert_eq!(app.input_text(), "");
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn shift_tab_cycles_all_three_modes() {
let mut app = test_app();
app.set_input("keep this draft");
for mode in [WorkMode::Agent, WorkMode::AgentAuto, WorkMode::Chat] {
handle_key(&mut app, KeyCode::BackTab.into()).unwrap();
assert_eq!(app.work_mode, mode);
assert_eq!(app.input_text(), "keep this draft");
}
}
#[test]
fn shift_tab_toggles_work_mode_reusing_the_root_without_changing_the_draft() {
let mut app = test_app();
let root = std::env::temp_dir().join(format!("dugix-toggle-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&root).unwrap();
app.execute(AppCommand::SetWorkMode {
mode: WorkMode::Agent,
root: Some(root.display().to_string()),
})
.unwrap();
app.set_input("keep this draft");
handle_key(&mut app, KeyCode::BackTab.into()).unwrap();
assert_eq!(app.work_mode, WorkMode::AgentAuto);
assert_eq!(app.input_text(), "keep this draft");
handle_key(&mut app, KeyCode::BackTab.into()).unwrap();
assert_eq!(app.work_mode, WorkMode::Chat);
assert_eq!(app.input_text(), "keep this draft");
handle_key(&mut app, KeyCode::BackTab.into()).unwrap();
assert_eq!(app.work_mode, WorkMode::Agent);
assert_eq!(
app.workspace.as_ref().unwrap().root(),
root.canonicalize().unwrap()
);
assert_eq!(app.input_text(), "keep this draft");
app.new_session();
handle_key(&mut app, KeyCode::BackTab.into()).unwrap();
assert_eq!(app.work_mode, WorkMode::Agent);
assert_eq!(
app.workspace.as_ref().unwrap().root(),
std::env::current_dir().unwrap().canonicalize().unwrap()
);
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn model_ui_events_are_not_composer_or_slash_commands() {
let mut app = test_app();
app.set_input("keep this draft");
let source = include_str!("../../core/tests/fixtures/interactive/counter.json");
app.messages.push(dugix_core::db::Message {
role: "assistant".into(),
content: format!("```dugix-ui\n{source}\n```"),
model: None,
reasoning: None,
tokens: None,
secs: None,
cost: None,
phrase: None,
persona: None,
created_at: None,
});
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 40)).unwrap();
terminal.draw(|f| ui::render(f, &mut app)).unwrap();
let buffer = terminal.backend().buffer();
let point = (0..40)
.find_map(|y| {
let line = (0..100)
.map(|x| buffer[(x, y)].symbol())
.collect::<String>();
line.find("Add one").map(|index| {
Position::new(u16::try_from(line[..index].chars().count()).unwrap(), y)
})
})
.unwrap();
handle_mouse(
&mut app,
MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column: point.x,
row: point.y,
modifiers: KeyModifiers::NONE,
},
Rect::new(0, 0, 100, 40),
)
.unwrap();
assert_eq!(app.popup, Popup::InteractiveUi);
handle_key(&mut app, KeyCode::F(2).into()).unwrap();
assert_eq!(app.popup, Popup::None);
handle_key(&mut app, KeyCode::F(2).into()).unwrap();
assert_eq!(app.popup, Popup::InteractiveUi);
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
assert_eq!(app.input_text(), "keep this draft");
assert_eq!(app.messages.len(), 1);
handle_key(&mut app, ctrl('c')).unwrap();
assert_eq!(app.popup, Popup::None);
assert!(!app.should_quit);
assert_eq!(app.input_text(), "keep this draft");
}
#[test]
fn interactive_text_editing_routes_modified_keys_without_touching_the_composer() {
let mut app = test_app();
app.vim_enabled = false;
app.clipboard = None;
app.set_input("keep this draft");
let source = "root = Panel('Contact', [Input($name, 'Name'), Textarea($notes, 'Notes', 3)])\n$name = 'Ada'\n$notes = ''";
app.messages.push(dugix_core::db::Message {
role: "assistant".into(),
content: format!("```dugix-ui\n{source}\n```"),
model: None,
reasoning: None,
tokens: None,
secs: None,
cost: None,
phrase: None,
persona: None,
created_at: None,
});
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 40)).unwrap();
terminal.draw(|frame| ui::render(frame, &mut app)).unwrap();
handle_key(&mut app, KeyCode::F(2).into()).unwrap();
handle_key(&mut app, KeyCode::Left.into()).unwrap();
handle_key(&mut app, KeyCode::Char('X').into()).unwrap();
let contents =
|app: &mut AppView, terminal: &mut ratatui::Terminal<ratatui::backend::TestBackend>| {
terminal.draw(|frame| ui::render(frame, app)).unwrap();
terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect::<String>()
};
assert!(contents(&mut app, &mut terminal).contains("AdXa"));
handle_key(&mut app, KeyEvent::new(KeyCode::Left, KeyModifiers::SHIFT)).unwrap();
app.paste("é");
assert!(contents(&mut app, &mut terminal).contains("Adéa"));
handle_key(&mut app, ctrl('a')).unwrap();
handle_key(&mut app, ctrl('c')).unwrap();
assert_eq!(
app.popup,
Popup::InteractiveUi,
"copy selection must not close the panel"
);
handle_key(&mut app, ctrl('x')).unwrap();
app.paste("Lin");
assert!(contents(&mut app, &mut terminal).contains("Lin"));
handle_key(&mut app, KeyCode::Tab.into()).unwrap();
app.paste("line one");
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
app.paste("line two");
let before = app.scroll;
handle_key(&mut app, KeyCode::PageUp.into()).unwrap();
assert_eq!(app.scroll, before, "editing must not scroll the transcript");
let rendered = contents(&mut app, &mut terminal);
assert!(rendered.contains("line one") && rendered.contains("line two"));
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.popup, Popup::None);
assert_eq!(app.input_text(), "keep this draft");
assert_eq!(app.messages.len(), 1);
}
#[test]
fn proposed_command_fills_only_an_empty_composer() {
let mut app = test_app();
app.core.approvals.proposed_command = Some("!sudo make install".into());
take_proposed_command(&mut app);
assert_eq!(app.input_text(), "!sudo make install");
assert!(app.core.approvals.proposed_command.is_none());
app.set_input("keep this draft");
app.core.approvals.proposed_command = Some("!make".into());
take_proposed_command(&mut app);
assert_eq!(app.input_text(), "keep this draft");
assert!(app.core.approvals.proposed_command.is_none());
assert_eq!(app.last_status(), "proposed: !make");
}
#[test]
fn ctrl_c_backs_out_before_quitting() {
let mut app = test_app();
app.popup = Popup::Help;
handle_key(&mut app, ctrl('c')).unwrap();
assert!(
app.popup == Popup::None && !app.should_quit,
"closes the popup first"
);
app.set_input("a draft");
handle_key(&mut app, ctrl('c')).unwrap();
assert!(
app.input_text().is_empty() && !app.should_quit,
"then clears the draft"
);
handle_key(&mut app, ctrl('c')).unwrap();
assert!(!app.should_quit, "an idle press only arms the quit");
handle_key(&mut app, ctrl('c')).unwrap();
assert!(app.should_quit, "a second press quits");
}
#[test]
fn page_keys_move_by_the_visible_height_and_ctrl_home_end_jump() {
let mut app = test_app();
app.history_height = 30;
app.max_scroll = 500;
let key = |code, modifiers| KeyEvent::new(code, modifiers);
handle_key(&mut app, key(KeyCode::PageUp, KeyModifiers::NONE)).unwrap();
assert_eq!(app.scroll, 28);
handle_key(&mut app, key(KeyCode::PageDown, KeyModifiers::NONE)).unwrap();
assert_eq!(app.scroll, 0);
handle_key(&mut app, key(KeyCode::Home, KeyModifiers::CONTROL)).unwrap();
assert_eq!(app.scroll, 500);
handle_key(&mut app, key(KeyCode::End, KeyModifiers::CONTROL)).unwrap();
assert_eq!(app.scroll, 0);
}
fn draw(app: &mut AppView, w: u16, h: u16) -> Vec<String> {
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(w, h)).unwrap();
terminal.draw(|f| crate::ui::render(f, app)).unwrap();
let buffer = terminal.backend().buffer();
(0..h)
.map(|y| (0..w).map(|x| buffer[(x, y)].symbol()).collect())
.collect()
}
#[test]
fn approval_docks_in_the_composer_and_leaves_the_conversation_readable() {
let mut app = test_app();
for n in 0..80 {
app.messages.push(dugix_core::db::Message {
role: "user".into(),
content: format!("conversation line {n}"),
model: None,
reasoning: None,
tokens: None,
secs: None,
cost: None,
phrase: None,
persona: None,
created_at: None,
});
}
let (sender, _receiver) = tokio::sync::oneshot::channel();
app.approvals.pending = Some(sender);
app.approvals.pending_request = Some(dugix_core::tools::ApprovalRequest {
tool: "shell".into(),
class: Some("runs a command".into()),
detail: None,
action: "run".into(),
summary: "$ cargo test".into(),
allow_session: true,
});
app.sync_approval_popup();
assert_eq!(app.popup, Popup::Approval);
let screen = draw(&mut app, 100, 40);
let title = screen
.iter()
.position(|line| line.contains("Approve"))
.expect("approval panel drawn");
assert!(title > 20, "{screen:#?}");
assert!(
screen[..title]
.iter()
.any(|line| line.contains("conversation line"))
);
assert!(
screen[title..]
.iter()
.any(|line| line.contains("$ cargo test"))
);
let before = app.scroll;
let wheel = |kind, row| MouseEvent {
kind,
column: 10,
row,
modifiers: KeyModifiers::NONE,
};
handle_mouse(
&mut app,
wheel(MouseEventKind::ScrollUp, 2),
Rect::new(0, 0, 100, 40),
)
.unwrap();
assert!(app.scroll > before, "transcript scrolled");
assert_eq!(app.popup, Popup::Approval, "still waiting for an answer");
}
fn click(app: &mut AppView, column: u16, row: u16) {
let m = MouseEvent {
kind: MouseEventKind::Down(MouseButton::Left),
column,
row,
modifiers: KeyModifiers::NONE,
};
handle_mouse(app, m, Rect::new(0, 0, 100, 40)).unwrap();
}
fn tool_app() -> AppView {
let mut app = test_app();
app.popup = Popup::None;
app.clipboard = None;
for path in ["first.rs", "second.rs"] {
app.messages.push(dugix_core::db::Message {
role: "tool_call".into(),
content: serde_json::json!({
"name":"fs",
"arguments":serde_json::json!({"action":"read","path":path}).to_string(),
"result":format!("{path} (lines 1-1 of 1):\n1: fn main() {{}}"),
"assistant_content":format!("Inspect {path} first."),
})
.to_string(),
model: None,
reasoning: None,
tokens: None,
secs: None,
cost: None,
phrase: None,
persona: None,
created_at: None,
});
}
app
}
fn history_mouse(app: &mut AppView, kind: MouseEventKind, column: u16, row: u16) {
handle_input_mouse(
app,
MouseEvent {
kind,
column,
row,
modifiers: KeyModifiers::NONE,
},
);
}
#[test]
fn batch_rows_click_enter_and_arrows_fold_independently() {
let mut app = tool_app();
app.messages[0].content = serde_json::json!({
"name":"batch",
"arguments":serde_json::json!({"calls":[
{"tool":"search", "arguments":{"query":"needle"}},
{"tool":"deck", "arguments":{"action":"edit","path":"a.deck.json"}}
]}).to_string(),
"result":"[1/2] search \"needle\"\n[1] A result\n https://example.test\n A snippet.\n[2/2] deck\ndeck failed: no block x"
}).to_string();
app.tool_open.insert(0, true);
let screen = draw(&mut app, 100, 40);
let row = u16::try_from(
screen
.iter()
.position(|line| line.contains("1 ◎ search"))
.unwrap(),
)
.unwrap();
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 4, row);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 4, row);
assert_eq!(app.batch_focus, Some((0, 0)));
assert!(app.batch_open.contains(&(0, 0)));
assert_eq!(app.tool_open.get(&0), Some(&true));
assert!(!app.tool_open.contains_key(&1));
let screen = draw(&mut app, 100, 40);
assert!(screen.iter().any(|line| line.contains("A snippet.")));
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
assert!(!app.batch_open.contains(&(0, 0)));
draw(&mut app, 100, 40);
handle_key(&mut app, KeyCode::Down.into()).unwrap();
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
assert!(app.batch_open.contains(&(0, 1)));
assert!(!app.batch_open.contains(&(0, 0)));
let screen = draw(&mut app, 100, 40);
assert!(
screen
.iter()
.any(|line| line.contains("▎ deck failed: no block x"))
);
handle_key(&mut app, ctrl('t')).unwrap();
assert!(app.batch_open.is_empty());
assert_eq!(app.batch_focus, None);
app.batch_open.insert((0, 1));
app.apply_event(&dugix_core::app::AppEvent::ViewportReset);
assert!(app.batch_open.is_empty());
}
#[test]
fn tool_clicks_toggle_one_card_and_ctrl_t_resets_all_overrides() {
let mut app = tool_app();
let screen = draw(&mut app, 100, 40);
let row = u16::try_from(
screen
.iter()
.position(|l| l.contains("read first.rs"))
.unwrap(),
)
.unwrap();
for open in [true, false, true] {
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 4, row);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 4, row);
assert_eq!(app.tool_open.get(&0), Some(&open));
assert!(!app.tool_open.contains_key(&1));
let screen = draw(&mut app, 100, 40);
assert!(screen[usize::from(row)].contains("read first.rs"));
}
handle_key(&mut app, ctrl('t')).unwrap();
assert!(app.show_tool_detail);
assert!(app.tool_open.is_empty());
let screen = draw(&mut app, 100, 40);
for path in ["first.rs", "second.rs"] {
assert!(
screen
.iter()
.any(|l| l.contains(&format!("read {path}")) && l.contains('▾'))
);
}
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 4, row);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 4, row);
assert_eq!(app.tool_open.get(&0), Some(&false));
assert!(!app.tool_open.contains_key(&1));
handle_key(&mut app, ctrl('t')).unwrap();
assert!(!app.show_tool_detail);
assert!(app.tool_open.is_empty());
}
#[test]
fn preamble_clicks_toggle_their_card_but_drags_do_not() {
let mut app = tool_app();
let screen = draw(&mut app, 100, 40);
let row = u16::try_from(
screen
.iter()
.position(|l| l.contains("Inspect first.rs first."))
.unwrap(),
)
.unwrap();
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 2, row);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 2, row);
assert_eq!(app.tool_open.get(&0), Some(&true));
draw(&mut app, 100, 40);
let generation = app.tool_open_gen;
history_mouse(
&mut app,
MouseEventKind::Down(MouseButton::Left),
2,
row + 1,
);
history_mouse(
&mut app,
MouseEventKind::Drag(MouseButton::Left),
10,
row + 1,
);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 10, row + 1);
assert!(app.sel.selected_text().is_some());
assert_eq!(app.tool_open_gen, generation);
assert_eq!(app.tool_open.get(&0), Some(&true));
}
#[test]
fn clicking_an_expanded_body_closes_only_its_card() {
let mut app = tool_app();
app.show_tool_detail = true;
let screen = draw(&mut app, 100, 40);
let row = u16::try_from(
screen
.iter()
.position(|l| l.contains("▎ 1: fn main()"))
.unwrap(),
)
.unwrap();
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 4, row);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 4, row);
assert_eq!(app.tool_open.get(&0), Some(&false));
assert!(!app.tool_open.contains_key(&1));
let screen = draw(&mut app, 100, 40);
assert!(
screen
.iter()
.any(|l| l.contains("read second.rs") && l.contains('▾'))
);
}
#[test]
fn clicking_empty_history_below_cards_does_not_fold_the_last_card() {
let mut app = tool_app();
draw(&mut app, 100, 40);
assert!(app.sel.pos_at(3, 15).is_some());
assert_eq!(app.sel.line_at_cell(3, 15), None);
history_mouse(&mut app, MouseEventKind::Down(MouseButton::Left), 3, 15);
history_mouse(&mut app, MouseEventKind::Up(MouseButton::Left), 3, 15);
assert!(app.tool_open.is_empty());
}
#[test]
fn expanded_result_url_click_is_handled_before_card_folding() {
let mut app = tool_app();
app.messages[0].content = serde_json::json!({
"name":"fetch_url",
"arguments":r#"{"url":"https://example.test"}"#,
"result":"see https://example.test/report here",
})
.to_string();
app.show_tool_detail = true;
let screen = draw(&mut app, 100, 40);
let row = u16::try_from(
screen
.iter()
.position(|l| l.contains("▎ see https://example.test/report"))
.unwrap(),
)
.unwrap();
let prefix = screen[usize::from(row)].split("https://").next().unwrap();
let column = u16::try_from(prefix.chars().count() + 3).unwrap();
history_mouse(
&mut app,
MouseEventKind::Down(MouseButton::Left),
column,
row,
);
let pos = app.sel.pos_at(column, row);
assert!(app.sel.is_plain_click(pos));
assert!(
matches!(app.sel.on_up(pos), Some(crate::selection::Action::OpenUrl(url)) if url == "https://example.test/report")
);
assert!(app.tool_open.is_empty());
}
#[test]
fn clicking_a_popup_row_selects_it_and_a_second_click_opens_it() {
let mut app = test_app();
let space = app.core.active_space.id.clone();
for title in ["alpha", "bravo", "charlie"] {
app.core
.db
.create_session(title, "a/one", &space, "chat")
.unwrap();
}
app.open_session_picker().unwrap();
let screen = draw(&mut app, 100, 40);
let target = app.filtered_sessions()[2].title.clone();
let row = screen
.iter()
.position(|l| l.contains(&format!(" {target} ")))
.unwrap_or_else(|| panic!("{target} not drawn:\n{}", screen.join("\n")));
let row = u16::try_from(row).unwrap();
let column = 50;
click(&mut app, column, row);
assert_eq!(app.session_selected, 2, "first click selects the row");
assert!(app.popup == Popup::Session);
draw(&mut app, 100, 40);
click(&mut app, column, row);
assert!(app.popup == Popup::None, "second click opens it");
assert_eq!(
app.session.as_ref().map(|s| s.title.as_str()),
Some(target.as_str())
);
}
#[test]
fn wheel_over_a_popup_moves_its_selection() {
let mut app = test_app();
let space = app.core.active_space.id.clone();
for title in ["alpha", "bravo"] {
app.core
.db
.create_session(title, "a/one", &space, "chat")
.unwrap();
}
app.open_session_picker().unwrap();
let wheel = |kind| MouseEvent {
kind,
column: 50,
row: 20,
modifiers: KeyModifiers::NONE,
};
handle_mouse(
&mut app,
wheel(MouseEventKind::ScrollDown),
Rect::new(0, 0, 100, 40),
)
.unwrap();
assert_eq!(app.session_selected, 1);
handle_mouse(
&mut app,
wheel(MouseEventKind::ScrollUp),
Rect::new(0, 0, 100, 40),
)
.unwrap();
assert_eq!(app.session_selected, 0);
}
#[test]
fn welcome_recent_sessions_open_by_alt_digit_and_click() {
let mut app = test_app();
let space = app.core.active_space.id.clone();
for title in ["alpha", "bravo"] {
let s = app
.core
.db
.create_session(title, "a/one", &space, "chat")
.unwrap();
app.core.db.add_user_message(&s.id, "hi").unwrap();
}
let screen = draw(&mut app, 100, 40);
assert_eq!(app.welcome_targets.len(), 2, "{}", screen.join("\n"));
let second = app.welcome_targets[1].1.clone();
let alt2 = KeyEvent::new(KeyCode::Char('2'), KeyModifiers::ALT);
handle_key(&mut app, alt2).unwrap();
assert_eq!(app.session.as_ref().map(|s| s.id.clone()), Some(second));
draw(&mut app, 100, 40);
assert!(app.welcome_targets.is_empty());
app.new_session();
draw(&mut app, 100, 40);
let (rect, first) = app.welcome_targets[0].clone();
click(&mut app, rect.x + rect.width / 2, rect.y);
assert_eq!(app.session.as_ref().map(|s| s.id.clone()), Some(first));
}
#[test]
fn ctrl_c_quit_disarms_on_other_keys_and_expires() {
let mut app = test_app();
handle_key(&mut app, ctrl('c')).unwrap();
handle_key(
&mut app,
KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE),
)
.unwrap();
app.set_input("");
handle_key(&mut app, ctrl('c')).unwrap();
assert!(!app.should_quit, "typing in between disarms");
app.quit_armed_at = Some(std::time::Instant::now() - QUIT_CONFIRM_WINDOW);
handle_key(&mut app, ctrl('c')).unwrap();
assert!(!app.should_quit, "a stale arm doesn't count");
}
fn mouse_at(app: &mut AppView, kind: MouseEventKind, column: u16, row: u16) {
let m = MouseEvent {
kind,
column,
row,
modifiers: KeyModifiers::NONE,
};
handle_mouse(app, m, Rect::new(0, 0, 100, 40)).unwrap();
}
#[test]
fn dragging_a_popup_border_resizes_it_and_rows_still_select_afterwards() {
let mut app = test_app();
let space = app.core.active_space.id.clone();
for title in ["alpha", "bravo", "charlie"] {
app.core
.db
.create_session(title, "a/one", &space, "chat")
.unwrap();
}
app.open_session_picker().unwrap();
draw(&mut app, 100, 40);
let rect = app.popup_hit.get().unwrap().rect;
assert_eq!(rect, ui::centered(Rect::new(0, 0, 100, 40), 64, 74));
let down = MouseEventKind::Down(MouseButton::Left);
mouse_at(&mut app, down, rect.x, rect.y + 8);
assert!(app.drag.is_some());
mouse_at(
&mut app,
MouseEventKind::Drag(MouseButton::Left),
10,
rect.y + 8,
);
mouse_at(
&mut app,
MouseEventKind::Up(MouseButton::Left),
10,
rect.y + 8,
);
assert_eq!(app.settings.popup_sizes, "session:80x74");
let screen = draw(&mut app, 100, 40);
assert_eq!(app.popup_hit.get().unwrap().rect.width, 80);
let target = app.filtered_sessions()[2].title.clone();
let row = screen
.iter()
.position(|l| l.contains(&format!(" {target} ")))
.unwrap();
click(&mut app, 50, u16::try_from(row).unwrap());
assert_eq!(app.session_selected, 2, "a click inside still selects");
assert!(app.drag.is_none());
}
#[test]
fn the_model_popup_picks_by_click_at_its_resized_position() {
let mut app = test_app();
app.core.models = ["a/alpha", "b/bravo", "c/charlie"]
.iter()
.map(|id| dugix_core::provider::Model {
id: (*id).into(),
name: (*id).into(),
reasoning_efforts: Vec::new(),
context_length: None,
supports_images: false,
supports_image_generation: false,
supports_video_generation: false,
backend: dugix_core::provider::BackendTag::OpenRouter,
pricing: None,
aliases: Vec::new(),
})
.collect();
app.core.set_setting("popup_sizes", "model:60x50").unwrap();
app.open_model_picker();
let screen = draw(&mut app, 100, 40);
let row = screen
.iter()
.position(|l| l.contains("b/bravo"))
.expect("bravo is listed");
let col = u16::try_from(screen[row].find("b/bravo").unwrap()).unwrap();
let (_, avail) = ui::popups::model::model_popup_areas(&app, Rect::new(0, 0, 100, 40));
assert!(
avail.x < col,
"the click lands in the resized available panel"
);
click(&mut app, col + 1, u16::try_from(row).unwrap());
assert!(app.popup == Popup::None, "the pick closed the picker");
assert!(
app.current_model
.as_deref()
.is_some_and(|m| m.ends_with("b/bravo")),
"{:?}",
app.current_model
);
}
struct CountingClipboard(std::sync::Arc<std::sync::atomic::AtomicUsize>);
impl crate::image_viewer_actions::Clipboard for CountingClipboard {
fn set_text(&mut self, _: &str) -> Result<(), String> {
Ok(())
}
fn set_image(&mut self, width: usize, height: usize, rgba: Vec<u8>) -> Result<(), String> {
assert_eq!((width, height, rgba.len()), (16, 8, 16 * 8 * 4));
self.0.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
Ok(())
}
}
fn viewer_with_picture() -> (AppView, std::sync::Arc<std::sync::atomic::AtomicUsize>) {
let mut app = test_app();
app.core.settings.image_viewer = "terminal".into();
let dir =
std::env::temp_dir().join(format!("dugix-events-viewer-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("p.png");
image::RgbImage::from_pixel(16, 8, image::Rgb([5, 6, 7]))
.save(&path)
.unwrap();
let copies = std::sync::Arc::default();
app.image_viewer.hooks.clipboard =
Some(Box::new(CountingClipboard(std::sync::Arc::clone(&copies))));
app.open_image_target(
&path.to_string_lossy(),
&crate::image_viewer::Anchor::ByTarget,
crate::image_viewer::Return::Nothing,
);
assert_eq!(app.popup, Popup::ImageViewer);
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
terminal.draw(|f| ui::render(f, &mut app)).unwrap();
(app, copies)
}
#[test]
fn a_japanese_session_title_fits_the_composer_border() {
let mut app = test_app();
let space = app.active_space.id.clone();
let title = "日本語の文章を書くための長いセッションタイトルです";
app.session = Some(app.db.create_session(title, "m", &space, "chat").unwrap());
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(50, 12)).unwrap();
terminal.draw(|f| ui::render(f, &mut app)).unwrap();
let buffer = terminal.backend().buffer();
let y = app.input_inner.y - 1;
let border: String = (0..50).map(|x| buffer[(x, y)].symbol()).collect();
assert!(border.contains('❯'), "{border}");
assert!(border.contains('…'), "{border}");
}
#[test]
fn the_terminal_cursor_sits_on_the_composer_caret_for_ime_preedit() {
use ratatui::backend::Backend as _;
let mut app = test_app();
app.set_input("日本語 abc");
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
terminal.draw(|f| ui::render(f, &mut app)).unwrap();
let inner = app.input_inner;
assert_eq!(
terminal.backend_mut().get_cursor_position().unwrap(),
Position::new(inner.x + 10, inner.y),
"6 columns of kanji, a space and abc put the caret at column 10"
);
}
#[test]
fn ctrl_c_in_the_image_viewer_copies_the_picture_and_leaves_it_open() {
let (mut app, copies) = viewer_with_picture();
handle_key(&mut app, ctrl('c')).unwrap();
assert_eq!(copies.load(std::sync::atomic::Ordering::SeqCst), 1);
assert_eq!(app.popup, Popup::ImageViewer, "Esc closes, Ctrl+C copies");
assert!(!app.should_quit && app.quit_armed_at.is_none());
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.popup, Popup::None);
}
#[test]
fn the_image_viewer_gets_every_mouse_event_while_it_is_open() {
let (mut app, _copies) = viewer_with_picture();
let screen = Rect::new(0, 0, 80, 24);
let event = |kind, column, row| MouseEvent {
kind,
column,
row,
modifiers: KeyModifiers::NONE,
};
handle_mouse(
&mut app,
event(MouseEventKind::Down(MouseButton::Right), 20, 6),
screen,
)
.unwrap();
assert!(
app.image_viewer.pointer.menu.is_some(),
"right-click opens the menu"
);
handle_mouse(
&mut app,
event(MouseEventKind::Down(MouseButton::Left), 70, 20),
screen,
)
.unwrap();
assert!(app.image_viewer.pointer.menu.is_none());
assert_eq!(app.popup, Popup::ImageViewer);
handle_mouse(&mut app, event(MouseEventKind::ScrollUp, 40, 10), screen).unwrap();
assert_ne!(app.image_viewer.zoom(), crate::image_viewer::Zoom::Fit);
assert_eq!(app.scroll, 0, "the transcript behind it did not scroll");
}
fn type_keys(app: &mut AppView, text: &str) {
for c in text.chars() {
handle_normal(app, KeyCode::Char(c).into()).unwrap();
}
}
#[test]
fn vim_is_on_by_default_and_edits_the_composer() {
let mut app = test_app();
assert!(app.vim_enabled);
type_keys(&mut app, "hello");
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.vim.mode(), crate::vim::Mode::Normal);
assert_eq!(
app.input_text(),
"hello",
"the first Esc only leaves Insert"
);
type_keys(&mut app, "0x");
assert_eq!(app.input_text(), "ello");
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.input_text(), "", "Esc in Normal mode clears, as before");
assert_eq!(app.vim.mode(), crate::vim::Mode::Insert);
}
#[test]
fn vim_normal_enter_submits_and_vim_off_restores_plain_esc() {
let mut app = test_app();
type_keys(&mut app, "/vim off");
app.set_input("vim off");
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
type_keys(&mut app, "I/");
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.input_text(), "/vim off");
handle_normal(&mut app, KeyCode::Enter.into()).unwrap();
assert!(!app.vim_enabled, "Normal-mode Enter ran /vim off");
app.set_input("draft");
handle_normal(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.input_text(), "", "one Esc clears without vim");
app.set_keymap("on").unwrap();
assert!(app.vim_enabled);
assert!(app.set_keymap("emacs").is_err());
}
#[test]
fn motion_command_toggles_panel_motion_and_persists() {
let mut app = test_app();
assert!(
crate::app_view::load_motion_enabled(&app.core),
"motion is on unless the setting says off"
);
app.set_motion("on").unwrap();
assert!(app.interactive.motion);
app.set_motion("off").unwrap();
assert!(!crate::app_view::load_motion_enabled(&app.core));
assert!(!app.interactive.motion);
let saved = app.core.db.load_settings().unwrap();
assert!(
saved
.iter()
.any(|(key, value)| key == "motion" && value == "off")
);
app.set_motion("").unwrap();
assert!(app.interactive.motion, "no argument toggles");
assert!(app.set_motion("sometimes").is_err());
}
#[test]
fn vim_keys_edit_panel_fields_and_code_editors() {
let mut app = test_app();
let source = "root = Panel('Form', [Input($name, 'Name'), Editor($code, 'Solution', 'python', 3)])\n$name = 'Ada'\n$code = 'x = 1'";
app.messages.push(dugix_core::db::Message {
role: "assistant".into(),
content: format!("```dugix-ui\n{source}\n```"),
model: None,
reasoning: None,
tokens: None,
secs: None,
cost: None,
phrase: None,
persona: None,
created_at: None,
});
let mut terminal =
ratatui::Terminal::new(ratatui::backend::TestBackend::new(100, 40)).unwrap();
let mut screen = |app: &mut AppView| {
terminal.draw(|frame| ui::render(frame, app)).unwrap();
terminal
.backend()
.buffer()
.content
.iter()
.map(|cell| cell.symbol())
.collect::<String>()
};
screen(&mut app);
handle_key(&mut app, KeyCode::F(2).into()).unwrap();
assert_eq!(app.popup, Popup::InteractiveUi);
assert!(
screen(&mut app).contains("INSERT"),
"the hint shows the mode"
);
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.popup, Popup::InteractiveUi, "Esc only left Insert");
assert!(screen(&mut app).contains("NORMAL"));
for c in "0x".chars() {
handle_key(&mut app, KeyCode::Char(c).into()).unwrap();
}
assert!(screen(&mut app).contains("da"), "x deleted the A");
assert!(!screen(&mut app).contains("Ada"));
handle_key(&mut app, KeyCode::Char('p').into()).unwrap();
assert!(
screen(&mut app).contains("dAa"),
"p put the deleted char back"
);
handle_key(&mut app, KeyCode::Tab.into()).unwrap();
handle_key(&mut app, KeyCode::Enter.into()).unwrap();
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
assert!(screen(&mut app).contains("NORMAL · i insert · Esc stop editing"));
for c in "0dwix".chars() {
handle_key(&mut app, KeyCode::Char(c).into()).unwrap();
}
assert!(screen(&mut app).contains("x= 1"), "dw then ix");
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
handle_key(&mut app, KeyCode::Char('u').into()).unwrap();
assert!(screen(&mut app).contains("= 1"));
assert!(!screen(&mut app).contains("x= 1"), "u undid the insert");
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
handle_key(&mut app, KeyCode::Esc.into()).unwrap();
assert_eq!(app.popup, Popup::None, "Esc in Normal leaves as before");
}
#[test]
fn ctrl_up_opens_the_sub_agents_only_while_this_chat_has_some() {
let mut app = test_app();
let session = app
.db
.create_session("helpers", "a/one", &app.active_space.id, "chat")
.unwrap();
app.session = Some(session.clone());
let ctrl_up = KeyEvent::new(KeyCode::Up, KeyModifiers::CONTROL);
handle_key(&mut app, ctrl_up).unwrap();
assert_eq!(app.popup, Popup::None);
app.subagent_runs.push(dugix_core::app::SubagentRun {
id: "run".into(),
session_id: session.id,
number: 1,
prompt: "look".into(),
model: "m".into(),
writable: false,
max_steps: 20,
status: dugix_core::app::SubagentStatus::Running,
started_at: "2026-11-08T00:00:00Z".into(),
finished_at: None,
steps: 0,
tokens: 0,
cost: None,
secs: 0.0,
review: None,
rows: Vec::new(),
live_reasoning: String::new(),
live_content: String::new(),
});
handle_key(&mut app, ctrl_up).unwrap();
assert_eq!(app.popup, Popup::Subagents);
}
}