From 812a063a55a16e95146c84c3d25ed1095af5c532 Mon Sep 17 00:00:00 2001 From: Pete Cornish Date: Sun, 6 Sep 2026 22:49:16 +0100 Subject: [PATCH 1/5] docs(serve): add the serve-ui openspec change --- openspec/changes/serve-ui/.openspec.yaml | 2 + openspec/changes/serve-ui/design.md | 196 ++++++++++++++ openspec/changes/serve-ui/proposal.md | 69 +++++ .../serve-ui/specs/local-serving/spec.md | 256 ++++++++++++++++++ openspec/changes/serve-ui/tasks.md | 31 +++ 5 files changed, 554 insertions(+) create mode 100644 openspec/changes/serve-ui/.openspec.yaml create mode 100644 openspec/changes/serve-ui/design.md create mode 100644 openspec/changes/serve-ui/proposal.md create mode 100644 openspec/changes/serve-ui/specs/local-serving/spec.md create mode 100644 openspec/changes/serve-ui/tasks.md diff --git a/openspec/changes/serve-ui/.openspec.yaml b/openspec/changes/serve-ui/.openspec.yaml new file mode 100644 index 0000000..1a62d62 --- /dev/null +++ b/openspec/changes/serve-ui/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-09-06 diff --git a/openspec/changes/serve-ui/design.md b/openspec/changes/serve-ui/design.md new file mode 100644 index 0000000..a8f286d --- /dev/null +++ b/openspec/changes/serve-ui/design.md @@ -0,0 +1,196 @@ +## Context + +`spinloop serve` runs its engine in the foreground. Today it forwards the +engine's stdio to the terminal; with `--api` it additionally builds a +`daemon.Daemon` in-process that serves the control API, runs the activity and +history sampler, and starts the engine through a supervisor whose `LogPath` +is empty — so the engine's output still goes to the terminal and the API's +log endpoint answers "missing". + +The fleet dashboard's node detail view (`dashboard_detail.go`) is the +reference screen: three stacked sections (metrics, tailed engine log, key +help), the metrics drawn from the same lines `dashNodeView` produces for a +tile, the log polled by byte offset on a one-shot rescheduled tick with a +generation guard, and a footer naming the keys. It reads its node over the +fleet's HTTP seam; serve's node is its own in-process daemon. + +`daemon.Daemon` already exposes what the view needs without HTTP: +`Status()`, `Metrics(ctx)`, and the log is a plain file read through +`daemon.ReadLog(path, offset, limit)`. The sampler retains a 10-minute, +40-sample history for the bars. The shared metrics renderers +(`metrics_render.go`) already know both formats: `renderStatBars` draws a +sparkline per series from the history, falling back to the gauge per series +where the history holds none; `renderStatGauges` draws the current reading. +`renderGauge` hard-codes its 25-column width; `renderSparkline` takes one. + +bubbletea and lipgloss are existing dependencies; `term.IsTerminal` on +stdout is the terminal gate `fleet dashboard` already uses. See proposal.md +for the motivation; the spec delta in this change is the behaviour contract. + +## Goals / Non-Goals + +**Goals:** + +- The serve view on a terminal: the detail screen's three-section frame, each + resource series drawn in both formats at once, the engine's log tailed with + arrow-key scrolling, and the keys and exit the spec delta names. +- One data path: the view reads the in-process daemon the serve process + already builds for `--api`, so the view works with or without the flag and + no second log mechanism is introduced. +- A non-terminal serve — with or without `--api` — behaves exactly as today. + +**Non-Goals:** + +- No changes to the fleet dashboard (it keeps one format at a time with the + `g` toggle) or to the one-shot `remote metrics` / `fleet metrics` formats. +- No starting, stopping, keeping or aborting from the view; the engine is + serve's own, and leaving stops it. +- No change to the control API surface: the log endpoint's contract is + unchanged; a view run merely gives it a file to serve. +- No log capture for non-terminal runs (their `serve --api` log endpoint + keeps answering "missing", as it does today). + +## Decisions + +**D1 — The terminal gate is stdout, checked before the engine starts.** +`term.IsTerminal(int(os.Stdout.Fd()))`, the dashboard's own check, decides the +view path after the command is built and printed and `--dry-run` has had its +say. A non-terminal run takes the existing exec path untouched. +*Alternative:* also require stdin to be a terminal — rejected; it adds an +edge the dashboard does not have, and bubbletea's own failure mode covers a +hostile terminal. + +**D2 — The view reads the in-process daemon, not its own HTTP API.** +Whenever the view opens — `--api` or not — the serve process runs the engine +through the shared supervised-foreground construction (D8), and the model +calls `d.Status()`, `d.Metrics(ctx)` and `daemon.ReadLog` directly on the +daemon it returns. These are the same functions the API handlers call, so the +view and the API cannot report different facts about the same engine. +*Alternative:* always listen and have the view talk to its own API through +`fleet.daemonNode` — rejected; it adds a socket, a token rule, and a loopback +dependency to a flag that exists to add precisely that, and the dashboard +seam buys serve nothing the in-process calls do not give it. + +**D3 — Engine output is captured to the daemon's state-dir engine log.** +The view run gives the supervisor +`filepath.Join(stateDir, "engine.log")` — the daemon's own file — so the +capture holds the engine's whole output from its first line, the view tails +it by byte offset, the status reports its path, and `serve --api`'s log +endpoint serves it. The file outlives the run, as the daemon's does. +*Alternative:* an in-memory ring buffer as the only log — rejected; it loses +the `/v1/logs` improvement and stands up a second log mechanism beside the +daemon's. + +**D4 — Both formats are one renderer, per series.** +A new shared function in `metrics_render.go` (the bar and gauge formats' +`barSeriesList` supplies the series and their order: CPU, RAM, each GPU's +utilisation and memory) draws, per series: the gauge of the current reading, +then — where the history holds samples — the sparkline beneath it, the bar +format's no-history rule making a history-less series gauge-only. The gauge +line carries the label; the sparkline line passes an empty label so the two +stack in the label column. `renderGauge` gains a width parameter (its +callers pass today's 25; the view passes `barLineW`), so gauge and bar share +one draw width and line up. +*Alternative:* a gauge block over a bar block — rejected; it separates +"now" from "trend" per resource, which is what the issue's "show both" does +not ask for. + +**D5 — The log pane scrolls an in-memory tail, clamped to a line budget.** +The model keeps the tailed content (most recent last) and `behind` — how +many lines the window's bottom sits behind the newest; 0 is at the tail. +Each poll (the detail view's 3-second cadence, same one-shot rescheduled +tick and generation guard) reads from the stored byte offset, appends, and +trims to a line budget (a few thousand lines, well past any pane, bounded in +memory; the file on disk keeps the whole record). `up`/`down` move `behind` +by one, `pgup`/`pgdown` by the pane's height, clamped so the window never +shows past the oldest retained line; while `behind` is 0 new lines keep it +at the tail, and while it is not, the window stays put as new lines arrive. +The displayed slice is the last `paneRows` lines ending `behind` from the +end, so the clamp and the stick are arithmetic on two integers, testable +without a terminal. A `StaleOffset` reply (the file shrank) resets the +offset to the reply's `NextOffset`, the rule the log read defines. +*Alternative:* scroll the file by offset — rejected; `ReadLog` is +forward-only with a 256 KiB read bound, so reaching far back means paging +and mid-line bookkeeping, and the detail view already establishes the +in-memory content pattern the budget generalises. + +**D6 — One new file, the frame helpers reused.** +`cmd/spinloop/serve_view.go` holds the model and its `View()`, drawn from +the detail screen's own parts: `dashTitleBar` (screen "serve", the +Spinloop's path and the log's following/paused state to the right), the +three-section frame with dividers, the metrics section's lines +(`dashStateLine`, `dashTileServingLine`, `renderActiveIndented` with no keep +deadline, D4's renderer, `renderTokenLines`), and the footer through the +existing key-hint helpers. The key help names exactly what the view answers +to — `↑↓` scroll, `pgup`/`pgdown` page, `f` follow, `q` quit — and nothing +else, per the cli-ux rule. Stale readings carry their age through the +detail view's own age rule, so a tick that could not renew a reading is not +drawn as current. + +**D7 — Refresh cadence matches the local node.** +One 2-second tick (the dashboard's local cadence) takes an in-process +status-plus-metrics reading and replaces the view's; the log poll chain runs +on its own 3-second cadence, independently, exactly as the detail view keeps +its log poll separate from the grid's refresh. A failed reading leaves the +last one in place with its age. + +**D8 — One shared construction for the supervised foreground engine.** +The daemon-plus-supervisor plumbing `runServeForegroundAPI` already has — +the supervisor, the daemon with its served name, scrape target, engine +endpoint and refusing start stub, the sampler for the run's life, +`MarkActive`, the signal relay, the graceful stop, and the exit-status rule +(a stop on request is success) — is extracted into one helper that the view +path and the `--api` path both call. It is parameterised only by the +supervisor's log target — the state-dir engine log for a view run, empty for +a non-terminal `--api` run, which forwards stdio as today — and whether the +control API listener comes up, which is `--api`'s own say. Nothing else +differs, so the two paths cannot drift: served, scraped and probed the same +way, stopped the same way, exited the same way. `withMetricsArgs`, +`scrapeTargetFor` and `engineEndpointFor` live inside it (an engine with no +metrics dialect gets no added switch and the host's series). The engine +still starts before the view opens, so a missing binary fails with its +install hint around no view; the view's own pieces — the program on the +alternate screen, `m.send = prog.Send` (the dashboard's own door), the +engine-exited message from the `sup.Wait()` goroutine that the model quits +on, and `q`/Ctrl+C and the inherited `SIGINT`/`SIGTERM` handler routing to +the same stop — sit on top of the helper rather than beside it, and the +narration (the command block and the preset/model line) goes to stderr in +the view path because stdout is the view's screen, passed through +`buildServeArgv` rather than printed there. +*Alternative:* the view path assembles its own daemon setup, kept matched to +`--api`'s by review — rejected; two setup blocks for one object drift, and +the second is where the first's later changes stop being applied. Opening +the view before the engine starts, so a key starts it — also rejected; +serve exists to run the engine, and the engine-not-installed scenario must +keep failing the way it does today. + +## Risks / Trade-offs + +- [An interactive user who expected raw logs gets a screen] → the + motivation for the issue; the command and narration still appear (on + stderr, in the scrollback after exit), piped and scripted runs are + byte-for-byte unchanged, and `q` leaves as easily as it entered. +- [Ctrl+C on a terminal changes from a hard SIGINT to the view's quit] → + the quit is a graceful stop with escalation, the behaviour `serve --api` + already has for Ctrl+C; a hard kill remains available as it always was. +- [The in-memory log tail is a second copy of the log] → bounded by the line + budget and trimmed to it; the file on disk is the record, and the copy is + the same pattern the dashboard's detail view already uses. +- [A terminal that is a TTY but cannot do an alternate screen] → the + dashboard has the same exposure; bubbletea restores the terminal on exit + whatever key got there, and the non-terminal path is untouched. +- [Metrics for a view run depend on the engine's endpoint being reachable + from the host] → the scrape target resolution already handles bind, + BASEURL and the engine defaults in that order, and an engine with no + metrics endpoint degrades to the host's series rather than failing the + view. + +## Migration Plan + +One CLI release; no data or config migration. Non-terminal behaviour is +unchanged, so nothing scripted depends on the new path. Rollback is a revert. + +## Open Questions + +None that would change the spec or the task breakdown; the log line budget +and exact pane proportions are tunable during implementation. diff --git a/openspec/changes/serve-ui/proposal.md b/openspec/changes/serve-ui/proposal.md new file mode 100644 index 0000000..eabe217 --- /dev/null +++ b/openspec/changes/serve-ui/proposal.md @@ -0,0 +1,69 @@ +## Why + +`spinloop serve` streams the engine's raw output straight to the terminal: the +operator sitting next to their own engine cannot see how hard it is working — +CPU, RAM, GPU, token counters — and once a log line has scrolled past it is +gone. The fleet dashboard already has a detail screen showing a node's metrics +and tailed log, but the machine where the engine runs in the foreground has +nothing equivalent. + +## What Changes + +- **BREAKING (interactive runs only):** `spinloop serve` on a terminal opens a + full-screen view instead of forwarding the engine's stdio: the engine's + metrics — state, what it serves, last active, the resource series, the token + counters — above the engine's log, in the three-section layout of the fleet + dashboard's node detail screen. A run whose output is not a terminal keeps + today's stdio-forwarded behaviour exactly. +- The view draws every resource series in both formats at once — the gauge of + the current reading and the bar of the retained history — where the + dashboard draws one or the other, toggled by `g`. +- The up and down arrow keys scroll the log pane through older output (page up + and page down by a page); while the pane is on the newest line, new output + appears as it is written. `f` pauses and resumes the log's follow, as in the + detail screen. +- Under the view the engine's stdout and stderr are captured to the daemon's + state-dir engine log — the same file `spinloop daemon` writes — instead of + being forwarded to the terminal. The view tails that file, and with `--api` + the control API's log endpoint serves it, so `serve --api`'s log endpoint + reports the real log rather than "missing". +- `serve --api` shows the same view with the control API listening alongside. +- The view run switches the engine's own metrics endpoint on for an engine + that has one — the same rule a supervised engine follows — and runs the + daemon's activity and history sampling for the life of the view, so the bars + have history to draw. An engine with no metrics endpoint gets the host's + series, as any node does. +- `q` or Ctrl+C stops the engine and exits; when the engine exits on its own + the view closes and serve exits with the engine's exit status, as today. + +## Capabilities + +### New Capabilities + +(none — the view is a surface of `spinloop serve`, which `local-serving` owns, +the same way the dashboard's detail view lives in `fleet-client`) + +### Modified Capabilities + +- `local-serving`: the stdio-forwarded foreground becomes the non-terminal + case; on a terminal serve runs the view. New requirements for the view + itself — its terminal gate and layout, both formats per series, the log's + tail and arrow-key scroll, its keys and exit, and the engine-output capture + it runs on — and the "Serve basics" and "Control API flag" requirements + change with it. + +## Impact + +- `cmd/spinloop/serve.go`, `cmd/spinloop/serve_daemon.go` — the terminal + check, the view's launch, and the supervised-foreground construction pulled + out of `serve --api` into one helper the view path and the `--api` path + share, parameterised by the log target and the API listener. +- A new model/renderer pair in `cmd/spinloop/` for the serve view, reusing the + fleet detail screen's frame helpers, the daemon's in-process + status/metrics/log reads, and the shared metrics renderers. +- `cmd/spinloop/metrics_render.go` — a combined renderer drawing each + series' gauge and bar together, and a width parameter on the gauge. +- `openspec/specs/local-serving/spec.md` — updated by this change's delta. +- `docs/commands/serve.md` — the foreground description and the view's keys. +- No new dependencies: bubbletea and lipgloss are already used by the fleet + dashboard. diff --git a/openspec/changes/serve-ui/specs/local-serving/spec.md b/openspec/changes/serve-ui/specs/local-serving/spec.md new file mode 100644 index 0000000..b2fe0ab --- /dev/null +++ b/openspec/changes/serve-ui/specs/local-serving/spec.md @@ -0,0 +1,256 @@ +## MODIFIED Requirements + +### Requirement: Serve basics + +`spinloop serve [path]` SHALL read a Spinloop (default `./Spinloop`, aliases and +directories accepted like every Spinloop command), build the command for the +engine its `PROVIDER` names, print it in copy-pasteable shell form, and run it. +`--dry-run`/`-n` SHALL print the command without launching. A missing binary +SHALL produce an install hint naming **that** engine rather than a raw exec +error. + +A run whose stdout is not a terminal SHALL forward the engine's stdout and +stderr to serve's own, exactly as before the view existed. A run on a terminal +SHALL run the engine under the serve view, whose log section is fed by the +engine's captured output (see The serve view); the command serve prints before +running SHALL be written to stderr there, since stdout is the view's screen. + +#### Scenario: Dry run + +- **WHEN** the user runs `spinloop serve --dry-run` +- **THEN** the resolved command is printed and no server starts + +#### Scenario: Engine not installed + +- **WHEN** the selected engine's binary cannot be found +- **THEN** the error suggests installing that engine, not another one + +#### Scenario: A piped run forwards the engine's output + +- **WHEN** `spinloop serve` runs with its stdout piped or redirected +- **THEN** the engine's stdout and stderr are forwarded to serve's own, no + view opens, and the printed command stays on stdout + +### Requirement: Control API flag + +`spinloop serve` SHALL accept `-a`/`--api` to expose the control API over the +foreground engine, as defined by the `daemon-api` capability. Serve SHALL +remain a foreground command with no daemon flag — long-lived supervision is +`spinloop daemon`'s job. The flag SHALL change only whether the control API +listens: the foreground behaviour — the view on a terminal, stdio forwarding +off one — is the same with and without it. + +#### Scenario: Plain serve is unchanged + +- **WHEN** the user runs `spinloop serve` without `--api`, with output not on + a terminal +- **THEN** the engine runs in the foreground with stdio forwarded, exactly as + before + +#### Scenario: Serve with the API stays foreground + +- **WHEN** the user runs `spinloop serve -a` +- **THEN** the engine runs in the foreground with the control API listening + beside it, and the foreground behaviour is the same as without the flag + +## ADDED Requirements + +### Requirement: The serve view + +`spinloop serve` on a terminal SHALL open a full-screen view of the engine it +is running: the engine's metrics, the engine's log, and a line naming the keys +the view answers to, in the three-section layout of the fleet dashboard's node +detail screen. The view SHALL need a terminal to draw on: a run whose output +is not a terminal SHALL NOT open it, and `--dry-run` SHALL open it neither, +printing the command without launching as it does today. + +The view's metrics section SHALL show the same facts, in the same wording, +that the dashboard's detail screen and the metrics formats show for the same +engine — state, what is served, last active, the resource series, and the +token and request counters — read from the daemon the serve process runs +in-process rather than over the network, refreshed on the dashboard's own +local cadence. A reading the view could not renew SHALL be shown with its age +rather than drawn identically to one just read. + +The view SHALL draw every resource series the reading carries in both formats +at once: the gauge of the current reading and, beneath it, the bar of the +retained history — the same series and labelling the bar and gauge formats +use, with the bar format's no-history rule where a series has no history to +draw, so a series with none carries its gauge alone. + +#### Scenario: The view opens on a terminal + +- **WHEN** the user runs `spinloop serve` at an interactive terminal +- **THEN** the view opens showing the engine's metrics above its log, with a + line naming the keys the view answers to + +#### Scenario: A piped run gets no view + +- **WHEN** `spinloop serve` runs with its stdout piped or redirected +- **THEN** no view opens and the engine's output is forwarded to serve's own + +#### Scenario: The metrics match the detail screen + +- **WHEN** the view is open on a running engine +- **THEN** its metrics section shows the same state, serving facts, last + active, resource series and counters the dashboard's detail screen shows + for the same engine, in full rather than clipped + +#### Scenario: Every series is drawn in both formats + +- **WHEN** the reading carries a CPU series with a retained history +- **THEN** the view draws the series' gauge of the current reading and, + beneath it, its bar of the retained history + +#### Scenario: A series with no history carries its gauge alone + +- **WHEN** a series has no retained history to draw +- **THEN** the view draws its gauge of the current reading only + +### Requirement: The serve view's log + +The view's log section SHALL show the engine's log, tailing and following it +the same way the dashboard's detail view follows its node's log: new output +appears while the view is open without the operator asking for it. An engine +that has written nothing yet SHALL show a waiting note, not an empty pane. + +The up and down arrow keys SHALL scroll the log pane: up moves the visible +window one line towards the oldest retained line, down one line towards the +newest; a press at either end SHALL leave the window where it is. Page up and +page down SHALL move the window by the pane's height. While the window is on +the newest line, new output SHALL appear in the pane as it is written; while +the window is scrolled away from it, new output SHALL be retained and the pane +SHALL stay where the operator put it until they scroll back to the newest +line, where it sticks again. + +The operator SHALL be able to pause and resume the log's follow from the +keyboard, independently of the rest of the view: while paused, the pane SHALL +stop picking up new output, and the view SHALL show whether the log is +following or paused. Nothing written while paused is lost: resuming SHALL +fetch and show whatever the engine wrote in the meantime, and pausing SHALL +not affect the metrics section's own refresh. + +#### Scenario: The log pane follows new output + +- **WHEN** the engine writes to its log while the view is open and the window + is on the newest line +- **THEN** the new lines appear in the log section without the operator + pressing any key + +#### Scenario: Scrolling the log + +- **WHEN** the operator presses the up arrow +- **THEN** the window moves one line towards the older output, and the down + arrow moves it back, line for line, until it is on the newest line again + and sticks to it + +#### Scenario: Paging the log + +- **WHEN** the operator presses page up +- **THEN** the window moves by the pane's height towards the older output, + clamped at the oldest retained line + +#### Scenario: An engine that has written nothing yet + +- **WHEN** the view is open and the engine has written no log output +- **THEN** the log section shows a waiting note, not an empty pane + +#### Scenario: Pausing the log + +- **WHEN** the operator pauses the log's follow +- **THEN** the pane stops picking up new output and the view shows that the + log is paused, while the metrics section keeps refreshing on its own cadence + +#### Scenario: Resuming the log + +- **WHEN** the operator resumes a paused log +- **THEN** whatever the engine wrote while paused appears in the pane, and + new output continues to appear as it is written + +### Requirement: The serve view's keys and exit + +The view SHALL name its keys on screen and offer only the ones that would do +something in it: the up and down arrows and page up and page down scroll the +log, `f` pauses and resumes the log's follow, and `q` or Ctrl+C leaves. The +view SHALL NOT offer start, stop, keep or abort keys: the engine is serve's +own — starting is serve's job, and stopping it is what leaving does. + +`q` and Ctrl+C SHALL stop the engine — gracefully, escalating as a stop does +elsewhere — and exit serve. When the engine exits on its own, whatever the +cause, the view SHALL close and serve SHALL exit with the engine's exit +status, exactly as a foreground serve does today. + +#### Scenario: The key help names only live keys + +- **WHEN** the view draws its key help line +- **THEN** it names the scroll, follow and quit keys, and nothing the view + cannot do + +#### Scenario: Quitting stops the engine + +- **WHEN** the operator presses q or Ctrl+C +- **THEN** the engine is stopped and serve exits + +#### Scenario: The engine's own exit closes the view + +- **WHEN** the engine process exits while the view is open +- **THEN** the view closes and serve exits with the engine's exit status + +### Requirement: Engine output capture under the serve view + +When serve runs the view, the engine's stdout and stderr SHALL be captured to +the daemon's state-dir engine log — the same file `spinloop daemon` writes — +rather than forwarded to serve's stdio. The capture SHALL hold the engine's +whole output from its first line, so the log the view tails is complete, and +the log's path SHALL be the one the control API's status reports. With +`--api`, the API's log endpoint SHALL serve the captured file rather than +reporting the log missing. + +#### Scenario: The engine's output lands in the log + +- **WHEN** the engine writes to stdout or stderr while the view is open +- **THEN** the output is appended to the engine log file named in the + daemon's status, and appears in the view's log section + +#### Scenario: serve --api's log endpoint serves the capture + +- **WHEN** `spinloop serve --api` runs under the view and a client asks its + log endpoint for the engine log +- **THEN** the reply carries the engine's output, not the missing-log answer + +#### Scenario: Off the terminal nothing is captured + +- **WHEN** `spinloop serve` runs with its output not on a terminal +- **THEN** the engine's output is forwarded to serve's stdio and the run + writes no engine log file + +### Requirement: The view's metrics sampling + +For an engine that exposes a metrics endpoint, a view run SHALL switch that +endpoint on before the engine starts — the same switch a supervised engine +gets — so the counters and the history the bars draw are the engine's own. +The daemon's activity and history sampling SHALL run for the life of the view, +the same sampling a running engine gets under the daemon, so the bars have a +retained history to draw. An engine with no metrics endpoint SHALL run with no +added switch, and its view SHALL draw the host's series — CPU, RAM and the +GPUs — as any node does. + +#### Scenario: A metrics-capable engine is switched on + +- **WHEN** `spinloop serve` opens the view for an engine that has a metrics + endpoint +- **THEN** the engine is launched with its metrics endpoint on, the same way + a supervised engine is + +#### Scenario: History accrues for the bars + +- **WHEN** the engine has been running for several sampler ticks under the + view +- **THEN** the bars draw the retained history of the ticks so far + +#### Scenario: An engine with no metrics endpoint + +- **WHEN** `spinloop serve` opens the view for an engine that exposes no + metrics endpoint +- **THEN** the engine is launched without any added switch, and the view + draws the host's CPU, RAM and GPU series diff --git a/openspec/changes/serve-ui/tasks.md b/openspec/changes/serve-ui/tasks.md new file mode 100644 index 0000000..5459fcb --- /dev/null +++ b/openspec/changes/serve-ui/tasks.md @@ -0,0 +1,31 @@ +## 1. Combined bar-and-gauge metrics rendering + +- [ ] 1.1 Give `renderGauge` a width parameter in `cmd/spinloop/metrics_render.go`, updating its existing callers to pass today's 25-column width, and verify the existing metrics render tests pass unchanged +- [ ] 1.2 Add the combined renderer (each series from `barSeriesList` as its gauge line of the current reading, then its sparkline line beneath where the history holds samples, the sparkline's label blank so the pair stacks, a history-less series gauge-only) and verify with table-driven tests covering: a series with history (both lines), a series with none (gauge alone), multi-GPU labelling, and the 80/90 colour thresholds on the gauge + +## 2. Serve view model + +- [ ] 2.1 Create `cmd/spinloop/serve_view.go` with the model's state (the metrics reading and its time, the tailed log content, its byte offset, its line budget, the scroll position and the follow flag, the window size) and its `Init`/`Update`/`View` shape, and verify the package compiles and an initial-state test passes +- [ ] 2.2 Add the metrics tick: a one-shot 2-second tick taking an in-process status-plus-metrics reading through an injected read function, a failed or stale reading leaving the last one in place with its age, and verify with tests that a reading replaces the prior one and a failed read keeps the last +- [ ] 2.3 Add the log poll: a one-shot 3-second tick with a generation guard, reading through an injected log read with the daemon's log semantics (tail on first read, resume from the stored offset, `StaleOffset` resetting to the reply's `NextOffset`), appending and trimming to the line budget, and verify with tests for the first read's backlog, no duplicates across polls, a stale-offset resume, and a superseded poll being discarded +- [ ] 2.4 Add the keys: `up`/`down` moving the scroll by one line, `pgup`/`pgdown` by the pane's height, clamped at the oldest retained line and the newest, the window sticking to the tail at the newest line and staying put while scrolled away, `f` pausing and resuming the follow, and `q`/Ctrl+C quitting, and verify with table-driven key tests over the scroll positions and the follow flag +- [ ] 2.5 Add the engine-exited message delivered through the model's `send` seam (the dashboard's `prog.Send` door), quitting the program on it, and verify a test drives the message and asserts the quit + +## 3. Serve view frame + +- [ ] 3.1 Draw the frame in `View()`: the title bar (screen "serve", the Spinloop's path and the log's state to the right), the metrics section (state with uptime, the serving line, the last-active line, the combined renderer, the token lines), the log section with the waiting note where there is no content yet, the dividers, and the footer key help naming exactly the scroll, follow and quit keys, reusing the detail screen's `dashTitleBar`, key-hint and clip helpers, and verify with render tests over a fixed model and terminal size +- [ ] 3.2 Show the log's following/paused state in the title bar from the follow flag, and verify a render test for each state + +## 4. `serve` wiring + +- [ ] 4.1 Gate the view on `term.IsTerminal` of stdout in `runServe` (never for `--dry-run`, never off the terminal), pass the narration writer through `buildServeArgv` so the command and preset/model lines go to stderr under the view and stay on stdout off it, and verify the existing serve tests pass plus a test that the gate is applied through an injectable check +- [ ] 4.2 Pull the supervised-foreground construction out of `runServeForegroundAPI` into one helper — the supervisor, the daemon with its served name, scrape target, engine endpoint and refusing start stub, the metrics switch for an engine that has one, the sampler for the run's life, the signal relay, the graceful stop and the exit-status rule (a stop on request as success) — parameterised only by the supervisor's log target (the state-dir engine log, or empty for stdio forwarding) and whether the control API listener comes up, and point the existing non-terminal `--api` path at it, and verify the existing foreground-serve tests pass unchanged +- [ ] 4.3 Build the view run on that helper — log target the state-dir engine log, listener per `--api`, the engine started before the program opens so a missing binary fails with its install hint around no view, and the narration on stderr — and verify with stub-engine tests covering: the metrics switch present for a metrics-capable engine, absent for one with no metrics dialect, the log file holding the engine's output, and the not-found hint +- [ ] 4.4 Run the program on the alternate screen with `send` wired, the `sup.Wait()` goroutine delivering the engine-exited message, `q`/Ctrl+C and the inherited `SIGINT`/`SIGTERM` handler routing to the helper's stop, serve exiting with the engine's exit status, and `--api` adding the listener and its shutdown, and verify with the existing foreground-serve test patterns: the stop-on-request success path, the non-zero exit path, and the non-terminal `--api` run answering its API as before +- [ ] 4.5 Update `serve`'s long help to describe the view and its keys, and verify `go run ./cmd/spinloop serve --help` shows the new text + +## 5. Docs and verification + +- [ ] 5.1 Update `docs/commands/serve.md` for the view: its layout, its keys, the terminal/non-terminal split, and `serve --api`'s log endpoint serving the captured log, and verify the file reads back consistent with the spec delta +- [ ] 5.2 Run `gofmt -l .`, `go vet ./...` and `go test ./... -cover`, and verify all are clean with total coverage at or above 80% +- [ ] 5.3 Smoke both paths by hand: on a terminal, run `spinloop serve` against a stub engine and confirm the view opens with gauge and bar per series, the log follows, the arrows scroll and stick to the tail, `f` pauses, and `q` stops the engine cleanly; off the terminal, confirm `spinloop serve | cat` forwards the engine's output exactly as before, and verify by the observed behaviour From d55863595cb226125bfd4d1a2dbef774d21f90e2 Mon Sep 17 00:00:00 2001 From: Pete Cornish Date: Mon, 7 Sep 2026 00:53:54 +0100 Subject: [PATCH 2/5] feat(serve): show the engine's metrics and log in a full-screen view --- cmd/spinloop/metrics_render.go | 30 +- cmd/spinloop/metrics_render_test.go | 93 ++++- cmd/spinloop/serve.go | 52 ++- cmd/spinloop/serve_argv_test.go | 7 +- cmd/spinloop/serve_daemon.go | 116 +++++-- cmd/spinloop/serve_daemon_test.go | 376 ++++++++++++++++++++ cmd/spinloop/serve_view.go | 510 ++++++++++++++++++++++++++++ cmd/spinloop/serve_view_test.go | 503 +++++++++++++++++++++++++++ docs/commands/serve.md | 52 ++- openspec/changes/serve-ui/tasks.md | 34 +- 10 files changed, 1701 insertions(+), 72 deletions(-) create mode 100644 cmd/spinloop/serve_view.go create mode 100644 cmd/spinloop/serve_view_test.go diff --git a/cmd/spinloop/metrics_render.go b/cmd/spinloop/metrics_render.go index ea2de6d..dbe53b7 100644 --- a/cmd/spinloop/metrics_render.go +++ b/cmd/spinloop/metrics_render.go @@ -137,6 +137,11 @@ const barLineW = 40 // full row fits the tile exactly and the clip never takes the percentage. const dashBarLineW = 25 +// gaugeW is the gauge's draw width in the one-shot formats — the width +// renderGauge has always drawn at. The serve view draws its gauges at +// barLineW instead, so the gauge and the bar beneath it share one width. +const gaugeW = 25 + // barGlyphs is the seven sub-full block elements the sparkline draws with, // lightest to heaviest: a series' value maps to the one whose fill height is // nearest. The set stops one grade short of the full block, so the tallest row @@ -217,8 +222,7 @@ func renderSparkline(w io.Writer, label string, samples []float64, width int) { // filled portion in the state colour, the unfilled portion in light shade, // the percentage in the terminal's default colour. It draws the current // reading only — it carries no history. -func renderGauge(w io.Writer, label string, pct float64) { - const width = 25 +func renderGauge(w io.Writer, label string, pct float64, width int) { colour := ansiGreen if pct > 90 { colour = ansiRed @@ -366,7 +370,25 @@ func renderStatBars(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, if len(s.history) > 0 { renderSparkline(w, s.label, s.history, lineW) } else { - renderGauge(w, s.label, *s.current) + renderGauge(w, s.label, *s.current, gaugeW) + } + } +} + +// renderStatCombined draws the resource series in the serve view's format: +// each series as a gauge of its current reading with its retained history as +// a sparkline beneath, so "now" and "trend" sit together per resource instead +// of being a toggle. The gauge line carries the label and the sparkline line +// passes a blank one, so the pair stacks in the label column; a series with +// no retained history carries its gauge alone, and a series with no current +// reading its sparkline alone, so the two halves never draw the same line. +func renderStatCombined(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, gpus []metrics.GpuStat, history []metrics.HistorySample, lineW int) { + for _, s := range barSeriesList(cpu, mem, gpus, history) { + if s.current != nil { + renderGauge(w, s.label, *s.current, lineW) + } + if len(s.history) > 0 { + renderSparkline(w, "", s.history, lineW) } } } @@ -376,7 +398,7 @@ func renderStatBars(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, func renderStatGauges(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, gpus []metrics.GpuStat) { for _, s := range barSeriesList(cpu, mem, gpus, nil) { if s.current != nil { - renderGauge(w, s.label, *s.current) + renderGauge(w, s.label, *s.current, gaugeW) } } } diff --git a/cmd/spinloop/metrics_render_test.go b/cmd/spinloop/metrics_render_test.go index 00ee879..1e7a1fc 100644 --- a/cmd/spinloop/metrics_render_test.go +++ b/cmd/spinloop/metrics_render_test.go @@ -110,14 +110,14 @@ func TestRenderSparklineColoursOnlyTheLastPoint(t *testing.T) { func TestRenderGauge(t *testing.T) { var b bytes.Buffer - renderGauge(&b, "CPU", 42) + renderGauge(&b, "CPU", 42, gaugeW) want := " CPU " + ansiGreen + strings.Repeat("█", 10) + ansiReset + strings.Repeat("░", 15) + " 42%\n" if got := b.String(); got != want { t.Errorf("gauge = %q, want %q", got, want) } // A value beyond 100 fills the gauge rather than spilling past it. b.Reset() - renderGauge(&b, "CPU", 150) + renderGauge(&b, "CPU", 150, gaugeW) want = " CPU " + ansiRed + strings.Repeat("█", 25) + ansiReset + " 150%\n" if got := b.String(); got != want { t.Errorf("out-of-range gauge = %q, want %q", got, want) @@ -307,6 +307,95 @@ func TestRenderStatGaugesIgnoresHistory(t *testing.T) { } } +// The serve view's format draws both halves together: each series as a gauge +// of its current reading with its retained history as a sparkline beneath, +// the gauge carrying the label and the sparkline a blank one, so the pair +// stacks in the label column. +func TestRenderStatCombined(t *testing.T) { + cpu := &metrics.CpuStat{Utilization: 42} + mem := &metrics.MemoryStat{Total: 1000, Used: 300} + gpus := []metrics.GpuStat{{Index: 0, Name: "H100", Utilization: 61, MemoryUsed: 80, MemoryTotal: 160}} + history := []metrics.HistorySample{ + {Time: 1, CPU: ptrPct(10), Mem: ptrPct(20), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 30, Mem: ptrPct(10)}}}, + {Time: 2, CPU: ptrPct(95), Mem: ptrPct(30), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 91, Mem: ptrPct(20)}}}, + } + var b bytes.Buffer + renderStatCombined(&b, cpu, mem, gpus, history, barLineW) + lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") + // One gauge and one sparkline per series, in the bar series' order. + if len(lines) != 8 { + t.Fatalf("drew %d lines, want 8: %q", len(lines), b.String()) + } + for i, label := range []string{" CPU ", " RAM ", " GPU util ", " GPU mem "} { + if !strings.HasPrefix(lines[i*2], label) { + t.Errorf("gauge line for %s: %q", label, lines[i*2]) + } + // The sparkline beneath leaves the label column blank. + if !strings.HasPrefix(lines[i*2+1], strings.Repeat(" ", 12)) { + t.Errorf("sparkline line took the label column: %q", lines[i*2+1]) + } + } + // Both halves take the state colour: the gauge over its whole fill, the + // sparkline on its last glyph only. + if !strings.Contains(lines[0], ansiGreen+strings.Repeat("█", 16)+ansiReset) { + t.Errorf("CPU gauge: %q", lines[0]) + } + // The sparkline stops one grade short of the full block, so the 95% + // sample draws the top of the seven sub-full glyphs. + if !strings.Contains(lines[1], ansiRed+"▇"+ansiReset+" 95%") { + t.Errorf("CPU sparkline: %q", lines[1]) + } +} + +// A memory reading with no total reports 0, not a division by it, in either +// half of the combined format. +func TestRenderStatCombinedMemoryWithoutTotal(t *testing.T) { + var b bytes.Buffer + renderStatCombined(&b, nil, &metrics.MemoryStat{Total: 0, Used: 100}, nil, nil, barLineW) + if !strings.Contains(b.String(), " 0%") || strings.Contains(b.String(), "NaN") { + t.Errorf("a memory reading with no total: %q", b.String()) + } +} + +// Without retained history the format degenerates to the gauge format: each +// series carries its gauge alone, byte for byte the gauge drawing at the +// same width. +func TestRenderStatCombinedWithoutHistory(t *testing.T) { + cpu := &metrics.CpuStat{Utilization: 42} + mem := &metrics.MemoryStat{Total: 1000, Used: 300} + gpus := []metrics.GpuStat{{Index: 0, Name: "H100", Utilization: 61, MemoryUsed: 80, MemoryTotal: 160}} + var got, want bytes.Buffer + renderStatCombined(&got, cpu, mem, gpus, nil, gaugeW) + renderStatGauges(&want, cpu, mem, gpus) + if got.String() != want.String() { + t.Errorf("no-history combined differs from the gauge drawing:\ngot:\n%q\nwant:\n%q", got.String(), want.String()) + } +} + +// A stopped engine carries no current figures, so the combined format draws +// the retained readings alone — the sparkline lines with their blank label +// column, no gauges at all. +func TestRenderStatCombinedStoppedEngineDrawsHistoryAlone(t *testing.T) { + history := []metrics.HistorySample{ + {Time: 1, CPU: ptrPct(10), Mem: ptrPct(20), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 50, Mem: ptrPct(50)}}}, + {Time: 2, CPU: ptrPct(20), Mem: ptrPct(30), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 60, Mem: ptrPct(60)}}}, + } + var b bytes.Buffer + renderStatCombined(&b, nil, nil, nil, history, barLineW) + lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") + if len(lines) != 4 { + t.Fatalf("drew %d lines, want CPU, RAM, GPU util and GPU mem: %q", len(lines), b.String()) + } + for _, line := range lines { + if !strings.HasPrefix(line, strings.Repeat(" ", 12)) { + t.Errorf("a line took the label column: %q", line) + } + } + if !strings.Contains(lines[1], " 30%") || !strings.Contains(lines[3], " 60%") { + t.Errorf("sparklines lost their last readings: %q", strings.Join(lines, " / ")) + } +} + func TestFormatMetricsBarStoppedWithHistory(t *testing.T) { resp := &remote.StatsResponse{ Environment: "prod", State: "stopped", ModelID: "org/qwen:q4", diff --git a/cmd/spinloop/serve.go b/cmd/spinloop/serve.go index 500dd43..4ed091b 100644 --- a/cmd/spinloop/serve.go +++ b/cmd/spinloop/serve.go @@ -9,6 +9,7 @@ package main import ( "errors" "fmt" + "io" "net/url" "os" "os/exec" @@ -22,6 +23,7 @@ import ( "github.com/spinloop-ai/spinloop/internal/preset" "github.com/spinloop-ai/spinloop/internal/spinloop" "github.com/spinloop-ai/spinloop/internal/spinloopsrc" + "golang.org/x/term" ) // llamaServerBinary is the llama.cpp server executable that `serve` launches. @@ -40,6 +42,13 @@ var vllmBinary = "vllm" // tests can point it at a stub instead of a real install. var mtlxBinary = "mtplx" +// stdoutIsTerminal reports whether serve's stdout is a terminal — the check +// that decides whether the run draws the serve view. A variable so a test +// takes either path without a terminal. +var stdoutIsTerminal = func() bool { + return term.IsTerminal(int(os.Stdout.Fd())) +} + // omlxBundleBinary is where the macOS app installs its CLI. oMLX ships as a // signed app rather than a PATH install, so a user who has only ever launched // it from the menu bar still has this and nothing on their PATH. @@ -208,7 +217,15 @@ func serveCmd() *cobra.Command { With a PRESET it turns the matching section into the command, reading it in that engine's flag vocabulary; otherwise it derives one from the Spinloop's own instructions. Prints the command before running it; --dry-run/-n prints -without launching the server.`, orList(servedProviders())), +without launching the server. + +On a terminal the server runs under a full-screen view: its metrics — each +resource series as a gauge of the current reading with its retained history +as a bar beneath — above its log, which follows new output as it is written. +The arrow keys scroll the log, page up and page down move it by a page, f +pauses and resumes the follow, and q or Ctrl+C leaves, stopping the server +with it. Piped and redirected runs forward the server's output as they +always have, with no view.`, orList(servedProviders())), Args: cobra.ArbitraryArgs, SilenceErrors: true, SilenceUsage: true, @@ -252,21 +269,34 @@ func runServe(args []string, dryRun, apiOn bool, apiAddr, logLevel string) error if err != nil { return err } - argv, err := buildServeArgv(engine, sel, spinloopPath) + // On a terminal the view draws on stdout, so the command and the + // narration go to stderr there — and stay on stdout wherever a pipe or + // redirect reads them. Never for a dry run, which prints and stops. + viewOn := !dryRun && stdoutIsTerminal() + narration := os.Stdout + if viewOn { + narration = os.Stderr + } + argv, err := buildServeArgv(narration, engine, sel, spinloopPath) if err != nil { return err } - if apiOn { + if apiOn || viewOn { // A supervised engine gets its metrics endpoint switched on, exactly - // as the cloud path does for a deployed one. + // as the cloud path does for a deployed one. Applied here so the + // printed command is the one that runs; the shared construction + // applies it to its own copy, where it is a no-op. argv = withMetricsArgs(argv, engine) } - fmt.Printf("%s\n\n", preset.FormatCommand(argv)) + fmt.Fprintf(narration, "%s\n\n", preset.FormatCommand(argv)) if dryRun { return nil } + if viewOn { + return runServeView(sel, spinloopPath, engine, argv, apiOn, apiAddr, logLevel) + } if apiOn { return runServeForegroundAPI(sel, spinloopPath, engine, argv, apiAddr, logLevel) } @@ -286,9 +316,9 @@ func runServe(args []string, dryRun, apiOn bool, apiAddr, logLevel string) error // buildServeArgv turns a Spinloop into the engine command, from its PRESET // section when it names one and from the Spinloop's own instructions otherwise, -// narrating which source it used. It is `spinloop serve`'s alone: the daemon -// reads no Spinloop, so nothing else builds a command this way. -func buildServeArgv(engine serveEngine, sel spinloop.Selection, spinloopPath string) ([]string, error) { +// narrating which source it used to w. It is `spinloop serve`'s alone: the +// daemon reads no Spinloop, so nothing else builds a command this way. +func buildServeArgv(w io.Writer, engine serveEngine, sel spinloop.Selection, spinloopPath string) ([]string, error) { // Anything the Spinloop states overrides the preset's own values. params, err := engine.params(sel) if err != nil { @@ -315,7 +345,7 @@ func buildServeArgv(engine serveEngine, sel spinloop.Selection, spinloopPath str return nil, fmt.Errorf("%s: %w", presetPath, err) } argv := pre.CommandIn(engine.dialect, engine.binary(), subcommandFor(engine, sel), sec, params) - fmt.Printf("Using preset %s (model %s)\n\n", presetPath, sec.Name) + fmt.Fprintf(w, "Using preset %s (model %s)\n\n", presetPath, sec.Name) return argv, nil } @@ -324,11 +354,11 @@ func buildServeArgv(engine serveEngine, sel spinloop.Selection, spinloopPath str } argv := assembleEngineArgv(engine, subcommandFor(engine, sel), params, nil) if sel.Model != "" { - fmt.Printf("Serving %s from %s\n\n", sel.Model, spinloopPath) + fmt.Fprintf(w, "Serving %s from %s\n\n", sel.Model, spinloopPath) } else { // An engine that needs no model to start (oMLX serves a whole // directory) has nothing to name but itself. - fmt.Printf("Starting %s from %s\n\n", sel.Provider, spinloopPath) + fmt.Fprintf(w, "Starting %s from %s\n\n", sel.Provider, spinloopPath) } return argv, nil } diff --git a/cmd/spinloop/serve_argv_test.go b/cmd/spinloop/serve_argv_test.go index 227ee81..e1c57cd 100644 --- a/cmd/spinloop/serve_argv_test.go +++ b/cmd/spinloop/serve_argv_test.go @@ -1,6 +1,7 @@ package main import ( + "io" "path/filepath" "reflect" "strings" @@ -185,7 +186,7 @@ func TestBuildServeArgvPresetlessPerEngine(t *testing.T) { } spinloopPath := filepath.Join(t.TempDir(), spinloop.DefaultFile) captureStdout(t, func() { - argv, err := buildServeArgv(eng, tc.sel, spinloopPath) + argv, err := buildServeArgv(io.Discard, eng, tc.sel, spinloopPath) if err != nil { t.Fatal(err) } @@ -217,7 +218,7 @@ func TestBuildServeArgvPresetBranch(t *testing.T) { var argv []string captureStdout(t, func() { var err error - argv, err = buildServeArgv(eng, sel, filepath.Join(dir, spinloop.DefaultFile)) + argv, err = buildServeArgv(io.Discard, eng, sel, filepath.Join(dir, spinloop.DefaultFile)) if err != nil { t.Fatal(err) } @@ -239,7 +240,7 @@ func TestBuildServeArgvPresetBranch(t *testing.T) { t.Fatal(err) } sel := spinloop.Selection{Provider: "llamacpp", Model: "/a.gguf", Alias: "wrong", Preset: "preset.ini"} - _, err = buildServeArgv(eng, sel, filepath.Join(dir, spinloop.DefaultFile)) + _, err = buildServeArgv(io.Discard, eng, sel, filepath.Join(dir, spinloop.DefaultFile)) if err == nil { t.Fatal("want an error for an alias that matches none of several preset sections, got nil") } diff --git a/cmd/spinloop/serve_daemon.go b/cmd/spinloop/serve_daemon.go index 5112900..b1aaa69 100644 --- a/cmd/spinloop/serve_daemon.go +++ b/cmd/spinloop/serve_daemon.go @@ -201,13 +201,30 @@ func runDaemonCommand(args []string, apiAddr, apiToken, apiTokenFile, logLevel s return nil } -// runServeForegroundAPI is `spinloop serve --api`: the engine runs in the -// foreground with stdio forwarded as ever, with the control API alongside it. Start over the API always fails — the engine is -// foreground-managed and already running — and stop terminates it, after -// which serve exits exactly as it does when the engine exits on its own. -func runServeForegroundAPI(sel spinloop.Selection, spinloopPath string, engine serveEngine, argv []string, apiAddr string, logLevel string) error { +// supervisedForeground is one foreground engine serve supervises — the view +// run and the --api run alike: the daemon and supervisor it runs under, the +// stop that ends it gracefully, and the wait that reports its exit as the +// run's result. +type supervisedForeground struct { + d *daemon.Daemon + stop func() // stop the engine gracefully, escalating as a stop does elsewhere; blocks until it is down + wait func() error // block until the engine exits and the run is wound down; nil where a stop on request or a clean exit counts as success +} + +// startSupervisedForeground is the supervised-foreground construction a +// `spinloop serve` run shares whatever its foreground behaviour is: the +// supervisor, the daemon with its served name, scrape target, engine +// endpoint and refusing start stub, the metrics switch for an engine that +// has one, the sampler for the run's life, the signal relay, the graceful +// stop, and the exit-status rule. It is parameterised only by the +// supervisor's log target — the state-dir engine log for a view run, empty +// for a run that forwards stdio — and whether the control API listener comes +// up, which is --api's own say. Nothing else differs, so the paths cannot +// drift: served, scraped and probed the same way, stopped the same way, +// exited the same way. +func startSupervisedForeground(sel spinloop.Selection, spinloopPath string, engine serveEngine, argv []string, apiOn bool, apiAddr, logLevel, logPath string) (*supervisedForeground, error) { if err := applySpinloopEnv(sel, spinloopPath); err != nil { - return err + return nil, err } token := os.Getenv(daemon.TokenEnvVar) // Resolved after the Spinloop's environment is in place, so unlike the @@ -216,19 +233,24 @@ func runServeForegroundAPI(sel spinloop.Selection, spinloopPath string, engine s // before anything listens. logger, err := commandLogger(logLevel) if err != nil { - return err + return nil, err } - ln, err := daemon.Listen(apiAddr, token) - if err != nil { - return err + var ln net.Listener + if apiOn { + ln, err = daemon.Listen(apiAddr, token) + if err != nil { + return nil, err + } } stateDir, err := daemon.StateDir() if err != nil { - ln.Close() - return err + if ln != nil { + ln.Close() + } + return nil, err } - sup := daemon.NewSupervisor("") // empty LogPath: stdio stays forwarded + sup := daemon.NewSupervisor(logPath) sup.Logger = logger d := &daemon.Daemon{ Sup: sup, @@ -246,6 +268,10 @@ func runServeForegroundAPI(sel spinloop.Selection, spinloopPath string, engine s model = sel.Alias } d.SetServed(sel.Provider, model) + // A supervised engine gets its metrics endpoint switched on, exactly as + // the cloud path does for a deployed one; an engine with no metrics + // dialect gets no added switch and the host's series. + argv = withMetricsArgs(argv, engine) d.SetScrape(scrapeTargetFor(engine, sel.BaseURL, argv)) d.SetEngineEndpoint(engineEndpointFor(engine, sel.BaseURL, argv)) @@ -254,42 +280,66 @@ func runServeForegroundAPI(sel spinloop.Selection, spinloopPath string, engine s // window exists where a signal kills serve and orphans it. sigCh := make(chan os.Signal, 1) signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + stop := func() { sup.Stop() } go func() { <-sigCh - sup.Stop() + stop() }() if err := sup.Start(argv); err != nil { - ln.Close() + if ln != nil { + ln.Close() + } signal.Stop(sigCh) if errors.Is(err, exec.ErrNotFound) || errors.Is(err, os.ErrNotExist) { - return fmt.Errorf("%s not found — %s", argv[0], engine.installHint) + return nil, fmt.Errorf("%s not found — %s", argv[0], engine.installHint) } - return err + return nil, err } // The engine started through the supervisor directly rather than through // StartEngine, so the activity record is stamped here instead. d.MarkActive() - srv := &http.Server{Handler: d.Handler(token)} - logger.Info("control API listening", slog.String("api", ln.Addr().String())) - go srv.Serve(ln) + var srv *http.Server + if apiOn { + srv = &http.Server{Handler: d.Handler(token)} + logger.Info("control API listening", slog.String("api", ln.Addr().String())) + go srv.Serve(ln) + } sampleCtx, stopSampling := context.WithCancel(context.Background()) go d.SampleActivity(sampleCtx) - waitErr := sup.Wait() - stopSampling() - signal.Stop(sigCh) - // Graceful shutdown: a stop requested over the API lands here while its - // response is still in flight — let it finish rather than cutting the - // connection. - shutdownCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second) - srv.Shutdown(shutdownCtx) - cancel() - if state, _, _ := sup.Status(); state == daemon.StateStopped { - // Stopped on request (signal or API) or exited cleanly: not an error. - return nil + wait := func() error { + waitErr := sup.Wait() + stopSampling() + signal.Stop(sigCh) + // Graceful shutdown: a stop requested over the API lands here while + // its response is still in flight — let it finish rather than cutting + // the connection. + if srv != nil { + shutdownCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + srv.Shutdown(shutdownCtx) + cancel() + } + if state, _, _ := sup.Status(); state == daemon.StateStopped { + // Stopped on request (signal or API) or exited cleanly: not an error. + return nil + } + return waitErr + } + return &supervisedForeground{d: d, stop: stop, wait: wait}, nil +} + +// runServeForegroundAPI is `spinloop serve --api` off the terminal: the +// engine runs in the foreground with stdio forwarded as ever, with the +// control API alongside it. Start over the API always fails — the engine is +// foreground-managed and already running — and stop terminates it, after +// which serve exits exactly as it does when the engine exits on its own. +func runServeForegroundAPI(sel spinloop.Selection, spinloopPath string, engine serveEngine, argv []string, apiAddr string, logLevel string) error { + run, err := startSupervisedForeground(sel, spinloopPath, engine, argv, true, apiAddr, logLevel, "") + if err != nil { + return err } - return waitErr + return run.wait() } // daemonAPIAddr resolves the daemon's listen address from its two flags. diff --git a/cmd/spinloop/serve_daemon_test.go b/cmd/spinloop/serve_daemon_test.go index c597ccd..53ba1ff 100644 --- a/cmd/spinloop/serve_daemon_test.go +++ b/cmd/spinloop/serve_daemon_test.go @@ -5,6 +5,7 @@ package main import ( "encoding/json" "fmt" + "io" "net" "net/http" "os" @@ -15,6 +16,7 @@ import ( "testing" "time" + tea "github.com/charmbracelet/bubbletea" "github.com/spinloop-ai/spinloop/internal/daemon" "github.com/spinloop-ai/spinloop/internal/remote" ) @@ -477,6 +479,380 @@ func TestCmdDaemon_StartCarriesDeployConfig(t *testing.T) { } } +// stubEngineView points llamaServerBinary at a script that records its argv, +// writes the named line to its own stdout as it starts, then either runs the +// remainder of body or sleeps until signalled, and restores the binary after. +func stubEngineView(t *testing.T, argsFile, startupLine, body string) { + t.Helper() + script := filepath.Join(t.TempDir(), "llama-server") + src := "#!/bin/sh\nprintf '%s\\n' \"$@\" > " + argsFile + "\necho " + startupLine + "\n" + if body != "" { + src += body + "\n" + } else { + src += "trap 'exit 0' TERM\nwhile true; do sleep 0.05; done\n" + } + if err := os.WriteFile(script, []byte(src), 0o755); err != nil { + t.Fatal(err) + } + orig := llamaServerBinary + llamaServerBinary = script + t.Cleanup(func() { llamaServerBinary = orig }) +} + +// fakeTerminal flips the gate serve checks for a terminal, so the view path +// runs in the suite without one. +func fakeTerminal(t *testing.T) { + t.Helper() + orig := stdoutIsTerminal + stdoutIsTerminal = func() bool { return true } + t.Cleanup(func() { stdoutIsTerminal = orig }) +} + +// fakeViewProgram runs the view on a program with injected input and output, +// so the suite executes it without a terminal: input disabled, the key rules +// being the model tests' — and output discarded, the frame being the render +// tests'. +func fakeViewProgram(t *testing.T) { + t.Helper() + orig := newServeProgram + newServeProgram = func(m tea.Model, opts ...tea.ProgramOption) *tea.Program { + return tea.NewProgram(m, tea.WithInput(nil), tea.WithOutput(io.Discard)) + } + t.Cleanup(func() { newServeProgram = orig }) +} + +// TestCmdServe_ViewRunCapturesEngineOutput covers the view run end to end: +// the engine's output lands in the state-dir engine log rather than on serve's +// stdio, the engine starts with its metrics endpoint on, and the command +// serve prints goes to stderr — stdout is the view's screen. +func TestCmdServe_ViewRunCapturesEngineOutput(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "tok") + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'engine up'", "sleep 0.3\necho 'engine down'\nexit 0") + fakeTerminal(t) + fakeViewProgram(t) + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + done := make(chan error, 1) + var stderr, stdout string + captureStdout(t, func() { + stderr = captureStderr(t, func() { + go func() { done <- cmdServe([]string{spinloopPath}) }() + select { + case err := <-done: + if err != nil { + t.Fatalf("serve exited with %v after a clean engine exit", err) + } + case <-time.After(20 * time.Second): + t.Fatal("serve did not exit after the engine did") + } + }) + }) + // The printed command goes to stderr, and stays off the view's screen. + if !strings.Contains(stderr, "llama-server") { + t.Errorf("the printed command must go to stderr under the view:\n%s", stderr) + } + if strings.Contains(stdout, "llama-server") { + t.Errorf("the printed command must stay off the view's screen:\n%s", stdout) + } + stateDir, err := daemon.StateDir() + if err != nil { + t.Fatal(err) + } + log := waitForFile(t, filepath.Join(stateDir, "engine.log")) + for _, want := range []string{"engine up", "engine down"} { + if !strings.Contains(log, want) { + t.Errorf("the engine log is missing %q:\n%s", want, log) + } + } + args := waitForFile(t, argsFile) + if !strings.Contains(args, "--metrics") { + t.Errorf("the view run must switch the metrics endpoint on:\n%s", args) + } +} + +// TestCmdServe_ViewRunExitsWithEngineStatus covers the exit-status rule: an +// engine that fails on its own takes serve down with it, whatever closed the +// view. +func TestCmdServe_ViewRunExitsWithEngineStatus(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "tok") + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'engine up'", "exit 3") + fakeTerminal(t) + fakeViewProgram(t) + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + done := make(chan error, 1) + captureStdout(t, func() { + captureStderr(t, func() { + go func() { done <- cmdServe([]string{spinloopPath}) }() + select { + case err := <-done: + if err == nil { + t.Fatal("serve must report the engine's failure status") + } + case <-time.After(20 * time.Second): + t.Fatal("serve did not exit after the engine did") + } + }) + }) +} + +// TestCmdServe_ViewQuitStopsTheEngine covers the quit key end to end: q goes +// through the view's own stop — the engine goes down through the supervisor, +// and serve exits cleanly after it is actually stopped. The Spinloop names no +// MODEL, so the supervised run serves under its alias. +func TestCmdServe_ViewQuitStopsTheEngine(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "tok") + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'engine up'", + "trap 'echo \"engine stopped on TERM\"; exit 0' TERM\nwhile true; do sleep 0.05; done\n") + dir := t.TempDir() + mustWrite(t, filepath.Join(dir, "preset.ini"), samplePreset) + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nALIAS qwen\nPRESET preset.ini\n") + + pr, pw := io.Pipe() + origProgram := newServeProgram + newServeProgram = func(m tea.Model, _ ...tea.ProgramOption) *tea.Program { + return tea.NewProgram(m, tea.WithInput(pr), tea.WithOutput(io.Discard)) + } + t.Cleanup(func() { + newServeProgram = origProgram + pw.Close() + }) + fakeTerminal(t) + + go func() { + time.Sleep(2 * time.Second) + fmt.Fprint(pw, "q") + }() + + done := make(chan error, 1) + captureStdout(t, func() { + captureStderr(t, func() { + go func() { done <- cmdServe([]string{spinloopPath}) }() + select { + case err := <-done: + if err != nil { + t.Fatalf("serve must exit cleanly after q, got %v", err) + } + case <-time.After(20 * time.Second): + t.Fatal("serve did not exit after q") + } + }) + }) + stateDir, err := daemon.StateDir() + if err != nil { + t.Fatal(err) + } + log := waitForFile(t, filepath.Join(stateDir, "engine.log")) + if !strings.Contains(log, "engine stopped on TERM") { + t.Errorf("the engine must be stopped through the supervisor on q:\n%s", log) + } +} + +// TestCmdServe_DryRunOnTerminalNeverOpensTheView pins the gate's dry-run +// half: on a terminal, --dry-run must still print the command and start +// nothing — no view, no engine, no engine log. +func TestCmdServe_DryRunOnTerminalNeverOpensTheView(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'engine up'", "exit 0") + fakeTerminal(t) + viewOpened := false + origProgram := newServeProgram + newServeProgram = func(m tea.Model, _ ...tea.ProgramOption) *tea.Program { + viewOpened = true + return tea.NewProgram(m, tea.WithInput(nil), tea.WithOutput(io.Discard)) + } + t.Cleanup(func() { newServeProgram = origProgram }) + + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + out := captureStdout(t, func() { + captureStderr(t, func() { + if err := cmdServe([]string{"--dry-run", spinloopPath}); err != nil { + t.Fatalf("dry run: %v", err) + } + }) + }) + if viewOpened { + t.Error("--dry-run must not open the view, even on a terminal") + } + if !strings.Contains(out, "llama-server") { + t.Errorf("the dry run must still print the command on stdout:\n%s", out) + } + if _, err := os.Stat(argsFile); !os.IsNotExist(err) { + t.Error("the dry run must not start the engine") + } + stateDir, err := daemon.StateDir() + if err != nil { + t.Fatal(err) + } + if _, err := os.Stat(filepath.Join(stateDir, "engine.log")); !os.IsNotExist(err) { + t.Error("the dry run must not open an engine log") + } +} + +// TestCmdServe_ViewRunMissingBinaryFailsAroundNoView covers the view's +// startup order: the engine starts before the view opens, so a missing +// binary fails with its install hint — and no view, no engine log. +func TestCmdServe_ViewRunMissingBinaryFailsAroundNoView(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "tok") + viewOpened := false + origProgram := newServeProgram + newServeProgram = func(m tea.Model, _ ...tea.ProgramOption) *tea.Program { + viewOpened = true + return tea.NewProgram(m, tea.WithInput(nil), tea.WithOutput(io.Discard)) + } + t.Cleanup(func() { newServeProgram = origProgram }) + origBin := llamaServerBinary + llamaServerBinary = filepath.Join(t.TempDir(), "no-such-llama-server") + t.Cleanup(func() { llamaServerBinary = origBin }) + fakeTerminal(t) + + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + err := cmdServe([]string{spinloopPath}) + if err == nil { + t.Fatal("a missing engine binary must fail the serve") + } + if !strings.Contains(err.Error(), "not found") || !strings.Contains(err.Error(), "install llama.cpp") { + t.Errorf("the failure must carry the install hint: %v", err) + } + if viewOpened { + t.Error("a missing binary must fail around no view") + } + stateDir, serr := daemon.StateDir() + if serr != nil { + t.Fatal(serr) + } + log, _ := os.ReadFile(filepath.Join(stateDir, "engine.log")) + if len(log) != 0 { + t.Errorf("a missing binary must not write an engine log: %q", log) + } +} + +// TestCmdServe_SupervisedRunRefusesAnInsecureListen covers the control API's +// listen guard on the supervised path: a non-loopback address without a token +// is refused before the engine starts — nothing listens, nothing runs. +func TestCmdServe_SupervisedRunRefusesAnInsecureListen(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "") + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'engine up'", "exit 0") + + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + err := cmdServe([]string{"-a", "--api-addr", "0.0.0.0:0", spinloopPath}) + if err == nil { + t.Fatal("a non-loopback listen without a token must be refused") + } + if !strings.Contains(err.Error(), "refusing to serve the control API on non-loopback") { + t.Errorf("the refusal must name what it refuses and the fix: %v", err) + } + if _, statErr := os.Stat(argsFile); !os.IsNotExist(statErr) { + t.Error("the engine must not start when the listen is refused") + } +} + +// TestCmdServe_ViewRunAPILogServesTheCapture covers serve --api under the +// view: the control API listens beside the run, and its log endpoint serves +// the captured engine log rather than reporting the log missing. +func TestCmdServe_ViewRunAPILogServesTheCapture(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + t.Setenv(daemon.TokenEnvVar, "tok") + argsFile := filepath.Join(t.TempDir(), "args") + stubEngineView(t, argsFile, "'boot line'", "") + fakeTerminal(t) + fakeViewProgram(t) + dir := t.TempDir() + spinloopPath := filepath.Join(dir, "Spinloop") + mustWrite(t, spinloopPath, "PROVIDER llamacpp\nMODEL org/model:Q4_K_M\n") + + waitAddr := apiAddrFromStderr(t) + done := make(chan error, 1) + go func() { + var serveErr error + captureStdout(t, func() { + serveErr = cmdServe([]string{"-a", "--api-addr", "127.0.0.1:0", spinloopPath}) + }) + done <- serveErr + }() + base := "http://" + waitAddr() + + // The engine's output reaches the log the API serves, not its stdio. + deadline := time.Now().Add(10 * time.Second) + var code int + var body map[string]any + for { + code, body = apiDo(t, "GET", base+"/v1/logs", "tok", "") + content, _ := body["content"].(string) + if code == 200 && strings.Contains(content, "boot line") { + break + } + if time.Now().After(deadline) { + t.Fatalf("the log endpoint never carried the engine's output: %d %v", code, body) + } + time.Sleep(50 * time.Millisecond) + } + + // Stop over the API; the stop on request exits serve as success. + if code, body := apiDo(t, "POST", base+"/v1/stop", "tok", ""); code != 200 || body["state"] != "stopped" { + t.Fatalf("stop = %d %v", code, body) + } + select { + case err := <-done: + if err != nil { + t.Fatalf("serve exited with %v after an API stop", err) + } + case <-time.After(20 * time.Second): + t.Fatal("serve did not exit after the foreground engine stopped") + } +} + +// TestCmdServe_ForegroundAPIStopExitsServe covers the non-terminal --api run +// against the same shared construction: the engine runs in the foreground +// with stdio forwarded, the API listens beside it, and a stop over the API +// exits serve as success. +// TestCmdServe_OffTerminalCapturesNothing covers the other side of the gate: +// off the terminal the run forwards the engine's output to serve's stdio and +// writes no engine log file — the capture is the view's own. +func TestCmdServe_OffTerminalCapturesNothing(t *testing.T) { + t.Setenv("XDG_CONFIG_HOME", t.TempDir()) + stateDir, err := daemon.StateDir() + if err != nil { + t.Fatal(err) + } + stubLlamaServer(t, filepath.Join(t.TempDir(), "args")) + spinloopPath := writePresetSpinloop(t, "PROVIDER llamacpp\nPRESET ./preset.ini\nALIAS qwen\n") + captureStdout(t, func() { + captureStderr(t, func() { + if err := cmdServe([]string{spinloopPath}); err != nil { + t.Error(err) + } + }) + }) + if _, err := os.Stat(filepath.Join(stateDir, "engine.log")); !os.IsNotExist(err) { + t.Errorf("a run off the terminal must write no engine log (stat = %v)", err) + } +} + func TestCmdServe_ForegroundAPIStopExitsServe(t *testing.T) { t.Setenv("XDG_CONFIG_HOME", t.TempDir()) t.Setenv(daemon.TokenEnvVar, "tok") diff --git a/cmd/spinloop/serve_view.go b/cmd/spinloop/serve_view.go new file mode 100644 index 0000000..0671ab8 --- /dev/null +++ b/cmd/spinloop/serve_view.go @@ -0,0 +1,510 @@ +// The serve view: what `spinloop serve` draws on a terminal — the engine's +// metrics above, its tailed log below, and a footer naming the keys the view +// answers to. The frame is the fleet dashboard's node detail screen three- +// section layout: the metrics section is the same lines the detail view and +// the metrics formats print for the same reading — state with uptime, what +// is served, the last-active line, the resource series, the token counters — +// with each resource series drawn in both formats at once, the gauge of the +// current reading and, beneath it, the bar of the retained history. The log +// section follows the engine's own log the way the detail view follows its +// node's. Everything it reads is in-process: the daemon the serve process +// runs itself, not the network. Bubble Tea drives the model through +// Init/Update/View, but every rule here is plain Go over plain data, so the +// suite runs the whole logic without a terminal. + +package main + +import ( + "context" + "fmt" + "path/filepath" + "strings" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/spinloop-ai/spinloop/internal/daemon" + "github.com/spinloop-ai/spinloop/internal/metrics" + "github.com/spinloop-ai/spinloop/internal/spinloop" +) + +// newServeProgram builds the program the view runs on: the model, the +// alternate screen, and nothing else. A variable so a test runs the view with +// injected input and output, where opening the terminal's own input would +// fail. +var newServeProgram = func(m tea.Model, opts ...tea.ProgramOption) *tea.Program { + return tea.NewProgram(m, append([]tea.ProgramOption{tea.WithAltScreen()}, opts...)...) +} + +// serveViewLogBudget is how many lines of the tailed log the view retains in +// memory. A few thousand is well past any pane the frame can show, so the +// scroll can reach back as far as the frame can ever go; the file on disk +// keeps the whole record, so the budget only bounds the copy. +const serveViewLogBudget = 2000 + +// serveViewLogTailBytes is the byte budget of the first read of a freshly +// opened view — the backlog — the same way the detail view budgets its tail. +const serveViewLogTailBytes = 200 * bytesPerLineGuess + +// serveViewMetricsTimeout caps one in-process metrics read. The read takes +// host stats and the sampler's own counters — no network — so a deadline this +// loose only catches a wedged host probe, which is exactly what the age +// beside a stale reading is for. +const serveViewMetricsTimeout = 5 * time.Second + +// serveViewKeys is the view's footer key help: exactly the keys the view +// answers to — the scroll, the follow, and the quit — and nothing the view +// cannot do. Starting, stopping, keeping and aborting are not among them: +// the engine is serve's own, and leaving is what stops it. +const serveViewKeys = "↑↓ scroll pgup/pgdown page f follow q quit" + +// serveView is the program's state: the metrics reading and when it was +// taken, the tailed log and where its window sits in it, and the window size +// the frame draws to. +type serveView struct { + spinloopPath string + + stats metrics.Stats // the last successful read; zero until the first + statsAt time.Time // when it was taken; a failed read leaves the last one here, and its age is drawn from it + + logOffset int64 // where the next poll resumes from; TailLog for the first, which is the backlog + logContent string // the tailed lines, most recent last, trimmed to the budget + logBudget int // how many lines the tail retains + logBehind int // how many lines the window's bottom sits behind the newest; 0 is on the newest line + logFollow bool // whether the poll picks up new output; f pauses and resumes it + logBusy bool // a poll is in flight + logGen int // bumped to supersede a poll in flight + logNote string // why the pane has no content — empty once it does, or once a read fails with content in place + + metricsBusy bool + metricsGen int + + width, height int + + // send feeds a message back into the program from outside the Update + // loop — the engine's own exit, which its wait goroutine reports. It is + // the tea.Program's Send, safe from any goroutine and a no-op once the + // program has left; nil where the model is driven directly in a test. + send func(tea.Msg) + // stop ends the run: the graceful stop, escalating as a stop does + // elsewhere. It blocks until the engine is down, so it runs in a + // Bubble Tea command, never inside Update. + stop func() + // readMetrics and readLog are the view's two data paths, injected so a + // test drives the model with its own answers. The real ones call the + // in-process daemon and the daemon's own log read — the same functions + // the control API's handlers call, so the view and the API cannot + // report different facts about the same engine. + readMetrics func() (metrics.Stats, error) + readLog func(offset int64, limit int) (daemon.LogsResponse, error) +} + +// serveViewMetricsTickMsg fires on the dashboard's own local cadence. +type serveViewMetricsTickMsg time.Time + +func serveViewMetricsTickCmd() tea.Cmd { + return tea.Tick(dashboardRefreshInterval, func(time.Time) tea.Msg { return serveViewMetricsTickMsg{} }) +} + +// serveViewLogTickMsg fires on the detail view's log cadence, the chain the +// log poll runs on, separately from the metrics tick. +type serveViewLogTickMsg time.Time + +func serveViewLogTickCmd() tea.Cmd { + return tea.Tick(detailLogInterval, func(time.Time) tea.Msg { return serveViewLogTickMsg{} }) +} + +// serveViewMetricsMsg is one completed in-process reading. gen ties it to +// the model that started it, so a reply a superseded read sent is discarded +// rather than painted over a newer one. +type serveViewMetricsMsg struct { + gen int + stats metrics.Stats + err error +} + +// serveViewLogMsg is one completed poll of the engine's log. +type serveViewLogMsg struct { + gen int + reply daemon.LogsResponse + err error +} + +// serveViewStoppedMsg says the operator's stop has landed and the engine is +// down: the view quits on it. +type serveViewStoppedMsg struct{} + +// serveViewEngineExitedMsg says the engine exited on its own, whatever the +// cause: the view quits on it, and the run reports the engine's exit status +// after the program has left. +type serveViewEngineExitedMsg struct{} + +// Init starts both chains at once — the first metrics read and the first +// log poll, which is the backlog, because the offset opens on the tail. +func (m *serveView) Init() tea.Cmd { + return tea.Batch( + serveViewMetricsTickCmd(), m.startMetricsRead(), + serveViewLogTickCmd(), m.startLogPoll(), + ) +} + +func (m *serveView) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + switch msg := msg.(type) { + case tea.WindowSizeMsg: + m.width, m.height = msg.Width, msg.Height + m.clampBehind() + case serveViewMetricsTickMsg: + // One tick, one read, the tick rescheduling itself for the life of + // the view. A read starts only when none is in flight, so a slow + // read stretches to its own time rather than overlapping the next. + return m, tea.Batch(serveViewMetricsTickCmd(), m.startMetricsRead()) + case serveViewMetricsMsg: + m.metricsBusy = false + if msg.gen != m.metricsGen { + return m, nil + } + if msg.err == nil { + // A successful read replaces the one on screen. A failed one + // leaves the last in place: its statsAt stands, and the age + // beside the state line says what it says. + m.stats = msg.stats + m.statsAt = dashNow() + } + case serveViewLogTickMsg: + // The chain keeps ticking whether or not follow is on — pausing + // only skips the round it would have started, so unpausing with f + // needs nothing more than flipping the flag back, and the metrics + // section's own refresh never felt it either. + var cmd tea.Cmd + if m.logFollow { + cmd = m.startLogPoll() + } + return m, tea.Batch(serveViewLogTickCmd(), cmd) + case serveViewLogMsg: + m.logBusy = false + if msg.gen != m.logGen { + return m, nil + } + m.applyLogReply(msg) + case serveViewStoppedMsg, serveViewEngineExitedMsg: + return m, tea.Quit + case tea.KeyMsg: + return m, m.updateKey(msg) + } + return m, nil +} + +// updateKey answers the keys the view reads: the scroll of the log pane, f +// to pause and resume the follow, and q or Ctrl+C to leave — which stops the +// engine. Nothing else drives anything in the view, so nothing else is read. +func (m *serveView) updateKey(msg tea.KeyMsg) tea.Cmd { + switch msg.String() { + case "q", "ctrl+c": + return m.stopCmd() + case "f": + m.logFollow = !m.logFollow + case "up": + m.logBehind++ + m.clampBehind() + case "down": + m.logBehind-- + m.clampBehind() + case "pgup": + m.logBehind += m.logPaneRows() + m.clampBehind() + case "pgdown": + m.logBehind -= m.logPaneRows() + m.clampBehind() + } + return nil +} + +// stopCmd ends the run. The stop blocks until the engine is down — the +// graceful escalation a stop does elsewhere — and the view quits on the round +// trip, so the screen closes when the engine is actually stopped, not before. +func (m *serveView) stopCmd() tea.Cmd { + return func() tea.Msg { + if m.stop != nil { + m.stop() + } + return serveViewStoppedMsg{} + } +} + +// startMetricsRead takes one in-process reading through the injected read. +// It never starts a second read over one still in flight. +func (m *serveView) startMetricsRead() tea.Cmd { + if m.metricsBusy || m.readMetrics == nil { + return nil + } + m.metricsBusy = true + gen := m.metricsGen + read := m.readMetrics + return func() tea.Msg { + stats, err := read() + return serveViewMetricsMsg{gen: gen, stats: stats, err: err} + } +} + +// startLogPoll reads the engine's log through the daemon's own log read: +// the tail on the first read, the stored offset on every one after, the +// daemon's byte bounds doing the rest. It never starts a second poll over +// one still in flight. +func (m *serveView) startLogPoll() tea.Cmd { + if m.logBusy || m.readLog == nil { + return nil + } + m.logBusy = true + gen := m.logGen + offset, limit := m.logOffset, 0 + if offset == daemon.TailLog { + limit = serveViewLogTailBytes + } + read := m.readLog + return func() tea.Msg { + reply, err := read(offset, limit) + return serveViewLogMsg{gen: gen, reply: reply, err: err} + } +} + +// applyLogReply folds one completed poll into the view. New output is +// appended and trimmed to the line budget, so a long session never grows an +// unbounded buffer — the file on disk keeps the whole record — and a failed +// poll leaves the prior content in place rather than blanking it. The +// window's stick-and-stay rule is arithmetic on logBehind: on the newest +// line new output keeps it there, scrolled away it stays put as the new +// lines land behind it. +func (m *serveView) applyLogReply(msg serveViewLogMsg) { + if msg.err != nil { + if m.logContent == "" { + m.logNote = "log read failed: " + msg.err.Error() + } + return + } + m.logNote = "" + if msg.reply.StaleOffset { + // The file shrank — truncated or replaced. The content in memory is + // from the file it replaced, so it goes, and the cursor resumes from + // the reply's end, the rule the log read defines. + m.logContent = "" + m.logBehind = 0 + m.logOffset = msg.reply.NextOffset + return + } + m.logOffset = msg.reply.NextOffset + if msg.reply.Content != "" { + appended := lineCount(msg.reply.Content) + m.logContent = lastLines(m.logContent+msg.reply.Content, m.logBudget) + if m.logBehind > 0 { + m.logBehind += appended + } + m.clampBehind() + } +} + +// lineCount is how many lines s carries, the way the pane counts them: the +// trailing newline does not start a line. +func lineCount(s string) int { + if s == "" { + return 0 + } + return len(strings.Split(strings.TrimRight(s, "\n"), "\n")) +} + +// clampBehind keeps the window inside the retained content: it never shows +// past the oldest retained line or ahead of the newest, so a press at either +// end leaves it where it is. +func (m *serveView) clampBehind() { + if m.logBehind < 0 { + m.logBehind = 0 + return + } + max := lineCount(m.logContent) - m.logPaneRows() + if max < 0 { + max = 0 + } + if m.logBehind > max { + m.logBehind = max + } +} + +// sectionHeights splits the frame's rows between the metrics section (its +// natural length) and the log section (whatever remains after the header, +// the footer, and the three dividers around the three sections), floored at +// one row each — the detail view's own split. +func (m *serveView) sectionHeights() (metricsH, logH int) { + metricsH = len(m.metricsLines()) + if metricsH < 1 { + metricsH = 1 + } + const fixedRows = 5 // header + divider + divider + divider + footer + logH = m.effHeight() - fixedRows - metricsH + if logH < 1 { + logH = 1 + } + return metricsH, logH +} + +// logPaneRows is how many rows of log the frame shows at once — the page +// size pgup and pgdown move by. +func (m *serveView) logPaneRows() int { + _, logH := m.sectionHeights() + return logH +} + +// effWidth and effHeight report the window, defaulting where none was ever +// reported: Bubble Tea measures the real screen at startup, so a zero can +// only mean not-measured, not a real size. +func (m serveView) effWidth() int { + if m.width < 1 { + return 80 + } + return m.width +} + +func (m serveView) effHeight() int { + if m.height < 1 { + return 24 + } + return m.height +} + +// metricsLines is the metrics section: the same lines the dashboard's detail +// screen and the metrics formats print for the reading — state with uptime, +// what is served, the last-active line, the resource series in both formats +// at once, the token counters — so the view cannot word a number the other +// surfaces would not. +func (m serveView) metricsLines() []string { + if m.statsAt.IsZero() { + return []string{"waiting for the first reading…"} + } + var b strings.Builder + fmt.Fprintf(&b, "%s%s\n", dashStateLine(m.stats.State, m.stats), m.staleSuffix()) + if line := dashTileServingLine(m.stats); line != "" { + fmt.Fprintln(&b, line) + } + renderActiveIndented(&b, m.stats.LastActiveAt, m.stats.IdleSeconds, m.stats.RetainUntil, dashNow()) + // A running reading carries its current figures; a settled one carries + // its retained history, which survives a stop — the detail view's own + // rule for when the series exist at all. + resources := m.stats.State == "running" || len(m.stats.History) > 0 + if resources { + renderStatCombined(&b, m.stats.CPU, m.stats.Memory, m.stats.GPUs, m.stats.History, barLineW) + renderTokenLines(&b, m.stats.Tokens) + } + lines := strings.Split(b.String(), "\n") + return lines[:len(lines)-1] +} + +// staleSuffix is the "· 3m ago" the state line carries once the reading has +// aged past the dashboard's own stale rule, or "" while it is current: a +// reading the view could not renew is not drawn identically to one just +// read. +func (m serveView) staleSuffix() string { + if m.statsAt.IsZero() { + return "" + } + staleAfter := dashStaleThreshold * dashboardRefreshInterval + age := dashNow().Sub(m.statsAt) + if age < staleAfter { + return "" + } + return " · " + formatDuration(int(age.Seconds())) + " ago" +} + +// View draws the frame: the title bar — the screen, the Spinloop's path, and +// the log's following or paused state to the right — the metrics section, a +// divider, the tailed log filling the remaining rows, a divider, and the +// footer naming the view's keys. +func (m serveView) View() string { + w := m.effWidth() + metricsH, avail := m.sectionHeights() + + logState := "following" + if !m.logFollow { + logState = "paused" + } + header := dashTitleBar("serve", m.spinloopPath+" log: "+logState, w) + divider := strings.Repeat("─", w) + + metrics := m.metricsLines() + for len(metrics) < metricsH { + metrics = append(metrics, "") + } + + logLines := detailLogLines(m.logContent, m.logNote) + if m.logBehind > 0 { + // Scrolled away: the window ends that many lines behind the newest. + end := len(logLines) - m.logBehind + if end < 0 { + end = 0 + } + logLines = logLines[:end] + } + if len(logLines) > avail { + logLines = logLines[len(logLines)-avail:] + } + + parts := make([]string, 0, len(metrics)+len(logLines)+4) + parts = append(parts, header, divider) + for _, line := range metrics { + parts = append(parts, dashClip(line, w)) + } + parts = append(parts, divider) + for _, line := range logLines { + parts = append(parts, dashClip(line, w)) + } + parts = append(parts, divider) + parts = append(parts, dashClip(dashKeyHints(serveViewKeys), w)) + return strings.Join(parts, "\n") +} + +// runServeView is `spinloop serve` on a terminal: the engine runs through +// the shared supervised-foreground construction with its output captured to +// the daemon's state-dir engine log, and the view draws on the alternate +// screen for the life of the run. The engine starts before the view opens, +// so a missing binary fails with its install hint around no view, and the +// run reports the engine's exit status whatever closed the view — the +// operator's q or the engine's own exit. +func runServeView(sel spinloop.Selection, spinloopPath string, engine serveEngine, argv []string, apiOn bool, apiAddr, logLevel string) error { + stateDir, err := daemon.StateDir() + if err != nil { + return err + } + logPath := filepath.Join(stateDir, "engine.log") + run, err := startSupervisedForeground(sel, spinloopPath, engine, argv, apiOn, apiAddr, logLevel, logPath) + if err != nil { + return err + } + m := &serveView{ + spinloopPath: spinloopPath, + logOffset: daemon.TailLog, + logBudget: serveViewLogBudget, + logFollow: true, + stop: run.stop, + readMetrics: func() (metrics.Stats, error) { + ctx, cancel := context.WithTimeout(context.Background(), serveViewMetricsTimeout) + defer cancel() + return run.d.Metrics(ctx), nil + }, + readLog: func(offset int64, limit int) (daemon.LogsResponse, error) { + return daemon.ReadLog(logPath, offset, limit) + }, + } + prog := newServeProgram(m) + // The engine's own exit closes the view, whatever its cause. The send is + // wired before the wait goroutine starts, so it cannot fire into a nil — + // and it is a no-op once the program has left, so the two exit paths + // cannot double-quit. + m.send = prog.Send + go func() { + run.wait() + m.send(serveViewEngineExitedMsg{}) + }() + if _, err := prog.Run(); err != nil { + return err + } + // The view has left and the engine is down: the run reports the + // engine's exit status as a foreground serve always has, a stop on + // request counting as success. + return run.wait() +} diff --git a/cmd/spinloop/serve_view_test.go b/cmd/spinloop/serve_view_test.go new file mode 100644 index 0000000..17a27d2 --- /dev/null +++ b/cmd/spinloop/serve_view_test.go @@ -0,0 +1,503 @@ +package main + +import ( + "errors" + "fmt" + "strings" + "testing" + "time" + + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/lipgloss" + "github.com/spinloop-ai/spinloop/internal/daemon" + "github.com/spinloop-ai/spinloop/internal/metrics" +) + +func fixDashNow(t *testing.T, at time.Time) { + t.Helper() + dashNow = func() time.Time { return at } + t.Cleanup(func() { dashNow = time.Now }) +} + +// newTestServeView is the model a test drives directly: the window already +// measured at 100x30, the two data paths injected, and nothing else set. +func newTestServeView(readMetrics func() (metrics.Stats, error), readLog func(int64, int) (daemon.LogsResponse, error)) *serveView { + m := &serveView{ + spinloopPath: "Spinloop", + logOffset: daemon.TailLog, + logBudget: serveViewLogBudget, + logFollow: true, + readMetrics: readMetrics, + readLog: readLog, + } + m.Update(tea.WindowSizeMsg{Width: 100, Height: 30}) + return m +} + +func requireQuit(t *testing.T, cmd tea.Cmd) { + t.Helper() + if cmd == nil { + t.Fatal("the message must return tea.Quit, got no command") + } + if _, ok := cmd().(tea.QuitMsg); !ok { + t.Fatalf("the message must return tea.Quit, got a %T", cmd()) + } +} + +// The model opens knowing nothing: the window unmeasured, the first read a +// tail, the follow on, and the frame carrying its two waiting notes until the +// first replies land. +func TestServeViewInitialState(t *testing.T) { + fixDashNow(t, time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC)) + m := newTestServeView(nil, nil) + if cmd := m.Init(); cmd == nil { + t.Fatal("Init must schedule the first reading and the first log poll") + } + if m.logOffset != daemon.TailLog || !m.logFollow || m.logBudget != serveViewLogBudget { + t.Errorf("the view must open on the tail, following, with its line budget: %+v", m) + } + v := m.View() + if !strings.Contains(v, "waiting for the first reading…") { + t.Errorf("View before a reading must carry the waiting note:\n%s", v) + } + if !strings.Contains(v, "waiting for the log…") { + t.Errorf("View before a log read must carry the waiting note:\n%s", v) + } +} + +func TestServeViewMetricsReadReplacesPrior(t *testing.T) { + at := time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC) + fixDashNow(t, at) + first := metrics.Stats{State: "running", UptimeSeconds: 10} + second := metrics.Stats{State: "running", UptimeSeconds: 40} + next := first + m := newTestServeView(func() (metrics.Stats, error) { return next, nil }, nil) + + m.Update(m.startMetricsRead()()) + if m.stats.UptimeSeconds != 10 || !m.statsAt.Equal(at) { + t.Fatalf("the first reading was not stored: %+v at %v", m.stats, m.statsAt) + } + next = second + m.Update(m.startMetricsRead()()) + if m.stats.UptimeSeconds != 40 { + t.Errorf("the second reading must replace the first: %+v", m.stats) + } +} + +func TestServeViewMetricsFailedReadKeepsLast(t *testing.T) { + at := time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC) + fixDashNow(t, at) + var fail bool + m := newTestServeView(func() (metrics.Stats, error) { + if fail { + return metrics.Stats{}, errors.New("the host probe wedged") + } + return metrics.Stats{State: "running", UptimeSeconds: 10}, nil + }, nil) + m.Update(m.startMetricsRead()()) + if m.stats.UptimeSeconds != 10 || !m.statsAt.Equal(at) { + t.Fatal("the first reading was not stored") + } + + fail = true + m.Update(m.startMetricsRead()()) + if m.stats.UptimeSeconds != 10 || !m.statsAt.Equal(at) { + t.Error("a failed read must leave the last reading in place, its age included") + } +} + +func TestServeViewMetricsSupersededReadDiscarded(t *testing.T) { + fixDashNow(t, time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC)) + m := newTestServeView(func() (metrics.Stats, error) { + return metrics.Stats{State: "running"}, nil + }, nil) + cmd := m.startMetricsRead() + m.metricsGen++ + m.Update(cmd()) + if !m.statsAt.IsZero() { + t.Error("a superseded read's reply must be discarded") + } +} + +// A reading the view could not renew is not drawn identically to one just +// read: past the board's own stale rule the state line carries the age. +func TestServeViewStaleReadingCarriesItsAge(t *testing.T) { + at := time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC) + fixDashNow(t, at) + m := newTestServeView(func() (metrics.Stats, error) { + return metrics.Stats{State: "running"}, nil + }, nil) + m.Update(m.startMetricsRead()()) + if m.staleSuffix() != "" { + t.Errorf("a fresh reading carries no age: %q", m.staleSuffix()) + } + + fixDashNow(t, at.Add(dashStaleThreshold*dashboardRefreshInterval+time.Second)) + if suffix := m.staleSuffix(); !strings.HasSuffix(suffix, "ago") { + t.Errorf("a reading past the stale threshold must carry its age, got %q", suffix) + } +} + +// The first poll reads the tail — the backlog — budgeted the way the detail +// view budgets its tail; every poll after resumes from the stored offset with +// no byte limit, the daemon's own bounds doing the rest. +func TestServeViewLogFirstReadIsBacklog(t *testing.T) { + var gotOffset int64 + var gotLimit int + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + gotOffset, gotLimit = offset, limit + return daemon.LogsResponse{Content: "one\ntwo\n", NextOffset: 8}, nil + }) + m.Update(m.startLogPoll()()) + if gotOffset != daemon.TailLog { + t.Errorf("the first poll must read the tail, got offset %d", gotOffset) + } + if gotLimit != serveViewLogTailBytes { + t.Errorf("the first poll must budget the backlog, got limit %d", gotLimit) + } + if m.logContent != "one\ntwo\n" || m.logOffset != 8 { + t.Errorf("the backlog was not stored: %q at %d", m.logContent, m.logOffset) + } +} + +func TestServeViewLogPollsAppendWithoutDuplicates(t *testing.T) { + var calls [][2]int64 + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + calls = append(calls, [2]int64{offset, int64(limit)}) + if offset == daemon.TailLog { + return daemon.LogsResponse{Content: "one\ntwo\n", NextOffset: 8}, nil + } + return daemon.LogsResponse{Content: "three\n", NextOffset: 14}, nil + }) + m.Update(m.startLogPoll()()) + m.Update(m.startLogPoll()()) + if m.logContent != "one\ntwo\nthree\n" { + t.Errorf("the append must keep the backlog and add the new lines once: %q", m.logContent) + } + if len(calls) != 2 || calls[1][0] != 8 || calls[1][1] != 0 { + t.Errorf("the second poll must resume from the stored offset with no byte limit: %v", calls) + } +} + +// A file that shrank — truncated or replaced — drops the content from the +// file it replaced and resumes from the reply's end. +func TestServeViewLogStaleOffsetResumes(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + if offset == daemon.TailLog { + return daemon.LogsResponse{Content: "one\ntwo\n", NextOffset: 8}, nil + } + return daemon.LogsResponse{NextOffset: 3, Size: 3, StaleOffset: true}, nil + }) + m.Update(m.startLogPoll()()) + m.Update(m.startLogPoll()()) + if m.logContent != "" { + t.Errorf("a stale offset must drop the content from the replaced file: %q", m.logContent) + } + if m.logOffset != 3 { + t.Errorf("the cursor must resume from the reply's end, got %d", m.logOffset) + } + if m.logBehind != 0 { + t.Errorf("the window must be back on the newest line, behind %d", m.logBehind) + } +} + +func TestServeViewLogSupersededPollDiscarded(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + return daemon.LogsResponse{Content: "one\n", NextOffset: 5}, nil + }) + cmd := m.startLogPoll() + m.logGen++ + m.Update(cmd()) + if m.logContent != "" || m.logOffset != daemon.TailLog { + t.Errorf("a superseded poll's reply must be discarded: %q at %d", m.logContent, m.logOffset) + } +} + +// A long session never grows an unbounded buffer: the tail is trimmed to the +// line budget, the file on disk keeping the whole record. +func TestServeViewLogTrimmedToBudget(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + var b strings.Builder + for i := 0; i < 10; i++ { + fmt.Fprintf(&b, "line %d\n", i) + } + return daemon.LogsResponse{Content: b.String(), NextOffset: 100}, nil + }) + m.logBudget = 5 + m.Update(m.startLogPoll()()) + if got := lineCount(m.logContent); got != 5 { + t.Errorf("the tail must be trimmed to the budget of 5 lines, got %d", got) + } + if !strings.HasPrefix(m.logContent, "line 5\n") { + t.Errorf("the trim must keep the newest lines: %q", m.logContent) + } +} + +// A failed poll leaves the prior content in place; with no content at all it +// says why the pane is empty rather than drawing nothing. +func TestServeViewLogReadFailure(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + return daemon.LogsResponse{}, errors.New("the log is gone") + }) + m.Update(m.startLogPoll()()) + if m.logNote != "log read failed: the log is gone" { + t.Errorf("a failed first read must say so, got note %q", m.logNote) + } + if v := m.View(); !strings.Contains(v, "log read failed: the log is gone") { + t.Errorf("the empty pane must carry the failure note:\n%s", v) + } + + m.logContent = "one\n" + m.Update(m.startLogPoll()()) + if m.logContent != "one\n" { + t.Errorf("a failed poll must leave the prior content in place: %q", m.logContent) + } +} + +// The scroll: one line at a time, a page at a time, clamped at both ends — +// a press at either end leaves the window where it is. +func TestServeViewKeysScroll(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + var b strings.Builder + for i := 0; i < 30; i++ { + fmt.Fprintf(&b, "line %02d\n", i) + } + return daemon.LogsResponse{Content: b.String(), NextOffset: 100}, nil + }) + m.Update(m.startLogPoll()()) + // 30 lines against a 24-row pane: the window can sit at most 6 lines + // behind the newest. + cases := []struct { + key tea.Msg + want int + }{ + {tea.KeyMsg{Type: tea.KeyUp}, 1}, + {tea.KeyMsg{Type: tea.KeyDown}, 0}, + {tea.KeyMsg{Type: tea.KeyDown}, 0}, // on the newest line, down stays put + {tea.KeyMsg{Type: tea.KeyPgUp}, 6}, + {tea.KeyMsg{Type: tea.KeyUp}, 6}, // at the oldest retained line, up stays put + {tea.KeyMsg{Type: tea.KeyPgDown}, 0}, + {tea.KeyMsg{Type: tea.KeyDown}, 0}, + } + for i, tc := range cases { + m.Update(tc.key) + if m.logBehind != tc.want { + t.Errorf("key %d: behind = %d, want %d", i, m.logBehind, tc.want) + } + } +} + +// On the newest line, new output keeps the window there; scrolled away, the +// window stays put as the new lines land behind it. +func TestServeViewWindowSticksAndStays(t *testing.T) { + calls := 0 + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + calls++ + if calls == 1 { + var b strings.Builder + for i := 0; i < 30; i++ { + fmt.Fprintf(&b, "line %02d\n", i) + } + return daemon.LogsResponse{Content: b.String(), NextOffset: 100}, nil + } + return daemon.LogsResponse{Content: "line 30\n", NextOffset: 110}, nil + }) + m.Update(m.startLogPoll()()) + m.Update(m.startLogPoll()()) + if m.logBehind != 0 { + t.Fatalf("on the newest line the window must stay there, behind %d", m.logBehind) + } + if !strings.HasSuffix(m.logContent, "line 30\n") { + t.Fatalf("the new line must land in the pane: %q", m.logContent) + } + + m.Update(tea.KeyMsg{Type: tea.KeyUp}) // scroll one line away + if m.logBehind != 1 { + t.Fatalf("the up arrow must move the window one line, behind %d", m.logBehind) + } + m.Update(m.startLogPoll()()) + if m.logBehind != 2 { + t.Errorf("scrolled away, new output must stay behind the window, behind %d", m.logBehind) + } + if !strings.HasSuffix(m.logContent, "line 30\n") { + t.Errorf("the new line must be retained while the pane stays put: %q", m.logContent) + } +} + +// f pauses and resumes the follow: paused, the log tick starts no poll while +// the metrics tick keeps its own cadence; resumed, the next tick starts a +// poll again. +func TestServeViewFollowPauseAndResume(t *testing.T) { + calls := 0 + m := newTestServeView( + func() (metrics.Stats, error) { return metrics.Stats{State: "running"}, nil }, + func(offset int64, limit int) (daemon.LogsResponse, error) { + calls++ + return daemon.LogsResponse{Content: "a\n", NextOffset: 2}, nil + }, + ) + m.Update(m.startLogPoll()()) + + m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("f")}) + if m.logFollow { + t.Error("f must pause the follow") + } + m.Update(serveViewLogTickMsg{}) + if m.logBusy || calls != 1 { + t.Errorf("a paused follow must not start a poll (busy %v, %d calls)", m.logBusy, calls) + } + m.Update(serveViewMetricsTickMsg{}) + if !m.metricsBusy { + t.Error("pausing the log must not pause the metrics refresh") + } + + m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("f")}) + if !m.logFollow { + t.Fatal("f must resume the follow") + } + m.Update(serveViewLogTickMsg{}) + if !m.logBusy { + t.Error("the next tick after resuming must start a poll") + } +} + +// While the follow is paused the offset holds; the next poll reads from it, so +// whatever the engine wrote in the meantime arrives on the resume. +func TestServeViewPauseLosesNothing(t *testing.T) { + m := newTestServeView(nil, func(offset int64, limit int) (daemon.LogsResponse, error) { + if offset == daemon.TailLog { + return daemon.LogsResponse{Content: "a\n", NextOffset: 2}, nil + } + return daemon.LogsResponse{Content: "b\nc\n", NextOffset: 10}, nil + }) + m.Update(m.startLogPoll()()) + m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("f")}) + if m.logOffset != 2 { + t.Fatalf("the pause must hold the offset, got %d", m.logOffset) + } + m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("f")}) + m.Update(m.startLogPoll()()) + if m.logContent != "a\nb\nc\n" { + t.Errorf("nothing written while paused may be lost: %q", m.logContent) + } +} + +// The keys that leave: q and Ctrl+C both stop the engine — outside Update, +// in the command — and the view quits on the round trip. +func TestServeViewQuitStopsTheEngine(t *testing.T) { + for _, key := range []tea.Msg{ + tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("q")}, + tea.KeyMsg{Type: tea.KeyCtrlC}, + } { + stopped := 0 + m := newTestServeView(nil, nil) + m.stop = func() { stopped++ } + + _, cmd := m.Update(key) + if cmd == nil { + t.Fatalf("%v must return the stop command", key) + } + if stopped != 0 { + t.Fatalf("the stop must not run inside Update") + } + msg := cmd() + if stopped != 1 { + t.Errorf("the stop command must run the graceful stop") + } + if _, ok := msg.(serveViewStoppedMsg); !ok { + t.Fatalf("the stop command must report back, got a %T", msg) + } + _, quit := m.Update(msg) + requireQuit(t, quit) + } +} + +// The engine's own exit closes the view too, whatever its cause. +func TestServeViewEngineExitedQuits(t *testing.T) { + m := newTestServeView(nil, nil) + _, cmd := m.Update(serveViewEngineExitedMsg{}) + requireQuit(t, cmd) +} + +// The frame: the title bar with the path and the log's state, the metrics +// section in the view's own format — each series its gauge with its bar +// beneath — the tailed log, the dividers, and the footer naming exactly the +// keys the view answers to. +func TestServeViewFrame(t *testing.T) { + fixDashNow(t, time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC)) + stats := metrics.Stats{ + State: "running", + UptimeSeconds: 90, + Runner: "llama.cpp", + ModelID: "org/model", + CPU: &metrics.CpuStat{Utilization: 42}, + Memory: &metrics.MemoryStat{Total: 1000, Used: 500}, + History: []metrics.HistorySample{{Time: 1, CPU: f64ptr(10), Mem: f64ptr(40)}}, + Tokens: &metrics.TokenStats{PromptTokens: 10, GenerationTokens: 5, Requests: 2}, + } + m := newTestServeView( + func() (metrics.Stats, error) { return stats, nil }, + func(offset int64, limit int) (daemon.LogsResponse, error) { + return daemon.LogsResponse{Content: "alpha\nbeta\n", NextOffset: 12}, nil + }, + ) + m.Update(m.startMetricsRead()()) + m.Update(m.startLogPoll()()) + + v := m.View() + for _, want := range []string{ + "serve", // the screen + "Spinloop", // the path, right of the screen + "log: following", // the log's state + "running (up 1m 30s)", // state with uptime + "llama.cpp org/model", // what is served + " 42%", // the CPU gauge of the current reading + " 50%", // the RAM gauge + "prompt tokens:", "requests:", // the counters + "alpha", "beta", // the tailed log + "scroll", "follow", "quit", // the footer's keys + } { + if !strings.Contains(v, want) { + t.Errorf("the frame is missing %q:\n%s", want, v) + } + } + // The gauge of each series sits with its bar beneath: the series' label + // once, on the gauge line, the bar's label blank. + if strings.Count(v, "CPU") != 1 { + t.Errorf("the CPU series must draw once, label and all:\n%s", v) + } + if strings.Count(v, "RAM") != 1 { + t.Errorf("the RAM series must draw once, label and all:\n%s", v) + } + // Every line fits the window. + for i, line := range strings.Split(v, "\n") { + if w := lipgloss.Width(line); w > 100 { + t.Errorf("line %d is %d columns wide, want at most 100: %q", i, w, line) + } + } +} + +// The same frame, the follow paused: the title bar says so. +func TestServeViewFramePaused(t *testing.T) { + fixDashNow(t, time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC)) + m := newTestServeView(nil, nil) + m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("f")}) + if v := m.View(); !strings.Contains(v, "log: paused") { + t.Errorf("the title bar must name the paused log:\n%s", v) + } +} + +// A window shorter than the frame's fixed rows: the log pane floors at one +// row, and the frame still draws — a negative pane would clip out of range. +func TestServeViewTinyWindowFloorsTheLogPane(t *testing.T) { + m := newTestServeView(nil, nil) + m.Update(tea.WindowSizeMsg{Width: 80, Height: 3}) + if _, logH := m.sectionHeights(); logH != 1 { + t.Errorf("the log pane must floor at one row on a 3-row window, got %d", logH) + } + if m.View() == "" { + t.Error("the frame must still draw on a tiny window") + } +} + +func f64ptr(v float64) *float64 { return &v } diff --git a/docs/commands/serve.md b/docs/commands/serve.md index b6305ba..1d2f2e1 100644 --- a/docs/commands/serve.md +++ b/docs/commands/serve.md @@ -19,6 +19,52 @@ It prints the command before running it, and never touches your agent's config — pair it with [`spinloop apply`](apply.md) to point the agent at the server. +## On a terminal, the serve view + +Run `serve` on a terminal and the engine runs under a full-screen view rather +than forwarding its output: the engine's **metrics** above, its **log** below, +and a footer naming the keys the view answers to. + +- **Metrics** — the same facts the fleet dashboard's node detail screen shows + for the same engine: state and uptime, what is served, last active, and the + resource series — CPU, RAM, and each GPU's utilisation and memory — with + every series drawn in both formats at once: a gauge of the current reading + and, beneath it, the bar of its retained history. Below them, the token and + request counters. The reading comes from the daemon the serve process runs + in-process and refreshes on the dashboard's own local cadence; a reading the + view could not renew is shown with its age. +- **Log** — the engine's own output, tailed and followed, so new lines appear + as they are written. An engine that has written nothing yet shows a waiting + note, not an empty pane. +- **Footer** — the view's keys, and nothing the view cannot do. Starting, + stopping, keeping and aborting are not among them: the engine is serve's + own, and leaving is what stops it. + +| Key | What it does | +| --- | ------------ | +| `↑` / `↓` | Scroll the log one line; a press at either end leaves the window where it is | +| `pgup` / `pgdown` | Scroll the log by a page | +| `f` | Pause and resume the log's follow — the metrics section keeps refreshing either way | +| `q` or `Ctrl+C` | Leave — stops the engine and exits serve | + +While the log's window is on the newest line it sticks to the tail: new +output appears as it is written. Scrolled away from it, the window stays put +and the new lines accrue behind it. Pausing the follow holds the window, and +resuming fetches whatever the engine wrote in the meantime — nothing is lost. + +The engine's own exit closes the view and serve exits with the engine's exit +status, exactly as a foreground serve does. + +Under the view, the engine's stdout and stderr are captured to the same +`daemon/engine.log` [spinloop's daemon](#the-control-api---api-and-spinloop-daemon) +writes, from the engine's first line — so with `--api` the control API's log +endpoint serves the engine's output rather than reporting the log missing. + +Off a terminal — piped or redirected — there is no view: the engine's output +is forwarded to serve's own stdio as before, and the printed command stays on +stdout. On a terminal the view owns stdout, so the command serve prints goes +to stderr there. `--dry-run` never opens the view. + ## The engine comes from `PROVIDER` `PROVIDER` already names the engine, so `serve` needs no keyword of its own — @@ -257,7 +303,9 @@ of you exits. Two related surfaces build on it: - `serve --api` (`-a`) exposes the control API *beside* the foreground engine — status and metrics answer, start fails (the engine is already running), and stop terminates the engine, after which serve exits as it - always has. + always has. The flag changes only whether the API listens: the foreground + behaviour — the view on a terminal, stdio forwarding off one — is the same + with and without it. - `spinloop daemon` is the long-lived agent: it supervises one engine, writes its output to `daemon/engine.log` under [spinloop's config directory](../env-vars.md#config-directory-resolution), @@ -290,7 +338,7 @@ See [HTTP Control API](../http-api.md) for details, or | `POST /v1/start` | Start the engine (optional deploy-config body, optionally carrying the engine's API key; 409 while one runs) | | `POST /v1/stop` | Stop the engine (idempotent; never ends the daemon) | | `GET /v1/metrics` | Engine token counters plus host GPU/CPU/RAM | -| `GET /v1/logs` | A slice of the engine's captured output, by offset | +| `GET /v1/logs` | A slice of the engine's captured output, by offset — where the output is captured: under the daemon, and under the serve view; a plain foreground serve forwards its engine's output to its own stdio, and the endpoint reports the log missing | | `PUT /v1/deploy-config` | Set what the *next* start serves | Requests carry `Authorization: Bearer `. The token comes from one of diff --git a/openspec/changes/serve-ui/tasks.md b/openspec/changes/serve-ui/tasks.md index 5459fcb..a652d09 100644 --- a/openspec/changes/serve-ui/tasks.md +++ b/openspec/changes/serve-ui/tasks.md @@ -1,31 +1,31 @@ ## 1. Combined bar-and-gauge metrics rendering -- [ ] 1.1 Give `renderGauge` a width parameter in `cmd/spinloop/metrics_render.go`, updating its existing callers to pass today's 25-column width, and verify the existing metrics render tests pass unchanged -- [ ] 1.2 Add the combined renderer (each series from `barSeriesList` as its gauge line of the current reading, then its sparkline line beneath where the history holds samples, the sparkline's label blank so the pair stacks, a history-less series gauge-only) and verify with table-driven tests covering: a series with history (both lines), a series with none (gauge alone), multi-GPU labelling, and the 80/90 colour thresholds on the gauge +- [x] 1.1 Give `renderGauge` a width parameter in `cmd/spinloop/metrics_render.go`, updating its existing callers to pass today's 25-column width, and verify the existing metrics render tests pass unchanged +- [x] 1.2 Add the combined renderer (each series from `barSeriesList` as its gauge line of the current reading, then its sparkline line beneath where the history holds samples, the sparkline's label blank so the pair stacks, a history-less series gauge-only) and verify with table-driven tests covering: a series with history (both lines), a series with none (gauge alone), multi-GPU labelling, and the 80/90 colour thresholds on the gauge ## 2. Serve view model -- [ ] 2.1 Create `cmd/spinloop/serve_view.go` with the model's state (the metrics reading and its time, the tailed log content, its byte offset, its line budget, the scroll position and the follow flag, the window size) and its `Init`/`Update`/`View` shape, and verify the package compiles and an initial-state test passes -- [ ] 2.2 Add the metrics tick: a one-shot 2-second tick taking an in-process status-plus-metrics reading through an injected read function, a failed or stale reading leaving the last one in place with its age, and verify with tests that a reading replaces the prior one and a failed read keeps the last -- [ ] 2.3 Add the log poll: a one-shot 3-second tick with a generation guard, reading through an injected log read with the daemon's log semantics (tail on first read, resume from the stored offset, `StaleOffset` resetting to the reply's `NextOffset`), appending and trimming to the line budget, and verify with tests for the first read's backlog, no duplicates across polls, a stale-offset resume, and a superseded poll being discarded -- [ ] 2.4 Add the keys: `up`/`down` moving the scroll by one line, `pgup`/`pgdown` by the pane's height, clamped at the oldest retained line and the newest, the window sticking to the tail at the newest line and staying put while scrolled away, `f` pausing and resuming the follow, and `q`/Ctrl+C quitting, and verify with table-driven key tests over the scroll positions and the follow flag -- [ ] 2.5 Add the engine-exited message delivered through the model's `send` seam (the dashboard's `prog.Send` door), quitting the program on it, and verify a test drives the message and asserts the quit +- [x] 2.1 Create `cmd/spinloop/serve_view.go` with the model's state (the metrics reading and its time, the tailed log content, its byte offset, its line budget, the scroll position and the follow flag, the window size) and its `Init`/`Update`/`View` shape, and verify the package compiles and an initial-state test passes +- [x] 2.2 Add the metrics tick: a one-shot 2-second tick taking an in-process status-plus-metrics reading through an injected read function, a failed or stale reading leaving the last one in place with its age, and verify with tests that a reading replaces the prior one and a failed read keeps the last +- [x] 2.3 Add the log poll: a one-shot 3-second tick with a generation guard, reading through an injected log read with the daemon's log semantics (tail on first read, resume from the stored offset, `StaleOffset` resetting to the reply's `NextOffset`), appending and trimming to the line budget, and verify with tests for the first read's backlog, no duplicates across polls, a stale-offset resume, and a superseded poll being discarded +- [x] 2.4 Add the keys: `up`/`down` moving the scroll by one line, `pgup`/`pgdown` by the pane's height, clamped at the oldest retained line and the newest, the window sticking to the tail at the newest line and staying put while scrolled away, `f` pausing and resuming the follow, and `q`/Ctrl+C quitting, and verify with table-driven key tests over the scroll positions and the follow flag +- [x] 2.5 Add the engine-exited message delivered through the model's `send` seam (the dashboard's `prog.Send` door), quitting the program on it, and verify a test drives the message and asserts the quit ## 3. Serve view frame -- [ ] 3.1 Draw the frame in `View()`: the title bar (screen "serve", the Spinloop's path and the log's state to the right), the metrics section (state with uptime, the serving line, the last-active line, the combined renderer, the token lines), the log section with the waiting note where there is no content yet, the dividers, and the footer key help naming exactly the scroll, follow and quit keys, reusing the detail screen's `dashTitleBar`, key-hint and clip helpers, and verify with render tests over a fixed model and terminal size -- [ ] 3.2 Show the log's following/paused state in the title bar from the follow flag, and verify a render test for each state +- [x] 3.1 Draw the frame in `View()`: the title bar (screen "serve", the Spinloop's path and the log's state to the right), the metrics section (state with uptime, the serving line, the last-active line, the combined renderer, the token lines), the log section with the waiting note where there is no content yet, the dividers, and the footer key help naming exactly the scroll, follow and quit keys, reusing the detail screen's `dashTitleBar`, key-hint and clip helpers, and verify with render tests over a fixed model and terminal size +- [x] 3.2 Show the log's following/paused state in the title bar from the follow flag, and verify a render test for each state ## 4. `serve` wiring -- [ ] 4.1 Gate the view on `term.IsTerminal` of stdout in `runServe` (never for `--dry-run`, never off the terminal), pass the narration writer through `buildServeArgv` so the command and preset/model lines go to stderr under the view and stay on stdout off it, and verify the existing serve tests pass plus a test that the gate is applied through an injectable check -- [ ] 4.2 Pull the supervised-foreground construction out of `runServeForegroundAPI` into one helper — the supervisor, the daemon with its served name, scrape target, engine endpoint and refusing start stub, the metrics switch for an engine that has one, the sampler for the run's life, the signal relay, the graceful stop and the exit-status rule (a stop on request as success) — parameterised only by the supervisor's log target (the state-dir engine log, or empty for stdio forwarding) and whether the control API listener comes up, and point the existing non-terminal `--api` path at it, and verify the existing foreground-serve tests pass unchanged -- [ ] 4.3 Build the view run on that helper — log target the state-dir engine log, listener per `--api`, the engine started before the program opens so a missing binary fails with its install hint around no view, and the narration on stderr — and verify with stub-engine tests covering: the metrics switch present for a metrics-capable engine, absent for one with no metrics dialect, the log file holding the engine's output, and the not-found hint -- [ ] 4.4 Run the program on the alternate screen with `send` wired, the `sup.Wait()` goroutine delivering the engine-exited message, `q`/Ctrl+C and the inherited `SIGINT`/`SIGTERM` handler routing to the helper's stop, serve exiting with the engine's exit status, and `--api` adding the listener and its shutdown, and verify with the existing foreground-serve test patterns: the stop-on-request success path, the non-zero exit path, and the non-terminal `--api` run answering its API as before -- [ ] 4.5 Update `serve`'s long help to describe the view and its keys, and verify `go run ./cmd/spinloop serve --help` shows the new text +- [x] 4.1 Gate the view on `term.IsTerminal` of stdout in `runServe` (never for `--dry-run`, never off the terminal), pass the narration writer through `buildServeArgv` so the command and preset/model lines go to stderr under the view and stay on stdout off it, and verify the existing serve tests pass plus a test that the gate is applied through an injectable check +- [x] 4.2 Pull the supervised-foreground construction out of `runServeForegroundAPI` into one helper — the supervisor, the daemon with its served name, scrape target, engine endpoint and refusing start stub, the metrics switch for an engine that has one, the sampler for the run's life, the signal relay, the graceful stop and the exit-status rule (a stop on request as success) — parameterised only by the supervisor's log target (the state-dir engine log, or empty for stdio forwarding) and whether the control API listener comes up, and point the existing non-terminal `--api` path at it, and verify the existing foreground-serve tests pass unchanged +- [x] 4.3 Build the view run on that helper — log target the state-dir engine log, listener per `--api`, the engine started before the program opens so a missing binary fails with its install hint around no view, and the narration on stderr — and verify with stub-engine tests covering: the metrics switch present for a metrics-capable engine, absent for one with no metrics dialect, the log file holding the engine's output, and the not-found hint +- [x] 4.4 Run the program on the alternate screen with `send` wired, the `sup.Wait()` goroutine delivering the engine-exited message, `q`/Ctrl+C and the inherited `SIGINT`/`SIGTERM` handler routing to the helper's stop, serve exiting with the engine's exit status, and `--api` adding the listener and its shutdown, and verify with the existing foreground-serve test patterns: the stop-on-request success path, the non-zero exit path, and the non-terminal `--api` run answering its API as before +- [x] 4.5 Update `serve`'s long help to describe the view and its keys, and verify `go run ./cmd/spinloop serve --help` shows the new text ## 5. Docs and verification -- [ ] 5.1 Update `docs/commands/serve.md` for the view: its layout, its keys, the terminal/non-terminal split, and `serve --api`'s log endpoint serving the captured log, and verify the file reads back consistent with the spec delta -- [ ] 5.2 Run `gofmt -l .`, `go vet ./...` and `go test ./... -cover`, and verify all are clean with total coverage at or above 80% -- [ ] 5.3 Smoke both paths by hand: on a terminal, run `spinloop serve` against a stub engine and confirm the view opens with gauge and bar per series, the log follows, the arrows scroll and stick to the tail, `f` pauses, and `q` stops the engine cleanly; off the terminal, confirm `spinloop serve | cat` forwards the engine's output exactly as before, and verify by the observed behaviour +- [x] 5.1 Update `docs/commands/serve.md` for the view: its layout, its keys, the terminal/non-terminal split, and `serve --api`'s log endpoint serving the captured log, and verify the file reads back consistent with the spec delta +- [x] 5.2 Run `gofmt -l .`, `go vet ./...` and `go test ./... -cover`, and verify all are clean with total coverage at or above 80% +- [x] 5.3 Smoke both paths by hand: on a terminal, run `spinloop serve` against a stub engine and confirm the view opens with gauge and bar per series, the log follows, the arrows scroll and stick to the tail, `f` pauses, and `q` stops the engine cleanly; off the terminal, confirm `spinloop serve | cat` forwards the engine's output exactly as before, and verify by the observed behaviour From 50a488b07f7803e303eff65d3f11417d13c37700 Mon Sep 17 00:00:00 2001 From: Pete Cornish Date: Mon, 7 Sep 2026 01:54:09 +0100 Subject: [PATCH 3/5] refactor(serve): draw the view's gauge and bar side by side --- cmd/spinloop/metrics_render.go | 82 ++++++++++------- cmd/spinloop/metrics_render_test.go | 87 ++++++++++++------- cmd/spinloop/serve_view.go | 2 +- cmd/spinloop/serve_view_test.go | 15 ++-- docs/commands/serve.md | 10 +-- openspec/changes/serve-ui/design.md | 28 +++--- .../serve-ui/specs/local-serving/spec.md | 16 ++-- openspec/changes/serve-ui/tasks.md | 2 +- 8 files changed, 152 insertions(+), 90 deletions(-) diff --git a/cmd/spinloop/metrics_render.go b/cmd/spinloop/metrics_render.go index dbe53b7..1593dc6 100644 --- a/cmd/spinloop/metrics_render.go +++ b/cmd/spinloop/metrics_render.go @@ -9,6 +9,7 @@ package main import ( "fmt" "io" + "strings" "time" "github.com/spinloop-ai/spinloop/internal/metrics" @@ -138,8 +139,8 @@ const barLineW = 40 const dashBarLineW = 25 // gaugeW is the gauge's draw width in the one-shot formats — the width -// renderGauge has always drawn at. The serve view draws its gauges at -// barLineW instead, so the gauge and the bar beneath it share one width. +// renderGauge has always drawn at. The serve view draws its gauge half at +// serveGaugeW instead, beside the bar half of serveBarW. const gaugeW = 25 // barGlyphs is the seven sub-full block elements the sparkline draws with, @@ -196,6 +197,15 @@ func poolMax(values []float64, width int) []float64 { // gauge's 80/90 thresholds, and the trailing figure is the latest sample's // percentage — the exact value the last glyph approximates. func renderSparkline(w io.Writer, label string, samples []float64, width int) { + block, last := sparklineBlock(samples, width) + fmt.Fprintf(w, " %-9s %s %.0f%%\n", label, block, last) +} + +// sparklineBlock returns the sparkline's drawing across width, one glyph per +// sample newest on the right, the window's leading columns blank while it +// still fills, and the final glyph in the state colour — the label and the +// trailing figure excluded — along with the latest sample the figure reports. +func sparklineBlock(samples []float64, width int) (string, float64) { pooled := poolMax(samples, width) last := pooled[len(pooled)-1] colour := ansiGreen @@ -204,18 +214,16 @@ func renderSparkline(w io.Writer, label string, samples []float64, width int) { } else if last >= 80 { colour = ansiYellow } - fmt.Fprintf(w, " %-9s ", label) - for i := 0; i < width-len(pooled); i++ { - fmt.Fprint(w, " ") - } + var b strings.Builder + b.WriteString(strings.Repeat(" ", width-len(pooled))) for i, v := range pooled { if i == len(pooled)-1 { - fmt.Fprintf(w, "%s%c%s", colour, barGlyph(v), ansiReset) + b.WriteString(fmt.Sprintf("%s%c%s", colour, barGlyph(v), ansiReset)) } else { - fmt.Fprintf(w, "%c", barGlyph(v)) + b.WriteRune(barGlyph(v)) } } - fmt.Fprintf(w, " %.0f%%\n", last) + return b.String(), last } // renderGauge draws one resource series as a horizontal progress gauge: the @@ -223,6 +231,13 @@ func renderSparkline(w io.Writer, label string, samples []float64, width int) { // the percentage in the terminal's default colour. It draws the current // reading only — it carries no history. func renderGauge(w io.Writer, label string, pct float64, width int) { + fmt.Fprintf(w, " %-9s %s %.0f%%\n", label, gaugeBlock(pct, width), pct) +} + +// gaugeBlock returns the gauge's drawing at width — the filled portion in +// the state colour, the rest in light shade — the label and the trailing +// figure excluded. +func gaugeBlock(pct float64, width int) string { colour := ansiGreen if pct > 90 { colour = ansiRed @@ -233,17 +248,7 @@ func renderGauge(w io.Writer, label string, pct float64, width int) { if filled > width { filled = width } - empty := width - filled - fmt.Fprintf(w, " %-9s ", label) - fmt.Fprintf(w, "%s", colour) - for i := 0; i < filled; i++ { - fmt.Fprint(w, "█") - } - fmt.Fprintf(w, "%s", ansiReset) - for i := 0; i < empty; i++ { - fmt.Fprint(w, "░") - } - fmt.Fprintf(w, " %.0f%%\n", pct) + return colour + strings.Repeat("█", filled) + ansiReset + strings.Repeat("░", width-filled) } // barSeries is one resource series the bar and gauge formats draw: the label @@ -375,21 +380,40 @@ func renderStatBars(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, } } +// serveGaugeW and serveBarW are the two halves of the serve view's combined +// line: gauge and sparkline side by side at these widths, one line per +// series, sized so the line fits the default 80-column window label and +// trailing figure included. +const ( + serveGaugeW = 20 + serveBarW = 25 +) + // renderStatCombined draws the resource series in the serve view's format: -// each series as a gauge of its current reading with its retained history as -// a sparkline beneath, so "now" and "trend" sit together per resource instead -// of being a toggle. The gauge line carries the label and the sparkline line -// passes a blank one, so the pair stacks in the label column; a series with -// no retained history carries its gauge alone, and a series with no current -// reading its sparkline alone, so the two halves never draw the same line. -func renderStatCombined(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, gpus []metrics.GpuStat, history []metrics.HistorySample, lineW int) { +// each series on one line — its gauge of the current reading and its bar of +// the retained history side by side — so "now" and "trend" sit together per +// resource instead of being a toggle. The line's trailing figure is the +// current reading, falling back to the bar's latest sample where the reading +// carries no current one; a series with no history leaves its bar half blank +// and a series with no current reading its gauge half blank, so the lines +// align and the two halves never draw the same figure. +func renderStatCombined(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, gpus []metrics.GpuStat, history []metrics.HistorySample) { for _, s := range barSeriesList(cpu, mem, gpus, history) { + gaugeHalf := strings.Repeat(" ", serveGaugeW) + barHalf := strings.Repeat(" ", serveBarW) + figure := 0.0 if s.current != nil { - renderGauge(w, s.label, *s.current, lineW) + gaugeHalf = gaugeBlock(*s.current, serveGaugeW) + figure = *s.current } if len(s.history) > 0 { - renderSparkline(w, "", s.history, lineW) + var last float64 + barHalf, last = sparklineBlock(s.history, serveBarW) + if s.current == nil { + figure = last + } } + fmt.Fprintf(w, " %-9s %s %s %.0f%%\n", s.label, gaugeHalf, barHalf, figure) } } diff --git a/cmd/spinloop/metrics_render_test.go b/cmd/spinloop/metrics_render_test.go index 1e7a1fc..b431a9c 100644 --- a/cmd/spinloop/metrics_render_test.go +++ b/cmd/spinloop/metrics_render_test.go @@ -5,6 +5,7 @@ import ( "strings" "testing" + "github.com/charmbracelet/lipgloss" "github.com/spinloop-ai/spinloop/internal/metrics" "github.com/spinloop-ai/spinloop/internal/remote" ) @@ -320,30 +321,37 @@ func TestRenderStatCombined(t *testing.T) { {Time: 2, CPU: ptrPct(95), Mem: ptrPct(30), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 91, Mem: ptrPct(20)}}}, } var b bytes.Buffer - renderStatCombined(&b, cpu, mem, gpus, history, barLineW) + renderStatCombined(&b, cpu, mem, gpus, history) lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") - // One gauge and one sparkline per series, in the bar series' order. - if len(lines) != 8 { - t.Fatalf("drew %d lines, want 8: %q", len(lines), b.String()) + // One line per series, in the bar series' order. + if len(lines) != 4 { + t.Fatalf("drew %d lines, want 4: %q", len(lines), b.String()) } for i, label := range []string{" CPU ", " RAM ", " GPU util ", " GPU mem "} { - if !strings.HasPrefix(lines[i*2], label) { - t.Errorf("gauge line for %s: %q", label, lines[i*2]) - } - // The sparkline beneath leaves the label column blank. - if !strings.HasPrefix(lines[i*2+1], strings.Repeat(" ", 12)) { - t.Errorf("sparkline line took the label column: %q", lines[i*2+1]) + if !strings.HasPrefix(lines[i], label) { + t.Errorf("line for %s: %q", label, lines[i]) } } // Both halves take the state colour: the gauge over its whole fill, the - // sparkline on its last glyph only. - if !strings.Contains(lines[0], ansiGreen+strings.Repeat("█", 16)+ansiReset) { + // sparkline on its last glyph only — and the sparkline stops one grade + // short of the full block, so the 95% sample draws the top of the seven + // sub-full glyphs. + if !strings.Contains(lines[0], ansiGreen+strings.Repeat("█", 8)+ansiReset+strings.Repeat("░", 12)) { t.Errorf("CPU gauge: %q", lines[0]) } - // The sparkline stops one grade short of the full block, so the 95% - // sample draws the top of the seven sub-full glyphs. - if !strings.Contains(lines[1], ansiRed+"▇"+ansiReset+" 95%") { - t.Errorf("CPU sparkline: %q", lines[1]) + if !strings.Contains(lines[0], ansiRed+"▇"+ansiReset) { + t.Errorf("CPU sparkline: %q", lines[0]) + } + // The line's figure is the current reading, not the bar's last sample. + if !strings.HasSuffix(lines[0], " 42%") { + t.Errorf("the figure must be the current reading: %q", lines[0]) + } + // Every line is label, gauge half, bar half and figure: the halves sit + // side by side, aligned across the series. + for i, line := range lines { + if w := lipgloss.Width(line); w != 12+serveGaugeW+1+serveBarW+4 { + t.Errorf("line %d is %d columns wide, want %d: %q", i, w, 12+serveGaugeW+1+serveBarW+4, line) + } } } @@ -351,48 +359,67 @@ func TestRenderStatCombined(t *testing.T) { // half of the combined format. func TestRenderStatCombinedMemoryWithoutTotal(t *testing.T) { var b bytes.Buffer - renderStatCombined(&b, nil, &metrics.MemoryStat{Total: 0, Used: 100}, nil, nil, barLineW) + renderStatCombined(&b, nil, &metrics.MemoryStat{Total: 0, Used: 100}, nil, nil) if !strings.Contains(b.String(), " 0%") || strings.Contains(b.String(), "NaN") { t.Errorf("a memory reading with no total: %q", b.String()) } } -// Without retained history the format degenerates to the gauge format: each -// series carries its gauge alone, byte for byte the gauge drawing at the -// same width. +// Without retained history each series carries its gauge alone, its bar +// half left blank. func TestRenderStatCombinedWithoutHistory(t *testing.T) { cpu := &metrics.CpuStat{Utilization: 42} mem := &metrics.MemoryStat{Total: 1000, Used: 300} gpus := []metrics.GpuStat{{Index: 0, Name: "H100", Utilization: 61, MemoryUsed: 80, MemoryTotal: 160}} - var got, want bytes.Buffer - renderStatCombined(&got, cpu, mem, gpus, nil, gaugeW) - renderStatGauges(&want, cpu, mem, gpus) - if got.String() != want.String() { - t.Errorf("no-history combined differs from the gauge drawing:\ngot:\n%q\nwant:\n%q", got.String(), want.String()) + var b bytes.Buffer + renderStatCombined(&b, cpu, mem, gpus, nil) + lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") + blankBar := strings.Repeat(" ", serveBarW) + want := []string{ + " CPU " + gaugeBlock(42, serveGaugeW) + " " + blankBar + " 42%", + " RAM " + gaugeBlock(30, serveGaugeW) + " " + blankBar + " 30%", + " GPU util " + gaugeBlock(61, serveGaugeW) + " " + blankBar + " 61%", + " GPU mem " + gaugeBlock(50, serveGaugeW) + " " + blankBar + " 50%", + } + if len(lines) != len(want) { + t.Fatalf("drew %d lines, want %d: %q", len(lines), len(want), b.String()) + } + for i := range want { + if lines[i] != want[i] { + t.Errorf("line %d:\ngot %q\nwant %q", i, lines[i], want[i]) + } } } // A stopped engine carries no current figures, so the combined format draws // the retained readings alone — the sparkline lines with their blank label // column, no gauges at all. +// A stopped engine carries no current figures, so the combined format draws +// each series' history alone: the gauge half blank, the series' label kept, +// and the bar's latest sample as the line's figure. func TestRenderStatCombinedStoppedEngineDrawsHistoryAlone(t *testing.T) { history := []metrics.HistorySample{ {Time: 1, CPU: ptrPct(10), Mem: ptrPct(20), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 50, Mem: ptrPct(50)}}}, {Time: 2, CPU: ptrPct(20), Mem: ptrPct(30), GPUs: []metrics.HistoryGPU{{Index: 0, Util: 60, Mem: ptrPct(60)}}}, } var b bytes.Buffer - renderStatCombined(&b, nil, nil, nil, history, barLineW) + renderStatCombined(&b, nil, nil, nil, history) lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") if len(lines) != 4 { t.Fatalf("drew %d lines, want CPU, RAM, GPU util and GPU mem: %q", len(lines), b.String()) } + for i, label := range []string{"CPU", "RAM", "GPU util", "GPU mem"} { + if !strings.HasPrefix(lines[i], " "+label) { + t.Errorf("the history's series keep their labels: %q", lines[i]) + } + } for _, line := range lines { - if !strings.HasPrefix(line, strings.Repeat(" ", 12)) { - t.Errorf("a line took the label column: %q", line) + if !strings.Contains(line, strings.Repeat(" ", serveGaugeW+1)) { + t.Errorf("the gauge half must stay blank without a current reading: %q", line) } } - if !strings.Contains(lines[1], " 30%") || !strings.Contains(lines[3], " 60%") { - t.Errorf("sparklines lost their last readings: %q", strings.Join(lines, " / ")) + if !strings.HasSuffix(lines[1], " 30%") || !strings.HasSuffix(lines[3], " 60%") { + t.Errorf("the lines must carry the bar's latest sample as their figure: %q", strings.Join(lines, " / ")) } } diff --git a/cmd/spinloop/serve_view.go b/cmd/spinloop/serve_view.go index 0671ab8..bdb2d74 100644 --- a/cmd/spinloop/serve_view.go +++ b/cmd/spinloop/serve_view.go @@ -388,7 +388,7 @@ func (m serveView) metricsLines() []string { // rule for when the series exist at all. resources := m.stats.State == "running" || len(m.stats.History) > 0 if resources { - renderStatCombined(&b, m.stats.CPU, m.stats.Memory, m.stats.GPUs, m.stats.History, barLineW) + renderStatCombined(&b, m.stats.CPU, m.stats.Memory, m.stats.GPUs, m.stats.History) renderTokenLines(&b, m.stats.Tokens) } lines := strings.Split(b.String(), "\n") diff --git a/cmd/spinloop/serve_view_test.go b/cmd/spinloop/serve_view_test.go index 17a27d2..38c33f8 100644 --- a/cmd/spinloop/serve_view_test.go +++ b/cmd/spinloop/serve_view_test.go @@ -420,9 +420,9 @@ func TestServeViewEngineExitedQuits(t *testing.T) { } // The frame: the title bar with the path and the log's state, the metrics -// section in the view's own format — each series its gauge with its bar -// beneath — the tailed log, the dividers, and the footer naming exactly the -// keys the view answers to. +// section in the view's own format — each series its gauge and its bar side +// by side on one line — the tailed log, the dividers, and the footer naming +// exactly the keys the view answers to. func TestServeViewFrame(t *testing.T) { fixDashNow(t, time.Date(2026, 9, 6, 12, 0, 0, 0, time.UTC)) stats := metrics.Stats{ @@ -461,14 +461,19 @@ func TestServeViewFrame(t *testing.T) { t.Errorf("the frame is missing %q:\n%s", want, v) } } - // The gauge of each series sits with its bar beneath: the series' label - // once, on the gauge line, the bar's label blank. + // The gauge of each series sits with its bar on the series' own line: + // the label once, and both drawings on it. if strings.Count(v, "CPU") != 1 { t.Errorf("the CPU series must draw once, label and all:\n%s", v) } if strings.Count(v, "RAM") != 1 { t.Errorf("the RAM series must draw once, label and all:\n%s", v) } + for _, line := range strings.Split(v, "\n") { + if strings.Contains(line, "CPU") && (!strings.Contains(line, "█") || !strings.Contains(line, "▁")) { + t.Errorf("the CPU line must carry its gauge and its bar side by side:\n%q", line) + } + } // Every line fits the window. for i, line := range strings.Split(v, "\n") { if w := lipgloss.Width(line); w > 100 { diff --git a/docs/commands/serve.md b/docs/commands/serve.md index 1d2f2e1..2378df7 100644 --- a/docs/commands/serve.md +++ b/docs/commands/serve.md @@ -28,11 +28,11 @@ and a footer naming the keys the view answers to. - **Metrics** — the same facts the fleet dashboard's node detail screen shows for the same engine: state and uptime, what is served, last active, and the resource series — CPU, RAM, and each GPU's utilisation and memory — with - every series drawn in both formats at once: a gauge of the current reading - and, beneath it, the bar of its retained history. Below them, the token and - request counters. The reading comes from the daemon the serve process runs - in-process and refreshes on the dashboard's own local cadence; a reading the - view could not renew is shown with its age. + every series drawn in both formats at once, each on one line: a gauge of + the current reading beside the bar of its retained history. Below them, the + token and request counters. The reading comes from the daemon the serve + process runs in-process and refreshes on the dashboard's own local cadence; + a reading the view could not renew is shown with its age. - **Log** — the engine's own output, tailed and followed, so new lines appear as they are written. An engine that has written nothing yet shows a waiting note, not an empty pane. diff --git a/openspec/changes/serve-ui/design.md b/openspec/changes/serve-ui/design.md index a8f286d..4d5f4ea 100644 --- a/openspec/changes/serve-ui/design.md +++ b/openspec/changes/serve-ui/design.md @@ -81,19 +81,23 @@ endpoint serves it. The file outlives the run, as the daemon's does. the `/v1/logs` improvement and stands up a second log mechanism beside the daemon's. -**D4 — Both formats are one renderer, per series.** -A new shared function in `metrics_render.go` (the bar and gauge formats' +**D4 — Both formats share one line per series, in the view only.** +A new function in `metrics_render.go` (the bar and gauge formats' `barSeriesList` supplies the series and their order: CPU, RAM, each GPU's -utilisation and memory) draws, per series: the gauge of the current reading, -then — where the history holds samples — the sparkline beneath it, the bar -format's no-history rule making a history-less series gauge-only. The gauge -line carries the label; the sparkline line passes an empty label so the two -stack in the label column. `renderGauge` gains a width parameter (its -callers pass today's 25; the view passes `barLineW`), so gauge and bar share -one draw width and line up. -*Alternative:* a gauge block over a bar block — rejected; it separates -"now" from "trend" per resource, which is what the issue's "show both" does -not ask for. +utilisation and memory) draws one line per series — the gauge of the current +reading and the sparkline of the retained history side by side — with the +current reading as the line's figure, falling back to the bar's latest sample +where the reading carries no current one. A series with no history leaves its +bar half blank; a series with no current reading (the stopped engine) leaves +its gauge half blank, so the lines align and the two halves never draw the +same figure. The halves draw at `serveGaugeW` (20) and `serveBarW` (25) +columns, so a line fits the default 80-column window label and figure +included. `renderGauge` and `renderSparkline` sit on label-less, figure-less +block helpers, so the combined line joins the two halves without duplicating +their drawing, and the one-shot formats keep their own stacked output. +*Alternative:* the gauge stacked above its bar — rejected; two lines per +series at the 40-column width the stacked halves shared, wider than a row of +the dashboard's reference screen. **D5 — The log pane scrolls an in-memory tail, clamped to a line budget.** The model keeps the tailed content (most recent last) and `behind` — how diff --git a/openspec/changes/serve-ui/specs/local-serving/spec.md b/openspec/changes/serve-ui/specs/local-serving/spec.md index b2fe0ab..ddccd0a 100644 --- a/openspec/changes/serve-ui/specs/local-serving/spec.md +++ b/openspec/changes/serve-ui/specs/local-serving/spec.md @@ -73,10 +73,11 @@ local cadence. A reading the view could not renew SHALL be shown with its age rather than drawn identically to one just read. The view SHALL draw every resource series the reading carries in both formats -at once: the gauge of the current reading and, beneath it, the bar of the -retained history — the same series and labelling the bar and gauge formats -use, with the bar format's no-history rule where a series has no history to -draw, so a series with none carries its gauge alone. +at once, each series on one line: its gauge of the current reading and its +bar of the retained history side by side — the same series and labelling the +bar and gauge formats use, with the bar format's no-history rule where a +series has no history to draw, so a series with none carries its gauge +alone, its bar half blank. #### Scenario: The view opens on a terminal @@ -99,13 +100,14 @@ draw, so a series with none carries its gauge alone. #### Scenario: Every series is drawn in both formats - **WHEN** the reading carries a CPU series with a retained history -- **THEN** the view draws the series' gauge of the current reading and, - beneath it, its bar of the retained history +- **THEN** the view draws the series on one line: its gauge of the current + reading and its bar of the retained history, side by side #### Scenario: A series with no history carries its gauge alone - **WHEN** a series has no retained history to draw -- **THEN** the view draws its gauge of the current reading only +- **THEN** the view draws its gauge of the current reading only, its bar + half left blank ### Requirement: The serve view's log diff --git a/openspec/changes/serve-ui/tasks.md b/openspec/changes/serve-ui/tasks.md index a652d09..fe1737a 100644 --- a/openspec/changes/serve-ui/tasks.md +++ b/openspec/changes/serve-ui/tasks.md @@ -1,7 +1,7 @@ ## 1. Combined bar-and-gauge metrics rendering - [x] 1.1 Give `renderGauge` a width parameter in `cmd/spinloop/metrics_render.go`, updating its existing callers to pass today's 25-column width, and verify the existing metrics render tests pass unchanged -- [x] 1.2 Add the combined renderer (each series from `barSeriesList` as its gauge line of the current reading, then its sparkline line beneath where the history holds samples, the sparkline's label blank so the pair stacks, a history-less series gauge-only) and verify with table-driven tests covering: a series with history (both lines), a series with none (gauge alone), multi-GPU labelling, and the 80/90 colour thresholds on the gauge +- [x] 1.2 Add the combined renderer (each series from `barSeriesList` on one line: its gauge of the current reading beside its sparkline of the retained history, the line's figure the current reading or, where none, the bar's latest sample, a history-less series gauge-only its bar half blank, a current-less series history-only its gauge half blank) and verify with table-driven tests covering: a series with history (gauge and bar on one line), a series with none (gauge alone), a current-less series (history alone), multi-GPU labelling, and the 80/90 colour thresholds on both halves ## 2. Serve view model From 23ba6cdb7bea53c4aa68af4d551a9f7e71c92134 Mon Sep 17 00:00:00 2001 From: Pete Cornish Date: Mon, 7 Sep 2026 02:18:11 +0100 Subject: [PATCH 4/5] refactor(serve): put the view's figure between gauge and bar --- cmd/spinloop/metrics_render.go | 22 +++++------ cmd/spinloop/metrics_render_test.go | 59 +++++++++++++++++++---------- 2 files changed, 49 insertions(+), 32 deletions(-) diff --git a/cmd/spinloop/metrics_render.go b/cmd/spinloop/metrics_render.go index 1593dc6..702a0cb 100644 --- a/cmd/spinloop/metrics_render.go +++ b/cmd/spinloop/metrics_render.go @@ -381,22 +381,22 @@ func renderStatBars(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, } // serveGaugeW and serveBarW are the two halves of the serve view's combined -// line: gauge and sparkline side by side at these widths, one line per -// series, sized so the line fits the default 80-column window label and -// trailing figure included. +// line: gauge and sparkline at these widths with the figure between them, +// one line per series, sized so the line fits the default 80-column window +// label and figure included. const ( serveGaugeW = 20 serveBarW = 25 ) // renderStatCombined draws the resource series in the serve view's format: -// each series on one line — its gauge of the current reading and its bar of -// the retained history side by side — so "now" and "trend" sit together per -// resource instead of being a toggle. The line's trailing figure is the -// current reading, falling back to the bar's latest sample where the reading -// carries no current one; a series with no history leaves its bar half blank -// and a series with no current reading its gauge half blank, so the lines -// align and the two halves never draw the same figure. +// each series on one line — its gauge of the current reading, the figure, +// and its bar of the retained history — so "now" and "trend" sit together +// per resource instead of being a toggle. The figure is the current reading, +// falling back to the bar's latest sample where the reading carries no +// current one; a series with no history leaves its bar half blank and a +// series with no current reading its gauge half blank, so the lines align +// and the figure never draws a half's own number twice. func renderStatCombined(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemoryStat, gpus []metrics.GpuStat, history []metrics.HistorySample) { for _, s := range barSeriesList(cpu, mem, gpus, history) { gaugeHalf := strings.Repeat(" ", serveGaugeW) @@ -413,7 +413,7 @@ func renderStatCombined(w io.Writer, cpu *metrics.CpuStat, mem *metrics.MemorySt figure = last } } - fmt.Fprintf(w, " %-9s %s %s %.0f%%\n", s.label, gaugeHalf, barHalf, figure) + fmt.Fprintf(w, " %-9s %s %.0f%% %s\n", s.label, gaugeHalf, figure, barHalf) } } diff --git a/cmd/spinloop/metrics_render_test.go b/cmd/spinloop/metrics_render_test.go index b431a9c..cbe384c 100644 --- a/cmd/spinloop/metrics_render_test.go +++ b/cmd/spinloop/metrics_render_test.go @@ -332,6 +332,14 @@ func TestRenderStatCombined(t *testing.T) { t.Errorf("line for %s: %q", label, lines[i]) } } + // The line is label, gauge half, figure, bar half — the figure between + // the two halves, and it is the current reading, not the bar's last + // sample. + cpuBar, _ := sparklineBlock([]float64{10, 95}, serveBarW) + wantCPU := " CPU " + gaugeBlock(42, serveGaugeW) + " 42% " + cpuBar + if lines[0] != wantCPU { + t.Errorf("CPU line:\ngot %q\nwant %q", lines[0], wantCPU) + } // Both halves take the state colour: the gauge over its whole fill, the // sparkline on its last glyph only — and the sparkline stops one grade // short of the full block, so the 95% sample draws the top of the seven @@ -342,15 +350,12 @@ func TestRenderStatCombined(t *testing.T) { if !strings.Contains(lines[0], ansiRed+"▇"+ansiReset) { t.Errorf("CPU sparkline: %q", lines[0]) } - // The line's figure is the current reading, not the bar's last sample. - if !strings.HasSuffix(lines[0], " 42%") { - t.Errorf("the figure must be the current reading: %q", lines[0]) - } - // Every line is label, gauge half, bar half and figure: the halves sit - // side by side, aligned across the series. + // Every line is label, gauge half, figure and bar half: the halves sit + // side by side, aligned across the series. 62 is label (12), gauge half, + // " 42%"-style figure (4, two digits in this data), a space, bar half. for i, line := range lines { - if w := lipgloss.Width(line); w != 12+serveGaugeW+1+serveBarW+4 { - t.Errorf("line %d is %d columns wide, want %d: %q", i, w, 12+serveGaugeW+1+serveBarW+4, line) + if w := lipgloss.Width(line); w != 12+serveGaugeW+4+1+serveBarW { + t.Errorf("line %d is %d columns wide, want %d: %q", i, w, 12+serveGaugeW+4+1+serveBarW, line) } } } @@ -376,10 +381,10 @@ func TestRenderStatCombinedWithoutHistory(t *testing.T) { lines := strings.Split(strings.TrimSuffix(b.String(), "\n"), "\n") blankBar := strings.Repeat(" ", serveBarW) want := []string{ - " CPU " + gaugeBlock(42, serveGaugeW) + " " + blankBar + " 42%", - " RAM " + gaugeBlock(30, serveGaugeW) + " " + blankBar + " 30%", - " GPU util " + gaugeBlock(61, serveGaugeW) + " " + blankBar + " 61%", - " GPU mem " + gaugeBlock(50, serveGaugeW) + " " + blankBar + " 50%", + " CPU " + gaugeBlock(42, serveGaugeW) + " 42% " + blankBar, + " RAM " + gaugeBlock(30, serveGaugeW) + " 30% " + blankBar, + " GPU util " + gaugeBlock(61, serveGaugeW) + " 61% " + blankBar, + " GPU mem " + gaugeBlock(50, serveGaugeW) + " 50% " + blankBar, } if len(lines) != len(want) { t.Fatalf("drew %d lines, want %d: %q", len(lines), len(want), b.String()) @@ -408,18 +413,30 @@ func TestRenderStatCombinedStoppedEngineDrawsHistoryAlone(t *testing.T) { if len(lines) != 4 { t.Fatalf("drew %d lines, want CPU, RAM, GPU util and GPU mem: %q", len(lines), b.String()) } - for i, label := range []string{"CPU", "RAM", "GPU util", "GPU mem"} { - if !strings.HasPrefix(lines[i], " "+label) { - t.Errorf("the history's series keep their labels: %q", lines[i]) - } + blankGauge := strings.Repeat(" ", serveGaugeW) + wantPrefix := []string{ + " CPU " + blankGauge + " 20% ", + " RAM " + blankGauge + " 30% ", + " GPU util " + blankGauge + " 60% ", + " GPU mem " + blankGauge + " 60% ", } - for _, line := range lines { - if !strings.Contains(line, strings.Repeat(" ", serveGaugeW+1)) { - t.Errorf("the gauge half must stay blank without a current reading: %q", line) + for i, want := range wantPrefix { + if !strings.HasPrefix(lines[i], want) { + t.Errorf("line %d:\ngot %q\nwant prefix %q", i, lines[i], want) } } - if !strings.HasSuffix(lines[1], " 30%") || !strings.HasSuffix(lines[3], " 60%") { - t.Errorf("the lines must carry the bar's latest sample as their figure: %q", strings.Join(lines, " / ")) + // The bar ends the line, its two samples as its two right-most glyphs, + // the newest in the state colour. + wantSuffix := []string{ + "▁" + ansiGreen + "▂" + ansiReset, + "▂" + ansiGreen + "▃" + ansiReset, + "▄" + ansiGreen + "▅" + ansiReset, + "▄" + ansiGreen + "▅" + ansiReset, + } + for i, want := range wantSuffix { + if !strings.HasSuffix(lines[i], want) { + t.Errorf("line %d must end with the bar's two samples:\ngot %q", i, lines[i]) + } } } From 3b139760d66f393263845516aeb701f766d02a39 Mon Sep 17 00:00:00 2001 From: Pete Cornish Date: Mon, 7 Sep 2026 09:13:10 +0100 Subject: [PATCH 5/5] docs: adds screenshot of serve UI --- README.md | 26 ++++++++++++++++---------- docs/img/serve_metrics.png | Bin 0 -> 390962 bytes 2 files changed, 16 insertions(+), 10 deletions(-) create mode 100644 docs/img/serve_metrics.png diff --git a/README.md b/README.md index bae73ad..20fff4a 100644 --- a/README.md +++ b/README.md @@ -46,6 +46,12 @@ llama.cpp, vLLM, MTPLX and oMLX all run from those same few lines — change `PROVIDER` and the same file serves the model on a different engine. → [Serving a local model](#serving-a-local-model) +

+ The spinloop serve view: Gemma4 running locally under llama.cpp, with live engine and machine metrics +

+ +> In this screenshot, Gemma4 running locally under llama.cpp, with live engine and machine metrics. + ### 2. On every machine you own Whilst `serve` holds a terminal open for as long as the model runs, `spinloop daemon` @@ -67,16 +73,16 @@ Start the whole fleet with `spinloop up` or just one with `spinloop fleet start The spinloop fleet dashboard: four nodes serving Qwen3.8-27B under llama.cpp, and a fifth cloud node not yet deployed

-In this screenshot, five nodes are configured and four are up, each serving the same -`Qwen3.8-27B` model through llama.cpp. Three of them — `dev-2`, `dev-3`, -`dev-4` — are mid-request: one slot running apiece, GPU util between 91% and -98%. `dev-1` finished about a minute ago, so its GPU util has dropped to 0% -while GPU memory stays at 89% — the weights are still loaded, and the next -request it takes starts generating without a reload. - -The keys along the bottom drive the fleet from here: `s` start, `x` stop, `r` -refresh, and `` for one node full-screen with its engine log tailed live. -→ [The fleet](#the-fleet) +> In this screenshot, five nodes are configured and four are up, each serving the same +> `Qwen3.8-27B` model through llama.cpp. Three of them — `dev-2`, `dev-3`, +> `dev-4` — are mid-request: one slot running apiece, GPU util between 91% and +> 98%. `dev-1` finished about a minute ago, so its GPU util has dropped to 0% +> while GPU memory stays at 89% — the weights are still loaded, and the next +> request it takes starts generating without a reload. +> +> The keys along the bottom drive the fleet from here: `s` start, `x` stop, `r` +> refresh, and `` for one node full-screen with its engine log tailed live. +> → [The fleet](#the-fleet) ### 3. On a cloud GPU, for as long as you need one diff --git a/docs/img/serve_metrics.png b/docs/img/serve_metrics.png new file mode 100644 index 0000000000000000000000000000000000000000..47db8e02575f1027a6e123a05a0987f26b24c2bc GIT binary patch literal 390962 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

r8;;+xo^yE5shFx0*KbF-TY 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%0AAPCrYS7Y=$RvQCPkJy;Bb=E{*p4o@(u4F`S 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

BeZkJXM;_W3-B%rGDZYR<0&?j{ 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�Kx|7g0Sl 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 X@*yv)q4H7=3HVb})>10IdL#H>=!(sC literal 0 HcmV?d00001