repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

Attach ui telemetry digest once

778a7e374a34d16f5153cfa4beb31e7725021bc1

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

unsigned

Browse filesCompare with HEAD

Changed files (9)

extensions/ui/__tests__/command-adapter.test.ts

Modified
16 16 expect(rpc.sent).toEqual([{ type: "prompt", message: "hello" }]);
19 + it("attaches digest once to the next prompt", async () => {
20 + const rpc = fakeRpc();
21 + let digest = "Browser digest:\n- click SEND";
22 + await sendPrompt(rpc, "hello", {
23 + digest: () => digest,
24 + clearDigest: () => {
25 + digest = "";
26 + },
27 + });
28 + await sendPrompt(rpc, "again", {
29 + digest: () => digest,
30 + clearDigest: () => {
31 + digest = "";
32 + },
33 + });
34 + expect(rpc.sent).toEqual([
35 + {
36 + type: "prompt",
37 + message: "Browser digest:\n- click SEND\n\nUser prompt:\nhello",
38 + },
39 + { type: "prompt", message: "again" },
40 + ]);
41 + });
19 43 it("runs slash commands through prompt expansion", async () => {
20 44 const rpc = fakeRpc();
21 45 await runSlashCommand(rpc, "mode", "terse");

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

Added
new file mode 100644
1 +import { describe, expect, it } from "vitest";
2 +import { digestIndicatorText } from "../web/components/digest-indicator.js";
4 +describe("ui digest indicator", () => {
5 + it("describes pending digest state", () => {
6 + expect(digestIndicatorText(0)).toBe("digest empty");
7 + expect(digestIndicatorText(3)).toBe("digest will be sent · 3 events");
8 + });
9 +});

extensions/ui/__tests__/runtime.test.ts

Modified
166 166 expect(sent).toContainEqual({ type: "abort" });
169 + it("attaches telemetry digest once to browser prompt", async () => {
170 + const sent: unknown[] = [];
171 + const runtime = await createUiRuntime({
172 + sessionLabel: "ui: test",
173 + address: "127.0.0.1",
174 + cwd: "C:/repo",
175 + openBrowser: false,
176 + sessionManager: fakeSessionManager(),
177 + startRpcBridge: ({ sessionPath }) => fakeRpc(sent, sessionPath),
178 + });
179 + runtimes.push(runtime);
180 + const url = new URL(runtime.status().url ?? "");
181 + const socketUrl = new URL("/ws", url);
182 + socketUrl.protocol = "ws:";
183 + socketUrl.searchParams.set("token", url.searchParams.get("token") ?? "");
184 + const socket = new WebSocket(socketUrl);
185 + await new Promise((resolve) =>
186 + socket.addEventListener("open", resolve, { once: true }),
187 + );
189 + socket.send(
190 + JSON.stringify({
191 + type: "telemetry_batch",
192 + events: [{ type: "click", target: "SEND" }],
193 + }),
194 + );
195 + socket.send(JSON.stringify({ type: "prompt", text: "hello" }));
196 + socket.send(JSON.stringify({ type: "prompt", text: "again" }));
197 + await new Promise((resolve) => setTimeout(resolve, 20));
198 + socket.close();
200 + expect(sent).toContainEqual({
201 + type: "prompt",
202 + message: "Browser digest:\n- click SEND\n\nUser prompt:\nhello",
203 + });
204 + expect(sent).toContainEqual({ type: "prompt", message: "again" });
205 + });
169 207 it("routes extension UI responses to rpc", async () => {
170 208 const sent: unknown[] = [];
171 209 const runtime = await createUiRuntime({

extensions/ui/command-adapter.ts

Modified
2 2 import type { RpcClient, RpcResponse } from "./rpc";
4 4 export type RpcSender = Pick<RpcClient, "send">;
6 -export function sendPrompt(rpc: RpcSender, text: string): Promise<RpcResponse> {
7 - return rpc.send({ type: "prompt", message: text });
6 +export type PromptOptions = {
7 + digest?: () => string;
8 + clearDigest?: () => void;
9 +};
11 +export function sendPrompt(
12 + rpc: RpcSender,
13 + text: string,
14 + options: PromptOptions = {},
15 +): Promise<RpcResponse> {
16 + const digest = options.digest?.() ?? "";
17 + if (!digest) return rpc.send({ type: "prompt", message: text });
18 + options.clearDigest?.();
19 + return rpc.send({
20 + type: "prompt",
21 + message: `${digest}\n\nUser prompt:\n${text}`,
22 + });
10 25 export function runSlashCommand(

extensions/ui/runtime.ts

Modified
19 19 import { type RpcClient, type StartRpcOptions, startRpc } from "./rpc";
20 20 import { startUiServer, type UiServer, type UiServerState } from "./server";
21 21 import { seedUiSession, type UiSeedSessionManager } from "./session-seed";
22 +import { TelemetryAggregator, type TelemetryEvent } from "./telemetry";
22 23 import { renderUiWidget } from "./terminal-widget";
24 25 export type UiRuntimeStatus = {
61 62 let sessionPath: string | undefined;
62 63 let rpcState: string | undefined;
63 64 const events = options.events ?? new EventStore();
65 + const telemetry = new TelemetryAggregator();
65 67 const publish = (input: Parameters<EventStore["append"]>[0]) => {
66 68 const event = events.append(input);
100 102 events,
101 103 snapshotStatus: rpcState ? mapRpcState(rpcState) : "waiting",
102 104 onBrowserMessage: async (message) => {
103 - await handleBrowserMessage(message, rpc, publish);
105 + await handleBrowserMessage(message, rpc, publish, telemetry);
105 107 onClientState: () => {
106 108 state = currentStatus();
167 169 message: unknown,
168 170 rpc: RpcClient | undefined,
169 171 publish: (input: Parameters<EventStore["append"]>[0]) => unknown,
172 + telemetry: TelemetryAggregator,
170 173 ): Promise<void> {
171 174 if (!rpc || !isBrowserMessage(message)) return;
172 175 if (message.type === "abort") {
191 194 publish({ type: "log", level: "info", message: "toggle expand requested" });
192 195 return;
197 + if (message.type === "telemetry_batch") {
198 + for (const event of message.events) telemetry.add(event);
199 + publish({
200 + type: "log",
201 + level: "info",
202 + message: "browser digest will be sent",
203 + });
204 + return;
194 206 if (message.type === "ui_response") {
195 207 await rpc.send(
196 208 extensionUiResponseCommand(message.id, responseInput(message)),
245 257 return;
247 259 publish({ type: "message", role: "user", text: parsed.text });
248 - await sendPrompt(rpc, parsed.text);
260 + await sendPrompt(rpc, parsed.text, {
261 + digest: () => telemetry.digest(),
262 + clearDigest: () => telemetry.clear(),
263 + });
251 266 type BrowserMessage =
254 269 | { type: "cycle_model" }
255 270 | { type: "cycle-model" }
256 271 | { type: "toggle-expand" }
272 + | { type: "telemetry_batch"; events: TelemetryEvent[] }
257 273 | ({ type: "ui_response"; id: string } & (
258 274 | { value: string }
259 275 | { confirmed: boolean }
274 290 const type = (value as { type?: unknown }).type;
275 291 if (type === "prompt")
276 292 return typeof (value as { text?: unknown }).text === "string";
293 + if (type === "telemetry_batch")
294 + return Array.isArray((value as { events?: unknown }).events);
277 295 if (type === "ui_response")
278 296 return typeof (value as { id?: unknown }).id === "string";
279 297 if (type === "widget_action")

extensions/ui/web/app.css.ts

Modified
17 17 .ui-visual-fallback { color: color-mix(in srgb, CanvasText 70%, Canvas); margin-bottom: 8px; }
18 18 .ui-visual-block-row iframe { display: block; width: 100%; height: min(60vh, 600px); max-height: 600px; border: 2px solid CanvasText; background: Canvas; }
19 19 .ui-visual-error-hint { margin-top: 8px; font-weight: 800; }
20 +#ui-digest { border-top: 3px solid CanvasText; padding: 6px 8px; font-size: 12px; }
20 21 #ui-composer { display: grid; grid-template-columns: 1fr auto; gap: 8px; border-top: 3px solid CanvasText; padding: 8px; }
21 22 #ui-input-wrap { position: relative; min-width: 0; }
22 23 #ui-input { width: 100%; min-height: 42px; resize: vertical; font: inherit; background: Canvas; color: CanvasText; border: 2px solid CanvasText; padding: 8px; }

extensions/ui/web/app.html.ts

Modified
12 12 <div id="ui-shell">
13 13 <header id="ui-status">starting</header>
14 14 <main id="ui-stream" aria-live="polite"><h1>Pi UI shell</h1></main>
15 +<details id="ui-digest">digest empty</details>
15 16 <form id="ui-composer">
16 17 <div id="ui-input-wrap">
17 18 <textarea id="ui-input" name="prompt" placeholder="Message Pi"></textarea>

extensions/ui/web/app.js.ts

Modified
1 1 import { renderComposerComponentJs } from "./components/composer.js";
2 2 import { renderDialogsComponentJs } from "./components/dialogs.js";
3 +import { renderDigestIndicatorJs } from "./components/digest-indicator.js";
3 4 import { renderVisualBlockComponentJs } from "./components/visual-block.js";
4 5 import { renderTelemetryWorkerJs } from "./worker.js";
20 21 ${renderComposerComponentJs()}
21 22 ${renderDialogsComponentJs()}
22 23 ${renderVisualBlockComponentJs()}
24 +${renderDigestIndicatorJs()}
23 25 const telemetryWorkerSource = ${JSON.stringify(renderTelemetryWorkerJs())};
24 26 function startTelemetryWorker() {
25 27 if (!('Worker' in window)) return;
26 28 const url = URL.createObjectURL(new Blob([telemetryWorkerSource], { type: 'text/javascript' }));
27 29 telemetryWorker = new Worker(url);
28 30 telemetryWorker.addEventListener('message', event => {
29 - if (event.data?.type === 'telemetry_batch') socket?.send(JSON.stringify(event.data));
31 + if (event.data?.type === 'telemetry_batch') {
32 + setDigestIndicator(telemetryEventCount + (event.data.events || []).length);
33 + socket?.send(JSON.stringify(event.data));
34 + }
32 37 function trackTelemetry(event) {
136 141 socket.send(JSON.stringify({ type: 'prompt', text }));
137 142 renderEvents([{ id: Number.MAX_SAFE_INTEGER, at: Date.now(), type: 'message', role: 'user', text }]);
138 143 input.value = '';
144 + setDigestIndicator(0);
139 145 send.disabled = false;

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

Added
new file mode 100644
1 +export function digestIndicatorText(count: number): string {
2 + return count > 0 ? `digest will be sent · ${count} events` : "digest empty";
3 +}
5 +export function renderDigestIndicatorJs(): string {
6 + return `let telemetryEventCount = 0;
7 +function setDigestIndicator(count) {
8 + telemetryEventCount = count;
9 + const indicator = document.querySelector('#ui-digest');
10 + if (!indicator) return;
11 + indicator.textContent = count > 0 ? 'digest will be sent · ' + count + ' events' : 'digest empty';
12 + indicator.open = count > 0;
14 +`;