meshcode 2.8.6__tar.gz → 2.8.8__tar.gz

{meshcode-2.8.6 → meshcode-2.8.8}/PKG-INFO

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

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode/__init__.py

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

meshcode-2.8.8/meshcode/ascii_art.py

@@ -0,0 +1,130 @@
+"""Procedural ASCII art generator for MeshCode agents.
+
+Each agent gets a unique visual identity — like a QR code / identicon
+but made of block characters. Generated deterministically from the
+agent name hash, so it's always the same for the same agent.
+Stored in mc_agents.ascii_art, displayed on terminal launch.
+"""
+import hashlib
+
+# Block characters for the pattern
+BLOCKS = {
+    0: "  ",    # empty
+    1: "██",    # full block
+    2: "░░",    # light shade
+    3: "▓▓",    # dark shade
+    4: "▒▒",    # medium shade
+    5: "╬╬",    # cross
+    6: "◆◆",    # diamond
+    7: "●●",    # circle
+}
+
+# ANSI colors
+COLORS = [
+    "\033[36m",   # cyan
+    "\033[35m",   # magenta
+    "\033[32m",   # green
+    "\033[33m",   # yellow
+    "\033[34m",   # blue
+    "\033[91m",   # bright red
+    "\033[96m",   # bright cyan
+    "\033[95m",   # bright magenta
+    "\033[92m",   # bright green
+    "\033[94m",   # bright blue
+]
+RESET = "\033[0m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+
+
+def _hash_bytes(name: str) -> bytes:
+    """Get deterministic hash bytes from agent name."""
+    return hashlib.sha256(name.encode("utf-8")).digest()
+
+
+def generate_art(agent_name: str, size: int = 7) -> str:
+    """Generate a unique symmetric block pattern from the agent name.
+
+    Creates a (size x size) grid that's mirrored horizontally for symmetry
+    (like identicons / QR codes). The pattern is deterministic — same name
+    always produces the same art.
+    """
+    h = _hash_bytes(agent_name)
+    half = (size + 1) // 2  # columns to generate (left half + center)
+    rows = []
+
+    for y in range(size):
+        row = []
+        for x in range(half):
+            # Each cell uses a byte from the hash
+            idx = (y * half + x) % len(h)
+            byte_val = h[idx]
+
+            # Decide if cell is filled (60% chance) and which block
+            if byte_val < 100:
+                block = BLOCKS[0]  # empty
+            else:
+                block_idx = (byte_val % 6) + 1  # blocks 1-6
+                block = BLOCKS[block_idx]
+            row.append(block)
+
+        # Mirror: build full row (left + center + right)
+        if size % 2 == 1:
+            full_row = row[:-1] + [row[-1]] + row[-2::-1]
+        else:
+            full_row = row + row[::-1]
+        rows.append("".join(full_row))
+
+    # Add border
+    width = len(rows[0]) if rows else 0
+    border_h = "─" * (width + 2)
+    lines = []
+    lines.append(f"  ┌{border_h}┐")
+    for row in rows:
+        lines.append(f"  │ {row} │")
+    lines.append(f"  └{border_h}┘")
+    lines.append(f"    ⟨ {agent_name} ⟩")
+
+    return "\n".join(lines)
+
+
+YELLOW = "\033[33m"
+STAR = "★"
+
+
+def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str,
+                   version: str = "", is_commander: bool = False) -> str:
+    """Render the full colored welcome banner for terminal display."""
+    h = _hash_bytes(agent_name)
+    color = COLORS[h[0] % len(COLORS)]
+
+    ver_str = f"v{version}" if version else ""
+    commander_badge = f" {YELLOW}{STAR} COMMANDER{RESET}" if is_commander else ""
+    lines = []
+    lines.append("")
+    lines.append(f"{color}{BOLD}  ╔══════════════════════════════════════════╗{RESET}")
+    lines.append(f"{color}{BOLD}  ║{RESET}  {DIM}M E S H C O D E{RESET}   {color}{ver_str}{RESET}          {color}{BOLD}║{RESET}")
+    lines.append(f"{color}{BOLD}  ╚══════════════════════════════════════════╝{RESET}")
+    lines.append("")
+
+    for line in ascii_art.split("\n"):
+        lines.append(f"  {color}{line}{RESET}")
+
+    lines.append("")
+    lines.append(f"  {BOLD}{color}●{RESET} {BOLD}{agent_name}{RESET}{commander_badge} {DIM}is online{RESET}")
+    lines.append(f"  {DIM}meshwork:{RESET} {meshwork_name}")
+    if version:
+        lines.append(f"  {DIM}version:{RESET}  {version}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    # Demo: show a few agents
+    import sys
+    names = sys.argv[1:] or ["sammy", "ian", "fis", "backend", "security", "commander"]
+    for name in names:
+        art = generate_art(name)
+        print(render_welcome(name, "demo-mesh", art, "2.8.6"))
+        print()

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode/comms_v4.py

@@ -1484,6 +1484,20 @@ def connect_terminal(project, name, role=""):
     session_data = {"project": project, "agent": name, "pid": ppid, "tty": tty, "registered_at": now()}
     (SESSIONS_DIR / f"{project}_{name}").write_text(json.dumps(session_data), encoding="utf-8")
 
+    # Track install/connection for admin metrics (fire-and-forget)
+    try:
+        import platform as _platform
+        sb_rpc("mc_track_install", {
+            "p_api_key": _api_key,
+            "p_project_id": project_id,
+            "p_agent_name": name,
+            "p_cli_version": VERSION,
+            "p_platform": sys.platform,
+            "p_editor": os.environ.get("MESHCODE_EDITOR", "unknown"),
+        })
+    except Exception:
+        pass  # Non-critical — don't block agent boot
+
     hb_pid = _start_heartbeat_daemon(project, name)
 
     pending = (rpc_result or {}).get("pending_messages", 0)

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode/meshcode_mcp/server.py

@@ -12,11 +12,41 @@ import json
 import logging
 import os
 import sys
+import hashlib as _hashlib
 from collections import deque
 from contextlib import asynccontextmanager
 from typing import Any, Dict, List, Optional, Union
 
 
+# ── Agent color for terminal logs (pure ANSI, zero tokens) ──────
+_ANSI_COLORS = [
+    "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
+    "\033[91m", "\033[96m", "\033[95m", "\033[92m", "\033[94m",
+]
+_ANSI_RESET = "\033[0m"
+_ANSI_BOLD = "\033[1m"
+_ANSI_DIM = "\033[2m"
+
+
+def _agent_color(name: str) -> str:
+    """Deterministic ANSI color from agent name hash."""
+    h = int(_hashlib.md5(name.encode()).hexdigest()[:8], 16)
+    return _ANSI_COLORS[h % len(_ANSI_COLORS)]
+
+
+def _mc_log(msg: str, level: str = "info") -> None:
+    """Colored [meshcode-mcp] log line. Uses agent color if available."""
+    agent = os.environ.get("MESHCODE_AGENT", "")
+    c = _agent_color(agent) if agent else "\033[36m"
+    prefix = f"{c}{_ANSI_BOLD}[meshcode-mcp]{_ANSI_RESET}"
+    if level == "error":
+        print(f"{prefix} \033[91mERROR:{_ANSI_RESET} {msg}", "warn")
+    elif level == "warn":
+        print(f"{prefix} \033[33mWARNING:{_ANSI_RESET} {msg}", "warn")
+    else:
+        print(f"{prefix} {c}{msg}{_ANSI_RESET}", "warn")
+
+
 # ============================================================
 # Dedupe: track IDs of messages we've already returned from
 # meshcode_wait / meshcode_check so the same row doesn't show
@@ -309,7 +339,7 @@ def _get_api_key() -> str:
                 _API_KEY_CACHE = kc_val
                 return kc_val
         except Exception as e:
-            print(f"[meshcode-mcp] WARNING: keychain lookup failed for profile '{profile}': {e}", file=sys.stderr)
+            _mc_log(f" keychain lookup failed for profile '{profile}': {e}", "warn")
     _API_KEY_CACHE = ""
     return ""
 
@@ -330,13 +360,13 @@ if not _PROJECT_ID:
             if isinstance(_r, dict) and _r.get("project_id"):
                 _PROJECT_ID = _r["project_id"]
             elif isinstance(_r, dict) and _r.get("error"):
-                print(f"[meshcode-mcp] WARNING: mc_resolve_project: {_r['error']}", file=sys.stderr)
+                _mc_log(f" mc_resolve_project: {_r['error']}", "warn")
         except Exception as _e:
-            print(f"[meshcode-mcp] WARNING: mc_resolve_project failed: {_e}", file=sys.stderr)
+            _mc_log(f" mc_resolve_project failed: {_e}", "warn")
 if not _PROJECT_ID:
     _PROJECT_ID = be.get_project_id(PROJECT_NAME)
 if not _PROJECT_ID:
-    print(f"[meshcode-mcp] ERROR: project '{PROJECT_NAME}' not found (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", file=sys.stderr)
+    _mc_log(f"project '{PROJECT_NAME}' not found (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", "error")
     sys.exit(2)
 
 # Resolve project plan for adaptive features (heartbeat interval, etc.)
@@ -350,7 +380,7 @@ except Exception:
 
 _register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MCP-connected agent", api_key=_get_api_key())
 if isinstance(_register_result, dict) and _register_result.get("error"):
-    print(f"[meshcode-mcp] WARNING: register failed: {_register_result['error']}", file=sys.stderr)
+    _mc_log(f" register failed: {_register_result['error']}", "warn")
 
 # Flip to online so the dashboard reflects the live MCP session.
 # Use the SECURITY DEFINER RPC (mc_agent_set_status_by_api_key) so we
@@ -368,7 +398,7 @@ def _flip_status(status: str, task: str = "") -> bool:
         return False
 
 if not _flip_status("idle", ""):
-    print(f"[meshcode-mcp] WARNING: could not flip status to idle", file=sys.stderr)
+    _mc_log(f" could not flip status to idle", "warn")
 
 
 # ============================================================
@@ -530,7 +560,7 @@ def _acquire_lease() -> bool:
         })
     except Exception as e:
         # Non-fatal: RPC might not exist on older servers.
-        print(f"[meshcode-mcp] stale-lease pre-clean skipped: {e}", file=sys.stderr)
+        _mc_log(f"stale-lease pre-clean skipped: {e}", "warn")
     for attempt in range(3):
         try:
             r = be.sb_rpc("mc_acquire_agent_lease", {
@@ -547,11 +577,11 @@ def _acquire_lease() -> bool:
                     if attempt < 2:
                         # The old lease might be stale — wait and retry
                         # (the 90s stale check in the RPC should clear it)
-                        print(f"[meshcode-mcp] Lease held by another instance — retrying in {2 * (attempt+1)}s...", file=sys.stderr)
+                        _mc_log(f"Lease held by another instance — retrying in {2 * (attempt+1)}s...")
                         _time.sleep(2 * (attempt + 1))
                         continue
                     # Final attempt — force release the old lease and try once more
-                    print(f"[meshcode-mcp] Force-releasing stale lease...", file=sys.stderr)
+                    _mc_log("Force-releasing stale lease...")
                     try:
                         be.sb_rpc("mc_release_agent_lease", {
                             "p_api_key": api_key,
@@ -575,21 +605,21 @@ def _acquire_lease() -> bool:
                             "p_instance_id": _INSTANCE_ID,
                         })
                         if isinstance(r2, dict) and r2.get("ok"):
-                            print(f"[meshcode-mcp] Lease acquired after force-release.", file=sys.stderr)
+                            _mc_log("Lease acquired after force-release.")
                             return True
                     except Exception:
                         pass
-                    print(f"[meshcode-mcp] ERROR: Could not start — agent '{AGENT_NAME}' is running in another window.", file=sys.stderr)
-                    print(f"[meshcode-mcp] Close the other window first, or use a different agent name.", file=sys.stderr)
+                    _mc_log(f"Could not start — agent '{AGENT_NAME}' is running in another window.", "error")
+                    _mc_log("Close the other window first, or use a different agent name.", "error")
                     return False
-                print(f"[meshcode-mcp] lease attempt {attempt+1}: {r.get('error')}", file=sys.stderr)
+                _mc_log(f"lease attempt {attempt+1}: {r.get('error')}", "warn")
             else:
                 return True
         except Exception as e:
-            print(f"[meshcode-mcp] lease attempt {attempt+1} failed: {e}", file=sys.stderr)
+            _mc_log(f"lease attempt {attempt+1} failed: {e}", "warn")
         if attempt < 2:
             _time.sleep(2)
-    print(f"[meshcode-mcp] WARNING: lease failed after 3 attempts — proceeding anyway", file=sys.stderr)
+    _mc_log(f" lease failed after 3 attempts — proceeding anyway", "warn")
     return True
 
 if not _acquire_lease():
@@ -607,7 +637,7 @@ def _boot_diagnostic() -> None:
         be.sb_select("mc_projects", f"id=eq.{_PROJECT_ID}", limit=1)
         checks_passed += 1
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", file=sys.stderr)
+        print(f"[meshcode] BOOT CHECK FAILED: Supabase API unreachable ({e}). Fix: check network/VPN.", "warn")
 
     # Check 2: Lease valid
     try:
@@ -617,11 +647,11 @@ def _boot_diagnostic() -> None:
             if agent.get("instance_id") == _INSTANCE_ID:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", file=sys.stderr)
+                print(f"[meshcode] BOOT CHECK FAILED: Lease mismatch — expected {_INSTANCE_ID}, got {agent.get('instance_id')}. Fix: restart agent.", "warn")
         else:
-            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", file=sys.stderr)
+            print(f"[meshcode] BOOT CHECK FAILED: Agent '{AGENT_NAME}' not found in project. Fix: register agent first.", "warn")
     except Exception as e:
-        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", file=sys.stderr)
+        print(f"[meshcode] BOOT CHECK FAILED: Could not verify lease ({e}).", "warn")
 
     # Check 3: Heartbeat recent
     try:
@@ -630,7 +660,7 @@ def _boot_diagnostic() -> None:
             if hb:
                 checks_passed += 1
             else:
-                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", file=sys.stderr)
+                print(f"[meshcode] BOOT CHECK WARNING: No heartbeat recorded yet.", "warn")
         else:
             checks_passed += 1  # skip if no agent data
     except Exception:
@@ -647,9 +677,9 @@ def _boot_diagnostic() -> None:
         checks_passed += 1  # non-critical
 
     if checks_passed == checks_total:
-        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", file=sys.stderr)
+        print(f"[meshcode] All boot checks passed ({checks_passed}/{checks_total}).", "warn")
     else:
-        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", file=sys.stderr)
+        print(f"[meshcode] Boot checks: {checks_passed}/{checks_total} passed. Agent starting anyway.", "warn")
 
 
 _boot_diagnostic()
@@ -1291,9 +1321,9 @@ try:
         elif isinstance(_ls_val, str):
             _LAST_SEEN_TS = _ls_val
         if _LAST_SEEN_TS:
-            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", file=sys.stderr)
+            print(f"[meshcode] Restored last_seen={_LAST_SEEN_TS} from mesh memory.", "warn")
 except Exception as _e:
-    print(f"[meshcode] Could not restore last_seen: {_e}", file=sys.stderr)
+    print(f"[meshcode] Could not restore last_seen: {_e}", "warn")
 
 
 def _get_pending_tasks_summary() -> Optional[List[Dict[str, str]]]:
@@ -2406,7 +2436,7 @@ def _auto_update() -> None:
         return
 
     # 3. Install the new version (blocking, 60s timeout)
-    print(f"[meshcode] Updating {current} → {latest}...", file=sys.stderr)
+    print(f"[meshcode] Updating {current} → {latest}...", "warn")
     try:
         result = subprocess.run(
             [sys.executable, "-m", "pip", "install", "--upgrade",
@@ -2424,7 +2454,7 @@ def _auto_update() -> None:
         return
 
     # 4. Re-exec to load the new code
-    print(f"[meshcode] Updated to {latest}, restarting...", file=sys.stderr)
+    print(f"[meshcode] Updated to {latest}, restarting...", "warn")
     os.environ["MESHCODE_UPDATED"] = "1"
     try:
         os.execv(sys.executable, [sys.executable] + sys.argv)

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode/run_agent.py

@@ -32,6 +32,76 @@ WORKSPACES_ROOT = Path.home() / "meshcode"
 REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
 
 
+def _fetch_or_generate_art(agent: str, project: str) -> str:
+    """Fetch ASCII art from server. If not stored yet, generate and save it."""
+    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)
+
+    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)
+
+    sb = _load_supabase_env()
+    try:
+        from urllib.request import Request, urlopen
+        import urllib.parse
+        # Step 1: resolve project_id
+        proj_req = Request(
+            f"{sb['SUPABASE_URL']}/rest/v1/mc_projects?select=id&name=eq.{urllib.parse.quote(project)}",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Accept-Profile": "meshcode",
+            },
+        )
+        with urlopen(proj_req, timeout=5) as resp:
+            proj_data = json.loads(resp.read().decode())
+        if not proj_data:
+            return generate_art(agent)
+        project_id = proj_data[0]["id"]
+        # Step 2: fetch existing art
+        req = Request(
+            f"{sb['SUPABASE_URL']}/rest/v1/mc_agents?select=ascii_art&name=eq.{urllib.parse.quote(agent)}&project_id=eq.{project_id}",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Accept-Profile": "meshcode",
+            },
+        )
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode())
+        if data and data[0].get("ascii_art"):
+            return data[0]["ascii_art"]
+    except Exception:
+        pass
+
+    # Generate and store
+    art = generate_art(agent)
+    try:
+        body = json.dumps({"p_project_name": project, "p_agent_name": agent, "p_ascii_art": art})
+        req = Request(
+            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_store_agent_art",
+            data=body.encode(),
+            method="POST",
+            headers={
+                "apikey": sb["SUPABASE_KEY"],
+                "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                "Content-Type": "application/json",
+                "Content-Profile": "meshcode",
+            },
+        )
+        urlopen(req, timeout=5)
+    except Exception:
+        pass
+    return art
+
+
 def _check_agent_ownership(agent: str, project: str) -> Optional[str]:
     """Pre-flight check: verify caller owns this agent before launching editor.
 
@@ -266,6 +336,18 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
         print("[meshcode]        Or open the workspace manually with the editor of your choice.", file=sys.stderr)
         return 2
 
+    # ── Welcome banner with unique ASCII art ───────────────────────
+    try:
+        from .ascii_art import generate_art, render_welcome
+        from . import __version__ as cli_version
+        # Try to fetch stored art from server, generate if missing
+        ascii_art = _fetch_or_generate_art(agent, resolved_project)
+        # Check if this agent is the commander
+        is_cmd = "commander" in agent.lower()
+        print(render_welcome(agent, resolved_project, ascii_art, cli_version, is_commander=is_cmd))
+    except Exception:
+        pass  # Non-critical — skip banner on error
+
     print(f"[meshcode] Launching {editor} for agent '{agent}' (project: {resolved_project})")
     print(f"[meshcode]   Workspace: {ws}")
     print(f"[meshcode]   MCP server: {server_id}")

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.8.6 → meshcode-2.8.8}/meshcode.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 meshcode/__init__.py
+meshcode/ascii_art.py
 meshcode/cli.py
 meshcode/comms_v4.py
 meshcode/invites.py

{meshcode-2.8.6 → meshcode-2.8.8}/pyproject.toml

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