meshcode 2.10.22__tar.gz → 2.10.26__tar.gz

{meshcode-2.10.22 → meshcode-2.10.26}/PKG-INFO

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

{meshcode-2.10.22 → meshcode-2.10.26}/meshcode/__init__.py

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

{meshcode-2.10.22 → meshcode-2.10.26}/meshcode/meshcode_mcp/server.py

@@ -156,9 +156,11 @@ def _try_auto_wake(from_agent: str, preview: str) -> None:
     # Sanitize inputs: strip everything except alphanumeric, spaces, basic punctuation
     safe_agent = re.sub(r'[^a-zA-Z0-9_\- ]', '', from_agent)[:50]
     safe_preview = re.sub(r'[^a-zA-Z0-9_\-.,!? ]', '', preview)[:60]
-    # Color-coded nudge with sender's agent color
-    ac = _agent_color(safe_agent)
-    nudge = f"{ac}{_ANSI_BOLD}[mesh]{_ANSI_RESET} {ac}{safe_agent}{_ANSI_RESET} {_ANSI_DIM}>{_ANSI_RESET} {safe_preview} {_ANSI_DIM}— meshcode_check(){_ANSI_RESET}"
+    # Plain-text nudge. ANSI colors were stripped 2026-04-16 because terminals
+    # that don't interpret escape sequences (TypeScript runners, some VSCode
+    # configurations, pipelines, tmux without termguicolors) render the raw
+    # bytes — "[91m[1m[mesh][0m …" — which is worse UX than no color at all.
+    nudge = f"[mesh] {safe_agent} > {safe_preview} — meshcode_check()"
     system = platform.system()
     try:
         if system == "Darwin":
@@ -799,12 +801,11 @@ def _log_crash_to_db(reason: str = "unknown", error_detail: str = "") -> None:
 
 
 
-# NOTE: Do NOT install signal handlers (SIGTERM, SIGINT) or atexit hooks here.
-# FastMCP/anyio manages its own event loop and signal handling. Custom signal
-# handlers override Python's default KeyboardInterrupt, preventing anyio from
-# cancelling tasks cleanly. Network calls inside signal/atexit handlers can
-# deadlock or corrupt the event loop. The lease will be released by the
+# NOTE: Do NOT install custom SIGTERM handlers or atexit hooks here — network
+# calls inside them can deadlock the event loop. The lease is released by the
 # lifespan shutdown handler instead.
+#
+# SIGINT handling is special — see run_server() for why we set SIG_IGN there.
 
 
 # ============================================================
@@ -1345,14 +1346,12 @@ def meshcode_broadcast(payload: Any) -> Dict[str, Any]:
     elif not isinstance(payload, dict):
         return {"error": "payload must be a string or object", "got_type": type(payload).__name__}
 
-    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",
-                               api_key=_get_api_key())
-            sent += 1
-    return {"broadcast": True, "agents_notified": sent}
+    # Canonical broadcast: one row with to_agent='*'. Every agent's inbox
+    # query includes `to_agent = '*'` so all recipients see it, without the
+    # N-row fanout that caused duplicate-render bugs.
+    be.send_message(_PROJECT_ID, AGENT_NAME, "*", payload, msg_type="broadcast",
+                    api_key=_get_api_key())
+    return {"broadcast": True, "to": "*"}
 
 
 @mcp.tool()
@@ -1488,7 +1487,7 @@ def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
 
 @mcp.tool()
 @with_working_status
-async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False) -> Dict[str, Any]:
+async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -> Dict[str, Any]:
     """Block until a mesh message arrives or a task needs attention.
 
     INTERNAL LOOP: This function loops internally and only returns when
@@ -1498,7 +1497,10 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
     accidentally using ScheduleWakeup or exiting the loop.
 
     Args:
-        timeout_seconds: Max wait time per poll cycle (default 120, hard cap 120).
+        timeout_seconds: Max wait time per poll cycle (default 20, hard cap 20).
+            Short cap keeps the outer tool call bounded so the user can press
+            ESC in Claude Code without killing the MCP server — the inner
+            loop continues polling across cycles at zero token cost.
     """
     global _IN_WAIT, _CONSECUTIVE_IDLE_SECONDS, _LAST_SEEN_TS
 
@@ -1541,7 +1543,7 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
 
     _IN_WAIT = True
     _set_state("waiting", "listening for messages")
-    capped_timeout = min(max(1, int(timeout_seconds)), 120)
+    capped_timeout = min(max(1, int(timeout_seconds)), 20)
     try:
         # ── INTERNAL LOOP ──────────────────────────────────────────
         # Keep polling until something actionable arrives.
@@ -1944,17 +1946,44 @@ def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
 
 @mcp.tool()
 @with_working_status
-def meshcode_tasks(status_filter: Optional[str] = None) -> Dict[str, Any]:
+def meshcode_tasks(status_filter: Optional[str] = None, verbose: bool = False) -> Dict[str, Any]:
     """List tasks. Filter by status to find work.
 
     Args:
         status_filter: 'open' / 'in_progress' / 'done' / etc. None = all.
+        verbose: When False (default), descriptions are truncated to 200 chars
+            and null/empty fields are dropped to save tokens. Pass True for
+            the full payload.
 
     Returns: {"ok": true, "tasks": [...]}
     """
     api_key = _get_api_key()
     include_done = status_filter == "done"
-    return be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=status_filter, include_done=include_done)
+    result = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=status_filter, include_done=include_done)
+    if verbose or not isinstance(result, dict) or not result.get("ok"):
+        return result
+    compact: List[Dict[str, Any]] = []
+    for t in result.get("tasks", []):
+        desc = t.get("description") or ""
+        row: Dict[str, Any] = {
+            "id": t.get("id"),
+            "title": t.get("title"),
+            "status": t.get("status"),
+            "priority": t.get("priority"),
+            "assignee": t.get("assignee"),
+        }
+        if t.get("claimed_by"):
+            row["claimed_by"] = t["claimed_by"]
+        if t.get("parent_task_id"):
+            row["parent_task_id"] = t["parent_task_id"]
+        if desc:
+            if len(desc) > 200:
+                row["description"] = desc[:200]
+                row["_description_truncated"] = True
+            else:
+                row["description"] = desc
+        compact.append(row)
+    return {"ok": True, "tasks": compact}
 
 
 @mcp.tool()
@@ -1967,9 +1996,32 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
 
 @mcp.tool()
 @with_working_status
-def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
-    """Complete a claimed task with summary. Auto-remembers the task summary."""
+def meshcode_task_complete(task_id: str, summary: str = "", force: bool = False) -> Dict[str, Any]:
+    """Complete a claimed task with summary. Auto-remembers the task summary.
+
+    Refuses if the task has open subtasks, unless force=True is passed with a
+    reason in `summary`. This prevents closing a parent while lanes are still
+    in flight.
+    """
     api_key = _get_api_key()
+    if not force:
+        try:
+            listing = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=None, include_done=False)
+            if isinstance(listing, dict) and listing.get("ok"):
+                open_subs = [
+                    {"id": t["id"][:8], "title": t["title"][:80], "status": t["status"]}
+                    for t in listing.get("tasks", [])
+                    if t.get("parent_task_id") == task_id
+                    and t.get("status") in ("open", "in_progress", "in_review")
+                ]
+                if open_subs:
+                    return {
+                        "refused": True,
+                        "reason": f"Cannot complete — {len(open_subs)} open subtasks. Finish them or pass force=True with a reason in summary.",
+                        "open_subtasks": open_subs,
+                    }
+        except Exception:
+            pass  # Best-effort check; don't block on listing failure.
     result = be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
     # Auto-remember task completion for future context
     if isinstance(result, dict) and result.get("ok") and summary:
@@ -2020,6 +2072,62 @@ def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_task_search(title_contains: Optional[str] = None,
+                         status: Optional[str] = None,
+                         assignee: Optional[str] = None,
+                         limit: int = 20) -> Dict[str, Any]:
+    """Search tasks by title/status/assignee. Use before task_create to dedupe."""
+    return be.sb_rpc("mc_search_tasks", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+        "p_caller_agent": AGENT_NAME,
+        "p_title_contains": title_contains,
+        "p_status": status,
+        "p_assignee": assignee,
+        "p_limit": limit,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_agent_list() -> Dict[str, Any]:
+    """Roster of agents in this meshwork with status + last_heartbeat."""
+    return be.sb_rpc("mc_list_agents", {
+        "p_api_key": _get_api_key(),
+        "p_project_id": _PROJECT_ID,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_cancel(task_id: str, reason: str = "") -> Dict[str, Any]:
+    """Cancel a task. Creator or commander only. Works on open/in_progress/in_review."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_task_cancel", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_task_id": task_id,
+        "p_cancelling_agent": AGENT_NAME,
+        "p_reason": reason,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_task_reassign(task_id: str, new_assignee: str) -> Dict[str, Any]:
+    """Reassign an unclaimed open task to a different agent. Creator or commander only."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_task_reassign", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_task_id": task_id,
+        "p_reassigning_agent": AGENT_NAME,
+        "p_new_assignee": new_assignee,
+    })
+
+
 # ----------------- PROACTIVE HEALTH SCAN -----------------
 
 @mcp.tool()
@@ -2149,6 +2257,47 @@ def meshcode_links() -> Dict[str, Any]:
     })
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_link_invite(source_project: str, note: str = "") -> Dict[str, Any]:
+    """Generate a one-time invite token for another meshwork to link in.
+
+    Returns {token, expires_at}. Share the token out-of-band. The recipient
+    calls meshcode_link_redeem(token, their_meshwork) to auto-link
+    (no separate accept step).
+    """
+    return be.sb_rpc("mc_create_link_invite", {
+        "p_source_project": source_project,
+        "p_note": note,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_redeem(token: str, target_meshwork: str) -> Dict[str, Any]:
+    """Redeem an invite token — creates an ACTIVE mesh link in one step."""
+    return be.sb_rpc("mc_redeem_link_invite", {
+        "p_token": token,
+        "p_target_project": target_meshwork,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_invites(source_project: Optional[str] = None) -> Dict[str, Any]:
+    """List link invites this user has created (active/redeemed/expired/revoked)."""
+    return be.sb_rpc("mc_list_my_link_invites", {
+        "p_source_project": source_project,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_link_invite_revoke(token: str) -> Dict[str, Any]:
+    """Revoke an outstanding (unredeemed) invite token."""
+    return be.sb_rpc("mc_revoke_link_invite", {"p_token": token})
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:
@@ -2647,14 +2796,7 @@ def _auto_update() -> None:
 
 
 def run_server():
-    """Start the MCP server on stdio (default for Claude Code).
-
-    IMPORTANT: Do NOT wrap mcp.run() with try/except, signal handlers, or
-    atexit hooks. FastMCP/anyio manages its own event loop lifecycle and
-    signal handling. Any interference (custom SIGINT handler, atexit network
-    calls, catching KeyboardInterrupt) corrupts the event loop and causes
-    the MCP server to crash when Claude Code cancels a tool call (ESC).
-    """
+    """Start the MCP server on stdio (default for Claude Code)."""
     _auto_update()
     print(
         f"[meshcode-mcp] Starting server for {AGENT_NAME}@{PROJECT_NAME}",
@@ -2664,4 +2806,25 @@ def run_server():
     # sys.stdout was redirected to stderr at module load to prevent
     # accidental stdout writes from corrupting the MCP protocol.
     sys.stdout = _REAL_STDOUT
+
+    # Claude Code cancels tool calls on ESC via TWO parallel channels:
+    #   (1) JSON-RPC `notifications/cancelled` over stdin (the correct path)
+    #   (2) SIGINT to the stdio subprocess (a destructive side-channel)
+    # anyio's asyncio backend installs its own SIGINT handler inside
+    # Runner.run() only if the current handler is `default_int_handler`
+    # (see anyio/_backends/_asyncio.py ~L197-210). That handler cancels the
+    # *main task* — which for a stdio server IS the whole server run —
+    # tearing the event loop down and killing the subprocess. Setting
+    # SIG_IGN before mcp.run() trips anyio's guard, so it leaves SIGINT
+    # alone; the kernel drops the signal; only the notifications/cancelled
+    # path remains, which cancels just the in-flight tool call as intended.
+    # SIGTERM is deliberately untouched so Claude Code can still force-shut
+    # the server on session end. stdin EOF remains the normal exit path.
+    import signal
+    try:
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+    except (ValueError, OSError):
+        # Non-main thread or platform that can't install handlers — harmless.
+        pass
+
     mcp.run()

{meshcode-2.10.22 → meshcode-2.10.26}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.22 → meshcode-2.10.26}/pyproject.toml

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