All checks were successful
Build and Deploy Nuxt / build (push) Successful in 1m51s
497 lines
23 KiB
JavaScript
497 lines
23 KiB
JavaScript
const {
|
||
ActionRowBuilder,
|
||
ButtonBuilder,
|
||
ButtonStyle,
|
||
Client,
|
||
EmbedBuilder,
|
||
Events,
|
||
GatewayIntentBits,
|
||
MessageFlags,
|
||
PermissionFlagsBits,
|
||
REST,
|
||
Routes
|
||
} = require('discord.js');
|
||
const { getConfig } = require('./config');
|
||
const {
|
||
createDragonrollApi,
|
||
CampaignNotLinkedError,
|
||
DragonrollNotConnectedError
|
||
} = require('./dragonroll-api');
|
||
const commands = require('./commands');
|
||
|
||
// Same lifetime as the authorization link on the backend.
|
||
const LINK_REQUEST_TTL_MS = 10 * 60 * 1000;
|
||
const LINK_NOTIFICATION_POLL_MS = 4000;
|
||
|
||
function abilityModifier(score) {
|
||
const modifier = Math.floor((Number(score || 10) - 10) / 2);
|
||
return `${modifier >= 0 ? '+' : ''}${modifier}`;
|
||
}
|
||
|
||
function safeField(value, limit = 600) {
|
||
const text = String(value || '').trim();
|
||
if (!text) return '—';
|
||
return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
|
||
}
|
||
|
||
// Actor images are stored as a bare filename and served publicly at
|
||
// `<api>/public/<filename>`, the same way the frontend renders them. An
|
||
// absolute URL is used as-is if one ever gets saved.
|
||
function actorImageUrl(image, publicBaseUrl) {
|
||
const value = String(image || '').trim();
|
||
if (!value) return null;
|
||
if (/^https?:\/\//i.test(value)) return value;
|
||
return `${publicBaseUrl.replace(/\/+$/, '')}/${encodeURIComponent(value)}`;
|
||
}
|
||
|
||
function actorEmbed(actor, campaign, publicImageBaseUrl) {
|
||
const abilities = actor.abilityScores || {};
|
||
const abilityFields = [
|
||
['💪 STR', 'str'], ['🏹 DEX', 'dex'], ['🛡️ CON', 'con'],
|
||
['📚 INT', 'int'], ['👁️ WIS', 'wis'], ['✨ CHA', 'cha']
|
||
].map(([name, key]) => {
|
||
const score = abilities[key] ?? 10;
|
||
return { name, value: `**${score}** · _${abilityModifier(score)}_`, inline: true };
|
||
});
|
||
const className = String(actor.className || actor.class || '').trim();
|
||
const race = actor.species || actor.race;
|
||
|
||
const embed = new EmbedBuilder()
|
||
.setTitle(safeField(actor.name, 256))
|
||
.setColor(0x8c6bb1)
|
||
.setDescription(safeField(actor.description, 1200))
|
||
.setFooter({ text: safeField(`Campaign: ${campaign.name}`, 600) });
|
||
|
||
const imageUrl = actorImageUrl(actor.image, publicImageBaseUrl);
|
||
if (imageUrl) embed.setImage(imageUrl);
|
||
|
||
embed.addFields(
|
||
{ name: '🧬 Race', value: safeField(race), inline: true },
|
||
{ name: '⚔️ Class', value: safeField([className, actor.level ? `Level ${actor.level}` : null].filter(Boolean).join(' · ')), inline: true }
|
||
);
|
||
if (actor.subclass) embed.addFields({ name: '✨ Subclass', value: safeField(actor.subclass), inline: true });
|
||
embed.addFields(
|
||
{ name: '📜 Background', value: safeField(actor.background), inline: true },
|
||
{ name: '🛡️ Combat', value: `AC ${actor.armorClass ?? 10} · Speed ${actor.speed ?? 30} ft.`, inline: true },
|
||
{ name: 'Ability scores', value: '\u200b' },
|
||
...abilityFields
|
||
);
|
||
|
||
if (actor.proficiencies) embed.addFields({ name: 'Proficiencies', value: safeField(actor.proficiencies) });
|
||
if (actor.traits) embed.addFields({ name: 'Traits', value: safeField(actor.traits) });
|
||
if (actor.spells) embed.addFields({ name: 'Spells', value: safeField(actor.spells) });
|
||
|
||
if (Array.isArray(actor.inventory) && actor.inventory.length) {
|
||
const inventory = actor.inventory
|
||
.map((item) => `${item.name || 'Item'} ×${item.quantity || 1}`)
|
||
.join('\n');
|
||
embed.addFields({ name: 'Inventory', value: safeField(inventory) });
|
||
}
|
||
|
||
return embed;
|
||
}
|
||
|
||
function findActor(actors, input) {
|
||
const query = input.trim().toLocaleLowerCase();
|
||
const exact = actors.find((actor) => actor.name.toLocaleLowerCase() === query);
|
||
if (exact) return { actor: exact };
|
||
|
||
const matches = actors.filter((actor) => actor.name.toLocaleLowerCase().includes(query));
|
||
if (matches.length === 1) return { actor: matches[0] };
|
||
return { matches };
|
||
}
|
||
|
||
async function main() {
|
||
const config = getConfig();
|
||
if (!config.discordBotSecret) {
|
||
console.warn('DRAGONROLL_DISCORD_BOT_SECRET is not set; the bot will start, but Dragonroll commands will need it.');
|
||
}
|
||
const dragonroll = createDragonrollApi(config);
|
||
const client = new Client({ intents: [GatewayIntentBits.Guilds] });
|
||
const rest = new REST({ version: '10' }).setToken(config.discordToken);
|
||
// Discord downloads character portraits itself, so they need to be absolute
|
||
// URLs pointing at the backend's public uploads folder.
|
||
const publicImageBaseUrl = `${config.apiBaseUrl}/public`;
|
||
|
||
// Reply, or edit the deferred reply, always without pinging anybody.
|
||
async function respond(interaction, payload) {
|
||
const body = { allowedMentions: { parse: [] }, ...payload };
|
||
if (interaction.deferred || interaction.replied) return interaction.editReply(body);
|
||
return interaction.reply({ ...body, flags: MessageFlags.Ephemeral });
|
||
}
|
||
|
||
async function explainMissingCampaign(interaction, guildId) {
|
||
await respond(interaction, {
|
||
content: safeField([
|
||
'This Discord server is not linked to a Dragonroll campaign yet.',
|
||
`A server administrator can connect Dragonroll with \`/dragonroll connect\`, then choose a campaign with \`/dragonroll link\`. Server ID: \`${guildId}\`.`
|
||
].join('\n'), 1800)
|
||
});
|
||
}
|
||
|
||
async function explainNotConnected(interaction, guildId) {
|
||
await respond(interaction, {
|
||
content: safeField([
|
||
'No Dragonroll account is connected to this Discord server yet.',
|
||
`A server administrator can run \`/dragonroll connect\` to sign in. Server ID: \`${guildId}\`.`
|
||
].join('\n'), 1800)
|
||
});
|
||
}
|
||
|
||
// The /dragonroll connect interactions waiting for somebody to authorize on Dragonroll.
|
||
// Their tokens stay usable for 15 minutes, longer than the authorization link lasts.
|
||
const pendingLinkRequests = new Map();
|
||
let linkNotificationTimer = null;
|
||
|
||
function linkRequestKey(guildId, discordUserId) {
|
||
return `${guildId}:${discordUserId}`;
|
||
}
|
||
|
||
function rememberLinkRequest(interaction) {
|
||
for (const [key, pending] of pendingLinkRequests) {
|
||
if (Date.now() - pending.requestedAt > LINK_REQUEST_TTL_MS) pendingLinkRequests.delete(key);
|
||
}
|
||
pendingLinkRequests.set(linkRequestKey(interaction.guildId, interaction.user.id), {
|
||
interaction,
|
||
requestedAt: Date.now()
|
||
});
|
||
|
||
if (!linkNotificationTimer) {
|
||
linkNotificationTimer = setInterval(() => {
|
||
deliverLinkNotifications().catch((error) => {
|
||
console.error('Could not confirm a Dragonroll authorization:', error.message);
|
||
});
|
||
}, LINK_NOTIFICATION_POLL_MS);
|
||
linkNotificationTimer.unref();
|
||
}
|
||
}
|
||
|
||
async function confirmLinkRequest(interaction, notification) {
|
||
const account = notification.dragonrollUserName ? ` \`${safeField(notification.dragonrollUserName, 40)}\`` : '';
|
||
await interaction.followUp({
|
||
content: safeField([
|
||
`Your Dragonroll account${account} is now connected to **${safeField(notification.guildName, 100)}**.`,
|
||
'Run `/dragonroll link` to choose which campaign this server can read.'
|
||
].join('\n'), 1800),
|
||
flags: MessageFlags.Ephemeral,
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
}
|
||
|
||
async function deliverLinkNotifications() {
|
||
if (!config.discordBotSecret || !pendingLinkRequests.size) return;
|
||
|
||
const notifications = await dragonroll.claimLinkNotifications();
|
||
for (const notification of notifications) {
|
||
const key = linkRequestKey(notification.guildId, notification.discordUserId);
|
||
const pending = pendingLinkRequests.get(key);
|
||
pendingLinkRequests.delete(key);
|
||
// Without the interaction that asked for this authorization there is nothing to
|
||
// answer: the bot was restarted, and Dragonroll's own web page already told the
|
||
// person what to do next.
|
||
if (!pending) continue;
|
||
|
||
try {
|
||
await confirmLinkRequest(pending.interaction, notification);
|
||
} catch (error) {
|
||
console.error(`Could not confirm the Dragonroll authorization for Discord user ${notification.discordUserId}:`, error.message);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Commands live on every server the bot joins: guild-scoped registration is
|
||
// instant, unlike the global registration done by deploy-commands.
|
||
async function registerCommandsIn(guildId) {
|
||
try {
|
||
await rest.put(Routes.applicationGuildCommands(config.discordClientId, guildId), {
|
||
body: commands.map((command) => command.toJSON())
|
||
});
|
||
} catch (error) {
|
||
console.error(`Could not register commands in Discord server ${guildId}:`, error.message);
|
||
}
|
||
}
|
||
|
||
async function showStatus(interaction, guildId) {
|
||
const embed = new EmbedBuilder()
|
||
.setTitle('Dragonroll link')
|
||
.setColor(0x8c6bb1)
|
||
.addFields({ name: 'This server', value: `${interaction.guild?.name || 'Unknown'} · \`${guildId}\`` });
|
||
|
||
let status;
|
||
try {
|
||
status = await dragonroll.getStatus(guildId);
|
||
} catch (error) {
|
||
console.error('Could not read the Dragonroll connection for this server:', error.message);
|
||
embed.addFields({ name: 'Dragonroll account', value: 'Dragonroll could not be reached right now.' });
|
||
await respond(interaction, { embeds: [embed] });
|
||
return;
|
||
}
|
||
|
||
embed.addFields(
|
||
{ name: 'Dragonroll account', value: status.connected ? 'Connected' : 'Not connected.' },
|
||
{ name: 'Campaign', value: status.campaign
|
||
? `${status.campaign.name} · \`${status.campaign._id ?? status.campaign.id}\``
|
||
: 'Not linked yet.' }
|
||
);
|
||
|
||
if (!status.connected) {
|
||
embed.setDescription('A server administrator can run /dragonroll connect to connect a Dragonroll account.');
|
||
} else if (!status.campaign) {
|
||
embed.setDescription('A server administrator can run /dragonroll link to choose a campaign.');
|
||
}
|
||
|
||
await respond(interaction, { embeds: [embed] });
|
||
}
|
||
|
||
client.once(Events.ClientReady, (readyClient) => {
|
||
console.log(`Dragonroll character bot is online as ${readyClient.user.tag}, in ${readyClient.guilds.cache.size} servers.`);
|
||
// Guild commands registered when the bot joined shadow global ones and
|
||
// keep their old definition forever, so refresh them on every start to
|
||
// propagate command changes (new options, autocomplete) to all servers.
|
||
for (const guild of readyClient.guilds.cache.values()) registerCommandsIn(guild.id);
|
||
});
|
||
|
||
client.on(Events.GuildCreate, (guild) => {
|
||
console.log(`Added to Discord server ${guild.id} (${guild.name}).`);
|
||
registerCommandsIn(guild.id);
|
||
});
|
||
|
||
client.on(Events.InteractionCreate, (interaction) => {
|
||
// One broken command should not take the bot down for every other server.
|
||
handleInteraction(interaction).catch((error) => {
|
||
console.error(`Could not answer ${interaction.commandName}:`, error.message);
|
||
});
|
||
});
|
||
|
||
async function respondCampaignChoices(interaction, guildId) {
|
||
if (!interaction.memberPermissions?.has(PermissionFlagsBits.Administrator)) {
|
||
await interaction.respond([]);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const query = interaction.options.getFocused().toLocaleLowerCase();
|
||
const campaigns = await dragonroll.listCampaigns(guildId);
|
||
const choices = campaigns
|
||
.filter((campaign) => !campaign.discordGuildId || String(campaign.discordGuildId) === String(guildId))
|
||
.filter((campaign) => String(campaign.name || '').toLocaleLowerCase().includes(query))
|
||
.slice(0, 25)
|
||
.map((campaign) => ({
|
||
name: safeField(campaign.name, 100),
|
||
value: String(campaign._id ?? campaign.id)
|
||
}))
|
||
.filter((choice) => choice.value && choice.value !== 'undefined');
|
||
await interaction.respond(choices);
|
||
} catch (error) {
|
||
if (error.status !== 401 && error.code !== 'discord.errors.not-connected') {
|
||
console.error('Could not list campaigns for Discord configuration:', error.message);
|
||
}
|
||
await interaction.respond([]);
|
||
}
|
||
}
|
||
|
||
// Character names for /character. Anyone who may read the campaign may use
|
||
// the suggestions; when nothing is linked we answer with an empty list, as
|
||
// autocomplete replies cannot carry an error message.
|
||
async function respondActorChoices(interaction, guildId) {
|
||
try {
|
||
const query = interaction.options.getFocused().trim().toLocaleLowerCase();
|
||
const { actors } = await dragonroll.listActors(guildId);
|
||
const seen = new Set();
|
||
const choices = actors
|
||
.filter((actor) => String(actor.name || '').trim() && actor.name.length <= 100)
|
||
.filter((actor) => actor.name.toLocaleLowerCase().includes(query))
|
||
.map((actor) => ({
|
||
name: safeField(actor.name, 100),
|
||
value: actor.name
|
||
}))
|
||
.filter((choice) => !seen.has(choice.value) && seen.add(choice.value))
|
||
.slice(0, 25);
|
||
await interaction.respond(choices);
|
||
} catch (error) {
|
||
if (!(error instanceof DragonrollNotConnectedError)
|
||
&& !(error instanceof CampaignNotLinkedError)
|
||
&& error.status !== 401
|
||
&& error.code !== 'discord.errors.not-connected') {
|
||
console.error('Could not list characters for Discord autocomplete:', error.message);
|
||
}
|
||
await interaction.respond([]);
|
||
}
|
||
}
|
||
|
||
async function handleInteraction(interaction) {
|
||
if (interaction.isAutocomplete()) {
|
||
const guildId = interaction.guildId;
|
||
if (!guildId) {
|
||
await interaction.respond([]);
|
||
return;
|
||
}
|
||
|
||
if (interaction.commandName === 'character') {
|
||
await respondActorChoices(interaction, guildId);
|
||
return;
|
||
}
|
||
if (interaction.commandName === 'dragonroll' && interaction.options.getSubcommand() === 'link') {
|
||
await respondCampaignChoices(interaction, guildId);
|
||
return;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (!interaction.isChatInputCommand()) return;
|
||
if (!['characters', 'character', 'dragonroll'].includes(interaction.commandName)) return;
|
||
|
||
const guildId = interaction.guildId;
|
||
if (!guildId) {
|
||
await respond(interaction, { content: 'These commands only work inside a Discord server.' });
|
||
return;
|
||
}
|
||
|
||
if (interaction.commandName === 'dragonroll') {
|
||
const subcommand = interaction.options.getSubcommand();
|
||
if (['connect', 'link', 'unlink'].includes(subcommand)) {
|
||
if (!interaction.memberPermissions?.has(PermissionFlagsBits.Administrator)) {
|
||
await respond(interaction, { content: 'Only Discord server administrators can connect Dragonroll or change this campaign link.' });
|
||
return;
|
||
}
|
||
|
||
await interaction.deferReply({ flags: MessageFlags.Ephemeral });
|
||
try {
|
||
if (subcommand === 'connect') {
|
||
const request = await dragonroll.startAuthorization(
|
||
guildId,
|
||
interaction.guild?.name || 'Discord server',
|
||
interaction.user.id,
|
||
interaction.user.username
|
||
);
|
||
const authorizationUrl = `${config.frontendBaseUrl}/discord/authorize#code=${encodeURIComponent(request.code)}`;
|
||
const button = new ButtonBuilder()
|
||
.setLabel('Sign in to Dragonroll')
|
||
.setStyle(ButtonStyle.Link)
|
||
.setURL(authorizationUrl);
|
||
await respond(interaction, {
|
||
content: 'Open Dragonroll to sign in and authorize this server. The link expires in 10 minutes.',
|
||
components: [new ActionRowBuilder().addComponents(button)]
|
||
});
|
||
rememberLinkRequest(interaction);
|
||
return;
|
||
} else if (subcommand === 'link') {
|
||
const campaignId = interaction.options.getString('campaign', true);
|
||
const campaign = await dragonroll.linkCampaign(guildId, campaignId);
|
||
await respond(interaction, {
|
||
content: `This server is now linked to **${safeField(campaign.name, 180)}**.`,
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
} else {
|
||
try {
|
||
const campaign = await dragonroll.unlinkCampaign(guildId);
|
||
await respond(interaction, {
|
||
content: `Removed this server’s link to **${safeField(campaign.name, 180)}**.`,
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
} catch (error) {
|
||
if (error instanceof CampaignNotLinkedError) {
|
||
await respond(interaction, { content: 'This server does not have a linked campaign.' });
|
||
return;
|
||
}
|
||
throw error;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error(`Could not ${subcommand} the campaign for Discord server ${guildId}:`, error.message);
|
||
let message = `I could not ${subcommand} this campaign link. Please try again.`;
|
||
if (error instanceof DragonrollNotConnectedError || error.code === 'discord.errors.not-connected') {
|
||
message = 'Connect a Dragonroll account first with /dragonroll connect.';
|
||
} else if (error.status === 401 || error.message.includes('DRAGONROLL_DISCORD_BOT_SECRET')) {
|
||
message = 'The bot API secret is missing or does not match the backend. Contact the bot operator.';
|
||
} else if (error.code === 'campaigns.errors.discord-guild-in-use' || error.code === 'discord.errors.campaign-already-linked') {
|
||
message = 'That campaign is already linked to another Discord server.';
|
||
}
|
||
await respond(interaction, { content: message });
|
||
}
|
||
return;
|
||
}
|
||
|
||
await interaction.deferReply({ flags: MessageFlags.Ephemeral });
|
||
await showStatus(interaction, guildId);
|
||
return;
|
||
}
|
||
|
||
const showCharacterPublicly = interaction.commandName === 'character'
|
||
&& interaction.options.getBoolean('public');
|
||
await interaction.deferReply(showCharacterPublicly ? {} : { flags: MessageFlags.Ephemeral });
|
||
|
||
try {
|
||
const { campaign, actors } = await dragonroll.listActors(guildId);
|
||
|
||
if (interaction.commandName === 'characters') {
|
||
const type = interaction.options.getString('type') || 'all';
|
||
const filtered = type === 'all' ? actors : actors.filter((actor) => actor.type === type);
|
||
if (!filtered.length) {
|
||
await interaction.editReply({
|
||
content: type === 'all'
|
||
? `There are no characters in **${campaign.name}** yet.`
|
||
: `There are no ${type === 'npc' ? 'NPCs' : `${type}s`} in **${campaign.name}**.`,
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
return;
|
||
}
|
||
|
||
const shown = filtered.slice(0, 40);
|
||
const lines = shown.map((actor) => {
|
||
const details = [actor.species, actor.className, actor.level ? `Lv. ${actor.level}` : null]
|
||
.filter(Boolean)
|
||
.join(' · ');
|
||
return `• **${actor.name}**${details ? ` — ${details}` : ''}`;
|
||
});
|
||
const embed = new EmbedBuilder()
|
||
.setTitle(`Characters of ${campaign.name}`)
|
||
.setColor(0x8c6bb1)
|
||
.setDescription(safeField(lines.join('\n'), 4000))
|
||
.setFooter({ text: filtered.length > shown.length
|
||
? `Showing ${shown.length} of ${filtered.length}; use /character to look up a specific sheet.`
|
||
: `${filtered.length} ${filtered.length === 1 ? 'entry' : 'entries'} · Use /character to inspect a sheet.` });
|
||
await interaction.editReply({ embeds: [embed], allowedMentions: { parse: [] } });
|
||
return;
|
||
}
|
||
|
||
const name = interaction.options.getString('name', true);
|
||
const result = findActor(actors, name);
|
||
if (result.actor) {
|
||
await interaction.editReply({ embeds: [actorEmbed(result.actor, campaign, publicImageBaseUrl)], allowedMentions: { parse: [] } });
|
||
} else if (result.matches?.length > 1) {
|
||
await interaction.editReply({
|
||
content: safeField(`Several characters match **${name}**: ${result.matches.slice(0, 15).map((actor) => actor.name).join(', ')}. Try a more specific name.`, 1800),
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
} else {
|
||
await interaction.editReply({
|
||
content: `I couldn't find a character named **${name}**. Try \`/characters\` to see the campaign roster.`,
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
}
|
||
} catch (error) {
|
||
if (error instanceof DragonrollNotConnectedError) {
|
||
await explainNotConnected(interaction, guildId);
|
||
return;
|
||
}
|
||
if (error instanceof CampaignNotLinkedError) {
|
||
await explainMissingCampaign(interaction, guildId);
|
||
return;
|
||
}
|
||
console.error('Character lookup failed:', error.message);
|
||
await interaction.editReply({
|
||
content: 'I could not reach the Dragonroll campaign right now. Please try again in a moment.',
|
||
allowedMentions: { parse: [] }
|
||
});
|
||
}
|
||
}
|
||
|
||
await client.login(config.discordToken);
|
||
}
|
||
|
||
main().catch((error) => {
|
||
console.error('Could not start Dragonroll Discord bot:', error.message);
|
||
process.exitCode = 1;
|
||
});
|