meshcode 1.6.0__tar.gz → 1.8.0__tar.gz

{meshcode-1.6.0 → meshcode-1.8.0}/PKG-INFO

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

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

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

{meshcode-1.6.0 → meshcode-1.8.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", parent_msg_id: Optional[str] = None) -> 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, sensitive: bool = False) -> Dict:
     if not isinstance(payload, dict):
         payload = {"text": str(payload)}
     msg = {
@@ -177,6 +177,8 @@ def send_message(project_id: str, from_agent: str, to_agent: str, payload: Any,
     }
     if parent_msg_id:
         msg["parent_msg_id"] = parent_msg_id
+    if sensitive:
+        msg["is_sensitive"] = True
     result = sb_insert("mc_messages", msg)
     if isinstance(result, dict) and result.get("_error"):
         return {"error": result["_error"]}
@@ -257,6 +259,47 @@ def set_status(project_id: str, agent: str, status: str, task: str = "") -> Dict
     return {"ok": True, "status": status}
 
 
+def task_create(api_key, project_id, creator_agent, title, description="", assignee="*", priority="normal", parent_task_id=None):
+    return sb_rpc("mc_task_create", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_creator_agent": creator_agent,
+        "p_title": title,
+        "p_description": description,
+        "p_assignee": assignee,
+        "p_priority": priority,
+        "p_parent_task_id": parent_task_id,
+    })
+
+
+def task_list(api_key, project_id, agent, status_filter=None):
+    return sb_rpc("mc_task_list", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_agent": agent,
+        "p_status_filter": status_filter,
+    })
+
+
+def task_claim(api_key, project_id, task_id, claiming_agent):
+    return sb_rpc("mc_task_claim", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_task_id": task_id,
+        "p_claiming_agent": claiming_agent,
+    })
+
+
+def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
+    return sb_rpc("mc_task_complete", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_task_id": task_id,
+        "p_completing_agent": completing_agent,
+        "p_summary": summary,
+    })
+
+
 def get_history(project_id: str, limit: int = 20) -> List[Dict]:
     return sb_select(
         "mc_messages",

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

@@ -363,6 +363,14 @@ 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).
 
+SENSITIVE DATA: when sharing API keys, credentials, customer data, personal
+information, secrets, or anything that should not be in a public log, set
+sensitive=True in your meshcode_send call. Sensitive messages are NEVER
+included in public meshwork exports, even if the meshwork owner publishes
+the meshwork. The flag is enforced at the database level — there is no way
+for a public viewer to read sensitive messages. Use this liberally — false
+positives are harmless, false negatives are a privacy leak.
+
 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
@@ -383,6 +391,17 @@ YOUR FIRST ACTIONS WHEN THIS SESSION STARTS:
    idle/listening state. Stay there forever unless one of the
    break-out conditions above fires.
 
+TASK BOARD: the meshwork has a shared task list. Use it instead of just messages
+when work needs tracking. Tools:
+  meshcode_tasks(status_filter='open')   — list tasks you could pick up
+  meshcode_task_claim(task_id)            — atomically claim one (CAS — fails if
+                                            another agent already claimed)
+  meshcode_task_complete(task_id, summary)— mark done with a 1-line summary
+  meshcode_task_create(title, description, assignee='*')  — create one (commanders
+                                                            usually do this)
+The dashboard renders the board live. Prefer claiming open tasks over starting
+fresh work — it makes coordination visible to humans.
+
 AVAILABLE MESH TOOLS (all from this MCP server):
   meshcode_wait        — block until a mesh message arrives (your idle state)
   meshcode_done        — broadcast a GLOBAL DONE to break every agent out of wait
@@ -394,6 +413,10 @@ AVAILABLE MESH TOOLS (all from this MCP server):
   meshcode_broadcast   — send to ALL agents in the meshwork
   meshcode_register    — re-register if disconnected
   meshcode_init        — re-initialize agent context (rarely needed)
+  meshcode_tasks             — list tasks on the shared board
+  meshcode_task_create       — create a new task
+  meshcode_task_claim        — atomically claim an open task
+  meshcode_task_complete     — mark a claimed task done
 
 You are not a single-turn chatbot. You are a persistent mesh agent. Act
 accordingly.
@@ -490,7 +513,8 @@ except Exception:
 # ----------------- TOOLS -----------------
 
 @mcp.tool()
-def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None) -> Dict[str, Any]:
+def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
+                  sensitive: bool = False) -> 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
@@ -505,6 +529,13 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None) -> D
             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.
+        sensitive: If True, this message will NEVER appear in a public meshwork
+            export, regardless of whether the meshwork is published. ALWAYS
+            set this to True when sharing API keys, credentials, customer
+            data, secrets, personal information, or anything that should not
+            be visible to anyone outside the meshwork. The owner can publish
+            the meshwork without leaking sensitive messages, because the
+            sensitive flag is enforced at the database level.
     """
     if isinstance(message, str):
         payload: Dict[str, Any] = {"text": message}
@@ -513,7 +544,7 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None) -> D
     else:
         payload = {"text": str(message)}
     return be.send_message(_PROJECT_ID, AGENT_NAME, to, payload, msg_type="msg",
-                           parent_msg_id=in_reply_to)
+                           parent_msg_id=in_reply_to, sensitive=sensitive)
 
 
 @mcp.tool()
@@ -763,6 +794,65 @@ def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
     return {"ok": True, "project": project, "agent": agent, "register": result}
 
 
+@mcp.tool()
+def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
+                          priority: str = "normal", parent_task_id: Optional[str] = None) -> Dict[str, Any]:
+    """Create a task in the meshwork's shared backlog. Use this when you (typically
+    the commander) want to assign work that needs tracking.
+
+    Args:
+        title: Short title of the task.
+        description: Longer description / acceptance criteria.
+        assignee: Agent name to assign to, or "*" for any agent (anyone can claim).
+        priority: 'low' / 'normal' / 'high' / 'urgent'.
+        parent_task_id: Optional parent task id for nesting subtasks.
+
+    Returns: {"ok": true, "task_id": "...", "title": "..."}
+    """
+    api_key = _get_api_key()
+    return be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
+                           description=description, assignee=assignee,
+                           priority=priority, parent_task_id=parent_task_id)
+
+
+@mcp.tool()
+def meshcode_tasks(status_filter: Optional[str] = None) -> Dict[str, Any]:
+    """List tasks in the meshwork. Use this to discover work you can pick up.
+
+    Args:
+        status_filter: 'open' / 'in_progress' / 'done' / etc. None = all.
+
+    Returns: {"ok": true, "tasks": [...]}
+    """
+    api_key = _get_api_key()
+    return be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter=status_filter)
+
+
+@mcp.tool()
+def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
+    """Atomically claim an open task. If the task is already claimed by someone
+    else (or assigned to a different agent), this returns an error and another
+    task should be picked.
+
+    Args:
+        task_id: The uuid of the task you want to claim.
+    """
+    api_key = _get_api_key()
+    return be.task_claim(api_key, _PROJECT_ID, task_id, AGENT_NAME)
+
+
+@mcp.tool()
+def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
+    """Mark a task as done. Only the claimer can complete it.
+
+    Args:
+        task_id: The uuid of the task you previously claimed.
+        summary: Short description of what was accomplished + any artifacts.
+    """
+    api_key = _get_api_key()
+    return be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
+
+
 # ----------------- RESOURCES -----------------
 
 @mcp.resource("meshcode://inbox")

{meshcode-1.6.0 → meshcode-1.8.0}/meshcode.egg-info/PKG-INFO

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

{meshcode-1.6.0 → meshcode-1.8.0}/pyproject.toml

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