Merge pull request #52 from korotovsky/resources

Added MCP Resources

Author: korotovsky

README.md

@@ -81,6 +81,34 @@ Get list of channels
   - `limit` (number, default: 100): The maximum number of items to return. Must be an integer between 1 and 1000 (maximum 999).
   - `cursor` (string, optional): Cursor for pagination. Use the value of the last row and column in the response as next_cursor field returned from the previous request.
 
+## Resources
+
+The Slack MCP Server exposes two special directory resources for easy access to workspace metadata:
+
+### 1. `slack://<workspace>/channels` — Directory of Channels
+
+Fetches a CSV directory of all channels in the workspace, including public channels, private channels, DMs, and group DMs.
+
+- **URI:** `slack://<workspace>/channels`
+- **Format:** `text/csv`
+- **Fields:**
+  - `id`: Channel ID (e.g., `C1234567890`)
+  - `name`: Channel name (e.g., `#general`, `@username_dm`)
+  - `topic`: Channel topic (if any)
+  - `purpose`: Channel purpose/description
+  - `memberCount`: Number of members in the channel
+
+### 2. `slack://<workspace>/users` — Directory of Users
+
+Fetches a CSV directory of all users in the workspace.
+
+- **URI:** `slack://<workspace>/users`
+- **Format:** `text/csv`
+- **Fields:**
+  - `userID`: User ID (e.g., `U1234567890`)
+  - `userName`: Slack username (e.g., `john`)
+  - `realName`: User’s real name (e.g., `John Doe`)
+
 ## Setup Guide
 
 - [Authentication Setup](docs/01-authentication-setup.md)

cmd/slack-mcp-server/main.go

@@ -27,11 +27,8 @@ func main() {
 		log.Fatalf("error in SLACK_MCP_ADD_MESSAGE_TOOL: %v", err)
 	}
 
-	p := provider.New()
-
-	s := server.NewMCPServer(p,
-		transport,
-	)
+	p := provider.New(transport)
+	s := server.NewMCPServer(p)
 
 	go func() {
 		newUsersWatcher(p)()

pkg/handler/channels.go

@@ -3,11 +3,14 @@ package handler
 import (
 	"context"
 	"encoding/base64"
+	"fmt"
 	"sort"
 	"strings"
 
 	"github.com/gocarina/gocsv"
 	"github.com/korotovsky/slack-mcp-server/pkg/provider"
+	"github.com/korotovsky/slack-mcp-server/pkg/server/auth"
+	"github.com/korotovsky/slack-mcp-server/pkg/text"
 	"github.com/mark3labs/mcp-go/mcp"
 )
 
@@ -37,6 +40,53 @@ func NewChannelsHandler(apiProvider *provider.ApiProvider) *ChannelsHandler {
 	}
 }
 
+func (ch *ChannelsHandler) ChannelsResource(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
+	// mark3labs/mcp-go does not support middlewares for resources.
+	if authenticated, err := auth.IsAuthenticated(ctx, ch.apiProvider.ServerTransport()); !authenticated {
+		return nil, err
+	}
+
+	var channelList []Channel
+
+	if ready, err := ch.apiProvider.IsReady(); !ready {
+		return nil, err
+	}
+
+	_, ar, err := ch.apiProvider.ProvideGeneric()
+	if err != nil {
+		return nil, err
+	}
+
+	ws, err := text.Workspace(ar.URL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse workspace from URL: %v", err)
+	}
+
+	channels := ch.apiProvider.ProvideChannelsMaps().Channels
+	for _, channel := range channels {
+		channelList = append(channelList, Channel{
+			ID:          channel.ID,
+			Name:        channel.Name,
+			Topic:       channel.Topic,
+			Purpose:     channel.Purpose,
+			MemberCount: channel.MemberCount,
+		})
+	}
+
+	csvBytes, err := gocsv.MarshalBytes(&channelList)
+	if err != nil {
+		return nil, err
+	}
+
+	return []mcp.ResourceContents{
+		mcp.TextResourceContents{
+			URI:      "slack://" + ws + "/channels",
+			MIMEType: "text/csv",
+			Text:     string(csvBytes),
+		},
+	}, nil
+}
+
 func (ch *ChannelsHandler) ChannelsHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	if ready, err := ch.apiProvider.IsReady(); !ready {
 		return nil, err

pkg/handler/conversations.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/gocarina/gocsv"
 	"github.com/korotovsky/slack-mcp-server/pkg/provider"
+	"github.com/korotovsky/slack-mcp-server/pkg/server/auth"
 	"github.com/korotovsky/slack-mcp-server/pkg/text"
 	"github.com/mark3labs/mcp-go/mcp"
 	"github.com/slack-go/slack"
@@ -32,6 +33,12 @@ type Message struct {
 	Cursor   string `json:"cursor"`
 }
 
+type User struct {
+	UserID   string `json:"userID"`
+	UserName string `json:"userName"`
+	RealName string `json:"realName"`
+}
+
 type conversationParams struct {
 	channel  string
 	limit    int
@@ -75,13 +82,59 @@ func NewConversationsHandler(apiProvider *provider.ApiProvider) *ConversationsHa
 	}
 }
 
+func (ch *ConversationsHandler) UsersResource(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
+	// mark3labs/mcp-go does not support middlewares for resources.
+	if authenticated, err := auth.IsAuthenticated(ctx, ch.apiProvider.ServerTransport()); !authenticated {
+		return nil, err
+	}
+
+	if ready, err := ch.apiProvider.IsReady(); !ready {
+		return nil, err
+	}
+
+	_, ar, err := ch.apiProvider.ProvideGeneric()
+	if err != nil {
+		return nil, err
+	}
+
+	ws, err := text.Workspace(ar.URL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse workspace from URL: %v", err)
+	}
+
+	usersMaps := ch.apiProvider.ProvideUsersMap()
+	users := usersMaps.Users
+
+	usersList := make([]User, 0, len(users))
+	for _, user := range users {
+		usersList = append(usersList, User{
+			UserID:   user.ID,
+			UserName: user.Name,
+			RealName: user.RealName,
+		})
+	}
+
+	csvBytes, err := gocsv.MarshalBytes(&usersList)
+	if err != nil {
+		return nil, err
+	}
+
+	return []mcp.ResourceContents{
+		mcp.TextResourceContents{
+			URI:      "slack://" + ws + "/users",
+			MIMEType: "text/csv",
+			Text:     string(csvBytes),
+		},
+	}, nil
+}
+
 func (ch *ConversationsHandler) ConversationsAddMessageHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 	params, err := ch.parseParamsToolAddMessage(request)
 	if err != nil {
 		return nil, err
 	}
 
-	api, err := ch.apiProvider.ProvideGeneric()
+	api, _, err := ch.apiProvider.ProvideGeneric()
 	if err != nil {
 		return nil, err
 	}
@@ -140,7 +193,7 @@ func (ch *ConversationsHandler) ConversationsHistoryHandler(ctx context.Context,
 		return nil, err
 	}
 
-	api, err := ch.apiProvider.ProvideGeneric()
+	api, _, err := ch.apiProvider.ProvideGeneric()
 	if err != nil {
 		return nil, err
 	}
@@ -179,7 +232,7 @@ func (ch *ConversationsHandler) ConversationsRepliesHandler(ctx context.Context,
 		return nil, errors.New("thread_ts must be a string")
 	}
 
-	api, err := ch.apiProvider.ProvideGeneric()
+	api, _, err := ch.apiProvider.ProvideGeneric()
 	if err != nil {
 		return nil, err
 	}
@@ -214,7 +267,7 @@ func (ch *ConversationsHandler) ConversationsSearchHandler(ctx context.Context,
 		return nil, err
 	}
 
-	api, err := ch.apiProvider.ProvideGeneric()
+	api, _, err := ch.apiProvider.ProvideGeneric()
 	if err != nil {
 		return nil, err
 	}

pkg/provider/api.go

@@ -43,7 +43,8 @@ type ChannelsCache struct {
 }
 
 type ApiProvider struct {
-	boot func(ap *ApiProvider) *slack.Client
+	transport string
+	boot      func(ap *ApiProvider) *slack.Client
 
 	authProvider *auth.ValueAuth
 	authResponse *slack2.AuthTestResponse
@@ -73,7 +74,7 @@ type Channel struct {
 	IsPrivate   bool   `json:"private"`
 }
 
-func New() *ApiProvider {
+func New(transport string) *ApiProvider {
 	var (
 		authProvider auth.ValueAuth
 		err          error
@@ -87,7 +88,7 @@ func New() *ApiProvider {
 			panic(err)
 		}
 
-		return newWithXOXP(authProvider)
+		return newWithXOXP(transport, authProvider)
 	}
 
 	// Fall back to XOXC/XOXD tokens (session-based)
@@ -103,10 +104,10 @@ func New() *ApiProvider {
 		panic(err)
 	}
 
-	return newWithXOXC(authProvider)
+	return newWithXOXC(transport, authProvider)
 }
 
-func newWithXOXP(authProvider auth.ValueAuth) *ApiProvider {
+func newWithXOXP(transport string, authProvider auth.ValueAuth) *ApiProvider {
 	usersCache := os.Getenv("SLACK_MCP_USERS_CACHE")
 	if usersCache == "" {
 		usersCache = ".users_cache.json"
@@ -118,6 +119,7 @@ func newWithXOXP(authProvider auth.ValueAuth) *ApiProvider {
 	}
 
 	return &ApiProvider{
+		transport: transport,
 		boot: func(ap *ApiProvider) *slack.Client {
 			api := slack.New(authProvider.SlackToken())
 			res, err := api.AuthTest()
@@ -150,7 +152,7 @@ func newWithXOXP(authProvider auth.ValueAuth) *ApiProvider {
 	}
 }
 
-func newWithXOXC(authProvider auth.ValueAuth) *ApiProvider {
+func newWithXOXC(transport string, authProvider auth.ValueAuth) *ApiProvider {
 	usersCache := os.Getenv("SLACK_MCP_USERS_CACHE")
 	if usersCache == "" {
 		usersCache = ".users_cache.json"
@@ -162,6 +164,7 @@ func newWithXOXC(authProvider auth.ValueAuth) *ApiProvider {
 	}
 
 	return &ApiProvider{
+		transport: transport,
 		boot: func(ap *ApiProvider) *slack.Client {
 			api := slack.New(authProvider.SlackToken(),
 				withHTTPClientOption(authProvider.Cookies()),
@@ -201,22 +204,30 @@ func newWithXOXC(authProvider auth.ValueAuth) *ApiProvider {
 	}
 }
 
-func (ap *ApiProvider) ProvideGeneric() (*slack.Client, error) {
+func (ap *ApiProvider) ProvideGeneric() (*slack.Client, *slack2.AuthTestResponse, error) {
 	if ap.clientGeneric == nil {
 		ap.clientGeneric = ap.boot(ap)
 	}
 
-	return ap.clientGeneric, nil
+	return ap.clientGeneric, ap.authResponse, nil
 }
 
-func (ap *ApiProvider) ProvideEnterprise() (*edge.Client, error) {
+func (ap *ApiProvider) ProvideEnterprise() (*edge.Client, *slack2.AuthTestResponse, error) {
 	if ap.clientEnterprise == nil {
 		ap.clientEnterprise, _ = edge.NewWithInfo(ap.authResponse, ap.authProvider,
 			withHTTPClientEdgeOption(ap.authProvider.Cookies()),
 		)
 	}
 
-	return ap.clientEnterprise, nil
+	return ap.clientEnterprise, ap.authResponse, nil
+}
+
+func (ap *ApiProvider) AuthResponse() (*slack2.AuthTestResponse, error) {
+	if ap.authResponse == nil {
+		return nil, errors.New("not authenticated")
+	}
+
+	return ap.authResponse, nil
 }
 
 func (ap *ApiProvider) RefreshUsers(ctx context.Context) error {
@@ -237,7 +248,7 @@ func (ap *ApiProvider) RefreshUsers(ctx context.Context) error {
 
 	optionLimit := slack.GetUsersOptionLimit(1000)
 
-	client, err := ap.ProvideGeneric()
+	client, _, err := ap.ProvideGeneric()
 	if err != nil {
 		return err
 	}
@@ -324,12 +335,12 @@ func (ap *ApiProvider) GetChannels(ctx context.Context, channelTypes []string) [
 		nextcur string
 	)
 
-	clientGeneric, err := ap.ProvideGeneric()
+	clientGeneric, _, err := ap.ProvideGeneric()
 	if err != nil {
 		return nil
 	}
 
-	clientE, err := ap.ProvideEnterprise()
+	clientE, _, err := ap.ProvideEnterprise()
 	if err != nil {
 		return nil
 	}
@@ -452,6 +463,10 @@ func (ap *ApiProvider) IsReady() (bool, error) {
 	return true, nil
 }
 
+func (ap *ApiProvider) ServerTransport() string {
+	return ap.transport
+}
+
 func withHTTPClientOption(cookies []*http.Cookie) func(c *slack.Client) {
 	return func(c *slack.Client) {
 		slack.OptionHTTPClient(provideHTTPClient(cookies))(c)