pi-claude-supervisor 0.4.0 → 0.5.0

package/src/worker/process-adapter.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { spawn, type ChildProcess } from "node:child_process";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import type {
@@ -25,6 +25,8 @@ export interface ProcessWorkerAdapterOptions {
   maxOutputChunks?: number;
   /** Maximum UTF-8 bytes of captured output retained per worker. */
   maxOutputBytes?: number;
+  /** Maximum UTF-8 bytes retained for an incomplete Claude JSONL record. */
+  maxProtocolBufferBytes?: number;
   /** Maximum time a blocked stdin write may hold lifecycle operations. */
   inputWriteTimeoutMs?: number;
   /** Linux descendant cleanup mode; auto uses cgroup v2 when available. */
@@ -43,7 +45,12 @@ interface ProcessRecord {
   lastInputAt?: string;
   activeRequests: number;
   turnSequence: number;
+  requestSequence: number;
+  activeRequestSequence?: number;
+  seenResultIds: Set<string>;
+  seenPermissionRequestIds: Set<string>;
   protocolBuffer: string;
+  discardProtocolLine: boolean;
   exitCode?: number | null;
   signal?: NodeJS.Signals;
   spawnError?: Error;
@@ -83,6 +90,7 @@ export class ProcessWorkerAdapter implements WorkerAdapter {
   readonly #killGraceMs: number;
   readonly #maxOutputChunks: number;
   readonly #maxOutputBytes: number;
+  readonly #maxProtocolBufferBytes: number;
   readonly #inputWriteTimeoutMs: number;
   readonly #cgroupMode: "off" | "auto" | "required";
   readonly #cgroupParentPath?: string;
@@ -93,6 +101,7 @@ export class ProcessWorkerAdapter implements WorkerAdapter {
     this.#killGraceMs = boundedDelay(options.killGraceMs ?? 500);
     this.#maxOutputChunks = boundedPositiveInteger(options.maxOutputChunks ?? 10_000, "maxOutputChunks");
     this.#maxOutputBytes = boundedPositiveInteger(options.maxOutputBytes ?? 8 * 1024 * 1024, "maxOutputBytes");
+    this.#maxProtocolBufferBytes = boundedPositiveInteger(options.maxProtocolBufferBytes ?? 256 * 1024, "maxProtocolBufferBytes");
     this.#inputWriteTimeoutMs = boundedDelay(options.inputWriteTimeoutMs ?? 10_000);
     this.#cgroupMode = options.cgroupMode ?? "auto";
     this.#cgroupParentPath = options.cgroupParentPath;
@@ -140,7 +149,12 @@ export class ProcessWorkerAdapter implements WorkerAdapter {
       outputTruncated: false,
       activeRequests: input.task ? 1 : 0,
       turnSequence: 0,
+      requestSequence: input.task ? 1 : 0,
+      activeRequestSequence: input.task ? 1 : undefined,
+      seenResultIds: new Set(),
+      seenPermissionRequestIds: new Set(),
       protocolBuffer: "",
+      discardProtocolLine: false,
       exited,
       resolveExit,
       sentKeys: new Set(),
@@ -366,7 +380,10 @@ export class ProcessWorkerAdapter implements WorkerAdapter {
       if (record.stopping) throw new Error("worker is stopping");
       if (record.sentKeys.has(idempotencyKey)) return;
       if (record.exitCode !== undefined) throw new Error("worker is not running");
-      if (this.#mode === "claude-jsonl") record.activeRequests += 1;
+      if (this.#mode === "claude-jsonl") {
+        record.activeRequests += 1;
+        record.activeRequestSequence = ++record.requestSequence;
+      }
       try {
         await this.#writeInput(record, this.#encodeMessage(message));
       } catch (error) {
@@ -454,41 +471,76 @@ export class ProcessWorkerAdapter implements WorkerAdapter {
   }
 
   #observeJsonl(record: ProcessRecord, chunk: string): void {
-    record.protocolBuffer += chunk;
-    let newline = record.protocolBuffer.indexOf("\n");
-    while (newline >= 0) {
-      const line = record.protocolBuffer.slice(0, newline).trim();
-      record.protocolBuffer = record.protocolBuffer.slice(newline + 1);
-      if (line) {
-        try {
-          const event = JSON.parse(line) as Record<string, unknown>;
-          this.#emit(record, { type: "jsonl", handle: record.handle, record: event });
-          if (event.type === "control_request") {
-            const request = event.request;
-            if (isPermissionRequest(event, request)) {
-              this.#emit(record, {
-                type: "permission_request",
-                handle: record.handle,
-                request: {
-                  requestId: String(event.request_id),
-                  toolUseId: request.tool_use_id,
-                  toolName: request.tool_name,
-                  input: request.input,
-                  raw: event,
-                },
-              });
-            }
-          }
-          if (event.type === "result") {
-            record.activeRequests = Math.max(0, record.activeRequests - 1);
-            record.turnSequence += 1;
-            this.#emit(record, { type: "turn_completed", handle: record.handle, result: event, sequence: record.turnSequence });
+    let offset = 0;
+    while (offset < chunk.length) {
+      if (record.discardProtocolLine) {
+        const newline = chunk.indexOf("\n", offset);
+        if (newline < 0) return;
+        record.discardProtocolLine = false;
+        record.protocolBuffer = "";
+        offset = newline + 1;
+        continue;
+      }
+      const newline = chunk.indexOf("\n", offset);
+      if (newline < 0) {
+        const tail = chunk.slice(offset);
+        if (Buffer.byteLength(record.protocolBuffer, "utf8") + Buffer.byteLength(tail, "utf8") > this.#maxProtocolBufferBytes) {
+          record.protocolBuffer = "";
+          record.discardProtocolLine = true;
+          record.outputTruncated = true;
+        } else {
+          record.protocolBuffer += tail;
+        }
+        return;
+      }
+      const linePart = chunk.slice(offset, newline);
+      if (Buffer.byteLength(record.protocolBuffer, "utf8") + Buffer.byteLength(linePart, "utf8") > this.#maxProtocolBufferBytes) {
+        record.outputTruncated = true;
+      } else {
+        this.#processJsonlLine(record, `${record.protocolBuffer}${linePart}`.trim());
+      }
+      record.protocolBuffer = "";
+      offset = newline + 1;
+    }
+  }
+
+  #processJsonlLine(record: ProcessRecord, line: string): void {
+    if (!line) return;
+    try {
+      const event = JSON.parse(line) as Record<string, unknown>;
+      this.#emit(record, { type: "jsonl", handle: record.handle, record: event });
+      if (event.type === "control_request") {
+        const request = event.request;
+        if (isPermissionRequest(event, request)) {
+          const requestId = String(event.request_id);
+          if (!record.seenPermissionRequestIds.has(requestId)) {
+            rememberBounded(record.seenPermissionRequestIds, requestId);
+            this.#emit(record, {
+              type: "permission_request",
+              handle: record.handle,
+              request: {
+                requestId,
+                toolUseId: request.tool_use_id,
+                toolName: request.tool_name,
+                input: request.input,
+                raw: event,
+              },
+            });
           }
-        } catch {
-          // Keep raw output for diagnostics; malformed output is not a completion signal.
         }
       }
-      newline = record.protocolBuffer.indexOf("\n");
+      if (event.type === "result" && record.activeRequests > 0) {
+        const resultId = jsonlRecordId(event, record.activeRequestSequence);
+        if (!record.seenResultIds.has(resultId)) {
+          rememberBounded(record.seenResultIds, resultId);
+          record.activeRequests = Math.max(0, record.activeRequests - 1);
+          record.activeRequestSequence = undefined;
+          record.turnSequence += 1;
+          this.#emit(record, { type: "turn_completed", handle: record.handle, result: event, sequence: record.turnSequence });
+        }
+      }
+    } catch {
+      // Keep raw output for diagnostics; malformed output is not a completion signal.
     }
   }
 
@@ -665,6 +717,23 @@ async function cleanupCgroup(path: string, graceMs: number): Promise<void> {
   throw new Error(`worker cgroup ${path} did not empty before cleanup deadline`);
 }
 
+function rememberBounded(values: Set<string>, value: string, limit = 2_000): void {
+  values.add(value);
+  while (values.size > limit) {
+    const first = values.values().next().value;
+    if (first === undefined) break;
+    values.delete(first);
+  }
+}
+
+function jsonlRecordId(record: Record<string, unknown>, requestSequence?: number): string {
+  for (const key of ["uuid", "request_id"]) {
+    if (typeof record[key] === "string" && record[key]) return `${key}:${record[key]}`;
+  }
+  const digest = createHash("sha256").update(JSON.stringify(record)).digest("hex").slice(0, 32);
+  return `request:${requestSequence ?? "unknown"}:${digest}`;
+}
+
 function isPermissionRequest(event: Record<string, unknown>, request: unknown): request is { subtype: "can_use_tool"; tool_use_id: string; tool_name: string; input: unknown } {
   if (event.type !== "control_request" || typeof event.request_id !== "string" || !request || typeof request !== "object") return false;
   const value = request as { subtype?: unknown; tool_use_id?: unknown; tool_name?: unknown; input?: unknown };

package/src/worker/tmux-adapter.ts

@@ -264,10 +264,16 @@ export class TmuxWorkerAdapter implements WorkerAdapter {
         const pane = await this.#paneStatus(record);
         record.paneDead = pane.dead;
         record.panePid = pane.pid;
-        if (!pane.dead) await this.#rememberPaneIdentity(record, pane.pid);
+        if (pane.dead) record.cleanupError = undefined;
+        else await this.#rememberPaneIdentity(record, pane.pid);
       } catch (error) {
-        if (isMissingSession(error) || isPaneIdentityError(error)) record.paneDead = true;
-        else record.cleanupError = asError(error);
+        if (isMissingSession(error)) {
+          record.paneDead = true;
+          record.cleanupError = undefined;
+        } else if (isPaneIdentityError(error)) {
+          record.paneDead = false;
+          record.cleanupError = asError(error);
+        } else record.cleanupError = asError(error);
       }
       return this.#status(record, !record.paneDead);
     }
@@ -284,10 +290,11 @@ export class TmuxWorkerAdapter implements WorkerAdapter {
     } catch (error) {
       if (isMissingSession(error)) {
         record.paneDead = true;
+        record.cleanupError = undefined;
         if (!record.cleanupComplete && record.owned) await this.#cleanup(record, false);
       } else {
         record.cleanupError = asError(error);
-        if (isPaneIdentityError(error)) record.paneDead = true;
+        if (isPaneIdentityError(error)) record.paneDead = false;
       }
     }
     return this.#status(record, !record.paneDead && !record.released);
@@ -485,7 +492,7 @@ export class TmuxWorkerAdapter implements WorkerAdapter {
   #startMonitor(record: TmuxRecord): void {
     record.monitor = setInterval(() => {
       void this.#monitor(record).catch((error) => {
-        if (isPaneIdentityError(error)) record.paneDead = true;
+        if (isPaneIdentityError(error)) record.paneDead = false;
         if (!record.cleanupComplete && !isMissingSession(error)) record.cleanupError = asError(error);
       });
     }, this.#pollIntervalMs);