feat(commands): add getPlayerConnectionHistory command for ownerOnly access

Author: sonikro

.env.example

@@ -3,6 +3,9 @@ DISCORD_TOKEN=
 DISCORD_CLIENT_ID=
 SRCDS_LOG_ADDRESS=
 
+# Optional, but required for Owner-only commands
+DISCORD_OWNER_GUILD_ID=
+
 # Required for interacting with Oracle Cloud
 OCI_CONFIG_FILE=
 

packages/entrypoints/src/commands/GetPlayerConnectionHistory/definition.ts

@@ -0,0 +1,11 @@
+import { SlashCommandBuilder } from "discord.js";
+
+export const getPlayerConnectionHistoryDefinition = new SlashCommandBuilder()
+    .setName('get-player-connection-history')
+    .setDescription('Gets the connection history for a specific player (Owner only)')
+    .setDefaultMemberPermissions(0)  // Hides from everyone by default
+    .addStringOption(option =>
+        option.setName('player_steam_id3')
+            .setDescription('Player Steam ID3 (e.g., U:1:12345678)')
+            .setRequired(true)
+    );

packages/entrypoints/src/commands/GetPlayerConnectionHistory/handler.ts

@@ -0,0 +1,13 @@
+import { ChatInputCommandInteraction, MessageFlags } from "discord.js";
+
+export function getPlayerConnectionHistoryHandlerFactory() {
+    return async (interaction: ChatInputCommandInteraction) => {
+        const playerSteamId3 = interaction.options.getString('player_steam_id3', true);
+
+        // Dummy implementation - just echo back for now
+        await interaction.reply({
+            content: `🔍 **Player Connection History**\n\nSearching for player: \`${playerSteamId3}\`\n\n_This is a dummy implementation. Full functionality coming soon!_`,
+            flags: MessageFlags.Ephemeral
+        });
+    };
+}

packages/entrypoints/src/commands/GetPlayerConnectionHistory/index.ts

@@ -0,0 +1,2 @@
+export { getPlayerConnectionHistoryDefinition } from "./definition";
+export { getPlayerConnectionHistoryHandlerFactory } from "./handler";

packages/entrypoints/src/commands/index.ts

@@ -14,6 +14,14 @@ import { ConfigManager } from "@tf2qs/core";
 import { setUserDataDefinition, setUserDataHandlerFactory } from "./SetUserData";
 import { SetUserData } from "@tf2qs/core";
 import { statusCommandDefinition, createStatusCommandHandlerFactory } from "./Status";
+import { getPlayerConnectionHistoryDefinition, getPlayerConnectionHistoryHandlerFactory } from "./GetPlayerConnectionHistory";
+
+export type Command = {
+    name: string;
+    definition: SlashCommandOptionsOnlyBuilder;
+    handler: (interaction: ChatInputCommandInteraction) => Promise<void>;
+    ownerOnly?: boolean;
+}
 
 export type CommandDependencies = {
     createServerForUser: CreateServerForUser;
@@ -26,7 +34,7 @@ export type CommandDependencies = {
     getUserServers: GetUserServers;
 }
 
-export function createCommands(dependencies: CommandDependencies) {
+export function createCommands(dependencies: CommandDependencies): Record<string, Command> {
     return {
         createServer: {
             name: "create-server",
@@ -48,7 +56,13 @@ export function createCommands(dependencies: CommandDependencies) {
             definition: setUserDataDefinition,
             handler: setUserDataHandlerFactory({
                 setUserData: dependencies.setUserData,
-            })
+            }),
+        },
+        getPlayerConnectionHistory: {
+            name: "get-player-connection-history",
+            definition: getPlayerConnectionHistoryDefinition,
+            handler: getPlayerConnectionHistoryHandlerFactory(),
+            ownerOnly: true,
         },
         status: {
             name: "status",
@@ -82,9 +96,5 @@ export function createCommands(dependencies: CommandDependencies) {
         //         createCreditsPurchaseOrder: dependencies.createCreditsPurchaseOrder,
         //     })
         // }
-    } satisfies Record<string, {
-        name: string;
-        definition: SlashCommandOptionsOnlyBuilder,
-        handler: (interaction: ChatInputCommandInteraction) => Promise<void>;
-    }>
+    };
 }

packages/entrypoints/src/discordBot.test.ts

@@ -76,20 +76,35 @@ describe("startDiscordBot", () => {
         beforeAll(async () => {
             process.env.DISCORD_TOKEN = 'valid_token';
             process.env.DISCORD_CLIENT_ID = 'valid_client_id';
+            process.env.DISCORD_OWNER_GUILD_ID = 'test_guild_123';
             await startDiscordBot();
         })
 
         it("should initialize KnexConnectionManager", () => {
             expect(KnexConnectionManager.initialize).toHaveBeenCalled();
         })
         it("should register all commands globally with Discord API", async () => {
-            const expectedCommands = Object.values(discordCommands)
+            const regularCommands = Object.values(discordCommands)
+                .filter(cmd => !cmd.ownerOnly)
                 .map(command => command.definition.toJSON());
 
             expect(rest.put).toHaveBeenCalledWith(
                 Routes.applicationCommands('valid_client_id'),
                 expect.objectContaining({
-                    body: expectedCommands
+                    body: regularCommands
+                })
+            );
+        })
+
+        it("should register owner-only commands to the specific guild", async () => {
+            const ownerOnlyCommands = Object.values(discordCommands)
+                .filter(cmd => cmd.ownerOnly)
+                .map(command => command.definition.toJSON());
+
+            expect(rest.put).toHaveBeenCalledWith(
+                Routes.applicationGuildCommands('valid_client_id', 'test_guild_123'),
+                expect.objectContaining({
+                    body: ownerOnlyCommands
                 })
             );
         })

packages/entrypoints/src/discordBot.ts

@@ -60,6 +60,7 @@ export async function startDiscordBot() {
     // Define the bot token
     const token = process.env.DISCORD_TOKEN!;
     const clientId = process.env.DISCORD_CLIENT_ID!;
+    const ownerGuildId = process.env.DISCORD_OWNER_GUILD_ID;
 
     // Check if token and clientId are available
     if (!token) {
@@ -279,7 +280,16 @@ export async function startDiscordBot() {
     })
 
     // Slash commands
-    const commands = Object.values(discordCommands).map(command => command.definition)
+    const allCommands = Object.values(discordCommands);
+    
+    // Separate regular commands from owner-only commands
+    const regularCommands = allCommands
+        .filter(cmd => !cmd.ownerOnly)
+        .map(cmd => cmd.definition);
+    
+    const ownerOnlyCommands = allCommands
+        .filter(cmd => cmd.ownerOnly)
+        .map(cmd => cmd.definition);
 
     // Register commands with Discord API
     const rest = new REST({ version: '10' }).setToken(token);
@@ -290,11 +300,33 @@ export async function startDiscordBot() {
         body: 'Started refreshing application (/) commands.'
     });
 
-    // Register commands globally (this applies to all guilds)
+    // Register regular commands globally (this applies to all guilds)
     await rest.put(Routes.applicationCommands(clientId), {
-        body: commands.map(command => command.toJSON()), // Convert CommandBuilder to JSON
+        body: regularCommands.map(command => command.toJSON()), // Convert CommandBuilder to JSON
     });
 
+    logger.emit({
+        severityText: 'INFO',
+        body: `Successfully registered ${regularCommands.length} global command(s).`
+    });
+
+    // Register owner-only commands to the specific guild if configured
+    if (ownerGuildId && ownerOnlyCommands.length > 0) {
+        await rest.put(Routes.applicationGuildCommands(clientId, ownerGuildId), {
+            body: ownerOnlyCommands.map(command => command.toJSON()),
+        });
+
+        logger.emit({
+            severityText: 'INFO',
+            body: `Successfully registered ${ownerOnlyCommands.length} owner-only command(s) to guild ${ownerGuildId}.`
+        });
+    } else if (ownerOnlyCommands.length > 0) {
+        logger.emit({
+            severityText: 'WARN',
+            body: 'DISCORD_OWNER_GUILD_ID not set. Owner-only commands will not be registered.'
+        });
+    }
+
     logger.emit({
         severityText: 'INFO',
         body: 'Successfully reloaded application (/) commands.'