Add restore-token reset control command

Let control clients clear one target's Wayland portal restore token and reconnect it without rewriting other credentials. Preserve receiver ports and reject shared capture groups so unrelated streams stay intact.

Co-authored-by: minpeter <minpeterx@gmail.com>

Generated with [OpenAI Codex](https://openai.com/codex/)

Author: minpeter

README.md

@@ -344,6 +344,7 @@ doubletake-ctl status
 doubletake-ctl connect 192.168.1.77
 doubletake-ctl connect 192.168.1.133
 doubletake-ctl disconnect 192.168.1.77
+doubletake-ctl reset-restore-token 192.168.1.133
 doubletake-ctl disconnect
 ```
 
@@ -399,13 +400,19 @@ doubletake-ctl devices
 doubletake-ctl connect [target] [PIN-or-password]
 doubletake-ctl pin <PIN-or-password>
 doubletake-ctl disconnect [target]
+doubletake-ctl reset-restore-token <target>
 doubletake-ctl mute [target]
 doubletake-ctl unmute [target]
 ```
 
 - `disconnect` without a target stops all active streams.
 - `disconnect <target>` stops only that receiver.
 - `mute`/`unmute` can operate globally or per target.
+- `reset-restore-token <target>` stops one fully streaming receiver, clears only
+  its saved Wayland portal restore token, and reconnects it on the same IP and
+  port. Pairing credentials and other streams are unchanged. The command rejects
+  targets sharing a capture group; disconnect those peers first so the old portal
+  source can be stopped before a replacement is authorized.
 - `pin` retains its historical command name, but submits whichever credential
   the daemon requests: an on-screen PIN or a configured password. It is
   targetless and therefore requires exactly one waiting receiver; use

cmd/doubletake-ctl/main.go

@@ -61,6 +61,12 @@ func main() {
 		} else {
 			resp, err = client.Disconnect()
 		}
+	case "reset-restore-token":
+		if len(args) != 2 {
+			fmt.Fprintln(os.Stderr, "Usage: doubletake-ctl reset-restore-token <target>")
+			os.Exit(1)
+		}
+		resp, err = client.ResetRestoreToken(args[1])
 	case "mute":
 		if len(args) >= 2 {
 			resp, err = client.MuteTarget(args[1])
@@ -94,5 +100,5 @@ func main() {
 }
 
 func usage() {
-	fmt.Fprintf(os.Stderr, "Usage: doubletake-ctl [-socket path] <command> [args]\n\nCommands:\n  status                              Show daemon state and all active streams\n  discover                            Discover AirPlay devices on the network\n  devices                             List cached discovered devices\n  connect [target] [PIN-or-password]  Start mirroring (to target IP, or first free device)\n  pin <PIN-or-password>               Submit pairing credentials for a waiting device\n  disconnect [target]                 Stop mirroring (all streams, or only the given IP)\n  mute [target]                       Mute mirrored audio (all streams, or only the given IP)\n  unmute [target]                     Unmute mirrored audio (all streams, or only the given IP)\n\nFlags:\n  -socket path                        Override daemon socket path (default: %s)\n", daemon.DefaultSocketPath())
+	fmt.Fprintf(os.Stderr, "Usage: doubletake-ctl [-socket path] <command> [args]\n\nCommands:\n  status                              Show daemon state and all active streams\n  discover                            Discover AirPlay devices on the network\n  devices                             List cached discovered devices\n  connect [target] [PIN-or-password]  Start mirroring (to target IP, or first free device)\n  pin <PIN-or-password>               Submit pairing credentials for a waiting device\n  disconnect [target]                 Stop mirroring (all streams, or only the given IP)\n  reset-restore-token <target>         Clear one Wayland restore token and reconnect that target\n  mute [target]                       Mute mirrored audio (all streams, or only the given IP)\n  unmute [target]                     Unmute mirrored audio (all streams, or only the given IP)\n\nFlags:\n  -socket path                        Override daemon socket path (default: %s)\n", daemon.DefaultSocketPath())
 }

internal/airplay/credentials.go

@@ -193,6 +193,24 @@ func (cs *CredentialStore) SaveRestoreToken(deviceID, restoreToken string) error
 	return cs.backend.Save(deviceID, creds)
 }
 
+// ClearRestoreToken removes only the Wayland screencast restore token for a
+// device. Pairing credentials and all other device entries are preserved.
+func (cs *CredentialStore) ClearRestoreToken(deviceID string) error {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+
+	creds, err := cs.backend.Lookup(deviceID)
+	if err != nil {
+		return err
+	}
+	if creds == nil || creds.RestoreToken == "" {
+		return nil
+	}
+	updated := *creds
+	updated.RestoreToken = ""
+	return cs.backend.Save(deviceID, &updated)
+}
+
 // fileBackend stores credentials as a JSON file on disk.
 type fileBackend struct {
 	path    string

internal/airplay/credentials_clear_test.go

@@ -0,0 +1,86 @@
+package airplay
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"path/filepath"
+	"testing"
+)
+
+func TestCredentialStoreClearRestoreTokenPreservesPairingAndOtherDevices(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "credentials.json")
+	store, err := NewCredentialStore(path)
+	if err != nil {
+		t.Fatalf("NewCredentialStore: %v", err)
+	}
+	pub, priv, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatalf("GenerateKey: %v", err)
+	}
+	if err := store.SavePairing("device-1", "pair-1", pub, priv, PairingProtocolHAP); err != nil {
+		t.Fatalf("SavePairing: %v", err)
+	}
+	if err := store.SaveRestoreToken("device-1", "restore-1"); err != nil {
+		t.Fatalf("SaveRestoreToken device-1: %v", err)
+	}
+	if err := store.SaveRestoreToken("device-2", "restore-2"); err != nil {
+		t.Fatalf("SaveRestoreToken device-2: %v", err)
+	}
+
+	if err := store.ClearRestoreToken("device-1"); err != nil {
+		t.Fatalf("ClearRestoreToken: %v", err)
+	}
+
+	reloaded, err := NewCredentialStore(path)
+	if err != nil {
+		t.Fatalf("reload credential store: %v", err)
+	}
+	cleared := reloaded.Lookup("device-1")
+	if cleared == nil || !cleared.HasPairingCredentials() {
+		t.Fatal("clearing the restore token removed pairing credentials")
+	}
+	if cleared.PairingID != "pair-1" || cleared.PairingProtocol != PairingProtocolHAP {
+		t.Fatalf("pairing metadata changed: %+v", cleared)
+	}
+	if cleared.RestoreToken != "" {
+		t.Fatalf("restore token = %q, want empty", cleared.RestoreToken)
+	}
+	other := reloaded.Lookup("device-2")
+	if other == nil || other.RestoreToken != "restore-2" {
+		t.Fatalf("other device changed: %+v", other)
+	}
+}
+
+type recordingCredentialBackend struct {
+	devices map[string]*SavedCredentials
+	saves   []string
+}
+
+func (b *recordingCredentialBackend) Lookup(deviceID string) (*SavedCredentials, error) {
+	return b.devices[deviceID], nil
+}
+
+func (b *recordingCredentialBackend) Save(deviceID string, creds *SavedCredentials) error {
+	b.devices[deviceID] = creds
+	b.saves = append(b.saves, deviceID)
+	return nil
+}
+
+func TestCredentialStoreClearRestoreTokenUsesBackendWithoutDeletingEntry(t *testing.T) {
+	backend := &recordingCredentialBackend{devices: map[string]*SavedCredentials{
+		"device-1": {PairingID: "pair-1", RestoreToken: "restore-1"},
+	}}
+	store := NewCredentialStoreWithBackend(backend)
+
+	if err := store.ClearRestoreToken("device-1"); err != nil {
+		t.Fatalf("ClearRestoreToken: %v", err)
+	}
+
+	if len(backend.saves) != 1 || backend.saves[0] != "device-1" {
+		t.Fatalf("backend saves = %v, want [device-1]", backend.saves)
+	}
+	creds := backend.devices["device-1"]
+	if creds == nil || creds.PairingID != "pair-1" || creds.RestoreToken != "" {
+		t.Fatalf("backend credentials after clear = %+v", creds)
+	}
+}

internal/daemon/daemon.go

@@ -204,6 +204,7 @@ type activeStream struct {
 	device         string // friendly name
 	deviceIP       string
 	deviceID       string
+	port           int
 	state          State
 	audioMuted     bool
 	session        *airplay.MirrorSession
@@ -548,6 +549,8 @@ func (d *Daemon) handleRequest(req Request) Response {
 		return d.handleConnect(req)
 	case "disconnect":
 		return d.handleDisconnect(req)
+	case "reset-restore-token":
+		return d.handleResetRestoreToken(req)
 	case "mute":
 		return d.handleSetMute(req, true)
 	case "unmute":
@@ -783,6 +786,7 @@ func (d *Daemon) handleConnect(req Request) Response {
 	connCtx, cancel := context.WithCancel(context.Background())
 	entry := &activeStream{
 		deviceIP:     target,
+		port:         port,
 		state:        StateConnecting,
 		cancelFn:     cancel,
 		credentialCh: make(chan string, 1),

internal/daemon/daemonclient/client.go

@@ -54,6 +54,12 @@ func (c *Client) DisconnectTarget(target string) (*daemon.Response, error) {
 	return c.send(daemon.Request{Cmd: "disconnect", Target: target})
 }
 
+// ResetRestoreToken clears one active receiver's Wayland restore token and
+// reconnects that same target.
+func (c *Client) ResetRestoreToken(target string) (*daemon.Response, error) {
+	return c.send(daemon.Request{Cmd: "reset-restore-token", Target: target})
+}
+
 // Mute mutes mirrored audio on all active sessions.
 func (c *Client) Mute() (*daemon.Response, error) {
 	return c.send(daemon.Request{Cmd: "mute"})

internal/daemon/daemonclient/client_test.go

@@ -0,0 +1,52 @@
+package daemonclient
+
+import (
+	"encoding/json"
+	"net"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"doubletake/internal/daemon"
+)
+
+func TestClientResetRestoreTokenSendsTargetedCommand(t *testing.T) {
+	socketPath := filepath.Join(t.TempDir(), "doubletake.sock")
+	listener, err := net.Listen("unix", socketPath)
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	defer listener.Close()
+	requestCh := make(chan daemon.Request, 1)
+	go func() {
+		conn, acceptErr := listener.Accept()
+		if acceptErr != nil {
+			return
+		}
+		defer conn.Close()
+		var request daemon.Request
+		if json.NewDecoder(conn).Decode(&request) != nil {
+			return
+		}
+		requestCh <- request
+		_ = json.NewEncoder(conn).Encode(daemon.Response{OK: true, State: daemon.StateConnecting})
+	}()
+	client := New(socketPath)
+
+	response, err := client.ResetRestoreToken("192.0.2.10")
+
+	if err != nil {
+		t.Fatalf("ResetRestoreToken: %v", err)
+	}
+	if response == nil || !response.OK {
+		t.Fatalf("response = %+v", response)
+	}
+	select {
+	case request := <-requestCh:
+		if request.Cmd != "reset-restore-token" || request.Target != "192.0.2.10" {
+			t.Fatalf("request = %+v", request)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("client did not send reset request")
+	}
+}

internal/daemon/reset_restore_token.go

@@ -0,0 +1,92 @@
+package daemon
+
+import "context"
+
+func (d *Daemon) handleResetRestoreToken(req Request) Response {
+	d.mu.Lock()
+	if req.Target == "" {
+		response := Response{OK: false, State: d.overallStateLocked(), Error: "reset-restore-token requires a target IP"}
+		d.mu.Unlock()
+		return response
+	}
+	entry, ok := d.streams[req.Target]
+	if !ok {
+		response := Response{OK: false, State: d.overallStateLocked(), Error: "no active stream to " + req.Target}
+		d.mu.Unlock()
+		return response
+	}
+	if entry.state != StateStreaming {
+		response := Response{OK: false, State: d.overallStateLocked(), Error: "restore token can be reset only for a fully streaming target: " + req.Target}
+		d.mu.Unlock()
+		return response
+	}
+	if entry.captureGroup == nil || d.captureGroups[entry.captureGroup.key] != entry.captureGroup {
+		response := Response{OK: false, State: d.overallStateLocked(), Error: "active target has no owned capture group: " + req.Target}
+		d.mu.Unlock()
+		return response
+	}
+	for target, other := range d.streams {
+		if target != req.Target && other.captureGroup == entry.captureGroup {
+			response := Response{OK: false, State: d.overallStateLocked(), Error: "target uses a shared capture group; disconnect its peers before resetting the restore token"}
+			d.mu.Unlock()
+			return response
+		}
+	}
+	if entry.deviceID == "" || entry.port == 0 {
+		response := Response{OK: false, State: d.overallStateLocked(), Error: "active target is missing receiver identity or port: " + req.Target}
+		d.mu.Unlock()
+		return response
+	}
+
+	target := entry.deviceIP
+	deviceID := entry.deviceID
+	port := entry.port
+	cleanup := d.detachStreamLocked(target)
+	connCtx, cancel := context.WithCancel(context.Background())
+	replacement := &activeStream{
+		deviceIP:     target,
+		deviceID:     deviceID,
+		port:         port,
+		state:        StateConnecting,
+		cancelFn:     cancel,
+		credentialCh: make(chan string, 1),
+	}
+	d.clearLastErrorForTargetLocked(target)
+	d.streams[target] = replacement
+	// Reserve the target and register the replacement worker before unlocking.
+	// Shutdown can detach the reservation, but cannot finish Wait until this
+	// reset either abandons it or hands ownership to connectAndStream.
+	d.streamWorkers.Add(1)
+	d.mu.Unlock()
+
+	cleanup.run()
+
+	d.mu.Lock()
+	if d.shuttingDown || d.streams[target] != replacement {
+		if d.streams[target] == replacement {
+			abandoned := d.detachStreamLocked(target)
+			d.mu.Unlock()
+			abandoned.run()
+		} else {
+			d.mu.Unlock()
+		}
+		d.streamWorkers.Done()
+		return Response{OK: false, State: StateIdle, Error: "daemon is shutting down"}
+	}
+	if err := d.credStore.ClearRestoreToken(deviceID); err != nil {
+		abandoned := d.detachStreamLocked(target)
+		state := d.overallStateLocked()
+		d.mu.Unlock()
+		abandoned.run()
+		d.streamWorkers.Done()
+		return Response{OK: false, State: state, Error: "clear restore token: " + err.Error()}
+	}
+	state := d.overallStateLocked()
+	d.mu.Unlock()
+
+	go func() {
+		defer d.streamWorkers.Done()
+		d.connectAndStream(connCtx, replacement, target, port, "")
+	}()
+	return Response{OK: true, State: state, Device: target, DeviceIP: target}
+}