@cueloop/daemon 0.1.0-alpha.12 → 0.1.0-alpha.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -9,7 +9,7 @@
     "./review": "./src/review.ts"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.12",
+    "@cueloop/schema": "0.1.0-alpha.14",
     "valibot": "^1.4.2"
   },
   "publishConfig": {

package/src/client.ts

@@ -6,7 +6,7 @@
 
 import { existsSync, rmSync } from "node:fs";
 import type { Annotation, Artifact, ReviewSession, VerdictKind, WorkspaceKey } from "@cueloop/schema";
-import { LineBuffer, type EventFrame, type Response } from "./protocol";
+import { BackpressureWriter, LineBuffer, type EventFrame, type Response } from "./protocol";
 import { cueloopHome, socketPath } from "./paths";
 
 export interface ConnectOptions {
@@ -19,6 +19,7 @@ type Pending = { resolve: (v: unknown) => void; reject: (e: Error) => void };
 
 export class DaemonClient {
   private socket: Awaited<ReturnType<typeof Bun.connect>> | null = null;
+  private writer: BackpressureWriter | null = null;
   private pending = new Map<number, Pending>();
   private nextId = 1;
   private eventListeners = new Set<(e: EventFrame) => void>();
@@ -62,6 +63,9 @@ export class DaemonClient {
         data(_socket, data) {
           buffer.push(data.toString(), (line) => self.handleFrame(line));
         },
+        drain() {
+          self.writer?.drain();
+        },
         close() {
           self.closed = true;
           for (const p of self.pending.values()) p.reject(new Error("daemon connection closed"));
@@ -70,6 +74,7 @@ export class DaemonClient {
         error() {},
       },
     });
+    this.writer = new BackpressureWriter(this.socket);
     // Verify liveness: a dead socket file accepts connects on some platforms
     // only to fail later, so a ping is the actual handshake.
     await this.request("daemon.ping", {}, 2_000);
@@ -116,7 +121,7 @@ export class DaemonClient {
           reject(e);
         },
       });
-      this.socket!.write(JSON.stringify({ id, method, params }) + "\n");
+      this.writer!.write(JSON.stringify({ id, method, params }) + "\n");
     });
   }
 

package/src/protocol.ts

@@ -38,3 +38,40 @@ export class LineBuffer {
     }
   }
 }
+
+/** The surface both Bun.listen and Bun.connect sockets satisfy. */
+interface WritableSocket {
+  write(data: Buffer): number;
+}
+
+/**
+ * Outbound writes honoring socket backpressure. A frame larger than the
+ * kernel buffer is written partially by the socket; the unwritten tail must
+ * wait for the drain callback or the frame truncates mid-line and the NDJSON
+ * stream corrupts for good. Frames never reorder: while a tail is pending,
+ * new writes append behind it.
+ */
+export class BackpressureWriter {
+  private pending: Buffer | null = null;
+
+  constructor(private socket: WritableSocket) {}
+
+  write(data: string): void {
+    const bytes = Buffer.from(data, "utf8");
+    if (this.pending) {
+      this.pending = Buffer.concat([this.pending, bytes]);
+      return;
+    }
+    const written = Math.max(0, this.socket.write(bytes));
+    if (written < bytes.length) this.pending = bytes.subarray(written);
+  }
+
+  /** Call from the socket's drain handler. */
+  drain(): void {
+    if (!this.pending) return;
+    const tail = this.pending;
+    this.pending = null;
+    const written = Math.max(0, this.socket.write(tail));
+    if (written < tail.length) this.pending = tail.subarray(written);
+  }
+}

package/src/server.test.ts

@@ -112,3 +112,21 @@ describe("socket round-trip", () => {
     second.close();
   });
 });
+
+describe("large payloads survive socket backpressure", () => {
+  test("a session bigger than the kernel socket buffer round-trips", async () => {
+    // Regression: responses larger than one socket write used to truncate
+    // mid-line because the write return value was ignored, so the client
+    // never saw the frame's newline and every later request wedged too.
+    const bigContent = "# Big plan\n" + "lorem ipsum dolor sit amet, consectetur adipiscing elit\n".repeat(4000);
+    const created = await client.sessionCreate(
+      { repoRoot: "/repo", branch: "main" },
+      { type: "plan", content: bigContent, meta: { title: "big" } },
+    );
+    const fetched = await client.sessionGet(created.id);
+    expect(fetched.artifact.content).toBe(bigContent);
+    // the connection must still be usable for the next frame
+    const listed = await client.sessionList();
+    expect(listed.some((session) => session.id === created.id)).toBe(true);
+  }, 15_000);
+});

package/src/server.ts

@@ -8,7 +8,7 @@ import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, rm
 import { DaemonCore, type DaemonEvent } from "./api";
 import { DaemonError } from "./errors";
 import { isKnownMethod, parseParams } from "./validate";
-import { LineBuffer, type Request } from "./protocol";
+import { BackpressureWriter, LineBuffer, type Request } from "./protocol";
 import { cueloopHome, lockPath, pidPath, socketPath } from "./paths";
 
 interface Conn {
@@ -119,12 +119,13 @@ export class DaemonServer {
     // socket file left behind is stale
     if (existsSync(path)) rmSync(path, { force: true });
     const self = this;
-    this.server = Bun.listen<{ buffer: LineBuffer; conn: Conn }>({
+    this.server = Bun.listen<{ buffer: LineBuffer; conn: Conn; writer: BackpressureWriter }>({
       unix: path,
       socket: {
         open(socket) {
-          const conn: Conn = { write: (d) => socket.write(d), subscribed: false };
-          socket.data = { buffer: new LineBuffer(), conn };
+          const writer = new BackpressureWriter(socket);
+          const conn: Conn = { write: (data) => writer.write(data), subscribed: false };
+          socket.data = { buffer: new LineBuffer(), conn, writer };
           self.conns.add(conn);
           self.scheduleIdleCheck();
         },
@@ -133,6 +134,11 @@ export class DaemonServer {
             void self.handleLine(socket.data.conn, line);
           });
         },
+        drain(socket) {
+          // drain can fire before open has attached data on some platforms;
+          // a throw here would take the whole daemon down with the socket
+          socket.data?.writer.drain();
+        },
         close(socket) {
           self.conns.delete(socket.data.conn);
           self.scheduleIdleCheck();