meshcode 2.10.45__tar.gz → 2.10.47__tar.gz

{meshcode-2.10.45 → meshcode-2.10.47}/PKG-INFO

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

{meshcode-2.10.45 → meshcode-2.10.47}/meshcode/__init__.py

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

{meshcode-2.10.45 → meshcode-2.10.47}/meshcode/meshcode_mcp/server.py

@@ -635,6 +635,12 @@ def with_working_status(func):
                 _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
                 return await func(*args, **kwargs)
+            except asyncio.CancelledError:
+                # ESC in Claude Code cancels the in-flight task. Catch here
+                # to prevent cascade through FastMCP into the event loop.
+                # Return an error dict instead of propagating BaseException.
+                log.debug(f"[meshcode] tool {name} cancelled by client (ESC)")
+                return {"error": "cancelled_by_client", "tool": name}
             except Exception as e:
                 if not skip:
                     _auto_learn_error(name, e, list(kwargs.keys()))
@@ -1665,7 +1671,11 @@ async def meshcode_call(to: str, function: str, args: Any = None, timeout_second
     poll_interval = 1.0
     elapsed = 0.0
     while elapsed < timeout_seconds:
-        await _asyncio.sleep(poll_interval)
+        try:
+            await _asyncio.sleep(poll_interval)
+        except _asyncio.CancelledError:
+            log.debug("[meshcode] meshcode_call poll cancelled by ESC")
+            return {"error": "cancelled_by_client", "call_id": call_id, "ok": False}
         elapsed += poll_interval
 
         # Check Realtime buffer first
@@ -1898,7 +1908,13 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
         # Keep polling until something actionable arrives.
         # The agent (LLM) is NOT called between iterations — zero token cost.
         while True:
-            result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
+            try:
+                result = await _meshcode_wait_inner(actual_timeout=capped_timeout, include_acks=include_acks)
+            except asyncio.CancelledError:
+                # Safety net: if CancelledError escapes _meshcode_wait_inner
+                # despite the inner shield, catch it here to prevent cascade.
+                log.debug("[meshcode] meshcode_wait outer loop caught CancelledError")
+                result = {"timed_out": True, "reason": "cancelled_by_client"}
 
             if result.get("got_message"):
                 # Real message arrived — return to agent for processing
@@ -2041,7 +2057,20 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
 
     if _rt_live:
         # 2a) Real async wait — zero CPU, zero Supabase calls.
-        woke = await _REALTIME.wait_for_message(timeout=float(actual_timeout))
+        # Shield from CancelledError: when Claude Code presses ESC, it cancels
+        # the in-flight asyncio task. CancelledError is a BaseException that
+        # bypasses most try/except, cascades through FastMCP's tool handler,
+        # and unwinds the event loop — killing the MCP server. By shielding
+        # the await and catching CancelledError, we return a clean timeout
+        # result instead. The mcp.run() retry loop restarts the event loop
+        # without the lifespan cascade.
+        try:
+            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__}")
+            return {"timed_out": True, "reason": "cancelled_by_client"}
         if woke:
             buffered = _REALTIME.drain()
             if buffered:
@@ -2054,7 +2083,11 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         _poll_interval = 5
         _elapsed = 0
         while _elapsed < actual_timeout:
-            await asyncio.sleep(min(_poll_interval, actual_timeout - _elapsed))
+            try:
+                await asyncio.sleep(min(_poll_interval, actual_timeout - _elapsed))
+            except asyncio.CancelledError:
+                log.debug("[meshcode] DB poll sleep cancelled by ESC")
+                return {"timed_out": True, "reason": "cancelled_by_client"}
             _elapsed += _poll_interval
             try:
                 api_key = _get_api_key()
@@ -2456,6 +2489,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.45 → meshcode-2.10.47}/meshcode/run_agent.py

@@ -393,8 +393,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,
@@ -434,8 +434,20 @@ def _resolve_pinned_claude(editor_cmd: str) -> str:
             print(f"[meshcode] Global admin pin: Claude Code v{pinned}", file=sys.stderr)
     if not pinned:
         pinned = load_prefs().get("claude_version", "")
+
+    # "latest" or "none" means skip pinning — use whatever is installed
+    if pinned and pinned.lower() in ("latest", "none", "skip"):
+        print(f"[meshcode] Version pin disabled ({pinned}) — using installed version", file=sys.stderr)
+        return editor_cmd
+
     if not pinned:
-        return editor_cmd  # No pin — use installed version
+        # Default pin: v2.1.104 is the last Claude Code version where ESC
+        # doesn't kill the MCP server. Newer versions send CancelledError
+        # that cascades through the event loop. This default is overridden
+        # by any of the 3 pin sources above (set to "latest" to disable).
+        # Remove this default once Anthropic fixes the ESC bug upstream.
+        pinned = "2.1.104"
+        print(f"[meshcode] Default ESC-safe pin: Claude Code v{pinned}", file=sys.stderr)
 
     current = _get_claude_version(editor_cmd)
     if current == pinned:
@@ -707,7 +719,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)
@@ -803,7 +815,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.45 → meshcode-2.10.47}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.45 → meshcode-2.10.47}/pyproject.toml

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