@selesai/code 0.8.3 → 0.8.4

package/dist/extensions/pi-intercom/broker/client-liveness.test.ts

@@ -0,0 +1,173 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import net from "node:net";
+import { once } from "node:events";
+import { mkdtempSync, rmSync } from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { IntercomClient } from "./client.ts";
+import { writeMessage } from "./framing.ts";
+
+/**
+ * Unit tests for the half-open socket fix.
+ *
+ * Bug: when the broker dies without sending a FIN (SIGKILL, crash, host loss),
+ * the client's socket stays "writable" indefinitely. isConnected() keeps
+ * returning true, no "disconnected" event fires, and the extension's
+ * scheduleReconnect() is never called — so the agent silently drops out of the
+ * intercom roster forever (this is why long-lived headless/RPC pi agents
+ * vanish from `intercom list` after a broker restart).
+ *
+ * The fix: (1) a socket "error" after registration destroys the socket so the
+ * existing onClose -> "disconnected" path runs, and (2) a liveness heartbeat
+ * that round-trips a lightweight request and tears down the socket on timeout
+ * or write error, so a half-open connection is detected within a bounded
+ * window even when the OS never delivers an error.
+ */
+
+const homeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-liveness-unit-"));
+const runtimeAgentDir = process.platform === "win32" ? undefined : mkdtempSync("/tmp/piic-");
+const previousHome = process.env.HOME;
+const previousUserProfile = process.env.USERPROFILE;
+const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+if (runtimeAgentDir) process.env.SELESAI_CODING_AGENT_DIR = runtimeAgentDir;
+process.env.PI_INTERCOM_LIVENESS_INTERVAL_MS = "100";
+process.env.PI_INTERCOM_LIVENESS_TIMEOUT_MS = "200";
+
+test.after(() => {
+  process.env.HOME = previousHome;
+  process.env.USERPROFILE = previousUserProfile;
+  if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+  else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+  rmSync(homeDir, { recursive: true, force: true });
+  if (runtimeAgentDir) rmSync(runtimeAgentDir, { recursive: true, force: true });
+});
+
+/**
+ * Build a registered IntercomClient wired to a fake server socket pair, so we
+ * can simulate a half-open connection without spawning a real broker.
+ */
+async function registeredClientAgainstFakeSocket(): Promise<{
+  client: IntercomClient;
+  serverSide: net.Socket;
+  closeServerSideAbruptly(): void;
+  stopResponding(): void;
+}> {
+  const { getBrokerSocketPath } = await import("./paths.ts");
+  const { mkdirSync, unlinkSync } = await import("node:fs");
+  const socketPath = getBrokerSocketPath();
+  const intercomDir = path.dirname(socketPath);
+  mkdirSync(intercomDir, { recursive: true });
+  try { unlinkSync(socketPath); } catch { /* no stale socket */ }
+
+  const client = new IntercomClient();
+  let resolveReady: (value: { serverSide: net.Socket; closeServerSideAbruptly(): void; stopResponding(): void }) => void;
+  let rejectReady: (reason: unknown) => void;
+  const ready = new Promise<{ serverSide: net.Socket; closeServerSideAbruptly(): void; stopResponding(): void }>((res, rej) => {
+    resolveReady = res;
+    rejectReady = rej;
+  });
+
+  let responding = true;
+  const server = net.createServer((serverSide) => {
+    serverSide.on("data", (data) => {
+      if (!responding) return; // simulate a dead/unresponsive broker: drop everything
+      try {
+        const len = data.readUInt32BE(0);
+        const json = JSON.parse(data.subarray(4, 4 + len).toString("utf-8"));
+        if (json.type === "register") {
+          writeMessage(serverSide, { type: "registered", sessionId: json.sessionId ?? "stable-test", features: [] });
+        }
+        if (json.type === "list") {
+          writeMessage(serverSide, { type: "sessions", requestId: json.requestId, sessions: [] });
+        }
+      } catch {
+        // ignore parse errors in the fake
+      }
+    });
+    server.close();
+    resolveReady({
+      serverSide,
+      closeServerSideAbruptly() {
+        // Destroy WITHOUT a clean FIN — simulates a SIGKILL'd broker peer.
+        serverSide.destroy();
+      },
+      stopResponding() {
+        // Simulate a half-open socket: the peer stops reading/replying but the
+        // connection is not closed, so no "close"/"error" event reaches the
+        // client. Only an active liveness probe can detect this.
+        responding = false;
+      },
+    });
+  });
+  server.on("error", (err) => rejectReady(err));
+  await new Promise<void>((resolve) => server.listen(socketPath, () => resolve()));
+
+  await client.connect(
+    {
+      name: "liveness-unit",
+      cwd: homeDir,
+      model: "test-model",
+      pid: process.pid,
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+    },
+    "stable-liveness-unit",
+  );
+  const { serverSide, closeServerSideAbruptly, stopResponding } = await ready;
+  return { client, serverSide, closeServerSideAbruptly, stopResponding };
+}
+
+test("client emits disconnected when the peer destroys the socket without a FIN", async () => {
+  const { client, closeServerSideAbruptly } = await registeredClientAgainstFakeSocket();
+  try {
+    assert.equal(client.isConnected(), true, "client should be connected after register");
+
+    const disconnected = once(client, "disconnected");
+    closeServerSideAbruptly();
+
+    const event = await Promise.race([
+      disconnected,
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () => reject(new Error("client never noticed the abruptly-closed peer (half-open socket)")),
+          3000,
+        ),
+      ),
+    ]);
+    assert.ok(event, "expected a disconnected event");
+    assert.equal(client.isConnected(), false);
+  } finally {
+    await client.disconnect().catch(() => undefined);
+  }
+});
+
+test("client liveness heartbeat detects a half-open socket within a bounded window", async () => {
+  const { client, stopResponding } = await registeredClientAgainstFakeSocket();
+  try {
+    assert.equal(client.isConnected(), true);
+
+    const disconnected = once(client, "disconnected");
+    // Simulate a half-open socket: the peer stops replying but does NOT close
+    // the connection. No "close"/"error" event reaches the client, so passive
+    // detection cannot fire — only the liveness heartbeat can notice.
+    stopResponding();
+
+    // The heartbeat (interval ~100ms, timeout ~200ms) must notice and tear down.
+    const event = await Promise.race([
+      disconnected,
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () => reject(new Error("liveness heartbeat did not detect the half-open socket within 3s")),
+          3000,
+        ),
+      ),
+    ]);
+    assert.ok(event, "expected the heartbeat to surface a disconnected event");
+    assert.equal(client.isConnected(), false);
+  } finally {
+    await client.disconnect().catch(() => undefined);
+  }
+});

package/dist/extensions/pi-intercom/broker/client.ts

@@ -3,6 +3,7 @@ import net from "net";
 import { randomUUID } from "crypto";
 import { writeMessage, createMessageReader } from "./framing.ts";
 import { getBrokerConnectTarget, type BrokerConnectTarget } from "./paths.ts";
+import { isMessage, isMessageControl, isMessageReceipt, isSessionInfo } from "./protocol.ts";
 import { EXTENSION_BUS_FEATURE } from "../types.ts";
 import type {
   Attachment,
@@ -11,7 +12,6 @@ import type {
   Message,
   MessageControl,
   MessageReceipt,
-  MessageReceiptStatus,
   SessionInfo,
   SessionRegistration,
 } from "../types.ts";
@@ -36,156 +36,28 @@ function toError(error: unknown): Error {
   return error instanceof Error ? error : new Error(String(error));
 }
 
-function connectToBrokerTarget(target: BrokerConnectTarget): net.Socket {
-  return typeof target === "string"
-    ? net.connect(target)
-    : net.connect({ host: target.host, port: target.port });
-}
-
-function isMessageReceiptStatus(value: unknown): value is MessageReceiptStatus {
-  return value === "receiver_received"
-    || value === "queued"
-    || value === "injected"
-    || value === "acknowledged"
-    || value === "expired"
-    || value === "cancelled"
-    || value === "superseded"
-    || value === "cancellation_requested";
-}
-
-function isMessageReceipt(value: unknown): value is MessageReceipt {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const receipt = value as Record<string, unknown>;
-  if (typeof receipt.messageId !== "string" || !isMessageReceiptStatus(receipt.status) || typeof receipt.timestamp !== "number") {
-    return false;
-  }
-  return receipt.detail === undefined || typeof receipt.detail === "string";
+/**
+ * Liveness heartbeat interval. A half-open socket (peer killed with SIGKILL or
+ * crashed without sending a FIN) stays "writable" indefinitely, so passive
+ * close-event detection never fires and the client silently drops out of the
+ * roster. The heartbeat actively round-trips a lightweight request and tears
+ * down the socket if the broker does not respond within the timeout, letting
+ * the existing onClose -> "disconnected" path drive reconnection.
+ */
+function getLivenessIntervalMs(): number {
+  const raw = Number.parseInt(process.env.PI_INTERCOM_LIVENESS_INTERVAL_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
 }
 
-function isMessageControl(value: unknown): value is MessageControl {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const control = value as Record<string, unknown>;
-  if (typeof control.messageId !== "string" || typeof control.timestamp !== "number") {
-    return false;
-  }
-  if (control.action !== "cancel" && control.action !== "supersede") {
-    return false;
-  }
-  if (control.supersededBy !== undefined && typeof control.supersededBy !== "string") {
-    return false;
-  }
-  return control.detail === undefined || typeof control.detail === "string";
-}
-
-function isAttachment(value: unknown): value is Attachment {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const attachment = value as Record<string, unknown>;
-
-  if (
-    attachment.type !== "file"
-    && attachment.type !== "snippet"
-    && attachment.type !== "context"
-  ) {
-    return false;
-  }
-
-  if (typeof attachment.name !== "string" || typeof attachment.content !== "string") {
-    return false;
-  }
-
-  return attachment.language === undefined || typeof attachment.language === "string";
+function getLivenessTimeoutMs(): number {
+  const raw = Number.parseInt(process.env.PI_INTERCOM_LIVENESS_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, getLivenessIntervalMs()) : 5_000;
 }
 
-function isMessage(value: unknown): value is Message {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const message = value as Record<string, unknown>;
-
-  if (typeof message.id !== "string" || typeof message.timestamp !== "number") {
-    return false;
-  }
-
-  for (const key of ["senderSequence", "brokerReceivedAt", "brokerDeliveredAt", "receiverReceivedAt", "injectedAt"] as const) {
-    if (message[key] !== undefined && typeof message[key] !== "number") {
-      return false;
-    }
-  }
-
-  if (message.supersedes !== undefined && typeof message.supersedes !== "string") {
-    return false;
-  }
-
-  if (message.retryOf !== undefined && typeof message.retryOf !== "string") {
-    return false;
-  }
-
-  if (message.replyTo !== undefined && typeof message.replyTo !== "string") {
-    return false;
-  }
-
-  if (message.expectsReply !== undefined && typeof message.expectsReply !== "boolean") {
-    return false;
-  }
-
-  if (typeof message.content !== "object" || message.content === null) {
-    return false;
-  }
-
-  const content = message.content as Record<string, unknown>;
-  if (typeof content.text !== "string") {
-    return false;
-  }
-
-  return content.attachments === undefined
-    || (Array.isArray(content.attachments) && content.attachments.every(isAttachment));
-}
-
-function isSessionInfo(value: unknown): value is SessionInfo {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const session = value as Record<string, unknown>;
-
-  if (
-    typeof session.id !== "string"
-    || typeof session.cwd !== "string"
-    || typeof session.model !== "string"
-    || typeof session.pid !== "number"
-    || typeof session.startedAt !== "number"
-    || typeof session.lastActivity !== "number"
-  ) {
-    return false;
-  }
-
-  if (session.name !== undefined && typeof session.name !== "string") {
-    return false;
-  }
-
-  if (session.status !== undefined && typeof session.status !== "string") {
-    return false;
-  }
-
-  if (session.peerUid !== undefined && typeof session.peerUid !== "number") {
-    return false;
-  }
-
-  for (const key of ["contextPct", "contextTokens", "contextWindow"] as const) {
-    if (session[key] !== undefined && typeof session[key] !== "number") {
-      return false;
-    }
-  }
-
-  return session.trustedLocal === undefined || typeof session.trustedLocal === "boolean";
+function connectToBrokerTarget(target: BrokerConnectTarget): net.Socket {
+  return typeof target === "string"
+    ? net.connect(target)
+    : net.connect({ host: target.host, port: target.port });
 }
 
 export class IntercomClient extends EventEmitter {
@@ -197,6 +69,8 @@ export class IntercomClient extends EventEmitter {
   private nextSenderSequence = 1;
   private disconnecting = false;
   private disconnectError: Error | null = null;
+  private livenessTimer: NodeJS.Timeout | null = null;
+  private livenessInFlight = false;
 
   private failPending(error: Error): void {
     for (const pending of this.pendingSends.values()) {
@@ -222,6 +96,50 @@ export class IntercomClient extends EventEmitter {
     return Boolean(socket && this._sessionId && !this.disconnecting && !socket.destroyed && !socket.writableEnded && socket.writable);
   }
 
+  /**
+   * Start the liveness heartbeat. Must be called once the connection is
+   * registered. The heartbeat periodically round-trips a lightweight list
+   * request and tears down the socket if the broker does not respond within
+   * the liveness timeout, so a half-open connection is detected within a
+   * bounded window instead of silently lingering forever.
+   */
+  private startLivenessHeartbeat(): void {
+    this.stopLivenessHeartbeat();
+    this.livenessTimer = setInterval(() => {
+      this.runLivenessProbe();
+    }, getLivenessIntervalMs());
+    this.livenessTimer.unref?.();
+  }
+
+  private stopLivenessHeartbeat(): void {
+    if (this.livenessTimer) {
+      clearInterval(this.livenessTimer);
+      this.livenessTimer = null;
+    }
+    this.livenessInFlight = false;
+  }
+
+  private async runLivenessProbe(): Promise<void> {
+    if (this.livenessInFlight || !this.isConnected()) {
+      return;
+    }
+    this.livenessInFlight = true;
+    try {
+      await this.listSessions({ timeoutMs: getLivenessTimeoutMs() });
+    } catch (error) {
+      // A timeout or write error means the socket is half-open: the broker is
+      // gone but the OS never delivered a close event. Destroy the socket so
+      // the onClose handler emits "disconnected" and the extension reconnects.
+      const socket = this.socket;
+      if (socket && !socket.destroyed) {
+        this.disconnectError = toError(error);
+        socket.destroy();
+      }
+    } finally {
+      this.livenessInFlight = false;
+    }
+  }
+
   private requireActiveSocket(): net.Socket {
     if (this.disconnecting) {
       throw new Error("Client disconnecting");
@@ -275,6 +193,7 @@ export class IntercomClient extends EventEmitter {
         settled = true;
         connectionEstablished = true;
         cleanupConnectionAttempt();
+        this.startLivenessHeartbeat();
         resolve();
       };
       
@@ -294,6 +213,7 @@ export class IntercomClient extends EventEmitter {
         const wasDisconnecting = this.disconnecting;
         const disconnectError = this.disconnectError ?? new Error("Client disconnected");
         this.disconnecting = false;
+        this.stopLivenessHeartbeat();
         cleanupConnectionAttempt();
         cleanupSocketListeners();
         this.failPending(disconnectError);
@@ -315,6 +235,13 @@ export class IntercomClient extends EventEmitter {
         if (connectionEstablished) {
           this.disconnectError = err;
           this.emit("error", err);
+          // A socket error after registration means the connection is dead.
+          // Destroy the socket so onClose fires and emits "disconnected",
+          // driving the extension's reconnect path. Without this, a half-open
+          // socket can linger with isConnected() returning true.
+          if (!socket.destroyed) {
+            socket.destroy();
+          }
         }
       };
 
@@ -609,6 +536,7 @@ export class IntercomClient extends EventEmitter {
 
     this.disconnecting = true;
     this.disconnectError = null;
+    this.stopLivenessHeartbeat();
     this.failPending(new Error("Client disconnected"));
 
     await new Promise<void>((resolve) => {
@@ -650,7 +578,7 @@ export class IntercomClient extends EventEmitter {
     writeMessage(socket, { type: "extension_capabilities_update", extensions: extensions ?? [] });
   }
 
-  listSessions(): Promise<SessionInfo[]> {
+  listSessions(options: { timeoutMs?: number } = {}): Promise<SessionInfo[]> {
     let socket: net.Socket;
     try {
       socket = this.requireActiveSocket();
@@ -673,7 +601,7 @@ export class IntercomClient extends EventEmitter {
           this.pendingLists.delete(requestId);
           wrappedReject(new Error("List sessions timeout"));
         }
-      }, 5000);
+      }, options.timeoutMs ?? 5000);
       this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject });
       try {
         writeMessage(socket, { type: "list", requestId });
@@ -800,7 +728,7 @@ export class IntercomClient extends EventEmitter {
     }
   }
 
-  updatePresence(updates: { name?: string; status?: string; model?: string; contextPct?: number | null; contextTokens?: number | null; contextWindow?: number | null }): void {
+  updatePresence(updates: { name?: string; runtimeFallbackAlias?: boolean; status?: string; model?: string; contextPct?: number | null; contextTokens?: number | null; contextWindow?: number | null }): void {
     if (this.disconnecting) {
       return;
     }

package/dist/extensions/pi-intercom/broker/extension-state.ts

@@ -15,7 +15,7 @@ import { dirname, join } from "node:path";
 
 const MAX_STATE_BYTES = 64 * 1024;
 
-export interface StateEnvelope {
+interface StateEnvelope {
   formatVersion: 1;
   namespace: string;
   revision: number;
@@ -74,23 +74,34 @@ export class ExtensionStateManager {
       if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 
       const envelope = value as Record<string, unknown>;
+      const revision = envelope.revision;
+      const updatedAt = envelope.updatedAt;
+      const payloadSha256 = envelope.payloadSha256;
       if (
         envelope.formatVersion !== 1
         || envelope.namespace !== namespace
-        || !Number.isSafeInteger(envelope.revision)
-        || (envelope.revision as number) < 0
-        || typeof envelope.updatedAt !== "number"
-        || typeof envelope.payloadSha256 !== "string"
+        || typeof revision !== "number"
+        || !Number.isSafeInteger(revision)
+        || revision < 0
+        || typeof updatedAt !== "number"
+        || typeof payloadSha256 !== "string"
       ) {
         return null;
       }
 
       const payloadJson = serializePayload(envelope.payload);
-      if (payloadJson === null || payloadHash(payloadJson) !== envelope.payloadSha256) {
+      if (payloadJson === null || payloadHash(payloadJson) !== payloadSha256) {
         return null;
       }
 
-      return envelope as unknown as StateEnvelope;
+      return {
+        formatVersion: 1,
+        namespace,
+        revision,
+        updatedAt,
+        payloadSha256,
+        payload: envelope.payload,
+      };
     } catch {
       return null;
     }

package/dist/extensions/pi-intercom/broker/framing.ts

@@ -1,6 +1,6 @@
 import type { Socket } from "net";
 
-export const MAX_FRAME_BYTES = 1024 * 1024;
+const MAX_FRAME_BYTES = 1024 * 1024;
 
 /**
  * Write a length-prefixed message to a socket.