jeopi-cli 16.6.13 → 16.6.17

package/src/messenger/discord.ts

@@ -6,9 +6,10 @@ import type { MessengerAdapter, MessengerMessage, MessengerPlatformConfig, Messe
 // Protocol: https://docs.discord.com/developers/events/gateway
 // Close codes: https://docs.discord.com/developers/topics/opcodes-and-status-codes
 // REST messages: https://docs.discord.com/developers/resources/message#create-message
-const API = "https://discord.com/api/v10";
-const INTENTS = (1 << 9) | (1 << 12) | (1 << 15);
+export const DISCORD_API = "https://discord.com/api/v10";
+export const DISCORD_GATEWAY_INTENTS = (1 << 9) | (1 << 12) | (1 << 15);
 const PERMANENT_CLOSE_CODES = new Set([4004, 4010, 4011, 4012, 4013, 4014]);
+const MAX_CLASSIFICATION_PENDING = 100;
 
 // Discord strips boundary whitespace. Invisible guards preserve it in message content;
 // they are part of the delivered text, and consume one UTF-16 unit each.
@@ -82,7 +83,7 @@ interface DiscordSession {
 	sequence: number | null;
 }
 
-function gatewayUrl(value: unknown): string {
+export function discordGatewayUrl(value: unknown): string {
 	let url: URL;
 	try {
 		if (typeof value !== "string") throw new Error();
@@ -158,7 +159,7 @@ function connectGateway(
 	token: string,
 	accountId: string,
 	session: DiscordSession,
-	onMessage: (message: MessengerMessage) => Promise<void>,
+	onMessage: (message: MessengerMessage, raw: unknown) => Promise<void>,
 	signal: AbortSignal,
 	WebSocketImpl: typeof WebSocket,
 	clock: DiscordClock,
@@ -267,7 +268,7 @@ function connectGateway(
 			} else {
 				send(2, {
 					token,
-					intents: INTENTS,
+					intents: DISCORD_GATEWAY_INTENTS,
 					properties: { os: process.platform, browser: "jeopi", device: "jeopi" },
 				});
 			}
@@ -287,7 +288,7 @@ function connectGateway(
 					return;
 				}
 				try {
-					session.url = gatewayUrl(packet.d.resume_gateway_url);
+					session.url = discordGatewayUrl(packet.d.resume_gateway_url);
 				} catch {
 					finish(new DiscordConfigurationError("Discord returned an untrusted resume Gateway URL"));
 					return;
@@ -304,7 +305,7 @@ function connectGateway(
 					// The gateway owns authorization, deduplication and its bounded work queue.
 					void Promise.resolve()
 						.then(() => {
-							if (!signal.aborted) return onMessage(message);
+							if (!signal.aborted) return onMessage(message, packet.d);
 						})
 						.catch(() => logger.warn("Discord message handler failed"));
 				}
@@ -328,6 +329,9 @@ export function createDiscordAdapter(
 	const token = env[config.tokenEnv]?.trim();
 	const clock = deps.clock ?? defaultClock;
 	const createdThreads = new Map<string, { parentChannelId: string; senderId: string }>();
+	const classificationTails = new Map<string, Promise<void>>();
+	const messageClassifications = new Map<string, Promise<void>>();
+	const pendingClassifications = new Set<string>();
 	const rememberThread = (threadId: string, parentChannelId: string, senderId: string): void => {
 		createdThreads.set(threadId, { parentChannelId, senderId });
 		if (createdThreads.size > 10_000) {
@@ -351,7 +355,12 @@ export function createDiscordAdapter(
 				let retryDelay = delay;
 				try {
 					if (!accountId) {
-						const user = await messengerFetchJson(`${API}/users/@me`, { headers: headers() }, signal, deps.fetch);
+						const user = await messengerFetchJson(
+							`${DISCORD_API}/users/@me`,
+							{ headers: headers() },
+							signal,
+							deps.fetch,
+						);
 						if (signal.aborted) return;
 						if (!isRecord(user) || typeof user.id !== "string" || !user.id || user.bot !== true) {
 							throw new DiscordConfigurationError("Discord credentials must identify a bot account");
@@ -360,7 +369,7 @@ export function createDiscordAdapter(
 					}
 					if (!initialUrl) {
 						const gateway = await messengerFetchJson(
-							`${API}/gateway/bot`,
+							`${DISCORD_API}/gateway/bot`,
 							{ headers: headers() },
 							signal,
 							deps.fetch,
@@ -370,49 +379,159 @@ export function createDiscordAdapter(
 						if (isRecord(gateway.session_start_limit) && gateway.session_start_limit.remaining === 0) {
 							throw new DiscordConfigurationError("Discord Gateway session start limit is exhausted");
 						}
-						initialUrl = gatewayUrl(gateway.url);
+						initialUrl = discordGatewayUrl(gateway.url);
 					}
-					const deliver = async (message: MessengerMessage): Promise<void> => {
-						const thread = createdThreads.get(message.channelId);
-						if (thread && thread.senderId === message.senderId) {
-							await onMessage({
-								...message,
-								threadId: message.channelId,
-								parentChannelId: thread.parentChannelId,
-							});
-						} else if (
-							!message.direct &&
-							message.mentioned &&
-							config.allowedUserIds.includes(message.senderId) &&
-							config.allowedChannelIds &&
-							!config.allowedChannelIds.includes(message.channelId)
-						) {
+					const lookup = async (url: string): Promise<unknown> => {
+						for (let attempt = 0; ; attempt++) {
 							try {
-								const channel = await messengerFetchJson(
-									`${API}/channels/${encodeURIComponent(message.channelId)}`,
-									{ headers: headers() },
-									signal,
-									deps.fetch,
-								);
+								return await messengerFetchJson(url, { headers: headers() }, signal, deps.fetch);
+							} catch (error) {
 								if (
-									isRecord(channel) &&
-									typeof channel.type === "number" &&
-									[10, 11, 12].includes(channel.type) &&
-									typeof channel.parent_id === "string" &&
-									channel.parent_id
+									!(error instanceof MessengerHttpError) ||
+									error.status !== 429 ||
+									attempt >= 3 ||
+									signal.aborted
 								) {
-									await onMessage({
-										...message,
-										threadId: message.channelId,
-										parentChannelId: channel.parent_id,
-									});
+									throw error;
 								}
+								await waitForReconnect(error.retryAfterMs ?? 1_000, signal, clock);
+								if (signal.aborted) throw error;
+							}
+						}
+					};
+					const isBotReply = async (value: unknown, channelId: string): Promise<boolean> => {
+						if (!isRecord(value) || value.type !== 19 || !isRecord(value.message_reference)) return false;
+						const reference = value.message_reference;
+						if (
+							typeof reference.message_id !== "string" ||
+							(reference.channel_id && reference.channel_id !== channelId)
+						)
+							return false;
+						let original = value.referenced_message;
+						if (original === undefined) {
+							try {
+								original = await lookup(
+									`${DISCORD_API}/channels/${encodeURIComponent(channelId)}/messages/${encodeURIComponent(reference.message_id)}`,
+								);
 							} catch {
-								if (!signal.aborted) logger.warn("Discord thread parent lookup failed");
+								if (!signal.aborted) logger.warn("Discord reply lookup failed");
+								return false;
 							}
-						} else {
-							await onMessage(message);
 						}
+						return (
+							isRecord(original) &&
+							original.id === reference.message_id &&
+							isRecord(original.author) &&
+							original.author.id === accountId
+						);
+					};
+					const forward = (message: MessengerMessage): void => {
+						if (signal.aborted) return;
+						try {
+							void onMessage(message).catch(() => logger.warn("Discord message handler failed"));
+						} catch {
+							logger.warn("Discord message handler failed");
+						}
+					};
+					const classify = async (message: MessengerMessage, raw: unknown): Promise<void> => {
+						if (message.direct || !config.allowedUserIds.includes(message.senderId)) {
+							forward(message);
+							return;
+						}
+						if (!message.mentioned && (await isBotReply(raw, message.channelId))) {
+							message = { ...message, mentioned: true };
+						}
+						const thread = createdThreads.get(message.channelId);
+						if (thread && thread.senderId === message.senderId) {
+							forward({ ...message, threadId: message.channelId, parentChannelId: thread.parentChannelId });
+							return;
+						}
+						try {
+							const channel = await lookup(`${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}`);
+							if (
+								!isRecord(channel) ||
+								typeof channel.type !== "number" ||
+								![10, 11, 12].includes(channel.type) ||
+								typeof channel.parent_id !== "string" ||
+								!channel.parent_id ||
+								(config.allowedChannelIds &&
+									!config.allowedChannelIds.includes(message.channelId) &&
+									!config.allowedChannelIds.includes(channel.parent_id))
+							) {
+								forward(message);
+								return;
+							}
+							if (!message.mentioned && channel.owner_id !== accountId) {
+								let before = message.messageId;
+								for (;;) {
+									const history = await lookup(
+										`${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}/messages?limit=100&before=${encodeURIComponent(before)}`,
+									);
+									if (!Array.isArray(history)) return;
+									let invoked = false;
+									for (const entry of history) {
+										if (
+											!isRecord(entry) ||
+											!isRecord(entry.author) ||
+											entry.author.bot ||
+											entry.webhook_id ||
+											typeof entry.author.id !== "string" ||
+											!config.allowedUserIds.includes(entry.author.id)
+										)
+											continue;
+										if (
+											(Array.isArray(entry.mentions) &&
+												entry.mentions.some(user => isRecord(user) && user.id === accountId)) ||
+											(await isBotReply(entry, message.channelId))
+										) {
+											invoked = true;
+											break;
+										}
+									}
+									if (invoked) break;
+									if (history.length < 100) {
+										forward(message);
+										return;
+									}
+									const last = history[history.length - 1];
+									if (!isRecord(last) || typeof last.id !== "string" || !last.id || last.id === before) return;
+									before = last.id;
+								}
+							}
+							forward({ ...message, threadId: message.channelId, parentChannelId: channel.parent_id });
+						} catch {
+							if (!signal.aborted) logger.warn("Discord thread lookup failed");
+						}
+						return;
+					};
+					const deliver = (message: MessengerMessage, raw: unknown): Promise<void> => {
+						if (signal.aborted) return Promise.resolve();
+						if (message.direct || !config.allowedUserIds.includes(message.senderId)) {
+							forward(message);
+							return Promise.resolve();
+						}
+						const key = `${message.channelId}:${message.messageId}`;
+						if (pendingClassifications.has(key) || pendingClassifications.size >= MAX_CLASSIFICATION_PENDING) {
+							return Promise.resolve();
+						}
+						pendingClassifications.add(key);
+						const previous = Promise.all([
+							classificationTails.get(message.channelId),
+							messageClassifications.get(message.channelId),
+						]);
+						const current = previous
+							.then(() => (signal.aborted ? undefined : classify(message, raw)))
+							.catch(() => logger.warn("Discord classification failed"));
+						classificationTails.set(message.channelId, current);
+						messageClassifications.set(message.messageId, current);
+						void current.then(() => {
+							pendingClassifications.delete(key);
+							if (messageClassifications.get(message.messageId) === current)
+								messageClassifications.delete(message.messageId);
+							if (classificationTails.get(message.channelId) === current)
+								classificationTails.delete(message.channelId);
+						});
+						return current;
 					};
 					await connectGateway(
 						session.url ?? initialUrl,
@@ -459,7 +578,7 @@ export function createDiscordAdapter(
 				return message;
 			}
 			const channel = await messengerFetchJson(
-				`${API}/channels/${encodeURIComponent(message.channelId)}`,
+				`${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}`,
 				{ headers: headers() },
 				signal,
 				deps.fetch,
@@ -474,7 +593,7 @@ export function createDiscordAdapter(
 			}
 			if (channel.type !== 0 && channel.type !== 5) throw new Error("Discord channel cannot host a reply thread");
 			const thread = await messengerFetchJson(
-				`${API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/threads`,
+				`${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/threads`,
 				{ method: "POST", headers: headers(), body: JSON.stringify({ name: `Request ${message.messageId}` }) },
 				signal,
 				deps.fetch,
@@ -485,7 +604,7 @@ export function createDiscordAdapter(
 			return { ...message, threadId: thread.id };
 		},
 		async status(message, state, signal) {
-			const base = `${API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/reactions`;
+			const base = `${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/reactions`;
 			const processing = encodeURIComponent("⏳");
 			if (state !== "processing") {
 				try {
@@ -500,17 +619,44 @@ export function createDiscordAdapter(
 				}
 			}
 			const emoji = state === "processing" ? "⏳" : state === "success" ? "✅" : "❌";
+			try {
+				await messengerFetchJson(
+					`${base}/${encodeURIComponent(emoji)}/@me`,
+					{ method: "PUT", headers: headers() },
+					signal,
+					deps.fetch,
+				);
+			} finally {
+				if (state === "processing" && signal?.aborted) {
+					try {
+						await messengerFetchJson(
+							`${base}/${processing}/@me`,
+							{ method: "DELETE", headers: headers() },
+							AbortSignal.timeout(3_000),
+							deps.fetch,
+						);
+					} catch {
+						logger.warn("Discord late processing reaction removal failed");
+					}
+				}
+			}
+		},
+		async clearStatus(message, signal) {
+			const base = `${DISCORD_API}/channels/${encodeURIComponent(message.channelId)}/messages/${encodeURIComponent(message.messageId)}/reactions`;
 			await messengerFetchJson(
-				`${base}/${encodeURIComponent(emoji)}/@me`,
-				{ method: "PUT", headers: headers() },
+				`${base}/${encodeURIComponent("⏳")}/@me`,
+				{ method: "DELETE", headers: headers() },
 				signal,
 				deps.fetch,
 			);
 		},
+		releaseActivity(message) {
+			activityMessages.delete(JSON.stringify([message.threadId ?? message.channelId, message.messageId]));
+		},
 		async activity(message, text, signal) {
 			const channelId = message.threadId ?? message.channelId;
 			const key = JSON.stringify([channelId, message.messageId]);
-			const messages = `${API}/channels/${encodeURIComponent(channelId)}/messages`;
+			const messages = `${DISCORD_API}/channels/${encodeURIComponent(channelId)}/messages`;
 			const statusId = activityMessages.get(key);
 			if (text === undefined) {
 				if (!statusId) return;
@@ -560,6 +706,19 @@ export function createDiscordAdapter(
 			);
 			if (!isRecord(created) || typeof created.id !== "string" || !created.id)
 				throw new Error("Discord activity message returned no ID");
+			if (signal?.aborted) {
+				try {
+					await messengerFetchJson(
+						`${messages}/${encodeURIComponent(created.id)}`,
+						{ method: "DELETE", headers: headers() },
+						AbortSignal.timeout(3_000),
+						deps.fetch,
+					);
+				} catch {
+					logger.warn("Discord late activity removal failed");
+				}
+				return;
+			}
 			activityMessages.set(key, created.id);
 		},
 		async send(message, text, signal) {
@@ -571,7 +730,7 @@ export function createDiscordAdapter(
 					files = result.files;
 				} catch {
 					await messengerFetchJson(
-						`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+						`${DISCORD_API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
 						{
 							method: "POST",
 							headers: headers(),
@@ -614,7 +773,7 @@ export function createDiscordAdapter(
 							});
 						}
 						await messengerFetchJson(
-							`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+							`${DISCORD_API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
 							{
 								method: "POST",
 								headers: requestHeaders,
@@ -655,7 +814,7 @@ export function createDiscordAdapter(
 				for (let attempt = 0; ; attempt++) {
 					try {
 						await messengerFetchJson(
-							`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+							`${DISCORD_API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
 							{ method: "POST", headers: requestHeaders, body: form },
 							signal,
 							deps.fetch,
@@ -668,7 +827,7 @@ export function createDiscordAdapter(
 						}
 						if (!signal?.aborted) {
 							await messengerFetchJson(
-								`${API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
+								`${DISCORD_API}/channels/${encodeURIComponent(message.threadId ?? message.channelId)}/messages`,
 								{
 									method: "POST",
 									headers: headers(),