meshcode 2.11.8__tar.gz → 2.11.9__tar.gz

{meshcode-2.11.8 → meshcode-2.11.9}/PKG-INFO

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

{meshcode-2.11.8 → meshcode-2.11.9}/meshcode/__init__.py

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

{meshcode-2.11.8 → meshcode-2.11.9}/meshcode/comms_v4.py

@@ -3397,11 +3397,16 @@ if __name__ == "__main__":
             from meshcode.preferences import load_prefs, save_prefs
             if len(sys.argv) > 3:
                 ver = sys.argv[3].strip()
-                if ver in ("reset", "unpin", "latest"):
+                if ver in ("reset", "unpin"):
                     prefs = load_prefs()
                     prefs.pop("claude_version", None)
                     save_prefs(prefs)
-                    print("[meshcode] Claude Code version pin removed — will use installed version")
+                    print("[meshcode] Claude Code version pin removed — will use default ESC-safe pin")
+                elif ver in ("latest", "none", "skip"):
+                    prefs = load_prefs()
+                    prefs["claude_version"] = ver
+                    save_prefs(prefs)
+                    print(f"[meshcode] Claude Code version pinning disabled ({ver}) — using installed version")
                 else:
                     prefs = load_prefs()
                     prefs["claude_version"] = ver

{meshcode-2.11.8 → meshcode-2.11.9}/meshcode/meshcode_mcp/server.py

@@ -1699,61 +1699,109 @@ def _snapshot_pkg_mtimes():
 _PKG_PY_MTIMES = _snapshot_pkg_mtimes()
 log.info(f"install-guard: snapshotted {len(_PKG_PY_MTIMES)} *.py mtimes under {_PKG_DIR}")
 
+_INSTALL_GUARD_MODE = os.environ.get("MESHCODE_INSTALL_GUARD", "warn").lower()
+if _INSTALL_GUARD_MODE not in ("execv", "warn", "off"):
+    log.warning(f"MESHCODE_INSTALL_GUARD={_INSTALL_GUARD_MODE!r} invalid; falling back to 'warn'")
+    _INSTALL_GUARD_MODE = "warn"
+_INSTALL_GUARD_STALE_NOTIFIED = False
+
+
+def _is_agent_active() -> bool:
+    """True if agent should NOT be execv-restarted right now."""
+    if os.environ.get("MESHCODE_AGENT_ACTIVE", "").lower() in ("1", "true", "yes"):
+        return True
+    if _IN_WAIT:
+        return True
+    try:
+        if (_time.time() - _last_tool_at) < 300:
+            return True
+    except Exception:
+        pass
+    return False
+
 
 def _install_guard_check() -> None:
-    """Heartbeat-tick scan: if any *.py under the meshcode pkg path has
-    a fresher mtime than recorded at boot, the env was reinstalled while
-    the process is alive (class feedback_pip_install_into_live_mcp_env_self_kill).
-    The running image holds stale bytecode; lockfile collision and
-    orphan-watchdog will eventually kill us anyway. Pre-empt: release the
-    lease and execv-restart so the new wheel is picked up cleanly.
-
-    The MCP socket to Claude Code WILL drop during the exec window.
-    Stop_hook _mcp_disconnected_without_reconnect (mig 68a3545e) catches
-    it; user runs `meshcode go <agent>` to pick up the new wheel.
-
-    Soft-fail throughout: any exception here is logged and swallowed so
-    the heartbeat thread isn't taken down by a flaky filesystem call.
+    """Heartbeat-tick scan: detect mid-session pkg reinstall.
+
+    Modes (MESHCODE_INSTALL_GUARD env var):
+      - 'warn' (default): log + one-shot boot_version_drift msg; never execv.
+        New wheel picked up on next cold boot. Removes mid-session surprise drops
+        (RC of task 0c4524af 2026-05-19: pip install over live 2.11.7 sessions
+        triggered execv on both backend+commander hb tick, dropping MCP socket).
+      - 'execv': legacy auto-restart. Deferred to warn-mode when agent is active
+        (in_wait, recent tool call <5min, or MESHCODE_AGENT_ACTIVE=1).
+      - 'off': skip scan entirely.
+
+    Soft-fail throughout.
     """
-    if not _PKG_PY_MTIMES:
+    global _INSTALL_GUARD_STALE_NOTIFIED
+    if _INSTALL_GUARD_MODE == "off" or not _PKG_PY_MTIMES:
         return
     try:
+        stale_path = None
+        old_m = new_m = 0.0
         for path, old_mtime in list(_PKG_PY_MTIMES.items()):
             try:
                 new_mtime = os.path.getmtime(path)
             except OSError:
                 continue
-            # 0.5s slack — covers fs-timestamp resolution and tar extract
-            # re-emit jitter without false-positive on intentional touch.
             if new_mtime <= old_mtime + 0.5:
                 continue
+            stale_path = path
+            old_m, new_m = old_mtime, new_mtime
+            break
+        if not stale_path:
+            return
+        if _INSTALL_GUARD_MODE == "execv" and not _is_agent_active():
             log.warning(
-                f"install-guard: self-modification detected on {path} "
-                f"(mtime {old_mtime:.0f} → {new_mtime:.0f}). The running "
-                f"image holds stale bytecode; triggering clean execv-restart "
-                f"so the new wheel is picked up. MCP socket will drop briefly "
-                f"— stop_hook handles the agent release (mig 68a3545e). User "
-                f"runs `meshcode go <agent>` to relaunch under the new image. "
-                f"Class: feedback_pip_install_into_live_mcp_env_self_kill."
+                f"install-guard: self-modification on {stale_path} "
+                f"(mtime {old_m:.0f} -> {new_m:.0f}). Mode=execv, agent inactive "
+                f"-- execv-restart. MCP socket will drop; stop_hook handles release."
             )
             try:
                 _release_lease_synchronous(timeout_s=1.5)
             except Exception:
                 pass
             _heartbeat_stop.set()
-            # execv replaces the current process; daemon threads die with
-            # it; new process inherits stdio. We pass the original argv so
-            # the entry-point command line is preserved verbatim.
             try:
                 os.execv(sys.executable, [sys.executable] + sys.argv)
             except Exception as _exec_err:
-                log.error(
-                    f"install-guard execv failed ({_exec_err}); "
-                    f"falling back to os._exit(0). Lifespan finally + "
-                    f"stop_hook still recover."
-                )
+                log.error(f"install-guard execv failed ({_exec_err}); os._exit(0)")
                 os._exit(0)
-            return  # unreachable but explicit
+            return
+        if not _INSTALL_GUARD_STALE_NOTIFIED:
+            _INSTALL_GUARD_STALE_NOTIFIED = True
+            log.warning(
+                f"install-guard: self-modification on {stale_path} "
+                f"(mtime {old_m:.0f} -> {new_m:.0f}). Mode={_INSTALL_GUARD_MODE}, "
+                f"agent_active={_is_agent_active()}. Running on STALE image -- new wheel "
+                f"picked up on next `meshcode go <agent>` cold boot. "
+                f"Set MESHCODE_INSTALL_GUARD=execv to opt into auto-restart."
+            )
+            try:
+                import threading as _t
+                def _notify():
+                    try:
+                        be.send_message(
+                            _PROJECT_ID, AGENT_NAME, "mesh-commander",
+                            {
+                                "type": "boot_version_drift",
+                                "subtype": "mid_session_stale_image",
+                                "path": stale_path,
+                                "old_mtime": old_m,
+                                "new_mtime": new_m,
+                                "agent": AGENT_NAME,
+                                "platform": sys.platform,
+                                "loaded_version": _SDK_VERSION,
+                            },
+                            msg_type="report",
+                            api_key=_get_api_key(),
+                        )
+                    except Exception as _e:
+                        log.debug(f"boot_version_drift notify failed (soft): {_e}")
+                _t.Thread(target=_notify, daemon=True, name="meshcode-install-guard-notify").start()
+            except Exception:
+                pass
     except Exception as e:
         log.debug(f"install-guard scan failed (soft): {e}")
 

meshcode-2.11.9/meshcode/meshcode_mcp/test_install_guard.py

@@ -0,0 +1,75 @@
+"""Unit tests for the install-guard heartbeat scan.
+
+RC for task 0c4524af (2026-05-19): pip install over live 2.11.7 sessions
+triggered execv on both backend+commander hb tick, dropping MCP socket.
+Fix (task d7df438e): default mode is 'warn' — log + one-shot notify, never
+execv mid-session. Legacy execv path preserved as opt-in (MESHCODE_INSTALL_GUARD=execv)
+and further deferred when agent is active.
+
+Server module requires MESHCODE_PROJECT and MESHCODE_AGENT at import time
+(L616-621). MESHCODE_PROJECT_ID short-circuits the network resolve path.
+"""
+import os
+
+os.environ.setdefault("MESHCODE_PROJECT", "test-install-guard")
+os.environ.setdefault("MESHCODE_AGENT", "test-agent")
+os.environ.setdefault("MESHCODE_PROJECT_ID", "00000000-0000-0000-0000-000000000000")
+os.environ.setdefault("MESHCODE_API_KEY", "mc_test_fake_key_not_used")
+
+import time
+import pytest
+from unittest import mock
+from meshcode.meshcode_mcp import server as srv
+
+
+@pytest.fixture
+def stale_setup(monkeypatch, tmp_path):
+    fake = tmp_path / "fake_pkg.py"
+    fake.write_text("# stale")
+    old = fake.stat().st_mtime
+    monkeypatch.setattr(srv, "_PKG_PY_MTIMES", {str(fake): old - 100.0})
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_STALE_NOTIFIED", False)
+    return fake
+
+
+def test_default_warn_no_execv(stale_setup, monkeypatch):
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_MODE", "warn")
+    with mock.patch.object(os, "execv") as me, mock.patch.object(os, "_exit") as mex:
+        srv._install_guard_check()
+    assert not me.called and not mex.called
+
+
+def test_off_skips(stale_setup, monkeypatch):
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_MODE", "off")
+    with mock.patch.object(os, "execv") as me:
+        srv._install_guard_check()
+    assert not me.called
+
+
+def test_execv_inactive_fires(stale_setup, monkeypatch):
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_MODE", "execv")
+    monkeypatch.setattr(srv, "_IN_WAIT", False)
+    monkeypatch.setattr(srv, "_last_tool_at", 0.0)
+    monkeypatch.delenv("MESHCODE_AGENT_ACTIVE", raising=False)
+    with mock.patch.object(os, "execv") as me, \
+         mock.patch.object(srv, "_release_lease_synchronous", create=True):
+        srv._install_guard_check()
+    assert me.called
+
+
+def test_execv_active_defers(stale_setup, monkeypatch):
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_MODE", "execv")
+    monkeypatch.setattr(srv, "_IN_WAIT", True)
+    with mock.patch.object(os, "execv") as me:
+        srv._install_guard_check()
+    assert not me.called
+
+
+def test_one_shot_notify(stale_setup, monkeypatch):
+    monkeypatch.setattr(srv, "_INSTALL_GUARD_MODE", "warn")
+    sends = []
+    monkeypatch.setattr(srv.be, "send_message", lambda *a, **kw: sends.append((a, kw)))
+    srv._install_guard_check(); time.sleep(0.3)
+    n1 = len(sends)
+    srv._install_guard_check(); time.sleep(0.3)
+    assert len(sends) == n1, "second call must not duplicate notify"

meshcode-2.11.9/meshcode/meshcode_mcp/test_prefs_claude_version.py

@@ -0,0 +1,82 @@
+"""Regression test for B1 (task f1d34641) — friction #9.
+
+`meshcode prefs claude-version latest` must save "latest" literally instead
+of deleting the key. The disable sentinel "latest"/"none"/"skip" is read at
+run_agent.py:475 to skip the ESC pin; if the CLI deletes the key, the user
+falls back to the hardcoded 2.1.104 pin → npx fails for users without Node.
+
+Bug location: comms_v4.py:3396-3416 (pre-fix grouped `latest` with
+`reset`/`unpin` and popped the key).
+"""
+import json
+import os
+
+os.environ.setdefault("MESHCODE_PROJECT", "test-prefs-b1")
+os.environ.setdefault("MESHCODE_AGENT", "test-agent")
+
+import pytest
+
+
+@pytest.fixture
+def isolated_prefs(tmp_path, monkeypatch):
+    pref_file = tmp_path / "preferences.json"
+    from meshcode import preferences
+    monkeypatch.setattr(preferences, "PREFS_PATH", pref_file)
+    return pref_file
+
+
+def _apply_branch(ver: str):
+    """Mirror the post-fix branch in comms_v4.py:3396-3420."""
+    from meshcode.preferences import load_prefs, save_prefs
+    if ver in ("reset", "unpin"):
+        prefs = load_prefs()
+        prefs.pop("claude_version", None)
+        save_prefs(prefs)
+    elif ver in ("latest", "none", "skip"):
+        prefs = load_prefs()
+        prefs["claude_version"] = ver
+        save_prefs(prefs)
+    else:
+        prefs = load_prefs()
+        prefs["claude_version"] = ver
+        save_prefs(prefs)
+
+
+def test_claude_version_latest_saves_literal(isolated_prefs):
+    """Repro for friction #9: `meshcode prefs claude-version latest` must
+    save "latest" to JSON, NOT delete the key."""
+    from meshcode.preferences import save_prefs
+    save_prefs({"claude_version": "2.1.50"})
+    _apply_branch("latest")
+    data = json.loads(isolated_prefs.read_text())
+    assert data.get("claude_version") == "latest", \
+        f"expected 'latest' literal, got {data!r}"
+
+
+def test_claude_version_none_saves_literal(isolated_prefs):
+    _apply_branch("none")
+    assert json.loads(isolated_prefs.read_text()).get("claude_version") == "none"
+
+
+def test_claude_version_skip_saves_literal(isolated_prefs):
+    _apply_branch("skip")
+    assert json.loads(isolated_prefs.read_text()).get("claude_version") == "skip"
+
+
+def test_claude_version_reset_clears_key(isolated_prefs):
+    from meshcode.preferences import save_prefs, load_prefs
+    save_prefs({"claude_version": "2.1.50"})
+    _apply_branch("reset")
+    assert "claude_version" not in load_prefs()
+
+
+def test_claude_version_unpin_clears_key(isolated_prefs):
+    from meshcode.preferences import save_prefs, load_prefs
+    save_prefs({"claude_version": "2.1.50"})
+    _apply_branch("unpin")
+    assert "claude_version" not in load_prefs()
+
+
+def test_claude_version_pin_saves_specific_version(isolated_prefs):
+    _apply_branch("2.1.108")
+    assert json.loads(isolated_prefs.read_text()).get("claude_version") == "2.1.108"

{meshcode-2.11.8 → meshcode-2.11.9}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.8 → meshcode-2.11.9}/meshcode.egg-info/SOURCES.txt

@@ -186,6 +186,8 @@ meshcode/meshcode_mcp/server.py
 meshcode/meshcode_mcp/sleep_signals.py
 meshcode/meshcode_mcp/test_backend.py
 meshcode/meshcode_mcp/test_boot_timing.py
+meshcode/meshcode_mcp/test_install_guard.py
+meshcode/meshcode_mcp/test_prefs_claude_version.py
 meshcode/meshcode_mcp/test_realtime.py
 meshcode/meshcode_mcp/test_server_wrapper.py
 meshcode/scripts/check_secrets.py

{meshcode-2.11.8 → meshcode-2.11.9}/pyproject.toml

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