@gugu910/pi-slack-bridge 0.1.3

package/dist/broker/adapters/slack.js

@@ -0,0 +1,645 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackAdapter = exports.RECONNECT_DELAY_MS = void 0;
+exports.parseSocketFrame = parseSocketFrame;
+exports.extractThreadStarted = extractThreadStarted;
+exports.extractAppHomeOpened = extractAppHomeOpened;
+exports.classifyMessage = classifyMessage;
+exports.parseMemberJoinedChannel = parseMemberJoinedChannel;
+const helpers_js_1 = require("../../helpers.js");
+const reaction_triggers_js_1 = require("../../reaction-triggers.js");
+const ttl_cache_js_1 = require("../../ttl-cache.js");
+const slack_socket_dedup_js_1 = require("../../slack-socket-dedup.js");
+const slack_block_kit_js_1 = require("../../slack-block-kit.js");
+/**
+ * Parse a raw Socket Mode WebSocket frame into a structured envelope.
+ * Returns null if the frame is malformed JSON.
+ */
+function parseSocketFrame(raw) {
+    try {
+        const data = JSON.parse(raw);
+        const result = {
+            type: data.type ?? "",
+        };
+        if (data.envelope_id) {
+            result.envelopeId = data.envelope_id;
+        }
+        const dedupKey = (0, slack_socket_dedup_js_1.extractSlackSocketDedupKey)(data);
+        if (dedupKey) {
+            result.dedupKey = dedupKey;
+        }
+        if (data.type === "events_api") {
+            const payload = data.payload;
+            result.event = payload?.event;
+        }
+        const interactivePayload = (0, slack_block_kit_js_1.extractSlackInteractivePayloadFromEnvelope)(data);
+        if (interactivePayload) {
+            result.interactivePayload = interactivePayload;
+        }
+        return result;
+    }
+    catch {
+        /* malformed JSON */
+        return null;
+    }
+}
+/**
+ * Extract thread info from an assistant_thread_started event.
+ */
+function extractThreadStarted(evt) {
+    const t = evt.assistant_thread;
+    if (!t)
+        return null;
+    const result = {
+        channelId: t.channel_id,
+        threadTs: t.thread_ts,
+        userId: t.user_id,
+    };
+    const ctx = t.context;
+    if (ctx?.channel_id) {
+        result.context = { channelId: ctx.channel_id, teamId: ctx.team_id ?? "" };
+    }
+    return result;
+}
+function extractAppHomeOpened(evt) {
+    const userId = typeof evt.user === "string" && evt.user.length > 0 ? evt.user : null;
+    if (!userId)
+        return null;
+    const tab = typeof evt.tab === "string" && evt.tab.length > 0 ? evt.tab : "home";
+    return {
+        userId,
+        tab,
+        eventTs: typeof evt.event_ts === "string" && evt.event_ts.length > 0 ? evt.event_ts : null,
+    };
+}
+/**
+ * Classify an incoming Slack message event. Determines whether the
+ * message is relevant (DM, known thread, or bot mention) and
+ * extracts the cleaned fields.
+ */
+function classifyMessage(evt, botUserId, trackedThreadIds, isKnownThread) {
+    // Skip bot messages and messages with subtypes (joins, edits, etc.)
+    if (evt.subtype || evt.bot_id)
+        return { relevant: false };
+    const text = evt.text ?? "";
+    const user = evt.user;
+    const threadTs = evt.thread_ts;
+    const channel = evt.channel;
+    const channelType = evt.channel_type;
+    const isKnown = !!threadTs && (isKnownThread?.(threadTs) ?? trackedThreadIds.has(threadTs));
+    const isDM = channelType === "im";
+    const isMention = botUserId != null && text.includes(`<@${botUserId}>`);
+    if (!isKnown && !isDM && !isMention)
+        return { relevant: false };
+    const effectiveTs = threadTs ?? evt.ts;
+    const isChannelMention = isMention && !isDM && !isKnown;
+    const cleanText = isChannelMention && botUserId ? (0, helpers_js_1.stripBotMention)(text, botUserId) : text;
+    return {
+        relevant: true,
+        threadTs: effectiveTs,
+        channel,
+        userId: user,
+        text: cleanText,
+        isDM,
+        isChannelMention,
+        messageTs: evt.ts ?? effectiveTs,
+    };
+}
+/**
+ * Parse a member_joined_channel event. Returns null if required fields
+ * are missing.
+ */
+function parseMemberJoinedChannel(evt, botUserId) {
+    const user = evt.user;
+    const channel = evt.channel;
+    if (!user || !channel)
+        return null;
+    return { channel, isSelf: user === botUserId };
+}
+// ─── Reconnect delay (exported for testing) ──────────────
+exports.RECONNECT_DELAY_MS = 5000;
+// ─── Slack Adapter ───────────────────────────────────────
+class SlackAdapter {
+    name = "slack";
+    config;
+    allowlist;
+    slackRequests = (0, helpers_js_1.createAbortableOperationTracker)();
+    botUserId = null;
+    ws = null;
+    reconnectTimer = null;
+    shuttingDown = false;
+    inboundHandler = null;
+    reactionCommands;
+    threads = new Map();
+    userNames = new ttl_cache_js_1.TtlCache({
+        maxSize: 2000,
+        ttlMs: 60 * 60 * 1000,
+    });
+    processedSocketDeliveries = new ttl_cache_js_1.TtlSet({
+        maxSize: slack_socket_dedup_js_1.SLACK_SOCKET_DELIVERY_DEDUP_MAX_SIZE,
+        ttlMs: slack_socket_dedup_js_1.SLACK_SOCKET_DELIVERY_DEDUP_TTL_MS,
+    });
+    pendingEyes = new Map();
+    constructor(config) {
+        this.config = config;
+        this.allowlist = (0, helpers_js_1.buildAllowlist)({ allowedUsers: config.allowedUsers }, undefined);
+        this.reactionCommands = (0, reaction_triggers_js_1.resolveReactionCommands)(config.reactionCommands);
+    }
+    async callSlack(method, token, body) {
+        return this.slackRequests.run((signal) => (0, helpers_js_1.callSlackAPI)(method, token, body, { signal }));
+    }
+    // ─── MessageAdapter interface ─────────────────────────
+    async connect() {
+        this.shuttingDown = false;
+        this.slackRequests = (0, helpers_js_1.createAbortableOperationTracker)();
+        const auth = await this.callSlack("auth.test", this.config.botToken);
+        this.botUserId = auth.user_id;
+        await this.connectSocketMode();
+    }
+    async disconnect() {
+        this.shuttingDown = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        try {
+            this.ws?.close();
+        }
+        catch {
+            /* ignore close errors */
+        }
+        this.ws = null;
+        await this.slackRequests.abortAndWait();
+    }
+    onInbound(handler) {
+        this.inboundHandler = handler;
+    }
+    async send(msg) {
+        const body = {
+            channel: msg.channel,
+            text: msg.text,
+            thread_ts: msg.threadId,
+        };
+        if (msg.agentName ?? msg.agentOwnerToken ?? msg.metadata) {
+            body.metadata = {
+                event_type: "pi_agent_msg",
+                event_payload: {
+                    ...(msg.agentName ? { agent: msg.agentName } : {}),
+                    ...(msg.agentOwnerToken ? { agent_owner: msg.agentOwnerToken } : {}),
+                    ...(msg.agentEmoji ? { emoji: msg.agentEmoji } : {}),
+                    ...msg.metadata,
+                },
+            };
+        }
+        await this.callSlack("chat.postMessage", this.config.botToken, body);
+        if (this.shuttingDown)
+            return;
+        // Remove pending eyes for this thread
+        const pending = this.pendingEyes.get(msg.threadId);
+        if (pending) {
+            for (const p of pending) {
+                void this.removeReaction(p.channel, p.messageTs, "eyes");
+            }
+            this.pendingEyes.delete(msg.threadId);
+        }
+        // Clear thread status
+        void this.clearThreadStatus(msg.channel, msg.threadId);
+    }
+    // ─── Getters (for inspection / testing) ────────────────
+    getBotUserId() {
+        return this.botUserId;
+    }
+    getTrackedThreadIds() {
+        return new Set(this.threads.keys());
+    }
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    // ─── Socket Mode connection ────────────────────────────
+    async connectSocketMode() {
+        if (this.shuttingDown)
+            return;
+        try {
+            const res = await this.callSlack("apps.connections.open", this.config.appToken);
+            this.ws = new WebSocket(res.url);
+            this.ws.addEventListener("message", (event) => {
+                void this.handleFrame(String(event.data));
+            });
+            this.ws.addEventListener("close", () => {
+                if (!this.shuttingDown)
+                    this.scheduleReconnect();
+            });
+            this.ws.addEventListener("error", () => {
+                /* close fires after error — handled there */
+            });
+        }
+        catch (err) {
+            if (!(0, helpers_js_1.isAbortError)(err)) {
+                console.error(`[slack-adapter] Socket Mode: ${errorMsg(err)}`);
+            }
+            this.scheduleReconnect();
+        }
+    }
+    async handleFrame(raw) {
+        if (this.shuttingDown)
+            return;
+        const envelope = parseSocketFrame(raw);
+        if (!envelope)
+            return;
+        // ACK every envelope
+        if (envelope.envelopeId) {
+            this.ws?.send(JSON.stringify({ envelope_id: envelope.envelopeId }));
+        }
+        const dedupKey = envelope.dedupKey ?? null;
+        try {
+            if (dedupKey) {
+                if (this.processedSocketDeliveries.has(dedupKey)) {
+                    return;
+                }
+                this.processedSocketDeliveries.add(dedupKey);
+            }
+            if (envelope.type === "disconnect") {
+                this.scheduleReconnect();
+                return;
+            }
+            if (envelope.interactivePayload) {
+                if (envelope.interactivePayload.type === "block_actions") {
+                    await this.onBlockActions(envelope.interactivePayload);
+                }
+                else if (envelope.interactivePayload.type === "view_submission") {
+                    await this.onViewSubmission(envelope.interactivePayload);
+                }
+                return;
+            }
+            if (!envelope.event)
+                return;
+            const evt = envelope.event;
+            switch (evt.type) {
+                case "assistant_thread_started":
+                    await this.onThreadStarted(evt);
+                    break;
+                case "assistant_thread_context_changed":
+                    this.onContextChanged(evt);
+                    break;
+                case "message":
+                    await this.onMessage(evt);
+                    break;
+                case "reaction_added":
+                    await this.onReactionAdded(evt);
+                    break;
+                case "member_joined_channel":
+                    this.onMemberJoined(evt);
+                    break;
+                case "app_home_opened":
+                    await this.onAppHomeOpened(evt);
+                    break;
+            }
+        }
+        catch (err) {
+            if (dedupKey) {
+                this.processedSocketDeliveries.delete(dedupKey);
+            }
+            throw err;
+        }
+    }
+    // ─── Event handlers ────────────────────────────────────
+    async onThreadStarted(evt) {
+        if (this.shuttingDown)
+            return;
+        const parsed = extractThreadStarted(evt);
+        if (!parsed)
+            return;
+        const info = {
+            channelId: parsed.channelId,
+            threadTs: parsed.threadTs,
+            userId: parsed.userId,
+        };
+        if (parsed.context) {
+            info.context = parsed.context;
+        }
+        this.threads.set(info.threadTs, info);
+        try {
+            this.config.rememberKnownThread?.(info.threadTs, info.channelId);
+        }
+        catch {
+            /* best effort — DB cache sync must not break Slack event handling */
+        }
+        await this.setSuggestedPrompts(info.channelId, info.threadTs);
+    }
+    onContextChanged(evt) {
+        if (this.shuttingDown)
+            return;
+        const t = evt.assistant_thread;
+        if (!t)
+            return;
+        const existing = this.threads.get(t.thread_ts);
+        if (!existing)
+            return;
+        const ctx = t.context;
+        if (ctx?.channel_id) {
+            existing.context = {
+                channelId: ctx.channel_id,
+                teamId: ctx.team_id ?? "",
+            };
+        }
+    }
+    async onAppHomeOpened(evt) {
+        if (this.shuttingDown)
+            return;
+        const parsed = extractAppHomeOpened(evt);
+        if (!parsed || parsed.tab !== "home") {
+            return;
+        }
+        try {
+            await this.config.onAppHomeOpened?.(parsed);
+        }
+        catch (err) {
+            console.error(`[slack-adapter] Home tab callback failed: ${errorMsg(err)}`);
+        }
+    }
+    async fetchMessageByTs(channel, messageTs) {
+        try {
+            const response = await this.callSlack("conversations.history", this.config.botToken, {
+                channel,
+                oldest: messageTs,
+                latest: messageTs,
+                inclusive: true,
+                limit: 1,
+            });
+            const messages = response.messages ?? [];
+            return messages.find((message) => message.ts === messageTs) ?? messages[0] ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async onReactionAdded(evt) {
+        if (this.shuttingDown)
+            return;
+        const item = evt.item;
+        const userId = evt.user;
+        const rawReaction = evt.reaction;
+        if (!item || item.type !== "message" || !item.channel || !item.ts || !userId || !rawReaction) {
+            return;
+        }
+        if (userId === this.botUserId)
+            return;
+        let reactionName;
+        try {
+            reactionName = (0, reaction_triggers_js_1.normalizeReactionName)(rawReaction);
+        }
+        catch {
+            return;
+        }
+        const command = this.reactionCommands.get(reactionName);
+        if (!command || !(0, helpers_js_1.isUserAllowed)(this.allowlist, userId)) {
+            return;
+        }
+        try {
+            const reactedMessage = await this.fetchMessageByTs(item.channel, item.ts);
+            if (!reactedMessage) {
+                throw new Error(`Unable to fetch reacted message ${item.ts} in channel ${item.channel}`);
+            }
+            const threadTs = reactedMessage.thread_ts ??
+                reactedMessage.ts ??
+                item.ts;
+            if (!this.threads.has(threadTs)) {
+                this.threads.set(threadTs, {
+                    channelId: item.channel,
+                    threadTs,
+                    userId: reactedMessage.user ?? userId,
+                });
+                try {
+                    this.config.rememberKnownThread?.(threadTs, item.channel);
+                }
+                catch {
+                    /* best effort — DB cache sync must not break reaction handling */
+                }
+            }
+            const reactorName = await this.resolveUser(userId);
+            if (this.shuttingDown)
+                return;
+            const reactedMessageAuthorId = reactedMessage.user ?? evt.item_user;
+            const reactedMessageAuthor = reactedMessageAuthorId
+                ? await this.resolveUser(reactedMessageAuthorId)
+                : reactedMessage.bot_id
+                    ? "bot"
+                    : "unknown";
+            if (this.shuttingDown)
+                return;
+            const reactedMessageText = typeof reactedMessage.text === "string" && reactedMessage.text.trim().length > 0
+                ? reactedMessage.text
+                : "(no text)";
+            this.inboundHandler?.({
+                source: "slack",
+                threadId: threadTs,
+                channel: item.channel,
+                userId,
+                userName: reactorName,
+                text: (0, reaction_triggers_js_1.buildReactionTriggerMessage)({
+                    reactionName,
+                    command,
+                    reactorName,
+                    channel: item.channel,
+                    threadTs,
+                    messageTs: item.ts,
+                    reactedMessageText,
+                    reactedMessageAuthor,
+                }),
+                timestamp: evt.event_ts ?? item.ts,
+            });
+            await this.addReaction(item.channel, item.ts, "white_check_mark");
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            console.error(`[slack-adapter] reaction trigger failed: ${errorMsg}`);
+            await this.addReaction(item.channel, item.ts, "x");
+        }
+    }
+    async onMessage(evt) {
+        if (this.shuttingDown)
+            return;
+        const classified = classifyMessage(evt, this.botUserId, this.getTrackedThreadIds(), this.config.isKnownThread);
+        if (!classified.relevant)
+            return;
+        const { threadTs, channel, userId, text, isChannelMention, messageTs } = classified;
+        // Track thread if new
+        if (!this.threads.has(threadTs)) {
+            this.threads.set(threadTs, {
+                channelId: channel,
+                threadTs,
+                userId,
+            });
+        }
+        // Allowlist check — silently drop unauthorized users
+        if (!(0, helpers_js_1.isUserAllowed)(this.allowlist, userId))
+            return;
+        // React with eyes to acknowledge
+        void this.addReaction(channel, messageTs, "eyes");
+        const pending = this.pendingEyes.get(threadTs) ?? [];
+        pending.push({ channel, messageTs });
+        this.pendingEyes.set(threadTs, pending);
+        // Resolve user name
+        const userName = await this.resolveUser(userId);
+        if (this.shuttingDown)
+            return;
+        // Emit inbound message
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: threadTs,
+            channel,
+            userId,
+            userName,
+            text,
+            timestamp: messageTs,
+            ...(isChannelMention ? { isChannelMention: true } : {}),
+        });
+    }
+    async emitInteractiveInbound(normalized) {
+        if (!this.threads.has(normalized.threadTs)) {
+            this.threads.set(normalized.threadTs, {
+                channelId: normalized.channel,
+                threadTs: normalized.threadTs,
+                userId: normalized.userId,
+            });
+        }
+        try {
+            this.config.rememberKnownThread?.(normalized.threadTs, normalized.channel);
+        }
+        catch {
+            /* best effort — DB cache sync must not break Slack event handling */
+        }
+        if (!(0, helpers_js_1.isUserAllowed)(this.allowlist, normalized.userId))
+            return;
+        const userName = await this.resolveUser(normalized.userId);
+        if (this.shuttingDown)
+            return;
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: normalized.threadTs,
+            channel: normalized.channel,
+            userId: normalized.userId,
+            userName,
+            text: normalized.text,
+            timestamp: normalized.timestamp,
+            metadata: normalized.metadata,
+        });
+    }
+    async onBlockActions(payload) {
+        if (this.shuttingDown)
+            return;
+        const normalized = (0, slack_block_kit_js_1.normalizeSlackBlockActionPayload)(payload);
+        if (!normalized)
+            return;
+        await this.emitInteractiveInbound(normalized);
+    }
+    async onViewSubmission(payload) {
+        if (this.shuttingDown)
+            return;
+        const normalized = (0, slack_block_kit_js_1.normalizeSlackViewSubmissionPayload)(payload);
+        if (!normalized)
+            return;
+        await this.emitInteractiveInbound(normalized);
+    }
+    onMemberJoined(evt) {
+        const parsed = parseMemberJoinedChannel(evt, this.botUserId);
+        if (!parsed || !parsed.isSelf)
+            return;
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: "",
+            channel: parsed.channel,
+            userId: "system",
+            text: `Bot was added to channel ${parsed.channel}`,
+            timestamp: String(Date.now() / 1000),
+        });
+    }
+    // ─── Slack API helpers ─────────────────────────────────
+    async addReaction(channel, ts, emoji) {
+        try {
+            await this.callSlack("reactions.add", this.config.botToken, {
+                channel,
+                timestamp: ts,
+                name: emoji,
+            });
+        }
+        catch {
+            /* already_reacted or non-critical */
+        }
+    }
+    async removeReaction(channel, ts, emoji) {
+        try {
+            await this.callSlack("reactions.remove", this.config.botToken, {
+                channel,
+                timestamp: ts,
+                name: emoji,
+            });
+        }
+        catch {
+            /* not_reacted or non-critical */
+        }
+    }
+    async resolveUser(userId) {
+        const cached = this.userNames.get(userId);
+        if (cached)
+            return cached;
+        try {
+            const res = await this.callSlack("users.info", this.config.botToken, {
+                user: userId,
+            });
+            if (this.shuttingDown)
+                return userId;
+            const u = res.user;
+            const name = u.real_name ?? u.name ?? userId;
+            this.userNames.set(userId, name);
+            return name;
+        }
+        catch {
+            /* non-critical — return raw userId */
+            return userId;
+        }
+    }
+    async clearThreadStatus(channelId, threadTs) {
+        try {
+            await this.callSlack("assistant.threads.setStatus", this.config.botToken, {
+                channel_id: channelId,
+                thread_ts: threadTs,
+                status: "",
+            });
+        }
+        catch {
+            /* non-critical */
+        }
+    }
+    async setSuggestedPrompts(channelId, threadTs) {
+        const prompts = this.config.suggestedPrompts ?? [
+            { title: "Status", message: "What are you working on right now?" },
+            { title: "Help", message: "I need help with something in the codebase" },
+            { title: "Review", message: "Summarise the recent changes" },
+        ];
+        try {
+            await this.callSlack("assistant.threads.setSuggestedPrompts", this.config.botToken, {
+                channel_id: channelId,
+                thread_ts: threadTs,
+                prompts,
+            });
+        }
+        catch {
+            /* non-critical */
+        }
+    }
+    // ─── Reconnect ─────────────────────────────────────────
+    scheduleReconnect() {
+        if (this.shuttingDown || this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.connectSocketMode();
+        }, exports.RECONNECT_DELAY_MS);
+    }
+}
+exports.SlackAdapter = SlackAdapter;
+// ─── Utility ─────────────────────────────────────────────
+function errorMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/broker/adapters/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// ─── Adapter message types ───────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });