repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

Add ui progress and status strips

ffef3b8eef4e3ecddad04db0a394da60a4605fe0

Oliver Krylow <o.krylow@isp-insoft.de> ·

unsigned

Browse filesCompare with HEAD

Changed files (15)

extensions/ui/__e2e__/fake-rpc.spec.ts

Modified
60 60 const unauthorized = await request.get(server.baseUrl + "/api/status");
61 61 expect(unauthorized.status()).toBe(401);
62 62 await page.goto(server.publicUrl);
63 - await expect(page.locator("#ui-status")).toHaveText(
63 + await expect(page.locator("#ui-progress")).toHaveText(
64 64 /starting|connected|waiting|rpc/,
66 66 if (pageErrors.length) throw new Error(pageErrors.join("\n"));

extensions/ui/__tests__/digest-indicator.test.ts

Modified
2 2 import { describe, expect, it } from "vitest";
3 3 import { digestIndicatorText } from "../web/components/digest-indicator.js";
5 5 describe("ui digest indicator", () => {
6 - it("describes pending digest state", () => {
7 - expect(digestIndicatorText(0)).toBe("digest empty");
8 - expect(digestIndicatorText(3)).toBe("digest will be sent · 3 events");
6 + it("describes pending digest state as a compact chip", () => {
7 + expect(digestIndicatorText(0)).toBe("digest 0");
8 + expect(digestIndicatorText(3)).toBe("digest 3");
9 9 });

extensions/ui/__tests__/extension-ui.test.ts

Modified
58 + it("preserves status request keys for the browser status strip", () => {
59 + expect(
60 + extensionUiEventFromRequest({
61 + type: "extension_ui_request",
62 + id: "s1",
63 + method: "setStatus",
64 + statusKey: "model-info",
65 + statusText: "gpt-5 high",
66 + }),
67 + ).toMatchObject({
68 + type: "ui_status",
69 + requestId: "s1",
70 + statusKey: "model-info",
71 + statusText: "gpt-5 high",
72 + });
73 + });
58 75 it("creates response commands for values, confirmations, and cancellations", () => {
59 76 expect(extensionUiResponseCommand("u1", { value: "a" })).toEqual({
60 77 type: "extension_ui_response",

extensions/ui/__tests__/server.test.ts

Modified
37 +async function waitFor(predicate: () => boolean): Promise<void> {
38 + for (let attempt = 0; attempt < 20; attempt += 1) {
39 + if (predicate()) return;
40 + await new Promise((resolve) => setTimeout(resolve, 10));
41 + }
37 44 describe("ui errors", () => {
38 45 it("formats human-actionable errors", () => {
39 46 const err = uiError("server_bind_failed", "Could not bind LAN server", {
150 + it("counts active websocket tabs, not html loads", async () => {
151 + const server = await startUiServer({
152 + address: "127.0.0.1",
153 + token: "tok",
154 + preferredPort: 0,
155 + });
156 + try {
157 + const page = await fetch(`${server.baseUrl}/?token=tok`);
158 + expect(page.status).toBe(200);
159 + expect(server.clients()).toBe(0);
161 + const ws = new WebSocket(
162 + `${server.baseUrl.replace("http", "ws")}/ws?token=tok`,
163 + );
164 + await once(ws, "open");
165 + expect(server.clients()).toBe(1);
166 + ws.close();
167 + await once(ws, "close");
168 + await waitFor(() => server.clients() === 0);
169 + expect(server.clients()).toBe(0);
170 + } finally {
171 + await server.close("test");
173 + });
143 175 it("authenticates websocket replay and broadcasts events", async () => {
144 176 const events = new EventStore({ now: () => 2 });
145 177 events.append({ type: "log", level: "info", message: "old" });

extensions/ui/__tests__/theme.test.ts

Modified
1 1 import { describe, expect, it } from "vitest";
2 2 import { renderAppCss } from "../web/app.css";
3 +import { renderAppHtml } from "../web/app.html";
3 4 import { renderThemeCss } from "../web/theme.css";
5 6 describe("ui Nugu theme", () => {
29 30 expect(css).toContain("#ui-bottom { position: sticky; bottom: 0;");
30 31 expect(css).toContain("#ui-input { width: 100%; max-height: 30vh;");
34 + it("renders explicit progress and status regions", () => {
35 + const html = renderAppHtml();
36 + const css = renderAppCss();
37 + expect(html).toContain('id="ui-top"');
38 + expect(html).toContain('id="ui-progress"');
39 + expect(html).toContain('id="ui-meta"');
40 + expect(html).toContain('id="ui-digest"');
41 + expect(html).not.toContain("<details");
42 + expect(css).toContain("#ui-progress");
43 + expect(css).toContain("#ui-meta");
44 + expect(css).toContain("#ui-digest");
45 + });

extensions/ui/__tests__/web-smoke.test.ts

Modified
12 12 const shell = await fetch(`${server.baseUrl}/?token=tok`);
13 13 expect(shell.status).toBe(200);
14 14 const html = await shell.text();
15 - expect(html).toContain('id="ui-status"');
15 + expect(html).toContain('id="ui-progress"');
16 + expect(html).toContain('id="ui-meta"');
16 17 expect(html).toContain('id="ui-stream"');
17 18 expect(html).toContain('id="ui-composer"');
18 19 expect(html).toContain('type="module"');

extensions/ui/extension-ui.ts

Modified
80 80 notifyType: notifyType(request.notifyType),
83 + const { method, ...fields } = request;
84 + delete fields.type;
85 + delete fields.id;
83 86 return {
84 - type: extensionUiEventType(request.method),
87 + type: extensionUiEventType(method),
85 88 requestId: request.id,
86 - message: `${request.method}: ${JSON.stringify(request)}`,
89 + message: statusMessage(method, fields),
90 + ...fields,
118 122 if (method === "set_editor_text") return "ui_editor_text";
119 123 return "ui_status";
126 +function statusMessage(
127 + method: string,
128 + fields: Record<string, unknown>,
129 +): string {
130 + if (typeof fields.statusText === "string") return fields.statusText;
131 + if (typeof fields.title === "string") return fields.title;
132 + return method;

extensions/ui/scripts/phase1-smoke.mjs

Modified
68 68 await page.goto(url);
69 69 await page.waitForSelector("#ui-shell");
70 70 await page.waitForSelector("#ui-composer");
71 - return await page.locator("#ui-status").innerText();
71 + return await page.locator("#ui-progress").innerText();
72 72 } finally {
73 73 await browser.close();

extensions/ui/scripts/zellij-smoke.mjs

Modified
181 181 await page.goto(url);
182 182 await page.waitForSelector("#ui-shell");
183 183 await page.waitForSelector("#ui-composer");
184 - return await page.locator("#ui-status").innerText();
184 + return await page.locator("#ui-progress").innerText();
185 185 } finally {
186 186 await browser.close();

extensions/ui/server.ts

Modified
46 46 const token = options.token ?? randomBytes(32).toString("base64url");
47 47 const host = listenHostFor(options.address);
48 48 let currentState: UiServerState = "waiting";
49 - let clientCount = 0;
50 49 let clientSeq = 0;
51 50 let closed = false;
52 51 const sockets = new Set<WebSocket>();
58 57 snapshotStatus: options.snapshotStatus,
59 58 commands: options.commands,
60 59 state: () => currentState,
61 - clients: () => clientCount,
60 + clients: () => sockets.size,
62 61 setState(next) {
63 62 currentState = next;
64 63 options.onClientState?.(next);
66 - clientSeen() {
67 - clientCount += 1;
68 - },
79 75 wss.handleUpgrade(req, socket, head, (ws) => {
80 76 const clientId = `client-${++clientSeq}`;
81 77 sockets.add(ws);
82 - clientCount += 1;
83 78 currentState = "connected";
84 79 options.onClientState?.("connected");
85 80 void options.onBrowserMessage?.({
113 108 ws.on("close", () => {
114 109 sockets.delete(ws);
110 + currentState = sockets.size > 0 ? "connected" : "inactive";
111 + options.onClientState?.(currentState);
115 112 void options.onBrowserMessage?.({ type: "lifecycle_close", clientId });
130 127 port: address.port,
131 128 token,
132 129 state: () => currentState,
133 - clients: () => clientCount,
130 + clients: () => sockets.size,
134 131 publish(event) {
135 132 const payload = JSON.stringify({ type: "events", events: [event] });
136 133 for (const ws of sockets) {
159 156 state(): UiServerState;
160 157 clients(): number;
161 158 setState(state: UiServerState): void;
162 - clientSeen(): void;
165 161 async function dispatch(
223 219 serveUnauthorized(res);
224 220 return;
226 - ctx.clientSeen();
227 - ctx.setState("connected");
228 222 res.setHeader(
229 223 "Set-Cookie",
230 224 `${COOKIE}=${ctx.token}; SameSite=Strict; Path=/`,

extensions/ui/web/app.css.ts

Modified
17 17 .ui-diff summary { cursor: pointer; font-weight: 800; }
18 18 .ui-expand-output { display: block; margin-top: 8px; font: inherit; border: 2px solid var(--nugu-line); background: var(--nugu-bg); color: var(--nugu-fg); }
19 19 #ui-bottom { position: sticky; bottom: 0; z-index: 10; border-top: 4px solid var(--nugu-accent); background: var(--nugu-panel); box-shadow: 0 -8px 0 color-mix(in srgb, var(--nugu-bg) 85%, transparent); }
20 -#ui-digest { padding: 6px 8px; font-size: 12px; }
21 -#ui-composer { display: grid; grid-template-columns: 1fr auto; gap: 8px; border-top: 3px solid var(--nugu-line); padding: 8px; }
20 +#ui-meta { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; padding: 6px 8px; border-bottom: 2px solid var(--nugu-line); color: var(--nugu-muted); font-size: 12px; }
21 +#ui-meta span { border: 1px solid color-mix(in srgb, var(--nugu-line) 45%, transparent); padding: 2px 5px; }
22 +#ui-digest { color: var(--nugu-muted); }
23 +#ui-digest[data-pending="true"] { color: var(--nugu-accent); border-color: var(--nugu-accent); }
24 +#ui-composer { display: grid; grid-template-columns: 1fr auto; gap: 8px; padding: 8px; }
22 25 #ui-input-wrap { position: relative; min-width: 0; }
23 26 #ui-input { width: 100%; max-height: 30vh; min-height: 42px; resize: vertical; font: inherit; background: var(--nugu-bg); color: var(--nugu-fg); border: 2px solid var(--nugu-line); padding: 8px; }
24 27 #ui-command-menu { position: absolute; left: 0; right: 0; bottom: 100%; border: 2px solid var(--nugu-line); background: var(--nugu-bg); max-height: 40vh; overflow: auto; }

extensions/ui/web/app.html.ts

Modified
10 10 </head>
11 11 <body>
12 12 <div id="ui-shell">
13 -<header id="ui-status">starting</header>
13 +<header id="ui-top"><strong>PI</strong><span id="ui-progress">starting</span><span>/ui off in terminal</span></header>
14 14 <main id="ui-stream" aria-live="polite"></main>
15 15 <div id="ui-bottom">
16 -<details id="ui-digest">digest empty</details>
16 +<div id="ui-meta"><span>model —</span><span>thinking —</span><span>ctx —</span><span>Esc abort · Ctrl+O expand · Ctrl+P model · / @ !</span><span id="ui-digest" role="status" aria-live="polite" data-pending="false">digest 0</span></div>
17 17 <form id="ui-composer">
18 18 <div id="ui-input-wrap">
19 19 <textarea id="ui-input" name="prompt" placeholder="Message Pi"></textarea>

extensions/ui/web/app.js.ts

Modified
9 9 import { renderTelemetryWorkerJs } from "./worker.js";
11 11 export function renderAppJs(): string {
12 - return `const status = document.querySelector('#ui-status');
12 + return `const status = document.querySelector('#ui-progress');
13 +const meta = document.querySelector('#ui-meta');
13 14 const stream = document.querySelector('#ui-stream');
14 15 const form = document.querySelector('#ui-composer');
15 16 const input = document.querySelector('#ui-input');
21 22 let telemetryWorker;
22 23 let lastEventId = 0;
23 24 let socket;
25 +const statusItems = new Map();
25 27 ${renderComposerComponentJs()}
26 28 ${renderDialogsComponentJs()}
57 59 const response = await fetch('/api/snapshot', { headers: authHeaders() });
58 60 if (!response.ok) throw new Error('snapshot failed: ' + response.status);
59 61 const snapshot = await response.json();
60 - status.textContent = snapshot.status;
62 + setProgress(snapshot.status);
61 63 commands = snapshot.commands || [];
62 64 renderEvents(snapshot.events || []);
63 65 lastEventId = snapshot.lastEventId || 0;
75 77 if (payload.type === 'events') renderEvents(payload.events || []);
77 79 socket.addEventListener('open', () => {
78 - status.textContent = 'connected';
80 + if (status.textContent === 'starting') setProgress('connected');
79 81 socket.send(JSON.stringify({ type: 'lifecycle_heartbeat' }));
80 82 setInterval(() => socket?.readyState === WebSocket.OPEN && socket.send(JSON.stringify({ type: 'lifecycle_heartbeat' })), 5000);
82 - socket.addEventListener('close', () => { status.textContent = 'disconnected'; });
84 + socket.addEventListener('close', () => { setProgress('disconnected'); });
85 87 function renderEvents(events) {
118 120 function applyInternalEvent(event) {
119 - if (event.type === 'state') status.textContent = event.state;
120 - if (event.type === 'log' && event.level === 'error') status.textContent = event.message;
121 + if (event.type === 'state') setProgress(event.state);
122 + if (event.type === 'log' && event.level === 'error') setProgress(event.message);
123 + if (event.type === 'ui_status') updateMetaStatus(event);
126 +function setProgress(value) {
127 + status.textContent = value;
128 + status.dataset.state = String(value || 'unknown');
131 +function updateMetaStatus(event) {
132 + const key = event.statusKey || event.key || event.requestId;
133 + const value = event.statusText || event.text || event.message || '';
134 + if (!key || !value) return;
135 + statusItems.set(String(key), String(value));
136 + renderMetaStatus();
139 +function renderMetaStatus() {
140 + const digest = document.querySelector('#ui-digest');
141 + const rows = [...statusItems.entries()].slice(-6);
142 + meta.textContent = '';
143 + if (rows.length === 0) {
144 + for (const label of ['model —', 'thinking —', 'ctx —', 'Esc abort · Ctrl+O expand · Ctrl+P model · / @ !']) {
145 + const item = document.createElement('span');
146 + item.textContent = label;
147 + meta.append(item);
149 + } else {
150 + for (const [key, value] of rows) {
151 + const item = document.createElement('span');
152 + item.textContent = key + ': ' + value;
153 + meta.append(item);
156 + if (digest) meta.append(digest);
123 159 function isStreamEvent(event) {
195 231 startTelemetryWorker();
196 232 trackTelemetry({ type: 'viewport', device: deviceClass(), width: innerWidth, height: innerHeight });
197 233 fetchSnapshot().then(connectSocket).catch(error => {
198 - status.textContent = 'error';
234 + setProgress('error');
199 235 renderEvents([{ id: Number.MAX_SAFE_INTEGER - 1, at: Date.now(), type: 'error', message: error.message }]);

extensions/ui/web/components/digest-indicator.js.ts

Modified
1 1 export function digestIndicatorText(count: number): string {
2 - return count > 0 ? `digest will be sent · ${count} events` : "digest empty";
2 + return `digest ${count}`;
5 5 export function renderDigestIndicatorJs(): string {
8 8 telemetryEventCount = count;
9 9 const indicator = document.querySelector('#ui-digest');
10 10 if (!indicator) return;
11 - indicator.textContent = count > 0 ? 'digest will be sent · ' + count + ' events' : 'digest empty';
12 - indicator.open = count > 0;
11 + indicator.textContent = 'digest ' + count;
12 + indicator.dataset.pending = count > 0 ? 'true' : 'false';

extensions/ui/web/theme.css.ts

Modified
27 27 * { box-sizing: border-box; }
28 28 body { margin: 0; min-height: 100vh; height: 100vh; overflow: hidden; background: var(--nugu-bg); color: var(--nugu-fg); }
29 29 #ui-shell { min-height: 100vh; height: 100vh; display: grid; grid-template-rows: auto minmax(0, 1fr) auto; }
30 -#ui-status { border-bottom: 3px solid var(--nugu-line); padding: 4px 8px; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; }
30 +#ui-top { display: flex; align-items: center; justify-content: space-between; gap: 12px; border-bottom: 3px solid var(--nugu-line); padding: 4px 8px; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; }
31 +#ui-progress { color: var(--nugu-accent); }