@gugu910/pi-slack-bridge 0.1.3

package/dist/broker/client.js

@@ -0,0 +1,495 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokerClient = exports.HEARTBEAT_INTERVAL_MS = exports.MAX_RECONNECT_DELAY_MS = exports.INITIAL_RECONNECT_DELAY_MS = exports.RECONNECT_DELAY_MS = exports.REQUEST_TIMEOUT_MS = exports.DEFAULT_SOCKET_PATH = void 0;
+exports.computeReconnectDelay = computeReconnectDelay;
+const net = __importStar(require("node:net"));
+const auth_js_1 = require("./auth.js");
+const paths_js_1 = require("./paths.js");
+const types_js_1 = require("./types.js");
+// ─── Constants (exported for testing) ────────────────────
+exports.DEFAULT_SOCKET_PATH = paths_js_1.DEFAULT_SOCKET_PATH;
+exports.REQUEST_TIMEOUT_MS = 5000;
+exports.RECONNECT_DELAY_MS = 3000;
+exports.INITIAL_RECONNECT_DELAY_MS = 1000;
+exports.MAX_RECONNECT_DELAY_MS = 30000;
+exports.HEARTBEAT_INTERVAL_MS = 5000;
+/** Compute reconnect delay with exponential backoff and jitter. */
+function computeReconnectDelay(attempt, random = Math.random()) {
+    const baseDelay = exports.INITIAL_RECONNECT_DELAY_MS * Math.pow(2, attempt);
+    const capped = Math.min(baseDelay, exports.MAX_RECONNECT_DELAY_MS);
+    // Add jitter: ±25%
+    const jitter = capped * (0.75 + random * 0.5);
+    return Math.round(jitter);
+}
+function createRpcRequestError(method, error) {
+    const err = new Error(error.message);
+    err.name = "BrokerRpcRequestError";
+    err.code = error.code;
+    err.data = error.data;
+    err.method = method;
+    return err;
+}
+function isRpcMethodNotFoundError(err, method) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const rpcErr = err;
+    if (rpcErr.method !== method) {
+        return false;
+    }
+    return rpcErr.code === types_js_1.RPC_METHOD_NOT_FOUND || err.message === `Unknown method: ${method}`;
+}
+function getMeshAuthCompatibilityError() {
+    return new Error("Broker does not support Pinet mesh auth (`auth`). Upgrade the broker or disable follower mesh auth when connecting to older/no-auth brokers.");
+}
+function getErrorCode(err) {
+    if (typeof err !== "object" || err == null || !("code" in err)) {
+        return null;
+    }
+    const code = err.code;
+    return typeof code === "string" ? code : null;
+}
+// ─── BrokerClient ────────────────────────────────────────
+class BrokerClient {
+    connectOpts;
+    meshSecret;
+    meshSecretPath;
+    socket = null;
+    connected = false;
+    shuttingDown = false;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    disconnectHandler = null;
+    reconnectHandler = null;
+    reconnectAttempt = 0;
+    registrationSnapshot = null;
+    registeredIdentity = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    constructor(opts) {
+        if (opts === undefined) {
+            this.connectOpts = { path: exports.DEFAULT_SOCKET_PATH };
+            this.meshSecret = null;
+            this.meshSecretPath = null;
+            return;
+        }
+        if (typeof opts === "string") {
+            this.connectOpts = { path: opts };
+            this.meshSecret = null;
+            this.meshSecretPath = null;
+            return;
+        }
+        if ("path" in opts) {
+            this.connectOpts = { path: opts.path };
+        }
+        else {
+            this.connectOpts = { host: opts.host, port: opts.port };
+        }
+        const meshSecret = opts.meshSecret?.trim();
+        this.meshSecret = meshSecret && meshSecret.length > 0 ? meshSecret : null;
+        const meshSecretPath = opts.meshSecretPath?.trim();
+        this.meshSecretPath = meshSecretPath && meshSecretPath.length > 0 ? meshSecretPath : null;
+    }
+    // ─── Connection ──────────────────────────────────────
+    async connect() {
+        this.shuttingDown = false;
+        await this.connectSocket();
+        try {
+            await this.authenticateIfNeeded();
+        }
+        catch (err) {
+            this.disconnect();
+            throw err;
+        }
+    }
+    disconnect() {
+        this.shuttingDown = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.stopHeartbeat();
+        this.rejectAllPending(new Error("Client disconnected"));
+        try {
+            this.socket?.destroy();
+        }
+        catch {
+            /* ignore */
+        }
+        this.socket = null;
+        this.connected = false;
+    }
+    async disconnectGracefully() {
+        this.shuttingDown = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.stopHeartbeat();
+        try {
+            await this.unregister();
+        }
+        finally {
+            this.disconnect();
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    resolveMeshSecret() {
+        if (this.meshSecret) {
+            return this.meshSecret;
+        }
+        if (this.meshSecretPath) {
+            try {
+                return (0, auth_js_1.readMeshSecret)(this.meshSecretPath);
+            }
+            catch (err) {
+                if (getErrorCode(err) === "ENOENT") {
+                    throw new Error(`Configured Pinet mesh secret file not found: ${this.meshSecretPath}. Set slack-bridge.meshSecretPath to an existing file, provide slack-bridge.meshSecret directly, or leave both unset to disable shared-secret auth.`);
+                }
+                throw err;
+            }
+        }
+        return null;
+    }
+    async authenticateIfNeeded() {
+        const meshSecret = this.resolveMeshSecret();
+        if (!meshSecret) {
+            return;
+        }
+        try {
+            await this.request("auth", { secret: meshSecret });
+        }
+        catch (err) {
+            if (isRpcMethodNotFoundError(err, "auth")) {
+                throw getMeshAuthCompatibilityError();
+            }
+            throw err;
+        }
+    }
+    // ─── Registration ────────────────────────────────────
+    async register(name, emoji, metadata, stableId) {
+        this.registrationSnapshot = {
+            name,
+            emoji,
+            ...(metadata ? { metadata } : {}),
+            ...(stableId ? { stableId } : {}),
+        };
+        return this.performRegister(this.registrationSnapshot);
+    }
+    async unregister() {
+        if (!this.connected)
+            return;
+        try {
+            await this.request("unregister");
+        }
+        finally {
+            this.stopHeartbeat();
+            this.registrationSnapshot = null;
+            this.registeredIdentity = null;
+        }
+    }
+    async heartbeat() {
+        await this.request("heartbeat");
+    }
+    // ─── Messaging ───────────────────────────────────────
+    async pollInbox() {
+        const result = (await this.request("inbox.poll"));
+        return result;
+    }
+    async ackMessages(ids) {
+        await this.request("inbox.ack", { ids });
+    }
+    async send(threadId, text, metadata) {
+        await this.request("send", { threadId, body: text, ...(metadata ? { metadata } : {}) });
+    }
+    // ─── Thread ownership ─────────────────────────────────
+    async claimThread(threadId, channel) {
+        const params = { threadId };
+        if (channel)
+            params.channel = channel;
+        const result = (await this.request("thread.claim", params));
+        return result;
+    }
+    async resolveThread(threadTs) {
+        const result = (await this.request("resolveThread", { threadTs }));
+        return typeof result.channelId === "string" ? result.channelId : null;
+    }
+    // ─── Status ────────────────────────────────────────────
+    async updateStatus(status) {
+        await this.request("status.update", { status });
+    }
+    // ─── Agent-to-agent messaging ─────────────────────────
+    async sendAgentMessage(target, body, metadata) {
+        const result = (await this.request("agent.message", {
+            targetAgent: target,
+            body,
+            ...(metadata ? { metadata } : {}),
+        }));
+        return result.messageId;
+    }
+    async sendAgentBroadcast(channel, body) {
+        const result = (await this.request("agent.broadcast", {
+            channel,
+            body,
+        }));
+        return {
+            channel: result.channel,
+            messageIds: result.messageIds,
+            recipients: result.recipients,
+        };
+    }
+    async scheduleWakeup(fireAt, body) {
+        const result = (await this.request("schedule.create", {
+            fireAt,
+            body,
+        }));
+        return {
+            id: result.id,
+            threadId: result.threadId,
+            fireAt: result.fireAt,
+        };
+    }
+    // ─── Queries ─────────────────────────────────────────
+    async listThreads() {
+        const result = (await this.request("threads.list"));
+        return result;
+    }
+    async listAgents(includeDisconnected = false) {
+        const result = (await this.request("agents.list", includeDisconnected ? { includeDisconnected: true } : undefined));
+        return result;
+    }
+    // ─── Slack proxy (read-through) ──────────────────────
+    async slackProxy(method, params) {
+        const result = (await this.request("slack.proxy", { method, params }));
+        return result;
+    }
+    // ─── Events ──────────────────────────────────────────
+    onDisconnect(handler) {
+        this.disconnectHandler = handler;
+    }
+    onReconnect(handler) {
+        this.reconnectHandler = handler;
+    }
+    getReconnectAttempt() {
+        return this.reconnectAttempt;
+    }
+    getRegisteredIdentity() {
+        return this.registeredIdentity ? { ...this.registeredIdentity } : null;
+    }
+    // ─── JSON-RPC transport ──────────────────────────────
+    request(method, params) {
+        if (!this.connected || !this.socket) {
+            return Promise.reject(new Error("Not connected to broker"));
+        }
+        const id = this.nextId++;
+        const msg = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            ...(params ? { params } : {}),
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Request timed out: ${method}`));
+            }, exports.REQUEST_TIMEOUT_MS);
+            this.pending.set(id, { method, resolve, reject, timer });
+            const line = JSON.stringify(msg) + "\n";
+            this.socket.write(line, "utf-8", (err) => {
+                if (err) {
+                    clearTimeout(timer);
+                    this.pending.delete(id);
+                    reject(err);
+                }
+            });
+        });
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        // Keep the last incomplete line in the buffer
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const msg = JSON.parse(line);
+                this.handleResponse(msg);
+            }
+            catch {
+                /* malformed JSON — skip */
+            }
+        }
+    }
+    handleResponse(msg) {
+        const entry = this.pending.get(msg.id);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        this.pending.delete(msg.id);
+        if (msg.error) {
+            entry.reject(createRpcRequestError(entry.method, msg.error));
+        }
+        else {
+            entry.resolve(msg.result);
+        }
+    }
+    // ─── Reconnect ──────────────────────────────────────
+    scheduleReconnect() {
+        if (this.shuttingDown || this.reconnectTimer)
+            return;
+        const delay = computeReconnectDelay(this.reconnectAttempt);
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.reconnectOnce();
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    connectSocket() {
+        return new Promise((resolve, reject) => {
+            const sock = net.createConnection(this.connectOpts);
+            sock.on("connect", () => {
+                this.socket = sock;
+                this.connected = true;
+                this.buffer = "";
+                resolve();
+            });
+            sock.on("data", (chunk) => {
+                this.onData(chunk.toString("utf-8"));
+            });
+            sock.on("close", () => {
+                const wasConnected = this.connected;
+                this.connected = false;
+                this.socket = null;
+                this.stopHeartbeat();
+                this.rejectAllPending(new Error("Socket closed"));
+                if (wasConnected && !this.shuttingDown) {
+                    this.disconnectHandler?.();
+                    this.scheduleReconnect();
+                }
+            });
+            sock.on("error", (err) => {
+                if (!this.connected) {
+                    reject(err);
+                }
+                // If already connected, the close event handles cleanup
+            });
+        });
+    }
+    async performRegister(snapshot) {
+        const result = (await this.request("register", {
+            name: snapshot.name,
+            emoji: snapshot.emoji,
+            pid: process.pid,
+            ...(snapshot.metadata ? { metadata: snapshot.metadata } : {}),
+            ...(snapshot.stableId ? { stableId: snapshot.stableId } : {}),
+        }));
+        this.registrationSnapshot = {
+            ...snapshot,
+            name: result.name,
+            emoji: result.emoji,
+            ...(result.metadata ? { metadata: result.metadata } : {}),
+        };
+        this.registeredIdentity = result;
+        this.startHeartbeat();
+        return result;
+    }
+    async reconnectOnce() {
+        try {
+            await this.connectSocket();
+        }
+        catch {
+            this.scheduleReconnect();
+            return;
+        }
+        try {
+            await this.authenticateIfNeeded();
+            if (this.registrationSnapshot) {
+                await this.performRegister(this.registrationSnapshot);
+            }
+            this.reconnectAttempt = 0;
+            this.reconnectHandler?.();
+        }
+        catch {
+            // Re-registration failed after the socket connected. Clear the connection
+            // state immediately instead of waiting for the async "close" event so the
+            // client cannot stay in a broken "connected but not registered" state.
+            // Then schedule the next reconnect attempt ourselves. (#139)
+            const failedSocket = this.socket;
+            this.socket = null;
+            this.connected = false;
+            this.buffer = "";
+            this.stopHeartbeat();
+            this.rejectAllPending(new Error("Socket closed"));
+            try {
+                failedSocket?.destroy();
+            }
+            catch {
+                /* ignore */
+            }
+            this.scheduleReconnect();
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.connected)
+                return;
+            void this.heartbeat().catch(() => {
+                /* best effort */
+            });
+        }, exports.HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+    }
+    stopHeartbeat() {
+        if (!this.heartbeatTimer)
+            return;
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+    }
+    rejectAllPending(err) {
+        for (const [id, entry] of this.pending) {
+            clearTimeout(entry.timer);
+            entry.reject(err);
+            this.pending.delete(id);
+        }
+    }
+}
+exports.BrokerClient = BrokerClient;