Webhooks: Discord and Slack formats (Discord hooks switched over), a masked URL that wraps, the last delivery in the table, an edit form, and web issue events delivered 9756c67d3aec

-- The body a webhook receives (hub spec §12.2): `oxygenhub` (the signed

-- envelope), `discord` or `slack`. Discord and Slack webhooks made before

-- formats existed switch to their format, since they never accepted the envelope.

ALTER TABLE hooks ADD COLUMN format TEXT NOT NULL DEFAULT 'oxygenhub' CHECK (format IN ('oxygenhub', 'discord', 'slack'));

UPDATE hooks SET format = 'discord'

 WHERE url LIKE 'https://discord.com/api/webhooks/%' OR url LIKE 'https://discordapp.com/api/webhooks/%'

    OR url LIKE 'https://canary.discord.com/api/webhooks/%' OR url LIKE 'https://ptb.discord.com/api/webhooks/%';

UPDATE hooks SET format = 'slack' WHERE url LIKE 'https://hooks.slack.com/%';

    /// `oxygenhub`, `discord` or `slack`.

    pub format: String,

/// The formats a webhook can be delivered in.

pub const FORMATS: [&str; 3] = ["oxygenhub", "discord", "slack"];

/// The format a URL most likely wants: Discord and Slack webhooks accept

/// only their own bodies.

pub fn format_for_url(url: &str) -> &'static str {

    let host = url.split("://").nth(1).unwrap_or("").split(['/', ':']).next().unwrap_or("").to_ascii_lowercase();

    if matches!(host.as_str(), "discord.com" | "discordapp.com" | "canary.discord.com" | "ptb.discord.com")

        && url.contains("/api/webhooks/")

    {

        "discord"

    } else if host == "hooks.slack.com" {

        "slack"

    } else {

        "oxygenhub"

    }

}

/// A URL for display: scheme, host and path, with long segments (the tokens

/// Discord and Slack keep in the path) and any query cut to a few characters.

pub fn masked_url(url: &str) -> String {

    let (scheme, rest) = url.split_once("://").unwrap_or(("", url));

    let (path, query) = rest.split_once('?').map(|(p, q)| (p, Some(q))).unwrap_or((rest, None));

    let parts: Vec<String> =

        path.split('/')

            .enumerate()

            .map(|(i, seg)| {

                if i > 0 && seg.chars().count() > 14 {

                    format!("{}…", seg.chars().take(4).collect::<String>())

                } else {

                    seg.to_string()

                }

            })

            .collect();

    let mut out = if scheme.is_empty() { parts.join("/") } else { format!("{scheme}://{}", parts.join("/")) };

    if query.is_some() {

        out.push_str("?…");

    }

    out

}

    sqlx::query_as("INSERT INTO hooks (repo_id, org_id, url, secret, events, created_ms, format) VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING *")

        .bind(format_for_url(url))

        .await

}

/// Change a hook; `None` keeps the URL or secret as it is.

pub async fn update_hook(

    pool: &Pool,

    id: i64,

    url: Option<&str>,

    secret: Option<&str>,

    events: &str,

    format: &str,

    active: bool,

) -> sqlx::Result<()> {

    sqlx::query("UPDATE hooks SET url = COALESCE(?, url), secret = COALESCE(?, secret), events = ?, format = ?, active = ? WHERE id = ?")

        .bind(url)

        .bind(secret)

        .bind(events)

        .bind(format)

        .bind(active)

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn set_hook_format(pool: &Pool, id: i64, format: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE hooks SET format = ? WHERE id = ?").bind(format).bind(id).execute(pool).await?;

    Ok(())

}

/// The newest delivery that was attempted, for the settings table.

pub async fn last_attempt(pool: &Pool, hook_id: i64) -> sqlx::Result<Option<Delivery>> {

    sqlx::query_as("SELECT * FROM deliveries WHERE hook_id = ? AND attempts > 0 ORDER BY id DESC LIMIT 1")

        .bind(hook_id)

        .fetch_optional(pool)

/// What a chat message says about an event: a title, the page it links

/// to (absolute) and a short detail.

pub fn summary(env: &WebhookEnvelope, base: &str) -> (String, String, String) {

    let repo = env.repository.as_ref().map(|r| format!("{}/{}", r.owner, r.name)).unwrap_or_default();

    let page = |path: &str| format!("{}/{repo}{path}", base.trim_end_matches('/'));

    let d = &env.data;

    let text = |v: &serde_json::Value| v.as_str().unwrap_or("").to_string();

    let num = |v: &serde_json::Value| v.as_i64().unwrap_or(0);

    let actor = if env.actor.is_empty() { "Someone".to_string() } else { env.actor.clone() };

    let issue_n = if d["issue"]["number"].is_i64() { num(&d["issue"]["number"]) } else { num(&d["number"]) };

    let issue_title = text(&d["issue"]["title"]);

    match env.event.as_str() {

        "ping" => (

            "OxygenHub is connected".into(),

            if repo.is_empty() { base.to_string() } else { page("") },

            "Events from OxygenHub will arrive here.".into(),

        ),

        "push" => {

            let lines: Vec<String> = d["updates"]

                .as_array()

                .map(|u| {

                    u.iter()

                        .map(|x| {

                            let n = num(&x["changes"]);

                            format!("{}: {n} change{}", text(&x["reference"]), if n == 1 { "" } else { "s" })

                        })

                        .collect()

                })

                .unwrap_or_default();

            let first = d["updates"][0]["reference"].as_str().unwrap_or("").to_string();

            (format!("{actor} pushed to {repo}"), page(&format!("/changes/{first}")), lines.join("\n"))

        }

        "issue.opened" => {

            (format!("{actor} opened issue #{issue_n}: {issue_title}"), page(&format!("/issue/{issue_n}")), text(&d["issue"]["body"]))

        }

        "issue.closed" | "issue.reopened" | "issue.edited" => {

            let verb = env.event.trim_start_matches("issue.");

            (format!("{actor} {verb} issue #{issue_n}: {issue_title}"), page(&format!("/issue/{issue_n}")), String::new())

        }

        "comment.issue" => {

            let body = if d["comment"]["body"].is_string() { text(&d["comment"]["body"]) } else { String::new() };

            (

                format!(

                    "{actor} commented on issue #{issue_n}{}",

                    if issue_title.is_empty() { String::new() } else { format!(": {issue_title}") }

                ),

                page(&format!("/issue/{issue_n}")),

                body,

            )

        }

        "review" => (

            format!("{actor} reviewed proposal #{}: {}", num(&d["number"]), text(&d["verdict"])),

            page(&format!("/proposal/{}", num(&d["number"]))),

            String::new(),

        ),

        "release.published" => (

            format!("{actor} released {} ({})", text(&d["title"]), text(&d["tag"])),

            page(&format!("/releases/tag/{}", text(&d["tag"]))),

            String::new(),

        ),

        "check" => (

            format!("Check {} {} on {repo}", text(&d["check"]["name"]), text(&d["check"]["status"])),

            text(&d["check"]["url"]).chars().take(500).collect::<String>().replace(' ', "%20"),

            text(&d["check"]["summary"]),

        ),

        e if e.starts_with("proposal.") => {

            let n = num(&d["number"]);

            let verb = e.trim_start_matches("proposal.");

            let title = text(&d["title"]);

            (

                format!("{actor} {verb} proposal #{n}{}", if title.is_empty() { String::new() } else { format!(": {title}") }),

                page(&format!("/proposal/{n}")),

                String::new(),

            )

        }

        e => (format!("{e} on {repo}"), page(""), String::new()),

    }

}

fn cut(s: &str, max: usize) -> String {

    if s.chars().count() <= max {

        s.to_string()

    } else {

        format!("{}…", s.chars().take(max.saturating_sub(1)).collect::<String>())

    }

}

/// The body a hook receives in its format; the envelope itself for `oxygenhub`.

pub fn body_for(format: &str, payload: &str, base: &str) -> String {

    let Ok(env) = serde_json::from_str::<WebhookEnvelope>(payload) else { return payload.to_string() };

    let (title, url, detail) = summary(&env, base);

    let repo = env.repository.as_ref().map(|r| format!("{}/{}", r.owner, r.name)).unwrap_or_else(|| "OxygenHub".into());

    match format {

        "discord" => {

            let mut embed = serde_json::json!({

                "title": cut(&title, 256),

                "description": cut(&detail, 2000),

                "color": 0x0064e0,

                "footer": { "text": cut(&format!("{repo} · {}", env.event), 200) },

                "timestamp": crate::render::time::rfc3339(env.at_ms as u64),

            });

            if url.starts_with("http") {

                embed["url"] = serde_json::Value::String(url);

            }

            // No @everyone, @here or role pings from anything a user typed.

            serde_json::json!({ "username": "OxygenHub", "allowed_mentions": { "parse": [] }, "embeds": [embed] }).to_string()

        }

        "slack" => {

            let esc = |s: &str| s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;");

            let head = if url.starts_with("http") { format!("<{}|{}>", url, esc(&title)) } else { esc(&title) };

            let text = if detail.is_empty() { head } else { format!("{head}\n>{}", esc(&cut(&detail, 1500)).replace('\n', "\n>")) };

            serde_json::json!({ "text": text }).to_string()

        }

        _ => payload.to_string(),

    }

}

        let body = body_for(&hook.format, &d.payload, app.config.base_url());

            .header("x-oxyhub-signature", signature(&hook.secret, body.as_bytes()))

            .body(body)

    fn envelope(event: &str, data: serde_json::Value) -> String {

        serde_json::to_string(&WebhookEnvelope {

            event: event.into(),

            delivery: "d".into(),

            repository: Some(hub_api::Repository {

                owner: "andymccall".into(),

                name: "oxygen".into(),

                description: String::new(),

                default_bookmark: "main".into(),

                visibility: hub_api::Visibility::Public,

                created_ms: 0,

                updated_ms: 0,

                clone_url: String::new(),

            }),

            actor: "andy".into(),

            at_ms: 1_790_000_000_000,

            data,

        })

        .unwrap()

    }

    #[test]

    fn discord_gets_an_embed_without_mentions() {

        let p = envelope(

            "issue.opened",

            serde_json::json!({ "issue": { "number": 12, "title": "@everyone crash", "body": "x".repeat(3000) } }),

        );

        let v: serde_json::Value = serde_json::from_str(&body_for("discord", &p, "https://hub.example:7343/")).unwrap();

        let e = &v["embeds"][0];

        assert_eq!(e["title"], "andy opened issue #12: @everyone crash");

        assert_eq!(e["url"], "https://hub.example:7343/andymccall/oxygen/issue/12");

        assert_eq!(e["description"].as_str().unwrap().chars().count(), 2000, "cut to Discord's limits");

        assert_eq!(v["allowed_mentions"]["parse"], serde_json::json!([]), "no pings from user text");

        assert_eq!(v["username"], "OxygenHub");

        let push = envelope("push", serde_json::json!({ "updates": [{ "reference": "main", "changes": 3 }] }));

        let v: serde_json::Value = serde_json::from_str(&body_for("discord", &push, "https://h")).unwrap();

        assert_eq!(v["embeds"][0]["title"], "andy pushed to andymccall/oxygen");

        assert_eq!(v["embeds"][0]["description"], "main: 3 changes");

        assert_eq!(v["embeds"][0]["url"], "https://h/andymccall/oxygen/changes/main");

        let ping = envelope("ping", serde_json::json!({}));

        assert!(body_for("discord", &ping, "https://h").contains("OxygenHub is connected"));

    }

    #[test]

    fn slack_text_is_escaped_and_the_envelope_is_unchanged() {

        let p = envelope(

            "comment.issue",

            serde_json::json!({ "number": 3, "issue": { "number": 3, "title": "<b>" }, "comment": { "body": "a & b" } }),

        );

        let v: serde_json::Value = serde_json::from_str(&body_for("slack", &p, "https://h")).unwrap();

        assert_eq!(v["text"], "<https://h/andymccall/oxygen/issue/3|andy commented on issue #3: &lt;b&gt;>\n>a &amp; b");

        assert_eq!(body_for("oxygenhub", &p, "https://h"), p);

    }

    #[test]

    fn formats_follow_the_url_and_urls_are_masked() {

        use crate::db::hooks::{format_for_url, masked_url};

        assert_eq!(format_for_url("https://discord.com/api/webhooks/155/abc"), "discord");

        assert_eq!(format_for_url("https://hooks.slack.com/services/T/B/x"), "slack");

        assert_eq!(format_for_url("https://discord.com.evil.example/api/webhooks/1"), "oxygenhub");

        assert_eq!(format_for_url("https://ci.example/hook"), "oxygenhub");

        let m = masked_url("https://discord.com/api/webhooks/1554146511347126332/6g_WnXRdNOiVoo8sGXXW_OuIUceluD8lIUckxb9KHPwZ895XE");

        assert_eq!(m, "https://discord.com/api/webhooks/1554…/6g_W…");

        assert!(!m.contains("6g_WnX"), "the token is not shown");

        assert_eq!(masked_url("https://ci.example/hook?token=secret"), "https://ci.example/hook?…");

    }

    crate::hooks::emit(

        &app,

        &row,

        "issue.opened",

        &me.account.username,

        serde_json::json!({ "issue": { "number": issue.number, "title": issue.title, "body": issue.body } }),

    )

    .await;

    let hook_event = if kind == "issue.comment" { "comment.issue" } else { kind };

    crate::hooks::emit(

        &app,

        &row,

        hook_event,

        &me.account.username,

        serde_json::json!({ "number": number, "issue": { "number": number, "title": i.title }, "comment": { "body": f.body.trim() } }),

    )

    .await;

        crate::hooks::emit(

            &app,

            &row,

            kind,

            &me.account.username,

            serde_json::json!({ "issue": { "number": number, "title": i.title }, "reason": event }),

        )

        .await;

    hooks: Vec<super::webhooks::HookRow>,

    let hooks = super::webhooks::rows(app, hooks).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    hooks: Vec<super::webhooks::HookRow>,

    let hooks = super::webhooks::rows(app, hooks).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    /// `oxygenhub`, `discord` or `slack`; guessed from the URL when absent.

    #[serde(default)]

    format: String,

    /// For `update`: whether the hook stays active.

    #[serde(default)]

    active: Option<String>,

}

/// A hook as the settings table shows it: the URL masked, and how its

/// newest delivery went.

pub struct HookRow {

    pub hook: db::hooks::Hook,

    pub masked: String,

    pub last: Option<db::hooks::Delivery>,

}

impl HookRow {

    /// `✔ 204` or `✘ 400: why`, for the table.

    pub fn last_result(&self) -> Option<(bool, String)> {

        let d = self.last.as_ref()?;

        let ok = d.delivered_ms.is_some();

        let status = d.status.map(|s| s.to_string()).unwrap_or_else(|| "no answer".into());

        let why: String = d.response.chars().take(80).collect();

        Some((ok, if ok || why.is_empty() { status } else { format!("{status}: {why}") }))

    }

}

pub async fn rows(app: &Shared, hooks: Vec<db::hooks::Hook>) -> sqlx::Result<Vec<HookRow>> {

    let mut out = Vec::with_capacity(hooks.len());

    for hook in hooks {

        let last = db::hooks::last_attempt(&app.db, hook.id).await?;

        out.push(HookRow { masked: db::hooks::masked_url(&hook.url), last, hook });

    }

    Ok(out)

}

fn url_ok(url: &str) -> bool {

    (url.starts_with("http://") || url.starts_with("https://")) && url.len() <= 2000 && !url.contains(char::is_whitespace)

        ("update", Some(id)) => {

            let Some(h) = owned(db::hooks::hook(&app.db, id).await?) else { return Ok(Err("No such webhook.".into())) };

            let url = f.url.trim();

            if !url.is_empty() && !url_ok(url) {

                return Ok(Err("A webhook URL starts with http:// or https://.".into()));

            }

            let format = if db::hooks::FORMATS.contains(&f.format.as_str()) { f.format.as_str() } else { h.format.as_str() };

            let events = if f.events.trim().is_empty() { "*" } else { f.events.trim() };

            let secret = f.secret.trim();

            db::hooks::update_hook(

                &app.db,

                id,

                (!url.is_empty()).then_some(url),

                (!secret.is_empty()).then_some(secret),

                events,

                format,

                f.active.is_some(),

            )

            .await?;

            accounts::audit(

                &app.db,

                viewer.account(),

                "hook.updated",

                scope.label(),

                &db::hooks::masked_url(if url.is_empty() { &h.url } else { url }),

            )

            .await

            .ok();

            "Webhook saved.".to_string()

        }

            let url = f.url.trim();

            if !url_ok(url) {

            let h = db::hooks::create_hook(&app.db, repo_id, org_id, url, f.secret.trim(), f.events.trim()).await?;

            if db::hooks::FORMATS.contains(&f.format.as_str()) && f.format != h.format {

                db::hooks::set_hook_format(&app.db, h.id, &f.format).await?;

            }

            // Never the full URL in the log: it can hold a token.

            accounts::audit(&app.db, viewer.account(), "hook.created", scope.label(), &db::hooks::masked_url(url)).await.ok();

#[tokio::test(flavor = "multi_thread")]

async fn webhook_formats_editing_and_web_issue_events() {

    let h = hub().await;

    let app = &h.app;

    let andy = call(app, "POST", "/register", None, None, None, Some("username=andy&email=a%40example.com&password=correct-horse-battery"))

        .await

        .cookie

        .unwrap();

    let page = call(app, "GET", "/settings/tokens", None, Some(&andy), None, None).await;

    let r = call(

        app,

        "POST",

        "/settings/tokens",

        None,

        Some(&andy),

        None,

        Some(&format!("_csrf={}&name=t&scopes=repo%3Aadmin", csrf_of(&page.body))),

    )

    .await;

    let token = r.body.split("oxyhub_").nth(1).map(|s| format!("oxyhub_{}", s.split('<').next().unwrap().trim())).unwrap();

    assert_eq!(

        api(app, "POST", "/api/v1/repos", Some(&token), Some(r#"{"owner":"andy","name":"demo","visibility":"public"}"#)).await.0,

        StatusCode::CREATED

    );

    let rx = receiver().await;

    *rx.fail_first.lock().unwrap() = false;

    let settings = call(app, "GET", "/andy/demo/settings", None, Some(&andy), None, None).await.body;

    let csrf = csrf_of(&settings);

    let form = |f: String| {

        let andy = andy.clone();

        async move { call(app, "POST", "/andy/demo/settings/hooks", None, Some(&andy), None, Some(&f)).await.body }

    };

    let url = rx.url.replace(':', "%3A").replace('/', "%2F");

    assert!(form(format!("_csrf={csrf}&url={url}&format=discord&events=*")).await.contains("Webhook added"));

    let hook = oxygenhub::db::hooks::hooks_for_repo(&app.db, 1).await.unwrap().remove(0);

    assert_eq!(hook.format, "discord");

    // Ping arrives as a Discord message.

    form(format!("_csrf={csrf}&id={}&action=ping", hook.id)).await;

    let mut got = String::new();

    for _ in 0..100 {

        if let Some((_, _, body)) = rx.seen.lock().unwrap().first() {

            got = body.clone();

        }

        if !got.is_empty() {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    }

    let v: serde_json::Value = serde_json::from_str(&got).unwrap();

    assert_eq!(v["embeds"][0]["title"], "OxygenHub is connected");

    assert_eq!(v["allowed_mentions"]["parse"], serde_json::json!([]));

    let page = call(app, "GET", "/andy/demo/settings", None, Some(&andy), None, None).await.body;

    assert!(page.contains("last delivery <span class=\"sig sig-valid\">✔</span> 200"), "the table shows how it went");

    // Editing: a blank URL and secret keep theirs; format, events and active change.

    assert!(form(format!("_csrf={csrf}&id={}&action=update&url=&secret=&events=issue&format=oxygenhub&active=1", hook.id))

        .await

        .contains("Webhook saved"));

    let edited = oxygenhub::db::hooks::hook(&app.db, hook.id).await.unwrap().unwrap();

    assert_eq!(

        (edited.url.as_str(), edited.events.as_str(), edited.format.as_str(), edited.active),

        (rx.url.as_str(), "issue", "oxygenhub", true)

    );

    assert!(form(format!("_csrf={csrf}&id={}&action=update&url=ftp%3A%2F%2Fx&events=*", hook.id)).await.contains("starts with http"));

    // An issue opened on the web now reaches the hook, as the signed envelope.

    let new = call(app, "GET", "/andy/demo/issues/new", None, Some(&andy), None, None).await.body;

    call(

        app,

        "POST",

        "/andy/demo/issues/new",

        None,

        Some(&andy),

        None,

        Some(&format!("_csrf={}&title=From+the+web&body=hello", csrf_of(&new))),

    )

    .await;

    let mut envelope = None;

    for _ in 0..100 {

        envelope = rx.seen.lock().unwrap().iter().find(|(e, _, _)| e == "issue.opened").cloned();

        if envelope.is_some() {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    }

    let (_, sig, body) = envelope.expect("issue.opened delivered");

    let v: serde_json::Value = serde_json::from_str(&body).unwrap();

    assert_eq!(v["data"]["issue"]["title"], "From the web");

    assert!(sig.starts_with("blake3-keyed="));

    // A disabled hook through the edit form (no active box).

    form(format!("_csrf={csrf}&id={}&action=update&url=&events=*&format=oxygenhub", hook.id)).await;

    assert!(!oxygenhub::db::hooks::hook(&app.db, hook.id).await.unwrap().unwrap().active);

}

Per repository and per organisation: a URL, a secret, an event selection, active flag, and delivery log with redelivery. Each webhook has a **format**: `oxygenhub` (the signed JSON envelope below), `discord` (an embed with a title, link and short detail for the event, sent with mentions disabled so no user text can ping anyone) or `slack` (escaped `text`); a Discord or Slack URL picks its format by default, and every event has a one-line summary for the chat formats. The settings show a webhook's URL with its long path segments and query cut short, since chat webhooks keep a secret token there (the audit log records the same masked form), and each webhook's last delivery result; a webhook can be edited (URL, secret, events, format, active), a blank URL or secret keeping the current one. Repository admins manage a repository's webhooks under its settings; organisation owners manage the organisation's under its settings, and those hear every repository the organisation owns. Payloads are JSON with `X-Oxyhub-Event`, `X-Oxyhub-Delivery`, and `X-Oxyhub-Signature: blake3-keyed=<hex>` computed as keyed BLAKE3 over the body. Events: `push` (reference updated: old and new state, heads, changes), `proposal` (opened, edited, review requested, landed, closed, conflicted), `review`, `comment`, `issue`, `release`, `check`, `policy`. Deliveries retry with backoff up to 24 hours.

<div class="head"><h1>Deliveries <small><code class="hook-url">{{ crate::db::hooks::masked_url(hook.url) }}</code> · {{ hook.format }} · events {{ hook.events }}</small></h1></div>

/* Webhooks (hub spec §12.2): long URLs wrap inside the panel. */

ul.hooks { list-style: none; margin: 0 0 12px; padding: 0; display: flex; flex-direction: column; gap: 8px; }

li.hook { border: 1px solid var(--line); background: var(--soft); padding: 8px 12px; min-width: 0; }

.hook-head { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }

code.hook-url { overflow-wrap: anywhere; word-break: break-all; }

li.hook p { margin: 4px 0; }

li.hook .hook-edit { margin-top: 4px; }

  <ul class="hooks">

  {% for r in hooks %}

  <li class="hook">

    <div class="hook-head">

      <code class="hook-url" title="The path is shortened: webhook URLs often carry a secret token">{{ r.masked }}</code>

      <span class="tag">{{ r.hook.format }}</span>

      {% if r.hook.active %}<span class="tag head">active</span>{% else %}<span class="tag dim">disabled</span>{% endif %}

    </div>

    <p class="small mute">events <code>{{ r.hook.events }}</code> ·

      {% if let Some((ok, text)) = r.last_result() %}last delivery {% if ok %}<span class="sig sig-valid">✔</span>{% else %}<span class="sig sig-invalid">✘</span>{% endif %} {{ text }}{% else %}nothing delivered yet{% endif %}

      · <a href="{{ base }}/hooks/{{ r.hook.id }}/deliveries">deliveries</a></p>

    <form class="tiny" method="post" action="{{ base }}/hooks"><input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="id" value="{{ r.hook.id }}"><button name="action" value="ping">ping</button> <button name="action" value="toggle">{% if r.hook.active %}disable{% else %}enable{% endif %}</button> <button name="action" value="delete" onclick="return confirm('Delete this webhook?')">delete</button></form>

    <details class="hook-edit"><summary class="small">edit</summary>

      <form class="card" method="post" action="{{ base }}/hooks">

        <input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="id" value="{{ r.hook.id }}"><input type="hidden" name="action" value="update">

        <label for="hu{{ r.hook.id }}">URL</label><input type="text" id="hu{{ r.hook.id }}" name="url" placeholder="{{ r.masked }}" autocomplete="off">

        <p class="small mute">Leave empty to keep the current URL.</p>

        <label for="hs{{ r.hook.id }}">Secret</label><input type="text" id="hs{{ r.hook.id }}" name="secret" placeholder="unchanged" autocomplete="off">

        <label for="he{{ r.hook.id }}">Events</label><input type="text" id="he{{ r.hook.id }}" name="events" value="{{ r.hook.events }}">

        <label for="hf{{ r.hook.id }}">Format</label>

        <select id="hf{{ r.hook.id }}" name="format">

          <option value="oxygenhub"{% if r.hook.format == "oxygenhub" %} selected{% endif %}>OxygenHub (signed JSON envelope)</option>

          <option value="discord"{% if r.hook.format == "discord" %} selected{% endif %}>Discord</option>

          <option value="slack"{% if r.hook.format == "slack" %} selected{% endif %}>Slack</option>

        </select>

        <div class="choice"><label><input type="checkbox" name="active" value="1"{% if r.hook.active %} checked{% endif %}> active</label></div>

        <button type="submit">SAVE</button>

      </form>

    </details>

  </li>

  {% endfor %}

  </ul>{% endif %}

    <h3>Add a webhook</h3>

    <label for="hurl">URL</label><input type="text" id="hurl" name="url" placeholder="https://…" required autocomplete="off">

    <label for="hformat">Format</label>

    <select id="hformat" name="format">

      <option value="">From the URL (Discord and Slack are recognised)</option>

      <option value="oxygenhub">OxygenHub (signed JSON envelope)</option>

      <option value="discord">Discord</option>

      <option value="slack">Slack</option>

    </select>

    <label for="hsecret">Secret (signs each delivery)</label><input type="text" id="hsecret" name="secret" autocomplete="off">