Communitygithub.com

configure-notifications

Configurez les intégrations de notifications (Telegram, Discord, Slack) en langage naturel

Qu'est-ce que configure-notifications ?

Cette compétence permet aux utilisateurs de configurer facilement des notifications pour les services Telegram, Discord et Slack via un assistant en langage naturel. Utile pour être alerté lorsque des sessions se terminent, nécessitent une entrée ou terminent des tâches en arrière-plan, elle prend en charge les plateformes Claude Code, Cursor et Codex. Le flux interactif guide l'utilisateur étape par étape : détection de la configuration existante, collecte des jetons ou webhooks, validation des entrées, sélection des événements à notifier (comme la fin de session ou la demande d'entrée), et test de la configuration. Le résultat est stocké dans un fichier `.omc-config.json`, ce qui permet une intégration transparente avec le système de notification OMC.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Yeachan-Heo/oh-my-claudecode/tree/main/skills/configure-notifications
Voir l'original→Voir toutes les compétences

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Documentation

Configurer les notifications

Configurez les intégrations de notifications OMC pour être alerté lorsque les sessions se terminent, nécessitent une entrée ou terminent des tâches en arrière-plan.

Routage

Détectez le fournisseur que l'utilisateur souhaite en fonction de sa requête ou de son argument :

  • Si le déclencheur ou l'argument contient "telegram" → suivez la section Telegram
  • Si le déclencheur ou l'argument contient "discord" → suivez la section Discord
  • Si le déclencheur ou l'argument contient "slack" → suivez la section Slack
  • Si aucun fournisseur n'est spécifié, utilisez AskUserQuestion :

Question : "Quel service de notification souhaitez-vous configurer ?"

Options :

  1. Telegram - Jeton de bot + ID de chat. Fonctionne sur mobile et bureau.
  2. Discord - Webhook ou jeton de bot + ID de canal.
  3. Slack - URL de webhook entrant.

Configuration Telegram

Configurez les notifications Telegram pour qu'OMC puisse vous envoyer des messages lorsque les sessions se terminent, nécessitent une entrée ou terminent des tâches en arrière-plan.

Comment fonctionne cette compétence

Il s'agit d'une compétence de configuration interactive en langage naturel. Guidez l'utilisateur tout au long de la configuration en posant des questions avec AskUserQuestion. Écrivez le résultat dans ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.

Étape 1 : Détecter la configuration existante

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

Si une configuration existante est trouvée, affichez à l'utilisateur ce qui est actuellement configuré et demandez s'il souhaite mettre à jour ou reconfigurer.

Étape 2 : Créer un bot Telegram

Guidez l'utilisateur dans la création d'un bot s'il n'en a pas :

Pour configurer les notifications Telegram, vous avez besoin d'un jeton de bot Telegram et de votre ID de chat.

CRÉER UN BOT (si vous n'en avez pas) :
1. Ouvrez Telegram et recherchez @BotFather
2. Envoyez /newbot
3. Choisissez un nom (par ex. "Mon Notifieur OMC")
4. Choisissez un nom d'utilisateur (par ex. "mon_bot_omc")
5. BotFather vous donnera un jeton comme : 123456789:ABCdefGHIjklMNOpqrsTUVwxyz

OBTENIR VOTRE ID DE CHAT :
1. Démarrez une conversation avec votre nouveau bot (envoyez /start)
2. Visitez : https://api.telegram.org/bot<VOTRE_JETON>/getUpdates
3. Cherchez "chat":{"id":VOTRE_ID_DE_CHAT}
   - Les ID de chat personnels sont des nombres positifs (par ex. 123456789)
   - Les ID de chat de groupe sont des nombres négatifs (par ex. -1001234567890)

Étape 3 : Collecter le jeton du bot

Utilisez AskUserQuestion :

Question : "Collez votre jeton de bot Telegram (de @BotFather)"

L'utilisateur tapera son jeton dans le champ "Autre".

Validez le jeton :

  • Doit correspondre au motif : chiffres:alphanumérique (par ex. 123456789:ABCdefGHI...)
  • S'il est invalide, expliquez le format et demandez à nouveau

Étape 4 : Collecter l'ID de chat

Utilisez AskUserQuestion :

Question : "Collez votre ID de chat Telegram (le nombre de l'API getUpdates)"

L'utilisateur tapera son ID de chat dans le champ "Autre".

Validez l'ID de chat :

  • Doit être un nombre (positif pour personnel, négatif pour les groupes)
  • S'il est invalide, proposez de l'aider à le trouver :
# Aider l'utilisateur à trouver son ID de chat
BOT_TOKEN="JETON_UTILISATEUR"
echo "Récupération des messages récents pour trouver votre ID de chat..."
curl -s "https://api.telegram.org/bot${BOT_TOKEN}/getUpdates" | jq '.result[-1].message.chat.id // .result[-1].message.from.id // "Aucun message trouvé - envoyez d'abord /start à votre bot"'

Étape 5 : Choisir le mode d'analyse

Utilisez AskUserQuestion :

Question : "Quel format de message préférez-vous ?"

Options :

  1. Markdown (Recommandé) - Gras, italique, blocs de code avec la syntaxe Markdown
  2. HTML - Gras, italique, code avec des balises HTML

Étape 6 : Configurer les événements

Utilisez AskUserQuestion avec multiSelect :

Question : "Quels événements doivent déclencher les notifications Telegram ?"

Options (multiSelect: true) :

  1. Fin de session (Recommandé) - Lorsqu'une session Claude se termine
  2. Entrée nécessaire - Lorsque Claude attend votre réponse (idéal pour les tâches de longue durée)
  3. Début de session - Lorsqu'une nouvelle session commence
  4. Session en cours - Lorsqu'un mode persistant maintient la session active

Sélection par défaut : session-end + ask-user-question.

Étape 7 : Écrire la configuration

Lisez la configuration existante, fusionnez les nouveaux paramètres Telegram et réécrivez :

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 sont collectés auprès de l'utilisateur
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"

Ajouter une configuration spécifique aux événements si l'utilisateur n'a pas sélectionné tous les événements :

Pour chaque événement NON sélectionné, désactivez-le :

# Exemple : désactiver session-start s'il n'est pas sélectionné
echo "$(cat "$CONFIG_FILE")" | jq \
  '.notifications.events = (.notifications.events // {}) |
   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"

Étape 8 : Tester la configuration

Après avoir écrit la configuration, proposez d'envoyer une notification de test :

Utilisez AskUserQuestion :

Question : "Envoyer une notification de test pour vérifier la configuration ?"

Options :

  1. Oui, tester maintenant (Recommandé) - Envoyer un message de test à votre chat Telegram
  2. Non, je testerai plus tard - Ignorer le test

Si test :

BOT_TOKEN="JETON_UTILISATEUR"
CHAT_ID="ID_CHAT_UTILISATEUR"
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=Notification de test OMC - Telegram est configuré !")

HTTP_CODE=$(echo "$RESPONSE" | tail -1)
BODY=$(echo "$RESPONSE" | head -1)

if [ "$HTTP_CODE" = "200" ]; then
  echo "Notification de test envoyée avec succès !"
else
  echo "Échec (HTTP $HTTP_CODE) :"
  echo "$BODY" | jq -r '.description // "Erreur inconnue"' 2>/dev/null || echo "$BODY"
fi

Signalez le succès ou l'échec. Problèmes courants :

  • 401 Non autorisé : Le jeton du bot est invalide
  • 400 Bad Request : chat not found : L'ID de chat est incorrect, ou l'utilisateur n'a pas envoyé /start au bot
  • Erreur réseau : Vérifiez la connectivité à api.telegram.org

Étape 9 : Confirmer

Affichez le résumé de la configuration finale :

Notifications Telegram configurées !

  Bot :        @votre_nom_bot
  ID de chat : 123456789
  Format :     Markdown
  Événements : session-end, ask-user-question

Config sauvegardée dans : ~/.claude/.omc-config.json

Vous pouvez également les définir via des variables d'environnement :
  OMC_TELEGRAM_BOT_TOKEN=123456789:ABCdefGHI...
  OMC_TELEGRAM_CHAT_ID=123456789

Pour reconfigurer : /oh-my-claudecode:configure-notifications telegram
Pour configurer Discord : /oh-my-claudecode:configure-notifications discord
Pour configurer Slack : /oh-my-claudecode:configure-notifications slack

Alternative par variable d'environnement

Les utilisateurs peuvent contourner complètement cet assistant en définissant des variables d'environnement dans leur profil shell :

export OMC_TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
export OMC_TELEGRAM_CHAT_ID="123456789"

Les variables d'environnement sont automatiquement détectées par le système de notification sans avoir besoin de .omc-config.json.

Configuration Discord

Configurez les notifications Discord pour qu'OMC puisse vous alerter lorsque les sessions se terminent, nécessitent une entrée ou terminent des tâches en arrière-plan.

Comment fonctionne cette compétence

Il s'agit d'une compétence de configuration interactive en langage naturel. Guidez l'utilisateur tout au long de la configuration en posant des questions avec AskUserQuestion. Écrivez le résultat dans ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.

Étape 1 : Détecter la configuration existante

CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"

if [ -f "$CONFIG_FILE" ]; then
  # Vérifier la configuration discord existante
  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

Si une configuration existante est trouvée, affichez à l'utilisateur ce qui est actuellement configuré et demandez s'il souhaite mettre à jour ou reconfigurer.

Étape 2 : Choisir la méthode Discord

Utilisez AskUserQuestion :

Question : "Comment souhaitez-vous envoyer les notifications Discord ?"

Options :

  1. Webhook (Recommandé) - Créez un webhook dans votre canal Discord. Simple, pas besoin de bot. Collez simplement l'URL.
  2. API Bot - Utilisez un jeton de bot Discord + ID de canal. Plus flexible, nécessite une application bot.

Étape 3A : Configuration du webhook

Si l'utilisateur a choisi Webhook :

Utilisez AskUserQuestion :

Question : "Collez votre URL de webhook Discord. Pour en créer une : Paramètres du serveur > Intégrations > Webhooks > Nouveau webhook > Copier l'URL"

L'utilisateur tapera son URL de webhook dans le champ "Autre".

Validez l'URL :

  • Doit commencer par https://discord.com/api/webhooks/ ou https://discordapp.com/api/webhooks/
  • Si elle est invalide, expliquez le format et demandez à nouveau

Étape 3B : Configuration de l'API Bot

Si l'utilisateur a choisi API Bot :

Posez deux questions :

  1. "Collez votre jeton de bot Discord" - De discord.com/developers > Votre application > Bot > Jeton
  2. "Collez l'ID du canal" - Clic droit sur le canal > Copier l'ID du canal (nécessite le mode développeur)

Étape 4 : Configurer la mention (ping utilisateur)

Utilisez AskUserQuestion :

Question : "Souhaitez-vous que les notifications mentionnent (ping) quelqu'un ?"

Options :

  1. Oui, mentionner un utilisateur - Tagger un utilisateur spécifique par son ID Discord
  2. Oui, mentionner un rôle - Tagger un rôle par son ID de rôle
  3. Aucune mention - Publier le message sans pinger personne

Si l'utilisateur souhaite mentionner un utilisateur :

Demandez : "Quel est l'ID Discord de l'utilisateur à mentionner ? (Clic droit sur l'utilisateur > Copier l'ID, nécessite le mode développeur)"

Le format de mention est : <@USER_ID> (par ex. <@1465264645320474637>)

Si l'utilisateur souhaite mentionner un rôle :

Demandez : "Quel est l'ID de rôle Discord à mentionner ? (Paramètres du serveur > Rôles > clic droit sur le rôle > Copier l'ID du rôle)"

Le format de mention est : <@&ROLE_ID> (par ex. <@&123456789>)

Étape 5 : Configurer les événements

Utilisez AskUserQuestion avec multiSelect :

Question : "Quels événements doivent déclencher les notifications Discord ?"

Options (multiSelect: true) :

  1. Fin de session (Recommandé) - Lorsqu'une session Claude se termine
  2. Entrée nécessaire - Lorsque Claude attend votre réponse (idéal pour les tâches de longue durée)
  3. Début de session - Lorsqu'une nouvelle session commence
  4. Session en cours - Lorsqu'un mode persistant maintient la session active

Sélection par défaut : session-end + ask-user-question.

Étape 6 : Surcharge facultative du nom d'utilisateur

Utilisez AskUserQuestion :

Question : "Nom d'affichage personnalisé du bot ? (S'affiche comme nom de l'expéditeur du webhook dans Discord)"

Options :

  1. OMC (par défaut) - Afficher comme "OMC"
  2. Claude Code - Afficher comme "Claude Code"
  3. Personnalisé - Entrer un nom personnalisé

Étape 7 : Écrire la configuration

Lisez la configuration existante, fusionnez les nouveaux paramètres Discord et réécrivez :

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

Pour la méthode Webhook :

Construisez l'objet de notifications avec les valeurs collectées et fusionnez dans .omc-config.json en utilisant jq :

# WEBHOOK_URL, MENTION, USERNAME sont collectés auprès de l'utilisateur
# EVENTS est la liste des événements activés

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"

Pour la méthode API 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"

Ajouter une configuration spécifique aux événements si l'utilisateur n'a pas sélectionné tous les événements :

Pour chaque événement NON sélectionné, désactivez-le :

# Exemple : désactiver session-start s'il n'est pas sélectionné
echo "$(cat "$CONFIG_FILE")" | jq \
  '.notifications.events = (.notifications.events // {}) |
   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"

Étape 8 : Tester la configuration

Après avoir écrit la configuration, proposez d'envoyer une notification de test :

Utilisez AskUserQuestion :

Question : "Envoyer une notification de test pour vérifier la configuration ?"

Options :

  1. Oui, tester maintenant (Recommandé) - Envoyer un message de test à votre canal Discord
  2. Non, je testerai plus tard - Ignorer le test

Si test :

# Pour webhook :
curl -s -o /dev/null -w "%{http_code}" \
  -H "Content-Type: application/json" \
  -d "{\"content\": \"${MENTION:+$MENTION\n}Notification de test OMC - Discord est configuré !\"}" \
  "$WEBHOOK_URL"

Signalez le succès ou l'échec. S'il échoue...

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

agent-doc-discipline

Writing-time discipline for documents agents consume (the five surfaces, specs, tickets, .omc/skills/) — every rule checkable and carrying a why, steps before reference, one meaning in one home, no restating what the environment already says. Mandatory at drydock seed generation and the launch C5 sediment pass; opt-in for any other agent-facing doc edit. The companion of minimal-code-discipline: that one disciplines code, this one disciplines papers.

ai-slop-cleaner

Clean AI-generated code slop with a regression-safe, deletion-first workflow and optional reviewer-only mode

ask

Process-first advisor routing for Claude, Codex, Gemini, Antigravity, Grok, or Cursor via `omc ask`, with artifact capture and no raw CLI assembly

ask-navigator

Shipyard

autopilot

Full autonomous execution from idea to working code

autoresearch

Stateful single-mission improvement loop with strict evaluator contract, markdown decision logs, and max-runtime stop behavior

cancel

Cancel any active OMC mode (autopilot, ralph, ultragoal, swarm, ultrapilot, pipeline, team) and clean up retired legacy state

debug

Diagnose the current OMC session or repo state using logs, traces, state, and focused reproduction

deepinit

Deep codebase initialization with hierarchical AGENTS.md documentation

deep-interview

Socratic deep interview with mathematical ambiguity gating before explicit execution approval

drydock

Lay the keel of the shipyard harness in any repo — the 4-pillar shared environment (Context, Rules, Tools, Standards) across 5 surfaces (CLAUDE.md, skills, design-system, mcp/cli, shared context) so that every human and agent inherits the same design language and anyone can ship. Run once per repo; re-run with --check to audit drift.

execute

Carry an approved task through to working, verified code

external-context

Invoke parallel document-specialist agents for external web searches and documentation lookup

graph

Deterministic orchestration graph runtime - declarative DAG pipelines with journal-based crash recovery

harbor

Harbor intake for external work — the captain only handles unresolved decisions. Sweeps incoming issues and PRs, verifies every claim before disposition, reuses every decision already made, and hands the maintainer a docket whose pending items each carry one question with options, recommendation, impact and evidence. Agent-autonomous for facts and for actions covered by standing authorization; signed for every new judgment. Never merges.

hud

Configure HUD display options (layout, presets, display elements)

launch

Shipyard

loft

Loft the shape before cutting steel — answer a design question that prose cannot settle by building a throwaway artifact: a pure logic module in a clickable shell, or structurally different UI variants behind one route. The captain reacts to the artifact; the answer folds into the decision; the artifact never docks. Use when a design question stalls in words, when a navigator map carries a loft ticket, or when a spec discussion reaches

minimal-code-discipline

YAGNI-ladder coding discipline for writing changes — existence-first, reuse before writing, dependency ladder, shortest correct diff, with non-negotiables that must never be minimized away

omc-doctor

Diagnose and fix oh-my-claudecode installation issues

Skills associés

steipete/video-frames

Extract frames or short clips from videos using ffmpeg.

community

steipete/summarize

Summarize or transcribe URLs, YouTube/videos, podcasts, articles, transcripts, PDFs, and local files.

community

openclaw/openclaw

Use when testing, fixing, or extending the OpenClaw Control UI GUI with Vitest + Playwright end-to-end checks, mocked Gateway WebSocket flows, mocked dashboard runs, screenshots/videos, or agent-verifiable browser proof.

community

obra/superpowers

Obra superpowers agent skills.

community

affaan-m/ECC

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio...

community

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

community