home / skills / terrylica / cc-skills / dual-channel-watchexec

dual-channel-watchexec skill

/plugins/devops-tools/skills/dual-channel-watchexec

This skill sends dual-channel watchexec notifications to Telegram (HTML) and Pushover (plain text) for file changes and crashes.

npx playbooks add skill terrylica/cc-skills --skill dual-channel-watchexec

Review the files below or copy the command above to add this skill to your agents.

Files (10)
SKILL.md
5.4 KB
---
name: dual-channel-watchexec-notifications
description: Dual-channel notifications on watchexec events. TRIGGERS - watchexec alerts, Telegram+Pushover, file change notifications.
allowed-tools: Read, Write, Edit, Bash
---

# Dual-Channel Watchexec Notifications

Send reliable notifications to both Telegram and Pushover when watchexec detects file changes or process crashes.

## When to Use This Skill

Use this skill when:

- Setting up file change monitoring with notifications
- Implementing process crash alerting via Telegram and Pushover
- Creating watchexec wrappers with dual-channel notification support
- Formatting messages for both HTML (Telegram) and plain text (Pushover)
- Troubleshooting notification delivery or formatting issues

## Core Pattern

**watchexec wrapper script** → **detect event** → **notify-script** → **Telegram + Pushover**

```bash
# wrapper.sh - Monitors process and detects restart reasons
watchexec --restart -- python bot.py

# On event, call:
notify-script.sh <reason> <exit_code> <watchexec_info_file> <crash_context>
```

---

## Critical Rule: Format Differences

**Telegram**: HTML mode ONLY

```bash
MESSAGE="<b>Alert</b>: <code>file.py</code>"
# Escape 3 chars: & → &amp;, < → &lt;, > → &gt;
```

**Pushover**: Plain text ONLY

```bash
/usr/bin/env bash << 'SKILL_SCRIPT_EOF'
# Strip HTML tags before sending
MESSAGE_PLAIN=$(echo "$MESSAGE_HTML" | sed 's/<[^>]*>//g')
SKILL_SCRIPT_EOF
```

**Why HTML for Telegram**:

- Markdown requires escaping 40+ chars (`.`, `-`, `_`, etc.)
- HTML only requires escaping 3 chars (`&`, `<`, `>`)
- Industry best practice

---

## Quick Reference

### Send to Both Channels

```bash
/usr/bin/env bash << 'SKILL_SCRIPT_EOF_2'
# 1. Build HTML message for Telegram
MESSAGE_HTML="<b>File</b>: <code>handler_classes.py</code>"

# 2. Strip HTML for Pushover
MESSAGE_PLAIN=$(echo "$MESSAGE_HTML" | sed 's/<[^>]*>//g')

# 3. Send to Telegram with HTML
curl -s -d "chat_id=$CHAT_ID" \
  -d "text=$MESSAGE_HTML" \
  -d "parse_mode=HTML" \
  https://api.telegram.org/bot$BOT_TOKEN/sendMessage

# 4. Send to Pushover with plain text
curl -s --form-string "message=$MESSAGE_PLAIN" \
  https://api.pushover.net/1/messages.json
SKILL_SCRIPT_EOF_2
```

### Execution Pattern

```bash
# Fire-and-forget background notifications (don't block restarts)
"$NOTIFY_SCRIPT" "crash" "$EXIT_CODE" "$INFO_FILE" "$CONTEXT_FILE" &
```

---

## Validation Checklist

Before deploying:

- [ ] Using HTML parse mode for Telegram (not Markdown)
- [ ] HTML tags stripped for Pushover (plain text only)
- [ ] HTML escaping applied to all dynamic content (`&`, `<`, `>`)
- [ ] Credentials loaded from env vars/Doppler (not hardcoded)
- [ ] Message archiving enabled for debugging
- [ ] File detection uses `stat` (not `find -newermt`)
- [ ] Heredocs use unquoted delimiters for variable expansion
- [ ] Notifications run in background (fire-and-forget)
- [ ] Tested with files containing special chars (`_`, `.`, `-`)
- [ ] Both Telegram and Pushover successfully receiving

---

## Summary

**Key Lessons**:

1. Always use HTML mode for Telegram (simpler escaping)
2. Always strip HTML tags for Pushover (plain text only)
3. Escape only 3 chars in HTML: `&` → `&amp;`, `<` → `&lt;`, `>` → `&gt;`
4. Archive messages before sending for debugging
5. Use `stat` for file detection on macOS (not `find -newermt`)
6. Load credentials from env vars/Doppler (never hardcode)
7. Fire-and-forget background notifications (don't block restarts)

---

## Reference Documentation

For detailed information, see:

- [Telegram HTML](./references/telegram-html.md) - HTML mode formatting and message templates
- [Pushover Integration](./references/pushover-integration.md) - API calls and priority levels
- [Credential Management](./references/credential-management.md) - Doppler, env vars, and keychain patterns
- [Watchexec Patterns](./references/watchexec-patterns.md) - File detection and restart reason detection
- [Common Pitfalls](./references/common-pitfalls.md) - HTML tags in Pushover, escaping issues, macOS compatibility

**Bundled Examples:**

- `examples/notify-restart.sh` - Complete dual-channel notification script
- `examples/bot-wrapper.sh` - watchexec wrapper with restart detection
- `examples/setup-example.sh` - Setup guide and installation steps

---

## Troubleshooting

| Issue                      | Cause                          | Solution                                       |
| -------------------------- | ------------------------------ | ---------------------------------------------- |
| Telegram escaping errors   | Using Markdown instead of HTML | Switch to HTML mode with parse_mode=HTML       |
| Pushover shows HTML tags   | HTML not stripped              | Strip tags with sed before sending to Pushover |
| Notifications not arriving | Credentials missing            | Verify BOT_TOKEN, CHAT_ID, Pushover keys       |
| Special chars broken       | Missing HTML escaping          | Escape &, <, > in dynamic content              |
| find -newermt fails macOS  | macOS incompatibility          | Use stat for file detection instead            |
| Notifications blocking     | Not running in background      | Add & to run notify script fire-and-forget     |
| Duplicate notifications    | Restart loop                   | Add debounce logic or cooldown period          |
| Missing crash context      | Context file not written       | Verify watchexec info file path exists         |

Overview

This skill sends reliable dual-channel notifications (Telegram + Pushover) when watchexec detects file changes, process crashes, or restarts. It provides a lightweight wrapper pattern and concrete message formatting rules to ensure consistent delivery and readable alerts. The goal is fast, fire-and-forget notifications that work across platforms and reduce troubleshooting time.

How this skill works

A watchexec wrapper monitors the target process and on relevant events calls a notify script with context (reason, exit code, info file). The notify script builds an HTML message for Telegram, strips HTML to plain text for Pushover, escapes the three required characters for HTML, and sends both requests asynchronously. Notifications are archived for debugging and credentials are loaded from environment variables.

When to use it

  • Monitor file changes or application restarts and alert operators immediately
  • Notify on process crashes with exit code and contextual info files
  • Wrap bots or long-running scripts managed by watchexec to add alerts
  • Ensure message formatting works across Telegram (HTML) and Pushover (plain text)
  • Troubleshoot delivery or escaping issues across both channels

Best practices

  • Use HTML parse_mode for Telegram and escape only &, <, >
  • Strip all HTML tags before sending to Pushover (plain text only)
  • Load BOT_TOKEN, CHAT_ID, and Pushover keys from env vars or a secret manager
  • Run notify commands in background (fire-and-forget) to avoid blocking restarts
  • Archive outgoing messages and log delivery attempts for debugging
  • Use stat-based file detection on macOS instead of find -newermt

Example use cases

  • A watchexec wrapper that restarts a Python bot and notifies a dev channel on crashes
  • File watcher that announces critical config file edits to Telegram and Pushover
  • CI helper that alerts on build script failures via both channels
  • Operational script that logs and forwards restart reasons and exit codes
  • Debugging tool that shows escaped filenames with special chars in alerts

FAQ

Why use HTML for Telegram instead of Markdown?

HTML requires escaping only &, <, > while Markdown needs many more escapes for punctuation and special characters, making HTML simpler and more reliable.

How do I prevent notifications from blocking restarts?

Invoke the notify script with an ampersand (&) so it runs in the background and does not block watchexec from restarting the process.