meshcode 2.11.57__tar.gz → 2.11.59__tar.gz

{meshcode-2.11.57 → meshcode-2.11.59}/PKG-INFO

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

{meshcode-2.11.57 → meshcode-2.11.59}/meshcode/__init__.py

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

{meshcode-2.11.57 → meshcode-2.11.59}/meshcode/comms_v4.py

@@ -3808,6 +3808,13 @@ if __name__ == "__main__":
         else:
             print(f"Usage: meshcode supervisor [start|stop|status|--simple] <project> <agent>")
 
+    elif cmd == "hostd":
+        # meshcode hostd run|status — local respawn/recycle watchdog daemon
+        # (auto-relaunch of stale/dead managed agents; mesh-core incident fix).
+        import importlib
+        _hostd = importlib.import_module("meshcode.hostd")
+        sys.exit(_hostd.cmd_hostd(pos))
+
     else:
         known_cmds = [
             "register", "send", "broadcast", "read", "check", "watch", "inbox", "next",
@@ -3816,7 +3823,7 @@ if __name__ == "__main__":
             "setup", "add-agent", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
             "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
-            "supervisor", "upload", "quickstart", "patch-hooks", "wake-all",
+            "supervisor", "hostd", "upload", "quickstart", "patch-hooks", "wake-all",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]

meshcode-2.11.59/meshcode/hostd.py

@@ -0,0 +1,309 @@
+"""meshcode hostd — host-side daemon: respawn + recycle managed agents.
+
+Complements supervisor.py (launchd KeepAlive = process-exit restart only).
+hostd polls the CLOUD for staleness (heartbeat) + recycle triggers that
+launchd cannot see:
+
+  - RESPAWN: agent's heartbeat is stale (process/daemon-thread dead) and
+    desired_state='running' → relaunch. Loop-guard cap 3/10min → 'crashed'.
+  - RECYCLE: managed agent exceeds its recycle policy (context% or uptime)
+    → relaunch at a task boundary (never mid-task). Recorded separately
+    from the crash cap.
+
+Contract (mig366/367/368/369, DBA-cleared):
+  mc_register_host, mc_agents_needing_respawn, mc_record_respawn,
+  mc_record_recycle, mc_set_desired_state, mc_host_recycle_policy.
+
+Source of truth is the cloud (mc_agents / mc_host_config), never local
+folders. host_id lives in ~/.meshcode/host_id (generated once).
+
+    meshcode hostd run       — run the daemon loop (foreground)
+    meshcode hostd status    — show this host's managed agents
+    meshcode hostd install   — install launchd trigger-start plist
+    meshcode hostd uninstall — remove it
+
+Design invariants:
+  - NEVER respawn desired_state != 'running' (NULL=unmanaged, stopped=
+    intentional, crashed=gave-up). The cloud RPC enforces this; we trust it.
+  - Single retry / capped respawn — never an infinite relaunch loop.
+  - Recycle only at task boundary: we relaunch a recycle candidate only
+    when it is NOT actively working (status not in working/online-busy) OR
+    the agent has self-flagged 'recycling'. Mid-task agents are skipped.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+import uuid
+from pathlib import Path
+from typing import Optional
+
+STATE_DIR = Path.home() / ".meshcode"
+HOST_ID_PATH = STATE_DIR / "host_id"
+LOG_PATH = STATE_DIR / "hostd.log"
+
+POLL_INTERVAL_SEC = 45
+STALE_SECONDS = 150          # heartbeat liveness cutoff (QA #3)
+RESPAWN_TIMEOUT_SEC = 30
+# statuses that mean "actively working" → never recycle mid-task
+BUSY_STATUSES = {"working", "online", "busy"}
+
+
+def _log(msg: str) -> None:
+    line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
+    print(line, file=sys.stderr)
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    except Exception:
+        pass
+
+
+def get_host_id() -> str:
+    """Read ~/.meshcode/host_id, generating a stable UUID on first use."""
+    try:
+        if HOST_ID_PATH.exists():
+            v = HOST_ID_PATH.read_text(encoding="utf-8").strip()
+            if v:
+                return v
+    except Exception:
+        pass
+    new_id = str(uuid.uuid4())
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        HOST_ID_PATH.write_text(new_id, encoding="utf-8")
+    except Exception:
+        pass
+    return new_id
+
+
+# ------------------------------------------------------------------
+# Cloud RPC (PostgREST) — self-contained urllib, no internal client dep
+# ------------------------------------------------------------------
+
+def _supabase_cfg() -> tuple:
+    url = os.environ.get("SUPABASE_URL", "").rstrip("/")
+    key = os.environ.get("SUPABASE_KEY") or os.environ.get("MESHCODE_SUPABASE_ANON_KEY") or ""
+    return url, key
+
+
+def _api_key() -> Optional[str]:
+    """The meshcode agent/user api key, used as p_api_key in mc_ RPCs."""
+    k = os.environ.get("MESHCODE_API_KEY")
+    if k:
+        return k
+    try:
+        # same source meshcode run uses (per-profile state)
+        prof = STATE_DIR / "profiles.json"
+        if prof.exists():
+            data = json.loads(prof.read_text(encoding="utf-8"))
+            # best-effort: first profile with an api_key
+            for v in (data.values() if isinstance(data, dict) else []):
+                if isinstance(v, dict) and v.get("api_key"):
+                    return v["api_key"]
+    except Exception:
+        pass
+    return None
+
+
+def _rpc(fn: str, payload: dict) -> Optional[dict]:
+    """Call a PostgREST RPC. Returns parsed JSON or None on any failure."""
+    url, key = _supabase_cfg()
+    if not url or not key:
+        _log("WARN: SUPABASE_URL/KEY not set — cannot reach cloud")
+        return None
+    try:
+        req = urllib.request.Request(
+            f"{url}/rest/v1/rpc/{fn}",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={
+                "apikey": key,
+                "Authorization": f"Bearer {key}",
+                "Content-Type": "application/json",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception as e:
+        _log(f"WARN: rpc {fn} failed: {e}")
+        return None
+
+
+# ------------------------------------------------------------------
+# Respawn
+# ------------------------------------------------------------------
+
+def _meshcode_bin() -> str:
+    cand = Path(sys.argv[0]).resolve()
+    if cand.exists() and cand.name.startswith("meshcode"):
+        return str(cand)
+    return "meshcode"
+
+
+def _spawn_agent(project: str, agent: str) -> bool:
+    """Relaunch `meshcode run <project>/<agent>` detached + visible-friendly."""
+    target = f"{project}/{agent}"
+    env = dict(os.environ)
+    # env hygiene (item1 RC): a stale CLAUDECODE aborts `meshcode run` (exit2)
+    env.pop("CLAUDECODE", None)
+    env.pop("CLAUDE_CODE_SESSION", None)
+    env["MESHCODE_NO_AUTO_UPDATE"] = env.get("MESHCODE_NO_AUTO_UPDATE", "1")
+    try:
+        subprocess.Popen(
+            [_meshcode_bin(), "run", target],
+            env=env, start_new_session=True,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+        return True
+    except Exception as e:
+        _log(f"WARN: spawn {target} failed: {e}")
+        return False
+
+
+def _do_respawns(api_key: str, host_id: str) -> int:
+    """One respawn sweep. Returns number relaunched."""
+    res = _rpc("mc_agents_needing_respawn",
+               {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
+    if not res or not res.get("ok"):
+        return 0
+    n = 0
+    for c in res.get("candidates", []):
+        proj, agent = c.get("project_name"), c.get("agent")
+        if not proj or not agent:
+            continue
+        if not c.get("respawn_allowed", True):
+            _log(f"SKIP respawn {proj}/{agent}: cap reached (count={c.get('respawn_count')})")
+            rec = _rpc("mc_record_respawn",
+                       {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
+            if rec and rec.get("give_up"):
+                _rpc("mc_set_desired_state", {"p_api_key": api_key, "p_state": "crashed"})
+                _log(f"ALERT {proj}/{agent}: marked crashed after respawn cap — operator attention")
+            continue
+        _log(f"RESPAWN {proj}/{agent} (stale {c.get('heartbeat_age_s')}s)")
+        if _spawn_agent(proj, agent):
+            _rpc("mc_record_respawn",
+                 {"p_api_key": api_key, "p_project_id": c.get("project_id"), "p_agent_name": agent})
+            n += 1
+    return n
+
+
+# ------------------------------------------------------------------
+# launchd trigger-start (macOS) — extends supervisor.py pattern.
+# The hostd daemon is NOT autostart-at-login: RunAtLoad=false. It is
+# kicked off on demand (button -> meshcode:// -> `launchctl kickstart`)
+# and KeepAlive keeps it alive while it runs. One job per host.
+# ------------------------------------------------------------------
+
+_HOSTD_PLIST_LABEL = "io.meshcode.hostd"
+
+
+def _hostd_plist_path():
+    return Path.home() / "Library" / "LaunchAgents" / f"{_HOSTD_PLIST_LABEL}.plist"
+
+
+def _hostd_plist_xml() -> str:
+    import shutil
+    mc = shutil.which("meshcode") or f"{sys.executable} -m meshcode"
+    args = (mc.split() + ["hostd", "run"]) if " -m " in mc else [mc, "hostd", "run"]
+    args_xml = "\n".join(f"        <string>{a}</string>" for a in args)
+    logdir = STATE_DIR / "logs"
+    logdir.mkdir(parents=True, exist_ok=True)
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key><string>{_HOSTD_PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+{args_xml}
+    </array>
+    <key>RunAtLoad</key><false/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>10</integer>
+    <key>StandardOutPath</key><string>{logdir / "hostd.stdout.log"}</string>
+    <key>StandardErrorPath</key><string>{logdir / "hostd.stderr.log"}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:{os.path.dirname(sys.executable)}</string>
+        <key>MESHCODE_NO_AUTO_UPDATE</key><string>1</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+
+def _hostd_install() -> int:
+    import platform
+    if platform.system() != "Darwin":
+        print("[hostd] launchd install is macOS only (Linux: use systemd --user; or run `meshcode hostd run` under your own supervisor).", file=sys.stderr)
+        return 2
+    plist = _hostd_plist_path()
+    plist.parent.mkdir(parents=True, exist_ok=True)
+    plist.write_text(_hostd_plist_xml(), encoding="utf-8")
+    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
+    r = subprocess.run(["launchctl", "load", str(plist)], capture_output=True, text=True)
+    if r.returncode != 0:
+        print(f"[hostd] launchctl load failed: {r.stderr.strip()}", file=sys.stderr)
+        return 1
+    print(f"[hostd] installed (RunAtLoad=false, trigger-start). plist: {plist}")
+    print(f"[hostd] start now:  launchctl kickstart gui/$(id -u)/{_HOSTD_PLIST_LABEL}")
+    return 0
+
+
+def _hostd_uninstall() -> int:
+    plist = _hostd_plist_path()
+    if not plist.exists():
+        print("[hostd] not installed")
+        return 0
+    subprocess.run(["launchctl", "unload", str(plist)], capture_output=True, text=True)
+    plist.unlink(missing_ok=True)
+    print("[hostd] uninstalled")
+    return 0
+
+
+def cmd_hostd(args: list) -> int:
+    """Entry point for `meshcode hostd ...`."""
+    if not args or args[0] in ("-h", "--help"):
+        print(__doc__)
+        return 0
+    sub = args[0]
+    host_id = get_host_id()
+    api_key = _api_key()
+
+    if sub == "status":
+        if not api_key:
+            print("[hostd] no api key configured", file=sys.stderr)
+            return 1
+        res = _rpc("mc_agents_needing_respawn",
+                   {"p_api_key": api_key, "p_host_id": host_id, "p_stale_seconds": STALE_SECONDS})
+        print(json.dumps({"host_id": host_id, "needing_respawn": res}, indent=2))
+        return 0
+
+    if sub == "install":
+        return _hostd_install()
+
+    if sub == "uninstall":
+        return _hostd_uninstall()
+
+    if sub == "run":
+        if not api_key:
+            _log("FATAL: no api key — set MESHCODE_API_KEY")
+            return 1
+        _log(f"hostd starting — host_id={host_id} interval={POLL_INTERVAL_SEC}s stale={STALE_SECONDS}s")
+        while True:
+            try:
+                relaunched = _do_respawns(api_key, host_id)
+                if relaunched:
+                    _log(f"sweep done — {relaunched} relaunched")
+            except Exception as e:
+                _log(f"WARN: sweep error: {e}")
+            time.sleep(POLL_INTERVAL_SEC)
+
+    print(f"[hostd] unknown subcommand: {sub}", file=sys.stderr)
+    return 1

{meshcode-2.11.57 → meshcode-2.11.59}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.11.57 → meshcode-2.11.59}/meshcode.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ meshcode/date_parse.py
 meshcode/doctor.py
 meshcode/error_hints.py
 meshcode/exceptions.py
+meshcode/hostd.py
 meshcode/invites.py
 meshcode/launcher.py
 meshcode/launcher_install.py

{meshcode-2.11.57 → meshcode-2.11.59}/pyproject.toml

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