feat(client): implement server-initiated mode with WebSocket support

cmd/client/main.go

@@ -5,21 +5,24 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
 	"github.com/Sendspin/sendspin-go/pkg/discovery"
 	"github.com/Sendspin/sendspin-go/pkg/sendspin"
+	"github.com/gorilla/websocket"
 
 	"rpi-sendspin/internal/pipewire"
 )
 
 func main() {
-	server := flag.String("server", "localhost:8927", "server address")
+	server := flag.String("server", "", "server address for client-initiated mode (dial out). Leave empty for server-initiated mode: advertise via mDNS and wait for the server to connect.")
 	name := flag.String("name", hostname(), "player name")
 	device := flag.String("device", "", "PipeWire sink node name (default: system default)")
 	listDevices := flag.Bool("list-devices", false, "list available PipeWire sinks and exit")
@@ -119,23 +122,109 @@ func main() {
 	} else {
 		log.Printf("output: PipeWire default sink")
 	}
-	log.Printf("connecting to %s as %q...", *server, *name)
-
-	if err := player.Connect(); err != nil {
-		log.Fatalf("connect: %v", err)
-	}
-	if err := player.Play(); err != nil {
-		log.Fatalf("play: %v", err)
-	}
 
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
-	<-sig
+
+	if *server == "" {
+		// Server-initiated mode: the server discovers us via mDNS and dials
+		// our /sendspin endpoint. We just listen and let player.Accept drive
+		// each connection.
+		if *noMDNS {
+			log.Printf("warning: --no-mdns with no --server — the server cannot discover this player")
+		}
+		runServerInitiated(player, *mdnsPort, sig)
+	} else {
+		// Client-initiated mode: dial the configured server.
+		log.Printf("connecting to %s as %q...", *server, *name)
+		if err := player.Connect(); err != nil {
+			log.Fatalf("connect: %v", err)
+		}
+		if err := player.Play(); err != nil {
+			log.Fatalf("play: %v", err)
+		}
+		<-sig
+	}
 
 	log.Println("stopping")
 	player.Stop()
 }
 
+// runServerInitiated runs an HTTP/WebSocket server on the mDNS-advertised
+// port and hands each accepted /sendspin connection to player.Accept. Only
+// one session runs at a time; a newer connection evicts the current one
+// (newest-wins) so a server that reconnects isn't blocked behind a stale
+// socket. Blocks until a signal arrives on sig.
+func runServerInitiated(player *sendspin.Player, port int, sig <-chan os.Signal) {
+	upgrader := websocket.Upgrader{
+		CheckOrigin: func(*http.Request) bool { return true },
+	}
+
+	var (
+		mu      sync.Mutex // serializes sessions; held for a connection's lifetime
+		connMu  sync.Mutex // guards curConn
+		curConn *websocket.Conn
+	)
+
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			log.Printf("websocket upgrade failed: %v", err)
+			return
+		}
+
+		// Evict any in-flight session so its Accept returns and releases mu.
+		connMu.Lock()
+		if curConn != nil {
+			curConn.Close()
+		}
+		curConn = conn
+		connMu.Unlock()
+
+		mu.Lock()
+		defer mu.Unlock()
+
+		// We may have been superseded while waiting for the lock.
+		connMu.Lock()
+		superseded := curConn != conn
+		connMu.Unlock()
+		if superseded {
+			conn.Close()
+			return
+		}
+
+		if err := player.Accept(conn); err != nil {
+			log.Printf("session ended: %v", err)
+		}
+
+		connMu.Lock()
+		if curConn == conn {
+			curConn = nil
+		}
+		connMu.Unlock()
+	}
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/sendspin", handler)
+	srv := &http.Server{Addr: fmt.Sprintf(":%d", port), Handler: mux}
+
+	go func() {
+		log.Printf("server-initiated mode: listening on :%d/sendspin, waiting for a server to connect", port)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("listen: %v", err)
+		}
+	}()
+
+	<-sig
+
+	// Drop the active session first so the blocked handler returns, then let
+	// Shutdown drain the (now-unblocked) server.
+	player.CloseConnection()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	srv.Shutdown(ctx)
+}
+
 func hostname() string {
 	h, _ := os.Hostname()
 	if h == "" {
@@ -154,11 +243,20 @@ func hostname() string {
 // during reconnect could in theory move the player to a different server,
 // but for the same-machine echo-cancel use case that's acceptable.
 func buildMuter(server, muteServer, muteLoopback string) *pipewire.Muter {
-	if muteLoopback == "" && muteServer == "" {
+	if muteLoopback == "" {
+		if muteServer != "" {
+			log.Printf("muter: --mute-server set without --mute-loopback; loopback mute disabled")
+		}
 		return nil
 	}
-	if muteLoopback == "" || muteServer == "" {
-		log.Printf("muter: --mute-loopback and --mute-server must be set together; loopback mute disabled")
+	// Server-initiated (listen) mode has no fixed --server to compare
+	// against, so arm the muter purely on --mute-loopback.
+	if server == "" {
+		log.Printf("muter: will mute PipeWire node %q while streaming (server-initiated mode)", muteLoopback)
+		return pipewire.NewMuter(muteLoopback)
+	}
+	if muteServer == "" {
+		log.Printf("muter: --mute-loopback and --mute-server must be set together in client-initiated mode; loopback mute disabled")
 		return nil
 	}
 	if !sameServerAddr(server, muteServer) {