meshcode 2.11.116__tar.gz → 2.11.118__tar.gz

{meshcode-2.11.116 → meshcode-2.11.118}/PKG-INFO

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

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/__init__.py

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

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/comms_v4.py

@@ -1886,7 +1886,7 @@ def _start_heartbeat_daemon(project, name, agent_pid=None):
         "        if not check_still_leased(pid):\n"
         "            sys.exit(0)\n"
         "        post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
-        "    time.sleep(10)\n"  # R2-3 (.116): 30s->10s so the fork's agent-alive check (self-exit on recycle/stop) tightens the stale-heartbeat window to <=10s
+        "    time.sleep(30)\n"  # .117: back to 30s (commander 2026-06-09 — 10s tripled hb RPC volume; Fix A already bounds the stale window)
     )
     # Windows: start_new_session kwarg doesn't exist. Use creationflags.
     _popen_kwargs = {

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/meshcode_mcp/server.py

@@ -7612,6 +7612,24 @@ def run_server():
         )
         # Stash for the heartbeat thread to relay to commander on first beat.
         os.environ["_MESHCODE_BOOT_DRIFT"] = f"{_installed}->{_loaded}"
+    # R2-5 (2.11.117) boot drift self-check: the launcher stamps the version it
+    # RESOLVED for this agent (pin else latest PyPI) into the .mcp.json env as
+    # MESHCODE_EXPECTED_VERSION. If what actually loaded differs, the spawn env
+    # is stale/mismatched — report it to the mesh (first-heartbeat relay picks
+    # up the sentinel) instead of degrading into "weird behavior".
+    _expected = os.environ.get("MESHCODE_EXPECTED_VERSION", "").strip()
+    if _expected and _expected != _SDK_VERSION:
+        print(
+            f"[meshcode] WARN boot_version_drift: expected={_expected} "
+            f"loaded={_SDK_VERSION} — this agent's spawn env does not serve the "
+            f"version the launcher resolved. Check ~/.meshcode/envs/{_expected}.",
+            file=sys.stderr,
+        )
+        _prev = os.environ.get("_MESHCODE_BOOT_DRIFT", "")
+        os.environ["_MESHCODE_BOOT_DRIFT"] = (
+            (_prev + " " if _prev else "")
+            + f"expected:{_expected}->loaded:{_SDK_VERSION}"
+        )
     if sys.platform == "win32":
         # Windows can't execv-preserve stdio; auto-update defers to next boot.
         # Always announce so Windows users know why their first launch may

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/protocol_handler.py

@@ -298,7 +298,13 @@ def _spawn_terminal_windows(cmd: str) -> tuple[bool, str]:
             # is what Samuel wants ("ventana nueva ENFOCADA"). The old `-w 0 nt` opened a tab in
             # the most-recently-used window — frequently minimized/background, so the launch
             # looked like "nada pasó".
-            subprocess.Popen([wt, "-w", "new", "nt", "cmd", "/k", cmd])
+            # mesh-core patch-wt-semicolon (e9786e2d, verified on Samuel's box
+            # 2026-06-07): wt treats an unescaped ';' as a pane/tab delimiter,
+            # and the hostd PATH-inject (`set "PATH={bindir};%PATH%"`) always
+            # carries one → the cmdline splits and wt fails with 0x80070002.
+            # Escape ONLY here; the cmd.exe fallback below stays unescaped
+            # (cmd.exe does not split on ';').
+            subprocess.Popen([wt, "-w", "new", "nt", "cmd", "/k", cmd.replace(";", "\\;")])
             return True, "wt"
         except Exception as e:
             return False, f"wt.exe: {e}"

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/run_agent.py

@@ -886,12 +886,22 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             print(f"[meshcode]        Run `meshcode setup {resolved_project} {agent}` to fix.", file=sys.stderr)
             return 2
 
-    # Env-mismatch storm fix (2.11.109): the non-blocking auto-pip above updated the
-    # LAUNCHER env (sys.executable). But THIS agent's MCP server runs from this
-    # workspace's .mcp.json `command` python — that's the env that reports
-    # cli_version. Sync IT to the launcher's installed version so hostd
-    # version-recycle CONVERGES instead of looping forever. Non-blocking, best-effort.
+    # R2-5 (2.11.117) boot-always-latest: resolve target version (explicit pin
+    # else latest PyPI — owner directive sammybenu 2026-06-09), guarantee an
+    # immutable ~/.meshcode/envs/<target>/ env serving exactly it, and point
+    # this workspace's .mcp.json at it. Live agents keep their old env until
+    # recycle (no in-place overwrite → no class#2 clobber). Soft-fail → legacy
+    # sync_agent_env path (2.11.109 env-mismatch storm fix) below.
+    _boot_env_ver = None
     if not dry_run:
+        try:
+            _boot_env_ver = self_update.ensure_boot_env(mcp_json_path)
+            if _boot_env_ver:
+                print(f"[meshcode]   agent env: meshcode {_boot_env_ver} "
+                      f"(boot-always-latest)", file=sys.stderr)
+        except Exception:
+            _boot_env_ver = None
+    if not dry_run and not _boot_env_ver:
         try:
             _doc = json.loads(mcp_json_path.read_text(encoding="utf-8"))
             for _srv in (_doc.get("mcpServers") or {}).values():

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode/self_update.py

@@ -456,10 +456,18 @@ def check_and_maybe_update(verbose: bool = False) -> None:
 
 
 def _env_version(python_exe: str) -> Optional[str]:
-    """meshcode.__version__ as seen by ANOTHER python env (the agent's MCP server)."""
+    """meshcode.__version__ as seen by ANOTHER python env (the agent's MCP server).
+
+    -I (isolated mode): `python -c` prepends CWD to sys.path, so probing from a
+    dir that contains a meshcode/ package (the SDK repo, any vendored copy)
+    reports THAT tree's version instead of the env's installed one (caught live
+    2026-06-09: env build verify refused a correct env because the probe ran
+    from the .117 worktree). Isolated mode answers the only question this
+    function asks: what does THIS env serve.
+    """
     try:
         out = subprocess.run(
-            [python_exe, "-c", "import meshcode,sys; sys.stdout.write(meshcode.__version__)"],
+            [python_exe, "-I", "-c", "import meshcode,sys; sys.stdout.write(meshcode.__version__)"],
             capture_output=True, text=True, timeout=10).stdout.strip()
         return out or None
     except Exception:
@@ -495,6 +503,144 @@ def sync_agent_env(mcp_python: str, verbose: bool = False) -> None:
         pass
 
 
+# ============================================================
+# R2-5 (2.11.117): versioned immutable envs + boot-always-latest
+#
+# Owner directive (sammybenu 2026-06-09T22:54Z): "al boot SIEMPRE
+# auto-update meshcode a la versión más nueva de PyPI" — per-agent pin
+# only when explicitly set.
+#
+# Instead of upgrading a SHARED live env in place (class#2 clobber —
+# the reason the 8e4f93f9 guard defers forever on a 24/7 fleet), each
+# version gets its own immutable venv under ~/.meshcode/envs/<version>/
+# built exactly once and never touched again. Running agents keep
+# importing their old env until recycle; new spawns point at the
+# resolved target. No overwrite → no clobber → no deferral.
+# ============================================================
+
+ENVS_DIR = STATE_DIR / "envs"
+ENV_BUILD_TIMEOUT_SEC = 240
+_ENV_OK_MARKER = ".build-ok"
+
+
+def resolve_target_version() -> Optional[str]:
+    """Version an agent spawn should run. Resolution order:
+
+      1. MESHCODE_VERSION_PIN env var          (explicit pin wins)
+      2. prefs key "version_pin"               (explicit pin wins)
+      3. latest PyPI (1.5s probe)              (the owner-directive default)
+      4. None → caller keeps current behavior  (offline-safe)
+    """
+    pin = os.environ.get("MESHCODE_VERSION_PIN") or _read_prefs().get("version_pin")
+    if pin:
+        return str(pin).strip()
+    return fetch_latest_version()
+
+
+def _env_python(version: str) -> Path:
+    sub = "Scripts" if sys.platform == "win32" else "bin"
+    exe = "python.exe" if sys.platform == "win32" else "python3"
+    return ENVS_DIR / version / sub / exe
+
+
+def ensure_versioned_env(version: str, verbose: bool = True) -> Optional[Path]:
+    """Create-once immutable venv for `version`; return its python, or None.
+
+    Build is atomic: venv + pip install + import-verify happen in a
+    .tmp-<version>-<pid> dir which is renamed into place only after the
+    installed version is VERIFIED == target (refuse-stale-spawn at the
+    source). Concurrent builders race benignly — first rename wins, the
+    loser falls back to the winner's env. Never raises.
+    """
+    try:
+        final = ENVS_DIR / version
+        py = _env_python(version)
+        if py.exists() and (final / _ENV_OK_MARKER).exists():
+            return py
+
+        tmp = ENVS_DIR / f".tmp-{version}-{os.getpid()}"
+        tmp_py = Path(str(py).replace(str(final), str(tmp), 1))
+        ENVS_DIR.mkdir(parents=True, exist_ok=True)
+        if verbose:
+            print(f"[meshcode] building env for meshcode {version} (one-time, ~30s)...",
+                  file=sys.stderr)
+        import shutil
+        shutil.rmtree(tmp, ignore_errors=True)
+        if subprocess.run([sys.executable, "-m", "venv", str(tmp)],
+                          capture_output=True, timeout=ENV_BUILD_TIMEOUT_SEC).returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        proc = subprocess.run(
+            [str(tmp_py), "-m", "pip", "install", "--no-cache-dir", "--quiet",
+             "--disable-pip-version-check", f"{PKG_NAME}=={version}"],
+            capture_output=True, timeout=ENV_BUILD_TIMEOUT_SEC)
+        if proc.returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        got = _env_version(str(tmp_py))
+        if got != version:  # refuse-stale-spawn: never bless a wrong env
+            shutil.rmtree(tmp, ignore_errors=True)
+            return None
+        (tmp / _ENV_OK_MARKER).write_text(version, encoding="utf-8")
+        try:
+            os.rename(tmp, final)
+        except OSError:
+            shutil.rmtree(tmp, ignore_errors=True)  # concurrent builder won
+        if py.exists() and (final / _ENV_OK_MARKER).exists():
+            return py
+        return None
+    except Exception:
+        return None
+
+
+def ensure_boot_env(mcp_json_path, verbose: bool = True) -> Optional[str]:
+    """Boot-always-latest engine, called by `meshcode run` pre-editor-exec.
+
+    Resolves the target version (pin else latest PyPI), guarantees an
+    immutable env serving EXACTLY it, points the workspace .mcp.json
+    command there, and stamps MESHCODE_EXPECTED_VERSION into the server
+    env block (the serve compares it against its loaded __version__ at
+    boot and reports boot_version_drift to the mesh on mismatch).
+
+    Returns the target version on success, None on ANY failure — the
+    caller then keeps the legacy sync_agent_env path. Never raises.
+    """
+    try:
+        if update_disabled() or is_editable_install():
+            return None
+        mcp_json_path = Path(mcp_json_path)
+        target = resolve_target_version()
+        if not target:
+            return None
+        doc = json.loads(mcp_json_path.read_text(encoding="utf-8"))
+        servers = doc.get("mcpServers") or {}
+        if not servers:
+            return None
+        srv = next(iter(servers.values()))
+        cur_cmd = srv.get("command") or ""
+        cur_ver = _env_version(cur_cmd) if cur_cmd else None
+
+        changed = False
+        if cur_ver != target:
+            py = ensure_versioned_env(target, verbose=verbose)
+            if py is None:
+                return None
+            if cur_cmd != str(py):
+                srv["command"] = str(py)
+                changed = True
+        env_block = srv.setdefault("env", {})
+        if env_block.get("MESHCODE_EXPECTED_VERSION") != target:
+            env_block["MESHCODE_EXPECTED_VERSION"] = target
+            changed = True
+        if changed:
+            tmp = mcp_json_path.with_name(mcp_json_path.name + ".tmp")
+            tmp.write_text(json.dumps(doc, indent=2), encoding="utf-8")
+            tmp.replace(mcp_json_path)
+        return target
+    except Exception:
+        return None
+
+
 # ============================================================
 # Blocking variant — used by `meshcode run` to guarantee the editor
 # subprocess inherits the latest meshcode_mcp/server.py on disk.

{meshcode-2.11.116 → meshcode-2.11.118}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.116 → meshcode-2.11.118}/pyproject.toml

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