@mahesvara/discord-mcpserver 1.0.7 → 1.0.9

package/dist/tools/channel.js

@@ -0,0 +1,510 @@
+import { ListChannelsSchema, GetChannelSchema, CreateChannelSchema, DeleteChannelSchema, EditChannelSchema, SetChannelPermissionsSchema, RemoveChannelPermissionsSchema, GetChannelPermissionsSchema, SyncChannelPermissionsSchema, } from "../schemas/index.js";
+import { getClient, formatChannel, channelToMarkdown, formatResponse, truncateIfNeeded, getChannelType, } from "../services/discord.js";
+import { ChannelType, GuildChannel, PermissionsBitField, OverwriteType } from "discord.js";
+// Helper function to convert permission strings to bitfield
+function parsePermissions(permissions) {
+    let bits = BigInt(0);
+    for (const perm of permissions) {
+        const flag = PermissionsBitField.Flags[perm];
+        if (flag) {
+            bits |= flag;
+        }
+    }
+    return bits;
+}
+// List of common permission names for reference
+const PERMISSION_LIST = [
+    'ViewChannel', 'ManageChannels', 'ManageRoles', 'CreateInstantInvite',
+    'SendMessages', 'SendMessagesInThreads', 'CreatePublicThreads', 'CreatePrivateThreads',
+    'EmbedLinks', 'AttachFiles', 'AddReactions', 'UseExternalEmojis', 'UseExternalStickers',
+    'MentionEveryone', 'ManageMessages', 'ManageThreads', 'ReadMessageHistory',
+    'SendTTSMessages', 'UseApplicationCommands',
+    'Connect', 'Speak', 'Stream', 'UseEmbeddedActivities', 'UseSoundboard',
+    'UseExternalSounds', 'UseVAD', 'PrioritySpeaker', 'MuteMembers', 'DeafenMembers', 'MoveMembers',
+    'ManageEvents', 'ManageWebhooks'
+];
+export function registerChannelTools(server) {
+    server.registerTool("discord_list_channels", {
+        title: "List Discord Channels",
+        description: `List channels in a Discord server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - type ('text' | 'voice' | 'category' | 'all'): Filter by channel type (default: 'all')
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  List of channels with id, name, type, topic, and category info`,
+        inputSchema: ListChannelsSchema,
+        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}` }],
+                };
+            }
+            // Get all channels as array to avoid type predicate issues
+            const allChannels = Array.from(guild.channels.cache.values());
+            // Filter out threads and apply type filter
+            let filteredChannels = allChannels.filter(c => !c.isThread());
+            if (params.type !== "all") {
+                const targetType = getChannelType(params.type);
+                if (targetType !== null) {
+                    filteredChannels = filteredChannels.filter(c => c.type === targetType);
+                }
+            }
+            const formatted = filteredChannels.map(c => formatChannel(c));
+            const text = formatResponse(formatted, params.response_format, (items) => items.map(channelToMarkdown).join("\n\n"));
+            return {
+                content: [{ type: "text", text: truncateIfNeeded(text) }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error listing channels: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_get_channel", {
+        title: "Get Discord Channel Info",
+        description: `Get detailed information about a specific channel.
+
+Args:
+  - channel_id (string): Discord channel ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  Channel details including name, type, topic, and category`,
+        inputSchema: GetChannelSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !(channel instanceof GuildChannel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found: ${params.channel_id}` }],
+                };
+            }
+            const formatted = formatChannel(channel);
+            const text = formatResponse(formatted, params.response_format, channelToMarkdown);
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting channel: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_create_channel", {
+        title: "Create Discord Channel",
+        description: `Create a new channel or category in a Discord server.
+
+Args:
+  - guild_id (string): Discord server/guild ID
+  - name (string): Channel name
+  - type ('text' | 'voice' | 'category'): Channel type (default: 'text')
+  - topic (string, optional): Channel topic (text channels only)
+  - parent_id (string, optional): Category ID to create channel under (not for categories)
+  - nsfw (boolean, optional): Whether the channel is NSFW (text channels only)
+  - bitrate (number, optional): Bitrate for voice channels (8000-384000)
+  - user_limit (number, optional): User limit for voice channels (0 = unlimited)
+
+Returns:
+  The created channel's details`,
+        inputSchema: CreateChannelSchema,
+        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}` }],
+                };
+            }
+            let channelType;
+            switch (params.type) {
+                case "voice":
+                    channelType = ChannelType.GuildVoice;
+                    break;
+                case "category":
+                    channelType = ChannelType.GuildCategory;
+                    break;
+                default:
+                    channelType = ChannelType.GuildText;
+            }
+            const channelOptions = {
+                name: params.name,
+                type: channelType,
+            };
+            // Only add these for non-category channels
+            if (params.type !== "category") {
+                if (params.parent_id)
+                    channelOptions.parent = params.parent_id;
+            }
+            // Text channel specific options
+            if (params.type === "text" || !params.type) {
+                if (params.topic)
+                    channelOptions.topic = params.topic;
+                if (params.nsfw !== undefined)
+                    channelOptions.nsfw = params.nsfw;
+            }
+            // Voice channel specific options
+            if (params.type === "voice") {
+                if (params.bitrate)
+                    channelOptions.bitrate = params.bitrate;
+                if (params.user_limit !== undefined)
+                    channelOptions.userLimit = params.user_limit;
+            }
+            const channel = await guild.channels.create(channelOptions);
+            const typeLabel = params.type === "category" ? "category" : "channel";
+            const prefix = params.type === "category" ? "📁" : "#";
+            return {
+                content: [{ type: "text", text: `Created ${typeLabel} ${prefix}${channel.name} (ID: ${channel.id})` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error creating channel: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_delete_channel", {
+        title: "Delete Discord Channel",
+        description: `Delete a channel from a Discord server. This action is permanent!
+
+Args:
+  - channel_id (string): Discord channel ID to delete
+
+Returns:
+  Confirmation of deletion`,
+        inputSchema: DeleteChannelSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('delete' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found: ${params.channel_id}` }],
+                };
+            }
+            const name = 'name' in channel ? channel.name : params.channel_id;
+            await channel.delete();
+            return {
+                content: [{ type: "text", text: `Deleted channel: ${name}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error deleting channel: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_edit_channel", {
+        title: "Edit Discord Channel",
+        description: `Edit a channel's properties including name, topic, category, position, and more.
+
+Args:
+  - channel_id (string): Discord channel ID
+  - name (string, optional): New channel name
+  - topic (string, optional): New channel topic
+  - parent_id (string, optional): Move to a different category (or 'none' to remove from category)
+  - position (number, optional): New position of the channel
+  - nsfw (boolean, optional): Whether the channel is NSFW
+  - bitrate (number, optional): Bitrate for voice channels (8000-384000)
+  - user_limit (number, optional): User limit for voice channels
+
+Returns:
+  Updated channel details`,
+        inputSchema: EditChannelSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('edit' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found: ${params.channel_id}` }],
+                };
+            }
+            const updates = {};
+            if (params.name)
+                updates.name = params.name;
+            if (params.topic !== undefined)
+                updates.topic = params.topic;
+            if (params.position !== undefined)
+                updates.position = params.position;
+            if (params.nsfw !== undefined)
+                updates.nsfw = params.nsfw;
+            if (params.bitrate !== undefined)
+                updates.bitrate = params.bitrate;
+            if (params.user_limit !== undefined)
+                updates.userLimit = params.user_limit;
+            if (params.parent_id !== undefined) {
+                updates.parent = params.parent_id === 'none' ? null : params.parent_id;
+            }
+            await channel.edit(updates);
+            return {
+                content: [{ type: "text", text: `Updated channel ${params.channel_id}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error editing channel: ${error.message}` }],
+            };
+        }
+    });
+    // ============================================================================
+    // PERMISSION TOOLS
+    // ============================================================================
+    server.registerTool("discord_set_channel_permissions", {
+        title: "Set Channel Permissions",
+        description: `Set permission overrides for a role or member on a channel.
+
+Common permission names:
+- View: ViewChannel
+- Messages: SendMessages, ReadMessageHistory, ManageMessages, EmbedLinks, AttachFiles, AddReactions
+- Voice: Connect, Speak, Stream, MuteMembers, DeafenMembers, MoveMembers
+- Threads: CreatePublicThreads, CreatePrivateThreads, SendMessagesInThreads
+- Management: ManageChannels, ManageRoles, ManageWebhooks
+
+Args:
+  - channel_id (string): Discord channel ID
+  - target_id (string): Role or User ID to set permissions for
+  - target_type ('role' | 'member'): Whether target is a role or member
+  - allow (string[], optional): Permissions to allow (e.g., ['ViewChannel', 'SendMessages'])
+  - deny (string[], optional): Permissions to deny (e.g., ['SendMessages'])
+
+Returns:
+  Confirmation of permission changes`,
+        inputSchema: SetChannelPermissionsSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('permissionOverwrites' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found or doesn't support permissions: ${params.channel_id}` }],
+                };
+            }
+            const guildChannel = channel;
+            // Build permission overwrite object with individual permission keys
+            const permissionOverwrite = {};
+            // Set allowed permissions to true
+            if (params.allow) {
+                for (const perm of params.allow) {
+                    permissionOverwrite[perm] = true;
+                }
+            }
+            // Set denied permissions to false
+            if (params.deny) {
+                for (const perm of params.deny) {
+                    permissionOverwrite[perm] = false;
+                }
+            }
+            await guildChannel.permissionOverwrites.edit(params.target_id, permissionOverwrite, {
+                type: params.target_type === 'role' ? OverwriteType.Role : OverwriteType.Member,
+            });
+            const allowList = params.allow?.join(', ') || 'none';
+            const denyList = params.deny?.join(', ') || 'none';
+            return {
+                content: [{ type: "text", text: `Updated permissions for ${params.target_type} ${params.target_id} on channel ${params.channel_id}\nAllowed: ${allowList}\nDenied: ${denyList}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error setting permissions: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_remove_channel_permissions", {
+        title: "Remove Channel Permission Overrides",
+        description: `Remove all permission overrides for a role or member on a channel.
+
+Args:
+  - channel_id (string): Discord channel ID
+  - target_id (string): Role or User ID to remove permission overrides for
+
+Returns:
+  Confirmation of removal`,
+        inputSchema: RemoveChannelPermissionsSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('permissionOverwrites' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found or doesn't support permissions: ${params.channel_id}` }],
+                };
+            }
+            const guildChannel = channel;
+            await guildChannel.permissionOverwrites.delete(params.target_id);
+            return {
+                content: [{ type: "text", text: `Removed permission overrides for ${params.target_id} on channel ${params.channel_id}` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error removing permissions: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_get_channel_permissions", {
+        title: "Get Channel Permissions",
+        description: `Get all permission overrides for a channel.
+
+Args:
+  - channel_id (string): Discord channel ID
+  - response_format ('markdown' | 'json'): Output format (default: 'json')
+
+Returns:
+  List of permission overrides with allow/deny for each role/member`,
+        inputSchema: GetChannelPermissionsSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('permissionOverwrites' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found or doesn't support permissions: ${params.channel_id}` }],
+                };
+            }
+            const guildChannel = channel;
+            const overwrites = guildChannel.permissionOverwrites.cache;
+            const formatted = overwrites.map(ow => {
+                const allowedPerms = new PermissionsBitField(ow.allow).toArray();
+                const deniedPerms = new PermissionsBitField(ow.deny).toArray();
+                return {
+                    id: ow.id,
+                    type: ow.type === OverwriteType.Role ? 'role' : 'member',
+                    allow: allowedPerms,
+                    deny: deniedPerms,
+                };
+            });
+            if (params.response_format === 'json') {
+                return {
+                    content: [{ type: "text", text: JSON.stringify(Array.from(formatted.values()), null, 2) }],
+                };
+            }
+            // Markdown format
+            const lines = Array.from(formatted.values()).map(ow => {
+                const allowStr = ow.allow.length > 0 ? ow.allow.join(', ') : 'none';
+                const denyStr = ow.deny.length > 0 ? ow.deny.join(', ') : 'none';
+                return `### ${ow.type}: ${ow.id}\n- **Allow**: ${allowStr}\n- **Deny**: ${denyStr}`;
+            });
+            const text = lines.length > 0 ? lines.join('\n\n') : 'No permission overrides on this channel.';
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error getting permissions: ${error.message}` }],
+            };
+        }
+    });
+    server.registerTool("discord_sync_channel_permissions", {
+        title: "Sync Channel Permissions with Category",
+        description: `Sync a channel's permissions with its parent category.
+
+Args:
+  - channel_id (string): Discord channel ID
+
+Returns:
+  Confirmation of sync`,
+        inputSchema: SyncChannelPermissionsSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (params) => {
+        try {
+            const client = await getClient();
+            const channel = client.channels.cache.get(params.channel_id);
+            if (!channel || !('lockPermissions' in channel)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Channel not found or doesn't support permission sync: ${params.channel_id}` }],
+                };
+            }
+            await channel.lockPermissions();
+            return {
+                content: [{ type: "text", text: `Synced permissions for channel ${params.channel_id} with its parent category` }],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error syncing permissions: ${error.message}` }],
+            };
+        }
+    });
+}

package/dist/tools/community.d.ts

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