Rename HotkeyDaemon -> Daemon

update readme

internal/daemon/daemon.go

@@ -0,0 +1,147 @@
+package daemon
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+
+	"github.com/leonardotrapani/hyprvoice/internal/bus"
+	"github.com/leonardotrapani/hyprvoice/internal/notify"
+)
+
+type Daemon struct {
+	mu        sync.Mutex
+	recording bool
+	notifier  notify.Notifier
+	ctx       context.Context
+	cancel    context.CancelFunc
+}
+
+func New(n notify.Notifier) *Daemon {
+	if n == nil {
+		n = notify.Desktop{}
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	return &Daemon{
+		notifier: n,
+		ctx:      ctx,
+		cancel:   cancel,
+	}
+}
+
+func (d *Daemon) Rec() bool {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	return d.recording
+}
+
+func (d *Daemon) Run() error {
+	if err := bus.CheckExistingDaemon(); err != nil {
+		return err
+	}
+
+	ln, err := bus.Listen()
+	if err != nil {
+		return err
+	}
+	defer ln.Close()
+
+	if err := bus.CreatePidFile(); err != nil {
+		return fmt.Errorf("failed to create PID file: %w", err)
+	}
+	defer bus.RemovePidFile()
+
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGINT)
+	defer signal.Stop(sigCh)
+
+	go func() {
+		sig := <-sigCh
+		log.Printf("Received signal %v, shutting down gracefully", sig)
+		d.cancel()
+	}()
+
+	log.Printf("Daemon started, listening on socket")
+
+	// Accept connections in a goroutine
+	connCh := make(chan net.Conn)
+	errCh := make(chan error)
+
+	go func() {
+		for {
+			c, err := ln.Accept()
+			if err != nil {
+				errCh <- err
+				return
+			}
+			connCh <- c
+		}
+	}()
+
+	for {
+		select {
+		case <-d.ctx.Done():
+			log.Printf("Shutdown requested, exiting")
+			return nil
+		case c := <-connCh:
+			go d.handle(c)
+		case err := <-errCh:
+			// If context is cancelled, this is expected
+			if d.ctx.Err() != nil {
+				return nil
+			}
+			log.Printf("Accept error: %v", err)
+			return fmt.Errorf("accept failed: %w", err)
+		}
+	}
+}
+
+func (d *Daemon) handle(c net.Conn) {
+	defer c.Close()
+
+	line, err := bufio.NewReader(c).ReadString('\n')
+	if err != nil {
+		log.Printf("Client read error: %v", err)
+		fmt.Fprintf(c, "ERR read_error: %v\n", err)
+		return
+	}
+	if len(line) == 0 {
+		fmt.Fprint(c, "ERR empty\n")
+		return
+	}
+	cmd := line[0]
+
+	switch cmd {
+	case 't': // toggle
+		d.mu.Lock()
+		d.recording = !d.recording
+		isRecording := d.recording
+		d.mu.Unlock()
+
+		d.notifier.RecordingChanged(isRecording)
+		log.Printf("Recording toggled: %t", isRecording)
+
+		fmt.Fprintf(c, "STATUS recording=%t\n", isRecording)
+	case 's': // status
+		d.mu.Lock()
+		isRecording := d.recording
+		d.mu.Unlock()
+
+		fmt.Fprintf(c, "STATUS recording=%t\n", isRecording)
+	case 'v': // protocol version
+		fmt.Fprintf(c, "STATUS proto=%s\n", bus.ProtoVer)
+	case 'q': // quit daemon
+		log.Printf("Shutdown requested")
+		fmt.Fprint(c, "OK quitting\n")
+		d.cancel()
+	default:
+		log.Printf("Unknown command: %c", cmd)
+		fmt.Fprintf(c, "ERR unknown=%q\n", cmd)
+	}
+}

internal/daemon/daemon_test.go

@@ -0,0 +1,66 @@
+package daemon
+
+import (
+	"testing"
+	"time"
+
+	"github.com/leonardotrapani/hyprvoice/internal/bus"
+	"github.com/leonardotrapani/hyprvoice/internal/notify"
+)
+
+func TestToggle(t *testing.T) {
+	// Clean up any existing daemon
+	bus.RemovePidFile()
+
+	d := New(notify.Nop{})
+
+	// Start daemon in goroutine
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- d.Run()
+	}()
+
+	// Wait for daemon to be ready by trying to connect
+	maxAttempts := 50
+	for i := range maxAttempts {
+		if _, err := bus.SendCommand('s'); err == nil {
+			break // daemon is ready
+		}
+		if i == maxAttempts-1 {
+			t.Fatal("daemon failed to start within timeout")
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	defer func() {
+		bus.SendCommand('q')
+		// Wait for daemon to exit
+		select {
+		case <-errCh:
+		case <-time.After(3 * time.Second):
+			t.Error("daemon did not exit within timeout")
+		}
+	}()
+
+	// Test first toggle
+	if out, err := bus.SendCommand('t'); err != nil {
+		t.Fatalf("first toggle failed: %v", err)
+	} else if out != "STATUS recording=true\n" {
+		t.Fatalf("unexpected first toggle response: %s", out)
+	}
+
+	if !d.Rec() {
+		t.Fatalf("state should be true after first toggle")
+	}
+
+	// Test second toggle
+	if out, err := bus.SendCommand('t'); err != nil {
+		t.Fatalf("second toggle failed: %v", err)
+	} else if out != "STATUS recording=false\n" {
+		t.Fatalf("unexpected second toggle response: %s", out)
+	}
+
+	if d.Rec() {
+		t.Fatalf("state should be false after second toggle")
+	}
+}