The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
//! New Harness: a compact keyboard-driven form, with a persistent draft and side choosers.
pub(crate) mod data;
pub(crate) mod receipt;
mod task;
mod welcome;
mod welcome_view;
pub(crate) use welcome::{Welcome, draw as draw_welcome, tick as welcome_tick};
pub(crate) use welcome::{key as welcome_key, mouse as welcome_mouse, paste as welcome_paste};
pub(crate) use welcome::editing as welcome_editing;
pub(crate) use welcome::remap as remap_welcome;
pub(crate) use receipt::Creation;
mod view;
use crate::{
app::App,
modal::{self, Modal, What},
picker::{Picker, Row},
theme,
};
use crossterm::event::{
KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent, MouseEventKind,
};
use ratatui::{
buffer::Buffer,
layout::{Position, Rect},
style::{Modifier, Style},
};
use serde_json::{Value, json};
use std::{collections::HashMap, time::Duration};
use unicode_width::UnicodeWidthStr;
pub use view::draw;
#[derive(Clone, Debug)]
pub enum Project {
Folder(String),
New(String),
Clone(String),
}
#[derive(Clone, Debug)]
pub struct Draft {
pub machine: String,
pub what: What,
pub project: Project,
pub task: String,
pub permission: String,
pub worktree: Option<bool>,
pub branch: Option<String>,
pub new_branch: Option<String>,
/// Model route and profile are explicit choices; never silently replace either at launch.
pub model: Option<(String, String, String)>,
pub profile: Option<(String, String, String)>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Field {
Agent,
Machine,
Project,
Task,
Model,
Approvals,
Profile,
Branch,
Worktree,
Create,
Terminal,
Recent(usize),
Browse,
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Surface { Dialog, Dismissed, Window(String) }
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ProjectAction {
Open,
New,
Clone,
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Choice {
Agent,
Compatible(String),
Project,
Machine(Option<ProjectAction>),
Approvals,
Model,
Profile,
Branch,
Folder(String),
Path,
Clone,
NewFolder,
}
impl Choice {
fn editing(&self) -> bool {
matches!(self, Self::Path | Self::Clone | Self::NewFolder)
}
}
struct Child {
kind: Choice,
picker: Picker,
generation: String,
}
pub struct Form {
pub draft: Draft,
pub id: String,
pub starting: bool,
checking: bool,
pub error: String,
pub attempt: Option<Creation>,
surface: Surface,
recovery_page: Option<String>,
recent: Vec<crate::input::HomeRow>,
recent_labels: Vec<(String, String)>,
recent_status: String,
first_run: bool,
launch_target: Option<crate::input::LaunchTarget>,
remember_choices: bool,
local_only: bool,
/// On a machine shared with this account (guest sharing): its harness runs on the owner's plans,
/// and the owner's daemon lists a guest no models or profiles.
guest: bool,
prepared_folder: Option<String>,
focus: Field,
child: Option<Child>,
child_active: bool,
trail: Vec<Child>,
area: Rect,
child_area: Rect,
/// The dialog's `[ Cancel ]` button, where it was last drawn: a click on it closes the form.
cancel_area: Rect,
/// On the button row, Cancel is the one chosen (← from Start), not Start.
cancel_chosen: bool,
task_area: Rect,
task_editor: task::Editor,
hits: Vec<(Rect, Field)>,
machine_label: String,
home: String,
git: Value,
git_key: Option<(String, String)>,
git_loading: bool,
submit_after_git: bool,
git_generation: String,
models: Value,
profiles: Value,
resource_generation: String,
projects: HashMap<String, Project>,
modes: HashMap<String, String>,
}
impl Form {
/// Where the form was last drawn, with a side chooser beside it (empty before its first frame).
pub(crate) fn drawn_area(&self) -> Rect {
if self.child_area.is_empty() { self.area } else { self.area.union(self.child_area) }
}
fn project_payload(&self) -> Result<(Option<String>, Value), String> {
// A confirmed failure may have already made a clone or worktree. Reuse that
// exact folder until the user explicitly chooses another project/branch.
if let Some(path) = &self.prepared_folder {
if matches!(&self.draft.project, Project::Folder(p) if p == path)
&& self.draft.worktree == Some(false)
&& self.draft.branch.is_none()
&& self.draft.new_branch.is_none()
{
return Ok((Some(path.clone()), json!({})));
}
}
data::project_payload(&self.draft, &self.git)
}
fn fields(&self) -> Vec<Field> {
let page = matches!(self.surface, Surface::Window(_));
let git_controls = self.draft.what.engine != "terminal"
&& (data::git(&self.git) || self.git_loading || self.git["error"].is_string());
// The machine is its own row, here and on the page: not "project @ machine" in one.
let mut fields = vec![Field::Task, Field::Agent, Field::Machine, Field::Project];
if !page && git_controls { fields.extend([Field::Branch, Field::Worktree]); }
if self.draft.what.engine != "terminal" && !self.guest {
fields.push(Field::Model);
}
if !data::modes(&self.draft.what.engine).is_empty() {
fields.push(Field::Approvals);
}
if self.draft.what.engine == "codex" && self.draft.model.is_none() && !self.guest {
fields.push(Field::Profile);
}
if page && git_controls { fields.extend([Field::Worktree, Field::Branch]); }
fields.push(Field::Create);
if page {
fields.push(Field::Browse);
fields.extend((0..self.recent.len()).map(Field::Recent));
fields.push(Field::Terminal);
}
fields
}
fn move_by(&mut self, delta: isize) {
let fields = self.fields();
let at = fields.iter().position(|f| *f == self.focus).unwrap_or(0) as isize;
self.focus = fields[(at + delta).rem_euclid(fields.len() as isize) as usize];
// Coming back to the buttons, Start is the one chosen again.
self.cancel_chosen = false;
}
fn worktree(&self) -> bool {
self.draft.what.engine != "terminal"
&& data::git(&self.git)
&& self.draft.worktree.unwrap_or(true)
}
fn blocked(&self, field: Field) -> Option<String> {
if self.local_only && matches!(field, Field::Branch | Field::Worktree | Field::Create) && self.draft.what.engine != "terminal" {
Some("Start the Harness daemon first".into())
} else if field == Field::Task && !task::supported(&self.draft.what.engine) && self.draft.task.trim().is_empty() {
Some(format!("Not available for {}", self.draft.what.label))
} else if matches!(field, Field::Branch | Field::Worktree) {
if self.git_loading {
Some("Checking Git…".into())
} else if self.git["error"] == "OFFLINE" {
Some("Waiting for machine…".into())
} else if self.git["error"].is_string() {
Some("Could not read Git · Enter to retry".into())
} else if !data::git(&self.git) || self.draft.what.engine == "terminal" {
Some("Not a Git repository".into())
} else {
None
}
} else {
None
}
}
fn project_name(&self) -> String {
match &self.draft.project {
Project::Folder(p) => Some(crate::sys::path_name(p))
.filter(|name| !name.is_empty()).unwrap_or("/").into(),
Project::New(n) => {
if n.is_empty() {
"New Folder".into()
} else {
format!("New Folder: {n}")
}
}
Project::Clone(url) => format!("Clone: {url}"),
}
}
fn hint(&self) -> String {
if self.focus == Field::Project {
if let Project::Folder(path) = &self.draft.project {
return short_path(path, &self.home);
}
}
String::new()
}
fn describe(&self, field: Field) -> (String, String) {
let (label, value) = match field {
Field::Agent => (
if self.draft.what.dsh.is_some() {
"Harness"
} else {
"Agent"
},
self.draft.what.label.clone(),
),
Field::Machine => ("Machine", self.machine_label.clone()),
Field::Project => ("Project", self.project_name()),
Field::Task => ("Task", if self.draft.task.trim().is_empty() {
"Add a task (optional)".into()
} else {
self.draft.task.split_whitespace().collect::<Vec<_>>().join(" ")
}),
Field::Model => (
"Model",
self.draft
.model
.as_ref()
.map(|(_, id, node)| {
if node.is_empty() {
id.clone()
} else {
format!("{id} · {node}")
}
})
.unwrap_or_else(|| data::subscription(&self.draft.what.engine).into()),
),
Field::Approvals => (
"Approvals",
data::mode_label(&self.draft.what.engine, &self.draft.permission),
),
Field::Profile => (
"Profile",
self.draft
.profile
.as_ref()
.map(|(_, _, n)| n.clone())
.unwrap_or_else(|| "Default".into()),
),
Field::Branch => (
"Branch",
self.draft
.new_branch
.as_ref()
.map(|n| format!("{n} · new"))
.or_else(|| {
data::branch_ref(&self.draft, &self.git)
.map(|r| data::branch_name(&r).into())
})
.unwrap_or_else(|| {
if self.worktree() {
"Choose a branch"
} else {
"Detached HEAD"
}
.into()
}),
),
Field::Worktree => (
"Worktree",
if self.worktree() { "[x]" } else { "[ ]" }.into(),
),
Field::Create => (
if self.starting {
if self.checking {
"Checking…"
} else {
"Starting…"
}
} else if self.attempt.is_some() {
"Check status"
} else {
"Start"
},
String::new(),
),
Field::Terminal => ("New Terminal", String::new()),
Field::Recent(i) => ("", self.recent_labels.get(i).map(|r| r.0.clone()).unwrap_or_default()),
Field::Browse => ("All", String::new()),
};
(
if field == Field::Create && !self.starting && self.attempt.is_none() {
format!("Start {}", self.draft.what.label)
} else {
label.into()
},
self.blocked(field).unwrap_or(value),
)
}
}
fn short_path(path: &str, home: &str) -> String {
if !home.is_empty() && (path == home || path.starts_with(&format!("{home}/"))) {
format!("~{}", &path[home.len()..])
} else {
path.into()
}
}
/// A machine's home folder: as its daemon reported it, or this computer's own.
fn machine_home(app: &App, machine: &str) -> Option<String> {
app.homes.get(machine).cloned().or_else(|| {
(machine == app.fleet.local_id || crate::local::is_local(machine)).then(|| std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")).ok()).flatten()
})
}
/// A machine by its name — this computer's too, not "local".
fn machine_label(app: &App, machine: &str) -> String {
if app.fleet.machines.iter().any(|m| m.id == machine && m.local) {
app.fleet.local_machine_name()
} else {
app.fleet.machine_name(machine)
}
}
fn defaults_path() -> std::path::PathBuf {
crate::app::state_dir().join("new-harness.json")
}
fn defaults() -> Value {
if cfg!(test) {
return Value::Null;
}
std::fs::read(defaults_path())
.ok()
.and_then(|s| serde_json::from_slice(&s).ok())
.unwrap_or(Value::Null)
}
fn saved_agent(saved: &Value) -> What {
// Older builds remembered Terminal as an agent. Shells now have their own action;
// do not reopen the task form with that unusable choice or its stale label.
let engine = saved["engine"].as_str().filter(|engine| *engine != "terminal").unwrap_or("opencode");
let same = saved["engine"].as_str() == Some(engine);
What {
engine: engine.into(),
label: same.then(|| saved["label"].as_str()).flatten().unwrap_or(theme::engine_label(engine)).into(),
dsh: same.then(|| saved["dsh"].as_str()).flatten().map(str::to_string),
}
}
fn remember(form: &Form) {
use std::io::Write;
let path = defaults_path();
let Some(parent) = path.parent() else { return };
let mut saved = defaults();
if !saved.is_object() {
saved = json!({});
}
let d = &form.draft;
if !saved["permissions"].is_object() {
saved["permissions"] = json!({});
}
saved["permissions"][&d.what.engine] = json!(d.permission);
saved["engine"] = json!(d.what.engine);
saved["dsh"] = json!(d.what.dsh);
saved["label"] = json!(d.what.label);
if !saved["projects"].is_object() {
saved["projects"] = json!({});
}
if let Project::Folder(p) = &d.project {
saved["projects"][&d.machine] = json!(p);
}
let tmp = path.with_extension(format!("{}.tmp", uuid::Uuid::new_v4()));
let write = || -> std::io::Result<()> {
std::fs::create_dir_all(parent)?;
let mut f = crate::sys::private_file(std::fs::OpenOptions::new().write(true).create_new(true)).open(&tmp)?;
f.write_all(saved.to_string().as_bytes())?;
std::fs::rename(&tmp, &path)
};
if write().is_err() {
let _ = std::fs::remove_file(tmp);
}
}
pub fn open(app: &mut App, machine: Option<String>, cwd: Option<String>) {
let machine = machine.map(|id| app.fleet.launch_machine_id(&id).to_string());
if machine
.as_ref()
.is_some_and(|id| !app.fleet.machines.iter().any(|m| m.id == *id && m.usable()))
{
return app.error("That machine is not connected");
}
// A closed window can still own a pending receipt. Reopen that receipt as a dialog so
// it can be checked, without replacing an unrelated dismissed dialog's draft.
if machine.is_none() && cwd.is_none() {
let orphan = app.welcome.forms.iter().find(|(tab, form)|
(form.starting || form.attempt.is_some())
&& !app.tabs.iter().chain(app.sessions.iter().flat_map(|s| s.tabs.iter())).any(|t| &t.id == *tab)
).map(|(tab, _)| tab.clone());
if let Some(tab) = orphan {
let mut form = app.welcome.forms.remove(&tab).unwrap();
form.recovery_page = Some(tab);
form.surface = Surface::Dialog;
store_form(app, form);
return;
}
}
if app
.new_harness_draft
.as_ref()
.is_some_and(|f| f.starting || f.attempt.is_some())
|| (machine.is_none() && cwd.is_none() && app.new_harness_draft.is_some())
{
let mut form = app.new_harness_draft.take().unwrap();
form.surface = Surface::Dialog;
// A draft reopened to go on writing starts on its task, no chooser open. (One whose
// launch failed keeps Start in focus: Enter retries it.)
if !form.starting && form.attempt.is_none() {
if task::supported(&form.draft.what.engine) && form.error.is_empty() { form.focus = Field::Task; }
form.child = None;
form.child_active = false;
form.trail.clear();
}
resolve_launch_machine(app, &mut form);
refresh_form(app, &mut form);
app.modal = Some(Modal::NewHarness(form));
return;
}
let Some(form) = make_form(app, machine, cwd, Surface::Dialog) else {
return app.error("No machine is connected yet");
};
let machine = form.draft.machine.clone();
store_form(app, form);
crate::input::load_dsh(app, machine, false);
}
fn make_form(app: &mut App, machine: Option<String>, cwd: Option<String>, surface: Surface) -> Option<Box<Form>> {
let saved = defaults();
// A window inherits its pane's machine and folder together. A temporarily offline
// machine must not redirect that folder (and the next task) to another computer.
let machine = machine
.or_else(|| app.fleet.registered_local_machine().filter(|m| m.usable()).map(|m| m.id.clone()))
.or_else(|| {
app.fleet
.machines
.iter()
.find(|m| m.local && m.usable())
.map(|m| m.id.clone())
})
.or_else(|| {
app.fleet
.machines
.iter()
.find(|m| m.usable())
.map(|m| m.id.clone())
})
.or_else(|| matches!(surface, Surface::Window(_)).then(|| {
if app.fleet.local_id.is_empty() { crate::local::MACHINE.into() } else { app.fleet.local_id.clone() }
}));
let machine = machine?;
let current = app
.focused()
.and_then(|f| app.panes.get(&f))
.filter(|p| p.machine_id == machine)
.and_then(|p| app.fleet.agent(&p.machine_id, &p.agent_id));
let what = saved_agent(&saved);
let engine = what.engine.clone();
// The home folder is nobody's project: hn's first shell starts there, and a fresh Mac's first
// harness, from that shell, wrote its files straight into it (macOS VM, 2026-10-09). Where the form
// was opened from home, a new project, as the desktop app makes one. A project the person chose
// (remembered) stays theirs, and a terminal from it opens at home (set_engine, the welcome row).
let home = machine_home(app, &machine);
let at_home = |p: &String| home.as_deref().is_some_and(|h| p.trim_end_matches('/') == h.trim_end_matches('/'));
let project = if cwd.as_ref().is_some_and(at_home) {
Project::New(String::new())
} else {
cwd.or_else(|| saved["projects"][&machine].as_str().map(str::to_string))
.or_else(|| current.map(|a| a.cwd.clone()).filter(|p| !p.is_empty() && !at_home(p)))
.map(Project::Folder)
.unwrap_or_else(|| Project::New(String::new()))
};
let permission = saved["permissions"][&engine]
.as_str()
.map(str::to_string)
.or_else(|| app.options.get("@hn-permission-mode", "", None))
.filter(|p| data::modes(&engine).iter().any(|(id, _)| id == p))
.unwrap_or_else(|| "auto".into());
let draft = Draft {
machine: machine.clone(),
what,
project,
task: String::new(),
permission,
worktree: None,
branch: None,
new_branch: None,
model: None,
profile: None,
};
let mut form = Box::new(Form {
draft,
id: uuid::Uuid::new_v4().to_string(),
starting: false,
checking: false,
error: String::new(),
attempt: None,
surface,
recovery_page: None,
recent: vec![],
recent_labels: vec![],
recent_status: String::new(),
first_run: false,
launch_target: None,
remember_choices: true,
local_only: false,
guest: false,
prepared_folder: None,
focus: if task::supported(&engine) { Field::Task } else { Field::Create },
child: None,
child_active: false,
trail: vec![],
area: Rect::default(),
child_area: Rect::default(),
cancel_area: Rect::default(),
cancel_chosen: false,
task_area: Rect::default(),
task_editor: task::Editor::default(),
hits: vec![],
machine_label: String::new(),
home: String::new(),
git: Value::Null,
git_key: None,
git_loading: false,
submit_after_git: false,
git_generation: String::new(),
models: Value::Null,
profiles: Value::Null,
resource_generation: String::new(),
projects: HashMap::new(),
modes: HashMap::new(),
});
refresh_form(app, &mut form);
sync_git(app, &mut form, false);
Some(form)
}
fn refresh_form(app: &App, form: &mut Form) {
form.machine_label = machine_label(app, &form.draft.machine);
form.local_only = crate::local::is_local(&form.draft.machine) && app.daemon_down;
form.guest = app.fleet.shares.contains_key(&form.draft.machine);
// Git discovery can finish while its controls have keyboard focus.
if matches!(form.focus, Field::Branch | Field::Worktree) && !form.fields().contains(&form.focus) {
form.focus = Field::Project;
form.child = None;
form.child_active = false;
form.trail.clear();
}
form.home = machine_home(app, &form.draft.machine).unwrap_or_default();
if form.draft.what.engine == "terminal"
&& matches!(&form.draft.project,Project::Folder(p) if p.is_empty())
&& !form.home.is_empty()
{
form.draft.project = Project::Folder(form.home.clone());
}
if let Some(dsh) = &form.draft.what.dsh {
if let Some(row) = app
.dsh
.get(&form.draft.machine)
.into_iter()
.flatten()
.find(|r| r["id"].as_str() == Some(dsh))
{
if let Some(name) = row["name"].as_str() {
form.draft.what.label =
format!("{name} · {}", theme::engine_label(&form.draft.what.engine));
}
}
}
let Some(c) = &mut form.child else { return };
let rows = match &c.kind {
Choice::Agent => Some(agent_rows(app, &form.draft.machine)),
Choice::Compatible(dsh) => Some(compatible_rows(app, &form.draft.machine, dsh)),
Choice::Project => {
let mut rows = project_rows(app, &form.draft, !matches!(form.surface, Surface::Window(_)));
// The Machine field (and the welcome header) owns the destination: the projects are the
// chosen machine's, and choosing one never switches to another computer.
let chosen = app.fleet.launch_machine_id(&form.draft.machine);
rows.retain(|row| row.id.strip_prefix("at:").and_then(|s| s.split_once('\t'))
.is_none_or(|(machine, _)| machine == chosen || machine == form.draft.machine));
Some(rows)
}
Choice::Machine(_) => Some(modal::new_machine_rows(app, &form.draft.machine)),
Choice::Approvals => Some(
data::modes(&form.draft.what.engine)
.iter()
.map(|(id, label)| Row::new(*id, *label))
.collect(),
),
Choice::Model => Some(data::model_rows(&form.models, &form.draft.what.engine)),
Choice::Profile => {
let mut rows = vec![Row::new("default", "Default")];
for p in form.profiles["profiles"].as_array().into_iter().flatten() {
if let Some(path) = p["path"].as_str() {
rows.push(Row::new(path, p["label"].as_str().unwrap_or(path)).extra(path));
}
}
Some(rows)
}
Choice::Branch => Some(data::branch_rows(
&form.git,
form.draft.worktree.unwrap_or(data::git(&form.git)),
&c.picker.query,
)),
_ => None,
};
if let Some(rows) = rows {
c.picker.set_rows(rows);
}
}
pub fn refresh(app: &mut App) {
let mut ids: Vec<_> = app.welcome.forms.values().map(|f| f.id.clone()).collect();
if let Some(Modal::NewHarness(f)) = &app.modal { ids.push(f.id.clone()) }
for id in ids {
with_form(app, &id, |app, form| {
resolve_launch_machine(app, form);
refresh_form(app, form);
sync_git(app, form, false);
});
}
}
fn resolve_launch_machine(app: &mut App, form: &mut Form) {
// A pending receipt belongs to its original transport, even if the daemon has returned.
if form.starting || form.attempt.is_some() { return }
let machine = app.fleet.launch_machine_id(&form.draft.machine).to_string();
if machine != form.draft.machine {
let project = form.draft.project.clone();
set_machine(app, form, &machine);
set_project(form, project);
sync_git(app, form, false);
}
}
fn agent_rows(app: &App, machine: &str) -> Vec<Row> {
// A guest on a machine shared with this account starts Claude Code or Codex there, on its owner's plans, in
// a space of its own: nothing from the Store, no other engine (docs/plans/2026-10-19-guest-machine-sharing-plan.md).
if app.fleet.shares.contains_key(machine) {
return modal::new_what_rows(&[]).into_iter().filter(|r| matches!(r.id.as_str(), "engine:claude" | "engine:codex")).collect();
}
modal::new_what_rows(app.dsh.get(machine).map(Vec::as_slice).unwrap_or(&[]))
}
fn compatible_rows(app: &App, machine: &str, dsh: &str) -> Vec<Row> {
let row = app
.dsh
.get(machine)
.into_iter()
.flatten()
.find(|r| r["id"].as_str() == Some(dsh));
let engines: Vec<_> = row
.and_then(|r| r["engines"].as_array())
.map(|a| a.iter().filter_map(Value::as_str).collect())
.filter(|a: &Vec<&str>| !a.is_empty())
.unwrap_or_else(|| vec![row.and_then(|r| r["engine"].as_str()).unwrap_or("claude")]);
engines
.into_iter()
.filter(|engine| *engine != "terminal")
.map(|e| Row::new(format!("engine:{e}"), theme::engine_label(e)))
.collect()
}
fn project_rows(app: &App, draft: &Draft, show_machine: bool) -> Vec<Row> {
const PER_MACHINE: usize = 50;
// A guest on a machine shared with this account starts in its workspace or a folder the owner shares, and
// browses, makes or clones nothing of the owner's (docs/plans/2026-10-19-guest-machine-sharing-plan.md).
let chosen = app.fleet.launch_machine_id(&draft.machine);
if app.fleet.shares.contains_key(chosen) {
let mut rows = vec![];
if let Some(workspace) = app.homes.get(chosen) {
rows.push(Row::new(format!("home:{chosen}\t{workspace}"), "My workspace").extra("home workspace").group("Yours"));
}
for (path, write) in app.guest_folders.get(chosen).into_iter().flatten() {
rows.push(Row::new(format!("at:{chosen}\t{path}"), path.clone()).extra("shared folder").group("Shared with you")
.right(if *write { "you can edit it" } else { "read only" }));
}
return rows;
}
let mut rows = vec![];
if draft.what.engine != "terminal" {
rows.push(Row::new("clone", "Clone Repository"));
}
rows.push(Row::new("folder", "Open Folder"));
if draft.what.engine != "terminal" {
rows.push(Row::new("new", "New Folder"));
}
// The chosen machine's home first, as the composer offers "this folder": a machine whose recent
// agents all ran in scratch folders otherwise offered nothing else.
if let Some(home) = app.homes.get(chosen).filter(|h| crate::sys::path_absolute(h)) {
let label = if show_machine { format!("~ @ {}", machine_label(app, chosen)) } else { "~".into() };
// (Its own id, not a recent project's "at:": chosen the same way, never counted among them.)
rows.push(Row::new(format!("home:{chosen}\t{home}"), label).extra(format!("home {}", app.fleet.machine_name(chosen))).group("Home"));
}
let mut agents: Vec<_> = app
.fleet
.agents
.values()
.filter(|a| !a.cwd.is_empty() && !crate::shell_context::scratch_folder(&a.cwd))
.collect();
agents.sort_by_key(|a| {
(
app.fleet.launch_machine_id(&a.machine_id) != app.fleet.local_id,
std::cmp::Reverse(a.recency()),
a.cwd.as_str(),
a.machine_id.as_str(),
)
});
// Each destination gets its own recent-folder allowance. Duplicate sessions and local
// shell aliases share that allowance; a large local history cannot consume a remote's.
let mut seen = std::collections::HashSet::new();
let mut counts = HashMap::new();
for a in agents {
let machine = app.fleet.launch_machine_id(&a.machine_id);
if !seen.insert((machine.to_string(), a.cwd.clone())) {
continue;
}
let count = counts.entry(machine).or_insert(0);
if *count >= PER_MACHINE {
continue;
}
*count += 1;
let short = short_path(
&a.cwd,
app.homes
.get(machine)
.or_else(|| app.homes.get(&a.machine_id))
.map(String::as_str)
.unwrap_or(""),
);
// "folder @ machine", the machine by its name. "local" still finds this computer's.
let local = app.fleet.machines.iter().any(|m| m.id == machine && m.local);
let mut row = Row::new(
format!("at:{machine}\t{}", a.cwd),
if show_machine { format!("{short} @ {}", machine_label(app, machine)) } else { short },
)
.extra(format!("{}{}", app.fleet.machine_name(machine), if local { " local" } else { "" }))
.group("Recent projects");
row.disabled = !app
.fleet
.machines
.iter()
.any(|m| m.id == machine && m.usable());
if row.disabled {
row.label.push_str(" · offline");
}
rows.push(row);
}
rows
}
fn sync_git(app: &mut App, form: &mut Form, force: bool) {
let path = if let Project::Folder(p) = &form.draft.project {
Some(p.clone())
} else {
None
};
// (A guest reads no Git of the owner's: a shared folder is opened as it is.)
if form.draft.what.engine == "terminal" || form.local_only || path.is_none() || app.fleet.shares.contains_key(&form.draft.machine) {
form.git = Value::Null;
form.git_key = None;
form.git_loading = false;
form.git_generation.clear();
return;
}
let path = path.unwrap();
let key = (form.draft.machine.clone(), path.clone());
if !force && form.git_key.as_ref() == Some(&key) {
return;
}
let Some(link) = app.link(&form.draft.machine) else {
form.git = json!({"error":"OFFLINE"});
return;
};
form.git_key = Some(key.clone());
form.git_loading = true;
form.git = Value::Null;
form.git_generation = uuid::Uuid::new_v4().to_string();
let generation = form.git_generation.clone();
let id = form.id.clone();
app.spawn(
async move {
link.rpc(
"git_project_info",
json!({"path":path}),
Duration::from_secs(20),
)
.await
},
move |app, reply| {
let mut submit = false;
with_form(app, &id, |app, form| {
if form.git_generation != generation {
return;
}
form.git_loading = false;
submit = std::mem::take(&mut form.submit_after_git);
if form.error == "Checking the project…" { form.error.clear(); }
form.git = reply.unwrap_or_else(|_| json!({"error":"UNAVAILABLE"}));
if let Some(main) = form.git["mainFolder"].as_str().map(str::to_string)
.filter(|_| !matches!(&form.draft.project, Project::Folder(p) if form.prepared_folder.as_ref() == Some(p)))
{
if form.draft.worktree == Some(false) && form.draft.branch.is_none() {
form.draft.branch = form.git["branch"]
.as_str()
.map(|b| format!("refs/heads/{b}"));
}
form.draft.project = Project::Folder(main.clone());
form.git_key = Some((form.draft.machine.clone(), main));
form.git["branch"] = form.git["mainBranch"].clone();
}
refresh_form(app, form);
});
// Enter may arrive before the initial project check. Honor it once,
// only while this form is still visible and no later input cancelled it.
let visible = matches!(&app.modal, Some(Modal::NewHarness(f)) if f.id == id)
|| app.modal.is_none() && app.home_visible()
&& app.welcome.forms.get(&app.tab().id).is_some_and(|f| f.id == id);
if submit && visible { start(app); }
},
);
}
fn store_form(app: &mut App, form: Box<Form>) {
match &form.surface {
Surface::Dialog => app.modal = Some(Modal::NewHarness(form)),
Surface::Dismissed => app.new_harness_draft = Some(form),
Surface::Window(tab) => { app.welcome.forms.insert(tab.clone(), form); }
}
}
/// Preserve a local draft when first signing in, while invalidating every outstanding
/// read/launch callback. An uncertain creation keeps its receipt and is checked, never replayed.
pub(crate) fn account_changed(app: &mut App, local_before: Option<&str>, machine: &str) {
welcome::account_changed(app);
let mut forms: Vec<_> = std::mem::take(&mut app.welcome.forms).into_values().collect();
if let Some(form) = app.new_harness_draft.take() { forms.push(form); }
if matches!(app.modal, Some(Modal::NewHarness(_))) {
let Some(Modal::NewHarness(form)) = app.modal.take() else { unreachable!() }; forms.push(form);
}
let windows: std::collections::HashSet<_> = app.tabs.iter().chain(app.sessions.iter().flat_map(|s| s.tabs.iter())).map(|t| t.id.clone()).collect();
for mut form in forms {
let local = local_before == Some(form.draft.machine.as_str());
if !local && !crate::local::is_local(&form.draft.machine) { continue }
form.id = uuid::Uuid::new_v4().to_string();
form.starting = false; form.checking = false; form.git_loading = false; form.submit_after_git = false;
form.git_key = None; form.git = Value::Null; form.models = Value::Null; form.profiles = Value::Null;
form.child = None; form.child_active = false; form.trail.clear(); form.projects.clear();
form.recent.clear(); form.recent_labels.clear(); form.recent_status.clear();
if local {
form.draft.machine = machine.into(); form.local_only = false;
if let Some((host, _, _)) = &mut form.draft.profile { if local_before == Some(host.as_str()) { *host = machine.into(); } }
if let Some(attempt) = &mut form.attempt { if local_before == Some(attempt.machine.as_str()) { attempt.machine = machine.into(); } }
}
form.error = if form.attempt.is_some() { "Connection changed during launch. Check status to recover the same harness.".into() } else { String::new() };
if matches!(&form.surface, Surface::Window(tab) if !windows.contains(tab)) { form.surface = Surface::Dismissed; }
store_form(app, form);
}
}
fn dismiss(app: &mut App, mut form: Box<Form>) {
form.submit_after_git = false;
if let Some(tab) = form.recovery_page.take().filter(|_| form.starting || form.attempt.is_some()) {
form.surface = Surface::Window(tab);
} else if matches!(form.surface, Surface::Window(_)) {
form.focus = Field::Agent;
if !form.starting && form.attempt.is_none() { form.error.clear(); }
} else { form.surface = Surface::Dismissed; }
store_form(app, form);
}
/// Esc on the empty home window's form: keep the draft and close the window, returning to the
/// one the new-window came from. A mid-launch form (starting / attempting) is never closed here —
/// dismiss() keeps its window so the launch can continue when looked at again.
fn close_home_window(app: &mut App, mut form: Box<Form>) {
form.surface = Surface::Dismissed;
form.child = None;
form.child_active = false;
form.trail.clear();
store_form(app, form);
app.close_tab(app.active);
}
fn take_active(app: &mut App) -> Option<Box<Form>> {
if matches!(app.modal, Some(Modal::NewHarness(_))) {
let Some(Modal::NewHarness(form)) = app.modal.take() else { unreachable!() };
Some(form)
} else if app.home_visible() {
app.welcome.forms.remove(&app.tab().id.clone())
} else { None }
}
fn take_id(app: &mut App, id: &str) -> Option<Box<Form>> {
if matches!(&app.modal,Some(Modal::NewHarness(form)) if form.id==id) {
let Some(Modal::NewHarness(form)) = app.modal.take() else { unreachable!() };
Some(form)
} else if app.new_harness_draft.as_ref().is_some_and(|form| form.id == id) {
app.new_harness_draft.take()
} else {
let tab = app.welcome.forms.iter().find(|(_, f)| f.id == id).map(|(t, _)| t.clone())?;
app.welcome.forms.remove(&tab)
}
}
fn with_form(app: &mut App, id: &str, f: impl FnOnce(&mut App, &mut Form)) {
if let Some(mut form) = take_id(app, id) {
f(app, &mut form);
store_form(app, form);
}
}
pub(crate) fn record_attempt(app: &mut App, id: &str, attempt: Creation) -> bool {
let mut recorded = false;
with_form(app, id, |_, form| {
if form.attempt.is_some() { return }
form.attempt = Some(attempt);
form.starting = true;
form.error.clear();
recorded = true;
});
recorded
}
fn load_resource(app: &mut App, form: &mut Form, models: bool) {
let Some(link) = app.link(&form.draft.machine) else {
return;
};
let id = form.id.clone();
let generation = uuid::Uuid::new_v4().to_string();
form.resource_generation = generation.clone();
if let Some(c) = &mut form.child {
c.picker.busy = Some("Loading…".into());
}
app.spawn(
async move {
link.rpc(
if models {
"grid_models_list"
} else {
"codex_profiles_list"
},
json!({"rowState":true}),
Duration::from_secs(30),
)
.await
},
move |app, reply| {
with_form(app, &id, |app, form| {
if form.resource_generation != generation {
return;
}
let value = reply.unwrap_or_else(|_| json!({"error":"UNAVAILABLE"}));
if value["error"].is_string() {
form.error = if models {
"Could not load models · choose Refresh models"
} else {
"Could not load profiles · reopen Profile to retry"
}
.into();
}
if models {
form.models = value
} else {
form.profiles = value
}
if let Some(c) = &mut form.child {
c.picker.busy = None;
}
refresh_form(app, form);
});
},
);
}
fn child(app: &mut App, form: &mut Form, kind: Choice, initial: &str) {
let hint = match &kind {
Choice::Agent => "Search agents and harnesses",
Choice::Compatible(_) => "Choose a coding agent",
Choice::Project => "Search projects",
Choice::Machine(_) => "Choose a machine",
Choice::Approvals => "Search approvals",
Choice::Model => "Search models",
Choice::Profile => "Search profiles",
Choice::Branch => "Search or create a branch",
Choice::Folder(_) => "Search folders · Ctrl-L path",
Choice::Path => "/path/to/project or ~/project",
Choice::Clone => "GitHub URL or owner/repository",
Choice::NewFolder => "Folder name (optional)",
};
let mut picker = Picker::new("", hint);
picker.keep_order = kind != Choice::Project;
picker.search_extra = kind == Choice::Project;
picker.query = initial.into();
picker.qcursor = initial.chars().count();
picker.empty = "No matches".into();
form.child = Some(Child {
kind: kind.clone(),
picker,
generation: uuid::Uuid::new_v4().to_string(),
});
refresh_form(app, form);
let selected = match &kind {
Choice::Agent => Some(
form.draft
.what
.dsh
.as_ref()
.map(|d| format!("dsh:{d}:{}", form.draft.what.engine))
.unwrap_or_else(|| format!("engine:{}", form.draft.what.engine)),
),
Choice::Compatible(_) => Some(format!("engine:{}", form.draft.what.engine)),
Choice::Project => {
if let Project::Folder(p) = &form.draft.project {
Some(format!("at:{}\t{p}", form.draft.machine))
} else {
None
}
}
Choice::Machine(action) => Some(if action.is_none() { form.draft.machine.clone() } else { app.fleet.local_id.clone() }),
Choice::Approvals => Some(form.draft.permission.clone()),
Choice::Model => Some(
form.draft
.model
.as_ref()
.map(|(grid, id, _)| json!([grid, id]).to_string())
.unwrap_or_else(|| "subscription".into()),
),
Choice::Profile => Some(
form.draft
.profile
.as_ref()
.map(|(_, p, _)| p.clone())
.unwrap_or_else(|| "default".into()),
),
Choice::Branch => data::branch_ref(&form.draft, &form.git),
_ => None,
};
if let (Some(c), Some(id)) = (&mut form.child, selected) {
c.picker.select(&id);
}
match kind {
Choice::Folder(path) => load_folder(app, form, path),
Choice::Model => load_resource(app, form, true),
Choice::Profile => load_resource(app, form, false),
_ => {}
}
}
fn load_folder(app: &mut App, form: &mut Form, path: String) {
let Some(link) = app.link(&form.draft.machine) else {
form.error = "That machine is not connected".into();
return;
};
let id = form.id.clone();
let Some(c) = &mut form.child else { return };
let generation = c.generation.clone();
c.picker.busy = Some("Loading folders…".into());
app.spawn(
async move {
link.rpc("fs_list_dir", json!({"path":path}), Duration::from_secs(20))
.await
},
move |app, reply| {
with_form(app, &id, |_, form| {
let Some(c) = &mut form.child else { return };
if c.generation != generation {
return;
}
c.picker.busy = None;
match reply {
Ok(v) if v["path"].is_string() => {
let path = v["path"].as_str().unwrap().to_string();
c.kind = Choice::Folder(path.clone());
c.picker.placeholder =
format!("{} · Ctrl-L path", short_path(&path, &form.home));
// "Use ~/work/app", the folder it means, not "Use this folder".
let mut rows = vec![Row::new("use", format!("Use {}", short_path(&path, &form.home)))];
if path != "/" {
rows.push(Row::new("up", ".. /"));
}
for entry in v["entries"].as_array().into_iter().flatten() {
if entry["isDir"] == false {
continue;
}
if let Some(name) = entry["name"]
.as_str()
.filter(|n| !n.contains('/') && *n != "." && *n != "..")
{
rows.push(Row::new(format!("dir:{name}"), format!("{name}/")));
}
}
c.picker.set_rows(rows);
}
_ => c.picker.empty = "Could not open folder · Ctrl-L to edit path".into(),
}
});
},
);
}
fn reveal(app: &mut App, form: &mut Form) {
form.child = None;
form.child_active = false;
form.trail.clear();
if form.blocked(form.focus).is_some() {
return;
}
let kind = match form.focus {
Field::Agent => Choice::Agent,
Field::Machine => Choice::Machine(None),
Field::Project => Choice::Project,
Field::Task => return,
Field::Model => Choice::Model,
Field::Approvals => Choice::Approvals,
Field::Profile => Choice::Profile,
Field::Branch => Choice::Branch,
_ => return,
};
child(app, form, kind, "");
}
fn activate(app: &mut App, form: &mut Form) -> bool {
form.error.clear();
// The compact welcome page has no persistent daemon hint. Let submission
// explain an unavailable launch and preserve the task instead of doing nothing.
if form.focus == Field::Create { return true }
if form.blocked(form.focus).is_some() {
if form.git["error"].is_string() {
sync_git(app, form, true);
}
return false;
}
match form.focus {
Field::Create => return true,
Field::Task => { form.child_active = false; }
Field::Worktree => {
form.draft.worktree = Some(!form.worktree());
form.draft.branch = None;
form.draft.new_branch = None;
}
_ => {
if form.child.is_none() {
reveal(app, form);
}
form.child_active = true;
}
}
false
}
fn set_project(form: &mut Form, project: Project) {
form.prepared_folder = None;
form.draft.project = project;
form.draft.worktree = None;
form.draft.branch = None;
form.draft.new_branch = None;
form.git_key = None;
}
fn set_machine(app: &mut App, form: &mut Form, machine: &str) {
if form.draft.machine == machine {
return;
}
form.projects
.insert(form.draft.machine.clone(), form.draft.project.clone());
form.draft.machine = machine.into();
let project = form.projects.get(machine).cloned().unwrap_or_else(|| {
if form.draft.what.engine == "terminal" {
Project::Folder(app.homes.get(machine).cloned().unwrap_or_default())
} else {
Project::New(String::new())
}
});
set_project(form, project);
form.models = Value::Null;
form.profiles = Value::Null;
form.draft.profile = None;
// A guest's harness runs on the owner's plans: a model chosen for another machine stays behind.
if app.fleet.shares.contains_key(machine) { form.draft.model = None }
form.resource_generation.clear();
crate::input::load_dsh(app, machine.into(), false);
refresh_form(app, form);
}
fn set_engine(form: &mut Form, engine: &str) {
form.modes.insert(
form.draft.what.engine.clone(),
form.draft.permission.clone(),
);
form.draft.what.engine = engine.into();
form.draft.permission = form
.modes
.get(engine)
.filter(|p| data::modes(engine).iter().any(|(id, _)| id == p))
.cloned()
.unwrap_or_else(|| "auto".into());
if engine == "terminal" {
form.draft.model = None;
form.draft.profile = None;
form.draft.worktree = Some(false);
if !matches!(form.draft.project, Project::Folder(_)) {
form.draft.project = Project::Folder(form.home.clone());
}
}
form.git_key = None;
}
fn step_into(app: &mut App, form: &mut Form, previous: Child, kind: Choice, initial: &str) {
form.trail.push(previous);
child(app, form, kind, initial);
form.child_active = true;
}
fn project_action(form: &Form, action: ProjectAction) -> Choice {
match action {
ProjectAction::Clone => Choice::Clone,
ProjectAction::New => Choice::NewFolder,
ProjectAction::Open => Choice::Folder(if let Project::Folder(path) = &form.draft.project {
path.clone()
} else { form.home.clone() }),
}
}
fn choose(app: &mut App, form: &mut Form) {
let Some(c) = form.child.take() else { return };
let query = c.picker.query.trim().to_string();
let id = c.picker.current_id().unwrap_or_default();
if !c.kind.editing() && (id.is_empty() || c.picker.current().is_some_and(|r| r.disabled)) {
form.child = Some(c);
return;
}
match &c.kind {
Choice::Agent | Choice::Compatible(_) => {
if let Some((dsh, _)) = id.strip_prefix("dsh:").and_then(|s| s.rsplit_once(':')) {
let dsh = dsh.to_string();
step_into(app, form, c, Choice::Compatible(dsh), "");
return;
}
let Some(engine) = id.strip_prefix("engine:") else {
form.child = Some(c);
return;
};
let dsh = if let Choice::Compatible(dsh) = &c.kind {
Some(dsh.clone())
} else {
None
};
set_engine(form, engine);
form.draft.what.dsh = dsh;
form.draft.what.label = theme::engine_label(engine).into();
}
Choice::Project => match id.as_str() {
"clone" | "new" | "folder" => {
let action = match id.as_str() {
"clone" => ProjectAction::Clone,
"new" => ProjectAction::New,
_ => ProjectAction::Open,
};
// The machine is chosen in its own field: Open, New and Clone act on it, never
// asking for a machine a second time.
let next = project_action(form, action);
step_into(app, form, c, next, "");
return;
}
_ => {
if let Some((machine, path)) =
id.strip_prefix("at:").or_else(|| id.strip_prefix("home:")).and_then(|s| s.split_once('\t'))
{
set_machine(app, form, machine);
set_project(form, Project::Folder(path.into()));
} else {
form.child = Some(c);
return;
}
}
},
Choice::Machine(action) => {
// A machine may disconnect after the list was drawn.
if !app.fleet.machines.iter().any(|m| m.id == id && m.usable()) {
form.error = "That machine is not connected".into();
form.child = Some(c);
return;
}
let action = *action;
set_machine(app, form, &id);
if let Some(action) = action {
let next = project_action(form, action);
step_into(app, form, c, next, "");
return;
}
}
Choice::Approvals => form.draft.permission = id,
Choice::Model => {
if id == "refresh" {
form.child = Some(c);
load_resource(app, form, true);
return;
} else if id == "subscription" {
form.draft.model = None
} else if let Ok(pair) = serde_json::from_str::<Vec<String>>(&id) {
if pair.len() != 2 {
form.child = Some(c);
return;
}
let node = form.models["grids"]
.as_array()
.into_iter()
.flatten()
.find(|g| g["name"].as_str() == Some(&pair[0]))
.and_then(|g| g["models"].as_array())
.into_iter()
.flatten()
.find(|m| m["id"].as_str() == Some(&pair[1]))
.and_then(|m| m["node"].as_str())
.unwrap_or("")
.to_string();
form.draft.model = Some((pair[0].clone(), pair[1].clone(), node));
} else {
form.child = Some(c);
return;
}
}
Choice::Profile => {
form.draft.profile = if id == "default" {
None
} else {
Some((
form.draft.machine.clone(),
id,
c.picker.current().unwrap().label.clone(),
))
}
}
Choice::Branch => {
if let Some(name) = id.strip_prefix("new:") {
form.draft.new_branch = Some(name.into());
} else {
form.draft.branch = Some(id);
form.draft.new_branch = None;
}
}
Choice::Folder(path) => match id.as_str() {
"use" => set_project(form, Project::Folder(path.clone())),
"up" => {
let parent = path
.rsplit_once('/')
.map(|(p, _)| if p.is_empty() { "/" } else { p })
.unwrap_or("/")
.to_string();
step_into(app, form, c, Choice::Folder(parent), "");
return;
}
_ => {
if let Some(name) = id.strip_prefix("dir:") {
let next = format!("{}/{name}", path.trim_end_matches('/'));
step_into(app, form, c, Choice::Folder(next), "");
return;
} else {
form.child = Some(c);
return;
}
}
},
Choice::Path => {
if query.starts_with('~') && form.home.is_empty() {
form.error = "Home is loading; enter an absolute path".into();
form.child = Some(c);
return;
}
let path = if query == "~" {
form.home.clone()
} else if let Some(rest) = query.strip_prefix("~/") {
format!("{}/{rest}", form.home)
} else {
query
};
if !crate::sys::path_absolute(&path) {
form.error = "Enter an absolute path or ~/folder".into();
form.child = Some(c);
return;
}
step_into(app, form, c, Choice::Folder(path), "");
return;
}
Choice::Clone => {
if query.is_empty() {
form.error = "Enter a GitHub URL or owner/repository".into();
form.child = Some(c);
return;
}
set_project(form, Project::Clone(query));
}
Choice::NewFolder => set_project(form, Project::New(query)),
}
form.child_active = false;
form.trail.clear();
// (Chosen from the task, by `@ : %`: back to writing it.)
if form.focus != Field::Task { form.focus = Field::Create; }
form.error.clear();
refresh_form(app, form);
sync_git(app, form, false);
}
/// `@ : %` typed where a word starts in the task: the chooser of that scope (the shell composer's
/// `@ computer`, `: project`, `% model`). Inside a word each is a letter.
fn scope_choice(form: &Form, ch: char) -> Option<Choice> {
let task = &form.draft.task;
let before = task.get(..form.task_editor.cursor).unwrap_or(task);
if !before.chars().next_back().is_none_or(char::is_whitespace) { return None }
match ch {
'@' => Some(Choice::Machine(None)),
':' => Some(Choice::Project),
'%' if form.fields().contains(&Field::Model) => Some(Choice::Model),
_ => None,
}
}
fn back(app: &mut App, form: &mut Form) -> bool {
if form.child_active {
if let Some(previous) = form.trail.pop() {
form.child = Some(previous);
if let Some(c) = &mut form.child {
if c.picker.busy.is_some() {
if let Choice::Folder(path) = &c.kind {
let path = path.clone();
c.generation = uuid::Uuid::new_v4().to_string();
load_folder(app, form, path);
}
}
}
} else {
form.child = None;
form.child_active = false;
}
form.error.clear();
true
} else if form.child.take().is_some() {
form.trail.clear();
true
} else {
false
}
}
pub fn key(app: &mut App, mut form: Box<Form>, key: KeyEvent) {
if key.code != KeyCode::Enter || key.modifiers.intersects(KeyModifiers::ALT | KeyModifiers::SHIFT) {
form.submit_after_git = false;
}
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
// → enters a field's choices; ← comes back out, once the query's cursor is at its start: a step
// back (a folder's parent list), else to the field, its choices still beside the form.
if key.code == KeyCode::Left && !ctrl && form.child_active && form.child.as_ref().is_some_and(|c| c.picker.qcursor == 0) {
if let Some(previous) = form.trail.pop() { form.child = Some(previous) }
else if form.focus == Field::Task { form.child = None; form.child_active = false }
else { form.child_active = false }
form.error.clear();
store_form(app, form);
return;
}
if key.code == KeyCode::Esc || (ctrl && matches!(key.code, KeyCode::Char('c' | 'g'))) {
if back(app, &mut form) {
store_form(app, form);
} else if matches!(form.surface, Surface::Window(_)) && form.draft.task.trim().is_empty() && !form.starting && form.attempt.is_none() && app.tabs.len() > 1 {
// The empty home window's form is not a modal you cancel with focus, it is the window
// itself: Esc closes the window and returns to the one it came from (tmux's last-window).
close_home_window(app, form);
} else {
if matches!(form.surface, Surface::Window(_)) && form.draft.task.trim().is_empty() && !form.starting && form.attempt.is_none() {
form.focus = Field::Task;
store_form(app, form);
return;
}
// A welcome page is a window, not a modal. First leave the task editor;
// then return to the previous window, keeping this window's draft intact.
let previous = (matches!(form.surface, Surface::Window(_)) && form.focus != Field::Task)
.then(|| app.last_tab().and_then(|id| app.tabs.iter().position(|tab| &tab.id == id)))
.flatten();
dismiss(app, form);
if let Some(index) = previous { app.select_tab(index); }
}
return;
}
if form.starting || key.kind == KeyEventKind::Repeat && key.code == KeyCode::Enter {
store_form(app, form);
return;
}
if form.attempt.is_some() {
let check = matches!(key.code, KeyCode::Enter | KeyCode::Char(' '));
store_form(app, form);
if check {
start(app);
}
return;
}
// → opens these rows as Enter does: they have no chooser to enter.
if !form.child_active && matches!(key.code, KeyCode::Enter | KeyCode::Char(' ') | KeyCode::Right)
&& matches!(form.focus, Field::Terminal | Field::Recent(_) | Field::Browse) {
return welcome::activate(app, form);
}
let mut launch = false;
let scope = match key.code {
KeyCode::Char(ch) if !form.child_active && form.focus == Field::Task
&& !key.modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT)
&& form.blocked(Field::Task).is_none() => scope_choice(&form, ch),
_ => None,
};
if let Some(kind) = scope {
// The chooser drops down under the task; Esc leaves the task as it was.
child(app, &mut form, kind, "");
form.child_active = true;
} else if !form.child_active && form.focus == Field::Task {
match key.code {
KeyCode::Tab | KeyCode::BackTab => {
form.move_by(match key.code { KeyCode::Up | KeyCode::BackTab => -1, _ => 1 });
reveal(app, &mut form);
}
KeyCode::Up | KeyCode::Down => {
if !form.task_editor.key(&mut form.draft.task, key, form.task_area.width.max(1) as usize) {
form.move_by(if key.code == KeyCode::Up { -1 } else { 1 });
reveal(app, &mut form);
}
}
KeyCode::Enter if !key.modifiers.intersects(KeyModifiers::ALT | KeyModifiers::SHIFT) => {
form.focus = Field::Create;
form.child = None;
// With a task, Enter starts it: the second Enter, on Start, was the step a newcomer
// stopped at (macOS VM, 2026-10-09). Without one it still steps to Start.
launch = !form.draft.task.trim().is_empty();
}
_ if form.blocked(Field::Task).is_none() => {
form.task_editor.key(&mut form.draft.task, key, form.task_area.width.max(1) as usize);
form.error.clear();
}
_ => {}
}
} else if form.child_active {
if let Some(c) = &mut form.child {
let editing = c.kind.editing();
match key.code {
KeyCode::Enter => choose(app, &mut form),
KeyCode::Tab | KeyCode::BackTab => {
form.child_active = false;
// (Opened from the task by `@ : %`: nothing stays open behind it.)
if form.focus == Field::Task {
form.child = None;
form.trail.clear();
}
}
KeyCode::Char('l') if ctrl && matches!(c.kind, Choice::Folder(_)) => {
let path = if let Choice::Folder(path) = &c.kind {
path.clone()
} else {
String::new()
};
let previous = form.child.take().unwrap();
step_into(app, &mut form, previous, Choice::Path, &path);
}
KeyCode::Up if !editing => c.picker.move_by(-1),
KeyCode::Down if !editing => c.picker.move_by(1),
KeyCode::PageUp if !editing => c.picker.move_by(-c.picker.page_rows.get().max(1)),
KeyCode::PageDown if !editing => c.picker.move_by(c.picker.page_rows.get().max(1)),
KeyCode::Char('p') if ctrl && !editing => c.picker.move_by(-1),
KeyCode::Char('n') if ctrl && !editing => c.picker.move_by(1),
KeyCode::Backspace => c.picker.backspace(false),
KeyCode::Delete => c.picker.delete_forward(),
KeyCode::Left => c.picker.qmove(-1, ctrl),
KeyCode::Right => c.picker.qmove(1, ctrl),
KeyCode::Char('b') if ctrl => c.picker.qmove(-1, false),
KeyCode::Char('f') if ctrl => c.picker.qmove(1, false),
KeyCode::Home | KeyCode::Char('a') if key.code == KeyCode::Home || ctrl => {
c.picker.qhome()
}
KeyCode::End | KeyCode::Char('e') if key.code == KeyCode::End || ctrl => {
c.picker.qend()
}
KeyCode::Char('u') if ctrl => c.picker.clear_query(),
KeyCode::Char('k') if ctrl => c.picker.kill_line(),
KeyCode::Char('w') if ctrl => c.picker.backspace(true),
KeyCode::Char('y') if ctrl => c.picker.yank(),
KeyCode::Char(ch)
if !key
.modifiers
.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) =>
{
c.picker.type_char(ch)
}
_ => {}
}
}
if form
.child
.as_ref()
.is_some_and(|c| c.kind == Choice::Branch)
{
refresh_form(app, &mut form);
}
} else {
match key.code {
KeyCode::Up => {
form.move_by(-1);
reveal(app, &mut form);
}
KeyCode::Down => {
form.move_by(1);
reveal(app, &mut form);
}
KeyCode::Tab | KeyCode::BackTab => {
form.move_by(if key.code == KeyCode::BackTab { -1 } else { 1 });
reveal(app, &mut form);
}
// The dialog's button row: ← → choose between Cancel and Start, as every dialog's
// buttons do; Enter on Cancel closes the form, as Esc does.
KeyCode::Left | KeyCode::Right if form.focus == Field::Create && !matches!(form.surface, Surface::Window(_)) => {
form.cancel_chosen = key.code == KeyCode::Left;
}
KeyCode::Enter | KeyCode::Char(' ') if form.focus == Field::Create && form.cancel_chosen => {
form.cancel_chosen = false;
dismiss(app, form);
return;
}
KeyCode::Enter | KeyCode::Char(' ') => launch = activate(app, &mut form),
KeyCode::Right if form.focus != Field::Create => {
activate(app, &mut form);
}
// ← steps back to the task, as in the command panel (→ in, ← back).
KeyCode::Left if matches!(form.focus, Field::Recent(_) | Field::Browse | Field::Terminal) => {
form.focus = Field::Task;
reveal(app, &mut form);
}
KeyCode::Left | KeyCode::PageUp | KeyCode::PageDown
if form.focus == Field::Worktree =>
{
activate(app, &mut form);
}
KeyCode::Char(ch)
if !key
.modifiers
.intersects(KeyModifiers::CONTROL | KeyModifiers::ALT) =>
{
if form.child.is_none() && form.focus != Field::Create {
reveal(app, &mut form);
}
if form.child.is_some() {
form.child_active = true;
form.child.as_mut().unwrap().picker.type_char(ch);
} else {
let field = match ch {
'a' => Some(Field::Agent),
'p' => Some(Field::Project),
't' => Some(Field::Task),
_ => None,
};
if let Some(field) = field {
form.focus = field;
activate(app, &mut form);
}
}
}
_ => {}
}
}
if form
.child
.as_ref()
.is_some_and(|c| c.kind == Choice::Branch)
{
refresh_form(app, &mut form);
}
store_form(app, form);
if launch {
start(app);
}
}
pub fn paste(form: &mut Form, text: &str) {
form.submit_after_git = false;
if form.starting || form.attempt.is_some() {
return;
}
if !form.child_active && form.focus == Field::Task {
if form.blocked(Field::Task).is_none() {
form.task_editor.insert(&mut form.draft.task, text);
form.error.clear();
}
return;
}
if let Some(c) = &mut form.child {
form.child_active = true;
let mut line_break = false;
for ch in text.chars() {
if matches!(ch, '\r' | '\n') {
if !line_break {
c.picker.type_char(' ');
}
line_break = true;
} else {
line_break = false;
if !ch.is_control() {
c.picker.type_char(ch);
}
}
}
}
}
pub fn mouse(app: &mut App, mouse: MouseEvent) {
let Some(mut form) = take_active(app) else { return };
if matches!(mouse.kind, MouseEventKind::Down(_) | MouseEventKind::ScrollUp | MouseEventKind::ScrollDown) {
form.submit_after_git = false;
}
let pos = Position::new(mouse.column, mouse.row);
let mut launch = false;
if !form.starting && form.attempt.is_some() {
if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
launch = form
.hits
.iter()
.any(|(r, field)| *field == Field::Create && r.contains(pos));
if !form.area.contains(pos) {
dismiss(app, form);
return;
}
}
} else if !form.starting {
if matches!(mouse.kind, MouseEventKind::ScrollUp | MouseEventKind::ScrollDown) && form.task_area.contains(pos) {
let delta = if mouse.kind == MouseEventKind::ScrollUp { -3 } else { 3 };
form.task_editor.scroll_by(&form.draft.task, form.task_area, delta);
} else if matches!(
mouse.kind,
MouseEventKind::ScrollUp | MouseEventKind::ScrollDown
) && form.child_area.contains(pos)
{
if let Some(c) = &mut form.child {
form.child_active = true;
let delta = if mouse.kind == MouseEventKind::ScrollUp {
-1
} else {
1
};
c.picker.move_by(delta as i64);
}
} else if mouse.kind == MouseEventKind::Down(MouseButton::Left) {
if form.cancel_area.contains(pos) {
// `[ Cancel ]`: as Esc closes the dialog, the draft kept for next time.
dismiss(app, form);
return;
}
if form.child.is_some() && form.child_area.contains(pos) {
form.child_active = true;
let c = form.child.as_mut().unwrap();
if let Some((_, index)) = c.picker.row_at.iter().find(|(y, _)| *y == mouse.row) {
c.picker.cursor = *index;
choose(app, &mut form);
}
} else if form.task_area.contains(pos) {
form.focus = Field::Task;
reveal(app, &mut form);
form.task_editor.click(&form.draft.task, form.task_area, pos);
} else if let Some((_, field)) = form.hits.iter().find(|(r, _)| r.contains(pos)) {
form.focus = *field;
if matches!(field, Field::Terminal | Field::Recent(_) | Field::Browse) {
return welcome::activate(app, form);
}
reveal(app, &mut form);
launch = activate(app, &mut form);
} else if !form.area.contains(pos) {
if !back(app, &mut form) {
dismiss(app, form);
return;
}
}
}
}
store_form(app, form);
if launch {
start(app);
}
}
/// Validate launch choices using the selected machine; no side effects occur while browsing.
pub fn start(app: &mut App) {
let Some(mut form) = take_active(app) else { return };
if form.starting {
store_form(app, form);
return;
}
if let Some(attempt) = form.attempt.clone() {
form.starting = true;
form.checking = true;
form.error.clear();
let id = form.id.clone();
store_form(app, form);
crate::input::check_creation(app, id, attempt);
return;
}
resolve_launch_machine(app, &mut form);
form.remember_choices = true;
form.launch_target = Some(crate::input::LaunchTarget { session: app.session_id, tab: app.tab().id.clone() });
let fail = if form.local_only && form.draft.what.engine != "terminal" {
Some("Run `harness start` to connect agents, then retry. Your task stays here.".into())
} else if let Some(error) = task::error(&form.draft.what.engine, &form.draft.task) {
form.focus = Field::Task;
Some(error)
} else if form.git_loading {
form.submit_after_git = true;
Some("Checking the project…".into())
} else if form.git["error"] == "OFFLINE" {
Some("That machine is not connected. Reconnect or choose another project.".into())
} else if form.git["error"].is_string() {
Some("Could not read this project. Choose Branch to retry.".into())
} else {
form.project_payload().err()
};
if let Some(error) = fail {
form.error = error;
store_form(app, form);
return;
}
let Some(link) = app.link(&form.draft.machine) else {
form.error = "That machine is not connected".into();
store_form(app, form);
return;
};
let id = form.id.clone();
let model = form.draft.model.is_some();
let profile = form.draft.what.engine == "codex"
&& form.draft.model.is_none()
&& form.draft.profile.is_some();
let package = form.draft.what.dsh.is_some();
if !model && !profile && !package {
launch(app, form);
return;
}
form.starting = true;
form.error.clear();
store_form(app, form);
app.spawn(async move{
let models=async{if model{link.rpc("grid_models_list",json!({"rowState":true}),Duration::from_secs(30)).await.ok()}else{None}};
let profiles=async{if profile{link.rpc("codex_profiles_list",json!({}),Duration::from_secs(20)).await.ok()}else{None}};
let packages=async{if package{link.rpc("dsh_list",json!({}),Duration::from_secs(20)).await.ok()}else{None}};
tokio::join!(models,profiles,packages)
},move|app,(models,profiles,packages)|{
let mut result=None;with_form(app,&id,|_,form|{form.starting=false;
if let Some((grid,id,_))=&form.draft.model{let expected=json!([grid,id]).to_string();if !data::model_rows(&models.unwrap_or(Value::Null),&form.draft.what.engine).iter().any(|r|r.id==expected&&!r.disabled){form.error="Model unavailable here. Choose a model or your subscription.".into();return}}
if profile{let (machine,path,_)=form.draft.profile.as_ref().unwrap();if machine!=&form.draft.machine{form.error="Choose a profile on this machine.".into();return}if !profiles.unwrap_or(Value::Null)["profiles"].as_array().into_iter().flatten().any(|p|p["path"].as_str()==Some(path)){form.error="Profile unavailable here. Choose another profile.".into();return}}
if let Some(dsh)=&form.draft.what.dsh{let catalog=packages.unwrap_or(Value::Null);let row=catalog["dsh"].as_array().into_iter().flatten().find(|r|r["id"].as_str()==Some(dsh));
let Some(row)=row else{form.error="This harness is unavailable on this machine. Choose an agent or harness.".into();return};
if row["installed"]==false{form.error="Install this harness from the Store first, then retry.".into();return}
let compatible=row["engines"].as_array().filter(|a|!a.is_empty()).map(|a|a.iter().any(|e|e.as_str()==Some(&form.draft.what.engine))).unwrap_or_else(||row["engine"].as_str().unwrap_or("claude")==form.draft.what.engine);
if !compatible{form.error="Choose a compatible coding agent for this harness.".into();return}
}result=Some(());
});
if result.is_some() { if let Some(form) = take_id(app, &id) { launch(app, form); } }
});
}
fn launch(app: &mut App, mut form: Box<Form>) {
let d = form.draft.clone();
let (cwd, mut extra) = match form.project_payload() {
Ok(v) => v,
Err(e) => {
form.error = e;
store_form(app, form);
return;
}
};
if d.what.engine == "terminal" && cwd.is_none() {
form.error = "Choose an existing folder for a terminal".into();
store_form(app, form);
return;
}
extra["permissionMode"] = Value::Null;
extra["bypassPermission"] = json!(false);
if !data::modes(&d.what.engine).is_empty() {
extra["permissionMode"] = json!(d.permission);
extra["bypassPermission"] = json!(matches!(d.permission.as_str(), "auto" | "full"));
}
if let Some((grid, id, _)) = &d.model {
extra["gridName"] = json!(grid);
extra["gridModel"] = json!(id);
}
if d.what.engine == "codex" && d.model.is_none() {
if let Some((_, path, _)) = &d.profile {
extra["codexHome"] = json!(path);
}
}
let id = form.id.clone();
let target = form.launch_target.clone();
store_form(app, form);
crate::input::create_opts(
app,
d.machine,
d.what,
cwd,
Some(d.task),
false,
crate::input::NewOpts {
extra: Some(extra),
form_id: Some(id),
target,
..Default::default()
},
);
}
/// Apply the daemon's receipt before deciding whether another launch is allowed.
/// A status check is read-only, even after a reconnect or a daemon upgrade.
pub fn creation_reply(
app: &mut App,
id: &str,
reply: &Result<Value, crate::daemon::RpcError>,
checking: bool,
) -> bool {
let mut created = false;
with_form(app, id, |app, form| {
let Some(attempt) = &form.attempt else { return };
let outcome = receipt::outcome(&attempt.id, reply, checking);
form.starting = false;
form.checking = false;
match outcome {
receipt::Outcome::Created => created = true,
receipt::Outcome::Failed {
message,
prepared_folder,
} => {
form.attempt = None;
form.error = message;
if let Some(path) = prepared_folder {
set_project(form, Project::Folder(path.clone()));
form.prepared_folder = Some(path);
form.draft.worktree = Some(false);
sync_git(app, form, true);
}
}
receipt::Outcome::Uncertain(message) => form.error = message,
}
});
created
}
pub fn created(app: &mut App, id: &str, agent: &Value) {
with_form(app, id, |_, form| {
if !matches!(form.draft.project, Project::Folder(_)) {
if let Some(cwd) = agent
.pointer("/project/cwd")
.or_else(|| agent.get("cwd"))
.and_then(Value::as_str)
{
form.draft.project = Project::Folder(cwd.into());
}
}
});
completed(app, id, None);
}
pub fn completed(app: &mut App, id: &str, error: Option<String>) {
let mut success = false;
with_form(app, id, |_, form| {
form.starting = false;
if let Some(error) = error {
form.error = error;
} else {
if form.remember_choices { remember(form); }
success = true;
}
});
if success {
if matches!(&app.modal,Some(Modal::NewHarness(f))if f.id==id) {
app.modal = None;
}
if app.new_harness_draft.as_ref().is_some_and(|f| f.id == id) {
app.new_harness_draft = None;
}
app.welcome.forms.retain(|_, f| f.id != id);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn terminal_is_an_action_not_an_agent_or_a_remembered_default() {
let rows = modal::new_what_rows(&[
json!({"id":"example/shell", "engine":"terminal", "name":"Shell"}),
json!({"id":"example/blender", "engine":"codex", "name":"Blender"}),
]);
assert!(!rows.iter().any(|row| row.id.contains("terminal") || row.id.contains("example/shell")));
assert!(rows.iter().any(|row| row.id == "engine:codex"));
assert!(rows.iter().any(|row| row.id == "dsh:example/blender:codex"));
for saved in [Value::Null, json!({"engine":"terminal", "label":"Terminal", "dsh":"old/shell"})] {
let what = saved_agent(&saved);
assert_eq!(what.engine, "opencode");
assert_eq!(what.label, "OpenCode");
assert!(what.dsh.is_none());
}
let what = saved_agent(&json!({"engine":"codex", "label":"Blender · Codex", "dsh":"example/blender"}));
assert_eq!(what.engine, "codex");
assert_eq!(what.label, "Blender · Codex");
assert_eq!(what.dsh.as_deref(), Some("example/blender"));
}
#[tokio::test]
async fn store_compatibility_choices_also_exclude_shells() {
let mut app = app();
app.dsh.insert("local".into(), vec![json!({"id":"example/blender", "engine":"codex", "engines":["terminal", "codex"]})]);
let rows = compatible_rows(&app, "local", "example/blender");
assert_eq!(rows.iter().map(|row| row.id.as_str()).collect::<Vec<_>>(), vec!["engine:codex"]);
}
#[test]
fn a_guest_starts_in_its_workspace_or_a_folder_the_owner_shares_and_browses_nothing_of_the_owners() {
let mut app = app();
app.fleet.shares.insert("dee".into(), crate::fleet::MachineShare { owner: "Dee".into(), email: "[email protected]".into(), team: false });
app.homes.insert("dee".into(), "/Users/Shared/HarnessGuests/hg_0/work".into());
app.guest_folders.insert("dee".into(), vec![("/Users/dee/code/app".into(), true), ("/Users/dee/docs".into(), false)]);
let draft = |machine: &str| Draft {
machine: machine.into(), what: saved_agent(&Value::Null), project: Project::New(String::new()), task: String::new(),
permission: "auto".into(), worktree: None, branch: None, new_branch: None, model: None, profile: None,
};
let rows = project_rows(&app, &draft("dee"), false);
assert_eq!(rows.iter().map(|r| (r.id.as_str(), r.label.as_str(), r.right.as_str())).collect::<Vec<_>>(), [
("home:dee\t/Users/Shared/HarnessGuests/hg_0/work", "My workspace", ""),
("at:dee\t/Users/dee/code/app", "/Users/dee/code/app", "you can edit it"),
("at:dee\t/Users/dee/docs", "/Users/dee/docs", "read only"),
]);
// This account's own machine still opens, makes and clones folders.
let own = project_rows(&app, &draft("local"), false);
assert!(own.iter().any(|r| r.id == "folder"));
}
#[test]
fn a_guest_starts_claude_code_or_codex_on_a_machine_shared_with_it_and_nothing_from_its_store() {
let mut app = app();
app.dsh.insert("dee".into(), vec![json!({"id":"example/blender", "engine":"codex", "name":"Blender"})]);
app.fleet.shares.insert("dee".into(), crate::fleet::MachineShare { owner: "Dee".into(), email: "[email protected]".into(), team: false });
let ids = |rows: Vec<Row>| rows.into_iter().map(|row| row.id).collect::<Vec<_>>();
assert_eq!(ids(agent_rows(&app, "dee")), ["engine:claude", "engine:codex"]);
// This account's own machines still offer every engine.
assert!(agent_rows(&app, "local").len() > 2);
}
/// A guest's harness runs on the owner's plans, and the owner's daemon lists a guest no models or
/// profiles (GUEST_NOT_ALLOWED): no Model or Profile is offered there, and none chosen goes along.
#[tokio::test]
async fn a_guest_is_offered_no_model_or_profile_on_a_machine_shared_with_it() {
let mut app = app();
app.fleet.machines.push(crate::fleet::Machine { shared: false, id: "dee".into(), name: "Dee's Mac".into(), local: false, status: "online".into(), reach: crate::fleet::Reach::Ready });
app.fleet.shares.insert("dee".into(), crate::fleet::MachineShare { owner: "Dee".into(), email: "[email protected]".into(), team: false });
open(&mut app, None, Some("/home/dev/repo".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
set_engine(&mut form, "codex");
assert!(form.fields().contains(&Field::Model) && form.fields().contains(&Field::Profile), "this computer's own");
form.draft.model = Some(("own-grid".into(), "qwen-35b".into(), "studio".into()));
set_machine(&mut app, &mut form, "dee");
assert!(!form.fields().contains(&Field::Model));
assert!(!form.fields().contains(&Field::Profile));
assert_eq!((form.draft.model.clone(), form.draft.profile.clone()), (None, None));
}
fn app() -> App {
let (sink, _) = tokio::sync::mpsc::unbounded_channel();
let mut app = App::new(19789, sink, (150, 42));
app.fleet.local_id = "local".into();
app.fleet.machines.push(crate::fleet::Machine { shared: false,
id: "local".into(),
name: "studio".into(),
local: true,
status: "online".into(),
reach: crate::fleet::Reach::Ready,
});
app.homes.insert("local".into(), "/home/dev".into());
app
}
/// Opening a chooser leaves the main form where it was, on a wide window and a narrow one.
#[tokio::test]
async fn the_form_stays_put_when_a_chooser_opens() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
for body in [Rect::new(0, 0, 150, 41), Rect::new(0, 0, 90, 30)] {
form.child = None;
draw(&mut Buffer::empty(body), body, &mut form);
let alone = form.area;
child(&mut app, &mut form, Choice::Agent, "codex");
draw(&mut Buffer::empty(body), body, &mut form);
assert_eq!(form.area, alone, "the form moved at {}x{}", body.width, body.height);
}
}
fn press(app: &mut App, code: KeyCode) {
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
key(app, form, KeyEvent::new(code, KeyModifiers::NONE));
}
fn form_of(app: &App) -> &Form {
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
form
}
#[tokio::test]
async fn a_chooser_drops_down_under_its_field_in_the_panels_style() {
let _l = crate::term_out::colours_lock();
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
form.focus = Field::Project;
child(&mut app, &mut form, Choice::Project, "");
let body = Rect::new(0, 0, 120, 36);
draw(&mut Buffer::empty(body), body, &mut form);
assert!(form.child_area.is_empty(), "arrowing onto a field drops nothing down");
form.child_active = true;
let mut buf = Buffer::empty(body);
draw(&mut buf, body, &mut form);
let at = form.hits.iter().find(|(_, f)| *f == Field::Project).unwrap().0;
assert_eq!(form.child_area.y, at.y + 1, "right under the Project row");
assert_eq!(form.child_area.intersection(form.area), form.child_area, "inside the form: no side panel");
assert!(form.task_area.intersection(form.child_area).is_empty(), "never over the Task line");
assert_eq!(buf[(form.child_area.x + 1, form.child_area.y)].symbol(), "›", "the query line first");
let rule: String = (form.child_area.x + 1..form.child_area.right() - 1).map(|x| buf[(x, form.child_area.y + 1)].symbol()).collect();
assert!(rule.contains('/') && rule.ends_with('─'), "the count rule: {rule}");
let keys: String = (form.child_area.x..form.child_area.right()).map(|x| buf[(x, form.child_area.bottom() - 1)].symbol()).collect();
assert!(keys.contains("↑↓ move") && keys.contains("esc back"), "the keys line: {keys}");
let c = crate::settings::chrome();
let (y, _) = form.child.as_ref().unwrap().picker.row_at[0];
// (Under NO_COLOR the chosen row has no band, only a modifier.)
assert_eq!(buf[(form.child_area.x + 3, y)].bg, c.selected.bg.unwrap_or(ratatui::style::Color::Reset), "the chosen row on the panel's band");
assert!(buf[(form.child_area.x + 3, y)].modifier.contains(c.selected.add_modifier));
// A chooser's error: in the dropdown, not again in the form's footer.
form.error = "That machine is not connected".into();
let mut buf = Buffer::empty(body);
draw(&mut buf, body, &mut form);
let text: String = buf.content().iter().map(|c| c.symbol()).collect();
assert_eq!(text.matches("That machine is not connected").count(), 1, "{text}");
}
#[test]
fn the_dropdown_says_what_it_waits_for_and_its_error_in_place_of_its_keys() {
use ratatui::widgets::StatefulWidget;
let mut picker = Picker::new("", "Search folders");
picker.busy = Some("Loading folders…".into());
let area = Rect::new(0, 0, 50, 6);
let mut buf = Buffer::empty(area);
let mut dropdown = view::Dropdown { editing: false, error: "That machine is not connected", chrome: crate::settings::chrome_with(true), cursor: None };
(&mut dropdown).render(area, &mut buf, &mut picker);
assert_eq!(dropdown.cursor, Some(Position::new(3, 0)), "the text cursor where the query starts");
let row = |y| (0..50).map(|x| buf[(x, y)].symbol()).collect::<String>();
assert!(row(0).starts_with(" › Search folders"), "{}", row(0));
assert!(row(1).starts_with(" 0/0 ─") && row(1).trim_end().ends_with("Loading folders…"), "{}", row(1));
assert!(row(2).trim().is_empty(), "no empty-list notice while it loads: {}", row(2));
assert_eq!(row(5).trim(), "That machine is not connected");
}
/// The dropdown drawn with the panel's line widgets is the dropdown the hand-drawn lines drew:
/// a list or a path being typed, loading, failed, every width up to 160, in a dark theme, a
/// light one and NO_COLOR.
#[test]
fn the_dropdown_draws_what_it_did_with_the_hand_drawn_lines() {
use crate::settings::oracle::{chromes, grounds, LONG};
use ratatui::widgets::StatefulWidget;
let _l = crate::term_out::colours_lock();
// (The spinner still, so the two draws a moment apart show the same frame.)
theme::begin_animation_frame(false);
let n = LONG.chars().count();
// (editing, query, its cursor, loading, the error)
let cases: [(bool, &str, usize, Option<&str>, &str); 7] = [
(false, "", 0, None, ""),
(false, "pro", 3, None, ""),
(false, LONG, n, None, ""),
(false, LONG, 0, None, ""),
(false, "", 0, Some("Loading folders…"), ""),
(false, "", 0, None, "That machine is not connected"),
(true, "~/code/api", 10, None, ""),
];
// (From 3 columns: narrower, the old query line drew its mark past the dropdown's padding,
// or past the dropdown; the widget keeps to its area. Wider ones in steps — every width the
// line widgets are checked at is too slow here.)
let widths = [3, 4, 5, 8, 23, 24, 25, 30, 40, 47, 64, 80, 96, 120, 159, 160];
for c in chromes() { for w in widths { for h in [1, 2, 3, 4, 6, 12] {
let area = Rect::new(2, 1, w, h);
// (Over cells already written: the dropdown clears what it covers and touches nothing else.)
let [_, ground] = grounds(Rect::new(0, 0, w + 4, h + 2));
{
for (editing, query, at, busy, error) in cases {
let make = || {
let mut p = Picker::new("", "Search projects");
p.set_rows((0..9).map(|i| crate::picker::Row::new(format!("p{i}"), format!("project-{i}")).right("~/code")).collect());
p.query = query.into();
p.refilter();
p.qcursor = at;
p.busy = busy.map(String::from);
p
};
let (mut a, mut b) = (make(), make());
let (mut old, mut new) = (ground.clone(), ground.clone());
let mut was = view::Dropdown { editing, error, chrome: crate::settings::Chrome { ..c }, cursor: None };
view::oracle::render(&mut was, area, &mut old, &mut a);
let mut now = view::Dropdown { editing, error, chrome: crate::settings::Chrome { ..c }, cursor: None };
(&mut now).render(area, &mut new, &mut b);
let what = format!("{w}x{h} editing {editing} {query:?} at {at} {busy:?} {error:?}");
assert_eq!(was.cursor, now.cursor, "{what}");
assert_eq!((a.xoffset.get(), a.prompt_at.get(), &a.row_at, a.page_rows.get()), (b.xoffset.get(), b.prompt_at.get(), &b.row_at, b.page_rows.get()), "{what}");
assert!(old == new, "{what}: the cells that differ, as drawn now: {:?}", old.diff(&new));
}
}
} } }
}
/// `@` in the task (or the Machine field) lists the machines; ↑ ↓ move through them and stay
/// where they were moved to through the refreshes that follow.
#[tokio::test]
async fn arrows_move_through_the_machines_at_lists() {
let mut app = app();
for (id, name) in [("lap", "laptop"), ("box", "gpu-box")] {
app.fleet.machines.push(crate::fleet::Machine { shared: false, id: id.into(), name: name.into(), local: false,
status: "online".into(), reach: crate::fleet::Reach::Ready });
}
open(&mut app, None, Some("/home/dev/project".into()));
press(&mut app, KeyCode::Char('@'));
fn current(app: &App) -> Option<String> { form_of(app).child.as_ref().and_then(|c| c.picker.current_id()) }
let first = current(&app);
press(&mut app, KeyCode::Down);
let second = current(&app);
assert_ne!(second, first, "↓ moves");
crate::new_harness::refresh(&mut app);
assert_eq!(current(&app), second, "a refresh keeps the row ↓ moved to");
press(&mut app, KeyCode::Up);
crate::new_harness::refresh(&mut app);
assert_eq!(current(&app), first, "↑ moves back");
}
#[tokio::test]
async fn at_colon_percent_in_the_task_open_their_choosers() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
for ch in "fix the login ".chars() { press(&mut app, KeyCode::Char(ch)); }
press(&mut app, KeyCode::Char('@'));
let f = form_of(&app);
assert_eq!(f.child.as_ref().map(|c| c.kind.clone()), Some(Choice::Machine(None)));
assert!(f.child_active);
assert_eq!(f.draft.task, "fix the login ", "the @ is not typed into the task");
press(&mut app, KeyCode::Esc);
let f = form_of(&app);
assert!(f.child.is_none());
assert_eq!((f.focus, f.draft.task.as_str()), (Field::Task, "fix the login "));
press(&mut app, KeyCode::Char('%'));
assert_eq!(form_of(&app).child.as_ref().map(|c| c.kind.clone()), Some(Choice::Model));
press(&mut app, KeyCode::Esc);
press(&mut app, KeyCode::Char(':'));
assert_eq!(form_of(&app).child.as_ref().map(|c| c.kind.clone()), Some(Choice::Project));
// The dropdown opens under the task, its text still in view.
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
let body = Rect::new(0, 0, 120, 36);
draw(&mut Buffer::empty(body), body, &mut form);
assert_eq!(form.child_area.y, form.task_area.bottom());
app.modal = Some(Modal::NewHarness(form));
press(&mut app, KeyCode::Esc);
// Tab leaves it as Esc does: no chooser left behind the task.
press(&mut app, KeyCode::Char('@'));
press(&mut app, KeyCode::Tab);
let f = form_of(&app);
assert_eq!((f.focus, f.child.is_none(), f.child_active), (Field::Task, true, false));
for ch in "a@b".chars() { press(&mut app, KeyCode::Char(ch)); }
assert!(form_of(&app).child.is_none());
assert_eq!(form_of(&app).draft.task, "fix the login a@b", "inside a word it is a letter");
}
#[tokio::test]
async fn a_task_the_agent_cannot_take_names_it_and_a_reopened_form_is_on_the_task() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
set_engine(&mut form, "terminal");
form.draft.what.label = "Terminal".into();
assert_eq!(form.blocked(Field::Task).as_deref(), Some("Not available for Terminal"));
set_engine(&mut form, "codex");
form.focus = Field::Model;
app.modal = Some(Modal::NewHarness(form));
press(&mut app, KeyCode::Esc);
assert!(app.modal.is_none());
open(&mut app, None, None);
let f = form_of(&app);
assert_eq!((f.focus, f.child.is_none(), f.child_active), (Field::Task, true, false));
}
#[tokio::test]
async fn local_shell_entry_does_not_override_the_registered_launch_machine() {
let mut app = app();
let shell = crate::local::MACHINE;
app.fleet.machines.insert(0, crate::fleet::Machine { shared: false,
id: shell.into(), name: "m0".into(), local: true,
status: "running".into(), reach: crate::fleet::Reach::Ready,
});
for explicit in [None, Some(shell.into())] {
open(&mut app, explicit, None);
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert_eq!(form.draft.machine, "local");
assert_eq!((form.project_name().as_str(), form.machine_label.as_str()), ("New Folder", app.fleet.local_machine_name().as_str()));
for rows in [modal::machine_rows(&app), modal::new_machine_rows(&app, shell)] {
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].id, "local");
assert_eq!(rows[0].label, "studio");
}
}
// Recent local-shell folders use that same machine and collapse duplicate paths.
for machine in [shell, "local"] {
let agent = crate::fleet::agent_from(machine, &json!({"id":"agent", "engine":"terminal", "project":{"cwd":"/home/dev/repo"}}), None);
app.fleet.agents.insert(agent.key(), agent);
}
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
let rows = project_rows(&app, &form.draft, true);
let recent: Vec<_> = rows.iter().filter(|r| r.id.starts_with("at:")).collect();
assert_eq!(recent.len(), 1);
assert_eq!(recent[0].id, "at:local\t/home/dev/repo");
assert_eq!(recent[0].label, format!("~/repo @ {}", app.fleet.local_machine_name()), "its machine by name, not '@ local'");
}
#[tokio::test]
async fn project_search_reaches_remote_machines_after_a_large_local_history() {
let mut app = app();
for name in ["office", "m2"] {
app.fleet.machines.push(crate::fleet::Machine { shared: false,
id: name.into(), name: name.into(), local: false,
status: "running".into(), reach: crate::fleet::Reach::Ready,
});
app.homes.insert(name.into(), "/home/dev".into());
}
for (machine, count) in [("local", 100), ("office", 1), ("m2", 1)] {
for i in 0..count {
let agent = crate::fleet::agent_from(machine, &json!({
"id": format!("agent-{i}"), "engine": "codex",
"project": {"cwd": format!("/home/dev/harnesses/autonomous-harness-2026-{i:03}")},
}), None);
app.fleet.agents.insert(agent.key(), agent);
}
}
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
// The projects are the chosen machine's (the Machine field picks it): this computer's own,
// at most fifty, and none of another machine's.
child(&mut app, &mut form, Choice::Project, "");
let recent = |form: &Form| form.child.as_ref().unwrap().picker.rows.iter().filter(|r| r.id.starts_with("at:")).map(|r| r.id.clone()).collect::<Vec<_>>();
assert_eq!(recent(&form).len(), 50);
assert!(recent(&form).iter().all(|id| !id.starts_with("at:office") && !id.starts_with("at:m2")));
// A large local history does not crowd out a remote machine's: chosen, its project is there.
for machine in ["office", "m2"] {
set_machine(&mut app, &mut form, machine);
child(&mut app, &mut form, Choice::Project, "");
assert_eq!(recent(&form), [format!("at:{machine}\t/home/dev/harnesses/autonomous-harness-2026-000")]);
let picker = &mut form.child.as_mut().unwrap().picker;
picker.set_query("harness");
let selected = picker.current().expect("the machine's project is searchable");
assert!(selected.label.ends_with(&format!(" @ {machine}")), "{}", selected.label);
assert!(!selected.disabled);
choose(&mut app, &mut form);
assert_eq!(form.draft.machine, machine);
assert!(matches!(&form.draft.project, Project::Folder(path) if path == "/home/dev/harnesses/autonomous-harness-2026-000"));
}
}
#[tokio::test]
async fn project_limits_count_unique_folders_per_machine_by_recent_activity() {
let mut app = app();
let shell = crate::local::MACHINE;
for (id, local) in [(shell, true), ("office", false)] {
app.fleet.machines.push(crate::fleet::Machine { shared: false,
id: id.into(), name: id.into(), local,
status: "running".into(), reach: crate::fleet::Reach::Ready,
});
}
for machine in ["local", "office"] {
for i in 0..70 {
let mut agent = crate::fleet::agent_from(machine, &json!({
"id": format!("agent-{i}"), "engine": "codex",
"project": {"cwd": format!("/home/dev/repo-{i:02}")},
}), None);
agent.updated_at = 1000 - i;
app.fleet.agents.insert(agent.key(), agent);
}
// Many sessions in the oldest folder make it most recent but use just one slot.
// A local shell is the same destination as its registered local daemon.
let source = if machine == "local" { shell } else { machine };
for i in 0..10 {
let mut agent = crate::fleet::agent_from(source, &json!({
"id": format!("duplicate-{i}"), "engine": "terminal",
"project": {"cwd": "/home/dev/repo-69"},
}), None);
agent.active_at = 2000 + i;
app.fleet.agents.insert(agent.key(), agent);
}
}
open(&mut app, None, None);
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
let rows = project_rows(&app, &form.draft, true);
for machine in ["local", "office"] {
let prefix = format!("at:{machine}\t");
let actual: Vec<_> = rows.iter().filter(|r| r.id.starts_with(&prefix)).map(|r| r.id.clone()).collect();
let expected: Vec<_> = std::iter::once(69).chain(0..49)
.map(|i| format!("at:{machine}\t/home/dev/repo-{i:02}")).collect();
assert_eq!(actual, expected);
}
assert!(!rows.iter().any(|r| r.id.starts_with(&format!("at:{shell}\t"))));
}
/// → enters a field's choices and ← comes back out (at the query's start), the choices still
/// shown beside the form; a typed query keeps ← for its cursor.
#[tokio::test]
async fn left_leaves_a_chooser_that_right_entered() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
form.focus = Field::Agent;
reveal(&mut app, &mut form);
app.modal = Some(Modal::NewHarness(form));
press(&mut app, KeyCode::Right);
assert!(form_of(&app).child_active, "→ enters the choices");
press(&mut app, KeyCode::Char('c'));
press(&mut app, KeyCode::Left);
assert!(form_of(&app).child_active, "← moves the query's cursor first");
press(&mut app, KeyCode::Left);
assert!(!form_of(&app).child_active, "← at the query's start comes back to the field");
assert_eq!(form_of(&app).focus, Field::Agent);
assert!(form_of(&app).child.is_some(), "its choices stay in view");
}
/// The dialog's Start is a button on its own line, in view at 80×24 whatever the agent's settings;
/// a click on it is Start.
#[tokio::test]
async fn the_dialog_ends_with_a_start_button_always_in_view() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
for engine in ["claude", "codex", "terminal"] {
set_engine(&mut form, engine);
let area = Rect::new(0, 0, 80, 24);
let mut buf = Buffer::empty(area);
view::draw(&mut buf, area, &mut form);
let text: Vec<String> = (0..area.height).map(|y| (0..area.width).map(|x| buf[(x, y)].symbol().to_string()).collect()).collect();
let label = form.describe(Field::Create).0;
assert!(text.iter().any(|l| l.contains(&format!("[ {label} ]"))), "{engine}: no Start button\n{}", text.join("\n"));
assert!(form.hits.iter().any(|(r, f)| *f == Field::Create && r.height == 1 && text[r.y as usize].contains("[ ")), "the button is its click target");
assert!(text.iter().any(|l| l.contains("[ Cancel ]")), "{engine}: no Cancel button");
assert!(form.cancel_area.width > 0 && text[form.cancel_area.y as usize].contains("[ Cancel ]"));
}
// A click on Cancel closes the form.
app.modal = Some(Modal::NewHarness(form));
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
let at = form.cancel_area;
mouse(&mut app, MouseEvent { kind: MouseEventKind::Down(MouseButton::Left), column: at.x + 2, row: at.y, modifiers: KeyModifiers::NONE });
assert!(!matches!(app.modal, Some(Modal::NewHarness(_))), "Cancel closes the form");
// And from the keyboard: on the buttons, ← chooses Cancel, → Start again, Enter presses it.
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
form.focus = Field::Create;
app.modal = Some(Modal::NewHarness(form));
press(&mut app, KeyCode::Left);
assert!(form_of(&app).cancel_chosen, "← chooses Cancel");
press(&mut app, KeyCode::Right);
assert!(!form_of(&app).cancel_chosen, "→ chooses Start");
press(&mut app, KeyCode::Left);
press(&mut app, KeyCode::Up);
press(&mut app, KeyCode::Down);
assert!(!form_of(&app).cancel_chosen, "coming back to the buttons, Start is chosen");
press(&mut app, KeyCode::Left);
let created = app.models_view.sent.len();
press(&mut app, KeyCode::Enter);
assert!(!matches!(app.modal, Some(Modal::NewHarness(_))), "Enter on Cancel closes the form");
assert_eq!(app.models_view.sent.len(), created, "and starts nothing");
}
/// A machine whose agents ran in scratch folders (a test matrix in /tmp) offered only those, and
/// starting in one was refused (FORBIDDEN: projects open under the home). Its home comes first,
/// and only folders under it are offered.
#[tokio::test]
async fn projects_offer_the_machine_home_and_only_folders_under_it() {
let mut app = app();
let ids: Vec<String> = app.fleet.machines.iter().map(|m| m.id.clone()).chain(["local".to_string()]).collect();
for id in ids { app.homes.insert(id, "/home/dev".into()); }
for (id, cwd) in [("a1", "/home/dev/repo"), ("a2", "/tmp/grid-matrix-out/agents/codex-1"), ("a3", "/private/tmp/scratch")] {
let agent = crate::fleet::agent_from("local", &json!({ "id": id, "engine": "codex", "project": { "cwd": cwd } }), None);
app.fleet.agents.insert(agent.key(), agent);
}
open(&mut app, None, None);
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
let rows = project_rows(&app, &form.draft, true);
let first_folder = rows.iter().find(|r| r.id.starts_with("at:") || r.id.starts_with("home:")).expect("a folder");
assert_eq!(first_folder.group.as_deref(), Some("Home"), "the home comes first");
assert!(first_folder.id.starts_with("home:") && first_folder.id.ends_with("\t/home/dev"));
assert!(rows.iter().any(|r| r.id.ends_with("\t/home/dev/repo")));
assert!(!rows.iter().any(|r| r.id.contains("tmp/")), "folders outside the home are not offered: {:?}", rows.iter().map(|r| &r.id).collect::<Vec<_>>());
}
#[tokio::test]
async fn project_search_keeps_the_short_local_machine_name_searchable() {
let mut app = app();
app.fleet.machine_mut("local").unwrap().name = "M2".into();
let agent = crate::fleet::agent_from("local", &json!({
"id": "agent", "engine": "codex", "project": {"cwd": "/home/dev/harnesses/repo"},
}), None);
app.fleet.agents.insert(agent.key(), agent);
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
child(&mut app, &mut form, Choice::Project, "");
let picker = &mut form.child.as_mut().unwrap().picker;
for query in ["m2 harness", "harness m2", "M2 harness", "local harness"] {
picker.set_query(query);
let selected = picker.current().expect("the real machine name and local both work");
assert_eq!(selected.id, "at:local\t/home/dev/harnesses/repo", "{query}");
assert_eq!(selected.label, "~/harnesses/repo @ M2", "the real machine name, not '@ local'");
assert!(picker.visible.iter().all(|(i, hits)| hits.iter().all(|at| (*at as usize) < picker.rows[*i].label.chars().count())));
}
}
#[tokio::test]
async fn daemon_return_redirects_an_idle_local_draft_but_keeps_a_pending_receipt() {
for pending in [false, true] {
let mut app = app();
let shell = crate::local::MACHINE;
app.fleet.machines.insert(0, crate::fleet::Machine { shared: false,
id: shell.into(), name: "m0".into(), local: true,
status: "running".into(), reach: crate::fleet::Reach::Ready,
});
app.homes.insert(shell.into(), "/home/dev".into());
app.fleet.machine_mut("local").unwrap().reach = crate::fleet::Reach::Offline;
open(&mut app, Some(shell.into()), Some("/home/dev/repo".into()));
let Some(Modal::NewHarness(form)) = &mut app.modal else { panic!() };
if pending {
form.attempt = Some(Creation { id: "original".into(), machine: shell.into(), session: app.session_id, target: None });
}
app.fleet.machine_mut("local").unwrap().reach = crate::fleet::Reach::Ready;
app.fleet.machine_mut("local").unwrap().name = "office".into();
refresh(&mut app);
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert_eq!(form.draft.machine, if pending { shell } else { "local" });
// The machine by its name, renamed with it — not "local".
assert_eq!((form.project_name().as_str(), form.machine_label.as_str()), ("repo", "office"));
if pending { assert_eq!(form.attempt.as_ref().unwrap().machine, shell); }
}
}
/// Up/Down move between the fields from the Task field (where the crop of the form lands),
/// so a user is not stuck using Tab alone — the task editor keeps Ctrl-P/Ctrl-N for its own
/// vertical cursor.
#[tokio::test]
async fn arrows_move_between_fields_from_the_task_field() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
assert_eq!(form.focus, Field::Task);
// Down leaves the Task field for the next one.
key(&mut app, form, KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert_eq!(form.focus, Field::Agent);
// Up brings it back.
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
key(&mut app, form, KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert_eq!(form.focus, Field::Task);
}
// The second Enter, on Start, was where a newcomer stopped (macOS VM, 2026-10-09).
#[tokio::test]
async fn enter_in_a_task_starts_it_and_an_empty_task_steps_to_start() {
let mut app = app();
let mut form = make_form(&mut app, Some(crate::local::MACHINE.into()), Some("/home/dev/project".into()), Surface::Dialog).unwrap();
key(&mut app, form, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
form = take_active(&mut app).unwrap();
assert_eq!(form.focus, Field::Create, "no task: Enter steps to Start");
assert!(form.attempt.is_none() && !form.starting);
form.focus = Field::Task;
form.draft.task = "make a small web page".into();
key(&mut app, form, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
let form = take_active(&mut app).unwrap();
assert!(form.attempt.is_some() || form.starting || !form.error.is_empty(), "the task was submitted");
}
// The home folder is nobody's project: a fresh Mac's first harness wrote into it.
#[tokio::test]
async fn the_home_folder_is_a_new_project_unless_the_harness_is_a_terminal() {
let mut app = app();
let home = crate::sys::home().display().to_string();
app.homes.insert(crate::local::MACHINE.into(), home.clone());
let form = make_form(&mut app, Some(crate::local::MACHINE.into()), Some(format!("{home}/")), Surface::Dialog).unwrap();
assert!(matches!(&form.draft.project, Project::New(name) if name.is_empty()), "{:?}", form.draft.project);
let form = make_form(&mut app, Some(crate::local::MACHINE.into()), Some(format!("{home}/work")), Surface::Dialog).unwrap();
assert!(matches!(&form.draft.project, Project::Folder(path) if path.ends_with("/work")));
let mut form = make_form(&mut app, Some(crate::local::MACHINE.into()), Some(home.clone()), Surface::Dialog).unwrap();
set_engine(&mut form, "terminal");
assert!(matches!(&form.draft.project, Project::Folder(path) if *path == home), "a shell still opens at home");
}
#[tokio::test]
async fn offline_submission_explains_recovery_and_preserves_the_task_on_both_surfaces() {
for window in [false, true] {
let mut app = app();
app.daemon_down = true;
app.fleet.machines[0].reach = crate::fleet::Reach::Offline;
app.tab_mut().home = window;
let surface = if window { Surface::Window(app.tab().id.clone()) } else { Surface::Dialog };
let mut form = make_form(&mut app, Some(crate::local::MACHINE.into()), Some("/home/dev/project".into()), surface).unwrap();
assert!(form.local_only);
form.draft.task = "Keep my offline task".into();
// One Enter with a task submits it, and says why it could not start.
key(&mut app, form, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
let form = take_active(&mut app).unwrap();
assert!(form.error.contains("harness start"));
assert!(form.error.contains("task stays here"));
assert_eq!(form.draft.task, "Keep my offline task");
assert!(!form.starting && form.attempt.is_none());
}
}
#[tokio::test]
async fn esc_closes_an_empty_home_window_form_and_returns_to_its_last_window() {
let mut app = app();
// A window new-window came from, then the empty home window it made.
let from = app.tab().id.clone();
app.new_tab();
app.tab_mut().home = true;
welcome::ensure(&mut app, None, Some("/home/dev/project".into()));
let home = app.tab().id.clone();
assert!(app.home_visible(), "the home window shows the form");
assert!(app.welcome.forms.contains_key(&home));
let Some(form) = app.welcome.forms.remove(&home) else { panic!() };
key(&mut app, form, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
// The draft is kept for when `new` reopens it; the empty window is gone.
assert!(app.new_harness_draft.is_some(), "the draft survives closing the window");
assert!(!app.tabs.iter().any(|t| t.id == home), "the empty home window is closed");
assert_eq!(app.tabs.len(), 1);
assert_eq!(app.tab().id, from, "returns to the window it came from");
}
#[tokio::test]
async fn esc_keeps_the_only_home_window_open() {
let mut app = app();
app.tab_mut().home = true;
welcome::ensure(&mut app, None, Some("/home/dev/project".into()));
let home = app.tab().id.clone();
assert_eq!(app.tabs.len(), 1);
let Some(form) = app.welcome.forms.remove(&home) else { panic!() };
key(&mut app, form, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
// The only window cannot close: the form stays and focus goes to the task.
assert!(app.welcome.forms.contains_key(&home));
assert!(app.new_harness_draft.is_none());
assert_eq!(app.welcome.forms[&home].focus, Field::Task);
}
#[tokio::test]
async fn draft_survives_picker_escape_and_late_refresh() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else {
panic!()
};
form.focus = Field::Agent;
child(&mut app, &mut form, Choice::Agent, "codex");
app.modal = Some(Modal::NewHarness(form));
refresh(&mut app);
let Some(Modal::NewHarness(form)) = app.modal.take() else {
panic!()
};
assert_eq!(form.child.as_ref().unwrap().picker.query, "codex");
key(
&mut app,
form,
KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE),
);
let Some(Modal::NewHarness(form)) = &app.modal else {
panic!()
};
assert!(form.child.is_none());
assert!(matches!(&form.draft.project, Project::Folder(p) if p == "/home/dev/project"));
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
key(&mut app, form, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE));
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
assert!(form.child_active);
key(&mut app, form, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
key(&mut app, form, KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE));
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert!(form.child_active);
assert_eq!(form.child.as_ref().unwrap().picker.query, "c");
app.modal = Some(Modal::Confirm {
prompt: "keep me".into(),
command: "".into(),
key: 'y',
enter_yes: false,
});
refresh(&mut app);
assert!(matches!(app.modal, Some(Modal::Confirm { .. })));
}
#[tokio::test]
async fn multiline_task_survives_editing_dismissal_and_agent_changes() {
let mut app = app();
open(&mut app, None, Some("/home/dev/project".into()));
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
form.focus = Field::Task;
assert!(!activate(&mut app, &mut form));
paste(&mut form, "Fix café\r\n\r\nKeep 界 and 🦀 intact.");
let expected = "Fix café\n\nKeep 界 and 🦀 intact.";
assert_eq!(form.draft.task, expected);
key(&mut app, form, KeyEvent::new(KeyCode::Enter, KeyModifiers::ALT));
let Some(Modal::NewHarness(form)) = app.modal.take() else { panic!() };
assert_eq!(form.draft.task, format!("{expected}\n"));
// Escape dismisses the form, preserving the inline task.
key(&mut app, form, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
assert_eq!(form.draft.task, format!("{expected}\n"));
set_engine(&mut form, "terminal");
assert!(task::error(&form.draft.what.engine, &form.draft.task).is_some());
assert!(form.blocked(Field::Task).is_none(), "a retained task can still be cleared");
set_engine(&mut form, "claude");
reveal(&mut app, &mut form);
assert!(form.child.is_none());
assert_eq!(form.focus, Field::Task);
assert_eq!(form.draft.task, format!("{expected}\n"));
}
/// What the settle rewrite keeps as the form's overlay: the form, and the chooser dropped down
/// from a field.
#[tokio::test]
async fn the_drawn_area_takes_in_a_chooser() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
let area = Rect::new(0, 0, 150, 42);
draw(&mut Buffer::empty(area), area, &mut form);
assert_eq!(form.drawn_area(), form.area, "no chooser: the form");
form.focus = Field::Project;
child(&mut app, &mut form, Choice::Project, "");
form.child_active = true;
draw(&mut Buffer::empty(area), area, &mut form);
assert!(!form.child_area.is_empty(), "the chooser drops down");
assert_eq!(form.drawn_area(), form.area.union(form.child_area));
form.child = None;
draw(&mut Buffer::empty(area), area, &mut form);
assert_eq!(form.drawn_area(), form.area, "the chooser closed");
}
#[tokio::test]
async fn compact_form_and_dropdown_choosers_stay_anchored_at_every_terminal_size() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else {
panic!()
};
for width in [
1, 10, 21, 22, 45, 80, 109, 110, 120, 128, 130, 131, 132, 150, 220,
] {
for height in [1, 4, 5, 10, 14, 24, 42] {
let area = Rect::new(3, 2, width, height);
let mut anchor = None;
for engine in ["claude", "codex", "terminal"] {
set_engine(&mut form, engine);
let choosers = [None, Some(Choice::Agent), Some(Choice::Clone), Some(Choice::Path), None];
// (Under the task, and under a field below it.)
for (focus, chooser) in [Field::Task, Field::Agent].into_iter().flat_map(|f| choosers.clone().map(|c| (f, c))) {
form.focus = focus;
if let Some(kind) = chooser {
let text = "/home/dev/项目";
child(&mut app, &mut form, kind, text);
} else {
form.child = None;
}
for active in [false, true] {
form.child_active = active;
let mut buf = Buffer::empty(area);
if let Some(cursor) = draw(&mut buf, area, &mut form) {
assert!(active || form.focus == Field::Task, "only the task or an active chooser takes the cursor");
assert!(area.contains(cursor), "{area:?} {cursor:?}");
}
for (hit, _) in &form.hits {
assert_eq!(hit.intersection(area), *hit);
}
if form.area.width > 0 {
// The form's panel: its own height, one size and place whatever is open.
assert_eq!(form.area, crate::settings::area(area, crate::settings::PanelSize::Form, view::HEIGHT));
assert!(form.area.width <= 60 && form.area.height <= view::HEIGHT);
let left = form.area.x - area.x;
let right = area.right() - form.area.right();
assert!(left.abs_diff(right) <= 1, "not centered in {area:?}");
let top = form.area.y - area.y;
let bottom = area.bottom() - form.area.bottom();
assert!(top.abs_diff(bottom) <= 1, "not centered in {area:?}");
assert_eq!(
*anchor.get_or_insert(form.area),
form.area,
"form moved in {area:?}: engine={engine}, active={active}"
);
assert_eq!(form.area.intersection(area), form.area);
}
if form.child_area.width > 0 {
assert_eq!(form.child_area.intersection(area), form.child_area);
if form.child_area.x >= form.area.right() {
// Room beside the form (as before 0.1.17): the choices stand there,
// entered or not, and the form stays whole.
assert!(form.child_area.intersection(form.area).is_empty(), "beside, not over the form in {area:?}");
} else {
assert!(active, "where there is no room beside, a chooser drops down only when entered");
assert_eq!(form.child_area.intersection(form.area), form.child_area, "inside the form when narrow");
if form.child_area != form.area && focus != Field::Task {
assert!(form.task_area.intersection(form.child_area).is_empty(), "over the task in {area:?}");
}
}
}
if width >= 150 && height >= 24 && form.child.is_some() {
assert!(form.child_area.x >= form.area.right(), "a wide terminal shows the choices beside the form ({area:?})");
}
if width >= 80 && height >= 24 && form.child_area != form.area {
assert_eq!(form.hits.len(), form.fields().len(), "all settings stay visible");
}
}
}
}
}
}
}
#[tokio::test]
async fn project_chooser_keeps_the_selected_row_visible_past_the_action_separator() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
child(&mut app, &mut form, Choice::Project, "");
form.child_active = true;
let mut rows = vec![Row::new("clone", "Clone Repository"), Row::new("folder", "Open Folder"), Row::new("new", "New Folder")];
rows.extend((0..50).map(|n| Row::new(format!("at:local\t/project-{n}"), format!("project-{n} @ local"))));
form.child.as_mut().unwrap().picker.set_rows(rows);
for width in [80, 150] {
let area = Rect::new(0, 0, width, 42);
let count = form.child.as_ref().unwrap().picker.visible.len();
for cursor in (0..count).chain((0..count).rev()) {
form.child.as_mut().unwrap().picker.cursor = cursor;
draw(&mut Buffer::empty(area), area, &mut form);
let picker = &form.child.as_ref().unwrap().picker;
assert!(picker.row_at.iter().any(|(_, row)| *row == cursor), "selected row {cursor} is hidden at width {width}");
}
}
}
#[tokio::test]
async fn terminal_resize_before_its_input_event_keeps_the_form_and_choosers_in_frame() {
for choice in [None, Some(Choice::Agent), Some(Choice::Path)] {
let mut app = app();
open(&mut app, None, None);
if let Some(kind) = choice {
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
child(&mut app, &mut form, kind, "");
app.modal = Some(Modal::NewHarness(form));
}
// The backend has already resized, but no Resize input event has been delivered.
for (width, height) in [(80, 24), (45, 14), (22, 5), (1, 1), (150, 42)] {
let mut terminal = ratatui::Terminal::new(
ratatui::backend::TestBackend::new(width, height),
).unwrap();
terminal.draw(|frame| crate::ui::draw(frame, &mut app)).unwrap();
let bounds = Rect::new(0, 0, width, height);
let Some(Modal::NewHarness(form)) = &app.modal else { panic!() };
assert_eq!(form.area.intersection(bounds), form.area);
assert_eq!(form.child_area.intersection(bounds), form.child_area);
assert!(form.hits.iter().all(|(hit, _)| hit.intersection(bounds) == *hit));
}
}
}
#[tokio::test]
async fn project_error_keeps_its_recovery_instruction_and_action_visible() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut form)) = app.modal.take() else { panic!() };
form.focus = Field::Create;
form.error = "Could not start it: “My-First-Claude-Project” already exists. Select that folder from your projects.".into();
for width in [45, 80, 130] {
let area = Rect::new(0, 0, width, 38);
let mut buf = Buffer::empty(area);
draw(&mut buf, area, &mut form);
let text: String = (form.area.y..form.area.bottom()).map(|y| {
(form.area.x + 2..form.area.right() - 2)
.map(|x| buf[(x, y)].symbol()).collect::<String>().trim().to_string()
}).collect::<Vec<_>>().join(" ");
assert!(text.contains("already exists. Select that folder from your projects."), "{text}");
assert!(form.hits.iter().any(|(_, f)| *f == Field::Create));
assert_eq!(form.area.intersection(area), form.area);
}
form.error = "项目".repeat(100);
for height in [5, 10, 24] {
let area = Rect::new(0, 0, 22, height);
let mut buf = Buffer::empty(area);
draw(&mut buf, area, &mut form);
assert_eq!(form.area.intersection(area), form.area);
assert!(form.hits.iter().any(|(_, f)| *f == Field::Create));
}
}
#[tokio::test]
async fn terminal_and_agent_options_match_the_launch_contract() {
let mut app = app();
open(&mut app, None, Some("/home/dev/repo".into()));
let Some(Modal::NewHarness(mut f)) = app.modal.take() else {
panic!()
};
assert_eq!(f.draft.what.engine, "opencode");
assert_eq!(f.draft.permission, "auto");
// Exercise remembered per-engine choices independently of the launch default.
set_engine(&mut f, "codex");
f.draft.permission = "readOnly".into();
set_engine(&mut f, "claude");
assert_eq!(f.draft.permission, "auto");
f.draft.permission = "plan".into();
set_engine(&mut f, "codex");
assert_eq!(f.draft.permission, "readOnly");
set_engine(&mut f, "terminal");
assert!(!f.fields().contains(&Field::Approvals));
assert!(!f.fields().contains(&Field::Model));
assert!(!f.fields().contains(&Field::Profile));
child(&mut app, &mut f, Choice::Clone, "");
f.child_active = true;
paste(&mut f, "owner/\r\nrepository");
assert_eq!(f.child.as_ref().unwrap().picker.query, "owner/ repository");
}
#[tokio::test]
async fn submitting_during_git_discovery_can_be_cancelled_without_losing_the_draft() {
for action in ["escape", "arrow", "typing", "paste", "dismiss", "account"] {
let mut app = app();
open(&mut app, None, Some("/home/dev/repo".into()));
let Some(Modal::NewHarness(f)) = &mut app.modal else { panic!() };
f.git_loading = true;
f.draft.task = "Keep this task".into();
start(&mut app);
let Some(Modal::NewHarness(f)) = app.modal.take() else { panic!() };
assert!(f.submit_after_git);
assert!(!f.starting && f.attempt.is_none());
key(&mut app, f, KeyEvent::new_with_kind(KeyCode::Enter, KeyModifiers::NONE, KeyEventKind::Repeat));
let Some(Modal::NewHarness(mut f)) = app.modal.take() else { panic!() };
assert!(f.submit_after_git, "holding Enter keeps one pending submission");
match action {
"paste" => { paste(&mut f, " more"); store_form(&mut app, f); }
"dismiss" => dismiss(&mut app, f),
"account" => {
let machine = f.draft.machine.clone();
store_form(&mut app, f);
account_changed(&mut app, Some(&machine), "signed-in-local");
}
action => key(&mut app, f, KeyEvent::new(match action {
"escape" => KeyCode::Esc, "arrow" => KeyCode::Down, _ => KeyCode::Char('!'),
}, KeyModifiers::NONE)),
}
let f = if let Some(Modal::NewHarness(f)) = &app.modal { f } else { app.new_harness_draft.as_ref().unwrap() };
assert!(!f.submit_after_git, "{action} must cancel pending submission");
assert!(f.draft.task.contains("Keep this task"));
}
}
#[tokio::test]
async fn delayed_callbacks_only_update_their_own_dismissed_draft() {
let mut app = app();
open(&mut app, None, Some("/home/dev/repo".into()));
let Some(Modal::NewHarness(f)) = app.modal.take() else {
panic!()
};
let id = f.id.clone();
key(&mut app, f, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
assert!(app.modal.is_none());
app.modal = Some(Modal::Confirm {
prompt: "stay here".into(),
command: "".into(),
key: 'y',
enter_yes: false,
});
with_form(&mut app, &id, |_, f| f.error = "late error".into());
assert!(matches!(app.modal, Some(Modal::Confirm { .. })));
assert_eq!(app.new_harness_draft.as_ref().unwrap().error, "late error");
with_form(&mut app, "stale-id", |_, _| panic!("wrong draft"));
}
#[tokio::test]
async fn uncertain_launch_keeps_its_machine_and_choices_until_confirmed() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut f)) = app.modal.take() else {
panic!()
};
let id = f.id.clone();
f.attempt = Some(Creation {
id: "intent".into(),
machine: "local".into(),
session: 0,
target: None,
});
app.modal = Some(Modal::NewHarness(f));
assert!(!creation_reply(
&mut app,
&id,
&Err(crate::daemon::RpcError::new("TIMEOUT", "")),
false
));
let Some(Modal::NewHarness(f)) = app.modal.take() else {
panic!()
};
key(
&mut app,
f,
KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE),
);
let Some(Modal::NewHarness(f)) = app.modal.take() else {
panic!()
};
assert!(
f.child.is_none(),
"choices cannot change an unresolved launch"
);
key(&mut app, f, KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
// Even an explicit new destination must recover the existing attempt first.
open(&mut app, Some("local".into()), Some("/another".into()));
let Some(Modal::NewHarness(f)) = &app.modal else {
panic!()
};
assert_eq!(f.id, id);
assert_eq!(f.describe(Field::Create).0, "Check status");
assert!(!creation_reply(
&mut app,
&id,
&Ok(json!({"creationId":"wrong", "state":"created", "agent":{"id":"wrong"}})),
true
));
assert!(creation_reply(
&mut app,
&id,
&Ok(json!({"creationId":"intent", "state":"created", "agent":{"id":"original"}})),
true
));
}
#[tokio::test]
async fn confirmed_failure_reuses_prepared_worktree_without_preparing_another() {
let mut app = app();
open(&mut app, None, None);
let Some(Modal::NewHarness(mut f)) = app.modal.take() else {
panic!()
};
let id = f.id.clone();
f.attempt = Some(Creation {
id: "intent".into(),
machine: "local".into(),
session: 0,
target: None,
});
app.modal = Some(Modal::NewHarness(f));
assert!(!creation_reply(
&mut app,
&id,
&Ok(
json!({"creationId":"intent", "state":"failed", "failure":{"code":"ENGINE_UNAVAILABLE"}, "preparedFolder":"/repo/worktree"})
),
true
));
let Some(Modal::NewHarness(f)) = &mut app.modal else {
panic!()
};
assert!(
f.attempt.is_none(),
"a new deliberate retry gets a fresh receipt"
);
f.git = json!({"isGit":true, "branch":"feature", "defaultRef":"refs/heads/main"});
assert_eq!(
f.project_payload().unwrap(),
(Some("/repo/worktree".into()), json!({}))
);
set_project(f, Project::Folder("/another".into()));
assert!(f.prepared_folder.is_none());
}
#[test]
fn home_abbreviation_requires_a_path_boundary() {
assert_eq!(short_path("/home/dev/project", "/home/dev"), "~/project");
assert_eq!(
short_path("/home/developer/project", "/home/dev"),
"/home/developer/project"
);
}
}