meshcode 2.10.37__tar.gz → 2.10.40__tar.gz

{meshcode-2.10.37 → meshcode-2.10.40}/PKG-INFO

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

{meshcode-2.10.37 → meshcode-2.10.40}/meshcode/__init__.py

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

{meshcode-2.10.37 → meshcode-2.10.40}/meshcode/comms_v4.py

@@ -615,7 +615,7 @@ def spawn_headless_agent(project, name, project_id, message_body, from_agent):
         # The agent is identity-only at rest; next message wakes it again.
         sb_update("mc_agents",
                   f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-                  {"status": "sleeping", "task": "Esperando mensajes...",
+                  {"status": "sleeping", "task": "Waiting for messages...",
                    "last_active_at": now_iso(), "last_heartbeat": now_iso()})
     except Exception:
         pass
@@ -865,7 +865,7 @@ def register(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] No se pudo crear/encontrar proyecto '{project}'")
+        print(f"[ERROR] Could not create/find project '{project}'")
         return
 
     ppid = os.getppid()
@@ -946,7 +946,7 @@ def register(project, name, role=""):
         order="created_at.desc", limit=10)
     if recent:
         recent.reverse()
-        print(f"\n[COMMS] Últimos {len(recent)} mensajes del equipo:")
+        print(f"\n[COMMS] Last {len(recent)} team messages:")
         for msg in recent:
             ts = msg.get("created_at", "")[-8:]
             fr = msg["from_agent"]
@@ -1132,7 +1132,7 @@ def watch(project, name, interval=10, timeout=0):
     # Update status to standby
     sb_update("mc_agents",
         f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-        {"status": "standby", "task": "Esperando mensajes...", "last_heartbeat": now_iso()})
+        {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
     cycle = timeout if timeout > 0 else 600
     print(f"[{project}] {name} en watch — poll cada {interval}s, ciclo {cycle}s (auto-loop)")
@@ -1161,10 +1161,10 @@ def watch(project, name, interval=10, timeout=0):
             time.sleep(interval)
 
         # Cycle ended without messages — check user context, then AUTO-RESTART watch
-        print(f"[{project}] Otro ciclo sin mensajes. Watch activo, sigue corriendo. En standby.")
+        print(f"[{project}] No messages this cycle. Watch active, still running. Standby.")
         sb_update("mc_agents",
             f"project_id=eq.{project_id}&name=eq.{quote(name)}",
-            {"status": "standby", "task": "Esperando mensajes...", "last_heartbeat": now_iso()})
+            {"status": "standby", "task": "Waiting for messages...", "last_heartbeat": now_iso()})
 
 
 def update_board(project, name, status, task=""):
@@ -1183,7 +1183,7 @@ def update_board(project, name, status, task=""):
             print(f"[{project}] {name}: NO puedes estar idle — tienes {count} mensaje(s) pendientes.")
             print(f"[{project}] Ejecuta: python3 ~/Desktop/meshcode/comms_v4.py read {project} {name}")
             status = "working"
-            task = f"{count} mensajes pendientes"
+            task = f"{count} pending messages"
 
     updates = {"status": status, "last_heartbeat": now_iso()}
     if task:
@@ -1197,7 +1197,7 @@ def update_board(project, name, status, task=""):
 def show_board(project):
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[{project}] Sin proyecto")
+        print(f"[{project}] Project not found")
         return
 
     agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
@@ -1221,7 +1221,7 @@ def show_status(project=None):
         projects_data = sb_select("mc_projects", "", order="created_at.asc")
 
     if not projects_data:
-        print("[COMMS] Sin proyectos activos")
+        print("[COMMS] No active projects")
         return
 
     print(f"\n{'='*60}")
@@ -1266,7 +1266,7 @@ def show_history(project, last_n=20, between=None):
     messages.reverse()
 
     print(f"\n{'='*60}")
-    print(f" {project.upper()} — Historial ({len(messages)} mensajes)")
+    print(f" {project.upper()} — History ({len(messages)} messages)")
     if between:
         print(f" Filtro: {between}")
     print(f"{'='*60}\n")
@@ -1472,7 +1472,7 @@ def connect_terminal(project, name, role=""):
     ensure_sessions()
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] No se pudo crear/encontrar proyecto '{project}'")
+        print(f"[ERROR] Could not create/find project '{project}'")
         return
 
     tty, owning = _capture_tty_for_pid(os.getppid())
@@ -1542,7 +1542,7 @@ def disconnect_terminal(project, name):
     """Mark agent offline, clear tty/pid, stop heartbeat, remove session file."""
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[ERROR] proyecto '{project}' no encontrado")
+        print(f"[ERROR] project '{project}' not found")
         return
     rpc_result = sb_rpc("mc_disconnect_agent", {
         "p_project_id": project_id,
@@ -2177,7 +2177,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[ERROR] project '{proj}' not found")
             sys.exit(1)
         ok = spawn_headless_agent(proj, name, project_id,
                                   "ping: synthetic wake-headless test message", "test-harness")
@@ -2193,7 +2193,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[ERROR] project '{proj}' not found")
             sys.exit(1)
         rpc_name = {"kill": "mc_agent_kill", "wake": "mc_agent_wake", "sleep": "mc_agent_sleep"}[cmd]
         result = sb_rpc(rpc_name, {"p_project_id": project_id, "p_agent_name": name})
@@ -2212,7 +2212,7 @@ if __name__ == "__main__":
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
-            print(f"[ERROR] proyecto '{proj}' no encontrado")
+            print(f"[ERROR] project '{proj}' not found")
             sys.exit(1)
         if sub == "get":
             result = sb_rpc("mc_agent_get_profile", {"p_project_id": project_id, "p_agent_name": name})
@@ -2425,7 +2425,30 @@ if __name__ == "__main__":
             sys.exit(1)
         login(key)
 
-    elif cmd in ("profiles", "whoami"):
+    elif cmd == "whoami":
+        # Show the logged-in user identity from profile_meta.json
+        meta_path = Path.home() / ".meshcode" / "profile_meta.json"
+        if meta_path.exists():
+            try:
+                meta = json.loads(meta_path.read_text(encoding="utf-8"))
+                print()
+                print(f"[meshcode] Logged in as:")
+                if meta.get("email"):
+                    print(f"  email:        {meta['email']}")
+                if meta.get("display_name"):
+                    print(f"  display name: {meta['display_name']}")
+                if meta.get("user_id"):
+                    print(f"  user ID:      {meta['user_id']}")
+                active = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
+                print(f"  profile:      {active}")
+                print()
+            except Exception:
+                print("[meshcode] Could not read profile. Run `meshcode login <api_key>`.")
+        else:
+            print("[meshcode] Not logged in. Run `meshcode login <api_key>`.")
+        sys.exit(0)
+
+    elif cmd == "profiles":
         # List all stored keychain profiles with metadata
         try:
             import importlib as _il

{meshcode-2.10.37 → meshcode-2.10.40}/meshcode/meshcode_mcp/server.py

@@ -601,7 +601,9 @@ def with_working_status(func):
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
                 _set_state("working", name)
-                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
+                # Estimate input tokens (chars/4) for usage tracking
+                _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
                 return await func(*args, **kwargs)
             except Exception as e:
@@ -622,7 +624,8 @@ def with_working_status(func):
                 global _CONSECUTIVE_IDLE_SECONDS
                 _CONSECUTIVE_IDLE_SECONDS = 0  # any non-wait tool resets idle timer
                 _set_state("working", name)
-                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
+                _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
                 return func(*args, **kwargs)
             except Exception as e:
@@ -1512,6 +1515,88 @@ def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
     return split
 
 
+@mcp.tool()
+@with_working_status
+async def meshcode_call(to: str, function: str, args: Any = None, timeout_seconds: int = 30) -> Dict[str, Any]:
+    """Synchronous RPC call to another agent. Blocks until response (max 30s).
+
+    Sends a structured request, waits for the callee to respond with a matching
+    call_id. Like gRPC over the mesh — enables agents to ask each other questions
+    and get structured answers.
+
+    Args:
+        to: Target agent name.
+        function: Function/action name the callee should execute.
+        args: Arguments (any JSON-serializable value).
+        timeout_seconds: Max wait time (default 30, max 60).
+    """
+    import uuid as _uuid
+    if not to or not to.strip():
+        return {"error": "recipient 'to' cannot be empty"}
+    call_id = str(_uuid.uuid4())
+    timeout_seconds = min(max(timeout_seconds, 5), 60)
+
+    # Send the RPC request
+    request_payload = {
+        "type": "rpc_request",
+        "call_id": call_id,
+        "function": function,
+        "args": args,
+        "from": AGENT_NAME,
+        "timeout": timeout_seconds,
+    }
+    send_result = be.send_message(
+        _PROJECT_ID, AGENT_NAME, to, request_payload,
+        msg_type="rpc", api_key=_get_api_key()
+    )
+    if not send_result.get("sent") and send_result.get("error"):
+        return {"error": f"failed to send RPC request: {send_result['error']}"}
+
+    # Poll for response with matching call_id
+    import asyncio as _asyncio
+    poll_interval = 1.0
+    elapsed = 0.0
+    while elapsed < timeout_seconds:
+        await _asyncio.sleep(poll_interval)
+        elapsed += poll_interval
+
+        # Check Realtime buffer first
+        if _REALTIME:
+            for msg in _REALTIME.peek():
+                p = msg.get("payload") or {}
+                if isinstance(p, dict) and p.get("type") == "rpc_response" and p.get("call_id") == call_id:
+                    # Found response — drain it
+                    _REALTIME.drain()
+                    return {
+                        "ok": True,
+                        "call_id": call_id,
+                        "from": msg.get("from"),
+                        "result": p.get("result"),
+                        "error": p.get("error"),
+                    }
+
+        # Fallback: check DB
+        try:
+            raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=True, api_key=_get_api_key())
+            for m in (raw if isinstance(raw, list) else raw.get("messages", []) if isinstance(raw, dict) else []):
+                p = m.get("payload") or {}
+                if isinstance(p, dict) and p.get("type") == "rpc_response" and p.get("call_id") == call_id:
+                    return {
+                        "ok": True,
+                        "call_id": call_id,
+                        "from": m.get("from_agent") or m.get("from"),
+                        "result": p.get("result"),
+                        "error": p.get("error"),
+                    }
+        except Exception:
+            pass
+
+        # Exponential backoff on polling (1s → 2s → 3s, cap 3s)
+        poll_interval = min(poll_interval + 0.5, 3.0)
+
+    return {"error": f"RPC call to {to}.{function} timed out after {timeout_seconds}s", "call_id": call_id}
+
+
 @mcp.tool()
 @with_working_status
 def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dict[str, Any]:
@@ -2266,6 +2351,80 @@ def meshcode_task_reassign(task_id: str, new_assignee: str) -> Dict[str, Any]:
     })
 
 
+# ----------------- SCHEDULED TASKS -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_schedule(title: str, cron_expression: str, assignee: str = "*",
+                      description: str = "", priority: str = "normal") -> Dict[str, Any]:
+    """Create a recurring scheduled task. Fires on cron schedule.
+
+    Args:
+        title: Task title (created each time it fires).
+        cron_expression: Standard cron (e.g. "0 9 * * 1-5" = 9am weekdays).
+        assignee: Agent name or "*" for any.
+        description: Task description template.
+        priority: low/normal/high/urgent.
+    """
+    if not title or not title.strip():
+        return {"error": "title cannot be empty"}
+    if not cron_expression or not cron_expression.strip():
+        return {"error": "cron_expression cannot be empty"}
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_schedule_create", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_creator_agent": AGENT_NAME,
+        "p_title": title.strip(),
+        "p_cron_expression": cron_expression.strip(),
+        "p_description": description,
+        "p_assignee": assignee,
+        "p_priority": priority,
+    })
+
+
+@mcp.tool()
+@with_working_status
+def meshcode_schedule_list() -> Dict[str, Any]:
+    """List all scheduled/recurring tasks for this meshwork."""
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_schedule_list", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+    })
+
+
+# ----------------- TEMPLATES -----------------
+
+@mcp.tool()
+@with_working_status
+def meshcode_publish_template(slug: str, name: str, description: str = "",
+                               category: str = "Custom", tags: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Publish this meshwork as a reusable template others can fork.
+
+    Args:
+        slug: URL-safe identifier (e.g. "my-saas-team"). Must be unique.
+        name: Human-readable template name.
+        description: What this template is for.
+        category: Template category (Development, DevOps, Research, etc).
+        tags: Searchable tags.
+    """
+    if not slug or not slug.strip():
+        return {"error": "slug cannot be empty"}
+    if not name or not name.strip():
+        return {"error": "name cannot be empty"}
+    api_key = _get_api_key()
+    return be.sb_rpc("mc_template_publish", {
+        "p_api_key": api_key,
+        "p_project_id": _PROJECT_ID,
+        "p_slug": slug.strip(),
+        "p_name": name.strip(),
+        "p_description": description,
+        "p_category": category,
+        "p_tags": tags or [],
+    })
+
+
 # ----------------- PROACTIVE HEALTH SCAN -----------------
 
 @mcp.tool()
@@ -2485,21 +2644,36 @@ def meshcode_add_agent(name: str, role: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_edit_agent(name: str, role: Optional[str] = None, launch_prompt: Optional[str] = None) -> Dict[str, Any]:
-    """Update an agent's role or launch prompt.
+    """Update an agent's role or launch prompt. Notifies the running agent to reload.
 
     Args:
         name: Agent name to edit.
         role: New role description.
         launch_prompt: New launch prompt (injected into agent's system context).
     """
-    return be.sb_rpc("mc_agent_update_profile", {
+    result = be.sb_rpc("mc_agent_update_profile", {
         "p_project_id": _PROJECT_ID,
         "p_agent_name": name,
         "p_color": None,
         "p_display_name": None,
         "p_role_description": role,
         "p_launch_prompt": launch_prompt,
-    }) or {"error": "failed to update agent"}
+    })
+    if not result:
+        return {"error": "failed to update agent"}
+
+    # Hot-swap: notify the running agent to reload its prompt
+    if name != AGENT_NAME:
+        try:
+            be.send_message(_PROJECT_ID, AGENT_NAME, name, {
+                "type": "prompt_update",
+                "text": f"Your {'role' if role else 'launch prompt'} was updated by {AGENT_NAME}. Changes take effect on next boot or meshcode_check.",
+                "updated_fields": {"role": role, "launch_prompt": launch_prompt is not None},
+            }, msg_type="system", api_key=_get_api_key())
+        except Exception:
+            pass  # best-effort notification
+
+    return result
 
 
 @mcp.tool()

{meshcode-2.10.37 → meshcode-2.10.40}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.37 → meshcode-2.10.40}/pyproject.toml

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