slack-workspace-mcp-server 0.0.1

package/shared/tools/update-message.js

@@ -0,0 +1,87 @@
+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 update (e.g., "1234567890.123456"). ' +
+        'This is shown as "ts" in message outputs.',
+    text: 'The new content for the message. Completely replaces the existing text. ' +
+        'Supports Slack markdown: *bold*, _italic_, `code`, ```code blocks```.',
+};
+export const UpdateMessageSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    message_ts: z.string().min(1).describe(PARAM_DESCRIPTIONS.message_ts),
+    text: z.string().min(1).describe(PARAM_DESCRIPTIONS.text),
+});
+const TOOL_DESCRIPTION = `Update an existing message in Slack.
+
+Modifies the content of a message that was previously posted. The message will show an "(edited)" indicator after being updated.
+
+**Returns:**
+- Confirmation of the update
+- The updated message content
+
+**Use cases:**
+- Fix typos or errors in a message
+- Update information that has changed
+- Add clarifications to a previous message
+- Mark a task or question as resolved by editing the message
+
+**Note:**
+- You can only edit messages that the bot posted
+- The edit history is not preserved - only the final content is shown
+- Consider adding reactions instead if you just want to acknowledge a message`;
+export function updateMessageTool(server, clientFactory) {
+    return {
+        name: 'slack_update_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,
+                },
+                text: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.text,
+                },
+            },
+            required: ['channel_id', 'message_ts', 'text'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = UpdateMessageSchema.parse(args);
+                const client = clientFactory();
+                const message = await client.updateMessage(parsed.channel_id, parsed.message_ts, parsed.text);
+                const time = new Date(parseFloat(message.ts) * 1000).toISOString();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Message updated successfully!\n\n` +
+                                `Channel: ${parsed.channel_id}\n` +
+                                `Timestamp: ${message.ts}\n` +
+                                `Updated at: ${time}\n\n` +
+                                `New content:\n${parsed.text}`,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error updating message: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools.d.ts

@@ -0,0 +1,18 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ClientFactory } from './server.js';
+/**
+ * Tool groups for permission-based access control
+ */
+export type ToolGroup = 'readonly' | 'write';
+/**
+ * Parse enabled tool groups from environment variable
+ */
+export declare function parseEnabledToolGroups(enabledGroupsParam?: string): ToolGroup[];
+/**
+ * Creates a function to register all tools with the server
+ */
+export declare function createRegisterTools(clientFactory: ClientFactory, enabledGroups?: ToolGroup[]): (server: Server) => void;
+/**
+ * Backward compatibility export
+ */
+export declare function registerTools(server: Server): void;

package/shared/tools.js

@@ -0,0 +1,78 @@
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { logWarning } from './logging.js';
+import { getChannelsTool } from './tools/get-channels.js';
+import { getChannelTool } from './tools/get-channel.js';
+import { getThreadTool } from './tools/get-thread.js';
+import { postMessageTool } from './tools/post-message.js';
+import { replyToThreadTool } from './tools/reply-to-thread.js';
+import { updateMessageTool } from './tools/update-message.js';
+import { reactToMessageTool } from './tools/react-to-message.js';
+const ALL_TOOL_GROUPS = ['readonly', 'write'];
+/**
+ * Parse enabled tool groups from environment variable
+ */
+export function parseEnabledToolGroups(enabledGroupsParam) {
+    if (!enabledGroupsParam) {
+        return ALL_TOOL_GROUPS;
+    }
+    const requestedGroups = enabledGroupsParam.split(',').map((g) => g.trim().toLowerCase());
+    const validGroups = requestedGroups.filter((g) => ALL_TOOL_GROUPS.includes(g));
+    if (validGroups.length === 0) {
+        logWarning('parseEnabledToolGroups', `No valid tool groups found in "${enabledGroupsParam}". Valid groups: ${ALL_TOOL_GROUPS.join(', ')}`);
+        return ALL_TOOL_GROUPS;
+    }
+    return validGroups;
+}
+/**
+ * All available tools with their group assignments
+ */
+const ALL_TOOLS = [
+    // Read-only tools
+    { factory: getChannelsTool, groups: ['readonly', 'write'] },
+    { factory: getChannelTool, groups: ['readonly', 'write'] },
+    { factory: getThreadTool, groups: ['readonly', 'write'] },
+    // Write tools
+    { factory: postMessageTool, groups: ['write'] },
+    { factory: replyToThreadTool, groups: ['write'] },
+    { factory: updateMessageTool, groups: ['write'] },
+    { factory: reactToMessageTool, groups: ['write'] },
+];
+/**
+ * Creates a function to register all tools with the server
+ */
+export function createRegisterTools(clientFactory, enabledGroups) {
+    const groups = enabledGroups || parseEnabledToolGroups(process.env.ENABLED_TOOLGROUPS);
+    return (server) => {
+        // Filter tools by enabled groups and create instances
+        const tools = ALL_TOOLS.filter((def) => def.groups.some((g) => groups.includes(g))).map((def) => def.factory(server, clientFactory));
+        // List available tools
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                })),
+            };
+        });
+        // Handle tool calls
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const tool = tools.find((t) => t.name === name);
+            if (!tool) {
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            return await tool.handler(args);
+        });
+    };
+}
+/**
+ * Backward compatibility export
+ */
+export function registerTools(server) {
+    const factory = () => {
+        throw new Error('No client factory provided - use createRegisterTools for dependency injection');
+    };
+    const register = createRegisterTools(factory);
+    register(server);
+}

package/shared/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Slack API Types
+ * Based on Slack Web API responses
+ */
+export interface Channel {
+    id: string;
+    name: string;
+    is_channel: boolean;
+    is_group: boolean;
+    is_im: boolean;
+    is_mpim: boolean;
+    is_private: boolean;
+    is_archived: boolean;
+    is_general: boolean;
+    is_member: boolean;
+    topic?: {
+        value: string;
+        creator: string;
+        last_set: number;
+    };
+    purpose?: {
+        value: string;
+        creator: string;
+        last_set: number;
+    };
+    num_members?: number;
+    created: number;
+    creator?: string;
+}
+export interface Message {
+    type: string;
+    subtype?: string;
+    user?: string;
+    bot_id?: string;
+    text: string;
+    ts: string;
+    thread_ts?: string;
+    reply_count?: number;
+    reply_users_count?: number;
+    latest_reply?: string;
+    reply_users?: string[];
+    reactions?: Reaction[];
+    attachments?: Attachment[];
+    blocks?: Block[];
+    edited?: {
+        user: string;
+        ts: string;
+    };
+}
+export interface Reaction {
+    name: string;
+    count: number;
+    users: string[];
+}
+export interface Attachment {
+    id?: number;
+    fallback?: string;
+    color?: string;
+    pretext?: string;
+    author_name?: string;
+    author_link?: string;
+    author_icon?: string;
+    title?: string;
+    title_link?: string;
+    text?: string;
+    fields?: Array<{
+        title: string;
+        value: string;
+        short: boolean;
+    }>;
+    image_url?: string;
+    thumb_url?: string;
+    footer?: string;
+    footer_icon?: string;
+    ts?: number;
+}
+export interface Block {
+    type: string;
+    block_id?: string;
+    text?: {
+        type: string;
+        text: string;
+        emoji?: boolean;
+    };
+    elements?: unknown[];
+}
+export interface ThreadWithReplies {
+    messages: Message[];
+    has_more: boolean;
+    response_metadata?: {
+        next_cursor?: string;
+    };
+}
+export interface User {
+    id: string;
+    name: string;
+    real_name?: string;
+    display_name?: string;
+    is_bot: boolean;
+    is_admin?: boolean;
+    profile?: {
+        display_name?: string;
+        real_name?: string;
+        image_48?: string;
+        image_72?: string;
+    };
+}
+export interface PaginatedResponse<T> {
+    items: T[];
+    has_more: boolean;
+    next_cursor?: string;
+}

package/shared/types.js

@@ -0,0 +1,5 @@
+/**
+ * Slack API Types
+ * Based on Slack Web API responses
+ */
+export {};