meshcode 2.11.168__tar.gz → 2.11.171__tar.gz

{meshcode-2.11.168 → meshcode-2.11.171}/PKG-INFO

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

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode/__init__.py

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

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode/comms_v4.py

@@ -3104,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", "self-upgrade", "help", "--help", "-h", "login",
+    _NO_AUTH_CMDS = {"doctor", "smoke", "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:
@@ -3603,36 +3603,6 @@ if __name__ == "__main__":
         autonomous_env = (os.environ.get("MESHCODE_AUTONOMOUS", "").strip().lower()
                           in ("1", "true", "yes", "on"))
         autonomous = bool(flags.get("autonomous")) or autonomous_env
-        # SELF-BUMP-BEFORE-SPAWN (task 36fe573d ext, Samuel 2026-07-02): a human typing
-        # `meshcode run` must land on the LATEST meshcode WITHOUT ever updating by hand —
-        # "meshcode se debe actualizar solo, its the whole point". The CC-autoupdate +
-        # settings.json model-pin-strip fixes live in newer meshcode; a user stuck on an
-        # old CLI (e.g. 2.11.144) would never receive them (chicken-egg). hostd already
-        # runs `meshcode self-upgrade` as a launch pre-step, but a DIRECT human
-        # `meshcode run/go` went straight to spawn and skipped it — this closes that gap.
-        #
-        # Reuses the deferral-safe blocking updater (self_update.check_and_maybe_update_blocking,
-        # force=False): version-check-first + idempotent ("already latest" -> no-op), NEVER
-        # raises (offline/PyPI-fail -> stays on installed), DEFERS when a live agent serve
-        # shares this env (never clobbers a running MCP — the class#2-clobber guard), and
-        # honors the MESHCODE_NO_UPDATE=1 / --no-update opt-out. On a REAL upgrade the OLD
-        # code is already imported in-process, so we RE-EXEC the same argv under the fresh
-        # interpreter/site so THIS spawn runs the new launcher (versioned-env spawn-latest +
-        # CC-autoupdate + pin-strip). The _MESHCODE_SELF_BUMPED sentinel makes the re-exec
-        # one-shot (no loop; the post-exec run is already latest anyway). Skipped on --dry-run.
-        if not dry_run and not os.environ.get("_MESHCODE_SELF_BUMPED"):
-            try:
-                import importlib as _il
-                _su = _il.import_module("meshcode.self_update")
-                _bumped = _su.check_and_maybe_update_blocking(verbose=True, force=False)
-                if _bumped:
-                    print(f"[meshcode] re-exec under meshcode {_bumped} (self-bump) ...",
-                          file=sys.stderr)
-                    os.environ["_MESHCODE_SELF_BUMPED"] = str(_bumped)
-                    os.execv(sys.executable,
-                             [sys.executable, "-m", "meshcode"] + sys.argv[1:])
-            except Exception as _sbe:
-                print(f"[meshcode] self-bump skipped: {_sbe}", file=sys.stderr)
         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, dry_run=dry_run, autonomous=autonomous, repo_path=repo_override))

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode/hostd.py

@@ -864,6 +864,7 @@ _ORPHAN_CLAIMED_LOGGED: set = set()
 # C3 (task f9f4a2d3): names rejected by the is_valid_agent_name gate, logged once per
 # name per daemon session so a poisoned DB row raises a visible alert without flooding.
 _INVALID_NAME_LOGGED: set = set()
+_AUTORESPAWN_OFF_LOGGED: set = set()  # persistent fleet kill-switch (Samuel 2026-07-01)
 
 
 def _do_respawns(api_key: str, host_id: str) -> int:
@@ -936,6 +937,19 @@ def _do_respawns(api_key: str, host_id: str) -> int:
             # do NOT re-record here (that would inflate the count on a mere rate-limit skip).
             _log(f"SKIP respawn {proj}/{agent}: not allowed (count={c.get('respawn_count')}, rate-limited/at-cap)")
             continue
+        # PERSISTENT FLEET KILL-SWITCH (Samuel 2026-07-01, terminal-storm middle-ground):
+        # if ~/.meshcode/fleet-autorespawn-off exists, suppress ALL auto-respawn. EXPLICIT
+        # launches (restart_requested via mc_agent_power / the Launch button) STILL spawn, so
+        # commanders boot agents on demand while NOTHING auto-resurrects. Default (no file) =
+        # unchanged behavior. The permanent off-switch the 30-min fleet-native-disabled never was.
+        if not c.get("restart_requested") and (STATE_DIR / "fleet-autorespawn-off").exists():
+            _ao_t = f"{proj}/{agent}"
+            if _ao_t not in _AUTORESPAWN_OFF_LOGGED:
+                _AUTORESPAWN_OFF_LOGGED.add(_ao_t)
+                _log(f"AUTORESPAWN OFF: skip auto-respawn {_ao_t} "
+                     f"(~/.meshcode/fleet-autorespawn-off present -- persistent kill-switch; "
+                     f"explicit Launch still honored). Delete that file to re-enable auto-respawn.")
+            continue
         # BOOT-AUTOSTART GATE (task b6da0d54; signal fixed in task 8067e04c): don't auto-launch
         # an agent whose desired_state='running' was set BEFORE this hostd started — that's a
         # boot-stale 'running' leftover from a prior session (the "terminals pop at boot" bug),

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode/meshcode_mcp/server.py

@@ -1138,6 +1138,10 @@ def with_working_status(func):
             _check_hot_reload()
             _capture_session()  # stash session on first tool call for silent auto-wake
             _touch_active_bg()  # foreground last_active_at stamp (covers wait too, before skip)
+            if not skip:                      # meshcode_wait stays ungated (read-only, must always run)
+                _blocked = await _lease_gate_async(name)
+                if _blocked is not None:
+                    return _blocked
             if not skip:
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
@@ -1186,6 +1190,10 @@ def with_working_status(func):
             _check_hot_reload()
             _capture_session()  # stash session on first tool call for silent auto-wake
             _touch_active_bg()  # foreground last_active_at stamp (covers wait too, before skip)
+            if not skip:
+                _blocked = _lease_gate_sync(name)
+                if _blocked is not None:
+                    return _blocked
             if not skip:
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
@@ -1329,6 +1337,40 @@ _INSTANCE_ID = f"mcp-{_uuid.uuid4().hex[:12]}"
 # false-terminate a legitimately-detached process.
 _BOOT_PPID = os.getppid()
 
+# ---- Single-instance lease GATE (fix f43cf72f, sec bba8e9d0) ---------------
+# The lease acquire is deferred off the MCP handshake path (see lifespan +
+# run_server changes below) so `initialize` answers in <1s instead of blocking
+# on contended lease RPCs (3x sb_rpc retries x 10s socket timeout). But tools
+# must NOT dispatch before the lease is held, or a second live instance /
+# a tombstoned agent could mutate shared state (split-brain / tombstone-bypass).
+# _LEASE_ACQUIRED is set() ONLY after a genuine acquire; every tool waits on it.
+_LEASE_ACQUIRED = _threading.Event()  # module-level alias (L1024); no plain `import threading` at module scope
+_LEASE_GATE_TIMEOUT = 30.0   # max seconds a tool blocks waiting for the lease
+
+def _lease_gate_sync(tool_name: str):
+    """Block a sync tool until the lease is held. Returns an error dict to
+    short-circuit if the lease never arrives (process is os._exit-ing on
+    conflict, so this tail is rare)."""
+    if _LEASE_ACQUIRED.is_set():
+        return None
+    if _LEASE_ACQUIRED.wait(timeout=_LEASE_GATE_TIMEOUT):
+        return None
+    return {"error": "single-instance lease not yet acquired — retry shortly",
+            "error_code": "lease_pending", "tool": tool_name}
+
+async def _lease_gate_async(tool_name: str):
+    """Async twin of _lease_gate_sync — never blocks the event loop."""
+    if _LEASE_ACQUIRED.is_set():
+        return None
+    _loop = asyncio.get_running_loop()
+    _deadline = _loop.time() + _LEASE_GATE_TIMEOUT
+    while not _LEASE_ACQUIRED.is_set():
+        if _loop.time() > _deadline:
+            return {"error": "single-instance lease not yet acquired — retry shortly",
+                    "error_code": "lease_pending", "tool": tool_name}
+        await asyncio.sleep(0.05)
+    return None
+
 
 def _stdin_peer_dead() -> bool:
     """Non-destructively check whether stdin's peer has closed.
@@ -1389,7 +1431,7 @@ def _acquire_lease() -> bool:
             "p_api_key": api_key,
             "p_project_id": _PROJECT_ID,
             "p_agent_name": AGENT_NAME,
-        })
+        }, _max_retries=1)
     except Exception as e:
         # Non-fatal: RPC might not exist on older servers.
         _mc_log(f"stale-lease pre-clean skipped: {e}", "warn")
@@ -1400,7 +1442,7 @@ def _acquire_lease() -> bool:
                 "p_project_id": _PROJECT_ID,
                 "p_agent_name": AGENT_NAME,
                 "p_instance_id": _INSTANCE_ID,
-            })
+            }, _max_retries=1)
             if isinstance(r, dict) and r.get("ok"):
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # P6: reset idle counter on lease success
@@ -1453,7 +1495,7 @@ def _acquire_lease() -> bool:
                             "p_project_id": _PROJECT_ID,
                             "p_agent_name": AGENT_NAME,
                             "p_instance_id": _INSTANCE_ID,
-                        })
+                        }, _max_retries=1)
                         if isinstance(r2, dict) and r2.get("ok"):
                             _mc_log("Lease acquired after force-release.")
                             return True
@@ -2730,6 +2772,31 @@ async def lifespan(_app):
 
     asyncio.create_task(_bg_realtime_start())
 
+    # Single-instance lease — acquired OFF the handshake path (fix f43cf72f).
+    # Mirrors the c0e7de87 deferral of Realtime/heartbeat: run the blocking
+    # _acquire_lease() in a worker thread so the lifespan yields immediately and
+    # `initialize` is answered fast; gate all tool dispatch on _LEASE_ACQUIRED
+    # until it lands. Hard-exit (os._exit) on tombstone/kick or a genuine
+    # single-instance conflict — before any gated tool can unblock.
+    async def _bg_acquire_lease():
+        try:
+            ok = await asyncio.to_thread(_acquire_lease)
+        except SystemExit as _se:             # "kicked" tombstone path
+            os._exit(_se.code if isinstance(_se.code, int) else 0)
+            return
+        except Exception as _le:              # never fatal — degrade to no-lease, stay gated
+            log.warning(f"[meshcode] bg lease acquire error (non-fatal): {_le}")
+            return
+        if not ok:                            # another live instance holds it
+            try:
+                sys.stderr.write("[meshcode-mcp] lease held by another live instance — exiting\n")
+                sys.stderr.flush()
+            except Exception:
+                pass
+            os._exit(2)
+        _LEASE_ACQUIRED.set()                 # release the dispatch gate — ONLY on real acquire
+    asyncio.create_task(_bg_acquire_lease())
+
     def _initial_heartbeat_bg():
         """Send first heartbeat + flip status to 'idle' in a daemon thread.
 
@@ -8262,13 +8329,9 @@ def run_server():
     # only the lifespan re-runs. `SystemExit` is let through so `sys.exit`
     # from config-validation paths still works. stdin EOF returns from
     # `mcp.run()` normally, which breaks the loop.
-    # Lease acquire moved here from module-level (mig-322 fix). Running at
-    # import time caused _kill_stale_mcp_process() + _acquire_lease() to fire
-    # during pytest imports, killing live agents and hitting Supabase.
-    # _kill_stale_mcp_process() is already called in the lifespan; only the
-    # lease acquire needs an explicit call here before mcp.run().
-    if not _acquire_lease():
-        sys.exit(2)
+    # Lease acquire is DEFERRED into the lifespan (_bg_acquire_lease, fix
+    # f43cf72f) so it never blocks `initialize`. Tool dispatch is gated on
+    # _LEASE_ACQUIRED; conflict/kick hard-exits from that background task.
 
     import time as _time_mod
     _restart_count = 0

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode/run_agent.py

@@ -1718,28 +1718,7 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             _settings_model = None
             _sp = ws / ".claude" / "settings.json"
             if _sp.exists():
-                _sj = json.loads(_sp.read_text(encoding="utf-8")) or {}
-                _settings_model = _sj.get("model")
-                # DASHBOARD-MODEL-WINS (task 36fe573d, Samuel 2026-07-02): older meshcode
-                # versions auto-pinned "model": PLATFORM_DEFAULT_MODEL into every workspace
-                # settings.json. That legacy pin short-circuits the mc_agent_model_pref RPC
-                # below, so the dashboard model dropdown (Fable 5, etc.) NEVER takes effect.
-                # Current _meshcode_settings_dict() no longer writes it, but existing
-                # workspaces keep the stale key forever (_heal_settings_hooks only touches
-                # hooks). Strip it here ONLY when it equals the platform default (i.e. the
-                # auto-written value) so a human-chosen NON-default model is preserved.
-                # Net effect: dashboard pref becomes authoritative; if there is no pref,
-                # PLATFORM_DEFAULT_MODEL is re-applied a few lines below -> same model, no
-                # regression. Idempotent: after the first launch the key is gone.
-                if _settings_model == PLATFORM_DEFAULT_MODEL:
-                    _sj.pop("model", None)
-                    try:
-                        _sp.write_text(json.dumps(_sj, indent=2) + "\n", encoding="utf-8")
-                    except Exception:
-                        pass
-                    _settings_model = None
-                    print("[meshcode]   Stripped legacy settings.json model pin "
-                          "-> dashboard model_pref is now authoritative", file=sys.stderr)
+                _settings_model = (json.loads(_sp.read_text(encoding="utf-8")) or {}).get("model")
             if not _settings_model:
                 _mcp_cfg = json.loads(mcp_json_path.read_text(encoding="utf-8"))
                 _env = (next(iter((_mcp_cfg.get("mcpServers") or {}).values()), {}) or {}).get("env", {}) or {}
@@ -1909,6 +1888,14 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     # AND the repo-lock dir (whichever claude opens in).
     _pretrust_claude_workspace(str(ws), repo_lock)
 
+    # MCP handshake budget (mesh-dev piece-1, 2026-07-03): Claude Code's default
+    # MCP_TIMEOUT is 5s, but the meshcode MCP server can legitimately take longer
+    # on first connect (lease acquire vs a loaded Supabase pool = today's
+    # fleet-wide "agent won't connect"). Give every launched agent a 240s window
+    # automatically; setdefault so an explicit user/env override still wins.
+    # Root fix (lease deferral off the handshake path) ships separately.
+    os.environ.setdefault("MCP_TIMEOUT", "240000")
+
     # Flush all output before exec replaces this process — execvp does NOT
     # flush Python file buffers, so any buffered stdout (e.g. the banner)
     # would be silently lost.

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.168 → meshcode-2.11.171}/meshcode.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 README.md
 pyproject.toml
-setup.cfg
 meshcode/__init__.py
 meshcode/__main__.py
 meshcode/_launch_smoke.py

{meshcode-2.11.168 → meshcode-2.11.171}/pyproject.toml

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