@dorokuma/herdsman-pi 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorokuma/herdsman-pi",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Pi extension bridge for Herdsman agent history. Forked from @ryonakae/shepherd.",
   "type": "module",
   "keywords": [

package/src/daemon-client.ts

@@ -1,5 +1,5 @@
 import { createConnection, type Socket } from "node:net";
-import { JsonLineDecoder } from "@/shared/json-lines.js";
+import { JsonLineDecoder } from "./shared/json-lines.js";
 
 export type AgentEventWireRecord = {
   agentId?: string | null;

package/src/index.ts

@@ -45,6 +45,7 @@ type PiPresence = {
 
 type ConnectionStateResponse = {
   changed?: boolean;
+  ackedEventId?: number;
   context?: AgentWorkspaceContextSnapshot | null;
   events?: AgentEventWireRecord[];
   presence: PiPresence;
@@ -223,6 +224,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       state.runActive = false;
     };
 
+    const pruneAcknowledgedEvents = (ackedEventId: number | undefined) => {
+      if (ackedEventId === undefined) return;
+      state.pendingEvents = state.pendingEvents.filter((event) => event.id > ackedEventId);
+    };
+
     const applyOwnerContext = (response: ConnectionStateResponse) => {
       state.latestContext = isLocalOwner(response) ? response.context ?? undefined : undefined;
     };
@@ -448,6 +454,8 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
       applyOwnerContext(response);
       setHerdsmanUi(ctx);
       addPendingEvents(response.events ?? [], ctx);
+      pruneAcknowledgedEvents(response.state?.ackedEventId ?? response.ackedEventId);
+      setHerdsmanUi(ctx);
       scheduleWake(ctx);
     };
 
@@ -530,9 +538,11 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
               ? {
                   ...snapshot,
                   agents: snapshot.agents.filter((agent) => {
-                    const nextAgent = next?.agents.find((candidate) => candidate.paneId === agent.paneId);
-                    if (!nextAgent) return false;
-                    return !agent.id || !nextAgent.id || agent.id === nextAgent.id;
+                    const nextAgents = next?.agents.filter((candidate) => candidate.paneId === agent.paneId) ?? [];
+                    if (nextAgents.length === 0) return false;
+                    return nextAgents.some(
+                      (nextAgent) => !agent.id || !nextAgent.id || agent.id === nextAgent.id,
+                    );
                   }),
                 }
               : undefined;
@@ -762,10 +772,25 @@ export function createHerdsmanPiExtension(options: ExtensionOptions = {}) {
 
       for (const event of batch.events) {
         try {
-          await state.client.request("agent.notifications.ack", { eventId: event.id });
+          const ackResponse = (await state.client.request("agent.notifications.ack", {
+            eventId: event.id,
+          })) as { ackedEventId?: number; state?: { ackedEventId?: number } };
+          pruneAcknowledgedEvents(ackResponse?.ackedEventId ?? ackResponse?.state?.ackedEventId);
           state.pendingEvents = state.pendingEvents.filter((pending) => pending.id !== event.id);
           setHerdsmanUi(ctx);
-        } catch {
+        } catch (error) {
+          if (
+            error instanceof Error &&
+            /no longer pending|invalidated/i.test(error.message)
+          ) {
+            state.pendingEvents = state.pendingEvents.filter((pending) => pending.id > event.id);
+            state.failedWakeThroughEventId = Math.max(
+              state.failedWakeThroughEventId,
+              ...batch.events.map((batchEvent) => batchEvent.id),
+            );
+            setHerdsmanUi(ctx);
+            continue;
+          }
           // Keep the event pending so the next Herdsman round retries the acknowledgement.
           // Acknowledgement failure must not block delivery of the main turn.
           ctx.ui.notify?.(

package/src/shared/json-lines.ts

@@ -0,0 +1,46 @@
+export function encodeJsonLine(value: unknown): string {
+  const encoded = JSON.stringify(value);
+
+  if (encoded === undefined) {
+    throw new TypeError("JSON Lines values must be JSON-serializable");
+  }
+
+  return `${encoded}\n`;
+}
+
+export class JsonLineFrameTooLargeError extends Error {
+  constructor(readonly maxBytes: number) {
+    super(`JSON Lines frame exceeds maximum size of ${maxBytes} bytes`);
+    this.name = "JsonLineFrameTooLargeError";
+  }
+}
+
+export class JsonLineDecoder {
+  #buffer = "";
+  readonly #maxBytes: number;
+
+  constructor(maxBytes = 1024 * 1024) {
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0) {
+      throw new RangeError("JSON Lines maximum frame size must be a positive integer");
+    }
+    this.#maxBytes = maxBytes;
+  }
+
+  push(chunk: string): unknown[] {
+    this.#buffer += chunk;
+    if (Buffer.byteLength(this.#buffer, "utf8") > this.#maxBytes) {
+      throw new JsonLineFrameTooLargeError(this.#maxBytes);
+    }
+
+    const lines = this.#buffer.split("\n");
+    this.#buffer = lines.pop() ?? "";
+    return lines.filter((line) => line.length > 0).map((line) => JSON.parse(line));
+  }
+
+  flush(): unknown[] {
+    if (this.#buffer.length === 0) return [];
+    const line = this.#buffer;
+    this.#buffer = "";
+    return [JSON.parse(line)];
+  }
+}