meshcode 2.11.25__tar.gz → 2.11.27__tar.gz

{meshcode-2.11.25 → meshcode-2.11.27}/PKG-INFO

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

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode/__init__.py

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

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode/comms_v4.py

@@ -2597,13 +2597,20 @@ EXAMPLES:
   meshcode run backend
   meshcode run my-app/backend --editor cursor
 """,
-    "go": """meshcode go <agent> [--project <name>]
+    "go": """meshcode go <agent> [--project <name>] [--dry-run]
 
 Shortcut for setup + run. Creates workspace if needed, then launches.
 
+  --dry-run    Run every bootstrap step (auth, workspace, .mcp.json,
+               editor detection, banner) but stop just before the
+               heartbeat + editor exec. Returns 0 on a clean path.
+               Use in CI / pre-publish smokes to catch import-time
+               sys.exit and env-guard regressions.
+
 EXAMPLES:
   meshcode go backend
   meshcode go my-app/frontend
+  meshcode go my-app/frontend --dry-run
 """,
     "scan": """meshcode scan
 
@@ -3234,6 +3241,11 @@ if __name__ == "__main__":
             perm_override = "bypass"
         elif "--safe" in sys.argv:
             perm_override = "safe"
+        # --dry-run: exercise the full bootstrap codepath but stop just
+        # before pre-flight heartbeat + execvp(editor). Returns 0 on a
+        # clean path. Catches import-time sys.exit / env-guard regressions
+        # before they hit users (cf. 2.11.11 BUG-COMMANDER-MCP-BOOT).
+        dry_run = "--dry-run" in sys.argv
         # Auth pre-check: if not logged in, prompt inline
         api_key = _load_api_key_for_cli()
         if not api_key:
@@ -3249,7 +3261,7 @@ if __name__ == "__main__":
                 sys.exit(1)
         import importlib
         _run = importlib.import_module("meshcode.run_agent").run
-        sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override))
+        sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override, dry_run=dry_run))
 
     elif cmd == "scan":
         # meshcode scan — detect identicon from stdin/clipboard and launch agent

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode/meshcode_mcp/server.py

@@ -5398,6 +5398,42 @@ def meshcode_remember(
     return result
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_seed_fixture(
+    table: str,
+    overrides: Optional[Dict[str, Any]] = None,
+    ttl_seconds: int = 3600,
+) -> Dict[str, Any]:
+    """Seed a fixture row in a whitelisted table for Playwright/verify.
+    MESH-IMPROVE-7 (mig 345). Whitelist: mc_tasks, mc_messages, mc_agents.
+    Auto-swept after ttl_seconds (min 60). Pair with meshcode_release_fixture.
+    """
+    if table not in ("mc_tasks", "mc_messages", "mc_agents"):
+        return {"error": "table not seedable",
+                "hint": "whitelist: mc_tasks, mc_messages, mc_agents"}
+    return be.sb_rpc("mc_seed_fixture", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_table": table,
+        "p_overrides": overrides or {},
+        "p_ttl_seconds": max(int(ttl_seconds), 60),
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_release_fixture(row_id: str) -> Dict[str, Any]:
+    """Release a fixture row immediately (don't wait for sweeper).
+    MESH-IMPROVE-7 (mig 345)."""
+    if not row_id or not row_id.strip():
+        return {"error": "row_id cannot be empty"}
+    return be.sb_rpc("mc_release_fixture", {
+        "p_api_key": _get_api_key(),
+        "p_row_id": row_id.strip(),
+    })
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_register_skills(skills: List[str]) -> Dict[str, Any]:

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode/rpc_allowlist.py

@@ -107,6 +107,9 @@ AGENT_CALLABLE_RPCS = [
     # Skill parity (mig 344)
     "mc_register_skills",
     "mc_mandate_skill",
+    # Fixture seeding (mig 345)
+    "mc_seed_fixture",
+    "mc_release_fixture",
 ]
 
 

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode/run_agent.py

@@ -678,13 +678,24 @@ def _preflight_heartbeat(agent: str, project: str) -> None:
         print(f"[meshcode]   Pre-flight heartbeat skipped: {e}", file=sys.stderr)
 
 
-def run(agent: str, project: Optional[str] = None, editor_override: Optional[str] = None, permission_override: Optional[str] = None) -> int:
-    """Launch the user's editor with ONLY the named agent's MCP server loaded."""
-    # Non-blocking self-update check (consumes prior result, may spawn bg pip)
-    try:
-        self_update.check_and_maybe_update()
-    except Exception:
-        pass
+def run(agent: str, project: Optional[str] = None, editor_override: Optional[str] = None, permission_override: Optional[str] = None, dry_run: bool = False) -> int:
+    """Launch the user's editor with ONLY the named agent's MCP server loaded.
+
+    dry_run: when True, exercise the full bootstrap codepath (auth check,
+    workspace + .mcp.json validation, editor detection, banner generation,
+    env-var assembly, cmd construction) but stop just before mutating shared
+    state (pre-flight heartbeat) and replacing the process (execvp). Print
+    "[meshcode] DRY-RUN OK: ..." and return 0. Designed to catch bootstrap-
+    class bugs (import-time sys.exit, missing env-var guards, broken cross-
+    process imports — cf. BUG-COMMANDER-MCP-BOOT 2026-05-20) before publish.
+    """
+    # Non-blocking self-update check (consumes prior result, may spawn bg pip).
+    # Skip in dry-run — we don't want CI / pre-publish smokes to fork a pip.
+    if not dry_run:
+        try:
+            self_update.check_and_maybe_update()
+        except Exception:
+            pass
 
     # Detect: are we already inside a Claude Code session? os.execvp(claude)
     # from inside an existing claude won't work — claude needs a fresh
@@ -846,15 +857,12 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         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
+    # NOTE: do not import meshcode_mcp.server from this module. server.py has
+    # a module-level MESHCODE_PROJECT/AGENT precondition that sys.exit(2)s when
+    # those vars are not set in the parent shell — kills `meshcode go` on
+    # fresh machines. _fetch_or_generate_art below already fetches the profile
+    # color synchronously, so the banner gets the real color without any
+    # cross-process coordination.
 
     # ── Welcome banner with unique ASCII art + personality ──────────
     try:
@@ -993,6 +1001,17 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         except OSError:
             pass  # No devnull (unlikely) — let the editor handle it
 
+    # Dry-run bail-out: every validation above has passed, the editor cmd
+    # is fully assembled, and the next step (heartbeat + execvp) would
+    # mutate shared state. CI / pre-publish smokes stop here.
+    if dry_run:
+        print(
+            f"[meshcode] DRY-RUN OK: would exec {cmd[0]!r} for "
+            f"{resolved_project}/{agent} from cwd {os.getcwd()!r}",
+            file=sys.stderr,
+        )
+        return 0
+
     # Pre-flight heartbeat: mark the agent as online BEFORE the editor
     # subprocess spawns. On Windows without bypass mode, Claude Code may
     # delay starting the MCP server until the user interacts — leaving the

meshcode-2.11.27/meshcode/self_update.py

@@ -0,0 +1,370 @@
+"""Background self-update for the meshcode CLI.
+
+Design goals:
+  - ZERO added latency to `meshcode run`. The PyPI check + pip install
+    runs in a fully detached background subprocess. The current launch
+    is never blocked.
+  - Opt-in (first-run prompt, like permission_mode). Default ON for
+    interactive TTY users, default OFF for CI / non-TTY.
+  - Cache the PyPI check for 1 hour so we don't hit the network on
+    every launch.
+  - Two-launch model: launch N detects + downloads in the background;
+    launch N+1 reads the result file, prints "[meshcode] updated X → Y",
+    and the new code is already on disk.
+  - Safe in all the edge cases that bite Python CLI updaters:
+      * editable installs (dev mode) → skip
+      * pipx installs → use `pipx upgrade meshcode`
+      * MCP server subprocess → skip (we're inside an agent runtime)
+      * --no-update flag, MESHCODE_NO_UPDATE=1 env → skip
+      * offline / network error → silent skip
+      * concurrent runs → file lock so only one bg update at a time
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional, Tuple
+
+PKG_NAME = "meshcode"
+PYPI_URL = f"https://pypi.org/pypi/{PKG_NAME}/json"
+CACHE_TTL_SEC = 3600  # 1 hour
+NETWORK_TIMEOUT_SEC = 1.5
+
+STATE_DIR = Path.home() / ".meshcode"
+RESULT_PATH = STATE_DIR / ".update_result.json"
+LOCK_PATH = STATE_DIR / ".update.lock"
+LOG_PATH = STATE_DIR / "update.log"
+LOCK_STALE_SEC = 600  # 10 min — if a lock is older, treat as crashed
+
+
+# ============================================================
+# Detection helpers — when NOT to auto-update
+# ============================================================
+
+def _current_version() -> str:
+    try:
+        from . import __version__
+        return __version__
+    except Exception:
+        return "0.0.0"
+
+
+def is_editable_install() -> bool:
+    """True if meshcode is installed via `pip install -e .` (dev mode)."""
+    try:
+        import meshcode
+        path = os.path.realpath(meshcode.__file__)
+        return "site-packages" not in path and "dist-packages" not in path
+    except Exception:
+        return False
+
+
+def is_user_site_install() -> bool:
+    """True if meshcode is installed in the per-user site (`pip install --user`).
+
+    Used to keep the upgrade in the same site so the user-PATH shim
+    (e.g. ~/Library/Python/3.X/bin/meshcode) stays valid. Without this,
+    `pip install -U` falls back to system-site and orphans the binary
+    the user's PATH points at.
+    """
+    try:
+        import site
+        import meshcode
+        path = os.path.realpath(meshcode.__file__)
+        user_site = os.path.realpath(site.getusersitepackages())
+        return path.startswith(user_site + os.sep)
+    except Exception:
+        return False
+
+
+def is_inside_mcp_serve() -> bool:
+    """True if we're running inside the MCP subprocess of an agent client."""
+    if os.environ.get("MESHCODE_MCP_SERVE") == "1":
+        return True
+    argv0 = " ".join(sys.argv).lower()
+    return "meshcode_mcp" in argv0 or "meshcode.meshcode_mcp" in argv0
+
+
+def is_pipx_install() -> bool:
+    """True if installed via pipx (we should use `pipx upgrade` instead)."""
+    exe = os.path.realpath(sys.executable)
+    return "/pipx/" in exe or "\\pipx\\" in exe
+
+
+def update_disabled() -> bool:
+    """User explicitly opted out for this run / globally."""
+    if os.environ.get("MESHCODE_NO_UPDATE") == "1":
+        return True
+    if "--no-update" in sys.argv:
+        return True
+    return False
+
+
+def _version_tuple(v: str) -> Tuple[int, ...]:
+    parts = []
+    for p in v.split("."):
+        digits = "".join(c for c in p if c.isdigit())
+        parts.append(int(digits) if digits else 0)
+    return tuple(parts)
+
+
+def _is_newer(remote: str, local: str) -> bool:
+    try:
+        return _version_tuple(remote) > _version_tuple(local)
+    except Exception:
+        return False
+
+
+# ============================================================
+# Cache + result file (consumed by next launch)
+# ============================================================
+
+def _read_prefs() -> dict:
+    try:
+        from .preferences import load_prefs
+        return load_prefs()
+    except Exception:
+        return {}
+
+
+def _write_prefs_kv(**kv) -> None:
+    try:
+        from .preferences import load_prefs, save_prefs
+        prefs = load_prefs()
+        prefs.update(kv)
+        save_prefs(prefs)
+    except Exception:
+        pass
+
+
+def _cache_fresh() -> bool:
+    last = _read_prefs().get("last_update_check_at", 0)
+    return (time.time() - last) < CACHE_TTL_SEC
+
+
+def _mark_checked(latest: Optional[str]) -> None:
+    _write_prefs_kv(
+        last_update_check_at=int(time.time()),
+        last_known_latest_version=latest or _current_version(),
+    )
+
+
+def consume_pending_result() -> None:
+    """Read + delete .update_result.json, print outcome to stderr.
+
+    Called at the START of each `meshcode run` to surface what the
+    previous launch's background updater did.
+    """
+    if not RESULT_PATH.exists():
+        return
+    try:
+        data = json.loads(RESULT_PATH.read_text(encoding="utf-8"))
+        RESULT_PATH.unlink(missing_ok=True)
+    except Exception:
+        return
+    cur = _current_version()
+    new_v = data.get("version") or "?"
+    if data.get("ok"):
+        if _is_newer(new_v, cur):
+            print(f"[meshcode] updated {cur} → {new_v}. Restart your editor to load the new version.", file=sys.stderr)
+        else:
+            # update ran but pip didn't actually upgrade (already at latest)
+            pass
+    else:
+        err = data.get("error", "unknown error")
+        print(f"[meshcode] WARN: last auto-update failed: {err}", file=sys.stderr)
+
+
+# ============================================================
+# Network — PyPI version probe
+# ============================================================
+
+def fetch_latest_version(timeout: float = NETWORK_TIMEOUT_SEC) -> Optional[str]:
+    try:
+        import urllib.request
+        req = urllib.request.Request(PYPI_URL, headers={"User-Agent": f"meshcode/{_current_version()}"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+# ============================================================
+# File lock — prevent concurrent bg updates
+# ============================================================
+
+def _acquire_lock() -> bool:
+    try:
+        if LOCK_PATH.exists():
+            age = time.time() - LOCK_PATH.stat().st_mtime
+            if age < LOCK_STALE_SEC:
+                return False
+            LOCK_PATH.unlink(missing_ok=True)
+        LOCK_PATH.parent.mkdir(parents=True, exist_ok=True)
+        LOCK_PATH.write_text(str(os.getpid()), encoding="utf-8")
+        return True
+    except Exception:
+        return False
+
+
+# ============================================================
+# Background update spawn
+# ============================================================
+
+_BG_RUNNER_PY = r'''
+import json, os, subprocess, sys, time
+from pathlib import Path
+
+result = {"version": None, "ok": False, "error": None, "finished_at": None}
+state_dir = Path.home() / ".meshcode"
+result_path = state_dir / ".update_result.json"
+lock_path = state_dir / ".update.lock"
+log_path = state_dir / "update.log"
+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"
+
+try:
+    if mode == "pipx":
+        cmd = ["pipx", "upgrade", "meshcode"]
+    else:
+        cmd = [sys.executable, "-m", "pip", "install", "-U", "--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":
+            cmd.append("--user")
+        cmd.append("meshcode")
+    with open(log_path, "ab") as logf:
+        logf.write(f"\n=== {time.strftime('%Y-%m-%d %H:%M:%S')} bg update via {mode} ===\n".encode())
+        logf.flush()
+        proc = subprocess.run(cmd, stdout=logf, stderr=logf, timeout=180)
+    if proc.returncode == 0:
+        result["ok"] = True
+        result["version"] = target_version
+    else:
+        result["error"] = f"pip exit {proc.returncode}"
+except subprocess.TimeoutExpired:
+    result["error"] = "pip install timed out after 180s"
+except Exception as e:
+    result["error"] = str(e)
+finally:
+    result["finished_at"] = int(time.time())
+    try:
+        result_path.write_text(json.dumps(result), encoding="utf-8")
+    except Exception:
+        pass
+    try:
+        lock_path.unlink()
+    except Exception:
+        pass
+'''
+
+
+def _spawn_background_updater(target_version: str) -> 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.
+    """
+    if not _acquire_lock():
+        return False
+
+    mode = "pipx" if is_pipx_install() else "pip"
+    site_flag = "user" if (mode == "pip" and is_user_site_install()) else "system"
+
+    # 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]
+
+    try:
+        if sys.platform == "win32":
+            DETACHED_PROCESS = 0x00000008
+            CREATE_NEW_PROCESS_GROUP = 0x00000200
+            CREATE_NO_WINDOW = 0x08000000
+            flags = DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
+            proc = subprocess.Popen(
+                args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                creationflags=flags,
+                close_fds=True,
+            )
+        else:
+            proc = subprocess.Popen(
+                args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+                close_fds=True,
+            )
+        if proc.stdin:
+            proc.stdin.write(_BG_RUNNER_PY.encode("utf-8"))
+            proc.stdin.close()
+        return True
+    except Exception:
+        try:
+            LOCK_PATH.unlink(missing_ok=True)
+        except Exception:
+            pass
+        return False
+
+
+# ============================================================
+# Public entrypoint — called from meshcode run
+# ============================================================
+
+def check_and_maybe_update(verbose: bool = False) -> None:
+    """Non-blocking. Call at the start of `meshcode run`.
+
+    Order of checks (any failure → silent return, never raise):
+      1. consume any pending result from previous launch
+      2. opt-out gates: --no-update, MESHCODE_NO_UPDATE=1
+      3. context gates: editable install, MCP subprocess
+      4. user preference: resolve_auto_update() (may prompt first time)
+      5. cache TTL: skip if checked < 1h ago
+      6. PyPI fetch (1.5s timeout)
+      7. version compare; if newer → spawn background updater
+    """
+    try:
+        consume_pending_result()
+    except Exception:
+        pass
+
+    if update_disabled():
+        return
+    if is_inside_mcp_serve():
+        return
+    if is_editable_install():
+        return
+
+    try:
+        from .preferences import resolve_auto_update
+        if not resolve_auto_update():
+            return
+    except Exception:
+        return
+
+    if _cache_fresh():
+        return
+
+    latest = fetch_latest_version()
+    _mark_checked(latest)
+    if not latest:
+        return
+    if not _is_newer(latest, _current_version()):
+        return
+
+    started = _spawn_background_updater(latest)
+    if started and verbose:
+        print(f"[meshcode] downloading {latest} in background...", file=sys.stderr)

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.25 → meshcode-2.11.27}/meshcode.egg-info/SOURCES.txt

@@ -217,7 +217,10 @@ tests/test_realtime_event_freshness.py
 tests/test_rls_cross_tenant.py
 tests/test_rpc_grants.py
 tests/test_rpc_migrations.py
+tests/test_run_agent_dry_run.py
+tests/test_run_agent_no_server_import.py
 tests/test_security_regressions.py
+tests/test_self_update_user_site.py
 tests/test_sentinel.py
 tests/test_setup_path.py
 tests/test_sleep_signals.py

{meshcode-2.11.25 → meshcode-2.11.27}/pyproject.toml

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