meshcode 2.10.65__tar.gz → 2.10.70__tar.gz

{meshcode-2.10.65 → meshcode-2.10.70}/PKG-INFO

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

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode/__init__.py

@@ -1,5 +1,5 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.10.65"
+__version__ = "2.10.70"
 
 # Exception hierarchy — eagerly imported (lightweight, no deps)
 from meshcode.exceptions import (  # noqa: F401

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode/ascii_art.py

@@ -148,6 +148,135 @@ def generate_art(agent_name: str, meshwork_name: str = "", size: int = 7) -> str
     return "\n".join(lines)
 
 
+# ── Pixel Mascot renderer (Unicode block art) ──────────────────────
+# Renders a small pixel character using Unicode half-block chars.
+# Deterministic from agent name hash, like the identicon but cuter.
+
+_MASCOT_BODY_TEMPLATES = {
+    "round": [
+        "  ████  ",
+        " ██████ ",
+        "████████",
+        "████████",
+        " ██████ ",
+        "  ████  ",
+    ],
+    "square": [
+        "████████",
+        "██    ██",
+        "██    ██",
+        "██    ██",
+        "██    ██",
+        "████████",
+    ],
+    "tall": [
+        "  ████  ",
+        " ██████ ",
+        " ██████ ",
+        " ██████ ",
+        " ██████ ",
+        "  ████  ",
+        "  ████  ",
+        "  ████  ",
+    ],
+    "wide": [
+        "██████████",
+        "██      ██",
+        "██████████",
+        " ████████ ",
+    ],
+    "triangle": [
+        "   ██   ",
+        "  ████  ",
+        " ██████ ",
+        "████████",
+        "████████",
+        " ██  ██ ",
+    ],
+}
+
+_MASCOT_EYES = {
+    "dots":    ("●", "●"),
+    "circles": ("◉", "◉"),
+    "angry":   ("▼", "▼"),
+    "happy":   ("◠", "◠"),
+    "sleepy":  ("—", "—"),
+    "star":    ("★", "★"),
+}
+
+_MASCOT_HATS = {
+    "none": [],
+    "hat": ["   ▄▄   ", "  ████  "],
+    "glasses": [],  # applied as eye overlay
+    "antenna": ["    |   ", "   (◉)  "],
+    "headphones": ["  ╔══╗  "],
+    "crown": [" ▲ ▲ ▲  ", "  ████  "],
+}
+
+
+def render_pixel_mascot(agent_name: str, mascot_config: dict = None) -> str:
+    """Render a pixel mascot as Unicode art for terminal display.
+
+    If mascot_config is None, generates deterministic defaults from agent name.
+    """
+    h = _hash_bytes(agent_name)
+    hi = _hash_int(agent_name)
+
+    if mascot_config is None or mascot_config.get("generated"):
+        body_types = list(_MASCOT_BODY_TEMPLATES.keys())
+        eye_styles = list(_MASCOT_EYES.keys())
+        body_type = body_types[hi % len(body_types)]
+        eye_style = eye_styles[(hi // 10) % len(eye_styles)]
+        accessory = "none"
+        equipped = []
+    else:
+        body_type = mascot_config.get("body_type", "round")
+        eye_style = mascot_config.get("eye_style", "dots")
+        accessory = mascot_config.get("accessory", "none")
+        equipped = mascot_config.get("equipped", [])
+
+    # Get body template
+    body = list(_MASCOT_BODY_TEMPLATES.get(body_type, _MASCOT_BODY_TEMPLATES["round"]))
+
+    # Add eyes (on the 2nd or 3rd row depending on body)
+    eye_row = min(1, len(body) - 1)
+    if len(body) > 3:
+        eye_row = 2
+    eyes = _MASCOT_EYES.get(eye_style, _MASCOT_EYES["dots"])
+    if eye_row < len(body):
+        row = list(body[eye_row])
+        # Place eyes at 1/3 and 2/3 positions
+        w = len(row)
+        left_eye = w // 3
+        right_eye = 2 * w // 3
+        if left_eye < w:
+            row[left_eye] = eyes[0]
+        if right_eye < w:
+            row[right_eye] = eyes[1]
+        body[eye_row] = "".join(row)
+
+    # Add hat/accessory on top
+    hat_lines = _MASCOT_HATS.get(accessory, [])
+    # Check equipped accessories for hat/crown
+    for item in equipped:
+        if "crown" in item:
+            hat_lines = _MASCOT_HATS.get("crown", [])
+            break
+        elif "hat" in item:
+            hat_lines = _MASCOT_HATS.get("hat", [])
+            break
+        elif "antenna" in item:
+            hat_lines = _MASCOT_HATS.get("antenna", [])
+            break
+
+    lines = hat_lines + body
+
+    # Add feet
+    lines.append("  ▀  ▀  ")
+
+    return "\n".join(f"  {line}" for line in lines)
+
+
 # ── ANSI colors ─────────────────────────────────────────────────────
 COLORS = [
     "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
@@ -441,7 +570,8 @@ def get_tip(agent_name: str) -> str:
 def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
                    version: str = "", is_commander: bool = False,
                    role: str = "", stats: dict = None,
-                   profile_color: str = None) -> str:
+                   profile_color: str = None,
+                   mascot_config: dict = None) -> str:
     h = _hash_bytes(agent_name)
     # Use dashboard profile color if available, otherwise MD5 hash fallback
     color = None
@@ -465,7 +595,10 @@ def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
     lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
     lines.append("")
 
-    for line in ascii_art.split("\n"):
+    # Always use pixel mascot — generates deterministic defaults from agent name if no config
+    art_to_render = render_pixel_mascot(agent_name, mascot_config)
+
+    for line in art_to_render.split("\n"):
         lines.append(f"  {color}{line}{RESET}")
 
     lines.append("")

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode/comms_v4.py

@@ -1171,7 +1171,8 @@ def send_msg(project, from_agent, to_agent, content, msg_type="msg", compact=Fal
                 if agents and agents[0].get("status") not in ("offline", "killed"):
                     nudge_agent(project, to_agent, from_agent)
     else:
-        print(f"[{project}] ERROR: no se pudo enviar mensaje")
+        print(f"[meshcode] ERROR: Could not send message to {project}")
+        print(f"[meshcode] Fix: Check project name with: meshcode projects")
 
 
 def broadcast(project, from_agent, content, msg_type="broadcast"):
@@ -1200,7 +1201,7 @@ def read_messages(project, name, silent=False, send_acks=True):
     project_id = get_project_id(project)
     if not project_id:
         if not silent:
-            print("[EMPTY]")
+            print("No new messages.")
         return []
 
     # Get unread messages
@@ -1210,7 +1211,7 @@ def read_messages(project, name, silent=False, send_acks=True):
 
     if not messages:
         if not silent:
-            print("[EMPTY]")
+            print("No new messages.")
         return []
 
     # Mark all as read
@@ -1463,14 +1464,36 @@ def show_board(project):
         print(f"[{project}] No agents found")
         return
 
+    def _human_time(ts_str):
+        """Convert ISO timestamp to human-readable age."""
+        if not ts_str:
+            return ""
+        try:
+            from datetime import datetime, timezone
+            dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+            age = (datetime.now(timezone.utc) - dt).total_seconds()
+            if age < 60: return f"{int(age)}s ago"
+            if age < 3600: return f"{int(age/60)}m ago"
+            if age < 86400: return f"{int(age/3600)}h ago"
+            return f"{int(age/86400)}d ago"
+        except Exception:
+            return ""
+
     print(f"\n{'='*60}")
     print(f" {project.upper()} — Board")
     print(f"{'='*60}")
     for a in agents:
+        status = a.get("status", "?")
         icon = {"online": "●", "working": "▶", "blocked": "■", "standby": "◆",
                 "idle": "○", "done": "✓", "sleeping": "☾", "offline": "✗",
-                "waiting": "◎"}.get(a.get("status", ""), "?")
-        print(f"  {icon} {a['name']:<14} {a.get('status','?'):<10} {a.get('task','')}")
+                "waiting": "◎"}.get(status, "?")
+        task = a.get("task", "")
+        # Clean up noisy task text
+        if task and "idle" in task.lower() and "s —" in task:
+            task = ""  # hide "idle 29720s — still listening"
+        hb_age = _human_time(a.get("last_heartbeat"))
+        hb_info = f"  ({hb_age})" if hb_age and status in ("offline", "sleeping") else ""
+        print(f"  {icon} {a['name']:<14} {status:<10} {task[:40]}{hb_info}")
 
     # Enhanced: show health + tasks + activity from dashboard summary
     if _ak:
@@ -2996,9 +3019,47 @@ if __name__ == "__main__":
         #   name exists in multiple meshworks
         # meshcode run <agent> (backwards compat, same as go)
         if len(sys.argv) < 3:
-            print(f"Usage: meshcode {cmd} <agent> [--project <name>] [--editor claude|cursor|code]")
-            print(f"   or: meshcode {cmd} <project>/<agent>  (disambiguation)")
-            sys.exit(1)
+            # Interactive agent selection
+            _ak = _load_api_key_for_cli()
+            if _ak:
+                try:
+                    _projs = sb_rpc("mc_list_user_projects", {"p_api_key": _ak})
+                    _agents_list = []
+                    if isinstance(_projs, dict) and _projs.get("projects"):
+                        for _p in _projs["projects"]:
+                            for _a in (_p.get("agents") or []):
+                                _agents_list.append((_p["name"], _a.get("name", "?")))
+                    if _agents_list:
+                        print(f"\n  Your agents:")
+                        for i, (pn, an) in enumerate(_agents_list, 1):
+                            print(f"    {i}. {pn}/{an}")
+                        print()
+                        choice = input("  Which agent? (number or name): ").strip()
+                        if choice.isdigit() and 1 <= int(choice) <= len(_agents_list):
+                            pn, an = _agents_list[int(choice) - 1]
+                            sys.argv = [sys.argv[0], cmd, f"{pn}/{an}"] + sys.argv[2:]
+                        elif "/" in choice:
+                            sys.argv = [sys.argv[0], cmd, choice] + sys.argv[2:]
+                        else:
+                            # Try to find by name
+                            matches = [(pn, an) for pn, an in _agents_list if an == choice]
+                            if matches:
+                                pn, an = matches[0]
+                                sys.argv = [sys.argv[0], cmd, f"{pn}/{an}"] + sys.argv[2:]
+                            else:
+                                print(f"  Agent '{choice}' not found.")
+                                sys.exit(1)
+                    else:
+                        print(f"  No agents found. Run: meshcode quickstart")
+                        sys.exit(1)
+                except Exception:
+                    print(f"Usage: meshcode {cmd} <agent> [--project <name>]")
+                    sys.exit(1)
+            else:
+                print(f"Usage: meshcode {cmd} <agent> [--project <name>] [--editor claude|cursor|code]")
+                print(f"   or: meshcode {cmd} <project>/<agent>  (disambiguation)")
+                print(f"\n  Not logged in? Run: meshcode quickstart")
+                sys.exit(1)
         agent_arg = sys.argv[2]
         # Parse project/agent syntax
         if "/" in agent_arg and not agent_arg.startswith("/"):

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode/meshcode_mcp/server.py

@@ -1678,8 +1678,17 @@ def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
     else:
         payload = {"text": str(message)}
 
-    # Enforce message size limit — long content belongs in task descriptions
+    # Universal DM render guarantee: dashboard chat renderer keys on
+    # payload.text. Structured-dict DMs without a text field render blank.
     import json as _json
+    if "text" not in payload:
+        _synth = _json.dumps(
+            {k: v for k, v in payload.items() if not k.startswith("_")},
+            default=str, ensure_ascii=False,
+        )
+        payload["text"] = _synth if len(_synth) <= 280 else _synth[:279] + "…"
+
+    # Enforce message size limit — long content belongs in task descriptions
     _payload_len = len(_json.dumps(payload, default=str))
     if _payload_len > 2000:
         return {"error": f"message too large ({_payload_len} chars). Use meshcode_task_create for long content. Messages must be structured JSON <2000 chars."}
@@ -1899,6 +1908,116 @@ def meshcode_read_message(msg_id: str) -> Dict[str, Any]:
     }
 
 
+@mcp.tool()
+@with_working_status
+def meshcode_download_file(file_id: str) -> Dict[str, Any]:
+    """Download a file attachment from a mesh message.
+
+    Returns file content for text/JSON files, or saves to temp file and
+    returns the path for images (Claude can view image files directly).
+
+    Args:
+        file_id: UUID of the file (from message payload's file.file_id).
+    """
+    import tempfile
+    import urllib.request as _req
+    import urllib.error as _uerr
+
+    api_key = _get_api_key()
+    if not api_key:
+        return {"error": "no api key", "error_code": "auth_failed"}
+
+    # Step 1: Get file metadata via RPC
+    file_info = be.sb_rpc("mc_get_file_download", {
+        "p_api_key": api_key,
+        "p_file_id": file_id,
+    })
+    if not file_info or not file_info.get("ok"):
+        return {"error": file_info.get("error", "file not found"), "error_code": "not_found"}
+
+    storage_path = file_info["storage_path"]
+    bucket = file_info.get("bucket", "meshcode-files")
+    mime_type = file_info.get("mime_type", "application/octet-stream")
+    file_name = file_info.get("file_name", "download")
+
+    # Step 2: Download from Supabase Storage (using service-level anon key)
+    sb_url = os.environ.get("SUPABASE_URL", be._sb_url if hasattr(be, '_sb_url') else "")
+    sb_key = os.environ.get("SUPABASE_KEY", be._sb_key if hasattr(be, '_sb_key') else "")
+
+    if not sb_url or not sb_key:
+        return {"error": "storage not configured", "error_code": "config_error"}
+
+    # URL-encode each path segment so filenames with spaces/unicode (the common
+    # 400 cause when dashboard composer attaches files like "Screenshot 1.png")
+    # don't produce a malformed Storage URL.
+    from urllib.parse import quote as _quote
+    _enc_path = "/".join(_quote(seg, safe="") for seg in storage_path.split("/") if seg)
+    _enc_bucket = _quote(bucket, safe="")
+
+    def _try_download(url: str):
+        req = _req.Request(
+            url,
+            headers={
+                "apikey": sb_key,
+                "Authorization": f"Bearer {sb_key}",
+            },
+        )
+        with _req.urlopen(req, timeout=30) as resp:
+            return resp.read()
+
+    # Try authenticated object endpoint first; fall back to public endpoint
+    # for buckets that have public read enabled. Many 400/403 cases on private
+    # buckets resolve when the bucket is configured as public-readable.
+    auth_url = f"{sb_url}/storage/v1/object/{_enc_bucket}/{_enc_path}"
+    public_url = f"{sb_url}/storage/v1/object/public/{_enc_bucket}/{_enc_path}"
+    last_err = None
+    content = None
+    for _url in (auth_url, public_url):
+        try:
+            content = _try_download(_url)
+            break
+        except _uerr.HTTPError as e:
+            last_err = f"HTTP {e.code} on {_url}: {e.reason}"
+            continue
+        except Exception as e:
+            last_err = f"{type(e).__name__} on {_url}: {e}"
+            continue
+    if content is None:
+        return {
+            "error": f"download failed: {last_err}",
+            "error_code": "download_error",
+            "tried_urls": [auth_url, public_url],
+            "storage_path": storage_path,
+        }
+
+    # Step 3: Return content based on type
+    if mime_type.startswith("text/") or mime_type == "application/json":
+        try:
+            text = content.decode("utf-8")
+            if mime_type == "application/json":
+                return {"ok": True, "file_name": file_name, "mime_type": mime_type,
+                        "content": json.loads(text)}
+            return {"ok": True, "file_name": file_name, "mime_type": mime_type,
+                    "content": text[:50000]}  # cap at 50k chars
+        except Exception:
+            pass
+
+    # For images and binary: save to temp file, return path
+    suffix = "." + file_name.rsplit(".", 1)[-1] if "." in file_name else ""
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, prefix="meshcode_")
+    tmp.write(content)
+    tmp.close()
+
+    return {
+        "ok": True,
+        "file_name": file_name,
+        "mime_type": mime_type,
+        "size_bytes": len(content),
+        "local_path": tmp.name,
+        "note": "File saved to local_path. For images, use Read tool to view.",
+    }
+
+
 def _detect_global_done(messages: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
     """Return {reason, from} if the list contains a global_done signal, else None."""
     for m in messages:

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode/run_agent.py

@@ -33,23 +33,24 @@ REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
 
 
 def _fetch_or_generate_art(agent: str, project: str) -> tuple:
-    """Fetch ASCII art + role + profile color from server.
-    Returns (ascii_art, role_description, profile_color)."""
+    """Fetch ASCII art + role + profile color + mascot config from server.
+    Returns (ascii_art, role_description, profile_color, mascot_config)."""
     from .ascii_art import generate_art
     try:
         from .setup_clients import _load_supabase_env
         import importlib
         secrets_mod = importlib.import_module("meshcode.secrets")
     except Exception:
-        return generate_art(agent), agent, None
+        return generate_art(agent), agent, None, None
 
     profile = os.environ.get("MESHCODE_KEYCHAIN_PROFILE") or "default"
     api_key = secrets_mod.get_api_key(profile=profile)
     if not api_key:
-        return generate_art(agent), agent, None
+        return generate_art(agent), agent, None, None
 
     sb = _load_supabase_env()
     profile_color = None
+    mascot_config = None
     try:
         from urllib.request import Request, urlopen
         import urllib.parse
@@ -69,7 +70,7 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
         with urlopen(proj_req, timeout=5) as resp:
             proj_data = json.loads(resp.read().decode())
         if not proj_data or not proj_data.get("project_id"):
-            return generate_art(agent), agent, None
+            return generate_art(agent), agent, None, None
         project_id = proj_data["project_id"]
         # Step 2: fetch existing art + role via mc_get_agents RPC
         data = None
@@ -120,7 +121,7 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
             if agent_id:
                 try:
                     prof_req = Request(
-                        f"{sb['SUPABASE_URL']}/rest/v1/mc_agent_profiles?select=color&agent_id=eq.{agent_id}",
+                        f"{sb['SUPABASE_URL']}/rest/v1/mc_agent_profiles?select=color,mascot_config&agent_id=eq.{agent_id}",
                         headers={
                             "apikey": sb["SUPABASE_KEY"],
                             "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
@@ -129,12 +130,15 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
                     )
                     with urlopen(prof_req, timeout=5) as resp:
                         prof_data = json.loads(resp.read().decode())
-                    if prof_data and prof_data[0].get("color"):
-                        profile_color = prof_data[0]["color"]
+                    if prof_data:
+                        if prof_data[0].get("color"):
+                            profile_color = prof_data[0]["color"]
+                        if prof_data[0].get("mascot_config"):
+                            mascot_config = prof_data[0]["mascot_config"]
                 except Exception:
                     pass
             if data[0].get("ascii_art"):
-                return data[0]["ascii_art"], data[0].get("role") or agent, profile_color
+                return data[0]["ascii_art"], data[0].get("role") or agent, profile_color, mascot_config
     except Exception:
         pass
 
@@ -156,7 +160,7 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
         urlopen(req, timeout=5)
     except Exception:
         pass
-    return art, agent, profile_color
+    return art, agent, profile_color, mascot_config
 
 
 def _fetch_agent_stats(agent: str, project: str) -> dict:
@@ -784,7 +788,7 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
                             break
                 except Exception:
                     pass
-        ascii_art, agent_role, profile_color = _fetch_or_generate_art(agent, resolved_project)
+        ascii_art, agent_role, profile_color, mascot_cfg = _fetch_or_generate_art(agent, resolved_project)
         _leader_haystack = (agent + ' ' + agent_role).lower()
         _LEADER_KW = ('commander', 'lead', 'orchestrat', 'coordinator', 'coordinat',
                        'coordinad', 'jefe', 'líder', 'lider', 'director', 'manager',
@@ -795,6 +799,7 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
             agent, resolved_project, ascii_art, cli_version,
             is_commander=is_cmd, role=agent_role, stats=agent_stats,
             profile_color=profile_color,
+            mascot_config=mascot_cfg,
         ), file=sys.stderr, flush=True)
     except Exception as _banner_err:
         import traceback as _tb

{meshcode-2.10.65 → meshcode-2.10.70}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.65 → meshcode-2.10.70}/pyproject.toml

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