meshcode 2.8.5__tar.gz → 2.8.7__tar.gz

{meshcode-2.8.5 → meshcode-2.8.7}/PKG-INFO

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

{meshcode-2.8.5 → meshcode-2.8.7}/meshcode/__init__.py

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

meshcode-2.8.7/meshcode/ascii_art.py

@@ -0,0 +1,124 @@
+"""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)
+
+
+def render_welcome(agent_name: str, meshwork_name: str, ascii_art: str, version: str = "") -> 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 ""
+    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} {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.5 → meshcode-2.8.7}/meshcode/comms_v4.py

@@ -1392,9 +1392,20 @@ def _start_heartbeat_daemon(project, name):
         "        d=json.loads(urllib.request.urlopen(req,timeout=10).read())\n"
         "        return d[0]['id'] if d else None\n"
         "    except Exception: return None\n"
+        "def check_still_leased(pid):\n"
+        "    \"\"\"Return False if force-disconnected (instance_id cleared).\"\"\"\n"
+        "    try:\n"
+        "        req=urllib.request.Request(url+'/rest/v1/mc_agents?select=instance_id&project_id=eq.'+pid+'&name=eq.'+urllib.parse.quote(name),\n"
+        "            headers={'apikey':key,'Authorization':'Bearer '+key,'Accept-Profile':'meshcode'})\n"
+        "        d=json.loads(urllib.request.urlopen(req,timeout=10).read())\n"
+        "        return bool(d and d[0].get('instance_id'))\n"
+        "    except Exception: return True\n"
         "pid=get_pid_for_project()\n"
         "while True:\n"
-        "    if pid: post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
+        "    if pid:\n"
+        "        if not check_still_leased(pid):\n"
+        "            sys.exit(0)\n"
+        "        post('/rest/v1/rpc/mc_heartbeat', {'p_project_id':pid,'p_agent_name':name})\n"
         "    time.sleep(30)\n"
     )
     # Windows: start_new_session kwarg doesn't exist. Use creationflags.
@@ -1473,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.5 → meshcode-2.8.7}/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,16 @@ 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)
+        print(render_welcome(agent, resolved_project, ascii_art, cli_version))
+    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.5 → meshcode-2.8.7}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.8.5 → meshcode-2.8.7}/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.5 → meshcode-2.8.7}/pyproject.toml

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