meshcode 2.11.159__tar.gz → 2.11.160__tar.gz

{meshcode-2.11.159 → meshcode-2.11.160}/PKG-INFO

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

{meshcode-2.11.159 → meshcode-2.11.160}/meshcode/__init__.py

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

{meshcode-2.11.159 → meshcode-2.11.160}/meshcode/comms_v4.py

@@ -2519,6 +2519,7 @@ DIAGNOSTICS:
   doctor [--fix]                             Diagnose setup issues
   compat                                     Claude Code version compatibility
   upgrade                                    Upgrade meshcode to latest version
+  self-upgrade                               Unattended deferral-safe upgrade (used by the hostd launcher)
 
 ADMIN:
   clear <proj> <name>                        Clear inbox
@@ -3103,7 +3104,7 @@ if __name__ == "__main__":
 
     # Auth guard: commands that talk to Supabase need a valid API key.
     # doctor, help, version, login, prefs, launcher don't need auth.
-    _NO_AUTH_CMDS = {"doctor", "compat", "upgrade", "help", "--help", "-h", "login",
+    _NO_AUTH_CMDS = {"doctor", "compat", "upgrade", "self-upgrade", "help", "--help", "-h", "login",
                      "init", "prefs", "launcher", "--version", "-V", "version",
                      "whoami", "profiles", "scan", "setup-path"}
     if cmd not in _NO_AUTH_CMDS:
@@ -4010,6 +4011,25 @@ if __name__ == "__main__":
             print(f"  Upgrade cancelled.")
         sys.exit(0)
 
+    elif cmd == "self-upgrade":
+        # meshcode self-upgrade — UNATTENDED, deferral-safe self-upgrade for launcher
+        # pre-steps (task d84cbfa1, version-split self-heal). Distinct from:
+        #   - `meshcode upgrade` (INTERACTIVE force escape-hatch; cancels on no-TTY and
+        #      overwrites the env even while live agents share it), and
+        #   - `meshcode update`  (comms STATUS update — unrelated).
+        # Uses the BLOCKING updater with force=False so it DEFERS when a live agent serve
+        # shares the env (never clobbers a running MCP — the spec's live-agent deferral
+        # constraint). Honors MESHCODE_NO_UPDATE / MESHCODE_NO_AUTO_UPDATE (the hostd
+        # launcher clears them for this one explicit step). Never raises; always exits 0
+        # so a failed/offline upgrade can never wedge the launcher.
+        import importlib
+        try:
+            _su = importlib.import_module("meshcode.self_update")
+            _su.check_and_maybe_update_blocking(verbose=True, force=False)
+        except Exception as _e:
+            print(f"[meshcode] self-upgrade skipped: {_e}", file=sys.stderr)
+        sys.exit(0)
+
     elif cmd == "compat":
         from meshcode.compat import check as cc_check, format_report, RECOMMENDED_VERSION
         version, status, entry = cc_check()
@@ -4134,7 +4154,7 @@ if __name__ == "__main__":
             "history", "clear", "unregister", "connect", "disconnect",
             "setup", "add-agent", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
-            "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
+            "help", "init", "doctor", "compat", "upgrade", "self-upgrade", "profile", "validate-sessions", "wake-headless",
             "supervisor", "hostd", "up", "upload", "quickstart", "patch-hooks", "wake-all",
             "install-protocol", "launch-url", "launch-batch",
         ]

{meshcode-2.11.159 → meshcode-2.11.160}/meshcode/hostd.py

@@ -97,33 +97,56 @@ def _maybe_self_restart_on_version_drift() -> None:
             _su.check_and_maybe_update()  # non-blocking, detached, TTL-guarded internally
         except Exception:
             pass
+    # Resolve the best target to converge UP to: the NEWER of
+    #   (a) the pip-installed site-packages METADATA version, and
+    #   (b) the newest FINALIZED immutable env under ~/.meshcode/envs/<v>
+    #       (task d84cbfa1 converge-UP — adopt a version boot-always-latest
+    #        already built locally even if site-packages is stale).
+    # target_py is the interpreter we'd re-exec onto: our own for the metadata
+    # path, the env's python for the env-adoption path (so the new code actually
+    # loads — the supervisor would relaunch site-packages, not the env).
+    target = None
     try:
         import importlib.metadata as _ilmd
-        ondisk = _ilmd.version("meshcode")  # reads dist-info METADATA on disk (pip-updated)
+        target = _ilmd.version("meshcode")  # reads dist-info METADATA on disk (pip-updated)
     except Exception:
+        target = None
+    target_py = sys.executable
+    via_env = False
+    try:
+        from meshcode import self_update as _su
+        _env = _su.newest_installed_env()  # (version, python_path) or None
+        if _env:
+            _env_ver, _env_py = _env
+            if target is None or _su._is_newer(_env_ver, target):
+                target, target_py, via_env = _env_ver, str(_env_py), True
+    except Exception:
+        pass
+    if target is None:
         return
     try:
         from meshcode import self_update as _su
-        newer = _su._is_newer(ondisk, _RUNNING_VERSION)
+        newer = _su._is_newer(target, _RUNNING_VERSION)
     except Exception:
         def _vt(v):
             return tuple(int(x) for x in v.split(".") if x.isdigit())
         try:
-            newer = _vt(ondisk) > _vt(_RUNNING_VERSION)
+            newer = _vt(target) > _vt(_RUNNING_VERSION)
         except Exception:
             newer = False
     if not newer:
         return
-    # L3 update-guard (task 2e85c6a8): before re-exec'ing onto the new on-disk version,
-    # smoke-gate it. enforce -> if the candidate fails launch smoke, do NOT restart
-    # (stay on known-good), log + alert all commanders. dry_run -> log+alert only,
-    # restart proceeds. off (default) -> no-op. Fail-open so the guard can't wedge hostd.
+    # L3 update-guard (task 2e85c6a8): before re-exec'ing onto the candidate,
+    # smoke-gate it (the env python when adopting an env, else our interpreter).
+    # enforce -> if the candidate fails launch smoke, do NOT restart (stay on
+    # known-good), log + alert all commanders. dry_run -> log+alert only, restart
+    # proceeds. off (default) -> no-op. Fail-open so the guard can't wedge hostd.
     try:
         from meshcode import _update_guard as _ug
-        if _ug.guard_blocks_candidate(sys.executable, to_version=ondisk,
+        if _ug.guard_blocks_candidate(target_py, to_version=target,
                                       from_version=_RUNNING_VERSION,
                                       context="hostd_version_drift_restart"):
-            _log(f"UPDATE-GUARD: on-disk {ondisk} failed launch smoke -> NOT restarting; "
+            _log(f"UPDATE-GUARD: candidate {target} failed launch smoke -> NOT restarting; "
                  f"staying on known-good {_RUNNING_VERSION} (MESHCODE_UPDATE_GUARD=enforce).")
             return
     except Exception:
@@ -131,42 +154,46 @@ def _maybe_self_restart_on_version_drift() -> None:
     # Loop-guard (backend2 finding): in a source/dev run, importlib.metadata can report a
     # pip-installed wheel NEWER than the __init__.py actually executing, so the drift would
     # PERSIST across restart -> storm. Persist the attempt; if we already tried to reach this
-    # exact on-disk target recently and didn't advance, skip until the guard window passes.
+    # exact target recently and didn't advance, skip until the guard window passes.
     global _REEXEC_GUARD_LOGGED
     try:
         _st = _load_state()
     except Exception:
         _st = {}
     _att = _st.get("reexec_attempt") or {}
-    if _att.get("target") == ondisk and (time.time() - float(_att.get("at", 0) or 0)) < 600:
+    if _att.get("target") == target and (time.time() - float(_att.get("at", 0) or 0)) < 600:
         if not _REEXEC_GUARD_LOGGED:
             _REEXEC_GUARD_LOGGED = True
-            _log(f"version drift {_RUNNING_VERSION}->{ondisk} but a recent restart didn't advance the "
+            _log(f"version drift {_RUNNING_VERSION}->{target} but a recent restart didn't advance the "
                  f"running version (source/dev run?). Skipping to avoid a restart storm; retry after 600s.")
         return
-    _st["reexec_attempt"] = {"target": ondisk, "at": time.time()}
+    _st["reexec_attempt"] = {"target": target, "at": time.time()}
     try:
         _save_state(_st)
     except Exception:
         pass
-    _log(f"VERSION DRIFT: running {_RUNNING_VERSION}, on-disk {ondisk} -> restart to load new code "
+    _log(f"VERSION DRIFT: running {_RUNNING_VERSION}, target {target}"
+         f"{' (env adopt)' if via_env else ' (on-disk)'} -> restart to load new code "
          f"(Stop kill sweep + daemon fixes). headless_pids persisted.")
     # Prefer supervisor-restart where one manages hostd: field data (Samuel Mac) showed os.execv
     # is BLOCKED in the sandboxed runtime and the os._exit->KeepAlive fallback is what actually
     # restarts. So when a supervisor exists, exit cleanly and let it relaunch on the new wheel.
-    if _has_supervisor():
+    # EXCEPTION: when ADOPTING a versioned env, the supervisor would relaunch site-packages (NOT
+    # the env), so skip the clean-exit shortcut and re-exec the env's python directly below.
+    if not via_env and _has_supervisor():
         _log("supervisor present -> clean exit; launchd/systemd/schtasks relaunches on new code")
         os._exit(0)
-    # 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.
+    # No supervisor (e.g. dev foreground run / sandboxed Mac terminal) OR env adoption:
+    # try execv first (fastest, in-place; same PID so a supervisor's KeepAlive doesn't
+    # double-fire); if blocked (macOS sandbox), spawn a DETACHED hostd on the target and
+    # exit. The new process inherits nothing from us — clean slate on the target version;
+    # the hostd.lock singleton resolves any race with a supervisor relaunch.
     try:
-        os.execv(sys.executable, [sys.executable, "-m", "meshcode"] + sys.argv[1:])
+        os.execv(target_py, [target_py, "-m", "meshcode"] + sys.argv[1:])
     except Exception as e:
         _log(f"execv blocked ({e}); attempting detached self-relaunch via subprocess")
         try:
-            argv = _hostd_run_argv()
+            argv = [target_py, "-m", "meshcode", "hostd", "run"] if via_env else _hostd_run_argv()
             if sys.platform == "win32":
                 # DETACHED_PROCESS: no console inheritance, survives our exit.
                 subprocess.Popen(argv, creationflags=subprocess.DETACHED_PROCESS,
@@ -2580,13 +2607,44 @@ def _hostd_plist_path():
     return Path.home() / "Library" / "LaunchAgents" / f"{_HOSTD_PLIST_LABEL}.plist"
 
 
+def _hostd_launch_command_path():
+    return STATE_DIR / "hostd-launch.command"
+
+
 def _hostd_plist_xml() -> str:
     import shutil
-    mc = shutil.which("meshcode") or f"{sys.executable} -m meshcode"
-    args = (mc.split() + ["hostd", "run"]) if " -m " in mc else [mc, "hostd", "run"]
-    args_xml = "\n".join(f"        <string>{a}</string>" for a in args)
+    mc = shutil.which("meshcode")
+    mc_inv = shlex.quote(mc) if mc else f"{shlex.quote(sys.executable)} -m meshcode"
     logdir = STATE_DIR / "logs"
     logdir.mkdir(parents=True, exist_ok=True)
+    bindir = os.path.dirname(sys.executable)
+    # task d84cbfa1 (version-split self-heal): TODAY ProgramArguments ran `meshcode
+    # hostd run` DIRECTLY. Now generate a /bin/sh wrapper that self-upgrades to the
+    # latest version BEFORE exec'ing hostd, so a machine frozen on an OLD version
+    # autocures on the next launch without depending on the broken in-process upgrade
+    # path (anti chicken-egg). The plist keeps MESHCODE_NO_AUTO_UPDATE=1 in
+    # EnvironmentVariables (in-loop auto-update stays deferral-safe); the wrapper
+    # clears the guards ONLY for the explicit pre-flight upgrade, then restores them.
+    # `self-upgrade` uses the BLOCKING updater with force=False -> it DEFERS when a
+    # live agent serve shares the env, so it never clobbers a running MCP.
+    wrapper = _hostd_launch_command_path()
+    wrapper.write_text(
+        "#!/bin/sh\n"
+        "# MeshCode hostd launcher (task d84cbfa1: version-split self-heal). Generated\n"
+        "# by `meshcode hostd install` — do not edit; it is overwritten on reinstall.\n"
+        f'PATH="{bindir}:$PATH"; export PATH\n'
+        "unset MESHCODE_NO_UPDATE MESHCODE_NO_AUTO_UPDATE\n"
+        f'{mc_inv} self-upgrade >> "{logdir / "hostd-update.log"}" 2>&1 || true\n'
+        "MESHCODE_NO_AUTO_UPDATE=1; export MESHCODE_NO_AUTO_UPDATE\n"
+        f"exec {mc_inv} hostd run\n",
+        encoding="utf-8",
+    )
+    try:
+        os.chmod(wrapper, 0o755)
+    except Exception:
+        pass
+    args = ["/bin/sh", str(wrapper)]
+    args_xml = "\n".join(f"        <string>{a}</string>" for a in args)
     return f"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -2638,6 +2696,17 @@ def _hostd_install_windows() -> int:
         'set "MESHCODE_NO_UPDATE=1"\r\n'        # var honored pre-2.11.74 (belt-and-suspenders)
         'set "MESHCODE_NO_AUTO_UPDATE=1"\r\n'   # unified var (honored 2.11.74+)
         'set "MESHCODE_HOSTD_POLL_SEC=10"\r\n'  # faster click->spawn (default 10s, floor 3)
+        # task d84cbfa1 (version-split self-heal): self-upgrade to the latest version
+        # BEFORE starting hostd so a machine frozen on an OLD version autocures on the
+        # next launch (anti chicken-egg). Clear the two NO_*UPDATE guards for THIS one
+        # explicit step (they're re-set right after), then run the deferral-safe
+        # `self-upgrade` (force=False -> skips the overwrite if a live agent serve
+        # shares the env). The in-loop auto-update stays guarded by the re-set vars.
+        'set "MESHCODE_NO_UPDATE="\r\n'
+        'set "MESHCODE_NO_AUTO_UPDATE="\r\n'
+        f'"{mc}" self-upgrade\r\n'
+        'set "MESHCODE_NO_UPDATE=1"\r\n'
+        'set "MESHCODE_NO_AUTO_UPDATE=1"\r\n'
         # F1a (task 48c3f294): launch the SUPERVISOR, not `hostd run` directly.
         # The supervisor owns + revives hostd on CRASH — the recovery the HKCU\Run
         # tier (login-only) lacks (that was the dead launch button on Samuel's box).
@@ -2720,6 +2789,17 @@ def _hostd_install_linux() -> int:
     (STATE_DIR / "logs").mkdir(parents=True, exist_ok=True)
     argv = _hostd_run_argv()
     execstart = " ".join(shlex.quote(a) for a in argv)
+    # task d84cbfa1 (version-split self-heal): self-upgrade BEFORE ExecStart so a host
+    # frozen on an OLD version autocures on the next launch (anti chicken-egg). The unit
+    # sets MESHCODE_NO_*UPDATE=1 globally (keeps the in-loop auto-update deferral-safe),
+    # so the pre-step CLEARS them for this one explicit, deferral-safe `self-upgrade`
+    # (force=False -> skips the overwrite if a live agent serve shares the env). `|| true`
+    # so a failed/offline upgrade never blocks ExecStart.
+    _mc = shutil.which("meshcode")
+    _selfupg = [_mc, "self-upgrade"] if _mc else [sys.executable, "-m", "meshcode", "self-upgrade"]
+    _selfupg_str = " ".join(shlex.quote(a) for a in _selfupg)
+    preexec = "/bin/sh -c " + shlex.quote(
+        f"MESHCODE_NO_UPDATE= MESHCODE_NO_AUTO_UPDATE= {_selfupg_str} || true")
     if shutil.which("systemctl"):
         unit_dir = Path.home() / ".config" / "systemd" / "user"
         unit_dir.mkdir(parents=True, exist_ok=True)
@@ -2728,6 +2808,7 @@ def _hostd_install_linux() -> int:
             "[Service]\nType=simple\n"
             "Environment=MESHCODE_NO_UPDATE=1\nEnvironment=MESHCODE_NO_AUTO_UPDATE=1\n"
             "Environment=MESHCODE_HOSTD_POLL_SEC=10\n"
+            f"ExecStartPre={preexec}\n"
             f"ExecStart={execstart}\nRestart=on-failure\nRestartSec=10\n\n"
             "[Install]\nWantedBy=default.target\n",
             encoding="utf-8",
@@ -3187,6 +3268,17 @@ def cmd_hostd(args: list) -> int:
                  f"(budget {_WEDGE_MAX_RESTARTS}/{_WEDGE_WINDOW_S}s)")
         except Exception as e:
             _log(f"WARN: wedge watchdog failed to arm ({e}) — daemon runs unprotected")
+        # task d84cbfa1: converge-UP ONCE at run-startup. A hostd launched on STALE
+        # bytecode (launcher self-upgrade absent on an old machine, or a versioned env
+        # newer than this interpreter) re-execs onto the newest installed version HERE,
+        # BEFORE the poll loop spawns any agent — so the live-agent deferral is never at
+        # risk (no serve children exist yet). No-op when already current; smoke-gated +
+        # loop-guarded inside. Previously this fired only mid-sweep, so a daemon started
+        # stale stayed stale until the first drift sweep.
+        try:
+            _maybe_self_restart_on_version_drift()
+        except Exception as e:
+            _log(f"WARN: startup converge-up check failed ({e}); continuing on {_RUNNING_VERSION}")
         # uptime-since-spawn (core's suggestion): if the daemon dies <2min, the last alive log +
         # the uptime stamped on the FATAL line reveal the <2min pattern for RC.
         _spawn_mono = time.monotonic()

{meshcode-2.11.159 → meshcode-2.11.160}/meshcode/self_update.py

@@ -543,6 +543,41 @@ def _env_python(version: str) -> Path:
     return ENVS_DIR / version / sub / exe
 
 
+def newest_installed_env() -> Optional[tuple]:
+    """Return ``(version, python_path)`` for the newest FINALIZED immutable env
+    under ``ENVS_DIR`` — one whose ``.build-ok`` marker exists and whose
+    python interpreter is present — or None when no built env exists.
+
+    Used by hostd startup converge-UP (task d84cbfa1): a daemon launched on
+    STALE bytecode can adopt the newest version that boot-always-latest already
+    built locally, without depending on the in-process upgrade path or a fresh
+    PyPI probe (anti chicken-egg). Skips in-flight ``.tmp-*`` builds. Never
+    raises."""
+    try:
+        if not ENVS_DIR.exists():
+            return None
+        best_ver = None
+        best_py = None
+        for d in ENVS_DIR.iterdir():
+            try:
+                if not d.is_dir() or d.name.startswith(".tmp-"):
+                    continue
+                if not (d / _ENV_OK_MARKER).exists():
+                    continue
+                py = _env_python(d.name)
+                if not py.exists():
+                    continue
+                if best_ver is None or _is_newer(d.name, best_ver):
+                    best_ver, best_py = d.name, py
+            except Exception:
+                continue
+        if best_ver is None:
+            return None
+        return best_ver, best_py
+    except Exception:
+        return None
+
+
 def _prune_stale_tmp_envs(max_age_sec: int = 3600) -> None:
     """Best-effort removal of leftover .tmp-<ver>-<pid> env dirs left by
     crashed or locked-rename builds — the Windows version-split litter

{meshcode-2.11.159 → meshcode-2.11.160}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.159 → meshcode-2.11.160}/pyproject.toml

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