test

src/events/index.ts

@@ -1,4 +1,3 @@
-import { guildCreateEvent } from './guild-create.js';
 import { hasVarEvent } from './has-var.js';
 import { interactionCreateEvent } from './interaction-create.js';
 import { justAskEvent } from './just-ask.js';
@@ -7,7 +6,6 @@ import type { DiscordEvent } from './types.js';
 
 export const events = [
   readyEvent,
-  guildCreateEvent,
   justAskEvent,
   hasVarEvent,
   interactionCreateEvent,

src/events/interaction-create.ts

@@ -1,34 +1,32 @@
-import { Events, MessageFlags } from 'discord.js';
-import { commands } from '../commands/index.js';
-import { createEvent } from '../util/events.js';
-import { isAllowedServer } from '../util/server-guard.js';
+import { Events } from "discord.js";
+import { commands } from "../commands/index.js";
+import { config } from "../env.js";
+import { createEvent } from "../util/events.js";
 
 export const interactionCreateEvent = createEvent(
   {
     name: Events.InteractionCreate,
   },
   async (interaction) => {
-    if (interaction.isChatInputCommand() || interaction.isMessageContextMenuCommand()) {
-      // Block commands from unauthorized servers
-      if (!interaction.guildId || !isAllowedServer(interaction.guildId)) {
-        console.log(`⚠️ Command blocked from unauthorized server: ${interaction.guildId}`);
-        if (interaction.isRepliable()) {
-          await interaction.reply({
-            content: '❌ This bot is not authorized to operate in this server.',
-            flags: MessageFlags.Ephemeral,
-          });
-        }
+    if (
+      interaction.isChatInputCommand() ||
+      interaction.isMessageContextMenuCommand()
+    ) {
+      // Skip processing if not in the intended server
+      if (interaction.guild?.id !== config.serverId) {
         return;
       }
 
       console.log(`Interaction received: ${interaction.commandName}`);
       const command = commands.get(interaction.commandName);
 
       if (!command) {
-        throw new Error(`No command matching ${interaction.commandName} was found.`);
+        throw new Error(
+          `No command matching ${interaction.commandName} was found.`,
+        );
       }
 
       await command.execute(interaction);
     }
-  }
+  },
 );

src/events/ready.ts

@@ -3,7 +3,6 @@ import { config } from '../env.js';
 import { fetchAndCachePublicChannelsMessages } from '../util/cache.js';
 import { createEvent } from '../util/events.js';
 import { syncGuidesToChannel } from '../util/post-guides.js';
-import { leaveIfNotAllowedServer } from '../util/server-guard.js';
 
 export const readyEvent = createEvent(
   {
@@ -12,13 +11,6 @@ export const readyEvent = createEvent(
   },
   async (client) => {
     console.log(`Ready! Logged in as ${client.user.tag}`);
-
-    // Check all guilds and leave any unauthorized ones
-    console.log(`🔍 Checking ${client.guilds.cache.size} guild(s)...`);
-    for (const guild of client.guilds.cache.values()) {
-      await leaveIfNotAllowedServer(guild);
-    }
-
     if (config.fetchAndSyncMessages) {
       const guild = client.guilds.cache.get(config.serverId);
       if (guild) {

src/util/events.ts

@@ -1,12 +1,13 @@
-import type { Client, ClientEvents } from 'discord.js';
-import type { DiscordEvent } from '../events/types.js';
+import type { Client, ClientEvents } from "discord.js";
+import type { DiscordEvent } from "../events/types.js";
+import { config } from "../env.js";
 
 export const createEvent = <T extends keyof ClientEvents = keyof ClientEvents>(
   data: {
     name: T;
     once?: boolean;
   },
-  execute: (...args: ClientEvents[T]) => Promise<void> | void
+  execute: (...args: ClientEvents[T]) => Promise<void> | void,
 ): DiscordEvent<T> => {
   return { ...data, execute };
 };
@@ -18,16 +19,23 @@ export const createEvents = <T extends keyof ClientEvents = keyof ClientEvents>(
       once?: boolean;
     };
     execute: (...args: ClientEvents[T]) => Promise<void> | void;
-  }>
+  }>,
 ): DiscordEvent<T>[] => {
   return events.map(({ data, execute }) => createEvent(data, execute));
 };
 
-export const registerEvents = async (client: Client, events: DiscordEvent[]): Promise<void> => {
+export const registerEvents = async (
+  client: Client,
+  events: DiscordEvent[],
+): Promise<void> => {
   for (const event of events) {
     console.log(`Loading event: ${event.name}`);
-    client[event.once ? 'once' : 'on'](event.name, async (...args) => {
+    client[event.once ? "once" : "on"](event.name, async (...args) => {
       try {
+        // Skip processing if not in the intended server
+        if (args[0]?.guild?.id !== config.serverId) {
+          return;
+        }
         await event.execute(...args);
       } catch (error) {
         console.error(`Error executing event ${event.name}:`, error);