@jtalk22/slack-mcp 1.0.0

package/src/server.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Slack MCP Server
+ *
+ * A Model Context Protocol server for Slack integration.
+ * Provides read/write access to Slack messages, channels, and users.
+ *
+ * @version 1.0.0
+ */
+
+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 { loadTokens } from "../lib/token-store.js";
+import { TOOLS } from "../lib/tools.js";
+import {
+  handleHealthCheck,
+  handleRefreshTokens,
+  handleListConversations,
+  handleConversationsHistory,
+  handleGetFullConversation,
+  handleSearchMessages,
+  handleUsersInfo,
+  handleSendMessage,
+  handleGetThread,
+  handleListUsers,
+} from "../lib/handlers.js";
+
+// Package info
+const SERVER_NAME = "slack-mcp-server";
+const SERVER_VERSION = "1.0.0";
+
+// Initialize server
+const server = new Server(
+  { name: SERVER_NAME, version: SERVER_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+// Register tool list handler
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOLS
+}));
+
+// Register tool call handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "slack_health_check":
+        return await handleHealthCheck();
+
+      case "slack_refresh_tokens":
+        return await handleRefreshTokens();
+
+      case "slack_list_conversations":
+        return await handleListConversations(args);
+
+      case "slack_conversations_history":
+        return await handleConversationsHistory(args);
+
+      case "slack_get_full_conversation":
+        return await handleGetFullConversation(args);
+
+      case "slack_search_messages":
+        return await handleSearchMessages(args);
+
+      case "slack_users_info":
+        return await handleUsersInfo(args);
+
+      case "slack_send_message":
+        return await handleSendMessage(args);
+
+      case "slack_get_thread":
+        return await handleGetThread(args);
+
+      case "slack_list_users":
+        return await handleListUsers(args);
+
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error.message}` }],
+      isError: true
+    };
+  }
+});
+
+// Main entry point
+async function main() {
+  // Check for credentials at startup
+  const credentials = loadTokens();
+  if (!credentials) {
+    console.error("WARNING: No Slack credentials found at startup");
+    console.error("Will attempt Chrome auto-extraction on first API call");
+  } else {
+    console.error(`Credentials loaded from: ${credentials.source}`);
+  }
+
+  // Start server
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`${SERVER_NAME} v${SERVER_VERSION} running`);
+}
+
+main().catch(error => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/src/web-server.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * Slack Web API Server
+ *
+ * Exposes Slack MCP tools as REST endpoints for browser access.
+ * Run alongside or instead of the MCP server for web-based access.
+ *
+ * @version 1.0.0
+ */
+
+import express from "express";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { loadTokens } from "../lib/token-store.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+import {
+  handleHealthCheck,
+  handleRefreshTokens,
+  handleListConversations,
+  handleConversationsHistory,
+  handleGetFullConversation,
+  handleSearchMessages,
+  handleUsersInfo,
+  handleSendMessage,
+  handleGetThread,
+  handleListUsers,
+} from "../lib/handlers.js";
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Default API key for convenience - override with SLACK_API_KEY env var for production
+const DEFAULT_API_KEY = "slack-mcp-local";
+const API_KEY = process.env.SLACK_API_KEY || DEFAULT_API_KEY;
+
+// Middleware
+app.use(express.json());
+app.use(express.static(join(__dirname, "../public")));
+
+// CORS for local development
+app.use((req, res, next) => {
+  res.header("Access-Control-Allow-Origin", "*");
+  res.header("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  if (req.method === "OPTIONS") {
+    return res.sendStatus(200);
+  }
+  next();
+});
+
+// API Key authentication
+function authenticate(req, res, next) {
+  const authHeader = req.headers.authorization;
+  const providedKey = authHeader?.replace("Bearer ", "");
+
+  if (providedKey !== API_KEY) {
+    return res.status(401).json({ error: "Invalid API key" });
+  }
+  next();
+}
+
+// Helper to extract response content
+function extractContent(result) {
+  if (result.content && result.content[0] && result.content[0].text) {
+    try {
+      return JSON.parse(result.content[0].text);
+    } catch {
+      return { text: result.content[0].text };
+    }
+  }
+  return result;
+}
+
+// Root endpoint (no auth required)
+app.get("/", (req, res) => {
+  res.json({
+    name: "Slack Web API Server",
+    version: "1.0.0",
+    status: "running",
+    endpoints: [
+      "GET  /health",
+      "POST /refresh",
+      "GET  /conversations",
+      "GET  /conversations/:id/history",
+      "GET  /conversations/:id/full",
+      "GET  /conversations/:id/thread/:ts",
+      "GET  /search",
+      "POST /messages",
+      "GET  /users",
+      "GET  /users/:id",
+    ],
+    docs: "Add Authorization: Bearer <api-key> header to all requests"
+  });
+});
+
+// Health check
+app.get("/health", authenticate, async (req, res) => {
+  try {
+    const result = await handleHealthCheck();
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Refresh tokens
+app.post("/refresh", authenticate, async (req, res) => {
+  try {
+    const result = await handleRefreshTokens();
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// List conversations
+app.get("/conversations", authenticate, async (req, res) => {
+  try {
+    const result = await handleListConversations({
+      types: req.query.types || "im,mpim",
+      limit: parseInt(req.query.limit) || 100
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Get conversation history
+app.get("/conversations/:id/history", authenticate, async (req, res) => {
+  try {
+    const result = await handleConversationsHistory({
+      channel_id: req.params.id,
+      limit: parseInt(req.query.limit) || 50,
+      oldest: req.query.oldest,
+      latest: req.query.latest,
+      resolve_users: req.query.resolve_users !== "false"
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Get full conversation with threads
+app.get("/conversations/:id/full", authenticate, async (req, res) => {
+  try {
+    const result = await handleGetFullConversation({
+      channel_id: req.params.id,
+      oldest: req.query.oldest,
+      latest: req.query.latest,
+      max_messages: parseInt(req.query.max_messages) || 2000,
+      include_threads: req.query.include_threads !== "false",
+      output_file: req.query.output_file
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Get thread
+app.get("/conversations/:id/thread/:ts", authenticate, async (req, res) => {
+  try {
+    const result = await handleGetThread({
+      channel_id: req.params.id,
+      thread_ts: req.params.ts
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Search messages
+app.get("/search", authenticate, async (req, res) => {
+  try {
+    if (!req.query.q) {
+      return res.status(400).json({ error: "Query parameter 'q' is required" });
+    }
+    const result = await handleSearchMessages({
+      query: req.query.q,
+      count: parseInt(req.query.count) || 20
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Send message
+app.post("/messages", authenticate, async (req, res) => {
+  try {
+    if (!req.body.channel_id || !req.body.text) {
+      return res.status(400).json({ error: "channel_id and text are required" });
+    }
+    const result = await handleSendMessage({
+      channel_id: req.body.channel_id,
+      text: req.body.text,
+      thread_ts: req.body.thread_ts
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// List users
+app.get("/users", authenticate, async (req, res) => {
+  try {
+    const result = await handleListUsers({
+      limit: parseInt(req.query.limit) || 100
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Get user info
+app.get("/users/:id", authenticate, async (req, res) => {
+  try {
+    const result = await handleUsersInfo({
+      user_id: req.params.id
+    });
+    res.json(extractContent(result));
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Start server
+async function main() {
+  // Check for credentials
+  const credentials = loadTokens();
+  if (!credentials) {
+    console.error("WARNING: No Slack credentials found");
+    console.error("Run: npm run tokens:auto");
+  } else {
+    console.log(`Credentials loaded from: ${credentials.source}`);
+  }
+
+  app.listen(PORT, () => {
+    console.log(`\n🚀 Slack Web API Server running at http://localhost:${PORT}`);
+    console.log(`\n🔑 API Key: ${API_KEY}`);
+    console.log(`\nExample usage:`);
+    console.log(`  curl -H "Authorization: Bearer ${API_KEY}" http://localhost:${PORT}/health`);
+    console.log(`  curl -H "Authorization: Bearer ${API_KEY}" http://localhost:${PORT}/conversations`);
+  });
+}
+
+main().catch(e => {
+  console.error("Fatal error:", e);
+  process.exit(1);
+});