meshcode 2.6.8__tar.gz → 2.7.0__tar.gz

{meshcode-2.6.8 → meshcode-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.8
+Version: 2.7.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.6.8 → meshcode-2.7.0}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.6.8"
+__version__ = "2.7.0"

{meshcode-2.6.8 → meshcode-2.7.0}/meshcode/meshcode_mcp/backend.py

@@ -36,6 +36,14 @@ def _load_env_file() -> Dict[str, str]:
 _env_file = _load_env_file()
 SUPABASE_URL = os.environ.get("SUPABASE_URL") or _env_file.get("SUPABASE_URL") or _DEFAULT_SUPABASE_URL
 SUPABASE_KEY = os.environ.get("SUPABASE_KEY") or _env_file.get("SUPABASE_KEY") or _DEFAULT_SUPABASE_KEY
+SUPABASE_SERVICE_ROLE_KEY = (
+    os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
+    or os.environ.get("SUPABASE_SECRET_KEY")
+    or _env_file.get("SUPABASE_SERVICE_ROLE_KEY")
+    or _env_file.get("SUPABASE_SECRET_KEY")
+    or _env_file.get("NEW_SUPABASE_SECRET")
+    or ""
+)
 SCHEMA = "meshcode"
 
 

{meshcode-2.6.8 → meshcode-2.7.0}/meshcode/meshcode_mcp/realtime.py

@@ -44,12 +44,14 @@ class RealtimeListener:
         project_id: str,
         agent_name: str,
         notify_callback: Optional[Callable[[Dict], Awaitable[None]]] = None,
+        service_role_key: Optional[str] = None,
     ):
         self.supabase_url = supabase_url
         self.supabase_key = supabase_key
         self.project_id = project_id
         self.agent_name = agent_name
         self.notify_callback = notify_callback
+        self.service_role_key = service_role_key
 
         # Last 100 unread messages — drained by meshcode_check tool
         self.queue: Deque[Dict] = deque(maxlen=100)
@@ -127,6 +129,21 @@ class RealtimeListener:
             self._connected = True
             log.info(f"Realtime connected for agent={self.agent_name}")
 
+            # Elevate auth context if service_role_key is available.
+            # This lets Supabase Realtime bypass RLS for INSERT event delivery,
+            # so mc_user_has_project_access (which needs auth.uid()) is not required.
+            if self.service_role_key:
+                try:
+                    await ws.send(json.dumps({
+                        "topic": "realtime:*",
+                        "event": "access_token",
+                        "payload": {"access_token": self.service_role_key},
+                        "ref": "auth",
+                    }))
+                    log.info("Realtime auth elevated with service_role_key")
+                except Exception as e:
+                    log.warning(f"Failed to send access_token: {e}")
+
             # Phoenix channel join: phoenix realtime topic
             topic = f"realtime:{self.project_id}-{self.agent_name}"
             join_msg = {
@@ -148,6 +165,25 @@ class RealtimeListener:
             }
             await ws.send(json.dumps(join_msg))
 
+            # Wait for phx_reply to confirm subscription was accepted.
+            self._subscription_ok = False
+            try:
+                reply_raw = await asyncio.wait_for(ws.recv(), timeout=10.0)
+                reply = json.loads(reply_raw)
+                reply_status = (reply.get("payload") or {}).get("status")
+                if reply_status == "ok":
+                    self._subscription_ok = True
+                    log.info(f"Realtime subscription OK for {self.agent_name} on {topic}")
+                else:
+                    log.error(
+                        f"Realtime subscription FAILED for {self.agent_name}: "
+                        f"status={reply_status} payload={reply.get('payload')}"
+                    )
+            except asyncio.TimeoutError:
+                log.error(f"Realtime subscription TIMEOUT — no phx_reply in 10s for {self.agent_name}")
+            except Exception as e:
+                log.error(f"Realtime subscription error reading phx_reply: {e}")
+
             # Heartbeat task to keep the connection alive
             heartbeat_task = asyncio.create_task(self._heartbeat(ws))
             try:
@@ -247,3 +283,7 @@ class RealtimeListener:
     @property
     def is_connected(self) -> bool:
         return self._connected
+
+    @property
+    def is_subscribed(self) -> bool:
+        return self._connected and getattr(self, "_subscription_ok", False)

{meshcode-2.6.8 → meshcode-2.7.0}/meshcode/meshcode_mcp/server.py

@@ -1040,6 +1040,7 @@ async def lifespan(_app):
         project_id=_PROJECT_ID,
         agent_name=AGENT_NAME,
         notify_callback=_on_new_message,
+        service_role_key=be.SUPABASE_SERVICE_ROLE_KEY or None,
     )
     await _REALTIME.start()
 
@@ -1525,7 +1526,11 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             if shaped:
                 return shaped
 
-        # 2) Real async wait — zero CPU, zero Supabase calls.
+    # Determine if realtime is actually delivering events.
+    _rt_live = _REALTIME and _REALTIME.is_subscribed
+
+    if _rt_live:
+        # 2a) Real async wait — zero CPU, zero Supabase calls.
         woke = await _REALTIME.wait_for_message(timeout=float(actual_timeout))
         if woke:
             buffered = _REALTIME.drain()
@@ -1534,11 +1539,37 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                 if shaped:
                     return shaped
     else:
-        # Realtime unavailable — plain sleep fallback so we still honor timeout.
-        await asyncio.sleep(actual_timeout)
+        # 2b) Realtime NOT subscribed — aggressive DB polling every 5s
+        # so messages arrive within seconds, not after 120s timeout.
+        _poll_interval = 5
+        _elapsed = 0
+        while _elapsed < actual_timeout:
+            await asyncio.sleep(min(_poll_interval, actual_timeout - _elapsed))
+            _elapsed += _poll_interval
+            try:
+                api_key = _get_api_key()
+                if api_key:
+                    db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=api_key)
+                    if db_pending and db_pending > 0:
+                        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=api_key)
+                        if raw:
+                            msgs = [
+                                {"from": m["from_agent"], "type": m.get("type", "msg"),
+                                 "ts": m.get("created_at"), "payload": m.get("payload", {}),
+                                 "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
+                                for m in raw
+                            ]
+                            deduped = _filter_and_mark(msgs)
+                            if deduped:
+                                split = _split_messages(deduped)
+                                if not include_acks:
+                                    split["acks"] = []
+                                if split["messages"] or split["done_signals"]:
+                                    return {"got_message": True, "source": "db_poll_fallback", **split}
+            except Exception:
+                pass
 
-    # Fallback: poll DB for messages that realtime may have missed
-    # (connection drop, startup race, etc.)
+    # Final fallback: one last DB check (covers realtime path missing msgs)
     try:
         api_key = _get_api_key()
         if api_key:
@@ -1647,6 +1678,7 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
         "agent": AGENT_NAME,
         "project": PROJECT_NAME,
         "realtime_connected": _REALTIME.is_connected if _REALTIME else False,
+        "realtime_subscribed": _REALTIME.is_subscribed if _REALTIME else False,
         **split,
     }
     # Auto-inject pending tasks

{meshcode-2.6.8 → meshcode-2.7.0}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.6.8
+Version: 2.7.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.6.8 → meshcode-2.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.6.8"
+version = "2.7.0"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}