meshcode 1.0.0__tar.gz → 1.1.0__tar.gz

{meshcode-1.0.0 → meshcode-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 1.0.0
+Version: 1.1.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,6 +18,8 @@ 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
 
 # MeshCode
 

{meshcode-1.0.0 → meshcode-1.1.0}/meshcode/comms_v4.py

@@ -829,29 +829,45 @@ def connect(project, name, hook_target="claude", role=""):
     comms_path = str(Path(__file__).resolve())
 
     if hook_target == "claude":
-        settings_path = Path.home() / ".claude" / "settings.json"
-        hook_cmd = f"python3 {comms_path} check"
-
-        settings = {}
-        if settings_path.exists():
+        # Primary path: register MeshCode as an MCP server in ~/.mcp.json
+        # This replaces the AppleScript nudge entirely with native MCP delivery.
+        mcp_path = Path.home() / ".mcp.json"
+        server_id = f"meshcode-{project}-{name}"
+
+        # Load API key for the MCP server env
+        creds_path = Path.home() / ".meshcode" / "credentials.json"
+        api_key = ""
+        if creds_path.exists():
             try:
-                settings = json.loads(settings_path.read_text())
-            except:
+                api_key = json.loads(creds_path.read_text()).get("api_key", "")
+            except Exception:
                 pass
 
-        hooks = settings.setdefault("hooks", {})
-        post_hooks = hooks.setdefault("PostToolUse", [])
-
-        already = any(hook_cmd in h.get("command", "") for h in post_hooks)
-        if not already:
-            post_hooks.append({"command": hook_cmd, "matcher": ""})
-            settings_path.parent.mkdir(parents=True, exist_ok=True)
-            settings_path.write_text(json.dumps(settings, indent=2))
-            print(f"[MESHCODE] Hook PostToolUse instalado en {settings_path}")
-        else:
-            print(f"[MESHCODE] Hook PostToolUse ya existe")
-
-        print(f"[MESHCODE] Claude Code conectado a {project} como {name}")
+        mcp_cfg = {}
+        if mcp_path.exists():
+            try:
+                mcp_cfg = json.loads(mcp_path.read_text())
+            except Exception:
+                mcp_cfg = {}
+
+        servers = mcp_cfg.setdefault("mcpServers", {})
+        servers[server_id] = {
+            "command": "python3",
+            "args": ["-m", "meshcode.meshcode_mcp", "serve"],
+            "env": {
+                "MESHCODE_PROJECT": project,
+                "MESHCODE_AGENT": name,
+                "MESHCODE_ROLE": actual_role,
+                "MESHCODE_API_KEY": api_key,
+                "SUPABASE_URL": SUPABASE_URL,
+                "SUPABASE_KEY": SUPABASE_KEY,
+            },
+        }
+        mcp_path.write_text(json.dumps(mcp_cfg, indent=2))
+        print(f"[MESHCODE] MCP server '{server_id}' registrado en {mcp_path}")
+        print(f"[MESHCODE] Reinicia Claude Code para cargar el MCP server.")
+        print(f"[MESHCODE] Verifica con `/mcp` dentro de Claude Code.")
+        print(f"[MESHCODE] Tools disponibles: meshcode_send, meshcode_read, meshcode_check, meshcode_status, ...")
 
     elif hook_target == "codex":
         config_path = Path.cwd() / ".meshcode.json"
@@ -873,11 +889,16 @@ def connect(project, name, hook_target="claude", role=""):
         return
 
     # Print quickstart
-    print(f"\n[MESHCODE] ✓ Setup completo. Comandos útiles:")
-    print(f"  Leer:    python3 {comms_path} read {project} {name}")
-    print(f"  Enviar:  python3 {comms_path} send {project} {name}:<destino> '<mensaje>'")
-    print(f"  Board:   python3 {comms_path} board {project}")
-    print(f"  Watch:   python3 {comms_path} watch {project} {name}")
+    print(f"\n[MESHCODE] ✓ Setup completo.")
+    if hook_target == "claude":
+        print(f"  1. Reinicia Claude Code (cierra y vuelve a abrir)")
+        print(f"  2. Dentro de Claude, ejecuta `/mcp` para verificar que el server '{name}' esté listed")
+        print(f"  3. Empieza a usar las tools: meshcode_send, meshcode_read, etc.")
+        print(f"  Sin terminal extra. Sin watch loops. Sin AppleScript.")
+    else:
+        print(f"  Leer:    python3 {comms_path} read {project} {name}")
+        print(f"  Enviar:  python3 {comms_path} send {project} {name}:<destino> '<mensaje>'")
+        print(f"  Board:   python3 {comms_path} board {project}")
     print()
 
 

meshcode-1.1.0/meshcode/meshcode_mcp/__init__.py

@@ -0,0 +1,2 @@
+"""MeshCode MCP server — exposes meshcode tools to MCP clients (Claude Code, etc)."""
+__version__ = "1.0.0"

meshcode-1.1.0/meshcode/meshcode_mcp/__main__.py

@@ -0,0 +1,17 @@
+"""Run via: python -m meshcode_mcp serve"""
+import sys
+from .server import run_server
+
+
+def main():
+    args = sys.argv[1:]
+    if args and args[0] == "serve":
+        run_server()
+    else:
+        print("Usage: python -m meshcode_mcp serve", file=sys.stderr)
+        print("       (env vars: MESHCODE_PROJECT, MESHCODE_AGENT, SUPABASE_URL, SUPABASE_KEY)", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

meshcode-1.1.0/meshcode/meshcode_mcp/backend.py

@@ -0,0 +1,227 @@
+"""Thin Supabase REST backend used by both the MCP server and tests.
+
+Reuses the helpers from comms_v4.py without going through subprocess.
+Zero deps beyond stdlib (urllib).
+"""
+import json
+import os
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+SUPABASE_URL = os.environ.get(
+    "SUPABASE_URL",
+    "https://wwgzzmydrwrjgaebspdo.supabase.co",
+)
+SUPABASE_KEY = os.environ.get(
+    "SUPABASE_KEY",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Ind3Z3p6bXlkcndyamdhZWJzcGRvIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2NzY1NDc3MCwiZXhwIjoyMDgzMjMwNzcwfQ.0SBXfb8OtyHmfaKW3dFQ6JYbcLUzCS1d4oXg4V-RAag",
+)
+SCHEMA = "meshcode"
+
+
+def _now_iso() -> str:
+    return datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S+00:00")
+
+
+def _headers(*, prefer: Optional[str] = None, content_profile: bool = True) -> Dict[str, str]:
+    h = {
+        "apikey": SUPABASE_KEY,
+        "Authorization": f"Bearer {SUPABASE_KEY}",
+        "Content-Type": "application/json",
+    }
+    if content_profile:
+        h["Accept-Profile"] = SCHEMA
+        h["Content-Profile"] = SCHEMA
+    if prefer:
+        h["Prefer"] = prefer
+    return h
+
+
+def _request(method: str, path: str, *, data: Any = None, prefer: Optional[str] = None) -> Any:
+    url = f"{SUPABASE_URL}/rest/v1/{path}"
+    body = json.dumps(data).encode() if data else None
+    req = Request(url, data=body, method=method, headers=_headers(prefer=prefer))
+    try:
+        with urlopen(req, timeout=10) as resp:
+            raw = resp.read().decode()
+            return json.loads(raw) if raw.strip() else None
+    except HTTPError as e:
+        err = e.read().decode()
+        try:
+            err_obj = json.loads(err)
+            return {"_error": err_obj.get("message", err[:200]), "_code": e.code}
+        except Exception:
+            return {"_error": err[:200], "_code": e.code}
+    except URLError as e:
+        return {"_error": str(e.reason), "_code": 0}
+
+
+def sb_select(table: str, filters: str = "", order: Optional[str] = None, limit: Optional[int] = None) -> List[Dict]:
+    params = []
+    if filters:
+        params.append(filters)
+    if order:
+        params.append(f"order={order}")
+    if limit:
+        params.append(f"limit={limit}")
+    path = f"{table}?{'&'.join(params)}" if params else table
+    result = _request("GET", path)
+    if isinstance(result, dict) and result.get("_error"):
+        return []
+    return result or []
+
+
+def sb_insert(table: str, row: Dict, *, upsert: bool = False, on_conflict: Optional[str] = None) -> Any:
+    prefer = "return=representation"
+    if upsert:
+        prefer += ",resolution=merge-duplicates"
+    path = table
+    if on_conflict:
+        path += f"?on_conflict={on_conflict}"
+    return _request("POST", path, data=row, prefer=prefer)
+
+
+def sb_update(table: str, filters: str, updates: Dict) -> Any:
+    return _request("PATCH", f"{table}?{filters}", data=updates, prefer="return=representation")
+
+
+def sb_rpc(fn_name: str, params: Dict) -> Any:
+    url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
+    body = json.dumps(params).encode()
+    req = Request(url, data=body, method="POST", headers=_headers(content_profile=False))
+    try:
+        with urlopen(req, timeout=10) as resp:
+            raw = resp.read().decode()
+            return json.loads(raw) if raw.strip() else None
+    except HTTPError as e:
+        err = e.read().decode()
+        try:
+            return {"_error": json.loads(err).get("message", err[:200])}
+        except Exception:
+            return {"_error": err[:200]}
+    except URLError as e:
+        return {"_error": str(e.reason)}
+
+
+# ============================================================
+# Project + agent helpers
+# ============================================================
+
+def get_project_id(project_name: str) -> Optional[str]:
+    rows = sb_select("mc_projects", f"name=eq.{quote(project_name)}")
+    if rows:
+        return rows[0]["id"]
+    result = sb_insert("mc_projects", {"name": project_name})
+    if isinstance(result, list) and result:
+        return result[0]["id"]
+    return None
+
+
+def register_agent(project: str, name: str, role: str = "") -> Dict:
+    project_id = get_project_id(project)
+    if not project_id:
+        return {"error": f"Project '{project}' not found"}
+
+    result = sb_rpc("mc_register_agent", {
+        "p_project_id": project_id,
+        "p_name": name,
+        "p_role": role,
+        "p_status": "online",
+    })
+
+    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()})
+
+    return {
+        "registered": True,
+        "project_id": project_id,
+        "agent_name": name,
+        "agent_id": result.get("agent_id") if isinstance(result, dict) else None,
+    }
+
+
+def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any, msg_type: str = "msg") -> Dict:
+    if not isinstance(payload, dict):
+        payload = {"text": str(payload)}
+    msg = {
+        "project_id": project_id,
+        "from_agent": from_agent,
+        "to_agent": to_agent,
+        "type": msg_type,
+        "payload": payload,
+        "read": False,
+    }
+    result = sb_insert("mc_messages", msg)
+    if isinstance(result, dict) and result.get("_error"):
+        return {"error": result["_error"]}
+    if isinstance(result, list) and result:
+        return {"sent": True, "msg_id": result[0].get("id")}
+    return {"sent": True}
+
+
+def read_inbox(project_id: str, agent: str, mark_read: bool = True) -> List[Dict]:
+    messages = sb_select(
+        "mc_messages",
+        f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false",
+        order="created_at.asc",
+    )
+    if mark_read and messages:
+        for m in messages:
+            sb_update("mc_messages", f"id=eq.{m['id']}", {"read": True})
+
+        # Auto-ACK senders
+        ack_targets = {m["from_agent"] for m in messages if m.get("type") not in ("ack", "broadcast")}
+        for sender in ack_targets:
+            sb_insert("mc_messages", {
+                "project_id": project_id,
+                "from_agent": agent,
+                "to_agent": sender,
+                "type": "ack",
+                "payload": {"text": f"{agent} read your message"},
+                "read": False,
+            })
+    return messages
+
+
+def count_pending(project_id: str, agent: str) -> int:
+    pending = sb_select(
+        "mc_messages",
+        f"project_id=eq.{project_id}&to_agent=eq.{quote(agent)}&read=eq.false&type=neq.ack",
+        limit=1000,
+    )
+    return len(pending)
+
+
+def get_board(project_id: str) -> List[Dict]:
+    return sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
+
+
+def heartbeat(project_id: str, agent: str) -> Dict:
+    result = sb_rpc("mc_heartbeat", {"p_project_id": project_id, "p_agent_name": agent})
+    return result or {}
+
+
+def set_status(project_id: str, agent: str, status: str, task: str = "") -> Dict:
+    updates = {"status": status, "last_heartbeat": _now_iso()}
+    if task:
+        updates["task"] = task
+    result = sb_update("mc_agents", f"project_id=eq.{project_id}&name=eq.{quote(agent)}", updates)
+    if isinstance(result, dict) and result.get("_error"):
+        return {"error": result["_error"]}
+    return {"ok": True, "status": status}
+
+
+def get_history(project_id: str, limit: int = 20) -> List[Dict]:
+    return sb_select(
+        "mc_messages",
+        f"project_id=eq.{project_id}&type=neq.ack",
+        order="created_at.desc",
+        limit=limit,
+    )

meshcode-1.1.0/meshcode/meshcode_mcp/realtime.py

@@ -0,0 +1,181 @@
+"""Supabase Realtime listener for the MeshCode MCP server.
+
+Connects to Supabase Realtime via WebSocket (no supabase-py dep — uses
+the `websockets` package directly to keep the install light).
+
+When a new mc_message INSERT arrives for the current agent, it:
+  1. Pushes the message into an in-memory deque (consumed by meshcode_check tool)
+  2. Calls the registered notify_callback (FastMCP session.send_resource_updated)
+"""
+import asyncio
+import json
+import logging
+from collections import deque
+from typing import Any, Awaitable, Callable, Deque, Dict, Optional
+
+try:
+    import websockets
+    WEBSOCKETS_AVAILABLE = True
+except ImportError:
+    WEBSOCKETS_AVAILABLE = False
+
+log = logging.getLogger("meshcode-mcp.realtime")
+
+
+class RealtimeListener:
+    """Connects to Supabase Realtime and forwards mc_messages INSERTs to a callback."""
+
+    def __init__(
+        self,
+        supabase_url: str,
+        supabase_key: str,
+        project_id: str,
+        agent_name: str,
+        notify_callback: Optional[Callable[[Dict], Awaitable[None]]] = None,
+    ):
+        self.supabase_url = supabase_url
+        self.supabase_key = supabase_key
+        self.project_id = project_id
+        self.agent_name = agent_name
+        self.notify_callback = notify_callback
+
+        # Last 100 unread messages — drained by meshcode_check tool
+        self.queue: Deque[Dict] = deque(maxlen=100)
+        self._task: Optional[asyncio.Task] = None
+        self._stop = asyncio.Event()
+        self._connected = False
+
+    @property
+    def ws_url(self) -> str:
+        host = self.supabase_url.replace("https://", "").replace("http://", "").rstrip("/")
+        return f"wss://{host}/realtime/v1/websocket?apikey={self.supabase_key}&vsn=1.0.0"
+
+    async def start(self) -> None:
+        if not WEBSOCKETS_AVAILABLE:
+            log.warning("websockets package not installed — Realtime disabled")
+            return
+        if self._task and not self._task.done():
+            return
+        self._stop.clear()
+        self._task = asyncio.create_task(self._run(), name="meshcode-realtime")
+
+    async def stop(self) -> None:
+        self._stop.set()
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except (asyncio.CancelledError, Exception):
+                pass
+
+    async def _run(self) -> None:
+        """Outer loop: reconnect with exponential backoff on disconnect."""
+        backoff = 1
+        while not self._stop.is_set():
+            try:
+                await self._connect_and_listen()
+                backoff = 1  # reset on clean disconnect
+            except asyncio.CancelledError:
+                return
+            except Exception as e:
+                log.warning(f"Realtime connection error: {e}; reconnecting in {backoff}s")
+                try:
+                    await asyncio.wait_for(self._stop.wait(), timeout=backoff)
+                    return  # stop signaled
+                except asyncio.TimeoutError:
+                    pass
+                backoff = min(backoff * 2, 30)
+
+    async def _connect_and_listen(self) -> None:
+        """Single connection lifecycle: connect, subscribe, listen."""
+        async with websockets.connect(self.ws_url, ping_interval=20, ping_timeout=10) as ws:
+            self._connected = True
+            log.info(f"Realtime connected for agent={self.agent_name}")
+
+            # Phoenix channel join: phoenix realtime topic
+            topic = f"realtime:{self.project_id}-{self.agent_name}"
+            join_msg = {
+                "topic": topic,
+                "event": "phx_join",
+                "payload": {
+                    "config": {
+                        "postgres_changes": [
+                            {
+                                "event": "INSERT",
+                                "schema": "meshcode",
+                                "table": "mc_messages",
+                                "filter": f"to_agent=eq.{self.agent_name}",
+                            }
+                        ]
+                    }
+                },
+                "ref": "1",
+            }
+            await ws.send(json.dumps(join_msg))
+
+            # Heartbeat task to keep the connection alive
+            heartbeat_task = asyncio.create_task(self._heartbeat(ws))
+            try:
+                async for raw in ws:
+                    if self._stop.is_set():
+                        break
+                    try:
+                        msg = json.loads(raw)
+                    except Exception:
+                        continue
+                    await self._handle_message(msg)
+            finally:
+                heartbeat_task.cancel()
+                self._connected = False
+
+    async def _heartbeat(self, ws) -> None:
+        """Send phoenix heartbeats every 25s to keep the channel alive."""
+        ref = 0
+        while not self._stop.is_set():
+            await asyncio.sleep(25)
+            ref += 1
+            try:
+                await ws.send(json.dumps({
+                    "topic": "phoenix",
+                    "event": "heartbeat",
+                    "payload": {},
+                    "ref": str(ref),
+                }))
+            except Exception:
+                return
+
+    async def _handle_message(self, msg: Dict[str, Any]) -> None:
+        event = msg.get("event")
+        payload = msg.get("payload") or {}
+
+        # postgres_changes payload structure:
+        # {"event": "postgres_changes", "payload": {"data": {"record": {...}, "type": "INSERT", ...}}}
+        if event == "postgres_changes":
+            data = payload.get("data") or {}
+            if data.get("type") == "INSERT":
+                record = data.get("record") or {}
+                if record.get("to_agent") == self.agent_name:
+                    enriched = {
+                        "from": record.get("from_agent"),
+                        "type": record.get("type", "msg"),
+                        "ts": record.get("created_at"),
+                        "payload": record.get("payload", {}),
+                        "id": record.get("id"),
+                    }
+                    self.queue.append(enriched)
+                    log.info(f"new message from {enriched['from']}")
+                    if self.notify_callback:
+                        try:
+                            await self.notify_callback(enriched)
+                        except Exception as e:
+                            log.warning(f"notify_callback failed: {e}")
+
+    def drain(self) -> list:
+        """Pop and return all queued messages."""
+        out = list(self.queue)
+        self.queue.clear()
+        return out
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected

meshcode-1.1.0/meshcode/meshcode_mcp/server.py

@@ -0,0 +1,272 @@
+"""MeshCode MCP server — exposes meshcode tools to MCP clients (Claude Code, etc).
+
+Tools:    meshcode_send, meshcode_broadcast, meshcode_read, meshcode_check,
+          meshcode_status, meshcode_register, meshcode_set_status
+Resources: meshcode://inbox, meshcode://board, meshcode://history
+
+Run with:
+    MESHCODE_PROJECT=my-app MESHCODE_AGENT=backend python -m meshcode_mcp serve
+"""
+import asyncio
+import json
+import logging
+import os
+import sys
+from contextlib import asynccontextmanager
+from typing import Any, Dict, List, Optional
+
+from . import backend as be
+from .realtime import RealtimeListener
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except ImportError:
+    print(
+        "[meshcode-mcp] ERROR: mcp package not installed. Run: pip install 'mcp[cli]>=1.0'",
+        file=sys.stderr,
+    )
+    sys.exit(2)
+
+logging.basicConfig(level=logging.INFO, stream=sys.stderr,
+                    format="[meshcode-mcp] %(message)s")
+log = logging.getLogger("meshcode-mcp")
+
+
+# ============================================================
+# Server context — agent identity from env vars
+# ============================================================
+
+PROJECT_NAME = os.environ.get("MESHCODE_PROJECT", "")
+AGENT_NAME = os.environ.get("MESHCODE_AGENT", "")
+AGENT_ROLE = os.environ.get("MESHCODE_ROLE", "")
+
+if not PROJECT_NAME or not AGENT_NAME:
+    print(
+        "[meshcode-mcp] ERROR: MESHCODE_PROJECT and MESHCODE_AGENT env vars required",
+        file=sys.stderr,
+    )
+    sys.exit(2)
+
+
+# Resolve project_id once at startup; auto-register the agent
+_PROJECT_ID: Optional[str] = be.get_project_id(PROJECT_NAME)
+if not _PROJECT_ID:
+    print(f"[meshcode-mcp] ERROR: project '{PROJECT_NAME}' not found", file=sys.stderr)
+    sys.exit(2)
+
+_register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MCP-connected agent")
+if isinstance(_register_result, dict) and _register_result.get("error"):
+    print(f"[meshcode-mcp] WARNING: register failed: {_register_result['error']}", file=sys.stderr)
+
+
+# ============================================================
+# Realtime listener (created in lifespan)
+# ============================================================
+
+_REALTIME: Optional[RealtimeListener] = None
+
+
+async def _on_new_message(msg: Dict[str, Any]) -> None:
+    """Best-effort: try to push an MCP resource-updated notification.
+
+    If the underlying session supports send_resource_updated_notification,
+    use it. If not (older MCP versions or unsupported), the message is
+    still queued and meshcode_check / next-tool-call will surface it.
+    """
+    try:
+        srv = mcp._mcp_server  # FastMCP exposes the lowlevel server here
+        ctx = getattr(srv, "request_context", None)
+        if ctx and getattr(ctx, "session", None):
+            from pydantic import AnyUrl
+            await ctx.session.send_resource_updated(AnyUrl("meshcode://inbox"))
+            log.info(f"sent MCP resource_updated notification for msg from {msg.get('from')}")
+    except Exception as e:
+        log.debug(f"send_resource_updated unavailable: {e}")
+
+
+@asynccontextmanager
+async def lifespan(_app):
+    """Start the Realtime listener when the MCP server boots; stop on shutdown."""
+    global _REALTIME
+    _REALTIME = RealtimeListener(
+        supabase_url=be.SUPABASE_URL,
+        supabase_key=be.SUPABASE_KEY,
+        project_id=_PROJECT_ID,
+        agent_name=AGENT_NAME,
+        notify_callback=_on_new_message,
+    )
+    await _REALTIME.start()
+    log.info(f"lifespan started — Realtime listener active for {AGENT_NAME}")
+    try:
+        yield {"realtime": _REALTIME}
+    finally:
+        log.info("lifespan shutdown — stopping Realtime listener")
+        await _REALTIME.stop()
+
+
+# ============================================================
+# FastMCP server
+# ============================================================
+
+mcp = FastMCP(name=f"meshcode-{PROJECT_NAME}-{AGENT_NAME}", lifespan=lifespan)
+
+
+# ----------------- TOOLS -----------------
+
+@mcp.tool()
+def meshcode_send(to: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Send a message to another agent in the meshwork.
+
+    Args:
+        to: Name of the recipient agent.
+        payload: Structured message payload (use protocol keys: need/done/fyi/blocked).
+    """
+    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg")
+
+
+@mcp.tool()
+def meshcode_broadcast(payload: Dict[str, Any]) -> Dict[str, Any]:
+    """Send a message to ALL agents in the meshwork (except yourself).
+
+    Args:
+        payload: Structured message payload.
+    """
+    agents = be.get_board(_PROJECT_ID)
+    sent = 0
+    for a in agents:
+        if a["name"] != AGENT_NAME:
+            be.send_message(_PROJECT_ID, AGENT_NAME, a["name"], payload, msg_type="broadcast")
+            sent += 1
+    return {"broadcast": True, "agents_notified": sent}
+
+
+@mcp.tool()
+def meshcode_read() -> Dict[str, Any]:
+    """Read all pending (unread) messages for this agent. Marks them as read and ACKs senders."""
+    messages = be.read_inbox(_PROJECT_ID, AGENT_NAME)
+    return {
+        "count": len(messages),
+        "messages": [
+            {
+                "from": m["from_agent"],
+                "type": m.get("type", "msg"),
+                "ts": m.get("created_at"),
+                "payload": m.get("payload", {}),
+            }
+            for m in messages
+        ],
+    }
+
+
+@mcp.tool()
+def meshcode_check() -> Dict[str, Any]:
+    """Quick poll: returns pending message count + any messages buffered by the
+    Realtime listener since the last check.
+
+    Use this to check if there's anything new without marking messages as read.
+    Useful as the first call in a tool loop or after a long thinking phase.
+    """
+    pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
+    realtime_buffered = _REALTIME.drain() if _REALTIME else []
+    return {
+        "pending": pending,
+        "agent": AGENT_NAME,
+        "project": PROJECT_NAME,
+        "realtime_connected": _REALTIME.is_connected if _REALTIME else False,
+        "buffered": realtime_buffered,
+    }
+
+
+@mcp.tool()
+def meshcode_status() -> Dict[str, Any]:
+    """Get the meshwork status board: all agents with their status, role, and current task."""
+    agents = be.get_board(_PROJECT_ID)
+    return {
+        "project": PROJECT_NAME,
+        "agents": [
+            {
+                "name": a["name"],
+                "role": a.get("role", ""),
+                "status": a.get("status", "?"),
+                "task": a.get("task", ""),
+                "last_heartbeat": a.get("last_heartbeat"),
+            }
+            for a in agents
+        ],
+    }
+
+
+@mcp.tool()
+def meshcode_register(role: str = "") -> Dict[str, Any]:
+    """Re-register this agent in the meshwork. Use if you got disconnected or
+    want to update your role description.
+    """
+    return be.register_agent(PROJECT_NAME, AGENT_NAME, role or AGENT_ROLE)
+
+
+@mcp.tool()
+def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
+    """Update your status in the board.
+
+    Args:
+        status: One of: working, idle, standby, blocked, done, online.
+        task: Optional human-readable task description.
+    """
+    return be.set_status(_PROJECT_ID, AGENT_NAME, status, task)
+
+
+# ----------------- RESOURCES -----------------
+
+@mcp.resource("meshcode://inbox")
+def inbox_resource() -> str:
+    """Current pending messages for this agent. Read-only — does NOT mark as read."""
+    pending = be.sb_select(
+        "mc_messages",
+        f"project_id=eq.{_PROJECT_ID}&to_agent=eq.{AGENT_NAME}&read=eq.false",
+        order="created_at.asc",
+    )
+    return json.dumps({
+        "count": len(pending),
+        "messages": [
+            {
+                "from": m["from_agent"],
+                "type": m.get("type", "msg"),
+                "ts": m.get("created_at"),
+                "payload": m.get("payload", {}),
+            }
+            for m in pending
+        ],
+    }, indent=2)
+
+
+@mcp.resource("meshcode://board")
+def board_resource() -> str:
+    """Snapshot of the meshwork board (all agents and their status)."""
+    agents = be.get_board(_PROJECT_ID)
+    return json.dumps({
+        "project": PROJECT_NAME,
+        "agents": agents,
+    }, indent=2, default=str)
+
+
+@mcp.resource("meshcode://history")
+def history_resource() -> str:
+    """Recent message history for this meshwork (last 20 non-ack messages)."""
+    history = be.get_history(_PROJECT_ID, limit=20)
+    return json.dumps({
+        "project": PROJECT_NAME,
+        "history": history,
+    }, indent=2, default=str)
+
+
+# ============================================================
+# Entry point
+# ============================================================
+
+def run_server():
+    """Start the MCP server on stdio (default for Claude Code)."""
+    print(
+        f"[meshcode-mcp] Starting server for {AGENT_NAME}@{PROJECT_NAME}",
+        file=sys.stderr,
+    )
+    mcp.run()

meshcode-1.1.0/meshcode/meshcode_mcp/test_backend.py

@@ -0,0 +1,86 @@
+"""Tests for meshcode_mcp backend helpers (stdlib only — no pytest)."""
+import json
+import os
+import sys
+import time
+import unittest
+
+# Use service role key for testing
+os.environ.setdefault("SUPABASE_URL", "https://wwgzzmydrwrjgaebspdo.supabase.co")
+
+# Test against an isolated project
+TEST_PROJECT = f"mcp-test-{int(time.time())}"
+TEST_AGENT_A = "test-agent-a"
+TEST_AGENT_B = "test-agent-b"
+
+from . import backend as be  # noqa: E402
+
+
+class BackendTests(unittest.TestCase):
+    project_id = None
+
+    @classmethod
+    def setUpClass(cls):
+        cls.project_id = be.get_project_id(TEST_PROJECT)
+        assert cls.project_id, "Failed to create test project"
+
+    @classmethod
+    def tearDownClass(cls):
+        # Cleanup: delete the test project (cascades to agents + messages)
+        from urllib.parse import quote
+        be._request("DELETE", f"mc_projects?id=eq.{cls.project_id}")
+
+    def test_01_register_agent_a(self):
+        result = be.register_agent(TEST_PROJECT, TEST_AGENT_A, "Test agent A")
+        self.assertTrue(result.get("registered"), f"Register failed: {result}")
+        self.assertEqual(result.get("agent_name"), TEST_AGENT_A)
+
+    def test_02_register_agent_b(self):
+        result = be.register_agent(TEST_PROJECT, TEST_AGENT_B, "Test agent B")
+        self.assertTrue(result.get("registered"))
+
+    def test_03_send_message(self):
+        result = be.send_message(
+            self.project_id, TEST_AGENT_A, TEST_AGENT_B,
+            {"need": "test message", "priority": "normal"},
+        )
+        self.assertTrue(result.get("sent"))
+        self.assertIsNotNone(result.get("msg_id"))
+
+    def test_04_count_pending(self):
+        pending = be.count_pending(self.project_id, TEST_AGENT_B)
+        self.assertGreaterEqual(pending, 1, "Expected at least 1 pending message")
+
+    def test_05_read_inbox(self):
+        messages = be.read_inbox(self.project_id, TEST_AGENT_B)
+        self.assertGreaterEqual(len(messages), 1)
+        msg = messages[0]
+        self.assertEqual(msg["from_agent"], TEST_AGENT_A)
+        self.assertEqual(msg["payload"]["need"], "test message")
+
+    def test_06_inbox_empty_after_read(self):
+        # After read, pending should be 0 (the auto-ACK goes back to A, not B)
+        pending = be.count_pending(self.project_id, TEST_AGENT_B)
+        self.assertEqual(pending, 0)
+
+    def test_07_get_board(self):
+        agents = be.get_board(self.project_id)
+        names = [a["name"] for a in agents]
+        self.assertIn(TEST_AGENT_A, names)
+        self.assertIn(TEST_AGENT_B, names)
+
+    def test_08_set_status(self):
+        result = be.set_status(self.project_id, TEST_AGENT_A, "working", "running tests")
+        self.assertTrue(result.get("ok"), f"set_status failed: {result}")
+
+    def test_09_heartbeat(self):
+        result = be.heartbeat(self.project_id, TEST_AGENT_A)
+        self.assertEqual(result.get("status"), "alive")
+
+    def test_10_get_history(self):
+        history = be.get_history(self.project_id, limit=10)
+        self.assertGreaterEqual(len(history), 1)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

meshcode-1.1.0/meshcode/meshcode_mcp/test_realtime.py

@@ -0,0 +1,95 @@
+"""Tests for the Realtime listener — verifies WebSocket connect, subscribe,
+INSERT event handling, and queue draining.
+"""
+import asyncio
+import os
+import time
+import unittest
+
+from . import backend as be
+from .realtime import RealtimeListener, WEBSOCKETS_AVAILABLE
+
+TEST_PROJECT = f"mcp-rt-test-{int(time.time())}"
+TEST_AGENT = "rt-listener"
+SENDER = "rt-sender"
+
+
+@unittest.skipUnless(WEBSOCKETS_AVAILABLE, "websockets package not installed")
+class RealtimeTests(unittest.TestCase):
+    project_id = None
+
+    @classmethod
+    def setUpClass(cls):
+        cls.project_id = be.get_project_id(TEST_PROJECT)
+        be.register_agent(TEST_PROJECT, TEST_AGENT, "Realtime test target")
+        be.register_agent(TEST_PROJECT, SENDER, "Realtime test sender")
+
+    @classmethod
+    def tearDownClass(cls):
+        be._request("DELETE", f"mc_projects?id=eq.{cls.project_id}")
+
+    def test_listener_connects_and_receives(self):
+        """Connect listener, send message via REST, verify it lands in the queue."""
+        async def run():
+            received = []
+
+            async def callback(msg):
+                received.append(msg)
+
+            listener = RealtimeListener(
+                supabase_url=be.SUPABASE_URL,
+                supabase_key=be.SUPABASE_KEY,
+                project_id=self.project_id,
+                agent_name=TEST_AGENT,
+                notify_callback=callback,
+            )
+            await listener.start()
+
+            # Wait for the WebSocket connection to be established
+            for _ in range(20):
+                if listener.is_connected:
+                    break
+                await asyncio.sleep(0.5)
+            self.assertTrue(listener.is_connected, "Listener failed to connect")
+
+            # Give Phoenix a moment to process the join + subscribe
+            await asyncio.sleep(2)
+
+            # Send a message via REST (simulates another agent)
+            be.send_message(self.project_id, SENDER, TEST_AGENT, {"need": "rt-test"})
+
+            # Wait up to 10s for the message to arrive via Realtime
+            for _ in range(20):
+                if listener.queue:
+                    break
+                await asyncio.sleep(0.5)
+
+            await listener.stop()
+
+            # Verify it landed in the queue
+            self.assertGreater(len(listener.queue) + len(received), 0,
+                               "Listener did not receive any messages")
+            if listener.queue:
+                msg = listener.queue[0]
+                self.assertEqual(msg.get("from"), SENDER)
+                self.assertEqual(msg.get("payload", {}).get("need"), "rt-test")
+
+        asyncio.run(run())
+
+    def test_drain_clears_queue(self):
+        """drain() returns and clears the queue."""
+        listener = RealtimeListener(
+            supabase_url=be.SUPABASE_URL,
+            supabase_key=be.SUPABASE_KEY,
+            project_id=self.project_id,
+            agent_name=TEST_AGENT,
+        )
+        listener.queue.append({"from": "x", "payload": {}})
+        listener.queue.append({"from": "y", "payload": {}})
+        drained = listener.drain()
+        self.assertEqual(len(drained), 2)
+        self.assertEqual(len(listener.queue), 0)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{meshcode-1.0.0 → meshcode-1.1.0}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 1.0.0
+Version: 1.1.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,6 +18,8 @@ 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
 
 # MeshCode
 

meshcode-1.1.0/meshcode.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+meshcode/__init__.py
+meshcode/cli.py
+meshcode/comms_v4.py
+meshcode.egg-info/PKG-INFO
+meshcode.egg-info/SOURCES.txt
+meshcode.egg-info/dependency_links.txt
+meshcode.egg-info/entry_points.txt
+meshcode.egg-info/requires.txt
+meshcode.egg-info/top_level.txt
+meshcode/meshcode_mcp/__init__.py
+meshcode/meshcode_mcp/__main__.py
+meshcode/meshcode_mcp/backend.py
+meshcode/meshcode_mcp/realtime.py
+meshcode/meshcode_mcp/server.py
+meshcode/meshcode_mcp/test_backend.py
+meshcode/meshcode_mcp/test_realtime.py

meshcode-1.1.0/meshcode.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+meshcode = meshcode.cli:main
+meshcode-mcp = meshcode.meshcode_mcp.__main__:main

meshcode-1.1.0/meshcode.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp[cli]>=1.0.0
+websockets>=12.0

{meshcode-1.0.0 → meshcode-1.1.0}/pyproject.toml

@@ -4,13 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "1.0.0"
+version = "1.1.0"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}
 requires-python = ">=3.9"
 authors = [{name = "MeshCode", email = "hello@meshcode.io"}]
 keywords = ["ai", "agents", "communication", "realtime", "supabase", "claude", "codex"]
+dependencies = [
+    "mcp[cli]>=1.0.0",
+    "websockets>=12.0",
+]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
@@ -25,6 +29,7 @@ classifiers = [
 
 [project.scripts]
 meshcode = "meshcode.cli:main"
+meshcode-mcp = "meshcode.meshcode_mcp.__main__:main"
 
 [project.urls]
 Homepage = "https://meshcode.io"

meshcode-1.0.0/meshcode.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-README.md
-pyproject.toml
-meshcode/__init__.py
-meshcode/cli.py
-meshcode/comms_v4.py
-meshcode.egg-info/PKG-INFO
-meshcode.egg-info/SOURCES.txt
-meshcode.egg-info/dependency_links.txt
-meshcode.egg-info/entry_points.txt
-meshcode.egg-info/top_level.txt

meshcode-1.0.0/meshcode.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-meshcode = meshcode.cli:main