meshcode 2.10.55__tar.gz → 2.10.57__tar.gz

{meshcode-2.10.55 → meshcode-2.10.57}/PKG-INFO

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

meshcode-2.10.57/meshcode/__init__.py

@@ -0,0 +1,82 @@
+"""MeshCode — Real-time communication between AI agents."""
+__version__ = "2.10.57"
+
+# Exception hierarchy — eagerly imported (lightweight, no deps)
+from meshcode.exceptions import (  # noqa: F401
+    MeshCodeError,
+    AuthError,
+    RPCError,
+    MeshCodeTimeoutError,
+    MeshCodeConnectionError,
+)
+
+# Public API — lazy imports to avoid heavy deps at import time
+def __getattr__(name):
+    if name == "backend":
+        from meshcode.meshcode_mcp import backend
+        return backend
+    if name in _BACKEND_EXPORTS:
+        from meshcode.meshcode_mcp import backend
+        return getattr(backend, name)
+    if name in _SECRETS_EXPORTS:
+        from meshcode import secrets
+        return getattr(secrets, name)
+    raise AttributeError(f"module 'meshcode' has no attribute {name!r}")
+
+
+# Backend: core messaging & agent management
+_BACKEND_EXPORTS = {
+    "send_message",
+    "read_inbox",
+    "count_pending",
+    "get_board",
+    "heartbeat",
+    "set_status",
+    "register_agent",
+    "get_project_id",
+    "sb_rpc",
+    "task_create",
+    "task_list",
+    "encrypt_payload",
+    "decrypt_payload",
+}
+
+# Secrets: credential management
+_SECRETS_EXPORTS = {
+    "get_api_key",
+    "set_api_key",
+    "list_profiles",
+}
+
+__all__ = [
+    "__version__",
+    "backend",
+    # Exceptions
+    "MeshCodeError",
+    "AuthError",
+    "RPCError",
+    "MeshCodeTimeoutError",
+    "MeshCodeConnectionError",
+    # Messaging
+    "send_message",
+    "read_inbox",
+    "count_pending",
+    # Agent management
+    "register_agent",
+    "get_project_id",
+    "get_board",
+    "heartbeat",
+    "set_status",
+    # Tasks
+    "task_create",
+    "task_list",
+    # Low-level
+    "sb_rpc",
+    # Encryption
+    "encrypt_payload",
+    "decrypt_payload",
+    # Credentials
+    "get_api_key",
+    "set_api_key",
+    "list_profiles",
+]

{meshcode-2.10.55 → meshcode-2.10.57}/meshcode/comms_v4.py

@@ -166,7 +166,13 @@ def sb_delete(table, filters):
 
 
 def sb_rpc(fn_name, params):
-    """Call a Supabase RPC function."""
+    """Call a Supabase RPC function.
+
+    Returns the parsed JSON response on success, or None on network/HTTP error.
+    HTTP errors are logged and printed to stderr for observability.
+    RPC-level errors (e.g. {"error": "..."}) are returned as-is — callers
+    must check for result.get("error") themselves.
+    """
     url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
     body = json.dumps(params).encode()
     req = Request(url, data=body, method="POST", headers=_headers(content_profile=False))
@@ -174,8 +180,20 @@ def sb_rpc(fn_name, params):
         with urlopen(req, timeout=10) as resp:
             raw = resp.read().decode()
             return json.loads(raw) if raw.strip() else None
-    except (HTTPError, URLError) as e:
-        log_error(f"rpc:{fn_name}", str(e), json.dumps(params, default=str)[:200])
+    except HTTPError as e:
+        err_body = ""
+        try:
+            err_body = e.read().decode()
+            err_obj = json.loads(err_body)
+            msg = err_obj.get("message", err_body[:200])
+        except Exception:
+            msg = err_body[:200] if err_body else str(e)
+        print(f"[ERROR] rpc:{fn_name}: {e.code} {msg}", file=sys.stderr)
+        log_error(f"rpc:{fn_name}", f"{e.code} {msg}", json.dumps(params, default=str)[:200])
+        return None
+    except URLError as e:
+        print(f"[ERROR] rpc:{fn_name}: network error: {e.reason}", file=sys.stderr)
+        log_error(f"rpc:{fn_name}", f"network: {e.reason}", json.dumps(params, default=str)[:200])
         return None
 
 
@@ -1376,7 +1394,7 @@ def watch(project, name, interval=10, timeout=0):
                 print(f"\n*** [{project.upper()}] MENSAJE RECIBIDO ({elapsed}s en standby) ***")
                 read_messages(project, name, silent=False, send_acks=False)
 
-                _update_agent_status({"status": "working", "task": "Procesando mensaje recibido", "last_heartbeat": now_iso()})
+                _update_agent_status({"status": "working", "task": "Processing received message", "last_heartbeat": now_iso()})
 
                 # Reset to standby and keep polling (don't exit the loop)
                 time.sleep(2)
@@ -1430,7 +1448,7 @@ def show_board(project):
     project_id = get_project_id(project)
     if not project_id:
         print(f"[{project}] Project not found")
-        return
+        sys.exit(1)
 
     _ak = _load_api_key_for_cli()
     agents = None
@@ -1442,7 +1460,7 @@ def show_board(project):
     if agents is None:
         agents = sb_select("mc_agents", f"project_id=eq.{project_id}", order="registered_at.asc")
     if not agents:
-        print(f"[{project}] Sin agentes")
+        print(f"[{project}] No agents found")
         return
 
     print(f"\n{'='*60}")
@@ -1502,8 +1520,8 @@ def show_status(project=None):
 def show_history(project, last_n=20, between=None):
     project_id = get_project_id(project)
     if not project_id:
-        print(f"[{project}] Sin historial")
-        return
+        print(f"[{project}] No history")
+        sys.exit(1)
 
     filters = f"project_id=eq.{project_id}&type=neq.ack"
     if between:
@@ -1515,7 +1533,7 @@ def show_history(project, last_n=20, between=None):
 
     messages = sb_select("mc_messages", filters, order="created_at.desc", limit=last_n)
     if not messages:
-        print(f"[{project}] Sin historial")
+        print(f"[{project}] No history")
         return
 
     messages.reverse()
@@ -1523,7 +1541,7 @@ def show_history(project, last_n=20, between=None):
     print(f"\n{'='*60}")
     print(f" {project.upper()} — History ({len(messages)} messages)")
     if between:
-        print(f" Filtro: {between}")
+        print(f" Filter: {between}")
     print(f"{'='*60}\n")
 
     for msg in messages:
@@ -1917,6 +1935,222 @@ def connect(project, name, hook_target="claude", role=""):
     print()
 
 
+def cmd_doctor(flags, pos):
+    """Diagnose common meshcode setup issues."""
+    import subprocess as _sp
+    import shutil
+
+    auto_fix = "--fix" in sys.argv or flags.get("fix")
+    results = []  # (status, label, detail)  status: ok/warn/fail
+
+    def ok(label, detail=""):
+        results.append(("ok", label, detail))
+
+    def warn(label, detail=""):
+        results.append(("warn", label, detail))
+
+    def fail(label, detail=""):
+        results.append(("fail", label, detail))
+
+    # 1. Python version
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    if sys.version_info >= (3, 9):
+        ok("Python version", py_ver)
+    elif sys.version_info >= (3, 7):
+        warn("Python version", f"{py_ver} (3.9+ recommended)")
+    else:
+        fail("Python version", f"{py_ver} (3.9+ required)")
+
+    # 2. meshcode version vs latest PyPI
+    try:
+        from meshcode import __version__ as mc_ver
+    except Exception:
+        mc_ver = "unknown"
+    latest = None
+    try:
+        req = Request("https://pypi.org/pypi/meshcode/json", method="GET")
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode())
+            latest = data.get("info", {}).get("version")
+    except Exception:
+        pass
+    if latest and mc_ver != "unknown":
+        if mc_ver == latest:
+            ok("meshcode version", f"{mc_ver} (latest)")
+        else:
+            warn("meshcode version", f"{mc_ver} (latest: {latest}). Run: pip install --upgrade meshcode")
+    elif mc_ver != "unknown":
+        ok("meshcode version", f"{mc_ver} (could not check PyPI)")
+    else:
+        fail("meshcode version", "could not determine version")
+
+    # 3. Config directory
+    config_dir = Path.home() / ".meshcode"
+    if config_dir.exists():
+        api_key_file = config_dir / "api_key"
+        profile_meta = config_dir / "profile_meta.json"
+        has_key = bool(_load_api_key_for_cli())
+        if has_key:
+            ok("Authentication", "API key found in keychain")
+        elif api_key_file.exists():
+            warn("Authentication", "Legacy api_key file found. Run: meshcode login <key>")
+        else:
+            fail("Authentication", "Not logged in. Run: meshcode login <api_key>")
+        if profile_meta.exists():
+            try:
+                meta = json.loads(profile_meta.read_text(encoding="utf-8"))
+                email = meta.get("email", "unknown")
+                ok("Profile", f"logged in as {email}")
+            except Exception:
+                warn("Profile", "profile_meta.json exists but unreadable")
+        else:
+            warn("Profile", "no profile_meta.json (run meshcode login)")
+    else:
+        fail("Config directory", "~/.meshcode/ does not exist. Run: meshcode login <api_key>")
+
+    # 4. Supabase connectivity (use a lightweight RPC that always exists)
+    try:
+        # Ping via a simple select on a known table with limit=0
+        test_url = f"{SUPABASE_URL}/rest/v1/mc_projects?limit=0"
+        req = Request(test_url, method="GET", headers=_headers())
+        with urlopen(req, timeout=8) as resp:
+            ok("Supabase API", "reachable")
+    except HTTPError as e:
+        if e.code in (401, 403):
+            # Auth error means the API IS reachable, just RLS blocks it
+            ok("Supabase API", "reachable (auth required for data)")
+        else:
+            fail("Supabase API", f"HTTP {e.code}")
+    except Exception as e:
+        fail("Supabase API", f"unreachable: {e}")
+
+    # 5. Stale agents check (requires auth)
+    api_key = _load_api_key_for_cli()
+    if api_key:
+        try:
+            r = sb_rpc("mc_resolve_project", {"p_api_key": api_key, "p_project_name": "*"})
+            # Try listing all projects for this user
+            projects_data = sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+            if isinstance(projects_data, list):
+                stale_agents = []  # (project_id, agent_name)
+                for proj in projects_data[:5]:
+                    pid = proj.get("id") or proj.get("project_id")
+                    if not pid:
+                        continue
+                    agents = sb_select("mc_agents", f"project_id=eq.{pid}")
+                    if isinstance(agents, list):
+                        for a in agents:
+                            hb = a.get("last_heartbeat", "")
+                            status = a.get("status", "offline")
+                            if status not in ("offline", "needs_setup") and hb:
+                                try:
+                                    from datetime import datetime, timezone
+                                    hb_dt = datetime.fromisoformat(hb.replace("Z", "+00:00"))
+                                    age = (datetime.now(timezone.utc) - hb_dt).total_seconds()
+                                    if age > 180:
+                                        stale_agents.append((pid, a.get("name", "?")))
+                                except Exception:
+                                    pass
+                if stale_agents:
+                    names = ", ".join(n for _, n in stale_agents[:5])
+                    warn("Stale agents", f"{len(stale_agents)} stale: {names}")
+                    if auto_fix:
+                        fixed = 0
+                        for pid, aname in stale_agents:
+                            try:
+                                sb_rpc("mc_disconnect_agent", {
+                                    "p_project_id": pid, "p_agent_name": aname,
+                                })
+                                fixed += 1
+                            except Exception:
+                                pass
+                        if fixed:
+                            ok("Stale agent fix", f"forced {fixed} agent(s) offline")
+                else:
+                    ok("Stale agents", "none detected")
+            else:
+                warn("Stale agents", "could not list projects (RPC not available)")
+        except Exception as e:
+            warn("Stale agents", f"check failed: {e}")
+    else:
+        warn("Stale agents", "skipped (not logged in)")
+
+    # 6. MCP server processes
+    try:
+        out = _sp.run(["ps", "-eo", "pid,ppid,comm"], capture_output=True, text=True, timeout=5)
+        mcp_procs = [l for l in out.stdout.splitlines() if "meshcode_mcp" in l]
+        orphans = [l for l in mcp_procs if l.split()[1].strip() == "1"]
+        if not mcp_procs:
+            ok("MCP processes", "none running (normal if no agents active)")
+        elif len(orphans) > 3:
+            warn("MCP processes", f"{len(mcp_procs)} running, {len(orphans)} orphaned (PPID=1)")
+            if auto_fix:
+                for line in orphans:
+                    pid = line.split()[0].strip()
+                    try:
+                        os.kill(int(pid), 15)  # SIGTERM
+                    except Exception:
+                        pass
+                ok("MCP cleanup", f"sent SIGTERM to {len(orphans)} orphan processes")
+        else:
+            ok("MCP processes", f"{len(mcp_procs)} running")
+    except Exception:
+        warn("MCP processes", "could not check (ps failed)")
+
+    # 7. Claude Code version
+    claude_bin = shutil.which("claude")
+    if claude_bin:
+        try:
+            out = _sp.run([claude_bin, "--version"], capture_output=True, text=True, timeout=5)
+            cc_ver = out.stdout.strip()
+            # Check for known-bad versions
+            blocked = ["2.1.111", "2.1.112", "2.1.113", "2.1.114", "2.1.115",
+                        "2.1.116", "2.1.117", "2.1.118", "2.1.119"]
+            ver_num = cc_ver.split()[-1].strip("()") if cc_ver else ""
+            if any(b in cc_ver for b in blocked):
+                fail("Claude Code", f"{cc_ver} (KNOWN MCP REGRESSION). Pin to 2.1.104: npm i -g @anthropic-ai/claude-code@2.1.104")
+            else:
+                ok("Claude Code", cc_ver)
+            # Check for dual install
+            try:
+                out2 = _sp.run(["type", "-a", "claude"], capture_output=True, text=True,
+                               timeout=5, shell=True)
+                installs = [l for l in out2.stdout.strip().splitlines() if "claude" in l]
+                if len(installs) > 1:
+                    warn("Claude Code installs", f"DUAL INSTALL: {'; '.join(installs)}. Active: {claude_bin}")
+            except Exception:
+                pass
+        except Exception as e:
+            warn("Claude Code", f"found at {claude_bin} but version check failed: {e}")
+    else:
+        warn("Claude Code", "not found in PATH")
+
+    # Print results
+    print()
+    print("  meshcode doctor")
+    print("  " + "=" * 40)
+    ok_count = sum(1 for s, _, _ in results if s == "ok")
+    warn_count = sum(1 for s, _, _ in results if s == "warn")
+    fail_count = sum(1 for s, _, _ in results if s == "fail")
+    for status, label, detail in results:
+        icon = {"ok": "+", "warn": "!", "fail": "x"}[status]
+        detail_str = f" -- {detail}" if detail else ""
+        print(f"  [{icon}] {label}{detail_str}")
+    print()
+    summary_parts = []
+    if ok_count:
+        summary_parts.append(f"{ok_count} passed")
+    if warn_count:
+        summary_parts.append(f"{warn_count} warnings")
+    if fail_count:
+        summary_parts.append(f"{fail_count} failed")
+    print(f"  {', '.join(summary_parts)}")
+    if warn_count or fail_count:
+        print("  Run with --fix to auto-repair where possible.")
+    print()
+    sys.exit(1 if fail_count else 0)
+
+
 def login(api_key):
     """Authenticate with API key and save it to the OS keychain.
 
@@ -1983,6 +2217,7 @@ def show_help():
 ╚═══════════════════════════════════════════════════════════╝
 
 QUICK START:
+  init                                       Guided setup (opens browser + login)
   login <api_key>                            Authenticate (get key at meshcode.io)
   go <agent> [--project <name>]              Connect agent in one command
 
@@ -2022,6 +2257,10 @@ AGENT CONTROL:
   profile [agent]                            Show/set agent profile
   connect <proj> <name>                      Connect existing agent
 
+DIAGNOSTICS:
+  doctor [--fix]                             Diagnose setup issues
+  compat                                     Claude Code version compatibility
+
 ADMIN:
   clear <proj> <name>                        Clear inbox
   unregister <proj> <name>                   Leave project
@@ -2043,6 +2282,26 @@ Run `meshcode <command> --help` for help on a specific command.
 
 # Per-subcommand help texts
 SUBCOMMAND_HELP = {
+    "init": """meshcode init
+
+Guided first-time setup. Opens meshcode.io in your browser to create
+an account, then prompts you to paste your API key.
+
+After init, run:
+  meshcode go <agent-name> --project <meshwork-name>
+""",
+    "doctor": """meshcode doctor [--fix]
+
+Diagnose common setup issues: Python version, meshcode version, auth,
+Supabase connectivity, stale agents, MCP processes, Claude Code version.
+
+OPTIONS:
+  --fix    Auto-repair where possible (kill orphan MCP processes, etc.)
+
+EXAMPLES:
+  meshcode doctor          # diagnose only
+  meshcode doctor --fix    # diagnose + auto-fix
+""",
     "register": """meshcode register <project> <name> [role]
 
 Join a meshwork as a new agent. Tier limits enforced (free=3 agents).
@@ -2148,8 +2407,8 @@ EXAMPLES:
     "login": """meshcode login <api_key>
 
 Authenticate with a MeshCode API key. Saves credentials to
-~/.meshcode/credentials.json. Get a key from meshcode.io/settings or
-during the welcome wizard after signup.
+your OS keychain (macOS Keychain, Linux libsecret, Windows Credential
+Manager). Get a key from meshcode.io/settings or during signup.
 """,
     "clear": """meshcode clear <project> <name>
 
@@ -2329,6 +2588,53 @@ if __name__ == "__main__":
         except Exception:
             pass
 
+    if cmd == "init":
+        # Guided onboarding: open signup page + prompt for API key
+        import webbrowser
+        print()
+        print("  Welcome to MeshCode!")
+        print("  " + "=" * 40)
+        print()
+        print("  Step 1: Create your account")
+        print("  Opening meshcode.io in your browser...")
+        print()
+        try:
+            webbrowser.open("https://meshcode.io")
+        except Exception:
+            print("  Could not open browser. Visit: https://meshcode.io")
+        print("  Step 2: Copy your API key from Settings")
+        print()
+        try:
+            api_key = input("  Paste your API key (mc_...): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            api_key = ""
+            print()
+        if api_key:
+            login(api_key)
+            print()
+            print("  Step 3: Create your first meshwork")
+            print("  Run: meshcode go <agent-name> --project <meshwork-name>")
+            print()
+            print("  Example:")
+            print("    meshcode go backend --project my-app")
+            print()
+        else:
+            print("  [meshcode] No API key provided. Run: meshcode login <api_key>")
+            sys.exit(1)
+        sys.exit(0)
+
+    # Auth guard: commands that talk to Supabase need a valid API key.
+    # doctor, help, version, login, prefs, launcher don't need auth.
+    _NO_AUTH_CMDS = {"doctor", "compat", "help", "--help", "-h", "login", "init",
+                     "prefs", "launcher", "--version", "-V", "version", "whoami",
+                     "profiles", "scan"}
+    if cmd not in _NO_AUTH_CMDS:
+        _cli_key = _load_api_key_for_cli()
+        if not _cli_key:
+            print("[meshcode] Not logged in. Run: meshcode login <api_key>")
+            print("[meshcode] Get your API key at: https://meshcode.io/settings")
+            sys.exit(1)
+
     if cmd == "register":
         # Backwards-compat alias for `connect`. Mesh-only model: bind THIS
         # terminal to (project, agent) — never spawns claude.
@@ -2447,7 +2753,7 @@ if __name__ == "__main__":
     elif cmd == "validate-sessions":
         proj = pos[0] if len(pos) > 0 else (sys.argv[2] if len(sys.argv) > 2 else "")
         if not proj:
-            print("[meshcode] ERROR: Uso: meshcode validate-sessions <project>")
+            print("[ERROR] Usage: meshcode validate-sessions <project>")
             sys.exit(1)
         ensure_sessions()
         prefix = f"{proj}_"
@@ -2473,7 +2779,7 @@ if __name__ == "__main__":
         proj = pos[0] if len(pos) > 0 else ""
         name = pos[1] if len(pos) > 1 else ""
         if not proj or not name:
-            print("[meshcode] ERROR: Uso: meshcode wake-headless <project> <agent>")
+            print("[ERROR] Usage: meshcode wake-headless <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2489,7 +2795,7 @@ if __name__ == "__main__":
         proj = pos[0] if len(pos) > 0 else "default"
         name = pos[1] if len(pos) > 1 else ""
         if not name:
-            print(f"[meshcode] ERROR: Uso: meshcode {cmd} <project> <agent>")
+            print(f"[ERROR] Usage: meshcode {cmd} <project> <agent>")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2508,7 +2814,7 @@ if __name__ == "__main__":
         proj = pos[1] if len(pos) > 1 else "default"
         name = pos[2] if len(pos) > 2 else ""
         if not name:
-            print("[meshcode] ERROR: Uso: meshcode profile get|set <project> <agent> [flags]")
+            print("[ERROR] Usage: meshcode profile get|set <project> <agent> [flags]")
             sys.exit(1)
         project_id = get_project_id(proj)
         if not project_id:
@@ -2533,7 +2839,7 @@ if __name__ == "__main__":
                 sys.exit(1)
             print(f"[{proj}] profile updated for {name}")
         else:
-            print(f"[meshcode] ERROR: subcomando desconocido: {sub}. Usa 'get' o 'set'.")
+            print(f"[ERROR] Unknown subcommand: {sub}. Use 'get' or 'set'.")
             sys.exit(1)
 
     elif cmd == "connect":
@@ -2721,7 +3027,7 @@ if __name__ == "__main__":
     elif cmd == "login":
         key = sys.argv[2] if len(sys.argv) > 2 else ""
         if not key:
-            print("[meshcode] ERROR: Uso: meshcode login <api_key>")
+            print("[ERROR] Usage: meshcode login <api_key>")
             sys.exit(1)
         login(key)
 
@@ -2886,6 +3192,19 @@ if __name__ == "__main__":
             print("       meshcode prefs reset")
             sys.exit(1)
 
+    elif cmd == "compat":
+        from meshcode.compat import check as cc_check, format_report, RECOMMENDED_VERSION
+        version, status, entry = cc_check()
+        print()
+        print("  meshcode compat")
+        print("  " + "=" * 40)
+        print(format_report(version, entry))
+        print()
+        sys.exit(0 if status in ("safe", "unknown") else 1)
+
+    elif cmd == "doctor":
+        cmd_doctor(flags, pos)
+
     elif cmd == "launcher":
         # meshcode launcher {install|uninstall|start|stop|restart|status|logs|test}
         try:
@@ -2906,7 +3225,7 @@ if __name__ == "__main__":
             "history", "clear", "unregister", "connect", "disconnect",
             "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
-            "help", "profile", "validate-sessions", "wake-headless",
+            "help", "init", "doctor", "compat", "profile", "validate-sessions", "wake-headless",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]