meshcode 2.11.9__tar.gz → 2.11.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.9
+Version: 2.11.10
 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.10}/meshcode/__init__.py

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

{meshcode-2.11.9 → meshcode-2.11.10}/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"]

meshcode-2.11.10/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.10}/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,42 @@ 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.
+
     # ── Welcome banner with unique ASCII art + personality ──────────
     try:
         from .ascii_art import generate_art, render_welcome

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.9
+Version: 2.11.10
 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.10}/meshcode.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ 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
@@ -196,6 +197,7 @@ tests/test_auto_update_hardening.py
 tests/test_boot_bug_regression.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

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

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

meshcode-2.11.10/tests/test_doctor.py

@@ -0,0 +1,123 @@
+"""Tests for meshcode/doctor.py — env pre-flight checks."""
+import os
+import subprocess
+import sys
+from unittest import mock
+
+import pytest
+
+from meshcode import doctor
+
+
+def test_python_check_modern_returns_ok_or_fail():
+    level, title, _ = doctor._check_python()
+    assert level in ("ok", "fail")
+    if level == "ok":
+        assert "Python" in title
+
+
+def test_run_doctor_returns_0_when_all_ok(monkeypatch):
+    monkeypatch.setattr(doctor, "CHECKS", [lambda: ("ok", "fake", "")])
+    assert doctor.run_doctor(quiet=True) == 0
+
+
+def test_run_doctor_returns_1_on_failure(monkeypatch):
+    monkeypatch.setattr(doctor, "CHECKS", [lambda: ("fail", "fake", "fix me")])
+    assert doctor.run_doctor(quiet=True) == 1
+
+
+def test_run_doctor_warnings_dont_block(monkeypatch):
+    monkeypatch.setattr(
+        doctor,
+        "CHECKS",
+        [
+            lambda: ("ok", "a", ""),
+            lambda: ("warn", "b", "nbd"),
+        ],
+    )
+    assert doctor.run_doctor(quiet=True) == 0
+
+
+def test_run_doctor_skips_api_key_when_flagged(monkeypatch):
+    called = []
+
+    def _fake_api():
+        called.append(True)
+        return ("fail", "api", "x")
+
+    monkeypatch.setattr(doctor, "_check_api_key", _fake_api)
+    monkeypatch.setattr(doctor, "CHECKS", [_fake_api])
+    rc = doctor.run_doctor(skip_api_key_check=True, quiet=True)
+    assert rc == 0 and not called
+
+
+def test_check_crash_treated_as_fail(monkeypatch):
+    def _boom():
+        raise RuntimeError("kaboom")
+
+    monkeypatch.setattr(doctor, "CHECKS", [_boom])
+    assert doctor.run_doctor(quiet=True) == 1
+
+
+def test_prefs_json_corrupt(tmp_path, monkeypatch):
+    pref = tmp_path / "prefs.json"
+    pref.write_text("{invalid json")
+    orig_expand = os.path.expanduser
+    monkeypatch.setattr(
+        os.path,
+        "expanduser",
+        lambda p: str(pref) if "preferences.json" in p else orig_expand(p),
+    )
+    level, _, detail = doctor._check_prefs_json()
+    assert level == "fail" and "corrupt" in detail.lower()
+
+
+def test_git_check_apple_stub_returns_fail(monkeypatch):
+    """Apple stub git -- subprocess returns CLT-prompt-style stderr -> fail."""
+    fake = mock.MagicMock(
+        returncode=1,
+        stderr="git: command line developer tools missing",
+        stdout="",
+    )
+    monkeypatch.setattr(
+        "shutil.which",
+        lambda x: "/usr/bin/git" if x == "git" else None,
+    )
+    monkeypatch.setattr(subprocess, "run", lambda *a, **kw: fake)
+    monkeypatch.setattr(sys, "platform", "darwin")
+    level, _, detail = doctor._check_git()
+    assert level == "fail" and "Apple stub" in detail
+
+
+def test_git_check_real_git_passes(monkeypatch):
+    fake = mock.MagicMock(returncode=0, stderr="", stdout="git version 2.43.0")
+    monkeypatch.setattr(
+        "shutil.which",
+        lambda x: "/opt/homebrew/bin/git" if x == "git" else None,
+    )
+    monkeypatch.setattr(subprocess, "run", lambda *a, **kw: fake)
+    monkeypatch.setattr(sys, "platform", "darwin")
+    level, _, _ = doctor._check_git()
+    assert level == "ok"
+
+
+def test_git_check_timeout_returns_fail(monkeypatch):
+    monkeypatch.setattr(
+        "shutil.which",
+        lambda x: "/usr/bin/git" if x == "git" else None,
+    )
+
+    def _hang(*a, **kw):
+        raise subprocess.TimeoutExpired(cmd="git", timeout=3)
+
+    monkeypatch.setattr(subprocess, "run", _hang)
+    monkeypatch.setattr(sys, "platform", "darwin")
+    level, _, detail = doctor._check_git()
+    assert level == "fail" and "hung" in detail.lower()
+
+
+def test_git_check_missing_returns_fail(monkeypatch):
+    monkeypatch.setattr("shutil.which", lambda x: None)
+    level, _, detail = doctor._check_git()
+    assert level == "fail"
+    assert "git not installed" in detail