meshcode 2.10.52__tar.gz → 2.10.53__tar.gz

{meshcode-2.10.52 → meshcode-2.10.53}/PKG-INFO

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

{meshcode-2.10.52 → meshcode-2.10.53}/meshcode/__init__.py

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

{meshcode-2.10.52 → meshcode-2.10.53}/meshcode/meshcode_mcp/server.py

@@ -1871,23 +1871,130 @@ _AUTO_SLEEP_THRESHOLD = int(os.environ.get("MESHCODE_AUTO_SLEEP_SECONDS", "600")
 _STAY_AWAKE = False  # Set by meshcode_set_status("online") — prevents auto-sleep
 _LAST_SEEN_TS: Optional[str] = None  # auto-persisted for message dedup
 
-# Hydrate _LAST_SEEN_TS from mesh memory on boot so restarts skip old messages
-try:
-    _ls_result = be.sb_rpc("mc_memory_get", {
-        "p_api_key": _get_api_key(),
-        "p_agent_name": AGENT_NAME,
-        "p_key": "last_seen",
-    })
-    if isinstance(_ls_result, dict) and _ls_result.get("ok"):
-        _ls_val = _ls_result.get("value")
-        if isinstance(_ls_val, dict) and _ls_val.get("_raw"):
-            _LAST_SEEN_TS = str(_ls_val["_raw"])
-        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.", file=sys.stderr)
-except Exception as _e:
-    print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
+# ============================================================
+# Local disk state — survives MCP respawn instantly.
+# 2.10.53 fix for the ESC-kills-MCP friction: when Claude Code closes
+# stdin (ESC, /mcp disconnect), our process exits but Claude Code spawns
+# a fresh subprocess on next interaction. Without disk persistence, the
+# new process must round-trip mesh memory RPC to restore last_seen and
+# starts with an EMPTY dedup cache — 200ms-3s gap during which old
+# messages can be re-delivered to the LLM.
+#
+# With disk persistence, the new process restores state in <5ms and
+# never re-delivers messages it already showed the agent.
+# ============================================================
+def _state_file_path() -> str:
+    """Path to the local state file for this agent."""
+    state_dir = os.path.join(os.path.expanduser("~"), ".meshcode")
+    try:
+        os.makedirs(state_dir, exist_ok=True)
+    except Exception:
+        pass
+    safe = f"state_{PROJECT_NAME}_{AGENT_NAME}.json".replace("/", "_").replace(" ", "_")
+    return os.path.join(state_dir, safe)
+
+
+def _load_state_from_disk() -> Dict[str, Any]:
+    """Load persisted state. Returns empty dict on any failure."""
+    try:
+        path = _state_file_path()
+        if not os.path.exists(path):
+            return {}
+        with open(path, "r") as f:
+            data = json.load(f)
+        if not isinstance(data, dict):
+            return {}
+        return data
+    except Exception:
+        return {}
+
+
+_STATE_SAVE_LOCK = _threading.Lock()
+_STATE_LAST_SAVE_AT = 0.0
+_STATE_SAVE_DEBOUNCE_S = 1.0
+
+
+def _save_state_to_disk(force: bool = False) -> None:
+    """Persist current state to disk. Debounced unless force=True.
+
+    Atomic via .tmp + os.replace to prevent half-written files if SIGKILL
+    arrives mid-write.
+    """
+    global _STATE_LAST_SAVE_AT
+    with _STATE_SAVE_LOCK:
+        now = _time.monotonic()
+        if not force and (now - _STATE_LAST_SAVE_AT) < _STATE_SAVE_DEBOUNCE_S:
+            return
+        _STATE_LAST_SAVE_AT = now
+        try:
+            with _SEEN_LOCK:
+                # Persist last 200 dedup keys (most recent) — bounded so disk
+                # write stays fast even on long-running sessions.
+                seen_keys = list(_SEEN_MSG_ORDER)[-200:]
+            data = {
+                "last_seen": _LAST_SEEN_TS,
+                "seen_keys": seen_keys,
+                "agent": AGENT_NAME,
+                "project": PROJECT_NAME,
+                "saved_at": _time.time(),
+                "instance_id": _INSTANCE_ID if "_INSTANCE_ID" in globals() else None,
+            }
+            path = _state_file_path()
+            tmp = path + ".tmp"
+            with open(tmp, "w") as f:
+                json.dump(data, f)
+            os.replace(tmp, path)
+        except Exception:
+            pass  # Never let state save failure break tool flow
+
+
+def _save_state_async() -> None:
+    """Schedule a debounced background save. Safe to call from any thread."""
+    try:
+        _threading.Thread(
+            target=_save_state_to_disk,
+            daemon=True,
+            name="meshcode-state-save",
+        ).start()
+    except Exception:
+        pass
+
+
+# Hydrate _LAST_SEEN_TS — local disk first (instant), mesh memory fallback.
+_disk_state = _load_state_from_disk()
+if isinstance(_disk_state.get("last_seen"), str) and _disk_state["last_seen"]:
+    _LAST_SEEN_TS = str(_disk_state["last_seen"])
+    print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from local disk", file=sys.stderr)
+    # Pre-populate dedup cache so we don't re-deliver messages already shown
+    # to the LLM in the previous session.
+    _persisted_keys = _disk_state.get("seen_keys", [])
+    if isinstance(_persisted_keys, list) and _persisted_keys:
+        with _SEEN_LOCK:
+            _now_mono = _time.monotonic()
+            for _k in _persisted_keys:
+                if isinstance(_k, str) and _k not in _SEEN_MSG_IDS:
+                    _SEEN_MSG_IDS[_k] = _now_mono
+                    _SEEN_MSG_ORDER.append(_k)
+        print(f"[meshcode] Restored {len(_persisted_keys)} dedup keys from local disk", file=sys.stderr)
+
+# Mesh-memory hydration — only if disk had nothing.
+if _LAST_SEEN_TS is None:
+    try:
+        _ls_result = be.sb_rpc("mc_memory_get", {
+            "p_api_key": _get_api_key(),
+            "p_agent_name": AGENT_NAME,
+            "p_key": "last_seen",
+        })
+        if isinstance(_ls_result, dict) and _ls_result.get("ok"):
+            _ls_val = _ls_result.get("value")
+            if isinstance(_ls_val, dict) and _ls_val.get("_raw"):
+                _LAST_SEEN_TS = str(_ls_val["_raw"])
+            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.", file=sys.stderr)
+    except Exception as _e:
+        print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
 
 # Fallback: if last_seen is still None, default to now minus 5 minutes
 # to avoid flooding agent with ancient messages on cold boot.
@@ -2069,6 +2176,7 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 latest_ts = max((m.get("ts", "") for m in msgs), default="")
                 if latest_ts:
                     _LAST_SEEN_TS = latest_ts
+                    _save_state_async()  # 2.10.53: persist to disk for fast respawn
                     try:
                         be.sb_rpc("mc_memory_set", {
                             "p_api_key": _get_api_key(),
@@ -2395,6 +2503,7 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark
         latest_ts = max((str(m.get("ts", "")) for m in deduped), default=None)
         if latest_ts and (not _LAST_SEEN_TS or latest_ts > _LAST_SEEN_TS):
             _LAST_SEEN_TS = latest_ts
+        _save_state_async()  # 2.10.53: persist to disk for fast respawn
 
     split = _split_messages(deduped)
     if not include_acks:
@@ -3735,13 +3844,15 @@ def run_server():
     # `mcp.run()` normally, which breaks the loop.
     import time as _time_mod
     _restart_count = 0
-    _clean_return_count = 0
     while True:
         try:
             mcp.run()
         except SystemExit:
             raise
         except BaseException as _e:
+            # Crash path: an exception escaped mcp.run(). Retry the event loop
+            # up to 20 times. This is the path that has saved us from
+            # CancelledError cascades since 2.10.29.
             _restart_count += 1
             try:
                 sys.stderr.write(
@@ -3751,8 +3862,6 @@ def run_server():
                 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")
@@ -3762,29 +3871,36 @@ def run_server():
             _time_mod.sleep(0.3)
             continue
 
-        # mcp.run() returned cleanly (stdin EOF). This can mean:
-        # a) Claude Code intentionally shut us down (process exit)
-        # b) Claude Code closed the pipe temporarily due to ESC/cancel
-        # Instead of exiting immediately, wait briefly and retry — Claude
-        # Code's /mcp reconnect will re-attach stdin within seconds.
-        # Only exit after multiple consecutive clean returns with no
-        # recovery, which means the parent process truly wants us dead.
-        _clean_return_count += 1
-        if _clean_return_count > 5:
-            try:
-                sys.stderr.write("[meshcode-mcp] stdin EOF persisted after 5 retries; exiting\n")
-                sys.stderr.flush()
-            except Exception:
-                pass
-            break
+        # ===== Clean return: stdin EOF =====
+        # Claude Code closed the stdio pipe (ESC, /mcp disconnect, or full
+        # exit). The 2.10.52 "retry mcp.run() 5x with 2s sleep" bandaid was
+        # REVERTED in 2.10.53 — empirically it does not help:
+        #   1. mcp.run() returns immediately on already-closed stdin, so the
+        #      5 retries burn in microseconds, not 10 seconds.
+        #   2. Claude Code's /mcp reconnect spawns a NEW subprocess, it does
+        #      NOT re-attach to the dead-pipe one.
+        #   3. The new subprocess kills us via _kill_stale_mcp_process +
+        #      lockfile SIGKILL — so any "wait for reconnect" logic adds
+        #      zombie-process time that the new spawn has to clean up.
+        #
+        # The correct fix lives in TWO places:
+        #   - Pre-shutdown: persist last_seen + dedup cache to disk so the
+        #     next boot resumes seamlessly (handled here, force=True).
+        #   - Post-respawn: hydrate from disk before mesh memory (handled
+        #     in the _LAST_SEEN_TS section near the top of the module).
+        # Together they collapse the "lost messages on respawn" gap from
+        # 200ms-3s to <5ms.
+        try:
+            _save_state_to_disk(force=True)
+        except Exception:
+            pass
         try:
             sys.stderr.write(
-                f"[meshcode-mcp] mcp.run() returned cleanly (stdin EOF, attempt {_clean_return_count}/5); "
-                f"waiting 2s for Claude Code reconnect...\n"
+                "[meshcode-mcp] stdin EOF — Claude Code closed pipe (ESC, "
+                "/mcp disconnect, or exit). State persisted to disk; next "
+                "MCP spawn will resume seamlessly. Exiting cleanly.\n"
             )
             sys.stderr.flush()
         except Exception:
             pass
-        _time_mod.sleep(2.0)
-        # Reset exception restart count — this is a clean return, not a crash
-        _restart_count = 0
+        break

{meshcode-2.10.52 → meshcode-2.10.53}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.52 → meshcode-2.10.53}/pyproject.toml

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