@pinet/slack-bridge 0.1.0

package/dist/broker/adapters/slack.js

@@ -0,0 +1,563 @@
+import { addSlackReaction, buildSlackThreadRuntimeScope, classifyMessage, extractAppHomeOpened, extractThreadContextChanged, extractThreadStarted, fetchSlackMessageByTs, isSlackUserAllowed, removeSlackReaction, resolveSlackUserName, setSlackSuggestedPrompts, SlackSocketModeClient, } from "../../slack-access.js";
+import { createAbortableOperationTracker, callSlackAPI, isAbortError, buildAllowlist, buildPinetControlMessage, buildPinetControlMetadata, } from "../../helpers.js";
+import { buildReactionTriggerMessage, normalizeReactionName, resolveReactionCommands, } from "../../reaction-triggers.js";
+import { TtlCache, TtlSet } from "../../ttl-cache.js";
+import { SLACK_SOCKET_DELIVERY_DEDUP_MAX_SIZE, SLACK_SOCKET_DELIVERY_DEDUP_TTL_MS, } from "../../slack-access.js";
+import { DEFAULT_SLACK_THREAD_STATUS, SlackThreadStatusManager, } from "../../slack-thread-status.js";
+export { classifyMessage, extractAppHomeOpened, extractThreadStarted, parseMemberJoinedChannel, parseSocketFrame, RECONNECT_DELAY_MS, } from "../../slack-access.js";
+export const SLACK_THREAD_CACHE_MAX_SIZE = 5000;
+export const SLACK_THREAD_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export const SLACK_PENDING_ATTENTION_MAX_THREADS = 1000;
+export const SLACK_PENDING_ATTENTION_TTL_MS = 2 * 60 * 60 * 1000;
+export const SLACK_PENDING_ATTENTION_MAX_MESSAGES_PER_THREAD = 50;
+export class SlackAdapter {
+    name = "slack";
+    config;
+    allowlist;
+    slackRequests = createAbortableOperationTracker();
+    botUserId = null;
+    socketMode = null;
+    shuttingDown = false;
+    inboundHandler = null;
+    reactionCommands;
+    threads;
+    userNames = new TtlCache({
+        maxSize: 2000,
+        ttlMs: 60 * 60 * 1000,
+    });
+    processedSocketDeliveries = new TtlSet({
+        maxSize: SLACK_SOCKET_DELIVERY_DEDUP_MAX_SIZE,
+        ttlMs: SLACK_SOCKET_DELIVERY_DEDUP_TTL_MS,
+    });
+    pendingEyes;
+    threadStatuses;
+    constructor(config) {
+        this.config = config;
+        this.threads = new TtlCache({
+            maxSize: SLACK_THREAD_CACHE_MAX_SIZE,
+            ttlMs: SLACK_THREAD_CACHE_TTL_MS,
+        });
+        this.pendingEyes = new TtlCache({
+            maxSize: SLACK_PENDING_ATTENTION_MAX_THREADS,
+            ttlMs: SLACK_PENDING_ATTENTION_TTL_MS,
+        });
+        this.threadStatuses = new SlackThreadStatusManager({
+            slack: this.callSlack.bind(this),
+            getBotToken: () => this.config.botToken,
+            formatError: errorMsg,
+            logger: console,
+        });
+        this.allowlist = buildAllowlist({
+            allowedUsers: config.allowedUsers,
+            allowAllWorkspaceUsers: config.allowAllWorkspaceUsers,
+        }, undefined, undefined);
+        this.reactionCommands = resolveReactionCommands(config.reactionCommands);
+    }
+    async callSlack(method, token, body) {
+        return this.slackRequests.run((signal) => callSlackAPI(method, token, body, { signal }));
+    }
+    async connect() {
+        this.shuttingDown = false;
+        this.slackRequests = createAbortableOperationTracker();
+        this.socketMode = new SlackSocketModeClient({
+            slack: this.callSlack.bind(this),
+            botToken: this.config.botToken,
+            appToken: this.config.appToken,
+            dedup: this.processedSocketDeliveries,
+            abortAndWait: () => this.slackRequests.abortAndWait(),
+            onThreadStarted: (event) => this.onThreadStarted(event),
+            onThreadContextChanged: (event) => this.onContextChanged(event),
+            onMessage: (event) => this.onMessage(event),
+            onReactionAdded: (event) => this.onReactionAdded(event),
+            onMemberJoinedChannel: (event) => this.onMemberJoined(event),
+            onAppHomeOpened: (event) => this.onAppHomeOpened(event),
+            onInteractive: (event) => this.emitInteractiveInbound(event),
+            onError: (error) => {
+                if (!isAbortError(error)) {
+                    console.error(`[slack-adapter] Socket Mode: ${errorMsg(error)}`);
+                }
+            },
+        });
+        await this.socketMode.connect();
+        this.botUserId = this.socketMode.getBotUserId();
+    }
+    async disconnect() {
+        this.shuttingDown = true;
+        await this.threadStatuses.clearAll();
+        const socketMode = this.socketMode;
+        this.socketMode = null;
+        if (socketMode) {
+            await socketMode.disconnect();
+            return;
+        }
+        await this.slackRequests.abortAndWait();
+    }
+    onInbound(handler) {
+        this.inboundHandler = handler;
+    }
+    async invokeCapability(request) {
+        if (request.capability !== "api.call") {
+            throw new Error(`Unsupported Slack adapter capability: ${request.capability}`);
+        }
+        const method = typeof request.params.method === "string" ? request.params.method.trim() : "";
+        if (!method) {
+            throw new Error("method is required for Slack api.call capability");
+        }
+        const body = request.params.params &&
+            typeof request.params.params === "object" &&
+            !Array.isArray(request.params.params)
+            ? request.params.params
+            : {};
+        const result = await this.callSlack(method, this.config.botToken, body);
+        return {
+            result,
+            ...this.buildSlackApiCapabilityEffects(method, body, result),
+        };
+    }
+    async send(msg) {
+        const contentSlackBlocks = msg.content?.slackBlocks;
+        const slackBlocks = contentSlackBlocks && contentSlackBlocks.length > 0
+            ? contentSlackBlocks
+            : msg.blocks && msg.blocks.length > 0
+                ? msg.blocks
+                : undefined;
+        const body = {
+            channel: msg.channel,
+            text: msg.content?.text ?? msg.text,
+            thread_ts: msg.threadId,
+            ...(slackBlocks ? { blocks: slackBlocks } : {}),
+        };
+        const scope = msg.scope ?? this.resolveScopeForThread(msg.threadId, msg.channel);
+        if (msg.agentName ?? msg.agentOwnerToken ?? msg.metadata ?? msg.scope) {
+            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 } : {}),
+                    ...(scope ? { scope } : {}),
+                    ...msg.metadata,
+                },
+            };
+        }
+        await this.callSlack("chat.postMessage", this.config.botToken, body);
+        if (this.shuttingDown)
+            return;
+        const pending = this.pendingEyes.get(msg.threadId);
+        if (pending) {
+            for (const entry of pending) {
+                void this.removeReaction(entry.channel, entry.messageTs, "eyes");
+            }
+            this.pendingEyes.delete(msg.threadId);
+        }
+        void this.clearThreadStatus(msg.channel, msg.threadId);
+    }
+    buildSlackApiCapabilityEffects(method, body, result) {
+        if (method !== "chat.postMessage") {
+            return {};
+        }
+        const threadTs = typeof body.thread_ts === "string" ? body.thread_ts : "";
+        const messageTs = typeof result.ts === "string" ? result.ts : "";
+        const channel = typeof body.channel === "string"
+            ? body.channel
+            : typeof result.channel === "string"
+                ? result.channel
+                : undefined;
+        const threadId = threadTs || messageTs;
+        if (!threadId) {
+            return {};
+        }
+        return {
+            effects: {
+                claimThread: {
+                    threadId,
+                    ...(channel ? { channel } : {}),
+                },
+            },
+        };
+    }
+    getBotUserId() {
+        return this.socketMode?.getBotUserId() ?? this.botUserId;
+    }
+    getTrackedThreadIds() {
+        this.threads.sweep();
+        return new Set([...this.threads.entries()].map(([threadTs]) => threadTs));
+    }
+    isConnected() {
+        return this.socketMode?.isConnected() ?? false;
+    }
+    resolveScopeForThread(threadTs, channelId) {
+        return buildSlackThreadRuntimeScope({
+            channelId,
+            context: this.getThread(threadTs)?.context ?? null,
+        });
+    }
+    async onThreadStarted(event) {
+        if (this.shuttingDown)
+            return;
+        const parsed = isParsedThreadStarted(event) ? event : extractThreadStarted(event);
+        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, info.context ?? null);
+        }
+        catch {
+            /* best effort — DB cache sync must not break Slack event handling */
+        }
+        await this.setSuggestedPrompts(info.channelId, info.threadTs);
+    }
+    onContextChanged(event) {
+        if (this.shuttingDown)
+            return;
+        const parsed = isParsedThreadContextChanged(event) ? event : extractThreadContextChanged(event);
+        if (!parsed)
+            return;
+        const existing = this.getThread(parsed.threadTs);
+        if (!existing || !parsed.context)
+            return;
+        existing.context = parsed.context;
+        this.threads.set(parsed.threadTs, existing);
+        try {
+            this.config.rememberKnownThread?.(parsed.threadTs, existing.channelId, existing.context);
+        }
+        catch {
+            /* best effort — DB cache sync must not break Slack event handling */
+        }
+    }
+    async onAppHomeOpened(event) {
+        if (this.shuttingDown)
+            return;
+        const parsed = isParsedAppHomeOpened(event) ? event : extractAppHomeOpened(event);
+        if (!parsed || parsed.tab !== "home") {
+            return;
+        }
+        try {
+            await this.config.onAppHomeOpened?.(parsed);
+        }
+        catch (error) {
+            console.error(`[slack-adapter] Home tab callback failed: ${errorMsg(error)}`);
+        }
+    }
+    async fetchMessageByTs(channel, messageTs) {
+        return fetchSlackMessageByTs({
+            slack: this.callSlack.bind(this),
+            token: this.config.botToken,
+            channel,
+            messageTs,
+        });
+    }
+    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 = normalizeReactionName(rawReaction);
+        }
+        catch {
+            return;
+        }
+        const command = this.reactionCommands.get(reactionName);
+        if (!command || !isSlackUserAllowed(this.allowlist, userId)) {
+            return;
+        }
+        try {
+            const isInterruptReaction = command.action === "interrupt";
+            const reactedMessage = await this.fetchMessageByTs(item.channel, item.ts);
+            if (!reactedMessage && isInterruptReaction) {
+                throw new Error(`Unable to identify Slack thread for interrupt reaction ${item.ts} in channel ${item.channel}`);
+            }
+            const reactedMessageFetchStatus = reactedMessage ? "found" : "unavailable";
+            const threadTs = reactedMessage?.thread_ts ??
+                reactedMessage?.ts ??
+                item.ts;
+            if (!this.getThread(threadTs)) {
+                this.threads.set(threadTs, {
+                    channelId: item.channel,
+                    threadTs,
+                    userId: reactedMessage?.user ?? userId,
+                });
+                try {
+                    this.config.rememberKnownThread?.(threadTs, item.channel, null);
+                }
+                catch {
+                    /* best effort — DB cache sync must not break reaction handling */
+                }
+            }
+            const reactorName = isInterruptReaction
+                ? await this.resolveUser(userId).catch(() => userId)
+                : await this.resolveUser(userId);
+            if (this.shuttingDown)
+                return;
+            const reactedMessageAuthorId = reactedMessage?.user ?? evt.item_user;
+            const reactedMessageAuthor = isInterruptReaction
+                ? (reactedMessageAuthorId ??
+                    (reactedMessage?.bot_id ? "bot" : "unknown"))
+                : reactedMessageAuthorId
+                    ? await this.resolveUser(reactedMessageAuthorId)
+                    : reactedMessage?.bot_id
+                        ? "bot"
+                        : "unknown";
+            if (this.shuttingDown)
+                return;
+            const reactedMessageText = isInterruptReaction
+                ? "(interrupt control; reacted message text omitted)"
+                : typeof reactedMessage?.text === "string" && reactedMessage.text.trim().length > 0
+                    ? reactedMessage.text
+                    : reactedMessage
+                        ? "(no text)"
+                        : "(message text unavailable; Slack did not return the reacted message, so use the channel/thread/message ids for context)";
+            const threadInfo = this.getThread(threadTs);
+            const reactionEventTs = evt.event_ts ?? item.ts;
+            this.inboundHandler?.({
+                source: "slack",
+                threadId: threadTs,
+                channel: item.channel,
+                userId,
+                userName: reactorName,
+                text: isInterruptReaction
+                    ? buildPinetControlMessage("interrupt")
+                    : buildReactionTriggerMessage({
+                        reactionName,
+                        command,
+                        reactorName,
+                        channel: item.channel,
+                        threadTs,
+                        messageTs: item.ts,
+                        reactedMessageText,
+                        reactedMessageAuthor,
+                    }),
+                timestamp: reactionEventTs,
+                metadata: {
+                    reactionTrigger: true,
+                    reactionName,
+                    reactionAction: command.action,
+                    ...(isInterruptReaction
+                        ? {
+                            ...buildPinetControlMetadata("interrupt"),
+                            kind: "pinet_control",
+                            command: "interrupt",
+                            slackReactionControl: true,
+                        }
+                        : {}),
+                    reactorUserId: userId,
+                    reactorName,
+                    reactionEventTs,
+                    referencedSource: "slack",
+                    referencedChannel: item.channel,
+                    referencedThreadTs: threadTs,
+                    referencedMessageTs: item.ts,
+                    referencedExternalId: `${item.channel}:${item.ts}`,
+                    reactedMessageFetchStatus,
+                    reactedMessageAuthor,
+                    ...(reactedMessageAuthorId ? { reactedMessageAuthorId } : {}),
+                },
+                scope: buildSlackThreadRuntimeScope({
+                    channelId: item.channel,
+                    context: threadInfo?.context,
+                }),
+            });
+            await this.addReaction(item.channel, item.ts, "white_check_mark");
+        }
+        catch (error) {
+            console.error(`[slack-adapter] reaction trigger failed: ${errorMsg(error)}`);
+            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, isDM, isChannelMention, messageTs, metadata } = classified;
+        if (isDM &&
+            typeof evt.thread_ts === "string" &&
+            this.shouldSuppressLegacyThreadedDm(threadTs)) {
+            return;
+        }
+        if (!this.getThread(threadTs)) {
+            this.threads.set(threadTs, {
+                channelId: channel,
+                threadTs,
+                userId,
+            });
+        }
+        if (!isSlackUserAllowed(this.allowlist, userId))
+            return;
+        void this.threadStatuses.begin(channel, threadTs, DEFAULT_SLACK_THREAD_STATUS);
+        void this.addReaction(channel, messageTs, "eyes");
+        const pending = this.pendingEyes.get(threadTs) ?? [];
+        pending.push({ channel, messageTs });
+        if (pending.length > SLACK_PENDING_ATTENTION_MAX_MESSAGES_PER_THREAD) {
+            pending.splice(0, pending.length - SLACK_PENDING_ATTENTION_MAX_MESSAGES_PER_THREAD);
+        }
+        this.pendingEyes.set(threadTs, pending);
+        const userName = await this.resolveUser(userId);
+        if (this.shuttingDown)
+            return;
+        const threadInfo = this.getThread(threadTs);
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: threadTs,
+            channel,
+            userId,
+            userName,
+            text,
+            timestamp: messageTs,
+            scope: buildSlackThreadRuntimeScope({
+                channelId: channel,
+                context: threadInfo?.context,
+            }),
+            ...(isChannelMention ? { isChannelMention: true } : {}),
+            ...(metadata ? { metadata } : {}),
+        });
+    }
+    async emitInteractiveInbound(normalized) {
+        if (!this.getThread(normalized.threadTs)) {
+            this.threads.set(normalized.threadTs, {
+                channelId: normalized.channel,
+                threadTs: normalized.threadTs,
+                userId: normalized.userId,
+            });
+        }
+        try {
+            this.config.rememberKnownThread?.(normalized.threadTs, normalized.channel, null);
+        }
+        catch {
+            /* best effort — DB cache sync must not break Slack event handling */
+        }
+        if (!isSlackUserAllowed(this.allowlist, normalized.userId))
+            return;
+        const userName = await this.resolveUser(normalized.userId);
+        if (this.shuttingDown)
+            return;
+        const threadInfo = this.getThread(normalized.threadTs);
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: normalized.threadTs,
+            channel: normalized.channel,
+            userId: normalized.userId,
+            userName,
+            text: normalized.text,
+            timestamp: normalized.timestamp,
+            metadata: normalized.metadata,
+            scope: buildSlackThreadRuntimeScope({
+                channelId: normalized.channel,
+                context: threadInfo?.context,
+            }),
+        });
+    }
+    onMemberJoined(event) {
+        if (!event.isSelf)
+            return;
+        this.inboundHandler?.({
+            source: "slack",
+            threadId: "",
+            channel: event.channel,
+            userId: "system",
+            text: `Bot was added to channel ${event.channel}`,
+            timestamp: String(Date.now() / 1000),
+            scope: buildSlackThreadRuntimeScope({ channelId: event.channel }),
+        });
+    }
+    shouldSuppressLegacyThreadedDm(threadTs) {
+        const cached = this.threads.get(threadTs);
+        if (cached)
+            return false;
+        const known = this.config.getKnownThread?.(threadTs);
+        return !!known && known.channelId.startsWith("D") && !known.context;
+    }
+    getThread(threadTs) {
+        const cached = this.threads.get(threadTs);
+        if (cached) {
+            this.threads.set(threadTs, cached);
+            return cached;
+        }
+        const known = this.config.getKnownThread?.(threadTs);
+        if (!known?.channelId)
+            return undefined;
+        const restored = {
+            channelId: known.channelId,
+            threadTs,
+            userId: "",
+            ...(known.context ? { context: known.context } : {}),
+        };
+        this.threads.set(threadTs, restored);
+        return restored;
+    }
+    async addReaction(channel, ts, emoji) {
+        await addSlackReaction({
+            slack: this.callSlack.bind(this),
+            token: this.config.botToken,
+            channel,
+            timestamp: ts,
+            emoji,
+        });
+    }
+    async removeReaction(channel, ts, emoji) {
+        await removeSlackReaction({
+            slack: this.callSlack.bind(this),
+            token: this.config.botToken,
+            channel,
+            timestamp: ts,
+            emoji,
+        });
+    }
+    async resolveUser(userId) {
+        return resolveSlackUserName({
+            slack: this.callSlack.bind(this),
+            token: this.config.botToken,
+            userId,
+            cache: this.userNames,
+            shouldUseResult: () => !this.shuttingDown,
+        });
+    }
+    async clearThreadStatus(channelId, threadTs) {
+        await this.threadStatuses.clear(channelId, threadTs);
+    }
+    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" },
+        ];
+        await setSlackSuggestedPrompts({
+            slack: this.callSlack.bind(this),
+            token: this.config.botToken,
+            channelId,
+            threadTs,
+            prompts,
+        });
+    }
+}
+function isParsedThreadStarted(value) {
+    return (typeof value.channelId === "string" &&
+        typeof value.threadTs === "string" &&
+        typeof value.userId === "string");
+}
+function isParsedThreadContextChanged(value) {
+    return typeof value.threadTs === "string";
+}
+function isParsedAppHomeOpened(value) {
+    return typeof value.userId === "string" && typeof value.tab === "string";
+}
+function errorMsg(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/broker/adapters/types.d.ts

@@ -0,0 +1 @@
+export type { AdapterCapabilityRequest, AdapterCapabilityResult, InboundMessage, OutboundMessage, MessageAdapter, } from "@pinet/transport-core";

package/dist/broker/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/broker/agent-messaging.d.ts

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/agent-messaging";

package/dist/broker/agent-messaging.js

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/agent-messaging";

package/dist/broker/auth.d.ts

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/auth";

package/dist/broker/auth.js

@@ -0,0 +1 @@
+export * from "@pinet/broker-core/auth";