meshcode 2.6.3__tar.gz → 2.6.5__tar.gz

{meshcode-2.6.3 → meshcode-2.6.5}/PKG-INFO

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

{meshcode-2.6.3 → meshcode-2.6.5}/meshcode/__init__.py

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

{meshcode-2.6.3 → meshcode-2.6.5}/meshcode/meshcode_mcp/server.py

@@ -746,7 +746,7 @@ RULES:
 
 SESSION START (do these IMMEDIATELY — don't wait for user input):
 1. meshcode_set_status(status="online", task="ready")
-2. meshcode_check() — read pending messages
+2. meshcode_check() — read NEW messages only (last_seen is auto-restored from mesh memory on boot, old messages are skipped automatically)
 3. meshcode_tasks() — check for assigned/pending tasks and claim any unclaimed ones
 4. meshcode_auto_wake() — scan meshwork health, create tasks for issues found
 5. meshcode_status() — see who's online
@@ -1124,8 +1124,8 @@ except Exception:
 @mcp.tool()
 @with_working_status
 def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
-                  sensitive: bool = False, encrypted: bool = True) -> Dict[str, Any]:
-    """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports. All messages encrypted by default (AES-256-GCM). Pass encrypted=False to send plaintext."""
+                  sensitive: bool = False, encrypted: bool = False) -> Dict[str, Any]:
+    """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports. Pass encrypted=True for secrets/credentials (AES-256-GCM)."""
     if isinstance(message, str):
         # Auto-wrap strings but warn if too long — prefer structured JSON
         if len(message) > 400:
@@ -1291,6 +1291,25 @@ _CONSECUTIVE_IDLE_SECONDS = 0
 _AUTO_SLEEP_THRESHOLD = int(os.environ.get("MESHCODE_AUTO_SLEEP_SECONDS", "600"))  # default 10min
 _LAST_SEEN_TS: Optional[str] = None  # auto-persisted for message dedup
 
+# Hydrate _LAST_SEEN_TS from mesh memory on boot so restarts skip old messages
+try:
+    _ls_result = be.sb_rpc("mc_memory_get", {
+        "p_api_key": _get_api_key(),
+        "p_agent_name": AGENT_NAME,
+        "p_key": "last_seen",
+        "p_project_name": PROJECT_NAME,
+    })
+    if isinstance(_ls_result, dict) and _ls_result.get("ok"):
+        _ls_val = _ls_result.get("value")
+        if isinstance(_ls_val, dict) and _ls_val.get("_raw"):
+            _LAST_SEEN_TS = str(_ls_val["_raw"])
+        elif isinstance(_ls_val, str):
+            _LAST_SEEN_TS = _ls_val
+        if _LAST_SEEN_TS:
+            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", file=sys.stderr)
+except Exception as _e:
+    print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
+
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
     """Fetch open/in_progress tasks assigned to this agent. Returns compact list or None."""
@@ -1306,7 +1325,7 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
             {"id": t["id"][:8], "title": t["title"][:80], "priority": t.get("priority", "normal"), "status": t["status"]}
             for t in tasks
             if t.get("status") in ("open", "in_progress")
-            and (t.get("assigned_to") in (AGENT_NAME, "*", None) or t.get("claimed_by") == AGENT_NAME)
+            and (t.get("assignee") in (AGENT_NAME, "*", None) or t.get("claimed_by") == AGENT_NAME)
         ]
         return pending if pending else None
     except Exception:
@@ -1337,7 +1356,7 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
     # The in-memory dedupe (_SEEN_MSG_IDS) can mark messages as "seen" via
     # realtime without the agent actually processing them. Always check DB.
     try:
-        db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
+        db_pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
         if db_pending and db_pending > 0:
             # Fetch and return the messages — mark_read=True so the next
             # meshcode_wait() won't re-refuse with the same messages.
@@ -1404,11 +1423,49 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                 latest_ts = max((m.get("ts", "") for m in msgs), default="")
                 if latest_ts:
                     _LAST_SEEN_TS = latest_ts
+                    # Persist to mesh memory so next session resumes here
+                    try:
+                        be.sb_rpc("mc_memory_set", {
+                            "p_api_key": _get_api_key(),
+                            "p_agent_name": AGENT_NAME,
+                            "p_key": "last_seen",
+                            "p_value": {"_raw": latest_ts},
+                            "p_project_name": PROJECT_NAME,
+                        })
+                    except Exception:
+                        pass  # best-effort, never block wait loop
         return result
     finally:
         _IN_WAIT = False
 
 
+def _mark_realtime_msgs_read_in_db(messages: List[Dict[str, Any]]) -> None:
+    """Mark realtime-delivered messages as read in DB (background thread).
+
+    Without this, messages delivered via realtime stay read=false in the DB
+    and inflate pending counts when the agent restarts.
+    """
+    import threading
+    msg_ids = [m.get("id") for m in messages if m.get("id")]
+    if not msg_ids:
+        return
+    api_key = _get_api_key()
+    if not api_key:
+        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:
+                pass
+    threading.Thread(target=_do, daemon=True).start()
+
+
 async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[str, Any]:
 
     def _return_from_buffered(buffered: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
@@ -1436,6 +1493,9 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         # are no real messages or done signals, treat as nothing useful.
         if not split["messages"] and not split["done_signals"] and not split["acks"]:
             return None
+        # Mark realtime-delivered messages as read in DB so they don't
+        # inflate pending counts on agent restart.
+        _mark_realtime_msgs_read_in_db(deduped)
         out: Dict[str, Any] = {
             "got_message": True,
             "source": "realtime",
@@ -1468,6 +1528,31 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         # Realtime unavailable — plain sleep fallback so we still honor timeout.
         await asyncio.sleep(actual_timeout)
 
+    # Fallback: poll DB for messages that realtime may have missed
+    # (connection drop, startup race, etc.)
+    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_fallback", **split}
+    except Exception:
+        pass
+
     # Check if there's any pending work before returning timeout
     pending_tasks = _get_pending_tasks_summary()
     out: Dict[str, Any] = {"timed_out": True}
@@ -1750,7 +1835,7 @@ def meshcode_auto_wake() -> Dict[str, Any]:
         task_result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
         if isinstance(task_result, dict) and task_result.get("ok"):
             open_tasks = task_result.get("tasks", [])
-            unassigned = [t for t in open_tasks if not t.get("assigned_to") or t.get("assigned_to") == "*"]
+            unassigned = [t for t in open_tasks if not t.get("assignee") or t.get("assignee") == "*"]
             if len(unassigned) > 3:
                 suggestions.append({
                     "title": f"Task backlog: {len(unassigned)} unassigned open tasks",

{meshcode-2.6.3 → meshcode-2.6.5}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.6.3 → meshcode-2.6.5}/pyproject.toml

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