feat(webhook): add Discord notifications for config parse errors

- Extract webhook logic into dedicated src/webhook.rs module
- Fix Discord payload format (use embeds instead of text field)
- Add runner-level webhook config for config error notifications
- Send orange-colored notification when rollcron.yaml parsing fails

Author: aster-void

CLAUDE.md

@@ -17,11 +17,12 @@ src/
 │   └── job/                # Job Actor - single job control
 │       ├── mod.rs          # Actor definition, state machine
 │       ├── tick.rs         # cron evaluation, jitter
-│       └── executor.rs     # command execution, retry, timeout, logging
+│       └── executor.rs     # command execution, retry, timeout
 ├── config.rs               # YAML config parsing, Job struct
 ├── git.rs                  # Git operations (clone, pull, archive)
 ├── env.rs                  # Environment variable handling
-└── logging.rs              # Logging setup
+├── logging.rs              # Logging setup
+└── webhook.rs              # Discord webhook notifications
 ```
 
 ## Key Types
@@ -163,7 +164,9 @@ jobs:
 
 ## Webhooks
 
-Webhooks send notifications on job failure. Configure at runner level (inherited by all jobs) or job level.
+Webhooks send Discord notifications for:
+- **Job failures** (after all retries exhausted)
+- **Config parse errors** (runner-level webhooks only)
 
 ```yaml
 runner:
@@ -174,9 +177,11 @@ runner:
 
 **Format**: `{ type?: "discord", url: string }` where `type` defaults to "discord".
 
-**Payload**: JSON with `text`, `job_id`, `job_name`, `error`, `stderr`, `attempts`.
+**Payloads**:
+- Job failure: Discord embed (red) with Job, Attempts, Error, Stderr fields
+- Config error: Discord embed (orange) with Error field
 
-**Inheritance**: Job webhooks extend runner webhooks (both are notified).
+**Inheritance**: Job webhooks extend runner webhooks (both are notified on job failure).
 
 ## Environment Variables
 

src/actor/job/executor.rs

@@ -1,5 +1,4 @@
 use rand::Rng;
-use serde::Serialize;
 use std::collections::HashMap;
 use std::fs::{self, File, OpenOptions};
 use std::io::Write;
@@ -12,21 +11,11 @@ use tracing::{debug, error, info, warn};
 use crate::config::{Job, RetryConfig, RunnerConfig};
 use crate::env;
 use crate::git;
+use crate::webhook::{self, JobFailure};
 
 /// Default jitter ratio when not explicitly configured (25% of base delay)
 const AUTO_JITTER_RATIO: u32 = 25;
 
-/// Webhook notification payload
-#[derive(Debug, Serialize)]
-pub struct WebhookPayload {
-    pub text: String,
-    pub job_id: String,
-    pub job_name: String,
-    pub error: String,
-    pub stderr: String,
-    pub attempts: u32,
-}
-
 pub async fn execute_job(job: &Job, sot_path: &PathBuf, runner: &RunnerConfig) -> bool {
     let job_dir = git::get_job_dir(sot_path, &job.id);
     let work_dir = resolve_work_dir(sot_path, &job.id, &job.working_dir);
@@ -100,18 +89,17 @@ pub async fn execute_job(job: &Job, sot_path: &PathBuf, runner: &RunnerConfig) -
             None => ("unknown error".to_string(), String::new()),
         };
 
-        let payload = WebhookPayload {
-            text: format!("[rollcron] Job '{}' failed", job.name),
-            job_id: job.id.clone(),
-            job_name: job.name.clone(),
+        let failure = JobFailure {
+            job_id: &job.id,
+            job_name: &job.name,
             error,
             stderr,
             attempts: max_attempts,
         };
 
         let runner_env = load_runner_env_vars(sot_path, runner);
-        for webhook in &job.webhook {
-            let url = webhook.to_url(runner_env.as_ref());
+        for wh in &job.webhook {
+            let url = wh.to_url(runner_env.as_ref());
             if url.contains('$') {
                 warn!(
                     target: "rollcron::webhook",
@@ -130,7 +118,7 @@ pub async fn execute_job(job: &Job, sot_path: &PathBuf, runner: &RunnerConfig) -
                 );
                 continue;
             }
-            send_webhook(&url, &payload).await;
+            webhook::send_job_failure(&url, &failure).await;
         }
     }
 
@@ -376,23 +364,6 @@ fn create_log_file(job_dir: &PathBuf, log_path: &str, max_size: u64) -> Option<F
     }
 }
 
-// === Webhook ===
-
-async fn send_webhook(url: &str, payload: &WebhookPayload) {
-    let client = reqwest::Client::new();
-    match client.post(url).json(payload).send().await {
-        Ok(resp) if resp.status().is_success() => {
-            info!(target: "rollcron::webhook", url = %url, "Notification sent");
-        }
-        Ok(resp) => {
-            error!(target: "rollcron::webhook", url = %url, status = %resp.status(), "Failed to send notification");
-        }
-        Err(e) => {
-            error!(target: "rollcron::webhook", url = %url, error = %e, "Failed to send notification");
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -427,6 +398,7 @@ mod tests {
             timezone: TimezoneConfig::Utc,
             env_file: None,
             env: None,
+            webhook: vec![],
         }
     }
 

src/actor/runner/git_poll.rs

@@ -1,18 +1,19 @@
-use super::ConfigUpdate;
-use crate::config;
-use crate::git;
+use super::{ConfigUpdate, GetRunnerConfig};
+use crate::config::{self, RunnerConfig};
+use crate::{env, git, webhook};
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::time::Duration;
 use tokio::time::interval;
-use tracing::{error, info};
+use tracing::{error, info, warn};
 use xtra::prelude::*;
 use xtra::refcount::Weak;
 
 const CONFIG_FILE: &str = "rollcron.yaml";
 
 pub async fn run<A>(source: String, pull_interval: Duration, addr: Address<A, Weak>)
 where
-    A: Handler<ConfigUpdate>,
+    A: Handler<ConfigUpdate> + Handler<GetRunnerConfig, Return = RunnerConfig>,
 {
     let mut ticker = interval(pull_interval);
 
@@ -48,11 +49,64 @@ where
             }
             Err(e) => {
                 error!(target: "rollcron::runner", error = %e, "Failed to reload config");
+                notify_config_error(&addr, &sot_path, &e.to_string()).await;
             }
         }
     }
 }
 
+async fn notify_config_error<A>(addr: &Address<A, Weak>, sot_path: &PathBuf, error: &str)
+where
+    A: Handler<GetRunnerConfig, Return = RunnerConfig>,
+{
+    let runner = match addr.send(GetRunnerConfig).await {
+        Ok(r) => r,
+        Err(_) => return, // Runner stopped
+    };
+
+    if runner.webhook.is_empty() {
+        return;
+    }
+
+    let runner_env = load_runner_env(sot_path, &runner);
+    for wh in &runner.webhook {
+        let url = wh.to_url(runner_env.as_ref());
+        if url.contains('$') {
+            warn!(target: "rollcron::webhook", url = %url, "Webhook URL contains unexpanded variable, skipping");
+            continue;
+        }
+        if !url.starts_with("http://") && !url.starts_with("https://") {
+            warn!(target: "rollcron::webhook", url = %url, "Webhook URL must start with http:// or https://, skipping");
+            continue;
+        }
+        webhook::send_config_error(&url, error).await;
+    }
+}
+
+fn load_runner_env(sot_path: &PathBuf, runner: &RunnerConfig) -> Option<HashMap<String, String>> {
+    let mut env_vars = HashMap::new();
+
+    if let Some(env_file_path) = &runner.env_file {
+        let expanded = env::expand_string(env_file_path);
+        let full_path = sot_path.join(&expanded);
+        match env::load_env_from_path(&full_path) {
+            Ok(vars) => env_vars.extend(vars),
+            Err(e) => {
+                warn!(target: "rollcron::webhook", error = %e, "Failed to load runner env_file");
+                return None;
+            }
+        }
+    }
+
+    if let Some(runner_env) = &runner.env {
+        for (k, v) in runner_env {
+            env_vars.insert(k.clone(), env::expand_string(v));
+        }
+    }
+
+    Some(env_vars)
+}
+
 fn load_config(sot_path: &PathBuf) -> anyhow::Result<(config::RunnerConfig, Vec<config::Job>)> {
     let config_path = sot_path.join(CONFIG_FILE);
     let content = std::fs::read_to_string(&config_path)

src/actor/runner/mod.rs

@@ -199,6 +199,17 @@ impl Handler<GetJobActors> for RunnerActor {
     }
 }
 
+/// Get runner config for webhook notifications
+pub struct GetRunnerConfig;
+
+impl Handler<GetRunnerConfig> for RunnerActor {
+    type Return = RunnerConfig;
+
+    async fn handle(&mut self, _msg: GetRunnerConfig, _ctx: &mut Context<Self>) -> Self::Return {
+        self.runner_config.clone()
+    }
+}
+
 /// Respawn a job actor that died unexpectedly
 pub struct RespawnJob {
     pub job_id: String,

src/config.rs

@@ -81,6 +81,7 @@ pub struct RunnerConfig {
     pub timezone: TimezoneConfig,
     pub env_file: Option<String>,
     pub env: Option<HashMap<String, String>>,
+    pub webhook: Vec<WebhookConfig>,
 }
 
 #[derive(Debug, Deserialize, Default)]
@@ -205,6 +206,7 @@ pub fn parse_config(content: &str) -> Result<(RunnerConfig, Vec<Job>)> {
         timezone: timezone.clone(),
         env_file: config.runner.env_file,
         env: config.runner.env,
+        webhook: runner_webhook.clone(),
     };
 
     let jobs = config

src/main.rs

@@ -3,6 +3,7 @@ mod config;
 mod env;
 mod git;
 mod logging;
+mod webhook;
 
 use actor::runner::{GracefulShutdown, Initialize, RunnerActor};
 use anyhow::{Context, Result};

src/webhook.rs

@@ -0,0 +1,121 @@
+//! Discord webhook notifications.
+
+use serde::Serialize;
+use tracing::{error, info};
+
+/// Information about a failed job.
+pub struct JobFailure<'a> {
+    pub job_id: &'a str,
+    pub job_name: &'a str,
+    pub error: String,
+    pub stderr: String,
+    pub attempts: u32,
+}
+
+/// Send a Discord notification for a job failure.
+pub async fn send_job_failure(url: &str, failure: &JobFailure<'_>) {
+    let payload = build_job_failure_payload(failure);
+    send_discord(url, &payload).await;
+}
+
+/// Send a Discord notification for a config parse error.
+pub async fn send_config_error(url: &str, error: &str) {
+    let payload = build_config_error_payload(error);
+    send_discord(url, &payload).await;
+}
+
+async fn send_discord(url: &str, payload: &DiscordPayload) {
+    let client = reqwest::Client::new();
+    match client.post(url).json(payload).send().await {
+        Ok(resp) if resp.status().is_success() => {
+            info!(target: "rollcron::webhook", url = %url, "Notification sent");
+        }
+        Ok(resp) => {
+            error!(target: "rollcron::webhook", url = %url, status = %resp.status(), "Failed to send notification");
+        }
+        Err(e) => {
+            error!(target: "rollcron::webhook", url = %url, error = %e, "Failed to send notification");
+        }
+    }
+}
+
+// === Internal ===
+
+#[derive(Serialize)]
+struct DiscordPayload {
+    embeds: Vec<DiscordEmbed>,
+}
+
+#[derive(Serialize)]
+struct DiscordEmbed {
+    title: String,
+    color: u32,
+    fields: Vec<DiscordField>,
+}
+
+#[derive(Serialize)]
+struct DiscordField {
+    name: &'static str,
+    value: String,
+    inline: bool,
+}
+
+fn build_job_failure_payload(failure: &JobFailure<'_>) -> DiscordPayload {
+    let mut fields = vec![
+        DiscordField {
+            name: "Job",
+            value: format!("`{}`", failure.job_id),
+            inline: true,
+        },
+        DiscordField {
+            name: "Attempts",
+            value: failure.attempts.to_string(),
+            inline: true,
+        },
+        DiscordField {
+            name: "Error",
+            value: failure.error.clone(),
+            inline: false,
+        },
+    ];
+
+    if !failure.stderr.is_empty() {
+        let truncated = truncate(&failure.stderr, 1000);
+        fields.push(DiscordField {
+            name: "Stderr",
+            value: format!("```\n{}\n```", truncated),
+            inline: false,
+        });
+    }
+
+    DiscordPayload {
+        embeds: vec![DiscordEmbed {
+            title: format!("[rollcron] Job '{}' failed", failure.job_name),
+            color: 0xED4245, // Discord red
+            fields,
+        }],
+    }
+}
+
+fn build_config_error_payload(err: &str) -> DiscordPayload {
+    let truncated = truncate(err, 1000);
+    DiscordPayload {
+        embeds: vec![DiscordEmbed {
+            title: "[rollcron] Config parse error".to_string(),
+            color: 0xFFA500, // Orange
+            fields: vec![DiscordField {
+                name: "Error",
+                value: format!("```\n{}\n```", truncated),
+                inline: false,
+            }],
+        }],
+    }
+}
+
+fn truncate(s: &str, max_len: usize) -> &str {
+    if s.len() <= max_len {
+        s
+    } else {
+        &s[..max_len]
+    }
+}