feat: dispatch webhook and ntfy deliveries

Author: ardasevinc

internal/cli/cli_test.go

@@ -7,6 +7,7 @@ import (
 	"flag"
 	"os"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
 	"testing"
@@ -152,6 +153,27 @@ func TestTelegramDeliveryTarget(t *testing.T) {
 	}
 }
 
+func TestDeliveryRuntimeUsesStableTargetsAndEnvironmentSecrets(t *testing.T) {
+	t.Setenv("SCRIBA_WEBHOOK_TEST_SECRET", "webhook-secret")
+	t.Setenv("SCRIBA_NTFY_TEST_TOKEN", "ntfy-token")
+	cfg := config.Default()
+	cfg.Telegram.Enabled = true
+	cfg.Telegram.ChatID = "123"
+	cfg.Deliveries = config.DeliveryConfig{
+		Webhooks: []config.WebhookConfig{{ID: "deploy", Enabled: true, URL: "https://example.com/hook", SecretEnv: "SCRIBA_WEBHOOK_TEST_SECRET"}},
+		Ntfy:     []config.NtfyConfig{{ID: "phone", Enabled: true, URL: "https://ntfy.sh", Topic: "scriba", TokenEnv: "SCRIBA_NTFY_TEST_TOKEN"}},
+	}
+	chatID, targets, adapters, err := deliveryRuntime(cfg)
+	if err != nil || chatID != 123 || !reflect.DeepEqual(targets, []string{"telegram:123", "webhook:deploy", "ntfy:phone"}) || len(adapters) != 2 || adapters[0].Target() != "webhook:deploy" || adapters[1].Target() != "ntfy:phone" {
+		t.Fatalf("chat=%d targets=%v adapters=%v err=%v", chatID, targets, adapters, err)
+	}
+
+	t.Setenv("SCRIBA_WEBHOOK_TEST_SECRET", "")
+	if _, _, _, err := deliveryRuntime(cfg); err == nil || strings.Contains(err.Error(), "webhook-secret") {
+		t.Fatalf("missing or unsafe webhook secret error: %v", err)
+	}
+}
+
 func TestCodexLimitsFromSnapshotRequiresCodexProvider(t *testing.T) {
 	_, err := codexLimitsFromSnapshot(model.StatusSnapshot{
 		SchemaVersion: model.SchemaVersion,

internal/cli/server.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/agensfield/scriba/internal/buildinfo"
 	"github.com/agensfield/scriba/internal/config"
+	"github.com/agensfield/scriba/internal/delivery"
 	"github.com/agensfield/scriba/internal/localapi"
 	"github.com/agensfield/scriba/internal/radar"
 	"github.com/agensfield/scriba/internal/resetwatch"
@@ -113,20 +114,24 @@ func runServerRun(cfg config.Config, opts options) error {
 	if err != nil {
 		return err
 	}
-	chatID, notificationTarget, err := telegramDeliveryTarget(cfg)
+	chatID, notificationTargets, deliveryAdapters, err := deliveryRuntime(cfg)
 	if err != nil {
 		return err
 	}
 	srv := servercore.New(st, nil, nil, servercore.Config{
 		Profiles:                 profiles,
-		NotificationTarget:       notificationTarget,
+		NotificationTargets:      notificationTargets,
 		AccountLabel:             cfg.Server.AccountLabel,
 		JokeTone:                 cfg.Telegram.ResetJokeTone,
 		StartupHeartbeat:         heartbeat,
 		ObservationRetentionDays: cfg.Server.ObservationRetentionDays,
 	})
 	srv.SetRadarFetcher(radar.Client{})
 	children := []func(context.Context) error{srv.Run}
+	for _, adapter := range deliveryAdapters {
+		dispatcher := delivery.Dispatcher{Store: st, Adapter: adapter}
+		children = append(children, dispatcher.Run)
+	}
 	if cfg.Server.ContextAPI.Enabled {
 		socketPath := resolveContextAPISocketPath(st.Path(), cfg.Server.ContextAPI.SocketPath)
 		listener, err := localapi.Listen(ctx, socketPath)
@@ -323,13 +328,13 @@ func runServerRefresh(cfg config.Config, opts options) error {
 	if err := st.SyncProfiles(context.Background(), specs); err != nil {
 		return fmt.Errorf("sync server profiles: %w", err)
 	}
-	_, notificationTarget, err := telegramDeliveryTarget(cfg)
+	_, notificationTargets, _, err := deliveryRuntime(cfg)
 	if err != nil {
 		return err
 	}
 	srv := servercore.New(st, nil, nil, servercore.Config{
 		Profiles:                 profiles,
-		NotificationTarget:       notificationTarget,
+		NotificationTargets:      notificationTargets,
 		AccountLabel:             cfg.Server.AccountLabel,
 		JokeTone:                 cfg.Telegram.ResetJokeTone,
 		ObservationRetentionDays: cfg.Server.ObservationRetentionDays,
@@ -352,6 +357,44 @@ func telegramDeliveryTarget(cfg config.Config) (int64, string, error) {
 	return chatID, fmt.Sprintf("telegram:%d", chatID), nil
 }
 
+func deliveryRuntime(cfg config.Config) (int64, []string, []delivery.Adapter, error) {
+	chatID, telegramTarget, err := telegramDeliveryTarget(cfg)
+	if err != nil {
+		return 0, nil, nil, err
+	}
+	targets := make([]string, 0, 1+len(cfg.Deliveries.Webhooks)+len(cfg.Deliveries.Ntfy))
+	if telegramTarget != "" {
+		targets = append(targets, telegramTarget)
+	}
+	adapters := make([]delivery.Adapter, 0, len(cfg.Deliveries.Webhooks)+len(cfg.Deliveries.Ntfy))
+	for _, webhook := range cfg.Deliveries.Webhooks {
+		if !webhook.Enabled {
+			continue
+		}
+		secret := os.Getenv(webhook.SecretEnv)
+		if secret == "" {
+			return 0, nil, nil, fmt.Errorf("missing webhook secret; set env %s", webhook.SecretEnv)
+		}
+		adapter := delivery.Webhook{ID: webhook.ID, URL: webhook.URL, Secret: []byte(secret)}
+		targets, adapters = append(targets, adapter.Target()), append(adapters, adapter)
+	}
+	for _, ntfy := range cfg.Deliveries.Ntfy {
+		if !ntfy.Enabled {
+			continue
+		}
+		token := ""
+		if ntfy.TokenEnv != "" {
+			token = os.Getenv(ntfy.TokenEnv)
+			if token == "" {
+				return 0, nil, nil, fmt.Errorf("missing ntfy token; set env %s", ntfy.TokenEnv)
+			}
+		}
+		adapter := delivery.Ntfy{ID: ntfy.ID, URL: ntfy.URL, Topic: ntfy.Topic, Token: token}
+		targets, adapters = append(targets, adapter.Target()), append(adapters, adapter)
+	}
+	return chatID, targets, adapters, nil
+}
+
 func runServerPrune(cfg config.Config, opts options) error {
 	st, err := store.Open(resolveServerStatePath(cfg.Server.StatePath))
 	if err != nil {

internal/config/config.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/url"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -13,6 +14,8 @@ import (
 )
 
 var profileIDPattern = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
+var envNamePattern = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
+var ntfyTopicPattern = regexp.MustCompile(`^[-_A-Za-z0-9]{1,64}$`)
 
 type ProviderConfig struct {
 	Enabled bool     `json:"enabled"`
@@ -51,6 +54,26 @@ type ContextAPIConfig struct {
 	SocketPath string `json:"socketPath,omitempty"`
 }
 
+type WebhookConfig struct {
+	ID        string `json:"id"`
+	Enabled   bool   `json:"enabled"`
+	URL       string `json:"url"`
+	SecretEnv string `json:"secretEnv"`
+}
+
+type NtfyConfig struct {
+	ID       string `json:"id"`
+	Enabled  bool   `json:"enabled"`
+	URL      string `json:"url"`
+	Topic    string `json:"topic"`
+	TokenEnv string `json:"tokenEnv,omitempty"`
+}
+
+type DeliveryConfig struct {
+	Webhooks []WebhookConfig `json:"webhooks,omitempty"`
+	Ntfy     []NtfyConfig    `json:"ntfy,omitempty"`
+}
+
 type Config struct {
 	SchemaVersion    int       `json:"schemaVersion"`
 	DefaultProfileID string    `json:"defaultProfileId"`
@@ -62,8 +85,9 @@ type Config struct {
 		Claude ProviderConfig `json:"claude"`
 		Codex  ProviderConfig `json:"codex"`
 	} `json:"providers"`
-	Server   ServerConfig   `json:"server"`
-	Telegram TelegramConfig `json:"telegram"`
+	Server     ServerConfig   `json:"server"`
+	Telegram   TelegramConfig `json:"telegram"`
+	Deliveries DeliveryConfig `json:"deliveries,omitempty"`
 }
 
 type Profile struct {
@@ -266,5 +290,61 @@ func Validate(cfg Config) error {
 	if !defaultEnabled {
 		return errors.New("defaultProfileId must identify an enabled profile")
 	}
+	if err := validateDeliveries(cfg.Deliveries); err != nil {
+		return err
+	}
+	return nil
+}
+
+func validateDeliveries(cfg DeliveryConfig) error {
+	seen := make(map[string]struct{}, len(cfg.Webhooks)+len(cfg.Ntfy))
+	validateID := func(kind, id string) error {
+		if len(id) > 32 || !profileIDPattern.MatchString(id) {
+			return fmt.Errorf("%s id must be a lowercase slug of at most 32 characters", kind)
+		}
+		target := kind + ":" + id
+		if _, ok := seen[target]; ok {
+			return fmt.Errorf("duplicate delivery target %q", target)
+		}
+		seen[target] = struct{}{}
+		return nil
+	}
+	validateURL := func(kind, value string) error {
+		u, err := url.Parse(value)
+		if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.User != nil || u.Fragment != "" {
+			return fmt.Errorf("%s url must be an absolute HTTP(S) URL", kind)
+		}
+		return nil
+	}
+	for i, webhook := range cfg.Webhooks {
+		kind := fmt.Sprintf("deliveries.webhooks[%d]", i)
+		if err := validateID("webhook", webhook.ID); err != nil {
+			return fmt.Errorf("%s: %w", kind, err)
+		}
+		if err := validateURL(kind, webhook.URL); err != nil {
+			return err
+		}
+		if webhook.Enabled && !envNamePattern.MatchString(webhook.SecretEnv) {
+			return fmt.Errorf("%s.secretEnv is required and must name an environment variable", kind)
+		}
+	}
+	for i, ntfy := range cfg.Ntfy {
+		kind := fmt.Sprintf("deliveries.ntfy[%d]", i)
+		if err := validateID("ntfy", ntfy.ID); err != nil {
+			return fmt.Errorf("%s: %w", kind, err)
+		}
+		if err := validateURL(kind, ntfy.URL); err != nil {
+			return err
+		}
+		if u, _ := url.Parse(ntfy.URL); u.RawQuery != "" {
+			return fmt.Errorf("%s.url must not contain a query string", kind)
+		}
+		if !ntfyTopicPattern.MatchString(ntfy.Topic) {
+			return fmt.Errorf("%s.topic must contain 1-64 letters, numbers, underscores, or dashes", kind)
+		}
+		if ntfy.TokenEnv != "" && !envNamePattern.MatchString(ntfy.TokenEnv) {
+			return fmt.Errorf("%s.tokenEnv must name an environment variable", kind)
+		}
+	}
 	return nil
 }

internal/config/config_test.go

@@ -184,3 +184,43 @@ func TestProfileValidation(t *testing.T) {
 		})
 	}
 }
+
+func TestDeliveryConfigRoundTripAndValidation(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.json")
+	cfg := Default()
+	cfg.Deliveries = DeliveryConfig{
+		Webhooks: []WebhookConfig{{ID: "deploy", Enabled: true, URL: "https://example.com/scriba", SecretEnv: "SCRIBA_WEBHOOK_DEPLOY_SECRET"}},
+		Ntfy:     []NtfyConfig{{ID: "phone", Enabled: true, URL: "https://ntfy.sh", Topic: "scriba-private", TokenEnv: "SCRIBA_NTFY_TOKEN"}},
+	}
+	if err := Save(path, cfg); err != nil {
+		t.Fatal(err)
+	}
+	got, err := Load(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Deliveries.Webhooks) != 1 || got.Deliveries.Webhooks[0].ID != "deploy" || len(got.Deliveries.Ntfy) != 1 || got.Deliveries.Ntfy[0].Topic != "scriba-private" {
+		t.Fatalf("deliveries=%+v", got.Deliveries)
+	}
+
+	tests := []func(*Config){
+		func(c *Config) { c.Deliveries.Webhooks[0].ID = "Bad_ID" },
+		func(c *Config) { c.Deliveries.Webhooks[0].URL = "/relative" },
+		func(c *Config) { c.Deliveries.Webhooks[0].SecretEnv = "" },
+		func(c *Config) { c.Deliveries.Ntfy[0].Topic = " bad " },
+		func(c *Config) { c.Deliveries.Ntfy[0].Topic = strings.Repeat("a", 65) },
+		func(c *Config) { c.Deliveries.Ntfy[0].URL = "https://user:[email protected]" },
+		func(c *Config) { c.Deliveries.Ntfy[0].URL = "https://ntfy.sh?token=secret" },
+		func(c *Config) { c.Deliveries.Ntfy[0].TokenEnv = "BAD ENV" },
+		func(c *Config) { c.Deliveries.Ntfy = append(c.Deliveries.Ntfy, c.Deliveries.Ntfy[0]) },
+	}
+	for i, mutate := range tests {
+		broken := cfg
+		broken.Deliveries.Webhooks = append([]WebhookConfig(nil), cfg.Deliveries.Webhooks...)
+		broken.Deliveries.Ntfy = append([]NtfyConfig(nil), cfg.Deliveries.Ntfy...)
+		mutate(&broken)
+		if err := Validate(broken); err == nil {
+			t.Fatalf("invalid delivery config %d accepted", i)
+		}
+	}
+}