333 lines
16 KiB
JavaScript
333 lines
16 KiB
JavaScript
const { Client, GatewayIntentBits, Collection } = require('discord.js');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const deployCommands = require('./deploy-commands');
|
|
// legacy local db is available as a fallback in some commands via require('../../backend/db')
|
|
const api = require('./api');
|
|
|
|
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers] });
|
|
|
|
client.commands = new Collection();
|
|
|
|
// In-memory cache of server settings to allow backend to push updates and make toggles immediate
|
|
const guildSettingsCache = new Map();
|
|
|
|
function setGuildSettings(guildId, settings) {
|
|
if (!guildId) return;
|
|
guildSettingsCache.set(guildId, settings || {});
|
|
}
|
|
|
|
function getGuildSettingsFromCache(guildId) {
|
|
return guildSettingsCache.get(guildId) || null;
|
|
}
|
|
|
|
const commandHandler = require('./handlers/command-handler');
|
|
const eventHandler = require('./handlers/event-handler');
|
|
|
|
commandHandler(client);
|
|
eventHandler(client);
|
|
|
|
client.on('interactionCreate', async interaction => {
|
|
// Handle button/component interactions for invites
|
|
if (interaction.isButton && interaction.isButton()) {
|
|
const id = interaction.customId || '';
|
|
if (id.startsWith('copy_inv_')) {
|
|
const code = id.replace('copy_inv_', '');
|
|
try {
|
|
const invites = await api.listInvites(interaction.guildId);
|
|
const inv = (invites || []).find(i => i.code === code);
|
|
if (inv) {
|
|
await interaction.reply({ content: `Invite: ${inv.url}`, ephemeral: true });
|
|
} else {
|
|
await interaction.reply({ content: 'Invite not found.', ephemeral: true });
|
|
}
|
|
} catch (e) {
|
|
console.error('Error fetching invites via API:', e);
|
|
await interaction.reply({ content: 'Invite not found.', ephemeral: true });
|
|
}
|
|
} else if (id.startsWith('delete_inv_')) {
|
|
const code = id.replace('delete_inv_', '');
|
|
// permission check: admin only
|
|
const member = interaction.member;
|
|
if (!member.permissions.has('Administrator')) {
|
|
await interaction.reply({ content: 'You must be an administrator to delete invites.', ephemeral: true });
|
|
return;
|
|
}
|
|
try {
|
|
// call backend delete endpoint via helper
|
|
const ok = await api.deleteInvite(interaction.guildId, code);
|
|
if (ok) {
|
|
await interaction.reply({ content: 'Invite deleted.', ephemeral: true });
|
|
} else {
|
|
await interaction.reply({ content: 'Failed to delete invite via API.', ephemeral: true });
|
|
}
|
|
} catch (e) {
|
|
console.error('Error deleting invite via API:', e);
|
|
await interaction.reply({ content: 'Failed to delete invite.', ephemeral: true });
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Reaction role button handling
|
|
if (interaction.isButton && interaction.customId && interaction.customId.startsWith('rr_')) {
|
|
// customId format: rr_<reactionRoleId>_<roleId>
|
|
const parts = interaction.customId.split('_');
|
|
if (parts.length >= 3) {
|
|
const rrId = parts[1];
|
|
const roleId = parts[2];
|
|
try {
|
|
const rr = await api.safeFetchJsonPath(`/api/servers/${interaction.guildId}/reaction-roles`);
|
|
// rr is array; find by id
|
|
const found = (rr || []).find(r => String(r.id) === String(rrId));
|
|
if (!found) {
|
|
await interaction.reply({ content: 'Reaction role configuration not found.', ephemeral: true });
|
|
return;
|
|
}
|
|
const button = (found.buttons || []).find(b => String(b.roleId) === String(roleId));
|
|
if (!button) {
|
|
await interaction.reply({ content: 'Button config not found.', ephemeral: true });
|
|
return;
|
|
}
|
|
const roleId = button.roleId || button.role_id || button.role;
|
|
const member = interaction.member;
|
|
if (!member) return;
|
|
// Validate role hierarchy: bot must be higher than role, and member must be lower than role
|
|
const guild = interaction.guild;
|
|
const role = guild.roles.cache.get(roleId) || null;
|
|
if (!role) { await interaction.reply({ content: 'Configured role no longer exists.', ephemeral: true }); return; }
|
|
const botMember = await guild.members.fetchMe();
|
|
const botHighest = botMember.roles.highest;
|
|
const targetPosition = role.position || 0;
|
|
if (botHighest.position <= targetPosition) {
|
|
await interaction.reply({ content: 'Cannot assign role: bot lacks sufficient role hierarchy (move bot role higher).', ephemeral: true });
|
|
return;
|
|
}
|
|
const memberHighest = member.roles.highest;
|
|
if (memberHighest.position >= targetPosition) {
|
|
await interaction.reply({ content: 'Cannot assign role: your highest role is higher or equal to the role to be assigned.', ephemeral: true });
|
|
return;
|
|
}
|
|
const hasRole = member.roles.cache.has(roleId);
|
|
if (hasRole) {
|
|
await member.roles.remove(roleId, `Reaction role button toggled by user ${interaction.user.id}`);
|
|
await interaction.reply({ content: `Removed role ${role.name}.`, ephemeral: true });
|
|
} else {
|
|
await member.roles.add(roleId, `Reaction role button toggled by user ${interaction.user.id}`);
|
|
await interaction.reply({ content: `Assigned role ${role.name}.`, ephemeral: true });
|
|
}
|
|
} catch (e) {
|
|
console.error('Error handling reaction role button:', e);
|
|
try { await interaction.reply({ content: 'Failed to process reaction role.', ephemeral: true }); } catch(e){}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!interaction.isCommand()) return;
|
|
|
|
const command = client.commands.get(interaction.commandName);
|
|
|
|
if (!command) return;
|
|
|
|
// Check per-guild toggles via Postgres (directly) for lower latency and reliability
|
|
try {
|
|
// authoritative path: always try the backend HTTP API first so separate processes stay in sync
|
|
let guildSettings = await api.getServerSettings(interaction.guildId) || {};
|
|
// if API didn't return anything useful, try in-memory cache then direct DB as fallbacks
|
|
if (!guildSettings || Object.keys(guildSettings).length === 0) {
|
|
guildSettings = getGuildSettingsFromCache(interaction.guildId) || {};
|
|
if (!guildSettings || Object.keys(guildSettings).length === 0) {
|
|
try {
|
|
const pg = require('../backend/pg');
|
|
guildSettings = (await pg.getServerSettings(interaction.guildId)) || {};
|
|
} catch (pgErr) {
|
|
// leave guildSettings empty
|
|
}
|
|
}
|
|
}
|
|
// Normalize legacy flags into commandToggles for backward compatibility
|
|
const toggles = { ...(guildSettings.commandToggles || {}) };
|
|
// Example legacy flag mapping: pingCommand -> commandToggles.ping
|
|
if (typeof guildSettings.pingCommand !== 'undefined') {
|
|
toggles.ping = !!guildSettings.pingCommand;
|
|
}
|
|
const protectedCommands = ['manage-commands', 'help'];
|
|
|
|
// If command is protected, always allow
|
|
if (!protectedCommands.includes(command.name)) {
|
|
if (toggles[command.name] === false) {
|
|
await interaction.reply({ content: 'This command has been disabled on this server.', flags: 64 });
|
|
return;
|
|
}
|
|
// If the module-level enabled flag is false, treat as disabled too
|
|
if (command.enabled === false) {
|
|
await interaction.reply({ content: 'This command is currently disabled globally.', flags: 64 });
|
|
return;
|
|
}
|
|
}
|
|
|
|
try {
|
|
await command.execute(interaction);
|
|
} catch (error) {
|
|
console.error(error);
|
|
await interaction.reply({ content: 'There was an error while executing this command!', flags: 64 });
|
|
}
|
|
} catch (error) {
|
|
console.error('Error checking command toggles:', error);
|
|
await interaction.reply({ content: 'Internal error occurred.', flags: 64 });
|
|
}
|
|
});
|
|
|
|
client.on('guildCreate', guild => {
|
|
deployCommands(guild.id);
|
|
});
|
|
|
|
const login = () => {
|
|
client.login(process.env.DISCORD_BOT_TOKEN);
|
|
}
|
|
|
|
// Allow backend to trigger a live announcement for debugging
|
|
async function announceLive(guildId, stream) {
|
|
try {
|
|
const guild = await client.guilds.fetch(guildId).catch(() => null);
|
|
if (!guild) return { success: false, message: 'Guild not found' };
|
|
const settings = await (require('../backend/pg')).getServerSettings(guildId).catch(() => null) || await (require('./api')).getServerSettings(guildId).catch(() => ({}));
|
|
const liveSettings = (settings && settings.liveNotifications) || {};
|
|
if (!liveSettings.enabled) return { success: false, message: 'Live notifications disabled' };
|
|
const channelId = liveSettings.channelId;
|
|
if (!channelId) return { success: false, message: 'No channel configured' };
|
|
const channel = await guild.channels.fetch(channelId).catch(() => null);
|
|
if (!channel) return { success: false, message: 'Channel not found' };
|
|
const { EmbedBuilder } = require('discord.js');
|
|
const embed = new EmbedBuilder()
|
|
.setColor(0x9146FF)
|
|
.setTitle(stream.title || `${stream.user_name} is live`)
|
|
.setURL(stream.url)
|
|
.setAuthor({ name: stream.user_name, iconURL: stream.profile_image_url || undefined, url: stream.url })
|
|
.setThumbnail(stream.thumbnail_url || stream.profile_image_url || undefined)
|
|
.addFields(
|
|
{ name: 'Category', value: stream.game_name || 'Unknown', inline: true },
|
|
{ name: 'Viewers', value: String(stream.viewer_count || 0), inline: true }
|
|
)
|
|
.setDescription((stream.description || '').slice(0, 200))
|
|
.setFooter({ text: `ehchadservices • Started: ${stream.started_at ? new Date(stream.started_at).toLocaleString() : 'unknown'}` });
|
|
let prefixMsg = '';
|
|
if (liveSettings.customMessage) {
|
|
prefixMsg = liveSettings.customMessage;
|
|
} else if (liveSettings.message) {
|
|
prefixMsg = liveSettings.message;
|
|
} else {
|
|
prefixMsg = `🔴 ${stream.user_name} is now live!`;
|
|
}
|
|
const payload = prefixMsg ? { content: prefixMsg, embeds: [embed] } : { embeds: [embed] };
|
|
await channel.send(payload);
|
|
return { success: true };
|
|
} catch (e) {
|
|
console.error('announceLive failed:', e && e.message ? e.message : e);
|
|
return { success: false, message: e && e.message ? e.message : 'unknown error' };
|
|
}
|
|
}
|
|
|
|
module.exports = { login, client, setGuildSettings, getGuildSettingsFromCache, announceLive };
|
|
|
|
async function postReactionRoleMessage(guildId, reactionRole) {
|
|
try {
|
|
const guild = client.guilds.cache.get(guildId);
|
|
if (!guild) return { success: false, message: 'Guild not found' };
|
|
const channel = await guild.channels.fetch(reactionRole.channel_id || reactionRole.channelId).catch(() => null);
|
|
if (!channel) return { success: false, message: 'Channel not found' };
|
|
// Build buttons
|
|
const { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } = require('discord.js');
|
|
const row = new ActionRowBuilder();
|
|
const buttons = reactionRole.buttons || [];
|
|
for (let i = 0; i < buttons.length; i++) {
|
|
const b = buttons[i];
|
|
const customId = `rr_${reactionRole.id}_${b.roleId}`;
|
|
const btn = new ButtonBuilder().setCustomId(customId).setLabel(b.label || b.name || `Button ${i+1}`).setStyle(ButtonStyle.Primary);
|
|
row.addComponents(btn);
|
|
}
|
|
const embedData = reactionRole.embed || reactionRole.embed || {};
|
|
const embed = new EmbedBuilder();
|
|
if (embedData.title) embed.setTitle(embedData.title);
|
|
if (embedData.description) embed.setDescription(embedData.description);
|
|
if (embedData.color) embed.setColor(embedData.color);
|
|
if (embedData.thumbnail) embed.setThumbnail(embedData.thumbnail);
|
|
if (embedData.fields && Array.isArray(embedData.fields)) {
|
|
for (const f of embedData.fields) {
|
|
if (f.name && f.value) embed.addFields({ name: f.name, value: f.value, inline: false });
|
|
}
|
|
}
|
|
const sent = await channel.send({ embeds: [embed], components: [row] });
|
|
// update backend with message id
|
|
try {
|
|
const api = require('./api');
|
|
await api.updateReactionRole(guildId, reactionRole.id, { messageId: sent.id });
|
|
} catch (e) {
|
|
console.error('Failed to update reaction role message id in backend:', e);
|
|
}
|
|
return { success: true, messageId: sent.id };
|
|
} catch (e) {
|
|
console.error('postReactionRoleMessage failed:', e && e.message ? e.message : e);
|
|
return { success: false, message: e && e.message ? e.message : 'unknown error' };
|
|
}
|
|
}
|
|
|
|
module.exports.postReactionRoleMessage = postReactionRoleMessage;
|
|
|
|
// Start twitch watcher when client is ready (use 'clientReady' as the event name)
|
|
try {
|
|
const watcher = require('./twitch-watcher');
|
|
// discord.js uses 'clientReady' event
|
|
client.once('clientReady', () => {
|
|
// start polling in background
|
|
watcher.poll(client).catch(err => console.error('Twitch watcher failed to start:', err));
|
|
});
|
|
process.on('exit', () => { watcher.stop(); });
|
|
process.on('SIGINT', () => { watcher.stop(); process.exit(); });
|
|
} catch (e) {
|
|
// ignore if watcher not available
|
|
}
|
|
|
|
try {
|
|
const kickWatcher = require('./kick-watcher');
|
|
client.once('clientReady', () => {
|
|
// TEMPORARILY DISABLED: Kick watcher removed for now
|
|
// kickWatcher.poll(client).catch(err => console.error('Kick watcher failed to start:', err));
|
|
console.log('Kick watcher: temporarily disabled');
|
|
});
|
|
// process.on('exit', () => { kickWatcher.stop(); });
|
|
// process.on('SIGINT', () => { kickWatcher.stop(); process.exit(); });
|
|
} catch (e) {
|
|
// ignore if kick watcher not available
|
|
}
|
|
|
|
// --- Optional push receiver (so backend can notify a remote bot process) ---
|
|
try {
|
|
const express = require('express');
|
|
const bodyParser = require('body-parser');
|
|
const botPort = process.env.BOT_PUSH_PORT || process.env.BOT_PORT || null;
|
|
const botSecret = process.env.BOT_SECRET || null;
|
|
if (botPort) {
|
|
const app = express();
|
|
app.use(bodyParser.json());
|
|
app.post('/internal/set-settings', (req, res) => {
|
|
try {
|
|
if (botSecret) {
|
|
const provided = req.headers['x-bot-secret'];
|
|
if (!provided || provided !== botSecret) return res.status(401).json({ success: false, message: 'Unauthorized' });
|
|
}
|
|
const { guildId, settings } = req.body || {};
|
|
if (!guildId) return res.status(400).json({ success: false, message: 'Missing guildId' });
|
|
setGuildSettings(guildId, settings || {});
|
|
return res.json({ success: true });
|
|
} catch (e) {
|
|
console.error('Error in bot push receiver:', e);
|
|
return res.status(500).json({ success: false });
|
|
}
|
|
});
|
|
app.listen(botPort, () => console.log(`Bot push receiver listening on port ${botPort}`));
|
|
}
|
|
} catch (e) {
|
|
// ignore if express isn't available in this environment
|
|
} |