meshcode 2.11.108__tar.gz → 2.11.109__tar.gz

{meshcode-2.11.108 → meshcode-2.11.109}/PKG-INFO

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

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode/__init__.py

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

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode/hostd.py

@@ -561,11 +561,17 @@ def _do_respawns(api_key: str, host_id: str) -> int:
                 except Exception:
                     pass
             continue
+        # Part 2 (Samuel req #2): for a VISIBLE recycle, snapshot the OLD window
+        # pid(s) BEFORE spawning the fresh one — so the new pid is never in the
+        # close set (commander q1: never touch the fresh terminal).
+        _old_vis_pids = _discover_agent_pids(_target) if (_is_recycle and _visible) else []
         _log(f"{'RECYCLE-RESPAWN' if _is_recycle else 'RESPAWN'} {proj}/{agent} "
              f"({'VISIBLE ' if _visible else ''}stale {c.get('heartbeat_age_s')}s, count={c.get('respawn_count')})")
         if _spawn_agent(proj, agent, headless=_hl):
             _record_spawn(_target)  # count the terminal we just opened, against the breaker
             if _is_recycle:
+                if _visible and _old_vis_pids:
+                    _close_old_visible_recycle(_target, _old_vis_pids)  # close old window (DRY-RUN first)
                 _rpc("mc_record_recycle",
                      {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
                 n += 1
@@ -667,6 +673,69 @@ def _recycle_blocked(st, target, now=None):
     return None
 
 
+# Samuel rule 2026-06-04: never recycle a CONNECTED agent (live MCP session) except
+# the >3h uptime lifecycle. BUSY_STATUSES (working/online/busy) MISSES a connected-
+# but-idle agent (status idle/standby, window open, heartbeat fresh) — a fresh
+# heartbeat is the stronger 'live session' signal, so an idle-but-connected agent
+# was being version-recycled out from under the user (the storm he kept seeing).
+_CONNECTED_HEARTBEAT_S = _env_int("MESHCODE_CONNECTED_HEARTBEAT_SEC", 60, 10)
+
+
+def _agent_connected(a) -> bool:
+    """True if the agent has a live MCP session: an explicitly-busy status OR a
+    very-recent heartbeat (window open even when idle/standby)."""
+    if (a.get("status") or "") in BUSY_STATUSES:
+        return True
+    hb = a.get("heartbeat_age_s")
+    try:
+        return hb is not None and float(hb) < _CONNECTED_HEARTBEAT_S
+    except (TypeError, ValueError):
+        return False
+
+
+# Part 2 (Samuel req #2 2026-06-04): on a VISIBLE recycle, close the OLD window so
+# old+new don't both stay open (audit gap 6a203baa). DRY-RUN first (commander q2 +
+# reaper safe-arm pattern): log-only until the logs confirm it's ONLY the old pid.
+_CLOSE_OLD_VISIBLE_DRYRUN = True
+
+
+def _pid_alive(pid) -> bool:
+    if not pid:
+        return False
+    try:
+        os.kill(int(pid), 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True   # exists, owned by another uid — treat as alive (don't guess)
+    except Exception:
+        return False
+
+
+def _close_old_visible_recycle(target: str, old_pids) -> int:
+    """Close the OLD window's still-alive process on a VISIBLE recycle. `old_pids`
+    is the PRE-SPAWN snapshot, so the freshly-opened window's pid is excluded by
+    construction — we NEVER touch the fresh terminal (commander q1). Graceful
+    self-exit (the stop-hook ends the session on must_exit=recycle) is PRIMARY
+    (q3): an already-exited old pid is skipped. DRY-RUN first (q2): log the
+    would-close pid; flip _CLOSE_OLD_VISIBLE_DRYRUN=False to arm once logs show
+    it's only the old pid. Real kill reuses _kill_headless_pid's cmdline guard."""
+    n = 0
+    for pid in old_pids:
+        if not _pid_alive(pid):
+            continue  # already self-closed gracefully (q3 primary) — nothing to do
+        if _CLOSE_OLD_VISIBLE_DRYRUN:
+            _log(f"CLOSE-OLD-VISIBLE-DRYRUN {target}: WOULD close old window pid {pid} "
+                 f"(visible recycle; fresh window already spawned + excluded) — log-only. "
+                 f"Flip _CLOSE_OLD_VISIBLE_DRYRUN=False after confirming it's ONLY the old pid.")
+            continue
+        if _kill_headless_pid(target, pid):
+            _log(f"CLOSE-OLD-VISIBLE {target}: closed old window pid {pid} (visible recycle; kept fresh window)")
+            n += 1
+    return n
+
+
 def _spawn_rate_ok(target: str):
     """Anti-spam circuit breaker. Returns (ok, tripped_burst, reason).
 
@@ -1054,6 +1123,9 @@ def _do_recycle_enforce(api_key: str, host_id: str) -> int:
     agent (headless_pids, with _kill_headless_pid's reuse-guard) — NEVER blind cmdline. After the
     kill it goes stale and the recycle FAST-PATH in _do_respawns relaunches it within seconds ->
     SessionStart restores the handoff. Returns number force-killed."""
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): RECYCLE disabled in prod — hard no-op
+    # (no recycles are triggered, so there is nothing to enforce). Crash-RESPAWN unaffected.
+    return 0
     res = _rpc("mc_recycle_enforce_candidates", {"p_api_key": api_key, "p_host_id": host_id})
     if not res or not res.get("ok"):
         return 0
@@ -1099,6 +1171,11 @@ def _do_recycle_enforce(api_key: str, host_id: str) -> int:
 
 def _do_recycles(api_key: str, host_id: str) -> int:
     """Uptime-based recycle at task boundary. Returns number recycled."""
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): the RECYCLE feature is disabled in
+    # prod (unreliable — kept causing version/env-mismatch storms). Hard no-op in source so
+    # it stays dead even if a schedule row reappears. Crash-RESPAWN (_do_respawns) is
+    # UNAFFECTED — only RECYCLE triggers are killed.
+    return 0
     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
@@ -1489,6 +1566,10 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
     mid-task), rate-limited (<=1 version-recycle per agent / 30min), recycle-not-kill (clean handoff via
     mc_request_recycle -> agent exits at its boundary -> _do_respawns relaunches on the new version).
     Recorded via mc_record_recycle (NEVER counts against the mig406 crash respawn cap). Owner-scoped."""
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): RECYCLE disabled in prod — hard no-op.
+    # This was the env-mismatch storm source; fixed-at-source via run_agent env-sync, but the
+    # whole recycle feature is being removed per owner. Crash-RESPAWN is unaffected.
+    return 0
     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
@@ -1513,8 +1594,10 @@ def _do_version_recycles(api_key: str, host_id: str) -> int:
                 continue  # agent already on the on-disk version (or newer) — nothing to do
         except Exception:
             continue
-        if (a.get("status") or "") in BUSY_STATUSES:
-            continue  # safe-point ONLY — never recycle a working agent mid-task
+        if _agent_connected(a):
+            continue  # Samuel rule: never version-recycle a CONNECTED agent (live MCP session,
+                      # even if idle/standby) — the >3h uptime lifecycle (_do_recycles) is the
+                      # only recycle that may touch a connected agent.
         proj, agent = a.get("project_name"), a.get("name")
         if not proj or not agent:
             continue

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode/meshcode_mcp/server.py

@@ -6164,12 +6164,10 @@ def meshcode_recycle_agent(name: str, visible: bool = False) -> Dict[str, Any]:
         visible: True = respawn as a visible focused window; default False =
             preserve the agent's current headless/visible state.
     """
-    return be.sb_rpc("mc_recycle_as_agent", {
-        "p_api_key":    _get_api_key(),
-        "p_project_id": _PROJECT_ID,
-        "p_agent":      name,
-        "p_visible":    bool(visible),
-    })
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): recycle is disabled in prod
+    # (unreliable). No-op — do not call the RPC.
+    return {"ok": False, "error_code": "recycle_disabled",
+            "error": "recycle is disabled (feature removed — was unreliable). No action taken."}
 
 
 @mcp.tool()
@@ -6187,12 +6185,9 @@ def meshcode_recycle_fleet(visible: bool = False) -> Dict[str, Any]:
         visible: True = respawn each as a visible focused window; default False
             = preserve each agent's current headless/visible state.
     """
-    return be.sb_rpc("mc_recycle_as_agent", {
-        "p_api_key":    _get_api_key(),
-        "p_project_id": _PROJECT_ID,
-        "p_agent":      None,  # NULL = whole fleet (all running agents)
-        "p_visible":    bool(visible),
-    })
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): recycle is disabled in prod. No-op.
+    return {"ok": False, "error_code": "recycle_disabled",
+            "error": "recycle is disabled (feature removed — was unreliable). No action taken."}
 
 
 @mcp.tool()
@@ -6219,12 +6214,10 @@ def meshcode_set_recycle_schedule(interval_hours: int = 6, enabled: bool = True,
             "error_code": "not_yet_supported",
             "error": "per-agent recycle schedule is a fast-follow; pass agent=None for the mesh-global schedule.",
         }
-    return be.sb_rpc("mc_set_recycle_schedule_as_agent", {
-        "p_api_key":        _get_api_key(),
-        "p_project_id":     _PROJECT_ID,
-        "p_enabled":        bool(enabled),
-        "p_interval_hours": int(interval_hours),
-    })
+    # DEAD-FEATURE (task 222b1b02, Samuel 2026-06-04): auto-recycle scheduling is disabled
+    # in prod. No-op — never (re)enable a schedule.
+    return {"ok": False, "error_code": "recycle_disabled",
+            "error": "auto-recycle scheduling is disabled (feature removed — was unreliable). No action taken."}
 
 
 @mcp.tool()

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode/run_agent.py

@@ -820,6 +820,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.
+    if not dry_run:
+        try:
+            _doc = json.loads(mcp_json_path.read_text(encoding="utf-8"))
+            for _srv in (_doc.get("mcpServers") or {}).values():
+                _cmd = _srv.get("command")
+                if _cmd:
+                    self_update.sync_agent_env(_cmd)
+                    break
+        except Exception:
+            pass
+
     # ── Validate stop hook exists (required for wait-loop integrity) ─
     # If the workspace was created on an old CLI that didn't install hooks
     # (or someone wiped .claude/), Claude Code has nothing blocking turn-end

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode/self_update.py

@@ -275,6 +275,7 @@ state_dir.mkdir(parents=True, exist_ok=True)
 mode = sys.argv[1] if len(sys.argv) > 1 else "pip"
 target_version = sys.argv[2] if len(sys.argv) > 2 else None
 site_flag = sys.argv[3] if len(sys.argv) > 3 else "system"
+target_python = sys.argv[4] if len(sys.argv) > 4 and sys.argv[4] else None  # agent MCP-server env
 
 try:
     if mode == "pipx":
@@ -282,11 +283,12 @@ try:
     else:
         # --no-cache-dir (task 14782bb4 / urgent): never let pip serve a STALE cached wheel — always
         # fetch the true latest from PyPI (auto-update was grabbing an old cached version otherwise).
-        cmd = [sys.executable, "-m", "pip", "install", "-U", "--no-cache-dir",
+        exe = target_python or sys.executable
+        cmd = [exe, "-m", "pip", "install", "-U", "--no-cache-dir",
                "--disable-pip-version-check", "--quiet"]
-        # Keep upgrade in the same site as the current install so the
-        # user-PATH shim (~/Library/Python/X.Y/bin) doesn't get orphaned.
-        if site_flag == "user":
+        # --user only for the LAUNCHER's own user-site install; an explicit
+        # target_python (the agent's MCP env / venv) installs into ITS env.
+        if site_flag == "user" and not target_python:
             cmd.append("--user")
         cmd.append("meshcode")
     with open(log_path, "ab") as logf:
@@ -315,12 +317,13 @@ finally:
 '''
 
 
-def _spawn_background_updater(target_version: str) -> bool:
+def _spawn_background_updater(target_version: str, target_python: Optional[str] = None) -> bool:
     """Spawn a fully detached subprocess that runs the updater.
 
     The parent (current `meshcode run`) returns immediately. The child
     runs pip install in the background, writes the result to disk, and
-    exits. Next `meshcode run` consumes the result.
+    exits. Next `meshcode run` consumes the result. `target_python` (when set)
+    is the agent's MCP-server env — pip installs into IT, not the launcher.
     """
     if not _acquire_lock():
         return False
@@ -331,7 +334,7 @@ def _spawn_background_updater(target_version: str) -> bool:
     # We pass the runner code via stdin so we don't need to ship a
     # second .py file. The child reads it from sys.stdin and execs it.
     runner = f"import sys; exec(sys.stdin.read())"
-    args = [sys.executable, "-c", runner, mode, target_version, site_flag]
+    args = [sys.executable, "-c", runner, mode, target_version, site_flag, target_python or ""]
 
     try:
         if sys.platform == "win32":
@@ -418,6 +421,46 @@ def check_and_maybe_update(verbose: bool = False) -> None:
         print(f"[meshcode] downloading {latest} in background...", file=sys.stderr)
 
 
+def _env_version(python_exe: str) -> Optional[str]:
+    """meshcode.__version__ as seen by ANOTHER python env (the agent's MCP server)."""
+    try:
+        out = subprocess.run(
+            [python_exe, "-c", "import meshcode,sys; sys.stdout.write(meshcode.__version__)"],
+            capture_output=True, text=True, timeout=10).stdout.strip()
+        return out or None
+    except Exception:
+        return None
+
+
+def sync_agent_env(mcp_python: str, verbose: bool = False) -> None:
+    """Bring the agent's MCP-SERVER env (mcp_python, from the workspace .mcp.json
+    `command`) up to the LAUNCHER's installed meshcode version.
+
+    The MCP server is the env that reports cli_version. If it lags hostd's on-disk
+    version, hostd version-recycles the agent FOREVER (the env-mismatch storm),
+    because run_agent's normal auto-pip only updates the LAUNCHER env
+    (sys.executable). This syncs the env that actually matters. Non-blocking
+    (background pip). No-op if same env / already current / opted out / unreadable.
+    """
+    try:
+        if not mcp_python:
+            return
+        if os.path.realpath(mcp_python) == os.path.realpath(sys.executable):
+            return  # same env — the normal launcher update already covers it
+        if update_disabled():
+            return
+        launcher_ver = _current_version()
+        env_ver = _env_version(mcp_python)
+        if not launcher_ver or not env_ver:
+            return
+        if _is_newer(launcher_ver, env_ver):
+            if _spawn_background_updater(launcher_ver, mcp_python) and verbose:
+                print(f"[meshcode] syncing agent env {env_ver} -> {launcher_ver} in background...",
+                      file=sys.stderr)
+    except Exception:
+        pass
+
+
 # ============================================================
 # Blocking variant — used by `meshcode run` to guarantee the editor
 # subprocess inherits the latest meshcode_mcp/server.py on disk.

{meshcode-2.11.108 → meshcode-2.11.109}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.108 → meshcode-2.11.109}/pyproject.toml

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