feat(webhooks): templated body, custom headers/method, now_playing event, verified presets

Webhooks now carry a stable ID, optional Name, HTTP method, ContentType,
custom Headers map, and a Go text/template BodyTemplate. Empty template
preserves the legacy JSON envelope so existing receivers keep working.

- WebhookConfig grows ID/Name/Method/Headers/BodyTemplate/ContentType.
  Legacy entries get an ID backfilled at load time.
- dispatchWebhook renders the template against a context that merges
  event metadata (.Event/.Timestamp/.Hostname) with the per-event
  payload promoted to top-level fields (.Artist, .Title, .Mount, ...).
  Header values are templated too. For GET/HEAD the rendered body is
  appended as a query string so endpoints like TuneIn AIR's
  Playing.ashx work from a single template.
- Helper funcs exposed inside templates: urlencode, json, lower, upper.
- New now_playing event, fired from the streamer on each track start
  via a new StreamerManager.OnTrackStart callback (avoids server↔relay
  cyclic import).
- /api/webhooks: GET/POST/PUT/DELETE CRUD + /api/webhooks/test for
  firing a sample payload + /api/webhooks/meta exposing the canonical
  event list, sample payloads, placeholders and verified presets.
- Verified presets shipped: generic JSON, Discord, Slack, Mattermost,
  Microsoft Teams MessageCard, Telegram sendMessage, ntfy.sh, Pushover,
  TuneIn AIR Playing.ashx, webhook.site echo.
- Outbound URL is re-validated on every send (defence in depth against
  hand-edited configs becoming SSRF vectors).

Author: DatanoiseTV

config/config.go

@@ -1,13 +1,26 @@
 package config
 
 import (
+	"crypto/rand"
+	"encoding/hex"
 	"encoding/json"
 	"os"
 	"sync"
 
 	"golang.org/x/crypto/bcrypt"
 )
 
+// NewWebhookID returns a 12-char hex token used to address webhooks in
+// the API and admin UI. Random rather than sequential so deletes don't
+// invalidate cached references on the frontend.
+func NewWebhookID() string {
+	b := make([]byte, 6)
+	if _, err := rand.Read(b); err != nil {
+		return "wh-fallback"
+	}
+	return "wh_" + hex.EncodeToString(b)
+}
+
 const (
 	RoleSuperAdmin = "superadmin"
 	RoleAdmin      = "admin"
@@ -108,10 +121,33 @@ type TranscoderConfig struct {
 	OpusFrameSizeMS int    `json:"opus_frame_size_ms,omitempty"` // 2.5/5/10/20/40/60, 0 = 20
 }
 
+// WebhookConfig describes one outbound HTTP webhook subscription.
+//
+// The minimal form (URL + Events + Enabled) is preserved for backwards
+// compatibility with existing tinyice.json files written before templating
+// was added. New deployments get an ID assigned at load time so the admin
+// UI can address each entry uniquely even if URLs collide.
+//
+// BodyTemplate, when set, is rendered with Go text/template against a
+// context that contains .Event, .Timestamp, .Hostname plus every key from
+// the per-event payload promoted to the top level (so users can write
+// {{.Artist}} for now_playing, {{.Mount}} for source_connect, etc.). When
+// BodyTemplate is empty we fall back to the legacy JSON envelope, which
+// keeps existing receivers working unchanged.
+//
+// Method defaults to POST, ContentType to application/json. Headers is a
+// free-form map of extra request headers — useful for Authorization,
+// X-Webhook-Token, custom routing keys for Slack, etc.
 type WebhookConfig struct {
-	URL     string   `json:"url"`
-	Events  []string `json:"events"` // "source_connect", "source_disconnect", "metadata_update", "security_lockout"
-	Enabled bool     `json:"enabled"`
+	ID           string            `json:"id"`
+	Name         string            `json:"name,omitempty"`
+	URL          string            `json:"url"`
+	Method       string            `json:"method,omitempty"`
+	Events       []string          `json:"events"`
+	Headers      map[string]string `json:"headers,omitempty"`
+	BodyTemplate string            `json:"body_template,omitempty"`
+	ContentType  string            `json:"content_type,omitempty"`
+	Enabled      bool              `json:"enabled"`
 }
 
 type AutoDJConfig struct {
@@ -405,6 +441,14 @@ func (config *Config) initMapsAndArrays() {
 	if config.Webhooks == nil {
 		config.Webhooks = make([]*WebhookConfig, 0)
 	}
+	// Backfill IDs for legacy webhooks (pre-templating). Done in-place so
+	// the next SaveConfig persists them; without this the admin UI would
+	// have no stable handle for edit/delete on existing entries.
+	for _, wh := range config.Webhooks {
+		if wh.ID == "" {
+			wh.ID = NewWebhookID()
+		}
+	}
 	if config.BannedIPs == nil {
 		config.BannedIPs = make([]string, 0)
 	}

relay/streamer.go

@@ -82,6 +82,13 @@ type StreamerManager struct {
 	mu        sync.RWMutex
 	relay     *Relay
 	config    *config.Config
+
+	// OnTrackStart fires once per track, after metadata is parsed and just
+	// before encoding begins. Used by the server to dispatch the
+	// `now_playing` webhook event without dragging the server package
+	// into relay (which would be a cyclic import). Set by the server at
+	// startup; nil on construction.
+	OnTrackStart func(mount, streamerName, artist, title, album, filePath string)
 }
 
 func NewStreamerManager(r *Relay, cfg *config.Config) *StreamerManager {
@@ -1049,6 +1056,13 @@ func (sm *StreamerManager) streamFile(ctx context.Context, s *Streamer, path str
 	// Fire on_play_command hook (runs in background, non-blocking).
 	s.execOnPlayCommand(s.CurrentArtist, s.CurrentTitle, s.CurrentAlbum, path, s.OutputMount)
 
+	// Notify the server so it can dispatch webhook subscribers. Run in a
+	// goroutine: the server callback may block briefly on JSON marshal /
+	// HTTP send setup and we don't want to delay the encoder start.
+	if cb := sm.OnTrackStart; cb != nil {
+		go cb(s.OutputMount, s.Name, s.CurrentArtist, s.CurrentTitle, s.CurrentAlbum, path)
+	}
+
 	// Apply the streamer's volume setting (0..1) to the PCM stream before
 	// it reaches the encoder. When Volume is 1.0 the wrapper is a no-op.
 	var pcm io.Reader = decoder

server/handlers_admin.go

@@ -495,6 +495,7 @@ func (s *Server) handleAddWebhook(w http.ResponseWriter, r *http.Request) {
 	}
 
 	s.Config.Webhooks = append(s.Config.Webhooks, &config.WebhookConfig{
+		ID:      config.NewWebhookID(),
 		URL:     url,
 		Events:  events,
 		Enabled: true,