meshcode 2.10.58__tar.gz → 2.10.60__tar.gz

{meshcode-2.10.58 → meshcode-2.10.60}/PKG-INFO

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

{meshcode-2.10.58 → meshcode-2.10.60}/meshcode/__init__.py

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

{meshcode-2.10.58 → meshcode-2.10.60}/meshcode/comms_v4.py

@@ -3327,6 +3327,31 @@ if __name__ == "__main__":
     elif cmd in ("help", "--help", "-h"):
         show_help()
 
+    elif cmd == "supervisor":
+        # meshcode supervisor start|stop|status [project] [agent]
+        import importlib
+        _sup = importlib.import_module("meshcode.supervisor")
+        sub = pos[0] if pos else "status"
+        if sub == "start":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor start <project> <agent>")
+                sys.exit(1)
+            _sup.start(pos[1], pos[2])
+        elif sub == "stop":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor stop <project> <agent>")
+                sys.exit(1)
+            _sup.stop(pos[1], pos[2])
+        elif sub == "status":
+            _sup.status()
+        elif sub == "--simple":
+            if len(pos) < 3:
+                print("Usage: meshcode supervisor --simple <project> <agent>")
+                sys.exit(1)
+            _sup.simple(pos[1], pos[2])
+        else:
+            print(f"Usage: meshcode supervisor [start|stop|status|--simple] <project> <agent>")
+
     else:
         known_cmds = [
             "register", "send", "broadcast", "read", "check", "watch", "inbox", "next",
@@ -3335,6 +3360,7 @@ if __name__ == "__main__":
             "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
             "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
+            "supervisor",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]

{meshcode-2.10.58 → meshcode-2.10.60}/meshcode/meshcode_mcp/server.py

@@ -1949,6 +1949,47 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
         return None
 
 
+def _try_auto_claim_task() -> Optional[Dict[str, str]]:
+    """Auto-claim the oldest open task matching this agent's role.
+
+    Called during meshcode_wait idle loops. Only claims wildcard ('*')
+    tasks to avoid stealing directly-assigned work. Returns the claimed
+    task summary or None.
+    """
+    try:
+        api_key = _get_api_key()
+        if not api_key:
+            return None
+        result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
+        if not isinstance(result, dict) or not result.get("ok"):
+            return None
+        tasks = result.get("tasks", [])
+        # Only auto-claim wildcard tasks that nobody claimed yet
+        claimable = [
+            t for t in tasks
+            if t.get("assignee") == "*"
+            and not t.get("claimed_by")
+            and t.get("status") == "open"
+        ]
+        if not claimable:
+            return None
+        # Sort by priority (urgent first), then oldest
+        _PRIO = {"urgent": 0, "high": 1, "normal": 2, "low": 3}
+        claimable.sort(key=lambda t: (_PRIO.get(t.get("priority", "normal"), 2), t.get("created_at", "")))
+        target = claimable[0]
+        # Claim it
+        claim_result = be.sb_rpc("mc_task_claim", {
+            "p_api_key": api_key,
+            "p_task_id": target["id"],
+        })
+        if isinstance(claim_result, dict) and claim_result.get("ok"):
+            log.info(f"[meshcode] auto-claimed task: {target['title'][:60]}")
+            return {"id": target["id"][:8], "title": target["title"][:80], "priority": target.get("priority", "normal")}
+    except Exception as e:
+        log.debug(f"[meshcode] auto-claim failed: {e}")
+    return None
+
+
 @mcp.tool()
 @with_working_status
 async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -> Dict[str, Any]:
@@ -2042,6 +2083,16 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                     result["pending_tasks"] = pending_tasks
                     break  # Return so agent can work tasks
 
+                # Auto-claim: when idle >30s with no assigned tasks, try to
+                # claim the oldest open wildcard task. This makes agents
+                # self-directing instead of waiting passively for assignment.
+                if _CONSECUTIVE_IDLE_SECONDS >= 30 and not _is_leader_agent():
+                    claimed = _try_auto_claim_task()
+                    if claimed:
+                        result["auto_claimed"] = claimed
+                        result["pending_tasks"] = [claimed]
+                        break  # Return so agent works the claimed task
+
                 # Update status to sleeping after threshold, but keep looping
                 if _AUTO_SLEEP_THRESHOLD > 0 and _CONSECUTIVE_IDLE_SECONDS >= _AUTO_SLEEP_THRESHOLD and not _STAY_AWAKE:
                     try:
@@ -2132,6 +2183,16 @@ def _mark_realtime_msgs_read_in_db(messages: List[Dict[str, Any]]) -> None:
         except Exception as e:
             log.debug(f"mark_read failed for msg {mid}: {e}")
 
+    # Confirm delivery (best-effort, background) — completes the
+    # delivery pipeline: sent → read → confirmed.
+    try:
+        be.sb_rpc("mc_confirm_delivery", {
+            "p_api_key": api_key,
+            "p_message_ids": msg_ids,
+        })
+    except Exception:
+        pass  # Non-critical: messages still work without confirmation
+
 
 async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[str, Any]:
 

meshcode-2.10.60/meshcode/supervisor.py

@@ -0,0 +1,186 @@
+"""MeshCode Process Supervisor — auto-restart agents on crash.
+
+Generates macOS launchd plists (or simple bash wrappers) that keep
+agents running 24/7. When Claude crashes or MCP dies, the supervisor
+restarts in 2-5 seconds automatically.
+
+Usage:
+    meshcode supervisor start <project> <agent>  — install + start launchd plist
+    meshcode supervisor stop <project> <agent>   — stop + uninstall
+    meshcode supervisor status                   — list supervised agents
+    meshcode supervisor --simple <project> <agent> — bash while-loop fallback
+"""
+import os
+import sys
+import subprocess
+import json
+import platform
+from pathlib import Path
+
+
+_PLIST_DIR = Path.home() / "Library" / "LaunchAgents"
+_PLIST_PREFIX = "io.meshcode.agent"
+
+
+def _plist_path(project: str, agent: str) -> Path:
+    safe_name = f"{project}-{agent}".replace("/", "-").replace(" ", "-")
+    return _PLIST_DIR / f"{_PLIST_PREFIX}.{safe_name}.plist"
+
+
+def _plist_label(project: str, agent: str) -> str:
+    safe_name = f"{project}-{agent}".replace("/", "-").replace(" ", "-")
+    return f"{_PLIST_PREFIX}.{safe_name}"
+
+
+def _find_meshcode_bin() -> str:
+    """Find the meshcode executable path."""
+    import shutil
+    path = shutil.which("meshcode")
+    if path:
+        return path
+    # Fallback: python -m meshcode
+    return f"{sys.executable} -m meshcode"
+
+
+def _generate_plist(project: str, agent: str) -> str:
+    """Generate a launchd plist XML for auto-restarting an agent."""
+    label = _plist_label(project, agent)
+    meshcode_bin = _find_meshcode_bin()
+    log_dir = Path.home() / ".meshcode" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    stdout_log = log_dir / f"{project}-{agent}.stdout.log"
+    stderr_log = log_dir / f"{project}-{agent}.stderr.log"
+
+    # Build the command
+    if " -m " in meshcode_bin:
+        parts = meshcode_bin.split()
+        program_args = parts + ["run", project, agent]
+    else:
+        program_args = [meshcode_bin, "run", project, agent]
+
+    args_xml = "\n".join(f"        <string>{a}</string>" for a in program_args)
+
+    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>{label}</string>
+    <key>ProgramArguments</key>
+    <array>
+{args_xml}
+    </array>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>5</integer>
+    <key>StandardOutPath</key>
+    <string>{stdout_log}</string>
+    <key>StandardErrorPath</key>
+    <string>{stderr_log}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:{os.path.dirname(sys.executable)}</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+
+def start(project: str, agent: str) -> None:
+    """Install and start a launchd supervisor for an agent."""
+    if platform.system() != "Darwin":
+        print("[meshcode supervisor] launchd is macOS only. Use --simple for other platforms.")
+        return
+
+    plist = _plist_path(project, agent)
+    _PLIST_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Write plist
+    plist.write_text(_generate_plist(project, agent))
+    print(f"[meshcode supervisor] Plist written: {plist}")
+
+    # Load it
+    result = subprocess.run(
+        ["launchctl", "load", str(plist)],
+        capture_output=True, text=True
+    )
+    if result.returncode == 0:
+        print(f"[meshcode supervisor] Agent {agent}@{project} supervised (KeepAlive=true)")
+        print(f"[meshcode supervisor] Logs: ~/.meshcode/logs/{project}-{agent}.stderr.log")
+    else:
+        print(f"[meshcode supervisor] ERROR: launchctl load failed: {result.stderr.strip()}")
+
+
+def stop(project: str, agent: str) -> None:
+    """Stop and uninstall a supervised agent."""
+    plist = _plist_path(project, agent)
+    if not plist.exists():
+        print(f"[meshcode supervisor] No plist found for {agent}@{project}")
+        return
+
+    result = subprocess.run(
+        ["launchctl", "unload", str(plist)],
+        capture_output=True, text=True
+    )
+    plist.unlink(missing_ok=True)
+    print(f"[meshcode supervisor] Agent {agent}@{project} unsupervised")
+
+
+def status() -> None:
+    """List all supervised agents."""
+    if not _PLIST_DIR.exists():
+        print("[meshcode supervisor] No supervised agents")
+        return
+
+    plists = list(_PLIST_DIR.glob(f"{_PLIST_PREFIX}.*.plist"))
+    if not plists:
+        print("[meshcode supervisor] No supervised agents")
+        return
+
+    print(f"[meshcode supervisor] {len(plists)} supervised agent(s):")
+    for p in sorted(plists):
+        label = p.stem.replace(f"{_PLIST_PREFIX}.", "")
+        # Check if running
+        result = subprocess.run(
+            ["launchctl", "list", f"{_PLIST_PREFIX}.{label}"],
+            capture_output=True, text=True
+        )
+        running = result.returncode == 0
+        state = "RUNNING" if running else "STOPPED"
+        print(f"  {label}: {state}")
+
+
+def simple(project: str, agent: str) -> None:
+    """Simple bash while-loop supervisor (cross-platform fallback)."""
+    meshcode_bin = _find_meshcode_bin()
+    print(f"[meshcode supervisor] Starting simple supervisor for {agent}@{project}")
+    print("[meshcode supervisor] Press Ctrl+C to stop")
+
+    restart_count = 0
+    while True:
+        restart_count += 1
+        print(f"\n[meshcode supervisor] Starting agent (attempt #{restart_count})...")
+        try:
+            if " -m " in meshcode_bin:
+                parts = meshcode_bin.split()
+                cmd = parts + ["run", project, agent]
+            else:
+                cmd = [meshcode_bin, "run", project, agent]
+            result = subprocess.run(cmd)
+            print(f"[meshcode supervisor] Agent exited with code {result.returncode}")
+        except KeyboardInterrupt:
+            print("\n[meshcode supervisor] Stopped by user")
+            break
+        except Exception as e:
+            print(f"[meshcode supervisor] Error: {e}")
+
+        import time
+        backoff = min(2 + restart_count, 10)
+        print(f"[meshcode supervisor] Restarting in {backoff}s...")
+        try:
+            time.sleep(backoff)
+        except KeyboardInterrupt:
+            print("\n[meshcode supervisor] Stopped by user")
+            break

{meshcode-2.10.58 → meshcode-2.10.60}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.58 → meshcode-2.10.60}/meshcode.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ meshcode/run_agent.py
 meshcode/secrets.py
 meshcode/self_update.py
 meshcode/setup_clients.py
+meshcode/supervisor.py
 meshcode.egg-info/PKG-INFO
 meshcode.egg-info/SOURCES.txt
 meshcode.egg-info/dependency_links.txt

{meshcode-2.10.58 → meshcode-2.10.60}/pyproject.toml

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