improve daemon's toggle

internal/daemon/daemon.go

@@ -10,7 +10,6 @@ import (
 	"os/signal"
 	"sync"
 	"syscall"
-	"time"
 
 	"github.com/leonardotrapani/hyprvoice/internal/bus"
 	"github.com/leonardotrapani/hyprvoice/internal/notify"
@@ -35,8 +34,7 @@ type Daemon struct {
 	cancel context.CancelFunc
 
 	pipeline      pipeline.Pipeline
-	pipelineCancel context.CancelFunc
+	actionChannel chan<- pipeline.Action
-	statusCh       <-chan Status
 }
 
 func New(n notify.Notifier) *Daemon {
@@ -61,14 +59,12 @@ func (d *Daemon) Status() Status {
 }
 
 func (d *Daemon) startStatusReader(ctx context.Context, statusCh <-chan Status) {
-	go func() {
 	defer func() {
 		// Always clean up when this goroutine exits
 		d.mu.Lock()
 		d.status = Idle
-			d.statusCh = nil
 		d.pipeline = nil
-			d.pipelineCancel = nil
+		d.actionChannel = nil
 		d.mu.Unlock()
 	}()
 
@@ -92,7 +88,6 @@ func (d *Daemon) startStatusReader(ctx context.Context, statusCh <-chan Status)
 			return // Context cancelled
 		}
 	}
-	}()
 }
 
 func (d *Daemon) Run() error {
@@ -139,7 +134,6 @@ func (d *Daemon) Run() error {
 			log.Printf("Accept error: %v", err)
 			return fmt.Errorf("accept failed: %w", err)
 		}
-
 		go d.handle(c)
 	}
 }
@@ -165,7 +159,7 @@ func (d *Daemon) handle(c net.Conn) {
 		fmt.Fprint(c, "OK toggled\n")
 	case 's':
 		status := d.Status()
-		fmt.Fprintf(c, "STATUS recording=%s\n", status)
+		fmt.Fprintf(c, "STATUS status=%s\n", status)
 	case 'v':
 		fmt.Fprintf(c, "STATUS proto=%s\n", bus.ProtoVer)
 	case 'q':
@@ -178,44 +172,36 @@ func (d *Daemon) handle(c net.Conn) {
 }
 
 func (d *Daemon) toggle() {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	var notification func()
-
 	switch d.status {
 	case Idle:
-		ctx, cancel := context.WithTimeout(d.ctx, 5*time.Minute)
+		// Defensive: if a prior pipeline exists, stop and wait before starting a new one
-		p := pipeline.New()
+		if d.pipeline != nil {
-		d.pipeline = p
+			d.pipeline.Stop()
-		d.pipelineCancel = cancel
+			d.pipeline = nil
-		d.statusCh = p.Run(ctx)
+		}
-		notification = d.notifier.RecordingStarted
 
-		// Start status reader for this pipeline
+		p := pipeline.New()
-		d.startStatusReader(ctx, d.statusCh)
+		statusCh, actionCh := p.Run(d.ctx)
+
+		d.pipeline = p
+		d.actionChannel = actionCh
+
+		go d.notifier.RecordingStarted()
+
+		go d.startStatusReader(d.ctx, statusCh)
 
 	case Recording:
-		if d.pipelineCancel != nil {
+		go d.notifier.RecordingEnded()
-			d.pipelineCancel() // Context cleanup handles the rest
+		d.pipeline.Stop()
-		}
-		notification = d.notifier.RecordingEnded
 
 	case Transcribing:
-		if d.pipeline != nil {
+		select {
-			d.pipeline.Inject()
+		case d.actionChannel <- pipeline.Inject:
+		default:
 		}
-		// No notification for injection start
 
 	case Injecting:
-		if d.pipelineCancel != nil {
+		go d.notifier.RecordingEnded()
-			d.pipelineCancel() // Context cleanup handles the rest
+		d.pipeline.Stop() // aborted during injection
-		}
-		notification = d.notifier.RecordingEnded
-	}
-
-	// Send notification after releasing lock
-	if notification != nil {
-		go notification()
 	}
 }

internal/pipeline/pipeline.go

@@ -3,6 +3,7 @@ package pipeline
 import (
 	"context"
 	"log"
+	"sync"
 	"time"
 )
 
@@ -15,38 +16,48 @@ const (
 	Injecting    Status = "injecting"
 )
 
+// Action represents commands sent to the pipeline to drive state
+// transitions or trigger work. Keeping this separate from Status
+// preserves directionality: callers send Actions, pipeline emits Statuses.
+type Action int
+
+const (
+	Inject Action = iota
+)
+
 type Pipeline interface {
-	Run(ctx context.Context) <-chan Status
+	Run(ctx context.Context) (<-chan Status, chan<- Action)
-	Inject()
+	Stop()
 }
 
 type pipeline struct {
-	injectCh chan struct{}
+	actionCh chan Action
+	wg       sync.WaitGroup
+	cancel   context.CancelFunc
 }
 
 func New() Pipeline {
 	return &pipeline{
-		injectCh: make(chan struct{}, 1),
+		actionCh: make(chan Action, 1),
 	}
 }
 
-func (p *pipeline) Run(ctx context.Context) <-chan Status {
+func (p *pipeline) Run(ctx context.Context) (<-chan Status, chan<- Action) {
 	statusCh := make(chan Status, 1)
-	go p.run(ctx, statusCh)
+	runCtx, cancel := context.WithTimeout(ctx, 5*time.Minute)
-	return statusCh
+	p.cancel = cancel
-}
+	p.wg.Add(1)
-
+	go p.run(runCtx, statusCh)
-func (p *pipeline) Inject() {
+	return statusCh, p.actionCh
-	select {
-	case p.injectCh <- struct{}{}:
-	default:
-	}
 }
 
 func (p *pipeline) run(ctx context.Context, statusCh chan<- Status) {
-	defer close(statusCh)
+	defer func() {
+		// Ensure status channel is closed and wg is decremented
+		close(statusCh)
+		p.wg.Done()
+	}()
 
-	// Start recording
 	log.Printf("Pipeline: Starting recording")
 	statusCh <- Recording
 
@@ -60,9 +71,12 @@ func (p *pipeline) run(ctx context.Context, statusCh chan<- Status) {
 		return
 	}
 
-	// Wait for injection or timeout
+	// TODO: when integrating the recorder, ensure its context is cancelled here on exit paths
+	// Wait for an action or timeout
 	select {
-	case <-p.injectCh:
+	case action := <-p.actionCh:
+		switch action {
+		case Inject:
 			log.Printf("Pipeline: Injection started")
 			statusCh <- Injecting
 
@@ -70,11 +84,14 @@ func (p *pipeline) run(ctx context.Context, statusCh chan<- Status) {
 			select {
 			case <-time.After(1 * time.Second):
 				log.Printf("Pipeline: Injection complete")
-			statusCh <- Idle // Instead of Completed
+				statusCh <- Idle
 			case <-ctx.Done():
 				log.Printf("Pipeline: Stopped during injection")
 				return
 			}
+		default:
+			// Unknown action: ignore for now
+		}
 
 	case <-time.After(10 * time.Second): // use context timeout
 		log.Printf("Pipeline: Auto-timeout, completing")
@@ -85,3 +102,10 @@ func (p *pipeline) run(ctx context.Context, statusCh chan<- Status) {
 		return
 	}
 }
+
+func (p *pipeline) Stop() {
+	if p.cancel != nil {
+		p.cancel()
+	}
+	p.wg.Wait()
+}

internal/recording/recording.go

@@ -101,12 +101,8 @@ func (r *Recorder) Stop() error {
 	if cancel != nil {
 		cancel()
 	}
-
-	return nil
-}
-
-func (r *Recorder) Wait() {
 	r.wg.Wait()
+	return nil
 }
 
 func (r *Recorder) captureLoop(ctx context.Context, frameCh chan<- AudioFrame, errCh chan<- error) {
@@ -144,16 +140,16 @@ func (r *Recorder) captureLoop(ctx context.Context, frameCh chan<- AudioFrame, e
 		return
 	}
 
-	r.mu.Lock()
-	r.cmd = cmd
-	r.mu.Unlock()
-
 	if err := cmd.Start(); err != nil {
 		r.emitErr(errCh, fmt.Errorf("start pw-record: %w", err))
 		r.requestCancel()
 		return
 	}
 
+	r.mu.Lock()
+	r.cmd = cmd
+	r.mu.Unlock()
+
 	// Log stderr lines to aid diagnostics.
 	go func() {
 		scanner := bufio.NewScanner(stderr)
@@ -221,7 +217,6 @@ func (r *Recorder) emitErr(errCh chan<- error, err error) {
 	select {
 	case errCh <- err:
 	default:
-		// Best-effort; avoid blocking
 	}
 	log.Printf("Recording error: %v", err)
 }
@@ -246,9 +241,6 @@ func CheckPipeWireAvailable(ctx context.Context) error {
 		return fmt.Errorf("pw-record not found: %w (install pipewire-tools)", err)
 	}
 	// Use a short timeout to avoid hangs on misconfigured systems.
-	if ctx == nil {
-		ctx = context.Background()
-	}
 	checkCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
 	defer cancel()
 	cmd := exec.CommandContext(checkCtx, "pw-cli", "info")