meshcode 2.10.19__tar.gz → 2.10.21__tar.gz

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

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

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

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

{meshcode-2.10.19 → meshcode-2.10.21}/meshcode/meshcode_mcp/server.py

@@ -8,11 +8,9 @@ Run with:
     MESHCODE_PROJECT=my-app MESHCODE_AGENT=backend python -m meshcode_mcp serve
 """
 import asyncio
-import atexit
 import json
 import logging
 import os
-import signal
 import sys
 import hashlib as _hashlib
 import traceback as _traceback
@@ -518,17 +516,16 @@ def _schedule_flip(status: str, task: str = "") -> None:
 
 
 def _set_state(state: str, tool: str = "") -> None:
-    """Update the state machine and broadcast to dashboard. Thread-safe."""
+    """Update the state machine and broadcast to dashboard."""
     global _current_state, _current_tool, _last_tool_at, _working_timer
-    with _flip_lock:
-        # Cancel any pending working→online timer
-        if _working_timer is not None:
-            _working_timer.cancel()
-            _working_timer = None
-        _current_state = state
-        _current_tool = tool
-        if state == "working":
-            _last_tool_at = _time.time()
+    # Cancel any pending working→online timer
+    if _working_timer is not None:
+        _working_timer.cancel()
+        _working_timer = None
+    _current_state = state
+    _current_tool = tool
+    if state == "working":
+        _last_tool_at = _time.time()
     _schedule_flip(state, tool)
 
 
@@ -576,18 +573,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, 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()))
-                # NEVER re-raise — return structured error instead of crashing
-                import traceback as _tb
-                _log_crash_to_db("tool_exception", f"{name}: {type(e).__name__}: {e}\n{_tb.format_exc()[-500:]}")
-                return {"error": f"tool {name} failed: {type(e).__name__}: {e}", "_recovered": True}
+                raise
             finally:
                 if not skip:
                     global _last_tool_at
@@ -608,10 +597,7 @@ def with_working_status(func):
             except Exception as e:
                 if not skip:
                     _auto_learn_error(name, e, list(kwargs.keys()))
-                # NEVER re-raise — return structured error instead of crashing
-                import traceback as _tb
-                _log_crash_to_db("tool_exception", f"{name}: {type(e).__name__}: {e}\n{_tb.format_exc()[-500:]}")
-                return {"error": f"tool {name} failed: {type(e).__name__}: {e}", "_recovered": True}
+                raise
             finally:
                 if not skip:
                     global _last_tool_at
@@ -812,31 +798,13 @@ def _log_crash_to_db(reason: str = "unknown", error_detail: str = "") -> None:
     _mc_log(f" crash logged: {reason}", "warn")
 
 
-def _on_exit() -> None:
-    """atexit handler — release lease and log shutdown."""
-    _log_crash_to_db("process_exit", "atexit handler fired")
-    _release_lease()
-
-
-def _on_signal(signum, frame) -> None:
-    """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()
-    # 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)
+# NOTE: Do NOT install signal handlers (SIGTERM, SIGINT) or atexit hooks here.
+# FastMCP/anyio manages its own event loop and signal handling. Custom signal
+# handlers override Python's default KeyboardInterrupt, preventing anyio from
+# cancelling tasks cleanly. Network calls inside signal/atexit handlers can
+# deadlock or corrupt the event loop. The lease will be released by the
+# lifespan shutdown handler instead.
 
 
 # ============================================================
@@ -1129,12 +1097,11 @@ def _heartbeat_thread_fn():
         try:
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
 
-            # CPU-based status detection — read shared state under lock
+            # CPU-based status detection
             parent_cpu = _get_parent_cpu()
-            with _flip_lock:
-                cur_state = _current_state
-                in_wait = _IN_WAIT
-                idle_secs = _time.time() - _last_tool_at
+            cur_state = _current_state
+            in_wait = _IN_WAIT
+            idle_secs = _time.time() - _last_tool_at
 
             if in_wait:
                 # Actually in meshcode_wait right now — listening for messages
@@ -1631,13 +1598,6 @@ 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
 
@@ -2682,30 +2642,19 @@ def _auto_update() -> None:
 def run_server():
     """Start the MCP server on stdio (default for Claude Code).
 
-    Wraps mcp.run() with crash recovery: if the event loop dies for any
-    reason, log the crash, release the lease, and exit cleanly instead of
-    leaving the agent in a zombie state.
+    IMPORTANT: Do NOT wrap mcp.run() with try/except, signal handlers, or
+    atexit hooks. FastMCP/anyio manages its own event loop lifecycle and
+    signal handling. Any interference (custom SIGINT handler, atexit network
+    calls, catching KeyboardInterrupt) corrupts the event loop and causes
+    the MCP server to crash when Claude Code cancels a tool call (ESC).
     """
     _auto_update()
     print(
         f"[meshcode-mcp] Starting server for {AGENT_NAME}@{PROJECT_NAME}",
         file=sys.stderr,
     )
-    try:
-        # Restore real stdout for FastMCP's JSON-RPC transport.
-        # sys.stdout was redirected to stderr at module load to prevent
-        # accidental stdout writes from corrupting the MCP protocol.
-        sys.stdout = _REAL_STDOUT
-        mcp.run()
-    except KeyboardInterrupt:
-        _log_crash_to_db("keyboard_interrupt", "User stopped the agent")
-    except SystemExit as e:
-        _log_crash_to_db("system_exit", f"exit code: {e.code}")
-        raise  # re-raise so the process exits with the correct code
-    except Exception as e:
-        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}", file=sys.stderr)
-        print(f"[meshcode-mcp] Stack trace logged to mc_agent_crash_logs", file=sys.stderr)
-        sys.exit(1)
+    # Restore real stdout for FastMCP's JSON-RPC transport.
+    # sys.stdout was redirected to stderr at module load to prevent
+    # accidental stdout writes from corrupting the MCP protocol.
+    sys.stdout = _REAL_STDOUT
+    mcp.run()

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

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

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

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