meshcode 1.5.0__tar.gz → 1.6.0__tar.gz

meshcode-1.6.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: meshcode
+Version: 1.6.0
+Summary: Real-time communication between AI agents — Supabase-backed CLI
+Author-email: MeshCode <hello@meshcode.io>
+License: MIT
+Project-URL: Homepage, https://meshcode.io
+Project-URL: Repository, https://github.com/rf2f7f7sg4-dev/meshcode
+Keywords: ai,agents,communication,realtime,supabase,claude,codex
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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
+Requires-Dist: realtime>=2.0.0
+Requires-Dist: keyring>=24.0
+
+# MeshCode
+
+**Persistent AI coworkers.** MeshCode is the infrastructure that lets multiple AI agents (Claude Code, Cursor, Cline, Claude Desktop) coordinate as a real-time team — each agent is a real editor window on someone's machine, and MeshCode is the mesh between them.
+
+- Docs: https://meshcode.io/docs
+- Dashboard: https://meshcode.io/dashboard
+- GitHub: https://github.com/meshcode/meshcode
+
+---
+
+## Install
+
+```bash
+pip install meshcode
+```
+
+Requires Python 3.9+. Works on macOS, Linux, Windows.
+
+---
+
+## Quickstart (the 5-command happy path)
+
+```bash
+# 1. Sign up at https://meshcode.io and copy the mc_xxx key shown once on onboarding
+# 2. Store it in your OS keychain (once, forever)
+meshcode login mc_xxxxxxxxxxxxxxxxxxxxxxxx
+
+# 3. Create a workspace for your first agent
+meshcode setup my-project commander
+
+# 4. Launch the agent (this opens your editor with the MCP server wired up)
+meshcode run commander
+
+# 5. Watch it come online in the dashboard at https://meshcode.io/dashboard
+```
+
+That's it. Tell the agent what to do inside the editor — it will coordinate with any other MeshCode agents it can see on the mesh.
+
+---
+
+## How it works
+
+```
+   +-------------------+       +-------------------+       +-------------------+
+   |  Claude Code      |       |  Cursor           |       |  Cline            |
+   |  "commander"      |       |  "backend"        |       |  "frontend"       |
+   |  (your machine)   |       |  (your machine)   |       |  (friend's mac)   |
+   +---------+---------+       +---------+---------+       +---------+---------+
+             |                           |                           |
+             |   MCP (meshcode_wait,     |                           |
+             |    meshcode_done, ...)    |                           |
+             v                           v                           v
+        +-------------------------------------------------------------+
+        |                    MeshCode mesh (meshcode.io)              |
+        |    long-poll bus, status board, scoped keys, dashboard      |
+        +-------------------------------------------------------------+
+```
+
+Each agent is a *real* Claude/Cursor/Cline window. MeshCode gives them shared memory, a status board, long-poll message passing (`meshcode_wait` / `meshcode_done`), and a web dashboard.
+
+---
+
+## Solo workflow — run a team on your own machine
+
+```bash
+meshcode login mc_xxx                       # once, forever
+
+meshcode setup my-project commander         # ~/meshcode/my-project-commander/
+meshcode setup my-project backend
+meshcode setup my-project frontend
+
+# in three separate terminals:
+meshcode run commander
+meshcode run backend
+meshcode run frontend
+```
+
+Inside any window, tell the agent to coordinate with the others. They self-orchestrate through the mesh loop (`meshcode_wait` blocks until a peer sends a message, `meshcode_done` reports progress).
+
+---
+
+## Team workflow — invite a friend
+
+**As the owner:**
+
+```bash
+meshcode invite my-project designer --role "UI designer" --days 7
+# -> https://meshcode.io/join/mc_inv_ab12cd34
+```
+
+Share the URL. That's all that leaves your machine — no API keys, no secrets.
+
+**As the friend (no account needed):**
+
+```bash
+pip install meshcode
+meshcode join mc_inv_ab12cd34 --display-name "Alice"
+meshcode run designer
+```
+
+`meshcode join` redeems the invite and mints a **scoped key** — good only for that one agent slot, in that one meshwork, until the owner revokes it or it expires.
+
+**Owner management:**
+
+```bash
+meshcode invites my-project              # list outstanding + redeemed invites
+meshcode members my-project              # list current members
+meshcode revoke-invite <invite-id>       # cancel an outstanding invite
+meshcode revoke-member my-project <user> # kick a member instantly
+```
+
+---
+
+## Command reference
+
+| Command | Example | Description |
+|---|---|---|
+| `meshcode login <key>` | `meshcode login mc_abc123` | Store your API key in the OS keychain (once). |
+| `meshcode setup <project> <agent>` | `meshcode setup my-project backend` | Create a workspace and wire up the MCP config for your editor. |
+| `meshcode run <agent>` | `meshcode run backend` | Launch the editor with this agent's MCP server attached. |
+| `meshcode invite <project> <agent>` | `meshcode invite my-project designer --role "UI" --days 7` | Generate a join URL to share. |
+| `meshcode join <invite>` | `meshcode join mc_inv_xxx --display-name "Alice"` | Redeem an invite, mint a scoped key. |
+| `meshcode invites <project>` | `meshcode invites my-project` | List outstanding + redeemed invites. |
+| `meshcode members <project>` | `meshcode members my-project` | List current members. |
+| `meshcode revoke-invite <id>` | `meshcode revoke-invite inv_123` | Cancel an outstanding invite. |
+| `meshcode revoke-member <project> <user>` | `meshcode revoke-member my-project u_42` | Kick a member. |
+| `meshcode board <project>` | `meshcode board my-project` | Terminal view of the status board. |
+| `meshcode status` | `meshcode status` | Show the logged-in account and version. |
+| `meshcode send` (legacy) | `meshcode send my-project a:b '{"need":"..."}'` | Pre-1.5 manual message send (MCP tools are preferred). |
+| `meshcode read` (legacy) | `meshcode read my-project backend` | Pre-1.5 manual read. |
+| `meshcode --version` | `meshcode --version` | Print `meshcode 1.5.1`. |
+| `meshcode help` | `meshcode help` | Top-level help. Per-verb help: `meshcode <verb> --help`. |
+
+---
+
+## Editor support
+
+| Editor | Auto-detected? | Config file written |
+|---|---|---|
+| Claude Code | yes | workspace `.mcp.json` (passed via `--mcp-config`) |
+| Cursor | yes | workspace `.cursor/mcp.json` |
+| Cline | yes | workspace `.vscode/mcp.json` |
+| Claude Desktop | partial | global `~/Library/Application Support/Claude/claude_desktop_config.json` |
+
+Force a specific editor:
+
+```bash
+MESHCODE_EDITOR=cursor meshcode run backend
+```
+
+---
+
+## Security
+
+- **API keys live in your OS keychain** (macOS Keychain, Linux libsecret, Windows Credential Manager). Never written in plaintext to disk since 1.4.1.
+- **Scoped guest keys** for invited friends: 1 key = 1 agent slot in 1 meshwork. They cannot see other meshes, other members' agents, or billing.
+- **Server-side enforcement**: all RPCs are `SECURITY DEFINER` + scope-validated.
+- **Instant revoke** — `revoke-invite` and `revoke-member` take effect on the next request.
+
+---
+
+## Troubleshooting
+
+**1. `No credentials found. Run meshcode login first.`**
+You haven't stored a key yet. Grab your `mc_xxx` from https://meshcode.io/onboarding and run:
+```bash
+meshcode login mc_xxxxxxxxxxxx
+```
+
+**2. `agent already running in another window`**
+MeshCode prevents split-brain — the same agent name can't be live in two editor windows. Close the other window, or use a different agent name.
+
+**3. `scoped api key cannot access this project`**
+You joined a meshwork via an invite, and you're now trying to use a different project. Scoped keys only work for the one mesh they were minted for. Run `meshcode members <correct-project>` to confirm which mesh you belong to.
+
+**4. `meshcode: command not found`**
+Either `pip install` didn't add to your PATH (check `which meshcode` and `python -m site --user-base`), or you have a stale pre-1.0.0 `~/bin/meshcode` shim shadowing the real binary — delete it.
+
+**5. `MCP server failed to start` in the Claude Code `/mcp` panel**
+Run `claude --debug` to see the underlying error. Nine times out of ten it's a stale or missing key — run `meshcode login mc_xxx` again.
+
+**6. PyPI says `Could not find version 1.x.x` immediately after a publish**
+CDN propagation. Wait ~60s and force-fetch directly from the origin:
+```bash
+pip install --no-cache-dir -i https://pypi.org/simple/ meshcode
+```
+
+---
+
+## Links
+
+- Docs: https://meshcode.io/docs
+- Dashboard: https://meshcode.io/dashboard
+- GitHub: https://github.com/meshcode/meshcode
+- Sign up: https://meshcode.io/signup

meshcode-1.6.0/README.md

@@ -0,0 +1,195 @@
+# MeshCode
+
+**Persistent AI coworkers.** MeshCode is the infrastructure that lets multiple AI agents (Claude Code, Cursor, Cline, Claude Desktop) coordinate as a real-time team — each agent is a real editor window on someone's machine, and MeshCode is the mesh between them.
+
+- Docs: https://meshcode.io/docs
+- Dashboard: https://meshcode.io/dashboard
+- GitHub: https://github.com/meshcode/meshcode
+
+---
+
+## Install
+
+```bash
+pip install meshcode
+```
+
+Requires Python 3.9+. Works on macOS, Linux, Windows.
+
+---
+
+## Quickstart (the 5-command happy path)
+
+```bash
+# 1. Sign up at https://meshcode.io and copy the mc_xxx key shown once on onboarding
+# 2. Store it in your OS keychain (once, forever)
+meshcode login mc_xxxxxxxxxxxxxxxxxxxxxxxx
+
+# 3. Create a workspace for your first agent
+meshcode setup my-project commander
+
+# 4. Launch the agent (this opens your editor with the MCP server wired up)
+meshcode run commander
+
+# 5. Watch it come online in the dashboard at https://meshcode.io/dashboard
+```
+
+That's it. Tell the agent what to do inside the editor — it will coordinate with any other MeshCode agents it can see on the mesh.
+
+---
+
+## How it works
+
+```
+   +-------------------+       +-------------------+       +-------------------+
+   |  Claude Code      |       |  Cursor           |       |  Cline            |
+   |  "commander"      |       |  "backend"        |       |  "frontend"       |
+   |  (your machine)   |       |  (your machine)   |       |  (friend's mac)   |
+   +---------+---------+       +---------+---------+       +---------+---------+
+             |                           |                           |
+             |   MCP (meshcode_wait,     |                           |
+             |    meshcode_done, ...)    |                           |
+             v                           v                           v
+        +-------------------------------------------------------------+
+        |                    MeshCode mesh (meshcode.io)              |
+        |    long-poll bus, status board, scoped keys, dashboard      |
+        +-------------------------------------------------------------+
+```
+
+Each agent is a *real* Claude/Cursor/Cline window. MeshCode gives them shared memory, a status board, long-poll message passing (`meshcode_wait` / `meshcode_done`), and a web dashboard.
+
+---
+
+## Solo workflow — run a team on your own machine
+
+```bash
+meshcode login mc_xxx                       # once, forever
+
+meshcode setup my-project commander         # ~/meshcode/my-project-commander/
+meshcode setup my-project backend
+meshcode setup my-project frontend
+
+# in three separate terminals:
+meshcode run commander
+meshcode run backend
+meshcode run frontend
+```
+
+Inside any window, tell the agent to coordinate with the others. They self-orchestrate through the mesh loop (`meshcode_wait` blocks until a peer sends a message, `meshcode_done` reports progress).
+
+---
+
+## Team workflow — invite a friend
+
+**As the owner:**
+
+```bash
+meshcode invite my-project designer --role "UI designer" --days 7
+# -> https://meshcode.io/join/mc_inv_ab12cd34
+```
+
+Share the URL. That's all that leaves your machine — no API keys, no secrets.
+
+**As the friend (no account needed):**
+
+```bash
+pip install meshcode
+meshcode join mc_inv_ab12cd34 --display-name "Alice"
+meshcode run designer
+```
+
+`meshcode join` redeems the invite and mints a **scoped key** — good only for that one agent slot, in that one meshwork, until the owner revokes it or it expires.
+
+**Owner management:**
+
+```bash
+meshcode invites my-project              # list outstanding + redeemed invites
+meshcode members my-project              # list current members
+meshcode revoke-invite <invite-id>       # cancel an outstanding invite
+meshcode revoke-member my-project <user> # kick a member instantly
+```
+
+---
+
+## Command reference
+
+| Command | Example | Description |
+|---|---|---|
+| `meshcode login <key>` | `meshcode login mc_abc123` | Store your API key in the OS keychain (once). |
+| `meshcode setup <project> <agent>` | `meshcode setup my-project backend` | Create a workspace and wire up the MCP config for your editor. |
+| `meshcode run <agent>` | `meshcode run backend` | Launch the editor with this agent's MCP server attached. |
+| `meshcode invite <project> <agent>` | `meshcode invite my-project designer --role "UI" --days 7` | Generate a join URL to share. |
+| `meshcode join <invite>` | `meshcode join mc_inv_xxx --display-name "Alice"` | Redeem an invite, mint a scoped key. |
+| `meshcode invites <project>` | `meshcode invites my-project` | List outstanding + redeemed invites. |
+| `meshcode members <project>` | `meshcode members my-project` | List current members. |
+| `meshcode revoke-invite <id>` | `meshcode revoke-invite inv_123` | Cancel an outstanding invite. |
+| `meshcode revoke-member <project> <user>` | `meshcode revoke-member my-project u_42` | Kick a member. |
+| `meshcode board <project>` | `meshcode board my-project` | Terminal view of the status board. |
+| `meshcode status` | `meshcode status` | Show the logged-in account and version. |
+| `meshcode send` (legacy) | `meshcode send my-project a:b '{"need":"..."}'` | Pre-1.5 manual message send (MCP tools are preferred). |
+| `meshcode read` (legacy) | `meshcode read my-project backend` | Pre-1.5 manual read. |
+| `meshcode --version` | `meshcode --version` | Print `meshcode 1.5.1`. |
+| `meshcode help` | `meshcode help` | Top-level help. Per-verb help: `meshcode <verb> --help`. |
+
+---
+
+## Editor support
+
+| Editor | Auto-detected? | Config file written |
+|---|---|---|
+| Claude Code | yes | workspace `.mcp.json` (passed via `--mcp-config`) |
+| Cursor | yes | workspace `.cursor/mcp.json` |
+| Cline | yes | workspace `.vscode/mcp.json` |
+| Claude Desktop | partial | global `~/Library/Application Support/Claude/claude_desktop_config.json` |
+
+Force a specific editor:
+
+```bash
+MESHCODE_EDITOR=cursor meshcode run backend
+```
+
+---
+
+## Security
+
+- **API keys live in your OS keychain** (macOS Keychain, Linux libsecret, Windows Credential Manager). Never written in plaintext to disk since 1.4.1.
+- **Scoped guest keys** for invited friends: 1 key = 1 agent slot in 1 meshwork. They cannot see other meshes, other members' agents, or billing.
+- **Server-side enforcement**: all RPCs are `SECURITY DEFINER` + scope-validated.
+- **Instant revoke** — `revoke-invite` and `revoke-member` take effect on the next request.
+
+---
+
+## Troubleshooting
+
+**1. `No credentials found. Run meshcode login first.`**
+You haven't stored a key yet. Grab your `mc_xxx` from https://meshcode.io/onboarding and run:
+```bash
+meshcode login mc_xxxxxxxxxxxx
+```
+
+**2. `agent already running in another window`**
+MeshCode prevents split-brain — the same agent name can't be live in two editor windows. Close the other window, or use a different agent name.
+
+**3. `scoped api key cannot access this project`**
+You joined a meshwork via an invite, and you're now trying to use a different project. Scoped keys only work for the one mesh they were minted for. Run `meshcode members <correct-project>` to confirm which mesh you belong to.
+
+**4. `meshcode: command not found`**
+Either `pip install` didn't add to your PATH (check `which meshcode` and `python -m site --user-base`), or you have a stale pre-1.0.0 `~/bin/meshcode` shim shadowing the real binary — delete it.
+
+**5. `MCP server failed to start` in the Claude Code `/mcp` panel**
+Run `claude --debug` to see the underlying error. Nine times out of ten it's a stale or missing key — run `meshcode login mc_xxx` again.
+
+**6. PyPI says `Could not find version 1.x.x` immediately after a publish**
+CDN propagation. Wait ~60s and force-fetch directly from the origin:
+```bash
+pip install --no-cache-dir -i https://pypi.org/simple/ meshcode
+```
+
+---
+
+## Links
+
+- Docs: https://meshcode.io/docs
+- Dashboard: https://meshcode.io/dashboard
+- GitHub: https://github.com/meshcode/meshcode
+- Sign up: https://meshcode.io/signup

{meshcode-1.5.0 → meshcode-1.6.0}/meshcode/__init__.py

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

{meshcode-1.5.0 → meshcode-1.6.0}/meshcode/meshcode_mcp/backend.py

@@ -164,7 +164,7 @@ def register_agent(project: str, name: str, role: str = "") -> Dict:
     }
 
 
-def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any, msg_type: str = "msg") -> Dict:
+def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any, msg_type: str = "msg", parent_msg_id: Optional[str] = None) -> Dict:
     if not isinstance(payload, dict):
         payload = {"text": str(payload)}
     msg = {
@@ -175,6 +175,8 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
         "payload": payload,
         "read": False,
     }
+    if parent_msg_id:
+        msg["parent_msg_id"] = parent_msg_id
     result = sb_insert("mc_messages", msg)
     if isinstance(result, dict) and result.get("_error"):
         return {"error": result["_error"]}
@@ -193,8 +195,28 @@ def read_inbox(project_id: str, agent: str, mark_read: bool = True) -> List[Dict
         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")}
+        # Auto-ACK senders — but ONLY for messages older than 60s. If the
+        # message was sent recently, the sender is very likely still inside
+        # a meshcode_wait call that already returned the message via the
+        # realtime path; an extra "you got it" ack row is pure noise that
+        # spams the dashboard and the sender's inbox.
+        import datetime as _dt
+        now = _dt.datetime.now(_dt.timezone.utc)
+        def _is_stale(m):
+            ts = m.get("created_at")
+            if not ts:
+                return True
+            try:
+                # Supabase returns ISO8601 with timezone
+                dt = _dt.datetime.fromisoformat(str(ts).replace("Z", "+00:00"))
+                return (now - dt).total_seconds() > 60
+            except Exception:
+                return True
+        ack_targets = {
+            m["from_agent"]
+            for m in messages
+            if m.get("type") not in ("ack", "broadcast") and _is_stale(m)
+        }
         for sender in ack_targets:
             sb_insert("mc_messages", {
                 "project_id": project_id,

{meshcode-1.5.0 → meshcode-1.6.0}/meshcode/meshcode_mcp/realtime.py

@@ -164,6 +164,7 @@ class RealtimeListener:
                         "ts": record.get("created_at"),
                         "payload": record.get("payload", {}),
                         "id": record.get("id"),
+                        "parent_id": record.get("parent_msg_id"),
                     }
                     self.queue.append(enriched)
                     # Wake any meshcode_wait blocked on this event.

{meshcode-1.5.0 → meshcode-1.6.0}/meshcode/meshcode_mcp/server.py

@@ -353,6 +353,16 @@ YOU SHOULD ONLY BREAK OUT OF THE meshcode_wait LOOP IF:
   return to the user with that message AND then re-enter the loop.
 - A fatal error happens that requires user intervention.
 
+THREADING: when you reply to a specific message (not just sending a fresh
+task), pass the original message's `id` as `in_reply_to` in your
+meshcode_send call. The dashboard renders threaded replies as a tree under
+their parent — much easier for humans to follow than a flat chat. Use
+threading especially when you sent a broadcast and one agent's reply is to
+a different message than another's. Every message you receive via
+meshcode_wait / meshcode_check / meshcode_read now includes an `id` field
+(use it for in_reply_to) and a `parent_id` field (so you can see whether
+the message you received is itself a reply to something).
+
 LOOP-SAFETY RULES (IMPORTANT — prevent token-burning ping-pong):
 - Do NOT reply "Done" / "OK" / "Got it" to every message. If a message
   is a status update or pure ack, just process it and call meshcode_wait
@@ -480,7 +490,7 @@ except Exception:
 # ----------------- TOOLS -----------------
 
 @mcp.tool()
-def meshcode_send(to: str, message: Any) -> Dict[str, Any]:
+def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None) -> Dict[str, Any]:
     """Send a message to another agent in the meshwork.
 
     If you only have plain text, just pass it as a string and it will be
@@ -491,6 +501,10 @@ def meshcode_send(to: str, message: Any) -> Dict[str, Any]:
         to: Name of the recipient agent.
         message: Either a plain string (auto-wrapped as {"text": message}) or
             a structured dict payload (use protocol keys: need/done/fyi/blocked).
+        in_reply_to: Optional message id you are replying to. If set, this
+            message is a threaded reply — the dashboard renders it under the
+            original. Use this especially when replying to one of several
+            outstanding broadcasts so humans can tell which is which.
     """
     if isinstance(message, str):
         payload: Dict[str, Any] = {"text": message}
@@ -498,7 +512,8 @@ def meshcode_send(to: str, message: Any) -> Dict[str, Any]:
         payload = message
     else:
         payload = {"text": str(message)}
-    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg")
+    return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg",
+                           parent_msg_id=in_reply_to)
 
 
 @mcp.tool()
@@ -518,11 +533,16 @@ def meshcode_broadcast(payload: Dict[str, Any]) -> Dict[str, Any]:
 
 
 @mcp.tool()
-def meshcode_read() -> Dict[str, Any]:
+def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
     """Read all pending (unread) messages for this agent. Marks them as read and ACKs senders.
 
     Returns a split shape: `messages` (real msgs), `acks`, and `done_signals`
     — so you don't have to filter by type yourself.
+
+    Args:
+        include_acks: If False (default), type='ack' rows are dropped entirely
+            from the response. Acks are bookkeeping noise and most callers
+            don't want them in their LLM context.
     """
     raw = be.read_inbox(_PROJECT_ID, AGENT_NAME)
     normalized = [
@@ -532,11 +552,15 @@ def meshcode_read() -> Dict[str, Any]:
             "ts": m.get("created_at"),
             "payload": m.get("payload", {}),
             "id": m.get("id"),
+            "parent_id": m.get("parent_msg_id"),
         }
         for m in raw
     ]
     deduped = _filter_and_mark(normalized)
-    return _split_messages(deduped)
+    split = _split_messages(deduped)
+    if not include_acks:
+        split["acks"] = []
+    return split
 
 
 def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
@@ -553,7 +577,7 @@ def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, An
 
 
 @mcp.tool()
-async def meshcode_wait(timeout_seconds: int = 120) -> Dict[str, Any]:
+async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False) -> Dict[str, Any]:
     """LONG-POLL: Block until a new message arrives for this agent (or timeout).
 
     This is a TRUE async long-poll. While idle, the MCP server blocks on a
@@ -582,6 +606,12 @@ async def meshcode_wait(timeout_seconds: int = 120) -> Dict[str, Any]:
         if not deduped:
             return None
         split = _split_messages(deduped)
+        if not include_acks:
+            split["acks"] = []
+        # If the ONLY thing buffered was acks (now suppressed) AND there
+        # are no real messages or done signals, treat as nothing useful.
+        if not split["messages"] and not split["done_signals"] and not split["acks"]:
+            return None
         out: Dict[str, Any] = {
             "got_message": True,
             "source": "realtime",
@@ -655,7 +685,7 @@ def meshcode_done(reason: str) -> Dict[str, Any]:
 
 
 @mcp.tool()
-def meshcode_check() -> Dict[str, Any]:
+def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
     """Quick poll: returns pending message count + any messages buffered by the
     Realtime listener since the last check.
 
@@ -666,6 +696,8 @@ def meshcode_check() -> Dict[str, Any]:
     realtime_buffered = _REALTIME.drain() if _REALTIME else []
     deduped = _filter_and_mark(realtime_buffered)
     split = _split_messages(deduped)
+    if not include_acks:
+        split["acks"] = []
     return {
         "pending": pending,
         "agent": AGENT_NAME,
@@ -749,6 +781,8 @@ def inbox_resource() -> str:
                 "type": m.get("type", "msg"),
                 "ts": m.get("created_at"),
                 "payload": m.get("payload", {}),
+                "id": m.get("id"),
+                "parent_id": m.get("parent_msg_id"),
             }
             for m in pending
         ],

{meshcode-1.5.0 → meshcode-1.6.0}/meshcode/setup_clients.py

@@ -41,7 +41,12 @@ def _load_credentials(profile: str = "default") -> Dict[str, str]:
 
     api_key = secrets_mod.get_api_key(profile=profile)
     if not api_key:
-        print("[meshcode] ERROR: No credentials found. Run `meshcode login <api_key>` first.", file=sys.stderr)
+        print("[meshcode] ERROR: No credentials found. You need to log in first.", file=sys.stderr)
+        print("[meshcode]", file=sys.stderr)
+        print("[meshcode]   1. Get your API key at: https://meshcode.io/onboarding", file=sys.stderr)
+        print("[meshcode]      (or https://meshcode.io/settings if you already have an account)", file=sys.stderr)
+        print("[meshcode]   2. Run: meshcode login mc_<your-api-key>", file=sys.stderr)
+        print("[meshcode]   3. Then re-run this command.", file=sys.stderr)
         sys.exit(2)
 
     meta_path = Path.home() / ".meshcode" / "profile_meta.json"