Feat/session startup

src/app.js

@@ -12,6 +12,7 @@ import { logger, startupLog, shutdownLog } from './utils/logger.js';
 import { checkBirthdays } from './services/birthdayService.js';
 import { checkGiveaways } from './services/giveawayService.js';
 import { loadCommands, registerCommands as registerSlashCommands } from './handlers/commandLoader.js';
+import { registerSessionReactions } from './handlers/events/sessionReactions.js';
 
 class TitanBot extends Client {
   constructor() {
@@ -79,6 +80,14 @@ class TitanBot extends Client {
       startupLog('Loading handlers...');
       await this.loadHandlers();
       startupLog('Handlers loaded');
+
+      // Register session reaction listeners (if available)
+      try {
+        registerSessionReactions(this);
+        startupLog('Session reaction handler registered');
+      } catch (err) {
+        logger.warn('Failed to register session reaction handler:', err && err.message ? err.message : err);
+      }
 
       startupLog('Logging into Discord...');
       await this.login(this.config.bot.token);
@@ -347,7 +356,7 @@ class TitanBot extends Client {
 
       logger.info('✅ Graceful shutdown complete');
   shutdownLog('Bot stopped successfully.');
-      process.exit(0);
+        process.exit(0);
     } catch (error) {
       logger.error('Error during graceful shutdown:', error);
       process.exit(1);
@@ -381,6 +390,3 @@ try {
 }
 
 export default TitanBot;
-
-
-

src/commands/Economy/giveall.js

@@ -0,0 +1,183 @@
+import { SlashCommandBuilder, PermissionFlagsBits } from 'discord.js';
+import { createEmbed, errorEmbed, successEmbed, infoEmbed, warningEmbed } from '../../utils/embeds.js';
+import { getEconomyData, addMoney, removeMoney, setEconomyData } from '../../utils/economy.js';
+import { withErrorHandling, createError, ErrorTypes } from '../../utils/errorHandler.js';
+import { logger } from '../../utils/logger.js';
+import { InteractionHelper } from '../../utils/interactionHelper.js';
+import { MessageTemplates } from '../../utils/messageTemplates.js';
+import EconomyService from '../../services/economyService.js';
+
+export default {
+    data: new SlashCommandBuilder()
+        .setName('giveall')
+        .setDescription('Give money to all server members (Owner/Admin only)')
+        .addIntegerOption(option =>
+            option
+                .setName('amount')
+                .setDescription('Amount to give to each member')
+                .setRequired(true)
+                .setMinValue(0)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: withErrorHandling(async (interaction, config, client) => {
+        const deferred = await InteractionHelper.safeDefer(interaction, true);
+        if (!deferred) return;
+
+        const executorId = interaction.user.id;
+        const amount = interaction.options.getInteger("amount");
+        const guildId = interaction.guildId;
+
+        // Check if user is a bot owner
+        const ownerIds = config.commands.owners || [1022692130512191518];
+        const isOwner = ownerIds.includes(interaction.user.id);
+        const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.Administrator);
+
+        if (!isOwner && !isAdmin) {
+            throw createError(
+                "Permission denied",
+                ErrorTypes.VALIDATION,
+                "Only bot owners and server administrators can use this command.",
+                { userId: executorId, guildId }
+            );
+        }
+
+        if (amount <= 0) {
+            throw createError(
+                "Invalid amount",
+                ErrorTypes.VALIDATION,
+                "Amount must be greater than zero.",
+                { amount }
+            );
+        }
+
+        logger.debug(`[ECONOMY] GiveAll command initiated`, {
+            executorId,
+            amount,
+            guildId
+        });
+
+        try {
+            // Fetch all members
+            const guild = interaction.guild;
+            if (!guild) {
+                throw createError(
+                    "Guild not found",
+                    ErrorTypes.VALIDATION,
+                    "Could not find the server.",
+                    { guildId }
+                );
+            }
+
+            await InteractionHelper.safeEditReply(interaction, {
+                content: `⏳ Processing giveaway to **${guild.memberCount}** members...`
+            });
+
+            // Fetch all members from the guild
+            const members = await guild.members.fetch({ limit: 0 });
+            const memberIds = members
+                .filter(m => !m.user.bot) // Exclude bots
+                .map(m => m.user.id);
+
+            logger.info(`[ECONOMY] Starting money distribution`, {
+                executorId,
+                memberCount: memberIds.length,
+                amountPerMember: amount,
+                guildId
+            });
+
+            let successCount = 0;
+            let failureCount = 0;
+            const errors = [];
+
+            // Process each member in batches to avoid rate limiting
+            const batchSize = 10;
+            for (let i = 0; i < memberIds.length; i += batchSize) {
+                const batch = memberIds.slice(i, i + batchSize);
+
+                await Promise.all(
+                    batch.map(async (memberId) => {
+                        try {
+                            // Get member's current economy data
+                            const memberData = await getEconomyData(client, guildId, memberId);
+
+                            if (!memberData) {
+                                failureCount++;
+                                return;
+                            }
+
+                            // Add money to member's wallet
+                            const newWallet = memberData.wallet + amount;
+                            memberData.wallet = newWallet;
+
+                            // Update the economy data
+                            await setEconomyData(client, guildId, memberId, memberData);
+
+                            successCount++;
+                        } catch (err) {
+                            failureCount++;
+                            errors.push(`${memberId}: ${err.message}`);
+                            logger.warn(`Failed to give money to ${memberId}`, { error: err.message });
+                        }
+                    })
+                );
+            }
+
+            const embed = MessageTemplates.SUCCESS.DATA_UPDATED(
+                "giveall",
+                `Successfully distributed **$${amount.toLocaleString()}** to **${successCount}** members!`
+            )
+                .addFields(
+                    {
+                        name: "✅ Successful",
+                        value: `${successCount} members`,
+                        inline: true,
+                    },
+                    {
+                        name: "❌ Failed",
+                        value: `${failureCount} members`,
+                        inline: true,
+                    },
+                    {
+                        name: "💵 Amount Per Member",
+                        value: `$${amount.toLocaleString()}`,
+                        inline: true,
+                    },
+                    {
+                        name: "👥 Total Members Processed",
+                        value: `${memberIds.length}`,
+                        inline: true,
+                    }
+                )
+                .setFooter({
+                    text: `Executed by ${interaction.user.username}`,
+                    iconURL: interaction.user.displayAvatarURL(),
+                });
+
+            if (errors.length > 0 && errors.length <= 5) {
+                embed.addFields({
+                    name: "⚠️ Error Details",
+                    value: errors.join("\n").substring(0, 1024)
+                });
+            }
+
+            await InteractionHelper.safeEditReply(interaction, { embeds: [embed] });
+
+            logger.info(`[ECONOMY] GiveAll completed`, {
+                executorId,
+                successCount,
+                failureCount,
+                totalAmount: successCount * amount,
+                guildId
+            });
+
+        } catch (err) {
+            logger.error(`[ECONOMY] GiveAll command failed`, {
+                error: err.message,
+                executorId,
+                guildId
+            });
+            throw err;
+        }
+    }, { command: 'giveall' })
+};

src/commands/Session/startup.js

@@ -0,0 +1,101 @@
+import { SlashCommandBuilder } from 'discord.js';
+import { createEmbed } from '../../utils/embeds.js';
+
+/**
+ * /startup required_reactions: int
+ * Checks staff role from guild config, enforces allowed channels from guild config,
+ * posts the startup embed, pings everyone and stores session state/pending sessions on the client.
+ */
+export default {
+  slashOnly: true,
+  data: new SlashCommandBuilder()
+    .setName('startup')
+    .setDescription('Start a roleplay session')
+    .addIntegerOption((opt) =>
+      opt
+        .setName('required_reactions')
+        .setDescription('Number of reactions needed to start the session')
+        .setRequired(true)
+        .setMinValue(1),
+    ),
+
+  category: 'Session',
+
+  async execute(interaction, guildConfig = {}, client) {
+    const required = interaction.options.getInteger('required_reactions');
+
+    // Resolve staff role ID from guild config: config.roles.staff_team
+    const staffRoleId = String(guildConfig?.roles?.staff_team || '');
+    const memberRoles = interaction.member?.roles?.cache;
+
+    if (!staffRoleId || !(memberRoles && memberRoles.has && memberRoles.has(staffRoleId))) {
+      await interaction.reply({ content: 'Only staff team members can use this command.', ephemeral: true });
+      return;
+    }
+
+    // Enforce allowed channels from guild config: channels.session_commands_channel_id / _2
+    const channels = guildConfig?.channels || {};
+    const allowed1 = String(channels.session_commands_channel_id || '');
+    const allowed2 = String(channels.session_commands_channel_id_2 || '');
+
+    if (![String(interaction.channelId), String(allowed1), String(allowed2)].includes(String(interaction.channelId))) {
+      await interaction.reply({
+        content: `This command can only be used in <#${allowed1}> or <#${allowed2}>.`,
+        ephemeral: true,
+      });
+      return;
+    }
+
+    // Build embed from guild embed config (keys: embeds.startup)
+    const ecfg = (guildConfig?.embeds && guildConfig.embeds.startup) || {};
+    const title = ecfg.title || '_Greenville Roleplay Legacy_ - ___Session Startup___';
+    // replace placeholders {user} and {required} if present
+    let description = ecfg.description || '';
+    description = description.replace(/\{user\}/g, interaction.user?.toString() || '')
+                             .replace(/\{required\}/g, String(required));
+    const embed = createEmbed({
+      title,
+      description,
+      color: 'success',
+    });
+    if (ecfg.image_url) embed.setImage(ecfg.image_url);
+    embed.setFooter({ text: guildConfig?.bot?.footer_text || '', iconURL: guildConfig?.bot?.footer_icon || '' });
+
+    // Reply to invoker, then post the announcement (ping everyone)
+    await interaction.reply({ content: 'Startup initiated.', ephemeral: true });
+
+    const channel = interaction.channel;
+    const announcement = await channel.send({
+      content: '@everyone',
+      embeds: [embed],
+      allowedMentions: { parse: ['everyone'] },
+    });
+
+    // Add reaction (custom emoji string works: <:name:id>)
+    const targetEmoji = '<:pinkcheckmark:1502780778449342494>'; // same emoji used in your python
+    try {
+      await announcement.react(targetEmoji);
+    } catch (err) {
+      // Reaction might fail if emoji not available; ignore silently
+      // If you have a logger, you can log this error
+    }
+
+    // Ensure client-side stores exist
+    if (!client.sessionStates) client.sessionStates = new Map();
+    if (!client.pendingSessions) client.pendingSessions = new Map();
+
+    // Save session state and pending session entry
+    client.sessionStates.set(String(channel.id), {
+      messageId: announcement.id,
+      time: Math.floor(Date.now() / 1000),
+      completed: true,
+      reactors: new Set(),
+    });
+
+    client.pendingSessions.set(String(announcement.id), {
+      type: 'startup',
+      required,
+      user: interaction.user?.toString() || interaction.user?.tag || 'unknown',
+    });
+  },
+};