@mahesvara/discord-mcpserver 1.0.7 → 1.0.9

package/dist/tools/guild.js

@@ -0,0 +1,198 @@
+import { ListGuildsSchema, GetGuildSchema, LeaveGuildSchema, EditGuildSchema, } from "../schemas/index.js";
+import { getClient, formatGuild, guildToMarkdown, formatResponse, truncateIfNeeded, } from "../services/discord.js";
+import { GuildDefaultMessageNotifications, GuildVerificationLevel } from "discord.js";
+export function registerGuildTools(server) {
+    server.registerTool("discord_list_guilds", {
+        title: "List Discord Servers",
+        description: `List all Discord servers (guilds) the bot has access to.
+
+Returns server names, IDs, member counts, and owner information.
+
+Args:
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  List of guilds with id, name, memberCount, icon, ownerId`,
+        inputSchema: ListGuildsSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guilds = client.guilds.cache.map(formatGuild);
+            const text = formatResponse(guilds, params.response_format, (items) => items.map(guildToMarkdown).join("\n\n"));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(text) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing guilds: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_get_guild", {
+        title: "Get Discord Server Info",
+        description: `Get detailed information about a specific Discord server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  Server details including name, member count, owner, and icon`,
+        inputSchema: GetGuildSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}. Use discord_list_guilds to see available servers.` }],
+                };
+            }
+            const formatted = formatGuild(guild);
+            const text = formatResponse(formatted, params.response_format, guildToMarkdown);
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting guild: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_leave_guild", {
+        title: "Leave Discord Server",
+        description: `Leave a Discord server (guild). The bot will no longer have access to this server.
+
+WARNING: This is a destructive action. The bot will need to be re-invited to rejoin.
+
+Args:
+  - guild_id (string): Discord server/guild ID to leave
+  - confirm (boolean): Must be set to true to confirm leaving
+
+Returns:
+  Confirmation message with server details`,
+        inputSchema: LeaveGuildSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            if (!params.confirm) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "You must set 'confirm: true' to leave a server. This action cannot be undone - the bot will need to be re-invited to rejoin." }],
+                };
+            }
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}. Use discord_list_guilds to see available servers.` }],
+                };
+            }
+            const guildName = guild.name;
+            const memberCount = guild.memberCount;
+            const ownerId = guild.ownerId;
+            await guild.leave();
+            return {
+                content: [{ type: "text", text: `Successfully left server "${guildName}" (ID: ${params.guild_id}, Members: ${memberCount}, Owner: ${ownerId}). The bot will need to be re-invited to rejoin.` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error leaving guild: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_edit_guild", {
+        title: "Edit Discord Server",
+        description: `Edit server settings like name, verification level, and system channel.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - name (string, optional): New server name
+  - verification_level (string, optional): 'none', 'low', 'medium', 'high', 'very_high'
+  - default_notifications (string, optional): 'all_messages' or 'only_mentions'
+  - afk_channel_id (string, optional): AFK voice channel ID
+  - afk_timeout (number, optional): AFK timeout in seconds
+  - system_channel_id (string, optional): System messages channel
+  - system_channel_flags (object, optional): System channel behavior
+
+Returns:
+  Updated server details`,
+        inputSchema: EditGuildSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const verificationMap = {
+                none: GuildVerificationLevel.None,
+                low: GuildVerificationLevel.Low,
+                medium: GuildVerificationLevel.Medium,
+                high: GuildVerificationLevel.High,
+                very_high: GuildVerificationLevel.VeryHigh,
+            };
+            const notificationMap = {
+                all_messages: GuildDefaultMessageNotifications.AllMessages,
+                only_mentions: GuildDefaultMessageNotifications.OnlyMentions,
+            };
+            const updateData = {};
+            if (params.name)
+                updateData.name = params.name;
+            if (params.verification_level)
+                updateData.verificationLevel = verificationMap[params.verification_level];
+            if (params.default_notifications)
+                updateData.defaultMessageNotifications = notificationMap[params.default_notifications];
+            if (params.afk_channel_id)
+                updateData.afkChannel = params.afk_channel_id;
+            if (params.afk_timeout)
+                updateData.afkTimeout = params.afk_timeout;
+            if (params.system_channel_id)
+                updateData.systemChannel = params.system_channel_id;
+            const updated = await guild.edit(updateData);
+            return {
+                content: [{ type: "text", text: `Updated server "${updated.name}"` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error editing guild: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAllTools(server: McpServer): void;

package/dist/tools/index.js

@@ -0,0 +1,24 @@
+import { registerGuildTools } from "./guild.js";
+import { registerChannelTools } from "./channel.js";
+import { registerMessageTools } from "./message.js";
+import { registerMemberTools } from "./member.js";
+import { registerRoleTools } from "./role.js";
+import { registerModerationTools } from "./moderation.js";
+import { registerEmojiTools } from "./emoji.js";
+import { registerWebhookTools } from "./webhook.js";
+import { registerInviteTools } from "./invite.js";
+import { registerEventTools } from "./event.js";
+import { registerCommunityTools } from "./community.js";
+export function registerAllTools(server) {
+    registerGuildTools(server);
+    registerChannelTools(server);
+    registerMessageTools(server);
+    registerMemberTools(server);
+    registerRoleTools(server);
+    registerModerationTools(server);
+    registerEmojiTools(server);
+    registerWebhookTools(server);
+    registerInviteTools(server);
+    registerEventTools(server);
+    registerCommunityTools(server);
+}

package/dist/tools/invite.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerInviteTools(server: McpServer): void;

package/dist/tools/invite.js

@@ -0,0 +1,143 @@
+import { ListInvitesSchema, CreateInviteSchema, DeleteInviteSchema, } from "../schemas/index.js";
+import { getClient, formatResponse, truncateIfNeeded, } from "../services/discord.js";
+export function registerInviteTools(server) {
+    server.registerTool("discord_list_invites", {
+        title: "List Invites",
+        description: `List all active invites in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('json' | 'markdown'): Output format
+
+Returns:
+  List of invites with code, uses, max uses, expiration`,
+        inputSchema: ListInvitesSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const invites = await guild.invites.fetch();
+            const inviteList = invites.map(invite => ({
+                code: invite.code,
+                url: invite.url,
+                channel: invite.channel?.name || 'Unknown',
+                channelId: invite.channel?.id,
+                inviter: invite.inviter?.username || 'Unknown',
+                uses: invite.uses,
+                maxUses: invite.maxUses || 'Unlimited',
+                maxAge: invite.maxAge === 0 ? 'Never' : `${invite.maxAge} seconds`,
+                temporary: invite.temporary,
+                createdAt: invite.createdAt?.toISOString(),
+                expiresAt: invite.expiresAt?.toISOString() || 'Never',
+            }));
+            const result = formatResponse(inviteList, params.response_format, (items) => items.map(i => `**${i.code}** - #${i.channel}\nUses: ${i.uses}/${i.maxUses} | Expires: ${i.expiresAt}\nCreated by: ${i.inviter}`).join('\n\n'));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(result) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing invites: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_create_invite", {
+        title: "Create Invite",
+        description: `Create an invite link for a channel.
+
+Args:
+  - channel_id (string): Discord channel ID
+  - max_age (number): Duration in seconds (0 = never expires, max 604800 = 7 days)
+  - max_uses (number): Max uses (0 = unlimited)
+  - temporary (boolean): Kick members when they disconnect if not assigned a role
+  - unique (boolean): Create new unique invite vs reuse existing
+
+Returns:
+  Created invite URL`,
+        inputSchema: CreateInviteSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('createInvite' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found or cannot create invites: ${params.channel_id}` }],
+                };
+            }
+            const textChannel = channel;
+            const invite = await textChannel.createInvite({
+                maxAge: params.max_age,
+                maxUses: params.max_uses,
+                temporary: params.temporary,
+                unique: params.unique,
+            });
+            return {
+                content: [{ type: "text", text: `Created invite: ${invite.url}\nCode: ${invite.code}\nMax uses: ${invite.maxUses || 'Unlimited'}\nExpires: ${invite.expiresAt?.toISOString() || 'Never'}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error creating invite: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_delete_invite", {
+        title: "Delete Invite",
+        description: `Delete an invite by its code.
+
+Args:
+  - invite_code (string): The invite code to delete
+
+Returns:
+  Confirmation of deletion`,
+        inputSchema: DeleteInviteSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const invite = await client.fetchInvite(params.invite_code).catch(() => null);
+            if (!invite) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Invite not found: ${params.invite_code}` }],
+                };
+            }
+            await invite.delete();
+            return {
+                content: [{ type: "text", text: `Deleted invite: ${params.invite_code}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error deleting invite: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/member.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerMemberTools(server: McpServer): void;

package/dist/tools/member.js

@@ -0,0 +1,200 @@
+import { ListMembersSchema, GetMemberSchema, MoveMemberSchema, SetNicknameSchema, } from "../schemas/index.js";
+import { getClient, formatMember, memberToMarkdown, formatResponse, truncateIfNeeded, } from "../services/discord.js";
+export function registerMemberTools(server) {
+    server.registerTool("discord_list_members", {
+        title: "List Discord Members",
+        description: `List members in a Discord server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - limit (number): Maximum number of members (1-100, default: 20)
+  - after (string, optional): Get members after this user ID (for pagination)
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  List of members with username, nickname, roles, join date`,
+        inputSchema: ListMembersSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const options = { limit: params.limit };
+            if (params.after)
+                options.after = params.after;
+            // The fetch API returns a Collection when given limit, use 'as unknown as' to handle the union type
+            const membersResult = (await guild.members.fetch(options));
+            // Convert Collection to array
+            const membersArray = Array.from(membersResult.values());
+            const formatted = membersArray.map((m) => formatMember(m));
+            const text = formatResponse(formatted, params.response_format, (items) => items.map(memberToMarkdown).join("\n\n"));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(text) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing members: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_get_member", {
+        title: "Get Discord Member",
+        description: `Get detailed information about a specific member.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - user_id (string): Discord user ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  Member details including username, nickname, roles, join date`,
+        inputSchema: GetMemberSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const member = await guild.members.fetch(params.user_id);
+            const formatted = formatMember(member);
+            const text = formatResponse(formatted, params.response_format, memberToMarkdown);
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting member: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_move_member", {
+        title: "Move Member to Voice Channel",
+        description: `Move a member to a different voice channel or disconnect them from voice.
+
+The member must currently be connected to a voice channel to be moved.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - user_id (string): Discord user ID to move
+  - channel_id (string | null): Target voice channel ID, or null to disconnect
+
+Returns:
+  Confirmation of move or disconnect`,
+        inputSchema: MoveMemberSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const member = await guild.members.fetch(params.user_id);
+            if (!member.voice.channel) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `User ${params.user_id} is not connected to a voice channel` }],
+                };
+            }
+            const previousChannel = member.voice.channel.name;
+            if (params.channel_id === null) {
+                await member.voice.disconnect();
+                return {
+                    content: [{ type: "text", text: `Disconnected user ${member.user.tag} from voice channel "${previousChannel}"` }],
+                };
+            }
+            const targetChannel = guild.channels.cache.get(params.channel_id);
+            if (!targetChannel || !targetChannel.isVoiceBased()) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Voice channel not found: ${params.channel_id}` }],
+                };
+            }
+            await member.voice.setChannel(targetChannel);
+            return {
+                content: [{ type: "text", text: `Moved user ${member.user.tag} from "${previousChannel}" to "${targetChannel.name}"` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error moving member: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_set_nickname", {
+        title: "Set Member Nickname",
+        description: `Set or clear a member's nickname.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - user_id (string): Discord user ID
+  - nickname (string, optional): New nickname (empty/null to reset)
+
+Returns:
+  Confirmation of nickname change`,
+        inputSchema: SetNicknameSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const guild = client.guilds.cache.get(params.guild_id);
+            if (!guild) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Guild not found: ${params.guild_id}` }],
+                };
+            }
+            const member = await guild.members.fetch(params.user_id);
+            await member.setNickname(params.nickname ?? null);
+            const action = params.nickname ? `set to "${params.nickname}"` : "reset";
+            return {
+                content: [{ type: "text", text: `Nickname ${action} for user ${params.user_id}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error setting nickname: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/message.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerMessageTools(server: McpServer): void;