meshcode 2.7.0__tar.gz → 2.8.0__tar.gz

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

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

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

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

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

@@ -532,7 +532,21 @@ def heartbeat(project_id: str, agent: str) -> Dict:
     return result or {}
 
 
-def set_status(project_id: str, agent: str, status: str, task: str = "") -> Dict:
+def set_status(project_id: str, agent: str, status: str, task: str = "", api_key: Optional[str] = None) -> Dict:
+    # Use SECURITY DEFINER RPC when api_key is available (anon PATCH silently fails)
+    if api_key:
+        rpc_result = sb_rpc("mc_agent_set_status_by_api_key", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_agent_name": agent,
+            "p_status": status,
+            "p_task": task,
+        })
+        if isinstance(rpc_result, dict) and rpc_result.get("ok"):
+            return {"ok": True, "status": status}
+        # Fall through to direct PATCH if RPC doesn't exist yet
+
+    # Fallback: direct PATCH (may silently fail with anon key if RLS blocks)
     updates = {"status": status, "last_heartbeat": _now_iso()}
     if task:
         updates["task"] = task
@@ -595,7 +609,20 @@ def record_event(api_key, project_id, agent_name, session_id, event_type, payloa
     })
 
 
-def get_history(project_id: str, limit: int = 20, agent_filter: str = "") -> List[Dict]:
+def get_history(project_id: str, limit: int = 20, agent_filter: str = "", api_key: Optional[str] = None) -> List[Dict]:
+    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely)
+    if api_key:
+        rpc_result = sb_rpc("mc_get_history", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_limit": limit,
+            "p_agent_filter": agent_filter or None,
+        })
+        if isinstance(rpc_result, dict) and rpc_result.get("ok"):
+            return rpc_result.get("messages", [])
+        # Fall through to direct query if RPC doesn't exist yet
+
+    # Fallback: direct SELECT (tests/legacy)
     filters = f"project_id=eq.{project_id}&type=neq.ack"
     if agent_filter:
         filters += f"&or=(from_agent.eq.{quote(agent_filter)},to_agent.eq.{quote(agent_filter)})"
@@ -607,7 +634,21 @@ def get_history(project_id: str, limit: int = 20, agent_filter: str = "") -> Lis
     )
 
 
-def get_message_by_id(project_id: str, msg_id: str) -> Optional[Dict]:
+def get_message_by_id(project_id: str, msg_id: str, api_key: Optional[str] = None) -> Optional[Dict]:
+    # Use SECURITY DEFINER RPC when api_key is available (bypasses RLS safely)
+    if api_key:
+        rpc_result = sb_rpc("mc_get_message_by_id", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_msg_id": msg_id,
+        })
+        if isinstance(rpc_result, dict) and rpc_result.get("ok"):
+            return rpc_result.get("message")
+        if isinstance(rpc_result, dict) and rpc_result.get("error"):
+            return None
+        # Fall through to direct query if RPC doesn't exist yet
+
+    # Fallback: direct SELECT (tests/legacy)
     results = sb_select(
         "mc_messages",
         f"project_id=eq.{project_id}&id=eq.{msg_id}",

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

@@ -69,7 +69,11 @@ class RealtimeListener:
     @property
     def ws_url(self) -> str:
         host = self.supabase_url.replace("https://", "").replace("http://", "").rstrip("/")
-        return f"wss://{host}/realtime/v1/websocket?apikey={self.supabase_key}&vsn=1.0.0"
+        # Use service_role_key for WebSocket auth if available — bypasses RLS
+        # so Realtime can deliver INSERT events without needing auth.uid().
+        # Falls back to publishable key (requires anon RLS policy).
+        key = self.service_role_key or self.supabase_key
+        return f"wss://{host}/realtime/v1/websocket?apikey={key}&vsn=1.0.0"
 
     async def start(self) -> None:
         if not WEBSOCKETS_AVAILABLE:
@@ -129,21 +133,6 @@ 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 = {

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

@@ -357,31 +357,15 @@ if isinstance(_register_result, dict) and _register_result.get("error"):
 # bypass RLS — the publishable key has no JWT context and cannot UPDATE
 # mc_agents directly. The RPC validates ownership via api_key.
 def _flip_status(status: str, task: str = "") -> bool:
-    """Write status directly to mc_agents table for instant Realtime propagation.
+    """Write status via RPC for reliable updates (anon PATCH silently fails).
 
-    Uses direct PATCH (not RPC) so Supabase Realtime fires an UPDATE event
-    immediately — the dashboard sees the change in <100ms instead of waiting
-    for the next heartbeat cycle.
+    Falls back to direct PATCH only when no api_key is available (tests).
     """
     try:
-        be.set_status(_PROJECT_ID, AGENT_NAME, status, task)
-        return True
+        result = be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key())
+        return isinstance(result, dict) and result.get("ok", False)
     except Exception:
-        # Fallback to RPC if direct PATCH fails (RLS issue)
-        api_key = _get_api_key()
-        if not api_key:
-            return False
-        try:
-            r = be.sb_rpc("mc_agent_set_status_by_api_key", {
-                "p_api_key": api_key,
-                "p_project_id": _PROJECT_ID,
-                "p_agent_name": AGENT_NAME,
-                "p_status": status,
-                "p_task": task,
-            })
-            return isinstance(r, dict) and r.get("ok", False)
-        except Exception:
-            return False
+        return False
 
 if not _flip_status("idle", ""):
     print(f"[meshcode-mcp] WARNING: could not flip status to idle", file=sys.stderr)
@@ -578,7 +562,7 @@ def _acquire_lease() -> bool:
                     except Exception:
                         # Force clear via direct update
                         try:
-                            be.set_status(_PROJECT_ID, AGENT_NAME, "offline", "")
+                            be.set_status(_PROJECT_ID, AGENT_NAME, "offline", "", api_key=_get_api_key())
                         except Exception:
                             pass
                     _time.sleep(1)
@@ -1000,7 +984,7 @@ def _heartbeat_thread_fn():
 
             # Sync current state to DB (in case realtime missed it)
             try:
-                be.set_status(_PROJECT_ID, AGENT_NAME, _current_state, _current_tool)
+                be.set_status(_PROJECT_ID, AGENT_NAME, _current_state, _current_tool, api_key=_get_api_key())
             except Exception:
                 pass
             if _REALTIME and not _REALTIME.is_connected:
@@ -1049,7 +1033,7 @@ async def lifespan(_app):
     for _attempt in range(3):
         try:
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": "2.0.0"})
-            be.set_status(_PROJECT_ID, AGENT_NAME, "idle", "MCP session active")
+            be.set_status(_PROJECT_ID, AGENT_NAME, "idle", "MCP session active", api_key=_get_api_key())
             log.info(f"[meshcode] Agent {AGENT_NAME} online — initial heartbeat sent")
             break
         except Exception as e:
@@ -1128,9 +1112,9 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                   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:
-            return {"error": f"plain text message too long ({len(message)} chars). Use a dict payload with structured fields, or use meshcode_task_create for long content. Messages must be structured JSON <2000 chars."}
+        # Auto-wrap strings into dict. Warn if very long but don't reject.
+        if len(message) > 2000:
+            return {"error": f"message too long ({len(message)} chars). Use meshcode_task_create for long content, or split into multiple messages. Max ~2000 chars."}
         payload: Dict[str, Any] = {"text": message}
     elif isinstance(message, dict):
         payload = message
@@ -1237,7 +1221,7 @@ def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
 @with_working_status
 def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dict[str, Any]:
     """View past messages (read+unread). Optional agent_filter."""
-    raw = be.get_history(_PROJECT_ID, limit=limit, agent_filter=agent_filter or "")
+    raw = be.get_history(_PROJECT_ID, limit=limit, agent_filter=agent_filter or "", api_key=_get_api_key())
     messages = [
         {
             "from": m.get("from_agent", ""),
@@ -1257,7 +1241,7 @@ def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dic
 @with_working_status
 def meshcode_read_message(msg_id: str) -> Dict[str, Any]:
     """Fetch a specific message by its UUID."""
-    msg = be.get_message_by_id(_PROJECT_ID, msg_id)
+    msg = be.get_message_by_id(_PROJECT_ID, msg_id, api_key=_get_api_key())
     if not msg:
         return {"error": "message not found", "msg_id": msg_id}
     return {
@@ -1313,7 +1297,12 @@ except Exception as _e:
 
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
-    """Fetch open/in_progress tasks assigned to this agent. Returns compact list or None."""
+    """Fetch tasks that THIS agent should work on. Returns compact list or None.
+
+    Only blocks on tasks directly assigned to this agent or claimed by this agent.
+    Tasks assigned to '*' (wildcard) that are unclaimed are NOT blocking —
+    they're available for any agent but shouldn't prevent wait().
+    """
     try:
         api_key = _get_api_key()
         if not api_key:
@@ -1326,7 +1315,10 @@ 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("assignee") in (AGENT_NAME, "*", None) or t.get("claimed_by") == AGENT_NAME)
+            and (
+                t.get("claimed_by") == AGENT_NAME  # I claimed it — must work it
+                or t.get("assignee") == AGENT_NAME  # Directly assigned to me
+            )
         ]
         return pending if pending else None
     except Exception:
@@ -1370,13 +1362,19 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                  "id": m.get("id"), "parent_id": m.get("parent_msg_id")}
                 for m in raw
             ]
-            split = _split_messages(msgs)
-            return {
-                "refused": True,
-                "reason": f"You have {db_pending} unread messages. Process them before waiting.",
-                "got_message": True,
-                **split,
-            }
+            # 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)
+                return {
+                    "refused": True,
+                    "reason": f"You have {len(deduped)} unread messages. Process them before waiting.",
+                    "got_message": True,
+                    **split,
+                }
     except Exception:
         pass
 
@@ -1732,7 +1730,7 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
                 "reason": f"Cannot set status '{status}' — you have {len(pending_tasks)} open tasks. Work them first.",
                 "pending_tasks": pending_tasks,
             }
-    return be.set_status(_PROJECT_ID, AGENT_NAME, status, task)
+    return be.set_status(_PROJECT_ID, AGENT_NAME, status, task, api_key=_get_api_key())
 
 
 @mcp.tool()
@@ -2064,7 +2062,7 @@ def meshcode_scratchpad_set(key: str, value: Any) -> Dict[str, Any]:
         "p_api_key": api_key,
         "p_key": key,
         "p_value": json_value,
-        "p_project_name": PROJECT_NAME,
+        "p_tier": "reference",
     })
 
 
@@ -2078,9 +2076,9 @@ def meshcode_scratchpad_get(key: Optional[str] = None) -> Dict[str, Any]:
     """
     api_key = _get_api_key()
     if key:
-        return be.sb_rpc("mc_scratchpad_get", {"p_api_key": api_key, "p_key": key, "p_project_name": PROJECT_NAME})
+        return be.sb_rpc("mc_scratchpad_get", {"p_api_key": api_key, "p_key": key})
     else:
-        return be.sb_rpc("mc_scratchpad_list", {"p_api_key": api_key, "p_project_name": PROJECT_NAME})
+        return be.sb_rpc("mc_scratchpad_list", {"p_api_key": api_key})
 
 
 # ----------------- OBSIDIAN SYNC HELPER -----------------
@@ -2297,7 +2295,7 @@ def board_resource() -> str:
 @mcp.resource("meshcode://history")
 def history_resource() -> str:
     """Recent message history for this meshwork (last 20 non-ack messages)."""
-    history = be.get_history(_PROJECT_ID, limit=20)
+    history = be.get_history(_PROJECT_ID, limit=20, api_key=_get_api_key())
     return json.dumps({
         "project": PROJECT_NAME,
         "history": history,

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

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

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

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