Slash Command returns "bad_error_message"

[talaniz]

What happened

I'm following this tutorial for creating a Slack bot in socket mode. I've created a very basic "hello" command and reinstalled the app. However, when I run the code and attempt the command "/hello reader" per the tutorial, I get "/hello failed with the error "dispatch_failed"" instead of processing the command. I tried adding a default case to the switch statement and it returns ****** Received Event: {error_bad_message 0x1400029e5d0 <nil>}, which appears to come from the slack-go library.

Sample websocket message

socketmode: 2024/02/21 15:20:38 socket_mode_managed_conn.go:378: Received WebSocket message: {"envelope_id":"276bcbd8-cdba-48f6-95f6-6680f75728b4","payload":
{"token":"TOKEN","team_id":"T015M2ZDW58","team_domain":"DOMAIN","channel_id":"C015T89B4AY","channel_name":"general","user_id":"U015ZMBAL1X"
,"user_name":"USER.NAME","command":"\/hello","text":"reader","api_app_id":"A015T8ETJ92",
"is_enterprise_install":"false","response_url":"https:\/\/hooks.slack.com\/commands\/T015M2ZDW58\/6681237517090\/hY68y9aB79puxzLfT1id5c5f","trigger_id":"6704023023520.1191101472178.1810964e79c5559c22273228f710f5f7"},
"type":"slash_commands","accepts_response_payload":true}

Expected behavior

It looks like the code should process the command correctly.

Steps to reproduce

Follow the tutorial to create the slash command (code below).

reproducible code

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "os"
    "strings"
    "time"

    "github.com/joho/godotenv"
    "github.com/slack-go/slack"
    "github.com/slack-go/slack/slackevents"
    "github.com/slack-go/slack/socketmode"
)

func handleAppMentionEvent(event *slackevents.AppMentionEvent, client *slack.Client) error {

    user, err := client.GetUserInfo(event.User)
    if err != nil {
        return err
    }
    text := strings.ToLower(event.Text)

    attachment := slack.Attachment{}
    attachment.Fields = []slack.AttachmentField{
        {
            Title: "Date",
            Value: time.Now().String(),
        }, {
            Title: "Initializer",
            Value: user.Name,
        },
    }
    if strings.Contains(text, "hello") {
        attachment.Text = fmt.Sprintf("Hello %s", user.Name)
        attachment.Pretext = "Greetings"
        attachment.Color = "#4af030"
    } else {
        attachment.Text = fmt.Sprintf("How can I help you %s?", user.Name)
        attachment.Pretext = "How can I be of service"
        attachment.Color = "#3d3d3d"
    }
    _, _, err = client.PostMessage(event.Channel, slack.MsgOptionAttachments(attachment))
    if err != nil {
        return fmt.Errorf("failed to post message: %w", err)
    }
    return nil
}

func handleHelloCommand(command slack.SlashCommand, client *slack.Client) error {
    attachment := slack.Attachment{}
    attachment.Fields = []slack.AttachmentField{
        {
            Title: "Date",
            Value: time.Now().String(),
        }, {
            Title: "Initializer",
            Value: command.UserName,
        },
    }
    attachment.Text = fmt.Sprintf("Hello %s", command.Text)
    attachment.Color = "#4af030"

    _, _, err := client.PostMessage(command.ChannelID, slack.MsgOptionAttachments(attachment))
    if err != nil {
        return fmt.Errorf("failed to post message: %w", err)
    }
    return nil
}

// handleSlashCommand handles slash commands by routing them to the appropriate function
func handleSlashCommand(command slack.SlashCommand, client *slack.Client) error {
    log.Println("Received slash command", command)
    switch command.Command {
    case "/hello":
        return handleHelloCommand(command, client)
    }
    return nil
}

// handleEventMessage will take an event and handle itproperly based on the event type
func handleEventMessage(event slackevents.EventsAPIEvent, client *slack.Client) error {
    switch event.Type {

    case slackevents.CallbackEvent:
        innerEvent := event.InnerEvent
        switch ev := innerEvent.Data.(type) {
        case *slackevents.AppMentionEvent:
            err := handleAppMentionEvent(ev, client)
            if err != nil {
                return err
            }
        }
    default:
        return errors.New("unsupported event type")
    }
    return nil
}

func main() {
    godotenv.Load(".env")

    token := os.Getenv("SLACK_BOT_TOKEN")
    appToken := os.Getenv("SLACK_APP_TOKEN")

    client := slack.New(token, slack.OptionDebug(true), slack.OptionAppLevelToken(appToken))
    sockentClient := socketmode.New(
        client,
        socketmode.OptionDebug(true),
        socketmode.OptionLog(log.New(os.Stdout, "socketmode: ", log.Lshortfile|log.LstdFlags)),
    )

    // Implement a graceful shutdown here
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go func(ctx context.Context, client *slack.Client, socketClient *socketmode.Client) {
        for {
            select {
            case <-ctx.Done():
                log.Println("Shutting down socketmode listener")
                return
            case event := <-socketClient.Events:
                switch event.Type {
                // Slack events
                case socketmode.EventTypeEventsAPI:
                    eventsApiEvent, ok := event.Data.(slackevents.EventsAPIEvent)
                    if !ok {
                        log.Printf("Could not type case the event to the EventsAPIEvent: %v\n", event)
                        continue
                    }
                    log.Println("Received API event: ", event.Type)
                    socketClient.Ack(*event.Request)
                    err := handleEventMessage(eventsApiEvent, client)
                    if err != nil {
                        log.Fatal(err)
                    }
                // Slash command
                case socketmode.EventTypeSlashCommand:
                    command, ok := event.Data.(slack.SlashCommand)
                    if !ok {
                        log.Printf("Could not type case the message to a SlashCommand: %v\n", command)
                        continue
                    }
                    log.Println("Received slash event: ", command)
                    socketClient.Ack(*event.Request)
                    err := handleSlashCommand(command, client)
                    if err != nil {
                        log.Fatal(err)
                    }
                default:
                    log.Println("****** Received Event: ", event)
                }
            }
        }
    }(ctx, client, sockentClient)
    sockentClient.Run()
}

manifest.yaml

Versions

• Go: 1.21.0
• slack-go/slack: v.0.12.4

[rohithkakarla30]

It worked for me if i change the value of struct SlashCommand to

type SlashCommand struct {
    Token               string `json:"token"`
    TeamID              string `json:"team_id"`
    TeamDomain          string `json:"team_domain"`
    EnterpriseID        string `json:"enterprise_id,omitempty"`
    EnterpriseName      string `json:"enterprise_name,omitempty"`
    IsEnterpriseInstall bool   `json:"is_enterprise_install,string"`
    ChannelID           string `json:"channel_id"`
    ChannelName         string `json:"channel_name"`
    UserID              string `json:"user_id"`
    UserName            string `json:"user_name"`
    Command             string `json:"command"`
    Text                string `json:"text"`
    ResponseURL         string `json:"response_url"`
    TriggerID           string `json:"trigger_id"`
    APIAppID            string `json:"api_app_id"`
}

Which should not be the case. but not sure. Changed value IsEnterpriseInstall bool json:"is_enterprise_install" -> IsEnterpriseInstall bool json:"is_enterprise_install,string" Reference to line https://github.com/slack-go/slack/blob/v0.12.4/slash.go#L14

[nvjustdev]

Happened to me too

[SeniorPomidorro]

Same problem, rollback to v.0.12.3 is helped

slack-go/slack: v.0.12.4 go1.21.5 darwin/arm64

Event Data:

{parsing slash command: json: cannot unmarshal string into Go struct field SlashCommand.is_enterprise_install of type bool {"envelope_id":"XXXXX","payload":{"token":"XXXXX","team_id":"XXXXX","team_domain":"XXXX","channel_id":"XXXX","channel_name":"lolkek","user_id":"U0XXXXX","user_name":"XXXXX","command":"\/pollsettings","text":"","api_app_id":"XXXXX","is_enterprise_install":"false","response_url":"https:\/\/hooks.slack.com\/commands\/XXXXX\/XXXXXX\/XXXXXX","trigger_id":"XXXXXXX"},"type":"slash_commands","accepts_response_payload":true}}

Code sample:

func (s *Service) eventRouter(ctx context.Context, e socketmode.Event) error {

switch e.Type {
case socketmode.EventTypeSlashCommand:
    s.slack.Ack(e.Request)
    e := e.Data.(slack.SlashCommand)

    switch e.Command {
    case "/test":
        return s.poll.CreateModalView(ctx, &e)
    case "/pollsettings":
        return s.poll.CreatePollSettingsModal(ctx, &e)
    case "/pepefast":
        return s.poll.CreateFast(ctx, &e)
    }

case socketmode.EventTypeInteractive:
    s.slack.Ack(e.Request)
    e := e.Data.(slack.InteractionCallback)

    switch {
    case e.Type == slack.InteractionTypeViewSubmission && (e.View.CallbackID == "poll_modal_view" || e.View.CallbackID == "settings_modal_view"),
        e.Type == slack.InteractionTypeBlockActions && e.View.CallbackID == "settings_modal_view",
        e.Type == slack.InteractionTypeInteractionMessage && strings.Contains(e.CallbackID, "poll"):
        return s.poll.Interactions(ctx, &e)

    }
case socketmode.EventTypeErrorBadMessage:
    fmt.Printf("%s", e.Data)
default:
    if e.Type != "connecting" && e.Type != "connected" && e.Type != "hello" {
        return errors.New(fmt.Sprintf("UNKNOW EVENT TYPE %s", e.Type))
    }
}

return nil

}

[parsley42]

Sorry about that; probably a straight-forward fix, somebody care to work up a PR? I added a comment to the PR where this was introduced.

[talaniz]

Looks like there's one in that already addresses the comments on the original commit https://github.com/slack-go/slack/pull/1266

[parsley42]

Just published v0.12.5 which deals w/ bool or string. Thanks to @kpaulisse.

[talaniz]

I've tested in v0.12.5, looks like all is working. Thanks everyone!