out-of-your-element/d2m/event-dispatcher.js

245 lines
11 KiB
JavaScript
Raw Normal View History

2023-06-28 12:06:56 +00:00
const assert = require("assert").strict
2023-08-17 13:22:14 +00:00
const util = require("util")
const {sync, db, select, from} = require("../passthrough")
2023-05-04 20:25:00 +00:00
/** @type {import("./actions/send-message")}) */
const sendMessage = sync.require("./actions/send-message")
/** @type {import("./actions/edit-message")}) */
const editMessage = sync.require("./actions/edit-message")
2023-08-17 13:22:14 +00:00
/** @type {import("./actions/delete-message")}) */
const deleteMessage = sync.require("./actions/delete-message")
/** @type {import("./actions/add-reaction")}) */
const addReaction = sync.require("./actions/add-reaction")
/** @type {import("./actions/announce-thread")}) */
const announceThread = sync.require("./actions/announce-thread")
2023-08-19 11:12:36 +00:00
/** @type {import("./actions/create-room")}) */
const createRoom = sync.require("./actions/create-room")
/** @type {import("./actions/create-space")}) */
const createSpace = sync.require("./actions/create-space")
2023-08-17 13:22:14 +00:00
/** @type {import("../matrix/api")}) */
const api = sync.require("../matrix/api")
2023-09-17 08:15:29 +00:00
/** @type {import("../discord/discord-command-handler")}) */
const discordCommandHandler = sync.require("../discord/discord-command-handler")
2023-08-17 13:22:14 +00:00
let lastReportedEvent = 0
2023-05-04 20:25:00 +00:00
// Grab Discord events we care about for the bridge, check them, and pass them on
2023-04-30 12:57:30 +00:00
2023-04-25 20:06:08 +00:00
module.exports = {
2023-08-17 13:22:14 +00:00
/**
* @param {import("./discord-client")} client
* @param {Error} e
* @param {import("cloudstorm").IGatewayMessage} gatewayMessage
*/
onError(client, e, gatewayMessage) {
console.error("hit event-dispatcher's error handler with this exception:")
console.error(e) // TODO: also log errors into a file or into the database, maybe use a library for this? or just wing it? definitely need to be able to store the formatted event body to load back in later
console.error(`while handling this ${gatewayMessage.t} gateway event:`)
console.dir(gatewayMessage.d, {depth: null})
2023-08-17 13:22:14 +00:00
2023-09-18 13:23:32 +00:00
if (gatewayMessage.t === "TYPING_START") return
2023-08-19 06:39:23 +00:00
if (Date.now() - lastReportedEvent < 5000) return
lastReportedEvent = Date.now()
const channelID = gatewayMessage.d.channel_id
if (!channelID) return
const roomID = select("channel_room", "room_id", "WHERE channel_id = ?").pluck().get(channelID)
2023-08-19 06:39:23 +00:00
if (!roomID) return
let stackLines = e.stack.split("\n")
let cloudstormLine = stackLines.findIndex(l => l.includes("/node_modules/cloudstorm/"))
if (cloudstormLine !== -1) {
stackLines = stackLines.slice(0, cloudstormLine - 2)
2023-08-17 13:22:14 +00:00
}
2023-08-19 06:39:23 +00:00
api.sendEvent(roomID, "m.room.message", {
msgtype: "m.text",
body: "\u26a0 Bridged event from Discord not delivered. See formatted content for full details.",
format: "org.matrix.custom.html",
formatted_body: "\u26a0 <strong>Bridged event from Discord not delivered</strong>"
+ `<br>Gateway event: ${gatewayMessage.t}`
+ `<br>${e.toString()}`
2023-09-03 04:03:37 +00:00
+ `<br><details><summary>Error trace</summary>`
+ `<pre>${stackLines.join("\n")}</pre></details>`
+ `<details><summary>Original payload</summary>`
+ `<pre>${util.inspect(gatewayMessage.d, false, 4, false)}</pre></details>`,
"moe.cadence.ooye.error": {
source: "discord",
payload: gatewayMessage
},
2023-08-19 06:39:23 +00:00
"m.mentions": {
user_ids: ["@cadence:cadence.moe"]
}
})
2023-08-17 13:22:14 +00:00
},
/**
* When logging back in, check if we missed any conversations in any channels. Bridge up to 49 missed messages per channel.
* If more messages were missed, only the latest missed message will be posted. TODO: Consider bridging more, or post a warning when skipping history?
* This can ONLY detect new messages, not any other kind of event. Any missed edits, deletes, reactions, etc will not be bridged.
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayGuildCreateDispatchData} guild
*/
async checkMissedMessages(client, guild) {
if (guild.unavailable) return
const bridgedChannels = select("channel_room", "channel_id").pluck().all()
2023-09-18 13:23:32 +00:00
const prepared = select("event_message", "event_id", "WHERE message_id = ?").pluck()
for (const channel of guild.channels.concat(guild.threads)) {
if (!bridgedChannels.includes(channel.id)) continue
if (!channel.last_message_id) continue
const latestWasBridged = prepared.get(channel.last_message_id)
if (latestWasBridged) continue
/** More recent messages come first. */
2023-09-03 13:38:30 +00:00
// console.log(`[check missed messages] in ${channel.id} (${guild.name} / ${channel.name}) because its last message ${channel.last_message_id} is not in the database`)
let messages
try {
messages = await client.snow.channel.getChannelMessages(channel.id, {limit: 50})
} catch (e) {
if (e.message === `{"message": "Missing Access", "code": 50001}`) { // pathetic error handling from SnowTransfer
console.log(`[check missed messages] no permissions to look back in channel ${channel.name} (${channel.id})`)
continue // Sucks.
} else {
throw e // Sucks more.
}
}
let latestBridgedMessageIndex = messages.findIndex(m => {
return prepared.get(m.id)
})
2023-09-03 13:38:30 +00:00
// console.log(`[check missed messages] got ${messages.length} messages; last message that IS bridged is at position ${latestBridgedMessageIndex} in the channel`)
if (latestBridgedMessageIndex === -1) latestBridgedMessageIndex = 1 // rather than crawling the ENTIRE channel history, let's just bridge the most recent 1 message to make it up to date.
for (let i = Math.min(messages.length, latestBridgedMessageIndex)-1; i >= 0; i--) {
const simulatedGatewayDispatchData = {
guild_id: guild.id,
mentions: [],
2023-08-28 04:20:16 +00:00
backfill: true,
...messages[i]
}
await module.exports.onMessageCreate(client, simulatedGatewayDispatchData)
}
}
},
/**
2023-08-21 05:25:51 +00:00
* Announces to the parent room that the thread room has been created.
* See notes.md, "Ignore MESSAGE_UPDATE and bridge THREAD_CREATE as the announcement"
* @param {import("./discord-client")} client
2023-08-21 05:25:51 +00:00
* @param {import("discord-api-types/v10").APIThreadChannel} thread
*/
async onThreadCreate(client, thread) {
const parentRoomID = select("channel_room", "room_id", "WHERE channel_room = ?").pluck().get(thread.parent_id)
if (!parentRoomID) return // Not interested in a thread if we aren't interested in its wider channel
2023-08-21 05:25:51 +00:00
const threadRoomID = await createRoom.syncRoom(thread.id) // Create room (will share the same inflight as the initial message to the thread)
await announceThread.announceThread(parentRoomID, threadRoomID, thread)
},
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayGuildUpdateDispatchData} guild
*/
async onGuildUpdate(client, guild) {
const spaceID = select("guild_space", "space_id", "WHERE guild_id = ?").pluck().get(guild.id)
if (!spaceID) return
await createSpace.syncSpace(guild.id)
},
/**
2023-08-19 11:12:36 +00:00
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayChannelUpdateDispatchData} channelOrThread
* @param {boolean} isThread
*/
async onChannelOrThreadUpdate(client, channelOrThread, isThread) {
const roomID = select("channel_room", "room_id", "WHERE channel_id = ?").pluck().get(channelOrThread.id)
2023-08-19 11:12:36 +00:00
if (!roomID) return // No target room to update the data on
await createRoom.syncRoom(channelOrThread.id)
},
2023-04-25 20:06:08 +00:00
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayMessageCreateDispatchData} message
*/
async onMessageCreate(client, message) {
if (message.webhook_id) {
2023-09-18 13:23:32 +00:00
const row = select("webhook", "webhook_id", "WHERE webhook_id = ?").pluck().get(message.webhook_id)
if (row) {
// The message was sent by the bridge's own webhook on discord. We don't want to reflect this back, so just drop it.
return
}
}
2023-07-04 20:41:15 +00:00
/** @type {import("discord-api-types/v10").APIGuildChannel} */
const channel = client.channels.get(message.channel_id)
if (!channel.guild_id) return // Nothing we can do in direct messages.
const guild = client.guilds.get(channel.guild_id)
2023-08-24 05:09:25 +00:00
await sendMessage.sendMessage(message, guild),
await discordCommandHandler.execute(message, channel, guild)
2023-04-25 20:06:08 +00:00
},
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayMessageUpdateDispatchData} data
*/
async onMessageUpdate(client, data) {
2023-08-17 07:03:09 +00:00
if (data.webhook_id) {
const row = select("webhook", "1", "WHERE webhook_id = ?").pluck().get(message.webhook_id)
2023-08-17 07:03:09 +00:00
if (row) {
// The update was sent by the bridge's own webhook on discord. We don't want to reflect this back, so just drop it.
return
}
}
// Based on looking at data they've sent me over the gateway, this is the best way to check for meaningful changes.
// If the message content is a string then it includes all interesting fields and is meaningful.
if (typeof data.content === "string") {
/** @type {import("discord-api-types/v10").GatewayMessageCreateDispatchData} */
const message = data
/** @type {import("discord-api-types/v10").APIGuildChannel} */
const channel = client.channels.get(message.channel_id)
if (!channel.guild_id) return // Nothing we can do in direct messages.
const guild = client.guilds.get(channel.guild_id)
await editMessage.editMessage(message, guild)
}
},
2023-04-25 20:06:08 +00:00
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayMessageReactionAddDispatchData} data
*/
async onReactionAdd(client, data) {
2023-07-04 20:41:15 +00:00
if (data.user_id === client.user.id) return // m2d reactions are added by the discord bot user - do not reflect them back to matrix.
discordCommandHandler.onReactionAdd(data)
2023-06-28 11:38:58 +00:00
if (data.emoji.id !== null) return // TODO: image emoji reactions
await addReaction.addReaction(data)
2023-08-17 13:22:14 +00:00
},
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayMessageDeleteDispatchData} data
*/
async onMessageDelete(client, data) {
await deleteMessage.deleteMessage(data)
2023-09-17 11:07:33 +00:00
},
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayTypingStartDispatchData} data
*/
async onTypingStart(client, data) {
const roomID = select("channel_room", "room_id", "WHERE channel_id = ?").pluck().get(data.channel_id)
2023-09-17 11:07:33 +00:00
if (!roomID) return
const mxid = from("sim").join("sim_member", "mxid").and("WHERE discord_id = ? AND room_id = ?").pluck("mxid").get(data.user_id, roomID)
2023-09-17 11:07:33 +00:00
if (!mxid) return
// Each Discord user triggers the notification every 8 seconds as long as they remain typing.
// Discord does not send typing stopped events, so typing only stops if the timeout is reached or if the user sends their message.
// (We have to manually stop typing on Matrix-side when the message is sent. This is part of the send action.)
await api.sendTyping(roomID, true, mxid, 10000)
2023-09-18 13:23:32 +00:00
},
/**
* @param {import("./discord-client")} client
* @param {import("discord-api-types/v10").GatewayGuildEmojisUpdateDispatchData | import("discord-api-types/v10").GatewayGuildStickersUpdateDispatchData} data
*/
async onExpressionsUpdate(client, data) {
2023-09-18 13:45:40 +00:00
await createSpace.syncSpaceExpressions(data)
2023-04-25 20:06:08 +00:00
}
}