meshcode 2.11.1__tar.gz → 2.11.3__tar.gz

{meshcode-2.11.1 → meshcode-2.11.3}/PKG-INFO

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

{meshcode-2.11.1 → meshcode-2.11.3}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.1"
+__version__ = "2.11.3"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.1 → meshcode-2.11.3}/meshcode/_stop_hook_template.py

@@ -353,52 +353,61 @@ def _mcp_unreachable_recently(transcript_path, lookback_records=_UNREACHABLE_LOO
 
 
 def _latest_deferred_listing_lacks_meshcode(transcript_path, lookback_records=_UNREACHABLE_LOOKBACK):
-    """Find the most recent <system-reminder> that enumerates deferred
-    tools. If it lists mcp__ entries (proving the listing format is
-    canonical) but ZERO meshcode_* entries, the meshcode MCP server is
-    not registered for this session. Release.
-
-    Note: the listing is delivered as user-role content, often inside a
-    <system-reminder>...</system-reminder> block but sometimes plain.
-    We match on the marker substrings rather than tag parsing.
+    """Detect "meshcode MCP never loaded this session" by inspecting the
+    structured deferred-tools attachments Claude Code writes to the
+    transcript jsonl. Records of the form:
+
+        {"type": "attachment",
+         "attachment": {"type": "deferred_tools_delta",
+                        "addedNames": ["mcp__claude_ai_Gmail__...", ...]}}
+
+    accumulate over the session — meshcode tools land as
+    `mcp__meshcode-<server>__<tool>` once the server registers. If we
+    walk every delta and find ZERO meshcode entries (but DID find OTHER
+    mcp__ entries, confirming Claude Code is recording deltas at all),
+    the meshcode MCP server is missing for this session → release.
+
+    Replaces the previous text-marker scan ("the following deferred tools
+    are now available") — Claude Code never writes that rendered text
+    into the transcript; only the structured attachment. The old scan
+    therefore never fired, trapping agents whose MCP server failed at
+    boot in an infinite stay-on-loop. Confirmed via bob@justforfun
+    cross-mesh repro (2026-05-14) + Samuel mesh-commander launch.
     """
     try:
-        records = []
+        seen_other_mcp = False
+        seen_meshcode = False
+        record_count = 0
         with transcript_path.open() as f:
             for line in f:
                 try:
-                    records.append(json.loads(line))
+                    rec = json.loads(line)
                 except json.JSONDecodeError:
                     continue
-        tail = records[-lookback_records:] if lookback_records else records
-        for rec in reversed(tail):
-            if rec.get("role") != "user":
-                continue
-            content = rec.get("content")
-            blocks = content if isinstance(content, list) else [content] if isinstance(content, dict) else [content]
-            for block in blocks:
-                if isinstance(block, str):
-                    text = block
-                elif isinstance(block, dict):
-                    if block.get("type") == "tool_result":
-                        # tool_result blocks aren't system-reminders; skip
-                        continue
-                    text = str(block.get("text", "") or block.get("content", "") or "")
-                else:
+                record_count += 1
+                att = rec.get("attachment") if isinstance(rec, dict) else None
+                if not isinstance(att, dict):
                     continue
-                lower = text.lower()
-                if not any(m in lower for m in _DEFERRED_LISTING_MARKERS):
+                if att.get("type") != "deferred_tools_delta":
                     continue
-                # Found a listing. Check if it enumerates real tools.
-                has_mcp = "mcp__" in lower
-                has_meshcode = "meshcode_" in lower
-                if has_mcp and not has_meshcode:
-                    return True
-                # First listing that contains meshcode_ is enough to
-                # confirm MCP IS registered — stop searching backwards.
-                if has_meshcode:
-                    return False
-        return False
+                names = att.get("addedNames") or []
+                if not isinstance(names, list):
+                    continue
+                for n in names:
+                    if not isinstance(n, str):
+                        continue
+                    # meshcode tools are namespaced under their server name:
+                    # `mcp__meshcode-<server>__<tool>`. Substring check covers
+                    # all variants (self-improve, justforfun, mesh-dev, etc.).
+                    if "meshcode-" in n and "__meshcode_" in n:
+                        seen_meshcode = True
+                    elif n.startswith("mcp__"):
+                        seen_other_mcp = True
+        # Release only when we have evidence Claude Code IS recording deltas
+        # (other mcp__ tools present) but no meshcode_* entries appeared.
+        # Without the seen_other_mcp guard we'd false-positive on transcripts
+        # that simply haven't reached any deferred-tools delta yet.
+        return bool(seen_other_mcp and not seen_meshcode)
     except (OSError, FileNotFoundError):
         return False
 
@@ -467,7 +476,7 @@ def main():
         # session traces can show why the loop released without a user
         # release keyword. Released without printing a block decision.
         try:
-            sys.stderr.write("[stay_on_loop] release: mcp_unreachable\n")
+            sys.stderr.write("[stay_on_loop] release: mcp_unreachable\\n")
             sys.stderr.flush()
         except Exception:
             pass
@@ -475,7 +484,7 @@ def main():
 
     if transcript_path and _latest_deferred_listing_lacks_meshcode(transcript_path):
         try:
-            sys.stderr.write("[stay_on_loop] release: mcp_not_registered (deferred listing has no meshcode_*)\n")
+            sys.stderr.write("[stay_on_loop] release: mcp_not_registered (deferred listing has no meshcode_*)\\n")
             sys.stderr.flush()
         except Exception:
             pass
@@ -483,7 +492,7 @@ def main():
 
     if transcript_path and _user_explicitly_reports_mcp_failure(transcript_path):
         try:
-            sys.stderr.write("[stay_on_loop] release: user_reported_mcp_failure\n")
+            sys.stderr.write("[stay_on_loop] release: user_reported_mcp_failure\\n")
             sys.stderr.flush()
         except Exception:
             pass

{meshcode-2.11.1 → meshcode-2.11.3}/meshcode/meshcode_mcp/server.py

@@ -501,17 +501,22 @@ def _filter_and_mark(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
 
 _SLEEP_PAYLOAD_TYPES = {"sleep", "go_to_sleep", "shutdown", "got_done", "done",
                         "exit", "stop", "kill", "terminate"}
-# Spanish + English markers (es-MX hot path per SDK-S6.1). Matched as
-# substrings, lowercased before compare. Keep exclusive enough to not
-# false-positive on casual chatter (e.g. "no quiero dormir" still matches —
-# accepted tradeoff for user-control reliability).
+# Multi-word imperative markers ONLY. Single Spanish verbs like "salir" /
+# "terminar" / "duerme" were too loose and caught idiomatic prose like
+# "terminaron sus tasks" or "no puedo salir" (msg cfbd36b0 2026-05-14 alexa +
+# commander incidents — feedback_done_signal_false_positive_idiomatic
+# precedent). The parser now requires a directive-shaped phrase: a verb
+# combined with a temporal/object qualifier ("ahora" / "todos" / "to sleep")
+# so describing an event in prose can't trip must_exit.
 _SLEEP_TEXT_MARKERS = (
-    # English
+    # English directives
     "go to sleep", "all sleep now", "sleep now", "got_done", "go_done",
     "shut down", "shutdown", "stop now", "exit now",
-    # Spanish (es-MX, sammybenu's primary)
-    "a dormir", "todos a dormir", "duerme", "duerman", "dormir ahora",
-    "salir", "terminar", "para la sesion", "exit y duerme",
+    # Spanish directives (es-MX, sammybenu's primary). All require either a
+    # leading "a"/"todos" or a trailing "ahora" so plain conjugations
+    # ("salir", "terminar", "duerme") in body prose don't trigger.
+    "a dormir", "todos a dormir", "duerme ahora", "duerman ahora",
+    "dormir ahora", "para la sesion", "exit y duerme",
 )
 
 
@@ -2305,12 +2310,10 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
         to = recipients[0]
     if isinstance(message, str):
         # Auto-wrap strings into dict. Reject very long content; suggest
-        # task_create for >4000 chars so receiver context isn't blown.
-        # Cap raised from 2000 → 4000 (R3-CONV-1, 2026-05-05) — round-2/3
-        # task reports kept hitting the old cap and required forced
-        # downsizing or task_create fallback.
-        if len(message) > 4000:
-            return {"error": f"message too long ({len(message)} chars). Use meshcode_task_create for long content, or split into multiple messages. Max ~4000 chars."}
+        # task_create for >8000 chars. Cap raised 4000 → 8000 (mig 303,
+        # 2026-05-14) — Samuel hit the old cap on consolidations.
+        if len(message) > 8000:
+            return {"error": f"message too long ({len(message)} chars). Use meshcode_task_create for long content, or split into multiple messages. Max ~8000 chars."}
         payload: Dict[str, Any] = {"text": message}
     elif isinstance(message, dict):
         payload = message
@@ -2328,13 +2331,10 @@ def meshcode_send(to: Union[str, List[str]], message: Any, in_reply_to: Optional
         payload["text"] = _synth if len(_synth) <= 280 else _synth[:279] + "…"
 
     # Enforce message size limit — long content belongs in task descriptions.
-    # Cap raised 2000 → 4000 (R3-CONV-1, 2026-05-05). Above 2000 chars the
-    # error message hints at task_create so callers learn the convention,
-    # but the hard cap is at 4000 so structured JSON reports don't get
-    # forcibly trimmed mid-payload.
+    # Cap raised 4000 → 8000 chars in line with mig 303 (16KB DB cap).
     _payload_len = len(_json.dumps(payload, default=str))
-    if _payload_len > 4000:
-        return {"error": f"message too large ({_payload_len} chars). Use meshcode_task_create for long content. Messages must be structured JSON <4000 chars."}
+    if _payload_len > 8000:
+        return {"error": f"message too large ({_payload_len} chars). Use meshcode_task_create for long content. Messages must be structured JSON <8000 chars."}
 
     # Typed-catalog soft validation (BE-S4.2.sdk / mig 233): if caller
     # passes type=, fetch the schema and check required fields. NEVER
@@ -2671,6 +2671,13 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
     Returns file content for text/JSON files, or saves to temp file and
     returns the path for images (Claude can view image files directly).
 
+    Download strategy:
+      1. mc_get_file_download RPC returns metadata + (when GUC is configured
+         on the backend) a short-lived signed_url. If signed_url present,
+         fetch it WITHOUT auth headers — works for any agent without
+         per-client service_role secret distribution. Closes 235e85b6 PATH B.
+      2. Fallback: legacy service_role/anon/public path on the storage_path.
+
     Args:
         file_id: UUID of the file (from message payload's file.file_id).
     """
@@ -2682,23 +2689,55 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
     if not api_key:
         return {"error": "no api key", "error_code": "auth_failed"}
 
-    # Step 1: Get file metadata via RPC
+    def _consume(content: bytes, mime_type: str, file_name: str) -> Dict[str, Any]:
+        if mime_type.startswith("text/") or mime_type == "application/json":
+            try:
+                text = content.decode("utf-8")
+                if mime_type == "application/json":
+                    return {"ok": True, "file_name": file_name, "mime_type": mime_type,
+                            "content": json.loads(text)}
+                return {"ok": True, "file_name": file_name, "mime_type": mime_type,
+                        "content": text[:50000]}
+            except Exception:
+                pass
+        suffix = "." + file_name.rsplit(".", 1)[-1] if "." in file_name else ""
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, prefix="meshcode_")
+        tmp.write(content)
+        tmp.close()
+        return {
+            "ok": True,
+            "file_name": file_name,
+            "mime_type": mime_type,
+            "size_bytes": len(content),
+            "local_path": tmp.name,
+            "note": "File saved to local_path. For images, use Read tool to view.",
+        }
+
     file_info = be.sb_rpc("mc_get_file_download", {
         "p_api_key": api_key,
         "p_file_id": file_id,
     })
     if not file_info or not file_info.get("ok"):
-        return {"error": file_info.get("error", "file not found"), "error_code": "not_found"}
+        return {"error": (file_info or {}).get("error", "file not found"), "error_code": "not_found"}
 
     storage_path = file_info["storage_path"]
     bucket = file_info.get("bucket", "meshcode-files")
     mime_type = file_info.get("mime_type", "application/octet-stream")
     file_name = file_info.get("file_name", "download")
+    signed_url = file_info.get("signed_url")
 
-    # Step 2: Download from Supabase Storage.
-    # The bucket is private, so the publishable/anon key returns 404. We try
-    # the keys in order: service_role (if user opted in) → anon → public-bucket
-    # fallback. Most setups need service_role for cross-agent file access.
+    # Strategy 1: signed_url (no auth headers, no client service_role needed)
+    if signed_url:
+        try:
+            with _req.urlopen(_req.Request(signed_url), timeout=30) as resp:
+                content = resp.read()
+            return _consume(content, mime_type, file_name)
+        except _uerr.HTTPError:
+            pass  # fall through to legacy path
+        except Exception:
+            pass
+
+    # Strategy 2: legacy service_role/anon/public on storage_path
     sb_url = os.environ.get("SUPABASE_URL", be._sb_url if hasattr(be, '_sb_url') else "")
     anon_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
     service_key = os.environ.get("MESHCODE_SUPABASE_SERVICE_KEY", "")
@@ -2732,7 +2771,7 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
 
     last_err = None
     content = None
-    tried_labels = []
+    tried_labels: List[str] = ["signed_url"] if signed_url else []
     for label, _url, _key in attempts:
         tried_labels.append(label)
         try:
@@ -2750,35 +2789,10 @@ def meshcode_download_file(file_id: str) -> Dict[str, Any]:
             "error_code": "download_error",
             "tried": tried_labels,
             "storage_path": storage_path,
-            "hint": "set MESHCODE_SUPABASE_SERVICE_KEY in the MCP server env to enable service_role downloads (private bucket)" if not service_key else None,
+            "hint": "ask commander to apply backend GUC app.settings.service_role_key + supabase_url so the RPC can mint signed URLs" if not signed_url else None,
         }
 
-    # Step 3: Return content based on type
-    if mime_type.startswith("text/") or mime_type == "application/json":
-        try:
-            text = content.decode("utf-8")
-            if mime_type == "application/json":
-                return {"ok": True, "file_name": file_name, "mime_type": mime_type,
-                        "content": json.loads(text)}
-            return {"ok": True, "file_name": file_name, "mime_type": mime_type,
-                    "content": text[:50000]}  # cap at 50k chars
-        except Exception:
-            pass
-
-    # For images and binary: save to temp file, return path
-    suffix = "." + file_name.rsplit(".", 1)[-1] if "." in file_name else ""
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, prefix="meshcode_")
-    tmp.write(content)
-    tmp.close()
-
-    return {
-        "ok": True,
-        "file_name": file_name,
-        "mime_type": mime_type,
-        "size_bytes": len(content),
-        "local_path": tmp.name,
-        "note": "File saved to local_path. For images, use Read tool to view.",
-    }
+    return _consume(content, mime_type, file_name)
 
 
 def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:

{meshcode-2.11.1 → meshcode-2.11.3}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.1 → meshcode-2.11.3}/pyproject.toml

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