Pular para o conteúdo principal

​
Slack

Status: pronto para produção para DMs + canais por meio de integrações de apps do Slack. O modo padrão é Socket Mode; URLs de solicitação HTTP também são compatíveis.

Pareamento

As DMs do Slack usam o modo de pareamento por padrão.

Comandos de barra

Comportamento nativo de comandos e catálogo de comandos.

Solução de problemas de canal

Diagnósticos entre canais e guias de correção.

​
Configuração rápida

1

Criar um novo app do Slack

Nas configurações do app do Slack, pressione o botão Create New App:
  • escolha from a manifest e selecione um workspace para seu app
  • cole o manifesto de exemplo abaixo e continue para criar
  • gere um App-Level Token (xapp-...) com connections:write
  • instale o app e copie o Bot Token (xoxb-...) exibido
2

Configurar o OpenClaw

{
  channels: {
    slack: {
      enabled: true,
      mode: "socket",
      appToken: "xapp-...",
      botToken: "xoxb-...",
    },
  },
}
Fallback por variável de ambiente (somente conta padrão):
SLACK_APP_TOKEN=xapp-...
SLACK_BOT_TOKEN=xoxb-...
3

Iniciar o gateway

openclaw gateway

​
Lista de verificação de manifesto e escopos

{
  "display_information": {
    "name": "OpenClaw",
    "description": "Slack connector for OpenClaw"
  },
  "features": {
    "bot_user": {
      "display_name": "OpenClaw",
      "always_online": true
    },
    "app_home": {
      "messages_tab_enabled": true,
      "messages_tab_read_only_enabled": false
    },
    "slash_commands": [
      {
        "command": "/openclaw",
        "description": "Send a message to OpenClaw",
        "should_escape": false
      }
    ]
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "app_mentions:read",
        "assistant:write",
        "channels:history",
        "channels:read",
        "chat:write",
        "commands",
        "emoji:read",
        "files:read",
        "files:write",
        "groups:history",
        "groups:read",
        "im:history",
        "im:read",
        "im:write",
        "mpim:history",
        "mpim:read",
        "mpim:write",
        "pins:read",
        "pins:write",
        "reactions:read",
        "reactions:write",
        "users:read"
      ]
    }
  },
  "settings": {
    "socket_mode_enabled": true,
    "event_subscriptions": {
      "bot_events": [
        "app_mention",
        "channel_rename",
        "member_joined_channel",
        "member_left_channel",
        "message.channels",
        "message.groups",
        "message.im",
        "message.mpim",
        "pin_added",
        "pin_removed",
        "reaction_added",
        "reaction_removed"
      ]
    }
  }
}
Adicione o escopo de bot chat:write.customize se quiser que as mensagens de saída usem a identidade do agente ativo (nome de usuário e ícone personalizados) em vez da identidade padrão do app do Slack.Se você usar um ícone de emoji, o Slack espera a sintaxe :emoji_name:.
Se você configurar channels.slack.userToken, os escopos típicos de leitura são:
  • channels:history, groups:history, im:history, mpim:history
  • channels:read, groups:read, im:read, mpim:read
  • users:read
  • reactions:read
  • pins:read
  • emoji:read
  • search:read (se você depende de leituras da busca do Slack)

​
Modelo de token

  • botToken + appToken são obrigatórios para Socket Mode.
  • O modo HTTP exige botToken + signingSecret.
  • botToken, appToken, signingSecret e userToken aceitam strings em texto simples ou objetos SecretRef.
  • Tokens na configuração substituem o fallback por variável de ambiente.
  • O fallback por variável de ambiente SLACK_BOT_TOKEN / SLACK_APP_TOKEN se aplica apenas à conta padrão.
  • userToken (xoxp-...) é somente de configuração (sem fallback por variável de ambiente) e assume por padrão comportamento somente leitura (userTokenReadOnly: true).
Comportamento do snapshot de status:
  • A inspeção da conta do Slack rastreia campos *Source e *Status por credencial (botToken, appToken, signingSecret, userToken).
  • O status é available, configured_unavailable ou missing.
  • configured_unavailable significa que a conta está configurada por SecretRef ou outra fonte secreta não inline, mas o caminho atual de comando/runtime não conseguiu resolver o valor real.
  • No modo HTTP, signingSecretStatus é incluído; em Socket Mode, o par obrigatório é botTokenStatus + appTokenStatus.
Para ações/leituras de diretório, o token de usuário pode ser priorizado quando configurado. Para escritas, o token de bot continua sendo o preferido; escritas com token de usuário só são permitidas quando userTokenReadOnly: false e o token de bot não está disponível.

​
Ações e controles

As ações do Slack são controladas por channels.slack.actions.*. Grupos de ações disponíveis nas ferramentas atuais do Slack:
GrupoPadrão
messagesativado
reactionsativado
pinsativado
memberInfoativado
emojiListativado
As ações atuais de mensagem do Slack incluem send, upload-file, download-file, read, edit, delete, pin, unpin, list-pins, member-info e emoji-list.

​
Controle de acesso e roteamento

channels.slack.dmPolicy controla o acesso a DMs (legado: channels.slack.dm.policy):
  • pairing (padrão)
  • allowlist
  • open (exige que channels.slack.allowFrom inclua "*"; legado: channels.slack.dm.allowFrom)
  • disabled
Sinalizadores de DM:
  • dm.enabled (padrão true)
  • channels.slack.allowFrom (preferido)
  • dm.allowFrom (legado)
  • dm.groupEnabled (DMs em grupo têm padrão false)
  • dm.groupChannels (lista de permissões opcional para MPIM)
Precedência de várias contas:
  • channels.slack.accounts.default.allowFrom aplica-se apenas à conta default.
  • Contas nomeadas herdam channels.slack.allowFrom quando seu próprio allowFrom não está definido.
  • Contas nomeadas não herdam channels.slack.accounts.default.allowFrom.
O pareamento em DMs usa openclaw pairing approve slack <code>.

​
Threads, sessões e tags de resposta

  • DMs são roteadas como direct; canais como channel; MPIMs como group.
  • Com o padrão session.dmScope=main, as DMs do Slack são consolidadas na sessão principal do agente.
  • Sessões de canal: agent:<agentId>:slack:channel:<channelId>.
  • Respostas em thread podem criar sufixos de sessão de thread (:thread:<threadTs>) quando aplicável.
  • O padrão de channels.slack.thread.historyScope é thread; o padrão de thread.inheritParent é false.
  • channels.slack.thread.initialHistoryLimit controla quantas mensagens existentes da thread são buscadas quando uma nova sessão de thread começa (padrão 20; defina 0 para desativar).
  • channels.slack.thread.requireExplicitMention (padrão false): quando true, suprime menções implícitas em thread para que o bot responda apenas a menções explícitas @bot dentro de threads, mesmo quando o bot já participou da thread. Sem isso, respostas em uma thread com participação do bot ignoram o controle de requireMention.
Controles de encadeamento de respostas:
  • channels.slack.replyToMode: off|first|all|batched (padrão off)
  • channels.slack.replyToModeByChatType: por direct|group|channel
  • fallback legado para chats diretos: channels.slack.dm.replyToMode
Tags manuais de resposta são compatíveis:
  • [[reply_to_current]]
  • [[reply_to:<id>]]
Observação: replyToMode="off" desativa todo o encadeamento de respostas no Slack, incluindo tags explícitas [[reply_to_*]]. Isso difere do Telegram, onde tags explícitas ainda são respeitadas no modo "off". A diferença reflete os modelos de thread da plataforma: as threads do Slack ocultam mensagens do canal, enquanto as respostas do Telegram permanecem visíveis no fluxo principal do chat.

​
Reações de confirmação

ackReaction envia um emoji de confirmação enquanto o OpenClaw está processando uma mensagem de entrada. Ordem de resolução:
  • channels.slack.accounts.<accountId>.ackReaction
  • channels.slack.ackReaction
  • messages.ackReaction
  • fallback para emoji da identidade do agente (agents.list[].identity.emoji, senão ”👀”)
Observações:
  • O Slack espera shortcodes (por exemplo, "eyes").
  • Use "" para desativar a reação para a conta do Slack ou globalmente.

​
Streaming de texto

channels.slack.streaming controla o comportamento de prévia ao vivo:
  • off: desativa o streaming de prévia ao vivo.
  • partial (padrão): substitui o texto de prévia pela saída parcial mais recente.
  • block: acrescenta atualizações de prévia em blocos.
  • progress: mostra texto de status de progresso durante a geração e depois envia o texto final.
channels.slack.nativeStreaming controla o streaming nativo de texto do Slack quando streaming é partial (padrão: true).
  • Uma thread de resposta precisa estar disponível para que o streaming nativo de texto apareça. A seleção da thread ainda segue replyToMode. Sem isso, a prévia normal em rascunho é usada.
  • Mídia e payloads não textuais voltam para a entrega normal.
  • Se o streaming falhar no meio da resposta, o OpenClaw volta para a entrega normal para os payloads restantes.
Use prévia em rascunho em vez do streaming nativo de texto do Slack: 
{
  channels: {
    slack: {
      streaming: "partial",
      nativeStreaming: false,
    },
  },
}
Chaves legadas:
  • channels.slack.streamMode (replace | status_final | append) é migrado automaticamente para channels.slack.streaming.
  • boolean channels.slack.streaming é migrado automaticamente para channels.slack.nativeStreaming.

​
Fallback de reação de digitação

typingReaction adiciona uma reação temporária à mensagem recebida no Slack enquanto o OpenClaw está processando uma resposta e a remove quando a execução termina. Isso é mais útil fora de respostas em thread, que usam um indicador de status padrão “is typing…”. Ordem de resolução:
  • channels.slack.accounts.<accountId>.typingReaction
  • channels.slack.typingReaction
Observações:
  • O Slack espera shortcodes (por exemplo, "hourglass_flowing_sand").
  • A reação é best-effort e a limpeza é tentada automaticamente depois que a resposta ou o caminho de falha termina.

​
Mídia, fragmentação e entrega

Anexos de arquivo do Slack são baixados de URLs privadas hospedadas pelo Slack (fluxo de solicitação autenticado por token) e gravados no armazenamento de mídia quando a busca é bem-sucedida e os limites de tamanho permitem.O limite de tamanho de entrada em runtime tem padrão de 20MB, a menos que seja substituído por channels.slack.mediaMaxMb.
  • fragmentos de texto usam channels.slack.textChunkLimit (padrão 4000)
  • channels.slack.chunkMode="newline" ativa a divisão priorizando parágrafos
  • envios de arquivos usam as APIs de upload do Slack e podem incluir respostas em thread (thread_ts)
  • o limite de mídia de saída segue channels.slack.mediaMaxMb quando configurado; caso contrário, envios de canal usam os padrões por tipo MIME do pipeline de mídia
Destinos explícitos preferidos:
  • user:<id> para DMs
  • channel:<id> para canais
As DMs do Slack são abertas pelas APIs de conversa do Slack ao enviar para destinos de usuário.

​
Comandos e comportamento de slash

  • O modo automático de comando nativo está desativado para Slack (commands.native: "auto" não ativa comandos nativos do Slack).
  • Ative os manipuladores nativos de comando do Slack com channels.slack.commands.native: true (ou global commands.native: true).
  • Quando os comandos nativos estão ativados, registre os comandos de barra correspondentes no Slack (nomes /<command>), com uma exceção:
    • registre /agentstatus para o comando de status (o Slack reserva /status)
  • Se os comandos nativos não estiverem ativados, você pode executar um único comando de barra configurado por meio de channels.slack.slashCommand.
  • Menus nativos de argumentos agora adaptam sua estratégia de renderização:
    • até 5 opções: blocos de botão
    • de 6 a 100 opções: menu de seleção estático
    • mais de 100 opções: seleção externa com filtragem assíncrona de opções quando manipuladores de opções de interatividade estão disponíveis
    • se valores de opção codificados excederem os limites do Slack, o fluxo volta para botões
  • Para payloads longos de opção, menus de argumento de comando de barra usam um diálogo de confirmação antes de despachar um valor selecionado.
Configurações padrão de comando de barra:
  • enabled: false
  • name: "openclaw"
  • sessionPrefix: "slack:slash"
  • ephemeral: true
Sessões de slash usam chaves isoladas:
  • agent:<agentId>:slack:slash:<userId>
e ainda roteiam a execução do comando em relação à sessão de conversa de destino (CommandTargetSessionKey).

​
Respostas interativas

O Slack pode renderizar controles interativos de resposta criados pelo agente, mas esse recurso está desativado por padrão. Ative globalmente: 
{
  channels: {
    slack: {
      capabilities: {
        interactiveReplies: true,
      },
    },
  },
}
Ou ative somente para uma conta do Slack: 
{
  channels: {
    slack: {
      accounts: {
        ops: {
          capabilities: {
            interactiveReplies: true,
          },
        },
      },
    },
  },
}
Quando ativado, agentes podem emitir diretivas de resposta exclusivas do Slack:
  • [[slack_buttons: Approve:approve, Reject:reject]]
  • [[slack_select: Choose a target | Canary:canary, Production:production]]
Essas diretivas são compiladas em Slack Block Kit e encaminham cliques ou seleções de volta pelo caminho existente de eventos de interação do Slack. Observações:
  • Esta é uma UI específica do Slack. Outros canais não traduzem diretivas do Slack Block Kit para seus próprios sistemas de botões.
  • Os valores de callback interativo são tokens opacos gerados pelo OpenClaw, não valores brutos criados pelo agente.
  • Se os blocos interativos gerados excederem os limites do Slack Block Kit, o OpenClaw volta para a resposta de texto original em vez de enviar um payload de blocos inválido.

​
Aprovações de exec no Slack

O Slack pode atuar como um cliente nativo de aprovação com botões interativos e interações, em vez de recorrer à Web UI ou ao terminal.
  • Aprovações de exec usam channels.slack.execApprovals.* para roteamento nativo em DM/canal.
  • Aprovações de plugin ainda podem ser resolvidas pela mesma superfície nativa de botões do Slack quando a solicitação já chega ao Slack e o tipo de id de aprovação é plugin:.
  • A autorização do aprovador ainda é aplicada: somente usuários identificados como aprovadores podem aprovar ou negar solicitações pelo Slack.
Isso usa a mesma superfície compartilhada de botões de aprovação que outros canais. Quando interactivity está ativado nas configurações do seu app do Slack, os prompts de aprovação são renderizados como botões do Block Kit diretamente na conversa. Quando esses botões estão presentes, eles são a UX principal de aprovação; o OpenClaw deve incluir um comando manual /approve somente quando o resultado da ferramenta disser que aprovações no chat não estão disponíveis ou que a aprovação manual é o único caminho. Caminho de configuração:
  • channels.slack.execApprovals.enabled
  • channels.slack.execApprovals.approvers (opcional; usa fallback para commands.ownerAllowFrom quando possível)
  • channels.slack.execApprovals.target (dm | channel | both, padrão: dm)
  • agentFilter, sessionFilter
O Slack ativa automaticamente aprovações nativas de exec quando enabled não está definido ou é "auto" e pelo menos um aprovador é resolvido. Defina enabled: false para desativar explicitamente o Slack como cliente nativo de aprovação. Defina enabled: true para forçar aprovações nativas quando aprovadores forem resolvidos. Comportamento padrão sem configuração explícita de aprovação de exec no Slack: 
{
  commands: {
    ownerAllowFrom: ["slack:U12345678"],
  },
}
A configuração explícita nativa do Slack só é necessária quando você quer substituir aprovadores, adicionar filtros ou optar pela entrega no chat de origem: 
{
  channels: {
    slack: {
      execApprovals: {
        enabled: true,
        approvers: ["U12345678"],
        target: "both",
      },
    },
  },
}
O encaminhamento compartilhado de approvals.exec é separado. Use-o somente quando prompts de aprovação de exec também precisarem ser encaminhados para outros chats ou destinos explícitos fora de banda. O encaminhamento compartilhado de approvals.plugin também é separado; botões nativos do Slack ainda podem resolver aprovações de plugin quando essas solicitações já chegam ao Slack. O mesmo chat /approve também funciona em canais e DMs do Slack que já oferecem suporte a comandos. Consulte Aprovações de exec para o modelo completo de encaminhamento de aprovações.

​
Eventos e comportamento operacional

  • Edições/exclusões de mensagem/transmissões de thread são mapeadas para eventos de sistema.
  • Eventos de adicionar/remover reação são mapeados para eventos de sistema.
  • Eventos de entrada/saída de membro, canal criado/renomeado e adicionar/remover pin são mapeados para eventos de sistema.
  • channel_id_changed pode migrar chaves de configuração de canal quando configWrites está ativado.
  • Metadados de tópico/finalidade do canal são tratados como contexto não confiável e podem ser injetados no contexto de roteamento.
  • O iniciador da thread e a semeadura inicial do contexto do histórico da thread são filtrados pelas listas configuradas de permissões de remetente quando aplicável.
  • Ações de bloco e interações de modal emitem eventos de sistema estruturados Slack interaction: ... com campos ricos de payload:
    • ações de bloco: valores selecionados, rótulos, valores de seletor e metadados workflow_*
    • eventos de modal view_submission e view_closed com metadados de canal roteados e entradas de formulário

​
Ponteiros de referência de configuração

Referência principal:
  • Referência de configuração - Slack Campos de Slack de alto sinal:
    • modo/auth: mode, botToken, appToken, signingSecret, webhookPath, accounts.*
    • acesso a DM: dm.enabled, dmPolicy, allowFrom (legado: dm.policy, dm.allowFrom), dm.groupEnabled, dm.groupChannels
    • alternância de compatibilidade: dangerouslyAllowNameMatching (último recurso; mantenha desativado a menos que seja necessário)
    • acesso a canal: groupPolicy, channels.*, channels.*.users, channels.*.requireMention
    • threading/histórico: replyToMode, replyToModeByChatType, thread.*, historyLimit, dmHistoryLimit, dms.*.historyLimit
    • entrega: textChunkLimit, chunkMode, mediaMaxMb, streaming, nativeStreaming
    • operações/recursos: configWrites, commands.native, slashCommand.*, actions.*, userToken, userTokenReadOnly

​
Solução de problemas

Verifique, nesta ordem:
  • groupPolicy
  • lista de permissões de canal (channels.slack.channels)
  • requireMention
  • lista de permissões users por canal
Comandos úteis:
openclaw channels status --probe
openclaw logs --follow
openclaw doctor
Verifique:
  • channels.slack.dm.enabled
  • channels.slack.dmPolicy (ou legado channels.slack.dm.policy)
  • aprovações de pareamento / entradas de lista de permissões
openclaw pairing list slack
Valide os tokens de bot + app e a ativação do Socket Mode nas configurações do app do Slack.Se openclaw channels status --probe --json mostrar botTokenStatus ou appTokenStatus: "configured_unavailable", a conta do Slack está configurada, mas o runtime atual não conseguiu resolver o valor respaldado por SecretRef.
Valide:
  • signing secret
  • caminho do webhook
  • URLs de solicitação do Slack (Events + Interactivity + Slash Commands)
  • webhookPath exclusivo por conta HTTP
Se signingSecretStatus: "configured_unavailable" aparecer nos snapshots da conta, a conta HTTP está configurada, mas o runtime atual não conseguiu resolver o signing secret respaldado por SecretRef.
Verifique se a sua intenção era:
  • modo de comando nativo (channels.slack.commands.native: true) com comandos de barra correspondentes registrados no Slack
  • ou modo de comando de barra único (channels.slack.slashCommand.enabled: true)
Verifique também commands.useAccessGroups e as listas de permissões de canal/usuário.

​
Relacionado