meshcode 2.5.5__tar.gz → 2.5.7__tar.gz

{meshcode-2.5.5 → meshcode-2.5.7}/PKG-INFO

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

{meshcode-2.5.5 → meshcode-2.5.7}/meshcode/__init__.py

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

{meshcode-2.5.5 → meshcode-2.5.7}/meshcode/meshcode_mcp/backend.py

@@ -269,12 +269,18 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
             if actual_encrypted:
                 out["encrypted"] = True
             return out
-        # If RPC returned an auth/validation error, propagate it
-        if isinstance(result, dict) and result.get("error") and result.get("error_code"):
+        # If RPC returned an error, propagate it — do NOT fall through to
+        # direct insert (RLS blocks anon INSERT since migration 089).
+        if isinstance(result, dict) and result.get("error"):
             return {"error": result["error"]}
-        # If RPC doesn't exist yet (migration not applied), fall through to direct insert
+        # RPC returned unexpected shape but didn't error — treat as success
+        if result is not None:
+            return {"sent": True}
 
-    # Fallback: direct insert (tests / legacy)
+    # Fallback: direct insert — ONLY for tests or legacy (no api_key)
+    if api_key:
+        # api_key was provided but RPC path didn't return — should not happen
+        return {"error": "mc_send_message RPC unavailable and direct insert blocked by RLS"}
     msg = {
         "project_id": project_id,
         "from_agent": from_agent,
@@ -326,7 +332,9 @@ def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Opt
                 # If RPC succeeded, skip direct update
                 if isinstance(result, dict) and result.get("ok"):
                     marked = True
-            if not marked:
+            if not marked and not api_key:
+                # Only attempt direct update when no api_key (tests/legacy).
+                # With api_key, RLS blocks anon UPDATE since migration 089.
                 sb_update("mc_messages", f"id=eq.{m['id']}", {"read": True})
 
         # Auto-ACK senders — but ONLY for messages older than 60s. If the

{meshcode-2.5.5 → meshcode-2.5.7}/meshcode/meshcode_mcp/server.py

@@ -748,9 +748,10 @@ 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
 3. meshcode_tasks() — check for assigned/pending tasks and claim any unclaimed ones
-4. meshcode_status() — see who's online
-5. If other agents are online → meshcode_send them a greeting
-6. meshcode_wait() — enter the loop
+4. meshcode_auto_wake() — scan meshwork health, create tasks for issues found
+5. meshcode_status() — see who's online
+6. If other agents are online → meshcode_send them a greeting
+7. meshcode_wait() — enter the loop
 
 CRITICAL: You communicate by CALLING TOOLS, not by thinking or writing text.
 To talk to another agent → call meshcode_send(to="agent", message="...")
@@ -792,6 +793,9 @@ COMMANDER PROTOCOL (you are the team lead):
 - Keep the human informed with brief status updates at milestones.
 - You are autonomous: fix small issues yourself, delegate big ones.
 - After each sprint: consolidate learnings, update scratchpad, save to memory.
+- PROACTIVE MAINTENANCE: call meshcode_auto_wake() on session start and after
+  completing sprints. It scans meshwork health (stale agents, task backlog,
+  empty memories). Turn suggestions into real tasks — quality over quantity.
 """
     return base
 
@@ -1132,10 +1136,27 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
     # Cross-mesh routing: if 'to' contains '@', parse as agent@meshwork
     if "@" in to:
         target_agent, target_meshwork = to.split("@", 1)
-        if sensitive or encrypted:
-            return {"error": "sensitive/encrypted messages cannot be sent cross-mesh"}
+        if sensitive and not encrypted:
+            return {"error": "sensitive messages must use encrypted=True for cross-mesh"}
         api_key = _get_api_key()
-        return be.sb_rpc("mc_send_cross_mesh", {
+
+        # Bridge re-encryption: encrypt payload with the TARGET mesh key so
+        # the receiving agent decrypts normally. Uses mc_get_cross_mesh_key
+        # RPC which validates the link exists before returning the key.
+        if encrypted:
+            key_result = be.sb_rpc("mc_get_cross_mesh_key", {
+                "p_api_key": api_key,
+                "p_source_project": PROJECT_NAME,
+                "p_target_project": target_meshwork,
+            })
+            if not isinstance(key_result, dict) or not key_result.get("ok"):
+                err = key_result.get("error", "unknown") if isinstance(key_result, dict) else "RPC failed"
+                return {"error": f"cross-mesh encryption failed: {err}"}
+            tgt_key = key_result["key"]
+            encrypted_data = be.encrypt_payload(payload, tgt_key)
+            payload = {"_encrypted": encrypted_data}
+
+        result = be.sb_rpc("mc_send_cross_mesh", {
             "p_api_key": api_key,
             "p_from_project": PROJECT_NAME,
             "p_from_agent": AGENT_NAME,
@@ -1144,6 +1165,9 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
             "p_payload": payload,
             "p_type": "msg",
         })
+        if isinstance(result, dict) and result.get("ok") and encrypted:
+            result["encrypted"] = True
+        return result
 
     return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg",
                            parent_msg_id=in_reply_to, sensitive=sensitive,
@@ -1394,8 +1418,14 @@ def meshcode_done(reason: str) -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
-def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
-    """Peek at inbox (non-destructive). Returns pending count + new messages."""
+def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> Dict[str, Any]:
+    """Peek at inbox (non-destructive). Returns pending count + new messages.
+
+    Args:
+        include_acks: Include ack messages in response.
+        since: ISO-8601 timestamp. Only return messages newer than this.
+               Use meshcode_remember("last_seen", ts) to persist across sessions.
+    """
     pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
     # Peek at realtime buffer WITHOUT draining — check is non-destructive
     realtime_buffered = _REALTIME.peek() if _REALTIME else []
@@ -1421,11 +1451,15 @@ def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
             if _seen_key({"id": m.get("id"), "from": m.get("from_agent"), "payload": m.get("payload", {}), "ts": m.get("created_at")}) not in _SEEN_MSG_IDS
         ]
 
+    # Filter by `since` timestamp if provided
+    if since:
+        deduped = [m for m in deduped if m.get("ts") and str(m["ts"]) > since]
+
     split = _split_messages(deduped)
     if not include_acks:
         split["acks"] = []
     return {
-        "pending": pending,
+        "pending": pending if not since else len(split.get("messages", [])),
         "agent": AGENT_NAME,
         "project": PROJECT_NAME,
         "realtime_connected": _REALTIME.is_connected if _REALTIME else False,
@@ -1568,6 +1602,89 @@ def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
     })
 
 
+# ----------------- PROACTIVE HEALTH SCAN -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_auto_wake() -> Dict[str, Any]:
+    """Scan meshwork health and suggest maintenance tasks.
+
+    Checks: stale agents, task backlog, empty memories, unlinked meshworks.
+    Returns a list of suggested tasks the commander can create.
+    Call this on session start or periodically to keep the meshwork healthy.
+    """
+    api_key = _get_api_key()
+    suggestions: List[Dict[str, str]] = []
+
+    # 1. Check for stale agents (heartbeat >10 min, not offline/sleeping)
+    try:
+        agents = be.get_board(_PROJECT_ID)
+        import datetime as _dt
+        now = _dt.datetime.now(_dt.timezone.utc)
+        for a in agents:
+            if a.get("status") in ("offline", "sleeping", "done", "needs_setup"):
+                continue
+            hb = a.get("last_heartbeat")
+            if hb:
+                try:
+                    dt = _dt.datetime.fromisoformat(str(hb).replace("Z", "+00:00"))
+                    age_min = (now - dt).total_seconds() / 60
+                    if age_min > 10:
+                        suggestions.append({
+                            "title": f"Stale agent: {a['name']} ({int(age_min)}min no heartbeat)",
+                            "priority": "high",
+                            "assignee": "mesh-commander",
+                            "description": f"Agent {a['name']} shows status '{a.get('status')}' but last heartbeat was {int(age_min)} min ago. Force disconnect or investigate.",
+                        })
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+    # 2. Check task backlog — open tasks with no assignee
+    try:
+        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") == "*"]
+            if len(unassigned) > 3:
+                suggestions.append({
+                    "title": f"Task backlog: {len(unassigned)} unassigned open tasks",
+                    "priority": "normal",
+                    "assignee": "mesh-commander",
+                    "description": "Review and assign or close stale tasks to keep the board clean.",
+                })
+    except Exception:
+        pass
+
+    # 3. Check for agents with zero memories
+    try:
+        for a in agents:
+            mem_result = be.sb_rpc("mc_recall_all", {
+                "p_api_key": api_key,
+                "p_project_id": _PROJECT_ID,
+                "p_agent_name": a["name"],
+            })
+            if isinstance(mem_result, dict) and mem_result.get("ok"):
+                memories = mem_result.get("memories", [])
+                if len(memories) == 0 and a.get("status") not in ("needs_setup",):
+                    suggestions.append({
+                        "title": f"Agent {a['name']} has zero memories",
+                        "priority": "normal",
+                        "assignee": a["name"],
+                        "description": "Agent should save learnings, patterns, and preferences to memory for cross-session persistence.",
+                    })
+    except Exception:
+        pass
+
+    return {
+        "ok": True,
+        "suggestions": suggestions,
+        "total": len(suggestions),
+        "note": "Use meshcode_task_create to turn suggestions into assigned tasks.",
+    }
+
+
 # ----------------- MESH LINK TOOLS -----------------
 
 @mcp.tool()

{meshcode-2.5.5 → meshcode-2.5.7}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.5.5 → meshcode-2.5.7}/pyproject.toml

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