meshcode 2.11.171__tar.gz → 2.11.173__tar.gz

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

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

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

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

{meshcode-2.11.171 → meshcode-2.11.173}/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.171 → meshcode-2.11.173}/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
 
@@ -3285,6 +3308,33 @@ def cmd_hostd(args: list) -> int:
             sys.excepthook = lambda t, v, tb: _log("UNCAUGHT: " + "".join(_tbmod.format_exception(t, v, tb)))
         except Exception:
             pass
+        # task cccb0b88: DEATH-MARKER — hostd must never exit silently again
+        # (2026-07-03: died 11:16:46 with no FATAL line). atexit covers normal
+        # interpreter exit / sys.exit; handlers cover TERM/INT/HUP and re-raise
+        # with SIG_DFL so launchd still sees the true exit status (KeepAlive
+        # relaunch semantics unchanged). SIGKILL/OOM is unloggable by the dying
+        # process — covered server-side by mc_hostd_absent_sweep (mig 704).
+        try:
+            import atexit as _atexit
+            _death_spawn_mono = time.monotonic()
+            def _death_marker(reason: str) -> None:
+                try:
+                    _log(f"DEATH-MARKER: hostd exiting reason={reason} pid={os.getpid()} "
+                         f"uptime={int(time.monotonic() - _death_spawn_mono)}s")
+                except Exception:
+                    pass
+            _atexit.register(_death_marker, "atexit")
+            def _death_sig(signum, frame):
+                _death_marker(f"signal-{_signal.Signals(signum).name}")
+                _signal.signal(signum, _signal.SIG_DFL)
+                os.kill(os.getpid(), signum)
+            for _s in (_signal.SIGTERM, _signal.SIGINT, _signal.SIGHUP):
+                try:
+                    _signal.signal(_s, _death_sig)
+                except Exception:
+                    pass
+        except Exception:
+            pass
         # Register this host in mc_host_config so the dashboard can list it as a launch target.
         _reg = _rpc("mc_host_config_set", {"p_api_key": api_key, "p_host_id": host_id})
         if _reg and _reg.get("ok"):
@@ -3346,12 +3396,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.171 → meshcode-2.11.173}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.171 → meshcode-2.11.173}/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.171 → meshcode-2.11.173}/pyproject.toml

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