@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.
- package/README.md +17 -9
- package/dist/index.ts +145 -237
- package/dist/index.ts.map +2 -2
- package/package.json +4 -4
- package/src/herdr-agent-state.ts +38 -21
- package/src/herdr-client.ts +44 -53
- package/src/herdr-observer.ts +62 -108
- package/src/herdr-protocol.ts +21 -32
- package/src/herdr-widget.ts +1 -55
package/src/herdr-agent-state.ts
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
335
|
-
|
|
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 (
|
|
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 =
|
|
408
|
-
|
|
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
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
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 (
|
|
440
|
+
if (!stillOwnsShutdown()) {
|
|
424
441
|
return;
|
|
425
442
|
}
|
|
426
443
|
lastMetadataSnapshot = undefined;
|
package/src/herdr-client.ts
CHANGED
|
@@ -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
|
-
|
|
55
|
-
|
|
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
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
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
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
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
|
-
|
|
97
|
-
|
|
98
|
-
|
|
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", () =>
|
|
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", () =>
|
|
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 (
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
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;
|
package/src/herdr-observer.ts
CHANGED
|
@@ -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"
|
|
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
|
|
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:
|
|
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
|
|
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
|
-
|
|
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 (!
|
|
264
|
-
|
|
265
|
-
|
|
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
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
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
|
-
|
|
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
|
|
package/src/herdr-protocol.ts
CHANGED
|
@@ -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: "
|
|
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: "
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
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 === "
|
|
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")
|
|
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;
|
package/src/herdr-widget.ts
CHANGED
|
@@ -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,
|
|
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()]
|