meshcode 2.10.29__tar.gz → 2.10.31__tar.gz

{meshcode-2.10.29 → meshcode-2.10.31}/PKG-INFO

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

{meshcode-2.10.29 → meshcode-2.10.31}/meshcode/__init__.py

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

{meshcode-2.10.29 → meshcode-2.10.31}/meshcode/meshcode_mcp/server.py

@@ -1217,40 +1217,53 @@ async def lifespan(_app):
     try:
         yield {"realtime": _REALTIME}
     finally:
-        _record_event_bg("shutdown", {"agent": AGENT_NAME, "session_id": _SESSION_ID})
-        # Auto-save session summary to agent memory before shutdown
+        # 2.10.31: minimal-risk shutdown. The previous body did network I/O,
+        # a 5-second thread join, and an `await _REALTIME.stop()` inside the
+        # lifespan's finally. Under Claude Code 2.1.111 ESC, that cancellation
+        # path cascades through the awaits and unwinds the asyncio loop,
+        # killing the subprocess. A bare FastMCP (no lifespan) in the same
+        # bucket survives. To match that behavior without losing Realtime on
+        # startup, we keep the startup logic and make the shutdown strictly
+        # non-blocking, non-awaiting, non-raising. Daemon threads / realtime
+        # socket die with the process; the lease expires on heartbeat timeout.
         try:
-            import datetime as _dt
-            api_key = _get_api_key()
-            if api_key:
-                be.sb_rpc("mc_memory_set", {
-                    "p_api_key": api_key,
-                    "p_project_id": _PROJECT_ID,
-                    "p_agent_name": AGENT_NAME,
-                    "p_key": f"session_retro_{_dt.date.today().isoformat()}",
-                    "p_value": {
-                        "session_id": _SESSION_ID,
-                        "agent": AGENT_NAME,
-                        "shutdown_at": _dt.datetime.utcnow().isoformat(),
-                        "instance_id": _INSTANCE_ID,
-                        "auto_generated": True,
-                    },
-                })
+            _heartbeat_stop.set()
+        except Exception:
+            pass
+        try:
+            _record_event_bg("shutdown", {"agent": AGENT_NAME, "session_id": _SESSION_ID})
         except Exception:
-            pass  # Never block shutdown
-        log.info("lifespan shutdown — releasing lease + stopping heartbeat + realtime")
-        # Release lease FIRST — before stopping heartbeat thread.
-        # If heartbeat join times out, the lease is already released so
-        # the agent won't block reconnection.
+            pass
+        # Fire-and-forget best-effort cleanup in a daemon thread so we do not
+        # block, do not await, and any failure is confined to the thread.
+        def _bg_cleanup():
+            try:
+                import datetime as _dt
+                api_key = _get_api_key()
+                if api_key:
+                    be.sb_rpc("mc_memory_set", {
+                        "p_api_key": api_key,
+                        "p_project_id": _PROJECT_ID,
+                        "p_agent_name": AGENT_NAME,
+                        "p_key": f"session_retro_{_dt.date.today().isoformat()}",
+                        "p_value": {
+                            "session_id": _SESSION_ID,
+                            "agent": AGENT_NAME,
+                            "shutdown_at": _dt.datetime.utcnow().isoformat(),
+                            "instance_id": _INSTANCE_ID,
+                            "auto_generated": True,
+                        },
+                    })
+            except Exception:
+                pass
+            try:
+                _release_lease()
+            except Exception:
+                pass
         try:
-            _release_lease()
-        except Exception as _e:
-            log.warning(f"could not release lease: {_e}")
-        _heartbeat_stop.set()
-        hb_thread.join(timeout=5)
-        if hb_thread.is_alive():
-            log.warning("heartbeat thread did not stop within 5s — lease already released")
-        await _REALTIME.stop()
+            _threading.Thread(target=_bg_cleanup, daemon=True, name="meshcode-shutdown-cleanup").start()
+        except Exception:
+            pass
 
 
 # ============================================================
@@ -2852,4 +2865,48 @@ def run_server():
             # Non-main thread or Windows doesn't expose the signal — harmless.
             pass
 
-    mcp.run()
+    # 2.10.29 field test proved: a bare FastMCP (naive.py / armored.py) loaded
+    # via `claude mcp add` survives ESC, but meshcode does not — even after
+    # moving out of the "Built-in" bucket to "Project". The remaining delta
+    # between meshcode and the naked repro is our lifespan handler: it does
+    # network I/O (release_lease, memory_set), blocking thread joins, and an
+    # await on Realtime.stop() in its `finally`. When ESC cancels the in-flight
+    # tool, CancelledError cascades into those shutdown steps, one of them
+    # raises, and the event loop unwinds — process exits.
+    #
+    # Short of rewriting the lifespan (which we will), the pragmatic safety
+    # net is to treat `mcp.run()` returning unexpectedly as an event loop
+    # casualty and spin up a fresh one. FastMCP registers tools at import
+    # time on the module-level `mcp` object, so the restart re-uses them;
+    # only the lifespan re-runs. `SystemExit` is let through so `sys.exit`
+    # from config-validation paths still works. stdin EOF returns from
+    # `mcp.run()` normally, which breaks the loop.
+    import time as _time_mod
+    _restart_count = 0
+    while True:
+        try:
+            mcp.run()
+        except SystemExit:
+            raise
+        except BaseException as _e:
+            _restart_count += 1
+            try:
+                sys.stderr.write(
+                    f"[meshcode-mcp] mcp.run() raised {type(_e).__name__}: {_e} "
+                    f"(restart #{_restart_count}); re-entering event loop in 0.3s\n"
+                )
+                sys.stderr.flush()
+            except Exception:
+                pass
+            # If we're restarting more than a few times a second, something
+            # is wrong (config error, unrecoverable import). Bail.
+            if _restart_count > 20:
+                try:
+                    sys.stderr.write("[meshcode-mcp] too many restarts; exiting\n")
+                except Exception:
+                    pass
+                break
+            _time_mod.sleep(0.3)
+            continue
+        # Clean return = stdin EOF = Claude Code closed the pipe = real shutdown
+        break

{meshcode-2.10.29 → meshcode-2.10.31}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.29 → meshcode-2.10.31}/pyproject.toml

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