@pinet/slack-bridge 0.1.0

package/dist/broker/client.js

@@ -0,0 +1,624 @@
+import * as net from "node:net";
+import { readMeshSecret } from "./auth.js";
+import { DEFAULT_SOCKET_PATH as PINET_DEFAULT_SOCKET_PATH } from "./paths.js";
+import { assertLoopbackTcpHost } from "./raw-tcp-loopback.js";
+import { RPC_AGENT_NAME_CONFLICT, RPC_METHOD_NOT_FOUND } from "./types.js";
+// ─── Constants (exported for testing) ────────────────────
+export const DEFAULT_SOCKET_PATH = PINET_DEFAULT_SOCKET_PATH;
+export const REQUEST_TIMEOUT_MS = 5000;
+export const RECONNECT_DELAY_MS = 3000;
+export const INITIAL_RECONNECT_DELAY_MS = 1000;
+export const MAX_RECONNECT_DELAY_MS = 30000;
+export const HEARTBEAT_INTERVAL_MS = 5000;
+export const HEARTBEAT_METADATA_PROVIDER_TIMEOUT_MS = 2500;
+function withTimeout(promise, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
+        timer.unref?.();
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+}
+/** Compute reconnect delay with exponential backoff and jitter. */
+export function computeReconnectDelay(attempt, random = Math.random()) {
+    const baseDelay = INITIAL_RECONNECT_DELAY_MS * Math.pow(2, attempt);
+    const capped = Math.min(baseDelay, 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 === RPC_METHOD_NOT_FOUND || err.message === `Unknown method: ${method}`;
+}
+function isRpcAgentNameConflictError(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    const rpcErr = err;
+    if (rpcErr.code === RPC_AGENT_NAME_CONFLICT) {
+        return true;
+    }
+    if (typeof rpcErr.data !== "object" || rpcErr.data == null) {
+        return false;
+    }
+    return rpcErr.data.code === "AGENT_NAME_CONFLICT";
+}
+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 ────────────────────────────────────────
+export class BrokerClient {
+    connectOpts;
+    meshSecret;
+    meshSecretPath;
+    socket = null;
+    connected = false;
+    shuttingDown = false;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    disconnectHandler = null;
+    reconnectHandler = null;
+    reconnectFailedHandler = null;
+    reconnectAttempt = 0;
+    registrationSnapshot = null;
+    registeredIdentity = null;
+    heartbeatMetadataProvider = null;
+    heartbeatMetadataInFlight = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = "";
+    constructor(opts) {
+        if (opts === undefined) {
+            this.connectOpts = { path: 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 {
+            assertLoopbackTcpHost(opts.host, "broker client connect target");
+            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 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 } : {}),
+            ...(name.trim().length === 0 ? { brokerAssignedIdentity: true } : {}),
+        };
+        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(metadata) {
+        if (metadata === undefined) {
+            await this.request("heartbeat");
+            return;
+        }
+        await this.request("heartbeat", { metadata });
+    }
+    setHeartbeatMetadataProvider(provider) {
+        this.heartbeatMetadataProvider = provider;
+    }
+    // ─── Messaging ───────────────────────────────────────
+    async pollInbox() {
+        const result = (await this.request("inbox.poll"));
+        return result;
+    }
+    async readInbox(options = {}) {
+        const result = (await this.request("inbox.read", {
+            ...(options.threadId ? { threadId: options.threadId } : {}),
+            ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
+            ...(typeof options.unreadOnly === "boolean" ? { unreadOnly: options.unreadOnly } : {}),
+            ...(typeof options.markRead === "boolean" ? { markRead: options.markRead } : {}),
+        }));
+        return {
+            messages: result.messages.map((item) => ({
+                inboxId: item.entry.id,
+                delivered: item.entry.delivered,
+                readAt: item.entry.readAt,
+                message: item.message,
+            })),
+            unreadCountBefore: result.unreadCountBefore,
+            unreadCountAfter: result.unreadCountAfter,
+            unreadThreads: result.unreadThreads,
+            markedReadIds: result.markedReadIds,
+        };
+    }
+    async ackMessages(ids) {
+        await this.request("inbox.ack", { ids });
+    }
+    async send(threadId, text, metadata) {
+        await this.request("send", { threadId, body: text, ...(metadata ? { metadata } : {}) });
+    }
+    async sendMessage(input) {
+        const result = (await this.request("message.send", {
+            threadId: input.threadId,
+            body: input.body,
+            ...(input.source ? { source: input.source } : {}),
+            ...(input.channel ? { channel: input.channel } : {}),
+            ...(input.content ? { content: input.content } : {}),
+            ...(input.blocks && input.blocks.length > 0 ? { blocks: input.blocks } : {}),
+            ...(input.agentName ? { agentName: input.agentName } : {}),
+            ...(input.agentEmoji ? { agentEmoji: input.agentEmoji } : {}),
+            ...(input.agentOwnerToken ? { agentOwnerToken: input.agentOwnerToken } : {}),
+            ...(input.metadata ? { metadata: input.metadata } : {}),
+        }));
+        return result;
+    }
+    // ─── Thread ownership ─────────────────────────────────
+    async claimThread(threadId, channel, source) {
+        const params = { threadId };
+        if (channel)
+            params.channel = channel;
+        if (source)
+            params.source = source;
+        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,
+        };
+    }
+    async listLanes(options = {}) {
+        return (await this.request("lane.list", {
+            ...(options.state ? { state: options.state } : {}),
+            ...(options.ownerAgentId ? { ownerAgentId: options.ownerAgentId } : {}),
+            ...(typeof options.includeDone === "boolean" ? { includeDone: options.includeDone } : {}),
+        }));
+    }
+    async upsertLane(input) {
+        return (await this.request("lane.upsert", input));
+    }
+    async setLaneParticipant(input) {
+        return (await this.request("lane.participant", input));
+    }
+    async acquirePortLease(input) {
+        return (await this.request("portLease.acquire", input));
+    }
+    async renewPortLease(input) {
+        return (await this.request("portLease.renew", input));
+    }
+    async releasePortLease(input) {
+        return (await this.request("portLease.release", input));
+    }
+    async getPortLease(leaseId) {
+        return (await this.request("portLease.status", { leaseId }));
+    }
+    async listPortLeases(options = {}) {
+        return (await this.request("portLease.list", options));
+    }
+    async expirePortLeases() {
+        return (await this.request("portLease.expire"));
+    }
+    // ─── 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;
+    }
+    // ─── Adapter capabilities ───────────────────────────
+    async invokeAdapterCapability(adapter, capability, params = {}) {
+        const result = (await this.request("adapter.capability", {
+            adapter,
+            capability,
+            params,
+        }));
+        return result;
+    }
+    /**
+     * Compatibility wrapper for callers that still need direct Slack API access.
+     * The broker RPC boundary remains adapter-neutral; Slack-specific payloads are
+     * interpreted inside the Slack adapter's api.call capability.
+     */
+    async slackProxy(method, params) {
+        try {
+            return await this.invokeAdapterCapability("slack", "api.call", { method, params });
+        }
+        catch (err) {
+            if (!isRpcMethodNotFoundError(err, "adapter.capability")) {
+                throw err;
+            }
+        }
+        return (await this.request("slack.proxy", { method, params }));
+    }
+    // ─── Events ──────────────────────────────────────────
+    onDisconnect(handler) {
+        this.disconnectHandler = handler;
+    }
+    onReconnect(handler) {
+        this.reconnectHandler = handler;
+    }
+    onReconnectFailed(handler) {
+        this.reconnectFailedHandler = 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}`));
+            }, 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.brokerAssignedIdentity
+            ? {
+                ...snapshot,
+                ...(result.metadata ? { metadata: result.metadata } : {}),
+            }
+            : {
+                ...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 (err) {
+            // 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 either surface a terminal reconnect failure or schedule the next
+            // retry ourselves. (#139)
+            const reconnectError = err instanceof Error ? err : new Error(String(err));
+            const failedSocket = this.socket;
+            this.socket = null;
+            this.connected = false;
+            this.buffer = "";
+            this.stopHeartbeat();
+            this.rejectAllPending(new Error("Socket closed"));
+            this.registeredIdentity = null;
+            try {
+                failedSocket?.destroy();
+            }
+            catch {
+                /* ignore */
+            }
+            if (isRpcAgentNameConflictError(reconnectError)) {
+                this.reconnectAttempt = 0;
+                this.reconnectFailedHandler?.(reconnectError);
+                return;
+            }
+            this.scheduleReconnect();
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.connected)
+                return;
+            void this.runHeartbeatTick().catch(() => {
+                /* best effort */
+            });
+        }, HEARTBEAT_INTERVAL_MS);
+        this.heartbeatTimer.unref?.();
+    }
+    async readHeartbeatMetadata() {
+        const provider = this.heartbeatMetadataProvider;
+        if (!provider || this.heartbeatMetadataInFlight) {
+            return undefined;
+        }
+        const work = Promise.resolve()
+            .then(() => provider())
+            .finally(() => {
+            if (this.heartbeatMetadataInFlight === work) {
+                this.heartbeatMetadataInFlight = null;
+            }
+        });
+        this.heartbeatMetadataInFlight = work;
+        try {
+            return await withTimeout(work, HEARTBEAT_METADATA_PROVIDER_TIMEOUT_MS);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async runHeartbeatTick() {
+        await this.heartbeat(await this.readHeartbeatMetadata());
+    }
+    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);
+        }
+    }
+}