@pinet/slack-bridge 0.1.0

package/dist/single-player-runtime.js

@@ -0,0 +1,436 @@
+import { agentOwnsThread, normalizeOwnedThreads } from "./helpers.js";
+import { buildReactionTriggerMessage, normalizeReactionName, } from "./reaction-triggers.js";
+import { buildSlackThreadRuntimeScope, classifyMessage, resolveSlackThreadOwnerHint, SlackSocketModeClient, } from "./slack-access.js";
+import { isAbortError } from "./helpers.js";
+function interruptSinglePlayerTurn(ctx) {
+    if (ctx.isIdle?.() ?? true)
+        return;
+    try {
+        ctx.abort?.();
+    }
+    catch {
+        /* best effort — interrupt controls must not crash reaction handling */
+    }
+}
+export function createSinglePlayerRuntime(deps) {
+    let slackSocket = null;
+    let shuttingDown = false;
+    function getCurrentBotUserId() {
+        return slackSocket?.getBotUserId() ?? deps.getBotUserId();
+    }
+    function getAgentState() {
+        return {
+            agentName: deps.getAgentName(),
+            agentAliases: deps.getAgentAliases(),
+            agentOwnerToken: deps.getAgentOwnerToken(),
+        };
+    }
+    function trackOwnedThread(threadTs, channelId, source = "slack") {
+        const threads = deps.getThreads();
+        const agentOwnerToken = deps.getAgentOwnerToken();
+        if (!threads.has(threadTs)) {
+            threads.set(threadTs, {
+                channelId,
+                threadTs,
+                userId: "",
+                source,
+                owner: agentOwnerToken,
+            });
+        }
+        else {
+            const thread = threads.get(threadTs);
+            if (!thread.owner)
+                thread.owner = agentOwnerToken;
+            if (!thread.source) {
+                thread.source = source;
+            }
+        }
+        deps.getUnclaimedThreads().delete(threadTs);
+        deps.persistState();
+    }
+    function clearPendingAttention(threadTs) {
+        const pending = deps.getPendingEyes().get(threadTs);
+        if (!pending)
+            return;
+        for (const entry of pending) {
+            void deps.removeReaction(entry.channel, entry.messageTs, "eyes");
+        }
+        deps.getPendingEyes().delete(threadTs);
+    }
+    async function resolveThreadOwner(channel, threadTs) {
+        const hint = await resolveSlackThreadOwnerHint({
+            slack: deps.slack,
+            token: deps.getBotToken(),
+            channel,
+            threadTs,
+            limit: 50,
+        });
+        return hint?.agentOwner ?? hint?.agentName ?? null;
+    }
+    async function ensureLocalThreadOwnership(channel, threadTs) {
+        const threads = deps.getThreads();
+        const { agentName, agentAliases, agentOwnerToken } = getAgentState();
+        const localOwner = threads.get(threadTs)?.owner;
+        if (localOwner && !agentOwnsThread(localOwner, agentName, agentAliases, agentOwnerToken)) {
+            return "skip";
+        }
+        if (localOwner) {
+            const thread = threads.get(threadTs);
+            if (thread) {
+                normalizeOwnedThreads([thread], agentName, agentOwnerToken, agentAliases);
+            }
+            return "continue";
+        }
+        const unclaimedThreads = deps.getUnclaimedThreads();
+        if (unclaimedThreads.has(threadTs)) {
+            return "continue";
+        }
+        const remoteOwner = await resolveThreadOwner(channel, threadTs);
+        if (shuttingDown) {
+            return "shutdown";
+        }
+        const thread = threads.get(threadTs);
+        if (remoteOwner && !agentOwnsThread(remoteOwner, agentName, agentAliases, agentOwnerToken)) {
+            if (thread)
+                thread.owner = remoteOwner;
+            return "skip";
+        }
+        if (agentOwnsThread(remoteOwner ?? undefined, agentName, agentAliases, agentOwnerToken)) {
+            if (thread)
+                thread.owner = agentOwnerToken;
+        }
+        if (!remoteOwner) {
+            unclaimedThreads.add(threadTs);
+        }
+        return "continue";
+    }
+    async function onThreadStarted(event) {
+        if (shuttingDown)
+            return;
+        const info = {
+            channelId: event.channelId,
+            threadTs: event.threadTs,
+            userId: event.userId,
+            source: "slack",
+        };
+        if (event.context) {
+            info.context = event.context;
+        }
+        deps.getThreads().set(info.threadTs, info);
+        deps.setLastDmChannel(info.channelId);
+        deps.persistState();
+        await deps.setSuggestedPrompts(info.channelId, info.threadTs);
+    }
+    function onContextChanged(event) {
+        if (shuttingDown)
+            return;
+        const existing = deps.getThreads().get(event.threadTs);
+        if (!existing || !event.context)
+            return;
+        existing.context = event.context;
+        deps.persistState();
+    }
+    async function onAppHomeOpened(event, ctx) {
+        if (shuttingDown)
+            return;
+        await deps.publishCurrentPinetHomeTab(event.userId, ctx);
+    }
+    async function onReactionAdded(evt, ctx) {
+        if (shuttingDown)
+            return;
+        const item = evt.item;
+        const user = evt.user;
+        const rawReactionName = evt.reaction;
+        if (!item ||
+            item.type !== "message" ||
+            !item.channel ||
+            !item.ts ||
+            !user ||
+            !rawReactionName) {
+            return;
+        }
+        if (user === getCurrentBotUserId()) {
+            return;
+        }
+        let reactionName;
+        try {
+            reactionName = normalizeReactionName(rawReactionName);
+        }
+        catch {
+            return;
+        }
+        const command = deps.getReactionCommand(reactionName);
+        if (!command || !deps.isUserAllowed(user)) {
+            return;
+        }
+        try {
+            const isInterruptReaction = command.action === "interrupt";
+            const reactedMessage = await deps.fetchSlackMessageByTs(item.channel, item.ts);
+            if (!reactedMessage) {
+                const reason = isInterruptReaction
+                    ? "identify Slack thread for interrupt reaction"
+                    : "fetch reacted message";
+                throw new Error(`Unable to ${reason} ${item.ts} in channel ${item.channel}`);
+            }
+            const threadTs = reactedMessage?.thread_ts ??
+                reactedMessage?.ts ??
+                item.ts;
+            const threads = deps.getThreads();
+            if (!threads.has(threadTs)) {
+                threads.set(threadTs, {
+                    channelId: item.channel,
+                    threadTs,
+                    userId: reactedMessage?.user ?? user,
+                    source: "slack",
+                });
+            }
+            const ownership = await ensureLocalThreadOwnership(item.channel, threadTs);
+            if (ownership !== "continue") {
+                return;
+            }
+            const reactorName = isInterruptReaction
+                ? await deps.resolveUser(user).catch(() => user)
+                : await deps.resolveUser(user);
+            if (shuttingDown)
+                return;
+            if (isInterruptReaction) {
+                interruptSinglePlayerTurn(ctx);
+                ctx.ui.notify(`${reactorName} requested an interrupt with :${reactionName}:`, "warning");
+                await deps.addReaction(item.channel, item.ts, "white_check_mark");
+                return;
+            }
+            const reactedMessageAuthorId = reactedMessage?.user ?? evt.item_user;
+            const reactedMessageAuthor = reactedMessageAuthorId
+                ? await deps.resolveUser(reactedMessageAuthorId)
+                : reactedMessage?.bot_id
+                    ? "bot"
+                    : "unknown";
+            if (shuttingDown)
+                return;
+            const reactedMessageText = typeof reactedMessage?.text === "string" && reactedMessage.text.trim().length > 0
+                ? reactedMessage.text
+                : "(no text)";
+            const reactionMessage = buildReactionTriggerMessage({
+                reactionName,
+                command,
+                reactorName,
+                channel: item.channel,
+                threadTs,
+                messageTs: item.ts,
+                reactedMessageText,
+                reactedMessageAuthor,
+            });
+            ctx.ui.notify(`${reactorName} reacted with :${reactionName}:`, "info");
+            const threadInfo = threads.get(threadTs);
+            deps.pushInboxMessage({
+                channel: item.channel,
+                threadTs,
+                userId: user,
+                text: reactionMessage,
+                timestamp: evt.event_ts ?? item.ts,
+                scope: buildSlackThreadRuntimeScope({
+                    channelId: item.channel,
+                    context: threadInfo?.context,
+                }),
+            });
+            deps.persistState();
+            deps.updateBadge();
+            await deps.addReaction(item.channel, item.ts, "white_check_mark");
+            deps.maybeDrainInboxIfIdle(ctx);
+        }
+        catch (err) {
+            console.error(`[slack-bridge] reaction trigger failed: ${deps.formatError(err)}`);
+            await deps.addReaction(item.channel, item.ts, "x");
+        }
+    }
+    async function onMessage(evt, ctx) {
+        if (shuttingDown)
+            return;
+        const threads = deps.getThreads();
+        const classified = classifyMessage(evt, getCurrentBotUserId(), new Set(threads.keys()));
+        if (!classified.relevant)
+            return;
+        const { threadTs, channel, userId, text, isDM, isChannelMention, messageTs, metadata } = classified;
+        if (!threads.has(threadTs)) {
+            threads.set(threadTs, { channelId: channel, threadTs, userId, source: "slack" });
+        }
+        const ownership = await ensureLocalThreadOwnership(channel, threadTs);
+        if (ownership !== "continue") {
+            return;
+        }
+        if (!deps.isUserAllowed(userId)) {
+            await deps.slack("chat.postMessage", deps.getBotToken(), {
+                channel,
+                thread_ts: threadTs,
+                text: "Sorry, I can only respond to authorized users. Please contact an admin if you need access.",
+            });
+            return;
+        }
+        if (isDM) {
+            deps.setLastDmChannel(channel);
+        }
+        deps.persistState();
+        const confirmationResult = deps.consumeConfirmationReply(threadTs, text);
+        const messageText = confirmationResult === null
+            ? text
+            : confirmationResult.approved
+                ? `${text}\n\n✅ User approved security confirmation request in this thread.`
+                : `${text}\n\n❌ User denied security confirmation request in this thread.`;
+        const name = await deps.resolveUser(userId);
+        if (shuttingDown)
+            return;
+        ctx.ui.notify(`${name}: ${text.slice(0, 100)}`, "info");
+        void deps.beginThreadStatus?.(channel, threadTs, "is thinking…");
+        void deps.addReaction(channel, messageTs, "eyes");
+        const pending = deps.getPendingEyes().get(threadTs) ?? [];
+        pending.push({ channel, messageTs });
+        deps.getPendingEyes().set(threadTs, pending);
+        const threadInfo = threads.get(threadTs);
+        deps.pushInboxMessage({
+            channel,
+            threadTs,
+            userId,
+            text: messageText,
+            timestamp: messageTs,
+            scope: buildSlackThreadRuntimeScope({
+                channelId: channel,
+                context: threadInfo?.context,
+            }),
+            ...(isChannelMention && { isChannelMention: true }),
+            ...(metadata ? { metadata } : {}),
+        });
+        deps.updateBadge();
+        deps.maybeDrainInboxIfIdle(ctx);
+    }
+    async function queueInteractiveInboxEvent(normalized, ctx) {
+        const threads = deps.getThreads();
+        if (!threads.has(normalized.threadTs)) {
+            threads.set(normalized.threadTs, {
+                channelId: normalized.channel,
+                threadTs: normalized.threadTs,
+                userId: normalized.userId,
+                source: "slack",
+            });
+        }
+        const ownership = await ensureLocalThreadOwnership(normalized.channel, normalized.threadTs);
+        if (ownership !== "continue") {
+            return;
+        }
+        if (!deps.isUserAllowed(normalized.userId)) {
+            await deps.slack("chat.postMessage", deps.getBotToken(), {
+                channel: normalized.channel,
+                thread_ts: normalized.threadTs,
+                text: "Sorry, I can only respond to authorized users. Please contact an admin if you need access.",
+            });
+            return;
+        }
+        if (normalized.channel.startsWith("D")) {
+            deps.setLastDmChannel(normalized.channel);
+        }
+        deps.persistState();
+        void deps.beginThreadStatus?.(normalized.channel, normalized.threadTs, "is thinking…");
+        const name = await deps.resolveUser(normalized.userId);
+        if (shuttingDown)
+            return;
+        ctx.ui.notify(`${name}: ${normalized.text.slice(0, 100)}`, "info");
+        const threadInfo = threads.get(normalized.threadTs);
+        deps.pushInboxMessage({
+            channel: normalized.channel,
+            threadTs: normalized.threadTs,
+            userId: normalized.userId,
+            text: normalized.text,
+            timestamp: normalized.timestamp,
+            metadata: normalized.metadata,
+            scope: buildSlackThreadRuntimeScope({
+                channelId: normalized.channel,
+                context: threadInfo?.context,
+            }),
+        });
+        deps.updateBadge();
+        deps.maybeDrainInboxIfIdle(ctx);
+    }
+    const threadContextPort = {
+        resolveThreadChannel: (threadTs) => deps.resolveThreadChannel(threadTs),
+        noteThreadReply: (threadTs, channelId) => {
+            trackOwnedThread(threadTs, channelId, "slack");
+            deps.claimOwnedThread(threadTs, channelId, "slack");
+        },
+        clearPendingAttention: (threadTs) => {
+            clearPendingAttention(threadTs);
+        },
+    };
+    return {
+        async connect(ctx) {
+            shuttingDown = false;
+            const socket = new SlackSocketModeClient({
+                slack: deps.slack,
+                botToken: deps.getBotToken(),
+                appToken: deps.getAppToken(),
+                resolveBotUserIdOnConnect: false,
+                dedup: deps.dedup,
+                abortAndWait: deps.abortSlackRequests,
+                onOpen: () => deps.setExtStatus(ctx, "ok"),
+                onReconnectScheduled: () => {
+                    if (!shuttingDown && deps.isSingleRuntimeActive()) {
+                        deps.setExtStatus(ctx, "reconnecting");
+                    }
+                },
+                onError: (error) => {
+                    if (!isAbortError(error)) {
+                        console.error(`[slack-bridge] Slack access: ${deps.formatError(error)}`);
+                    }
+                },
+                onThreadStarted: (event) => onThreadStarted(event),
+                onThreadContextChanged: (event) => onContextChanged(event),
+                onAppHomeOpened: (event) => onAppHomeOpened(event, ctx),
+                onMessage: (event) => onMessage(event, ctx),
+                onReactionAdded: (event) => onReactionAdded(event, ctx),
+                onMemberJoinedChannel: async ({ channel, isSelf }) => {
+                    if (!isSelf)
+                        return;
+                    ctx.ui.notify(`Pinet added to channel ${channel}`, "info");
+                    deps.pushInboxMessage({
+                        channel,
+                        threadTs: "",
+                        userId: "system",
+                        text: `Pinet was added to channel <#${channel}>. You can now post messages there.`,
+                        timestamp: String(Date.now() / 1000),
+                    });
+                    deps.updateBadge();
+                    deps.maybeDrainInboxIfIdle(ctx);
+                },
+                onInteractive: (event) => queueInteractiveInboxEvent(event, ctx),
+            });
+            slackSocket = socket;
+            await socket.connect();
+        },
+        async disconnect() {
+            shuttingDown = true;
+            const socket = slackSocket;
+            slackSocket = null;
+            if (socket) {
+                await socket.disconnect();
+                return;
+            }
+            await deps.abortSlackRequests();
+        },
+        getBotUserId() {
+            return slackSocket?.getBotUserId() ?? null;
+        },
+        isConnected() {
+            return slackSocket?.isConnected() ?? false;
+        },
+        isShuttingDown() {
+            return shuttingDown;
+        },
+        resetShutdownState() {
+            shuttingDown = false;
+        },
+        trackOwnedThread(threadTs, channelId, source = "slack") {
+            trackOwnedThread(threadTs, channelId, source);
+        },
+        getThreadContextPort() {
+            return threadContextPort;
+        },
+    };
+}