Skip to content

Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.

fix(apps): keep the last Usage move when moves come quickly

leepokai9543afb343b4
diff --git a/apps/desktop/e2e/usage-chooser.spec.ts b/apps/desktop/e2e/usage-chooser.spec.ts
index 60294ec9..b0b42b8c 100644
--- a/apps/desktop/e2e/usage-chooser.spec.ts
+++ b/apps/desktop/e2e/usage-chooser.spec.ts
@@ -1,8 +1,15 @@
-import { test, expect } from '@playwright/test'
+import { test, expect, type Page } from '@playwright/test'
import { api, attach } from './sandbox.ts'
type Usage = { providers: { id: string }[]; services: { id: string; name: string; shown: boolean }[] }
+async function openChooser(page: Page) {
+ await page.reload() // A settings window left open would cover the account button.
+ await page.locator('.sidebar-account').click()
+ await page.locator('.account-panel').getByText('Usage', { exact: true }).click()
+ await page.getByRole('button', { name: 'Choose and arrange' }).first().click()
+}
+
test('Settings > Usage chooses which agents show, and the host keeps the choice', async () => {
const { browser, page } = await attach()
const usage = () => api<Usage>(page, 'usage', {})
@@ -12,10 +19,7 @@ test('Settings > Usage chooses which agents show, and the host keeps the choice'
const shownAtStart = service.shown
try {
await api(page, 'setUsageShown', { id: service.id, shown: false })
- await page.reload() // A settings window left open would cover the account button.
- await page.locator('.sidebar-account').click()
- await page.locator('.account-panel').getByText('Usage', { exact: true }).click()
- await page.getByRole('button', { name: 'Choose and arrange' }).first().click()
+ await openChooser(page)
const row = page.locator('.settings-usage-chooser').getByRole('switch', { name: service.name })
await expect(row).toHaveAttribute('aria-checked', 'false')
@@ -40,10 +44,7 @@ test('dragging an agent in Settings > Usage changes its order, and the host keep
const before = await order()
test.skip(before.length < 2, 'needs two agents that can report their usage')
try {
- await page.reload() // A settings window left open would cover the account button.
- await page.locator('.sidebar-account').click()
- await page.locator('.account-panel').getByText('Usage', { exact: true }).click()
- await page.getByRole('button', { name: 'Choose and arrange' }).first().click()
+ await openChooser(page)
const rows = page.locator('.settings-usage-choice')
await expect(rows).toHaveCount(before.length)
@@ -67,3 +68,28 @@ test('dragging an agent in Settings > Usage changes its order, and the host keep
await browser.close()
}
})
+
+// Guards the row staying where it was moved and the order the moves end on. It can't tell the order they reach the
+// host in (latest-only.test.ts does), and the first answer can land before the second press.
+test('two quick moves in Settings > Usage end on the second, and the row stays there', async () => {
+ const { browser, page } = await attach()
+ const order = async () => (await api<Usage>(page, 'usage', {})).services.map((s) => s.id)
+ const before = await order()
+ test.skip(before.length < 3, 'needs three agents that can report their usage')
+ try {
+ await openChooser(page)
+ const rows = page.locator('.settings-usage-choice')
+ await expect(rows).toHaveCount(before.length)
+
+ await rows.nth(0).locator('.settings-usage-grip').focus()
+ await page.keyboard.press('ArrowDown')
+ await page.keyboard.press('ArrowDown')
+
+ await expect.poll(order).toEqual([before[1], before[2], before[0], ...before.slice(3)])
+ await expect(rows.nth(0)).toHaveAttribute('data-usage-service', before[1])
+ await expect(rows.nth(2)).toHaveAttribute('data-usage-service', before[0])
+ } finally {
+ await api(page, 'setUsageOrder', { ids: before }).catch(() => {})
+ await browser.close()
+ }
+})
diff --git a/apps/desktop/src/renderer/lib/latest-only.test.ts b/apps/desktop/src/renderer/lib/latest-only.test.ts
new file mode 100644
index 00000000..52887efc
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/latest-only.test.ts
@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { latestOnly } from './latest-only.ts'
+
+/** A send whose calls finish when the test says. */
+function controlled() {
+ const sent: number[] = []
+ const finish: ((failure?: Error) => void)[] = []
+ const send = (value: number) => {
+ sent.push(value)
+ return new Promise<void>((resolve, reject) => finish.push((failure) => (failure ? reject(failure) : resolve())))
+ }
+ return { sent, finish, send }
+}
+
+const turn = () => new Promise((resolve) => setImmediate(resolve))
+
+test('sends one at a time and skips to the latest', async () => {
+ const { sent, finish, send } = controlled()
+ const order = latestOnly(send)
+ const all = [order(1), order(2), order(3)]
+ assert.deepEqual(sent, [1])
+ finish.shift()?.()
+ await turn()
+ assert.deepEqual(sent, [1, 3], 'the one in between never goes out')
+ finish.shift()?.()
+ await Promise.all(all)
+})
+
+test('starts again after it finished', async () => {
+ const { sent, finish, send } = controlled()
+ const order = latestOnly(send)
+ const first = order(1)
+ finish.shift()?.()
+ await first
+ const second = order(2)
+ assert.deepEqual(sent, [1, 2])
+ finish.shift()?.()
+ await second
+})
+
+test('a failure reaches every caller and drops what was waiting', async () => {
+ const { sent, finish, send } = controlled()
+ const order = latestOnly(send)
+ const all = [order(1), order(2)]
+ finish.shift()?.(new Error('refused'))
+ for (const call of all) await assert.rejects(call, /refused/)
+ assert.deepEqual(sent, [1])
+ const next = order(3)
+ assert.deepEqual(sent, [1, 3], 'the next call starts again')
+ finish.shift()?.()
+ await next
+})
diff --git a/apps/desktop/src/renderer/lib/latest-only.ts b/apps/desktop/src/renderer/lib/latest-only.ts
new file mode 100644
index 00000000..d74b2cda
--- /dev/null
+++ b/apps/desktop/src/renderer/lib/latest-only.ts
@@ -0,0 +1,26 @@
+/**
+ * Sends one value at a time, and only the latest of those that came in meanwhile. A host handles requests side by
+ * side, so two sent together could land in either order. Every call's promise settles when the sending is done; a
+ * failure drops what was waiting, since the caller goes back to what the host has.
+ */
+export function latestOnly<T>(send: (value: T) => Promise<void>): (value: T) => Promise<void> {
+ let waiting: { value: T } | undefined
+ let sending: Promise<void> | undefined
+ const drain = async () => {
+ try {
+ while (waiting) {
+ const { value } = waiting
+ waiting = undefined
+ await send(value)
+ }
+ } finally {
+ waiting = undefined
+ sending = undefined
+ }
+ }
+ return (value) => {
+ waiting = { value }
+ sending ??= drain()
+ return sending
+ }
+}
diff --git a/apps/desktop/src/renderer/store/bot-store.ts b/apps/desktop/src/renderer/store/bot-store.ts
index 039a9bf9..50d329d6 100644
--- a/apps/desktop/src/renderer/store/bot-store.ts
+++ b/apps/desktop/src/renderer/store/bot-store.ts
@@ -16,6 +16,7 @@ import {
import type { CallLine } from '@shared/calls'
import type { HostClient } from '../client/host-client'
import { readSharedFile } from '../../shared/files.ts'
+import { latestOnly } from '../lib/latest-only'
import { prefs } from '../lib/prefs'
import { updatePayload } from './bot-draft'
import { FileDownloads } from './file-downloads'
@@ -459,10 +460,11 @@ export class BotStore extends BotSync {
this.changed()
}
- async setUsageOrder(ids: string[]) {
+ /** The order this computer lists its agents in. */
+ setUsageOrder = latestOnly(async (ids: string[]) => {
this.usage = await (await this.ready()).call<Usage>('setUsageOrder', { ids })
this.changed()
- }
+ })
async refreshUsage() {
if (this.retired || !this.client) return
diff --git a/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swift b/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swift
index f0bdac77..ee94894d 100644
--- a/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swift
+++ b/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swift
@@ -403,13 +403,28 @@ extension BotStore {
}
}
- /// The order this computer lists its agents in. A host older than this refuses the call: the error shows and the order stays.
+ /// The order this computer lists its agents in; returns once it's sent. One at a time and only the newest: the host
+ /// handles requests side by side, so two sent together could land in either order. A host older than this refuses
+ /// the call: the error shows and the order stays.
public func setUsageOrder(_ ids: [String]) async {
- do {
- setUsage(try await ready().setUsageOrder(ids))
- } catch {
- lastError = error.localizedDescription
+ usageOrderWaiting = ids
+ let sending = usageOrderSending ?? Task { await sendUsageOrders() }
+ usageOrderSending = sending
+ await sending.value
+ }
+
+ private func sendUsageOrders() async {
+ while let ids = usageOrderWaiting {
+ usageOrderWaiting = nil
+ do {
+ setUsage(try await ready().setUsageOrder(ids))
+ } catch {
+ lastError = error.localizedDescription
+ // The row goes back to the host's order, and what waited was moved from one that didn't land.
+ usageOrderWaiting = nil
+ }
}
+ usageOrderSending = nil
}
public func refreshUsage() async {
diff --git a/apps/ios/Kit/Sources/CodyncUI/Store/BotStore.swift b/apps/ios/Kit/Sources/CodyncUI/Store/BotStore.swift
index d999cf61..a55fb834 100644
--- a/apps/ios/Kit/Sources/CodyncUI/Store/BotStore.swift
+++ b/apps/ios/Kit/Sources/CodyncUI/Store/BotStore.swift
@@ -66,6 +66,9 @@ public final class BotStore {
public internal(set) var bots: [String: Bot] = [:]
public internal(set) var entries: [String: [Entry]] = [:]
public internal(set) var usage: Usage
+ /// The newest order still to send, and the task sending them (`setUsageOrder`).
+ @ObservationIgnored var usageOrderWaiting: [String]?
+ @ObservationIgnored var usageOrderSending: Task<Void, Never>?
/// The computer's remote screen (`nil`: the host predates it).
public internal(set) var screen: ScreenState?
/// The computer's network of the user's computers (`nil`: the host predates it).
diff --git a/apps/ios/Kit/Tests/CodyncUITests/StoreTestFixtures.swift b/apps/ios/Kit/Tests/CodyncUITests/StoreTestFixtures.swift
index b5c9d95e..5b675534 100644
--- a/apps/ios/Kit/Tests/CodyncUITests/StoreTestFixtures.swift
+++ b/apps/ios/Kit/Tests/CodyncUITests/StoreTestFixtures.swift
@@ -50,6 +50,27 @@ actor FakeRemote: RemoteTransport {
/// The next `count` calls of `method` fail as if the link dropped under them.
func fail(_ method: String, times count: Int) { failures[method] = count }
private(set) var enqueued: [String] = []
+ /// Each `setUsageOrder`'s ids, in order.
+ private(set) var usageOrders: [[String]] = []
+ private var holdsUsageOrders = false
+ private var heldUsageOrders: [CheckedContinuation<Void, Never>] = []
+
+ /// While on, each `setUsageOrder` waits for `answerUsageOrder`; turning it off answers the ones waiting.
+ func holdUsageOrders(_ hold: Bool) {
+ holdsUsageOrders = hold
+ if !hold { while !heldUsageOrders.isEmpty { answerUsageOrder() } }
+ }
+
+ func answerUsageOrder() {
+ if !heldUsageOrders.isEmpty { heldUsageOrders.removeFirst().resume() }
+ }
+
+ private func receiveUsageOrder(_ body: Data) async {
+ let ids = (try? JSONSerialization.jsonObject(with: body) as? [String: [String]])?["ids"]
+ usageOrders.append(ids ?? [])
+ if holdsUsageOrders { await withCheckedContinuation { heldUsageOrders.append($0) } }
+ }
+
var cancelResult = MailboxCancel.cancelled
private var hello = #"{"hostId":"h1","name":"Mac","version":"3.0.0","os":"macos","backends":[],"rev":0}"#
@@ -100,6 +121,8 @@ actor FakeRemote: RemoteTransport {
// A fresh credential per provider session, so a test can tell a replaced session from the first.
let n = calls.filter { $0 == "startCall" }.count
return Data(#"{"instructions":"Be the relay.","tools":[],"credential":"token-\#(n)"}"#.utf8)
+ case "setUsageOrder":
+ return Data(#"{"providers":[]}"#.utf8)
case "createBot", "updateBot":
// The host's reply bot, which never carries a custom icon (icons sync on their own).
let id = (try JSONSerialization.jsonObject(with: body) as? [String: Any])?["id"] as? String ?? "new"
@@ -110,7 +133,8 @@ actor FakeRemote: RemoteTransport {
}
nonisolated func call(_ method: String, body: Data, timeout: TimeInterval) async throws -> Data {
- try await respond(method, body)
+ if method == "setUsageOrder" { await receiveUsageOrder(body) }
+ return try await respond(method, body)
}
private func addEvents(_ c: AsyncThrowingStream<Data, Error>.Continuation) {
diff --git a/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift b/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift
index 82f64071..3c53893f 100644
--- a/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift
+++ b/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift
@@ -1,5 +1,6 @@
import Foundation
import Testing
+@testable import CodyncKit
@testable import CodyncUI
@Suite struct UsageOrderTests {
@@ -14,3 +15,75 @@ import Testing
#expect(UsageOrder.moved(["claude", "codex"], from: [0], to: 1) == nil)
}
}
+
+/// How many of the moves started in a test got back to their caller.
+@MainActor private final class Returned {
+ var count = 0
+}
+
+@MainActor private func onlineStore(_ fake: FakeRemote, _ storage: SharedStore.Context) async -> BotStore {
+ let store = BotStore(computer: Computer(id: UUID().uuidString, name: "Mac", signKey: ""), storage: storage) { _ in fake }
+ store.setActive(true)
+ #expect(await until { await fake.subscribed })
+ await fake.emit(botEvent("b1", name: "Bot", rev: 1))
+ #expect(await until { store.connection == .online })
+ return store
+}
+
+@MainActor @Test func movesGoOutOneAtATimeAndOnlyTheNewest() async {
+ let (storage, suite) = context()
+ defer { UserDefaults(suiteName: suite)?.removePersistentDomain(forName: suite) }
+ let fake = FakeRemote(.ready(.direct))
+ let store = await onlineStore(fake, storage)
+ defer { store.retire() }
+ await fake.holdUsageOrders(true)
+ let returned = Returned()
+ let move = { (ids: [String]) in
+ Task {
+ await store.setUsageOrder(ids)
+ returned.count += 1
+ }
+ }
+
+ let first = move(["a"])
+ #expect(await until { await fake.usageOrders == [["a"]] })
+ let second = move(["b"])
+ #expect(await until { store.usageOrderWaiting == ["b"] })
+ let third = move(["c"])
+ #expect(await until { store.usageOrderWaiting == ["c"] })
+
+ await fake.answerUsageOrder()
+ #expect(await until { await fake.usageOrders == [["a"], ["c"]] }, "the one in between never goes out")
+ #expect(returned.count == 0, "every caller waits for the last answer")
+
+ await fake.holdUsageOrders(false)
+ for task in [first, second, third] { await task.value }
+ #expect(await fake.usageOrders == [["a"], ["c"]])
+
+ await store.setUsageOrder(["d"])
+ #expect(await fake.usageOrders == [["a"], ["c"], ["d"]], "a later move sends again")
+}
+
+@MainActor @Test func aFailedMoveShowsItsErrorAndDropsTheOneWaiting() async {
+ let (storage, suite) = context()
+ defer { UserDefaults(suiteName: suite)?.removePersistentDomain(forName: suite) }
+ let fake = FakeRemote(.ready(.direct))
+ let store = await onlineStore(fake, storage)
+ defer { store.retire() }
+ await fake.holdUsageOrders(true)
+ await fake.fail("setUsageOrder", times: 1)
+
+ let first = Task { await store.setUsageOrder(["a"]) }
+ #expect(await until { await fake.usageOrders == [["a"]] })
+ let second = Task { await store.setUsageOrder(["b"]) }
+ #expect(await until { store.usageOrderWaiting == ["b"] })
+
+ await fake.holdUsageOrders(false)
+ await first.value
+ await second.value
+ #expect(store.lastError != nil)
+ #expect(await fake.usageOrders == [["a"]], "it was moved from an order that didn't land")
+
+ await store.setUsageOrder(["c"])
+ #expect(await fake.usageOrders == [["a"], ["c"]], "the next move still sends")
+}
diff --git a/host/src/dev_servers/logs.rs b/host/src/dev_servers/logs.rs
index 6cb5fb20..6267740d 100644
--- a/host/src/dev_servers/logs.rs
+++ b/host/src/dev_servers/logs.rs
@@ -62,7 +62,11 @@ async fn pump(mut from: impl AsyncRead + Unpin, writer: Arc<Mutex<Writer>>) {
let mut buffer = vec![0; 8192];
loop {
match from.read(&mut buffer).await {
- Ok(0) | Err(_) => break,
+ Ok(0) => break,
+ Err(error) => {
+ tracing::warn!(error = format!("{error:#}"), "couldn't read a dev server's output");
+ break;
+ }
Ok(read) => {
if let Err(error) = writer.lock().await.write(&buffer[..read]).await {
// Keep reading: a full disk mustn't block the server on a full pipe.
diff --git a/host/src/tui/app/mod.rs b/host/src/tui/app/mod.rs
index a15c6a4e..a8ba006a 100644
--- a/host/src/tui/app/mod.rs
+++ b/host/src/tui/app/mod.rs
@@ -21,6 +21,7 @@ mod section_order;
mod slash;
mod steps;
mod ui;
+mod usage_chooser;
pub use approvals::parse_modes;
pub use bot::{AgentModel, Bot, ModelOption, OwnMemory};
diff --git a/host/src/tui/app/overlay_keys.rs b/host/src/tui/app/overlay_keys.rs
index 35c86c8f..ce7ceefb 100644
--- a/host/src/tui/app/overlay_keys.rs
+++ b/host/src/tui/app/overlay_keys.rs
@@ -1,10 +1,9 @@
//! Keys in the pickers: go-to, actions and folders.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-use serde_json::{Value, json};
+use serde_json::json;
use super::super::manage::{AnalyticsSheet, Reply};
-use super::super::view::usage_services;
use super::{
ACTIONS, Action, After, App, Bot, ConfirmAct, Dir, Editor, FILTERS, FolderMode, FolderPicker, Goto, GotoItem,
Overlay, PairCode, contains, fuzzy,
@@ -152,55 +151,8 @@ impl App {
_ => Some(Overlay::LeadAgent(scroll.min(max))),
}
}
- Overlay::Usage(scroll) => {
- let (_, height) = crossterm::terminal::size().unwrap_or((80, 24));
- let max = super::super::view::usage_scroll_max(self, height);
- match k.code {
- KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q' | 'U' | 'P') => None,
- KeyCode::Down | KeyCode::Char('j') => Some(Overlay::Usage((scroll + 1).min(max))),
- KeyCode::Up | KeyCode::Char('k') => Some(Overlay::Usage(scroll.saturating_sub(1))),
- KeyCode::PageDown | KeyCode::Char(' ') => Some(Overlay::Usage((scroll + 10).min(max))),
- KeyCode::PageUp => Some(Overlay::Usage(scroll.saturating_sub(10))),
- KeyCode::Char('s') if !usage_services(self).is_empty() => {
- self.overlays.push(Overlay::UsageChooser { row: 0, moving: false });
- Some(Overlay::Usage(scroll))
- }
- _ => Some(Overlay::Usage(scroll)),
- }
- }
- Overlay::UsageChooser { row, moving } => {
- let services = usage_services(self);
- let last = services.len().saturating_sub(1);
- // The list can shrink under the cursor: an agent turned off, a bot deleted on another device.
- let row = row.min(last);
- match k.code {
- KeyCode::Esc | KeyCode::Char('q' | 's') => None,
- KeyCode::Down | KeyCode::Char('j') => {
- Some(Overlay::UsageChooser { row: (row + 1).min(last), moving })
- }
- KeyCode::Up | KeyCode::Char('k') => {
- Some(Overlay::UsageChooser { row: row.saturating_sub(1), moving })
- }
- KeyCode::Char(key @ ('J' | 'K')) => {
- let to = if key == 'J' { (row + 1).min(last) } else { row.saturating_sub(1) };
- let starts = !moving && to != row;
- if starts {
- let mut ids: Vec<_> = services.iter().map(|service| &service["id"]).collect();
- ids.swap(row, to);
- self.call("setUsageOrder", json!({"ids": ids}), After::UsageOrder(to));
- }
- Some(Overlay::UsageChooser { row, moving: moving || starts })
- }
- KeyCode::Char(' ') | KeyCode::Enter => {
- if let Some(service) = services.get(row) {
- let shown = service["shown"].as_bool() != Some(true);
- self.call("setUsageShown", json!({"id": service["id"], "shown": shown}), After::Nothing);
- }
- Some(Overlay::UsageChooser { row, moving })
- }
- _ => Some(Overlay::UsageChooser { row, moving }),
- }
- }
+ Overlay::Usage(scroll) => self.usage_key(scroll, k),
+ Overlay::UsageChooser { row, moving } => self.usage_chooser_key(row, moving, k),
o @ Overlay::Pair(_) => {
if matches!(k.code, KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q' | 'U' | 'P')) {
None
@@ -215,27 +167,6 @@ impl App {
}
}
- /// The host's answer to a move. Only now do the list change and the cursor follow, so the next move starts from
- /// the order this one left, and a refused one leaves both where they were.
- pub(super) fn usage_order_answered(&mut self, to: usize, answer: Result<Value, String>) {
- let moved = match answer {
- Ok(usage) => {
- self.usage = usage;
- true
- }
- Err(error) => {
- self.flash(&error);
- false
- }
- };
- if let Some(Overlay::UsageChooser { row, moving }) = self.overlays.last_mut() {
- *moving = false;
- if moved {
- *row = to;
- }
- }
- }
-
fn goto_key(&mut self, mut g: Goto, k: KeyEvent) -> Option<Overlay> {
let items_len = self.goto_items(&g).len();
match k.code {
@@ -407,120 +338,9 @@ impl App {
#[cfg(test)]
mod tests {
- use super::super::super::net::Client;
- use super::super::{After, App, Bot, Editor, Goto, GotoItem, Msg, Overlay, test_app};
- use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+ use super::super::{Bot, Editor, Goto, GotoItem, test_app};
use serde_json::json;
- /// A host that hands each request it gets to `requests`, answering them all alike.
- async fn host() -> (String, tokio::sync::mpsc::UnboundedReceiver<String>) {
- use tokio::io::{AsyncReadExt, AsyncWriteExt};
- let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("a free port");
- let base = format!("http://{}", listener.local_addr().expect("its address"));
- let (seen, requests) = tokio::sync::mpsc::unbounded_channel();
- tokio::spawn(async move {
- while let Ok((mut socket, _)) = listener.accept().await {
- let mut request = Vec::new();
- while !request.ends_with(b"}") {
- let mut chunk = [0; 4096];
- let read = socket.read(&mut chunk).await.expect("a request");
- if read == 0 {
- break;
- }
- request.extend_from_slice(&chunk[..read]);
- }
- let _ = seen.send(String::from_utf8_lossy(&request).into_owned());
- let answer = b"HTTP/1.1 200 OK\r\ncontent-length: 2\r\nconnection: close\r\n\r\n{}";
- let _ = socket.write_all(answer).await;
- }
- });
- (base, requests)
- }
-
- #[tokio::test]
- async fn the_usage_sheet_opens_the_chooser_and_a_toggle_reaches_the_host() {
- let (base, mut requests) = host().await;
- let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
- let mut app = App::new(Client::new(&base, Some("token")), tx, String::new());
- app.usage = json!({"providers": [], "services": [
- {"id": "claude", "name": "Claude", "shown": true},
- {"id": "cursor", "name": "Cursor", "shown": false},
- ]});
- let key = |code| KeyEvent::new(code, KeyModifiers::NONE);
- app.overlays.push(Overlay::Usage(0));
- app.overlay_key(key(KeyCode::Char('s')));
- assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 0, .. })));
- app.overlay_key(key(KeyCode::Down));
- assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 1, .. })));
- app.overlay_key(key(KeyCode::Char(' ')));
- let request = next_request(&mut requests).await;
- assert!(request.starts_with("POST /api/setUsageShown"), "{request}");
- assert!(request.contains(r#""id":"cursor""#) && request.contains(r#""shown":true"#), "{request}");
- assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 1, .. })), "the chooser stays open");
- app.overlay_key(key(KeyCode::Esc));
- assert!(matches!(app.overlays.last(), Some(Overlay::Usage(0))), "back to the limits");
- }
-
- #[tokio::test]
- async fn j_and_k_move_the_selected_agent_as_the_host_answers() {
- let (base, mut requests) = host().await;
- let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
- let mut app = App::new(Client::new(&base, Some("token")), tx, String::new());
- let usage = |ids: &[&str]| {
- let services: Vec<_> = ids.iter().map(|id| json!({"id": id, "name": id, "shown": true})).collect();
- json!({"providers": [], "services": services})
- };
- let press = |app: &mut App, c| app.overlay_key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
- let row = |app: &App| match app.overlays.last() {
- Some(Overlay::UsageChooser { row, .. }) => *row,
- other => panic!("the chooser is closed: {:?}", other.is_some()),
- };
- app.usage = usage(&["a", "b", "c"]);
- app.overlays.push(Overlay::UsageChooser { row: 0, moving: false });
-
- press(&mut app, 'K');
- press(&mut app, 'J');
- press(&mut app, 'J');
- assert_eq!(row(&app), 0, "the cursor waits for the host");
- let sent = next_request(&mut requests).await;
- assert!(sent.starts_with("POST /api/setUsageOrder"), "{sent}");
- assert!(sent.contains(r#""ids":["b","a","c"]"#), "the top's K and the waiting J sent nothing: {sent}");
- app.on_msg(Msg::Reply(After::UsageOrder(1), Ok(usage(&["b", "a", "c"]))));
- assert_eq!(row(&app), 1, "the cursor follows the agent");
-
- press(&mut app, 'J');
- assert!(next_request(&mut requests).await.contains(r#""ids":["b","c","a"]"#));
- app.on_msg(Msg::Reply(After::UsageOrder(2), Ok(usage(&["b", "c", "a"]))));
- press(&mut app, 'J');
- assert_eq!(row(&app), 2, "the end of the list does nothing");
-
- press(&mut app, 'K');
- assert!(next_request(&mut requests).await.contains(r#""ids":["b","a","c"]"#), "the last J sent nothing");
- app.on_msg(Msg::Reply(After::UsageOrder(1), Err("unknown method".into())));
- assert_eq!(row(&app), 2, "a refused move keeps the cursor on its agent");
-
- // An agent turned off leaves the cursor past the end.
- app.usage = usage(&["b", "c"]);
- press(&mut app, 'K');
- assert!(next_request(&mut requests).await.contains(r#""ids":["c","b"]"#));
- }
-
- async fn next_request(requests: &mut tokio::sync::mpsc::UnboundedReceiver<String>) -> String {
- tokio::time::timeout(std::time::Duration::from_secs(10), requests.recv())
- .await
- .expect("the host hears of it in time")
- .expect("the host is up")
- }
-
- #[tokio::test]
- async fn a_host_with_no_list_offers_no_chooser() {
- let mut app = test_app();
- app.usage = json!({"providers": []});
- app.overlays.push(Overlay::Usage(0));
- app.overlay_key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
- assert!(matches!(app.overlays.last(), Some(Overlay::Usage(0))));
- }
-
#[tokio::test]
async fn the_palette_offers_to_unhide_hidden_bots() {
let mut app = test_app();
diff --git a/host/src/tui/app/usage_chooser.rs b/host/src/tui/app/usage_chooser.rs
new file mode 100644
index 00000000..aa378120
--- /dev/null
+++ b/host/src/tui/app/usage_chooser.rs
@@ -0,0 +1,206 @@
+//! The usage sheet and its chooser: their keys, and the host's answer to a move.
+
+use crossterm::event::{KeyCode, KeyEvent};
+use serde_json::{Value, json};
+
+use super::super::view::{usage_scroll_max, usage_services};
+use super::{After, App, Overlay};
+
+impl App {
+ pub(super) fn usage_key(&mut self, scroll: usize, k: KeyEvent) -> Option<Overlay> {
+ let (_, height) = crossterm::terminal::size().unwrap_or((80, 24));
+ let max = usage_scroll_max(self, height);
+ match k.code {
+ KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q' | 'U' | 'P') => None,
+ KeyCode::Down | KeyCode::Char('j') => Some(Overlay::Usage((scroll + 1).min(max))),
+ KeyCode::Up | KeyCode::Char('k') => Some(Overlay::Usage(scroll.saturating_sub(1))),
+ KeyCode::PageDown | KeyCode::Char(' ') => Some(Overlay::Usage((scroll + 10).min(max))),
+ KeyCode::PageUp => Some(Overlay::Usage(scroll.saturating_sub(10))),
+ KeyCode::Char('s') if !usage_services(self).is_empty() => {
+ self.overlays.push(Overlay::UsageChooser { row: 0, moving: false });
+ Some(Overlay::Usage(scroll))
+ }
+ _ => Some(Overlay::Usage(scroll)),
+ }
+ }
+
+ pub(super) fn usage_chooser_key(&mut self, row: usize, moving: bool, k: KeyEvent) -> Option<Overlay> {
+ let services = usage_services(self);
+ let last = services.len().saturating_sub(1);
+ // The list can shrink under the cursor: an agent turned off, a bot deleted on another device.
+ let row = row.min(last);
+ match k.code {
+ KeyCode::Esc | KeyCode::Char('q' | 's') => None,
+ KeyCode::Down | KeyCode::Char('j') => Some(Overlay::UsageChooser { row: (row + 1).min(last), moving }),
+ KeyCode::Up | KeyCode::Char('k') => Some(Overlay::UsageChooser { row: row.saturating_sub(1), moving }),
+ KeyCode::Char(key @ ('J' | 'K')) => {
+ let to = if key == 'J' { (row + 1).min(last) } else { row.saturating_sub(1) };
+ let starts = !moving && to != row;
+ if starts {
+ let mut ids: Vec<_> = services.iter().map(|service| &service["id"]).collect();
+ ids.swap(row, to);
+ self.call("setUsageOrder", json!({"ids": ids}), After::UsageOrder(to));
+ }
+ Some(Overlay::UsageChooser { row, moving: moving || starts })
+ }
+ KeyCode::Char(' ') | KeyCode::Enter => {
+ if let Some(service) = services.get(row) {
+ let shown = service["shown"].as_bool() != Some(true);
+ self.call("setUsageShown", json!({"id": service["id"], "shown": shown}), After::Nothing);
+ }
+ Some(Overlay::UsageChooser { row, moving })
+ }
+ _ => Some(Overlay::UsageChooser { row, moving }),
+ }
+ }
+
+ /// The host's answer to a move. Only now do the list change and the cursor follow, so the next move starts from
+ /// the order this one left, and a refused one leaves both where they were.
+ pub(super) fn usage_order_answered(&mut self, to: usize, answer: Result<Value, String>) {
+ let moved = match answer {
+ Ok(usage) => {
+ self.usage = usage;
+ true
+ }
+ Err(error) => {
+ self.flash(&error);
+ false
+ }
+ };
+ // Only the chooser that waits for a move: this one may have been closed and another opened since.
+ // ponytail: a move started in that other one takes this answer as its own; give moves an id if that ever shows.
+ if let Some(Overlay::UsageChooser { row, moving }) = self.overlays.last_mut()
+ && *moving
+ {
+ *moving = false;
+ if moved {
+ *row = to;
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::super::super::net::Client;
+ use super::super::{After, App, Msg, Overlay, test_app};
+ use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+ use serde_json::json;
+
+ /// A host that hands each request it gets to `requests`, answering them all alike.
+ async fn host() -> (String, tokio::sync::mpsc::UnboundedReceiver<String>) {
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("a free port");
+ let base = format!("http://{}", listener.local_addr().expect("its address"));
+ let (seen, requests) = tokio::sync::mpsc::unbounded_channel();
+ tokio::spawn(async move {
+ while let Ok((mut socket, _)) = listener.accept().await {
+ let mut request = Vec::new();
+ while !request.ends_with(b"}") {
+ let mut chunk = [0; 4096];
+ let read = socket.read(&mut chunk).await.expect("a request");
+ if read == 0 {
+ break;
+ }
+ request.extend_from_slice(&chunk[..read]);
+ }
+ let _ = seen.send(String::from_utf8_lossy(&request).into_owned());
+ let answer = b"HTTP/1.1 200 OK\r\ncontent-length: 2\r\nconnection: close\r\n\r\n{}";
+ let _ = socket.write_all(answer).await;
+ }
+ });
+ (base, requests)
+ }
+
+ async fn next_request(requests: &mut tokio::sync::mpsc::UnboundedReceiver<String>) -> String {
+ tokio::time::timeout(std::time::Duration::from_secs(10), requests.recv())
+ .await
+ .expect("the host hears of it in time")
+ .expect("the host is up")
+ }
+
+ #[tokio::test]
+ async fn the_usage_sheet_opens_the_chooser_and_a_toggle_reaches_the_host() {
+ let (base, mut requests) = host().await;
+ let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
+ let mut app = App::new(Client::new(&base, Some("token")), tx, String::new());
+ app.usage = json!({"providers": [], "services": [
+ {"id": "claude", "name": "Claude", "shown": true},
+ {"id": "cursor", "name": "Cursor", "shown": false},
+ ]});
+ let key = |code| KeyEvent::new(code, KeyModifiers::NONE);
+ app.overlays.push(Overlay::Usage(0));
+ app.overlay_key(key(KeyCode::Char('s')));
+ assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 0, .. })));
+ app.overlay_key(key(KeyCode::Down));
+ assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 1, .. })));
+ app.overlay_key(key(KeyCode::Char(' ')));
+ let request = next_request(&mut requests).await;
+ assert!(request.starts_with("POST /api/setUsageShown"), "{request}");
+ assert!(request.contains(r#""id":"cursor""#) && request.contains(r#""shown":true"#), "{request}");
+ assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 1, .. })), "the chooser stays open");
+ app.overlay_key(key(KeyCode::Esc));
+ assert!(matches!(app.overlays.last(), Some(Overlay::Usage(0))), "back to the limits");
+ }
+
+ #[tokio::test]
+ async fn j_and_k_move_the_selected_agent_as_the_host_answers() {
+ let (base, mut requests) = host().await;
+ let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
+ let mut app = App::new(Client::new(&base, Some("token")), tx, String::new());
+ let usage = |ids: &[&str]| {
+ let services: Vec<_> = ids.iter().map(|id| json!({"id": id, "name": id, "shown": true})).collect();
+ json!({"providers": [], "services": services})
+ };
+ let press = |app: &mut App, c| app.overlay_key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE));
+ let row = |app: &App| match app.overlays.last() {
+ Some(Overlay::UsageChooser { row, .. }) => *row,
+ other => panic!("the chooser is closed: {:?}", other.is_some()),
+ };
+ app.usage = usage(&["a", "b", "c"]);
+ app.overlays.push(Overlay::UsageChooser { row: 0, moving: false });
+
+ press(&mut app, 'K');
+ press(&mut app, 'J');
+ press(&mut app, 'J');
+ assert_eq!(row(&app), 0, "the cursor waits for the host");
+ let sent = next_request(&mut requests).await;
+ assert!(sent.starts_with("POST /api/setUsageOrder"), "{sent}");
+ assert!(sent.contains(r#""ids":["b","a","c"]"#), "the top's K and the waiting J sent nothing: {sent}");
+ app.on_msg(Msg::Reply(After::UsageOrder(1), Ok(usage(&["b", "a", "c"]))));
+ assert_eq!(row(&app), 1, "the cursor follows the agent");
+
+ press(&mut app, 'J');
+ assert!(next_request(&mut requests).await.contains(r#""ids":["b","c","a"]"#));
+ app.on_msg(Msg::Reply(After::UsageOrder(2), Ok(usage(&["b", "c", "a"]))));
+ press(&mut app, 'J');
+ assert_eq!(row(&app), 2, "the end of the list does nothing");
+
+ press(&mut app, 'K');
+ assert!(next_request(&mut requests).await.contains(r#""ids":["b","a","c"]"#), "the last J sent nothing");
+ app.on_msg(Msg::Reply(After::UsageOrder(1), Err("unknown method".into())));
+ assert_eq!(row(&app), 2, "a refused move keeps the cursor on its agent");
+
+ // An agent turned off leaves the cursor past the end.
+ app.usage = usage(&["b", "c"]);
+ press(&mut app, 'K');
+ assert!(next_request(&mut requests).await.contains(r#""ids":["c","b"]"#));
+ }
+
+ #[tokio::test]
+ async fn a_chooser_opened_after_a_move_was_sent_does_not_take_its_answer() {
+ let mut app = test_app();
+ app.overlays.push(Overlay::UsageChooser { row: 0, moving: false });
+ app.on_msg(Msg::Reply(After::UsageOrder(1), Ok(json!({"providers": []}))));
+ assert!(matches!(app.overlays.last(), Some(Overlay::UsageChooser { row: 0, moving: false })));
+ }
+
+ #[tokio::test]
+ async fn a_host_with_no_list_offers_no_chooser() {
+ let mut app = test_app();
+ app.usage = json!({"providers": []});
+ app.overlays.push(Overlay::Usage(0));
+ app.overlay_key(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE));
+ assert!(matches!(app.overlays.last(), Some(Overlay::Usage(0))));
+ }
+}
diff --git a/host/src/usage/services.rs b/host/src/usage/services.rs
index 359fdb69..aec20b51 100644
--- a/host/src/usage/services.rs
+++ b/host/src/usage/services.rs
@@ -231,8 +231,11 @@ fn held_readings(hub: &Hub) -> HashSet<&'static str> {
hub.usage.locked().providers.iter().map(|provider| provider.id).collect()
}
-/// Brings the chooser's list up to date and drops readings nobody wants any more.
+/// Brings the chooser's list up to date and drops readings nobody wants any more. One at a time: a sync that read the
+/// settings before a change can't land after the sync that change made.
pub(super) fn sync(hub: &Hub) {
+ static ONE_AT_A_TIME: std::sync::Mutex<()> = std::sync::Mutex::new(());
+ let _turn = ONE_AT_A_TIME.locked();
let store = &hub.store;
let used = used_agents(store);
// The database and the disk stay outside the usage lock: a reading landing meanwhile is kept.