meshcode 2.10.16__tar.gz → 2.10.18__tar.gz

{meshcode-2.10.16 → meshcode-2.10.18}/PKG-INFO

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

{meshcode-2.10.16 → meshcode-2.10.18}/meshcode/__init__.py

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

{meshcode-2.10.16 → meshcode-2.10.18}/meshcode/meshcode_mcp/backend.py

@@ -1,17 +1,19 @@
 """Thin Supabase REST backend used by both the MCP server and tests.
 
 Reuses the helpers from comms_v4.py without going through subprocess.
-Zero deps beyond stdlib (urllib).
+Zero deps beyond stdlib (urllib + http.client for connection pooling).
 """
+import http.client
 import json
 import os
+import ssl
 import time as _time
 import threading as _threading
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 from urllib.error import HTTPError, URLError
-from urllib.parse import quote
+from urllib.parse import quote, urlparse
 from urllib.request import Request, urlopen
 
 
@@ -97,6 +99,74 @@ SUPABASE_SERVICE_ROLE_KEY = (
 SCHEMA = "meshcode"
 
 
+# ── Persistent HTTPS Connection Pool ──────────────────────────────
+# Each urlopen() opens a new TCP+TLS connection (~1-2s overhead).
+# This pool reuses connections, cutting typical latency from ~3s to ~100ms.
+class _ConnectionPool:
+    """Thread-safe persistent HTTPS connection to Supabase."""
+
+    def __init__(self, url: str, max_idle: float = 30.0):
+        parsed = urlparse(url)
+        self._host = parsed.hostname
+        self._port = parsed.port or 443
+        self._conn: Optional[http.client.HTTPSConnection] = None
+        self._lock = _threading.Lock()
+        self._max_idle = max_idle
+        self._last_used = 0.0
+        self._ctx = ssl.create_default_context()
+
+    def _get_conn(self) -> http.client.HTTPSConnection:
+        now = _time.monotonic()
+        if self._conn is not None:
+            # Close stale connections
+            if now - self._last_used > self._max_idle:
+                try:
+                    self._conn.close()
+                except Exception:
+                    pass
+                self._conn = None
+        if self._conn is None:
+            self._conn = http.client.HTTPSConnection(
+                self._host, self._port, timeout=10, context=self._ctx
+            )
+        return self._conn
+
+    def request(self, method: str, path: str, body: Optional[bytes], headers: Dict[str, str]) -> tuple:
+        """Returns (status, response_body_str). Thread-safe with retry on broken pipe."""
+        with self._lock:
+            for attempt in range(2):
+                conn = self._get_conn()
+                try:
+                    conn.request(method, path, body=body, headers=headers)
+                    resp = conn.getresponse()
+                    data = resp.read().decode("utf-8")
+                    self._last_used = _time.monotonic()
+                    return resp.status, data
+                except (http.client.RemoteDisconnected, BrokenPipeError,
+                        ConnectionResetError, OSError) as e:
+                    # Connection went stale — close and retry once
+                    try:
+                        self._conn.close()
+                    except Exception:
+                        pass
+                    self._conn = None
+                    if attempt == 0:
+                        continue
+                    raise
+
+    def close(self):
+        with self._lock:
+            if self._conn:
+                try:
+                    self._conn.close()
+                except Exception:
+                    pass
+                self._conn = None
+
+
+_pool = _ConnectionPool(SUPABASE_URL)
+
+
 def _now_iso() -> str:
     return datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S+00:00")
 
@@ -118,27 +188,29 @@ def _headers(*, prefer: Optional[str] = None, content_profile: bool = True) -> D
 def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str] = None) -> Any:
     if not _circuit.can_execute():
         return {"_error": "circuit breaker open — Supabase temporarily unavailable", "_code": 503}
-    url = f"{SUPABASE_URL}/rest/v1/{path}"
+    rest_path = f"/rest/v1/{path}"
     body = json.dumps(data).encode("utf-8") if data else None
-    req = Request(url, data=body, method=method, headers=_headers(prefer=prefer))
+    hdrs = _headers(prefer=prefer)
     try:
-        with urlopen(req, timeout=10) as resp:
-            raw = resp.read().decode("utf-8")
+        status, raw = _pool.request(method, rest_path, body, hdrs)
+        if 200 <= status < 300:
             _circuit.record_success()
             return json.loads(raw) if raw.strip() else None
-    except HTTPError as e:
-        err = e.read().decode("utf-8", errors="replace")
-        # 4xx = client error (not a backend failure), don't trip breaker
-        if 400 <= e.code < 500:
+        elif 400 <= status < 500:
             _circuit.record_success()
+            try:
+                err_obj = json.loads(raw)
+                return {"_error": err_obj.get("message", raw[:200]), "_code": status}
+            except Exception:
+                return {"_error": raw[:200], "_code": status}
         else:
             _circuit.record_failure()
-        try:
-            err_obj = json.loads(err)
-            return {"_error": err_obj.get("message", err[:200]), "_code": e.code}
-        except Exception:
-            return {"_error": err[:200], "_code": e.code}
-    except (URLError, OSError, TimeoutError) as e:
+            try:
+                err_obj = json.loads(raw)
+                return {"_error": err_obj.get("message", raw[:200]), "_code": status}
+            except Exception:
+                return {"_error": raw[:200], "_code": status}
+    except (URLError, OSError, TimeoutError, http.client.HTTPException) as e:
         _circuit.record_failure()
         return {"_error": str(getattr(e, 'reason', e)), "_code": 0}
 
@@ -200,34 +272,31 @@ def sb_rpc(fn_name: str, params: Dict, *, _max_retries: int = 3) -> Any:
     if not _circuit.can_execute():
         return {"_error": "circuit breaker open — Supabase temporarily unavailable", "_circuit": "open"}
     last_err = None
+    rpc_path = f"/rest/v1/rpc/{fn_name}"
+    body = json.dumps(params).encode("utf-8")
+    hdrs = _headers(content_profile=False)
     for attempt in range(_max_retries):
-        url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
-        body = json.dumps(params).encode("utf-8")
-        req = Request(url, data=body, method="POST", headers=_headers(content_profile=False))
         try:
-            with urlopen(req, timeout=10) as resp:
-                raw = resp.read().decode("utf-8")
+            status, raw = _pool.request("POST", rpc_path, body, hdrs)
+            if 200 <= status < 300:
                 result = json.loads(raw) if raw.strip() else None
-            _circuit.record_success()
-            # Auto-record tool calls to session events (hot-reloadable)
-            if _recording_enabled and fn_name not in _SKIP_RECORDING:
-                _bg_record("tool_call", {"rpc": fn_name})
-            return result
-        except HTTPError as e:
-            err = e.read().decode("utf-8", errors="replace")
-            # 4xx errors are not transient — don't retry, don't trip breaker
-            if 400 <= e.code < 500:
+                _circuit.record_success()
+                if _recording_enabled and fn_name not in _SKIP_RECORDING:
+                    _bg_record("tool_call", {"rpc": fn_name})
+                return result
+            elif 400 <= status < 500:
                 _circuit.record_success()
                 try:
-                    result = {"_error": json.loads(err).get("message", err[:200])}
+                    result = {"_error": json.loads(raw).get("message", raw[:200])}
                 except Exception:
-                    result = {"_error": err[:200]}
+                    result = {"_error": raw[:200]}
                 if _recording_enabled and fn_name not in _SKIP_RECORDING:
-                    _bg_record("error", {"rpc": fn_name, "error": str(err)[:200]})
+                    _bg_record("error", {"rpc": fn_name, "error": raw[:200]})
                 return result
-            _circuit.record_failure()
-            last_err = err
-        except (URLError, OSError, TimeoutError) as e:
+            else:
+                _circuit.record_failure()
+                last_err = raw[:200]
+        except (URLError, OSError, TimeoutError, http.client.HTTPException) as e:
             _circuit.record_failure()
             last_err = str(getattr(e, 'reason', e))
         # Retry with jitter for transient errors (5xx, network)
@@ -260,13 +329,14 @@ def _bg_record(event_type: str, payload: dict):
 
 def sb_rpc_raw(fn_name: str, params: Dict) -> Any:
     """Raw RPC call without recording (to avoid infinite recursion)."""
-    url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
+    rpc_path = f"/rest/v1/rpc/{fn_name}"
     body = json.dumps(params).encode("utf-8")
-    req = Request(url, data=body, method="POST", headers=_headers(content_profile=False))
+    hdrs = _headers(content_profile=False)
     try:
-        with urlopen(req, timeout=10) as resp:
-            raw = resp.read().decode("utf-8")
+        status, raw = _pool.request("POST", rpc_path, body, hdrs)
+        if 200 <= status < 300:
             return json.loads(raw) if raw.strip() else None
+        return None
     except Exception:
         return None
 

{meshcode-2.10.16 → meshcode-2.10.18}/meshcode/meshcode_mcp/server.py

@@ -386,7 +386,7 @@ def _get_api_key() -> str:
                 _API_KEY_CACHE = kc_val
                 return kc_val
         except Exception as e:
-            _mc_log(f" keychain lookup failed for profile '{profile}': {e}", file=sys.stderr)
+            _mc_log(f" keychain lookup failed for profile '{profile}': {e}", "warn")
     _API_KEY_CACHE = ""
     return ""
 
@@ -411,17 +411,17 @@ if not _PROJECT_ID:
                     _PROJECT_ID = _r["project_id"]
                     break
                 elif isinstance(_r, dict) and _r.get("error"):
-                    _mc_log(f" mc_resolve_project: {_r['error']}", file=sys.stderr)
+                    _mc_log(f" mc_resolve_project: {_r['error']}", "warn")
             except Exception as _e:
-                _mc_log(f" mc_resolve_project failed: {_e}", file=sys.stderr)
+                _mc_log(f" mc_resolve_project failed: {_e}", "warn")
         if not _PROJECT_ID:
             _PROJECT_ID = be.get_project_id(PROJECT_NAME)
         if _PROJECT_ID:
             break
         if _boot_attempt < _BOOT_MAX_RETRIES - 1:
             _wait = _BOOT_BACKOFF[_boot_attempt]
-            _mc_log(f" project resolution failed (attempt {_boot_attempt+1}/{_BOOT_MAX_RETRIES}), retrying in {_wait}s...", file=sys.stderr)
-            _time.sleep(_wait)
+            _mc_log(f" project resolution failed (attempt {_boot_attempt+1}/{_BOOT_MAX_RETRIES}), retrying in {_wait}s...", "warn")
+            import time; time.sleep(_wait)
 if not _PROJECT_ID:
     _mc_log(f"project '{PROJECT_NAME}' not found after {_BOOT_MAX_RETRIES} attempts (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", "error")
     sys.exit(2)
@@ -437,7 +437,7 @@ except Exception:
 
 _register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MCP-connected agent", api_key=_get_api_key())
 if isinstance(_register_result, dict) and _register_result.get("error"):
-    _mc_log(f" register failed: {_register_result['error']}", file=sys.stderr)
+    _mc_log(f" register failed: {_register_result['error']}", "warn")
 
 # ── Fetch profile color from dashboard (single source of truth) ──
 try:
@@ -471,7 +471,7 @@ def _flip_status(status: str, task: str = "") -> bool:
         return False
 
 if not _flip_status("idle", ""):
-    _mc_log(f" could not flip status to idle", file=sys.stderr)
+    _mc_log(f" could not flip status to idle", "warn")
 
 
 # ============================================================
@@ -576,6 +576,10 @@ def with_working_status(func):
                 _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
             try:
                 return await func(*args, **kwargs)
+            except asyncio.CancelledError:
+                # User pressed ESC or MCP client cancelled the request.
+                # Let it propagate cleanly — FastMCP handles cancellation.
+                raise
             except Exception as e:
                 if not skip:
                     _auto_learn_error(name, e, list(kwargs.keys()))
@@ -636,7 +640,7 @@ def _acquire_lease() -> bool:
         })
     except Exception as e:
         # Non-fatal: RPC might not exist on older servers.
-        _mc_log(f"stale-lease pre-clean skipped: {e}", file=sys.stderr)
+        _mc_log(f"stale-lease pre-clean skipped: {e}", "warn")
     for attempt in range(3):
         try:
             r = be.sb_rpc("mc_acquire_agent_lease", {
@@ -688,14 +692,14 @@ def _acquire_lease() -> bool:
                     _mc_log(f"Could not start — agent '{AGENT_NAME}' is running in another window.", "error")
                     _mc_log("Close the other window first, or use a different agent name.", "error")
                     return False
-                _mc_log(f"lease attempt {attempt+1}: {r.get('error')}", file=sys.stderr)
+                _mc_log(f"lease attempt {attempt+1}: {r.get('error')}", "warn")
             else:
                 return True
         except Exception as e:
-            _mc_log(f"lease attempt {attempt+1} failed: {e}", file=sys.stderr)
+            _mc_log(f"lease attempt {attempt+1} failed: {e}", "warn")
         if attempt < 2:
             _time.sleep(2)
-    _mc_log(f" lease failed after 3 attempts — proceeding anyway", file=sys.stderr)
+    _mc_log(f" lease failed after 3 attempts — proceeding anyway", "warn")
     return True
 
 if not _acquire_lease():
@@ -783,9 +787,11 @@ _SHUTDOWN_LOGGED = False
 def _log_crash_to_db(reason: str = "unknown", error_detail: str = "") -> None:
     """Best-effort crash log to mc_agent_crash_logs table. Non-fatal if table doesn't exist."""
     global _SHUTDOWN_LOGGED
-    if _SHUTDOWN_LOGGED:
-        return
-    _SHUTDOWN_LOGGED = True
+    # Only suppress duplicates for process-level shutdown events, not tool exceptions
+    if reason in ("process_exit", "signal", "keyboard_interrupt", "system_exit", "unhandled_exception"):
+        if _SHUTDOWN_LOGGED:
+            return
+        _SHUTDOWN_LOGGED = True
     try:
         be.sb_rpc("mc_log_error", {
             "p_api_key": _get_api_key(),
@@ -802,7 +808,7 @@ def _log_crash_to_db(reason: str = "unknown", error_detail: str = "") -> None:
                           f"crashed: {reason[:100]}", api_key=_get_api_key())
         except Exception:
             pass
-    _mc_log(f" crash logged: {reason}", file=sys.stderr)
+    _mc_log(f" crash logged: {reason}", "warn")
 
 
 def _on_exit() -> None:

{meshcode-2.10.16 → meshcode-2.10.18}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.16 → meshcode-2.10.18}/pyproject.toml

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