OverviewHistoryStatsSecurity
npx skills add ...
Documentation
SKILL.md
npx skills add yeachan-heo/oh-my-claudecode --skill configure-notifications
Configure notification integrations (Telegram, Discord, Slack) via natural language
npx skills add yeachan-heo/oh-my-claudecode --skill configure-notifications
Set up OMC notification integrations so you're alerted when sessions end, need input, or complete background tasks.
Detect which provider the user wants based on their request or argument:
Question: "Which notification service would you like to configure?"
Options:
Set up Telegram notifications so OMC can message you when sessions end, need input, or complete background tasks.
This is an interactive, natural-language configuration skill. Walk the user through setup by asking questions with AskUserQuestion. Write the result to ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.
If existing config is found, show the user what's currently configured and ask if they want to update or reconfigure.
Guide the user through creating a bot if they don't have one:
Use AskUserQuestion:
Question: "Paste your Telegram bot token (from @BotFather)"
The user will type their token in the "Other" field.
Validate the token:
digits:alphanumeric (e.g., 123456789:ABCdefGHI...)Use AskUserQuestion:
Question: "Paste your Telegram chat ID (the number from getUpdates API)"
The user will type their chat ID in the "Other" field.
Validate the chat ID:
Use AskUserQuestion:
Question: "Which message format do you prefer?"
Options:
Use AskUserQuestion with multiSelect:
Question: "Which events should trigger Telegram notifications?"
Options (multiSelect: true):
Default selection: session-end + ask-user-question.
Read the existing config, merge the new Telegram settings, and write back:
For each event NOT selected, disable it:
After writing config, offer to send a test notification:
Use AskUserQuestion:
Question: "Send a test notification to verify the setup?"
Options:
Report success or failure. Common issues:
/start to the botDisplay the final configuration summary:
Users can skip this wizard entirely by setting env vars in their shell profile:
Env vars are auto-detected by the notification system without needing .omc-config.json.
Set up Discord notifications so OMC can ping you when sessions end, need input, or complete background tasks.
This is an interactive, natural-language configuration skill. Walk the user through setup by asking questions with AskUserQuestion. Write the result to ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.
If existing config is found, show the user what's currently configured and ask if they want to update or reconfigure.
Use AskUserQuestion:
Question: "How would you like to send Discord notifications?"
Options:
If user chose Webhook:
Use AskUserQuestion:
Question: "Paste your Discord webhook URL. To create one: Server Settings > Integrations > Webhooks > New Webhook > Copy URL"
The user will type their webhook URL in the "Other" field.
Validate the URL:
https://discord.com/api/webhooks/ or https://discordapp.com/api/webhooks/If user chose Bot API:
Ask two questions:
Use AskUserQuestion:
Question: "Would you like notifications to mention (ping) someone?"
Options:
Ask: "What is the Discord user ID to mention? (Right-click user > Copy User ID, requires Developer Mode)"
The mention format is: <@USER_ID> (e.g., <@1465264645320474637>)
Ask: "What is the Discord role ID to mention? (Server Settings > Roles > right-click role > Copy Role ID)"
The mention format is: <@&ROLE_ID> (e.g., <@&123456789>)
Use AskUserQuestion with multiSelect:
Question: "Which events should trigger Discord notifications?"
Options (multiSelect: true):
Default selection: session-end + ask-user-question.
Use AskUserQuestion:
Question: "Custom bot display name? (Shows as the webhook sender name in Discord)"
Options:
Read the existing config, merge the new Discord settings, and write back:
Build the notifications object with the collected values and merge into .omc-config.json using jq:
For each event NOT selected, disable it:
After writing config, offer to send a test notification:
Use AskUserQuestion:
Question: "Send a test notification to verify the setup?"
Options:
Report success or failure. If it fails, help the user debug (check URL, permissions, etc.).
Display the final configuration summary:
Users can skip this wizard entirely by setting env vars in their shell profile:
Webhook method:
Bot API method:
Env vars are auto-detected by the notification system without needing .omc-config.json.
Set up Slack notifications so OMC can message you when sessions end, need input, or complete background tasks.
This is an interactive, natural-language configuration skill. Walk the user through setup by asking questions with AskUserQuestion. Write the result to ${CLAUDE_CONFIG_DIR:-~/.claude}/.omc-config.json.
If existing config is found, show the user what's currently configured and ask if they want to update or reconfigure.
Guide the user through creating a webhook if they don't have one:
Use AskUserQuestion:
Question: "Paste your Slack incoming webhook URL (starts with https://hooks.slack.com/services/...)"
The user will type their webhook URL in the "Other" field.
Validate the URL:
https://hooks.slack.com/services/Use AskUserQuestion:
Question: "Would you like notifications to mention (ping) someone?"
Options:
Ask: "What is the Slack member ID to mention? (Click on a user's profile > More (⋯) > Copy member ID)"
The mention format is: <@MEMBER_ID> (e.g., <@U1234567890>)
The mention format is: <!channel>
The mention format is: <!here>
Use AskUserQuestion with multiSelect:
Question: "Which events should trigger Slack notifications?"
Options (multiSelect: true):
Default selection: session-end + ask-user-question.
Use AskUserQuestion:
Question: "Override the default notification channel? (The webhook already has a default channel)"
Options:
If override, ask for the channel name (e.g., #alerts).
Use AskUserQuestion:
Question: "Custom bot display name? (Shows as the webhook sender name in Slack)"
Options:
Read the existing config, merge the new Slack settings, and write back:
For each event NOT selected, disable it:
After writing config, offer to send a test notification:
Use AskUserQuestion:
Question: "Send a test notification to verify the setup?"
Options:
Report success or failure. Common issues:
Display the final configuration summary:
Users can skip this wizard entirely by setting env vars in their shell profile:
Env vars are auto-detected by the notification system without needing .omc-config.json.
| Type | Format | Example |
|---|---|---|
| User | <@MEMBER_ID> | <@U1234567890> |
| Channel | <!channel> | <!channel> |
| Here | <!here> | <!here> |
| Everyone | <!everyone> | <!everyone> |
| User Group | <!subteam^GROUP_ID> | <!subteam^S1234567890> |
All notification platforms require activation via CLI flags per session:
omc --telegram — Activates Telegram notifications (sets OMC_TELEGRAM=1)omc --discord — Activates Discord notifications (sets OMC_DISCORD=1)omc --slack — Activates Slack notifications (sets OMC_SLACK=1)omc --webhook — Activates webhook notifications (sets OMC_WEBHOOK=1)omc --openclaw — Activates OpenClaw gateway integration (sets OMC_OPENCLAW=1)Without these flags, configured platforms remain dormant. This prevents unwanted notifications during development while keeping configuration persistent.
Examples:
omc --telegram --discord — Telegram + Discord activeomc --telegram --slack --webhook — Telegram + Slack + Webhook activeomc --telegram --openclaw — Telegram + OpenClaw activeomc — No notifications sent (all platforms require explicit activation)Customize notification messages per event and per platform using omc_config.hook.json.
If the trigger or argument contains "hook", "template", or "customize messages" → follow this section.
Check if ${CLAUDE_CONFIG_DIR:-~/.claude}/omc_config.hook.json exists. If it does, show the current configuration. If not, explain what it does.
Use AskUserQuestion:
Question: "Which event would you like to configure templates for?"
Options:
Display the template variables available for the chosen event:
Use AskUserQuestion:
Question: "Enter the message template for this event (use {{variables}} for dynamic content)"
Options:
If "Simple summary", use a pre-built compact template:
{{projectDisplay}} session ended ({{duration}}) — {{reasonDisplay}}Input needed on {{projectDisplay}}: {{question}}{{projectDisplay}} is idle. {{#if reason}}Reason: {{reason}}{{/if}}Session started: {{projectDisplay}} at {{time}}Use AskUserQuestion:
Question: "Do you want different messages for specific platforms?"
Options:
If per-platform: ask for each enabled platform's template separately.
Read or create ${CLAUDE_CONFIG_DIR:-~/.claude}/omc_config.hook.json and merge the new settings:
Validate the template using validateTemplate() to check for unknown variables. If any are found, warn the user and offer to correct.
Offer to send a test notification with the new template.
/oh-my-claudecode:configure-openclaw — Configure OpenClaw gateway integrationConfigure custom webhooks and CLI commands for services beyond the native Discord/Telegram/Slack integrations.
If the user says "custom integration", "openclaw", "n8n", "webhook", "cli command", or similar → follow this section.
If ~/.claude/omc_config.openclaw.json exists, detect and offer migration:
Step 1: Detect Legacy Config
Step 2: Offer Migration If legacy found and not migrated:
Question: "Existing OpenClaw configuration detected. Would you like to migrate it to the new format?"
Options:
If migrate:
omc_config.openclaw.json.omc-config.jsonomc_config.openclaw.json.bakStep 1: Select Integration Type
Question: "Which type of custom integration would you like to configure?"
Options:
Step 2: Gateway URL
Question: "What is your gateway/webhook URL?"
Validation:
Step 3: Authentication (Optional)
Question: "Does your gateway require authentication?"
Options:
If Bearer: ask for token If Custom: ask for header name and value
Step 4: Events
Use AskUserQuestion with multiSelect:
Question: "Which events should trigger this integration?"
Options (with defaults from preset):
Default for OpenClaw: session-start, session-end, stop Default for n8n: session-end, ask-user-question
Step 5: Test
Question: "Send a test notification to verify the configuration?"
Options:
If test:
Show result (HTTP status, any error).
Step 6: Write Configuration
Merge into .omc-config.json:
Step 2: URL Ask for webhook URL (HTTPS required).
Step 3: Method Ask for HTTP method (GET, POST, PUT, PATCH, DELETE). Default: POST.
Step 4: Headers Ask for headers in "Name: Value" format, one per line. Default: Content-Type: application/json
Step 5: Body Template Show available template variables and ask for body template (JSON or other format).
Default:
Step 6: Timeout Ask for timeout in milliseconds (1000-60000). Default: 10000.
Step 7: Events Multi-select events.
Step 8: Test and Save Same as preset flow.
Step 2: Command
Question: "What command should be executed? (single executable, no arguments)"
Example: curl, /usr/local/bin/my-script, notify-send
Validation:
Step 3: Arguments
Question: "Command arguments (use {{variable}} for dynamic values). Enter one per line."
Example:
Show available template variables reference.
Step 4: Timeout Ask for timeout (1000-60000ms). Default: 5000.
Step 5: Events Multi-select events.
Step 6: Test and Save
For test, execute command with test values:
Show stdout/stderr and exit code.
List existing:
Disable/Enable:
Remove:
All custom integrations support these template variables:
| Variable | Description | Example |
|---|---|---|
{{sessionId}} | Unique session ID | sess_abc123 |
{{projectPath}} | Full project path | /home/user/my-project |
{{projectName}} | Project directory name | my-project |
{{timestamp}} | ISO 8601 timestamp | 2026-03-05T14:30:00Z |
{{event}} | Event name | session-end |
{{duration}} | Human-readable duration | 45s |
{{durationMs}} | Duration in milliseconds | 45000 |
{{reason}} | Stop/end reason | completed |
{{tmuxSession}} | tmux session name | claude:my-project |
Session-end only:
{{agentsSpawned}}, {{agentsCompleted}}, {{modesUsed}}, {{contextSummary}}Ask-user-question only:
{{question}}src/notifications/template-variables.tssrc/notifications/validation.tssrc/notifications/presets.tsTo set up Telegram notifications, you need a Telegram bot token and your chat ID.
CREATE A BOT (if you don't have one):
1. Open Telegram and search for @BotFather
2. Send /newbot
3. Choose a name (e.g., "My OMC Notifier")
4. Choose a username (e.g., "my_omc_bot")
5. BotFather will give you a token like: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz
GET YOUR CHAT ID:
1. Start a chat with your new bot (send /start)
2. Visit: https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates
3. Look for "chat":{"id":YOUR_CHAT_ID}
- Personal chat IDs are positive numbers (e.g., 123456789)
- Group chat IDs are negative numbers (e.g., -1001234567890)# Help user find their chat ID
BOT_TOKEN="USER_PROVIDED_TOKEN"
echo "Fetching recent messages to find your chat ID..."
curl -s "https://api.telegram.org/bot${BOT_TOKEN}/getUpdates" | jq '.result[-1].message.chat.id // .result[-1].message.from.id // "No messages found - send /start to your bot first"'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 are collected from user
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"# Example: disable session-start if not selected
echo "$(cat "$CONFIG_FILE")" | jq \
'.notifications.events = (.notifications.events // {}) |
.notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"# Example: disable session-start if not selected
echo "$(cat "$CONFIG_FILE")" | jq \
'.notifications.events = (.notifications.events // {}) |
.notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"# Example: disable session-start if not selected
echo "$(cat "$CONFIG_FILE")" | jq \
'.notifications.events = (.notifications.events // {}) |
.notifications.events["session-start"] = {enabled: false}' > "$CONFIG_FILE"BOT_TOKEN="USER_PROVIDED_TOKEN"
CHAT_ID="USER_PROVIDED_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 test notification - Telegram is configured!")
HTTP_CODE=$(echo "$RESPONSE" | tail -1)
BODY=$(echo "$RESPONSE" | head -1)
if [ "$HTTP_CODE" = "200" ]; then
echo "Test notification sent successfully!"
else
echo "Failed (HTTP $HTTP_CODE):"
echo "$BODY" | jq -r '.description // "Unknown error"' 2>/dev/null || echo "$BODY"
fiTelegram Notifications Configured!
Bot: @your_bot_username
Chat ID: 123456789
Format: Markdown
Events: session-end, ask-user-question
Config saved to: ~/.claude/.omc-config.json
You can also set these via environment variables:
OMC_TELEGRAM_BOT_TOKEN=123456789:ABCdefGHI...
OMC_TELEGRAM_CHAT_ID=123456789
To reconfigure: /oh-my-claudecode:configure-notifications telegram
To configure Discord: /oh-my-claudecode:configure-notifications discord
To configure Slack: /oh-my-claudecode:configure-notifications slackexport OMC_TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"
export OMC_TELEGRAM_CHAT_ID="123456789"CONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
if [ -f "$CONFIG_FILE" ]; then
# Check for existing discord config
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"
fiCONFIG_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# WEBHOOK_URL, MENTION, USERNAME are collected from user
# EVENTS is the list of enabled events
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"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"# For webhook:
curl -s -o /dev/null -w "%{http_code}" \
-H "Content-Type: application/json" \
-d "{\"content\": \"${MENTION:+$MENTION\\n}OMC test notification - Discord is configured!\"}" \
"$WEBHOOK_URL"Discord Notifications Configured!
Method: Webhook / Bot API
Mention: <@1465264645320474637> (or "none")
Events: session-end, ask-user-question
Username: OMC
Config saved to: ~/.claude/.omc-config.json
You can also set these via environment variables:
OMC_DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/...
OMC_DISCORD_MENTION=<@1465264645320474637>
To reconfigure: /oh-my-claudecode:configure-notifications discord
To configure Telegram: /oh-my-claudecode:configure-notifications telegram
To configure Slack: /oh-my-claudecode:configure-notifications slackexport OMC_DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/..."
export OMC_DISCORD_MENTION="<@1465264645320474637>" # optionalexport OMC_DISCORD_NOTIFIER_BOT_TOKEN="your-bot-token"
export OMC_DISCORD_NOTIFIER_CHANNEL="your-channel-id"
export OMC_DISCORD_MENTION="<@1465264645320474637>" # optionalCONFIG_FILE="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.omc-config.json"
if [ -f "$CONFIG_FILE" ]; then
HAS_SLACK=$(jq -r '.notifications.slack.enabled // false' "$CONFIG_FILE" 2>/dev/null)
WEBHOOK_URL=$(jq -r '.notifications.slack.webhookUrl // empty' "$CONFIG_FILE" 2>/dev/null)
MENTION=$(jq -r '.notifications.slack.mention // empty' "$CONFIG_FILE" 2>/dev/null)
CHANNEL=$(jq -r '.notifications.slack.channel // empty' "$CONFIG_FILE" 2>/dev/null)
if [ "$HAS_SLACK" = "true" ]; then
echo "EXISTING_CONFIG=true"
[ -n "$WEBHOOK_URL" ] && echo "WEBHOOK_URL=$WEBHOOK_URL"
[ -n "$MENTION" ] && echo "MENTION=$MENTION"
[ -n "$CHANNEL" ] && echo "CHANNEL=$CHANNEL"
else
echo "EXISTING_CONFIG=false"
fi
else
echo "NO_CONFIG_FILE"
fiTo set up Slack notifications, you need a Slack incoming webhook URL.
CREATE A WEBHOOK:
1. Go to https://api.slack.com/apps
2. Click "Create New App" > "From scratch"
3. Name your app (e.g., "OMC Notifier") and select your workspace
4. Go to "Incoming Webhooks" in the left sidebar
5. Toggle "Activate Incoming Webhooks" to ON
6. Click "Add New Webhook to Workspace"
7. Select the channel where notifications should be posted
8. Copy the webhook URL (starts with https://hooks.slack.com/services/...)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
# WEBHOOK_URL, MENTION, USERNAME, CHANNEL are collected from user
echo "$EXISTING" | jq \
--arg url "$WEBHOOK_URL" \
--arg mention "$MENTION" \
--arg username "$USERNAME" \
--arg channel "$CHANNEL" \
'.notifications = (.notifications // {enabled: true}) |
.notifications.enabled = true |
.notifications.slack = {
enabled: true,
webhookUrl: $url,
mention: (if $mention == "" then null else $mention end),
username: (if $username == "" then null else $username end),
channel: (if $channel == "" then null else $channel end)
}' > "$CONFIG_FILE"# For webhook:
MENTION_PREFIX=""
if [ -n "$MENTION" ]; then
MENTION_PREFIX="${MENTION}\n"
fi
curl -s -o /dev/null -w "%{http_code}" \
-H "Content-Type: application/json" \
-d "{\"text\": \"${MENTION_PREFIX}OMC test notification - Slack is configured!\"}" \
"$WEBHOOK_URL"Slack Notifications Configured!
Webhook: https://hooks.slack.com/services/T00/B00/xxx...
Mention: <@U1234567890> (or "none")
Channel: #alerts (or "webhook default")
Events: session-end, ask-user-question
Username: OMC
Config saved to: ~/.claude/.omc-config.json
You can also set these via environment variables:
OMC_SLACK_WEBHOOK_URL=https://hooks.slack.com/services/...
OMC_SLACK_MENTION=<@U1234567890>
To reconfigure: /oh-my-claudecode:configure-notifications slack
To configure Discord: /oh-my-claudecode:configure-notifications discord
To configure Telegram: /oh-my-claudecode:configure-notifications telegramexport OMC_SLACK_WEBHOOK_URL="https://hooks.slack.com/services/T00/B00/xxx"
export OMC_SLACK_MENTION="<@U1234567890>" # optionalHook event templates let you customize the notification messages sent to each platform.
You can set different messages for Discord vs Telegram vs Slack, and control which
events fire on which platform.
Config file: ~/.claude/omc_config.hook.jsonAvailable template variables:
RAW FIELDS:
{{sessionId}} - Session identifier
{{timestamp}} - ISO timestamp
{{tmuxSession}} - tmux session name
{{projectPath}} - Full project directory path
{{projectName}} - Project directory basename
{{reason}} - Stop/end reason
{{activeMode}} - Active OMC mode name
{{question}} - Question text (ask-user-question only)
{{agentName}} - Agent name (agent-call only)
{{agentType}} - Agent type (agent-call only)
COMPUTED (smart formatting):
{{duration}} - Human-readable duration (e.g., "5m 23s")
{{time}} - Locale time string
{{modesDisplay}} - Comma-separated modes or empty
{{iterationDisplay}} - "3/10" format or empty
{{agentDisplay}} - "2/5 completed" or empty
{{projectDisplay}} - Project name with fallbacks
{{footer}} - tmux + project info line
{{tmuxTailBlock}} - Recent output in code fence or empty
{{reasonDisplay}} - Reason with "unknown" fallback
CONDITIONALS:
{{#if variableName}}content shown when truthy{{/if}}{
"version": 1,
"enabled": true,
"events": {
"<event-name>": {
"enabled": true,
"template": "<user-provided-template>",
"platforms": {
"discord": { "template": "<discord-specific>" },
"telegram": { "template": "<telegram-specific>" }
}
}
}
}{
"version": 1,
"enabled": true,
"events": {
"session-end": {
"enabled": true,
"template": "Session {{sessionId}} ended after {{duration}}. Reason: {{reasonDisplay}}",
"platforms": {
"discord": {
"template": "**Session Complete** | `{{projectDisplay}}` | {{duration}} | {{reasonDisplay}}"
},
"telegram": {
"template": "Done: {{projectDisplay}} ({{duration}})\n{{#if contextSummary}}Summary: {{contextSummary}}{{/if}}"
}
}
},
"ask-user-question": {
"enabled": true,
"template": "{{#if question}}{{question}}{{/if}}\nWaiting for input on {{projectDisplay}}"
}
}
}LEGACY_CONFIG="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/omc_config.openclaw.json"
if [ -f "$LEGACY_CONFIG" ]; then
echo "LEGACY_FOUND=true"
# Check if already migrated
if jq -e '.customIntegrations.integrations[] | select(.preset == "openclaw")' "$CONFIG_FILE" >/dev/null 2>&1; then
echo "ALREADY_MIGRATED=true"
else
echo "ALREADY_MIGRATED=false"
fi
else
echo "LEGACY_FOUND=false"
fi# For webhook integrations
curl -X POST \
-H "Content-Type: application/json" \
${AUTH_HEADER:+"-H \"$AUTH_HEADER\""} \
-d '{"event":"test","instruction":"OMC test notification","timestamp":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"}' \
"$WEBHOOK_URL"{
"notifications": { /* existing native configs */ },
"customIntegrations": {
"enabled": true,
"integrations": [
{
"id": "my-openclaw",
"type": "webhook",
"preset": "openclaw",
"enabled": true,
"config": {
"url": "https://my-gateway.example.com/wake",
"method": "POST",
"headers": {
"Content-Type": "application/json",
"Authorization": "Bearer ..."
},
"bodyTemplate": "{\\"event\\":\\"{{event}}\\",\\"instruction\\":\\"Session {{sessionId}} {{event}}\\
"timeout": 10000
},
"events": ["session-start", "session-end"]
}
]
}
}{
"event": "{{event}}",
"sessionId": "{{sessionId}}",
"projectName": "{{projectName}}",
"timestamp": "{{timestamp}}"
}-X
POST
-d
{"event":"{{event}}","session":"{{sessionId}}"}
https://my-api.com/notify$COMMAND "${ARGS[@]//{{event}}/test}"jq '.customIntegrations.integrations[] | {id, type, preset, enabled, events}' "$CONFIG_FILE"# Disable
jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | if .id == "my-integration" then .enabled = false else . end]' "$CONFIG_FILE"
# Enable
jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | if .id == "my-integration" then .enabled = true else . end]' "$CONFIG_FILE"jq '.customIntegrations.integrations = [.customIntegrations.integrations[] | select(.id != "my-integration")]' "$CONFIG_FILE"