@meetquinn/animactl 0.1.1-canary.21.1.cd63d38

package/dist/server/inbox/slack-profiles.js

@@ -0,0 +1,119 @@
+import { errorMessage } from '../ids.js';
+import { SlackWorkspaceDirectoryService, } from '../slack/workspace-directory.service.js';
+import { atLabel, channelLabel, extractSlackChannelMentionIds, extractSlackUserMentionIds, } from '../slack/slack.helper.js';
+export class SlackProfileResolver {
+    conversations = new Map();
+    users = new Map();
+    async user(input) {
+        const cacheKey = `${input.teamId}:${input.userId}`;
+        if (this.users.has(cacheKey))
+            return this.users.get(cacheKey);
+        try {
+            const user = await new SlackWorkspaceDirectoryService({
+                client: input.client,
+                teamId: input.teamId,
+            }).getUser(input.userId);
+            const profile = normalizeSlackUserProfile(input.teamId, input.userId, user);
+            this.users.set(cacheKey, profile);
+            return profile;
+        }
+        catch (error) {
+            console.warn(`Slack users.info failed for ${input.userId}: ${errorMessage(error)}`);
+            this.users.set(cacheKey, undefined);
+            return undefined;
+        }
+    }
+    async conversation(input) {
+        const cacheKey = `${input.teamId}:${input.channelId}`;
+        if (this.conversations.has(cacheKey))
+            return this.conversations.get(cacheKey);
+        try {
+            const conversation = await new SlackWorkspaceDirectoryService({
+                client: input.client,
+                teamId: input.teamId,
+            }).getConversation(input.channelId);
+            const profile = normalizeSlackConversationProfile(conversation);
+            this.conversations.set(cacheKey, profile);
+            return profile;
+        }
+        catch (error) {
+            console.warn(`Slack conversations.info failed for ${input.channelId}: ${errorMessage(error)}`);
+            this.conversations.set(cacheKey, undefined);
+            return undefined;
+        }
+    }
+    async userMentionLabels(input) {
+        const mentions = await this.userMentions(input);
+        return new Map(mentions.map((mention) => [mention.userId, slackMentionLabel(mention)]));
+    }
+    async channelMentionLabels(input) {
+        const mentions = await this.channelMentions(input);
+        return new Map(mentions.map((mention) => [mention.channelId, slackChannelMentionLabel(mention)]));
+    }
+    async userMentions(input) {
+        const userIds = extractSlackUserMentionIds(input.text);
+        const profiles = await Promise.all(userIds.map(async (userId) => ({
+            profile: await this.user({
+                client: input.client,
+                teamId: input.teamId,
+                userId,
+            }),
+            userId,
+        })));
+        return profiles.map(({ profile, userId }) => ({
+            ...(profile ?? {}),
+            userId,
+        }));
+    }
+    async channelMentions(input) {
+        const channelIds = extractSlackChannelMentionIds(input.text);
+        const profiles = await Promise.all(channelIds.map(async (channelId) => ({
+            profile: await this.conversation({
+                channelId,
+                client: input.client,
+                teamId: input.teamId,
+            }),
+            channelId,
+        })));
+        return profiles.map(({ profile, channelId }) => ({
+            channelId,
+            ...(profile?.name ? { channelName: profile.name } : {}),
+        }));
+    }
+}
+function slackMentionLabel(mention) {
+    if (mention.handle)
+        return atLabel(mention.handle);
+    if (mention.displayName)
+        return atLabel(mention.displayName);
+    return atLabel(mention.userId);
+}
+function slackChannelMentionLabel(mention) {
+    return channelLabel(mention.channelName ?? mention.channelId);
+}
+function normalizeSlackUserProfile(_teamId, userId, user) {
+    const realName = user?.profile?.real_name?.trim() || user?.real_name?.trim() || undefined;
+    const handle = user?.name?.trim() || undefined;
+    const timezone = slackUserTimezone(user);
+    return {
+        displayName: user?.profile?.display_name?.trim() || realName || handle || userId,
+        handle,
+        realName,
+        ...(timezone ? { timezone } : {}),
+    };
+}
+function normalizeSlackConversationProfile(conversation) {
+    const name = conversation?.name_normalized?.trim() || conversation?.name?.trim();
+    return name ? { name } : {};
+}
+function slackUserTimezone(user) {
+    const name = user?.tz?.trim();
+    if (!name)
+        return undefined;
+    const label = user?.tz_label?.trim();
+    return {
+        name,
+        ...(label ? { label } : {}),
+        ...(typeof user?.tz_offset === 'number' ? { offsetSeconds: user.tz_offset } : {}),
+    };
+}

package/dist/server/inbox/slack-subscriber.d.ts

@@ -0,0 +1,23 @@
+import { WakeQueueService } from './wake-queue.service.js';
+export interface SlackInboxSubscriberOptions {
+    agentRuntimeKind: string;
+    appToken: string;
+    botToken: string;
+    queue: WakeQueueService;
+}
+export declare class SlackInboxSubscriber {
+    private readonly options;
+    private readonly app;
+    private readonly slackProfiles;
+    constructor(options: SlackInboxSubscriberOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private createApp;
+    private handleGlobalShortcut;
+    private handleMessageShortcut;
+    private handleInteractiveAskAction;
+    private handleSlackWorkspaceDirectoryEvent;
+    private handleSlackEvent;
+    private slackPermalink;
+}
+//# sourceMappingURL=slack-subscriber.d.ts.map

package/dist/server/inbox/slack-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-subscriber.d.ts","sourceRoot":"","sources":["../../../server/inbox/slack-subscriber.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAE,gBAAgB,EAA+B,MAAM,yBAAyB,CAAC;AAExF,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAED,qBAAa,oBAAoB;IAInB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAM;IAC1B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8B;gBAE/B,OAAO,EAAE,2BAA2B;IAI3D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,OAAO,CAAC,SAAS;YA4EH,oBAAoB;YASpB,qBAAqB;YAOrB,0BAA0B;YA2C1B,kCAAkC;YAYlC,gBAAgB;YA2DhB,cAAc;CAgB7B"}

package/dist/server/inbox/slack-subscriber.js

@@ -0,0 +1,301 @@
+import { App, LogLevel } from '@slack/bolt';
+import { activityServiceForAgent } from '../activities/activity.service.js';
+import { interactiveAskServiceForAgent } from '../asks/interactive-ask.service.js';
+import { errorMessage, slackMessageEventId } from '../ids.js';
+import { createSlackWebClient } from '../slack/client.js';
+import { defaultSlackShortcutService, userIdFromShortcutBody, } from '../slack/shortcut.service.js';
+import { SLACK_STOP_CONFIRM_VIEW_CALLBACK_ID, SLACK_VIEW_REMINDER_DETAIL_ACTION_ID, SLACK_VIEW_REMINDERS_ACTION_ID } from '../slack/shortcuts.js';
+import { SlackWorkspaceDirectoryService } from '../slack/workspace-directory.service.js';
+import { replaceSlackChannelMentions, replaceSlackUserMentions, normalizeSlackEventFiles, } from '../slack/slack.helper.js';
+import { isSlackEvent, isRoutableSlackMessage, normalizeSlackMessage, slackSurfaceForEvent, } from './slack-events.js';
+import { SlackProfileResolver } from './slack-profiles.js';
+import { slackRuntimeDecision } from './slack-subscription.service.js';
+export class SlackInboxSubscriber {
+    options;
+    app;
+    slackProfiles = new SlackProfileResolver();
+    constructor(options) {
+        this.options = options;
+        this.app = this.createApp();
+    }
+    async start() {
+        await this.app.start();
+    }
+    async stop() {
+        await this.app.stop().catch((error) => {
+            console.error(`Slack app stop failed: ${errorMessage(error)}`);
+        });
+    }
+    createApp() {
+        const app = new App({
+            appToken: this.options.appToken,
+            ignoreSelf: true,
+            logLevel: LogLevel.INFO,
+            socketMode: true,
+            token: this.options.botToken,
+        });
+        app.message(async ({ body, client, event }) => {
+            await this.handleSlackEvent(body, event, client);
+        });
+        app.event('app_mention', async ({ body, client, event }) => {
+            await this.handleSlackEvent(body, event, client);
+        });
+        app.action(/^anima\.ask\.answer/, async ({ ack, action, body, client }) => {
+            await ack();
+            await this.handleInteractiveAskAction(body, action, client);
+        });
+        app.action(SLACK_VIEW_REMINDERS_ACTION_ID, async ({ ack, body, client }) => {
+            await ack();
+            const triggerId = body.trigger_id;
+            if (!triggerId)
+                return;
+            await defaultSlackShortcutService.showRemindersView({
+                agentId: this.options.queue.agentId,
+                client,
+                triggerId,
+            });
+        });
+        app.action(SLACK_VIEW_REMINDER_DETAIL_ACTION_ID, async ({ ack, action, body, client }) => {
+            await ack();
+            const triggerId = body.trigger_id;
+            const reminderId = action.value;
+            if (!triggerId || !reminderId)
+                return;
+            await defaultSlackShortcutService.showReminderDetailView({
+                agentId: this.options.queue.agentId,
+                client,
+                reminderId,
+                triggerId,
+            });
+        });
+        app.shortcut({
+            callback_id: 'anima.home',
+            type: 'shortcut',
+        }, async ({ ack, body, client }) => {
+            await ack();
+            await this.handleGlobalShortcut(body, client);
+        });
+        app.shortcut({
+            callback_id: 'anima.hand_to_agent',
+            type: 'message_action',
+        }, async ({ ack, body }) => {
+            await ack();
+            await this.handleMessageShortcut(body);
+        });
+        app.view({
+            callback_id: SLACK_STOP_CONFIRM_VIEW_CALLBACK_ID,
+            type: 'view_submission',
+        }, async ({ ack, body, view }) => {
+            const resultView = await defaultSlackShortcutService.confirmStop({
+                agentId: this.options.queue.agentId,
+                userId: userIdFromShortcutBody(body),
+                view,
+            });
+            await ack({
+                response_action: 'update',
+                view: resultView,
+            });
+        });
+        for (const eventName of SLACK_DIRECTORY_EVENTS) {
+            app.event(eventName, async ({ body, client, event }) => {
+                await this.handleSlackWorkspaceDirectoryEvent(body, event, client);
+            });
+        }
+        return app;
+    }
+    async handleGlobalShortcut(body, client) {
+        const webClient = client ?? createSlackWebClient(this.options.botToken);
+        await defaultSlackShortcutService.handleShortcut({
+            agentId: this.options.queue.agentId,
+            body: body,
+            client: webClient,
+        });
+    }
+    async handleMessageShortcut(body) {
+        await defaultSlackShortcutService.handMessageToAgent({
+            agentId: this.options.queue.agentId,
+            body: body,
+        });
+    }
+    async handleInteractiveAskAction(body, action, client) {
+        const value = interactiveAskActionValue(action);
+        const userId = interactiveAskUserId(body);
+        if (!value || !userId) {
+            console.warn('Interactive ask action missing value or user id');
+            return;
+        }
+        const webClient = client ?? createSlackWebClient(this.options.botToken);
+        const askService = interactiveAskServiceForAgent(this.options.queue.agentId);
+        const result = await askService.answerAsk({
+            askId: value.askId,
+            client: webClient,
+            optionId: value.optionId,
+            userId,
+        });
+        if (result.outcome === 'answered' && result.ask) {
+            await askService.replaceAnsweredMessage({
+                ask: result.ask,
+                client: webClient,
+            }).catch((error) => {
+                console.warn(`Interactive ask message update failed: ${errorMessage(error)}`);
+            });
+        }
+        if (result.outcome === 'forbidden' && result.ask) {
+            await askService.notifyForbiddenClick({
+                ask: result.ask,
+                client: webClient,
+                userId,
+            }).catch((error) => {
+                console.warn(`Interactive ask forbidden notice failed: ${errorMessage(error)}`);
+            });
+        }
+        console.log(JSON.stringify({
+            agentRuntime: this.options.agentRuntimeKind,
+            askId: value.askId,
+            interactiveAsk: true,
+            optionId: value.optionId,
+            outcome: result.outcome,
+            queued: Boolean(result.queued),
+            userId,
+        }, null, 2));
+    }
+    async handleSlackWorkspaceDirectoryEvent(body, event, client) {
+        const envelope = body;
+        const rawEvent = event;
+        const webClient = client ?? createSlackWebClient(this.options.botToken);
+        await new SlackWorkspaceDirectoryService({
+            client: webClient,
+            teamId: envelope.team_id ?? rawEvent.team,
+        }).applyEvent(rawEvent).catch((error) => {
+            console.warn(`Slack directory cache update failed: ${errorMessage(error)}`);
+        });
+    }
+    async handleSlackEvent(body, event, client) {
+        const rawEvent = event;
+        if (!isRoutableSlackMessage(rawEvent))
+            return;
+        const envelope = body;
+        const teamId = envelope.team_id ?? rawEvent.team ?? 'unknown-team';
+        const duplicate = Boolean(rawEvent.channel && rawEvent.ts && await this.options.queue.find(slackMessageEventId(teamId, rawEvent.channel, rawEvent.ts)));
+        const runtimeDecision = await slackRuntimeDecision(rawEvent, { agentId: this.options.queue.agentId, duplicate });
+        if (!runtimeDecision.shouldStartRuntime) {
+            console.log(JSON.stringify(slackIgnoredLog(rawEvent, this.options.agentRuntimeKind, runtimeDecision.reason), null, 2));
+            return;
+        }
+        const webClient = client ?? createSlackWebClient(this.options.botToken);
+        const userProfile = await this.slackProfiles.user({
+            client: webClient,
+            teamId,
+            userId: rawEvent.user,
+        });
+        const conversationProfile = await this.slackProfiles.conversation({
+            channelId: rawEvent.channel,
+            client: webClient,
+            teamId,
+        });
+        const mentionLabels = await this.slackProfiles.userMentionLabels({
+            client: webClient,
+            teamId,
+            text: rawEvent.text,
+        });
+        const channelMentionLabels = await this.slackProfiles.channelMentionLabels({
+            client: webClient,
+            teamId,
+            text: rawEvent.text,
+        });
+        const permalink = await this.slackPermalink(rawEvent, webClient);
+        const downloadedFiles = normalizeSlackEventFiles(rawEvent.files);
+        const normalizedEvent = normalizeSlackMessage({
+            ...(runtimeDecision.attentionSuggestion ? { attentionSuggestion: runtimeDecision.attentionSuggestion } : {}),
+            envelope,
+            channelName: conversationProfile?.name,
+            event: rawEvent,
+            ...(downloadedFiles ? { files: downloadedFiles } : {}),
+            permalink,
+            text: replaceSlackChannelMentions(replaceSlackUserMentions(rawEvent.text, mentionLabels), channelMentionLabels),
+            userProfile,
+        });
+        const decision = await this.options.queue.enqueue(normalizedEvent);
+        if (runtimeDecision.reason === 'mention' && runtimeDecision.subscription && !decision.duplicate) {
+            const { channelId, channelName } = slackSurfaceForEvent(normalizedEvent);
+            activityServiceForAgent(this.options.queue.agentId).record({
+                type: 'anima.subscription.add',
+                payload: { channelId, ...(channelName ? { channelName } : {}), kind: runtimeDecision.subscription.kind },
+            }).catch((err) => console.warn(`subscription.add activity: ${errorMessage(err)}`));
+        }
+        console.log(JSON.stringify(slackDecisionLog(decision, this.options.agentRuntimeKind, runtimeDecision), null, 2));
+    }
+    async slackPermalink(event, client) {
+        if (!event.channel || !event.ts)
+            return undefined;
+        try {
+            const response = await client.chat.getPermalink({
+                channel: event.channel,
+                message_ts: event.ts,
+            });
+            return response.permalink;
+        }
+        catch (error) {
+            console.warn(`Slack permalink lookup failed for ${event.channel}/${event.ts}: ${errorMessage(error)}`);
+            return undefined;
+        }
+    }
+}
+const SLACK_DIRECTORY_EVENTS = [
+    'channel_archive',
+    'channel_created',
+    'channel_deleted',
+    'channel_rename',
+    'channel_unarchive',
+    'team_join',
+    'user_change',
+];
+function slackDecisionLog(decision, agentRuntimeKind, runtimeDecision) {
+    return {
+        agentRuntime: agentRuntimeKind,
+        duplicate: Boolean(decision.duplicate),
+        ...(runtimeDecision?.subscription ? { subscription: runtimeDecision.subscription } : {}),
+        ingested: !decision.duplicate,
+        queued: Boolean(decision.queued),
+        reason: runtimeDecision?.reason,
+        itemId: decision.item.id,
+        surface: isSlackEvent(decision.item)
+            ? slackSurfaceForEvent(decision.item)
+            : undefined,
+    };
+}
+function slackIgnoredLog(event, agentRuntimeKind, reason = 'not_addressed') {
+    return {
+        agentRuntime: agentRuntimeKind,
+        channel: event.channel,
+        ignored: true,
+        ingested: false,
+        reason,
+        ts: event.ts,
+    };
+}
+function interactiveAskActionValue(action) {
+    if (!isRecord(action) || typeof action['value'] !== 'string')
+        return undefined;
+    try {
+        const value = JSON.parse(action['value']);
+        if (!isRecord(value) || typeof value['askId'] !== 'string' || typeof value['optionId'] !== 'string') {
+            return undefined;
+        }
+        return { askId: value['askId'], optionId: value['optionId'] };
+    }
+    catch {
+        return undefined;
+    }
+}
+function interactiveAskUserId(body) {
+    if (!isRecord(body))
+        return undefined;
+    const user = body['user'];
+    if (isRecord(user) && typeof user['id'] === 'string')
+        return user['id'];
+    return undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/dist/server/inbox/slack-subscription.service.d.ts

@@ -0,0 +1,74 @@
+import { subscriptionStatus, type SubscriptionRecord } from '../storage/schema/subscription.store.js';
+export { subscriptionStatus };
+export type { SubscriptionRecord };
+export declare const THREAD_ACTIVE_WINDOW_MS: number;
+interface SlackRuntimeMessageEvent {
+    bot_id?: string;
+    channel?: string;
+    channel_type?: string;
+    subtype?: string;
+    text?: string;
+    thread_ts?: string;
+    ts?: string;
+    type?: string;
+    user?: string;
+}
+export interface SlackRuntimeDecision {
+    attentionSuggestion?: string;
+    subscription?: {
+        status: 'following' | 'muted';
+        subscriptionId: string;
+        kind: SubscriptionRecord['kind'];
+        threadTs?: string;
+    };
+    reason: 'channel_follow' | 'dm' | 'mention' | 'muted' | 'not_addressed' | 'thread_follow';
+    shouldStartRuntime: boolean;
+}
+export interface AttentionMap {
+    activeThreads: SubscriptionRecord[];
+    channels: Array<{
+        channelId: string;
+        channelName?: string;
+        status: 'following' | 'muted';
+        subscription?: SubscriptionRecord;
+    }>;
+    mutedThreads: SubscriptionRecord[];
+    quietThreadCount: number;
+    quietThreads: SubscriptionRecord[];
+}
+export declare function shouldReply(event: SlackRuntimeMessageEvent): boolean;
+export declare function listSubscriptionsForAgent(agentId: string): Promise<SubscriptionRecord[]>;
+export declare function attentionMapForSubscriptions(input: {
+    includeAll?: boolean;
+    memberChannels?: Array<{
+        id: string;
+        name?: string;
+    }>;
+    nowMs?: number;
+    subscriptions: SubscriptionRecord[];
+}): AttentionMap;
+export declare function muteSubscriptionForAgent(input: {
+    agentId: string;
+    channelId: string;
+    channelName?: string;
+    threadTs?: string;
+    nowMs?: number;
+}): Promise<SubscriptionRecord>;
+export declare function slackRuntimeDecision(event: SlackRuntimeMessageEvent, options: {
+    agentId?: string;
+    duplicate?: boolean;
+    nowMs?: number;
+}): Promise<SlackRuntimeDecision>;
+export declare function recordChannelPost(input: {
+    agentId: string;
+    channelId: string;
+    nowMs?: number;
+}): Promise<SubscriptionRecord | undefined>;
+export declare function ensureThreadSubscriptionForSentMessage(input: {
+    agentId: string;
+    channelId: string;
+    messageTs: string;
+    nowMs?: number;
+    threadTs?: string;
+}): Promise<SubscriptionRecord | undefined>;
+//# sourceMappingURL=slack-subscription.service.d.ts.map

package/dist/server/inbox/slack-subscription.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-subscription.service.d.ts","sourceRoot":"","sources":["../../../server/inbox/slack-subscription.service.ts"],"names":[],"mappings":"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"}