CtrlK
BlogDocsLog inGet started
Tessl Logo

slack-realtime-events

Real-time event handling with Socket Mode and Events API. Use when building interactive Slack bots, handling message events, app mentions, reactions, button clicks, modal submissions, slash commands, or any event-driven Slack application functionality.

64

Quality

80%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Low

Low-risk findings worth noting

Fix and improve this skill with Tessl

tessl review fix ./plugins/slack-go-sdk/skills/slack-realtime-events/SKILL.md
SKILL.md
Quality
Evals
Security

Slack Real-time Events

Socket Mode vs Events API

Socket Mode (WebSocket)

Use when:

  • App runs behind a firewall
  • No public HTTPS endpoint available
  • Development and testing
  • Running on localhost
import "github.com/slack-go/slack/socketmode"

client := socketmode.New(
    api,
    socketmode.OptionDebug(true),
)

See socket-mode-setup.md for complete Socket Mode implementation.

Events API (HTTP Webhooks)

Use when:

  • Public HTTPS endpoint available
  • Production cloud deployments
  • Webhook-based architecture preferred

See events-api-webhooks.md for HTTP webhook patterns.

Socket Mode Basic Setup

api := slack.New(
    os.Getenv("SLACK_BOT_TOKEN"),
    slack.OptionAppLevelToken(os.Getenv("SLACK_APP_TOKEN")),
)

client := socketmode.New(api)

go func() {
    for envelope := range client.Events {
        switch envelope.Type {
        case socketmode.EventTypeEventsAPI:
            client.Ack(*envelope.Request)
            // Handle event
        }
    }
}()

client.Run()

Event Handling Patterns

Message Events

func handleMessageEvent(event *slackevents.MessageEvent, api *slack.Client) {
    // Ignore bot messages
    if event.BotID != "" {
        return
    }

    fmt.Printf("Message from %s in %s: %s\n", event.User, event.Channel, event.Text)

    // Respond
    api.PostMessage(event.Channel, slack.MsgOptionText("Got your message!", false))
}

App Mention Events

func handleAppMention(event *slackevents.AppMentionEvent, api *slack.Client) {
    text := strings.TrimSpace(strings.Replace(event.Text, fmt.Sprintf("<@%s>", botUserID), "", 1))

    response := processCommand(text)

    api.PostMessage(
        event.Channel,
        slack.MsgOptionText(response, false),
        slack.MsgOptionTS(event.TimeStamp), // Reply in thread
    )
}

Reaction Events

func handleReaction(event *slackevents.ReactionAddedEvent, api *slack.Client) {
    fmt.Printf("User %s added reaction :%s: to message %s\n",
        event.User, event.Reaction, event.Item.Timestamp)

    // React back
    api.AddReaction(event.Reaction, slack.ItemRef{
        Channel:   event.Item.Channel,
        Timestamp: event.Item.Timestamp,
    })
}

Interactive Components

Button Clicks

func handleButtonClick(interaction slack.InteractionCallback, api *slack.Client) {
    action := interaction.ActionCallback.BlockActions[0]

    switch action.ActionID {
    case "approve_deployment":
        // Handle approval
        updateMessage(api, interaction.Channel.ID, interaction.Message.Timestamp, "Approved!")

    case "reject_deployment":
        // Handle rejection
        updateMessage(api, interaction.Channel.ID, interaction.Message.Timestamp, "Rejected!")
    }
}

Modal Submissions

func handleModalSubmission(interaction slack.InteractionCallback, api *slack.Client) {
    values := interaction.View.State.Values

    // Extract form data
    rating := values["rating_block"]["rating_select"].SelectedOption.Value
    comments := values["comments_block"]["comments_input"].Value

    // Process submission
    fmt.Printf("Feedback: %s stars - %s\n", rating, comments)

    // Acknowledge
    api.UpdateView(slack.View{}, interaction.View.ExternalID, "", interaction.View.ID)
}

See interactive-components.md for comprehensive interactive patterns.

Slash Commands

Handle slash command invocations:

func handleSlashCommand(command slack.SlashCommand, api *slack.Client) slack.Message {
    switch command.Command {
    case "/deploy":
        return slack.Message{
            Text: fmt.Sprintf("Deploying %s to %s...", command.Text, "production"),
        }

    case "/status":
        return slack.Message{
            Text: "All systems operational",
        }

    default:
        return slack.Message{
            Text: "Unknown command",
        }
    }
}

See slash-commands.md for command patterns and delayed responses.

Event Types

Common event types to handle:

  • message - New messages in channels
  • app_mention - Bot mentioned in message
  • reaction_added/removed - Message reactions
  • channel_created/renamed - Channel lifecycle
  • team_join - New workspace members
  • user_change - User profile updates

See event-types.md for comprehensive event catalog.

Connection Management

Graceful Shutdown

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

go func() {
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
    <-sigChan
    cancel()
}()

client.RunContext(ctx)

Error Handling

for envelope := range client.Events {
    switch envelope.Type {
    case socketmode.EventTypeErrorBadMessage:
        fmt.Printf("Error: Bad message - %v\n", envelope.Request)

    case socketmode.EventTypeConnectionError:
        fmt.Printf("Connection error: %v\n", envelope.Request)
    }
}

Common Pitfalls

  • Not acknowledging events (causes timeouts)
  • Blocking in event handlers (use goroutines for long operations)
  • Missing bot vs user message filtering
  • Not handling reconnections in Socket Mode
  • Forgetting to verify request signatures in Events API
Repository
freightCognition/linehaulai-claude-marketplace
Path

plugins/slack-go-sdk/skills/slack-realtime-events/SKILL.md

Commit

88571a6

Last updated
First committed

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.

Claim skill