meshcode 2.10.17__tar.gz → 2.10.19__tar.gz

{meshcode-2.10.17 → meshcode-2.10.19}/PKG-INFO

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

{meshcode-2.10.17 → meshcode-2.10.19}/meshcode/__init__.py

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

{meshcode-2.10.17 → meshcode-2.10.19}/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.17 → meshcode-2.10.19}/meshcode/meshcode_mcp/server.py

@@ -85,11 +85,11 @@ def _mc_log(msg: str, level: str = "info") -> None:
     c = _agent_color(agent) if agent else "\033[36m"
     prefix = f"{c}{_ANSI_BOLD}[meshcode-mcp]{_ANSI_RESET}"
     if level == "error":
-        print(f"{prefix} \033[91mERROR:{_ANSI_RESET} {msg}", "warn")
+        print(f"{prefix} \033[91mERROR:{_ANSI_RESET} {msg}", file=sys.stderr)
     elif level == "warn":
-        print(f"{prefix} \033[33mWARNING:{_ANSI_RESET} {msg}", "warn")
+        print(f"{prefix} \033[33mWARNING:{_ANSI_RESET} {msg}", file=sys.stderr)
     else:
-        print(f"{prefix} {c}{msg}{_ANSI_RESET}", "warn")
+        print(f"{prefix} {c}{msg}{_ANSI_RESET}", file=sys.stderr)
 
 
 # ============================================================
@@ -576,6 +576,11 @@ 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, KeyboardInterrupt):
+                # User pressed ESC or MCP client cancelled the request.
+                # Return clean dict — never propagate BaseException to FastMCP.
+                _mc_log(f"tool {name} cancelled by client", "warn")
+                return {"cancelled": True, "tool": name}
             except Exception as e:
                 if not skip:
                     _auto_learn_error(name, e, list(kwargs.keys()))
@@ -713,7 +718,7 @@ def _boot_diagnostic() -> None:
         be.sb_select("mc_projects", f"id=eq.{_PROJECT_ID}", limit=1)
         checks_passed += 1
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", "warn")
+        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", file=sys.stderr)
 
     # Check 2: Lease valid
     try:
@@ -723,11 +728,11 @@ def _boot_diagnostic() -> None:
             if agent.get("instance_id") == _INSTANCE_ID:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", "warn")
+                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", file=sys.stderr)
         else:
-            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", "warn")
+            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", file=sys.stderr)
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", "warn")
+        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", file=sys.stderr)
 
     # Check 3: Heartbeat recent
     try:
@@ -736,7 +741,7 @@ def _boot_diagnostic() -> None:
             if hb:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", "warn")
+                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", file=sys.stderr)
         else:
             checks_passed += 1  # skip if no agent data
     except Exception:
@@ -753,9 +758,9 @@ def _boot_diagnostic() -> None:
         checks_passed += 1  # non-critical
 
     if checks_passed == checks_total:
-        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", "warn")
+        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", file=sys.stderr)
     else:
-        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", "warn")
+        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", file=sys.stderr)
 
 
 _boot_diagnostic()
@@ -783,9 +788,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(),
@@ -812,15 +819,24 @@ def _on_exit() -> None:
 
 
 def _on_signal(signum, frame) -> None:
-    """Signal handler for SIGTERM/SIGINT — clean shutdown."""
+    """Signal handler for SIGTERM/SIGINT — graceful shutdown.
+
+    CRITICAL: Do NOT call sys.exit() here. sys.exit() inside a signal handler
+    can corrupt the asyncio event loop (raises SystemExit mid-await), which
+    crashes FastMCP's stdio transport. Instead, just log + release lease and
+    let the normal shutdown path handle process exit.
+    """
     sig_name = signal.Signals(signum).name if hasattr(signal, 'Signals') else str(signum)
+    _mc_log(f"Received {sig_name} — releasing lease", "warn")
     _log_crash_to_db("signal", f"Received {sig_name}")
     _release_lease()
-    sys.exit(128 + signum)
+    # Do NOT sys.exit() — let FastMCP's event loop shut down cleanly.
+    # The process will exit naturally when the event loop finishes.
 
 
 atexit.register(_on_exit)
 signal.signal(signal.SIGTERM, _on_signal)
+signal.signal(signal.SIGINT, _on_signal)
 
 
 # ============================================================
@@ -1462,9 +1478,9 @@ try:
         elif isinstance(_ls_val, str):
             _LAST_SEEN_TS = _ls_val
         if _LAST_SEEN_TS:
-            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", "warn")
+            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", file=sys.stderr)
 except Exception as _e:
-    print(f"[meshcode] Could not restore last_seen: {_e}", "warn")
+    print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
 
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
@@ -1615,6 +1631,13 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
                     except Exception:
                         pass
         return result
+    except (asyncio.CancelledError, KeyboardInterrupt, SystemExit):
+        # User pressed ESC or Claude Code cancelled the tool call.
+        # Return a clean dict instead of propagating — this prevents
+        # FastMCP/anyio event loop corruption and keeps the MCP server alive.
+        _mc_log("meshcode_wait cancelled by client (ESC) — returning cleanly", "warn")
+        _set_state("online", "interrupted")
+        return {"cancelled": True, "reason": "Tool call cancelled by user"}
     finally:
         _IN_WAIT = False
 
@@ -2624,7 +2647,7 @@ def _auto_update() -> None:
         return
 
     # 3. Install the new version (blocking, 60s timeout)
-    print(f"[meshcode] Updating {current} → {latest}...", "warn")
+    print(f"[meshcode] Updating {current} → {latest}...", file=sys.stderr)
     try:
         result = subprocess.run(
             [sys.executable, "-m", "pip", "install", "--upgrade",
@@ -2644,11 +2667,11 @@ def _auto_update() -> None:
     # 4. In MCP mode, NEVER re-exec — it kills the stdio pipe to Claude Code.
     #    The new version will load on the next clean boot.
     if os.environ.get("MESHCODE_MCP_SERVE") == "1":
-        print(f"[meshcode] Updated {current} → {latest}. Will load on next boot (MCP mode — cannot restart).", "warn")
+        print(f"[meshcode] Updated {current} → {latest}. Will load on next boot (MCP mode — cannot restart).", file=sys.stderr)
         return
 
     # CLI mode: safe to re-exec
-    print(f"[meshcode] Updated to {latest}, restarting...", "warn")
+    print(f"[meshcode] Updated to {latest}, restarting...", file=sys.stderr)
     os.environ["MESHCODE_UPDATED"] = "1"
     try:
         os.execv(sys.executable, [sys.executable] + sys.argv)
@@ -2683,6 +2706,6 @@ def run_server():
         import traceback as _tb
         tb_str = _tb.format_exc()
         _log_crash_to_db("unhandled_exception", f"{type(e).__name__}: {e}\n{tb_str}")
-        print(f"[meshcode-mcp] FATAL: {e}", "warn")
-        print(f"[meshcode-mcp] Stack trace logged to mc_agent_crash_logs", "warn")
+        print(f"[meshcode-mcp] FATAL: {e}", file=sys.stderr)
+        print(f"[meshcode-mcp] Stack trace logged to mc_agent_crash_logs", file=sys.stderr)
         sys.exit(1)

{meshcode-2.10.17 → meshcode-2.10.19}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.17 → meshcode-2.10.19}/pyproject.toml

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