Continues #3341 item 3, unblocked now that #3568/#3569 (items 1/2) are merged and GET /api/agents/status is live. Third fetch alongside the existing roster + config-PR ones, joined client-side by name same as the config-PR merge. Adds a hive column and a status column (freshness badge + status_text + relative-time, same rendering AgentsPage's sibling HivesPage already uses for the hive-level status endpoint).
211 lines
7.4 KiB
TypeScript
211 lines
7.4 KiB
TypeScript
// <AgentsPage> — the swarm's agent roster, merged with each agent's open
|
|
// config-PR status and swarm-wide health status in the same table. Three
|
|
// separate asks (a roster listing, a per-agent config-PR indicator, and
|
|
// per-agent status/liveness) that turned out to be one page: a roster with
|
|
// no per-row detail is thin, and neither a config-PR panel nor a status
|
|
// panel has anything to render against without a roster to embed in.
|
|
//
|
|
// Three fetches, all on a refresh-interval cadence like HivesPage: `GET
|
|
// /api/agents` (just names — the identity store is the roster, and
|
|
// deliberately says nothing about health), `GET /api/config-prs` (agent
|
|
// name -> open PR, only agents with one present), and `GET
|
|
// /api/agents/status` (one row per roster agent, freshness derived at read
|
|
// time — same shape and same roster-not-bucket rule as HivesPage's
|
|
// `/api/hives/status`, see `swarm-controller/src/agent_status.rs`). Merged
|
|
// client-side into one row per agent rather than N per-agent calls —
|
|
// exactly why the bulk endpoints exist instead of looping a single-agent
|
|
// one.
|
|
//
|
|
// Owns the "+ agent" trigger too — the roster this populates is the
|
|
// natural home for the action that populates it; a separate top-level
|
|
// nav entry would be one click of indirection for no benefit. The form
|
|
// itself (`CreateAgentForm`) mounts inside a `Dialog` here rather than
|
|
// its own route.
|
|
import { useState } from 'preact/hooks';
|
|
import { ApiErrorPanel } from '@hive/shared/api-error-panel.js';
|
|
import { readApiError, type ProblemDetails } from '@hive/shared/api-error.js';
|
|
import { Badge, type BadgeTone } from '@hive/shared/badge.js';
|
|
import { Button } from '../ui/button/Button.js';
|
|
import { Dialog } from '../ui/dialog/Dialog.js';
|
|
import { Panel } from '../ui/panel/Panel.js';
|
|
import { RelativeTime } from '../ui/relative-time/RelativeTime.js';
|
|
import {
|
|
RefreshIntervalPicker,
|
|
useRefreshInterval,
|
|
type RefreshIntervalMs,
|
|
} from '../ui/refresh-interval/RefreshInterval.js';
|
|
import { Table, type TableColumn } from '../ui/table/Table.js';
|
|
import { CreateAgentForm } from './CreateAgentForm.js';
|
|
|
|
interface ConfigPrStatus {
|
|
pr_number: number;
|
|
html_url: string | null;
|
|
}
|
|
|
|
type Freshness = 'fresh' | 'stale' | 'never_reported' | 'unknown';
|
|
|
|
interface AgentStatusSnapshot {
|
|
status_text: string | null;
|
|
status_set_at: number | null;
|
|
running: boolean;
|
|
}
|
|
|
|
interface AgentStatusRow {
|
|
name: string;
|
|
hive: string | null;
|
|
freshness: Freshness;
|
|
last_seen_unix: number | null;
|
|
// `age_seconds` deliberately unused here, same reason as HivesPage:
|
|
// `RelativeTime` recomputes age client-side from `last_seen_unix`
|
|
// rather than rendering a once-computed-at-fetch value.
|
|
snapshot: AgentStatusSnapshot | null;
|
|
}
|
|
|
|
interface AgentRow {
|
|
name: string;
|
|
configPr: ConfigPrStatus | null;
|
|
status: AgentStatusRow | null;
|
|
}
|
|
|
|
// Same tone/label pairing as HivesPage — one freshness enum shared by both
|
|
// endpoints, so the same rendering rule applies to both pages.
|
|
const FRESHNESS: Record<Freshness, { tone: BadgeTone; label: string }> = {
|
|
fresh: { tone: 'positive', label: 'fresh' },
|
|
stale: { tone: 'warning', label: 'stale' },
|
|
never_reported: { tone: 'neutral', label: 'never reported' },
|
|
unknown: { tone: 'negative', label: 'unknown' },
|
|
};
|
|
|
|
const COLUMNS: TableColumn<AgentRow>[] = [
|
|
{ key: 'name', header: 'name', render: (a) => a.name },
|
|
{ key: 'hive', header: 'hive', render: (a) => a.status?.hive ?? '—' },
|
|
{
|
|
key: 'status',
|
|
header: 'status',
|
|
render: (a) => {
|
|
if (!a.status) return '—';
|
|
const { tone, label } = FRESHNESS[a.status.freshness];
|
|
const text = a.status.snapshot?.status_text;
|
|
// A `running: false` snapshot always carries `status_text: null`
|
|
// (the wire contract's own rule, not something this page derives),
|
|
// so an agent that reported recently but isn't running still shows
|
|
// a bare freshness badge rather than a stale status string.
|
|
return (
|
|
<Badge
|
|
tone={tone}
|
|
value={
|
|
<>
|
|
{text ? `${text} — ` : ''}
|
|
{label}
|
|
{a.status.last_seen_unix !== null ? (
|
|
<>
|
|
{' '}
|
|
(<RelativeTime epochMs={a.status.last_seen_unix * 1000} />)
|
|
</>
|
|
) : null}
|
|
</>
|
|
}
|
|
/>
|
|
);
|
|
},
|
|
},
|
|
{
|
|
key: 'config-pr',
|
|
header: 'config PR',
|
|
render: (a) =>
|
|
a.configPr ? (
|
|
<Badge
|
|
tone="warning"
|
|
value={
|
|
a.configPr.html_url ? (
|
|
<a href={a.configPr.html_url} target="_blank" rel="noreferrer">
|
|
#{a.configPr.pr_number}
|
|
</a>
|
|
) : (
|
|
`#${a.configPr.pr_number}`
|
|
)
|
|
}
|
|
/>
|
|
) : (
|
|
'—'
|
|
),
|
|
},
|
|
];
|
|
|
|
// Same 30s default + same reasoning as HivesPage: no inputs on this page
|
|
// for a refresh to clobber, so the out-of-the-box behaviour should just
|
|
// solve staleness rather than require an opt-in every visit.
|
|
const DEFAULT_INTERVAL_MS: RefreshIntervalMs = 30_000;
|
|
|
|
export function AgentsPage() {
|
|
const [rows, setRows] = useState<AgentRow[] | null>(null);
|
|
const [error, setError] = useState<ProblemDetails | null>(null);
|
|
const [intervalMs, setIntervalMs] = useState<RefreshIntervalMs>(DEFAULT_INTERVAL_MS);
|
|
const [createOpen, setCreateOpen] = useState(false);
|
|
|
|
useRefreshInterval(intervalMs, () => {
|
|
(async () => {
|
|
const [namesRes, prsRes, statusRes] = await Promise.all([
|
|
fetch('/api/agents'),
|
|
fetch('/api/config-prs'),
|
|
fetch('/api/agents/status'),
|
|
]);
|
|
if (!namesRes.ok) {
|
|
setError(await readApiError(namesRes));
|
|
return;
|
|
}
|
|
if (!prsRes.ok) {
|
|
setError(await readApiError(prsRes));
|
|
return;
|
|
}
|
|
if (!statusRes.ok) {
|
|
setError(await readApiError(statusRes));
|
|
return;
|
|
}
|
|
const names = (await namesRes.json()) as string[];
|
|
const prs = (await prsRes.json()) as Record<string, ConfigPrStatus>;
|
|
const statuses = (await statusRes.json()) as AgentStatusRow[];
|
|
const statusByName = new Map(statuses.map((s) => [s.name, s]));
|
|
setRows(
|
|
names.map((name) => ({
|
|
name,
|
|
configPr: prs[name] ?? null,
|
|
status: statusByName.get(name) ?? null,
|
|
})),
|
|
);
|
|
// A refresh that succeeds clears a previous failure — otherwise a
|
|
// transient error would sit on screen forever after the data itself
|
|
// has recovered.
|
|
setError(null);
|
|
})().catch((e: unknown) => setError({ detail: String(e) }));
|
|
});
|
|
|
|
return (
|
|
<Panel
|
|
title="agents"
|
|
icon="👥"
|
|
actions={
|
|
<>
|
|
<Button variant="primary" onClick={() => setCreateOpen(true)}>
|
|
+ agent
|
|
</Button>
|
|
<RefreshIntervalPicker id="agents-refresh" value={intervalMs} onChange={setIntervalMs} />
|
|
</>
|
|
}
|
|
>
|
|
{error ? <ApiErrorPanel context="failed to load the agent roster" problem={error} /> : null}
|
|
{!error && rows === null ? <p>loading…</p> : null}
|
|
{rows ? (
|
|
<Table
|
|
columns={COLUMNS}
|
|
rows={rows}
|
|
rowKey={(a) => a.name}
|
|
emptyMessage="no agents yet — the swarm-wide identity store has no agents registered on any hive"
|
|
/>
|
|
) : null}
|
|
<Dialog open={createOpen} onClose={() => setCreateOpen(false)} label="create agent">
|
|
<CreateAgentForm />
|
|
</Dialog>
|
|
</Panel>
|
|
);
|
|
}
|