const fs = require('fs');
const Discord = require('discord.js');
const config = require('./config.json');
const storage = require('./storage.json');
// Write changes to storage.json
const writeStorage = () => {
fs.writeFileSync('./storage.json', JSON.stringify(storage, null, 4));
};
// Convert a permissions integer to an array of permission names
const permIntToNames = perms => {
// Convert to integer
perms = parseInt(perms.bitfield ? perms.bitfield : perms);
// Loop through permission entries and compile a list
const entries = [];
for (const [ name, bit ] of Object.entries(Discord.PermissionFlagsBits)) {
entries.push({ name, value: parseInt(bit) });
}
// Sort the list in descending order
entries.sort((a, b) => b.value - a.value);
// Check each entry and add it to the list if it's greater than
// the remaining number
const result = [];
for (const entry of entries) {
if (perms >= entry.value) {
result.push(entry.name);
perms -= entry.value;
}
}
// Return the list
return result;
}
const getRichTs = (date = new Date(), type = 'R') => {
const ts = Math.floor(date.getTime() / 1000);
return `<t:${ts}:${type}>`;
};
// Read command files from these folders
const dirs = [
'./commands',
'./context/message',
'./context/user'
];
const embedChannelIds = [];
const bot = new Discord.Client({
intents: [
Discord.GatewayIntentBits.Guilds,
Discord.GatewayIntentBits.GuildMembers,
Discord.GatewayIntentBits.GuildMessages,
Discord.GatewayIntentBits.GuildMessageReactions,
Discord.GatewayIntentBits.MessageContent
],
partials: [
Discord.Partials.User,
Discord.Partials.Channel,
Discord.Partials.Message,
Discord.Partials.Reaction
]
});
const sendLog = async(title, fields, type, color = '#77a4ff') => {
try {
const channelId = config.discord.log_channels[type];
const channel = bot.channels.cache.get(channelId) || await bot.channels.fetch(channelId);
channel.send({
embeds: [
new Discord.EmbedBuilder()
.setTitle(title)
.setFields(fields)
.setColor(color)
]
});
} catch (error) {
console.error(`Failed to send log:`, error);
console.error(`Log info:`, JSON.stringify({
type, title, fields, color
}, null, 2));
}
};
bot.on(Discord.Events.ClientReady, async () => {
console.log(`Logged in as ${bot.user.tag}`);
// Send embeds if they don't exist
const embedFiles = fs.readdirSync('./embeds');
for (const file of embedFiles) {
const filePath = `./embeds/${file}`;
// Clear require cache and require the file
delete require.cache[require.resolve(filePath)];
const data = require(filePath);
// Make sure the channel exists
const channel = bot.channels.cache.get(data.channel);
if (!channel) continue;
embedChannelIds.push(data.channel);
// Check if a message ID is saved and if it exists
const messageId = storage.embeds[filePath];
let msg;
if (messageId) {
try {
msg = await channel.messages.fetch(messageId);
} catch (error) {
console.log(`Error fetching message ${messageId}:`, error);
}
}
// If the message exists, edit it
if (msg) {
//msg.edit(data.message);
// Otherwise, send a new one
} else {
channel.send(data.message).then(msg => {
storage.embeds[filePath] = msg.id;
writeStorage();
});
}
}
// Run onLoad functions for each command
for (const dir of dirs) {
if (!fs.existsSync(dir)) continue;
const files = fs.readdirSync(dir);
for (const file of files) {
const data = require(`${dir}/${file}`);
if (data.onLoad) data.onLoad(bot);
}
}
// Send log
await sendLog('Bot started', [{
name: 'Started',
value: `${getRichTs()}`
}], 'system', '#7eff77');
});
// Handle new messages
bot.on(Discord.Events.MessageCreate, message => {
// If the message isn't in an embed channel, ignore it
if (!embedChannelIds.includes(message.channel.id)) return;
// If the message was sent by a bot, ignore it
if (message.author.bot) return;
// If the message was sent in an embed channel, delete it
if (embedChannelIds.includes(message.channel.id)) {
message.delete();
}
});
// Log message deletions
bot.on(Discord.Events.MessageDelete, message => {
if (message.type != Discord.MessageType.Default) return;
let content = message.content || '*no content*';
if (content.length > 1024) content = content.substring(0, 1021) + '...';
sendLog('Message deleted', [
{ name: 'Message', value: content },
{ name: 'Channel', value: `<#${message.channel.id}>`, inline: true },
{ name: 'Author', value: `<@${message.author.id}>`, inline: true }
], 'messages', '#ff77a3');
});
// Log message edits
bot.on(Discord.Events.MessageUpdate, (oldMessage, newMessage) => {
let oldContent = oldMessage.content || '*no content*';
let newContent = newMessage.content || '*no content*';
if (oldContent == newContent) return;
if (oldContent.length > 1024) oldContent = oldContent.substring(0, 1021) + '...';
if (newContent.length > 1024) newContent = newContent.substring(0, 1021) + '...';
sendLog('Message edited', [
{ name: 'Channel', value: `<#${newMessage.channel.id}>`, inline: true },
{ name: 'Author', value: `<@${newMessage.author.id}>`, inline: true },
{ name: 'Old message', value: oldContent },
{ name: 'New message', value: newContent }
], 'messages');
});
// Log user joins
bot.on(Discord.Events.GuildMemberAdd, member => {
sendLog('User joined', [
{ name: 'User', value: `<@${member.id}>`, inline: true },
{ name: 'Account created', value: getRichTs(member.user.createdAt), inline: true }
], 'join_leave', '#7eff77');
});
// Log user leaves
bot.on(Discord.Events.GuildMemberRemove, member => {
sendLog('User left', [
{ name: 'User', value: `<@${member.id}> (\`${member.user.tag}\`)`, inline: true },
{ name: 'Joined', value: getRichTs(member.joinedAt), inline: true },
], 'join_leave', '#ff77a3');
});
// Log channel creation
bot.on(Discord.Events.ChannelCreate, channel => {
sendLog('Channel created', [
{ name: 'Channel', value: `<#${channel.id}>`, inline: true }
], 'channels', '#7eff77');
});
// Log channel deletion
bot.on(Discord.Events.ChannelDelete, channel => {
sendLog('Channel deleted', [
{ name: 'Channel', value: `<#${channel.id}>`, inline: true },
{ name: 'Created', value: getRichTs(channel.createdAt), inline: true }
], 'channels', '#ff77a3');
});
// Log channel edits
bot.on(Discord.Events.ChannelUpdate, (oldChannel, newChannel) => {
const newName = newChannel.name;
const oldName = oldChannel.name;
const newTopic = newChannel.topic ? newChannel.topic.substring(0, 1021) + '...' : '*no topic*';
const oldTopic = oldChannel.topic ? oldChannel.topic.substring(0, 1021) + '...' : '*no topic*';
const fields = [
{ name: 'Channel', value: `<#${newChannel.id}>` }
];
if (newName !== oldName) {
fields.push(
{ name: 'Old name', value: oldName, inline: true },
{ name: 'New name', value: newName, inline: true }
);
}
if (newTopic !== oldTopic) {
fields.push(
{ name: 'Old topic', value: oldTopic },
{ name: 'New topic', value: newTopic }
);
}
sendLog('Channel edited', fields, 'channels');
});
// Log role creation
bot.on(Discord.Events.GuildRoleCreate, role => {
sendLog('Role created', [
{ name: 'Role', value: `<@&${role.id}>`, inline: true }
], 'roles', '#7eff77');
});
// Log role deletion
bot.on(Discord.Events.GuildRoleDelete, role => {
sendLog('Role deleted', [
{ name: 'Name', value: role.name, inline: true },
{ name: 'Created', value: getRichTs(role.createdAt), inline: true }
], 'roles', '#ff77a3');
});
// Log role edits
bot.on(Discord.Events.GuildRoleUpdate, (oldRole, newRole) => {
const newName = newRole.name;
const oldName = oldRole.name;
const newColor = newRole.hexColor;
const oldColor = oldRole.hexColor;
const newHoisted = newRole.hoist;
const oldHoisted = oldRole.hoist;
const newMentionable = newRole.mentionable;
const oldMentionable = oldRole.mentionable;
const newPerms = permIntToNames(newRole.permissions);
const oldPerms = permIntToNames(oldRole.permissions);
const addedPerms = newPerms.filter(perm => !oldPerms.includes(perm));
const removedPerms = oldPerms.filter(perm => !newPerms.includes(perm));
const oldPos = oldRole.position;
const newPos = newRole.position;
const fields = [
{ name: 'Role', value: `<@&${newRole.id}>` }
];
if (newName !== oldName) {
fields.push(
{ name: 'Old name', value: oldName, inline: true },
{ name: 'New name', value: newName, inline: true }
);
}
if (newColor !== oldColor) {
fields.push(
{ name: 'Color', value: `\`${oldColor}\` => \`${newColor}\`` }
);
}
if (newHoisted !== oldHoisted) {
fields.push(
{ name: 'Separate members', value: newHoisted ? 'No => Yes' : 'Yes => No' }
);
}
if (newMentionable !== oldMentionable) {
fields.push(
{ name: 'Mentionable', value: newMentionable ? 'No => Yes' : 'Yes => No' }
);
}
if (newPerms !== oldPerms) {
if (addedPerms.length) fields.push(
{ name: 'Added permissions', value: `\`${addedPerms.join('`, `')}\``, inline: true }
);
if (removedPerms.length) fields.push(
{ name: 'Removed permissions', value: `\`${removedPerms.join('`, `')}\``, inline: true }
);
}
if (newPos !== oldPos) {
fields.push(
{ name: 'Position', value: `${oldPos} => ${oldPos}` }
);
}
if (fields.length == 1) return;
sendLog('Role edited', fields, 'roles');
});
// Log user role list and nickname changes
bot.on(Discord.Events.GuildMemberUpdate, (oldMember, newMember) => {
const oldRoles = oldMember.roles.cache;
const newRoles = newMember.roles.cache;
const addedRoles = newRoles.filter(role => !oldRoles.has(role.id));
const removedRoles = oldRoles.filter(role => !newRoles.has(role.id));
const oldNick = oldMember.nickname || '*no nickname*';
const newNick = newMember.nickname || '*no nickname*';
if (addedRoles.size || removedRoles.size) {
const fields = [
{ name: 'User', value: `<@${newMember.id}>`, inline: true }
];
if (addedRoles.size) {
fields.push(
{ name: 'Added roles', value: addedRoles.map(role => `<@&${role.id}>`).join(', '), inline: true }
);
}
if (removedRoles.size) {
fields.push(
{ name: 'Removed roles', value: removedRoles.map(role => `<@&${role.id}>`).join(', '), inline: true }
);
}
sendLog('User roles updated', fields, 'roles');
}
if (oldNick !== newNick) {
sendLog('User nickname changed', [
{ name: 'User', value: `<@${newMember.id}>`, inline: true },
{ name: 'Old nickname', value: oldNick, inline: true },
{ name: 'New nickname', value: newNick, inline: true }
], 'roles');
}
});
// Handle interactions
bot.on(Discord.Events.InteractionCreate, async interaction => {
// Handle Apps command on messages
if (interaction.isMessageContextMenuCommand()) {
const data = require(`./context/message/${interaction.commandName}.js`);
data.handler(interaction);
}
// Handle Apps command on users
if (interaction.isUserContextMenuCommand()) {
const data = require(`./context/user/${interaction.commandName}.js`);
data.handler(interaction);
}
// Handle slash commands
if (interaction.isChatInputCommand()) {
const data = require(`./commands/${interaction.commandName}.js`);
data.handler(interaction);
}
});
// Handle RSS feeds
const rssChecks = {};
setTimeout(async() => {
const rssFiles = fs.readdirSync('./rss');
for (const file of rssFiles) {
const filePath = `./rss/${file}`;
const data = require(filePath);
if (rssChecks[file] && (Date.now()-rssChecks[file].lastCheck) < data.frequency_mins * 60 * 1000)
continue;
const parser = new rssParser();
const rss = await parser.parseURL(data.rss);
if (rssChecks[filePath]) {
const newEntries = rss.items.filter(item => item.link != rssChecks[filePath].lastItem.link);
newEntries.reverse();
const webhook = new Discord.WebhookClient({ url: data.webhook });
for (const entry of newEntries) {
webhook.send({
embeds: [
new Discord.EmbedBuilder()
.setAuthor({ name: entry.author })
.setTitle(entry.title)
.setURL(entry.link)
.setDescription(entry.contentSnippet.split('\n')[0])
.setFooter({ text: 'Click the title to read more...' })
.setColor(data.embed_color)
]
});
}
}
rssChecks[filePath] = {
lastCheck: Date.now(),
lastItem: rss.items[0]
};
}
}, 1000);
bot.login(config.discord.token);
