@elpapi42/pi-fleet 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/runtime.mjs

@@ -64,7 +64,7 @@ var PiProcess = class _PiProcess {
   #responses = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #exitListeners = /* @__PURE__ */ new Set();
-  #stdoutBuffer = "";
+  #stdoutBuffer = Buffer.alloc(0);
   #stderr = "";
   #stopping = false;
   #maxStdoutFrameBytes;
@@ -80,7 +80,6 @@ var PiProcess = class _PiProcess {
         stdio: ["pipe", "pipe", "pipe"]
       }
     );
-    this.#child.stdout.setEncoding("utf8");
     this.#child.stderr.setEncoding("utf8");
     this.#child.stdout.on("data", (chunk) => this.#consumeStdout(chunk));
     this.#child.stderr.on("data", (chunk) => {
@@ -136,11 +135,20 @@ var PiProcess = class _PiProcess {
     const response = new Promise((resolveResponse, rejectResponse) => {
       const timer = setTimeout(() => {
         this.#responses.delete(id);
-        rejectResponse(new Error(`Pi RPC request timed out. stderr: ${this.#stderr}`));
+        rejectResponse(new Error("Pi RPC request timed out"));
       }, timeoutMs);
       this.#responses.set(id, { resolve: resolveResponse, reject: rejectResponse, timer });
     });
-    await this.#write({ ...command, id });
+    try {
+      await this.#write({ ...command, id });
+    } catch (error) {
+      const waiter = this.#responses.get(id);
+      if (waiter !== void 0) {
+        clearTimeout(waiter.timer);
+        this.#responses.delete(id);
+        waiter.reject(error instanceof Error ? error : new Error("Pi RPC write failed"));
+      }
+    }
     const frame = await response;
     if (frame.success !== true)
       throw new Error(frame.error ?? `Pi rejected ${String(command.type)}`);
@@ -169,27 +177,29 @@ var PiProcess = class _PiProcess {
     await once(this.#child.stdin, "drain");
   }
   #consumeStdout(chunk) {
-    this.#stdoutBuffer += chunk;
+    this.#stdoutBuffer = Buffer.concat([this.#stdoutBuffer, chunk]);
     while (true) {
-      const newline = this.#stdoutBuffer.indexOf("\n");
+      const newline = this.#stdoutBuffer.indexOf(10);
       if (newline < 0) {
-        if (Buffer.byteLength(this.#stdoutBuffer) > this.#maxStdoutFrameBytes) {
+        if (this.#stdoutBuffer.length > this.#maxStdoutFrameBytes) {
           signalProcessTree(this.pid, "SIGTERM");
         }
         return;
       }
-      if (Buffer.byteLength(this.#stdoutBuffer.slice(0, newline)) > this.#maxStdoutFrameBytes) {
+      if (newline > this.#maxStdoutFrameBytes) {
         signalProcessTree(this.pid, "SIGTERM");
         return;
       }
-      const line = this.#stdoutBuffer.slice(0, newline).replace(/\r$/, "");
-      this.#stdoutBuffer = this.#stdoutBuffer.slice(newline + 1);
-      if (line.length === 0) continue;
+      let lineBytes = this.#stdoutBuffer.subarray(0, newline);
+      this.#stdoutBuffer = this.#stdoutBuffer.subarray(newline + 1);
+      if (lineBytes.at(-1) === 13) lineBytes = lineBytes.subarray(0, -1);
+      if (lineBytes.length === 0) continue;
       let frame;
       try {
+        const line = new TextDecoder("utf-8", { fatal: true }).decode(lineBytes);
         frame = JSON.parse(line);
       } catch {
-        this.#child.kill("SIGTERM");
+        signalProcessTree(this.pid, "SIGTERM");
         return;
       }
       if (frame.type === "extension_ui_request" && typeof frame.id === "string" && ["select", "confirm", "input", "editor"].includes(String(frame.method))) {
@@ -6533,12 +6543,12 @@ function handleConnection(socket, service, maxFrameBytes) {
       stopReading();
       void service.then((readyService) => dispatch(value, readyService, socket, abort.signal, maxFrameBytes)).catch((error) => {
         if (socket.destroyed) return;
-        const message = error instanceof Error ? error.message : "Internal runtime error";
+        const invalidRequest = error instanceof InvalidRequestError;
         writeJsonLine(socket, {
           v: PROTOCOL_VERSION,
           requestId: requestIdFrom(value),
           ok: false,
-          error: { code: "invalid_request", message }
+          error: invalidRequest ? { code: "invalid_request", message: error.message } : { code: "internal_error", message: "Pi Fleet encountered an internal error." }
         });
         socket.end();
       });
@@ -6556,7 +6566,14 @@ function handleConnection(socket, service, maxFrameBytes) {
   );
 }
 async function dispatch(value, service, socket, connectionSignal, maxFrameBytes) {
-  const request = parseProtocolRequest(value);
+  let request;
+  try {
+    request = parseProtocolRequest(value);
+  } catch (error) {
+    throw new InvalidRequestError(
+      error instanceof Error ? error.message : "Invalid protocol request"
+    );
+  }
   const operationId = request.operation?.operationId;
   let result;
   switch (request.method) {
@@ -6616,7 +6633,7 @@ async function dispatch(value, service, socket, connectionSignal, maxFrameBytes)
           });
           socket.end();
         }
-      } catch (error) {
+      } catch {
         if (!socket.destroyed) {
           writeJsonLine(socket, {
             v: PROTOCOL_VERSION,
@@ -6624,7 +6641,7 @@ async function dispatch(value, service, socket, connectionSignal, maxFrameBytes)
             stream: "error",
             error: {
               code: "session_changed",
-              message: error instanceof Error ? error.message : "Session watch failed."
+              message: "Pi session changed while watching."
             }
           });
           socket.end();
@@ -6648,10 +6665,10 @@ function asCreateInput(params) {
   const instructions = params.instructions;
   const piArgv = params.piArgv;
   if (instructions !== void 0 && typeof instructions !== "string") {
-    throw new Error("instructions must be a string");
+    throw new InvalidRequestError("instructions must be a string");
   }
   if (!Array.isArray(piArgv) || !piArgv.every((token) => typeof token === "string")) {
-    throw new Error("piArgv must be an array of strings");
+    throw new InvalidRequestError("piArgv must be an array of strings");
   }
   return { name, cwd, piArgv, ...instructions === void 0 ? {} : { instructions } };
 }
@@ -6663,13 +6680,17 @@ function asNamedInput(params) {
 }
 async function receiveWithTimeout(service, input, timeoutMs, connectionSignal) {
   const abort = new AbortController();
+  let timedOut = false;
   const onConnectionAbort = () => abort.abort();
   connectionSignal.addEventListener("abort", onConnectionAbort, { once: true });
-  const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => abort.abort(), timeoutMs);
+  const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    timedOut = true;
+    abort.abort();
+  }, timeoutMs);
   try {
     return await service.receive(input, abort.signal);
   } catch (error) {
-    if (abort.signal.aborted) {
+    if (timedOut) {
       return err({ code: "timeout", message: "Agent did not become idle before timeout." });
     }
     throw error;
@@ -6682,19 +6703,23 @@ function numberParam(params, key) {
   const value = params[key];
   if (value === void 0) return void 0;
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new Error(`${key} must be a non-negative number`);
+    throw new InvalidRequestError(`${key} must be a non-negative number`);
   }
   return value;
 }
 function stringParam(params, key) {
   const value = params[key];
-  if (typeof value !== "string") throw new Error(`${key} must be a string`);
+  if (typeof value !== "string") throw new InvalidRequestError(`${key} must be a string`);
   return value;
 }
 function requireOperation(operationId) {
-  if (operationId === void 0) throw new Error("Mutation requires operation identity");
+  if (operationId === void 0)
+    throw new InvalidRequestError("Mutation requires operation identity");
   return operationId;
 }
+var InvalidRequestError = class extends Error {
+  name = "InvalidRequestError";
+};
 function requestIdFrom(value) {
   if (typeof value !== "object" || value === null || !("requestId" in value)) return "unknown";
   return typeof value.requestId === "string" ? value.requestId : "unknown";
@@ -6918,16 +6943,17 @@ var AgentCoordinator = class {
     this.now = now;
     this.onProcessExit = onProcessExit;
     this.#unsubscribeFrame = process2.onFrame((frame) => {
-      if (frame.type === "agent_start") void this.#enqueue(() => this.#markWorking());
-      if (frame.type === "agent_settled") void this.#enqueue(() => this.#markIdle());
+      if (frame.type === "agent_start") this.#queueEvent(() => this.#markWorking());
+      if (frame.type === "agent_settled") this.#queueEvent(() => this.#markIdle());
     });
     this.#unsubscribeExit = process2.onExit((error) => {
-      void this.#enqueue(() => this.#handleProcessExit(error));
+      this.#queueEvent(() => this.#handleProcessExit(error));
     });
   }
   #idleWaiters = /* @__PURE__ */ new Set();
   #lane = Promise.resolve();
   #stopReason = null;
+  #handlingFailure = false;
   #unsubscribeFrame;
   #unsubscribeExit;
   get storedAgent() {
@@ -7101,6 +7127,17 @@ var AgentCoordinator = class {
     }
     this.#idleWaiters.clear();
   }
+  #queueEvent(operation) {
+    void this.#enqueue(operation).catch((error) => this.#handleEventFailure(error));
+  }
+  async #handleEventFailure(error) {
+    if (this.#handlingFailure) return;
+    this.#handlingFailure = true;
+    const failure = error instanceof Error ? error : new Error("Agent coordinator failed");
+    this.#rejectIdleWaiters(failure);
+    await this.process.stop().catch(() => void 0);
+    this.onProcessExit(failure);
+  }
   #enqueue(operation) {
     const result = this.#lane.then(operation, operation);
     this.#lane = result.then(
@@ -7253,6 +7290,7 @@ var FleetService = class {
   #coordinators = /* @__PURE__ */ new Map();
   #watchers = /* @__PURE__ */ new Map();
   #processSlots = /* @__PURE__ */ new Set();
+  #agentLanes = /* @__PURE__ */ new Map();
   #sendLanes = /* @__PURE__ */ new Map();
   #launcher;
   #now;
@@ -7262,7 +7300,7 @@ var FleetService = class {
       operationId,
       "create",
       input,
-      () => this.#createImpl(input, operationId)
+      () => this.#enqueueAgent(input.name, () => this.#createImpl(input, operationId))
     );
   }
   async #createImpl(input, operationId) {
@@ -7462,14 +7500,19 @@ var FleetService = class {
       const code = cleanupUncertain ? "incarnation_cleanup_uncertain" : deliveryAmbiguous ? "delivery_uncertain" : "pi_start_failed";
       const result = err({
         code,
-        message: error instanceof Error ? error.message : "Pi failed to start."
+        message: code === "delivery_uncertain" ? "Pi may have accepted the initial instructions; Fleet will not replay them automatically." : code === "incarnation_cleanup_uncertain" ? "Fleet could not prove the Pi process group was removed." : "Pi failed to start."
       });
       await this.#remember(operationId, "create", input, result);
       return result;
     }
   }
   send(input, operationId) {
-    return this.#runOperation(operationId, "send", input, () => this.#sendImpl(input, operationId));
+    return this.#runOperation(
+      operationId,
+      "send",
+      input,
+      () => this.#enqueueAgent(input.name, () => this.#sendImpl(input, operationId))
+    );
   }
   async #sendImpl(input, operationId) {
     const replay = await this.#operation(operationId, "send", input);
@@ -7569,7 +7612,22 @@ var FleetService = class {
   }
   async receive(input, signal) {
     const coordinator = this.#coordinators.get(input.name);
-    const agent = coordinator === void 0 ? await this.store.getAgent(input.name) : await coordinator.waitForIdle(signal);
+    let agent;
+    try {
+      agent = coordinator === void 0 ? await this.store.getAgent(input.name) : await coordinator.waitForIdle(signal);
+    } catch (error) {
+      if (signal?.aborted === true) throw error;
+      if (error instanceof Error && error.message === "Agent destroyed") {
+        return err({ code: "agent_destroyed", message: `Agent ${input.name} was destroyed.` });
+      }
+      if (error instanceof Error && error.message === "Pi work was interrupted") {
+        return err({
+          code: "runtime_interrupted",
+          message: `Agent ${input.name} was interrupted before becoming idle.`
+        });
+      }
+      throw error;
+    }
     if (agent === null) return this.#notFound(input.name);
     if (agent.latestAssistantText === null || agent.responseObservedAt === null) {
       return err({
@@ -7634,7 +7692,7 @@ var FleetService = class {
       operationId,
       "destroy",
       input,
-      () => this.#destroyImpl(input, operationId)
+      () => this.#enqueueAgent(input.name, () => this.#destroyImpl(input, operationId))
     );
   }
   async #destroyImpl(input, operationId) {
@@ -7781,7 +7839,7 @@ var FleetService = class {
         agent: { id: agent.summary.id, name: agent.summary.name },
         acceptedAt
       });
-    } catch (error) {
+    } catch {
       if (!this.#coordinators.has(input.name)) this.#releaseProcessSlot(input.name);
       if (incarnationId !== null && !this.#coordinators.has(input.name)) {
         await this.store.putIncarnation({
@@ -7801,7 +7859,7 @@ var FleetService = class {
       });
       return err({
         code: "delivery_uncertain",
-        message: error instanceof Error ? error.message : "Pi delivery became uncertain."
+        message: "Pi may have accepted the message; Fleet will not replay it automatically."
       });
     }
   }
@@ -7830,6 +7888,9 @@ var FleetService = class {
     this.#coordinators.set(agent.summary.name, coordinator);
     return coordinator;
   }
+  #enqueueAgent(name, operation) {
+    return enqueueNamed(this.#agentLanes, name, operation);
+  }
   #enqueueSend(name, operation) {
     const previous = this.#sendLanes.get(name) ?? Promise.resolve();
     const result = previous.then(operation, operation);
@@ -7955,6 +8016,18 @@ var FleetService = class {
           }
           return null;
         } else {
+          const send = await this.store.getSend(operationId);
+          if (send === null) {
+            await this.store.deleteOperation(operationId);
+            await this.store.putOperation({
+              operationId,
+              method,
+              fingerprint,
+              state: "pending",
+              result: null
+            });
+            return null;
+          }
           return err({
             code: "operation_in_progress",
             message: `Operation ${operationId} is still pending.`
@@ -7998,6 +8071,19 @@ var FleetService = class {
     });
   }
 };
+function enqueueNamed(lanes, name, operation) {
+  const previous = lanes.get(name) ?? Promise.resolve();
+  const result = previous.then(operation, operation);
+  const settled = result.then(
+    () => void 0,
+    () => void 0
+  );
+  lanes.set(name, settled);
+  void settled.finally(() => {
+    if (lanes.get(name) === settled) lanes.delete(name);
+  });
+  return result;
+}
 async function* watchWithCleanup(subscription, cleanup) {
   try {
     yield* subscription;
@@ -8013,19 +8099,24 @@ var WorkerFleetStore = class {
   #worker;
   #pending = /* @__PURE__ */ new Map();
   #closed = false;
+  #failure = null;
   constructor(path, workerUrl = new URL("./sqlite-worker.mjs", import.meta.url)) {
     this.#worker = new Worker(workerUrl, { workerData: { path } });
-    this.#worker.on("message", (response) => {
-      const pending = this.#pending.get(response.id);
+    this.#worker.on("message", (value) => {
+      if (!isWorkerResponse(value)) {
+        this.#fail(new Error("SQLite worker returned a malformed response"));
+        void this.#worker.terminate();
+        return;
+      }
+      const pending = this.#pending.get(value.id);
       if (pending === void 0) return;
-      this.#pending.delete(response.id);
-      if (response.ok) pending.resolve(response.value);
-      else pending.reject(new Error(response.error ?? "SQLite worker failed"));
+      this.#pending.delete(value.id);
+      if (value.ok) pending.resolve(value.value);
+      else pending.reject(new Error(value.error ?? "SQLite worker failed"));
     });
-    this.#worker.on("error", (error) => this.#rejectAll(error));
+    this.#worker.on("error", (error) => this.#fail(error));
     this.#worker.on("exit", (code) => {
-      if (!this.#closed)
-        this.#rejectAll(new Error(`SQLite worker exited unexpectedly with ${code}`));
+      if (!this.#closed) this.#fail(new Error(`SQLite worker exited unexpectedly with ${code}`));
     });
   }
   createAgent(agent) {
@@ -8075,12 +8166,13 @@ var WorkerFleetStore = class {
   }
   async close(cleanShutdown = true) {
     if (this.#closed) return;
-    await this.#call("close", [cleanShutdown]);
+    if (this.#failure === null) await this.#call("close", [cleanShutdown]);
     this.#closed = true;
     await this.#worker.terminate();
   }
   #call(method, args) {
     if (this.#closed) return Promise.reject(new Error("Fleet store is closed"));
+    if (this.#failure !== null) return Promise.reject(this.#failure);
     const id = randomUUID3();
     const result = new Promise((resolveCall, rejectCall) => {
       this.#pending.set(id, {
@@ -8088,14 +8180,25 @@ var WorkerFleetStore = class {
         reject: rejectCall
       });
     });
-    this.#worker.postMessage({ id, method, args });
+    try {
+      this.#worker.postMessage({ id, method, args });
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error("SQLite worker request failed");
+      this.#fail(failure);
+    }
     return result;
   }
-  #rejectAll(error) {
-    for (const pending of this.#pending.values()) pending.reject(error);
+  #fail(error) {
+    this.#failure ??= error;
+    for (const pending of this.#pending.values()) pending.reject(this.#failure);
     this.#pending.clear();
   }
 };
+function isWorkerResponse(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const response = value;
+  return typeof response.id === "string" && typeof response.ok === "boolean" && (response.error === void 0 || typeof response.error === "string");
+}
 
 // src/entry/runtime.ts
 async function runRuntime() {