Code

const { Client, GatewayIntentBits, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.GuildMembers,
        GatewayIntentBits.MessageContent,
        GatewayIntentBits.GuildMessageReactions
    ]
});

// Configuration
const config = {
    channelId: 'YOUR_CHANNEL_ID', // Channel where the message will be
    messageId: null, // Will be set when we create the message
    trackedRoles: new Map() // Stores role IDs and their display names
};

// Initialize with some roles if needed
// Format: trackedRoles.set('ROLE_ID', 'Display Name');

client.once('ready', async () => {
    console.log(`Logged in as ${client.user.tag}`);
    await checkOrCreateMessage();
    setInterval(() => updateRoleListMessage(), 60000); // Update every minute to catch any missed events
});

// Command handler
client.on('messageCreate', async message => {
    if (message.author.bot) return;
    if (!message.content.startsWith('!')) return;

    const args = message.content.slice(1).trim().split(/ +/);
    const command = args.shift().toLowerCase();

    if (command === 'add') {
        if (!message.member.permissions.has('ADMINISTRATOR')) {
            return message.reply('You need administrator permissions to use this command.');
        }

        const role = message.mentions.roles.first();
        if (!role) return message.reply('Please mention a role to track.');

        const roleName = args.slice(1).join(' ') || role.name;
        config.trackedRoles.set(role.id, roleName);
        await updateRoleListMessage();
        await message.reply(`Now tracking role: ${roleName}`);
    }

    if (command === 'remove') {
        if (!message.member.permissions.has('ADMINISTRATOR')) {
            return message.reply('You need administrator permissions to use this command.');
        }

        const role = message.mentions.roles.first();
        if (!role) return message.reply('Please mention a role to stop tracking.');

        if (config.trackedRoles.has(role.id)) {
            const roleName = config.trackedRoles.get(role.id);
            config.trackedRoles.delete(role.id);
            await updateRoleListMessage();
            await message.reply(`Stopped tracking role: ${roleName}`);
        } else {
            await message.reply('That role isn\'t being tracked.');
        }
    }

    if (command === 'refresh') {
        await updateRoleListMessage();
        await message.reply('Role list refreshed!');
    }
});

// Handle role changes
client.on('guildMemberUpdate', async (oldMember, newMember) => {
    const oldRoles = oldMember.roles.cache.map(r => r.id);
    const newRoles = newMember.roles.cache.map(r => r.id);

    // Check if any tracked roles were added or removed
    const needsUpdate = Array.from(config.trackedRoles.keys()).some(roleId =>
        oldRoles.includes(roleId) !== newRoles.includes(roleId)
    );

    if (needsUpdate) {
        await updateRoleListMessage();
    }
});

// Handle role deletions
client.on('roleDelete', async role => {
    if (config.trackedRoles.has(role.id)) {
        config.trackedRoles.delete(role.id);
        await updateRoleListMessage();
    }
});

// Main function to update the role list message
async function updateRoleListMessage() {
    if (!config.channelId) return;

    const channel = await client.channels.fetch(config.channelId).catch(console.error);
    if (!channel) return;

    // Create the embed with all tracked roles
    const embed = new EmbedBuilder()
        .setTitle('Server Staff')
        .setColor('#2b2d31')
        .setTimestamp();

    // Add a field for each tracked role
    for (const [roleId, roleName] of config.trackedRoles) {
        const role = await channel.guild.roles.fetch(roleId).catch(() => null);
        if (!role) {
            config.trackedRoles.delete(roleId);
            continue;
        }

        const members = role.members.map(m => m.user.toString());
        embed.addFields({
            name: roleName,
            value: members.length > 0 ? members.join('\n') : 'No members',
            inline: true
        });
    }

    // Add buttons for management
    const buttons = new ActionRowBuilder().addComponents(
        new ButtonBuilder()
            .setCustomId('add_role')
            .setLabel('Add Role')
            .setStyle(ButtonStyle.Primary),
        new ButtonBuilder()
            .setCustomId('refresh')
            .setLabel('Refresh')
            .setStyle(ButtonStyle.Secondary)
    );

    // Update or create the message
    try {
        if (config.messageId) {
            const message = await channel.messages.fetch(config.messageId);
            await message.edit({ embeds: [embed], components: [buttons] });
        } else {
            const message = await channel.send({ embeds: [embed], components: [buttons] });
            config.messageId = message.id;
        }
    } catch (error) {
        console.error('Error updating role list message:', error);
        // Message might have been deleted, send a new one
        const message = await channel.send({ embeds: [embed], components: [buttons] });
        config.messageId = message.id;
    }
}

// Check if we have a message or need to create one
async function checkOrCreateMessage() {
    if (!config.channelId) return;

    const channel = await client.channels.fetch(config.channelId).catch(console.error);
    if (!channel) return;

    if (config.messageId) {
        try {
            await channel.messages.fetch(config.messageId);
        } catch {
            // Message doesn't exist, reset the ID
            config.messageId = null;
            await updateRoleListMessage();
        }
    } else {
        await updateRoleListMessage();
    }
}

// Handle button interactions
client.on('interactionCreate', async interaction => {
    if (!interaction.isButton()) return;

    if (interaction.customId === 'refresh') {
        await interaction.deferUpdate();
        await updateRoleListMessage();
    }

    if (interaction.customId === 'add_role') {
        if (!interaction.member.permissions.has('ADMINISTRATOR')) {
            return interaction.reply({ content: 'You need administrator permissions to use this.', ephemeral: true });
        }

        await interaction.reply({
            content: 'Use `!add @role Role Name` to add a role to track.',
            ephemeral: true
        });
    }
});

client.login('YOUR_BOT_TOKEN');