Configurar Notificações
Configure integrações de notificação do OMC para ser alertado quando sessões terminarem, precisarem de entrada ou concluírem tarefas em segundo plano.
Roteamento
Detecte qual provedor o usuário deseja com base em sua solicitação ou argumento:
- Se o gatilho ou argumento contiver "telegram" → siga a seção Telegram
- Se o gatilho ou argumento contiver "discord" → siga a seção Discord
- Se o gatilho ou argumento contiver "slack" → siga a seção Slack
- Se nenhum provedor for especificado, use AskUserQuestion:
Pergunta: "Qual serviço de notificação você gostaria de configurar?"
Opções:
- Telegram - Token do bot + ID do chat. Funciona no celular e no desktop.
- Discord - Webhook ou token do bot + ID do canal.
- Slack - URL de webhook de entrada.
Configuração do Telegram
Configure notificações do Telegram para que o OMC possa enviar mensagens quando sessões terminarem, precisarem de entrada ou concluírem tarefas em segundo plano.
Como Esta Skill Funciona
Esta é uma skill de configuração interativa e em linguagem natural. Guie o usuário pelo processo fazendo perguntas com AskUserQuestion. Escreva o resultado em ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.
Passo 1: Detectar Configuração Existente
CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
if [ -f "$CONFIG_FILE" ]; then
HAS_TELEGRAM=$(jq -r '.notifications.telegram.enabled // false' "$CONFIG_FILE" 2>/dev/null)
CHAT_ID=$(jq -r '.notifications.telegram.chatId // empty' "$CONFIG_FILE" 2>/dev/null)
PARSE_MODE=$(jq -r '.notifications.telegram.parseMode // "Markdown"' "$CONFIG_FILE" 2>/dev/null)
if [ "$HAS_TELEGRAM" = "true" ]; then
echo "EXISTING_CONFIG=true"
echo "CHAT_ID=$CHAT_ID"
echo "PARSE_MODE=$PARSE_MODE"
else
echo "EXISTING_CONFIG=false"
fi
else
echo "NO_CONFIG_FILE"
fi
Se a configuração existente for encontrada, mostre ao usuário o que está configurado atualmente e pergunte se ele deseja atualizar ou reconfigurar.
Passo 2: Criar um Bot do Telegram
Guie o usuário na criação de um bot, caso ele não tenha um:
Para configurar notificações do Telegram, você precisa de um token de bot do Telegram e seu ID de chat.
CRIE UM BOT (se não tiver um):
1. Abra o Telegram e procure por @BotFather
2. Envie /newbot
3. Escolha um nome (ex.: "Meu Notificador OMC")
4. Escolha um nome de usuário (ex.: "meu_omc_bot")
5. O BotFather fornecerá um token como: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz
OBTENHA SEU ID DE CHAT:
1. Inicie uma conversa com seu novo bot (envie /start)
2. Visite: https://api.telegram.org/bot<SEU_TOKEN>/getUpdates
3. Procure por "chat":{"id":SEU_ID_DE_CHAT}
- IDs de chat pessoais são números positivos (ex.: 123456789)
- IDs de chat em grupo são números negativos (ex.: -1001234567890)
Passo 3: Coletar Token do Bot
Use AskUserQuestion:
Pergunta: "Cole seu token de bot do Telegram (do @BotFather)"
O usuário digitará o token no campo "Outro".
Valide o token:
- Deve corresponder ao padrão:
dígitos:alfanumérico(ex.:123456789:ABCdefGHI...) - Se for inválido, explique o formato e peça novamente
Passo 4: Coletar ID do Chat
Use AskUserQuestion:
Pergunta: "Cole seu ID de chat do Telegram (o número da API getUpdates)"
O usuário digitará o ID do chat no campo "Outro".
Valide o ID do chat:
- Deve ser um número (positivo para pessoal, negativo para grupos)
- Se for inválido, ofereça ajuda para encontrá-lo:
# Ajude o usuário a encontrar o ID do chat
BOT_TOKEN="TOKEN_FORNECIDO_PELO_USUARIO"
echo "Buscando mensagens recentes para encontrar seu ID de chat..."
curl -s "https://api.telegram.org/bot${BOT_TOKEN}/getUpdates" | jq '.result[-1].message.chat.id // .result[-1].message.from.id // "Nenhuma mensagem encontrada - envie /start para seu bot primeiro"'
Passo 5: Escolher Modo de Análise
Use AskUserQuestion:
Pergunta: "Qual formato de mensagem você prefere?"
Opções:
- Markdown (Recomendado) - Negrito, itálico, blocos de código com sintaxe Markdown
- HTML - Negrito, itálico, código com tags HTML
Passo 6: Configurar Eventos
Use AskUserQuestion com multiSelect:
Pergunta: "Quais eventos devem acionar notificações do Telegram?"
Opções (multiSelect: true):
- Fim da sessão (Recomendado) - Quando uma sessão do Claude termina
- Entrada necessária - Quando o Claude está aguardando sua resposta (ótimo para tarefas longas)
- Início da sessão - Quando uma nova sessão começa
- Sessão continuando - Quando o modo persistente mantém a sessão ativa
Seleção padrão: session-end + ask-user-question.
Passo 7: Escrever Configuração
Leia a configuração existente, mescle as novas configurações do Telegram e escreva de volta:
CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
mkdir -p "$(dirname "$CONFIG_FILE")"
if [ -f "$CONFIG_FILE" ]; then
EXISTING=$(cat "$CONFIG_FILE")
else
EXISTING='{}'
fi
# BOT_TOKEN, CHAT_ID, PARSE_MODE são coletados do usuário
echo "$EXISTING" | jq \
--arg token "$BOT_TOKEN" \
--arg chatId "$CHAT_ID" \
--arg parseMode "$PARSE_MODE" \
'.notifications = (.notifications // {enabled: true}) |
.notifications.enabled = true |
.notifications.telegram = {
enabled: true,
botToken: $token,
chatId: $chatId,
parseMode: $parseMode
}' > "$CONFIG_FILE"
Adicione configuração específica de evento se o usuário não selecionou todos os eventos:
Para cada evento NÃO selecionado, desabilite-o:
# Exemplo: desabilitar session-start se não selecionado
echo "$(cat "$CONFIG_FILE")" | jq \
'.notifications.events = (.notifications.events // {}) |
.notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"
Passo 8: Testar a Configuração
Após escrever a configuração, ofereça-se para enviar uma notificação de teste:
Use AskUserQuestion:
Pergunta: "Enviar uma notificação de teste para verificar a configuração?"
Opções:
- Sim, testar agora (Recomendado) - Enviar uma mensagem de teste para seu chat do Telegram
- Não, testarei depois - Pular o teste
Se testar:
BOT_TOKEN="TOKEN_FORNECIDO_PELO_USUARIO"
CHAT_ID="ID_DE_CHAT_FORNECIDO_PELO_USUARIO"
PARSE_MODE="Markdown"
RESPONSE=$(curl -s -w "\n%{http_code}" \
"https://api.telegram.org/bot${BOT_TOKEN}/sendMessage" \
-d "chat_id=${CHAT_ID}" \
-d "parse_mode=${PARSE_MODE}" \
-d "text=Notificação de teste OMC - Telegram está configurado!")
HTTP_CODE=$(echo "$RESPONSE" | tail -1)
BODY=$(echo "$RESPONSE" | head -1)
if [ "$HTTP_CODE" = "200" ]; then
echo "Notificação de teste enviada com sucesso!"
else
echo "Falhou (HTTP $HTTP_CODE):"
echo "$BODY" | jq -r '.description // "Erro desconhecido"' 2>/dev/null || echo "$BODY"
fi
Relate sucesso ou falha. Problemas comuns:
- 401 Não Autorizado: Token do bot é inválido
- 400 Bad Request: chat not found: ID do chat está errado, ou o usuário não enviou
/startpara o bot - Erro de rede: Verifique a conectividade com api.telegram.org
Passo 9: Confirmar
Exiba o resumo final da configuração:
Notificações do Telegram Configuradas!
Bot: @seu_nome_de_usuario_do_bot
ID do Chat: 123456789
Formato: Markdown
Eventos: session-end, ask-user-question
Config salva em: ~/.claude/.omc-config.json
Você também pode definir estas variáveis de ambiente:
OMC_TELEGRAM_BOT_TOKEN=123456789:ABCdefGHI...
OMC_TELEGRAM_CHAT_ID=123456789
Para reconfigurar: /oh-my-claudecode:configure-notifications telegram
Para configurar Discord: /oh-my-claudecode:configure-notifications discord
Para configurar Slack: /oh-my-claudecode:configure-notifications slack
Alternativa por Variável de Ambiente
Os usuários podem pular este assistente completamente definindo variáveis de ambiente em seu perfil de shell:
export OMC_TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
export OMC_TELEGRAM_CHAT_ID="123456789"
As variáveis de ambiente são detectadas automaticamente pelo sistema de notificação sem a necessidade de .omc-config.json.
Configuração do Discord
Configure notificações do Discord para que o OMC possa te notificar quando sessões terminarem, precisarem de entrada ou concluírem tarefas em segundo plano.
Como Esta Skill Funciona
Esta é uma skill de configuração interativa e em linguagem natural. Guie o usuário pelo processo fazendo perguntas com AskUserQuestion. Escreva o resultado em ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.
Passo 1: Detectar Configuração Existente
CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
if [ -f "$CONFIG_FILE" ]; then
# Verifique a configuração existente do discord
HAS_DISCORD=$(jq -r '.notifications.discord.enabled // false' "$CONFIG_FILE" 2>/dev/null)
HAS_DISCORD_BOT=$(jq -r '.notifications["discord-bot"].enabled // false' "$CONFIG_FILE" 2>/dev/null)
WEBHOOK_URL=$(jq -r '.notifications.discord.webhookUrl // empty' "$CONFIG_FILE" 2>/dev/null)
MENTION=$(jq -r '.notifications.discord.mention // empty' "$CONFIG_FILE" 2>/dev/null)
if [ "$HAS_DISCORD" = "true" ] || [ "$HAS_DISCORD_BOT" = "true" ]; then
echo "EXISTING_CONFIG=true"
echo "WEBHOOK_CONFIGURED=$HAS_DISCORD"
echo "BOT_CONFIGURED=$HAS_DISCORD_BOT"
[ -n "$WEBHOOK_URL" ] && echo "WEBHOOK_URL=$WEBHOOK_URL"
[ -n "$MENTION" ] && echo "MENTION=$MENTION"
else
echo "EXISTING_CONFIG=false"
fi
else
echo "NO_CONFIG_FILE"
fi
Se a configuração existente for encontrada, mostre ao usuário o que está configurado atualmente e pergunte se ele deseja atualizar ou reconfigurar.
Passo 2: Escolher Método do Discord
Use AskUserQuestion:
Pergunta: "Como você gostaria de enviar notificações do Discord?"
Opções:
- Webhook (Recomendado) - Crie um webhook no seu canal do Discord. Simples, não precisa de bot. Basta colar a URL.
- API do Bot - Use um token de bot do Discord + ID do canal. Mais flexível, requer um aplicativo de bot.
Passo 3A: Configuração de Webhook
Se o usuário escolheu Webhook:
Use AskUserQuestion:
Pergunta: "Cole sua URL de webhook do Discord. Para criar uma: Configurações do Servidor > Integrações > Webhooks > Novo Webhook > Copiar URL"
O usuário digitará a URL do webhook no campo "Outro".
Valide a URL:
- Deve começar com
https://discord.com/api/webhooks/ouhttps://discordapp.com/api/webhooks/ - Se for inválida, explique o formato e peça novamente
Passo 3B: Configuração da API do Bot
Se o usuário escolheu API do Bot:
Faça duas perguntas:
- "Cole seu token de bot do Discord" - De discord.com/developers > Seu App > Bot > Token
- "Cole o ID do canal" - Clique com o botão direito no canal > Copiar ID do Canal (requer Modo Desenvolvedor)
Passo 4: Configurar Menção (Marcar Usuário)
Use AskUserQuestion:
Pergunta: "Gostaria que as notificações mencionassem (marcassem) alguém?"
Opções:
- Sim, mencionar um usuário - Marcar um usuário específico pelo ID de usuário do Discord
- Sim, mencionar um cargo - Marcar um cargo pelo ID do cargo
- Sem menções - Apenas postar a mensagem sem marcar ninguém
Se o usuário quiser mencionar um usuário:
Pergunte: "Qual é o ID do usuário do Discord para mencionar? (Clique com o botão direito no usuário > Copiar ID do Usuário, requer Modo Desenvolvedor)"
O formato da menção é: <@ID_DO_USUARIO> (ex.: <@1465264645320474637>)
Se o usuário quiser mencionar um cargo:
Pergunte: "Qual é o ID do cargo do Discord para mencionar? (Configurações do Servidor > Cargos > clique com o botão direito no cargo > Copiar ID do Cargo)"
O formato da menção é: <@&ID_DO_CARGO> (ex.: <@&123456789>)
Passo 5: Configurar Eventos
Use AskUserQuestion com multiSelect:
Pergunta: "Quais eventos devem acionar notificações do Discord?"
Opções (multiSelect: true):
- Fim da sessão (Recomendado) - Quando uma sessão do Claude termina
- Entrada necessária - Quando o Claude está aguardando sua resposta (ótimo para tarefas longas)
- Início da sessão - Quando uma nova sessão começa
- Sessão continuando - Quando o modo persistente mantém a sessão ativa
Seleção padrão: session-end + ask-user-question.
Passo 6: Sobrescrita Opcional do Nome de Exibição
Use AskUserQuestion:
Pergunta: "Nome de exibição personalizado do bot? (Aparece como o nome do remetente do webhook no Discord)"
Opções:
- OMC (padrão) - Exibir como "OMC"
- Claude Code - Exibir como "Claude Code"
- Personalizado - Insira um nome personalizado
Passo 7: Escrever Configuração
Leia a configuração existente, mescle as novas configurações do Discord e escreva de volta:
CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
mkdir -p "$(dirname "$CONFIG_FILE")"
if [ -f "$CONFIG_FILE" ]; then
EXISTING=$(cat "$CONFIG_FILE")
else
EXISTING='{}'
fi
Para método Webhook:
Construa o objeto de notificações com os valores coletados e mescle em .omc-config.json usando jq:
# WEBHOOK_URL, MENTION, USERNAME são coletados do usuário
# EVENTS é a lista de eventos habilitados
echo "$EXISTING" | jq \
--arg url "$WEBHOOK_URL" \
--arg mention "$MENTION" \
--arg username "$USERNAME" \
'.notifications = (.notifications // {enabled: true}) |
.notifications.enabled = true |
.notifications.discord = {
enabled: true,
webhookUrl: $url,
mention: (if $mention == "" then null else $mention end),
username: (if $username == "" then null else $username end)
}' > "$CONFIG_FILE"
Para método API do Bot:
echo "$EXISTING" | jq \
--arg token "$BOT_TOKEN" \
--arg channel "$CHANNEL_ID" \
--arg mention "$MENTION" \
'.notifications = (.notifications // {enabled: true}) |
.notifications.enabled = true |
.notifications["discord-bot"] = {
enabled: true,
botToken: $token,
channelId: $channel,
mention: (if $mention == "" then null else $mention end)
}' > "$CONFIG_FILE"
Adicione configuração específica de evento se o usuário não selecionou todos os eventos:
Para cada evento NÃO selecionado, desabilite-o:
# Exemplo: desabilitar session-start se não selecionado
echo "$(cat "$CONFIG_FILE")" | jq \
'.notifications.events = (.notifications.events // {}) |
.notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"
Passo 8: Testar a Configuração
Após escrever a configuração, ofereça-se para enviar uma notificação de teste:
Use AskUserQuestion:
Pergunta: "Enviar uma notificação de teste para verificar a configuração?"
Opções:
- Sim, testar agora (Recomendado) - Enviar uma mensagem de teste para seu canal do Discord
- Não, testarei depois - Pular o teste
Se testar:
# Para webhook:
curl -s -o /dev/null -w "%{http_code}" \
-H "Content-Type: application/json" \
-d "{\"content\": \"${MENTION:+$MENTION\n}Notificação de teste OMC - Discord está configurado!\"}" \
"$WEBHOOK_URL"
Relate sucesso ou falha. Se falhar