@narumitw/pi-herdr 0.3.1 → 0.3.2

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.
@@ -108,7 +108,8 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
108
108
  let metadataDrainTask: Promise<void> | undefined;
109
109
  let lastMetadataSnapshot: HerdrMetadataSnapshot | undefined;
110
110
  let metadataRefreshTimer: ReturnType<typeof setTimeout> | undefined;
111
- let shutdownClearController: AbortController | undefined;
111
+ const sessionReportTasks = new Set<Promise<void>>();
112
+ let shutdownController: AbortController | undefined;
112
113
  let shutdownSession: ExtensionContext["sessionManager"] | undefined;
113
114
  let shutdownTask: Promise<void> | undefined;
114
115
 
@@ -154,7 +155,7 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
154
155
  function reportSession(sessionStartSource?: string): Promise<void> {
155
156
  const sessionRef = currentSessionRef();
156
157
  if (!sessionRef) return Promise.resolve();
157
- return safeSend(
158
+ const task = safeSend(
158
159
  {
159
160
  id: requestId("session"),
160
161
  method: "pane.report_agent_session",
@@ -169,6 +170,9 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
169
170
  },
170
171
  sessionController.signal,
171
172
  );
173
+ sessionReportTasks.add(task);
174
+ void task.finally(() => sessionReportTasks.delete(task));
175
+ return task;
172
176
  }
173
177
 
174
178
  function stateRequest(state: QueuedState): HerdrRequest {
@@ -331,8 +335,10 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
331
335
  const generation = ++sessionGeneration;
332
336
  const replaced = new DOMException("Herdr session replaced", "AbortError");
333
337
  sessionController.abort(replaced);
334
- shutdownClearController?.abort(replaced);
335
- shutdownClearController = undefined;
338
+ shutdownController?.abort(replaced);
339
+ shutdownController = undefined;
340
+ shutdownTask = undefined;
341
+ shutdownSession = undefined;
336
342
  if (metadataRefreshTimer) clearTimeout(metadataRefreshTimer);
337
343
  metadataRefreshTimer = undefined;
338
344
  queuedMetadata = undefined;
@@ -355,7 +361,12 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
355
361
  const sessionReport = reportSession(event.reason);
356
362
  publishMetadata(ctx);
357
363
  await Promise.all([sessionReport, widgetStart]);
358
- if (generation !== sessionGeneration || sessionController.signal.aborted || !rootSession) {
364
+ if (
365
+ generation !== sessionGeneration ||
366
+ activeSession !== ctx.sessionManager ||
367
+ sessionController.signal.aborted ||
368
+ !rootSession
369
+ ) {
359
370
  return;
360
371
  }
361
372
  agentActive = !ctx.isIdle();
@@ -403,24 +414,30 @@ export function createHerdrAgentStateExtension(options: HerdrAgentStateOptions =
403
414
  sessionController.abort(new DOMException("Herdr session shut down", "AbortError"));
404
415
  queuedState = undefined;
405
416
  queuedMetadata = undefined;
406
- await Promise.allSettled([drainTask, metadataDrainTask, widget.shutdown(ctx)]);
407
- const stillOwnsShutdown = shutdownGeneration === sessionGeneration && activeSession === session && !rootSession;
408
- if (shouldClearMetadata && stillOwnsShutdown) {
417
+ await Promise.allSettled([...sessionReportTasks, drainTask, metadataDrainTask, widget.shutdown(ctx)]);
418
+ const stillOwnsShutdown = () =>
419
+ shutdownGeneration === sessionGeneration && activeSession === session && !rootSession;
420
+ if (shouldClearMetadata && stillOwnsShutdown()) {
409
421
  const controller = new AbortController();
410
- shutdownClearController = controller;
411
- await safeSend(
412
- createHerdrMetadataRequest({
413
- id: requestId(),
414
- paneId: environment.paneId,
415
- source: SOURCE,
416
- seq: nextReportSeq(),
417
- snapshot: createHerdrMetadataClearSnapshot(),
418
- }),
419
- controller.signal,
420
- );
421
- if (shutdownClearController === controller) shutdownClearController = undefined;
422
+ shutdownController = controller;
423
+ try {
424
+ await safeSend(
425
+ createHerdrMetadataRequest({
426
+ id: requestId(),
427
+ paneId: environment.paneId,
428
+ source: SOURCE,
429
+ seq: nextReportSeq(),
430
+ snapshot: createHerdrMetadataClearSnapshot(),
431
+ }),
432
+ controller.signal,
433
+ );
434
+ // Native identity and restore remain Herdr-owned. Official-source
435
+ // release is a no-op; clearing authority would delete restore data.
436
+ } finally {
437
+ if (shutdownController === controller) shutdownController = undefined;
438
+ }
422
439
  }
423
- if (shutdownGeneration !== sessionGeneration || activeSession !== session || rootSession) {
440
+ if (!stillOwnsShutdown()) {
424
441
  return;
425
442
  }
426
443
  lastMetadataSnapshot = undefined;
@@ -39,6 +39,9 @@ class NdjsonFrames {
39
39
  throw new Error("Herdr returned invalid JSON");
40
40
  }
41
41
  }
42
+ if (this.buffer.length > MAX_HERDR_FRAME_BYTES) {
43
+ throw new Error("Herdr response frame exceeded the size limit");
44
+ }
42
45
  return frames;
43
46
  }
44
47
  }
@@ -51,51 +54,33 @@ function abortReason(signal: AbortSignal): Error {
51
54
  return signal.reason instanceof Error ? signal.reason : new DOMException("Herdr request aborted", "AbortError");
52
55
  }
53
56
 
54
- function responseError(frame: Record<string, unknown>): Error | undefined {
55
- if (!isRecord(frame.error)) return undefined;
56
- const message = typeof frame.error.message === "string" ? frame.error.message : "request failed";
57
- return new Error(`Herdr ${message}`);
58
- }
59
-
60
- function sendRequestAttempt(
61
- socketEndpoint: string,
62
- request: HerdrRequest,
63
- timeoutMs: number,
64
- signal: AbortSignal,
65
- ): Promise<boolean> {
66
- if (signal.aborted) return Promise.resolve(false);
67
-
68
- return new Promise((resolve) => {
69
- let finished = false;
70
- let timeout: ReturnType<typeof setTimeout> | undefined;
71
- const socket = net.createConnection(socketEndpoint);
57
+ class HerdrApiError extends Error {
58
+ readonly code: string | undefined;
72
59
 
73
- const finish = (delivered: boolean) => {
74
- if (finished) return;
75
- finished = true;
76
- if (timeout) clearTimeout(timeout);
77
- signal.removeEventListener("abort", abort);
78
- socket.destroy();
79
- resolve(delivered);
80
- };
81
- const abort = () => finish(false);
60
+ constructor(error: Record<string, unknown>) {
61
+ super(`Herdr ${typeof error.message === "string" ? error.message : "request failed"}`);
62
+ this.code = typeof error.code === "string" ? error.code : undefined;
63
+ }
64
+ }
82
65
 
83
- signal.addEventListener("abort", abort, { once: true });
84
- socket.on("error", () => finish(false));
85
- socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
86
- socket.on("data", () => finish(true));
87
- socket.on("end", () => finish(false));
88
- socket.on("close", () => finish(false));
89
- timeout = setTimeout(() => finish(false), timeoutMs);
90
- timeout.unref?.();
91
- });
66
+ function responseError(frame: Record<string, unknown>): Error | undefined {
67
+ if (!("error" in frame)) return undefined;
68
+ if (!isRecord(frame.error)) return new Error("Herdr returned an invalid error response");
69
+ return new HerdrApiError(frame.error);
92
70
  }
93
71
 
94
72
  export function createBestEffortSender(socketEndpoint: string) {
95
73
  return async (request: HerdrRequest, signal: AbortSignal): Promise<void> => {
96
- if (await sendRequestAttempt(socketEndpoint, request, 500, signal)) return;
97
- if (signal.aborted) return;
98
- await sendRequestAttempt(socketEndpoint, request, 1500, signal);
74
+ for (const timeoutMs of [500, 1500]) {
75
+ if (signal.aborted) return;
76
+ try {
77
+ const result = await requestHerdr(socketEndpoint, request, signal, timeoutMs);
78
+ if (isRecord(result) && result.type === "ok") return;
79
+ } catch (error) {
80
+ // API rejection is not a transport outage. Do not repeat a rejected report.
81
+ if (signal.aborted || error instanceof HerdrApiError) return;
82
+ }
83
+ }
99
84
  };
100
85
  }
101
86
 
@@ -108,6 +93,7 @@ export function requestHerdr(
108
93
  if (signal.aborted) return Promise.reject(abortReason(signal));
109
94
 
110
95
  return new Promise((resolve, reject) => {
96
+ const payload = `${JSON.stringify(request)}\n`;
111
97
  const socket = net.createConnection(socketEndpoint);
112
98
  const parser = new NdjsonFrames();
113
99
  let finished = false;
@@ -129,11 +115,14 @@ export function requestHerdr(
129
115
  const abort = () => finish(abortReason(signal));
130
116
 
131
117
  signal.addEventListener("abort", abort, { once: true });
132
- socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
118
+ socket.on("connect", () => {
119
+ if (!finished) socket.write(payload);
120
+ });
133
121
  socket.on("error", (error) => finish(error));
134
122
  socket.on("end", () => finish(new Error("Herdr closed the request before responding")));
135
123
  socket.on("close", () => finish(new Error("Herdr request socket closed")));
136
124
  socket.on("data", (chunk: Buffer) => {
125
+ if (finished) return;
137
126
  try {
138
127
  for (const value of parser.push(chunk)) {
139
128
  if (!isRecord(value)) continue;
@@ -171,6 +160,7 @@ export async function openHerdrSubscription(
171
160
  ): Promise<HerdrSubscription> {
172
161
  if (signal.aborted) throw abortReason(signal);
173
162
 
163
+ const payload = `${JSON.stringify(request)}\n`;
174
164
  const socket = net.createConnection(socketEndpoint);
175
165
  const parser = new NdjsonFrames();
176
166
  const pendingEvents: unknown[] = [];
@@ -212,6 +202,7 @@ export async function openHerdrSubscription(
212
202
  else resolveClosed();
213
203
  };
214
204
  const deliver = (frame: unknown) => {
205
+ if (finished) return;
215
206
  try {
216
207
  onEvent(frame);
217
208
  } catch (error) {
@@ -224,27 +215,27 @@ export async function openHerdrSubscription(
224
215
  };
225
216
 
226
217
  signal.addEventListener("abort", abort, { once: true });
227
- socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
218
+ socket.on("connect", () => {
219
+ if (!finished) socket.write(payload);
220
+ });
228
221
  socket.on("error", (error) => finish(error));
229
222
  socket.on("end", () => finish(new Error("Herdr subscription closed")));
230
223
  socket.on("close", () => finish(new Error("Herdr subscription socket closed")));
231
224
  socket.on("data", (chunk: Buffer) => {
225
+ if (finished) return;
232
226
  try {
233
227
  for (const value of parser.push(chunk)) {
234
- if (!ready) {
235
- if (isRecord(value)) {
236
- const uncorrelatedError = responseError(value);
237
- if (uncorrelatedError && (value.id === "" || value.id === undefined)) {
238
- finish(uncorrelatedError);
239
- return;
240
- }
228
+ if (finished) return;
229
+ if (isRecord(value)) {
230
+ const error = responseError(value);
231
+ if (error && (value.id === request.id || value.id === "" || value.id === undefined)) {
232
+ finish(error);
233
+ return;
241
234
  }
235
+ if ("id" in value && value.id !== request.id) continue;
236
+ }
237
+ if (!ready) {
242
238
  if (isRecord(value) && value.id === request.id) {
243
- const error = responseError(value);
244
- if (error) {
245
- finish(error);
246
- return;
247
- }
248
239
  if (!isRecord(value.result) || value.result.type !== "subscription_started") {
249
240
  finish(new Error("Herdr returned an invalid subscription acknowledgement"));
250
241
  return;
@@ -37,16 +37,12 @@ export interface HerdrWidgetObserver {
37
37
  shutdown(ctx: ExtensionContext): Promise<void>;
38
38
  }
39
39
 
40
- const MAX_PENDING_EVENTS = 1024;
41
-
42
40
  class HerdrTopologyChangedError extends Error {}
43
41
 
44
- function requiresResubscribe(event: HerdrPaneEvent): boolean {
45
- return event.type === "created" || event.type === "moved" || event.type === "agent_detected";
46
- }
47
-
48
42
  function isRelevantEvent(model: HerdrWidgetModel, event: HerdrPaneEvent): boolean {
49
- if (event.type === "created") return model.isCurrentWorkspace(event.pane.workspaceId);
43
+ if (event.type === "created" || event.type === "updated") {
44
+ return model.isCurrentWorkspace(event.pane.workspaceId);
45
+ }
50
46
  if (event.type === "moved") {
51
47
  return (
52
48
  model.isCurrentPane(event.previousPaneId) ||
@@ -54,7 +50,7 @@ function isRelevantEvent(model: HerdrWidgetModel, event: HerdrPaneEvent): boolea
54
50
  model.isCurrentWorkspace(event.pane.workspaceId)
55
51
  );
56
52
  }
57
- return model.isCurrentWorkspace(event.workspaceId);
53
+ return "workspaceId" in event && model.isCurrentWorkspace(event.workspaceId);
58
54
  }
59
55
 
60
56
  function subscriptionFingerprint(currentPane: HerdrPane, panes: readonly HerdrPane[]): string {
@@ -165,7 +161,13 @@ export function createHerdrWidgetObserver(options: HerdrObserverOptions): HerdrW
165
161
  ),
166
162
  ]);
167
163
  if (!owns(ctx, expectedGeneration) || signal.aborted) return undefined;
168
- const namesByPane = new Map(parseAgentListResult(agentResult).map((pane) => [pane.paneId, pane.agentName]));
164
+ const panes = parsePaneListResult(listResult);
165
+ const paneIds = new Set(panes.map((pane) => pane.paneId));
166
+ const namesByPane = new Map(
167
+ parseAgentListResult(agentResult)
168
+ .filter((pane) => pane.workspaceId === currentPane.workspaceId && paneIds.has(pane.paneId))
169
+ .map((pane) => [pane.paneId, pane.agentName]),
170
+ );
169
171
  const withAgentName = (pane: HerdrPane): HerdrPane => ({
170
172
  ...pane,
171
173
  agentName: namesByPane.get(pane.paneId) ?? pane.agentName,
@@ -176,7 +178,7 @@ export function createHerdrWidgetObserver(options: HerdrObserverOptions): HerdrW
176
178
  }
177
179
  return {
178
180
  currentPane: withAgentName(currentPane),
179
- panes: parsePaneListResult(listResult).map(withAgentName),
181
+ panes: panes.map(withAgentName),
180
182
  workspace,
181
183
  };
182
184
  };
@@ -193,62 +195,27 @@ export function createHerdrWidgetObserver(options: HerdrObserverOptions): HerdrW
193
195
  const signal = attemptController.signal;
194
196
  let attemptActive = true;
195
197
  let subscription: HerdrSubscription | undefined;
196
- let refreshTask: Promise<void> | undefined;
198
+ let failure: Error | undefined;
199
+ let wake: (() => void) | undefined;
200
+ const wakeRefresh = () => {
201
+ const resolve = wake;
202
+ wake = undefined;
203
+ resolve?.();
204
+ };
205
+ signal.addEventListener("abort", wakeRefresh);
206
+ const failAttempt = (error: Error) => {
207
+ if (!attemptActive || signal.aborted) return;
208
+ failure = error;
209
+ if (owns(ctx, expectedGeneration)) clearWidget(ctx);
210
+ attemptController.abort(error);
211
+ };
197
212
  try {
198
213
  const discovered = await loadPaneSet(ctx, expectedGeneration, signal);
199
214
  if (!discovered) return;
200
215
  const subscribedFingerprint = subscriptionFingerprint(discovered.currentPane, discovered.panes);
201
216
  const model = new HerdrWidgetModel();
202
217
  model.reset(discovered.currentPane, discovered.panes, discovered.workspace);
203
- const pendingEvents: HerdrPaneEvent[] = [];
204
- const pendingStatusEvents: HerdrPaneEvent[] = [];
205
- let initialized = false;
206
- let topologyPending = false;
207
- let refreshingTopology = false;
208
- let refreshAgain = false;
209
- let rejectReconfigure!: (error: Error) => void;
210
- let reconfigureSettled = false;
211
- const reconfigure = new Promise<never>((_resolve, reject) => {
212
- rejectReconfigure = reject;
213
- });
214
- void reconfigure.catch(() => undefined);
215
- const failAttempt = (error: Error) => {
216
- if (reconfigureSettled) return;
217
- reconfigureSettled = true;
218
- rejectReconfigure(error);
219
- };
220
- const scheduleTopologyRefresh = () => {
221
- if (!initialized || !attemptActive || signal.aborted) return;
222
- if (refreshTask) {
223
- refreshAgain = true;
224
- return;
225
- }
226
- refreshTask = (async () => {
227
- do {
228
- refreshAgain = false;
229
- refreshingTopology = true;
230
- const refreshed = await loadPaneSet(ctx, expectedGeneration, signal);
231
- if (!refreshed || !attemptActive || signal.aborted) return;
232
- model.reset(refreshed.currentPane, refreshed.panes, refreshed.workspace);
233
- for (const event of pendingStatusEvents.splice(0)) {
234
- if (isRelevantEvent(model, event)) model.apply(event);
235
- }
236
- refreshingTopology = false;
237
- publish(ctx, model, expectedGeneration);
238
- if (subscriptionFingerprint(refreshed.currentPane, refreshed.panes) !== subscribedFingerprint) {
239
- failAttempt(new HerdrTopologyChangedError());
240
- return;
241
- }
242
- } while (refreshAgain && attemptActive && !signal.aborted);
243
- })()
244
- .catch((error) => {
245
- failAttempt(error instanceof Error ? error : new Error(String(error)));
246
- })
247
- .finally(() => {
248
- refreshingTopology = false;
249
- refreshTask = undefined;
250
- });
251
- };
218
+ let dirty = true;
252
219
 
253
220
  subscription = await subscribe(
254
221
  options.environment.socketEndpoint,
@@ -259,64 +226,51 @@ export function createHerdrWidgetObserver(options: HerdrObserverOptions): HerdrW
259
226
  },
260
227
  signal,
261
228
  (frame) => {
229
+ if (!attemptActive || !owns(ctx, expectedGeneration) || signal.aborted) return;
262
230
  const event = parseHerdrPaneEvent(frame);
263
- if (!initialized) {
264
- if (!event || !isRelevantEvent(model, event)) return;
265
- if (requiresResubscribe(event)) {
266
- topologyPending = true;
267
- return;
268
- }
269
- if (pendingEvents.length >= MAX_PENDING_EVENTS) {
270
- throw new Error("Too many Herdr events arrived during initialization");
271
- }
272
- pendingEvents.push(event);
273
- return;
274
- }
275
-
276
- if (!event || !owns(ctx, expectedGeneration) || signal.aborted || !isRelevantEvent(model, event)) {
277
- return;
278
- }
279
- if (requiresResubscribe(event)) {
280
- scheduleTopologyRefresh();
281
- return;
282
- }
283
- if (refreshingTopology) {
284
- if (pendingStatusEvents.length >= MAX_PENDING_EVENTS) {
285
- throw new Error("Too many Herdr status events arrived during refresh");
286
- }
287
- pendingStatusEvents.push(event);
288
- return;
289
- }
290
- model.apply(event);
291
- publish(ctx, model, expectedGeneration);
231
+ if (!event || !isRelevantEvent(model, event)) return;
232
+ dirty = true;
233
+ wakeRefresh();
292
234
  },
235
+ ).catch(async (error: unknown) => {
236
+ if (!owns(ctx, expectedGeneration) || signal.aborted) throw error;
237
+ // A pane can disappear between discovery and subscription acceptance.
238
+ // Verify a changed target set before exempting this from outage retries.
239
+ const latest = await loadPaneSet(ctx, expectedGeneration, signal);
240
+ if (latest && subscriptionFingerprint(latest.currentPane, latest.panes) !== subscribedFingerprint) {
241
+ throw new HerdrTopologyChangedError();
242
+ }
243
+ throw error;
244
+ });
245
+ void subscription.closed.then(
246
+ () => failAttempt(new Error("Herdr subscription ended")),
247
+ (error) => failAttempt(error instanceof Error ? error : new Error(String(error))),
293
248
  );
294
- if (!owns(ctx, expectedGeneration) || signal.aborted) return;
295
249
 
296
- const reconciled = await loadPaneSet(ctx, expectedGeneration, signal);
297
- if (!reconciled) return;
298
- model.reset(reconciled.currentPane, reconciled.panes, reconciled.workspace);
299
- for (const event of pendingEvents.splice(0)) {
300
- if (isRelevantEvent(model, event)) model.apply(event);
301
- }
302
- if (subscriptionFingerprint(reconciled.currentPane, reconciled.panes) !== subscribedFingerprint) {
303
- throw new HerdrTopologyChangedError();
250
+ while (owns(ctx, expectedGeneration) && !signal.aborted) {
251
+ dirty = false;
252
+ const refreshed = await loadPaneSet(ctx, expectedGeneration, signal);
253
+ if (!refreshed || signal.aborted) break;
254
+ // Events and reads have no common sequence boundary. Never replay event
255
+ // payloads over a read, or publish a read invalidated while in flight.
256
+ if (dirty) continue;
257
+ if (subscriptionFingerprint(refreshed.currentPane, refreshed.panes) !== subscribedFingerprint) {
258
+ throw new HerdrTopologyChangedError();
259
+ }
260
+ model.reset(refreshed.currentPane, refreshed.panes, refreshed.workspace);
261
+ publish(ctx, model, expectedGeneration);
262
+ await new Promise<void>((resolve) => {
263
+ wake = resolve;
264
+ if (dirty || signal.aborted) wakeRefresh();
265
+ });
304
266
  }
305
- initialized = true;
306
- publish(ctx, model, expectedGeneration);
307
- if (topologyPending) scheduleTopologyRefresh();
308
- await Promise.race([
309
- subscription.closed.then(() => {
310
- if (!signal.aborted) throw new Error("Herdr subscription ended");
311
- }),
312
- reconfigure,
313
- ]);
267
+ if (failure) throw failure;
314
268
  } finally {
315
269
  attemptActive = false;
316
270
  attemptController.abort(new DOMException("Herdr widget attempt ended", "AbortError"));
271
+ signal.removeEventListener("abort", wakeRefresh);
317
272
  sessionSignal.removeEventListener("abort", abortAttempt);
318
273
  subscription?.close();
319
- await Promise.allSettled(refreshTask ? [refreshTask] : []);
320
274
  }
321
275
  };
322
276
 
@@ -25,35 +25,24 @@ export interface HerdrWorkspace {
25
25
  }
26
26
 
27
27
  export type HerdrPaneEvent =
28
- | { type: "created"; pane: HerdrPane }
29
- | { type: "closed" | "exited"; paneId: string; workspaceId: string }
28
+ | { type: "created" | "updated"; pane: HerdrPane }
30
29
  | {
31
- type: "moved";
32
- pane: HerdrPane;
33
- previousPaneId: string;
34
- previousWorkspaceId: string;
35
- }
36
- | {
37
- type: "agent_detected";
30
+ type: "closed" | "exited" | "agent_detected" | "agent_status_changed";
38
31
  paneId: string;
39
32
  workspaceId: string;
40
- agent?: string;
41
- finalStatus?: HerdrAgentStatus;
42
- released: boolean;
43
33
  }
34
+ | { type: "workspace_renamed"; workspaceId: string }
44
35
  | {
45
- type: "agent_status_changed";
46
- paneId: string;
47
- workspaceId: string;
48
- agent?: string;
49
- agentStatus: HerdrAgentStatus;
50
- displayAgent?: string;
51
- stateLabels?: Record<string, string>;
52
- title?: string;
36
+ type: "moved";
37
+ pane: HerdrPane;
38
+ previousPaneId: string;
39
+ previousWorkspaceId: string;
53
40
  };
54
41
 
55
42
  const HERDR_WIDGET_TOPOLOGY_SUBSCRIPTIONS = [
56
43
  { type: "pane.created" },
44
+ { type: "pane.updated" },
45
+ { type: "workspace.renamed" },
57
46
  { type: "pane.closed" },
58
47
  { type: "pane.moved" },
59
48
  { type: "pane.exited" },
@@ -178,7 +167,13 @@ export function parseHerdrPaneEvent(value: unknown): HerdrPaneEvent | undefined
178
167
  }
179
168
  const data = value.data;
180
169
 
181
- if (value.event === "pane.agent_status_changed") {
170
+ if (value.event === "workspace_renamed") {
171
+ const workspaceId = requiredString(data.workspace_id);
172
+ if (!workspaceId || typeof data.label !== "string") return undefined;
173
+ return { type: "workspace_renamed", workspaceId };
174
+ }
175
+
176
+ if (value.event === "pane.agent_status_changed" || value.event === "pane_agent_status_changed") {
182
177
  const paneId = requiredString(data.pane_id);
183
178
  const workspaceId = requiredString(data.workspace_id);
184
179
  const status = agentStatus(data.agent_status);
@@ -187,17 +182,12 @@ export function parseHerdrPaneEvent(value: unknown): HerdrPaneEvent | undefined
187
182
  type: "agent_status_changed",
188
183
  paneId,
189
184
  workspaceId,
190
- agent: optionalString(data.agent),
191
- agentStatus: status,
192
- displayAgent: optionalString(data.display_agent),
193
- stateLabels: stringRecord(data.state_labels),
194
- title: optionalString(data.title),
195
185
  };
196
186
  }
197
187
 
198
- if (value.event === "pane_created") {
188
+ if (value.event === "pane_created" || value.event === "pane_updated") {
199
189
  const pane = parseHerdrPane(data.pane);
200
- return pane ? { type: "created", pane } : undefined;
190
+ return pane ? { type: value.event === "pane_created" ? "created" : "updated", pane } : undefined;
201
191
  }
202
192
  if (value.event === "pane_closed" || value.event === "pane_exited") {
203
193
  const paneId = requiredString(data.pane_id);
@@ -219,16 +209,15 @@ export function parseHerdrPaneEvent(value: unknown): HerdrPaneEvent | undefined
219
209
  if (value.event === "pane_agent_detected") {
220
210
  const paneId = requiredString(data.pane_id);
221
211
  const workspaceId = requiredString(data.workspace_id);
222
- if (!paneId || !workspaceId || typeof data.released !== "boolean") return undefined;
212
+ if (!paneId || !workspaceId || (data.released !== undefined && typeof data.released !== "boolean")) {
213
+ return undefined;
214
+ }
223
215
  const finalStatus = data.final_status === null ? undefined : agentStatus(data.final_status);
224
216
  if (data.final_status !== undefined && data.final_status !== null && !finalStatus) return undefined;
225
217
  return {
226
218
  type: "agent_detected",
227
219
  paneId,
228
220
  workspaceId,
229
- agent: optionalString(data.agent),
230
- finalStatus,
231
- released: data.released,
232
221
  };
233
222
  }
234
223
  return undefined;
@@ -1,7 +1,7 @@
1
1
  import type { Theme } from "@earendil-works/pi-coding-agent";
2
2
  import { EditorStatusWidget } from "@narumitw/pi-tui-kit/editor-status-widget";
3
3
  import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
4
- import type { HerdrAgentStatus, HerdrPane, HerdrPaneEvent, HerdrWorkspace } from "./herdr-protocol.js";
4
+ import type { HerdrAgentStatus, HerdrPane, HerdrWorkspace } from "./herdr-protocol.js";
5
5
 
6
6
  export const HERDR_WIDGET_KEY = "herdr:agents";
7
7
  export const MAX_HERDR_WIDGET_AGENTS = 5;
@@ -136,60 +136,6 @@ export class HerdrWidgetModel {
136
136
  return this.currentWorkspaceId === workspaceId;
137
137
  }
138
138
 
139
- apply(event: HerdrPaneEvent): void {
140
- if (event.type === "created") {
141
- this.panes.set(event.pane.paneId, observedPane(event.pane));
142
- return;
143
- }
144
- if (event.type === "closed" || event.type === "exited") {
145
- this.panes.delete(event.paneId);
146
- return;
147
- }
148
- if (event.type === "moved") {
149
- this.panes.delete(event.previousPaneId);
150
- this.panes.set(event.pane.paneId, observedPane(event.pane));
151
- if (this.currentPaneId === event.previousPaneId) {
152
- this.currentPaneId = event.pane.paneId;
153
- this.currentWorkspaceId = event.pane.workspaceId;
154
- this.workspace = { workspaceId: event.pane.workspaceId };
155
- }
156
- return;
157
- }
158
-
159
- const existing = this.panes.get(event.paneId);
160
- if (event.type === "agent_detected") {
161
- if (event.released || !event.agent) {
162
- if (existing) this.panes.set(event.paneId, { ...existing, agent: undefined });
163
- return;
164
- }
165
- this.panes.set(event.paneId, {
166
- ...(existing ?? {
167
- paneId: event.paneId,
168
- workspaceId: event.workspaceId,
169
- agentStatus: event.finalStatus ?? "unknown",
170
- stateLabels: {},
171
- }),
172
- agent: event.agent,
173
- agentStatus: event.finalStatus ?? existing?.agentStatus ?? "unknown",
174
- });
175
- return;
176
- }
177
- if (event.type !== "agent_status_changed") return;
178
-
179
- this.panes.set(event.paneId, {
180
- ...(existing ?? {
181
- paneId: event.paneId,
182
- workspaceId: event.workspaceId,
183
- stateLabels: {},
184
- }),
185
- agent: event.agent ?? existing?.agent,
186
- agentStatus: event.agentStatus,
187
- displayAgent: event.displayAgent ?? existing?.displayAgent,
188
- stateLabels: event.stateLabels ?? existing?.stateLabels ?? {},
189
- title: event.title ?? existing?.title,
190
- });
191
- }
192
-
193
139
  snapshot(): HerdrWidgetSnapshot | undefined {
194
140
  if (!this.currentPaneId || !this.currentWorkspaceId || !this.workspace) return undefined;
195
141
  const rows = [...this.panes.values()]