Slack Integration Examples

import { AuthProvider } from "@leanmcp/auth";

// Validate required configuration
if (!process.env.COGNITO_USER_POOL_ID || !process.env.COGNITO_CLIENT_ID) {
  throw new Error('Missing AWS Cognito configuration');
}

// Initialize authentication provider
export const authProvider = new AuthProvider('cognito', {
  region: process.env.AWS_REGION || 'us-east-1',
  userPoolId: process.env.COGNITO_USER_POOL_ID,
  clientId: process.env.COGNITO_CLIENT_ID,
  clientSecret: process.env.COGNITO_CLIENT_SECRET
});

await authProvider.init();

import { Tool, SchemaConstraint, Authenticated } from "@leanmcp/core";
import { authProvider } from "../config.js";

class SendMessageInput {
  @SchemaConstraint({
    description: 'Slack channel ID or name',
    minLength: 1
  })
  channel!: string;

  @SchemaConstraint({
    description: 'Message text to send',
    minLength: 1
  })
  text!: string;
}

@Authenticated(authProvider)
export class SlackService {
  private slackToken: string;

  constructor() {
    this.slackToken = process.env.SLACK_BOT_TOKEN || 'simulated-token';
  }

  @Tool({ 
    description: 'Send a message to a Slack channel',
    inputClass: SendMessageInput
  })
  async sendMessage(args: SendMessageInput) {
    // Authentication is automatically enforced
    console.log(`Sending message to ${args.channel}: ${args.text}`);
    
    return {
      success: true,
      channel: args.channel,
      timestamp: Date.now().toString(),
      message: args.text
    };
  }

  @Tool({ 
    description: 'Search for messages across all channels',
    inputClass: SearchMessagesInput
  })
  async searchMessages(args: SearchMessagesInput) {
    return {
      total: 2,
      matches: [
        {
          channel: 'C1234567890',
          user: 'U1234567890',
          text: `Message containing ${args.query}`,
          timestamp: '1699999999.123456',
          permalink: 'https://workspace.slack.com/...'
        }
      ]
    };
  }
}

import 'dotenv/config';
import { createHTTPServer } from "@leanmcp/core";

await createHTTPServer({
  name: 'slack-with-auth',
  version: '1.0.0',
  port: parseInt(process.env.PORT || '3000'),
  cors: true,
  logging: true
});

import { Tool } from "@leanmcp/core";
import { Elicitation } from "@leanmcp/elicitation";

interface CreateChannelInput {
  channelName?: string;
  isPrivate?: boolean;
  description?: string;
}

export class SlackService {
  @Tool({ description: "Create a new Slack channel" })
  @Elicitation({
    title: "Create Slack Channel",
    description: "Please provide the channel details",
    fields: [
      {
        name: "channelName",
        label: "Channel Name",
        type: "text",
        required: true,
        placeholder: "e.g., team-announcements",
        validation: {
          pattern: "^[a-z0-9-]+$",
          errorMessage: "Channel name must be lowercase alphanumeric with hyphens"
        }
      },
      {
        name: "isPrivate",
        label: "Private Channel",
        type: "boolean",
        defaultValue: false,
        helpText: "Private channels are only visible to invited members"
      },
      {
        name: "description",
        label: "Channel Description",
        type: "textarea",
        required: false,
        placeholder: "What is this channel for?"
      }
    ]
  })
  async createChannel(args: CreateChannelInput) {
    return {
      success: true,
      channelId: `C${Date.now()}`,
      channelName: args.channelName,
      message: `Channel ${args.channelName} created!`
    };
  }
}

import { Tool } from '@leanmcp/core';
import { UIApp } from '@leanmcp/ui';

export class SlackService {
  @Tool({ description: 'List all Slack channels' })
  @UIApp({ component: './ChannelsList' })
  async listChannels() {
    const result = await this.client.conversations.list({
      types: 'public_channel,private_channel',
      exclude_archived: true,
      limit: 200,
    });

    const channels = result.channels?.map(ch => ({
      id: ch.id,
      name: ch.name,
      is_private: ch.is_private,
      is_member: ch.is_member,
      num_members: ch.num_members,
      topic: ch.topic?.value || '',
      purpose: ch.purpose?.value || '',
    })) || [];

    return {
      content: [{
        type: 'text' as const,
        text: JSON.stringify({ channels }, null, 2),
      }],
    };
  }

  @Tool({ description: 'Get recent messages from a channel' })
  @UIApp({ component: './MessageViewer' })
  async getMessages(input: GetMessagesInput) {
    const result = await this.client.conversations.history({
      channel: input.channel,
      limit: input.limit || 20,
    });

    const messages = await Promise.all(
      (result.messages || []).map(async msg => ({
        ts: msg.ts,
        user: msg.user,
        text: msg.text,
        thread_ts: msg.thread_ts,
        reply_count: msg.reply_count || 0,
      }))
    );

    return {
      content: [{
        type: 'text' as const,
        text: JSON.stringify({ messages }, null, 2),
      }],
    };
  }
}