meshcode 2.10.52__tar.gz → 2.10.54__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.52
+Version: 2.10.54
 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.54}/meshcode/__init__.py

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

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

@@ -721,6 +721,52 @@ def with_working_status(func):
                 # to prevent cascade through FastMCP into the event loop.
                 # Return an error dict instead of propagating BaseException.
                 log.debug(f"[meshcode] tool {name} cancelled by client (ESC)")
+                # 2.10.54 deaf-agent fix: for meshcode_wait specifically, the
+                # inner cancel handler already tries to drain pending messages.
+                # If we still got CancelledError here, the inner drain failed —
+                # do a last-ditch DB read so the LLM sees pending mail instead
+                # of a generic error and goes silent.
+                if name == "meshcode_wait":
+                    try:
+                        _t = asyncio.current_task()
+                        if _t is not None and hasattr(_t, "uncancel"):
+                            _t.uncancel()
+                    except Exception:
+                        pass
+                    try:
+                        _ak = _get_api_key()
+                        if _ak:
+                            _raw = be.read_inbox(
+                                _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_ak
+                            )
+                            if _raw:
+                                _msgs = [
+                                    {
+                                        "from": m["from_agent"],
+                                        "type": m.get("type", "msg"),
+                                        "ts": m.get("created_at"),
+                                        "payload": m.get("payload", {}),
+                                        "id": m.get("id"),
+                                        "parent_id": m.get("parent_msg_id"),
+                                    }
+                                    for m in _raw
+                                ]
+                                _filter_and_mark(_msgs)
+                                _split = _split_messages(_msgs)
+                                if _split["messages"] or _split["done_signals"]:
+                                    log.info(
+                                        f"[meshcode] wrapper-level cancel-drain rescued "
+                                        f"{_split['count']} messages"
+                                    )
+                                    return {
+                                        "got_message": True,
+                                        "cancelled_during_wait": True,
+                                        **_split,
+                                    }
+                    except Exception as _final_err:
+                        log.debug(
+                            f"[meshcode] wrapper cancel-drain failed: {_final_err}"
+                        )
                 return {"error": "cancelled_by_client", "tool": name}
             except Exception as e:
                 if not skip:
@@ -1871,23 +1917,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.
@@ -2013,10 +2166,79 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
             try:
                 result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
             except asyncio.CancelledError:
-                # Safety net: if CancelledError escapes _meshcode_wait_inner
-                # despite the inner shield, catch it here to prevent cascade.
-                log.debug("[meshcode] meshcode_wait outer loop caught CancelledError")
-                result = {"timed_out": True, "reason": "cancelled_by_client"}
+                # 2.10.54 deaf-agent fix: when ESC fires during meshcode_wait,
+                # Python keeps the task in cancelled state — every subsequent
+                # await re-raises CancelledError, even if we caught the first
+                # one. That trapped us in a loop that eventually returned
+                # `{"error": "cancelled_by_client"}` to the LLM, which never
+                # saw the messages that arrived during the cancel window —
+                # they sat in the queue/DB unread (the "deaf agents" bug).
+                #
+                # Fix: uncancel the current task so we can run a final drain
+                # cycle without re-raising. Then aggressively pull from BOTH
+                # the realtime buffer AND the DB and return whatever we find
+                # to the LLM. If nothing is pending, return cancelled-timeout
+                # cleanly so the LLM's wait loop continues normally.
+                log.info("[meshcode] meshcode_wait caught CancelledError — uncancelling + final drain")
+                try:
+                    _t = asyncio.current_task()
+                    if _t is not None and hasattr(_t, "uncancel"):
+                        _t.uncancel()
+                except Exception:
+                    pass
+
+                _final_msgs: List[Dict[str, Any]] = []
+                # 1) Drain realtime buffer (messages received during cancel window)
+                if _REALTIME:
+                    try:
+                        _rt_buf = _REALTIME.drain()
+                        if _rt_buf:
+                            _final_msgs.extend(_rt_buf)
+                    except Exception as _drain_err:
+                        log.debug(f"[meshcode] cancel-drain realtime failed: {_drain_err}")
+                # 2) Pull from DB (catches messages realtime missed)
+                try:
+                    _api_key = _get_api_key()
+                    if _api_key:
+                        _db_unread = be.read_inbox(
+                            _PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_api_key
+                        )
+                        if _db_unread:
+                            _final_msgs.extend([
+                                {
+                                    "from": m["from_agent"],
+                                    "type": m.get("type", "msg"),
+                                    "ts": m.get("created_at"),
+                                    "payload": m.get("payload", {}),
+                                    "id": m.get("id"),
+                                    "parent_id": m.get("parent_msg_id"),
+                                }
+                                for m in _db_unread
+                            ])
+                except Exception as _db_err:
+                    log.debug(f"[meshcode] cancel-drain DB failed: {_db_err}")
+
+                if _final_msgs:
+                    # Dedupe + filter, then return as got_message so the LLM
+                    # processes them instead of seeing a generic cancel error.
+                    _filter_and_mark(_final_msgs)
+                    _split = _split_messages(_final_msgs)
+                    if not include_acks:
+                        _split["acks"] = []
+                    if _split["messages"] or _split["done_signals"]:
+                        log.info(
+                            f"[meshcode] cancel-drain rescued {_split['count']} pending "
+                            f"messages from going deaf"
+                        )
+                        result = {
+                            "got_message": True,
+                            "cancelled_during_wait": True,
+                            **_split,
+                        }
+                    else:
+                        result = {"timed_out": True, "reason": "cancelled_by_client"}
+                else:
+                    result = {"timed_out": True, "reason": "cancelled_by_client"}
 
             if result.get("got_message"):
                 # Real message arrived — return to agent for processing
@@ -2069,6 +2291,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 +2618,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 +3959,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 +3977,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 +3986,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.54}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.10.52
+Version: 2.10.54
 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.54}/pyproject.toml

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