resolveDiscordGuildEntry,

shouldEmitDiscordReactionNotification,

} from "./allow-list.js";

import {

resolveDiscordChannelInfoSafe,

resolveDiscordChannelParentIdSafe,

} from "./channel-access.js";

import { formatDiscordReactionEmoji, formatDiscordUserTag } from "./format.js";

import { resolveDiscordChannelInfo } from "./message-utils.js";

import { setPresence } from "./presence-cache.js";

import { isThreadArchived } from "./thread-bindings.discord-api.js";

import { resolveFetchedDiscordThreadLikeChannelContext } from "./thread-channel-context.js";

import { closeDiscordThreadSessions } from "./thread-session-close.js";

import { normalizeDiscordListenerTimeoutMs, runDiscordTaskWithTimeout } from "./timeouts.js";

guildEntries?: Record<string, import("./allow-list.js").DiscordGuildEntryResolved>;

};

type DiscordReactionMode = "off" | "own" | "all" | "allowlist";

type DiscordReactionChannelConfig = ReturnType<typeof resolveDiscordChannelConfigWithFallback>;

type DiscordReactionIngressAccess = Awaited<ReturnType<typeof authorizeDiscordReactionIngress>>;

type DiscordFetchedReactionMessage = { author?: User } | null;

const DISCORD_SLOW_LISTENER_THRESHOLD_MS = 30_000;

const discordEventQueueLog = createSubsystemLogger("discord/event-queue");

return { allowed: true };

}

async function handleDiscordThreadReactionNotification(params: {

reactionMode: DiscordReactionMode;

message: DiscordReactionEvent["message"];

parentId?: string;

resolveThreadChannelAccess: () => Promise<{

access: DiscordReactionIngressAccess;

channelConfig: DiscordReactionChannelConfig;

}>;

shouldNotifyReaction: (options: {

mode: DiscordReactionMode;

messageAuthorId?: string;

channelConfig?: DiscordReactionChannelConfig;

}) => boolean;

resolveReactionBase: () => { baseText: string; contextKey: string };

emitReaction: (text: string, parentPeerId?: string) => void;

emitReactionWithAuthor: (message: DiscordFetchedReactionMessage) => void;

}) {

if (params.reactionMode === "off") {

return;

}

if (params.reactionMode === "all" || params.reactionMode === "allowlist") {

const { access, channelConfig } = await params.resolveThreadChannelAccess();

if (

!access.allowed ||

!params.shouldNotifyReaction({ mode: params.reactionMode, channelConfig })

) {

return;

}

const { baseText } = params.resolveReactionBase();

params.emitReaction(baseText, params.parentId);

return;

}

const message = await params.message.fetch().catch(() => null);

const { access, channelConfig } = await params.resolveThreadChannelAccess();

const messageAuthorId = message?.author?.id ?? undefined;

if (

!access.allowed ||

!params.shouldNotifyReaction({

mode: params.reactionMode,

messageAuthorId,

channelConfig,

})

) {

return;

}

params.emitReactionWithAuthor(message);

}

async function handleDiscordChannelReactionNotification(params: {

isGuildMessage: boolean;

reactionMode: DiscordReactionMode;

message: DiscordReactionEvent["message"];

channelConfig: DiscordReactionChannelConfig;

parentId?: string;

authorizeReactionIngressForChannel: (

channelConfig: DiscordReactionChannelConfig,

) => Promise<DiscordReactionIngressAccess>;

shouldNotifyReaction: (options: {

mode: DiscordReactionMode;

messageAuthorId?: string;

channelConfig?: DiscordReactionChannelConfig;

}) => boolean;

resolveReactionBase: () => { baseText: string; contextKey: string };

emitReaction: (text: string, parentPeerId?: string) => void;

emitReactionWithAuthor: (message: DiscordFetchedReactionMessage) => void;

}) {

if (params.isGuildMessage) {

const access = await params.authorizeReactionIngressForChannel(params.channelConfig);

if (!access.allowed) {

return;

}

}

if (params.reactionMode === "off") {

return;

}

if (params.reactionMode === "all" || params.reactionMode === "allowlist") {

if (

!params.shouldNotifyReaction({

mode: params.reactionMode,

channelConfig: params.channelConfig,

})

) {

return;

}

const { baseText } = params.resolveReactionBase();

params.emitReaction(baseText, params.parentId);

return;

}

const message = await params.message.fetch().catch(() => null);

const messageAuthorId = message?.author?.id ?? undefined;

if (

!params.shouldNotifyReaction({

mode: params.reactionMode,

messageAuthorId,

channelConfig: params.channelConfig,

})

) {

return;

}

params.emitReactionWithAuthor(message);

}

async function handleDiscordReactionEvent(

params: {

data: DiscordReactionEvent;

if (!channel) {

return;

}

const channelInfo = resolveDiscordChannelInfoSafe(channel);

const channelName = channelInfo.name;

const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";

const channelType = channelInfo.type;

const channelContext = await resolveFetchedDiscordThreadLikeChannelContext({

client,

channel,

channelIdFallback: data.channel_id,

});

const channelName = channelContext.channelName;

const channelSlug = channelContext.channelSlug;

const channelType = channelContext.channelType;

const isDirectMessage = channelType === ChannelType.DM;

const isGroupDm = channelType === ChannelType.GroupDM;

const isThreadChannel =

channelType === ChannelType.PublicThread ||

channelType === ChannelType.PrivateThread ||

channelType === ChannelType.AnnouncementThread;

const isThreadChannel = channelContext.isThreadChannel;

const memberRoleIds = Array.isArray(data.rawMember?.roles)

? data.rawMember.roles.map((roleId: string) => roleId)

: [];

return;

}

}

let parentId = resolveDiscordChannelParentIdSafe(channel);

let parentName: string | undefined;

let parentSlug = "";

const parentId = isThreadChannel ? channelContext.threadParentId : channelContext.parentId;

const parentName = isThreadChannel ? channelContext.threadParentName : undefined;

const parentSlug = isThreadChannel ? channelContext.threadParentSlug : "";

let reactionBase: { baseText: string; contextKey: string } | null = null;

const resolveReactionBase = () => {

if (reactionBase) {

});

};

const shouldNotifyReaction = (options: {

mode: "off" | "own" | "all" | "allowlist";

mode: DiscordReactionMode;

messageAuthorId?: string;

channelConfig?: ReturnType<typeof resolveDiscordChannelConfigWithFallback>;

channelConfig?: DiscordReactionChannelConfig;

}) =>

shouldEmitDiscordReactionNotification({

mode: options.mode,

const text = authorLabel ? `${baseText} from ${authorLabel}` : baseText;

emitReaction(text, parentId);

};

const loadThreadParentInfo = async () => {

if (!parentId) {

return;

}

const parentInfo = await resolveDiscordChannelInfo(client, parentId);

parentName = parentInfo?.name;

parentSlug = parentName ? normalizeDiscordSlug(parentName) : "";

};

const resolveThreadChannelConfig = () =>

resolveDiscordChannelConfigWithFallback({

guildInfo,

scope: "thread",

});

const authorizeReactionIngressForChannel = async (

channelConfig: ReturnType<typeof resolveDiscordChannelConfigWithFallback>,

channelConfig: DiscordReactionChannelConfig,

) =>

await authorizeDiscordReactionIngress({

...reactionIngressBase,

channelConfig,

});

const resolveThreadChannelAccess = async (channelInfo: { parentId?: string } | null) => {

parentId = channelInfo?.parentId;

await loadThreadParentInfo();

const resolveThreadChannelAccess = async () => {

const channelConfig = resolveThreadChannelConfig();

const access = await authorizeReactionIngressForChannel(channelConfig);

return { access, channelConfig };

};

// Parallelize async operations for thread channels

if (isThreadChannel) {

const reactionMode = guildInfo?.reactionNotifications ?? "own";

// Early exit: skip fetching message if notifications are off

if (reactionMode === "off") {

return;

}

const channelInfoPromise = parentId

? Promise.resolve({ parentId })

: resolveDiscordChannelInfo(client, data.channel_id);

// Fast path: for "all" and "allowlist" modes, we don't need to fetch the message

if (reactionMode === "all" || reactionMode === "allowlist") {

const channelInfo = await channelInfoPromise;

const { access: threadAccess, channelConfig: threadChannelConfig } =

await resolveThreadChannelAccess(channelInfo);

if (!threadAccess.allowed) {

return;

}

if (

!shouldNotifyReaction({

mode: reactionMode,

channelConfig: threadChannelConfig,

})

) {

return;

}

const { baseText } = resolveReactionBase();

emitReaction(baseText, parentId);

return;

}

// For "own" mode, we need to fetch the message to check the author

const messagePromise = data.message.fetch().catch(() => null);

const [channelInfo, message] = await Promise.all([channelInfoPromise, messagePromise]);

const { access: threadAccess, channelConfig: threadChannelConfig } =

await resolveThreadChannelAccess(channelInfo);

if (!threadAccess.allowed) {

return;

}

const messageAuthorId = message?.author?.id ?? undefined;

if (

!shouldNotifyReaction({

mode: reactionMode,

messageAuthorId,

channelConfig: threadChannelConfig,

})

) {

return;

}

emitReactionWithAuthor(message);

await handleDiscordThreadReactionNotification({

reactionMode,

message: data.message,

parentId,

resolveThreadChannelAccess,

shouldNotifyReaction,

resolveReactionBase,

emitReaction,

emitReactionWithAuthor,

});

return;

}

parentSlug,

scope: "channel",

});

if (isGuildMessage) {

const channelAccess = await authorizeReactionIngressForChannel(channelConfig);

if (!channelAccess.allowed) {

return;

}

}

const reactionMode = guildInfo?.reactionNotifications ?? "own";

// Early exit: skip fetching message if notifications are off

if (reactionMode === "off") {

return;

}

// Fast path: for "all" and "allowlist" modes, we don't need to fetch the message

if (reactionMode === "all" || reactionMode === "allowlist") {

if (!shouldNotifyReaction({ mode: reactionMode, channelConfig })) {

return;

}

const { baseText } = resolveReactionBase();

emitReaction(baseText, parentId);

return;

}

// For "own" mode, we need to fetch the message to check the author

const message = await data.message.fetch().catch(() => null);

const messageAuthorId = message?.author?.id ?? undefined;

if (!shouldNotifyReaction({ mode: reactionMode, messageAuthorId, channelConfig })) {

return;

}

emitReactionWithAuthor(message);

await handleDiscordChannelReactionNotification({

isGuildMessage,

reactionMode,

message: data.message,

channelConfig,

parentId,

authorizeReactionIngressForChannel,

shouldNotifyReaction,

resolveReactionBase,

emitReaction,

emitReactionWithAuthor,

});

} catch (err) {

params.logger.error(danger(`discord reaction handler failed: ${String(err)}`));

}