Terminal client: steer server chats and the factory
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6eb29ca19d
commit
73684253ce
6 files changed
+604
-7
No files matched your search
+306
-7
@@ -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);
|
||||
|
||||
Reference in new issue
Block a user