meshcode 2.5.7__tar.gz → 2.6.0__tar.gz

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

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

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

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

{meshcode-2.5.7 → meshcode-2.6.0}/meshcode/comms_v4.py

@@ -470,9 +470,10 @@ def _throttle_spawn_ok(project, name, max_per_5min=5):
 
 
 def _headless_spawn_allowed():
-    """MeshCode is mesh infrastructure only — by default it never spawns claude.
-    Power users can opt back in by exporting MESHCODE_ALLOW_HEADLESS_SPAWN=1."""
-    return os.environ.get("MESHCODE_ALLOW_HEADLESS_SPAWN", "").strip() in ("1", "true", "yes", "on")
+    """Headless spawn is ON by default for mesh agents — sleeping agents auto-wake
+    when a message/task arrives. Opt OUT with MESHCODE_ALLOW_HEADLESS_SPAWN=0."""
+    val = os.environ.get("MESHCODE_ALLOW_HEADLESS_SPAWN", "1").strip().lower()
+    return val not in ("0", "false", "no", "off")
 
 
 def spawn_headless_agent(project, name, project_id, message_body, from_agent):

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

@@ -244,8 +244,8 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
     if encrypted and api_key:
         mesh_key = get_mesh_key(api_key, project_id)
         if mesh_key:
-            encrypted_data = encrypt_payload(payload, mesh_key)
-            payload = {"_encrypted": encrypted_data}
+            encrypted_data = encrypt_payload(payload, mesh_key, aad=project_id)
+            payload = {"_encrypted": encrypted_data, "_aad": project_id}
             actual_encrypted = True
 
     # Use validated SECURITY DEFINER RPC when api_key is provided
@@ -302,6 +302,56 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
 
 
 def read_inbox(project_id: str, agent: str, mark_read: bool = True, 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_read_inbox", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_agent_name": agent,
+            "p_mark_read": mark_read,
+        })
+        if isinstance(rpc_result, dict) and rpc_result.get("ok"):
+            messages = rpc_result.get("messages", [])
+            if isinstance(messages, list):
+                # Auto-decrypt and ACK (mark_read already handled by RPC)
+                mesh_key = None
+                for m in messages:
+                    p = m.get("payload")
+                    if isinstance(p, dict) and "_encrypted" in p:
+                        if mesh_key is None:
+                            mesh_key = get_mesh_key(api_key, project_id)
+                        if mesh_key:
+                            msg_aad = p.get("_aad", project_id)
+                            decrypted = decrypt_payload(p["_encrypted"], mesh_key, aad=msg_aad)
+                            if decrypted is not None:
+                                m["payload"] = decrypted
+                                m["_was_encrypted"] = True
+                if mark_read and messages:
+                    import datetime as _dt
+                    now = _dt.datetime.now(_dt.timezone.utc)
+                    def _is_stale_rpc(m):
+                        ts = m.get("created_at")
+                        if not ts:
+                            return True
+                        try:
+                            dt = _dt.datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+                            return (now - dt).total_seconds() > 60
+                        except Exception:
+                            return True
+                    ack_targets = {
+                        m.get("from_agent", "")
+                        for m in messages
+                        if m.get("type") not in ("ack", "broadcast") and _is_stale_rpc(m)
+                    }
+                    for sender in ack_targets:
+                        if sender:
+                            send_message(project_id, agent, sender,
+                                         {"text": f"{agent} read your message"},
+                                         msg_type="ack", api_key=api_key)
+                return messages
+        # If RPC doesn't exist yet, fall through to direct query
+
+    # Fallback: direct SELECT (tests/legacy — requires anon RLS bypass)
     messages = sb_select(
         "mc_messages",
         f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false",
@@ -316,7 +366,8 @@ def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Opt
                 if mesh_key is None:
                     mesh_key = get_mesh_key(api_key, project_id)
                 if mesh_key:
-                    decrypted = decrypt_payload(p["_encrypted"], mesh_key)
+                    msg_aad = p.get("_aad", project_id)
+                    decrypted = decrypt_payload(p["_encrypted"], mesh_key, aad=msg_aad)
                     if decrypted is not None:
                         m["payload"] = decrypted
                         m["_was_encrypted"] = True
@@ -365,7 +416,19 @@ def read_inbox(project_id: str, agent: str, mark_read: bool = True, api_key: Opt
     return messages
 
 
-def count_pending(project_id: str, agent: str) -> int:
+def count_pending(project_id: str, agent: str, api_key: Optional[str] = None) -> int:
+    # Use SECURITY DEFINER RPC when api_key is available
+    if api_key:
+        result = sb_rpc("mc_count_pending", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_agent_name": agent,
+        })
+        if isinstance(result, dict) and result.get("ok"):
+            return result.get("count", 0)
+        # Fall through to direct query if RPC doesn't exist yet
+
+    # Fallback: direct SELECT (tests/legacy)
     pending = sb_select(
         "mc_messages",
         f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false&type=neq.ack",
@@ -396,8 +459,15 @@ def get_mesh_key(api_key: str, project_id: str) -> Optional[str]:
     return None
 
 
-def encrypt_payload(payload: Dict, hex_key: str) -> str:
-    """Encrypt a JSON payload using AES-256-GCM. Returns base64-encoded ciphertext."""
+def encrypt_payload(payload: Dict, hex_key: str, aad: Optional[str] = None) -> str:
+    """Encrypt a JSON payload using AES-256-GCM with optional AAD.
+
+    Args:
+        payload: JSON-serializable dict to encrypt.
+        hex_key: Hex-encoded AES-256 key.
+        aad: Additional Authenticated Data (e.g. project_id) to bind
+             ciphertext to context and prevent replay/swap attacks.
+    """
     import base64
     try:
         from cryptography.hazmat.primitives.ciphers.aead import AESGCM
@@ -406,14 +476,19 @@ def encrypt_payload(payload: Dict, hex_key: str) -> str:
     key = bytes.fromhex(hex_key)
     nonce = os.urandom(12)  # 96-bit nonce for GCM
     plaintext = json.dumps(payload).encode("utf-8")
+    aad_bytes = aad.encode("utf-8") if aad else None
     aesgcm = AESGCM(key)
-    ciphertext = aesgcm.encrypt(nonce, plaintext, None)
+    ciphertext = aesgcm.encrypt(nonce, plaintext, aad_bytes)
     # Format: base64(nonce + ciphertext)
     return base64.b64encode(nonce + ciphertext).decode("ascii")
 
 
-def decrypt_payload(encrypted_b64: str, hex_key: str) -> Optional[Dict]:
-    """Decrypt an AES-256-GCM encrypted payload. Returns None on failure."""
+def decrypt_payload(encrypted_b64: str, hex_key: str, aad: Optional[str] = None) -> Optional[Dict]:
+    """Decrypt an AES-256-GCM encrypted payload. Returns None on failure.
+
+    Tries with AAD first, falls back to no-AAD for backward compat
+    with messages encrypted before AAD was added.
+    """
     import base64
     try:
         from cryptography.hazmat.primitives.ciphers.aead import AESGCM
@@ -425,6 +500,15 @@ def decrypt_payload(encrypted_b64: str, hex_key: str) -> Optional[Dict]:
         nonce = raw[:12]
         ciphertext = raw[12:]
         aesgcm = AESGCM(key)
+        aad_bytes = aad.encode("utf-8") if aad else None
+        # Try with AAD first
+        if aad_bytes:
+            try:
+                plaintext = aesgcm.decrypt(nonce, ciphertext, aad_bytes)
+                return json.loads(plaintext.decode("utf-8"))
+            except Exception:
+                pass  # Fall through to no-AAD for backward compat
+        # Try without AAD (legacy messages)
         plaintext = aesgcm.decrypt(nonce, ciphertext, None)
         return json.loads(plaintext.decode("utf-8"))
     except Exception:

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

@@ -1124,15 +1124,24 @@ 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 = False) -> Dict[str, Any]:
-    """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports. encrypted=True encrypts payload with per-meshwork AES-256 key."""
+                  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."""
     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."}
         payload: Dict[str, Any] = {"text": message}
     elif isinstance(message, dict):
         payload = message
     else:
         payload = {"text": str(message)}
 
+    # Enforce message size limit — long content belongs in task descriptions
+    import json as _json
+    _payload_len = len(_json.dumps(payload, default=str))
+    if _payload_len > 2000:
+        return {"error": f"message too large ({_payload_len} chars). Use meshcode_task_create for long content. Messages must be structured JSON <2000 chars."}
+
     # Cross-mesh routing: if 'to' contains '@', parse as agent@meshwork
     if "@" in to:
         target_agent, target_meshwork = to.split("@", 1)
@@ -1148,13 +1157,15 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                 "p_api_key": api_key,
                 "p_source_project": PROJECT_NAME,
                 "p_target_project": target_meshwork,
+                "p_agent_name": AGENT_NAME,
             })
             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}
+            tgt_project_id = key_result.get("target_project_id", "")
+            encrypted_data = be.encrypt_payload(payload, tgt_key, aad=tgt_project_id)
+            payload = {"_encrypted": encrypted_data, "_aad": tgt_project_id}
 
         result = be.sb_rpc("mc_send_cross_mesh", {
             "p_api_key": api_key,
@@ -1278,6 +1289,28 @@ def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, An
 # Auto-sleep: track consecutive idle timeouts to auto-sleep after threshold
 _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
+
+
+def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
+    """Fetch open/in_progress tasks assigned to this agent. Returns compact list or None."""
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None)
+        if not isinstance(result, dict) or not result.get("ok"):
+            return None
+        tasks = result.get("tasks", [])
+        pending = [
+            {"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)
+        ]
+        return pending if pending else None
+    except Exception:
+        return None
 
 
 @mcp.tool()
@@ -1289,6 +1322,41 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
         timeout_seconds: Max wait time in seconds (default 120, hard cap 120).
     """
     global _IN_WAIT, _CONSECUTIVE_IDLE_SECONDS
+
+    # PRODUCT RULE 1: If agent has open tasks, refuse to wait. Work first.
+    pending_tasks = _get_pending_tasks_summary()
+    if pending_tasks:
+        return {
+            "refused": True,
+            "reason": "You have open tasks. Work them before entering wait.",
+            "pending_tasks": pending_tasks,
+            "count": len(pending_tasks),
+        }
+
+    # PRODUCT RULE 2: If agent has unread messages in DB, refuse to wait.
+    # 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)
+        if db_pending and db_pending > 0:
+            # Fetch and return the messages instead of waiting
+            raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=False, 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
+            ]
+            split = _split_messages(msgs)
+            return {
+                "refused": True,
+                "reason": f"You have {db_pending} unread messages. Process them before waiting.",
+                "got_message": True,
+                **split,
+            }
+    except Exception:
+        pass
+
     _IN_WAIT = True
     _set_state("waiting", "listening for messages")
     # Universal hard cap: even if a caller passes a larger value (e.g. 1800),
@@ -1323,6 +1391,18 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                     "threshold": _AUTO_SLEEP_THRESHOLD,
                     "instruction": "You have been idle too long. Status set to sleeping. Exit the wait loop to save resources. You will be woken by auto_wake if a new message arrives.",
                 }
+        # Auto-inject pending tasks so agents don't forget to check
+        pending_tasks = _get_pending_tasks_summary()
+        if pending_tasks:
+            result["pending_tasks"] = pending_tasks
+        # Track last seen timestamp for message dedup
+        global _LAST_SEEN_TS
+        if result.get("got_message"):
+            msgs = result.get("messages", [])
+            if msgs:
+                latest_ts = max((m.get("ts", "") for m in msgs), default="")
+                if latest_ts:
+                    _LAST_SEEN_TS = latest_ts
         return result
     finally:
         _IN_WAIT = False
@@ -1387,7 +1467,15 @@ 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)
 
-    return {"timed_out": True}
+    # Check if there's any pending work before returning timeout
+    pending_tasks = _get_pending_tasks_summary()
+    out: Dict[str, Any] = {"timed_out": True}
+    if pending_tasks:
+        out["pending_tasks"] = pending_tasks
+    else:
+        out["no_work"] = True
+        out["hint"] = "No messages or tasks. Safe to sleep — launcher daemon will wake you on new messages."
+    return out
 
 
 @mcp.tool()
@@ -1426,7 +1514,7 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
         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)
+    pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
     # Peek at realtime buffer WITHOUT draining — check is non-destructive
     realtime_buffered = _REALTIME.peek() if _REALTIME else []
     # Don't mark as seen — meshcode_check is a peek, not a consume
@@ -1451,20 +1539,26 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
             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]
+    # Auto-apply last_seen_ts if no explicit since provided
+    effective_since = since or _LAST_SEEN_TS
+    if effective_since:
+        deduped = [m for m in deduped if m.get("ts") and str(m["ts"]) > effective_since]
 
     split = _split_messages(deduped)
     if not include_acks:
         split["acks"] = []
-    return {
-        "pending": pending if not since else len(split.get("messages", [])),
+    result = {
+        "pending": pending if not effective_since else len(split.get("messages", [])),
         "agent": AGENT_NAME,
         "project": PROJECT_NAME,
         "realtime_connected": _REALTIME.is_connected if _REALTIME else False,
         **split,
     }
+    # Auto-inject pending tasks
+    pending_tasks = _get_pending_tasks_summary()
+    if pending_tasks:
+        result["pending_tasks"] = pending_tasks
+    return result
 
 
 @mcp.tool()
@@ -1499,9 +1593,18 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
     """Update your status in the board.
 
     Args:
-        status: One of: working, idle, standby, blocked, done, online.
+        status: One of: working, idle, standby, blocked, done, online, sleeping.
         task: Optional human-readable task description.
     """
+    # PRODUCT RULE: Cannot sleep/idle/standby with open tasks. Work first.
+    if status in ("sleeping", "idle", "standby"):
+        pending_tasks = _get_pending_tasks_summary()
+        if pending_tasks:
+            return {
+                "refused": True,
+                "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)
 
 
@@ -2079,7 +2182,15 @@ def history_resource() -> str:
 # ============================================================
 
 def _auto_update() -> None:
-    """Silently upgrade meshcode from PyPI in background on every launch."""
+    """Upgrade meshcode from PyPI in background — opt-in via MESHCODE_AUTO_UPDATE=1.
+
+    Disabled by default to mitigate supply chain risk: if the PyPI account
+    is compromised, every agent would silently install malicious code.
+    """
+    if os.environ.get("MESHCODE_AUTO_UPDATE", "0") != "1":
+        log.debug("[meshcode] Auto-update disabled (set MESHCODE_AUTO_UPDATE=1 to enable)")
+        return
+
     import threading
 
     def _upgrade():

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

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

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

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