More ntfy fixes

Author: joshsymonds

cmd/claude-code-ntfy/app.go

@@ -49,18 +49,34 @@ func NewDependencies(cfg *config.Config) (*Dependencies, error) {
 	// Start auto-refresh to keep the indicator visible despite Claude's screen clears
 	deps.StatusIndicator.StartAutoRefresh(deps.stopChan)
 
+	// Create pattern matcher and output monitor first (needed for terminal title)
+	deps.PatternMatcher = monitor.NewSimplePatternMatcher(cfg.Patterns)
+	outputMonitor := monitor.NewOutputMonitor(cfg, deps.PatternMatcher, deps.IdleDetector, nil) // nil notifier for now
+	deps.OutputMonitor = outputMonitor
+
 	// Create notification components
-	deps.Notifier = notification.NewNtfyClient(cfg.NtfyServer, cfg.NtfyTopic)
+	baseNotifier := notification.NewNtfyClient(cfg.NtfyServer, cfg.NtfyTopic)
+	
+	// Wrap with context notifier
+	contextNotifier := notification.NewContextNotifier(baseNotifier, func() string {
+		return outputMonitor.GetTerminalTitle()
+	})
+
+	// Wrap with backstop notifier if configured
+	var finalNotifier notification.Notifier = contextNotifier
+	if cfg.BackstopTimeout > 0 {
+		finalNotifier = notification.NewBackstopNotifier(contextNotifier, cfg.BackstopTimeout)
+	}
+	deps.Notifier = finalNotifier
+
 	deps.RateLimiter = notification.NewTokenBucketRateLimiter(cfg.RateLimit.MaxMessages, cfg.RateLimit.Window)
 	deps.NotificationManager = notification.NewManager(cfg, deps.Notifier, deps.RateLimiter)
 
 	// Connect status reporter to notification manager
 	deps.NotificationManager.SetStatusReporter(deps.StatusReporter)
-
-	// Create pattern matcher and output monitor
-	deps.PatternMatcher = monitor.NewSimplePatternMatcher(cfg.Patterns)
-	outputMonitor := monitor.NewOutputMonitor(cfg, deps.PatternMatcher, deps.IdleDetector, deps.NotificationManager)
-	deps.OutputMonitor = outputMonitor
+	
+	// Now set the notification manager on the output monitor
+	outputMonitor.SetNotifier(deps.NotificationManager)
 
 	// Connect status indicator to output monitor for screen clear detection
 	if statusEnabled {
@@ -95,6 +111,12 @@ func (d *Dependencies) Close() {
 		_ = d.StatusIndicator.Clear() // Best effort
 	}
 
+	// Close notifiers
+	// First try to close as backstop notifier
+	if backstopNotifier, ok := d.Notifier.(*notification.BackstopNotifier); ok {
+		_ = backstopNotifier.Close()
+	}
+
 	if d.NotificationManager != nil {
 		_ = d.NotificationManager.Close()
 	}

pkg/config/config.go

@@ -26,6 +26,9 @@ type Config struct {
 	DefaultClaudeArgs    []string      `yaml:"default_claude_args"`
 	EnableFocusDetection bool          `yaml:"enable_focus_detection" env:"CLAUDE_NOTIFY_FOCUS_DETECTION"`
 
+	// Backstop notification - send notification after inactivity
+	BackstopTimeout time.Duration `yaml:"backstop_timeout" env:"CLAUDE_NOTIFY_BACKSTOP_TIMEOUT"`
+
 	// Claude path configuration
 	ClaudePath string `yaml:"claude_path" env:"CLAUDE_NOTIFY_CLAUDE_PATH"`
 
@@ -71,6 +74,7 @@ func DefaultConfig() *Config {
 		IdleTimeout:          2 * time.Minute,
 		StartupGracePeriod:   10 * time.Second,
 		EnableFocusDetection: true,
+		BackstopTimeout:      30 * time.Second,
 		Patterns: []Pattern{
 			{
 				Name:    "bell",

pkg/monitor/output_monitor.go

@@ -56,6 +56,13 @@ func (om *OutputMonitor) SetScreenEventHandler(handler interfaces.ScreenEventHan
 	om.screenEventHandler = handler
 }
 
+// SetNotifier sets the notifier
+func (om *OutputMonitor) SetNotifier(notifier notification.Notifier) {
+	om.mu.Lock()
+	defer om.mu.Unlock()
+	om.notifier = notifier
+}
+
 // HandleData processes raw output data
 func (om *OutputMonitor) HandleData(data []byte) {
 	// Detect terminal sequences before locking (non-blocking operation)
@@ -69,6 +76,11 @@ func (om *OutputMonitor) HandleData(data []byte) {
 	// Update last output time
 	om.lastOutputTime = time.Now()
 
+	// Notify activity marker if we have one
+	if marker, ok := om.notifier.(notification.ActivityMarker); ok {
+		marker.MarkActivity()
+	}
+
 	// Add data to line buffer
 	om.lineBuffer.Write(data)
 
@@ -117,14 +129,8 @@ func (om *OutputMonitor) processLine(line string) {
 	if om.shouldNotify() {
 		// Create notifications for each match
 		for _, match := range matches {
-			// Include terminal title in notification if available
-			title := "Claude Code Match: " + match.PatternName
-			if termTitle := om.terminalState.GetTitle(); termTitle != "" {
-				title = "Claude Code [" + termTitle + "]: " + match.PatternName
-			}
-
 			n := notification.Notification{
-				Title:   title,
+				Title:   "Claude Code: " + match.PatternName,
 				Message: line,
 				Time:    time.Now(),
 				Pattern: match.PatternName,
@@ -248,3 +254,18 @@ func (om *OutputMonitor) ResetStartTime() {
 	defer om.mu.Unlock()
 	om.startTime = time.Now()
 }
+
+// LastOutputTime returns the time of the last output
+func (om *OutputMonitor) LastOutputTime() time.Time {
+	om.mu.Lock()
+	defer om.mu.Unlock()
+	return om.lastOutputTime
+}
+
+// GetTerminalTitle returns the current terminal title
+func (om *OutputMonitor) GetTerminalTitle() string {
+	if om.terminalState != nil {
+		return om.terminalState.GetTitle()
+	}
+	return ""
+}

pkg/monitor/output_monitor_test.go

@@ -525,8 +525,8 @@ func TestOutputMonitorTerminalTitleInNotifications(t *testing.T) {
 		t.Fatalf("expected 1 notification, got %d", len(notifs))
 	}
 
-	// Verify title includes terminal title
-	expectedTitle := "Claude Code [My Task Title]: test"
+	// Verify title is simple (context is added by ContextNotifier now)
+	expectedTitle := "Claude Code: test"
 	if notifs[0].Title != expectedTitle {
 		t.Errorf("expected title %q, got %q", expectedTitle, notifs[0].Title)
 	}

pkg/notification/backstop_notifier.go

@@ -0,0 +1,122 @@
+package notification
+
+import (
+	"sync"
+	"time"
+)
+
+// ActivityMarker is an interface for marking activity
+type ActivityMarker interface {
+	MarkActivity()
+}
+
+// BackstopNotifier wraps another notifier and sends a notification after inactivity
+type BackstopNotifier struct {
+	underlying Notifier
+	timeout    time.Duration
+
+	mu                   sync.Mutex
+	lastNotificationTime time.Time
+	lastActivityTime     time.Time
+	timer                *time.Timer
+}
+
+// NewBackstopNotifier creates a new backstop notifier
+func NewBackstopNotifier(underlying Notifier, timeout time.Duration) *BackstopNotifier {
+	bn := &BackstopNotifier{
+		underlying:       underlying,
+		timeout:          timeout,
+		lastActivityTime: time.Now(),
+	}
+
+	if timeout > 0 {
+		bn.startTimer()
+	}
+
+	return bn
+}
+
+// Send implements the Notifier interface
+func (bn *BackstopNotifier) Send(notification Notification) error {
+	bn.mu.Lock()
+	defer bn.mu.Unlock()
+
+	// Reset activity time
+	bn.lastActivityTime = time.Now()
+	bn.lastNotificationTime = time.Now()
+
+	// Reset the timer
+	if bn.timer != nil {
+		bn.timer.Stop()
+	}
+	// Always restart timer after a notification
+	if bn.timeout > 0 {
+		bn.timer = time.AfterFunc(bn.timeout, bn.sendBackstopNotification)
+	}
+
+	// Forward to underlying notifier
+	return bn.underlying.Send(notification)
+}
+
+// MarkActivity marks that there was activity (output) without sending a notification
+func (bn *BackstopNotifier) MarkActivity() {
+	bn.mu.Lock()
+	defer bn.mu.Unlock()
+
+	bn.lastActivityTime = time.Now()
+
+	// Reset the timer
+	if bn.timer != nil {
+		bn.timer.Stop()
+	}
+	// Always restart timer after activity
+	if bn.timeout > 0 {
+		bn.timer = time.AfterFunc(bn.timeout, bn.sendBackstopNotification)
+	}
+}
+
+// sendBackstopNotification sends a notification after inactivity
+func (bn *BackstopNotifier) sendBackstopNotification() {
+	bn.mu.Lock()
+	defer bn.mu.Unlock()
+
+	// Send backstop notification
+	notification := Notification{
+		Title:   "Claude Code: Inactive",
+		Message: "No activity detected - task may be complete",
+		Time:    time.Now(),
+		Pattern: "backstop",
+	}
+
+	bn.lastNotificationTime = time.Now()
+
+	// Send via underlying notifier
+	_ = bn.underlying.Send(notification)
+	
+	// Restart timer for next backstop
+	if bn.timeout > 0 {
+		bn.timer = time.AfterFunc(bn.timeout, bn.sendBackstopNotification)
+	}
+}
+
+// startTimer starts the initial timer
+func (bn *BackstopNotifier) startTimer() {
+	bn.mu.Lock()
+	defer bn.mu.Unlock()
+
+	if bn.timeout > 0 {
+		bn.timer = time.AfterFunc(bn.timeout, bn.sendBackstopNotification)
+	}
+}
+
+// Close stops the timer
+func (bn *BackstopNotifier) Close() error {
+	bn.mu.Lock()
+	defer bn.mu.Unlock()
+
+	if bn.timer != nil {
+		bn.timer.Stop()
+	}
+
+	return nil
+}