meshcode 2.10.49__tar.gz → 2.10.51__tar.gz

{meshcode-2.10.49 → meshcode-2.10.51}/PKG-INFO

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

{meshcode-2.10.49 → meshcode-2.10.51}/meshcode/__init__.py

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

{meshcode-2.10.49 → meshcode-2.10.51}/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.49 → meshcode-2.10.51}/meshcode/meshcode_mcp/realtime.py

@@ -173,6 +173,18 @@ class RealtimeListener:
                                 "schema": "meshcode",
                                 "table": "mc_messages",
                                 "filter": "to_agent=eq.*",
+                            },
+                            {
+                                "event": "INSERT",
+                                "schema": "meshcode",
+                                "table": "mc_tasks",
+                                "filter": f"assignee=eq.{url_quote(self.agent_name, safe='')}",
+                            },
+                            {
+                                "event": "UPDATE",
+                                "schema": "meshcode",
+                                "table": "mc_tasks",
+                                "filter": f"assignee=eq.{url_quote(self.agent_name, safe='')}",
                             }
                         ]
                     }
@@ -249,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:
@@ -260,7 +278,22 @@ class RealtimeListener:
         # {"event": "postgres_changes", "payload": {"data": {"record": {...}, "type": "INSERT", ...}}}
         if event == "postgres_changes":
             data = payload.get("data") or {}
-            if data.get("type") == "INSERT":
+            table = data.get("table", (data.get("record") or {}).get("_table", ""))
+            change_type = data.get("type")
+
+            # ── mc_tasks events: wake the agent when a task is assigned/updated ──
+            if table == "mc_tasks" and change_type in ("INSERT", "UPDATE"):
+                record = data.get("record") or {}
+                assignee = record.get("assignee", "")
+                if assignee == self.agent_name and record.get("status") in ("open", "in_progress"):
+                    log.info(f"task event: {change_type} task '{record.get('title', '?')[:60]}' for {self.agent_name}")
+                    try:
+                        self.message_event.set()
+                    except Exception:
+                        pass
+                return
+
+            if change_type == "INSERT":
                 record = data.get("record") or {}
                 to = record.get("to_agent")
                 from_agent = record.get("from_agent")
@@ -302,13 +335,16 @@ class RealtimeListener:
 
     def drain(self) -> list:
         """Pop and return all queued messages."""
-        out = list(self.queue)
-        self.queue.clear()
-        # Queue is empty → reset the wake event so the next wait blocks again.
+        # Clear event FIRST, then drain queue. If a message arrives between
+        # clear() and the drain, it re-sets the event and lands in queue —
+        # the next wait_for_message returns immediately. This avoids the race
+        # where clear() after drain() could eat a wake signal.
         try:
             self.message_event.clear()
         except Exception:
             pass
+        out = list(self.queue)
+        self.queue.clear()
         return out
 
     async def wait_for_message(self, timeout: Optional[float] = None) -> bool:

{meshcode-2.10.49 → meshcode-2.10.51}/meshcode/meshcode_mcp/server.py

@@ -13,6 +13,7 @@ import logging
 import os
 import sys
 import hashlib as _hashlib
+import threading as _threading
 import traceback as _traceback
 from collections import deque
 from contextlib import asynccontextmanager
@@ -103,13 +104,15 @@ 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
 
 # ============================================================
 # Auto-wake: when agent is NOT in meshcode_wait and a message
 # arrives, inject text into the terminal to wake the agent.
 # ============================================================
 _IN_WAIT = False  # True while meshcode_wait is blocking
+_STATE_LOCK = _threading.Lock()  # Guards _IN_WAIT, _CURRENT_STATE, _last_tool_at
 # Default OFF — keystroke injection can corrupt stdin on some terminals.
 # The primary nudge path is now in comms_v4.nudge_agent() which uses
 # platform-specific window activation (SetForegroundWindow on Windows,
@@ -292,8 +295,8 @@ def _seen_key(msg: Dict[str, Any]) -> str:
     return f"{msg.get('from') or msg.get('from_agent')}|{msg.get('ts') or msg.get('created_at')}|{payload_str}"
 
 
-def _evict_expired() -> None:
-    """Remove entries older than _SEEN_TTL from the dedup cache."""
+def _evict_expired_unlocked() -> None:
+    """Remove entries older than _SEEN_TTL. Caller MUST hold _SEEN_LOCK."""
     now = _time.monotonic()
     while _SEEN_MSG_ORDER:
         oldest_key = _SEEN_MSG_ORDER[0]
@@ -305,31 +308,43 @@ def _evict_expired() -> None:
             break
 
 
+def _evict_expired() -> None:
+    """Thread-safe wrapper for eviction."""
+    with _SEEN_LOCK:
+        _evict_expired_unlocked()
+
+
 def _mark_seen(key: str) -> None:
-    now = _time.monotonic()
-    if key in _SEEN_MSG_IDS:
-        # Refresh timestamp on re-sight (extends TTL)
+    with _SEEN_LOCK:
+        now = _time.monotonic()
+        if key in _SEEN_MSG_IDS:
+            _SEEN_MSG_IDS[key] = now
+            return
         _SEEN_MSG_IDS[key] = now
-        return
-    _SEEN_MSG_IDS[key] = now
-    _SEEN_MSG_ORDER.append(key)
-    # Evict expired + cap enforcement
-    _evict_expired()
-    while len(_SEEN_MSG_ORDER) > _SEEN_MSG_CAP:
-        old = _SEEN_MSG_ORDER.popleft()
-        _SEEN_MSG_IDS.pop(old, None)
+        _SEEN_MSG_ORDER.append(key)
+        _evict_expired_unlocked()
+        while len(_SEEN_MSG_ORDER) > _SEEN_MSG_CAP:
+            old = _SEEN_MSG_ORDER.popleft()
+            _SEEN_MSG_IDS.pop(old, None)
 
 
 def _filter_and_mark(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Drop already-seen messages; mark the rest as seen."""
-    _evict_expired()  # Clean stale entries before checking
-    out = []
-    for m in messages:
-        k = _seen_key(m)
-        if k in _SEEN_MSG_IDS:
-            continue
-        _mark_seen(k)
-        out.append(m)
+    """Drop already-seen messages; mark the rest as seen. Thread-safe."""
+    with _SEEN_LOCK:
+        _evict_expired_unlocked()
+        out = []
+        for m in messages:
+            k = _seen_key(m)
+            if k in _SEEN_MSG_IDS:
+                continue
+            now = _time.monotonic()
+            _SEEN_MSG_IDS[k] = now
+            _SEEN_MSG_ORDER.append(k)
+            out.append(m)
+        # Cap enforcement
+        while len(_SEEN_MSG_ORDER) > _SEEN_MSG_CAP:
+            old = _SEEN_MSG_ORDER.popleft()
+            _SEEN_MSG_IDS.pop(old, None)
     return out
 
 
@@ -1330,11 +1345,12 @@ def _heartbeat_loop_inner():
         try:
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
 
-            # CPU-based status detection
+            # CPU-based status detection — read shared state under lock
             parent_cpu = _get_parent_cpu()
-            cur_state = _current_state
-            in_wait = _IN_WAIT
-            idle_secs = _time.time() - _last_tool_at
+            with _STATE_LOCK:
+                cur_state = _current_state
+                in_wait = _IN_WAIT
+                idle_secs = _time.time() - _last_tool_at
 
             if _is_windows and lease_counter % 12 == 0:
                 # Periodic Windows debug dump (every ~60s on pro, ~180s on free)
@@ -1454,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.
@@ -1501,6 +1519,10 @@ async def lifespan(_app):
             _heartbeat_stop.set()
         except Exception:
             pass
+        try:
+            be.set_status(_PROJECT_ID, AGENT_NAME, "offline", "terminal closed", api_key=_get_api_key())
+        except Exception:
+            pass
         try:
             _remove_pid_lockfile()
         except Exception:
@@ -1867,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.
@@ -1949,19 +1978,17 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
         if db_pending and db_pending > 0:
             raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_get_api_key())
-            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
-            ]
-            # Dedup against already-seen messages (fixes race where
-            # background mark_read hasn't completed yet)
-            deduped = _filter_and_mark(msgs)
-            if not deduped:
-                pass  # All messages already seen — fall through to wait loop
-            else:
-                split = _split_messages(deduped)
+            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
+                ]
+                # DB is source of truth: if unread in DB, deliver to agent.
+                # Don't let in-memory dedup cache block delivery.
+                _filter_and_mark(msgs)  # mark as seen but don't filter
+                split = _split_messages(msgs)
                 # Only refuse for real messages — ack-only batches should not block wait
                 if split["messages"] or split["done_signals"]:
                     return {
@@ -1974,7 +2001,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
     except Exception:
         pass
 
-    _IN_WAIT = True
+    with _STATE_LOCK:
+        _IN_WAIT = True
     _set_state("waiting", "listening for messages")
     capped_timeout = min(max(1, int(timeout_seconds)), 20)
     try:
@@ -1996,6 +2024,13 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 _CONSECUTIVE_IDLE_SECONDS = 0
                 break
 
+            # Tasks detected mid-wait (via Realtime mc_tasks subscription
+            # or periodic sub-iteration polling) — return immediately.
+            if result.get("pending_tasks"):
+                _set_state("online", "")
+                _CONSECUTIVE_IDLE_SECONDS = 0
+                break
+
             if result.get("timed_out"):
                 _CONSECUTIVE_IDLE_SECONDS += capped_timeout
 
@@ -2047,7 +2082,8 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                         log.debug(f"last_seen memory persist failed: {e}")
         return result
     finally:
-        _IN_WAIT = False
+        with _STATE_LOCK:
+            _IN_WAIT = False
 
 
 def _mark_realtime_msgs_read_in_db(messages: List[Dict[str, Any]]) -> None:
@@ -2065,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]:
@@ -2111,6 +2157,9 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             "got_message": True,
             **split,
         }
+        # Expose queue overflow metric so agents know messages were lost
+        if _REALTIME and _REALTIME.dropped_count > 0:
+            out["dropped_messages"] = _REALTIME.dropped_count
         done = _detect_global_done(deduped)
         if done:
             out["got_done"] = True
@@ -2130,10 +2179,10 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
     _rt_live = _REALTIME and _REALTIME.is_subscribed
 
     if _rt_live:
-        # 2a) Real async wait — zero CPU, zero Supabase calls.
-        # Split into 5s sub-waits so we can detect Realtime subscription
-        # drops mid-wait and fall through to DB poll immediately instead
-        # of waiting the full timeout with a dead connection.
+        # 2a) Realtime wait with DB safety net.
+        # Split into 5s sub-waits. Between each sub-wait, also check DB
+        # as a safety net — Realtime WS can die silently and is_subscribed
+        # stays True, so we must not rely on it exclusively.
         _rt_sub_timeout = 5.0
         _rt_elapsed = 0.0
         woke = False
@@ -2153,6 +2202,34 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             if woke:
                 break
             _rt_elapsed += _this_wait
+            # Check for new tasks between sub-iterations
+            _sub_tasks = _get_pending_tasks_summary()
+            if _sub_tasks:
+                return {"timed_out": False, "got_message": False, "pending_tasks": _sub_tasks, "reason": "task_detected_mid_wait"}
+            # DB safety net: check for unread messages even when Realtime
+            # claims to be alive. Realtime WS can die silently.
+            try:
+                _safety_key = _get_api_key()
+                if _safety_key:
+                    _safety_cnt = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_safety_key)
+                    if _safety_cnt and _safety_cnt > 0:
+                        log.info(f"[meshcode] DB safety net: {_safety_cnt} unread msgs despite Realtime — reading from DB")
+                        _safety_raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_safety_key)
+                        if _safety_raw:
+                            _safety_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 _safety_raw
+                            ]
+                            _filter_and_mark(_safety_msgs)
+                            _safety_split = _split_messages(_safety_msgs)
+                            if not include_acks:
+                                _safety_split["acks"] = []
+                            if _safety_split["messages"] or _safety_split["done_signals"]:
+                                return {"got_message": True, **_safety_split}
+            except Exception as _db_err:
+                log.warning(f"[meshcode] DB safety net error: {_db_err}")
             # Health check: if subscription dropped, switch to DB poll
             if not (_REALTIME and _REALTIME.is_subscribed):
                 log.info("[meshcode] Realtime subscription lost mid-wait — switching to DB poll")
@@ -2188,15 +2265,17 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                                  "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, **split}
+                            # DB is source of truth: if read=false in DB, deliver
+                            # regardless of in-memory dedup cache (fixes stuck loop
+                            # where dedup blocks delivery but mark_read already fired).
+                            _filter_and_mark(msgs)  # mark as seen but don't filter
+                            split = _split_messages(msgs)
+                            if not include_acks:
+                                split["acks"] = []
+                            if split["messages"] or split["done_signals"]:
+                                return {"got_message": True, **split}
             except Exception as e:
-                log.debug(f"DB poll fallback error: {e}")
+                log.warning(f"DB poll fallback error: {e}")
 
     # Final fallback: one last DB check (covers realtime path missing msgs)
     try:
@@ -2212,15 +2291,15 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
                          "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, **split}
+                    # DB is source of truth: deliver all unread messages.
+                    _filter_and_mark(msgs)  # mark as seen but don't filter
+                    split = _split_messages(msgs)
+                    if not include_acks:
+                        split["acks"] = []
+                    if split["messages"] or split["done_signals"]:
+                        return {"got_message": True, **split}
     except Exception as e:
-        log.debug(f"final DB fallback error: {e}")
+        log.warning(f"final DB fallback error: {e}")
 
     # Check if there's any pending work before returning timeout
     pending_tasks = _get_pending_tasks_summary()
@@ -2278,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 = [
             {
@@ -2302,8 +2386,12 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
 
     # When mark_read=True, update tracking state so messages aren't re-processed
     if mark_read and deduped:
-        for m in deduped:
-            _SEEN_MSG_IDS.add(_seen_key(m))
+        with _SEEN_LOCK:
+            _now = _time.monotonic()
+            for m in deduped:
+                k = _seen_key(m)
+                _SEEN_MSG_IDS[k] = _now
+                _SEEN_MSG_ORDER.append(k)
         latest_ts = max((str(m.get("ts", "")) for m in deduped), default=None)
         if latest_ts and (not _LAST_SEEN_TS or latest_ts > _LAST_SEEN_TS):
             _LAST_SEEN_TS = latest_ts

{meshcode-2.10.49 → meshcode-2.10.51}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.49 → meshcode-2.10.51}/pyproject.toml

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