meshcode 2.11.9__tar.gz → 2.11.11__tar.gz

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

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

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

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

meshcode-2.11.11/meshcode/__main__.py

@@ -0,0 +1,42 @@
+"""Helpful error when user invokes `python -m meshcode` because the
+console-script isn't on PATH yet (B5 friction).
+
+Also dispatches `python -m meshcode setup-path` to the real CLI so the
+user can fix PATH without needing the `meshcode` binary on PATH first.
+"""
+import os
+import sys
+
+
+def main():
+    # If the user explicitly asked to set up PATH, delegate to the real CLI.
+    if len(sys.argv) > 1 and sys.argv[1] == "setup-path":
+        from meshcode import comms_v4 as _cv  # noqa: F401
+        sys.argv[0] = "meshcode"
+        # comms_v4 runs main() at module load via `if __name__ == "__main__"`.
+        # Re-exec the body by importing as __main__ would require executing
+        # the module again; simpler: invoke via runpy.
+        import runpy
+        runpy.run_module("meshcode.comms_v4", run_name="__main__", alter_sys=True)
+        return
+
+    # Otherwise: the user is here because `meshcode` isn't on PATH.
+    print()
+    print("  meshcode is installed but the `meshcode` command isn't on your PATH.")
+    print()
+    print("  Quick fix:")
+    print(f"    {sys.executable} -m meshcode setup-path")
+    print()
+    print("  Or manually:")
+    v = sys.version_info
+    if sys.platform == "darwin":
+        print(f'    export PATH="$HOME/Library/Python/{v.major}.{v.minor}/bin:$PATH"')
+    else:
+        print('    export PATH="$(python3 -m site --user-base)/bin:$PATH"')
+    print()
+    print("  Then re-run: meshcode --help")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -2143,6 +2143,30 @@ def cmd_doctor(flags, pos):
     except Exception as e:
         fail("MCP server", f"import error: {e}. Run: pip install --upgrade meshcode")
 
+    # 4d. Env checks (B2 + B9): Python stub, SSL, PATH, Claude, Node, git, prefs
+    try:
+        from meshcode.doctor import CHECKS as _env_checks
+        # Skip ones cmd_doctor already covered (python version, api key)
+        from meshcode.doctor import (
+            _check_python,
+            _check_api_key,
+            _check_meshcode_on_path,  # cmd_doctor doesn't check this
+        )
+        _seen = set()
+        for _fn in _env_checks:
+            if _fn in (_check_python, _check_api_key):
+                continue
+            try:
+                _lvl, _title, _detail = _fn()
+                if _title in _seen:
+                    continue
+                _seen.add(_title)
+                {"ok": ok, "warn": warn, "fail": fail}[_lvl](_title, _detail)
+            except Exception as _e:
+                warn(_fn.__name__.lstrip("_"), f"check crashed: {_e}")
+    except ImportError:
+        pass  # doctor module not available (legacy install)
+
     # 5. Stale agents check (requires auth)
     if api_key:
         try:
@@ -2745,8 +2769,33 @@ if __name__ == "__main__":
         print("  " + "=" * 40)
         print()
 
-        # Try device-code pairing first
-        pairing = sb_rpc("mc_create_pairing_session", {})
+        # B2 pre-flight: refuse to onboard if env is broken
+        from meshcode.doctor import run_doctor
+        if run_doctor(skip_api_key_check=True) != 0:
+            print()
+            print("  [meshcode] Fix the blocker(s) above, then run `meshcode init` again.")
+            sys.exit(1)
+        print()
+
+        # B3: wrap pairing RPC so SSL / network errors abort cleanly (no
+        # silent fall-through to API-key paste — friction #7).
+        try:
+            pairing = sb_rpc("mc_create_pairing_session", {})
+        except Exception as _init_e:
+            _msg = str(_init_e).lower()
+            if "certificate" in _msg or "ssl" in _msg:
+                print()
+                print("  [meshcode] SSL certificate verification failed.")
+                print("  [meshcode] This usually means your Python install is missing root certs.")
+                _v = sys.version_info
+                print(f"  [meshcode] Fix: run /Applications/Python\\ {_v.major}.{_v.minor}/Install\\ Certificates.command")
+                print(f"  [meshcode] (Replace {_v.major}.{_v.minor} with your actual installed version.)")
+                print(f"  [meshcode] Alternative: pip install --upgrade certifi")
+            else:
+                print()
+                print(f"  [meshcode] Pairing service unreachable: {_init_e}")
+                print(f"  [meshcode] Check your network, then re-run `meshcode init`.")
+            sys.exit(1)
         if pairing and isinstance(pairing, dict) and pairing.get("ok"):
             session_id = pairing["session_id"]
             code = pairing["code"]
@@ -2819,7 +2868,7 @@ if __name__ == "__main__":
     # doctor, help, version, login, prefs, launcher don't need auth.
     _NO_AUTH_CMDS = {"doctor", "compat", "upgrade", "help", "--help", "-h", "login",
                      "init", "prefs", "launcher", "--version", "-V", "version",
-                     "whoami", "profiles", "scan"}
+                     "whoami", "profiles", "scan", "setup-path"}
     if cmd not in _NO_AUTH_CMDS:
         _cli_key = _load_api_key_for_cli()
         if not _cli_key:
@@ -3430,6 +3479,69 @@ if __name__ == "__main__":
             print("       meshcode prefs reset")
             sys.exit(1)
 
+    elif cmd == "setup-path":
+        # B5: append Python user-bin to user's shell rc file (idempotent).
+        # Friction #8 fix: after `pip install --user meshcode`, `meshcode`
+        # isn't on PATH; this gives the user a one-command remediation.
+        import platform as _pl
+        import subprocess as _sp
+        _v = sys.version_info
+        if _pl.system() == "Darwin":
+            user_bin = os.path.expanduser(f"~/Library/Python/{_v.major}.{_v.minor}/bin")
+        else:
+            try:
+                user_bin = _sp.check_output(
+                    [sys.executable, "-m", "site", "--user-base"],
+                    text=True, timeout=5,
+                ).strip() + "/bin"
+            except Exception:
+                user_bin = os.path.expanduser("~/.local/bin")
+
+        shell = os.environ.get("SHELL", "")
+        if "zsh" in shell:
+            rc = os.path.expanduser("~/.zshrc")
+            fish = False
+        elif "fish" in shell:
+            rc = os.path.expanduser("~/.config/fish/config.fish")
+            fish = True
+        else:
+            rc = os.path.expanduser("~/.bashrc")
+            fish = False
+
+        marker = "# meshcode: PATH for user-installed Python binaries"
+        line = (f"set -gx PATH {user_bin} $PATH" if fish
+                else f'export PATH="{user_bin}:$PATH"')
+
+        existing = ""
+        try:
+            if os.path.exists(rc):
+                with open(rc) as f:
+                    existing = f.read()
+        except Exception:
+            pass
+
+        if user_bin in existing:
+            print(f"[meshcode] {rc} already exports {user_bin} — nothing to do.")
+            sys.exit(0)
+
+        try:
+            os.makedirs(os.path.dirname(rc), exist_ok=True)
+            with open(rc, "a") as f:
+                f.write(f"\n{marker}\n{line}\n")
+            print(f"[meshcode] Appended PATH export to {rc}")
+            print(f"[meshcode] Open a new terminal OR run: source {rc}")
+            print(f"[meshcode] Then: meshcode --help")
+            sys.exit(0)
+        except PermissionError:
+            print(f"[meshcode] ERROR: cannot write {rc} (permission denied).")
+            print(f"[meshcode] Manually add this line to your shell rc:")
+            print(f"  {line}")
+            sys.exit(1)
+        except Exception as _spe:
+            print(f"[meshcode] ERROR: {_spe}")
+            print(f"[meshcode] Manually add: {line}")
+            sys.exit(1)
+
     elif cmd == "upgrade":
         # meshcode upgrade — interactive foreground upgrade
         import importlib

meshcode-2.11.11/meshcode/doctor.py

@@ -0,0 +1,277 @@
+"""Pre-flight environment checks. `meshcode doctor` runs all and reports.
+
+Each check returns (level, title, detail):
+  level: "ok" | "warn" | "fail"
+  title: short identifier shown to user
+  detail: actionable fix when not OK ("" when OK)
+
+Exit code: 1 if any "fail", else 0 (warnings allowed).
+
+Covers frictions #4 Python stub, #5 SSL certs, #8 PATH, #10 git/CLT modal,
+#11 Claude not installed. Used as pre-flight by `meshcode init`.
+"""
+import os
+import sys
+import json
+import shutil
+import subprocess
+import urllib.request
+import urllib.error
+from typing import List, Tuple
+
+Status = Tuple[str, str, str]
+
+_HEALTH_URL = "https://meshcode.io/health"
+_SUPABASE_URL = "https://supabase.co"
+
+
+def _check_python() -> Status:
+    v = sys.version_info
+    if (v.major, v.minor) < (3, 9):
+        return (
+            "fail",
+            f"Python {v.major}.{v.minor}.{v.micro}",
+            "need Python >=3.9; install from python.org or `brew install python@3.13`",
+        )
+    # macOS Apple-stub detection: importing ssl on the stub fails
+    if sys.platform == "darwin":
+        try:
+            import ssl
+
+            _ = ssl.OPENSSL_VERSION
+        except Exception as e:
+            return (
+                "fail",
+                f"Python {v.major}.{v.minor}.{v.micro}",
+                f"Apple stub Python detected (ssl import failed: {e}). "
+                f"Install real Python: https://www.python.org/downloads/",
+            )
+    return ("ok", f"Python {v.major}.{v.minor}.{v.micro}", "")
+
+
+def _check_ssl() -> Status:
+    try:
+        urllib.request.urlopen(_HEALTH_URL, timeout=5).read(64)
+        return ("ok", "SSL certs", "")
+    except urllib.error.URLError as e:
+        msg = str(e).lower()
+        if "certificate" in msg or "ssl" in msg:
+            fix = (
+                "run python's Install Certificates.command "
+                "(/Applications/Python <ver>/Install Certificates.command) "
+                "OR `pip install --upgrade certifi`"
+            )
+            return ("fail", "SSL certs", fix)
+        return ("warn", "SSL certs", f"network unreachable (skip if offline): {e}")
+    except Exception as e:
+        return ("warn", "SSL certs", f"check inconclusive: {e}")
+
+
+def _check_meshcode_on_path() -> Status:
+    for tool in ("meshcode", "meshcode-mcp"):
+        if not shutil.which(tool):
+            v = sys.version_info
+            if sys.platform == "darwin":
+                hint = (
+                    f'export PATH="$HOME/Library/Python/{v.major}.{v.minor}/bin:$PATH" '
+                    f'(or run: python3 -m meshcode setup-path)'
+                )
+            else:
+                hint = (
+                    "add Python user-base bin to PATH "
+                    "(python3 -m site --user-base)/bin "
+                    "or run: python3 -m meshcode setup-path"
+                )
+            return ("fail", f"`{tool}` on PATH", hint)
+    return ("ok", "meshcode CLI on PATH", "")
+
+
+def _check_claude() -> Status:
+    if shutil.which("claude"):
+        return ("ok", "Claude Code installed", "")
+    return (
+        "fail",
+        "Claude Code installed",
+        "install from https://claude.ai/install "
+        "or `npm i -g @anthropic-ai/claude-code`",
+    )
+
+
+def _check_node() -> Status:
+    needs_node = False
+    try:
+        from meshcode.preferences import load_prefs
+
+        cv = (load_prefs().get("claude_version") or "").lower()
+        if cv and cv not in ("latest", "none", "skip"):
+            needs_node = True
+    except Exception:
+        pass
+    if os.environ.get("MESHCODE_USE_NPX"):
+        needs_node = True
+    has_node = bool(shutil.which("node"))
+    has_npx = bool(shutil.which("npx"))
+    if has_node and has_npx:
+        return ("ok", "Node/npx", "")
+    level = "fail" if needs_node else "warn"
+    detail = (
+        "install Node: https://nodejs.org or `brew install node`"
+        if needs_node
+        else "only needed for `claude_version` pin or MESHCODE_USE_NPX; safe to skip"
+    )
+    return (level, "Node/npx", detail)
+
+
+def _check_git() -> Status:
+    """git pre-flight with Apple stub detection + safe workarounds (B9)."""
+    git = shutil.which("git")
+    if not git:
+        return (
+            "fail",
+            "git",
+            "git not installed. Recommended (skip Apple's brittle modal):\n"
+            "    - Manual CLT download: https://developer.apple.com/download/all/?q=command%20line%20tools\n"
+            "    - OR Git for Mac: https://git-scm.com/download/mac\n"
+            "    - OR `brew install git` (if Homebrew is installed)",
+        )
+    if sys.platform == "darwin":
+        try:
+            r = subprocess.run(
+                [git, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=3,
+            )
+            stderr_lower = (r.stderr or "").lower()
+            if (
+                r.returncode != 0
+                or "command line developer tools" in stderr_lower
+            ):
+                return (
+                    "fail",
+                    "git",
+                    "Apple stub git detected (would trigger CLT install modal). "
+                    "Install real git: "
+                    "https://developer.apple.com/download/all/?q=command%20line%20tools "
+                    "OR `brew install git` OR https://git-scm.com/download/mac",
+                )
+        except subprocess.TimeoutExpired:
+            return (
+                "fail",
+                "git",
+                "git subprocess hung — likely the CLT install modal is "
+                "blocked or pending. Cancel any open Apple dialog; install "
+                "git manually: https://git-scm.com/download/mac",
+            )
+        except Exception:
+            pass
+    return ("ok", "git", "")
+
+
+def _check_network() -> Status:
+    for url in (_HEALTH_URL, _SUPABASE_URL):
+        try:
+            urllib.request.urlopen(url, timeout=5).read(64)
+        except Exception as e:
+            return (
+                "warn",
+                "Network reachability",
+                f"{url} unreachable ({type(e).__name__}); "
+                f"check VPN/firewall if persistent",
+            )
+    return ("ok", "Network reachability", "")
+
+
+def _check_api_key() -> Status:
+    try:
+        from meshcode.secrets import get_api_key, list_profiles
+
+        profiles = list_profiles() or []
+        if not profiles:
+            return (
+                "warn",
+                "API key in keychain",
+                "no profiles — run `meshcode init` to pair and store one",
+            )
+        for p in profiles:
+            if get_api_key(profile=p):
+                return ("ok", f"API key (profile={p})", "")
+        return (
+            "warn",
+            "API key in keychain",
+            f"profiles exist ({profiles}) but no key retrievable — "
+            f"`meshcode init` to re-pair",
+        )
+    except Exception as e:
+        return ("warn", "API key in keychain", f"secrets module unavailable: {e}")
+
+
+def _check_prefs_json() -> Status:
+    pref = os.path.expanduser("~/.meshcode/preferences.json")
+    if not os.path.exists(pref):
+        return ("ok", "preferences.json", "(not created yet — default fine)")
+    try:
+        with open(pref) as f:
+            json.load(f)
+        return ("ok", "preferences.json", "")
+    except json.JSONDecodeError as e:
+        return (
+            "fail",
+            "preferences.json",
+            f"corrupt JSON ({e}); delete or fix: {pref}",
+        )
+    except Exception as e:
+        return ("warn", "preferences.json", f"unreadable: {e}")
+
+
+CHECKS = [
+    _check_python,
+    _check_ssl,
+    _check_meshcode_on_path,
+    _check_claude,
+    _check_node,
+    _check_git,
+    _check_network,
+    _check_api_key,
+    _check_prefs_json,
+]
+
+
+def run_doctor(skip_api_key_check: bool = False, quiet: bool = False) -> int:
+    """Run all checks, print results, return exit code (0 ok/warn, 1 fail)."""
+    results: List[Status] = []
+    for fn in CHECKS:
+        if skip_api_key_check and fn is _check_api_key:
+            continue
+        try:
+            results.append(fn())
+        except Exception as e:
+            results.append(("fail", fn.__name__.lstrip("_"), f"check crashed: {e}"))
+    blockers = 0
+    if not quiet:
+        print()
+        print("  meshcode doctor — environment check")
+        print("  " + "=" * 40)
+    for level, title, detail in results:
+        sym = {"ok": "✓", "warn": "⚠", "fail": "✗"}[level]
+        if level == "fail":
+            blockers += 1
+        line = f"  {sym} {title}"
+        if detail:
+            line += f" — {detail}"
+        if not quiet:
+            print(line)
+    if not quiet:
+        print()
+        if blockers:
+            print(
+                f"  {blockers} blocker(s) found — fix the above "
+                f"before `meshcode init`/`go`."
+            )
+        else:
+            print("  All checks passed (warnings non-blocking).")
+    return 1 if blockers else 0
+
+
+if __name__ == "__main__":
+    sys.exit(run_doctor())

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

@@ -45,9 +45,21 @@ _ANSI_RGB = [
     (255, 85, 85), (85, 255, 255), (255, 85, 255), (85, 255, 85), (85, 85, 255),
 ]
 
+# BUG-AUDIO-COLOR fix (task e552412a, 2026-05-19): use 24-bit truecolor
+# escapes when the terminal supports them so every terminal renders the
+# same agent color (4-bit palette indices are remapped by terminal themes,
+# producing the cross-machine mismatch Samuel saw).
+_TRUECOLOR_OK = os.environ.get("COLORTERM", "").lower() in ("truecolor", "24bit")
+
 
 def _hex_to_ansi(hex_color: str) -> str:
-    """Map hex color to nearest ANSI code."""
+    """Return ANSI escape for a hex color.
+
+    On truecolor-capable terminals returns 24-bit truecolor (\\e[38;2;R;G;Bm) so
+    the color bypasses palette remapping. Falls back to nearest 4-bit ANSI
+    palette index when COLORTERM is not truecolor.
+    Returns None if hex is malformed.
+    """
     hx = hex_color.strip().lstrip("#")
     if len(hx) != 6:
         return None
@@ -55,6 +67,9 @@ def _hex_to_ansi(hex_color: str) -> str:
         r, g, b = int(hx[0:2], 16), int(hx[2:4], 16), int(hx[4:6], 16)
     except ValueError:
         return None
+    if _TRUECOLOR_OK:
+        return f"\033[38;2;{r};{g};{b}m"
+    # Fallback: map to nearest 4-bit ANSI palette index
     best_i, best_d = 0, float("inf")
     for i, (ar, ag, ab) in enumerate(_ANSI_RGB):
         d = (r - ar) ** 2 + (g - ag) ** 2 + (b - ab) ** 2
@@ -65,10 +80,18 @@ def _hex_to_ansi(hex_color: str) -> str:
 
 
 def _agent_color(name: str) -> str:
-    """ANSI color from profile (dashboard) or MD5 hash fallback."""
+    """Profile-canonical color if cached, else a deterministic per-name color.
+    Never random — same name -> same color on every machine."""
     if _CACHED_AGENT_COLOR:
         return _CACHED_AGENT_COLOR
     h = int(_hashlib.md5(name.encode()).hexdigest()[:8], 16)
+    if _TRUECOLOR_OK:
+        # Pseudo-random but deterministic 24-bit color from the hash. Clamp
+        # mid-range so the color is readable on both dark and light terminals.
+        r = max(70, min(220, (h >> 16) & 0xFF))
+        g = max(70, min(220, (h >> 8) & 0xFF))
+        b = max(70, min(220, h & 0xFF))
+        return f"\033[38;2;{r};{g};{b}m"
     return _ANSI_COLORS[h % len(_ANSI_COLORS)]
 
 

{meshcode-2.11.9 → meshcode-2.11.11}/meshcode/run_agent.py

@@ -461,6 +461,19 @@ def _resolve_pinned_claude(editor_cmd: str) -> str:
     """
     from .preferences import load_prefs
 
+    # B4: if user opts into legacy npx path AND no version is specified,
+    # fall back to the historical ESC-safe pin (2.1.104). Otherwise default
+    # to using installed claude — no implicit Node dependency.
+    if (
+        os.environ.get("MESHCODE_USE_NPX")
+        and not os.environ.get("MESHCODE_CLAUDE_VERSION")
+    ):
+        os.environ["MESHCODE_CLAUDE_VERSION"] = "2.1.104"
+        print(
+            f"[meshcode] --use-npx requested; pinning to legacy ESC-safe 2.1.104",
+            file=sys.stderr,
+        )
+
     pinned = os.environ.get("MESHCODE_CLAUDE_VERSION", "").strip()
     if not pinned:
         # Check global admin config from DB
@@ -471,19 +484,24 @@ def _resolve_pinned_claude(editor_cmd: str) -> str:
     if not pinned:
         pinned = load_prefs().get("claude_version", "")
 
-    # "latest" or "none" means skip pinning — use whatever is installed
+    # "latest"/"none"/"skip" → explicit opt-out of any pin
     if pinned and pinned.lower() in ("latest", "none", "skip"):
         print(f"[meshcode] Version pin disabled ({pinned}) — using installed version", file=sys.stderr)
         return editor_cmd
 
+    # B4: default = use installed claude. No implicit Node/npx tax. Users who
+    # want a specific version pin must opt in via:
+    #   - `meshcode prefs claude-version <ver>`        (persistent)
+    #   - MESHCODE_CLAUDE_VERSION env var               (one-shot)
+    #   - --use-npx flag on `meshcode go`               (one-shot, sets env)
+    #
+    # The 2.1.104 ESC-safe pin used to be the default; it added a hard Node
+    # dependency for users who didn't expect one. The ESC-cancel bug it works
+    # around should be addressed in meshcode_mcp/server.py directly; until
+    # then, --use-npx remains the escape hatch.
     if not pinned:
-        # Default pin: v2.1.104 is the last Claude Code version where ESC
-        # doesn't kill the MCP server. Newer versions send CancelledError
-        # that cascades through the event loop. This default is overridden
-        # by any of the 3 pin sources above (set to "latest" to disable).
-        # Remove this default once Anthropic fixes the ESC bug upstream.
-        pinned = "2.1.104"
-        print(f"[meshcode] Default ESC-safe pin: Claude Code v{pinned}", file=sys.stderr)
+        print(f"[meshcode] Using installed Claude Code (no version pin).", file=sys.stderr)
+        return editor_cmd
 
     current = _get_claude_version(editor_cmd)
     if current == pinned:
@@ -792,6 +810,52 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             print("[meshcode]        Then verify: which claude", file=sys.stderr)
         return 2
 
+    # B9 pre-flight: warn early if git is missing or is the Apple stub.
+    # We don't block boot — many agents work without git — but surface the
+    # friction so the user isn't surprised by an Apple modal when the
+    # Claude Code shell tool first runs `git status`.
+    if sys.platform == "darwin":
+        try:
+            import shutil as _shutil
+            _git = _shutil.which("git")
+            if not _git:
+                print(
+                    "[meshcode] WARNING: git not found on PATH. Claude Code may "
+                    "trigger the macOS 'install developer tools' modal when it "
+                    "first runs git. Install manually: "
+                    "https://git-scm.com/download/mac or `brew install git`",
+                    file=sys.stderr,
+                )
+            else:
+                _r = subprocess.run(
+                    [_git, "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=3,
+                )
+                if (
+                    _r.returncode != 0
+                    or "command line developer tools" in (_r.stderr or "").lower()
+                ):
+                    print(
+                        "[meshcode] WARNING: Apple stub git detected. "
+                        "Real git: https://git-scm.com/download/mac or "
+                        "`brew install git`",
+                        file=sys.stderr,
+                    )
+        except Exception:
+            pass  # Soft-fail — boot must proceed regardless.
+
+    # BUG-AUDIO-COLOR fix: wait briefly for profile fetch to populate
+    # _CACHED_AGENT_COLOR before rendering the banner, so the boot art
+    # doesn't flash the deterministic-hash fallback color and then "jump"
+    # to the canonical profile color. Upper-bound 350ms.
+    try:
+        from .meshcode_mcp.server import _REGISTER_PROFILE_READY
+        _REGISTER_PROFILE_READY.wait(timeout=0.35)
+    except Exception:
+        pass
+
     # ── Welcome banner with unique ASCII art + personality ──────────
     try:
         from .ascii_art import generate_art, render_welcome

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

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

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

@@ -1,12 +1,14 @@
 README.md
 pyproject.toml
 meshcode/__init__.py
+meshcode/__main__.py
 meshcode/_stop_hook_template.py
 meshcode/ascii_art.py
 meshcode/cli.py
 meshcode/comms_v4.py
 meshcode/compat.py
 meshcode/daemon.py
+meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
 meshcode/invites.py
@@ -194,8 +196,10 @@ meshcode/scripts/check_secrets.py
 meshcode/scripts/race_rate_harness.py
 tests/test_auto_update_hardening.py
 tests/test_boot_bug_regression.py
+tests/test_color_truecolor.py
 tests/test_core.py
 tests/test_cross_agent_messaging.py
+tests/test_doctor.py
 tests/test_epistemic_v1_python_sdk.py
 tests/test_epistemic_v1_stop_conditions.py
 tests/test_esc_deaf_state.py
@@ -209,6 +213,7 @@ tests/test_rls_cross_tenant.py
 tests/test_rpc_migrations.py
 tests/test_security_regressions.py
 tests/test_sentinel.py
+tests/test_setup_path.py
 tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py
 tests/test_stay_on_loop_hook.py