@mahesvara/discord-mcpserver 1.0.7

package/dist/services/discord.js

@@ -0,0 +1,211 @@
+import { Client, GatewayIntentBits, ChannelType } from "discord.js";
+import { ResponseFormat } from "../types.js";
+import { CHARACTER_LIMIT } from "../constants.js";
+let client = null;
+let isReady = false;
+/**
+ * Initialize the Discord client with bot token
+ */
+export async function initializeClient() {
+    if (client && isReady) {
+        return client;
+    }
+    const token = process.env.DISCORD_BOT_TOKEN;
+    if (!token) {
+        throw new Error("DISCORD_BOT_TOKEN environment variable is required. " +
+            "Set it before starting the server: export DISCORD_BOT_TOKEN=your_token_here");
+    }
+    client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMembers,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildModeration,
+        ],
+    });
+    return new Promise((resolve, reject) => {
+        client.once("ready", () => {
+            isReady = true;
+            console.error(`Discord bot logged in as ${client.user?.tag}`);
+            resolve(client);
+        });
+        client.once("error", (error) => {
+            reject(new Error(`Discord client error: ${error.message}`));
+        });
+        client.login(token).catch(reject);
+    });
+}
+/**
+ * Get the initialized Discord client
+ */
+export async function getClient() {
+    if (!client || !isReady) {
+        return initializeClient();
+    }
+    return client;
+}
+/**
+ * Format a guild for response
+ */
+export function formatGuild(guild) {
+    return {
+        id: guild.id,
+        name: guild.name,
+        memberCount: guild.memberCount,
+        icon: guild.iconURL() ?? undefined,
+        ownerId: guild.ownerId,
+    };
+}
+/**
+ * Format a channel for response
+ */
+export function formatChannel(channel) {
+    const baseChannel = {
+        id: channel.id,
+        name: channel.name,
+        type: ChannelType[channel.type],
+        position: channel.position,
+    };
+    if (channel.parent) {
+        baseChannel.parentId = channel.parent.id;
+        baseChannel.parentName = channel.parent.name;
+    }
+    if (channel.type === ChannelType.GuildText && 'topic' in channel) {
+        baseChannel.topic = channel.topic ?? undefined;
+    }
+    return baseChannel;
+}
+/**
+ * Format a member for response
+ */
+export function formatMember(member) {
+    return {
+        id: member.id,
+        username: member.user.username,
+        displayName: member.displayName,
+        nickname: member.nickname ?? undefined,
+        roles: member.roles.cache.map(r => r.name).filter(n => n !== "@everyone"),
+        joinedAt: member.joinedAt?.toISOString(),
+        isBot: member.user.bot,
+    };
+}
+/**
+ * Format a role for response
+ */
+export function formatRole(role) {
+    return {
+        id: role.id,
+        name: role.name,
+        color: role.color,
+        position: role.position,
+        permissions: role.permissions.bitfield.toString(),
+        mentionable: role.mentionable,
+        hoist: role.hoist,
+    };
+}
+/**
+ * Format a message for response
+ */
+export function formatMessage(message) {
+    return {
+        id: message.id,
+        content: message.content,
+        authorId: message.author.id,
+        authorName: message.author.username,
+        channelId: message.channelId,
+        timestamp: message.createdAt.toISOString(),
+        editedTimestamp: message.editedAt?.toISOString(),
+        attachments: message.attachments.map(a => a.url),
+        embeds: message.embeds.length,
+    };
+}
+/**
+ * Convert channel type string to Discord.js ChannelType
+ */
+export function getChannelType(type) {
+    switch (type) {
+        case "text": return ChannelType.GuildText;
+        case "voice": return ChannelType.GuildVoice;
+        case "category": return ChannelType.GuildCategory;
+        default: return null;
+    }
+}
+/**
+ * Format data as markdown
+ */
+export function toMarkdown(data, formatter) {
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return "No results found.";
+        return data.map(formatter).join("\n\n---\n\n");
+    }
+    return formatter(data);
+}
+/**
+ * Truncate text if too long
+ */
+export function truncateIfNeeded(text, limit = CHARACTER_LIMIT) {
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit - 100) + "\n\n... [Output truncated due to length]";
+}
+/**
+ * Format response based on format preference
+ */
+export function formatResponse(data, format, markdownFormatter) {
+    if (format === ResponseFormat.JSON) {
+        return JSON.stringify(data, null, 2);
+    }
+    return toMarkdown(data, markdownFormatter);
+}
+// Markdown formatters for different types
+export function guildToMarkdown(guild) {
+    return `## ${guild.name}
+- **ID**: ${guild.id}
+- **Members**: ${guild.memberCount}
+- **Owner ID**: ${guild.ownerId}`;
+}
+export function channelToMarkdown(channel) {
+    let md = `### #${channel.name}
+- **ID**: ${channel.id}
+- **Type**: ${channel.type}`;
+    if (channel.topic)
+        md += `\n- **Topic**: ${channel.topic}`;
+    if (channel.parentName)
+        md += `\n- **Category**: ${channel.parentName}`;
+    return md;
+}
+export function memberToMarkdown(member) {
+    let md = `### ${member.displayName}
+- **Username**: ${member.username}
+- **ID**: ${member.id}`;
+    if (member.nickname)
+        md += `\n- **Nickname**: ${member.nickname}`;
+    if (member.roles.length > 0)
+        md += `\n- **Roles**: ${member.roles.join(", ")}`;
+    if (member.joinedAt)
+        md += `\n- **Joined**: ${new Date(member.joinedAt).toLocaleDateString()}`;
+    if (member.isBot)
+        md += `\n- **Bot**: Yes`;
+    return md;
+}
+export function roleToMarkdown(role) {
+    return `### ${role.name}
+- **ID**: ${role.id}
+- **Color**: #${role.color.toString(16).padStart(6, "0")}
+- **Position**: ${role.position}
+- **Mentionable**: ${role.mentionable ? "Yes" : "No"}
+- **Hoisted**: ${role.hoist ? "Yes" : "No"}`;
+}
+export function messageToMarkdown(message) {
+    let md = `**${message.authorName}** (${new Date(message.timestamp).toLocaleString()})
+${message.content || "[No text content]"}`;
+    if (message.attachments.length > 0) {
+        md += `\n📎 ${message.attachments.length} attachment(s)`;
+    }
+    if (message.embeds > 0) {
+        md += `\n📋 ${message.embeds} embed(s)`;
+    }
+    return md;
+}

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+export interface DiscordChannel {
+    id: string;
+    name: string;
+    type: string;
+    topic?: string;
+    position?: number;
+    parentId?: string;
+    parentName?: string;
+}
+export interface DiscordGuild {
+    id: string;
+    name: string;
+    memberCount: number;
+    icon?: string;
+    ownerId: string;
+}
+export interface DiscordMember {
+    id: string;
+    username: string;
+    displayName: string;
+    nickname?: string;
+    roles: string[];
+    joinedAt?: string;
+    isBot: boolean;
+}
+export interface DiscordRole {
+    id: string;
+    name: string;
+    color: number;
+    position: number;
+    permissions: string;
+    mentionable: boolean;
+    hoist: boolean;
+}
+export interface DiscordMessage {
+    id: string;
+    content: string;
+    authorId: string;
+    authorName: string;
+    channelId: string;
+    timestamp: string;
+    editedTimestamp?: string;
+    attachments: string[];
+    embeds: number;
+}
+export interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    count: number;
+    offset: number;
+    has_more: boolean;
+    next_offset?: number;
+}
+export declare enum ResponseFormat {
+    JSON = "json",
+    MARKDOWN = "markdown"
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+// Type definitions for Discord MCP Server
+export var ResponseFormat;
+(function (ResponseFormat) {
+    ResponseFormat["JSON"] = "json";
+    ResponseFormat["MARKDOWN"] = "markdown";
+})(ResponseFormat || (ResponseFormat = {}));

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mahesvara/discord-mcpserver",
+  "version": "1.0.7",
+  "description": "MCP server for controlling Discord servers via bot token",
+  "author": "Mahesvara",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Oratorian/discord-node-mcp.git"
+  },
+  "mcpName": "io.github.Oratorian/discord-node-mcp",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "discord",
+    "discord-bot",
+    "discord-api",
+    "discord-management",
+    "claude",
+    "llm",
+    "ai",
+    "automation",
+    "chatbot"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "discord-mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "discord.js": "^14.14.1",
+    "dotenv": "^17.2.3",
+    "express": "^4.18.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.2"
+  }
+}