meshcode 2.9.2__tar.gz → 2.9.4__tar.gz

{meshcode-2.9.2 → meshcode-2.9.4}/PKG-INFO

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

{meshcode-2.9.2 → meshcode-2.9.4}/meshcode/__init__.py

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

{meshcode-2.9.2 → meshcode-2.9.4}/meshcode/ascii_art.py

@@ -153,9 +153,40 @@ COLORS = [
     "\033[36m", "\033[35m", "\033[32m", "\033[33m", "\033[34m",
     "\033[91m", "\033[96m", "\033[95m", "\033[92m", "\033[94m",
 ]
+# Same palette as hex RGB for nearest-match mapping from dashboard colors
+_ANSI_RGB = [
+    (0, 255, 255),    # 0: cyan       \033[36m
+    (255, 0, 255),    # 1: magenta    \033[35m
+    (0, 255, 0),      # 2: green      \033[32m
+    (255, 255, 0),    # 3: yellow     \033[33m
+    (0, 0, 255),      # 4: blue       \033[34m
+    (255, 85, 85),    # 5: bright red \033[91m
+    (85, 255, 255),   # 6: bright cyan \033[96m
+    (255, 85, 255),   # 7: bright mag \033[95m
+    (85, 255, 85),    # 8: bright grn \033[92m
+    (85, 85, 255),    # 9: bright blu \033[94m
+]
 RESET = "\033[0m"
 DIM = "\033[2m"
 BOLD = "\033[1m"
+
+
+def hex_to_ansi(hex_color: str) -> str:
+    """Map a hex color (e.g. '#F43F5E') to the nearest ANSI color code."""
+    hex_color = hex_color.strip().lstrip("#")
+    if len(hex_color) != 6:
+        return None
+    try:
+        r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
+    except ValueError:
+        return None
+    best_idx, best_dist = 0, float("inf")
+    for i, (ar, ag, ab) in enumerate(_ANSI_RGB):
+        dist = (r - ar) ** 2 + (g - ag) ** 2 + (b - ab) ** 2
+        if dist < best_dist:
+            best_dist = dist
+            best_idx = i
+    return COLORS[best_idx]
 YELLOW = "\033[33m"
 STAR = "★"
 
@@ -409,9 +440,15 @@ 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) -> str:
+                   role: str = "", stats: dict = None,
+                   profile_color: str = None) -> str:
     h = _hash_bytes(agent_name)
-    color = COLORS[h[0] % len(COLORS)]
+    # Use dashboard profile color if available, otherwise MD5 hash fallback
+    color = None
+    if profile_color:
+        color = hex_to_ansi(profile_color)
+    if not color:
+        color = COLORS[_hash_int(agent_name) % len(COLORS)]
 
     traits = get_personality_traits(agent_name, role, stats or {})
     catchphrase = get_catchphrase(agent_name, role)

{meshcode-2.9.2 → meshcode-2.9.4}/meshcode/meshcode_mcp/server.py

@@ -28,8 +28,35 @@ _ANSI_BOLD = "\033[1m"
 _ANSI_DIM = "\033[2m"
 
 
+_CACHED_AGENT_COLOR = None  # Set once on boot from profile color
+_ANSI_RGB = [
+    (0, 255, 255), (255, 0, 255), (0, 255, 0), (255, 255, 0), (0, 0, 255),
+    (255, 85, 85), (85, 255, 255), (255, 85, 255), (85, 255, 85), (85, 85, 255),
+]
+
+
+def _hex_to_ansi(hex_color: str) -> str:
+    """Map hex color to nearest ANSI code."""
+    hx = hex_color.strip().lstrip("#")
+    if len(hx) != 6:
+        return None
+    try:
+        r, g, b = int(hx[0:2], 16), int(hx[2:4], 16), int(hx[4:6], 16)
+    except ValueError:
+        return None
+    best_i, best_d = 0, float("inf")
+    for i, (ar, ag, ab) in enumerate(_ANSI_RGB):
+        d = (r - ar) ** 2 + (g - ag) ** 2 + (b - ab) ** 2
+        if d < best_d:
+            best_d = d
+            best_i = i
+    return _ANSI_COLORS[best_i]
+
+
 def _agent_color(name: str) -> str:
-    """Deterministic ANSI color from agent name hash."""
+    """ANSI color from profile (dashboard) or MD5 hash fallback."""
+    if _CACHED_AGENT_COLOR:
+        return _CACHED_AGENT_COLOR
     h = int(_hashlib.md5(name.encode()).hexdigest()[:8], 16)
     return _ANSI_COLORS[h % len(_ANSI_COLORS)]
 
@@ -384,6 +411,22 @@ _register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MC
 if isinstance(_register_result, dict) and _register_result.get("error"):
     _mc_log(f" register failed: {_register_result['error']}", "warn")
 
+# ── Fetch profile color from dashboard (single source of truth) ──
+try:
+    _agent_rows = be.sb_select("mc_agents", f"project_id=eq.{_PROJECT_ID}&name=eq.{AGENT_NAME}", limit=1)
+    if _agent_rows and isinstance(_agent_rows, list) and len(_agent_rows) > 0:
+        _aid = _agent_rows[0].get("id")
+        if _aid:
+            _prof_rows = be.sb_select("mc_agent_profiles", f"agent_id=eq.{_aid}", limit=1)
+            if _prof_rows and isinstance(_prof_rows, list) and len(_prof_rows) > 0:
+                _hex = _prof_rows[0].get("color") or ""
+                if _hex and len(_hex.lstrip("#")) == 6:
+                    _resolved = _hex_to_ansi(_hex)
+                    if _resolved:
+                        _CACHED_AGENT_COLOR = _resolved
+except Exception:
+    pass  # Non-critical — falls back to hash
+
 # 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
 # bypass RLS — the publishable key has no JWT context and cannot UPDATE

{meshcode-2.9.2 → meshcode-2.9.4}/meshcode/run_agent.py

@@ -33,42 +33,47 @@ REGISTRY_PATH = WORKSPACES_ROOT / ".registry.json"
 
 
 def _fetch_or_generate_art(agent: str, project: str) -> tuple:
-    """Fetch ASCII art + role from server. If not stored yet, generate and save.
-    Returns (ascii_art, role_description)."""
+    """Fetch ASCII art + role + profile color from server.
+    Returns (ascii_art, role_description, profile_color)."""
     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
+        return generate_art(agent), agent, 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, agent
+        return generate_art(agent), agent, None
 
     sb = _load_supabase_env()
+    profile_color = None
     try:
         from urllib.request import Request, urlopen
         import urllib.parse
-        # Step 1: resolve project_id
+        # Step 1: resolve project_id via RPC (bypasses RLS on mc_projects)
+        resolve_body = json.dumps({"p_api_key": api_key, "p_project_name": project})
         proj_req = Request(
-            f"{sb['SUPABASE_URL']}/rest/v1/mc_projects?select=id&name=eq.{urllib.parse.quote(project)}",
+            f"{sb['SUPABASE_URL']}/rest/v1/rpc/mc_resolve_project",
+            data=resolve_body.encode(),
+            method="POST",
             headers={
                 "apikey": sb["SUPABASE_KEY"],
                 "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
-                "Accept-Profile": "meshcode",
+                "Content-Type": "application/json",
+                "Content-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), agent
-        project_id = proj_data[0]["id"]
+        if not proj_data or not proj_data.get("project_id"):
+            return generate_art(agent), agent, None
+        project_id = proj_data["project_id"]
         # Step 2: fetch existing art + role
         req = Request(
-            f"{sb['SUPABASE_URL']}/rest/v1/mc_agents?select=ascii_art,role&name=eq.{urllib.parse.quote(agent)}&project_id=eq.{project_id}",
+            f"{sb['SUPABASE_URL']}/rest/v1/mc_agents?select=ascii_art,role,id&name=eq.{urllib.parse.quote(agent)}&project_id=eq.{project_id}",
             headers={
                 "apikey": sb["SUPABASE_KEY"],
                 "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
@@ -77,8 +82,27 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
         )
         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"], data[0].get("role") or agent
+        if data:
+            agent_id = data[0].get("id")
+            # Step 3: fetch profile color
+            if agent_id:
+                try:
+                    prof_req = Request(
+                        f"{sb['SUPABASE_URL']}/rest/v1/mc_agent_profiles?select=color&agent_id=eq.{agent_id}",
+                        headers={
+                            "apikey": sb["SUPABASE_KEY"],
+                            "Authorization": f"Bearer {sb['SUPABASE_KEY']}",
+                            "Accept-Profile": "meshcode",
+                        },
+                    )
+                    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"]
+                except Exception:
+                    pass
+            if data[0].get("ascii_art"):
+                return data[0]["ascii_art"], data[0].get("role") or agent, profile_color
     except Exception:
         pass
 
@@ -100,7 +124,7 @@ def _fetch_or_generate_art(agent: str, project: str) -> tuple:
         urlopen(req, timeout=5)
     except Exception:
         pass
-    return art, agent
+    return art, agent, profile_color
 
 
 def _fetch_agent_stats(agent: str, project: str) -> dict:
@@ -381,12 +405,13 @@ def run(agent: str, project: Optional[str] = None, editor_override: Optional[str
     try:
         from .ascii_art import generate_art, render_welcome
         from . import __version__ as cli_version
-        ascii_art, agent_role = _fetch_or_generate_art(agent, resolved_project)
+        ascii_art, agent_role, profile_color = _fetch_or_generate_art(agent, resolved_project)
         is_cmd = "commander" in agent.lower() or "commander" in agent_role.lower()
         agent_stats = _fetch_agent_stats(agent, resolved_project)
         print(render_welcome(
             agent, resolved_project, ascii_art, cli_version,
             is_commander=is_cmd, role=agent_role, stats=agent_stats,
+            profile_color=profile_color,
         ))
     except Exception:
         pass  # Non-critical — skip banner on error

{meshcode-2.9.2 → meshcode-2.9.4}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.9.2 → meshcode-2.9.4}/pyproject.toml

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