yt-slack-mcp 0.2.0 → 0.3.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Maksim Korinets
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Maksim Korinets
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,27 +1,28 @@
-# yt-slack-mcp
-
-A host-agnostic [Model Context Protocol](https://modelcontextprotocol.io) server for Slack. It communicates over stdio and can be used with any MCP client that launches local servers.
-
-## Features
-
-- Read Slack channel history and thread replies.
-- 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, 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.
-
-## Tools
-
-| Tool | Description |
-|------|-------------|
-| `slack_read_permalink` | Read a message or thread from a channel, DM, or group-DM permalink, including supported attachments. |
-| `slack_get_replies` | Read replies for a thread by channel ID and timestamp. |
-| `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. |
+# yt-slack-mcp
+
+A host-agnostic [Model Context Protocol](https://modelcontextprotocol.io) server for Slack. It communicates over stdio and can be used with any MCP client that launches local servers.
+
+## Features
+
+- Read Slack channel history and thread replies.
+- 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, add a reaction, edit an authored message or thread reply, 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.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `slack_read_permalink` | Read a message or thread from a channel, DM, or group-DM permalink, including supported attachments. |
+| `slack_get_replies` | Read replies for a thread by channel ID and timestamp. |
+| `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. |
+| `slack_edit_message` | Edit an authored message or thread reply by channel ID and timestamp; replaces the message text (Slack removes any existing Block Kit blocks) and returns the updated timestamp and permalink; restricted to allowed channels. |
 
 ## Setup
 
@@ -32,16 +33,16 @@ Attachment limits: images and text files are limited to 10 MB; text attachments
 
 These may need refreshing when Slack rotates/invalidates the session.
 
-### 2. Store the secrets
+### 2. Store the secrets
 
 Save each token as a single-line file:
 
-```
-~/.config/yt-slack-mcp/secrets/slack-xoxc.txt
-~/.config/yt-slack-mcp/secrets/slack-xoxd.txt
-```
-
-The server reads these paths by default. Override them with the config file or environment variables if your MCP host manages secrets elsewhere.
+```
+~/.config/yt-slack-mcp/secrets/slack-xoxc.txt
+~/.config/yt-slack-mcp/secrets/slack-xoxd.txt
+```
+
+The server reads these paths by default. Override them with the config file or environment variables if your MCP host manages secrets elsewhere.
 
 ### 3. (Optional) Configure allowed write channels and paths
 
@@ -49,17 +50,18 @@ All configuration can live in a JSON config file at
 `~/.config/yt-slack-mcp/config.json` (override with `SLACK_MCP_CONFIG`):
 
 ```json
-{
-  "secretsDir": "~/.config/yt-slack-mcp/secrets",
-  "xoxcPath": "~/.config/yt-slack-mcp/secrets/slack-xoxc.txt",
-  "xoxdPath": "~/.config/yt-slack-mcp/secrets/slack-xoxd.txt",
+{
+  "secretsDir": "~/.config/yt-slack-mcp/secrets",
+  "xoxcPath": "~/.config/yt-slack-mcp/secrets/slack-xoxc.txt",
+  "xoxdPath": "~/.config/yt-slack-mcp/secrets/slack-xoxd.txt",
   "allowedWriteChannels": ["C0123456789", "C0987654321"],
   "userAgent": "Mozilla/5.0"
 }
 ```
 
-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
+By default the write tools (`slack_reply_to_thread`, `slack_add_reaction`,
+`slack_edit_message`) 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
@@ -68,22 +70,22 @@ Config resolution order: built-in defaults → config file → env vars.
 
 | Config file key | Env var | Default | Description |
 |-----------------|---------|---------|-------------|
-| `secretsDir` | `SLACK_MCP_SECRETS_DIR` | `~/.config/yt-slack-mcp/secrets` | Directory holding the token files |
+| `secretsDir` | `SLACK_MCP_SECRETS_DIR` | `~/.config/yt-slack-mcp/secrets` | Directory holding the token files |
 | `xoxcPath` | `SLACK_MCP_XOXC_PATH` | `$SECRETS_DIR/slack-xoxc.txt` | Path to the `xoxc` token |
 | `xoxdPath` | `SLACK_MCP_XOXD_PATH` | `$SECRETS_DIR/slack-xoxd.txt` | Path to the `xoxd` token |
 | `allowedWriteChannels` | `SLACK_MCP_ALLOWED_WRITE_CHANNELS` | *(none)* | Channel IDs allowed for write tools (comma-separated in env) |
 | `userAgent` | `SLACK_MCP_USER_AGENT` | `Mozilla/5.0` | HTTP `User-Agent` header |
 | *(config file path)* | `SLACK_MCP_CONFIG` | `~/.config/yt-slack-mcp/config.json` | Path to the JSON config file |
 
-## MCP host configuration
-
-Configure your MCP host to run `yt-slack-mcp` over stdio. The host-specific configuration varies, but the command is:
-
-```
-npx yt-slack-mcp
-```
-
-For example, Claude Desktop uses:
+## MCP host configuration
+
+Configure your MCP host to run `yt-slack-mcp` over stdio. The host-specific configuration varies, but the command is:
+
+```
+npx yt-slack-mcp
+```
+
+For example, Claude Desktop uses:
 
 ```json
 {

package/index.js

@@ -18,16 +18,16 @@ import path from "path";
 import { fileURLToPath } from "url";
 
 
-const DEFAULT_SECRETS_DIR = path.join(os.homedir(), ".config", "yt-slack-mcp", "secrets");
+const DEFAULT_SECRETS_DIR = path.join(os.homedir(), ".config", "yt-slack-mcp", "secrets");
 const DEFAULT_CONFIG_PATH = path.join(os.homedir(), ".config", "yt-slack-mcp", "config.json");
 
 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 maxUploadBytes = 10 * 1024 * 1024;
+const maxTextFileBytes = 10 * 1024 * 1024;
+const maxTextFileCharacters = 100_000;
+const maxUploadBytes = 10 * 1024 * 1024;
 
 function expandHome(filePath) {
     if (!filePath) {
@@ -111,8 +111,8 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         return data;
     };
 
-    const getSlackFileData = async (file, { refresh = false } = {}) => {
-        if (!refresh && (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 });
@@ -192,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) {
@@ -227,73 +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;
-    };
-
-    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;
-            }
-        }));
-    };
+        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) {
@@ -346,7 +346,7 @@ function createSlackClient({ xoxcToken, xoxdToken, userAgent = "Mozilla/5.0" })
         return content;
     };
 
-    return { slackApi, formatMessages, uploadSlackFiles };
+    return { slackApi, formatMessages, uploadSlackFiles };
 }
 
 function parsePermalink(url) {
@@ -393,18 +393,24 @@ 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(),
-});
+});
+
+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(),
+});
+
+const EditMessageSchema = z.object({
+    channel_id: z.string(),
+    timestamp: z.string().describe("Timestamp of the message or thread reply to edit."),
+    text: z.string(),
+});
 
 // ── Tool definitions ─────────────────────────────────────────────────────────
 
@@ -429,21 +435,26 @@ 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),
-    },
-    {
-        name: "slack_upload_files",
-        description: "Upload one or more local files to a channel or thread. Restricted to allowed channels.",
-        inputSchema: zodToJsonSchema(UploadFilesSchema),
-    },
-];
+        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),
+    },
+    {
+        name: "slack_edit_message",
+        description: "Edit an authored Slack message or thread reply by channel id and timestamp. Replaces the message text; any existing Block Kit blocks are removed by Slack. Restricted to allowed channels.",
+        inputSchema: zodToJsonSchema(EditMessageSchema),
+    },
+];
 
 // ── Execute factory (exported for tests) ─────────────────────────────────────
 
-function createExecuteToolCall({ slackApi, formatMessages, uploadSlackFiles, allowedWriteChannels }) {
+function createExecuteToolCall({ slackApi, formatMessages, uploadSlackFiles, allowedWriteChannels }) {
     const allowed = new Set(allowedWriteChannels);
     return async function executeToolCall(name, args) {
         switch (name) {
@@ -489,7 +500,7 @@ function createExecuteToolCall({ slackApi, formatMessages, uploadSlackFiles, all
                 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);
@@ -498,26 +509,62 @@ function createExecuteToolCall({ slackApi, formatMessages, uploadSlackFiles, all
                     timestamp: requireString(a.timestamp, "timestamp"),
                     name: requireString(a.reaction, "reaction"),
                 }, "POST");
-                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"}`,
-                    })),
-                };
-            }
+                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"}`,
+                    })),
+                };
+            }
+
+            case "slack_edit_message": {
+                const a = EditMessageSchema.parse(args);
+                const channelId = requireString(a.channel_id, "channel_id");
+                assertAllowedWriteChannel(channelId, allowed);
+                const timestamp = requireString(a.timestamp, "timestamp");
+                const text = requireString(a.text, "text");
+                let updated;
+                try {
+                    updated = await slackApi("chat.update", {
+                        channel: channelId,
+                        ts: timestamp,
+                        text,
+                    }, "POST");
+                } catch (error) {
+                    const reason = String(error?.message ?? error).replace(/^slack chat\.update failed: /, "");
+                    throw new Error(
+                        `could not edit message ${timestamp} in ${channelId}: ${reason}. ` +
+                            "Slack only allows editing messages authored by this account, within its edit window, and in a channel the caller can write to."
+                    );
+                }
+                const messageTs = updated.ts || timestamp;
+                let permalink;
+                try {
+                    const result = await slackApi("chat.getPermalink", {
+                        channel: channelId,
+                        message_ts: messageTs,
+                    });
+                    permalink = result.permalink;
+                } catch {
+                    permalink = undefined;
+                }
+                const lines = [`edited message ${messageTs}`];
+                if (permalink) lines.push(`permalink: ${permalink}`);
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
 
             default:
                 throw new Error(`Unknown tool: ${name}`);
@@ -545,23 +592,23 @@ async function main() {
         process.exit(1);
     }
 
-    const { slackApi, formatMessages, uploadSlackFiles } = 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, slack_upload_files (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, slack_edit_message (restricted to allowed channels).",
         }
     );
 
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 
     const executeToolCall = createExecuteToolCall({
-        slackApi,
-        formatMessages,
-        uploadSlackFiles,
+        slackApi,
+        formatMessages,
+        uploadSlackFiles,
         allowedWriteChannels: config.allowedWriteChannels,
     });
 
@@ -605,6 +652,7 @@ export {
     GetRepliesSchema,
     GetHistorySchema,
     ReplyToThreadSchema,
-    AddReactionSchema,
-    UploadFilesSchema,
-};
+    AddReactionSchema,
+    UploadFilesSchema,
+    EditMessageSchema,
+};

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "yt-slack-mcp",
-  "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",
-  "bin": {
-    "yt-slack-mcp": "index.js"
-  },
-  "scripts": {
-    "test": "node --test --experimental-test-coverage"
-  },
-  "files": [
-    "index.js"
-  ],
-  "keywords": [
-    "mcp",
-    "slack",
-    "model-context-protocol"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yentsun/slack-mcp.git"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "pdfjs-dist": "^4.0.0",
-    "zod": "^3.23.0",
-    "zod-to-json-schema": "^3.23.0"
-  }
-}
+{
+  "name": "yt-slack-mcp",
+  "version": "0.3.0",
+  "description": "MCP server for Slack — read permalinks, threads, and channel history; reply to threads; add reactions; edit messages.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "yt-slack-mcp": "index.js"
+  },
+  "scripts": {
+    "test": "node --test --experimental-test-coverage"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "mcp",
+    "slack",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yentsun/slack-mcp.git"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "pdfjs-dist": "^4.0.0",
+    "zod": "^3.23.0",
+    "zod-to-json-schema": "^3.23.0"
+  }
+}