feat: implémentation complete v0.1.0 — daemon de sync clipboard bidirectionnel

internal/dedup/dedup.go

@@ -0,0 +1,102 @@
+// Package dedup provides the anti-ping-pong (deduplication) filter for clip-sync.
+//
+// Two guardrails prevent sync loops:
+//  1. Content hash cache — an LRU ring buffer of the last N SHA-256 hashes
+//     of locally written text. If we receive text whose hash matches a recent
+//     local write, we ignore it (our own content echoed back through a peer).
+//  2. Origin + timestamp — each payload carries an origin hostname and a
+//     nanosecond timestamp. If origin == our hostname (rebound via a third
+//     peer) or if the timestamp is not newer than our last write, we ignore.
+package dedup
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"sync"
+	"time"
+)
+
+const defaultCacheSize = 20
+
+// Filter prevents clipboard sync loops.
+type Filter struct {
+	mu          sync.Mutex
+	origin      string        // our hostname
+	cache       []string      // ring buffer of content hashes
+	cacheIdx    int           // write position in ring buffer
+	lastWriteTs int64         // nanosecond timestamp of our last local write
+}
+
+// NewFilter creates a new deduplication filter for the given origin hostname.
+func NewFilter(origin string) *Filter {
+	return &Filter{
+		origin: origin,
+		cache:  make([]string, 0, defaultCacheSize),
+	}
+}
+
+// Payload represents an incoming clip payload from a peer.
+type Payload struct {
+	Text   string `json:"text"`
+	Ts     int64  `json:"ts"`
+	Origin string `json:"origin"`
+}
+
+// ShouldIgnore returns true if the payload should NOT be written to the local clipboard.
+func (f *Filter) ShouldIgnore(p Payload) bool {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	// Guard 1: ignore our own origin (rebound via a third peer).
+	if p.Origin == f.origin {
+		return true
+	}
+
+	// Guard 2: ignore stale timestamps (not newer than our last write).
+	if p.Ts <= f.lastWriteTs {
+		return true
+	}
+
+	// Guard 3: ignore content we recently wrote (hash match).
+	hash := hashText(p.Text)
+	for _, h := range f.cache {
+		if h == hash {
+			return true
+		}
+	}
+
+	return false
+}
+
+// MarkWritten records that we just wrote text to the local clipboard.
+// This populates the hash cache and updates the last-write timestamp.
+func (f *Filter) MarkWritten(text string) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+
+	now := time.Now().UnixNano()
+	hash := hashText(text)
+
+	// Ring buffer: overwrite oldest entry when full.
+	if len(f.cache) < defaultCacheSize {
+		f.cache = append(f.cache, hash)
+	} else {
+		f.cache[f.cacheIdx] = hash
+		f.cacheIdx = (f.cacheIdx + 1) % defaultCacheSize
+	}
+
+	f.lastWriteTs = now
+}
+
+// LastWriteTs returns the timestamp of our last local write.
+func (f *Filter) LastWriteTs() int64 {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.lastWriteTs
+}
+
+// hashText returns the hex-encoded SHA-256 of the given text.
+func hashText(text string) string {
+	h := sha256.Sum256([]byte(text))
+	return hex.EncodeToString(h[:])
+}