fix: resolve #27 and refresh README

fix #27 streamable-http startup crash and refresh README

README.md

@@ -14,12 +14,16 @@ MCP-Discord provides the following Discord-related functionalities:
 - Login to Discord bot
 - List servers the bot is a member of
 - Get server information
+- List members and inspect member details
+- List, create, edit, delete, assign, and remove roles
 - Search messages in a server
-- Read/delete channel messages
+- Read, edit, and delete channel messages
-- Send messages to specified channels (using either channel IDs or channel names)
+- Send messages to specified channels
 - Retrieve forum channel lists
-- Create/delete/reply to forum posts
+- Create, update, delete, and reply to forum posts
-- Create/delete text channels
+- List forum threads and manage forum tags
+- Create, edit, and delete text, forum, voice channels, and categories
+- Set and remove channel permission overrides
 - Add/remove message reactions
 - Create/edit/delete/use webhooks
 
@@ -34,12 +38,14 @@ MCP-Discord provides the following Discord-related functionalities:
   - [Forum Functions](#forum-functions)
   - [Messages and Reactions](#messages-and-reactions)
   - [Webhook Management](#webhook-management)
+  - [Role Management](#role-management)
+  - [Member Management](#member-management)
 - [Development](#development)
 - [License](#license)
 
 ## Prerequisites
 
-- Node.js (v16.0.0 or higher)
+- Node.js (v18.0.0 or higher)
 - npm (v7.0.0 or higher)
 - A Discord bot with appropriate permissions
   - Bot token (obtainable from the [Discord Developer Portal](https://discord.com/developers/applications))
@@ -59,6 +65,7 @@ MCP-Discord provides the following Discord-related functionalities:
   - Manage Threads
   - Manage Channels
   - Manage Webhooks
+  - Manage Roles
   - Add Reactions
   - View Channel
 
@@ -95,35 +102,22 @@ You can run mcp-discord using Docker. The Docker images are automatically built
 
 **Docker Hub Repository**: [barryy625/mcp-discord](https://hub.docker.com/r/barryy625/mcp-discord)
 
-Docker container uses `stdio` by default.
+Docker uses the streamable HTTP server by default via `build/app.js`.
 
 ```bash
 # Pull the latest image
 docker pull barryy625/mcp-discord:latest
 
-# Run with environment variable
+# Run HTTP server on port 8080
-docker run -e DISCORD_TOKEN=your_discord_bot_token barryy625/mcp-discord:latest
+docker run -e DISCORD_TOKEN=your_discord_bot_token -p 8080:8080 barryy625/mcp-discord:latest
 
-# Or run with command line config
+# Override the listening port if needed
-docker run barryy625/mcp-discord:latest --config "your_discord_bot_token"
+docker run -e DISCORD_TOKEN=your_discord_bot_token -p 3000:3000 barryy625/mcp-discord:latest --transport http --port 3000
-```
-
-Alternatively, override the `--transport` and `--port` flags to run `http` on a port of your choosing. In this case, also map the ports.
-
-```bash
-# Pull the latest image
-docker pull barryy625/mcp-discord:latest
-
-# Run with environment variable
-docker run -e DISCORD_TOKEN=your_discord_bot_token -p 8080:8080 barryy625/mcp-discord:latest --transport http --port 8081
-
-# Or run with command line config
-docker run -p 8080:8080 barryy625/mcp-discord:latest --config "your_discord_bot_token" --transport http --port 8081
 ```
 
 **Available Tags:**
 - `latest` - Latest stable version from main branch
-- `v1.3.3`, etc. - Specific version releases
+- `v1.3.8`, etc. - Specific version releases
 
 ### Manual Installation
 ```bash
@@ -168,147 +162,138 @@ DISCORD_TOKEN=your_discord_bot_token
 node build/index.js --config "your_discord_bot_token"
 
 # For streamable HTTP transport
-node build/index.js --transport http --port 3000 --config "your_discord_bot_token"
+node build/app.js --transport http --port 3000 --config "your_discord_bot_token"
 ```
 
 ## Usage with Claude/Cursor
 
-### Docker
+### 1. Use Stdio Transport with Claude/Cursor
 
-You can use Docker containers with both Claude and Cursor:
+Use `build/index.js` when your MCP client expects a command-based stdio server.
 
-```json
+#### Claude Desktop / Claude Code
-{
-    "mcpServers": {
-        "discord": {
-            "command": "docker",
-            "args": [
-                "run",
-                "--rm",
-                "-e",
-                "DISCORD_TOKEN=your_discord_bot_token",
-                "-p",
-                "8080:8080",
-                "barryy625/mcp-discord:latest",
-                "--transport",
-                "http",
-                "--port",
-                "8080"
-            ]
-        }
-    }
-}
-```
 
-### Claude
-
-1. Using stdio transport:
 ```json
 {
     "mcpServers": {
         "discord": {
             "command": "node",
             "args": [
-                "path/to/mcp-discord/build/index.js",
+                "path/to/mcp-discord/build/index.js"
-                "--config",
+            ],
-                "your_discord_bot_token"
+            "env": {
-            ]
+                "DISCORD_TOKEN": "your_discord_bot_token"
+            }
         }
     }
 }
 ```
 
-2. Using streamable HTTP transport:
+#### Cursor
+
 ```json
 {
     "mcpServers": {
         "discord": {
             "command": "node",
             "args": [
-                "path/to/mcp-discord/build/index.js",
+                "path/to/mcp-discord/build/index.js"
-                "--transport",
+            ],
-                "http",
+            "env": {
-                "--port",
+                "DISCORD_TOKEN": "your_discord_bot_token"
-                "3000",
+            }
-                "--config",
-                "your_discord_bot_token"
-            ]
         }
     }
 }
 ```
 
-### Cursor
+This is the recommended setup for local command-based MCP clients.
 
-1. Using stdio transport:
+### 2. Self-Host the Streamable HTTP Server
-```json
+
-{
+Use `build/app.js` when you want to run mcp-discord as an HTTP MCP server.
-    "mcpServers": {
+
-        "discord": {
+#### Run with Node.js
-            "command": "cmd",
+
-            "args": [
+```bash
-                "/c",
+DISCORD_TOKEN=your_discord_bot_token node build/app.js --transport http --port 3000
-                "node",
-                "path/to/mcp-discord/build/index.js",
-                "--config",
-                "your_discord_bot_token"
-            ]
-        }
-    }
-}
 ```
 
-2. Using streamable HTTP transport:
+On Windows PowerShell:
-```json
+
-{
+```powershell
-    "mcpServers": {
+$env:DISCORD_TOKEN="your_discord_bot_token"
-        "discord": {
+node build/app.js --transport http --port 3000
-            "command": "cmd",
-            "args": [
-                "/c",
-                "node",
-                "path/to/mcp-discord/build/index.js",
-                "--transport",
-                "http",
-                "--port",
-                "3000",
-                "--config",
-                "your_discord_bot_token"
-            ]
-        }
-    }
-}
 ```
 
+#### Run with Docker
+
+```bash
+docker run -e DISCORD_TOKEN=your_discord_bot_token -p 3000:3000 barryy625/mcp-discord:latest --transport http --port 3000
+```
+
+Once started, the MCP HTTP endpoint is:
+
+```text
+http://localhost:3000/mcp
+```
+
+### 3. Connect to a Hosted HTTP MCP Server
+
+If you already host mcp-discord elsewhere, point your MCP client at the server's `/mcp` endpoint instead of launching `build/app.js` as a command.
+
+Example endpoint:
+
+```text
+https://your-server.example.com/mcp
+```
+
+Important notes:
+
+- `build/app.js` starts an HTTP server. It does not speak stdio.
+- `build/index.js` is the correct entrypoint for command-based stdio MCP clients.
+- For hosted HTTP usage, configure your MCP client to connect to the HTTP endpoint URL provided by your deployment.
+- The exact HTTP-client configuration format depends on the MCP client you use.
+
 ## Tools Documentation
 
 ### Basic Functions
 
 - `discord_login`: Login to Discord using the configured token
 - `discord_list_servers`: List all Discord servers the bot is a member of
-- `discord_send`: Send a message to a specified channel (supports both channel ID and channel name)
+- `discord_send`: Send a message to a specified channel
 - `discord_get_server_info`: Get Discord server information
 
 ### Channel Management
 
 - `discord_create_text_channel`: Create a text channel
+- `discord_create_forum_channel`: Create a forum channel
+- `discord_create_voice_channel`: Create a voice channel
+- `discord_edit_channel`: Edit a channel name, topic, parent category, or position
 - `discord_delete_channel`: Delete a channel
 - `discord_create_category`: Create a channel category
 - `discord_edit_category`: Edit a channel category
 - `discord_delete_category`: Delete a channel category
+- `discord_set_channel_permissions`: Set permission overrides for a role or user on a channel/category
+- `discord_remove_channel_permissions`: Remove permission overrides from a channel/category
 
 ### Forum Functions
 
 - `discord_get_forum_channels`: Get a list of forum channels
 - `discord_create_forum_post`: Create a forum post
 - `discord_get_forum_post`: Get a forum post
+- `discord_list_forum_threads`: List active and archived threads in a forum channel
 - `discord_reply_to_forum`: Reply to a forum post
+- `discord_get_forum_tags`: Get all available tags for a forum channel
+- `discord_set_forum_tags`: Replace the available tags for a forum channel
+- `discord_update_forum_post`: Update a forum post's title, tags, archived state, or locked state
 - `discord_delete_forum_post`: Delete a forum post
 
 ### Messages and Reactions
 
 - `discord_search_messages`: Search messages in a server
 - `discord_read_messages`: Read channel messages
+- `discord_edit_message`: Edit a bot-authored message
 - `discord_add_reaction`: Add a reaction to a message
 - `discord_add_multiple_reactions`: Add multiple reactions to a message
 - `discord_remove_reaction`: Remove a reaction from a message
@@ -321,6 +306,20 @@ You can use Docker containers with both Claude and Cursor:
 - `discord_edit_webhook`: Edits an existing webhook for a Discord channel
 - `discord_delete_webhook`: Deletes an existing webhook for a Discord channel
 
+### Role Management
+
+- `discord_list_roles`: List all roles in a server
+- `discord_create_role`: Create a role with color, hoist, mentionable, and permission options
+- `discord_edit_role`: Edit an existing role
+- `discord_delete_role`: Delete a role
+- `discord_assign_role`: Assign a role to a member
+- `discord_remove_role`: Remove a role from a member
+
+### Member Management
+
+- `discord_list_members`: List members in a server with roles
+- `discord_get_member`: Get detailed information about a specific member
+
 ## Development
 
 ```bash

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "mcp-discord",
-  "version": "1.3.4",
+  "version": "1.3.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "mcp-discord",
-      "version": "1.3.4",
+      "version": "1.3.8",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.11.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-discord",
-  "version": "1.3.4",
+  "version": "1.3.8",
   "description": "Model Context Protocol (MCP) server for Discord integration, allowing Claude and other MCP clients to interact with Discord",
   "main": "build/index.js",
   "bin": {

src/notifications.ts

@@ -1,4 +1,4 @@
-import { Server } from '@modelcontextprotocol/sdk/server'
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 
 export type Level = 'debug' | 'info' | 'notice' | 'warning' | 'error' | 'critical' | 'alert' | 'emergency';
 
@@ -21,8 +21,9 @@ export function setLevel(level: Level) {
     return true;
 }
 
-export function log(server: Server, message: string, level: Level = 'info') {
+export function log(server: Server | null | undefined, message: string, level: Level = 'info') {
     if (levelPriority[level] < levelPriority[currentLevel]) return;
+    if (!server?.transport) return;
     server.sendLoggingMessage(
         {
             level: level,
@@ -32,14 +33,14 @@ export function log(server: Server, message: string, level: Level = 'info') {
     );
 }
 
-export function info(server: Server, message: string) {
+export function info(server: Server | null | undefined, message: string) {
     log(server, message, 'info');
 }
 
-export function warning(server: Server, message: string) {
+export function warning(server: Server | null | undefined, message: string) {
     log(server, message, 'warning');
 }
 
-export function error(server: Server, message: string) {
+export function error(server: Server | null | undefined, message: string) {
     log(server, message, 'error');
 }