Rename presence.py to presence.hpp

presence.hpp

@@ -0,0 +1,213 @@
+#pragma once
+/*
+ * CollabDocs C++ — Presence Manager
+ *
+ * Tracks active users per doc:
+ *   color, name, cursor_pos, websocket connection pointer.
+ */
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <mutex>
+#include <memory>
+#include <functional>
+#include <chrono>
+#include <cmath>
+#include <nlohmann/json.hpp>
+
+namespace collab {
+
+static const std::vector<std::string> USER_COLORS = {
+    "#E63946","#2196F3","#FF9800","#9C27B0","#00BCD4",
+    "#4CAF50","#FF5722","#3F51B5","#009688","#F44336",
+    "#8BC34A","#FF4081","#00ACC1","#7E57C2","#FFA726",
+};
+
+static const std::vector<std::string> USER_NAMES = {
+    "Alice","Bob","Carol","Dave","Eve","Frank","Grace",
+    "Hank","Iris","Jack","Kate","Leo","Mia","Nick","Olivia",
+    "Pete","Quinn","Rosa","Sam","Tara",
+};
+
+static constexpr double STALE_TIMEOUT_SEC = 60.0;
+
+inline double now_sec() {
+    return std::chrono::duration_cast<std::chrono::duration<double>>(
+        std::chrono::system_clock::now().time_since_epoch()).count();
+}
+
+// ─── WebSocket abstraction ────────────────────────────────────────────────────
+// We store a send-callback so the presence manager is decoupled from
+// Boost.Beast specifics (easier to test too).
+
+using SendFn = std::function<void(const std::string&)>;
+
+// ─── UserPresence ─────────────────────────────────────────────────────────────
+
+struct UserPresence {
+    std::string user_id;
+    std::string name;
+    std::string color;
+    int         cursor_pos     = 0;
+    int         selection_start = -1;
+    int         selection_end   = -1;
+    double      last_seen      = 0.0;
+    SendFn      send_fn;        // call this to push JSON to this client
+
+    void ping() { last_seen = now_sec(); }
+
+    nlohmann::json to_json() const {
+        return {
+            {"user_id",          user_id},
+            {"name",             name},
+            {"color",            color},
+            {"cursor_pos",       cursor_pos},
+            {"selection_start",  selection_start},
+            {"selection_end",    selection_end},
+        };
+    }
+};
+
+// ─── PresenceManager ─────────────────────────────────────────────────────────
+
+class PresenceManager {
+public:
+    // Called when a user opens a document
+    UserPresence& join(const std::string& doc_id,
+                       const std::string& user_id,
+                       SendFn             send_fn)
+    {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto& users = doc_users_[doc_id];
+
+        auto it = users.find(user_id);
+        if (it == users.end()) {
+            UserPresence p;
+            p.user_id  = user_id;
+            p.color    = pick_color(doc_id);
+            p.name     = USER_NAMES[
+                std::hash<std::string>{}(user_id) % USER_NAMES.size()];
+            p.last_seen = now_sec();
+            p.send_fn  = std::move(send_fn);
+            users[user_id] = std::move(p);
+        } else {
+            it->second.send_fn = std::move(send_fn);
+            it->second.ping();
+        }
+        return users[user_id];
+    }
+
+    void leave(const std::string& doc_id, const std::string& user_id) {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto dit = doc_users_.find(doc_id);
+        if (dit == doc_users_.end()) return;
+        auto uit = dit->second.find(user_id);
+        if (uit == dit->second.end()) return;
+        release_color(doc_id, uit->second.color);
+        dit->second.erase(uit);
+    }
+
+    void update_cursor(const std::string& doc_id, const std::string& user_id,
+                       int pos, int sel_start = -1, int sel_end = -1) {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto& users = doc_users_[doc_id];
+        auto it = users.find(user_id);
+        if (it == users.end()) return;
+        it->second.cursor_pos      = pos;
+        it->second.selection_start = sel_start;
+        it->second.selection_end   = sel_end;
+        it->second.ping();
+    }
+
+    // Get snapshot of a user's presence data (thread-safe)
+    std::optional<UserPresence> get_user(const std::string& doc_id,
+                                          const std::string& user_id) {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto dit = doc_users_.find(doc_id);
+        if (dit == doc_users_.end()) return std::nullopt;
+        auto uit = dit->second.find(user_id);
+        if (uit == dit->second.end()) return std::nullopt;
+        return uit->second;
+    }
+
+    // Get list of active user JSON objects
+    std::vector<nlohmann::json> get_users_json(const std::string& doc_id) {
+        std::lock_guard<std::mutex> lk(mu_);
+        std::vector<nlohmann::json> out;
+        auto dit = doc_users_.find(doc_id);
+        if (dit == doc_users_.end()) return out;
+        double cutoff = now_sec() - STALE_TIMEOUT_SEC;
+        for (auto& [uid, p] : dit->second)
+            if (p.last_seen >= cutoff)
+                out.push_back(p.to_json());
+        return out;
+    }
+
+    // Broadcast to all users in doc except one; calls their send_fn.
+    // Returns list of user_ids whose send_fn threw (dead connections).
+    std::vector<std::string> broadcast(const std::string& doc_id,
+                                        const std::string& json_str,
+                                        const std::string& exclude = "") {
+        // Snapshot so we don't hold lock while calling send_fn
+        std::vector<std::pair<std::string, SendFn>> targets;
+        {
+            std::lock_guard<std::mutex> lk(mu_);
+            auto dit = doc_users_.find(doc_id);
+            if (dit == doc_users_.end()) return {};
+            for (auto& [uid, p] : dit->second)
+                if (uid != exclude && p.send_fn)
+                    targets.emplace_back(uid, p.send_fn);
+        }
+
+        std::vector<std::string> dead;
+        for (auto& [uid, fn] : targets) {
+            try { fn(json_str); }
+            catch (...) { dead.push_back(uid); }
+        }
+        return dead;
+    }
+
+    void send_to_user(const std::string& doc_id,
+                      const std::string& user_id,
+                      const std::string& json_str) {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto dit = doc_users_.find(doc_id);
+        if (dit == doc_users_.end()) return;
+        auto uit = dit->second.find(user_id);
+        if (uit == dit->second.end() || !uit->second.send_fn) return;
+        try { uit->second.send_fn(json_str); } catch (...) {}
+    }
+
+    size_t user_count(const std::string& doc_id) {
+        std::lock_guard<std::mutex> lk(mu_);
+        auto it = doc_users_.find(doc_id);
+        return (it != doc_users_.end()) ? it->second.size() : 0;
+    }
+
+private:
+    std::mutex mu_;
+    std::unordered_map<std::string,
+        std::unordered_map<std::string, UserPresence>> doc_users_;
+    std::unordered_map<std::string,
+        std::unordered_set<std::string>> used_colors_;
+
+    std::string pick_color(const std::string& doc_id) {
+        auto& used = used_colors_[doc_id];
+        for (auto& c : USER_COLORS)
+            if (!used.count(c)) { used.insert(c); return c; }
+        // All used — recycle
+        auto& c = USER_COLORS[used.size() % USER_COLORS.size()];
+        return c;
+    }
+
+    void release_color(const std::string& doc_id, const std::string& color) {
+        auto it = used_colors_.find(doc_id);
+        if (it != used_colors_.end()) it->second.erase(color);
+    }
+};
+
+inline PresenceManager g_presence;
+
+} // namespace collab

presence.py

@@ -1,155 +0,0 @@
-"""
-Presence Manager
-Tracks active users per document: cursor positions, selections, colors.
-
-Fixes over original:
-- Color reclamation in leave() actually works (was dead code before)
-- Stale user pruning doesn't mutate the dict while iterating
-- get_connections() returns a snapshot copy to avoid mutation during broadcast
-- User names are preserved on reconnect (same user_id)
-"""
-
-from __future__ import annotations
-
-import random
-import time
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set
-
-from fastapi import WebSocket
-
-USER_COLORS = [
-    "#E63946", "#2196F3", "#FF9800", "#9C27B0", "#00BCD4",
-    "#4CAF50", "#FF5722", "#3F51B5", "#009688", "#F44336",
-    "#8BC34A", "#FF4081", "#00ACC1", "#7E57C2", "#FFA726",
-]
-
-USER_NAMES = [
-    "Alice", "Bob", "Carol", "Dave", "Eve",
-    "Frank", "Grace", "Hank", "Iris", "Jack",
-    "Kate", "Leo", "Mia", "Nick", "Olivia",
-    "Pete", "Quinn", "Rosa", "Sam", "Tara",
-]
-
-STALE_TIMEOUT_SECONDS = 30
-
-
-@dataclass
-class UserPresence:
-    user_id: str
-    name: str
-    color: str
-    cursor_pos: int = 0
-    selection_start: int = -1
-    selection_end: int = -1
-    last_seen: float = field(default_factory=time.time)
-    websocket: Optional[object] = None
-
-    def to_dict(self) -> dict:
-        return {
-            "user_id": self.user_id,
-            "name": self.name,
-            "color": self.color,
-            "cursor_pos": self.cursor_pos,
-            "selection_start": self.selection_start,
-            "selection_end": self.selection_end,
-        }
-
-    def ping(self):
-        self.last_seen = time.time()
-
-
-class PresenceManager:
-    def __init__(self):
-        self._doc_users: Dict[str, Dict[str, UserPresence]] = {}
-        self._connections: Dict[str, Dict[str, WebSocket]] = {}
-        self._used_colors: Dict[str, Set[str]] = {}
-
-    def _get_color(self, doc_id: str) -> str:
-        used = self._used_colors.get(doc_id, set())
-        available = [c for c in USER_COLORS if c not in used]
-        if not available:
-            # All colors taken — recycle but pick least-used visually distinct
-            available = USER_COLORS
-        color = random.choice(available)
-        self._used_colors.setdefault(doc_id, set()).add(color)
-        return color
-
-    def _release_color(self, doc_id: str, color: str):
-        if doc_id in self._used_colors:
-            self._used_colors[doc_id].discard(color)
-
-    def join(self, doc_id: str, user_id: str, ws: WebSocket) -> UserPresence:
-        if doc_id not in self._doc_users:
-            self._doc_users[doc_id] = {}
-            self._connections[doc_id] = {}
-
-        if user_id not in self._doc_users[doc_id]:
-            color = self._get_color(doc_id)
-            # Assign name deterministically from user_id hash for consistency
-            name_idx = abs(hash(user_id)) % len(USER_NAMES)
-            name = USER_NAMES[name_idx]
-            presence = UserPresence(
-                user_id=user_id,
-                name=name,
-                color=color,
-                websocket=ws,
-            )
-            self._doc_users[doc_id][user_id] = presence
-        else:
-            # Reconnect: preserve name/color, just update ws
-            self._doc_users[doc_id][user_id].websocket = ws
-            self._doc_users[doc_id][user_id].ping()
-
-        self._connections[doc_id][user_id] = ws
-        return self._doc_users[doc_id][user_id]
-
-    def leave(self, doc_id: str, user_id: str):
-        if doc_id in self._doc_users:
-            user = self._doc_users[doc_id].pop(user_id, None)
-            self._connections[doc_id].pop(user_id, None)
-            # Actually release the color now (original had dead code here)
-            if user is not None:
-                self._release_color(doc_id, user.color)
-
-    def update_cursor(
-        self,
-        doc_id: str,
-        user_id: str,
-        cursor_pos: int,
-        sel_start: int = -1,
-        sel_end: int = -1,
-    ):
-        users = self._doc_users.get(doc_id, {})
-        if user_id in users:
-            p = users[user_id]
-            p.cursor_pos = cursor_pos
-            p.selection_start = sel_start
-            p.selection_end = sel_end
-            p.ping()
-
-    def get_users(self, doc_id: str) -> List[dict]:
-        users = self._doc_users.get(doc_id, {})
-        now = time.time()
-        # Build a new dict instead of mutating while iterating
-        active = {
-            uid: u
-            for uid, u in users.items()
-            if now - u.last_seen < STALE_TIMEOUT_SECONDS
-        }
-        stale = set(users) - set(active)
-        for uid in stale:
-            self._release_color(doc_id, users[uid].color)
-        self._doc_users[doc_id] = active
-        return [u.to_dict() for u in active.values()]
-
-    def get_connections(self, doc_id: str) -> Dict[str, WebSocket]:
-        # Return a snapshot so broadcast can't mutate the live dict mid-iteration
-        return dict(self._connections.get(doc_id, {}))
-
-    def get_user(self, doc_id: str, user_id: str) -> Optional[UserPresence]:
-        return self._doc_users.get(doc_id, {}).get(user_id)
-
-
-# Global singleton
-presence_manager = PresenceManager()