@striderlabs/mcp-slack 1.0.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
+var BASE_URL = "https://slack.com/api";
+async function slackRequest(method, endpoint, params) {
+  const headers = {
+    "Content-Type": "application/json; charset=utf-8"
+  };
+  if (BOT_TOKEN) {
+    headers["Authorization"] = `Bearer ${BOT_TOKEN}`;
+  }
+  let url = `${BASE_URL}/${endpoint}`;
+  let body;
+  if (method === "GET" && params) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0) qs.set(k, String(v));
+    }
+    url += `?${qs}`;
+  } else if (method === "POST" && params) {
+    body = JSON.stringify(params);
+  }
+  const res = await fetch(url, { method, headers, body });
+  const data = await res.json();
+  if (!res.ok) {
+    throw new Error(`Slack HTTP error ${res.status}`);
+  }
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+var server = new Server(
+  { name: "mcp-slack", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "list_channels",
+      description: "List Slack channels",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max channels to return (default 100)" },
+          cursor: { type: "string", description: "Pagination cursor" },
+          types: { type: "string", description: "Channel types: public_channel, private_channel, mpim, im" },
+          exclude_archived: { type: "boolean", description: "Exclude archived channels" }
+        }
+      }
+    },
+    {
+      name: "send_message",
+      description: "Send a message to a Slack channel",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "Channel ID or name" },
+          text: { type: "string", description: "Message text" },
+          blocks: { type: "array", description: "Block Kit blocks" },
+          unfurl_links: { type: "boolean", description: "Enable link unfurling" }
+        },
+        required: ["channel", "text"]
+      }
+    },
+    {
+      name: "list_messages",
+      description: "List messages in a Slack channel",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "Channel ID" },
+          limit: { type: "number", description: "Max messages to return" },
+          cursor: { type: "string", description: "Pagination cursor" },
+          oldest: { type: "string", description: "Start of time range (Unix timestamp)" },
+          latest: { type: "string", description: "End of time range (Unix timestamp)" }
+        },
+        required: ["channel"]
+      }
+    },
+    {
+      name: "search_messages",
+      description: "Search for messages in Slack",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+          count: { type: "number", description: "Number of results per page" },
+          page: { type: "number", description: "Page number" },
+          sort: { type: "string", description: "Sort by: score or timestamp" },
+          sort_dir: { type: "string", description: "Sort direction: asc or desc" }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "list_users",
+      description: "List Slack workspace members",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max users to return" },
+          cursor: { type: "string", description: "Pagination cursor" }
+        }
+      }
+    },
+    {
+      name: "post_thread_reply",
+      description: "Post a reply to a Slack thread",
+      inputSchema: {
+        type: "object",
+        properties: {
+          channel: { type: "string", description: "Channel ID" },
+          thread_ts: { type: "string", description: "Timestamp of the parent message" },
+          text: { type: "string", description: "Reply text" },
+          blocks: { type: "array", description: "Block Kit blocks" }
+        },
+        required: ["channel", "thread_ts", "text"]
+      }
+    }
+  ]
+}));
+var ListChannelsSchema = z.object({
+  limit: z.number().optional(),
+  cursor: z.string().optional(),
+  types: z.string().optional(),
+  exclude_archived: z.boolean().optional()
+});
+var SendMessageSchema = z.object({
+  channel: z.string(),
+  text: z.string(),
+  blocks: z.array(z.unknown()).optional(),
+  unfurl_links: z.boolean().optional()
+});
+var ListMessagesSchema = z.object({
+  channel: z.string(),
+  limit: z.number().optional(),
+  cursor: z.string().optional(),
+  oldest: z.string().optional(),
+  latest: z.string().optional()
+});
+var SearchMessagesSchema = z.object({
+  query: z.string(),
+  count: z.number().optional(),
+  page: z.number().optional(),
+  sort: z.string().optional(),
+  sort_dir: z.string().optional()
+});
+var ListUsersSchema = z.object({
+  limit: z.number().optional(),
+  cursor: z.string().optional()
+});
+var PostThreadReplySchema = z.object({
+  channel: z.string(),
+  thread_ts: z.string(),
+  text: z.string(),
+  blocks: z.array(z.unknown()).optional()
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "list_channels": {
+        const params = ListChannelsSchema.parse(args);
+        const result = await slackRequest("GET", "conversations.list", {
+          limit: params.limit ?? 100,
+          cursor: params.cursor,
+          types: params.types ?? "public_channel",
+          exclude_archived: params.exclude_archived ?? true
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "send_message": {
+        const params = SendMessageSchema.parse(args);
+        const body = {
+          channel: params.channel,
+          text: params.text
+        };
+        if (params.blocks) body.blocks = params.blocks;
+        if (params.unfurl_links !== void 0) body.unfurl_links = params.unfurl_links;
+        const result = await slackRequest("POST", "chat.postMessage", body);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "list_messages": {
+        const params = ListMessagesSchema.parse(args);
+        const result = await slackRequest("GET", "conversations.history", {
+          channel: params.channel,
+          limit: params.limit ?? 100,
+          cursor: params.cursor,
+          oldest: params.oldest,
+          latest: params.latest
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "search_messages": {
+        const params = SearchMessagesSchema.parse(args);
+        const result = await slackRequest("GET", "search.messages", {
+          query: params.query,
+          count: params.count ?? 20,
+          page: params.page ?? 1,
+          sort: params.sort ?? "score",
+          sort_dir: params.sort_dir ?? "desc"
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "list_users": {
+        const params = ListUsersSchema.parse(args);
+        const result = await slackRequest("GET", "users.list", {
+          limit: params.limit ?? 100,
+          cursor: params.cursor
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "post_thread_reply": {
+        const params = PostThreadReplySchema.parse(args);
+        const body = {
+          channel: params.channel,
+          thread_ts: params.thread_ts,
+          text: params.text
+        };
+        if (params.blocks) body.blocks = params.blocks;
+        const result = await slackRequest("POST", "chat.postMessage", body);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true
+    };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@striderlabs/mcp-slack",
+  "version": "1.0.0",
+  "description": "MCP connector for Slack Web API",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mcp-slack": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --watch"
+  },
+  "files": ["dist"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "tsup": "latest",
+    "typescript": "latest",
+    "@types/node": "latest"
+  }
+}