jeopi-cli 16.6.17 → 16.6.21

package/src/messenger/slack.ts

@@ -40,7 +40,7 @@ function requiredToken(value: string | undefined, prefix: string): string {
 }
 
 async function slackRequest(
-	method: "auth.test" | "apps.connections.open" | "chat.postMessage",
+	method: "auth.test" | "apps.connections.open" | "chat.postMessage" | "chat.update" | "chat.delete",
 	token: string,
 	body: Record<string, unknown>,
 	signal?: AbortSignal,
@@ -247,6 +247,7 @@ export function createSlackAdapter(
 ): MessengerAdapter {
 	let teamId: string | undefined;
 	let running = false;
+	const activityMessages = new Map<string, string>();
 	return {
 		platform: "slack",
 		async start(onMessage, signal) {
@@ -329,5 +330,65 @@ export function createSlackAdapter(
 				);
 			}
 		},
+		releaseActivity(message) {
+			activityMessages.delete(
+				JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]),
+			);
+		},
+		async activity(message, text, signal) {
+			if (message.platform !== "slack" || (teamId !== undefined && message.accountId !== teamId)) {
+				throw new SlackConfigurationError("Slack reply account does not match");
+			}
+			const token = requiredToken(env[config.tokenEnv], "xoxb-");
+			const key = JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]);
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				await slackRequest("chat.delete", token, { channel: message.channelId, ts: statusId }, signal, deps.fetch);
+				activityMessages.delete(key);
+				return;
+			}
+			const body = {
+				channel: message.channelId,
+				text: `⏳ ${text}`,
+				mrkdwn: false,
+				parse: "none",
+				link_names: false,
+				unfurl_links: false,
+				unfurl_media: false,
+			};
+			if (statusId) {
+				await slackRequest("chat.update", token, { ...body, ts: statusId }, signal, deps.fetch);
+				return;
+			}
+			if (signal?.aborted) return;
+			// Keep creation alive after cancellation so a late ID can be deleted; HTTP has its own timeout.
+			const created = await slackRequest(
+				"chat.postMessage",
+				token,
+				{
+					...body,
+					thread_ts: message.threadId ?? (message.direct ? undefined : message.messageId),
+				},
+				undefined,
+				deps.fetch,
+			);
+			if (typeof created.ts !== "string" || !created.ts) throw new Error("Slack activity message returned no ID");
+			if (signal?.aborted) {
+				try {
+					await slackRequest(
+						"chat.delete",
+						token,
+						{ channel: message.channelId, ts: created.ts },
+						AbortSignal.timeout(3_000),
+						deps.fetch,
+					);
+				} catch {
+					logger.warn("Slack late activity removal failed");
+				}
+				return;
+			}
+			activityMessages.set(key, created.ts);
+		},
 	};
 }

package/src/messenger/telegram.ts

@@ -144,6 +144,7 @@ export function createTelegramAdapter(
 	const baseUrl = `https://api.telegram.org/bot${encodeURIComponent(token).replaceAll("%3A", ":")}/`;
 	let running = false;
 	let offset = 0;
+	const activityMessages = new Map<string, number>();
 
 	async function request(method: string, parameters: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
 		const response = await messengerFetchJson(
@@ -156,7 +157,9 @@ export function createTelegramAdapter(
 		if (!response.ok) {
 			const status = isInteger(response.error_code) ? response.error_code : 400;
 			const retryAfter = isRecord(response.parameters) ? response.parameters.retry_after : undefined;
-			throw new TelegramApiError(status, isPositiveId(retryAfter) ? Math.min(retryAfter, 300) * 1_000 : 0);
+			const retryAfterMs = isPositiveId(retryAfter) ? Math.min(retryAfter, 300) * 1_000 : 0;
+			if (status === 429) throw new MessengerHttpError(status, retryAfterMs || undefined);
+			throw new TelegramApiError(status, retryAfterMs);
 		}
 		if (!("result" in response)) throw new TelegramApiError(400);
 		return response.result;
@@ -240,5 +243,55 @@ export function createTelegramAdapter(
 				if (!isRecord(result) || !isPositiveId(result.message_id)) throw new TelegramApiError(400);
 			}
 		},
+		releaseActivity(message) {
+			activityMessages.delete(
+				JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]),
+			);
+		},
+		async activity(message, text, signal) {
+			const key = JSON.stringify([message.accountId, message.channelId, message.threadId ?? "", message.messageId]);
+			const statusId = activityMessages.get(key);
+			if (text === undefined) {
+				if (!statusId) return;
+				await request("deleteMessage", { chat_id: message.channelId, message_id: statusId }, signal);
+				activityMessages.delete(key);
+				return;
+			}
+			if (statusId) {
+				await request(
+					"editMessageText",
+					{ chat_id: message.channelId, message_id: statusId, text: `⏳ ${text}` },
+					signal,
+				);
+				return;
+			}
+			const threadId = message.threadId === undefined ? undefined : Number(message.threadId);
+			if (threadId !== undefined && !isPositiveId(threadId)) throw new Error("Telegram topic identifier is invalid");
+			if (signal?.aborted) return;
+			// Keep creation alive after cancellation so a late ID can be deleted; HTTP has its own timeout.
+			const created = await request(
+				"sendMessage",
+				{
+					chat_id: message.channelId,
+					text: `⏳ ${text}`,
+					...(threadId === undefined ? {} : { message_thread_id: threadId }),
+				},
+				undefined,
+			);
+			if (!isRecord(created) || !isPositiveId(created.message_id)) throw new TelegramApiError(400);
+			if (signal?.aborted) {
+				try {
+					await request(
+						"deleteMessage",
+						{ chat_id: message.channelId, message_id: created.message_id },
+						AbortSignal.timeout(3_000),
+					);
+				} catch {
+					logger.warn("Telegram late activity removal failed");
+				}
+				return;
+			}
+			activityMessages.set(key, created.message_id);
+		},
 	};
 }