@narumitw/pi-herdr 0.2.0 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.ts ADDED
@@ -0,0 +1,1587 @@
1
+ // @generated by scripts/build-runtime.mjs; do not edit.
2
+ // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
3
+
4
+ // src/herdr-agent-state.ts
5
+ import path from "node:path";
6
+
7
+ // src/herdr-client.ts
8
+ import net from "node:net";
9
+ var MAX_HERDR_FRAME_BYTES = 1024 * 1024;
10
+ var MAX_PENDING_SUBSCRIPTION_EVENTS = 1024;
11
+ var NdjsonFrames = class {
12
+ buffer = Buffer.alloc(0);
13
+ push(chunk) {
14
+ this.buffer = Buffer.concat([this.buffer, chunk]);
15
+ if (this.buffer.length > MAX_HERDR_FRAME_BYTES && this.buffer.indexOf(10) < 0) {
16
+ throw new Error("Herdr response frame exceeded the size limit");
17
+ }
18
+ const frames = [];
19
+ while (true) {
20
+ const newline = this.buffer.indexOf(10);
21
+ if (newline < 0) break;
22
+ if (newline > MAX_HERDR_FRAME_BYTES) {
23
+ throw new Error("Herdr response frame exceeded the size limit");
24
+ }
25
+ const line = this.buffer.subarray(0, newline);
26
+ this.buffer = this.buffer.subarray(newline + 1);
27
+ if (line.length === 0) continue;
28
+ try {
29
+ frames.push(JSON.parse(line.toString("utf8")));
30
+ } catch {
31
+ throw new Error("Herdr returned invalid JSON");
32
+ }
33
+ }
34
+ return frames;
35
+ }
36
+ };
37
+ function isRecord(value) {
38
+ return typeof value === "object" && value !== null && !Array.isArray(value);
39
+ }
40
+ function abortReason(signal) {
41
+ return signal.reason instanceof Error ? signal.reason : new DOMException("Herdr request aborted", "AbortError");
42
+ }
43
+ function responseError(frame) {
44
+ if (!isRecord(frame.error)) return void 0;
45
+ const message = typeof frame.error.message === "string" ? frame.error.message : "request failed";
46
+ return new Error(`Herdr ${message}`);
47
+ }
48
+ function sendRequestAttempt(socketEndpoint, request, timeoutMs, signal) {
49
+ if (signal.aborted) return Promise.resolve(false);
50
+ return new Promise((resolve) => {
51
+ let finished = false;
52
+ let timeout;
53
+ const socket = net.createConnection(socketEndpoint);
54
+ const finish = (delivered) => {
55
+ if (finished) return;
56
+ finished = true;
57
+ if (timeout) clearTimeout(timeout);
58
+ signal.removeEventListener("abort", abort);
59
+ socket.destroy();
60
+ resolve(delivered);
61
+ };
62
+ const abort = () => finish(false);
63
+ signal.addEventListener("abort", abort, { once: true });
64
+ socket.on("error", () => finish(false));
65
+ socket.on("connect", () => socket.write(`${JSON.stringify(request)}
66
+ `));
67
+ socket.on("data", () => finish(true));
68
+ socket.on("end", () => finish(false));
69
+ socket.on("close", () => finish(false));
70
+ timeout = setTimeout(() => finish(false), timeoutMs);
71
+ timeout.unref?.();
72
+ });
73
+ }
74
+ function createBestEffortSender(socketEndpoint) {
75
+ return async (request, signal) => {
76
+ if (await sendRequestAttempt(socketEndpoint, request, 500, signal)) return;
77
+ if (signal.aborted) return;
78
+ await sendRequestAttempt(socketEndpoint, request, 1500, signal);
79
+ };
80
+ }
81
+ function requestHerdr(socketEndpoint, request, signal, timeoutMs = 1500) {
82
+ if (signal.aborted) return Promise.reject(abortReason(signal));
83
+ return new Promise((resolve, reject) => {
84
+ const socket = net.createConnection(socketEndpoint);
85
+ const parser = new NdjsonFrames();
86
+ let finished = false;
87
+ const timeout = setTimeout(() => finish(new Error("Herdr request timed out")), timeoutMs);
88
+ timeout.unref?.();
89
+ const cleanup = () => {
90
+ clearTimeout(timeout);
91
+ signal.removeEventListener("abort", abort);
92
+ socket.destroy();
93
+ };
94
+ const finish = (error, result) => {
95
+ if (finished) return;
96
+ finished = true;
97
+ cleanup();
98
+ if (error) reject(error);
99
+ else resolve(result);
100
+ };
101
+ const abort = () => finish(abortReason(signal));
102
+ signal.addEventListener("abort", abort, { once: true });
103
+ socket.on("connect", () => socket.write(`${JSON.stringify(request)}
104
+ `));
105
+ socket.on("error", (error) => finish(error));
106
+ socket.on("end", () => finish(new Error("Herdr closed the request before responding")));
107
+ socket.on("close", () => finish(new Error("Herdr request socket closed")));
108
+ socket.on("data", (chunk) => {
109
+ try {
110
+ for (const value of parser.push(chunk)) {
111
+ if (!isRecord(value)) continue;
112
+ const uncorrelatedError = responseError(value);
113
+ if (uncorrelatedError && (value.id === "" || value.id === void 0)) {
114
+ finish(uncorrelatedError);
115
+ return;
116
+ }
117
+ if (value.id !== request.id) continue;
118
+ const error = responseError(value);
119
+ if (error) {
120
+ finish(error);
121
+ return;
122
+ }
123
+ if (!("result" in value)) {
124
+ finish(new Error("Herdr response did not include a result"));
125
+ return;
126
+ }
127
+ finish(void 0, value.result);
128
+ return;
129
+ }
130
+ } catch (error) {
131
+ finish(error instanceof Error ? error : new Error(String(error)));
132
+ }
133
+ });
134
+ });
135
+ }
136
+ async function openHerdrSubscription(socketEndpoint, request, signal, onEvent, timeoutMs = 1500) {
137
+ if (signal.aborted) throw abortReason(signal);
138
+ const socket = net.createConnection(socketEndpoint);
139
+ const parser = new NdjsonFrames();
140
+ const pendingEvents = [];
141
+ let ready = false;
142
+ let finished = false;
143
+ let intentionalClose = false;
144
+ let resolveReady;
145
+ let rejectReady;
146
+ let resolveClosed;
147
+ let rejectClosed;
148
+ const readyPromise = new Promise((resolve, reject) => {
149
+ resolveReady = resolve;
150
+ rejectReady = reject;
151
+ });
152
+ const closed = new Promise((resolve, reject) => {
153
+ resolveClosed = resolve;
154
+ rejectClosed = reject;
155
+ });
156
+ void closed.catch(() => void 0);
157
+ const timeout = setTimeout(() => finish(new Error("Herdr subscription timed out")), timeoutMs);
158
+ timeout.unref?.();
159
+ const cleanup = () => {
160
+ clearTimeout(timeout);
161
+ signal.removeEventListener("abort", abort);
162
+ socket.destroy();
163
+ };
164
+ const finish = (error) => {
165
+ if (finished) return;
166
+ finished = true;
167
+ cleanup();
168
+ if (!ready) {
169
+ if (error && !intentionalClose) rejectReady(error);
170
+ else rejectReady(abortReason(signal));
171
+ resolveClosed();
172
+ return;
173
+ }
174
+ if (error && !intentionalClose) rejectClosed(error);
175
+ else resolveClosed();
176
+ };
177
+ const deliver = (frame) => {
178
+ try {
179
+ onEvent(frame);
180
+ } catch (error) {
181
+ finish(error instanceof Error ? error : new Error(String(error)));
182
+ }
183
+ };
184
+ const abort = () => {
185
+ intentionalClose = true;
186
+ finish();
187
+ };
188
+ signal.addEventListener("abort", abort, { once: true });
189
+ socket.on("connect", () => socket.write(`${JSON.stringify(request)}
190
+ `));
191
+ socket.on("error", (error) => finish(error));
192
+ socket.on("end", () => finish(new Error("Herdr subscription closed")));
193
+ socket.on("close", () => finish(new Error("Herdr subscription socket closed")));
194
+ socket.on("data", (chunk) => {
195
+ try {
196
+ for (const value of parser.push(chunk)) {
197
+ if (!ready) {
198
+ if (isRecord(value)) {
199
+ const uncorrelatedError = responseError(value);
200
+ if (uncorrelatedError && (value.id === "" || value.id === void 0)) {
201
+ finish(uncorrelatedError);
202
+ return;
203
+ }
204
+ }
205
+ if (isRecord(value) && value.id === request.id) {
206
+ const error = responseError(value);
207
+ if (error) {
208
+ finish(error);
209
+ return;
210
+ }
211
+ if (!isRecord(value.result) || value.result.type !== "subscription_started") {
212
+ finish(new Error("Herdr returned an invalid subscription acknowledgement"));
213
+ return;
214
+ }
215
+ ready = true;
216
+ clearTimeout(timeout);
217
+ resolveReady();
218
+ for (const event of pendingEvents.splice(0)) deliver(event);
219
+ continue;
220
+ }
221
+ if (pendingEvents.length >= MAX_PENDING_SUBSCRIPTION_EVENTS) {
222
+ finish(new Error("Too many Herdr events arrived before subscription acknowledgement"));
223
+ return;
224
+ }
225
+ pendingEvents.push(value);
226
+ continue;
227
+ }
228
+ deliver(value);
229
+ }
230
+ } catch (error) {
231
+ finish(error instanceof Error ? error : new Error(String(error)));
232
+ }
233
+ });
234
+ await readyPromise;
235
+ if (signal.aborted) {
236
+ intentionalClose = true;
237
+ finish();
238
+ throw abortReason(signal);
239
+ }
240
+ return {
241
+ closed,
242
+ close() {
243
+ intentionalClose = true;
244
+ finish();
245
+ }
246
+ };
247
+ }
248
+
249
+ // src/herdr-metadata.ts
250
+ import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
251
+ var HERDR_METADATA_TOKEN_KEYS = ["model", "provider", "thinking", "session", "context_usage"];
252
+ var HERDR_METADATA_MAX_CHARACTERS = 80;
253
+ var HERDR_METADATA_TTL_MS = 60 * 60 * 1e3;
254
+ var HERDR_METADATA_REFRESH_MS = 30 * 60 * 1e3;
255
+ function normalizeHerdrMetadataValue(value) {
256
+ if (typeof value !== "string") return null;
257
+ const normalized = sanitizeTerminalText(value).trim();
258
+ if (normalized.length === 0) return null;
259
+ return [...normalized].slice(0, HERDR_METADATA_MAX_CHARACTERS).join("");
260
+ }
261
+ function formatContextUsagePercent(value) {
262
+ if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
263
+ return `${Math.round(value)}%`;
264
+ }
265
+ function createHerdrMetadataSnapshot(inputs) {
266
+ return Object.freeze({
267
+ model: normalizeHerdrMetadataValue(inputs.model),
268
+ provider: normalizeHerdrMetadataValue(inputs.provider),
269
+ thinking: normalizeHerdrMetadataValue(inputs.thinking),
270
+ session: normalizeHerdrMetadataValue(inputs.session),
271
+ context_usage: formatContextUsagePercent(inputs.contextUsagePercent)
272
+ });
273
+ }
274
+ function createHerdrMetadataClearSnapshot() {
275
+ return Object.freeze({
276
+ model: null,
277
+ provider: null,
278
+ thinking: null,
279
+ session: null,
280
+ context_usage: null
281
+ });
282
+ }
283
+ function herdrMetadataSnapshotsEqual(left, right) {
284
+ return left !== void 0 && HERDR_METADATA_TOKEN_KEYS.every((key) => left[key] === right[key]);
285
+ }
286
+ function createHerdrMetadataRequest(options) {
287
+ return {
288
+ id: options.id,
289
+ method: "pane.report_metadata",
290
+ params: {
291
+ pane_id: options.paneId,
292
+ source: options.source,
293
+ seq: options.seq,
294
+ tokens: { ...options.snapshot },
295
+ ttl_ms: options.ttlMs ?? HERDR_METADATA_TTL_MS
296
+ }
297
+ };
298
+ }
299
+
300
+ // src/herdr-protocol.ts
301
+ var HERDR_AGENT_STATUSES = ["idle", "working", "blocked", "done", "unknown"];
302
+ var HERDR_WIDGET_TOPOLOGY_SUBSCRIPTIONS = [
303
+ { type: "pane.created" },
304
+ { type: "pane.closed" },
305
+ { type: "pane.moved" },
306
+ { type: "pane.exited" },
307
+ { type: "pane.agent_detected" }
308
+ ];
309
+ function herdrWidgetSubscriptions(panes) {
310
+ return [
311
+ ...HERDR_WIDGET_TOPOLOGY_SUBSCRIPTIONS.map((entry) => ({ ...entry })),
312
+ ...panes.filter((pane) => pane.agent !== void 0).map((pane) => ({ type: "pane.agent_status_changed", pane_id: pane.paneId }))
313
+ ];
314
+ }
315
+ function isRecord2(value) {
316
+ return typeof value === "object" && value !== null && !Array.isArray(value);
317
+ }
318
+ function requiredString(value) {
319
+ return typeof value === "string" && value.length > 0 ? value : void 0;
320
+ }
321
+ function optionalString(value) {
322
+ return typeof value === "string" ? value : void 0;
323
+ }
324
+ function agentStatus(value) {
325
+ return typeof value === "string" && HERDR_AGENT_STATUSES.includes(value) ? value : void 0;
326
+ }
327
+ function stringRecord(value) {
328
+ if (!isRecord2(value)) return void 0;
329
+ const entries = Object.entries(value);
330
+ if (!entries.every(([, entry]) => typeof entry === "string")) return void 0;
331
+ return Object.fromEntries(entries);
332
+ }
333
+ function parseHerdrPane(value) {
334
+ if (!isRecord2(value)) return void 0;
335
+ const paneId = requiredString(value.pane_id);
336
+ const workspaceId = requiredString(value.workspace_id);
337
+ const tabId = requiredString(value.tab_id);
338
+ const terminalId = requiredString(value.terminal_id);
339
+ const status = agentStatus(value.agent_status);
340
+ const revision = value.revision;
341
+ if (!paneId || !workspaceId || !tabId || !terminalId || !status || typeof value.focused !== "boolean" || typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) {
342
+ return void 0;
343
+ }
344
+ return {
345
+ paneId,
346
+ workspaceId,
347
+ tabId,
348
+ terminalId,
349
+ focused: value.focused,
350
+ revision,
351
+ agent: optionalString(value.agent),
352
+ agentName: optionalString(value.name),
353
+ agentStatus: status,
354
+ displayAgent: optionalString(value.display_agent),
355
+ label: optionalString(value.label),
356
+ stateLabels: stringRecord(value.state_labels) ?? {},
357
+ terminalTitle: optionalString(value.terminal_title_stripped) ?? optionalString(value.terminal_title),
358
+ title: optionalString(value.title)
359
+ };
360
+ }
361
+ function parsePaneCurrentResult(value) {
362
+ if (!isRecord2(value) || value.type !== "pane_current") {
363
+ throw new Error("Herdr returned an invalid current-pane response");
364
+ }
365
+ const pane = parseHerdrPane(value.pane);
366
+ if (!pane) throw new Error("Herdr returned an invalid current pane");
367
+ return pane;
368
+ }
369
+ function parsePaneListResult(value) {
370
+ if (!isRecord2(value) || value.type !== "pane_list" || !Array.isArray(value.panes)) {
371
+ throw new Error("Herdr returned an invalid pane-list response");
372
+ }
373
+ const panes = value.panes.map(parseHerdrPane);
374
+ if (panes.some((pane) => pane === void 0)) {
375
+ throw new Error("Herdr returned an invalid pane in the pane list");
376
+ }
377
+ return panes;
378
+ }
379
+ function parseAgentListResult(value) {
380
+ if (!isRecord2(value) || value.type !== "agent_list" || !Array.isArray(value.agents)) {
381
+ throw new Error("Herdr returned an invalid agent-list response");
382
+ }
383
+ return value.agents.flatMap((entry) => {
384
+ const pane = parseHerdrPane(entry);
385
+ return pane ? [pane] : [];
386
+ });
387
+ }
388
+ function parseWorkspaceGetResult(value) {
389
+ if (!isRecord2(value) || value.type !== "workspace_info" || !isRecord2(value.workspace)) {
390
+ throw new Error("Herdr returned an invalid workspace response");
391
+ }
392
+ const workspaceId = requiredString(value.workspace.workspace_id);
393
+ if (!workspaceId) throw new Error("Herdr returned an invalid workspace identity");
394
+ return { workspaceId, label: optionalString(value.workspace.label) };
395
+ }
396
+ function parseHerdrPaneEvent(value) {
397
+ if (!isRecord2(value) || typeof value.event !== "string" || !isRecord2(value.data)) {
398
+ return void 0;
399
+ }
400
+ const data = value.data;
401
+ if (value.event === "pane.agent_status_changed") {
402
+ const paneId = requiredString(data.pane_id);
403
+ const workspaceId = requiredString(data.workspace_id);
404
+ const status = agentStatus(data.agent_status);
405
+ if (!paneId || !workspaceId || !status) return void 0;
406
+ return {
407
+ type: "agent_status_changed",
408
+ paneId,
409
+ workspaceId,
410
+ agent: optionalString(data.agent),
411
+ agentStatus: status,
412
+ displayAgent: optionalString(data.display_agent),
413
+ stateLabels: stringRecord(data.state_labels),
414
+ title: optionalString(data.title)
415
+ };
416
+ }
417
+ if (value.event === "pane_created") {
418
+ const pane = parseHerdrPane(data.pane);
419
+ return pane ? { type: "created", pane } : void 0;
420
+ }
421
+ if (value.event === "pane_closed" || value.event === "pane_exited") {
422
+ const paneId = requiredString(data.pane_id);
423
+ const workspaceId = requiredString(data.workspace_id);
424
+ if (!paneId || !workspaceId) return void 0;
425
+ return {
426
+ type: value.event === "pane_closed" ? "closed" : "exited",
427
+ paneId,
428
+ workspaceId
429
+ };
430
+ }
431
+ if (value.event === "pane_moved") {
432
+ const pane = parseHerdrPane(data.pane);
433
+ const previousPaneId = requiredString(data.previous_pane_id);
434
+ const previousWorkspaceId = requiredString(data.previous_workspace_id);
435
+ if (!pane || !previousPaneId || !previousWorkspaceId) return void 0;
436
+ return { type: "moved", pane, previousPaneId, previousWorkspaceId };
437
+ }
438
+ if (value.event === "pane_agent_detected") {
439
+ const paneId = requiredString(data.pane_id);
440
+ const workspaceId = requiredString(data.workspace_id);
441
+ if (!paneId || !workspaceId || typeof data.released !== "boolean") return void 0;
442
+ const finalStatus = data.final_status === null ? void 0 : agentStatus(data.final_status);
443
+ if (data.final_status !== void 0 && data.final_status !== null && !finalStatus) return void 0;
444
+ return {
445
+ type: "agent_detected",
446
+ paneId,
447
+ workspaceId,
448
+ agent: optionalString(data.agent),
449
+ finalStatus,
450
+ released: data.released
451
+ };
452
+ }
453
+ return void 0;
454
+ }
455
+
456
+ // src/herdr-widget.ts
457
+ import { EditorStatusWidget } from "@narumitw/pi-tui-kit/editor-status-widget";
458
+ import { sanitizeTerminalText as sanitizeTerminalText2 } from "@narumitw/pi-tui-kit/terminal-text";
459
+ var HERDR_WIDGET_KEY = "herdr:agents";
460
+ var MAX_HERDR_WIDGET_AGENTS = 5;
461
+ var STATE_ORDER = {
462
+ blocked: 0,
463
+ done: 1,
464
+ working: 2,
465
+ idle: 3,
466
+ unknown: 4
467
+ };
468
+ function observedPane(pane) {
469
+ return {
470
+ paneId: pane.paneId,
471
+ workspaceId: pane.workspaceId,
472
+ agent: pane.agent,
473
+ agentName: pane.agentName,
474
+ agentStatus: pane.agentStatus,
475
+ displayAgent: pane.displayAgent,
476
+ label: pane.label,
477
+ stateLabels: { ...pane.stateLabels },
478
+ title: pane.title
479
+ };
480
+ }
481
+ function safeDisplay(value) {
482
+ if (value === void 0) return void 0;
483
+ const safe = sanitizeTerminalText2(value).trim();
484
+ return safe.length > 0 ? safe : void 0;
485
+ }
486
+ function shortIdentity(value, fallback) {
487
+ const safe = safeDisplay(value);
488
+ if (!safe) return fallback;
489
+ return safe.split(":").at(-1) || fallback;
490
+ }
491
+ function agentDisplay(pane) {
492
+ return safeDisplay(pane.agentName) ?? safeDisplay(pane.displayAgent) ?? safeDisplay(pane.agent) ?? "agent";
493
+ }
494
+ function paneDisplay(pane) {
495
+ const id = shortIdentity(pane.paneId, "pane");
496
+ const label = safeDisplay(pane.label) ?? safeDisplay(pane.title);
497
+ return label ? `${label}/${id}` : id;
498
+ }
499
+ function spaceDisplay(workspace) {
500
+ const id = shortIdentity(workspace.workspaceId, "space");
501
+ const label = safeDisplay(workspace.label);
502
+ return label ? `${label}/${id}` : id;
503
+ }
504
+ function rowForPane(pane, workspace) {
505
+ return {
506
+ agent: agentDisplay(pane),
507
+ pane: paneDisplay(pane),
508
+ paneId: safeDisplay(pane.paneId) ?? "pane",
509
+ space: spaceDisplay(workspace),
510
+ state: pane.agentStatus,
511
+ stateLabel: safeDisplay(pane.stateLabels[pane.agentStatus]) ?? safeDisplay(pane.agentStatus) ?? "unknown"
512
+ };
513
+ }
514
+ function immutableSnapshot(rows) {
515
+ if (rows.length === 0) return void 0;
516
+ const visible = rows.slice(0, MAX_HERDR_WIDGET_AGENTS).map((row) => Object.freeze({ ...row }));
517
+ return Object.freeze({
518
+ totalAgents: rows.length,
519
+ hiddenAgents: Math.max(0, rows.length - visible.length),
520
+ rows: Object.freeze(visible)
521
+ });
522
+ }
523
+ var HerdrWidgetModel = class {
524
+ currentPaneId;
525
+ currentWorkspaceId;
526
+ workspace;
527
+ panes = /* @__PURE__ */ new Map();
528
+ reset(currentPane, panes, workspace = { workspaceId: currentPane.workspaceId }) {
529
+ this.currentPaneId = currentPane.paneId;
530
+ this.currentWorkspaceId = currentPane.workspaceId;
531
+ this.workspace = { ...workspace };
532
+ this.panes = new Map(panes.map((pane) => [pane.paneId, observedPane(pane)]));
533
+ }
534
+ clear() {
535
+ this.currentPaneId = void 0;
536
+ this.currentWorkspaceId = void 0;
537
+ this.workspace = void 0;
538
+ this.panes.clear();
539
+ }
540
+ isCurrentPane(paneId) {
541
+ return this.currentPaneId === paneId;
542
+ }
543
+ isCurrentWorkspace(workspaceId) {
544
+ return this.currentWorkspaceId === workspaceId;
545
+ }
546
+ apply(event) {
547
+ if (event.type === "created") {
548
+ this.panes.set(event.pane.paneId, observedPane(event.pane));
549
+ return;
550
+ }
551
+ if (event.type === "closed" || event.type === "exited") {
552
+ this.panes.delete(event.paneId);
553
+ return;
554
+ }
555
+ if (event.type === "moved") {
556
+ this.panes.delete(event.previousPaneId);
557
+ this.panes.set(event.pane.paneId, observedPane(event.pane));
558
+ if (this.currentPaneId === event.previousPaneId) {
559
+ this.currentPaneId = event.pane.paneId;
560
+ this.currentWorkspaceId = event.pane.workspaceId;
561
+ this.workspace = { workspaceId: event.pane.workspaceId };
562
+ }
563
+ return;
564
+ }
565
+ const existing = this.panes.get(event.paneId);
566
+ if (event.type === "agent_detected") {
567
+ if (event.released || !event.agent) {
568
+ if (existing) this.panes.set(event.paneId, { ...existing, agent: void 0 });
569
+ return;
570
+ }
571
+ this.panes.set(event.paneId, {
572
+ ...existing ?? {
573
+ paneId: event.paneId,
574
+ workspaceId: event.workspaceId,
575
+ agentStatus: event.finalStatus ?? "unknown",
576
+ stateLabels: {}
577
+ },
578
+ agent: event.agent,
579
+ agentStatus: event.finalStatus ?? existing?.agentStatus ?? "unknown"
580
+ });
581
+ return;
582
+ }
583
+ if (event.type !== "agent_status_changed") return;
584
+ this.panes.set(event.paneId, {
585
+ ...existing ?? {
586
+ paneId: event.paneId,
587
+ workspaceId: event.workspaceId,
588
+ stateLabels: {}
589
+ },
590
+ agent: event.agent ?? existing?.agent,
591
+ agentStatus: event.agentStatus,
592
+ displayAgent: event.displayAgent ?? existing?.displayAgent,
593
+ stateLabels: event.stateLabels ?? existing?.stateLabels ?? {},
594
+ title: event.title ?? existing?.title
595
+ });
596
+ }
597
+ snapshot() {
598
+ if (!this.currentPaneId || !this.currentWorkspaceId || !this.workspace) return void 0;
599
+ const rows = [...this.panes.values()].filter(
600
+ (pane) => pane.workspaceId === this.currentWorkspaceId && pane.paneId !== this.currentPaneId && pane.agent !== void 0
601
+ ).map((pane) => rowForPane(pane, this.workspace));
602
+ rows.sort(
603
+ (left, right) => STATE_ORDER[left.state] - STATE_ORDER[right.state] || left.agent.localeCompare(right.agent) || left.pane.localeCompare(right.pane) || left.paneId.localeCompare(right.paneId)
604
+ );
605
+ return immutableSnapshot(rows);
606
+ }
607
+ };
608
+ function stateStyle(theme, state, text) {
609
+ switch (state) {
610
+ case "blocked":
611
+ return theme.fg("error", text);
612
+ case "done":
613
+ return theme.fg("accent", text);
614
+ case "working":
615
+ return theme.fg("warning", text);
616
+ case "idle":
617
+ return theme.fg("success", text);
618
+ case "unknown":
619
+ return theme.fg("dim", text);
620
+ }
621
+ }
622
+ function stateSymbol(state) {
623
+ switch (state) {
624
+ case "blocked":
625
+ return "\xD7";
626
+ case "done":
627
+ return "\u2713";
628
+ case "working":
629
+ return "\u25D0";
630
+ case "idle":
631
+ return "\u25CB";
632
+ case "unknown":
633
+ return "\xB7";
634
+ }
635
+ }
636
+ function createHerdrWidget(snapshot, theme) {
637
+ return new EditorStatusWidget({
638
+ theme,
639
+ renderBody() {
640
+ const noun = snapshot.totalAgents === 1 ? "agent" : "agents";
641
+ const lines = [theme.fg("muted", `Herdr \xB7 ${snapshot.totalAgents} sibling ${noun}`)];
642
+ const separator = theme.fg("dim", " \xB7 ");
643
+ for (const row of snapshot.rows) {
644
+ const state = stateStyle(theme, row.state, `${stateSymbol(row.state)} ${row.stateLabel}`);
645
+ const agent = theme.bold(theme.fg("text", row.agent));
646
+ const pane = theme.fg("muted", row.pane);
647
+ const space = theme.fg("dim", row.space);
648
+ lines.push(`${state} ${agent}${separator}${pane}${separator}${space}`);
649
+ }
650
+ if (snapshot.hiddenAgents > 0) {
651
+ lines.push(theme.fg("dim", `+${snapshot.hiddenAgents} more`));
652
+ }
653
+ return lines;
654
+ }
655
+ });
656
+ }
657
+ function herdrWidgetFingerprint(snapshot) {
658
+ return snapshot ? JSON.stringify(snapshot) : void 0;
659
+ }
660
+
661
+ // src/herdr-observer.ts
662
+ var MAX_PENDING_EVENTS = 1024;
663
+ var HerdrTopologyChangedError = class extends Error {
664
+ };
665
+ function requiresResubscribe(event) {
666
+ return event.type === "created" || event.type === "moved" || event.type === "agent_detected";
667
+ }
668
+ function isRelevantEvent(model, event) {
669
+ if (event.type === "created") return model.isCurrentWorkspace(event.pane.workspaceId);
670
+ if (event.type === "moved") {
671
+ return model.isCurrentPane(event.previousPaneId) || model.isCurrentWorkspace(event.previousWorkspaceId) || model.isCurrentWorkspace(event.pane.workspaceId);
672
+ }
673
+ return model.isCurrentWorkspace(event.workspaceId);
674
+ }
675
+ function subscriptionFingerprint(currentPane, panes) {
676
+ const agentPaneIds = panes.filter((pane) => pane.agent !== void 0).map((pane) => pane.paneId).sort();
677
+ return JSON.stringify([currentPane.paneId, currentPane.workspaceId, agentPaneIds]);
678
+ }
679
+ function waitForRetry(delayMs, signal) {
680
+ if (signal.aborted) return Promise.reject(signal.reason);
681
+ if (delayMs <= 0) return Promise.resolve();
682
+ return new Promise((resolve, reject) => {
683
+ const timer = setTimeout(() => {
684
+ signal.removeEventListener("abort", abort);
685
+ resolve();
686
+ }, delayMs);
687
+ timer.unref?.();
688
+ const abort = () => {
689
+ clearTimeout(timer);
690
+ reject(signal.reason);
691
+ };
692
+ signal.addEventListener("abort", abort, { once: true });
693
+ });
694
+ }
695
+ function createHerdrWidgetObserver(options) {
696
+ const now = options.now ?? Date.now;
697
+ const random = options.random ?? Math.random;
698
+ const request = options.request ?? requestHerdr;
699
+ const subscribe = options.subscribe ?? openHerdrSubscription;
700
+ const retryDelayMs = options.retryDelayMs ?? 200;
701
+ let generation = 0;
702
+ let activeContext;
703
+ let activeSession;
704
+ let controller;
705
+ const ownedTasks = /* @__PURE__ */ new Set();
706
+ let publishedFingerprint;
707
+ let hasPublished = false;
708
+ const owns = (ctx, expectedGeneration = generation) => ctx.sessionManager === activeSession && expectedGeneration === generation;
709
+ const requestId = (kind) => `herdr:pi:widget:${kind}:${now()}:${random().toString(36).slice(2)}`;
710
+ const clearWidget = (ctx) => {
711
+ if (ctx.mode === "tui") ctx.ui.setWidget(HERDR_WIDGET_KEY, void 0);
712
+ publishedFingerprint = void 0;
713
+ hasPublished = false;
714
+ };
715
+ const publish = (ctx, model, expectedGeneration) => {
716
+ if (!owns(ctx, expectedGeneration) || ctx.mode !== "tui") return;
717
+ const snapshot = model.snapshot();
718
+ const fingerprint = herdrWidgetFingerprint(snapshot);
719
+ if (hasPublished && fingerprint === publishedFingerprint) return;
720
+ if (!snapshot) {
721
+ ctx.ui.setWidget(HERDR_WIDGET_KEY, void 0);
722
+ } else {
723
+ ctx.ui.setWidget(HERDR_WIDGET_KEY, (_tui, theme) => createHerdrWidget(snapshot, theme), {
724
+ placement: "aboveEditor"
725
+ });
726
+ }
727
+ publishedFingerprint = fingerprint;
728
+ hasPublished = true;
729
+ };
730
+ const loadPaneSet = async (ctx, expectedGeneration, signal) => {
731
+ const currentResult = await request(
732
+ options.environment.socketEndpoint,
733
+ {
734
+ id: requestId("current"),
735
+ method: "pane.current",
736
+ params: { caller_pane_id: options.environment.paneId }
737
+ },
738
+ signal
739
+ );
740
+ if (!owns(ctx, expectedGeneration) || signal.aborted) return void 0;
741
+ const currentPane = parsePaneCurrentResult(currentResult);
742
+ const [listResult, agentResult, workspaceResult] = await Promise.all([
743
+ request(
744
+ options.environment.socketEndpoint,
745
+ {
746
+ id: requestId("list"),
747
+ method: "pane.list",
748
+ params: { workspace_id: currentPane.workspaceId }
749
+ },
750
+ signal
751
+ ),
752
+ request(
753
+ options.environment.socketEndpoint,
754
+ { id: requestId("agents"), method: "agent.list", params: {} },
755
+ signal
756
+ ),
757
+ request(
758
+ options.environment.socketEndpoint,
759
+ {
760
+ id: requestId("workspace"),
761
+ method: "workspace.get",
762
+ params: { workspace_id: currentPane.workspaceId }
763
+ },
764
+ signal
765
+ )
766
+ ]);
767
+ if (!owns(ctx, expectedGeneration) || signal.aborted) return void 0;
768
+ const namesByPane = new Map(parseAgentListResult(agentResult).map((pane) => [pane.paneId, pane.agentName]));
769
+ const withAgentName = (pane) => ({
770
+ ...pane,
771
+ agentName: namesByPane.get(pane.paneId) ?? pane.agentName
772
+ });
773
+ const workspace = parseWorkspaceGetResult(workspaceResult);
774
+ if (workspace.workspaceId !== currentPane.workspaceId) {
775
+ throw new Error("Herdr returned a mismatched workspace");
776
+ }
777
+ return {
778
+ currentPane: withAgentName(currentPane),
779
+ panes: parsePaneListResult(listResult).map(withAgentName),
780
+ workspace
781
+ };
782
+ };
783
+ const runAttempt = async (ctx, expectedGeneration, sessionSignal) => {
784
+ const attemptController = new AbortController();
785
+ const abortAttempt = () => attemptController.abort(sessionSignal.reason);
786
+ if (sessionSignal.aborted) abortAttempt();
787
+ else sessionSignal.addEventListener("abort", abortAttempt, { once: true });
788
+ const signal = attemptController.signal;
789
+ let attemptActive = true;
790
+ let subscription;
791
+ let refreshTask;
792
+ try {
793
+ const discovered = await loadPaneSet(ctx, expectedGeneration, signal);
794
+ if (!discovered) return;
795
+ const subscribedFingerprint = subscriptionFingerprint(discovered.currentPane, discovered.panes);
796
+ const model = new HerdrWidgetModel();
797
+ model.reset(discovered.currentPane, discovered.panes, discovered.workspace);
798
+ const pendingEvents = [];
799
+ const pendingStatusEvents = [];
800
+ let initialized = false;
801
+ let topologyPending = false;
802
+ let refreshingTopology = false;
803
+ let refreshAgain = false;
804
+ let rejectReconfigure;
805
+ let reconfigureSettled = false;
806
+ const reconfigure = new Promise((_resolve, reject) => {
807
+ rejectReconfigure = reject;
808
+ });
809
+ void reconfigure.catch(() => void 0);
810
+ const failAttempt = (error) => {
811
+ if (reconfigureSettled) return;
812
+ reconfigureSettled = true;
813
+ rejectReconfigure(error);
814
+ };
815
+ const scheduleTopologyRefresh = () => {
816
+ if (!initialized || !attemptActive || signal.aborted) return;
817
+ if (refreshTask) {
818
+ refreshAgain = true;
819
+ return;
820
+ }
821
+ refreshTask = (async () => {
822
+ do {
823
+ refreshAgain = false;
824
+ refreshingTopology = true;
825
+ const refreshed = await loadPaneSet(ctx, expectedGeneration, signal);
826
+ if (!refreshed || !attemptActive || signal.aborted) return;
827
+ model.reset(refreshed.currentPane, refreshed.panes, refreshed.workspace);
828
+ for (const event of pendingStatusEvents.splice(0)) {
829
+ if (isRelevantEvent(model, event)) model.apply(event);
830
+ }
831
+ refreshingTopology = false;
832
+ publish(ctx, model, expectedGeneration);
833
+ if (subscriptionFingerprint(refreshed.currentPane, refreshed.panes) !== subscribedFingerprint) {
834
+ failAttempt(new HerdrTopologyChangedError());
835
+ return;
836
+ }
837
+ } while (refreshAgain && attemptActive && !signal.aborted);
838
+ })().catch((error) => {
839
+ failAttempt(error instanceof Error ? error : new Error(String(error)));
840
+ }).finally(() => {
841
+ refreshingTopology = false;
842
+ refreshTask = void 0;
843
+ });
844
+ };
845
+ subscription = await subscribe(
846
+ options.environment.socketEndpoint,
847
+ {
848
+ id: requestId("subscribe"),
849
+ method: "events.subscribe",
850
+ params: { subscriptions: herdrWidgetSubscriptions(discovered.panes) }
851
+ },
852
+ signal,
853
+ (frame) => {
854
+ const event = parseHerdrPaneEvent(frame);
855
+ if (!initialized) {
856
+ if (!event || !isRelevantEvent(model, event)) return;
857
+ if (requiresResubscribe(event)) {
858
+ topologyPending = true;
859
+ return;
860
+ }
861
+ if (pendingEvents.length >= MAX_PENDING_EVENTS) {
862
+ throw new Error("Too many Herdr events arrived during initialization");
863
+ }
864
+ pendingEvents.push(event);
865
+ return;
866
+ }
867
+ if (!event || !owns(ctx, expectedGeneration) || signal.aborted || !isRelevantEvent(model, event)) {
868
+ return;
869
+ }
870
+ if (requiresResubscribe(event)) {
871
+ scheduleTopologyRefresh();
872
+ return;
873
+ }
874
+ if (refreshingTopology) {
875
+ if (pendingStatusEvents.length >= MAX_PENDING_EVENTS) {
876
+ throw new Error("Too many Herdr status events arrived during refresh");
877
+ }
878
+ pendingStatusEvents.push(event);
879
+ return;
880
+ }
881
+ model.apply(event);
882
+ publish(ctx, model, expectedGeneration);
883
+ }
884
+ );
885
+ if (!owns(ctx, expectedGeneration) || signal.aborted) return;
886
+ const reconciled = await loadPaneSet(ctx, expectedGeneration, signal);
887
+ if (!reconciled) return;
888
+ model.reset(reconciled.currentPane, reconciled.panes, reconciled.workspace);
889
+ for (const event of pendingEvents.splice(0)) {
890
+ if (isRelevantEvent(model, event)) model.apply(event);
891
+ }
892
+ if (subscriptionFingerprint(reconciled.currentPane, reconciled.panes) !== subscribedFingerprint) {
893
+ throw new HerdrTopologyChangedError();
894
+ }
895
+ initialized = true;
896
+ publish(ctx, model, expectedGeneration);
897
+ if (topologyPending) scheduleTopologyRefresh();
898
+ await Promise.race([
899
+ subscription.closed.then(() => {
900
+ if (!signal.aborted) throw new Error("Herdr subscription ended");
901
+ }),
902
+ reconfigure
903
+ ]);
904
+ } finally {
905
+ attemptActive = false;
906
+ attemptController.abort(new DOMException("Herdr widget attempt ended", "AbortError"));
907
+ sessionSignal.removeEventListener("abort", abortAttempt);
908
+ subscription?.close();
909
+ await Promise.allSettled(refreshTask ? [refreshTask] : []);
910
+ }
911
+ };
912
+ const run = async (ctx, expectedGeneration, signal) => {
913
+ let failures = 0;
914
+ while (owns(ctx, expectedGeneration) && !signal.aborted) {
915
+ try {
916
+ await runAttempt(ctx, expectedGeneration, signal);
917
+ return;
918
+ } catch (error) {
919
+ if (!owns(ctx, expectedGeneration) || signal.aborted) return;
920
+ clearWidget(ctx);
921
+ if (error instanceof HerdrTopologyChangedError) continue;
922
+ failures += 1;
923
+ if (failures >= 2) return;
924
+ try {
925
+ await waitForRetry(retryDelayMs, signal);
926
+ } catch {
927
+ return;
928
+ }
929
+ if (!owns(ctx, expectedGeneration) || signal.aborted) return;
930
+ }
931
+ }
932
+ };
933
+ return {
934
+ start(ctx) {
935
+ generation += 1;
936
+ controller?.abort(new DOMException("Herdr widget session replaced", "AbortError"));
937
+ if (activeContext) clearWidget(activeContext);
938
+ activeContext = void 0;
939
+ activeSession = void 0;
940
+ controller = void 0;
941
+ if (ctx.mode !== "tui") return;
942
+ activeContext = ctx;
943
+ activeSession = ctx.sessionManager;
944
+ controller = new AbortController();
945
+ const expectedGeneration = generation;
946
+ clearWidget(ctx);
947
+ const task = run(ctx, expectedGeneration, controller.signal).finally(() => {
948
+ ownedTasks.delete(task);
949
+ });
950
+ ownedTasks.add(task);
951
+ },
952
+ async shutdown(ctx) {
953
+ if (!owns(ctx)) return;
954
+ const shutdownGeneration = ++generation;
955
+ controller?.abort(new DOMException("Herdr widget session shut down", "AbortError"));
956
+ clearWidget(ctx);
957
+ await Promise.allSettled([...ownedTasks]);
958
+ if (generation !== shutdownGeneration) return;
959
+ activeContext = void 0;
960
+ activeSession = void 0;
961
+ controller = void 0;
962
+ }
963
+ };
964
+ }
965
+
966
+ // src/settings.ts
967
+ import { randomUUID } from "node:crypto";
968
+ import { constants } from "node:fs";
969
+ import { lstat, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
970
+ import { basename, dirname, join } from "node:path";
971
+ import { getAgentDir } from "@earendil-works/pi-coding-agent";
972
+ var HERDR_SETTINGS_FILE = "pi-herdr.json";
973
+ var MAX_SETTINGS_BYTES = 64 * 1024;
974
+ var DEFAULT_SETTINGS = { widget: true };
975
+ var queues = /* @__PURE__ */ new Map();
976
+ function herdrSettingsPath() {
977
+ return join(getAgentDir(), HERDR_SETTINGS_FILE);
978
+ }
979
+ function normalizeHerdrSettings(value) {
980
+ if (!isRecord3(value)) return void 0;
981
+ if (Object.hasOwn(value, "widget") && typeof value.widget !== "boolean") {
982
+ return void 0;
983
+ }
984
+ return {
985
+ widget: typeof value.widget === "boolean" ? value.widget : DEFAULT_SETTINGS.widget
986
+ };
987
+ }
988
+ function readHerdrSettings(settingsPath = herdrSettingsPath()) {
989
+ return enqueue(settingsPath, async () => {
990
+ let document;
991
+ try {
992
+ document = await readSettingsDocument(settingsPath);
993
+ } catch (error) {
994
+ if (isNodeError(error) && error.code === "ENOENT") {
995
+ return { kind: "missing", settings: { ...DEFAULT_SETTINGS } };
996
+ }
997
+ return {
998
+ kind: "invalid",
999
+ reason: `${settingsPath}: ${safeError(error)}`,
1000
+ settings: { ...DEFAULT_SETTINGS }
1001
+ };
1002
+ }
1003
+ const settings = normalizeHerdrSettings(document);
1004
+ return settings ? { kind: "loaded", settings } : {
1005
+ kind: "invalid",
1006
+ reason: `${settingsPath}: invalid settings shape`,
1007
+ settings: { ...DEFAULT_SETTINGS }
1008
+ };
1009
+ });
1010
+ }
1011
+ function updateHerdrSettings(patch, options = {}) {
1012
+ const settingsPath = options.settingsPath ?? herdrSettingsPath();
1013
+ return enqueue(settingsPath, async () => {
1014
+ const current = await readDocumentForUpdate(settingsPath);
1015
+ const updated = { ...current, ...patch };
1016
+ const settings = normalizeHerdrSettings(updated);
1017
+ if (!settings) throw new Error(`Pi Herdr settings at ${settingsPath} have an invalid shape.`);
1018
+ await publishSettings(settingsPath, updated, options);
1019
+ return settings;
1020
+ });
1021
+ }
1022
+ async function awaitHerdrSettingsWrites(settingsPath = herdrSettingsPath()) {
1023
+ await queues.get(settingsPath);
1024
+ }
1025
+ function enqueue(path2, operation) {
1026
+ const previous = queues.get(path2) ?? Promise.resolve();
1027
+ const result = previous.then(operation, operation);
1028
+ const settled = result.then(
1029
+ () => void 0,
1030
+ () => void 0
1031
+ );
1032
+ queues.set(path2, settled);
1033
+ void settled.finally(() => {
1034
+ if (queues.get(path2) === settled) queues.delete(path2);
1035
+ });
1036
+ return result;
1037
+ }
1038
+ async function readDocumentForUpdate(path2) {
1039
+ try {
1040
+ const document = await readSettingsDocument(path2);
1041
+ if (!normalizeHerdrSettings(document)) throw new Error("invalid settings shape");
1042
+ return document;
1043
+ } catch (error) {
1044
+ if (isNodeError(error) && error.code === "ENOENT") return {};
1045
+ throw new Error(`Pi Herdr settings at ${path2} are invalid: ${safeError(error)}`);
1046
+ }
1047
+ }
1048
+ async function readSettingsDocument(path2) {
1049
+ const pathStats = await lstat(path2);
1050
+ if (pathStats.isSymbolicLink() || !pathStats.isFile()) {
1051
+ throw new Error("settings path is not a regular file");
1052
+ }
1053
+ if (pathStats.size > MAX_SETTINGS_BYTES) {
1054
+ throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
1055
+ }
1056
+ const noFollow = constants.O_NOFOLLOW ?? 0;
1057
+ const handle = await open(path2, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | noFollow);
1058
+ try {
1059
+ const stats = await handle.stat();
1060
+ if (!stats.isFile() || stats.dev !== pathStats.dev || stats.ino !== pathStats.ino) {
1061
+ throw new Error("settings path changed while opening");
1062
+ }
1063
+ const buffer = Buffer.alloc(MAX_SETTINGS_BYTES + 1);
1064
+ let offset = 0;
1065
+ while (offset < buffer.length) {
1066
+ const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
1067
+ if (bytesRead === 0) break;
1068
+ offset += bytesRead;
1069
+ }
1070
+ if (offset > MAX_SETTINGS_BYTES) {
1071
+ throw new Error(`settings file exceeds ${MAX_SETTINGS_BYTES} bytes`);
1072
+ }
1073
+ let contents;
1074
+ try {
1075
+ contents = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer.subarray(0, offset));
1076
+ } catch {
1077
+ throw new Error("settings file is not valid UTF-8");
1078
+ }
1079
+ let parsed;
1080
+ try {
1081
+ parsed = JSON.parse(contents);
1082
+ } catch {
1083
+ throw new Error("invalid JSON");
1084
+ }
1085
+ if (!isRecord3(parsed)) throw new Error("settings document must be a JSON object");
1086
+ return parsed;
1087
+ } finally {
1088
+ await handle.close();
1089
+ }
1090
+ }
1091
+ async function publishSettings(path2, document, options) {
1092
+ const contents = `${JSON.stringify(document, null, 2)}
1093
+ `;
1094
+ if (Buffer.byteLength(contents) > MAX_SETTINGS_BYTES) {
1095
+ throw new Error(`Pi Herdr settings document exceeds ${MAX_SETTINGS_BYTES} bytes.`);
1096
+ }
1097
+ const directory = dirname(path2);
1098
+ await mkdir(directory, { recursive: true });
1099
+ const temporaryPath = join(directory, `.${basename(path2)}.${process.pid}.${randomUUID()}.tmp`);
1100
+ try {
1101
+ await writeFile(temporaryPath, contents, { encoding: "utf8", flag: "wx", mode: 384 });
1102
+ await options.beforeRename?.(temporaryPath, path2);
1103
+ await rename(temporaryPath, path2);
1104
+ } catch (error) {
1105
+ await rm(temporaryPath, { force: true }).catch(() => void 0);
1106
+ throw error;
1107
+ }
1108
+ }
1109
+ function isRecord3(value) {
1110
+ return typeof value === "object" && value !== null && !Array.isArray(value);
1111
+ }
1112
+ function isNodeError(error) {
1113
+ return error instanceof Error && "code" in error;
1114
+ }
1115
+ function safeError(error) {
1116
+ return error instanceof Error ? error.message : String(error);
1117
+ }
1118
+
1119
+ // src/herdr-settings-controller.ts
1120
+ function createHerdrSettingsController(pi, observer, options = {}) {
1121
+ const settingsPath = options.settingsPath ?? herdrSettingsPath();
1122
+ let generation = 0;
1123
+ let owner;
1124
+ let controller = new AbortController();
1125
+ let enabled = true;
1126
+ let changes = Promise.resolve();
1127
+ let menuOpen = false;
1128
+ const current = (expected) => expected === generation && !controller.signal.aborted;
1129
+ pi.registerCommand("herdr", {
1130
+ description: "Configure the Herdr agent widget",
1131
+ handler: async (args, ctx) => {
1132
+ if (args.trim()) throw new Error("/herdr does not accept arguments.");
1133
+ if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
1134
+ throw new Error("/herdr requires TUI or RPC mode.");
1135
+ }
1136
+ if (!owner || ctx.sessionManager !== owner.sessionManager || menuOpen) return;
1137
+ const expected = generation;
1138
+ const signal = controller.signal;
1139
+ menuOpen = true;
1140
+ try {
1141
+ const [{ runMenu }, { createHerdrMenu }] = await Promise.all([
1142
+ import("@narumitw/pi-tui-kit"),
1143
+ import("./chunks/herdr-menu-IUPFF5YK.ts")
1144
+ ]);
1145
+ if (!current(expected)) return;
1146
+ await runMenu(
1147
+ ctx,
1148
+ createHerdrMenu({
1149
+ settingsPath,
1150
+ isEnabled: () => enabled,
1151
+ toggle: (actionSignal) => {
1152
+ const result = changes.then(async () => {
1153
+ if (actionSignal.aborted || !current(expected) || !owner) return false;
1154
+ const previous = enabled;
1155
+ const actionOwner = owner;
1156
+ try {
1157
+ enabled = !previous;
1158
+ if (enabled && actionOwner.mode === "tui") observer.start(actionOwner);
1159
+ else await observer.shutdown(actionOwner);
1160
+ if (!current(expected)) return false;
1161
+ await updateHerdrSettings({ widget: enabled }, { settingsPath });
1162
+ return current(expected);
1163
+ } catch {
1164
+ if (!current(expected)) return false;
1165
+ enabled = previous;
1166
+ try {
1167
+ if (previous && actionOwner.mode === "tui") observer.start(actionOwner);
1168
+ else await observer.shutdown(actionOwner);
1169
+ } finally {
1170
+ if (current(expected))
1171
+ ctx.ui.notify(
1172
+ "Herdr settings were not saved; the previous widget setting was restored. Check pi-herdr.json and its permissions.",
1173
+ "warning"
1174
+ );
1175
+ }
1176
+ return false;
1177
+ }
1178
+ });
1179
+ changes = result.then(
1180
+ () => void 0,
1181
+ () => void 0
1182
+ );
1183
+ return result;
1184
+ }
1185
+ }),
1186
+ {
1187
+ getState: () => void 0,
1188
+ signal,
1189
+ isCurrent: () => current(expected),
1190
+ onError: () => {
1191
+ if (current(expected)) ctx.ui.notify("The Herdr menu could not be displayed.", "error");
1192
+ }
1193
+ }
1194
+ );
1195
+ } finally {
1196
+ if (expected === generation) menuOpen = false;
1197
+ }
1198
+ }
1199
+ });
1200
+ return {
1201
+ async start(ctx) {
1202
+ const expected = ++generation;
1203
+ controller.abort();
1204
+ controller = new AbortController();
1205
+ menuOpen = false;
1206
+ const previous = owner;
1207
+ owner = ctx;
1208
+ if (previous) await observer.shutdown(previous);
1209
+ if (!current(expected)) return;
1210
+ await changes;
1211
+ if (!current(expected)) return;
1212
+ const loaded = await readHerdrSettings(settingsPath);
1213
+ if (!current(expected)) return;
1214
+ enabled = loaded.settings.widget;
1215
+ if (loaded.kind === "invalid" && ctx.hasUI)
1216
+ ctx.ui.notify(
1217
+ "Herdr ignored invalid pi-herdr.json settings and kept the widget enabled. Fix the file before saving.",
1218
+ "warning"
1219
+ );
1220
+ if (enabled && ctx.mode === "tui") observer.start(ctx);
1221
+ },
1222
+ async shutdown(ctx) {
1223
+ if (ctx.sessionManager !== owner?.sessionManager) return;
1224
+ generation += 1;
1225
+ controller.abort();
1226
+ owner = void 0;
1227
+ menuOpen = false;
1228
+ await Promise.all([observer.shutdown(ctx), changes]);
1229
+ await awaitHerdrSettingsWrites(settingsPath);
1230
+ }
1231
+ };
1232
+ }
1233
+
1234
+ // src/herdr-agent-state.ts
1235
+ var SOURCE = "herdr:pi";
1236
+ var reportSeq = Date.now() * 1e3;
1237
+ function nextReportSeq() {
1238
+ reportSeq += 1;
1239
+ return reportSeq;
1240
+ }
1241
+ function resolveSocketEndpoint(socketPath, platform = process.platform) {
1242
+ if (!socketPath || platform !== "win32") return socketPath ?? "";
1243
+ const normalized = socketPath.toLowerCase();
1244
+ if (normalized.startsWith("\\\\.\\pipe\\") || normalized.startsWith("\\\\?\\pipe\\")) {
1245
+ return socketPath;
1246
+ }
1247
+ return `\\\\.\\pipe\\${socketPath}`;
1248
+ }
1249
+ function readEnvironment(environment = process.env) {
1250
+ const socketPath = environment.HERDR_SOCKET_PATH;
1251
+ const paneId = environment.HERDR_PANE_ID;
1252
+ return {
1253
+ enabled: environment.HERDR_ENV === "1" && !!socketPath && !!paneId,
1254
+ paneId: paneId ?? "",
1255
+ socketEndpoint: resolveSocketEndpoint(socketPath)
1256
+ };
1257
+ }
1258
+ function createHerdrAgentStateExtension(options = {}) {
1259
+ const environment = options.environment ?? readEnvironment();
1260
+ const now = options.now ?? Date.now;
1261
+ const random = options.random ?? Math.random;
1262
+ const sendRequest = options.sendRequest ?? createBestEffortSender(environment.socketEndpoint);
1263
+ const widgetObserver = options.widgetObserver ?? createHerdrWidgetObserver({
1264
+ environment,
1265
+ now,
1266
+ random
1267
+ });
1268
+ return function herdrAgentState2(pi) {
1269
+ if (!environment.enabled) return;
1270
+ const widget = createHerdrSettingsController(pi, widgetObserver, options);
1271
+ let sessionGeneration = 0;
1272
+ let sessionController = new AbortController();
1273
+ let activeSession;
1274
+ let currentAgentSessionId;
1275
+ let currentAgentSessionPath;
1276
+ let agentActive = false;
1277
+ let blockedCount = 0;
1278
+ let blockedMessage;
1279
+ let lastState;
1280
+ let lastMessage;
1281
+ let rootSession = false;
1282
+ let queuedState;
1283
+ let drainTask;
1284
+ let queuedMetadata;
1285
+ let metadataDrainTask;
1286
+ let lastMetadataSnapshot;
1287
+ let metadataRefreshTimer;
1288
+ let shutdownClearController;
1289
+ let shutdownSession;
1290
+ let shutdownTask;
1291
+ function requestId(kind) {
1292
+ const segment = kind ? `${kind}:` : "";
1293
+ return `${SOURCE}:${segment}${now()}:${random().toString(36).slice(2)}`;
1294
+ }
1295
+ function updateSessionRef(ctx) {
1296
+ try {
1297
+ const file = ctx.sessionManager.getSessionFile();
1298
+ currentAgentSessionPath = typeof file === "string" && path.isAbsolute(file) ? file : void 0;
1299
+ } catch {
1300
+ currentAgentSessionPath = void 0;
1301
+ }
1302
+ try {
1303
+ const id = ctx.sessionManager.getSessionId();
1304
+ currentAgentSessionId = typeof id === "string" && id.length > 0 ? id : void 0;
1305
+ } catch {
1306
+ currentAgentSessionId = void 0;
1307
+ }
1308
+ }
1309
+ function currentSessionRef() {
1310
+ if (currentAgentSessionPath) return { agent_session_path: currentAgentSessionPath };
1311
+ if (currentAgentSessionId) return { agent_session_id: currentAgentSessionId };
1312
+ return void 0;
1313
+ }
1314
+ function withSessionRef(params) {
1315
+ return { ...params, ...currentSessionRef() };
1316
+ }
1317
+ async function safeSend(request, signal) {
1318
+ try {
1319
+ await sendRequest(request, signal);
1320
+ } catch {
1321
+ }
1322
+ }
1323
+ function reportSession(sessionStartSource) {
1324
+ const sessionRef = currentSessionRef();
1325
+ if (!sessionRef) return Promise.resolve();
1326
+ return safeSend(
1327
+ {
1328
+ id: requestId("session"),
1329
+ method: "pane.report_agent_session",
1330
+ params: {
1331
+ pane_id: environment.paneId,
1332
+ source: SOURCE,
1333
+ agent: "pi",
1334
+ seq: nextReportSeq(),
1335
+ session_start_source: sessionStartSource,
1336
+ ...sessionRef
1337
+ }
1338
+ },
1339
+ sessionController.signal
1340
+ );
1341
+ }
1342
+ function stateRequest(state) {
1343
+ return {
1344
+ id: requestId(),
1345
+ method: "pane.report_agent",
1346
+ params: withSessionRef({
1347
+ pane_id: environment.paneId,
1348
+ source: SOURCE,
1349
+ agent: "pi",
1350
+ state: state.state,
1351
+ message: state.message,
1352
+ seq: state.seq
1353
+ })
1354
+ };
1355
+ }
1356
+ function readMetadataSnapshot(ctx) {
1357
+ let session;
1358
+ let contextUsagePercent;
1359
+ try {
1360
+ session = pi.getSessionName();
1361
+ } catch {
1362
+ }
1363
+ try {
1364
+ contextUsagePercent = ctx.getContextUsage()?.percent;
1365
+ } catch {
1366
+ }
1367
+ return createHerdrMetadataSnapshot({
1368
+ model: ctx.model?.id,
1369
+ provider: ctx.model?.provider,
1370
+ thinking: ctx.thinkingLevel,
1371
+ session,
1372
+ contextUsagePercent
1373
+ });
1374
+ }
1375
+ function metadataRequest(metadata) {
1376
+ return createHerdrMetadataRequest({
1377
+ id: requestId(),
1378
+ paneId: environment.paneId,
1379
+ source: SOURCE,
1380
+ seq: metadata.seq,
1381
+ snapshot: metadata.snapshot
1382
+ });
1383
+ }
1384
+ async function drainStateQueue() {
1385
+ while (queuedState) {
1386
+ const next = queuedState;
1387
+ queuedState = void 0;
1388
+ if (!next.signal.aborted) await safeSend(stateRequest(next), next.signal);
1389
+ }
1390
+ }
1391
+ function queueState(state, message) {
1392
+ queuedState = {
1393
+ state,
1394
+ message,
1395
+ seq: nextReportSeq(),
1396
+ signal: sessionController.signal
1397
+ };
1398
+ if (drainTask) return;
1399
+ drainTask = drainStateQueue().finally(() => {
1400
+ drainTask = void 0;
1401
+ if (queuedState) queueState(queuedState.state, queuedState.message);
1402
+ });
1403
+ }
1404
+ async function drainMetadataQueue() {
1405
+ while (queuedMetadata) {
1406
+ const next = queuedMetadata;
1407
+ queuedMetadata = void 0;
1408
+ if (next.signal.aborted || next.generation !== sessionGeneration || !rootSession) {
1409
+ continue;
1410
+ }
1411
+ await safeSend(metadataRequest(next), next.signal);
1412
+ }
1413
+ }
1414
+ function startMetadataDrain() {
1415
+ if (metadataDrainTask) return;
1416
+ metadataDrainTask = drainMetadataQueue().finally(() => {
1417
+ metadataDrainTask = void 0;
1418
+ if (queuedMetadata) startMetadataDrain();
1419
+ });
1420
+ }
1421
+ function scheduleMetadataRefresh(generation) {
1422
+ if (metadataRefreshTimer) clearTimeout(metadataRefreshTimer);
1423
+ metadataRefreshTimer = setTimeout(() => {
1424
+ metadataRefreshTimer = void 0;
1425
+ if (generation !== sessionGeneration || sessionController.signal.aborted || !rootSession || !lastMetadataSnapshot) {
1426
+ return;
1427
+ }
1428
+ queueMetadata(lastMetadataSnapshot, true);
1429
+ }, HERDR_METADATA_REFRESH_MS);
1430
+ metadataRefreshTimer.unref?.();
1431
+ }
1432
+ function queueMetadata(snapshot, force = false) {
1433
+ if (!rootSession || sessionController.signal.aborted) return;
1434
+ if (!force && herdrMetadataSnapshotsEqual(lastMetadataSnapshot, snapshot)) return;
1435
+ lastMetadataSnapshot = snapshot;
1436
+ queuedMetadata = {
1437
+ snapshot,
1438
+ seq: nextReportSeq(),
1439
+ signal: sessionController.signal,
1440
+ generation: sessionGeneration
1441
+ };
1442
+ scheduleMetadataRefresh(sessionGeneration);
1443
+ startMetadataDrain();
1444
+ }
1445
+ function owns(ctx) {
1446
+ return rootSession && ctx.sessionManager === activeSession;
1447
+ }
1448
+ function publishMetadata(ctx) {
1449
+ if (!owns(ctx)) return;
1450
+ queueMetadata(readMetadataSnapshot(ctx));
1451
+ }
1452
+ function desiredState() {
1453
+ if (blockedCount > 0) return { state: "blocked", message: blockedMessage };
1454
+ if (agentActive) return { state: "working" };
1455
+ return { state: "idle" };
1456
+ }
1457
+ function publishState(force = false) {
1458
+ const next = desiredState();
1459
+ if (!force && next.state === lastState && next.message === lastMessage) return;
1460
+ lastState = next.state;
1461
+ lastMessage = next.message;
1462
+ queueState(next.state, next.message);
1463
+ }
1464
+ pi.on("ui_prompt_start", (event, ctx) => {
1465
+ if (!owns(ctx)) return;
1466
+ blockedCount += 1;
1467
+ blockedMessage = event.title?.trim() || event.kind;
1468
+ publishState();
1469
+ });
1470
+ pi.on("ui_prompt_end", (_event, ctx) => {
1471
+ if (!owns(ctx)) return;
1472
+ blockedCount = Math.max(0, blockedCount - 1);
1473
+ if (blockedCount === 0) blockedMessage = void 0;
1474
+ publishState();
1475
+ });
1476
+ pi.on("session_start", async (event, ctx) => {
1477
+ const generation = ++sessionGeneration;
1478
+ const replaced = new DOMException("Herdr session replaced", "AbortError");
1479
+ sessionController.abort(replaced);
1480
+ shutdownClearController?.abort(replaced);
1481
+ shutdownClearController = void 0;
1482
+ if (metadataRefreshTimer) clearTimeout(metadataRefreshTimer);
1483
+ metadataRefreshTimer = void 0;
1484
+ queuedMetadata = void 0;
1485
+ lastMetadataSnapshot = void 0;
1486
+ sessionController = new AbortController();
1487
+ activeSession = ctx.sessionManager;
1488
+ rootSession = ctx.mode === "tui";
1489
+ const widgetStart = widget.start(ctx);
1490
+ agentActive = false;
1491
+ blockedCount = 0;
1492
+ blockedMessage = void 0;
1493
+ lastState = void 0;
1494
+ lastMessage = void 0;
1495
+ if (!rootSession) {
1496
+ await widgetStart;
1497
+ return;
1498
+ }
1499
+ updateSessionRef(ctx);
1500
+ const sessionReport = reportSession(event.reason);
1501
+ publishMetadata(ctx);
1502
+ await Promise.all([sessionReport, widgetStart]);
1503
+ if (generation !== sessionGeneration || sessionController.signal.aborted || !rootSession) {
1504
+ return;
1505
+ }
1506
+ agentActive = !ctx.isIdle();
1507
+ publishState(true);
1508
+ });
1509
+ pi.on("agent_start", (_event, ctx) => {
1510
+ if (!owns(ctx)) return;
1511
+ updateSessionRef(ctx);
1512
+ void reportSession();
1513
+ agentActive = true;
1514
+ publishState();
1515
+ });
1516
+ pi.on("agent_settled", (_event, ctx) => {
1517
+ if (!owns(ctx)) return;
1518
+ publishMetadata(ctx);
1519
+ if (!ctx.isIdle()) return;
1520
+ agentActive = false;
1521
+ publishState();
1522
+ });
1523
+ pi.on("session_info_changed", (_event, ctx) => publishMetadata(ctx));
1524
+ pi.on("model_select", (_event, ctx) => publishMetadata(ctx));
1525
+ pi.on("thinking_level_select", (_event, ctx) => publishMetadata(ctx));
1526
+ pi.on("session_compact", (_event, ctx) => publishMetadata(ctx));
1527
+ pi.on("session_shutdown", async (_event, ctx) => {
1528
+ if (ctx.sessionManager !== activeSession) {
1529
+ await Promise.allSettled([widget.shutdown(ctx)]);
1530
+ return;
1531
+ }
1532
+ if (shutdownTask && shutdownSession === ctx.sessionManager) {
1533
+ await shutdownTask;
1534
+ return;
1535
+ }
1536
+ const session = ctx.sessionManager;
1537
+ const task = (async () => {
1538
+ const shouldClearMetadata = rootSession;
1539
+ const shutdownGeneration = ++sessionGeneration;
1540
+ rootSession = false;
1541
+ if (metadataRefreshTimer) clearTimeout(metadataRefreshTimer);
1542
+ metadataRefreshTimer = void 0;
1543
+ sessionController.abort(new DOMException("Herdr session shut down", "AbortError"));
1544
+ queuedState = void 0;
1545
+ queuedMetadata = void 0;
1546
+ await Promise.allSettled([drainTask, metadataDrainTask, widget.shutdown(ctx)]);
1547
+ const stillOwnsShutdown = shutdownGeneration === sessionGeneration && activeSession === session && !rootSession;
1548
+ if (shouldClearMetadata && stillOwnsShutdown) {
1549
+ const controller = new AbortController();
1550
+ shutdownClearController = controller;
1551
+ await safeSend(
1552
+ createHerdrMetadataRequest({
1553
+ id: requestId(),
1554
+ paneId: environment.paneId,
1555
+ source: SOURCE,
1556
+ seq: nextReportSeq(),
1557
+ snapshot: createHerdrMetadataClearSnapshot()
1558
+ }),
1559
+ controller.signal
1560
+ );
1561
+ if (shutdownClearController === controller) shutdownClearController = void 0;
1562
+ }
1563
+ if (shutdownGeneration !== sessionGeneration || activeSession !== session || rootSession) {
1564
+ return;
1565
+ }
1566
+ lastMetadataSnapshot = void 0;
1567
+ currentAgentSessionId = void 0;
1568
+ currentAgentSessionPath = void 0;
1569
+ activeSession = void 0;
1570
+ })();
1571
+ shutdownSession = session;
1572
+ shutdownTask = task;
1573
+ await task;
1574
+ if (shutdownTask === task) {
1575
+ shutdownTask = void 0;
1576
+ shutdownSession = void 0;
1577
+ }
1578
+ });
1579
+ };
1580
+ }
1581
+ function herdrAgentState(pi) {
1582
+ createHerdrAgentStateExtension()(pi);
1583
+ }
1584
+ export {
1585
+ herdrAgentState as default
1586
+ };
1587
+ //# sourceMappingURL=index.ts.map