meshcode 2.5.8__tar.gz → 2.6.1__tar.gz

{meshcode-2.5.8 → meshcode-2.6.1}/PKG-INFO

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

{meshcode-2.5.8 → meshcode-2.6.1}/meshcode/__init__.py

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

{meshcode-2.5.8 → meshcode-2.6.1}/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.8 → meshcode-2.6.1}/meshcode/meshcode_mcp/backend.py

@@ -321,7 +321,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 +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

{meshcode-2.5.8 → meshcode-2.6.1}/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)
@@ -1154,8 +1163,9 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                 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,
@@ -1279,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()
@@ -1290,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),
@@ -1324,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
@@ -1388,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()
@@ -1452,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()
@@ -1500,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)
 
 
@@ -2080,13 +2182,13 @@ def history_resource() -> str:
 # ============================================================
 
 def _auto_update() -> None:
-    """Upgrade meshcode from PyPI in background — opt-in via MESHCODE_AUTO_UPDATE=1.
+    """Silently upgrade meshcode from PyPI in background on every launch.
 
-    Disabled by default to mitigate supply chain risk: if the PyPI account
-    is compromised, every agent would silently install malicious code.
+    Ensures all agents always run the latest version. Disable with
+    MESHCODE_AUTO_UPDATE=0 if needed.
     """
-    if os.environ.get("MESHCODE_AUTO_UPDATE", "0") != "1":
-        log.debug("[meshcode] Auto-update disabled (set MESHCODE_AUTO_UPDATE=1 to enable)")
+    if os.environ.get("MESHCODE_AUTO_UPDATE", "1").lower() in ("0", "false", "no"):
+        log.debug("[meshcode] Auto-update disabled (MESHCODE_AUTO_UPDATE=0)")
         return
 
     import threading

{meshcode-2.5.8 → meshcode-2.6.1}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.5.8 → meshcode-2.6.1}/pyproject.toml

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