Initial Commit
This commit is contained in:
Salastil
488
sneed/client.go
Normal file
488
sneed/client.go
Normal file
@@ -0,0 +1,488 @@
|
||||
package sneed
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"html"
|
||||
"log"
|
||||
"net/http"
|
||||
"regexp"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gorilla/websocket"
|
||||
"local/sneedchatbridge/cookie"
|
||||
"local/sneedchatbridge/utils"
|
||||
)
|
||||
|
||||
const (
|
||||
ProcessedCacheSize = 1000
|
||||
ReconnectInterval = 7 * time.Second
|
||||
MappingCacheSize = 1000
|
||||
MappingCleanupInterval = 5 * time.Minute
|
||||
MappingMaxAge = 1 * time.Hour
|
||||
OutboundMatchWindow = 60 * time.Second
|
||||
)
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Client structure
|
||||
// ------------------------------------------------------------
|
||||
|
||||
type Client struct {
|
||||
wsURL string
|
||||
roomID int
|
||||
cookies *cookie.CookieRefreshService
|
||||
|
||||
conn *websocket.Conn
|
||||
connected bool
|
||||
mu sync.RWMutex
|
||||
|
||||
lastMessage time.Time
|
||||
stopCh chan struct{}
|
||||
wg sync.WaitGroup
|
||||
|
||||
processedMu sync.Mutex
|
||||
processedMessageIDs []int
|
||||
messageEditDates *utils.BoundedMap
|
||||
|
||||
// APP-SERVICE CALLBACKS (Discord removed)
|
||||
OnMessage func(msgID int, userID int, username string, content string)
|
||||
OnEdit func(msgID int, userID int, newText string)
|
||||
OnDelete func(msgID int, userID int)
|
||||
OnConnect func()
|
||||
OnDisconnect func()
|
||||
|
||||
recentOutboundIter func() []map[string]interface{}
|
||||
|
||||
bridgeUserID int
|
||||
bridgeUsername string
|
||||
baseLoopsStarted bool
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Constructor
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func NewClient(roomID int, cookieSvc *cookie.CookieRefreshService) *Client {
|
||||
return &Client{
|
||||
wsURL: "wss://kiwifarms.st:9443/chat.ws",
|
||||
roomID: roomID,
|
||||
cookies: cookieSvc,
|
||||
stopCh: make(chan struct{}),
|
||||
processedMessageIDs: make([]int, 0, ProcessedCacheSize),
|
||||
messageEditDates: utils.NewBoundedMap(MappingCacheSize, MappingMaxAge),
|
||||
lastMessage: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) SetBridgeIdentity(userID int, username string) {
|
||||
c.bridgeUserID = userID
|
||||
c.bridgeUsername = username
|
||||
}
|
||||
|
||||
func (c *Client) SetOutboundIter(f func() []map[string]interface{}) {
|
||||
c.recentOutboundIter = f
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Connect + Reconnect
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) Connect() error {
|
||||
c.mu.Lock()
|
||||
if c.connected {
|
||||
c.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
c.mu.Unlock()
|
||||
|
||||
headers := http.Header{}
|
||||
if ck := c.cookies.GetCurrentCookie(); ck != "" {
|
||||
headers.Add("Cookie", ck)
|
||||
}
|
||||
|
||||
log.Printf("Connecting to Sneedchat room %d", c.roomID)
|
||||
conn, _, err := websocket.DefaultDialer.Dial(c.wsURL, headers)
|
||||
if err != nil {
|
||||
return fmt.Errorf("websocket connection failed: %w", err)
|
||||
}
|
||||
|
||||
c.mu.Lock()
|
||||
c.conn = conn
|
||||
c.connected = true
|
||||
c.lastMessage = time.Now()
|
||||
c.mu.Unlock()
|
||||
|
||||
if !c.baseLoopsStarted {
|
||||
c.baseLoopsStarted = true
|
||||
c.wg.Add(2)
|
||||
go c.heartbeatLoop()
|
||||
go c.cleanupLoop()
|
||||
}
|
||||
|
||||
c.wg.Add(1)
|
||||
go c.readLoop()
|
||||
|
||||
c.Send(fmt.Sprintf("/join %d", c.roomID))
|
||||
log.Printf("✅ Successfully connected to Sneedchat room %d", c.roomID)
|
||||
|
||||
if c.OnConnect != nil {
|
||||
c.OnConnect()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) joinRoom() {
|
||||
c.Send(fmt.Sprintf("/join %d", c.roomID))
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Read loop
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) readLoop() {
|
||||
defer c.wg.Done()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-c.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
|
||||
c.mu.RLock()
|
||||
conn := c.conn
|
||||
c.mu.RUnlock()
|
||||
|
||||
if conn == nil {
|
||||
return
|
||||
}
|
||||
|
||||
_, raw, err := conn.ReadMessage()
|
||||
if err != nil {
|
||||
log.Printf("Sneedchat read error: %v", err)
|
||||
c.handleDisconnect()
|
||||
return
|
||||
}
|
||||
|
||||
c.lastMessage = time.Now()
|
||||
c.handleIncoming(string(raw))
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Heartbeat
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) heartbeatLoop() {
|
||||
defer c.wg.Done()
|
||||
|
||||
t := time.NewTicker(30 * time.Second)
|
||||
defer t.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-t.C:
|
||||
c.mu.RLock()
|
||||
connected := c.connected
|
||||
conn := c.conn
|
||||
c.mu.RUnlock()
|
||||
|
||||
if connected && time.Since(c.lastMessage) > 60*time.Second && conn != nil {
|
||||
_ = conn.WriteMessage(websocket.TextMessage, []byte("/ping"))
|
||||
}
|
||||
|
||||
case <-c.stopCh:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Cleanup loop
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) cleanupLoop() {
|
||||
defer c.wg.Done()
|
||||
|
||||
t := time.NewTicker(MappingCleanupInterval)
|
||||
defer t.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-t.C:
|
||||
removed := c.messageEditDates.CleanupOldEntries()
|
||||
if removed > 0 {
|
||||
log.Printf("🧹 Cleaned %d old edit tracking entries", removed)
|
||||
}
|
||||
case <-c.stopCh:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Send
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) Send(s string) bool {
|
||||
c.mu.RLock()
|
||||
conn := c.conn
|
||||
ok := c.connected && conn != nil
|
||||
c.mu.RUnlock()
|
||||
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
if err := conn.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
|
||||
log.Printf("Sneedchat write error: %v", err)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Disconnect + Reconnect
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) handleDisconnect() {
|
||||
select {
|
||||
case <-c.stopCh:
|
||||
return
|
||||
default:
|
||||
}
|
||||
|
||||
c.mu.Lock()
|
||||
c.connected = false
|
||||
if c.conn != nil {
|
||||
c.conn.Close()
|
||||
c.conn = nil
|
||||
}
|
||||
c.mu.Unlock()
|
||||
|
||||
log.Println("🔴 Sneedchat disconnected")
|
||||
if c.OnDisconnect != nil {
|
||||
c.OnDisconnect()
|
||||
}
|
||||
|
||||
delay := ReconnectInterval
|
||||
maxDelay := 2 * time.Minute
|
||||
attempt := 0
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-c.stopCh:
|
||||
log.Println("Reconnection cancelled - bridge stopping")
|
||||
return
|
||||
|
||||
case <-time.After(delay):
|
||||
attempt++
|
||||
log.Printf("🔄 Reconnection attempt #%d...", attempt)
|
||||
|
||||
if err := c.Connect(); err != nil {
|
||||
log.Printf("⚠️ Reconnect attempt #%d failed: %v", attempt, err)
|
||||
|
||||
delay *= 2
|
||||
if delay > maxDelay {
|
||||
delay = maxDelay
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
log.Println("🟢 Reconnected successfully")
|
||||
time.Sleep(2 * time.Second)
|
||||
|
||||
c.joinRoom()
|
||||
c.Send("/ping")
|
||||
|
||||
log.Printf("📍 Rejoined Sneedchat room %d after reconnect", c.roomID)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) Disconnect() {
|
||||
close(c.stopCh)
|
||||
|
||||
c.mu.Lock()
|
||||
if c.conn != nil {
|
||||
c.conn.Close()
|
||||
}
|
||||
c.connected = false
|
||||
c.mu.Unlock()
|
||||
|
||||
c.wg.Wait()
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Incoming Message Parsing (Siropu Format)
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) handleIncoming(raw string) {
|
||||
var payload SneedPayload
|
||||
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
// Handle Delete
|
||||
if payload.Delete != nil {
|
||||
var ids []int
|
||||
switch v := payload.Delete.(type) {
|
||||
case float64:
|
||||
ids = []int{int(v)}
|
||||
case []interface{}:
|
||||
for _, x := range v {
|
||||
if fid, ok := x.(float64); ok {
|
||||
ids = append(ids, int(fid))
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, id := range ids {
|
||||
c.messageEditDates.Delete(id)
|
||||
c.removeFromProcessed(id)
|
||||
if c.OnDelete != nil {
|
||||
c.OnDelete(id, 0) // userID unknown for batch deletes
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Messages
|
||||
var msgs []SneedMessage
|
||||
if len(payload.Messages) > 0 {
|
||||
msgs = payload.Messages
|
||||
} else if payload.Message != nil {
|
||||
msgs = []SneedMessage{*payload.Message}
|
||||
}
|
||||
|
||||
for _, m := range msgs {
|
||||
c.processMessage(m)
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Process a Sneedchat message
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) processMessage(m SneedMessage) {
|
||||
username := "Unknown"
|
||||
userID := 0
|
||||
|
||||
if a, ok := m.Author["username"].(string); ok {
|
||||
username = a
|
||||
}
|
||||
if id, ok := m.Author["id"].(float64); ok {
|
||||
userID = int(id)
|
||||
}
|
||||
|
||||
msg := m.MessageRaw
|
||||
if msg == "" {
|
||||
msg = m.Message
|
||||
}
|
||||
msg = html.UnescapeString(msg)
|
||||
|
||||
editDate := m.MessageEditDate
|
||||
deleted := m.Deleted || m.IsDeleted
|
||||
|
||||
// Delete
|
||||
if deleted {
|
||||
c.messageEditDates.Delete(m.MessageID)
|
||||
c.removeFromProcessed(m.MessageID)
|
||||
if c.OnDelete != nil {
|
||||
c.OnDelete(m.MessageID, userID)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Bridge echo suppression (Matrix only now; Discord logic removed)
|
||||
if (c.bridgeUserID > 0 && userID == c.bridgeUserID) ||
|
||||
(c.bridgeUsername != "" && username == c.bridgeUsername) {
|
||||
|
||||
c.addToProcessed(m.MessageID)
|
||||
c.messageEditDates.Set(m.MessageID, editDate)
|
||||
return
|
||||
}
|
||||
|
||||
// Edits
|
||||
if c.isProcessed(m.MessageID) {
|
||||
if prev, exists := c.messageEditDates.Get(m.MessageID); exists {
|
||||
if editDate > prev.(int) {
|
||||
c.messageEditDates.Set(m.MessageID, editDate)
|
||||
if c.OnEdit != nil {
|
||||
c.OnEdit(m.MessageID, userID, msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Fresh message
|
||||
c.addToProcessed(m.MessageID)
|
||||
c.messageEditDates.Set(m.MessageID, editDate)
|
||||
|
||||
if c.OnMessage != nil {
|
||||
c.OnMessage(
|
||||
m.MessageID,
|
||||
userID,
|
||||
username,
|
||||
msg,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Message Processed Cache
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func (c *Client) isProcessed(id int) bool {
|
||||
c.processedMu.Lock()
|
||||
defer c.processedMu.Unlock()
|
||||
for _, x := range c.processedMessageIDs {
|
||||
if x == id {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (c *Client) addToProcessed(id int) {
|
||||
c.processedMu.Lock()
|
||||
defer c.processedMu.Unlock()
|
||||
|
||||
c.processedMessageIDs = append(c.processedMessageIDs, id)
|
||||
|
||||
if len(c.processedMessageIDs) > ProcessedCacheSize {
|
||||
excess := len(c.processedMessageIDs) - ProcessedCacheSize
|
||||
c.processedMessageIDs = c.processedMessageIDs[excess:]
|
||||
if excess > 50 {
|
||||
log.Printf("⚠️ Processed message cache full, evicted %d entries", excess)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) removeFromProcessed(id int) {
|
||||
c.processedMu.Lock()
|
||||
defer c.processedMu.Unlock()
|
||||
|
||||
for i, x := range c.processedMessageIDs {
|
||||
if x == id {
|
||||
c.processedMessageIDs = append(
|
||||
c.processedMessageIDs[:i],
|
||||
c.processedMessageIDs[i+1:]...,
|
||||
)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// Utility
|
||||
// ------------------------------------------------------------
|
||||
|
||||
func ReplaceBridgeMention(content, bridgeUsername, pingID string) string {
|
||||
if bridgeUsername == "" || pingID == "" {
|
||||
return content
|
||||
}
|
||||
pat := regexp.MustCompile(fmt.Sprintf(`(?i)@%s(?:\W|$)`, regexp.QuoteMeta(bridgeUsername)))
|
||||
return pat.ReplaceAllString(content, fmt.Sprintf("<@%s>", pingID))
|
||||
}
|
||||
Reference in New Issue
Block a user