Terminal client: steer server chats and the factory

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Richard ZinkandClaude Sonnet 5.5 committed 2026-11-19 13:42:49 +01:00
1 parent 6eb29ca19d
commit 73684253ce
6 files changed
+604 -7

No files matched your search

+306 -7
View File
@@ -3,6 +3,7 @@
use crate::agent::{Env, Reply, UiEvent};
use crate::editor::Editor;
use crate::i18n::t;
use crate::remote::{self, Remote, Snapshot};
use crate::session::LocalSession;
use crate::theme::{self, Theme};
use anyhow::Result;
@@ -61,6 +62,11 @@ enum PickKind {
Permission,
Effort,
Lang,
/// Chats of the server.
Remote,
/// Issues of the factory board / the actions for one issue.
FactoryIssue,
FactoryAction,
}
struct Picker {
@@ -129,6 +135,14 @@ pub struct App {
/// Running setup action (login / provider test): Ok(message) or error.
pending_setup: Option<oneshot::Receiver<Result<String>>>,
pending_env: Option<oneshot::Receiver<Result<Env>>>,
/// A chat of the server that this terminal follows (instead of the local session).
remote: Option<Remote>,
pending_snapshot: Option<oneshot::Receiver<Result<Snapshot>>>,
pending_open: Option<oneshot::Receiver<Result<Remote>>>,
pending_pick: Option<oneshot::Receiver<Result<(PickKind, String, Vec<(String, String, String)>)>>>,
pending_note: Option<oneshot::Receiver<Result<String>>>,
/// The factory issue ("repo#number") whose actions are open.
factory_key: String,
}
const SPINNER: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -317,6 +331,12 @@ impl App {
pending_detect: None,
pending_setup: None,
pending_env: None,
remote: None,
pending_snapshot: None,
pending_open: None,
pending_pick: None,
pending_note: None,
factory_key: String::new(),
};
app.rebuild_items();
app
@@ -446,6 +466,10 @@ impl App {
return;
}
let text = self.expand_command(&trimmed).unwrap_or(trimmed);
if self.remote.is_some() {
self.send_remote(text);
return;
}
if self.busy {
self.queue.push_back(text);
self.status = format!("{} ({})", t("queued"), self.queue.len());
@@ -527,6 +551,9 @@ impl App {
("setup", "add model providers or sign in to a server"),
("memory", "show the project memory"),
("jobs", "automations on the server"),
("projects", "chats on the server: open and steer them"),
("factory", "software factory of the server: board and actions"),
("local", "back to a local chat"),
("quit", "exit"),
]
}
@@ -545,6 +572,21 @@ impl App {
}
self.dialog = Dialog::Text { title: t("help").into(), body };
}
"projects" | "server" => self.fetch_pick(PickKind::Remote),
"factory" if arg == "check" => {
if let Some(server) = self.env.server.clone() {
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::factory_poll(&server).await);
});
self.pending_note = Some(rx);
} else {
self.items.push(Item::Error("not signed in to a server".into()));
}
}
"factory" => self.fetch_pick(PickKind::FactoryIssue),
"local" => self.leave_remote(),
"model" | "mode" | "permissions" | "effort" if self.remote.is_some() => self.items.push(Item::Info("this chat runs on the server – change this in the web interface (/local returns to a local chat)".into())),
"model" => self.open_picker(PickKind::Model),
"mode" => {
if arg.is_empty() {
@@ -558,7 +600,18 @@ impl App {
"theme" => self.open_picker(PickKind::Theme),
"lang" => self.open_picker(PickKind::Lang),
"resume" | "sessions" => self.open_picker(PickKind::Session),
"compact" if self.remote.is_some() => {
if let (Some(server), Some(r)) = (self.env.server.clone(), &self.remote) {
let id = r.id.clone();
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::compact(&server, &id).await.map(|_| "compacting on the server…".to_string()));
});
self.pending_note = Some(rx);
}
}
"new" | "clear" => {
self.remote = None;
let _ = self.cmd.send(Cmd::New);
self.session = LocalSession::new(&self.session.cwd, &self.session.model, &self.session.mode, &self.session.permission_mode);
self.items.clear();
@@ -638,6 +691,7 @@ impl App {
PickKind::Effort => ("Effort".into(), ["low", "medium", "high", "max"].iter().map(|e| (e.to_string(), e.to_string(), "next message only".into())).collect()),
PickKind::Theme => (t("choose_theme").into(), theme::names().into_iter().flat_map(|n| ["auto", "dark", "light"].map(|m| (format!("{n}:{m}"), format!("{n} ({m})"), String::new()))).collect()),
PickKind::Lang => ("Language".into(), vec![("en".into(), "English".into(), String::new()), ("de".into(), "Deutsch".into(), String::new())]),
PickKind::Remote | PickKind::FactoryIssue | PickKind::FactoryAction => return,
PickKind::Session => (
t("choose_session").into(),
crate::session::list(None)
@@ -682,6 +736,12 @@ impl App {
cfg.lang = Some(key);
let _ = cfg.save();
}
PickKind::Remote => self.open_remote(&key),
PickKind::FactoryIssue => {
self.factory_key = key.clone();
self.fetch_actions(&key);
}
PickKind::FactoryAction => self.factory_action(&key),
PickKind::Session => {
if let Ok(s) = LocalSession::load(&key) {
self.session = s.clone();
@@ -694,6 +754,245 @@ impl App {
}
}
// --- server: remote chats and the factory ----------------------------------------------
fn abort_current(&mut self) {
if let (Some(server), Some(r)) = (self.env.server.clone(), &self.remote) {
let id = r.id.clone();
tokio::spawn(async move {
let _ = remote::abort(&server, &id).await;
});
} else if let Some(c) = &self.cancel {
c.cancel();
}
}
/// Fetch the entries of a server picker in the background; the picker opens when they arrive.
fn fetch_pick(&mut self, kind: PickKind) {
let Some(server) = self.env.server.clone() else {
self.items.push(Item::Error("not signed in to a server – run: codecraft login".into()));
return;
};
let (tx, rx) = oneshot::channel();
self.status = "loading…".into();
tokio::spawn(async move {
let res = match kind {
PickKind::Remote => remote::sessions(&server).await.map(|items| (kind, "Chats on the server".to_string(), items)),
_ => remote::factory_board(&server).await.map(|(summary, items)| (kind, summary, items)),
};
let _ = tx.send(res);
});
self.pending_pick = Some(rx);
}
fn fetch_actions(&mut self, key: &str) {
let Some(server) = self.env.server.clone() else { return };
let key = key.to_string();
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::factory_actions(&server, &key).await.map(|(title, acts)| (PickKind::FactoryAction, title, acts)));
});
self.pending_pick = Some(rx);
}
fn factory_action(&mut self, action: &str) {
if let Some(id) = action.strip_prefix("chat:") {
self.open_remote(id);
return;
}
let Some(server) = self.env.server.clone() else { return };
let (key, action) = (self.factory_key.clone(), action.to_string());
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::factory_do(&server, &key, &action).await);
});
self.pending_note = Some(rx);
}
fn open_remote(&mut self, id: &str) {
let Some(server) = self.env.server.clone() else { return };
let id = id.to_string();
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::open(&server, &id).await);
});
self.pending_open = Some(rx);
}
fn leave_remote(&mut self) {
if self.remote.take().is_some() {
self.items.clear();
self.todos = Value::Null;
self.busy = false;
self.rebuild_items();
self.status = "local chat".into();
}
}
fn send_remote(&mut self, text: String) {
let (Some(server), Some(r)) = (self.env.server.clone(), &self.remote) else { return };
let id = r.id.clone();
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::prompt(&server, &id, &text).await.map(|_| String::new()));
});
self.pending_note = Some(rx);
self.busy = true;
self.busy_since = Instant::now();
self.scroll = 0;
}
/// Items of messages (shared by the local and the remote view).
fn items_of(messages: &[codecraft_core::types::Message], open: &std::collections::HashSet<String>) -> Vec<Item> {
let mut items = Vec::new();
for m in messages {
for p in &m.parts {
match (&m.role, p) {
(Role::User, Part::Text { text }) => items.push(Item::User(text.clone(), 0)),
(Role::User, Part::Summary { .. }) => items.push(Item::Info("— conversation compacted —".into())),
(_, Part::Text { text }) => items.push(Item::Assistant(text.clone())),
(_, Part::Reasoning { text, .. }) if !text.trim().is_empty() => items.push(Item::Thinking(text.clone(), false)),
(_, Part::ToolCall { id, name, input, .. }) => items.push(Item::Tool { id: id.clone(), name: name.clone(), title: tool_title(name, input), state: ToolState::Running, output: String::new(), diff: None, open: open.contains(id) }),
(_, Part::ToolResult { call_id, content, is_error, meta, .. }) => {
if let Some(Item::Tool { state, output, diff, .. }) = items.iter_mut().rev().find(|i| matches!(i, Item::Tool { id, .. } if id == call_id)) {
*state = if *is_error { ToolState::Err } else { ToolState::Ok };
*output = content.clone();
*diff = meta.as_ref().and_then(|m| m["diff"].as_str().map(String::from));
}
}
_ => {}
}
}
}
items
}
/// Poll the followed server chat every ~1.5 s and take up the results of background requests.
fn poll_remote(&mut self) {
if let Some(rx) = &mut self.pending_pick {
if let Ok(res) = rx.try_recv() {
self.pending_pick = None;
self.status.clear();
match res {
Ok((kind, title, items)) if items.is_empty() => {
let _ = kind;
self.items.push(Item::Info(format!("{title}: nothing to show")));
}
Ok((kind, title, items)) => self.dialog = Dialog::Picker(Picker { kind, title, items, filter: String::new(), sel: 0 }),
Err(e) => self.items.push(Item::Error(format!("{e:#}"))),
}
}
}
if let Some(rx) = &mut self.pending_note {
if let Ok(res) = rx.try_recv() {
self.pending_note = None;
match res {
Ok(msg) if !msg.is_empty() => self.items.push(Item::Info(msg)),
Ok(_) => {}
Err(e) => self.items.push(Item::Error(format!("{e:#}"))),
}
}
}
if let Some(rx) = &mut self.pending_open {
if let Ok(res) = rx.try_recv() {
self.pending_open = None;
match res {
Ok(r) => {
self.items.clear();
self.items.push(Item::Info(format!("server chat: {} · {} · {} · {} – /local returns", r.title, r.agent, r.model, r.cwd)));
self.todos = Value::Null;
self.busy = false;
self.dialog = Dialog::None;
self.remote = Some(r);
self.pending_snapshot = None;
}
Err(e) => self.items.push(Item::Error(format!("{e:#}"))),
}
}
}
let Some(server) = self.env.server.clone() else { return };
let Some(r) = &mut self.remote else { return };
if let Some(rx) = &mut self.pending_snapshot {
if let Ok(res) = rx.try_recv() {
self.pending_snapshot = None;
match res {
Ok(snap) => {
let open: std::collections::HashSet<String> = self.items.iter().filter_map(|i| if let Item::Tool { id, open: true, .. } = i { Some(id.clone()) } else { None }).collect();
let was_busy = self.busy;
let at_end = self.scroll == 0;
let mut items = Self::items_of(&snap.messages, &open);
// Tool calls without a result are still running only while the chat is busy.
if !snap.busy {
for i in items.iter_mut() {
if let Item::Tool { state, .. } = i {
if matches!(state, ToolState::Running) {
*state = ToolState::Err;
}
}
}
}
let head = self.items.first().filter(|i| matches!(i, Item::Info(s) if s.starts_with("server chat:"))).map(|i| if let Item::Info(s) = i { s.clone() } else { String::new() });
self.items = head.map(Item::Info).into_iter().chain(items).collect();
self.busy = snap.busy;
if snap.busy && !was_busy {
self.busy_since = Instant::now();
}
self.todos = snap.todos.clone();
if !snap.title.is_empty() {
r.title = snap.title.clone();
}
if at_end {
self.scroll = 0;
}
// Requests that wait for an answer (permissions and questions of this chat).
if matches!(self.dialog, Dialog::None) {
if let Some(ev) = snap.pending.iter().find(|e| e["id"].as_str().is_some_and(|id| !r.answered.contains(id))) {
let id = ev["id"].as_str().unwrap_or("").to_string();
r.answered.insert(id.clone());
if ev["type"] == "permission_request" {
let (tx, rx) = oneshot::channel::<Reply>();
let srv = server.clone();
tokio::spawn(async move {
if let Ok(reply) = rx.await {
let (kind, msg) = match reply {
Reply::Once => ("once", None),
Reply::Always => ("always", None),
Reply::Reject(m) => ("reject", m),
};
let _ = remote::reply_permission(&srv, &id, kind, msg).await;
}
});
self.dialog = Dialog::Permission { tool: ev["tool"].as_str().unwrap_or("").into(), title: ev["title"].as_str().unwrap_or("").into(), diff: ev["diff"].as_str().map(String::from), input: ev["input"].clone(), reply: Some(tx), feedback: None };
} else if ev["type"] == "question_request" {
let questions: Vec<Question> = serde_json::from_value(ev["questions"].clone()).unwrap_or_default();
if !questions.is_empty() {
let (tx, rx) = oneshot::channel::<Option<serde_json::Map<String, Value>>>();
let srv = server.clone();
tokio::spawn(async move {
if let Ok(answers) = rx.await {
let _ = remote::answer_question(&srv, &id, answers).await;
}
});
self.dialog = Dialog::Question { questions, idx: 0, sel: 0, custom: String::new(), answers: Default::default(), reply: Some(tx) };
}
}
}
}
}
Err(e) => self.status = format!("server: {e:#}"),
}
}
} else if r.last_poll.elapsed() >= Duration::from_millis(1500) {
r.last_poll = Instant::now();
let id = r.id.clone();
let (tx, rx) = oneshot::channel();
tokio::spawn(async move {
let _ = tx.send(remote::snapshot(&server, &id).await);
});
self.pending_snapshot = Some(rx);
}
}
// --- setup wizard ---------------------------------------------------------------
fn open_setup(&mut self) {
@@ -771,9 +1070,7 @@ impl App {
match (k.code, ctrl) {
(KeyCode::Char('c'), true) => {
if self.busy {
if let Some(c) = &self.cancel {
c.cancel();
}
self.abort_current();
self.items.push(Item::Info(t("aborted").into()));
} else if !self.editor.is_empty() {
self.editor.clear();
@@ -787,9 +1084,7 @@ impl App {
(KeyCode::Char('d'), true) if self.editor.is_empty() => self.quit = true,
(KeyCode::Esc, _) => {
if self.busy {
if let Some(c) = &self.cancel {
c.cancel();
}
self.abort_current();
self.queue.clear();
self.items.push(Item::Info(t("aborted").into()));
}
@@ -1147,6 +1442,7 @@ impl App {
}
fn poll_pending(&mut self) {
self.poll_remote();
if let Some(rx) = &mut self.pending_detect {
if let Ok(found) = rx.try_recv() {
self.pending_detect = None;
@@ -1398,7 +1694,10 @@ impl App {
// Status line.
let ctx_pct = self.env.catalog.find(&self.session.model).and_then(|m| m.config.context).filter(|c| *c > 0).map(|c| format!("{} {}%", t("context"), self.context * 100 / c)).unwrap_or_default();
let cost = if self.session.cost > 0.0 { format!(" · {:.3} {}", self.session.cost, self.env.catalog.currency) } else { String::new() };
let left = format!(" {} · {} ", self.model_label(), self.session.permission_mode);
let left = match &self.remote {
Some(r) => format!(" server · {} · {} ", r.model, r.agent),
None => format!(" {} · {} ", self.model_label(), self.session.permission_mode),
};
let right = format!("{ctx_pct}{cost} · Shift+Tab {} · /help ", t("mode"));
let pad = (area.width as usize).saturating_sub(left.chars().count() + right.chars().count());
f.render_widget(Paragraph::new(Line::from(vec![Span::styled(left, Style::default().fg(th.fg3)), Span::raw(" ".repeat(pad)), Span::styled(right, Style::default().fg(th.muted))])).style(Style::default().bg(th.bg1)), status);