slack-workspace-mcp-server 0.0.1

package/shared/tools/get-thread.d.ts

@@ -0,0 +1,54 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const GetThreadSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    thread_ts: z.ZodString;
+    reply_limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    channel_id: string;
+    thread_ts: string;
+    reply_limit: number;
+}, {
+    channel_id: string;
+    thread_ts: string;
+    reply_limit?: number | undefined;
+}>;
+export declare function getThreadTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            thread_ts: {
+                type: string;
+                description: string;
+            };
+            reply_limit: {
+                type: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};

package/shared/tools/get-thread.js

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    channel_id: 'The channel ID where the thread exists (e.g., "C1234567890"). ' +
+        'Get channel IDs using the slack_get_channels tool.',
+    thread_ts: 'The timestamp of the parent message that started the thread (e.g., "1234567890.123456"). ' +
+        'This is shown as "ts" in message outputs.',
+    reply_limit: 'Maximum number of replies to return. Default: 50. Maximum: 200. ' +
+        'The parent message is always included.',
+};
+export const GetThreadSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    thread_ts: z.string().min(1).describe(PARAM_DESCRIPTIONS.thread_ts),
+    reply_limit: z.number().min(1).max(200).default(50).describe(PARAM_DESCRIPTIONS.reply_limit),
+});
+const TOOL_DESCRIPTION = `Get a thread conversation with all its replies.
+
+Returns the parent message and all replies in a thread. This is equivalent to clicking on "X replies" in Slack to expand a thread.
+
+**Returns:**
+- Parent message with full content
+- All reply messages in chronological order
+- Reactions on each message
+- Timestamps for each message
+
+**Use cases:**
+- Read an entire threaded conversation
+- Get context before replying to a thread
+- Review discussion history on a topic
+- Find the latest reply timestamp for adding new replies
+
+**Note:** The thread_ts parameter is the timestamp of the parent message, not a reply.`;
+export function getThreadTool(server, clientFactory) {
+    return {
+        name: 'slack_get_thread',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channel_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.channel_id,
+                },
+                thread_ts: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.thread_ts,
+                },
+                reply_limit: {
+                    type: 'number',
+                    default: 50,
+                    minimum: 1,
+                    maximum: 200,
+                    description: PARAM_DESCRIPTIONS.reply_limit,
+                },
+            },
+            required: ['channel_id', 'thread_ts'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = GetThreadSchema.parse(args);
+                const client = clientFactory();
+                const { messages, hasMore } = await client.getThread(parsed.channel_id, parsed.thread_ts, {
+                    limit: parsed.reply_limit,
+                });
+                if (messages.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Thread not found or has no messages.',
+                            },
+                        ],
+                    };
+                }
+                // First message is the parent
+                const parent = messages[0];
+                const replies = messages.slice(1);
+                let output = `# Thread in channel ${parsed.channel_id}\n\n`;
+                // Format parent message
+                const parentTime = new Date(parseFloat(parent.ts) * 1000).toISOString();
+                const parentSender = parent.user || parent.bot_id || 'unknown';
+                const parentReactions = parent.reactions
+                    ? `\nReactions: ${parent.reactions.map((r) => `:${r.name}: ${r.count}`).join(' ')}`
+                    : '';
+                output += `## Parent Message\n`;
+                output += `**${parentSender}** (${parentTime})\n`;
+                output += `${parent.text}${parentReactions}\n`;
+                output += `ts: ${parent.ts}\n\n`;
+                // Format replies
+                if (replies.length > 0) {
+                    output += `## Replies (${replies.length}${hasMore ? '+' : ''}):\n\n`;
+                    for (const reply of replies) {
+                        const time = new Date(parseFloat(reply.ts) * 1000).toISOString();
+                        const sender = reply.user || reply.bot_id || 'unknown';
+                        const reactions = reply.reactions
+                            ? `\nReactions: ${reply.reactions.map((r) => `:${r.name}: ${r.count}`).join(' ')}`
+                            : '';
+                        output += `**${sender}** (${time})\n`;
+                        output += `${reply.text}${reactions}\n`;
+                        output += `ts: ${reply.ts}\n\n`;
+                    }
+                    if (hasMore) {
+                        output += `_More replies available. Increase reply_limit to see more._\n`;
+                    }
+                }
+                else {
+                    output += '_No replies yet._\n';
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: output,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error fetching thread: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/post-message.d.ts

@@ -0,0 +1,44 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const PostMessageSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    channel_id: string;
+}, {
+    text: string;
+    channel_id: string;
+}>;
+export declare function postMessageTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            text: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};

package/shared/tools/post-message.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    channel_id: 'The channel ID to post the message to (e.g., "C1234567890"). ' +
+        'Get channel IDs using the slack_get_channels tool.',
+    text: 'The message content to post. Supports Slack markdown formatting: ' +
+        '*bold*, _italic_, `code`, ```code blocks```, and <URL|link text>.',
+};
+export const PostMessageSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    text: z.string().min(1).describe(PARAM_DESCRIPTIONS.text),
+});
+const TOOL_DESCRIPTION = `Post a new message to a Slack channel.
+
+Creates a new message in the specified channel. The message appears as a new post, not as a reply to any thread.
+
+**Returns:**
+- Confirmation of the posted message
+- The message timestamp (ts) which can be used to:
+  - Start a thread by replying with slack_reply_to_thread
+  - Edit the message with slack_update_message
+  - Add reactions with slack_react_to_message
+
+**Use cases:**
+- Share information with a channel
+- Start a new discussion topic
+- Post announcements or updates
+- Ask questions to the channel
+
+**Note:** To reply to an existing thread, use slack_reply_to_thread instead.`;
+export function postMessageTool(server, clientFactory) {
+    return {
+        name: 'slack_post_message',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channel_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.channel_id,
+                },
+                text: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.text,
+                },
+            },
+            required: ['channel_id', 'text'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = PostMessageSchema.parse(args);
+                const client = clientFactory();
+                const message = await client.postMessage(parsed.channel_id, parsed.text);
+                const time = new Date(parseFloat(message.ts) * 1000).toISOString();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Message posted successfully!\n\n` +
+                                `Channel: ${parsed.channel_id}\n` +
+                                `Timestamp: ${message.ts}\n` +
+                                `Posted at: ${time}\n\n` +
+                                `Content:\n${parsed.text}\n\n` +
+                                `Use the timestamp (ts: ${message.ts}) to reply to this message or add reactions.`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error posting message: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/react-to-message.d.ts

@@ -0,0 +1,51 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const ReactToMessageSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    message_ts: z.ZodString;
+    emoji: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    emoji: string;
+    channel_id: string;
+    message_ts: string;
+}, {
+    emoji: string;
+    channel_id: string;
+    message_ts: string;
+}>;
+export declare function reactToMessageTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            message_ts: {
+                type: string;
+                description: string;
+            };
+            emoji: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};

package/shared/tools/react-to-message.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    channel_id: 'The channel ID where the message exists (e.g., "C1234567890"). ' +
+        'Get channel IDs using the slack_get_channels tool.',
+    message_ts: 'The timestamp of the message to react to (e.g., "1234567890.123456"). ' +
+        'This is shown as "ts" in message outputs.',
+    emoji: 'The emoji name without colons (e.g., "thumbsup", "white_check_mark", "eyes"). ' +
+        'Common reactions: thumbsup, thumbsdown, heart, eyes, white_check_mark, x, tada.',
+};
+export const ReactToMessageSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    message_ts: z.string().min(1).describe(PARAM_DESCRIPTIONS.message_ts),
+    emoji: z.string().min(1).describe(PARAM_DESCRIPTIONS.emoji),
+});
+const TOOL_DESCRIPTION = `Add an emoji reaction to a message in Slack.
+
+Adds a reaction (emoji) to a specific message. Reactions are a lightweight way to acknowledge or respond to messages without creating a new message.
+
+**Returns:**
+- Confirmation that the reaction was added
+
+**Common emoji names:**
+- Positive: thumbsup, +1, heart, tada, star, clap
+- Acknowledgment: eyes, white_check_mark, ok_hand
+- Negative: thumbsdown, -1, x
+- Status: hourglass, warning, question, exclamation
+
+**Use cases:**
+- Acknowledge that you've seen a message (:eyes:)
+- Mark a task as complete (:white_check_mark:)
+- Show approval or agreement (:thumbsup:)
+- Celebrate achievements (:tada:)
+- Signal that something needs attention (:warning:)
+
+**Note:** If the reaction already exists from this bot, no error is returned.`;
+export function reactToMessageTool(server, clientFactory) {
+    return {
+        name: 'slack_react_to_message',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channel_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.channel_id,
+                },
+                message_ts: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.message_ts,
+                },
+                emoji: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.emoji,
+                },
+            },
+            required: ['channel_id', 'message_ts', 'emoji'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = ReactToMessageSchema.parse(args);
+                const client = clientFactory();
+                // Remove colons if the user included them
+                const emojiName = parsed.emoji.replace(/^:/, '').replace(/:$/, '');
+                await client.addReaction(parsed.channel_id, parsed.message_ts, emojiName);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Reaction added successfully!\n\n` +
+                                `Channel: ${parsed.channel_id}\n` +
+                                `Message: ${parsed.message_ts}\n` +
+                                `Reaction: :${emojiName}:`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error adding reaction: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/reply-to-thread.d.ts

@@ -0,0 +1,59 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const ReplyToThreadSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    thread_ts: z.ZodString;
+    text: z.ZodString;
+    broadcast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    channel_id: string;
+    thread_ts: string;
+    broadcast: boolean;
+}, {
+    text: string;
+    channel_id: string;
+    thread_ts: string;
+    broadcast?: boolean | undefined;
+}>;
+export declare function replyToThreadTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            thread_ts: {
+                type: string;
+                description: string;
+            };
+            text: {
+                type: string;
+                description: string;
+            };
+            broadcast: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};

package/shared/tools/reply-to-thread.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    channel_id: 'The channel ID where the thread exists (e.g., "C1234567890"). ' +
+        'Get channel IDs using the slack_get_channels tool.',
+    thread_ts: 'The timestamp of the parent message to reply to (e.g., "1234567890.123456"). ' +
+        'This creates a threaded reply under that message.',
+    text: 'The reply content. Supports Slack markdown formatting: ' +
+        '*bold*, _italic_, `code`, ```code blocks```, and <URL|link text>.',
+    broadcast: 'Also post the reply to the channel (not just the thread). Default: false. ' +
+        'When true, the reply appears both in the thread and as a channel message.',
+};
+export const ReplyToThreadSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    thread_ts: z.string().min(1).describe(PARAM_DESCRIPTIONS.thread_ts),
+    text: z.string().min(1).describe(PARAM_DESCRIPTIONS.text),
+    broadcast: z.boolean().default(false).describe(PARAM_DESCRIPTIONS.broadcast),
+});
+const TOOL_DESCRIPTION = `Reply to an existing thread in Slack.
+
+Posts a message as a reply to a specific thread. The reply will appear nested under the parent message.
+
+**Returns:**
+- Confirmation of the posted reply
+- The reply's timestamp (ts) for further operations
+
+**Use cases:**
+- Continue a threaded conversation
+- Answer a question in a thread
+- Provide follow-up information
+- Keep discussions organized within threads
+
+**Note:** Use slack_get_thread first to read the conversation before replying.`;
+export function replyToThreadTool(server, clientFactory) {
+    return {
+        name: 'slack_reply_to_thread',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channel_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.channel_id,
+                },
+                thread_ts: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.thread_ts,
+                },
+                text: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.text,
+                },
+                broadcast: {
+                    type: 'boolean',
+                    default: false,
+                    description: PARAM_DESCRIPTIONS.broadcast,
+                },
+            },
+            required: ['channel_id', 'thread_ts', 'text'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = ReplyToThreadSchema.parse(args);
+                const client = clientFactory();
+                const message = await client.postMessage(parsed.channel_id, parsed.text, {
+                    threadTs: parsed.thread_ts,
+                    replyBroadcast: parsed.broadcast,
+                });
+                const time = new Date(parseFloat(message.ts) * 1000).toISOString();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Reply posted successfully!\n\n` +
+                                `Channel: ${parsed.channel_id}\n` +
+                                `Thread: ${parsed.thread_ts}\n` +
+                                `Reply timestamp: ${message.ts}\n` +
+                                `Posted at: ${time}\n` +
+                                (parsed.broadcast ? 'Broadcasted to channel: Yes\n' : '') +
+                                `\nContent:\n${parsed.text}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error posting reply: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/update-message.d.ts

@@ -0,0 +1,51 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const UpdateMessageSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    message_ts: z.ZodString;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    channel_id: string;
+    message_ts: string;
+}, {
+    text: string;
+    channel_id: string;
+    message_ts: string;
+}>;
+export declare function updateMessageTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            message_ts: {
+                type: string;
+                description: string;
+            };
+            text: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};