v0.2.0 (#50)

Co-authored-by: Tasnim Kabir Sadik <tksadik@omukk.dev>

Reviewed-on: wrenn/wrenn#50

pkg/channels/dispatcher.go

@@ -101,6 +101,10 @@ func (d *Dispatcher) handleMessage(ctx context.Context, msg redis.XMessage) {
 		return
 	}
 
+	if isRedundantSystemFollowup(event) {
+		return
+	}
+
 	teamID, err := id.ParseTeamID(event.TeamID)
 	if err != nil {
 		slog.Warn("channels: invalid team ID in event", "team_id", event.TeamID, "error", err)
@@ -181,3 +185,23 @@ func (d *Dispatcher) decryptConfig(configJSON []byte) (map[string]string, error)
 func isGroupExistsError(err error) bool {
 	return err != nil && err.Error() == "BUSYGROUP Consumer Group name already exists"
 }
+
+// isRedundantSystemFollowup filters out capsule lifecycle events emitted by
+// the SandboxService background goroutine / host-agent callback after a
+// user-initiated action. The corresponding handler already publishes a
+// user-actor event for the same intent; without this filter, every user
+// action delivers two notifications.
+//
+// Genuinely system-only emitters (TTL auto-pause, host_monitor reconciler,
+// host-reported failures) always set Metadata["reason"], so they pass.
+func isRedundantSystemFollowup(e events.Event) bool {
+	if e.Actor.Type != events.ActorSystem {
+		return false
+	}
+	switch e.Event {
+	case events.CapsuleCreate, events.CapsulePause, events.CapsuleResume, events.CapsuleDestroy:
+	default:
+		return false
+	}
+	return e.Metadata["reason"] == ""
+}

pkg/channels/message.go

@@ -14,27 +14,55 @@ func FormatMessage(e events.Event) string {
 
 	b.WriteString(formatSummary(e))
 	fmt.Fprintf(&b, "\n\nEvent: %s", e.Event)
+	if e.Outcome != "" {
+		fmt.Fprintf(&b, "\nOutcome: %s", e.Outcome)
+	}
 	fmt.Fprintf(&b, "\nResource: %s %s", e.Resource.Type, e.Resource.ID)
 	fmt.Fprintf(&b, "\nActor: %s", formatActor(e.Actor))
 	fmt.Fprintf(&b, "\nTeam: %s", e.TeamID)
 	fmt.Fprintf(&b, "\nTime: %s", e.Timestamp)
+	if e.Error != "" {
+		fmt.Fprintf(&b, "\nError: %s", e.Error)
+	}
+	if reason, ok := e.Metadata["reason"]; ok {
+		fmt.Fprintf(&b, "\nReason: %s", reason)
+	}
 
 	return b.String()
 }
 
 func formatSummary(e events.Event) string {
+	failed := e.Outcome == events.OutcomeError
 	switch e.Event {
-	case events.CapsuleCreated:
+	case events.CapsuleCreate:
+		if failed {
+			return fmt.Sprintf("Capsule %s failed to create", e.Resource.ID)
+		}
 		return fmt.Sprintf("Capsule %s created", e.Resource.ID)
-	case events.CapsuleRunning:
-		return fmt.Sprintf("Capsule %s is running", e.Resource.ID)
-	case events.CapsulePaused:
+	case events.CapsulePause:
+		if failed {
+			return fmt.Sprintf("Capsule %s failed to pause", e.Resource.ID)
+		}
 		return fmt.Sprintf("Capsule %s paused", e.Resource.ID)
-	case events.CapsuleDestroyed:
+	case events.CapsuleResume:
+		if failed {
+			return fmt.Sprintf("Capsule %s failed to resume", e.Resource.ID)
+		}
+		return fmt.Sprintf("Capsule %s resumed", e.Resource.ID)
+	case events.CapsuleDestroy:
+		if failed {
+			return fmt.Sprintf("Capsule %s failed to destroy", e.Resource.ID)
+		}
 		return fmt.Sprintf("Capsule %s destroyed", e.Resource.ID)
-	case events.SnapshotCreated:
+	case events.SnapshotCreate:
+		if failed {
+			return fmt.Sprintf("Template snapshot %s failed to create", e.Resource.ID)
+		}
 		return fmt.Sprintf("Template snapshot %s created", e.Resource.ID)
-	case events.SnapshotDeleted:
+	case events.SnapshotDelete:
+		if failed {
+			return fmt.Sprintf("Template snapshot %s failed to delete", e.Resource.ID)
+		}
 		return fmt.Sprintf("Template snapshot %s deleted", e.Resource.ID)
 	case events.HostUp:
 		return fmt.Sprintf("Host %s is up", e.Resource.ID)

pkg/channels/publisher.go

@@ -10,7 +10,10 @@ import (
 	"git.omukk.dev/wrenn/wrenn/pkg/events"
 )
 
-const streamKey = "wrenn:events"
+const (
+	streamKey        = "wrenn:events"
+	ssePubSubChannel = "wrenn:sse"
+)
 
 // Publisher pushes events onto the Redis stream for the dispatcher to consume.
 type Publisher struct {
@@ -22,8 +25,9 @@ func NewPublisher(rdb *redis.Client) *Publisher {
 	return &Publisher{rdb: rdb}
 }
 
-// Publish serializes the event and appends it to the global stream.
-// Fire-and-forget: failures are logged, never propagated.
+// Publish serializes the event, appends it to the durable Redis stream
+// (consumed by channel dispatcher for webhook/telegram delivery), and
+// mirrors it on the SSE Pub/Sub channel for the dashboard. Fire-and-forget.
 func (p *Publisher) Publish(ctx context.Context, e events.Event) {
 	payload, err := json.Marshal(e)
 	if err != nil {
@@ -41,4 +45,24 @@ func (p *Publisher) Publish(ctx context.Context, e events.Event) {
 	}).Err(); err != nil {
 		slog.Warn("channels: failed to publish event", "event", e.Event, "error", err)
 	}
+
+	if err := p.rdb.Publish(ctx, ssePubSubChannel, string(payload)).Err(); err != nil {
+		slog.Warn("channels: failed to publish SSE event", "event", e.Event, "error", err)
+	}
+}
+
+// PublishTransient mirrors the event on the SSE Pub/Sub channel only — no
+// durable stream write, no channel dispatch. Used for ephemeral UI signals
+// (status transitions during start/pause/resume) that should reach the
+// dashboard live but must not be delivered to webhook/telegram subscribers.
+func (p *Publisher) PublishTransient(ctx context.Context, e events.Event) {
+	payload, err := json.Marshal(e)
+	if err != nil {
+		slog.Warn("channels: failed to marshal transient event", "event", e.Event, "error", err)
+		return
+	}
+
+	if err := p.rdb.Publish(ctx, ssePubSubChannel, string(payload)).Err(); err != nil {
+		slog.Warn("channels: failed to publish transient SSE event", "event", e.Event, "error", err)
+	}
 }

pkg/channels/service.go

@@ -45,8 +45,8 @@ var requiredFields = map[string][]string{
 var validEvents map[string]bool
 
 func init() {
-	validEvents = make(map[string]bool, len(events.AllEventTypes))
-	for _, et := range events.AllEventTypes {
+	validEvents = make(map[string]bool, len(events.SubscribableEventTypes))
+	for _, et := range events.SubscribableEventTypes {
 		validEvents[et] = true
 	}
 }