@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/pi-intercom/broker/client.js

@@ -1,65 +1,37 @@
 import { EventEmitter } from "events";
-import net from "net";
 import { randomUUID } from "crypto";
-import { writeMessage, createMessageReader } from "./framing.js";
-import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
-import { compactTopicMessage, normalizeMessage, normalizeSessionInfo } from "../types.js";
+import { writeMessage } from "./framing.js";
+import { BrokerConnection, connectBrokerSocket } from "./connection.js";
+import { SnapshotReader } from "./snapshot-reader.js";
+import { errorMessage, isRecord, isUnknownArray, } from "../../shared/unknown.js";
+import { compactTopicMessage, normalizeMessage, normalizeSessionInfo, } from "../types.js";
 /** Default delivery-ack timeout for `send` (broker acknowledges quickly). */
 const DEFAULT_SEND_TIMEOUT_MS = 8000;
 /** Default timeout for `listSessions` responses. */
 const DEFAULT_LIST_TIMEOUT_MS = 5000;
 function toError(error) {
-    return error instanceof Error ? error : new Error(String(error));
+    return error instanceof Error ? error : new Error(errorMessage(error));
 }
-function connectSocket(socketPath, timeoutMs = 500) {
-    return new Promise((resolve, reject) => {
-        const socket = net.connect(socketPath);
-        const finish = (error) => {
-            clearTimeout(timeout);
-            socket.off("connect", onConnect);
-            socket.off("error", onError);
-            if (error) {
-                socket.destroy();
-                reject(error);
-            }
-            else {
-                resolve(socket);
-            }
-        };
-        const onConnect = () => finish();
-        const onError = (error) => finish(error);
-        socket.once("connect", onConnect);
-        socket.once("error", onError);
-        const timeout = setTimeout(() => finish(new Error(`Connection timeout: ${socketPath}`)), timeoutMs);
-        timeout.unref?.();
-    });
-}
-async function connectBrokerSocket() {
-    const preferred = getBrokerSocketPath();
-    const legacy = getLegacyBrokerSocketPath();
-    const candidates = [preferred, ...(legacy !== preferred ? [legacy] : [])];
-    let lastError;
-    for (const candidate of candidates) {
-        if (!isOwnedBrokerSocket(candidate))
-            continue;
-        try {
-            return await connectSocket(candidate);
-        }
-        catch (error) {
-            lastError = toError(error);
-        }
+function messageDelivery(options) {
+    if (options.delivery !== undefined) {
+        return options.delivery;
+    }
+    if (options.passive === true) {
+        return "passive";
     }
-    throw lastError ?? new Error(`Intercom broker socket is unavailable: ${preferred}`);
+    if (options.expectsReply === true) {
+        return;
+    }
+    return "steer";
 }
 export class IntercomClient extends EventEmitter {
-    socket = null;
+    connection = null;
     _sessionId = null;
     _topicsSupported = false;
     pendingSends = new Map();
     pendingLists = new Map();
     connecting = false;
     disconnecting = false;
-    disconnectError = null;
     sendTimeoutMs;
     listTimeoutMs;
     constructor(options = {}) {
@@ -80,308 +52,204 @@ export class IntercomClient extends EventEmitter {
     get sessionId() {
         return this._sessionId;
     }
-    get supportsTopics() { return this.isConnected() && this._topicsSupported; }
+    get supportsTopics() {
+        return this.isConnected() && this._topicsSupported;
+    }
     isConnected() {
-        const socket = this.socket;
-        return Boolean(socket && this._sessionId && !this.disconnecting && !socket.destroyed && !socket.writableEnded && socket.writable);
+        return ((this._sessionId ?? "").length > 0 &&
+            !this.disconnecting &&
+            this.connection?.isActive() === true);
     }
     requireActiveSocket() {
         if (this.disconnecting) {
             throw new Error("Client disconnecting");
         }
-        const socket = this.socket;
-        if (!socket || !this._sessionId) {
+        const connection = this.connection;
+        if (!connection || (this._sessionId ?? "").length === 0) {
             throw new Error("Not connected");
         }
-        if (socket.destroyed || socket.writableEnded || !socket.writable) {
+        if (!connection.isActive()) {
             throw new Error("Client disconnected");
         }
-        return socket;
+        return connection.socket;
     }
     async connect(session, requestedId) {
-        if (this.socket || this.connecting) {
+        if (this.connection || this.connecting) {
             throw new Error("Already connected");
         }
         this.connecting = true;
-        let socket;
         try {
-            socket = await connectBrokerSocket();
-        }
-        finally {
-            this.connecting = false;
-        }
-        const { topics, subscriptions, ...identity } = session;
-        await new Promise((resolve, reject) => {
-            this.socket = socket;
-            this.disconnectError = null;
-            let settled = false;
-            const timeout = setTimeout(() => {
-                if (!this._sessionId) {
-                    cleanupConnectionAttempt();
-                    cleanupSocketListeners();
-                    if (this.socket === socket) {
-                        this.socket = null;
+            const socket = await connectBrokerSocket();
+            const connection = new BrokerConnection(socket, {
+                message: (message) => this.handleBrokerMessage(message),
+                error: (error) => {
+                    this.emit("error", error);
+                },
+                closed: (error, expected) => {
+                    if (this.connection !== connection) {
+                        return;
                     }
-                    socket.destroy();
-                    reject(new Error("Connection timeout"));
-                }
-            }, 10000);
-            timeout.unref?.();
-            let connectionEstablished = false;
-            const onRegistered = () => {
-                settled = true;
-                connectionEstablished = true;
-                cleanupConnectionAttempt();
-                resolve();
-            };
-            const onError = (err) => {
-                settled = true;
-                cleanupConnectionAttempt();
-                cleanupSocketListeners();
-                if (this.socket === socket) {
-                    this.socket = null;
-                }
-                socket.destroy();
-                reject(err);
-            };
-            const onClose = () => {
-                const wasConnecting = !settled && !this._sessionId;
-                const wasDisconnecting = this.disconnecting;
-                const disconnectError = this.disconnectError ?? new Error("Client disconnected");
-                this.disconnecting = false;
-                cleanupConnectionAttempt();
-                cleanupSocketListeners();
-                this.failPending(disconnectError);
-                if (this.socket === socket) {
-                    this.socket = null;
-                }
-                this._sessionId = null;
-                this.disconnectError = null;
-                if (connectionEstablished && !wasDisconnecting) {
-                    this.emit("disconnected", disconnectError);
-                }
-                if (wasConnecting) {
-                    reject(new Error("Connection closed before registration"));
-                }
-            };
-            const onSocketError = (err) => {
-                if (connectionEstablished) {
-                    this.disconnectError = err;
-                    this.emit("error", err);
-                }
-            };
-            const onReaderError = (error) => {
-                const protocolError = new Error(`Intercom protocol error: ${error.message}`, { cause: error });
-                if (!connectionEstablished) {
-                    onError(protocolError);
-                    return;
-                }
-                this.disconnectError = protocolError;
-                this.emit("error", protocolError);
-                socket.destroy();
-            };
-            const reader = createMessageReader((msg) => {
-                this.handleBrokerMessage(msg);
-            }, onReaderError);
-            const cleanupConnectionAttempt = () => {
-                this.off("_registered", onRegistered);
-                socket.off("error", onError);
-                clearTimeout(timeout);
-            };
-            const cleanupSocketListeners = () => {
-                socket.off("data", reader);
-                socket.off("error", onSocketError);
-                socket.off("close", onClose);
-            };
-            socket.on("data", reader);
-            socket.on("error", onError);
-            socket.on("close", onClose);
-            socket.on("error", onSocketError);
-            this.once("_registered", onRegistered);
+                    const established = this._sessionId !== null;
+                    this.connection = null;
+                    this._sessionId = null;
+                    this._topicsSupported = false;
+                    this.disconnecting = false;
+                    this.failPending(error);
+                    if (established && !expected) {
+                        this.emit("disconnected", error);
+                    }
+                },
+            });
+            this.connection = connection;
+            const { topics, subscriptions, ...identity } = session;
             try {
-                writeMessage(socket, { type: "register", session: identity, requestedId, topicFrames: true });
+                await connection.start({
+                    type: "register",
+                    session: identity,
+                    requestedId,
+                    topicFrames: true,
+                });
             }
             catch (error) {
-                cleanupConnectionAttempt();
-                cleanupSocketListeners();
-                if (this.socket === socket) {
-                    this.socket = null;
+                if (this.connection === connection) {
+                    this.connection = null;
                 }
-                socket.destroy();
-                reject(toError(error));
+                throw error;
+            }
+            if (this.supportsTopics) {
+                await this.restoreTopics(topics, subscriptions);
             }
-        });
-        if (this.supportsTopics) {
-            for (const topic of topics ?? [])
-                await this.updateTopics({ action: "restore", topic });
-            for (const subscription of subscriptions ?? [])
-                await this.updateTopics({ action: "restore", subscription });
+        }
+        finally {
+            this.connecting = false;
+        }
+    }
+    async restoreTopics(topics, subscriptions) {
+        for (const topic of topics ?? []) {
+            // Restore frames are individually acknowledged to preserve order and bound socket payloads.
+            // oxlint-disable-next-line no-await-in-loop
+            await this.updateTopics({ action: "restore", topic });
+        }
+        for (const subscription of subscriptions ?? []) {
+            // Subscriptions are committed before connect resolves and subsequent messages can arrive.
+            // oxlint-disable-next-line no-await-in-loop
+            await this.updateTopics({ action: "restore", subscription });
         }
     }
     handleBrokerMessage(msg) {
-        if (typeof msg !== "object" || msg === null || !("type" in msg) || typeof msg.type !== "string") {
+        if (!isRecord(msg) || typeof msg.type !== "string") {
             throw new Error("Invalid broker message");
         }
         const brokerMessage = msg;
-        if (this._sessionId === null && brokerMessage.type !== "registered") {
-            throw new Error(`Received ${brokerMessage.type} before registered`);
+        const type = msg.type;
+        if (this._sessionId === null && type !== "registered") {
+            throw new Error(`Received ${type} before registered`);
         }
-        switch (brokerMessage.type) {
-            case "registered": {
-                if (typeof brokerMessage.sessionId !== "string") {
-                    throw new Error("Invalid registered message");
-                }
-                if (this._sessionId !== null) {
-                    throw new Error("Received duplicate registered message");
-                }
-                this._sessionId = brokerMessage.sessionId;
-                this._topicsSupported = brokerMessage.topicsSupported === true && brokerMessage.topicFrames === true;
-                this.emit("_registered", { type: "registered", sessionId: brokerMessage.sessionId });
-                break;
-            }
-            case "sessions": {
-                const { requestId, sessions, receipts, more, error } = brokerMessage;
-                if (typeof requestId !== "string" || !Array.isArray(sessions) || (more !== undefined && typeof more !== "boolean"))
-                    throw new Error("Invalid sessions message");
-                const pending = this.pendingLists.get(requestId);
-                if (!pending)
-                    return;
-                if (typeof error === "string") {
-                    this.pendingLists.delete(requestId);
-                    pending.reject(new Error(error));
-                    break;
-                }
-                for (const row of sessions) {
-                    if (!row || typeof row.id !== "string" || (row.topics !== undefined && !Array.isArray(row.topics)) || (row.subscriptions !== undefined && !Array.isArray(row.subscriptions)))
-                        throw new Error("Invalid session snapshot row");
-                    const previous = pending.sessions.get(row.id);
-                    const info = normalizeSessionInfo({ ...previous, ...row,
-                        ...(row.topics ? { topics: [...(previous?.topics ?? []), ...row.topics] } : {}),
-                        ...(row.subscriptions ? { subscriptions: [...(previous?.subscriptions ?? []), ...row.subscriptions] } : {}),
-                    });
-                    if (!info)
-                        throw new Error("Invalid session snapshot");
-                    pending.sessions.set(info.id, info);
-                }
-                if (receipts !== undefined) {
-                    if (!Array.isArray(receipts) || receipts.some((receipt) => !receipt || typeof receipt.to !== "string" || typeof receipt.id !== "string" || typeof receipt.accepted !== "boolean" || typeof receipt.delivered !== "boolean"))
-                        throw new Error("Invalid topic delivery receipts");
-                    pending.receipts.push(...receipts);
-                }
-                if (more !== true) {
-                    this.pendingLists.delete(requestId);
-                    pending.resolve({ sessions: [...pending.sessions.values()], receipts: pending.receipts });
-                }
+        switch (type) {
+            case "registered":
+                this.receiveRegistration(brokerMessage);
                 break;
-            }
-            case "message": {
-                const { from } = brokerMessage;
-                const message = normalizeMessage(brokerMessage.message);
-                const normalizedFrom = normalizeSessionInfo(from);
-                if (!normalizedFrom || !message) {
-                    throw new Error("Invalid message event");
-                }
-                this.emit("message", normalizedFrom, message);
+            case "sessions":
+                this.receiveSessions(brokerMessage);
                 break;
-            }
-            case "delivered": {
-                const { messageId } = brokerMessage;
-                if (typeof messageId !== "string") {
-                    throw new Error("Invalid delivered message");
-                }
-                const pending = this.pendingSends.get(messageId);
-                if (!pending) {
-                    // Late send responses are harmless once the caller has already timed out.
-                    return;
-                }
-                this.pendingSends.delete(messageId);
-                pending.resolve({ id: messageId, accepted: true, delivered: true });
+            case "message":
+                this.receiveMessage(brokerMessage);
                 break;
-            }
-            case "delivery_queued": {
-                const { messageId, reason } = brokerMessage;
-                if (typeof messageId !== "string" || typeof reason !== "string") {
-                    throw new Error("Invalid delivery_queued message");
-                }
-                const pending = this.pendingSends.get(messageId);
-                if (!pending) {
-                    // Late send responses are harmless once the caller has already timed out.
-                    return;
-                }
-                this.pendingSends.delete(messageId);
-                pending.resolve({ id: messageId, accepted: true, delivered: false, queued: true, reason });
-                break;
-            }
-            case "delivery_failed": {
-                const { messageId, reason } = brokerMessage;
-                if (typeof messageId !== "string" || typeof reason !== "string") {
-                    throw new Error("Invalid delivery_failed message");
-                }
-                const pending = this.pendingSends.get(messageId);
-                if (!pending) {
-                    // Late send responses are harmless once the caller has already timed out.
-                    return;
-                }
-                this.pendingSends.delete(messageId);
-                pending.resolve({ id: messageId, accepted: false, delivered: false, reason });
+            case "delivered":
+            case "delivery_queued":
+            case "delivery_failed":
+                this.receiveDelivery(brokerMessage);
                 break;
-            }
-            case "session_left": {
+            case "session_left":
                 if (typeof brokerMessage.sessionId !== "string") {
                     throw new Error("Invalid session_left message");
                 }
                 this.emit("session_left", brokerMessage.sessionId);
                 break;
-            }
             default:
-                throw new Error(`Unknown broker message type: ${brokerMessage.type}`);
+                throw new Error(`Unknown broker message type: ${type}`);
+        }
+    }
+    receiveRegistration(msg) {
+        if (typeof msg.sessionId !== "string") {
+            throw new Error("Invalid registered message");
+        }
+        if (this._sessionId !== null) {
+            throw new Error("Received duplicate registered message");
+        }
+        this._sessionId = msg.sessionId;
+        this._topicsSupported = msg.topicsSupported === true && msg.topicFrames === true;
+        this.connection?.confirmRegistration();
+        this.emit("_registered", { type: "registered", sessionId: msg.sessionId });
+    }
+    receiveMessage(msg) {
+        const message = normalizeMessage(msg.message);
+        const from = normalizeSessionInfo(msg.from);
+        if (!from || !message) {
+            throw new Error("Invalid message event");
+        }
+        this.emit("message", from, message);
+    }
+    receiveDelivery(msg) {
+        const { messageId, reason, type } = msg;
+        if (typeof messageId !== "string") {
+            throw new Error(`Invalid ${errorMessage(type)} message`);
+        }
+        if (type !== "delivered" && typeof reason !== "string") {
+            throw new Error(`Invalid ${errorMessage(type)} message`);
+        }
+        const pending = this.pendingSends.get(messageId);
+        // Late responses are harmless after the caller has timed out.
+        if (!pending) {
+            return;
+        }
+        this.pendingSends.delete(messageId);
+        pending.resolve({
+            id: messageId,
+            accepted: type !== "delivery_failed",
+            delivered: type === "delivered",
+            ...(type === "delivery_queued" ? { queued: true } : {}),
+            ...(typeof reason === "string" && type !== "delivered" ? { reason } : {}),
+        });
+    }
+    receiveSessions(brokerMessage) {
+        const { requestId, sessions, receipts, more, error } = brokerMessage;
+        if (typeof requestId !== "string" ||
+            !isUnknownArray(sessions) ||
+            (more !== undefined && typeof more !== "boolean")) {
+            throw new Error("Invalid sessions message");
+        }
+        const pending = this.pendingLists.get(requestId);
+        if (!pending) {
+            return;
+        }
+        if (typeof error === "string") {
+            this.pendingLists.delete(requestId);
+            pending.reject(new Error(error));
+            return;
+        }
+        pending.reader.append(sessions, receipts);
+        if (more !== true) {
+            this.pendingLists.delete(requestId);
+            pending.resolve(pending.reader.finish());
         }
     }
     async disconnect() {
-        const socket = this.socket;
-        if (!socket) {
+        const connection = this.connection;
+        if (!connection) {
             return;
         }
         this.disconnecting = true;
-        this.disconnectError = null;
         this.failPending(new Error("Client disconnected"));
-        await new Promise((resolve) => {
-            let settled = false;
-            const finish = () => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                clearTimeout(timeout);
-                socket.off("close", onClose);
-                socket.off("error", onError);
-                resolve();
-            };
-            const onClose = () => finish();
-            const onError = () => {
-                socket.destroy();
-            };
-            const timeout = setTimeout(() => {
-                socket.destroy();
-            }, 2000);
-            socket.once("close", onClose);
-            socket.once("error", onError);
-            try {
-                writeMessage(socket, { type: "unregister" });
-                socket.end();
-            }
-            catch {
-                // Disconnect should still finish even if the unregister write fails.
-                socket.destroy();
-            }
-        });
+        await connection.disconnect();
     }
     listSessions() {
-        return this.requestSessions().then((snapshot) => snapshot.sessions);
+        return this.requestSessions().then((snapshot) => [...snapshot.sessions]);
     }
     updateTopics(change, onAccepted) {
-        if (!this.supportsTopics)
+        if (!this.supportsTopics) {
             return Promise.reject(new Error("This broker does not support topic snapshots."));
+        }
         return this.requestSessions(change, onAccepted);
     }
     requestSessions(change, onAccepted) {
@@ -415,10 +283,19 @@ export class IntercomClient extends EventEmitter {
                     wrappedReject(new Error("List sessions timeout"));
                 }
             }, this.listTimeoutMs);
-            timeout.unref?.();
-            this.pendingLists.set(requestId, { resolve: wrappedResolve, reject: wrappedReject, sessions: new Map(), receipts: [] });
+            timeout.unref();
+            this.pendingLists.set(requestId, {
+                resolve: wrappedResolve,
+                reject: wrappedReject,
+                reader: new SnapshotReader(),
+            });
             try {
-                writeMessage(socket, { type: "list", requestId, stream: true, ...(change ? { change } : {}) });
+                writeMessage(socket, {
+                    type: "list",
+                    requestId,
+                    stream: true,
+                    ...(change ? { change } : {}),
+                });
             }
             catch (error) {
                 clearTimeout(timeout);
@@ -443,7 +320,7 @@ export class IntercomClient extends EventEmitter {
             expectsReply: options.expectsReply,
             ...(options.human ? { human: options.human } : {}),
             ...(options.topic ? { topic: options.topic } : {}),
-            delivery: options.delivery ?? (options.passive === true ? "passive" : options.expectsReply === true ? undefined : "steer"),
+            delivery: messageDelivery(options),
             queueMode: options.queueMode,
             threadId: options.threadId,
             passive: options.passive,
@@ -467,10 +344,14 @@ export class IntercomClient extends EventEmitter {
                     wrappedReject(new Error("Send timeout"));
                 }
             }, this.sendTimeoutMs);
-            timeout.unref?.();
+            timeout.unref();
             this.pendingSends.set(messageId, { resolve: wrappedResolve, reject: wrappedReject });
             try {
-                writeMessage(socket, { type: "send", to, message: this._topicsSupported ? compactTopicMessage(message) : message });
+                writeMessage(socket, {
+                    type: "send",
+                    to,
+                    message: this._topicsSupported ? compactTopicMessage(message) : message,
+                });
             }
             catch (error) {
                 clearTimeout(timeout);
@@ -483,8 +364,12 @@ export class IntercomClient extends EventEmitter {
         if (this.disconnecting) {
             return;
         }
-        const socket = this.socket;
-        if (!socket || !this._sessionId || socket.destroyed || socket.writableEnded || !socket.writable) {
+        const socket = this.connection?.socket;
+        if (!socket ||
+            (this._sessionId ?? "").length === 0 ||
+            socket.destroyed ||
+            socket.writableEnded ||
+            !socket.writable) {
             return;
         }
         writeMessage(socket, { type: "presence", ...updates });