bun install

# Discord API Credentials (Required)
DISCORD_APPLICATION_ID=your_application_id
DISCORD_API_TOKEN=your_api_token

# Channel Restrictions (Optional)
# Comma-separated list of Discord channel IDs to restrict the bot to.
# If not set, the bot operates in all channels.
# These channels cannot be removed via the leaveChannel action.
CHANNEL_IDS=123456789012345678,987654321098765432

# Listen-only channels (Optional)
# Comma-separated list of channel IDs where the bot will only listen (not respond).
DISCORD_LISTEN_CHANNEL_IDS=123456789012345678

# Voice Channel (Optional)
# ID of the voice channel the bot should auto-join when scanning a guild.
# If not set, the bot selects based on member activity.
DISCORD_VOICE_CHANNEL_ID=123456789012345678

# Behavior Settings (Optional)
# If true, ignore messages from other bots (default: true)
DISCORD_SHOULD_IGNORE_BOT_MESSAGES=true

# If true, ignore direct messages by default (default: true).
# DMs can still be allowed explicitly via DISCORD_ALLOW_FROM / pairing allowlist.
DISCORD_SHOULD_IGNORE_DIRECT_MESSAGES=true

# If true, only respond when explicitly @mentioned (default: true)
DISCORD_SHOULD_RESPOND_ONLY_TO_MENTIONS=true

# Testing (Optional)
DISCORD_TEST_CHANNEL_ID=123456789012345678

{
  "settings": {
    "discord": {
      "shouldIgnoreBotMessages": true,
      "shouldIgnoreDirectMessages": true,
      "shouldRespondOnlyToMentions": true,
      "allowedChannelIds": ["123456789012345678"]
    }
  }
}

{
  "plugins": ["@elizaos/plugin-discord"]
}

import { PermissionFlagsBits } from "discord.js";

// Simple command (works everywhere)
const helpCommand = {
  name: "help",
  description: "Show help information",
};

// Guild-only command
const serverInfoCommand = {
  name: "serverinfo",
  description: "Show server information",
  guildOnly: true,
};

// Requires Discord permission
const configCommand = {
  name: "config",
  description: "Configure bot settings",
  requiredPermissions: PermissionFlagsBits.ManageGuild,
};

// Bypasses channel whitelist
const utilityCommand = {
  name: "export",
  description: "Export data",
  bypassChannelWhitelist: true,
};

// Advanced: custom validation
const adminCommand = {
  name: "admin",
  description: "Admin-only command",
  validator: async (interaction, runtime) => {
    const adminIds = runtime.getSetting("ADMIN_USER_IDS")?.split(",") ?? [];
    return adminIds.includes(interaction.user.id);
  },
};

// Register commands
await runtime.emitEvent(["DISCORD_REGISTER_COMMANDS"], {
  commands: [
    helpCommand,
    serverInfoCommand,
    configCommand,
    utilityCommand,
    adminCommand,
  ],
});

// Register custom slash commands
await runtime.emitEvent(["DISCORD_REGISTER_COMMANDS"], {
  commands: [
    {
      name: "mycommand",
      description: "My custom command",
      options: [
        {
          name: "input",
          description: "User input",
          type: 3, // STRING type
          required: true,
        },
      ],
    },
    {
      name: "serverinfo",
      description: "Get server information",
      guildOnly: true, // Only works in guilds, not DMs
    },
  ],
});

// Listen for slash command events to handle the interaction
runtime.registerEvent({
  name: "DISCORD_SLASH_COMMAND",
  handler: async (payload) => {
    const { interaction, client, commands } = payload;

    if (interaction.commandName === "mycommand") {
      const input = interaction.options.getString("input");
      await interaction.reply(`You said: ${input}`);
    }
  },
});

// Check if a channel is listen-only
const listenChannels = runtime.getSetting("DISCORD_LISTEN_CHANNEL_IDS");
const listenChannelIds = listenChannels?.split(",").map((s) => s.trim()) || [];

runtime.registerEvent({
  name: "DISCORD_MESSAGE_RECEIVED",
  handler: async (payload) => {
    const { message } = payload;
    const channelId = message.content.channelId;

    if (listenChannelIds.includes(channelId)) {
      // This is a listen-only channel - process without responding
      await processMessageSilently(message);
    }
  },
});

// Listen for modal submissions
runtime.registerEvent({
  name: "DISCORD_MODAL_SUBMIT",
  handler: async (payload) => {
    const { interaction } = payload;
    const fieldValue = interaction.fields.getTextInputValue("myField");
    await interaction.reply(`Received: ${fieldValue}`);
  },
});

interface ChannelPermissionsChangedPayload {
  runtime: IAgentRuntime;
  guild: { id: string; name: string };
  channel: { id: string; name: string };
  target: { type: "role" | "user"; id: string; name: string };
  action: "CREATE" | "UPDATE" | "DELETE";
  changes: Array<{
    permission: string; // e.g., 'ManageMessages', 'Administrator'
    oldState: "ALLOW" | "DENY" | "NEUTRAL";
    newState: "ALLOW" | "DENY" | "NEUTRAL";
  }>;
  audit: {
    executorId: string;
    executorTag: string;
    reason: string | null;
  } | null;
}

interface RolePermissionsChangedPayload {
  runtime: IAgentRuntime;
  guild: { id: string; name: string };
  role: { id: string; name: string };
  changes: PermissionDiff[];
  audit: AuditInfo | null;
}

interface MemberRolesChangedPayload {
  runtime: IAgentRuntime;
  guild: { id: string; name: string };
  member: { id: string; tag: string };
  added: Array<{ id: string; name: string; permissions: string[] }>;
  removed: Array<{ id: string; name: string; permissions: string[] }>;
  audit: AuditInfo | null;
}

interface RoleLifecyclePayload {
  runtime: IAgentRuntime;
  guild: { id: string; name: string };
  role: { id: string; name: string; permissions: string[] };
  audit: AuditInfo | null;
}

import { DiscordEventTypes } from "@elizaos/plugin-discord";

// Alert on dangerous permission grants
runtime.registerEvent({
  name: DiscordEventTypes.CHANNEL_PERMISSIONS_CHANGED,
  handler: async (payload) => {
    const dangerousPerms = ["Administrator", "ManageGuild", "ManageRoles"];

    for (const change of payload.changes) {
      if (
        dangerousPerms.includes(change.permission) &&
        change.newState === "ALLOW"
      ) {
        console.warn(`⚠️ Dangerous permission granted!`, {
          channel: payload.channel.name,
          target: payload.target.name,
          permission: change.permission,
          grantedBy: payload.audit?.executorTag || "Unknown",
        });
      }
    }
  },
});

// Track role escalations
runtime.registerEvent({
  name: DiscordEventTypes.MEMBER_ROLES_CHANGED,
  handler: async (payload) => {
    const adminRoles = payload.added.filter((r) =>
      r.permissions.includes("Administrator"),
    );

    if (adminRoles.length > 0) {
      console.warn(`⚠️ Admin role granted to ${payload.member.tag}`, {
        roles: adminRoles.map((r) => r.name),
        grantedBy: payload.audit?.executorTag || "Unknown",
      });
    }
  },
});

// Log all role creations
runtime.registerEvent({
  name: DiscordEventTypes.ROLE_CREATED,
  handler: async (payload) => {
    console.log(`New role created: ${payload.role.name}`, {
      permissions: payload.role.permissions,
      createdBy: payload.audit?.executorTag || "Unknown",
    });
  },
});

runtime.registerEvent({
  name: DiscordEventTypes.MEMBER_ROLES_CHANGED,
  handler: async (payload) => {
    const botId = runtime.getSetting("DISCORD_APPLICATION_ID");

    if (payload.member.id === botId && payload.removed.length > 0) {
      console.error(`🚨 Bot roles removed!`, {
        removed: payload.removed.map((r) => r.name),
        by: payload.audit?.executorTag || "Unknown",
      });
      // Could trigger alerts, notifications, etc.
    }
  },
});

bun run test