meshcode 2.11.100__tar.gz → 2.11.102__tar.gz

{meshcode-2.11.100 → meshcode-2.11.102}/PKG-INFO

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

{meshcode-2.11.100 → meshcode-2.11.102}/meshcode/__init__.py

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

{meshcode-2.11.100 → meshcode-2.11.102}/meshcode/hostd.py

@@ -458,6 +458,10 @@ def _spawn_agent(project: str, agent: str, headless: bool = False) -> bool:
         return False
 
 
+# 38523a98: max terminals opened per host per sweep (anti boot-storm; excess defers to next sweep).
+_MAX_SPAWNS_PER_SWEEP = 3
+
+
 def _do_respawns(api_key: str, host_id: str) -> int:
     """One respawn sweep. Returns number relaunched."""
     res = _rpc("mc_agents_needing_respawn",
@@ -466,6 +470,14 @@ def _do_respawns(api_key: str, host_id: str) -> int:
         return 0
     n = 0
     for c in res.get("candidates", []):
+        # 38523a98 GLOBAL spawn cap: never open more than _MAX_SPAWNS_PER_SWEEP terminals in one ~10s
+        # sweep (canonical model: 2-3, not 7-at-once). Excess agents respawn on the NEXT sweep — smooths
+        # the boot-storm Samuel hit (a fresh host with the whole fleet stale spawned every agent at once).
+        # Per-target rate-limit + circuit-breaker still apply below; this is the cross-agent backstop.
+        if n >= _MAX_SPAWNS_PER_SWEEP:
+            _log(f"GLOBAL spawn cap {_MAX_SPAWNS_PER_SWEEP}/sweep hit — deferring remaining respawn(s) "
+                 f"to next sweep (anti boot-storm)")
+            break
         proj, agent = c.get("project_name"), c.get("agent")
         if not proj or not agent:
             continue
@@ -789,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
@@ -1375,10 +1453,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.100 → meshcode-2.11.102}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.100 → meshcode-2.11.102}/pyproject.toml

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