slack-workspace-mcp-server 0.0.2 → 0.0.3

package/package.json

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

package/shared/server.d.ts

@@ -1,5 +1,5 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import type { Channel, Message } from './types.js';
+import type { Channel, Message, SlackFile } from './types.js';
 /**
  * Slack API client interface
  * Defines all methods for interacting with the Slack Web API
@@ -55,6 +55,14 @@ export interface ISlackClient {
      * Add a reaction to a message
      */
     addReaction(channelId: string, timestamp: string, emoji: string): Promise<void>;
+    /**
+     * Get file metadata from Slack
+     */
+    getFileInfo(fileId: string): Promise<SlackFile>;
+    /**
+     * Download a file from Slack (requires authenticated URL)
+     */
+    downloadFile(fileUrl: string): Promise<Buffer>;
 }
 /**
  * Slack API client implementation
@@ -93,6 +101,8 @@ export declare class SlackClient implements ISlackClient {
     }): Promise<Message>;
     updateMessage(channelId: string, ts: string, text: string): Promise<Message>;
     addReaction(channelId: string, timestamp: string, emoji: string): Promise<void>;
+    getFileInfo(fileId: string): Promise<SlackFile>;
+    downloadFile(fileUrl: string): Promise<Buffer>;
 }
 export type ClientFactory = () => ISlackClient;
 export interface CreateMCPServerOptions {

package/shared/server.js

@@ -41,6 +41,14 @@ export class SlackClient {
         const { addReaction } = await import('./slack-client/lib/add-reaction.js');
         return addReaction(this.baseUrl, this.headers, channelId, timestamp, emoji);
     }
+    async getFileInfo(fileId) {
+        const { getFileInfo } = await import('./slack-client/lib/get-file-info.js');
+        return getFileInfo(this.baseUrl, this.headers, fileId);
+    }
+    async downloadFile(fileUrl) {
+        const { downloadFile } = await import('./slack-client/lib/download-file.js');
+        return downloadFile(this.headers, fileUrl);
+    }
 }
 export function createMCPServer(options) {
     const server = new Server({

package/shared/slack-client/lib/download-file.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Downloads a file from Slack using an authenticated URL.
+ * Slack's url_private requires the bot token in the Authorization header.
+ */
+export declare function downloadFile(headers: Record<string, string>, fileUrl: string): Promise<Buffer>;

package/shared/slack-client/lib/download-file.js

@@ -0,0 +1,15 @@
+/**
+ * Downloads a file from Slack using an authenticated URL.
+ * Slack's url_private requires the bot token in the Authorization header.
+ */
+export async function downloadFile(headers, fileUrl) {
+    const response = await fetch(fileUrl, {
+        method: 'GET',
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}

package/shared/slack-client/lib/get-file-info.d.ts

@@ -0,0 +1,5 @@
+import type { SlackFile } from '../../types.js';
+/**
+ * Fetches information about a specific file using Slack's files.info API
+ */
+export declare function getFileInfo(baseUrl: string, headers: Record<string, string>, fileId: string): Promise<SlackFile>;

package/shared/slack-client/lib/get-file-info.js

@@ -0,0 +1,23 @@
+/**
+ * Fetches information about a specific file using Slack's files.info API
+ */
+export async function getFileInfo(baseUrl, headers, fileId) {
+    const params = new URLSearchParams({
+        file: fileId,
+    });
+    const response = await fetch(`${baseUrl}/files.info?${params}`, {
+        method: 'GET',
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch file info: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    if (!data.ok) {
+        throw new Error(`Slack API error: ${data.error}`);
+    }
+    if (!data.file) {
+        throw new Error('File not found in response');
+    }
+    return data.file;
+}

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

@@ -101,6 +101,19 @@ export function createIntegrationMockSlackClient(mockData = {}) {
         async addReaction() {
             // No-op for mock
         },
+        async getFileInfo(fileId) {
+            return {
+                id: fileId,
+                name: `mock-file-${fileId}.txt`,
+                mimetype: 'text/plain',
+                size: 1024,
+                url_private: `https://files.slack.com/files-pri/mock/${fileId}`,
+                url_private_download: `https://files.slack.com/files-pri/mock/${fileId}/download`,
+            };
+        },
+        async downloadFile() {
+            return Buffer.from('mock-file-content');
+        },
     };
     return client;
 }

package/shared/tools/download-file.d.ts

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

package/shared/tools/download-file.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+const PARAM_DESCRIPTIONS = {
+    file_id: 'The Slack file ID (e.g., "F1234567890"). ' +
+        'File IDs are shown in message outputs next to uploaded files.',
+};
+export const DownloadFileSchema = z.object({
+    file_id: z.string().min(1).describe(PARAM_DESCRIPTIONS.file_id),
+});
+const TOOL_DESCRIPTION = `Download a file from Slack to a local temporary path.
+
+Slack files require authentication to access, so this tool handles the download using the bot token. It saves the file to a temporary directory and returns the local file path.
+
+**Returns:**
+- Local file path (file:// URI) where the downloaded file was saved
+- File metadata: name, type, size
+
+**Use cases:**
+- Download images shared in Slack to view them
+- Download documents, PDFs, or other files shared in channels
+- Access any file attachment from a Slack message
+
+**Note:** File IDs (e.g., "F1234567890") are shown in message outputs from slack_get_channel and slack_get_thread.`;
+export function downloadFileTool(server, clientFactory) {
+    return {
+        name: 'slack_download_file',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.file_id,
+                },
+            },
+            required: ['file_id'],
+        },
+        handler: async (args) => {
+            try {
+                const parsed = DownloadFileSchema.parse(args);
+                const client = clientFactory();
+                // Get file metadata
+                const fileInfo = await client.getFileInfo(parsed.file_id);
+                const downloadUrl = fileInfo.url_private_download || fileInfo.url_private;
+                if (!downloadUrl) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `File ${parsed.file_id} has no downloadable URL. It may have been deleted or is not accessible.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Download the file
+                const fileBuffer = await client.downloadFile(downloadUrl);
+                // Write to temp directory
+                const slackTmpDir = join(tmpdir(), 'slack-files');
+                await mkdir(slackTmpDir, { recursive: true });
+                const fileName = fileInfo.name || fileInfo.title || parsed.file_id;
+                const safeName = fileName.replace(/[^a-zA-Z0-9._-]/g, '_');
+                const localPath = join(slackTmpDir, `${parsed.file_id}-${safeName}`);
+                await writeFile(localPath, fileBuffer);
+                const sizeParts = [];
+                if (fileInfo.mimetype)
+                    sizeParts.push(fileInfo.mimetype);
+                if (fileInfo.size)
+                    sizeParts.push(formatFileSize(fileInfo.size));
+                let output = `File downloaded successfully.\n`;
+                output += `Name: ${fileName}\n`;
+                if (sizeParts.length > 0)
+                    output += `Type: ${sizeParts.join(', ')}\n`;
+                output += `Path: file://${localPath}\n`;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: output,
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error downloading file: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/shared/tools/format-message-extras.js

@@ -51,13 +51,8 @@ export function formatMessageExtras(msg) {
             if (file.size) {
                 parts.push(formatFileSize(file.size));
             }
-            if (file.permalink) {
-                parts.push(`Link: ${file.permalink}`);
-            }
-            else if (file.url_private) {
-                parts.push(`Link: ${file.url_private}`);
-            }
-            output += `  📄 File: ${parts.join(' | ')}\n`;
+            parts.push(`id: ${file.id}`);
+            output += `  📄 File: ${parts.join(' | ')} — use slack_download_file to download\n`;
         }
     }
     return output;

package/shared/tools.js

@@ -7,6 +7,7 @@ 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';
+import { downloadFileTool } from './tools/download-file.js';
 const ALL_TOOL_GROUPS = ['readonly', 'write'];
 /**
  * Parse enabled tool groups from environment variable
@@ -31,6 +32,7 @@ const ALL_TOOLS = [
     { factory: getChannelsTool, groups: ['readonly', 'write'] },
     { factory: getChannelTool, groups: ['readonly', 'write'] },
     { factory: getThreadTool, groups: ['readonly', 'write'] },
+    { factory: downloadFileTool, groups: ['readonly', 'write'] },
     // Write tools
     { factory: postMessageTool, groups: ['write'] },
     { factory: replyToThreadTool, groups: ['write'] },