meshcode 2.10.50__tar.gz → 2.10.52__tar.gz

{meshcode-2.10.50 → meshcode-2.10.52}/PKG-INFO

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

{meshcode-2.10.50 → meshcode-2.10.52}/meshcode/__init__.py

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

{meshcode-2.10.50 → meshcode-2.10.52}/meshcode/meshcode_mcp/backend.py

@@ -715,9 +715,10 @@ def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Opt
         # If RPC doesn't exist yet, fall through to direct query
 
     # Fallback: direct SELECT (tests/legacy — requires anon RLS bypass)
+    # Include broadcasts (to_agent='*') — matches RPC behavior.
     messages = sb_select(
         "mc_messages",
-        f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false",
+        f"project_id=eq.{project_id}&to_agent=in.({quote(agent)},*)&read=eq.false",
         order="created_at.asc",
     )
     # Auto-decrypt encrypted messages
@@ -792,9 +793,10 @@ def count_pending(project_id: str, agent: str, api_key: Optional[str] = None) ->
         # Fall through to direct query if RPC doesn't exist yet
 
     # Fallback: direct SELECT (tests/legacy)
+    # Include broadcasts (to_agent='*') — matches mc_read_inbox behavior.
     pending = sb_select(
         "mc_messages",
-        f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false&type=neq.ack",
+        f"project_id=eq.{project_id}&to_agent=in.({quote(agent)},*)&read=eq.false&type=neq.ack",
         limit=1000,
     )
     return len(pending)

{meshcode-2.10.50 → meshcode-2.10.52}/meshcode/meshcode_mcp/realtime.py

@@ -261,7 +261,13 @@ class RealtimeListener:
                     "ref": str(ref),
                 }))
             except Exception as e:
-                log.warning(f"Realtime heartbeat send failed: {e}")
+                log.warning(f"Realtime heartbeat send failed: {e} — closing WS to force reconnect")
+                # Close WS to trigger recv loop exit → outer _run() reconnects.
+                # Without this, half-dead WS stays open for 45-60s silent blackout.
+                try:
+                    await ws.close()
+                except Exception:
+                    pass
                 return
 
     async def _handle_message(self, msg: Dict[str, Any]) -> None:

{meshcode-2.10.50 → meshcode-2.10.52}/meshcode/meshcode_mcp/server.py

@@ -104,7 +104,7 @@ def _mc_log(msg: str, level: str = "info") -> None:
 _SEEN_MSG_IDS: dict = {}  # key -> timestamp (monotonic)
 _SEEN_MSG_ORDER: deque = deque()
 _SEEN_MSG_CAP = 2000
-_SEEN_TTL = 300.0  # 5 minutes
+_SEEN_TTL = 1800.0  # 30 minutes — prevents duplicate delivery during long sessions
 _SEEN_LOCK = _threading.Lock()  # Guards _SEEN_MSG_IDS + _SEEN_MSG_ORDER
 
 # ============================================================
@@ -1470,13 +1470,15 @@ async def lifespan(_app):
     # Without this, the lifespan yields before the WS is ready, and Claude
     # Code's handshake can time out on slower network paths — one agent
     # fails while siblings on the same box succeed.
-    for _rt_check in range(10):
-        if getattr(_REALTIME, '_connected', False):
-            log.info(f"Realtime connected for {AGENT_NAME}")
+    for _rt_check in range(20):
+        if getattr(_REALTIME, '_subscription_ok', False):
+            log.info(f"Realtime connected + subscribed for {AGENT_NAME}")
             break
+        if _rt_check == 10 and getattr(_REALTIME, '_connected', False):
+            log.info(f"Realtime connected (not yet subscribed) for {AGENT_NAME} — waiting for subscription...")
         await asyncio.sleep(0.5)
     else:
-        log.warning(f"Realtime not connected after 5s for {AGENT_NAME} — continuing with polling fallback")
+        log.warning(f"Realtime not fully subscribed after 10s for {AGENT_NAME} — continuing with polling fallback")
 
     # IMMEDIATE: send first heartbeat + set online status BEFORE any tool calls.
     # Without this, the agent appears offline for up to 30s after boot.
@@ -1887,6 +1889,13 @@ try:
 except Exception as _e:
     print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
 
+# Fallback: if last_seen is still None, default to now minus 5 minutes
+# to avoid flooding agent with ancient messages on cold boot.
+if _LAST_SEEN_TS is None:
+    from datetime import datetime, timezone, timedelta
+    _LAST_SEEN_TS = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
+    print(f"[meshcode] last_seen fallback: {_LAST_SEEN_TS} (now minus 5min)", file=sys.stderr)
+
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
     """Fetch tasks that THIS agent should work on. Returns compact list or None.
@@ -2092,16 +2101,26 @@ def _mark_realtime_msgs_read_in_db(messages: List[Dict[str, Any]]) -> None:
         return
 
     def _do():
-        for mid in msg_ids:
-            try:
-                be.sb_rpc("mc_mark_message_read", {
-                    "p_api_key": api_key,
-                    "p_project_id": _PROJECT_ID,
-                    "p_message_id": mid,
-                })
-            except Exception as e:
-                log.debug(f"mark_read failed for msg {mid}: {e}")
-    threading.Thread(target=_do, daemon=True).start()
+        # Batch mark_read: single RPC instead of N individual calls
+        try:
+            be.sb_rpc("mc_mark_messages_read_batch", {
+                "p_api_key": api_key,
+                "p_project_id": _PROJECT_ID,
+                "p_message_ids": msg_ids,
+            })
+        except Exception:
+            # Fallback: individual mark_read if batch RPC not deployed yet
+            for mid in msg_ids:
+                try:
+                    be.sb_rpc("mc_mark_message_read", {
+                        "p_api_key": api_key,
+                        "p_project_id": _PROJECT_ID,
+                        "p_message_id": mid,
+                    })
+                except Exception as e:
+                    log.debug(f"mark_read failed for msg {mid}: {e}")
+    # Non-daemon: survives MCP shutdown so mark_read RPCs complete
+    threading.Thread(target=_do, daemon=False, name="mark_read_bg").start()
 
 
 async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[str, Any]:
@@ -2338,9 +2357,14 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
     # Don't mark as seen — meshcode_check is a peek, not a consume
     deduped = [m for m in realtime_buffered if _seen_key(m) not in _SEEN_MSG_IDS]
 
-    # Fallback: if realtime buffer is empty but DB has pending messages,
-    # fetch them from the DB. mark_read controls whether we consume or peek.
-    if not deduped and pending > 0:
+    # When mark_read=True and we have RT-buffered messages, also mark them
+    # as read in DB so they don't inflate pending counts on restart.
+    if mark_read and deduped:
+        _mark_realtime_msgs_read_in_db(deduped)
+
+    # Fetch from DB when: (a) RT buffer empty and DB has pending, OR
+    # (b) mark_read=True and DB has pending (must hit DB to actually mark read).
+    if (not deduped and pending > 0) or (mark_read and pending > 0):
         raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=mark_read, api_key=_get_api_key())
         deduped = [
             {
@@ -3711,6 +3735,7 @@ def run_server():
     # `mcp.run()` normally, which breaks the loop.
     import time as _time_mod
     _restart_count = 0
+    _clean_return_count = 0
     while True:
         try:
             mcp.run()
@@ -3736,5 +3761,30 @@ def run_server():
                 break
             _time_mod.sleep(0.3)
             continue
-        # Clean return = stdin EOF = Claude Code closed the pipe = real shutdown
-        break
+
+        # mcp.run() returned cleanly (stdin EOF). This can mean:
+        # a) Claude Code intentionally shut us down (process exit)
+        # b) Claude Code closed the pipe temporarily due to ESC/cancel
+        # Instead of exiting immediately, wait briefly and retry — Claude
+        # Code's /mcp reconnect will re-attach stdin within seconds.
+        # Only exit after multiple consecutive clean returns with no
+        # recovery, which means the parent process truly wants us dead.
+        _clean_return_count += 1
+        if _clean_return_count > 5:
+            try:
+                sys.stderr.write("[meshcode-mcp] stdin EOF persisted after 5 retries; exiting\n")
+                sys.stderr.flush()
+            except Exception:
+                pass
+            break
+        try:
+            sys.stderr.write(
+                f"[meshcode-mcp] mcp.run() returned cleanly (stdin EOF, attempt {_clean_return_count}/5); "
+                f"waiting 2s for Claude Code reconnect...\n"
+            )
+            sys.stderr.flush()
+        except Exception:
+            pass
+        _time_mod.sleep(2.0)
+        # Reset exception restart count — this is a clean return, not a crash
+        _restart_count = 0

{meshcode-2.10.50 → meshcode-2.10.52}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.50 → meshcode-2.10.52}/pyproject.toml

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