@mahesvara/discord-mcpserver 1.0.8 → 1.0.9

package/dist/tools/community.js

@@ -0,0 +1,259 @@
+import { GetWelcomeScreenSchema, EditWelcomeScreenSchema, GetOnboardingSchema, EditOnboardingSchema, } from "../schemas/index.js";
+import { getClient, formatResponse, } from "../services/discord.js";
+export function registerCommunityTools(server) {
+    // ============================================================================
+    // WELCOME SCREEN TOOLS
+    // ============================================================================
+    server.registerTool("discord_get_welcome_screen", {
+        title: "Get Welcome Screen",
+        description: `Get the welcome screen configuration for a server.
+
+Requires the server to have Community features enabled.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  Welcome screen settings including description and channels`,
+        inputSchema: GetWelcomeScreenSchema,
+        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 welcomeScreen = await guild.fetchWelcomeScreen();
+            const result = {
+                enabled: welcomeScreen.enabled,
+                description: welcomeScreen.description,
+                channels: welcomeScreen.welcomeChannels.map(ch => ({
+                    channelId: ch.channelId,
+                    description: ch.description,
+                    emoji: ch.emoji ? { id: ch.emoji.id, name: ch.emoji.name } : null,
+                })),
+            };
+            const text = formatResponse(result, params.response_format, (data) => `**Welcome Screen**\nEnabled: ${data.enabled}\nDescription: ${data.description || 'None'}\n\n**Channels:**\n${data.channels.map(ch => `- <#${ch.channelId}>: ${ch.description} ${ch.emoji?.name || ''}`).join('\n')}`);
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting welcome screen: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_edit_welcome_screen", {
+        title: "Edit Welcome Screen",
+        description: `Edit the welcome screen configuration for a server.
+
+Requires the server to have Community features enabled and bot must have MANAGE_GUILD permission.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - enabled (boolean, optional): Enable/disable the welcome screen
+  - description (string, optional): Server description (max 140 chars)
+  - welcome_channels (array, optional): Up to 5 channels to show (channel_id, description, emoji)
+
+Returns:
+  Updated welcome screen settings`,
+        inputSchema: EditWelcomeScreenSchema,
+        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 updateData = {};
+            if (params.enabled !== undefined)
+                updateData.enabled = params.enabled;
+            if (params.description !== undefined)
+                updateData.description = params.description;
+            if (params.welcome_channels !== undefined) {
+                updateData.welcomeChannels = params.welcome_channels.map(ch => ({
+                    channel: ch.channel_id,
+                    description: ch.description,
+                    emoji: ch.emoji_id ? { id: ch.emoji_id, name: ch.emoji_name } : ch.emoji_name ? { name: ch.emoji_name } : undefined,
+                }));
+            }
+            const welcomeScreen = await guild.editWelcomeScreen(updateData);
+            return {
+                content: [{ type: "text", text: `Welcome screen updated. Enabled: ${welcomeScreen.enabled}, Channels: ${welcomeScreen.welcomeChannels.size}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error editing welcome screen: ${error.message}` }],
+            };
+        }
+    });
+    // ============================================================================
+    // ONBOARDING TOOLS
+    // ============================================================================
+    server.registerTool("discord_get_onboarding", {
+        title: "Get Server Onboarding",
+        description: `Get the onboarding configuration for a server.
+
+Onboarding guides new members through a questionnaire to customize their experience.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  Onboarding settings including prompts, options, and default channels`,
+        inputSchema: GetOnboardingSchema,
+        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 onboarding = await guild.fetchOnboarding();
+            const result = {
+                enabled: onboarding.enabled,
+                mode: onboarding.mode,
+                defaultChannelIds: onboarding.defaultChannels.map(c => c.id),
+                prompts: onboarding.prompts.map(p => ({
+                    id: p.id,
+                    type: p.type,
+                    title: p.title,
+                    singleSelect: p.singleSelect,
+                    required: p.required,
+                    inOnboarding: p.inOnboarding,
+                    options: p.options.map(o => ({
+                        id: o.id,
+                        title: o.title,
+                        description: o.description,
+                        emoji: o.emoji ? { id: o.emoji.id, name: o.emoji.name } : null,
+                        roleIds: o.roles.map(r => r.id),
+                        channelIds: o.channels.map(c => c.id),
+                    })),
+                })),
+            };
+            const text = formatResponse(result, params.response_format, (data) => {
+                let output = `**Server Onboarding**\nEnabled: ${data.enabled}\nMode: ${data.mode}\nDefault Channels: ${data.defaultChannelIds.length}\n\n**Prompts:**\n`;
+                data.prompts.forEach((p, i) => {
+                    output += `\n${i + 1}. **${p.title}** (${p.type})\n`;
+                    output += `   Required: ${p.required}, Single Select: ${p.singleSelect}\n`;
+                    output += `   Options: ${p.options.map((o) => o.title).join(', ')}\n`;
+                });
+                return output;
+            });
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting onboarding: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_edit_onboarding", {
+        title: "Edit Server Onboarding",
+        description: `Edit the onboarding configuration for a server.
+
+Configure prompts/questions that new members answer to customize their server experience.
+Each prompt can assign roles or show channels based on member selections.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - prompts (array, optional): Onboarding prompts with options
+  - default_channel_ids (array, optional): Channels shown to all new members
+  - enabled (boolean, optional): Enable/disable onboarding
+  - mode ('onboarding_default' | 'onboarding_advanced', optional): Onboarding mode
+
+Returns:
+  Updated onboarding configuration`,
+        inputSchema: EditOnboardingSchema,
+        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 promptTypeMap = { multiple_choice: 0, dropdown: 1 };
+            const modeMap = { onboarding_default: 0, onboarding_advanced: 1 };
+            const updateData = {};
+            if (params.enabled !== undefined)
+                updateData.enabled = params.enabled;
+            if (params.default_channel_ids !== undefined)
+                updateData.defaultChannelIds = params.default_channel_ids;
+            if (params.mode !== undefined)
+                updateData.mode = modeMap[params.mode];
+            if (params.prompts !== undefined) {
+                updateData.prompts = params.prompts.map(p => ({
+                    id: p.id,
+                    type: promptTypeMap[p.type],
+                    title: p.title,
+                    singleSelect: p.single_select,
+                    required: p.required,
+                    inOnboarding: p.in_onboarding,
+                    options: p.options.map(o => ({
+                        id: o.id,
+                        title: o.title,
+                        description: o.description,
+                        emoji: o.emoji_id ? { id: o.emoji_id, name: o.emoji_name } : o.emoji_name ? { name: o.emoji_name } : undefined,
+                        roleIds: o.role_ids,
+                        channelIds: o.channel_ids,
+                    })),
+                }));
+            }
+            const onboarding = await guild.editOnboarding(updateData);
+            return {
+                content: [{ type: "text", text: `Onboarding updated. Enabled: ${onboarding.enabled}, Prompts: ${onboarding.prompts.size}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error editing onboarding: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/emoji.d.ts

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

package/dist/tools/emoji.js

@@ -0,0 +1,247 @@
+import { ListEmojisSchema, CreateEmojiSchema, DeleteEmojiSchema, ListStickersSchema, DeleteStickerSchema, } from "../schemas/index.js";
+import { getClient, formatResponse, truncateIfNeeded, } from "../services/discord.js";
+export function registerEmojiTools(server) {
+    // ============================================================================
+    // EMOJI TOOLS
+    // ============================================================================
+    server.registerTool("discord_list_emojis", {
+        title: "List Emojis",
+        description: `List all custom emojis in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('json' | 'markdown'): Output format
+
+Returns:
+  List of emojis with name, ID, and whether animated`,
+        inputSchema: ListEmojisSchema,
+        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 emojis = guild.emojis.cache.map(emoji => ({
+                id: emoji.id,
+                name: emoji.name,
+                animated: emoji.animated,
+                available: emoji.available,
+                managed: emoji.managed,
+                requireColons: emoji.requiresColons,
+                roles: emoji.roles.cache.map(r => r.name),
+                url: emoji.url,
+            }));
+            const result = formatResponse(emojis, params.response_format, (items) => items.map(e => `${e.animated ? '(animated) ' : ''}**${e.name}** - ID: ${e.id}`).join('\n'));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(result) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing emojis: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_create_emoji", {
+        title: "Create Emoji",
+        description: `Create a custom emoji in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - name (string): Emoji name (2-32 chars, alphanumeric and underscores)
+  - image_url (string): URL of image (PNG, JPG, GIF under 256KB)
+  - roles (string[], optional): Role IDs that can use this emoji
+
+Returns:
+  Created emoji details`,
+        inputSchema: CreateEmojiSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            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 emoji = await guild.emojis.create({
+                attachment: params.image_url,
+                name: params.name,
+                roles: params.roles,
+            });
+            return {
+                content: [{ type: "text", text: `Created emoji :${emoji.name}: (ID: ${emoji.id})` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error creating emoji: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_delete_emoji", {
+        title: "Delete Emoji",
+        description: `Delete a custom emoji from a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - emoji_id (string): Discord emoji ID
+
+Returns:
+  Confirmation of deletion`,
+        inputSchema: DeleteEmojiSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            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 emoji = guild.emojis.cache.get(params.emoji_id);
+            if (!emoji) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Emoji not found: ${params.emoji_id}` }],
+                };
+            }
+            const name = emoji.name;
+            await emoji.delete();
+            return {
+                content: [{ type: "text", text: `Deleted emoji :${name}:` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error deleting emoji: ${error.message}` }],
+            };
+        }
+    });
+    // ============================================================================
+    // STICKER TOOLS
+    // ============================================================================
+    server.registerTool("discord_list_stickers", {
+        title: "List Stickers",
+        description: `List all custom stickers in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('json' | 'markdown'): Output format
+
+Returns:
+  List of stickers with name, description, and format`,
+        inputSchema: ListStickersSchema,
+        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 stickers = await guild.stickers.fetch();
+            const stickerList = stickers.map(sticker => ({
+                id: sticker.id,
+                name: sticker.name,
+                description: sticker.description,
+                tags: sticker.tags,
+                format: sticker.format,
+                available: sticker.available,
+                url: sticker.url,
+            }));
+            const result = formatResponse(stickerList, params.response_format, (items) => items.map(s => `**${s.name}** (ID: ${s.id})\nDescription: ${s.description || 'None'}\nTags: ${s.tags || 'None'}`).join('\n\n'));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(result) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing stickers: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_delete_sticker", {
+        title: "Delete Sticker",
+        description: `Delete a custom sticker from a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - sticker_id (string): Discord sticker ID
+
+Returns:
+  Confirmation of deletion`,
+        inputSchema: DeleteStickerSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            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 sticker = await guild.stickers.fetch(params.sticker_id).catch(() => null);
+            if (!sticker) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Sticker not found: ${params.sticker_id}` }],
+                };
+            }
+            const name = sticker.name;
+            await sticker.delete();
+            return {
+                content: [{ type: "text", text: `Deleted sticker: ${name}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error deleting sticker: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/event.d.ts

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

package/dist/tools/event.js

@@ -0,0 +1,170 @@
+import { ListEventsSchema, CreateEventSchema, DeleteEventSchema, } from "../schemas/index.js";
+import { getClient, formatResponse, truncateIfNeeded, } from "../services/discord.js";
+import { GuildScheduledEventEntityType, GuildScheduledEventPrivacyLevel } from "discord.js";
+export function registerEventTools(server) {
+    server.registerTool("discord_list_events", {
+        title: "List Scheduled Events",
+        description: `List all scheduled events in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - response_format ('json' | 'markdown'): Output format
+
+Returns:
+  List of events with name, time, location, and status`,
+        inputSchema: ListEventsSchema,
+        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 events = await guild.scheduledEvents.fetch();
+            const eventList = events.map(event => ({
+                id: event.id,
+                name: event.name,
+                description: event.description,
+                status: event.status,
+                entityType: event.entityType,
+                channel: event.channel?.name,
+                channelId: event.channelId,
+                location: event.entityMetadata?.location,
+                scheduledStartTime: event.scheduledStartAt?.toISOString(),
+                scheduledEndTime: event.scheduledEndAt?.toISOString(),
+                userCount: event.userCount,
+                creator: event.creator?.username,
+            }));
+            const result = formatResponse(eventList, params.response_format, (items) => items.map(e => `**${e.name}** (ID: ${e.id})\nStatus: ${e.status}\nStart: ${e.scheduledStartTime}\nLocation: ${e.location || e.channel || 'TBD'}\nAttending: ${e.userCount || 0}`).join('\n\n'));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(result) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing events: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_create_event", {
+        title: "Create Scheduled Event",
+        description: `Create a scheduled event in a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - name (string): Event name
+  - description (string, optional): Event description
+  - scheduled_start_time (string): ISO8601 timestamp for start
+  - scheduled_end_time (string, optional): ISO8601 timestamp for end
+  - entity_type ('stage' | 'voice' | 'external'): Type of event
+  - channel_id (string, optional): Channel ID for stage/voice events
+  - location (string, optional): Location for external events
+
+Returns:
+  Created event details`,
+        inputSchema: CreateEventSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            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 entityTypeMap = {
+                stage: GuildScheduledEventEntityType.StageInstance,
+                voice: GuildScheduledEventEntityType.Voice,
+                external: GuildScheduledEventEntityType.External,
+            };
+            const createOptions = {
+                name: params.name,
+                scheduledStartTime: new Date(params.scheduled_start_time),
+                privacyLevel: GuildScheduledEventPrivacyLevel.GuildOnly,
+                entityType: entityTypeMap[params.entity_type],
+            };
+            if (params.description)
+                createOptions.description = params.description;
+            if (params.scheduled_end_time)
+                createOptions.scheduledEndTime = new Date(params.scheduled_end_time);
+            if (params.channel_id)
+                createOptions.channel = params.channel_id;
+            if (params.entity_metadata?.location)
+                createOptions.entityMetadata = { location: params.entity_metadata.location };
+            const event = await guild.scheduledEvents.create(createOptions);
+            return {
+                content: [{ type: "text", text: `Created event "${event.name}" (ID: ${event.id})\nStart: ${event.scheduledStartAt?.toISOString()}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error creating event: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_delete_event", {
+        title: "Delete Scheduled Event",
+        description: `Delete a scheduled event from a server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - event_id (string): Discord scheduled event ID
+
+Returns:
+  Confirmation of deletion`,
+        inputSchema: DeleteEventSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            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 event = await guild.scheduledEvents.fetch(params.event_id).catch(() => null);
+            if (!event) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Event not found: ${params.event_id}` }],
+                };
+            }
+            const name = event.name;
+            await event.delete();
+            return {
+                content: [{ type: "text", text: `Deleted event: ${name}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error deleting event: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/guild.d.ts

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