circle-chat 0.1.0__tar.gz

circle_chat-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.serena/
+.env
+.venv/
+__pycache__/
+*.pyc
+supabase/.temp/
+dist/
+.gitnexus/

circle_chat-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.5
+Name: circle-chat
+Version: 0.1.0
+Summary: Chat with your circle of friends, entirely in the terminal.
+Project-URL: Repository, https://github.com/bgaibull/circle
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: livekit>=1.1.17
+Requires-Dist: opencv-python-headless>=5.0.0.93
+Requires-Dist: supabase
+Requires-Dist: textual
+Requires-Dist: textual-image>=0.13.2
+Description-Content-Type: text/markdown
+
+# circle
+
+Chat with your circle of friends, entirely in the terminal.
+
+    uv tool install circle-chat
+    circle

circle_chat-0.1.0/README.md

@@ -0,0 +1,6 @@
+# circle
+
+Chat with your circle of friends, entirely in the terminal.
+
+    uv tool install circle-chat
+    circle

circle_chat-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "circle-chat"
+version = "0.1.0"
+description = "Chat with your circle of friends, entirely in the terminal."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+dependencies = [
+    "textual",
+    "supabase",
+    "livekit>=1.1.17",
+    "textual-image>=0.13.2",
+    "opencv-python-headless>=5.0.0.93",
+]
+
+[project.scripts]
+circle = "circle.cli:main"
+
+[dependency-groups]
+dev = [
+    "livekit-api>=1.2.1",
+    "pytest",
+    "pytest-asyncio",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/circle"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/circle", "README.md", "pyproject.toml"]
+
+[project.urls]
+Repository = "https://github.com/bgaibull/circle"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+filterwarnings = ["ignore::DeprecationWarning:supabase"]

circle_chat-0.1.0/src/circle/__init__.py

@@ -0,0 +1 @@
+"""circle — terminal chat for a closed circle of friends."""

circle_chat-0.1.0/src/circle/api.py

@@ -0,0 +1,241 @@
+"""Everything the TUI needs from Supabase, in one thin async wrapper. No UI here."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Optional
+
+import asyncio
+
+import httpx
+from realtime import RealtimeSubscribeStates
+from supabase import AsyncClient, AsyncClientOptions, acreate_client
+from supabase_auth.errors import AuthApiError
+
+from .config import SUPABASE_KEY, SUPABASE_URL
+from .session import FileStorage
+
+
+@dataclass(frozen=True)
+class Friend:
+    id: str
+    name: str
+
+
+@dataclass(frozen=True)
+class Message:
+    id: int
+    sender_id: str
+    recipient_id: str
+    body: str
+    created_at: str
+
+
+class Circle:
+    def __init__(self, storage: Optional[FileStorage] = None) -> None:
+        self.storage = storage or FileStorage()
+        self.client: AsyncClient | None = None
+        self.user_id: str | None = None
+        self._channel = None
+        self._signal_channel = None
+        self.online: set[str] = set()
+
+    # ---- lifecycle -------------------------------------------------------------------
+
+    async def connect(self) -> bool:
+        """Create the client; return True when a stored session is still usable."""
+        self.client = await acreate_client(
+            SUPABASE_URL, SUPABASE_KEY,
+            AsyncClientOptions(storage=self.storage, auto_refresh_token=True, persist_session=True),
+        )
+        try:
+            session = await self.client.auth.get_session()
+        except AuthApiError:
+            # the server rejected the stored refresh token (revoked, reused, expired): it is dead
+            self.storage.clear()
+            return False
+        except Exception:
+            # network hiccup, DNS, timeout: keep the file — the next launch may well succeed
+            return False
+        if session is None:
+            return False
+        self.user_id = session.user.id
+        return True
+
+    async def close(self) -> None:
+        for ch in (self._channel, self._signal_channel):
+            if ch is not None:
+                try:
+                    await self.client.remove_channel(ch)
+                except Exception:
+                    pass
+        self._channel = self._signal_channel = None
+
+    # ---- auth: an invite code is the only credential -----------------------------------
+
+    async def redeem(self, code: str, display_name: str | None = None) -> dict:
+        """Redeem a code through the Edge Function.
+
+        Signed out: a *friend* code creates the account (needs display_name) and signs in; a
+        *device* code signs in as the code's issuer. Signed in: a friend code adds a friend.
+        """
+        body: dict[str, Any] = {"code": code.strip().upper()}
+        if display_name:
+            body["display_name"] = display_name.strip()
+        res = await self.client.functions.invoke("redeem-invite", {"body": body, "responseType": "json"})
+        if isinstance(res, dict) and res.get("token_hash"):
+            auth = await self.client.auth.verify_otp({"token_hash": res["token_hash"], "type": "magiclink"})
+            self.user_id = auth.user.id
+        return res
+
+    async def livekit_token(self, friend_id: str) -> dict:
+        """{url, room, token, identity} for a call with a friend — minted by the Edge Function."""
+        return await self.client.functions.invoke(
+            "livekit-token", {"body": {"friend_id": friend_id}, "responseType": "json"}
+        )
+
+    async def sign_out(self, everywhere: bool = False) -> None:
+        try:
+            await self.client.auth.sign_out({"scope": "global" if everywhere else "local"})
+        finally:
+            self.storage.clear()
+            self.user_id = None
+
+    # ---- data ------------------------------------------------------------------------
+
+    async def me(self) -> Friend:
+        row = (await self.client.table("profiles").select("id, display_name").eq("id", self.user_id).single().execute()).data
+        return Friend(row["id"], row["display_name"])
+
+    async def friends(self) -> list[Friend]:
+        rows = (await self.client.table("friendships").select("user_a, user_b, blocked_by").execute()).data
+        ids = [r["user_b"] if r["user_a"] == self.user_id else r["user_a"] for r in rows if r["blocked_by"] is None]
+        if not ids:
+            return []
+        profiles = (await self.client.table("profiles").select("id, display_name").in_("id", ids).execute()).data
+        return sorted((Friend(p["id"], p["display_name"]) for p in profiles), key=lambda f: f.name.lower())
+
+    async def latest_per_friend(self, limit: int = 300) -> dict[str, Message]:
+        """Most recent message per friend, for the sidebar previews. One query."""
+        me = self.user_id
+        rows = (
+            await self.client.table("messages").select("*")
+            .or_(f"sender_id.eq.{me},recipient_id.eq.{me}")
+            .order("created_at", desc=True).limit(limit).execute()
+        ).data
+        latest: dict[str, Message] = {}
+        for r in rows:
+            other = r["recipient_id"] if r["sender_id"] == me else r["sender_id"]
+            latest.setdefault(other, Message(**r))
+        return latest
+
+    async def issue_invite(self, kind: str = "friend") -> str:
+        """kind: 'friend' lets one person into your circle; 'device' signs *you* in elsewhere."""
+        row = (await self.client.table("invites").insert({"inviter_id": self.user_id, "kind": kind}).execute()).data[0]
+        return row["code"]
+
+    async def open_invites(self) -> list[dict]:
+        return (
+            await self.client.table("invites").select("code, kind, created_at, expires_at")
+            .is_("redeemed_at", "null").is_("revoked_at", "null").order("created_at", desc=True).execute()
+        ).data
+
+    async def revoke_invite(self, code: str) -> None:
+        await self.client.table("invites").update({"revoked_at": "now()"}).eq("code", code).execute()
+
+    async def history(self, friend_id: str, limit: int = 200) -> list[Message]:
+        me, them = self.user_id, friend_id
+        rows = (
+            await self.client.table("messages").select("*")
+            .or_(f"and(sender_id.eq.{me},recipient_id.eq.{them}),and(sender_id.eq.{them},recipient_id.eq.{me})")
+            .order("created_at", desc=True).limit(limit).execute()
+        ).data
+        return [Message(**r) for r in reversed(rows)]
+
+    async def send(self, friend_id: str, body: str) -> Message:
+        row = (await self.client.table("messages").insert(
+            {"sender_id": self.user_id, "recipient_id": friend_id, "body": body}
+        ).execute()).data[0]
+        return Message(**row)
+
+    async def unfriend(self, friend_id: str) -> None:
+        a, b = sorted([self.user_id, friend_id])
+        await self.client.table("friendships").delete().eq("user_a", a).eq("user_b", b).execute()
+
+    # ---- realtime --------------------------------------------------------------------
+
+    async def subscribe(
+        self,
+        on_message: Callable[[Message], Any],
+        on_friends_changed: Callable[[], Any],
+        on_presence: Callable[[set[str]], Any] | None = None,
+        on_signal: Callable[[str, dict, str], Any] | None = None,
+    ) -> None:
+        """Live inserts addressed to me, changes to my friendships, who is online, and call
+        signals addressed to me. RLS applies to the table changes; presence and signals ride
+        public channels (uuids only) — private channels are the upgrade path, see [2.3]."""
+        me = self.user_id
+        ch = self.client.channel("circle", {"config": {"presence": {"key": me}}})
+        ch.on_postgres_changes(
+            "INSERT", schema="public", table="messages",
+            filter=f"recipient_id=eq.{me}",
+            callback=lambda payload: on_message(Message(**payload["data"]["record"])),
+        )
+        ch.on_postgres_changes(
+            "*", schema="public", table="friendships",
+            callback=lambda _payload: on_friends_changed(),
+        )
+
+        def _presence_sync() -> None:
+            self.online = {
+                p.get("user_id") for entries in ch.presence_state().values() for p in entries if p.get("user_id")
+            }
+            if on_presence:
+                on_presence(set(self.online))
+
+        ch.on_presence_sync(_presence_sync)
+        await self._subscribed(ch)
+        await ch.track({"user_id": me})
+        self._channel = ch
+
+        if on_signal:
+            sig = self.client.channel(f"sig:{me}", {"config": {"broadcast": {"self": False}}})
+
+            def _on_signal(wrapper: dict) -> None:  # realtime hands over {"event", "payload"}
+                p = wrapper.get("payload") or {}
+                on_signal(p.get("event", ""), p, p.get("from", ""))
+
+            sig.on_broadcast("signal", _on_signal)
+            await self._subscribed(sig)
+            self._signal_channel = sig
+
+    async def send_signal(self, to: str, event: str, data: dict) -> None:
+        """Broadcast a call signal onto the recipient's `sig:<id>` topic through Realtime's REST
+        endpoint — no channel join, works across sockets, one HTTP call."""
+        session = await self.client.auth.get_session()
+        async with httpx.AsyncClient(timeout=10) as http:
+            r = await http.post(
+                f"{SUPABASE_URL}/realtime/v1/api/broadcast",
+                headers={"apikey": SUPABASE_KEY, "Authorization": f"Bearer {session.access_token}",
+                         "content-type": "application/json"},
+                json={"messages": [{"topic": f"sig:{to}", "event": "signal",
+                                    "payload": {"event": event, "from": self.user_id, **data}}]},
+            )
+            r.raise_for_status()
+
+    async def _subscribed(self, ch) -> None:
+        """Subscribe and wait for the server's ack; the postgres_changes binding is confirmed here."""
+        ready: asyncio.Future = asyncio.get_running_loop().create_future()
+
+        def _status(status: RealtimeSubscribeStates, err: Exception | None) -> None:
+            if ready.done():
+                return
+            if status == RealtimeSubscribeStates.SUBSCRIBED:
+                ready.set_result(True)
+            elif status in (RealtimeSubscribeStates.CHANNEL_ERROR, RealtimeSubscribeStates.TIMED_OUT):
+                ready.set_exception(RuntimeError(f"realtime {status.value}: {err}"))
+
+        await ch.subscribe(_status)
+        await asyncio.wait_for(ready, 20)
+        # ponytail: Realtime's WAL poller picks a new binding up ~1s after the SUBSCRIBED ack;
+        # an insert in that gap is silently lost. A settle beats a resync protocol; raise if flaky.
+        await asyncio.sleep(1.5)