slack-workspace-mcp-server 0.0.3 → 0.0.4

package/README.md

@@ -11,6 +11,7 @@ A Model Context Protocol (MCP) server for integrating with Slack workspaces. Thi
 - **Reply to Threads** - Continue threaded conversations
 - **Update Messages** - Edit previously posted messages
 - **React to Messages** - Add emoji reactions to messages
+- **Upload Snippets** - Upload text content as file snippets (for long content that exceeds message limits)
 
 ## Setup
 
@@ -38,6 +39,7 @@ A Model Context Protocol (MCP) server for integrating with Slack workspaces. Thi
    - `groups:history` - View messages in private channels
    - `chat:write` - Send messages
    - `reactions:write` - Add reactions
+   - `files:write` - Upload files and snippets
 5. Install the app to your workspace
 6. Copy the **Bot User OAuth Token** (starts with `xoxb-`)
 
@@ -85,12 +87,13 @@ Restart Claude Desktop and you should be ready to go!
 
 ### Write Tools
 
-| Tool                     | Description                        |
-| ------------------------ | ---------------------------------- |
-| `slack_post_message`     | Post a new message to a channel    |
-| `slack_reply_to_thread`  | Reply to an existing thread        |
-| `slack_update_message`   | Update a previously posted message |
-| `slack_react_to_message` | Add an emoji reaction to a message |
+| Tool                     | Description                                        |
+| ------------------------ | -------------------------------------------------- |
+| `slack_post_message`     | Post a new message to a channel                    |
+| `slack_reply_to_thread`  | Reply to an existing thread                        |
+| `slack_update_message`   | Update a previously posted message                 |
+| `slack_react_to_message` | Add an emoji reaction to a message                 |
+| `slack_upload_snippet`   | Upload text content as a file snippet to a channel |
 
 ## Tool Groups
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-workspace-mcp-server",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "MCP server for Slack workspace integration",
   "main": "build/index.js",
   "type": "module",

package/shared/server.d.ts

@@ -63,6 +63,15 @@ export interface ISlackClient {
      * Download a file from Slack (requires authenticated URL)
      */
     downloadFile(fileUrl: string): Promise<Buffer>;
+    /**
+     * Upload text content as a snippet/file to a channel
+     */
+    uploadSnippet(content: string, options: {
+        channelId: string;
+        filename?: string;
+        title?: string;
+        threadTs?: string;
+    }): Promise<SlackFile>;
 }
 /**
  * Slack API client implementation
@@ -103,6 +112,12 @@ export declare class SlackClient implements ISlackClient {
     addReaction(channelId: string, timestamp: string, emoji: string): Promise<void>;
     getFileInfo(fileId: string): Promise<SlackFile>;
     downloadFile(fileUrl: string): Promise<Buffer>;
+    uploadSnippet(content: string, options: {
+        channelId: string;
+        filename?: string;
+        title?: string;
+        threadTs?: string;
+    }): Promise<SlackFile>;
 }
 export type ClientFactory = () => ISlackClient;
 export interface CreateMCPServerOptions {

package/shared/server.js

@@ -49,6 +49,10 @@ export class SlackClient {
         const { downloadFile } = await import('./slack-client/lib/download-file.js');
         return downloadFile(this.headers, fileUrl);
     }
+    async uploadSnippet(content, options) {
+        const { uploadSnippet } = await import('./slack-client/lib/upload-snippet.js');
+        return uploadSnippet(this.baseUrl, this.headers, content, options);
+    }
 }
 export function createMCPServer(options) {
     const server = new Server({

package/shared/slack-client/lib/upload-snippet.d.ts

@@ -0,0 +1,14 @@
+import type { SlackFile } from '../../types.js';
+/**
+ * Uploads text content as a snippet/file to Slack using the modern
+ * files.getUploadURLExternal + files.completeUploadExternal flow.
+ *
+ * The deprecated files.upload API stopped working for new apps in May 2024
+ * and was fully retired in November 2025.
+ */
+export declare function uploadSnippet(baseUrl: string, headers: Record<string, string>, content: string, options: {
+    channelId: string;
+    filename?: string;
+    title?: string;
+    threadTs?: string;
+}): Promise<SlackFile>;

package/shared/slack-client/lib/upload-snippet.js

@@ -0,0 +1,80 @@
+/**
+ * Uploads text content as a snippet/file to Slack using the modern
+ * files.getUploadURLExternal + files.completeUploadExternal flow.
+ *
+ * The deprecated files.upload API stopped working for new apps in May 2024
+ * and was fully retired in November 2025.
+ */
+export async function uploadSnippet(baseUrl, headers, content, options) {
+    const filename = options.filename ?? 'snippet.txt';
+    const contentBuffer = Buffer.from(content, 'utf-8');
+    const length = contentBuffer.length;
+    // Step 1: Get an upload URL from Slack
+    const params = new URLSearchParams({
+        filename,
+        length: length.toString(),
+    });
+    const uploadUrlResponse = await fetch(`${baseUrl}/files.getUploadURLExternal?${params}`, {
+        method: 'GET',
+        headers,
+    });
+    if (!uploadUrlResponse.ok) {
+        throw new Error(`Failed to get upload URL: ${uploadUrlResponse.status} ${uploadUrlResponse.statusText}`);
+    }
+    const uploadUrlData = (await uploadUrlResponse.json());
+    if (!uploadUrlData.ok) {
+        throw new Error(`Slack API error (getUploadURLExternal): ${uploadUrlData.error}`);
+    }
+    if (!uploadUrlData.upload_url || !uploadUrlData.file_id) {
+        throw new Error('Missing upload_url or file_id in response');
+    }
+    // Step 2: Upload the file content to the presigned URL (no auth headers needed)
+    const uploadResponse = await fetch(uploadUrlData.upload_url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/octet-stream',
+        },
+        body: contentBuffer,
+    });
+    if (!uploadResponse.ok) {
+        throw new Error(`Failed to upload file content: ${uploadResponse.status} ${uploadResponse.statusText}`);
+    }
+    // Step 3: Complete the upload and share in channel
+    const completeBody = {
+        files: [
+            {
+                id: uploadUrlData.file_id,
+                title: options.title,
+            },
+        ],
+        channel_id: options.channelId,
+    };
+    if (options.threadTs) {
+        completeBody.thread_ts = options.threadTs;
+    }
+    const completeResponse = await fetch(`${baseUrl}/files.completeUploadExternal`, {
+        method: 'POST',
+        headers: {
+            ...headers,
+            'Content-Type': 'application/json; charset=utf-8',
+        },
+        body: JSON.stringify(completeBody),
+    });
+    if (!completeResponse.ok) {
+        throw new Error(`Failed to complete upload: ${completeResponse.status} ${completeResponse.statusText}`);
+    }
+    const completeData = (await completeResponse.json());
+    if (!completeData.ok) {
+        throw new Error(`Slack API error (completeUploadExternal): ${completeData.error}`);
+    }
+    const file = completeData.files?.[0];
+    if (!file) {
+        // Return a minimal file object using the file_id we already know
+        return {
+            id: uploadUrlData.file_id,
+            name: filename,
+            title: options.title,
+        };
+    }
+    return file;
+}

package/shared/slack-client/slack-client.integration-mock.js

@@ -114,6 +114,16 @@ export function createIntegrationMockSlackClient(mockData = {}) {
         async downloadFile() {
             return Buffer.from('mock-file-content');
         },
+        async uploadSnippet(content, options) {
+            return {
+                id: `F${Date.now()}`,
+                name: options.filename ?? 'snippet.txt',
+                title: options.title,
+                mimetype: 'text/plain',
+                size: content.length,
+                permalink: `https://slack.com/files/mock/${options.filename ?? 'snippet.txt'}`,
+            };
+        },
     };
     return client;
 }

package/shared/tools/upload-snippet.d.ts

@@ -0,0 +1,65 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { ClientFactory } from '../server.js';
+export declare const UploadSnippetSchema: z.ZodObject<{
+    channel_id: z.ZodString;
+    content: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    thread_ts: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channel_id: string;
+    content: string;
+    thread_ts?: string | undefined;
+    filename?: string | undefined;
+    title?: string | undefined;
+}, {
+    channel_id: string;
+    content: string;
+    thread_ts?: string | undefined;
+    filename?: string | undefined;
+    title?: string | undefined;
+}>;
+export declare function uploadSnippetTool(server: Server, clientFactory: ClientFactory): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            channel_id: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            filename: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: "Title displayed in Slack above the snippet.";
+            };
+            thread_ts: {
+                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/upload-snippet.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    channel_id: 'The channel ID to share the snippet in (e.g., "C1234567890"). ' +
+        'Get channel IDs using the slack_get_channels tool.',
+    content: 'The text content to upload as a snippet. Can be arbitrarily long — ' +
+        'use this instead of slack_post_message when content exceeds message length limits.',
+    filename: 'Filename for the snippet (e.g., "output.txt", "error.log", "code.py"). ' +
+        'Slack uses the file extension for syntax highlighting. Default: "snippet.txt".',
+    title: 'Title displayed in Slack above the snippet.',
+    thread_ts: 'Post the snippet as a thread reply to this message timestamp. ' +
+        'If omitted, the snippet is posted as a new message in the channel.',
+};
+export const UploadSnippetSchema = z.object({
+    channel_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.channel_id),
+    content: z.string().min(1).describe(PARAM_DESCRIPTIONS.content),
+    filename: z.string().optional().describe(PARAM_DESCRIPTIONS.filename),
+    title: z.string().optional().describe(PARAM_DESCRIPTIONS.title),
+    thread_ts: z.string().optional().describe(PARAM_DESCRIPTIONS.thread_ts),
+});
+const TOOL_DESCRIPTION = `Upload text content as a file snippet to a Slack channel.
+
+Uploads content as a text file/snippet, bypassing Slack's message length limits. Use this when content is too long for slack_post_message (e.g., long URLs, logs, code, JSON payloads).
+
+**Returns:**
+- Confirmation of the uploaded snippet
+- The file ID for reference
+
+**Use cases:**
+- Share very long URLs that exceed message length limits
+- Post error logs, stack traces, or debug output
+- Share code snippets or configuration files
+- Upload large JSON or text payloads
+
+**Note:** For short messages that fit within Slack's limits, use slack_post_message instead. Use the filename extension to control syntax highlighting (e.g., "code.py" for Python).`;
+export function uploadSnippetTool(server, clientFactory) {
+    return {
+        name: 'slack_upload_snippet',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channel_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.channel_id,
+                },
+                content: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.content,
+                },
+                filename: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.filename,
+                },
+                title: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.title,
+                },
+                thread_ts: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.thread_ts,
+                },
+            },
+            required: ['channel_id', 'content'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = UploadSnippetSchema.parse(args);
+                const client = clientFactory();
+                const file = await client.uploadSnippet(parsed.content, {
+                    channelId: parsed.channel_id,
+                    filename: parsed.filename,
+                    title: parsed.title,
+                    threadTs: parsed.thread_ts,
+                });
+                const parts = [
+                    `Snippet uploaded successfully!\n`,
+                    `Channel: ${parsed.channel_id}`,
+                    `File ID: ${file.id}`,
+                ];
+                if (file.name) {
+                    parts.push(`Filename: ${file.name}`);
+                }
+                if (file.title) {
+                    parts.push(`Title: ${file.title}`);
+                }
+                if (parsed.thread_ts) {
+                    parts.push(`Thread: ${parsed.thread_ts}`);
+                }
+                if (file.permalink) {
+                    parts.push(`Permalink: ${file.permalink}`);
+                }
+                const byteLength = Buffer.from(parsed.content, 'utf-8').length;
+                parts.push(`\nContent length: ${byteLength} bytes`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: parts.join('\n'),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error uploading snippet: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools.js

@@ -8,6 +8,7 @@ import { replyToThreadTool } from './tools/reply-to-thread.js';
 import { updateMessageTool } from './tools/update-message.js';
 import { reactToMessageTool } from './tools/react-to-message.js';
 import { downloadFileTool } from './tools/download-file.js';
+import { uploadSnippetTool } from './tools/upload-snippet.js';
 const ALL_TOOL_GROUPS = ['readonly', 'write'];
 /**
  * Parse enabled tool groups from environment variable
@@ -38,6 +39,7 @@ const ALL_TOOLS = [
     { factory: replyToThreadTool, groups: ['write'] },
     { factory: updateMessageTool, groups: ['write'] },
     { factory: reactToMessageTool, groups: ['write'] },
+    { factory: uploadSnippetTool, groups: ['write'] },
 ];
 /**
  * Creates a function to register all tools with the server