Benachrichtigungen konfigurieren

Was macht Benachrichtigungen konfigurieren?

Richte OMC-Benachrichtigungsintegrationen ein, damit du benachrichtigt wirst, wenn Sitzungen enden, eine Eingabe erforderlich ist oder Hintergrundaufgaben abgeschlossen werden.

Routing

Erkenne, welchen Anbieter der Benutzer basierend auf seiner Anfrage oder seinem Argument wünscht:

• Wenn der Auslöser oder das Argument "telegram" enthält → folge dem Telegram-Abschnitt
• Wenn der Auslöser oder das Argument "discord" enthält → folge dem Discord-Abschnitt
• Wenn der Auslöser oder das Argument "slack" enthält → folge dem Slack-Abschnitt
• Wenn kein Anbieter angegeben ist, verwende AskUserQuestion:

Frage: "Welchen Benachrichtigungsdienst möchtest du konfigurieren?"

Optionen:

1. Telegram - Bot-Token + Chat-ID. Funktioniert auf Mobilgeräten und dem Desktop.
2. Discord - Webhook- oder Bot-Token + Kanal-ID.
3. Slack - Eingehende Webhook-URL.

---

Telegram Einrichtung

Richte Telegram-Benachrichtigungen ein, damit OMC dich benachrichtigen kann, wenn Sitzungen enden, eine Eingabe erforderlich ist oder Hintergrundaufgaben abgeschlossen werden.

So funktioniert diese Skill

Dies ist eine interaktive Konfigurations-Skill in natürlicher Sprache. Führe den Benutzer durch die Einrichtung, indem du Fragen mit AskUserQuestion stellst. Schreibe das Ergebnis in ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.

Schritt 1: Vorhandene Konfiguration erkennen

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

Wenn eine vorhandene Konfiguration gefunden wird, zeige dem Benutzer, was aktuell konfiguriert ist, und frage, ob er sie aktualisieren oder neu konfigurieren möchte.

Schritt 2: Einen Telegram-Bot erstellen

Führe den Benutzer durch die Erstellung eines Bots, falls er noch keinen hat:

Um Telegram-Benachrichtigungen einzurichten, benötigst du ein Telegram-Bot-Token und deine Chat-ID.

EINEN BOT ERSTELLEN (falls du keinen hast):
1. Öffne Telegram und suche nach @BotFather
2. Sende /newbot
3. Wähle einen Namen (z. B. "Mein OMC Notifier")
4. Wähle einen Benutzernamen (z. B. "mein_omc_bot")
5. BotFather gibt dir ein Token wie: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz

DEINE CHAT-ID ERHALTEN:
1. Starte einen Chat mit deinem neuen Bot (sende /start)
2. Besuche: https://api.telegram.org/bot<DEIN_TOKEN>/getUpdates
3. Suche nach "chat":{"id":DEINE_CHAT_ID}
   - Persönliche Chat-IDs sind positive Zahlen (z. B. 123456789)
   - Gruppen-Chat-IDs sind negative Zahlen (z. B. -1001234567890)

Schritt 3: Bot-Token sammeln

Verwende AskUserQuestion:

Frage: "Füge dein Telegram-Bot-Token ein (von @BotFather)"

Der Benutzer gibt sein Token in das Feld "Anderes" ein.

Validiere das Token:

• Muss dem Muster entsprechen: Ziffern:alphanumerisch (z. B. 123456789:ABCdefGHI...)
• Wenn ungültig, erkläre das Format und frage erneut

Schritt 4: Chat-ID sammeln

Verwende AskUserQuestion:

Frage: "Füge deine Telegram-Chat-ID ein (die Nummer von der getUpdates-API)"

Der Benutzer gibt seine Chat-ID in das Feld "Anderes" ein.

Validiere die Chat-ID:

• Muss eine Zahl sein (positiv für persönlich, negativ für Gruppen)
• Wenn ungültig, biete Hilfe an, sie zu finden:

# Hilf dem Benutzer, seine Chat-ID zu finden
BOT_TOKEN="VOM_BENUTZER_BEREITGESTELLTES_TOKEN"
echo "Rufe letzte Nachrichten ab, um die Chat-ID zu finden..."
curl -s "https://api.telegram.org/bot${BOT_TOKEN}/getUpdates" | jq '.result[-1].message.chat.id // .result[-1].message.from.id // "Keine Nachrichten gefunden - sende zuerst /start an deinen Bot"'

Schritt 5: Parse-Modus auswählen

Verwende AskUserQuestion:

Frage: "Welches Nachrichtenformat bevorzugst du?"

Optionen:

1. Markdown (Empfohlen) - Fett, kursiv, Codeblöcke mit Markdown-Syntax
2. HTML - Fett, kursiv, Code mit HTML-Tags

Schritt 6: Ereignisse konfigurieren

Verwende AskUserQuestion mit multiSelect:

Frage: "Welche Ereignisse sollen Telegram-Benachrichtigungen auslösen?"

Optionen (multiSelect: true):

1. Sitzungsende (Empfohlen) - Wenn eine Claude-Sitzung beendet wird
2. Eingabe erforderlich - Wenn Claude auf deine Antwort wartet (ideal für langlaufende Aufgaben)
3. Sitzungsbeginn - Wenn eine neue Sitzung beginnt
4. Sitzung wird fortgesetzt - Wenn ein persistenter Modus die Sitzung am Leben hält

Standardauswahl: Sitzungsende + Benutzereingabe erforderlich.

Schritt 7: Konfiguration schreiben

Lies die vorhandene Konfiguration, füge die neuen Telegram-Einstellungen zusammen und schreibe zurück:

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 werden vom Benutzer gesammelt
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"

Ereignisspezifische Konfiguration hinzufügen, wenn der Benutzer nicht alle Ereignisse ausgewählt hat:

Für jedes NICHT ausgewählte Ereignis deaktiviere es:

# Beispiel: Sitzungsbeginn deaktivieren, wenn nicht ausgewählt
echo "$(cat "$CONFIG_FILE")" | jq \
  '.notifications.events = (.notifications.events // {}) |
   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"

Schritt 8: Konfiguration testen

Nach dem Schreiben der Konfiguration biete an, eine Testbenachrichtigung zu senden:

Verwende AskUserQuestion:

Frage: "Eine Testbenachrichtigung senden, um die Einrichtung zu überprüfen?"

Optionen:

1. Ja, jetzt testen (Empfohlen) - Sende eine Testnachricht an deinen Telegram-Chat
2. Nein, ich teste später - Test überspringen

Beim Testen:

BOT_TOKEN="VOM_BENUTZER_BEREITGESTELLTES_TOKEN"
CHAT_ID="VOM_BENUTZER_BEREITGESTELLTE_CHAT_ID"
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=OMC Testbenachrichtigung - Telegram ist konfiguriert!")

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

if [ "$HTTP_CODE" = "200" ]; then
  echo "Testbenachrichtigung erfolgreich gesendet!"
else
  echo "Fehlgeschlagen (HTTP $HTTP_CODE):"
  echo "$BODY" | jq -r '.description // "Unbekannter Fehler"' 2>/dev/null || echo "$BODY"
fi

Melde Erfolg oder Misserfolg. Häufige Probleme:

• 401 Nicht autorisiert: Bot-Token ist ungültig
• 400 Bad Request: Chat nicht gefunden: Chat-ID ist falsch oder der Benutzer hat /start nicht an den Bot gesendet
• Netzwerkfehler: Überprüfe die Verbindung zu api.telegram.org

Schritt 9: Bestätigen

Zeige die endgültige Konfigurationszusammenfassung an:

Telegram-Benachrichtigungen konfiguriert!

  Bot:        @dein_bot_benutzername
  Chat-ID:    123456789
  Format:     Markdown
  Ereignisse: Sitzungsende, Benutzereingabe erforderlich

Konfiguration gespeichert unter: ~/.claude/.omc-config.json

Du kannst diese auch über Umgebungsvariablen setzen:
  OMC_TELEGRAM_BOT_TOKEN=123456789:ABCdefGHI...
  OMC_TELEGRAM_CHAT_ID=123456789

Zum Neukonfigurieren: /oh-my-claudecode:configure-notifications telegram
Zum Konfigurieren von Discord: /oh-my-claudecode:configure-notifications discord
Zum Konfigurieren von Slack: /oh-my-claudecode:configure-notifications slack

Alternative über Umgebungsvariablen

Benutzer können diesen Assistenten vollständig überspringen, indem sie Umgebungsvariablen in ihrem Shell-Profil setzen:

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

Umgebungsvariablen werden automatisch vom Benachrichtigungssystem erkannt, ohne dass .omc-config.json erforderlich ist.

---

Discord Einrichtung

Richte Discord-Benachrichtigungen ein, damit OMC dich benachrichtigen kann, wenn Sitzungen enden, eine Eingabe erforderlich ist oder Hintergrundaufgaben abgeschlossen werden.

So funktioniert diese Skill

Dies ist eine interaktive Konfigurations-Skill in natürlicher Sprache. Führe den Benutzer durch die Einrichtung, indem du Fragen mit AskUserQuestion stellst. Schreibe das Ergebnis in ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.

Schritt 1: Vorhandene Konfiguration erkennen

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

if [ -f "$CONFIG_FILE" ]; then
  # Prüfe auf vorhandene Discord-Konfiguration
  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

Wenn eine vorhandene Konfiguration gefunden wird, zeige dem Benutzer, was aktuell konfiguriert ist, und frage, ob er sie aktualisieren oder neu konfigurieren möchte.

Schritt 2: Discord-Methode auswählen

Verwende AskUserQuestion:

Frage: "Wie möchtest du Discord-Benachrichtigungen senden?"

Optionen:

1. Webhook (Empfohlen) - Erstelle einen Webhook in deinem Discord-Kanal. Einfach, kein Bot nötig. Füge einfach die URL ein.
2. Bot-API - Verwende ein Discord-Bot-Token + Kanal-ID. Flexibler, erfordert eine Bot-Anwendung.

Schritt 3A: Webhook-Einrichtung

Wenn der Benutzer Webhook gewählt hat:

Verwende AskUserQuestion:

Frage: "Füge deine Discord-Webhook-URL ein. So erstellst du eine: Servereinstellungen > Integrationen > Webhooks > Neuer Webhook > URL kopieren"

Der Benutzer gibt seine Webhook-URL in das Feld "Anderes" ein.

Validiere die URL:

• Muss mit https://discord.com/api/webhooks/ oder https://discordapp.com/api/webhooks/ beginnen
• Wenn ungültig, erkläre das Format und frage erneut

Schritt 3B: Bot-API-Einrichtung

Wenn der Benutzer Bot-API gewählt hat:

Stelle zwei Fragen:

1. "Füge dein Discord-Bot-Token ein" - Von discord.com/developers > Deine App > Bot > Token
2. "Füge die Kanal-ID ein" - Rechtsklick auf Kanal > Kanal-ID kopieren (erfordert Entwicklermodus)

Schritt 4: Erwähnung konfigurieren (Benutzer-Ping)

Verwende AskUserQuestion:

Frage: "Sollen Benachrichtigungen jemanden erwähnen (pingen)?"

Optionen:

1. Ja, einen Benutzer erwähnen - Markiere einen bestimmten Benutzer über seine Discord-Benutzer-ID
2. Ja, eine Rolle erwähnen - Markiere eine Rolle über ihre Rollen-ID
3. Keine Erwähnungen - Sende die Nachricht, ohne jemanden anzupingen

Wenn der Benutzer einen Benutzer erwähnen möchte:

Frage: "Wie lautet die Discord-Benutzer-ID, die erwähnt werden soll? (Rechtsklick auf Benutzer > Benutzer-ID kopieren, erfordert Entwicklermodus)"

Das Erwähnungsformat ist: <@BENUTZER_ID> (z. B. <@1465264645320474637>)

Wenn der Benutzer eine Rolle erwähnen möchte:

Frage: "Wie lautet die Discord-Rollen-ID, die erwähnt werden soll? (Servereinstellungen > Rollen > Rechtsklick auf Rolle > Rollen-ID kopieren)"

Das Erwähnungsformat ist: <@&ROLLEN_ID> (z. B. <@&123456789>)

Schritt 5: Ereignisse konfigurieren

Verwende AskUserQuestion mit multiSelect:

Frage: "Welche Ereignisse sollen Discord-Benachrichtigungen auslösen?"

Optionen (multiSelect: true):

1. Sitzungsende (Empfohlen) - Wenn eine Claude-Sitzung beendet wird
2. Eingabe erforderlich - Wenn Claude auf deine Antwort wartet (ideal für langlaufende Aufgaben)
3. Sitzungsbeginn - Wenn eine neue Sitzung beginnt
4. Sitzung wird fortgesetzt - Wenn ein persistenter Modus die Sitzung am Leben hält

Standardauswahl: Sitzungsende + Benutzereingabe erforderlich.

Schritt 6: Optionaler Benutzernamen-Override

Verwende AskUserQuestion:

Frage: "Benutzerdefinierter Bot-Anzeigename? (Wird als Webhook-Absendername in Discord angezeigt)"

Optionen:

1. OMC (Standard) - Anzeige als "OMC"
2. Claude Code - Anzeige als "Claude Code"
3. Benutzerdefiniert - Gib einen benutzerdefinierten Namen ein

Schritt 7: Konfiguration schreiben

Lies die vorhandene Konfiguration, füge die neuen Discord-Einstellungen zusammen und schreibe zurück:

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

Für die Webhook-Methode:

Erstelle das Benachrichtigungsobjekt mit den gesammelten Werten und füge es mit jq in .omc-config.json ein:

# WEBHOOK_URL, MENTION, USERNAME werden vom Benutzer gesammelt
# EVENTS ist die Liste der aktivierten Ereignisse

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"

Für die Bot-API-Methode:

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"

Ereignisspezifische Konfiguration hinzufügen, wenn der Benutzer nicht alle Ereignisse ausgewählt hat:

Für jedes NICHT ausgewählte Ereignis deaktiviere es:

# Beispiel: Sitzungsbeginn deaktivieren, wenn nicht ausgewählt
echo "$(cat "$CONFIG_FILE")" | jq \
  '.notifications.events = (.notifications.events // {}) |
   .notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"

Schritt 8: Konfiguration testen

Nach dem Schreiben der Konfiguration biete an, eine Testbenachrichtigung zu senden:

Verwende AskUserQuestion:

Frage: "Eine Testbenachrichtigung senden, um die Einrichtung zu überprüfen?"

Optionen:

1. Ja, jetzt testen (Empfohlen) - Sende eine Testnachricht an deinen Discord-Kanal
2. Nein, ich teste später - Test überspringen

Beim Testen:

# Für Webhook:
curl -s -o /dev/null -w "%{http_code}" \
  -H "Content-Type: application/json" \
  -d "{\"content\": \"${MENTION:+$MENTION\n}OMC Testbenachrichtigung - Discord ist konfiguriert!\"}" \
  "$WEBHOOK_URL"

Melde Erfolg oder Misserfolg. Wenn es fehlschlägt...