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.
Rust acpagent-client-protocolai-agentsai-assistantclaudeclaude-codecodexcoding-agentscursorgeminigemini-cligrok-bot-alternativeiosiphonelinuxmacosmcpopen-sourcerustself-hosted
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.tsindex 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.showntry {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 keepconst 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 keepawait 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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) returndiff --git a/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swift b/apps/ios/Kit/Sources/CodyncUI/Store/BotStore+Actions.swiftindex 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.swiftindex 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.swiftindex 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.cancelledprivate 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" }.countreturn 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.swiftindex 82f64071..3c53893f 100644--- a/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift+++ b/apps/ios/Kit/Tests/CodyncUITests/UsageOrderTests.swift@@ -1,5 +1,6 @@import Foundationimport 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.