meshcode 2.11.101__tar.gz → 2.11.103__tar.gz

{meshcode-2.11.101 → meshcode-2.11.103}/PKG-INFO

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

{meshcode-2.11.101 → meshcode-2.11.103}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.11.101"
+__version__ = "2.11.103"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.11.101 → meshcode-2.11.103}/meshcode/hostd.py

@@ -801,6 +801,72 @@ def _do_stops(api_key: str, host_id: str) -> int:
     return n
 
 
+def _do_reap(api_key: str, host_id: str) -> int:
+    """Reaper (38523a98) — kill headless processes that should NOT be running. CONSERVATIVE: a no-op in
+    normal operation. Both cases are protected by _kill_headless_pid's cmdline reuse-guard (final safety):
+      (A) DUP ghosts: an agent with >1 live `meshcode run <target>` process (a double-spawn left ghost
+          terminals — Samuel's 'se traslapan y desconectan otro'). Kill the EXTRAS, KEEP the recorded PID
+          — but ONLY when that recorded PID is itself confirmed ALIVE, so a known-good survivor stays. If
+          the recorded PID is dead we do NOT guess a survivor (leave it to _do_respawns/_do_stops).
+      (B) ORPHAN: a headless agent the owner set to a TERMINAL state (desired_state in stopped/crashed)
+          whose recorded PID is still alive AND heartbeat is stale (>=90s, so NOT a just-recovered agent)
+          — the 'offline but still reading' case. _do_stops (runs first) already kills stopped+FRESH; this
+          catches the stale-but-alive gap + 'crashed'.
+    NEVER reaps: a VISIBLE agent (user owns the window), a FRESH-heartbeat agent (genuinely alive), or a
+    desired_state='running' agent. Returns number of processes killed."""
+    cfg = _rpc("mc_host_config_get", {"p_api_key": api_key, "p_host_id": host_id})
+    if not cfg or not cfg.get("ok"):
+        return 0
+    agents = cfg.get("agents") or []
+    if not agents:
+        return 0
+
+    def _alive(p) -> bool:
+        if not p:
+            return False
+        try:
+            os.kill(int(p), 0)
+            return True
+        except ProcessLookupError:
+            return False
+        except PermissionError:
+            return True  # exists, owned by another uid — treat as alive (don't reap blindly)
+        except Exception:
+            return False
+
+    st = _load_state()
+    pids = st.get("headless_pids") or {}
+    n = 0
+    for a in agents:
+        if not a.get("headless"):
+            continue  # NEVER reap a visible agent — the user closes its window
+        proj, agent = a.get("project_name"), a.get("name")
+        if not proj or not agent:
+            continue
+        target = f"{proj}/{agent}"
+        hb = a.get("heartbeat_age_s")
+        fresh = (hb is not None and hb < 90)        # genuinely alive => never reap
+        keep = pids.get(target)
+        keep_alive = _alive(keep)
+        # (A) DEDUP — only with a CONFIRMED-ALIVE survivor to keep.
+        if keep_alive:
+            discovered = _discover_agent_pids(target)
+            if len(discovered) > 1:
+                for p in discovered:
+                    if p != keep and _kill_headless_pid(target, p):
+                        n += 1
+                        _log(f"REAP-DUP {target}: killed duplicate ghost pid {p} (kept live {keep})")
+        # (B) ORPHAN — owner set it stopped/crashed, it's not a recovered (fresh-hb) agent.
+        if keep_alive and (a.get("desired_state") in ("stopped", "crashed")) and not fresh:
+            if _kill_headless_pid(target, keep):
+                pids.pop(target, None)
+                n += 1
+                _log(f"REAP {target}: killed orphan (desired={a.get('desired_state')}, hb={hb}s) headless pid {keep}")
+    st["headless_pids"] = pids
+    _save_state(st)
+    return n
+
+
 def _do_recycle_enforce(api_key: str, host_id: str) -> int:
     """RECYCLE-MUST-GUARANTEE-RESPAWN (task c0fc5597). An interactive claude (no --print) can't
     self-exit on must_exit=recycle: the model leaves its loop but the process idles + the MCP
@@ -840,6 +906,15 @@ def _do_recycle_enforce(api_key: str, host_id: str) -> int:
                  f"recycled {c.get('recycled_age_s')}s ago, hb {c.get('heartbeat_age_s')}s) "
                  f"-> fast-path respawn will relaunch it.")
             n += 1
+            # mig425 companion (49fd4ebf, anti kill-loop): a 'requested_never_consumed' candidate was
+            # killed for NEVER consuming its recycle (last_recycle_at still NULL). Record the recycle NOW
+            # so the respawn does NOT immediately re-match mig425 branch 2 (which keys on last_recycle_at
+            # IS NULL) -> it would otherwise force-kill the fresh process every sweep forever. Recording
+            # moves it into branch 1's window, which ages out. NO-OP until mig425 lands: mig419 candidates
+            # carry no enforce_reason, so this is skipped (the consumed-still-alive path already records).
+            if c.get("enforce_reason") == "requested_never_consumed":
+                _rpc("mc_record_recycle",
+                     {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
     st["headless_pids"] = pids
     _save_state(st)
     return n
@@ -1387,10 +1462,11 @@ def cmd_hostd(args: list) -> int:
                         recycled = _do_recycles(api_key, host_id)
                         ver_recycled = _do_version_recycles(api_key, host_id)
                         stopped = _do_stops(api_key, host_id)
+                        reaped = _do_reap(api_key, host_id)  # 38523a98: kill ghosts/dup-PIDs/crashed-orphans
                         _gc_headless_pids()  # cb90b058: drop dead PIDs (stale entry can't mask a live agent)
                         _up = int(time.monotonic() - _spawn_mono)
-                        if relaunched or recycled or ver_recycled or stopped or enforced:
-                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {enforced} recycle-enforced")
+                        if relaunched or recycled or ver_recycled or stopped or enforced or reaped:
+                            _log(f"sweep done (uptime={_up}s) — {relaunched} respawned, {recycled} recycled, {ver_recycled} version-recycled, {stopped} stopped, {enforced} recycle-enforced, {reaped} reaped")
                         elif time.monotonic() - _last_alive_log >= 60:
                             _log(f"alive — uptime={_up}s")
                             _last_alive_log = time.monotonic()

{meshcode-2.11.101 → meshcode-2.11.103}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.101 → meshcode-2.11.103}/pyproject.toml

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