update

plugins/examples/discord-rich-presence/README.md

@@ -0,0 +1,88 @@
+# Discord Rich Presence Plugin
+
+This example plugin integrates Navidrome with Discord Rich Presence. It shows how a plugin can keep a real-time
+connection to an external service while remaining completely stateless. This plugin is based on the 
+[Navicord](https://github.com/logixism/navicord) project, which provides a similar functionality.
+
+**NOTE: This plugin is for demonstration purposes only. It relies on the user's Discord token being stored in the 
+Navidrome configuration file, which is not secure, and may be against Discord's terms of service. 
+Use it at your own risk.**
+
+## Overview
+
+The plugin exposes three capabilities:
+
+- **Scrobbler** – receives `NowPlaying` notifications from Navidrome
+- **WebSocketCallback** – handles Discord gateway messages
+- **SchedulerCallback** – used to clear presence and send periodic heartbeats
+
+It relies on several host services declared in `manifest.json`:
+
+- `http` – queries Discord API endpoints
+- `websocket` – maintains gateway connections
+- `scheduler` – schedules heartbeats and presence cleanup
+- `cache` – stores sequence numbers for heartbeats
+- `config` – retrieves the plugin configuration on each call
+- `artwork` – resolves track artwork URLs
+
+## Architecture
+
+Each call from Navidrome creates a new plugin instance. The `init` function registers the capabilities and obtains the
+scheduler service:
+
+```go
+api.RegisterScrobbler(plugin)
+api.RegisterWebSocketCallback(plugin.rpc)
+plugin.sched = api.RegisterNamedSchedulerCallback("close-activity", plugin)
+plugin.rpc.sched = api.RegisterNamedSchedulerCallback("heartbeat", plugin.rpc)
+```
+
+When `NowPlaying` is invoked the plugin:
+
+1. Loads `clientid` and user tokens from the configuration (because plugins are stateless).
+2. Connects to Discord using `WebSocketService` if no connection exists.
+3. Sends the activity payload with track details and artwork.
+4. Schedules a one‑time callback to clear the presence after the track finishes.
+
+Heartbeat messages are sent by a recurring scheduler job. Sequence numbers received from Discord are stored in
+`CacheService` to remain available across plugin instances.
+
+The `OnSchedulerCallback` method clears the presence and closes the connection when the scheduled time is reached.
+
+```go
+// The plugin is stateless, we need to load the configuration every time
+clientID, users, err := d.getConfig(ctx)
+```
+
+## Configuration
+
+Add the following to `navidrome.toml` and adjust for your tokens:
+
+```toml
+[PluginConfig.discord-rich-presence]
+ClientID = "123456789012345678"
+Users = "alice:token123,bob:token456"
+```
+
+- `clientid` is your Discord application ID
+- `users` is a comma‑separated list of `username:token` pairs used for authorization
+
+## Building
+
+```sh
+GOOS=wasip1 GOARCH=wasm go build -buildmode=c-shared -o plugin.wasm ./discord-rich-presence/...
+```
+
+Place the resulting `plugin.wasm` and `manifest.json` in a `discord-rich-presence` folder under your Navidrome plugins
+directory.
+
+## Stateless Operation
+
+Navidrome plugins are completely stateless – each method call instantiates a new plugin instance and discards it
+afterwards.
+
+To work within this model the plugin stores no in-memory state. Connections are keyed by user name inside the host
+services and any transient data (like Discord sequence numbers) is kept in the cache. Configuration is reloaded on every
+method call.
+
+For more implementation details see `plugin.go` and `rpc.go`.

plugins/examples/discord-rich-presence/manifest.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://raw.githubusercontent.com/navidrome/navidrome/refs/heads/master/plugins/schema/manifest.schema.json",
+  "name": "discord-rich-presence",
+  "author": "Navidrome Team",
+  "version": "1.0.0",
+  "description": "Discord Rich Presence integration for Navidrome",
+  "website": "https://github.com/navidrome/navidrome/tree/master/plugins/examples/discord-rich-presence",
+  "capabilities": ["Scrobbler", "SchedulerCallback", "WebSocketCallback"],
+  "permissions": {
+    "http": {
+      "reason": "To communicate with Discord API for gateway discovery and image uploads",
+      "allowedUrls": {
+        "https://discord.com/api/*": ["GET", "POST"]
+      },
+      "allowLocalNetwork": false
+    },
+    "websocket": {
+      "reason": "To maintain real-time connection with Discord gateway",
+      "allowedUrls": ["wss://gateway.discord.gg"],
+      "allowLocalNetwork": false
+    },
+    "config": {
+      "reason": "To access plugin configuration (client ID and user tokens)"
+    },
+    "cache": {
+      "reason": "To store connection state and sequence numbers"
+    },
+    "scheduler": {
+      "reason": "To schedule heartbeat messages and activity clearing"
+    },
+    "artwork": {
+      "reason": "To get track artwork URLs for rich presence display"
+    }
+  }
+}

plugins/examples/discord-rich-presence/plugin.go

@@ -0,0 +1,186 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/navidrome/navidrome/plugins/api"
+	"github.com/navidrome/navidrome/plugins/host/artwork"
+	"github.com/navidrome/navidrome/plugins/host/cache"
+	"github.com/navidrome/navidrome/plugins/host/config"
+	"github.com/navidrome/navidrome/plugins/host/http"
+	"github.com/navidrome/navidrome/plugins/host/scheduler"
+	"github.com/navidrome/navidrome/plugins/host/websocket"
+	"github.com/navidrome/navidrome/utils/slice"
+)
+
+type DiscordRPPlugin struct {
+	rpc     *discordRPC
+	cfg     config.ConfigService
+	artwork artwork.ArtworkService
+	sched   scheduler.SchedulerService
+}
+
+func (d *DiscordRPPlugin) IsAuthorized(ctx context.Context, req *api.ScrobblerIsAuthorizedRequest) (*api.ScrobblerIsAuthorizedResponse, error) {
+	// Get plugin configuration
+	_, users, err := d.getConfig(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check user authorization: %w", err)
+	}
+
+	// Check if the user has a Discord token configured
+	_, authorized := users[req.Username]
+	log.Printf("IsAuthorized for user %s: %v", req.Username, authorized)
+	return &api.ScrobblerIsAuthorizedResponse{
+		Authorized: authorized,
+	}, nil
+}
+
+func (d *DiscordRPPlugin) NowPlaying(ctx context.Context, request *api.ScrobblerNowPlayingRequest) (*api.ScrobblerNowPlayingResponse, error) {
+	log.Printf("Setting presence for user %s, track: %s", request.Username, request.Track.Name)
+
+	// The plugin is stateless, we need to load the configuration every time
+	clientID, users, err := d.getConfig(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get config: %w", err)
+	}
+
+	// Check if the user has a Discord token configured
+	userToken, authorized := users[request.Username]
+	if !authorized {
+		return nil, fmt.Errorf("user '%s' not authorized", request.Username)
+	}
+
+	// Make sure we have a connection
+	if err := d.rpc.connect(ctx, request.Username, userToken); err != nil {
+		return nil, fmt.Errorf("failed to connect to Discord: %w", err)
+	}
+
+	// Cancel any existing completion schedule
+	if resp, _ := d.sched.CancelSchedule(ctx, &scheduler.CancelRequest{ScheduleId: request.Username}); resp.Error != "" {
+		log.Printf("Ignoring failure to cancel schedule: %s", resp.Error)
+	}
+
+	// Send activity update
+	if err := d.rpc.sendActivity(ctx, clientID, request.Username, userToken, activity{
+		Application: clientID,
+		Name:        "Navidrome",
+		Type:        2,
+		Details:     request.Track.Name,
+		State:       d.getArtistList(request.Track),
+		Timestamps: activityTimestamps{
+			Start: (request.Timestamp - int64(request.Track.Position)) * 1000,
+			End:   (request.Timestamp - int64(request.Track.Position) + int64(request.Track.Length)) * 1000,
+		},
+		Assets: activityAssets{
+			LargeImage: d.imageURL(ctx, request),
+			LargeText:  request.Track.Album,
+		},
+	}); err != nil {
+		return nil, fmt.Errorf("failed to send activity: %w", err)
+	}
+
+	// Schedule a timer to clear the activity after the track completes
+	_, err = d.sched.ScheduleOneTime(ctx, &scheduler.ScheduleOneTimeRequest{
+		ScheduleId:   request.Username,
+		DelaySeconds: request.Track.Length - request.Track.Position + 5,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to schedule completion timer: %w", err)
+	}
+
+	return nil, nil
+}
+
+func (d *DiscordRPPlugin) imageURL(ctx context.Context, request *api.ScrobblerNowPlayingRequest) string {
+	imageResp, _ := d.artwork.GetTrackUrl(ctx, &artwork.GetArtworkUrlRequest{Id: request.Track.Id, Size: 300})
+	imageURL := imageResp.Url
+	if strings.HasPrefix(imageURL, "http://localhost") {
+		return ""
+	}
+	return imageURL
+}
+
+func (d *DiscordRPPlugin) getArtistList(track *api.TrackInfo) string {
+	return strings.Join(slice.Map(track.Artists, func(a *api.Artist) string { return a.Name }), " • ")
+}
+
+func (d *DiscordRPPlugin) Scrobble(context.Context, *api.ScrobblerScrobbleRequest) (*api.ScrobblerScrobbleResponse, error) {
+	return nil, nil
+}
+
+func (d *DiscordRPPlugin) getConfig(ctx context.Context) (string, map[string]string, error) {
+	const (
+		clientIDKey = "clientid"
+		usersKey    = "users"
+	)
+	confResp, err := d.cfg.GetPluginConfig(ctx, &config.GetPluginConfigRequest{})
+	if err != nil {
+		return "", nil, fmt.Errorf("unable to load config: %w", err)
+	}
+	conf := confResp.GetConfig()
+	if len(conf) < 1 {
+		log.Print("missing configuration")
+		return "", nil, nil
+	}
+	clientID := conf[clientIDKey]
+	if clientID == "" {
+		log.Printf("missing ClientID: %v", conf)
+		return "", nil, nil
+	}
+	cfgUsers := conf[usersKey]
+	if len(cfgUsers) == 0 {
+		log.Print("no users configured")
+		return "", nil, nil
+	}
+	users := map[string]string{}
+	for _, user := range strings.Split(cfgUsers, ",") {
+		tuple := strings.Split(user, ":")
+		if len(tuple) != 2 {
+			return clientID, nil, fmt.Errorf("invalid user config: %s", user)
+		}
+		users[tuple[0]] = tuple[1]
+	}
+	return clientID, users, nil
+}
+
+func (d *DiscordRPPlugin) OnSchedulerCallback(ctx context.Context, req *api.SchedulerCallbackRequest) (*api.SchedulerCallbackResponse, error) {
+	log.Printf("Removing presence for user %s", req.ScheduleId)
+	if err := d.rpc.clearActivity(ctx, req.ScheduleId); err != nil {
+		return nil, fmt.Errorf("failed to clear activity: %w", err)
+	}
+	log.Printf("Disconnecting user %s", req.ScheduleId)
+	if err := d.rpc.disconnect(ctx, req.ScheduleId); err != nil {
+		return nil, fmt.Errorf("failed to disconnect from Discord: %w", err)
+	}
+	return nil, nil
+}
+
+// Creates a new instance of the DiscordRPPlugin, with all host services as dependencies
+var plugin = &DiscordRPPlugin{
+	cfg:     config.NewConfigService(),
+	artwork: artwork.NewArtworkService(),
+	rpc: &discordRPC{
+		ws:  websocket.NewWebSocketService(),
+		web: http.NewHttpService(),
+		mem: cache.NewCacheService(),
+	},
+}
+
+func init() {
+	// Configure logging: No timestamps, no source file/line, prepend [Discord]
+	log.SetFlags(0)
+	log.SetPrefix("[Discord] ")
+
+	// Register plugin capabilities
+	api.RegisterScrobbler(plugin)
+	api.RegisterWebSocketCallback(plugin.rpc)
+
+	// Register named scheduler callbacks, and get the scheduler service for each
+	plugin.sched = api.RegisterNamedSchedulerCallback("close-activity", plugin)
+	plugin.rpc.sched = api.RegisterNamedSchedulerCallback("heartbeat", plugin.rpc)
+}
+
+func main() {}

plugins/examples/discord-rich-presence/rpc.go

@@ -0,0 +1,402 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/plugins/api"
+	"github.com/navidrome/navidrome/plugins/host/cache"
+	"github.com/navidrome/navidrome/plugins/host/http"
+	"github.com/navidrome/navidrome/plugins/host/scheduler"
+	"github.com/navidrome/navidrome/plugins/host/websocket"
+)
+
+type discordRPC struct {
+	ws    websocket.WebSocketService
+	web   http.HttpService
+	mem   cache.CacheService
+	sched scheduler.SchedulerService
+}
+
+// Discord WebSocket Gateway constants
+const (
+	heartbeatOpCode = 1 // Heartbeat operation code
+	gateOpCode      = 2 // Identify operation code
+	presenceOpCode  = 3 // Presence update operation code
+)
+
+const (
+	heartbeatInterval = 41 // Heartbeat interval in seconds
+	defaultImage      = "https://i.imgur.com/hb3XPzA.png"
+)
+
+// Activity is a struct that represents an activity in Discord.
+type activity struct {
+	Name        string             `json:"name"`
+	Type        int                `json:"type"`
+	Details     string             `json:"details"`
+	State       string             `json:"state"`
+	Application string             `json:"application_id"`
+	Timestamps  activityTimestamps `json:"timestamps"`
+	Assets      activityAssets     `json:"assets"`
+}
+
+type activityTimestamps struct {
+	Start int64 `json:"start"`
+	End   int64 `json:"end"`
+}
+
+type activityAssets struct {
+	LargeImage string `json:"large_image"`
+	LargeText  string `json:"large_text"`
+}
+
+// PresencePayload is a struct that represents a presence update in Discord.
+type presencePayload struct {
+	Activities []activity `json:"activities"`
+	Since      int64      `json:"since"`
+	Status     string     `json:"status"`
+	Afk        bool       `json:"afk"`
+}
+
+// IdentifyPayload is a struct that represents an identify payload in Discord.
+type identifyPayload struct {
+	Token      string             `json:"token"`
+	Intents    int                `json:"intents"`
+	Properties identifyProperties `json:"properties"`
+}
+
+type identifyProperties struct {
+	OS      string `json:"os"`
+	Browser string `json:"browser"`
+	Device  string `json:"device"`
+}
+
+func (r *discordRPC) processImage(ctx context.Context, imageURL string, clientID string, token string) (string, error) {
+	return r.processImageWithFallback(ctx, imageURL, clientID, token, false)
+}
+
+func (r *discordRPC) processImageWithFallback(ctx context.Context, imageURL string, clientID string, token string, isDefaultImage bool) (string, error) {
+	// Check if context is canceled
+	if err := ctx.Err(); err != nil {
+		return "", fmt.Errorf("context canceled: %w", err)
+	}
+
+	if imageURL == "" {
+		if isDefaultImage {
+			// We're already processing the default image and it's empty, return error
+			return "", fmt.Errorf("default image URL is empty")
+		}
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+
+	if strings.HasPrefix(imageURL, "mp:") {
+		return imageURL, nil
+	}
+
+	// Check cache first
+	cacheKey := fmt.Sprintf("discord.image.%x", imageURL)
+	cacheResp, _ := r.mem.GetString(ctx, &cache.GetRequest{Key: cacheKey})
+	if cacheResp.Exists {
+		log.Printf("Cache hit for image URL: %s", imageURL)
+		return cacheResp.Value, nil
+	}
+
+	resp, _ := r.web.Post(ctx, &http.HttpRequest{
+		Url: fmt.Sprintf("https://discord.com/api/v9/applications/%s/external-assets", clientID),
+		Headers: map[string]string{
+			"Authorization": token,
+			"Content-Type":  "application/json",
+		},
+		Body: fmt.Appendf(nil, `{"urls":[%q]}`, imageURL),
+	})
+
+	// Handle HTTP error responses
+	if resp.Status >= 400 {
+		if isDefaultImage {
+			return "", fmt.Errorf("failed to process default image: HTTP %d %s", resp.Status, resp.Error)
+		}
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+	if resp.Error != "" {
+		if isDefaultImage {
+			// If we're already processing the default image and it fails, return error
+			return "", fmt.Errorf("failed to process default image: %s", resp.Error)
+		}
+		// Try with default image
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+
+	var data []map[string]string
+	if err := json.Unmarshal(resp.Body, &data); err != nil {
+		if isDefaultImage {
+			// If we're already processing the default image and it fails, return error
+			return "", fmt.Errorf("failed to unmarshal default image response: %w", err)
+		}
+		// Try with default image
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+
+	if len(data) == 0 {
+		if isDefaultImage {
+			// If we're already processing the default image and it fails, return error
+			return "", fmt.Errorf("no data returned for default image")
+		}
+		// Try with default image
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+
+	image := data[0]["external_asset_path"]
+	if image == "" {
+		if isDefaultImage {
+			// If we're already processing the default image and it fails, return error
+			return "", fmt.Errorf("empty external_asset_path for default image")
+		}
+		// Try with default image
+		return r.processImageWithFallback(ctx, defaultImage, clientID, token, true)
+	}
+
+	processedImage := fmt.Sprintf("mp:%s", image)
+
+	// Cache the processed image URL
+	var ttl = 4 * time.Hour // 4 hours for regular images
+	if isDefaultImage {
+		ttl = 48 * time.Hour // 48 hours for default image
+	}
+
+	_, _ = r.mem.SetString(ctx, &cache.SetStringRequest{
+		Key:        cacheKey,
+		Value:      processedImage,
+		TtlSeconds: int64(ttl.Seconds()),
+	})
+
+	log.Printf("Cached processed image URL for %s (TTL: %s seconds)", imageURL, ttl)
+
+	return processedImage, nil
+}
+
+func (r *discordRPC) sendActivity(ctx context.Context, clientID, username, token string, data activity) error {
+	log.Printf("Sending activity to for user %s: %#v", username, data)
+
+	processedImage, err := r.processImage(ctx, data.Assets.LargeImage, clientID, token)
+	if err != nil {
+		log.Printf("Failed to process image for user %s, continuing without image: %v", username, err)
+		// Clear the image and continue without it
+		data.Assets.LargeImage = ""
+	} else {
+		log.Printf("Processed image for URL %s: %s", data.Assets.LargeImage, processedImage)
+		data.Assets.LargeImage = processedImage
+	}
+
+	presence := presencePayload{
+		Activities: []activity{data},
+		Status:     "dnd",
+		Afk:        false,
+	}
+	return r.sendMessage(ctx, username, presenceOpCode, presence)
+}
+
+func (r *discordRPC) clearActivity(ctx context.Context, username string) error {
+	log.Printf("Clearing activity for user %s", username)
+	return r.sendMessage(ctx, username, presenceOpCode, presencePayload{})
+}
+
+func (r *discordRPC) sendMessage(ctx context.Context, username string, opCode int, payload any) error {
+	message := map[string]any{
+		"op": opCode,
+		"d":  payload,
+	}
+	b, err := json.Marshal(message)
+	if err != nil {
+		return fmt.Errorf("failed to marshal presence update: %w", err)
+	}
+
+	resp, _ := r.ws.SendText(ctx, &websocket.SendTextRequest{
+		ConnectionId: username,
+		Message:      string(b),
+	})
+	if resp.Error != "" {
+		return fmt.Errorf("failed to send presence update: %s", resp.Error)
+	}
+	return nil
+}
+
+func (r *discordRPC) getDiscordGateway(ctx context.Context) (string, error) {
+	resp, _ := r.web.Get(ctx, &http.HttpRequest{
+		Url: "https://discord.com/api/gateway",
+	})
+	if resp.Error != "" {
+		return "", fmt.Errorf("failed to get Discord gateway: %s", resp.Error)
+	}
+	var result map[string]string
+	err := json.Unmarshal(resp.Body, &result)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse Discord gateway response: %w", err)
+	}
+	return result["url"], nil
+}
+
+func (r *discordRPC) sendHeartbeat(ctx context.Context, username string) error {
+	resp, _ := r.mem.GetInt(ctx, &cache.GetRequest{
+		Key: fmt.Sprintf("discord.seq.%s", username),
+	})
+	log.Printf("Sending heartbeat for user %s: %d", username, resp.Value)
+	return r.sendMessage(ctx, username, heartbeatOpCode, resp.Value)
+}
+
+func (r *discordRPC) cleanupFailedConnection(ctx context.Context, username string) {
+	log.Printf("Cleaning up failed connection for user %s", username)
+
+	// Cancel the heartbeat schedule
+	if resp, _ := r.sched.CancelSchedule(ctx, &scheduler.CancelRequest{ScheduleId: username}); resp.Error != "" {
+		log.Printf("Failed to cancel heartbeat schedule for user %s: %s", username, resp.Error)
+	}
+
+	// Close the WebSocket connection
+	if resp, _ := r.ws.Close(ctx, &websocket.CloseRequest{
+		ConnectionId: username,
+		Code:         1000,
+		Reason:       "Connection lost",
+	}); resp.Error != "" {
+		log.Printf("Failed to close WebSocket connection for user %s: %s", username, resp.Error)
+	}
+
+	// Clean up cache entries (just the sequence number, no failure tracking needed)
+	_, _ = r.mem.Remove(ctx, &cache.RemoveRequest{Key: fmt.Sprintf("discord.seq.%s", username)})
+
+	log.Printf("Cleaned up connection for user %s", username)
+}
+
+func (r *discordRPC) isConnected(ctx context.Context, username string) bool {
+	// Try to send a heartbeat to test the connection
+	err := r.sendHeartbeat(ctx, username)
+	if err != nil {
+		log.Printf("Heartbeat test failed for user %s: %v", username, err)
+		return false
+	}
+	return true
+}
+
+func (r *discordRPC) connect(ctx context.Context, username string, token string) error {
+	if r.isConnected(ctx, username) {
+		log.Printf("Reusing existing connection for user %s", username)
+		return nil
+	}
+	log.Printf("Creating new connection for user %s", username)
+
+	// Get Discord Gateway URL
+	gateway, err := r.getDiscordGateway(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to get Discord gateway: %w", err)
+	}
+	log.Printf("Using gateway: %s", gateway)
+
+	// Connect to Discord Gateway
+	resp, _ := r.ws.Connect(ctx, &websocket.ConnectRequest{
+		ConnectionId: username,
+		Url:          gateway,
+	})
+	if resp.Error != "" {
+		return fmt.Errorf("failed to connect to WebSocket: %s", resp.Error)
+	}
+
+	// Send identify payload
+	payload := identifyPayload{
+		Token:   token,
+		Intents: 0,
+		Properties: identifyProperties{
+			OS:      "Windows 10",
+			Browser: "Discord Client",
+			Device:  "Discord Client",
+		},
+	}
+	err = r.sendMessage(ctx, username, gateOpCode, payload)
+	if err != nil {
+		return fmt.Errorf("failed to send identify payload: %w", err)
+	}
+
+	// Schedule heartbeats for this user/connection
+	cronResp, _ := r.sched.ScheduleRecurring(ctx, &scheduler.ScheduleRecurringRequest{
+		CronExpression: fmt.Sprintf("@every %ds", heartbeatInterval),
+		ScheduleId:     username,
+	})
+	log.Printf("Scheduled heartbeat for user %s with ID %s", username, cronResp.ScheduleId)
+
+	log.Printf("Successfully authenticated user %s", username)
+	return nil
+}
+
+func (r *discordRPC) disconnect(ctx context.Context, username string) error {
+	if resp, _ := r.sched.CancelSchedule(ctx, &scheduler.CancelRequest{ScheduleId: username}); resp.Error != "" {
+		return fmt.Errorf("failed to cancel schedule: %s", resp.Error)
+	}
+	resp, _ := r.ws.Close(ctx, &websocket.CloseRequest{
+		ConnectionId: username,
+		Code:         1000,
+		Reason:       "Navidrome disconnect",
+	})
+	if resp.Error != "" {
+		return fmt.Errorf("failed to close WebSocket connection: %s", resp.Error)
+	}
+	return nil
+}
+
+func (r *discordRPC) OnTextMessage(ctx context.Context, req *api.OnTextMessageRequest) (*api.OnTextMessageResponse, error) {
+	if len(req.Message) < 1024 {
+		log.Printf("Received WebSocket message for connection '%s': %s", req.ConnectionId, req.Message)
+	} else {
+		log.Printf("Received WebSocket message for connection '%s' (truncated): %s...", req.ConnectionId, req.Message[:1021])
+	}
+
+	// Parse the message. If it's a heartbeat_ack, store the sequence number.
+	message := map[string]any{}
+	err := json.Unmarshal([]byte(req.Message), &message)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse WebSocket message: %w", err)
+	}
+	if v := message["s"]; v != nil {
+		seq := int64(v.(float64))
+		log.Printf("Received heartbeat_ack for connection '%s': %d", req.ConnectionId, seq)
+		resp, _ := r.mem.SetInt(ctx, &cache.SetIntRequest{
+			Key:        fmt.Sprintf("discord.seq.%s", req.ConnectionId),
+			Value:      seq,
+			TtlSeconds: heartbeatInterval * 2,
+		})
+		if !resp.Success {
+			return nil, fmt.Errorf("failed to store sequence number for user %s", req.ConnectionId)
+		}
+	}
+	return nil, nil
+}
+
+func (r *discordRPC) OnBinaryMessage(_ context.Context, req *api.OnBinaryMessageRequest) (*api.OnBinaryMessageResponse, error) {
+	log.Printf("Received unexpected binary message for connection '%s'", req.ConnectionId)
+	return nil, nil
+}
+
+func (r *discordRPC) OnError(_ context.Context, req *api.OnErrorRequest) (*api.OnErrorResponse, error) {
+	log.Printf("WebSocket error for connection '%s': %s", req.ConnectionId, req.Error)
+	return nil, nil
+}
+
+func (r *discordRPC) OnClose(_ context.Context, req *api.OnCloseRequest) (*api.OnCloseResponse, error) {
+	log.Printf("WebSocket connection '%s' closed with code %d: %s", req.ConnectionId, req.Code, req.Reason)
+	return nil, nil
+}
+
+func (r *discordRPC) OnSchedulerCallback(ctx context.Context, req *api.SchedulerCallbackRequest) (*api.SchedulerCallbackResponse, error) {
+	err := r.sendHeartbeat(ctx, req.ScheduleId)
+	if err != nil {
+		// On first heartbeat failure, immediately clean up the connection
+		// The next NowPlaying call will reconnect if needed
+		log.Printf("Heartbeat failed for user %s, cleaning up connection: %v", req.ScheduleId, err)
+		r.cleanupFailedConnection(ctx, req.ScheduleId)
+		return nil, fmt.Errorf("heartbeat failed, connection cleaned up: %w", err)
+	}
+
+	return nil, nil
+}