yt-slack-mcp 0.1.1 → 0.2.0

package/README.md

@@ -8,7 +8,7 @@ A host-agnostic [Model Context Protocol](https://modelcontextprotocol.io) server
 - Read message permalinks from channels, DMs, and group DMs.
 - Return image attachments inline, extract text from PDFs, and return `text/*` attachment contents inline.
 - Retrieve private attachment contents through the authenticated Slack browser session.
-- Reply to a thread or add a reaction only in explicitly allowed channel IDs.
+- Reply to a thread, add a reaction, or upload local files only in explicitly allowed channel IDs.
 
 Attachment limits: images and text files are limited to 10 MB; text attachments are truncated at 100,000 characters. PDFs are limited to 20 MB, 50 pages, and 100,000 extracted characters.
 
@@ -21,6 +21,7 @@ Attachment limits: images and text files are limited to 10 MB; text attachments
 | `slack_get_history` | Read recent channel history. |
 | `slack_reply_to_thread` | Reply to a thread; restricted to allowed channels. |
 | `slack_add_reaction` | Add a reaction; restricted to allowed channels. |
+| `slack_upload_files` | Upload up to 10 local files to a channel or thread, with an optional initial comment; returns file and message permalinks; restricted to allowed channels. |
 
 ## Setup
 
@@ -57,8 +58,8 @@ All configuration can live in a JSON config file at
 }
 ```
 
-By default the write tools (`slack_reply_to_thread`, `slack_add_reaction`)
-are locked down — no channel is writable. Every field is optional; a
+By default the write tools (`slack_reply_to_thread`, `slack_add_reaction`)
+and `slack_upload_files` are locked down — no channel is writable. Each upload is limited to 10 MB. Every field is optional; a
 missing file just means defaults. Env vars always override the config file.
 
 ## Configuration

package/index.js

@@ -25,8 +25,9 @@ const maxImageBytes = 10 * 1024 * 1024;
 const maxPdfBytes = 20 * 1024 * 1024;
 const maxPdfPages = 50;
 const maxPdfTextCharacters = 100_000;
-const maxTextFileBytes = 10 * 1024 * 1024;
-const maxTextFileCharacters = 100_000;
+const maxTextFileBytes = 10 * 1024 * 1024;
+const maxTextFileCharacters = 100_000;
+const maxUploadBytes = 10 * 1024 * 1024;
 
 function expandHome(filePath) {
     if (!filePath) {
@@ -110,8 +111,8 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         return data;
     };
 
-    const getSlackFileData = async (file) => {
-        if (file.url_private_download || file.url_private || !file.id) {
+    const getSlackFileData = async (file, { refresh = false } = {}) => {
+        if (!refresh && (file.url_private_download || file.url_private || !file.id)) {
             return file;
         }
         const response = await slackApi("files.info", { file: file.id });
@@ -191,7 +192,7 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         return extractPdfText(pdfData);
     };
 
-    const downloadSlackText = async (file) => {
+    const downloadSlackText = async (file) => {
         const fileData = await getSlackFileData(file);
         const textUrl = fileData.url_private_download || fileData.url_private;
         if (!textUrl) {
@@ -226,8 +227,73 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         if (text.length > maxTextFileCharacters) {
             text = `${text.slice(0, maxTextFileCharacters)}\n\n[Text file truncated at ${maxTextFileCharacters} characters]`;
         }
-        return text;
-    };
+        return text;
+    };
+
+    const uploadSlackFiles = async ({ filePaths, channelId, threadTs, initialComment }) => {
+        const localFiles = filePaths.map((filePath) => {
+            const fileStats = fs.statSync(filePath);
+            if (!fileStats.isFile()) {
+                throw new Error(`not a file: ${filePath}`);
+            }
+            if (fileStats.size > maxUploadBytes) {
+                throw new Error(`file exceeds ${maxUploadBytes / 1024 / 1024} MB limit: ${filePath}`);
+            }
+            const data = fs.readFileSync(filePath);
+            if (data.length > maxUploadBytes) {
+                throw new Error(`file exceeds ${maxUploadBytes / 1024 / 1024} MB limit: ${filePath}`);
+            }
+            return { name: path.basename(filePath), data };
+        });
+
+        const uploadedFiles = [];
+        for (const file of localFiles) {
+            const upload = await slackApi("files.getUploadURLExternal", {
+                filename: file.name,
+                length: String(file.data.length),
+            }, "POST");
+            if (!upload.upload_url || !upload.file_id) {
+                throw new Error("Slack did not provide an upload URL or file ID");
+            }
+            const response = await fetch(upload.upload_url, {
+                method: "POST",
+                headers: { "content-type": "application/octet-stream" },
+                body: file.data,
+            });
+            if (!response.ok) {
+                throw new Error(`Slack file upload failed: ${response.status}`);
+            }
+            uploadedFiles.push({ id: upload.file_id, title: file.name });
+        }
+
+        const completeParams = {
+            files: JSON.stringify(uploadedFiles),
+            channel_id: channelId,
+        };
+        if (threadTs) completeParams.thread_ts = threadTs;
+        if (initialComment) completeParams.initial_comment = initialComment;
+        const completed = await slackApi("files.completeUploadExternal", completeParams, "POST");
+        if (!completed.files?.length) {
+            throw new Error("Slack did not return uploaded file details");
+        }
+        return Promise.all(completed.files.map(async (file) => {
+            const fileData = await getSlackFileData(file, { refresh: true });
+            const shares = Object.values(fileData.shares || {});
+            const share = shares.flatMap((shareType) => shareType[channelId] || []).at(0);
+            if (!share?.ts) {
+                return fileData;
+            }
+            try {
+                const permalink = await slackApi("chat.getPermalink", {
+                    channel: channelId,
+                    message_ts: share.ts,
+                });
+                return { ...fileData, message_permalink: permalink.permalink };
+            } catch {
+                return fileData;
+            }
+        }));
+    };
 
     const formatMessages = async (messages) => {
         if (!messages.length) {
@@ -280,7 +346,7 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         return content;
     };
 
-    return { slackApi, formatMessages };
+    return { slackApi, formatMessages, uploadSlackFiles };
 }
 
 function parsePermalink(url) {
@@ -327,11 +393,18 @@ const ReplyToThreadSchema = z.object({
     text: z.string(),
 });
 
-const AddReactionSchema = z.object({
+const AddReactionSchema = z.object({
     channel_id: z.string(),
     timestamp: z.string(),
     reaction: z.string().describe("Emoji name without colons."),
-});
+});
+
+const UploadFilesSchema = z.object({
+    channel_id: z.string(),
+    file_paths: z.array(z.string().min(1)).min(1).max(10),
+    thread_ts: z.string().optional(),
+    initial_comment: z.string().optional(),
+});
 
 // ── Tool definitions ─────────────────────────────────────────────────────────
 
@@ -356,16 +429,21 @@ const TOOLS = [
         description: "Reply to a Slack thread. Restricted to allowed channels.",
         inputSchema: zodToJsonSchema(ReplyToThreadSchema),
     },
-    {
-        name: "slack_add_reaction",
+    {
+        name: "slack_add_reaction",
         description: "Add a reaction to a Slack message. Restricted to allowed channels.",
-        inputSchema: zodToJsonSchema(AddReactionSchema),
-    },
-];
+        inputSchema: zodToJsonSchema(AddReactionSchema),
+    },
+    {
+        name: "slack_upload_files",
+        description: "Upload one or more local files to a channel or thread. Restricted to allowed channels.",
+        inputSchema: zodToJsonSchema(UploadFilesSchema),
+    },
+];
 
 // ── Execute factory (exported for tests) ─────────────────────────────────────
 
-function createExecuteToolCall({ slackApi, formatMessages, allowedWriteChannels }) {
+function createExecuteToolCall({ slackApi, formatMessages, uploadSlackFiles, allowedWriteChannels }) {
     const allowed = new Set(allowedWriteChannels);
     return async function executeToolCall(name, args) {
         switch (name) {
@@ -411,7 +489,7 @@ function createExecuteToolCall({ slackApi, formatMessages, allowedWriteChannels
                 return { content: [{ type: "text", text: `posted reply at ${response.ts}` }] };
             }
 
-            case "slack_add_reaction": {
+            case "slack_add_reaction": {
                 const a = AddReactionSchema.parse(args);
                 const channelId = requireString(a.channel_id, "channel_id");
                 assertAllowedWriteChannel(channelId, allowed);
@@ -420,8 +498,26 @@ function createExecuteToolCall({ slackApi, formatMessages, allowedWriteChannels
                     timestamp: requireString(a.timestamp, "timestamp"),
                     name: requireString(a.reaction, "reaction"),
                 }, "POST");
-                return { content: [{ type: "text", text: "added reaction" }] };
-            }
+                return { content: [{ type: "text", text: "added reaction" }] };
+            }
+
+            case "slack_upload_files": {
+                const a = UploadFilesSchema.parse(args);
+                const channelId = requireString(a.channel_id, "channel_id");
+                assertAllowedWriteChannel(channelId, allowed);
+                const files = await uploadSlackFiles({
+                    filePaths: a.file_paths,
+                    channelId,
+                    threadTs: a.thread_ts && requireString(a.thread_ts, "thread_ts"),
+                    initialComment: a.initial_comment,
+                });
+                return {
+                    content: files.map((file) => ({
+                        type: "text",
+                        text: `uploaded file: ${file.title || file.name || file.id}\nfile permalink: ${file.permalink || "unavailable"}\nmessage permalink: ${file.message_permalink || "unavailable"}`,
+                    })),
+                };
+            }
 
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -449,22 +545,23 @@ async function main() {
         process.exit(1);
     }
 
-    const { slackApi, formatMessages } = createSlackClient({ xoxcToken, xoxdToken, userAgent: config.userAgent });
+    const { slackApi, formatMessages, uploadSlackFiles } = createSlackClient({ xoxcToken, xoxdToken, userAgent: config.userAgent });
 
     const server = new Server(
         { name: "yt-slack-mcp", version: "0.1.0" },
         {
             capabilities: { tools: {} },
             instructions:
-                "MCP server for Slack. Read with slack_read_permalink, slack_get_replies, slack_get_history; write with slack_reply_to_thread, slack_add_reaction (restricted to allowed channels).",
+                "MCP server for Slack. Read with slack_read_permalink, slack_get_replies, slack_get_history; write with slack_reply_to_thread, slack_add_reaction, slack_upload_files (restricted to allowed channels).",
         }
     );
 
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 
     const executeToolCall = createExecuteToolCall({
-        slackApi,
-        formatMessages,
+        slackApi,
+        formatMessages,
+        uploadSlackFiles,
         allowedWriteChannels: config.allowedWriteChannels,
     });
 
@@ -508,5 +605,6 @@ export {
     GetRepliesSchema,
     GetHistorySchema,
     ReplyToThreadSchema,
-    AddReactionSchema,
-};
+    AddReactionSchema,
+    UploadFilesSchema,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yt-slack-mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server for Slack — read permalinks, threads, and channel history; reply to threads; add reactions.",
   "type": "module",
   "main": "index.js",