diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5277742..f292177 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,12 @@
All notable changes to CodeCraft. Versions follow [Semantic Versioning](https://semver.org/);
until 1.0, minor versions may contain breaking changes.
+## [Unreleased]
+
+### Added
+
+- **Terminal client: steer the server.** `/projects` lists your chats on the server and opens one in the terminal – the agent keeps running on the server; you read along, send messages, answer permissions and questions, interrupt and compact. `/factory` shows the factory board and lets you merge pull requests, close, restart or remove issues and open the chat of any run; `/factory check` polls for new issues. `/local` returns to the local chat.
+
## [v202611-00065] – 2026-11-19
### Added
diff --git a/README.md b/README.md
index 34120fa..91908bc 100644
--- a/README.md
+++ b/README.md
@@ -210,6 +210,15 @@ codecraft login # server URL, user name, password → creates an API
codecraft # start in the current folder; /help lists the commands
```
+Signed in to a server, the terminal also steers the server itself:
+
+- `/projects` lists your chats on the server; open one and follow it – the agent keeps running **on the
+ server**, in the server's folder – and answer its permission requests and questions, send messages, interrupt
+ it (Esc) and `/compact` it. `/local` returns to a local chat. The view refreshes every second or two.
+- `/factory` shows the factory board (issues by phase with their latest run, totals and cost) and offers per
+ issue: open the chat of a run, merge the pull request (merge, squash or rebase), close the issue, restart it at
+ the review, build or acceptance, or remove it from the board. `/factory check` looks for new issues right away.
+
The Docker image ships static binaries for Linux x86_64, aarch64 and riscv64; the server offers them
for download (*Settings → Account*) and `codecraft update` fetches new versions from it. Other
platforms: `cargo install --locked --git https://git.familie-zink.org/zink/codecraft codecraft-cli`.
diff --git a/cli/src/app.rs b/cli/src/app.rs
index 7a8cf92..145bada 100644
--- a/cli/src/app.rs
+++ b/cli/src/app.rs
@@ -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>>,
pending_env: Option>>,
+ /// A chat of the server that this terminal follows (instead of the local session).
+ remote: Option,
+ pending_snapshot: Option>>,
+ pending_open: Option>>,
+ pending_pick: Option)>>>,
+ pending_note: Option>>,
+ /// 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) -> Vec- {
+ 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 = 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::();
+ 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 = serde_json::from_value(ev["questions"].clone()).unwrap_or_default();
+ if !questions.is_empty() {
+ let (tx, rx) = oneshot::channel::