meshcode 2.11.170__tar.gz → 2.11.172__tar.gz

{meshcode-2.11.170 → meshcode-2.11.172}/PKG-INFO

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

{meshcode-2.11.170 → meshcode-2.11.172}/meshcode/__init__.py

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

{meshcode-2.11.170 → meshcode-2.11.172}/meshcode/claude_update.py

@@ -45,6 +45,34 @@ INSTALL_TIMEOUT_SEC = 90  # npm i -g can be slow on cold-cache machines
 STATE_DIR = Path.home() / ".meshcode"
 LOG_PATH = STATE_DIR / "claude_update.log"
 
+# --- P0 launch-latency (task 9fb81ff5 / 1d4276c3): never run a doomed global install ---
+SKIP_STATE = STATE_DIR / "claude_update_skip.json"
+NEG_CACHE_SEC = 6 * 3600  # a failed target version is not retried for 6h
+
+
+def _global_prefix_writable(npm: str) -> bool:
+    """True if `npm i -g` can succeed (global node_modules writable).
+
+    On boxes where /usr/local/lib/node_modules is root-owned, every blocking
+    global install hits EACCES — retried on EVERY launch, it can never
+    succeed (446 doomed attempts observed in claude_update.log, 2026-07-03).
+    """
+    try:
+        r = subprocess.run([npm, "prefix", "-g"], capture_output=True, text=True, timeout=5)
+        root = os.path.join((r.stdout or "").strip(), "lib", "node_modules")
+        probe = os.path.join(root, NPM_PKG.split("/")[0])  # @anthropic-ai scope dir
+        return os.access(probe if os.path.isdir(probe) else root, os.W_OK)
+    except Exception:
+        return True  # fail-open: unknown -> let npm try once
+
+
+def _mark_skip(version: str, reason: str) -> None:
+    """Record a failed/doomed target version so it is not retried for 6h."""
+    try:
+        SKIP_STATE.write_text(json.dumps({"version": version, "ts": time.time(), "reason": reason}))
+    except Exception:
+        pass
+
 
 # ============================================================
 # Skip-condition helpers
@@ -214,6 +242,27 @@ def check_and_maybe_update_claude_blocking(
             )
         return None
 
+    # negative cache: same target version failed <6h ago -> skip silently
+    try:
+        st = json.loads(SKIP_STATE.read_text())
+        if st.get("version") == latest and time.time() - st.get("ts", 0) < NEG_CACHE_SEC:
+            return None
+    except Exception:
+        pass
+
+    if not _global_prefix_writable(npm):
+        # global install can NEVER succeed (EACCES) -> route latest via npx instead
+        # (run_agent npx launch path picks this env up; user npm cache, no root needed)
+        os.environ["_MESHCODE_NPX_CLAUDE_VERSION"] = latest
+        _mark_skip(latest, "eacces")
+        if verbose:
+            print(
+                f"[meshcode] WARN: npm global prefix not writable; using npx claude@{latest}. "
+                f"Permanent fix: sudo chown -R $(whoami) /usr/local/lib/node_modules",
+                file=sys.stderr,
+            )
+        return None
+
     if verbose:
         print(
             f"[meshcode] Upgrading claude {current} -> {latest} (blocking, can take ~30s)...",
@@ -234,6 +283,7 @@ def check_and_maybe_update_claude_blocking(
             if verbose:
                 print(f"[meshcode]   claude upgraded to {latest}", file=sys.stderr)
             return latest
+        _mark_skip(latest, f"exit_{proc.returncode}")
         if verbose:
             print(
                 f"[meshcode] WARN: npm install exit {proc.returncode}; "
@@ -242,6 +292,7 @@ def check_and_maybe_update_claude_blocking(
             )
         return None
     except subprocess.TimeoutExpired:
+        _mark_skip(latest, "timeout")
         if verbose:
             print(
                 f"[meshcode] WARN: npm install timed out after {timeout_sec}s; "

{meshcode-2.11.170 → meshcode-2.11.172}/meshcode/hostd.py

@@ -525,8 +525,27 @@ def _api_key() -> Optional[str]:
     return None
 
 
+# P0 launch-latency FIX B (task 9fb81ff5 / 1d4276c3): during a DB degradation
+# (e.g. PostgREST pool exhaustion, 2026-07-03) each sweep runs 5-7 sequential
+# RPCs; at the old hard timeout=15 a fully-degraded sweep took 75-105s and
+# Launch clicks sat unhonored for minutes. 6s is >> p99 healthy RPC latency
+# and cuts the worst-case sweep to ~42s. Override via MESHCODE_HOSTD_RPC_TIMEOUT.
+try:
+    _RPC_TIMEOUT = int(os.environ.get("MESHCODE_HOSTD_RPC_TIMEOUT", "6"))
+except ValueError:
+    _RPC_TIMEOUT = 6
+
+# Consecutive _rpc transport failures (timeout / unreachable / None). Reset on
+# success OR HTTPError (an HTTP error proves the cloud is reachable — that's a
+# server-side refusal, not degradation). At >=3 the sweep loop skips its
+# non-critical phases (stops / force-kills / ghost sweep / reap) so heartbeat +
+# respawns — the paths that honor an explicit human Launch — stay first-class.
+_rpc_fail_streak = 0
+
+
 def _rpc(fn: str, payload: dict) -> Optional[dict]:
     """Call a PostgREST RPC. Returns parsed JSON or None on any failure."""
+    global _rpc_fail_streak
     url, key = _supabase_cfg()
     if not url or not key:
         _log("WARN: SUPABASE_URL/KEY not set — cannot reach cloud")
@@ -542,12 +561,15 @@ def _rpc(fn: str, payload: dict) -> Optional[dict]:
             },
             method="POST",
         )
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            return json.loads(resp.read().decode("utf-8"))
+        with urllib.request.urlopen(req, timeout=_RPC_TIMEOUT) as resp:
+            out = json.loads(resp.read().decode("utf-8"))
+            _rpc_fail_streak = 0
+            return out
     except urllib.error.HTTPError as e:
         # task 89d50a14 [E]: log the PostgREST error BODY, not just the status line.
         # mc_log_respawn_event failed 400 for DAYS and the cause (42804 host_id
         # uuid-vs-text) was undiagnosable from "HTTP Error 400: Bad Request" alone.
+        _rpc_fail_streak = 0  # cloud reachable — server refusal, not degradation
         try:
             body = e.read().decode("utf-8", "replace").strip()[:300]
         except Exception:
@@ -555,6 +577,7 @@ def _rpc(fn: str, payload: dict) -> Optional[dict]:
         _log(f"WARN: rpc {fn} failed: {e}" + (f" — {body}" if body else ""))
         return None
     except Exception as e:
+        _rpc_fail_streak += 1
         _log(f"WARN: rpc {fn} failed: {e}")
         return None
 
@@ -3346,12 +3369,22 @@ def cmd_hostd(args: list) -> int:
                         # always run on a stale-running host without manual intervention.
                         _maybe_self_restart_on_version_drift()
                         relaunched = _do_respawns(api_key, host_id)
-                        stopped = _do_stops(api_key, host_id)
-                        force_killed = _do_force_kills(api_key, host_id)  # 38523a98 Gap1: visible explicit human stop
-                        # 91201315: stopped agents whose instance/heartbeat already cleared —
-                        # invisible to both RPC sweeps above (their <90s heartbeat gate).
-                        ghost_killed = _do_stopped_ghost_sweep(api_key, host_id)
-                        reaped = _do_reap(api_key, host_id)  # 38523a98: kill ghosts/dup-PIDs/crashed-orphans
+                        # P0 FIX B (task 9fb81ff5 / 1d4276c3): degraded-sweep short-circuit.
+                        # Heartbeat + respawns above ALWAYS run — they honor an explicit
+                        # human Launch. When the cloud is degraded (>=3 consecutive _rpc
+                        # transport failures), skip the non-critical phases this sweep so
+                        # a fully-degraded pass stays ~2 RPCs instead of 5-7 × timeout.
+                        # Stops/kills/reaps resume on the next healthy sweep.
+                        if _rpc_fail_streak >= 3:
+                            _log(f"sweep degraded (rpc_fail_streak={_rpc_fail_streak}) — skipping non-critical phases (stops/force-kills/ghost-sweep/reap)")
+                            stopped = force_killed = ghost_killed = reaped = 0
+                        else:
+                            stopped = _do_stops(api_key, host_id)
+                            force_killed = _do_force_kills(api_key, host_id)  # 38523a98 Gap1: visible explicit human stop
+                            # 91201315: stopped agents whose instance/heartbeat already cleared —
+                            # invisible to both RPC sweeps above (their <90s heartbeat gate).
+                            ghost_killed = _do_stopped_ghost_sweep(api_key, host_id)
+                            reaped = _do_reap(api_key, host_id)  # 38523a98: kill ghosts/dup-PIDs/crashed-orphans
                         _gc_headless_pids()  # cb90b058: drop dead PIDs (stale entry can't mask a live agent)
                         _gc_stop_markers()   # a4001d59: stale stop-markers can't flip a later crash into a silent close
                         _up = int(time.monotonic() - _spawn_mono)

{meshcode-2.11.170 → meshcode-2.11.172}/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.170 → meshcode-2.11.172}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.170 → meshcode-2.11.172}/meshcode.egg-info/SOURCES.txt

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

{meshcode-2.11.170 → meshcode-2.11.172}/pyproject.toml

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