feat: add admin /logs command to view bot log lines

BigMichi1 · BigMichi1 · commit 6da1ccf58dc6 · 2026-05-24T08:58:51.000+02:00
Signed-off-by: Michael Cramer &lt;michael@bigmichi1.de&gt;
diff --git a/src/bot/bot.ts b/src/bot/bot.ts
@@ -18,6 +18,7 @@ import { buildCodesPage } from './commands/codes';
 import * as autoredeemCommand from './commands/autoredeem';
 import * as helpCommand from './commands/help';
 import * as inventoryCommand from './commands/inventory';
+import * as logsCommand from './commands/logs';
 import * as makepublicCommand from './commands/makepublic';
 import * as notificationsCommand from './commands/notifications';
 import * as openCommand from './commands/open';
@@ -61,6 +62,7 @@ const commands = [
   deleteaccountCommand,
   helpCommand,
   inventoryCommand,
+  logsCommand,
   makepublicCommand,
   notificationsCommand,
   openCommand,
diff --git a/src/bot/commands/help.ts b/src/bot/commands/help.ts
@@ -76,6 +76,11 @@ export async function execute(interaction: ChatInputCommandInteraction) {
           value: '`/backfill [channel:<channel>]`\nRecover missed codes from message history (admin only).',
           inline: false,
         },
+        {
+          name: '📋 Logs',
+          value: '`/logs [lines:<n>]`\nShow the last N lines of the bot log (admin only, default 20, max 100).',
+          inline: false,
+        },
         {
           name: '🗑️ Delete Account',
           value:
diff --git a/src/bot/commands/logs.test.ts b/src/bot/commands/logs.test.ts
@@ -0,0 +1,231 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test';
+import { MessageFlags } from 'discord.js';
+import fs from 'fs';
+import { execute } from './logs';
+
+// ---------------------------------------------------------------------------
+// Interaction mock helpers
+// ---------------------------------------------------------------------------
+
+function makeInteraction(opts: { hasPermission?: boolean; lines?: number | null } = {}) {
+  const { hasPermission = true, lines = null } = opts;
+
+  const editReplySpy = spyOn({ editReply: async (_: unknown) => {} }, 'editReply');
+  const replySpy = spyOn({ reply: async (_: unknown) => {} }, 'reply');
+
+  const interaction = {
+    user: { id: 'admin-1', tag: 'admin#0001' },
+    deferred: false,
+    replied: false,
+    memberPermissions: hasPermission ? { has: () => true } : null,
+    deferReply: async () => {
+      (interaction as any).deferred = true;
+    },
+    editReply: editReplySpy,
+    reply: replySpy,
+    options: {
+      getInteger: (name: string) => (name === 'lines' ? lines : null),
+    },
+  } as any;
+
+  return { interaction, editReplySpy, replySpy };
+}
+
+// Sample log lines used across multiple tests
+const SAMPLE_LINES = Array.from(
+  { length: 50 },
+  (_, i) => `2026-05-24 12:00:${String(i).padStart(2, '0')} [INFO]: Log message ${i}`
+);
+const SAMPLE_CONTENT = SAMPLE_LINES.join('\n');
+
+// ---------------------------------------------------------------------------
+// Permission denied
+// ---------------------------------------------------------------------------
+
+describe('/logs – permission denied', () => {
+  test('replies ephemerally with "Permission Denied" when user lacks ManageMessages', async () => {
+    const { interaction, replySpy } = makeInteraction({ hasPermission: false });
+
+    await execute(interaction);
+
+    expect(replySpy).toHaveBeenCalledTimes(1);
+    const reply = replySpy.mock.calls[0]![0] as any;
+    expect(reply.embeds[0].data.title).toContain('Permission Denied');
+    expect(reply.flags).toBe(MessageFlags.Ephemeral);
+    expect(interaction.deferred).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Log file missing
+// ---------------------------------------------------------------------------
+
+describe('/logs – log file missing', () => {
+  let existsSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    existsSpy = spyOn(fs, 'existsSync').mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    existsSpy.mockRestore();
+  });
+
+  test('defers reply and shows "No log entries found" when combined.log does not exist', async () => {
+    const { interaction, editReplySpy } = makeInteraction();
+
+    await execute(interaction);
+
+    expect(interaction.deferred).toBe(true);
+    expect(editReplySpy).toHaveBeenCalledTimes(1);
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.description).toContain('No log entries found');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Reading log lines
+// ---------------------------------------------------------------------------
+
+describe('/logs – reading log lines', () => {
+  let existsSpy: ReturnType<typeof spyOn>;
+  let readSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    existsSpy = spyOn(fs, 'existsSync').mockReturnValue(true);
+    readSpy = spyOn(fs, 'readFileSync').mockReturnValue(SAMPLE_CONTENT);
+  });
+
+  afterEach(() => {
+    existsSpy.mockRestore();
+    readSpy.mockRestore();
+  });
+
+  test('defers reply', async () => {
+    const { interaction } = makeInteraction({ lines: 5 });
+
+    await execute(interaction);
+
+    expect(interaction.deferred).toBe(true);
+  });
+
+  test('defaults to 20 lines when no lines param is provided', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: null });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.title).toContain('last 20 lines');
+    const lastTwenty = SAMPLE_LINES.slice(-20);
+    expect(embed.description).toContain(lastTwenty[0]);
+    expect(embed.description).toContain(lastTwenty[19]);
+  });
+
+  test('respects custom lines parameter', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: 5 });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.title).toContain('last 5 lines');
+    const lastFive = SAMPLE_LINES.slice(-5);
+    for (const line of lastFive) {
+      expect(embed.description).toContain(line);
+    }
+    // Lines outside the requested range must not appear
+    expect(embed.description).not.toContain(SAMPLE_LINES[0]);
+  });
+
+  test('wraps output in a code block', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: 3 });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.description).toMatch(/^```\n/);
+    expect(embed.description).toMatch(/\n```$/);
+  });
+
+  test('title includes the actual number of lines returned', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: 10 });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.title).toContain('10 lines');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Truncation
+// ---------------------------------------------------------------------------
+
+describe('/logs – truncation', () => {
+  let existsSpy: ReturnType<typeof spyOn>;
+  let readSpy: ReturnType<typeof spyOn>;
+
+  // Build a log whose content far exceeds the 4096-char embed limit
+  const bigLine = 'X'.repeat(80);
+  const bigLines = Array.from({ length: 100 }, (_, i) => `${bigLine} line-${i}`);
+  const bigContent = bigLines.join('\n');
+
+  beforeEach(() => {
+    existsSpy = spyOn(fs, 'existsSync').mockReturnValue(true);
+    readSpy = spyOn(fs, 'readFileSync').mockReturnValue(bigContent);
+  });
+
+  afterEach(() => {
+    existsSpy.mockRestore();
+    readSpy.mockRestore();
+  });
+
+  test('embed description stays within the 4096-char limit', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: 100 });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.description.length).toBeLessThanOrEqual(4096);
+  });
+
+  test('title indicates truncation when content was trimmed', async () => {
+    const { interaction, editReplySpy } = makeInteraction({ lines: 100 });
+
+    await execute(interaction);
+
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.title).toContain('truncated');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('/logs – error handling', () => {
+  let existsSpy: ReturnType<typeof spyOn>;
+  let readSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    existsSpy = spyOn(fs, 'existsSync').mockReturnValue(true);
+    readSpy = spyOn(fs, 'readFileSync').mockImplementation(() => {
+      throw new Error('disk read error');
+    });
+  });
+
+  afterEach(() => {
+    existsSpy.mockRestore();
+    readSpy.mockRestore();
+  });
+
+  test('replies with error embed when log file cannot be read', async () => {
+    const { interaction, editReplySpy } = makeInteraction();
+
+    await execute(interaction);
+
+    expect(editReplySpy).toHaveBeenCalledTimes(1);
+    const embed = (editReplySpy.mock.calls[0]![0] as any).embeds[0].data;
+    expect(embed.title).toContain('Error');
+    expect(embed.description).toContain('Failed to read log file');
+  });
+});
diff --git a/src/bot/commands/logs.ts b/src/bot/commands/logs.ts
@@ -0,0 +1,98 @@
+import {
+  SlashCommandBuilder,
+  ChatInputCommandInteraction,
+  EmbedBuilder,
+  MessageFlags,
+  PermissionFlagsBits,
+} from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+import logger from '../utils/logger';
+
+const LOG_FILE = path.join(process.cwd(), 'logs', 'combined.log');
+const MAX_LINES = 100;
+const EMBED_DESCRIPTION_LIMIT = 4096;
+
+function readLastLines(filePath: string, n: number): string[] {
+  if (!fs.existsSync(filePath)) return [];
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n').filter((l) => l.trim() !== '');
+  return lines.slice(-n);
+}
+
+export const data = new SlashCommandBuilder()
+  .setName('logs')
+  .setDescription('Show the last N lines of the bot log (admin only)')
+  .setDefaultMemberPermissions(PermissionFlagsBits.ManageMessages)
+  .addIntegerOption((option) =>
+    option
+      .setName('lines')
+      .setDescription(`Number of log lines to show (1-${MAX_LINES}, default 20)`)
+      .setRequired(false)
+      .setMinValue(1)
+      .setMaxValue(MAX_LINES)
+  );
+
+export async function execute(interaction: ChatInputCommandInteraction) {
+  try {
+    if (!interaction.memberPermissions?.has(PermissionFlagsBits.ManageMessages)) {
+      const embed = new EmbedBuilder()
+        .setColor(0xff0000)
+        .setTitle('❌ Permission Denied')
+        .setDescription('You need the "Manage Messages" permission to view logs.');
+      await interaction.reply({ embeds: [embed], flags: MessageFlags.Ephemeral });
+      return;
+    }
+
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+    const n = interaction.options.getInteger('lines') ?? 20;
+    logger.info(`[LOGS CMD] ${interaction.user.tag} requested last ${n} log lines`);
+
+    const lines = readLastLines(LOG_FILE, n);
+
+    if (lines.length === 0) {
+      const embed = new EmbedBuilder()
+        .setColor(0xffaa00)
+        .setTitle('📋 Bot Logs')
+        .setDescription('No log entries found.');
+      await interaction.editReply({ embeds: [embed] });
+      return;
+    }
+
+    // Build the code block and truncate from the start if it exceeds Discord's limit
+    const codeBlockOverhead = '```\n'.length + '\n```'.length;
+    const maxContent = EMBED_DESCRIPTION_LIMIT - codeBlockOverhead;
+
+    let content = lines.join('\n');
+    let truncated = false;
+    if (content.length > maxContent) {
+      content = content.slice(content.length - maxContent);
+      // Trim to a clean line boundary
+      const firstNewline = content.indexOf('\n');
+      if (firstNewline !== -1) content = content.slice(firstNewline + 1);
+      truncated = true;
+    }
+
+    const description = `\`\`\`\n${content}\n\`\`\``;
+    const title = truncated
+      ? `📋 Bot Logs (last ${lines.length} lines — truncated)`
+      : `📋 Bot Logs (last ${lines.length} lines)`;
+
+    const embed = new EmbedBuilder().setColor(0x0099ff).setTitle(title).setDescription(description);
+
+    await interaction.editReply({ embeds: [embed] });
+  } catch (error) {
+    logger.error('[LOGS CMD] Error:', error);
+    const embed = new EmbedBuilder()
+      .setColor(0xff0000)
+      .setTitle('❌ Error')
+      .setDescription('Failed to read log file.');
+    if (interaction.deferred) {
+      await interaction.editReply({ embeds: [embed] });
+    } else {
+      await interaction.reply({ embeds: [embed], flags: MessageFlags.Ephemeral });
+    }
+  }
+}
