meshcode 2.11.149__tar.gz → 2.11.150__tar.gz

{meshcode-2.11.149 → meshcode-2.11.150}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.149
+Version: 2.11.150
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,8 +18,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: realtime>=2.0.0
+Requires-Dist: keyring>=24.0
+Requires-Dist: cryptography>=41.0
 Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.149 → meshcode-2.11.150}/meshcode/__init__.py

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

{meshcode-2.11.149 → meshcode-2.11.150}/meshcode/hostd.py

@@ -2822,7 +2822,12 @@ def _hostd_install_windows() -> int:
         'set "MESHCODE_NO_UPDATE=1"\r\n'        # var honored pre-2.11.74 (belt-and-suspenders)
         'set "MESHCODE_NO_AUTO_UPDATE=1"\r\n'   # unified var (honored 2.11.74+)
         'set "MESHCODE_HOSTD_POLL_SEC=10"\r\n'  # faster click->spawn (default 10s, floor 3)
-        f'"{mc}" hostd run\r\n',
+        # F1a (task 48c3f294): launch the SUPERVISOR, not `hostd run` directly.
+        # The supervisor owns + revives hostd on CRASH — the recovery the HKCU\Run
+        # tier (login-only) lacks (that was the dead launch button on Samuel's box).
+        # It self-singletons, so the Task-Scheduler periodic watchdog tier above
+        # can also point here without ever double-starting.
+        f'"{mc}" hostd supervise\r\n',
         encoding="utf-8",
     )
     # Register-ScheduledTask (PowerShell) — ROBUST KEEP-ALIVE (task 843f282c CRITICAL: hostd died ~15:04
@@ -3135,6 +3140,163 @@ def _acquire_hostd_singleton():
         return (None, "error")
 
 
+# ------------------------------------------------------------------
+# hostd SUPERVISOR (task 48c3f294 / F1a — Windows crash+reboot revive). The only
+# non-admin Windows persistence that works on locked-down boxes (Samuel's) is
+# HKCU\Run, which fires ONLY at login: a hostd that CRASHES mid-session is never
+# revived = the dead launch button. This supervisor is a SEPARATE, minimal
+# process that OWNS a `hostd run` child and restarts it on exit — the crash
+# recovery HKCU\Run lacks. Separate process, NOT hostd self-forking: an early
+# hostd crash (import error / startup fault) before any in-process fork would
+# otherwise never be revived. COMPOSES with hostd's in-process wedge watchdog
+# (process-STUCK self-restart via execv); this is the process-GONE half.
+# Anti-storm: the restart loop mirrors the absolute respawn cap (5618ac17) — a
+# hostd that crash-loops WITHOUT ever staying up is STOPPED after a ceiling and
+# its status written to hostd-supervisor.state, so the supervisor can never
+# become the storm it guards against. macOS (launchd KeepAlive) + Linux (systemd
+# Restart=on-failure) already get crash-revive, so this is win32-only in practice.
+# ------------------------------------------------------------------
+_SUP_LOCK_FH = None
+_SUP_STATE_PATH = STATE_DIR / "hostd-supervisor.state"
+_SUP_CONFIRMED_BOOT_S = _env_int("MESHCODE_SUP_CONFIRMED_BOOT_SEC", 120, 30)  # child up >= this = confirmed boot -> reset cap
+_SUP_ABS_CAP          = _env_int("MESHCODE_SUP_ABS_CAP", 5, 2)                # crash-restarts w/o confirmed boot before STOP
+_SUP_ABS_WINDOW_S     = _env_int("MESHCODE_SUP_ABS_WINDOW_SEC", 3600, 300)    # rolling window
+_SUP_BACKOFF_BASE_S   = _env_int("MESHCODE_SUP_BACKOFF_BASE_SEC", 5, 1)       # exp backoff base between crash restarts
+_SUP_BACKOFF_MAX_S    = _env_int("MESHCODE_SUP_BACKOFF_MAX_SEC", 300, 10)     # backoff ceiling
+_SUP_POLL_S           = _env_int("MESHCODE_SUP_POLL_SEC", 5, 1)               # poll cadence while a hostd is already alive
+
+
+def _flock_probe_held(lock_path: Path) -> bool:
+    """True if a LIVE process holds an exclusive flock/msvcrt lock on lock_path.
+    Non-destructive try-acquire-release — robust vs the informational pid inside
+    the lock file (which can be stale after a hard kill). Used to detect a live
+    hostd before the supervisor spawns one (never double-start)."""
+    try:
+        fh = open(lock_path, "a+")
+    except Exception:
+        return False  # can't evaluate -> assume free (supervisor errs toward having a hostd)
+    try:
+        if sys.platform == "win32":
+            import msvcrt
+            fh.seek(0)
+            try:
+                msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+            except OSError:
+                return True  # held by a live process
+            try:
+                msvcrt.locking(fh.fileno(), msvcrt.LK_UNLCK, 1)
+            except OSError:
+                pass
+            return False
+        import fcntl
+        try:
+            fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            return True
+        fcntl.flock(fh.fileno(), fcntl.LOCK_UN)
+        return False
+    finally:
+        fh.close()
+
+
+def _acquire_supervisor_singleton():
+    """One supervisor per machine — flock/msvcrt on hostd-supervisor.lock, held
+    for the process lifetime, OS-released on ANY death (no stale-lock problem;
+    same field-tested mechanism as _acquire_hostd_singleton — addresses the
+    SPOC's 'O_EXCL leaves a stale lock after a hard kill' note). Returns the fh
+    on success, None if another live supervisor already holds it."""
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        fh = open(STATE_DIR / "hostd-supervisor.lock", "a+")
+    except Exception:
+        return None
+    try:
+        if sys.platform == "win32":
+            import msvcrt
+            fh.seek(0)
+            msvcrt.locking(fh.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(fh.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        fh.close()
+        return None
+    try:
+        fh.seek(0)
+        fh.truncate()
+        fh.write(str(os.getpid()))
+        fh.flush()
+    except Exception:
+        pass
+    return fh
+
+
+def _sup_write_state(state: str, reason: str = "", restart_count: int = 0) -> None:
+    """Persist supervisor status to hostd-supervisor.state — the data source for
+    the F1b dashboard-liveness UX (FE reads it to surface 'hostd stopped/looping'
+    instead of a silently dead daemon). Best-effort."""
+    try:
+        _SUP_STATE_PATH.write_text(json.dumps({
+            "state": state, "reason": reason, "restart_count": restart_count,
+            "pid": os.getpid(), "ts": int(time.time()),
+        }), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def _hostd_supervise() -> int:
+    """Supervisor loop: own a `hostd run` child and revive it on crash, with an
+    absolute no-confirmed-boot cap so a crash-loop can't storm. See the block
+    comment above for the full rationale."""
+    fh = _acquire_supervisor_singleton()
+    if fh is None:
+        _log("hostd supervisor already running (hostd-supervisor.lock held) — exiting (singleton)")
+        return 0
+    global _SUP_LOCK_FH
+    _SUP_LOCK_FH = fh
+    _log("hostd supervisor started — owning + reviving `hostd run` (F1a)")
+    argv = _hostd_run_argv()
+    restarts: list = []  # spawn timestamps that did NOT reach a confirmed boot
+    while True:
+        # NEVER double-start: if a live hostd already holds hostd.lock (a manual
+        # `hostd run`, or an orphan that outlived a prior supervisor), don't spawn
+        # — wait for it to free. Without this, hostd's own singleton would make
+        # our child exit 0 instantly and we'd read that as a crash and loop.
+        if _flock_probe_held(STATE_DIR / "hostd.lock"):
+            _sup_write_state("running", "hostd_already_live", len(restarts))
+            time.sleep(_SUP_POLL_S)
+            continue
+        now = time.time()
+        restarts = [t for t in restarts if now - t < _SUP_ABS_WINDOW_S]
+        if len(restarts) >= _SUP_ABS_CAP:
+            _sup_write_state("stopped", "abs_cap_crash_loop", len(restarts))
+            _log(f"SUPERVISOR ABS-CAP: hostd crash-looped {len(restarts)}x in <= {_SUP_ABS_WINDOW_S}s "
+                 f"without staying up >= {_SUP_CONFIRMED_BOOT_S}s — STOPPING (a fresh `meshcode hostd "
+                 f"install` re-arms). Wrote {_SUP_STATE_PATH.name} for the dashboard.")
+            return 0
+        start = time.time()
+        restarts.append(start)
+        _sup_write_state("running", "spawning_hostd", len(restarts))
+        try:
+            proc = subprocess.Popen(argv, stdin=subprocess.DEVNULL)
+        except Exception as e:
+            backoff = min(_SUP_BACKOFF_MAX_S, _SUP_BACKOFF_BASE_S * (2 ** (len(restarts) - 1)))
+            _log(f"supervisor: failed to spawn hostd ({e}) — retry in {backoff}s")
+            time.sleep(backoff)
+            continue
+        rc = proc.wait()  # authoritative: the hostd process is GONE
+        uptime = time.time() - start
+        if uptime >= _SUP_CONFIRMED_BOOT_S:
+            restarts = []  # stayed up long enough = confirmed boot -> reset the cap
+            backoff = _SUP_BACKOFF_BASE_S
+            _log(f"hostd exited rc={rc} after {int(uptime)}s (confirmed boot) — restart in {backoff}s")
+        else:
+            backoff = min(_SUP_BACKOFF_MAX_S, _SUP_BACKOFF_BASE_S * (2 ** (len(restarts) - 1)))
+            _log(f"hostd exited rc={rc} after {int(uptime)}s (no confirmed boot, "
+                 f"{len(restarts)}/{_SUP_ABS_CAP}) — restart in {backoff}s")
+        time.sleep(backoff)
+
+
 def cmd_hostd(args: list) -> int:
     """Entry point for `meshcode hostd ...`."""
     if not args or args[0] in ("-h", "--help"):
@@ -3159,6 +3321,12 @@ def cmd_hostd(args: list) -> int:
     if sub == "uninstall":
         return _hostd_uninstall()
 
+    if sub == "supervise":
+        # F1a (task 48c3f294): own + revive `hostd run`. The Windows non-admin
+        # autostart (HKCU\Run) points here so a mid-session hostd CRASH is revived,
+        # not just a login. Not for macOS/Linux (launchd/systemd already revive).
+        return _hostd_supervise()
+
     if sub == "run":
         if not api_key:
             _log("FATAL: no api key — run `meshcode login` (key is read from the keychain)")

{meshcode-2.11.149 → meshcode-2.11.150}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: meshcode
-Version: 2.11.149
+Version: 2.11.150
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,8 +18,17 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: realtime>=2.0.0
+Requires-Dist: keyring>=24.0
+Requires-Dist: cryptography>=41.0
 Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.149 → meshcode-2.11.150}/pyproject.toml

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