meshcode 2.10.46__tar.gz → 2.10.48__tar.gz

{meshcode-2.10.46 → meshcode-2.10.48}/PKG-INFO

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

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.46"
+__version__ = "2.10.48"

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/comms_v4.py

@@ -640,11 +640,19 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
     # Flip status to 'working' so the dashboard reflects real-time activity.
     # We'll flip back to 'sleeping' (or 'online' if any reply went out) at the end.
     try:
-        sb_update("mc_agents",
-                  f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                  {"status": "working", "task": f"headless: msg from {from_agent}",
+        _ak = _load_api_key_for_cli()
+        _fields = {"status": "working", "task": f"headless: msg from {from_agent}",
                    "last_active_at": now_iso(), "last_heartbeat": now_iso(),
-                   "last_woken_at": now_iso()})
+                   "last_woken_at": now_iso()}
+        if _ak:
+            _r = sb_rpc("mc_update_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                            "p_agent_name": name, "p_fields": _fields})
+            if not (_r and _r.get("ok")):
+                sb_update("mc_agents",
+                          f"project_id=eq.{project_id}&name=eq.{quote(name)}", _fields)
+        else:
+            sb_update("mc_agents",
+                      f"project_id=eq.{project_id}&name=eq.{quote(name)}", _fields)
     except Exception:
         pass
     try:
@@ -692,10 +700,18 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
     try:
         # Flip status back to 'sleeping' after the headless turn ends.
         # The agent is identity-only at rest; next message wakes it again.
-        sb_update("mc_agents",
-                  f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                  {"status": "sleeping", "task": "Waiting for messages...",
-                   "last_active_at": now_iso(), "last_heartbeat": now_iso()})
+        _ak = _load_api_key_for_cli()
+        _fields = {"status": "sleeping", "task": "Waiting for messages...",
+                   "last_active_at": now_iso(), "last_heartbeat": now_iso()}
+        if _ak:
+            _r = sb_rpc("mc_update_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                            "p_agent_name": name, "p_fields": _fields})
+            if not (_r and _r.get("ok")):
+                sb_update("mc_agents",
+                          f"project_id=eq.{project_id}&name=eq.{quote(name)}", _fields)
+        else:
+            sb_update("mc_agents",
+                      f"project_id=eq.{project_id}&name=eq.{quote(name)}", _fields)
     except Exception:
         pass
 
@@ -995,16 +1011,24 @@ def register(project, name, role=""):
         return
 
     # Update tty/pid (RPC doesn't take these — patch separately)
-    sb_update("mc_agents",
-        f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-        {"tty": tty, "pid": ppid, "task": role, "last_heartbeat": now_iso()})
+    _fields_reg = {"tty": tty, "pid": ppid, "task": role, "last_heartbeat": now_iso()}
+    _r_upd = sb_rpc("mc_update_agent", {"p_api_key": _api_key, "p_project_id": project_id,
+                                         "p_agent_name": name, "p_fields": _fields_reg})
+    if not (_r_upd and _r_upd.get("ok")):
+        sb_update("mc_agents",
+            f"project_id=eq.{project_id}&name=eq.{quote(name)}", _fields_reg)
 
     # Save local session file (for nudge TTY detection)
     session_data = {"project": project, "agent": name, "pid": ppid, "tty": tty, "registered_at": now()}
     (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data), encoding="utf-8")
 
     # Get all agents in project
-    agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
+    _r_agents = sb_rpc("mc_get_agents", {"p_api_key": _api_key, "p_project_id": project_id,
+                                          "p_agent_name": None, "p_select": None, "p_limit": None})
+    if _r_agents and _r_agents.get("ok"):
+        agents = _r_agents.get("agents", [])
+    else:
+        agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
     agent_names = [a["name"] for a in agents]
 
     # Count pending messages
@@ -1044,7 +1068,15 @@ def _resolve_agent_name(project_id, name):
     """Resolve partial agent name to full registered name."""
     if not name or name == "*":
         return name
-    agents = sb_select("mc_agents", f"project_id=eq.{project_id}", limit=50)
+    _ak = _load_api_key_for_cli()
+    agents = None
+    if _ak:
+        _r = sb_rpc("mc_get_agents", {"p_api_key": _ak, "p_project_id": project_id,
+                                       "p_agent_name": None, "p_select": ["name"], "p_limit": 50})
+        if _r and _r.get("ok"):
+            agents = _r.get("agents", [])
+    if agents is None:
+        agents = sb_select("mc_agents", f"project_id=eq.{project_id}", limit=50)
     if not agents:
         return name
     all_names = [a["name"] for a in agents]
@@ -1107,8 +1139,17 @@ def send_msg(project, from_agent, to_agent, content, msg_type="msg", compact=Fal
         # and forth and burn tokens forever.
         if msg_type not in ("ack", "warning") and from_agent != "system":
             if not _is_pure_ack_payload(payload):
-                agents = sb_select("mc_agents",
-                    f"project_id=eq.{project_id}&name=eq.{quote(to_agent)}")
+                _ak = _load_api_key_for_cli()
+                agents = None
+                if _ak:
+                    _r = sb_rpc("mc_get_agents", {"p_api_key": _ak, "p_project_id": project_id,
+                                                   "p_agent_name": to_agent, "p_select": ["name", "status"],
+                                                   "p_limit": 1})
+                    if _r and _r.get("ok"):
+                        agents = _r.get("agents", [])
+                if agents is None:
+                    agents = sb_select("mc_agents",
+                        f"project_id=eq.{project_id}&name=eq.{quote(to_agent)}")
                 if agents and agents[0].get("status") not in ("offline", "killed"):
                     nudge_agent(project, to_agent, from_agent)
     else:
@@ -1119,7 +1160,15 @@ def broadcast(project, from_agent, content, msg_type="broadcast"):
     project_id = get_project_id(project)
     if not project_id:
         return
-    agents = sb_select("mc_agents", f"project_id=eq.{project_id}")
+    _ak = _load_api_key_for_cli()
+    agents = None
+    if _ak:
+        _r = sb_rpc("mc_get_agents", {"p_api_key": _ak, "p_project_id": project_id,
+                                       "p_agent_name": None, "p_select": ["name"], "p_limit": None})
+        if _r and _r.get("ok"):
+            agents = _r.get("agents", [])
+    if agents is None:
+        agents = sb_select("mc_agents", f"project_id=eq.{project_id}")
     count = 0
     for agent in agents:
         if agent["name"] != from_agent:
@@ -1191,8 +1240,17 @@ def inbox(project, name):
         return
 
     # Agent status
-    agent_rows = sb_select("mc_agents",
-        f"project_id=eq.{project_id}&name=eq.{quote(name)}", limit=1)
+    _ak = _load_api_key_for_cli()
+    agent_rows = None
+    if _ak:
+        _r = sb_rpc("mc_get_agents", {"p_api_key": _ak, "p_project_id": project_id,
+                                       "p_agent_name": name, "p_select": ["name", "status", "task"],
+                                       "p_limit": 1})
+        if _r and _r.get("ok"):
+            agent_rows = _r.get("agents", [])
+    if agent_rows is None:
+        agent_rows = sb_select("mc_agents",
+            f"project_id=eq.{project_id}&name=eq.{quote(name)}", limit=1)
     if agent_rows:
         a = agent_rows[0]
         print(f"[{project}] {name} | status: {a.get('status', '?')} | task: {a.get('task', '-')}")
@@ -1242,9 +1300,16 @@ def hook_check():
         return
 
     # Always heartbeat — keeps agent alive on dashboard
-    sb_update("mc_agents",
-        f"project_id=eq.{project_id}&name=eq.{quote(agent)}",
-        {"status": "working", "last_heartbeat": now_iso()})
+    _ak = _load_api_key_for_cli()
+    _hb_fields = {"status": "working", "last_heartbeat": now_iso()}
+    _hb_ok = False
+    if _ak:
+        _r = sb_rpc("mc_update_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                         "p_agent_name": agent, "p_fields": _hb_fields})
+        _hb_ok = bool(_r and _r.get("ok"))
+    if not _hb_ok:
+        sb_update("mc_agents",
+            f"project_id=eq.{project_id}&name=eq.{quote(agent)}", _hb_fields)
 
     # Check for unread non-ack messages
     pending = sb_select("mc_messages",
@@ -1268,14 +1333,24 @@ def watch(project, name, interval=10, timeout=0):
     if not project_id:
         return
 
+    _ak = _load_api_key_for_cli()
+
+    def _update_agent_status(fields):
+        """Try RPC first, fall back to direct PostgREST."""
+        if _ak:
+            _r = sb_rpc("mc_update_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                             "p_agent_name": name, "p_fields": fields})
+            if _r and _r.get("ok"):
+                return
+        sb_update("mc_agents",
+            f"project_id=eq.{project_id}&name=eq.{quote(name)}", fields)
+
     import signal
     _interrupted = [False]
     def handle_interrupt(signum, frame):
         _interrupted[0] = True
         print(f"\n[{project}] {name}: Watch interrumpido por el usuario.")
-        sb_update("mc_agents",
-            f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-            {"status": "online", "task": "Listening to user", "last_heartbeat": now_iso()})
+        _update_agent_status({"status": "online", "task": "Listening to user", "last_heartbeat": now_iso()})
         sys.exit(0)
     try:
         signal.signal(signal.SIGINT, handle_interrupt)
@@ -1283,9 +1358,7 @@ def watch(project, name, interval=10, timeout=0):
         pass  # Non-main thread (Windows restriction)
 
     # Update status to standby
-    sb_update("mc_agents",
-        f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-        {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
+    _update_agent_status({"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
     cycle = timeout if timeout > 0 else 600
     print(f"[{project}] {name} en watch — poll cada {interval}s, ciclo {cycle}s (auto-loop)")
@@ -1303,15 +1376,11 @@ def watch(project, name, interval=10, timeout=0):
                 print(f"\n*** [{project.upper()}] MENSAJE RECIBIDO ({elapsed}s en standby) ***")
                 read_messages(project, name, silent=False, send_acks=False)
 
-                sb_update("mc_agents",
-                    f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                    {"status": "working", "task": "Procesando mensaje recibido", "last_heartbeat": now_iso()})
+                _update_agent_status({"status": "working", "task": "Procesando mensaje recibido", "last_heartbeat": now_iso()})
 
                 # Reset to standby and keep polling (don't exit the loop)
                 time.sleep(2)
-                sb_update("mc_agents",
-                    f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                    {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
+                _update_agent_status({"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
                 continue
 
             # Heartbeat
@@ -1320,9 +1389,7 @@ def watch(project, name, interval=10, timeout=0):
 
         # Cycle ended without messages — check user context, then AUTO-RESTART watch
         print(f"[{project}] No messages this cycle. Watch active, still running. Standby.")
-        sb_update("mc_agents",
-            f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-            {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
+        _update_agent_status({"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
 
 def update_board(project, name, status, task=""):
@@ -1347,8 +1414,15 @@ def update_board(project, name, status, task=""):
     if task:
         updates["task"] = task
 
-    sb_update("mc_agents",
-        f"project_id=eq.{project_id}&name=eq.{quote(name)}", updates)
+    _ak = _load_api_key_for_cli()
+    _ub_ok = False
+    if _ak:
+        _r = sb_rpc("mc_update_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                         "p_agent_name": name, "p_fields": updates})
+        _ub_ok = bool(_r and _r.get("ok"))
+    if not _ub_ok:
+        sb_update("mc_agents",
+            f"project_id=eq.{project_id}&name=eq.{quote(name)}", updates)
     print(f"[{project}] {name}: {status} — {task}")
 
 
@@ -1358,7 +1432,15 @@ def show_board(project):
         print(f"[{project}] Project not found")
         return
 
-    agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
+    _ak = _load_api_key_for_cli()
+    agents = None
+    if _ak:
+        _r = sb_rpc("mc_get_agents", {"p_api_key": _ak, "p_project_id": project_id,
+                                       "p_agent_name": None, "p_select": None, "p_limit": None})
+        if _r and _r.get("ok"):
+            agents = _r.get("agents", [])
+    if agents is None:
+        agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
     if not agents:
         print(f"[{project}] Sin agentes")
         return
@@ -1395,7 +1477,14 @@ def show_status(project=None):
     print(f"{'='*60}")
 
     for proj in projects_data:
-        agents = sb_select("mc_agents", f"project_id=eq.{proj['id']}", order="name.asc")
+        agents = None
+        if api_key:
+            _r = sb_rpc("mc_get_agents", {"p_api_key": api_key, "p_project_id": proj['id'],
+                                           "p_agent_name": None, "p_select": None, "p_limit": None})
+            if _r and _r.get("ok"):
+                agents = _r.get("agents", [])
+        if agents is None:
+            agents = sb_select("mc_agents", f"project_id=eq.{proj['id']}", order="name.asc")
         if not agents:
             continue
 
@@ -1494,7 +1583,14 @@ def unregister(project, name):
     project_id = get_project_id(project)
     if not project_id:
         return
-    sb_delete("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(name)}")
+    _ak = _load_api_key_for_cli()
+    _del_ok = False
+    if _ak:
+        _r = sb_rpc("mc_delete_agent", {"p_api_key": _ak, "p_project_id": project_id,
+                                         "p_agent_name": name})
+        _del_ok = bool(_r and _r.get("ok"))
+    if not _del_ok:
+        sb_delete("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(name)}")
 
     # Clean local session
     session_file = SESSIONS_DIR / f"{project}_{name}"
@@ -1570,17 +1666,30 @@ def _start_heartbeat_daemon(project, name):
     except Exception:
         pass
 
+    _ak = _load_api_key_for_cli()
     code = (
         "import os,sys,time,json,urllib.request\n"
         f"project={project!r}; name={name!r}\n"
         f"url={SUPABASE_URL!r}; key={SUPABASE_KEY!r}\n"
+        f"api_key={_ak!r}\n"
         "import urllib.parse\n"
         "def post(path, body):\n"
         "    req=urllib.request.Request(url+path, data=json.dumps(body).encode(),\n"
         "        headers={'apikey':key,'Authorization':'Bearer '+key,'Content-Type':'application/json','Accept-Profile':'meshcode','Content-Profile':'meshcode'}, method='POST')\n"
         "    try: urllib.request.urlopen(req,timeout=10).read()\n"
         "    except Exception: pass\n"
+        "def rpc(fn, params):\n"
+        "    req=urllib.request.Request(url+'/rest/v1/rpc/'+fn, data=json.dumps(params).encode(),\n"
+        "        headers={'apikey':key,'Authorization':'Bearer '+key,'Content-Type':'application/json'}, method='POST')\n"
+        "    try:\n"
+        "        d=json.loads(urllib.request.urlopen(req,timeout=10).read())\n"
+        "        return d\n"
+        "    except Exception: return None\n"
         "def get_pid_for_project():\n"
+        "    if api_key:\n"
+        "        r=rpc('mc_resolve_project',{'p_api_key':api_key,'p_project_name':project})\n"
+        "        if isinstance(r,dict) and r.get('project_id'): return r['project_id']\n"
+        "        if isinstance(r,list) and r and r[0].get('project_id'): return r[0]['project_id']\n"
         "    req=urllib.request.Request(url+'/rest/v1/mc_projects?select=id&name=eq.'+urllib.parse.quote(project), headers={'apikey':key,'Authorization':'Bearer '+key,'Accept-Profile':'meshcode'})\n"
         "    try:\n"
         "        d=json.loads(urllib.request.urlopen(req,timeout=10).read())\n"
@@ -1588,6 +1697,11 @@ def _start_heartbeat_daemon(project, name):
         "    except Exception: return None\n"
         "def check_still_leased(pid):\n"
         "    \"\"\"Return False if force-disconnected (instance_id cleared).\"\"\"\n"
+        "    if api_key:\n"
+        "        r=rpc('mc_get_agents',{'p_api_key':api_key,'p_project_id':pid,'p_agent_name':name,'p_select':['instance_id'],'p_limit':1})\n"
+        "        if r and isinstance(r,dict) and r.get('ok'):\n"
+        "            agents=r.get('agents',[])\n"
+        "            return bool(agents and agents[0].get('instance_id'))\n"
         "    try:\n"
         "        req=urllib.request.Request(url+'/rest/v1/mc_agents?select=instance_id&project_id=eq.'+pid+'&name=eq.'+urllib.parse.quote(name),\n"
         "            headers={'apikey':key,'Authorization':'Bearer '+key,'Accept-Profile':'meshcode'})\n"

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/meshcode_mcp/backend.py

@@ -334,7 +334,13 @@ _recording_session_id = ""
 
 # RPCs that should NOT be recorded (internal/heartbeat/recording itself)
 _SKIP_RECORDING = {"mc_heartbeat", "mc_record_event", "mc_agent_set_status_by_api_key",
-                    "mc_acquire_agent_lease", "mc_release_agent_lease"}
+                    "mc_acquire_agent_lease", "mc_release_agent_lease",
+                    "mc_update_agent", "mc_get_agents"}
+
+
+def _get_api_key() -> Optional[str]:
+    """Return the current agent's API key (set at boot via enable_recording)."""
+    return _recording_api_key or os.environ.get("MESHCODE_API_KEY") or None
 
 
 def enable_recording(api_key: str, project_id: str, agent_name: str, session_id: str):
@@ -462,9 +468,23 @@ def register_agent(project: str, name: str, role: str = "", api_key: Optional[st
     if not result or (isinstance(result, dict) and result.get("error")):
         return result or {"error": "Failed to register agent"}
 
-    sb_update("mc_agents",
-              f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-              {"task": role, "last_heartbeat": _now_iso()})
+    # Prefer SECURITY DEFINER RPC for mc_agents update
+    _ak = api_key or _get_api_key()
+    _agent_updated = False
+    if _ak:
+        _upd = sb_rpc("mc_update_agent", {
+            "p_api_key": _ak,
+            "p_project_id": project_id,
+            "p_agent_name": name,
+            "p_fields": {"task": role, "last_heartbeat": _now_iso()},
+        })
+        if isinstance(_upd, dict) and _upd.get("ok"):
+            _agent_updated = True
+    if not _agent_updated:
+        # Fallback: direct PATCH (gradual rollout)
+        sb_update("mc_agents",
+                  f"project_id=eq.{project_id}&name=eq.{quote(name)}",
+                  {"task": role, "last_heartbeat": _now_iso()})
 
     return {
         "registered": True,
@@ -522,15 +542,42 @@ def resolve_agent_name(project_id: str, name: str) -> str:
     cached = _agent_name_cache_get(project_id, name)
     if cached is not None:
         return cached
-    # Exact match — fast path
-    exact = sb_select("mc_agents",
-                      f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                      limit=1)
+    # Exact match — fast path (prefer SECURITY DEFINER RPC)
+    api_key = _get_api_key()
+    exact = None
+    if api_key:
+        _res = sb_rpc("mc_get_agents", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_agent_name": name,
+            "p_select": None,
+            "p_limit": 1,
+        })
+        if isinstance(_res, dict) and _res.get("ok"):
+            exact = _res.get("agents", [])
+    if exact is None:
+        # Fallback: direct SELECT (gradual rollout)
+        exact = sb_select("mc_agents",
+                          f"project_id=eq.{project_id}&name=eq.{quote(name)}",
+                          limit=1)
     if exact:
         _agent_name_cache_set(project_id, name, name)
         return name
     # Fuzzy: prefix or substring match among registered agents
-    agents = sb_select("mc_agents", f"project_id=eq.{project_id}&select=name")
+    agents = None
+    if api_key:
+        _res2 = sb_rpc("mc_get_agents", {
+            "p_api_key": api_key,
+            "p_project_id": project_id,
+            "p_agent_name": None,
+            "p_select": ["name"],
+            "p_limit": None,
+        })
+        if isinstance(_res2, dict) and _res2.get("ok"):
+            agents = _res2.get("agents", [])
+    if agents is None:
+        # Fallback: direct SELECT (gradual rollout)
+        agents = sb_select("mc_agents", f"project_id=eq.{project_id}&select=name")
     if not agents:
         return name
     all_names = [a["name"] for a in agents]
@@ -845,7 +892,20 @@ def decrypt_payload(encrypted_b64: str, hex_key: str, aad: Optional[str] = None)
         return None
 
 
-def get_board(project_id: str) -> List[Dict]:
+def get_board(project_id: str, api_key: Optional[str] = None) -> List[Dict]:
+    # Prefer SECURITY DEFINER RPC
+    _ak = api_key or _get_api_key()
+    if _ak:
+        _res = sb_rpc("mc_get_agents", {
+            "p_api_key": _ak,
+            "p_project_id": project_id,
+            "p_agent_name": None,
+            "p_select": ["name", "role", "status", "task", "last_heartbeat", "registered_at"],
+            "p_limit": None,
+        })
+        if isinstance(_res, dict) and _res.get("ok"):
+            return _res.get("agents", [])
+    # Fallback: direct SELECT (gradual rollout)
     return sb_select(
         "mc_agents",
         f"project_id=eq.{project_id}&select=name,role,status,task,last_heartbeat,registered_at",
@@ -875,13 +935,24 @@ def set_status(project_id: str, agent: str, status: str, task: str = "", api_key
             return {"ok": True, "status": status}
         # Fall through to direct PATCH if RPC doesn't exist yet
 
-    # Fallback: direct PATCH (may silently fail with anon key if RLS blocks)
-    updates = {"status": status, "last_heartbeat": _now_iso()}
+    # Fallback: try mc_update_agent RPC, then direct PATCH
+    _ak = api_key or _get_api_key()
+    fields: Dict[str, Any] = {"status": status, "last_heartbeat": _now_iso()}
     if task:
-        updates["task"] = task
+        fields["task"] = task
     if editor:
-        updates["editor"] = editor
-    result = sb_update("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(agent)}", updates)
+        fields["editor"] = editor
+    if _ak:
+        _upd = sb_rpc("mc_update_agent", {
+            "p_api_key": _ak,
+            "p_project_id": project_id,
+            "p_agent_name": agent,
+            "p_fields": fields,
+        })
+        if isinstance(_upd, dict) and _upd.get("ok"):
+            return {"ok": True, "status": status}
+    # Final fallback: direct PATCH (may silently fail with anon key if RLS blocks)
+    result = sb_update("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(agent)}", fields)
     if isinstance(result, dict) and result.get("_error"):
         return {"error": result["_error"]}
     return {"ok": True, "status": status}

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/meshcode_mcp/realtime.py

@@ -143,7 +143,7 @@ class RealtimeListener:
         # can hang indefinitely behind a corporate firewall / DNS stall, which
         # blocks the MCP lifespan startup -> Claude Code times out the spawn
         # -> "Failed to reconnect".
-        connect_kwargs = {"ping_interval": 20, "ping_timeout": 10}
+        connect_kwargs = {"ping_interval": 20, "ping_timeout": 15}
         if _SSL_CTX is not None and self.ws_url.startswith("wss://"):
             connect_kwargs["ssl"] = _SSL_CTX
         ws = await asyncio.wait_for(

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/meshcode_mcp/server.py

@@ -118,6 +118,72 @@ _IN_WAIT = False  # True while meshcode_wait is blocking
 # the MCP server side (useful if comms_v4 nudge doesn't reach the agent).
 _AUTO_WAKE = os.environ.get("MESHCODE_AUTO_WAKE", "0").lower() in ("1", "true", "yes")
 
+# ============================================================
+# PID lockfile: prevent zombie MCP processes from accumulating.
+# When Claude Code respawns the MCP server, the old process may
+# still be alive. We write our PID to a lockfile on boot and
+# kill any stale process found there first.
+# ============================================================
+import signal as _signal
+import tempfile as _tempfile
+
+
+def _pid_lockfile_path() -> str:
+    """Return path to the PID lockfile for this agent."""
+    agent = os.environ.get("MESHCODE_AGENT", "unknown")
+    project = os.environ.get("MESHCODE_PROJECT", "unknown")
+    safe_name = f"meshcode_mcp_{project}_{agent}.pid".replace("/", "_").replace(" ", "_")
+    return os.path.join(_tempfile.gettempdir(), safe_name)
+
+
+def _kill_stale_mcp_process() -> None:
+    """Kill any stale MCP process for this agent found in the lockfile."""
+    lockfile = _pid_lockfile_path()
+    if not os.path.exists(lockfile):
+        return
+    try:
+        with open(lockfile, "r") as f:
+            old_pid = int(f.read().strip())
+        if old_pid == os.getpid():
+            return  # It's us
+        # Check if process is alive
+        os.kill(old_pid, 0)  # Signal 0 = existence check, no actual signal
+        # Process is alive — kill it gracefully, then forcefully
+        _mc_log(f"Killing stale MCP process (PID {old_pid})")
+        os.kill(old_pid, _signal.SIGTERM)
+        import time
+        time.sleep(1)
+        try:
+            os.kill(old_pid, 0)  # Still alive?
+            os.kill(old_pid, _signal.SIGKILL)
+            _mc_log(f"Force-killed stale MCP process (PID {old_pid})")
+        except OSError:
+            pass  # Already dead after SIGTERM
+    except (ValueError, FileNotFoundError):
+        pass  # Corrupt or missing lockfile
+    except OSError:
+        pass  # Process not found (already dead)
+
+
+def _write_pid_lockfile() -> None:
+    """Write current PID to lockfile."""
+    lockfile = _pid_lockfile_path()
+    try:
+        with open(lockfile, "w") as f:
+            f.write(str(os.getpid()))
+    except Exception as e:
+        _mc_log(f"Warning: couldn't write PID lockfile: {e}", level="warn")
+
+
+def _remove_pid_lockfile() -> None:
+    """Remove PID lockfile on shutdown."""
+    lockfile = _pid_lockfile_path()
+    try:
+        if os.path.exists(lockfile):
+            os.remove(lockfile)
+    except Exception:
+        pass
+
 
 def _try_auto_wake(from_agent: str, preview: str) -> None:
     """Inject a nudge into the terminal ONLY when agent is truly sleeping.
@@ -1362,6 +1428,10 @@ async def lifespan(_app):
     global _REALTIME, _MAIN_LOOP
     _MAIN_LOOP = asyncio.get_running_loop()
 
+    # Kill any stale MCP process for this agent before acquiring lease
+    _kill_stale_mcp_process()
+    _write_pid_lockfile()
+
     import platform as _pl
     if _pl.system() == "Windows":
         log.info(
@@ -1431,6 +1501,10 @@ async def lifespan(_app):
             _heartbeat_stop.set()
         except Exception:
             pass
+        try:
+            _remove_pid_lockfile()
+        except Exception:
+            pass
         try:
             _record_event_bg("shutdown", {"agent": AGENT_NAME, "session_id": _SESSION_ID})
         except Exception:
@@ -2068,9 +2142,14 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
             woke = await asyncio.shield(
                 _REALTIME.wait_for_message(timeout=float(actual_timeout))
             )
-        except (asyncio.CancelledError, Exception) as _cancel_exc:
-            log.debug(f"[meshcode] wait_for_message cancelled/failed: {type(_cancel_exc).__name__}")
+        except asyncio.CancelledError:
+            log.debug("[meshcode] wait_for_message cancelled by ESC")
             return {"timed_out": True, "reason": "cancelled_by_client"}
+        except Exception as _wait_exc:
+            # Non-cancellation errors (e.g. connection dropped) — log and
+            # fall through to DB fallback instead of masking the error.
+            log.warning(f"[meshcode] wait_for_message error: {type(_wait_exc).__name__}: {_wait_exc}")
+            woke = False
         if woke:
             buffered = _REALTIME.drain()
             if buffered:
@@ -2174,13 +2253,16 @@ def meshcode_done(reason: str) -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
-def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> Dict[str, Any]:
+def meshcode_check(include_acks: bool = False, since: Optional[str] = None, mark_read: bool = False) -> Dict[str, Any]:
     """Peek at inbox (non-destructive). Returns pending count + new messages.
 
     Args:
         include_acks: Include ack messages in response.
         since: ISO-8601 timestamp. Only return messages newer than this.
                Use meshcode_remember("last_seen", ts) to persist across sessions.
+        mark_read: When True, consume messages (mark as read in DB) instead of
+                   just peeking. Useful during boot when meshcode_wait() refuses
+                   to run because of open tasks.
     """
     global _LAST_SEEN_TS
     pending = be.count_pending(_PROJECT_ID, AGENT_NAME, api_key=_get_api_key())
@@ -2190,11 +2272,9 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
     deduped = [m for m in realtime_buffered if _seen_key(m) not in _SEEN_MSG_IDS]
 
     # Fallback: if realtime buffer is empty but DB has pending messages,
-    # fetch them from the DB. Use mark_read=False so meshcode_check is a
-    # non-destructive peek — messages stay pending until meshcode_wait or
-    # meshcode_read consumes them.
+    # fetch them from the DB. mark_read controls whether we consume or peek.
     if not deduped and pending > 0:
-        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=False, api_key=_get_api_key())
+        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=mark_read, api_key=_get_api_key())
         deduped = [
             {
                 "from": m["from_agent"],
@@ -2213,6 +2293,14 @@ def meshcode_check(include_acks: bool = False, since: Optional[str] = None) -> D
     if effective_since:
         deduped = [m for m in deduped if m.get("ts") and str(m["ts"]) > effective_since]
 
+    # When mark_read=True, update tracking state so messages aren't re-processed
+    if mark_read and deduped:
+        for m in deduped:
+            _SEEN_MSG_IDS.add(_seen_key(m))
+        latest_ts = max((str(m.get("ts", "")) for m in deduped), default=None)
+        if latest_ts and (not _LAST_SEEN_TS or latest_ts > _LAST_SEEN_TS):
+            _LAST_SEEN_TS = latest_ts
+
     split = _split_messages(deduped)
     if not include_acks:
         split["acks"] = []
@@ -2489,6 +2577,199 @@ def meshcode_task_reassign(task_id: str, new_assignee: str) -> Dict[str, Any]:
     })
 
 
+# ----------------- CROSS-MESH TASKS -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_create_cross_mesh_task(target_mesh: str, title: str,
+                                     description: str = "",
+                                     assignee: Optional[str] = None,
+                                     priority: str = "normal") -> Dict[str, Any]:
+    """Create a task in a linked meshwork (requires active mesh link).
+
+    Args:
+        target_mesh: Name of the target meshwork.
+        title: Task title.
+        description: Task description.
+        assignee: Agent name in target mesh to assign to.
+        priority: low / normal / high / urgent.
+    """
+    return be.sb_rpc("mc_create_cross_mesh_task", {
+        "p_api_key": _get_api_key(),
+        "p_target_mesh": target_mesh,
+        "p_title": title,
+        "p_description": description,
+        "p_assignee": assignee,
+        "p_priority": priority,
+        "p_agent_name": AGENT_NAME,
+    })
+
+
+# ----------------- GOALS -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_set_goal(title: str, description: str = "",
+                      priority: str = "normal", assignee: Optional[str] = None,
+                      target_date: Optional[str] = None,
+                      parent_id: Optional[str] = None) -> Dict[str, Any]:
+    """Create a new goal for the meshwork.
+
+    Args:
+        title: Goal title.
+        description: Optional detailed description.
+        priority: low / normal / high / urgent.
+        assignee: Agent name to assign the goal to.
+        target_date: Target date (YYYY-MM-DD format).
+        parent_id: UUID of parent goal for sub-goals.
+    """
+    return be.sb_rpc("mc_create_goal", {
+        "p_api_key": _get_api_key(),
+        "p_title": title,
+        "p_description": description,
+        "p_priority": priority,
+        "p_assignee": assignee,
+        "p_target_date": target_date,
+        "p_parent_id": parent_id,
+        "p_agent_name": AGENT_NAME,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_goals() -> Dict[str, Any]:
+    """List all goals for this meshwork."""
+    return be.sb_rpc("mc_get_goals", {
+        "p_api_key": _get_api_key(),
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_update_goal(goal_id: str, status: Optional[str] = None,
+                         title: Optional[str] = None,
+                         description: Optional[str] = None,
+                         priority: Optional[str] = None,
+                         assignee: Optional[str] = None) -> Dict[str, Any]:
+    """Update a goal's status or details.
+
+    Args:
+        goal_id: UUID of the goal to update.
+        status: active / in_progress / achieved / abandoned.
+        title: New title (optional).
+        description: New description (optional).
+        priority: New priority (optional).
+        assignee: New assignee (optional).
+    """
+    return be.sb_rpc("mc_update_goal", {
+        "p_api_key": _get_api_key(),
+        "p_goal_id": goal_id,
+        "p_status": status,
+        "p_title": title,
+        "p_description": description,
+        "p_priority": priority,
+        "p_assignee": assignee,
+    })
+
+
+# ----------------- MARKETPLACE -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_marketplace_search(query: Optional[str] = None,
+                                 category: Optional[str] = None) -> Dict[str, Any]:
+    """Search the MarketMesh marketplace for agents and meshes.
+
+    Args:
+        query: Search term (matches name, description, tags).
+        category: Filter by category (Development, Content, Marketing, etc.).
+    """
+    return be.sb_rpc("mc_marketplace_list", {
+        "p_category": category,
+        "p_search": query,
+        "p_status": "available",
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_marketplace_install(template_slug: str,
+                                  meshwork_name: str) -> Dict[str, Any]:
+    """Install a marketplace item — creates a new meshwork with pre-configured agents.
+
+    Args:
+        template_slug: The slug of the marketplace item to install.
+        meshwork_name: Name for the new meshwork (must be unique).
+    """
+    return be.sb_rpc("mc_marketplace_install_by_key", {
+        "p_api_key": _get_api_key(),
+        "p_template_slug": template_slug,
+        "p_meshwork_name": meshwork_name,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_marketplace_list_installed() -> Dict[str, Any]:
+    """List marketplace items you have installed."""
+    return be.sb_rpc("mc_marketplace_installed_by_key", {
+        "p_api_key": _get_api_key(),
+    })
+
+
+# ----------------- WEBHOOKS -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_webhook_register(url: str,
+                               events: Optional[list] = None,
+                               description: str = "") -> Dict[str, Any]:
+    """Register a webhook URL to receive POST notifications for mesh events.
+
+    Args:
+        url: The URL to POST events to.
+        events: List of event types to subscribe to.
+               Options: agent_online, agent_offline, task_created, task_completed,
+               message_cross_mesh, goal_updated.
+               Default: all events (agent_online, agent_offline, task_created,
+               task_completed, message_cross_mesh, goal_created, goal_updated).
+        description: Human-readable description of this webhook.
+
+    Returns the webhook_id and signing secret (save the secret — shown only once).
+    """
+    return be.sb_rpc("mc_webhook_register", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_url": url,
+        "p_events": events,
+        "p_description": description,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_webhook_list() -> Dict[str, Any]:
+    """List all registered webhooks for this meshwork."""
+    return be.sb_rpc("mc_webhook_list", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_webhook_delete(webhook_id: str) -> Dict[str, Any]:
+    """Delete a webhook by ID.
+
+    Args:
+        webhook_id: UUID of the webhook to delete.
+    """
+    return be.sb_rpc("mc_webhook_delete", {
+        "p_api_key": _get_api_key(),
+        "p_webhook_id": webhook_id,
+    })
+
+
 # ----------------- SCHEDULED TASKS -----------------
 
 @mcp.tool()

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode/run_agent.py

@@ -71,17 +71,49 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
         if not proj_data or not proj_data.get("project_id"):
             return generate_art(agent), agent, None
         project_id = proj_data["project_id"]
-        # Step 2: fetch existing art + role
-        req = Request(
-            f"{sb['SUPABASE_URL']}/rest/v1/mc_agents?select=ascii_art,role,id&name=eq.{urllib.parse.quote(agent)}&project_id=eq.{project_id}",
-            headers={
-                "apikey": sb["SUPABASE_KEY"],
-                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
-                "Accept-Profile": "meshcode",
-            },
-        )
-        with urlopen(req, timeout=5) as resp:
-            data = json.loads(resp.read().decode())
+        # Step 2: fetch existing art + role via mc_get_agents RPC
+        data = None
+        try:
+            rpc_body = json.dumps({
+                "p_api_key": api_key,
+                "p_project_id": project_id,
+                "p_agent_name": agent,
+                "p_select": ["ascii_art", "role", "id"],
+            })
+            rpc_req = Request(
+                f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_get_agents",
+                data=rpc_body.encode(),
+                method="POST",
+                headers={
+                    "apikey": sb["SUPABASE_KEY"],
+                    "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                    "Content-Type": "application/json",
+                    "Content-Profile": "meshcode",
+                },
+            )
+            with urlopen(rpc_req, timeout=5) as resp:
+                rpc_result = json.loads(resp.read().decode())
+            if isinstance(rpc_result, dict) and rpc_result.get("ok"):
+                data = rpc_result.get("agents") or []
+        except Exception:
+            pass  # fall through to legacy direct REST call
+
+        # Legacy fallback: direct REST call to mc_agents table
+        if data is None:
+            try:
+                req = Request(
+                    f"{sb['SUPABASE_URL']}/rest/v1/mc_agents?select=ascii_art,role,id&name=eq.{urllib.parse.quote(agent)}&project_id=eq.{project_id}",
+                    headers={
+                        "apikey": sb["SUPABASE_KEY"],
+                        "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                        "Accept-Profile": "meshcode",
+                    },
+                )
+                with urlopen(req, timeout=5) as resp:
+                    data = json.loads(resp.read().decode())
+            except Exception:
+                data = []
+
         if data:
             agent_id = data[0].get("id")
             # Step 3: fetch profile color
@@ -393,8 +425,8 @@ def _fetch_global_claude_version() -> Optional[str]:
         from urllib.request import Request, urlopen
         import json as _json
         req = Request(
-            f"{url}/rest/v1/rpc/mc_get_global_config_by_key",
-            data=_json.dumps({"p_api_key": api_key, "p_config_key": "claude_version"}).encode(),
+            f"{url}/rest/v1/rpc/mc_get_global_config",
+            data=_json.dumps({"p_key": "claude_code_version"}).encode(),
             headers={
                 "Content-Type": "application/json",
                 "apikey": anon_key,
@@ -719,7 +751,7 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     if not editor:
         print("[meshcode] ERROR: 'claude' not found in PATH", file=sys.stderr)
         print(f"[meshcode]        Workspace is ready at: {ws}", file=sys.stderr)
-        print("[meshcode]        Install Claude Code: npm install -g @anthropic-ai/claude-code", file=sys.stderr)
+        print("[meshcode]        Install Claude Code: npm install -g @anthropic-ai/claude-code@2.1.104", file=sys.stderr)
         if sys.platform == "win32":
             print("[meshcode]        Then verify: where claude", file=sys.stderr)
             print("[meshcode]        If 'where' finds it, open a NEW terminal and try again.", file=sys.stderr)
@@ -815,7 +847,7 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             else:
                 print(f"[meshcode]   Permission mode: bypass requested but --dangerously-skip-permissions")
                 print(f"[meshcode]   not supported by this Claude Code version. Agent will prompt for tools.")
-                print(f"[meshcode]   Upgrade Claude Code: npm install -g @anthropic-ai/claude-code@latest")
+                print(f"[meshcode]   Upgrade Claude Code: npm install -g @anthropic-ai/claude-code@2.1.104")
         else:
             print(f"[meshcode]   Permission mode: safe (Claude will prompt for every tool call)")
             print(f"[meshcode]   Tip: change with `meshcode prefs permission-mode bypass`")

{meshcode-2.10.46 → meshcode-2.10.48}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.46 → meshcode-2.10.48}/pyproject.toml

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