meshcode 2.11.143__tar.gz → 2.11.145__tar.gz

{meshcode-2.11.143 → meshcode-2.11.145}/PKG-INFO

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

{meshcode-2.11.143 → meshcode-2.11.145}/meshcode/__init__.py

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

{meshcode-2.11.143 → meshcode-2.11.145}/meshcode/hostd.py

@@ -148,13 +148,31 @@ def _maybe_self_restart_on_version_drift() -> None:
     if _has_supervisor():
         _log("supervisor present -> clean exit; launchd/systemd/schtasks relaunches on new code")
         os._exit(0)
-    # No supervisor (e.g. dev foreground run): execv is the only in-place restart. If it's blocked,
-    # do NOT self-destruct (nothing would relaunch us) — stay on old code, retry after the guard window.
+    # No supervisor (e.g. dev foreground run / sandboxed Mac terminal):
+    # try execv first (fastest, in-place); if blocked (macOS sandbox), spawn a
+    # DETACHED hostd on the new wheel and exit. The new process inherits nothing
+    # from us — clean slate on the on-disk version.
     try:
         os.execv(sys.executable, [sys.executable, "-m", "meshcode"] + sys.argv[1:])
     except Exception as e:
-        _log(f"WARN: no supervisor + execv failed ({e}); staying on {_RUNNING_VERSION}, retry after guard window")
-        return
+        _log(f"execv blocked ({e}); attempting detached self-relaunch via subprocess")
+        try:
+            argv = _hostd_run_argv()
+            if sys.platform == "win32":
+                # DETACHED_PROCESS: no console inheritance, survives our exit.
+                subprocess.Popen(argv, creationflags=subprocess.DETACHED_PROCESS,
+                                 close_fds=True, stdin=subprocess.DEVNULL,
+                                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            else:
+                subprocess.Popen(argv, start_new_session=True,
+                                 close_fds=True, stdin=subprocess.DEVNULL,
+                                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            _log(f"detached hostd spawned ({' '.join(argv)}); exiting old ({_RUNNING_VERSION})")
+            os._exit(0)
+        except Exception as e2:
+            _log(f"WARN: no supervisor + execv failed + detached spawn failed ({e2}); "
+                 f"staying on {_RUNNING_VERSION}, retry after guard window")
+            return
 
 STATE_DIR = Path.home() / ".meshcode"
 HOST_ID_PATH = STATE_DIR / "host_id"
@@ -2243,8 +2261,6 @@ def _do_reap(api_key: str, host_id: str) -> int:
     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:
@@ -2332,6 +2348,62 @@ def _do_reap(api_key: str, host_id: str) -> int:
         elif now - float(first) >= _REAP_ORPHAN_GRACE_SEC:
             n += _reap(target, pid, f"deleted-agent orphan; alive {int(now-float(first))}s after roster removal")
             seen.pop(target, None)
+    # (D) STALE-ENV SERVE ORPHAN (version-split fix): an MCP serve process whose interpreter
+    # lives in ~/.meshcode/envs/<old_version>/ while the active installed version is different.
+    # These are leftovers from a version split: the agent relaunched on the new env but the old
+    # serve (child of the old claude session) keeps running, potentially with stale bindings.
+    # Reap them. DRY-RUN gated like everything else.
+    # Cross-platform: posix = .../envs/<ver>/bin/python3, win = ...\envs\<ver>\Scripts\python.exe.
+    # Use os.path.normcase for case-insensitive matching on Windows.
+    try:
+        import importlib.metadata as _ilmd
+        _active_ver = _ilmd.version("meshcode")
+    except Exception:
+        _active_ver = None
+    if _active_ver:
+        _envs_prefix = os.path.normcase(str(STATE_DIR / "envs"))
+        ps = _psutil()
+        if ps:
+            try:
+                for p in ps.process_iter():
+                    try:
+                        cl = " ".join(p.cmdline() or [])
+                        if "meshcode" not in cl or "serve" not in cl or "meshcode_mcp" not in cl:
+                            continue
+                        if p.pid == _own_pid():
+                            continue
+                        # Check if the interpreter (argv[0]) is from an old env
+                        _argv = p.cmdline() or []
+                        if not _argv:
+                            continue
+                        _interp = os.path.normcase(_argv[0])
+                        if _envs_prefix not in _interp:
+                            continue  # not running from a versioned env — skip (e.g. anaconda)
+                        # Extract version from path (separator-agnostic):
+                        # posix: .../envs/2.11.140/bin/python3
+                        # win:   ...\envs\2.11.140\Scripts\python.exe
+                        _env_ver = None
+                        try:
+                            _rest = _interp[len(_envs_prefix):]
+                            # Strip leading separators (/ or \)
+                            _rest = _rest.lstrip("/").lstrip("\\")
+                            # Split on either separator to get the version component
+                            import re as _re
+                            _parts = _re.split(r"[/\\]", _rest)
+                            _env_ver = _parts[0] if _parts and _parts[0] else None
+                        except Exception:
+                            pass
+                        if _env_ver and _env_ver != _active_ver:
+                            _env_info = p.environ() or {}
+                            _s_agent = _env_info.get("MESHCODE_AGENT", "?")
+                            _s_proj = _env_info.get("MESHCODE_PROJECT", "?")
+                            _s_target = f"{_s_proj}/{_s_agent}"
+                            n += _reap(_s_target, p.pid,
+                                       f"stale-env serve: interp={_env_ver}, active={_active_ver}")
+                    except Exception:
+                        continue
+            except Exception:
+                pass
     # prune grace clocks only for targets that are BOTH gone from the roster AND have no alive recorded PID
     for t in list(seen.keys()):
         if t not in live_targets and not _alive(pids.get(t)):

{meshcode-2.11.143 → meshcode-2.11.145}/meshcode/run_agent.py

@@ -1257,8 +1257,17 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
                        'chief', 'captain', 'boss', 'head agent')
         is_cmd = any(k in _leader_haystack for k in _LEADER_KW)
         agent_stats = _fetch_agent_stats(agent, resolved_project)
+        # Banner must show the version the agent will ACTUALLY run — the
+        # boot-env target resolved by ensure_boot_env() above (always-latest),
+        # NOT the launcher's own installed __version__. The launcher's global
+        # install can lag (its self-update is non-blocking → one-launch
+        # behind), which made the banner read e.g. v2.11.140 while the agent
+        # actually booted on .143 (Samuel 2026-06-17). _boot_env_ver is None on
+        # offline / dry-run / editable installs → fall back to the launcher
+        # version so the banner never goes blank.
+        _banner_version = _boot_env_ver or cli_version
         print(render_welcome(
-            agent, resolved_project, ascii_art, cli_version,
+            agent, resolved_project, ascii_art, _banner_version,
             is_commander=is_cmd, role=agent_role, stats=agent_stats,
             profile_color=profile_color,
             mascot_config=mascot_cfg,

{meshcode-2.11.143 → meshcode-2.11.145}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.143 → meshcode-2.11.145}/pyproject.toml

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

{meshcode-2.11.143 → meshcode-2.11.145}/tests/test_hostd_zombie_sessions.py

@@ -20,6 +20,7 @@ Field data behind the fix: 14 live sessions for 5 agents (up to 3 per agent),
 each splitting the inbox -> 'non-responsive with a fresh heartbeat'.
 """
 import os
+import subprocess
 import unittest
 from unittest import mock
 
@@ -768,5 +769,287 @@ class RpcErrorBodyTests(unittest.TestCase):
         self.assertIn("host_id", joined)
 
 
+class SelfRelaunchDetachedTests(unittest.TestCase):
+    """Fix #1: when no supervisor and execv is blocked, hostd spawns a detached
+    process on the new wheel and exits, instead of staying on old code forever."""
+
+    def setUp(self):
+        self.logs = []
+        self._orig_version = hostd._RUNNING_VERSION
+        self._orig_guard_logged = hostd._REEXEC_GUARD_LOGGED
+
+    def tearDown(self):
+        hostd._RUNNING_VERSION = self._orig_version
+        hostd._REEXEC_GUARD_LOGGED = self._orig_guard_logged
+
+    def test_detached_spawn_on_execv_blocked(self):
+        """execv raises -> subprocess.Popen detached -> os._exit(0)."""
+        hostd._RUNNING_VERSION = "2.11.140"
+        popen_calls = []
+
+        def fake_popen(argv, **kw):
+            popen_calls.append((argv, kw))
+            return mock.Mock()
+
+        with mock.patch.object(hostd, "_log", self.logs.append), \
+             mock.patch.object(hostd, "_load_state", lambda: {}), \
+             mock.patch.object(hostd, "_save_state", lambda st: None), \
+             mock.patch.object(hostd, "_has_supervisor", lambda: False), \
+             mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch("os.execv", side_effect=OSError("blocked")), \
+             mock.patch("subprocess.Popen", fake_popen), \
+             self.assertRaises(SystemExit):
+            # os._exit raises SystemExit in test (mock it to raise)
+            with mock.patch("os._exit", side_effect=SystemExit(0)):
+                hostd._maybe_self_restart_on_version_drift()
+
+        self.assertEqual(len(popen_calls), 1, "should have spawned exactly one detached process")
+        argv = popen_calls[0][0]
+        self.assertIn("hostd", " ".join(argv), "detached process must run hostd")
+        kw = popen_calls[0][1]
+        self.assertTrue(kw.get("start_new_session") or kw.get("creationflags"),
+                        "must be detached (start_new_session or DETACHED_PROCESS)")
+        joined = "\n".join(self.logs)
+        self.assertIn("detached hostd spawned", joined)
+
+    def test_stays_on_old_if_both_fail(self):
+        """execv fails + Popen fails -> stay on old code, no exit."""
+        hostd._RUNNING_VERSION = "2.11.140"
+
+        with mock.patch.object(hostd, "_log", self.logs.append), \
+             mock.patch.object(hostd, "_load_state", lambda: {}), \
+             mock.patch.object(hostd, "_save_state", lambda st: None), \
+             mock.patch.object(hostd, "_has_supervisor", lambda: False), \
+             mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch("os.execv", side_effect=OSError("blocked")), \
+             mock.patch("subprocess.Popen", side_effect=OSError("popen failed")):
+            hostd._maybe_self_restart_on_version_drift()  # should return, NOT exit
+
+        joined = "\n".join(self.logs)
+        self.assertIn("detached spawn failed", joined)
+        self.assertIn("staying on 2.11.140", joined)
+
+    def test_detached_spawn_win32(self):
+        """On Windows, uses DETACHED_PROCESS creationflags."""
+        hostd._RUNNING_VERSION = "2.11.140"
+        popen_calls = []
+        _DETACHED = 0x00000008  # subprocess.DETACHED_PROCESS value on Windows
+
+        def fake_popen(argv, **kw):
+            popen_calls.append((argv, kw))
+            return mock.Mock()
+
+        with mock.patch.object(hostd, "_log", self.logs.append), \
+             mock.patch.object(hostd, "_load_state", lambda: {}), \
+             mock.patch.object(hostd, "_save_state", lambda st: None), \
+             mock.patch.object(hostd, "_has_supervisor", lambda: False), \
+             mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch("os.execv", side_effect=OSError("blocked")), \
+             mock.patch("subprocess.Popen", fake_popen), \
+             mock.patch.object(hostd.sys, "platform", "win32"), \
+             mock.patch.object(hostd.subprocess, "DETACHED_PROCESS", _DETACHED, create=True), \
+             mock.patch("os._exit", side_effect=SystemExit(0)), \
+             self.assertRaises(SystemExit):
+            hostd._maybe_self_restart_on_version_drift()
+
+        self.assertEqual(len(popen_calls), 1)
+        kw = popen_calls[0][1]
+        self.assertIn("creationflags", kw, "Windows must use creationflags")
+        self.assertEqual(kw["creationflags"], _DETACHED)
+
+    def test_supervisor_path_unchanged(self):
+        """With a supervisor present, behavior is unchanged: os._exit(0)."""
+        hostd._RUNNING_VERSION = "2.11.140"
+
+        with mock.patch.object(hostd, "_log", self.logs.append), \
+             mock.patch.object(hostd, "_load_state", lambda: {}), \
+             mock.patch.object(hostd, "_save_state", lambda st: None), \
+             mock.patch.object(hostd, "_has_supervisor", lambda: True), \
+             mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch("os._exit", side_effect=SystemExit(0)), \
+             self.assertRaises(SystemExit):
+            hostd._maybe_self_restart_on_version_drift()
+
+        joined = "\n".join(self.logs)
+        self.assertIn("supervisor present", joined)
+
+
+class StaleEnvServeReaperTests(ZombieFixBase):
+    """Fix #2: _do_reap case (D) kills MCP serve processes running from an old
+    env (e.g. ~/.meshcode/envs/2.11.140/) when the active version is newer."""
+
+    def setUp(self):
+        super().setUp()
+        # Clear the per-sweep TTL cache so each test gets a fresh RPC call
+        hostd._HOST_CFG_CACHE.update({"key": None, "at": 0.0, "cfg": None})
+
+    def _add_serve_proc(self, pid, version, agent="backend", project="self-improve"):
+        """Add a fake MCP serve process with interpreter from envs/<version>/."""
+        interp = f"/Users/test/.meshcode/envs/{version}/bin/python3"
+        self.ps.add(pid, 1,
+                    f"{interp} -m meshcode.meshcode_mcp serve",
+                    name="python3",
+                    env={"MESHCODE_PROJECT": project, "MESHCODE_AGENT": agent})
+
+    def test_reaps_old_env_serve(self):
+        """A serve running from envs/2.11.140 is reaped when active is 2.11.144."""
+        self.add_hostd()
+        self._add_serve_proc(200, "2.11.140")
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        fake_state_dir = pathlib.PurePosixPath("/Users/test/.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir):
+            hostd._do_reap("key", "host1")
+
+        # _REAP_DRYRUN is True, so it should LOG but not kill
+        joined = "\n".join(self.logs)
+        self.assertIn("stale-env serve", joined)
+        self.assertIn("2.11.140", joined)
+        self.assertIn("2.11.144", joined)
+
+    def test_does_not_reap_active_env_serve(self):
+        """A serve running from the ACTIVE env version is NOT reaped."""
+        self.add_hostd()
+        self._add_serve_proc(200, "2.11.144")
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        fake_state_dir = pathlib.PurePosixPath("/Users/test/.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir):
+            hostd._do_reap("key", "host1")
+
+        joined = "\n".join(self.logs)
+        self.assertNotIn("stale-env serve", joined,
+                         "active-version serve must NOT be flagged for reap")
+
+    def test_does_not_reap_non_env_serve(self):
+        """A serve running from anaconda (not envs/) is NOT reaped."""
+        self.add_hostd()
+        self.ps.add(200, 1,
+                    "/opt/anaconda3/bin/python3 -m meshcode.meshcode_mcp serve",
+                    name="python3",
+                    env={"MESHCODE_PROJECT": "self-improve", "MESHCODE_AGENT": "backend"})
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        fake_state_dir = pathlib.PurePosixPath("/Users/test/.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir):
+            hostd._do_reap("key", "host1")
+
+        joined = "\n".join(self.logs)
+        self.assertNotIn("stale-env serve", joined,
+                         "non-env interpreter must NOT be flagged")
+
+    def test_reaps_old_env_serve_windows_path(self):
+        """Windows-style path: envs\\2.11.140\\Scripts\\python.exe is reaped."""
+        self.add_hostd()
+        win_interp = "C:\\Users\\Usuario\\.meshcode\\envs\\2.11.140\\Scripts\\python.exe"
+        self.ps.add(200, 1,
+                    f"{win_interp} -m meshcode.meshcode_mcp serve",
+                    name="python.exe",
+                    env={"MESHCODE_PROJECT": "mesh-core", "MESHCODE_AGENT": "qa"})
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        fake_state_dir = pathlib.PureWindowsPath("C:\\Users\\Usuario\\.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir), \
+             mock.patch("os.path.normcase", side_effect=lambda p: p.lower().replace("/", "\\")):
+            hostd._do_reap("key", "host1")
+
+        joined = "\n".join(self.logs)
+        self.assertIn("stale-env serve", joined)
+        self.assertIn("2.11.140", joined)
+
+    def test_reaps_old_env_serve_windows_case_mismatch(self):
+        """Windows case mismatch: interp uses USUARIO while STATE_DIR has Usuario.
+        os.path.normcase normalizes both to lowercase so the match succeeds."""
+        self.add_hostd()
+        # Interp has UPPERCASE path component — psutil cmdline can return this
+        win_interp = "C:\\Users\\USUARIO\\.meshcode\\envs\\2.11.140\\Scripts\\python.exe"
+        self.ps.add(200, 1,
+                    f"{win_interp} -m meshcode.meshcode_mcp serve",
+                    name="python.exe",
+                    env={"MESHCODE_PROJECT": "mesh-core", "MESHCODE_AGENT": "qa"})
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        # STATE_DIR has different casing (Title case from Path.home())
+        fake_state_dir = pathlib.PureWindowsPath("C:\\Users\\Usuario\\.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir), \
+             mock.patch("os.path.normcase", side_effect=lambda p: p.lower().replace("/", "\\")):
+            hostd._do_reap("key", "host1")
+
+        joined = "\n".join(self.logs)
+        self.assertIn("stale-env serve", joined,
+                       "case mismatch must NOT prevent the match on Windows")
+        self.assertIn("2.11.140", joined)
+
+    def test_does_not_reap_active_env_windows(self):
+        """Windows: serve from ACTIVE version is NOT reaped."""
+        self.add_hostd()
+        win_interp = "C:\\Users\\Usuario\\.meshcode\\envs\\2.11.144\\Scripts\\python.exe"
+        self.ps.add(200, 1,
+                    f"{win_interp} -m meshcode.meshcode_mcp serve",
+                    name="python.exe",
+                    env={"MESHCODE_PROJECT": "mesh-core", "MESHCODE_AGENT": "qa"})
+
+        self.rpc.script("mc_host_config_get", {"ok": True, "agents": []})
+
+        import pathlib
+        fake_state_dir = pathlib.PureWindowsPath("C:\\Users\\Usuario\\.meshcode")
+
+        with mock.patch("importlib.metadata.version", return_value="2.11.144"), \
+             mock.patch.object(hostd, "STATE_DIR", fake_state_dir), \
+             mock.patch("os.path.normcase", side_effect=lambda p: p.lower().replace("/", "\\")):
+            hostd._do_reap("key", "host1")
+
+        joined = "\n".join(self.logs)
+        self.assertNotIn("stale-env serve", joined)
+
+
+class MeshBindingTests(ZombieFixBase):
+    """Fix #3: verify that MCP serve processes bind to the correct meshwork
+    via MESHCODE_PROJECT/MESHCODE_AGENT env vars, and that stale serves
+    from old envs (which may have different bindings) are caught by the reaper."""
+
+    def test_serve_env_binding_correct(self):
+        """A serve process with matching MESHCODE_PROJECT+AGENT is discoverable
+        by _discover_serve_pids_ex with the correct target."""
+        self.add_hostd()
+        self.add_session(100, "self-improve/backend")
+
+        # The serve (pid 103) should be discoverable for self-improve/backend
+        result = hostd._discover_serve_pids_ex("self-improve/backend")
+        self.assertFalse(result.get("errored"))
+        self.assertIn(103, result["pids"])
+
+    def test_serve_env_binding_no_cross_mesh(self):
+        """A serve process bound to mesh-A must NOT be discovered when
+        querying for mesh-B — env-var attribution prevents cross-mesh."""
+        self.add_hostd()
+        self.add_session(100, "self-improve/backend")
+
+        result = hostd._discover_serve_pids_ex("other-mesh/backend")
+        self.assertFalse(result.get("errored"))
+        self.assertNotIn(103, result["pids"],
+                         "serve bound to self-improve must not match other-mesh")
+
+
 if __name__ == "__main__":
     unittest.main()