meshcode 2.10.62__tar.gz → 2.10.64__tar.gz

{meshcode-2.10.62 → meshcode-2.10.64}/PKG-INFO

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

{meshcode-2.10.62 → meshcode-2.10.64}/meshcode/__init__.py

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

{meshcode-2.10.62 → meshcode-2.10.64}/meshcode/comms_v4.py

@@ -2024,8 +2024,31 @@ def cmd_doctor(flags, pos):
     except Exception as e:
         fail("Supabase API", f"unreachable: {e}")
 
-    # 5. Stale agents check (requires auth)
+    # 4b. API key validity
     api_key = _load_api_key_for_cli()
+    if api_key:
+        try:
+            result = sb_rpc("mc_validate_api_key", {"p_api_key": api_key})
+            if isinstance(result, dict) and result.get("ok"):
+                ok("API key", "valid")
+            elif isinstance(result, dict) and result.get("error"):
+                fail("API key", f"invalid: {result.get('error')}. Run: meshcode login <new_key>")
+            else:
+                ok("API key", "accepted (validation RPC may not exist)")
+        except Exception:
+            ok("API key", "present (could not validate)")
+    else:
+        fail("API key", "not found. Run: meshcode login <api_key>")
+
+    # 4c. MCP server import test
+    try:
+        import importlib
+        _mod = importlib.import_module("meshcode.meshcode_mcp.server")
+        ok("MCP server", "module imports cleanly")
+    except Exception as e:
+        fail("MCP server", f"import error: {e}. Run: pip install --upgrade meshcode")
+
+    # 5. Stale agents check (requires auth)
     if api_key:
         try:
             # Try listing all projects for this user
@@ -3314,6 +3337,11 @@ if __name__ == "__main__":
     elif cmd == "doctor":
         cmd_doctor(flags, pos)
 
+    elif cmd == "quickstart":
+        import importlib
+        _qs = importlib.import_module("meshcode.quickstart")
+        sys.exit(_qs.cmd_quickstart())
+
     elif cmd == "launcher":
         # meshcode launcher {install|uninstall|start|stop|restart|status|logs|test}
         try:
@@ -3369,7 +3397,7 @@ if __name__ == "__main__":
             "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
             "help", "init", "doctor", "compat", "upgrade", "profile", "validate-sessions", "wake-headless",
-            "supervisor", "upload",
+            "supervisor", "upload", "quickstart",
         ]
         # Simple fuzzy: prefix match + Levenshtein-like best match
         suggestions = [c for c in known_cmds if c.startswith(cmd)]

{meshcode-2.10.62 → meshcode-2.10.64}/meshcode/meshcode_mcp/server.py

@@ -684,6 +684,33 @@ def _auto_learn_error(tool_name: str, error: Exception, args_keys: list) -> None
         pass  # Never let error-learning itself cause failures
 
 
+# ── Activity feed auto-logger ──────────────────────────────────
+# Logs tool calls to mc_activity for the live dashboard feed.
+# Background thread, fire-and-forget — never blocks tool execution.
+_ACTIVITY_LOG_SKIP = {"meshcode_wait", "meshcode_check", "meshcode_set_status",
+                      "meshcode_recall", "meshcode_recall_keys", "meshcode_recall_search",
+                      "meshcode_health", "meshcode_status", "meshcode_debug_sleep"}
+
+def _log_activity_bg(event_type: str, summary: str) -> None:
+    """Fire-and-forget activity logging in background thread."""
+    try:
+        import threading
+        def _do():
+            try:
+                api_key = _get_api_key()
+                if api_key:
+                    be.sb_rpc("mc_log_activity", {
+                        "p_api_key": api_key,
+                        "p_event_type": event_type,
+                        "p_summary": summary[:200],
+                    })
+            except Exception:
+                pass
+        threading.Thread(target=_do, daemon=True).start()
+    except Exception:
+        pass
+
+
 def with_working_status(func):
     name = func.__name__
     skip = (name == "meshcode_wait")
@@ -700,11 +727,12 @@ def with_working_status(func):
                 _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
                 _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
-                return await func(*args, **kwargs)
+                result = await func(*args, **kwargs)
+                # Auto-log to activity feed (skip noisy read-only tools)
+                if not skip and name not in _ACTIVITY_LOG_SKIP:
+                    _log_activity_bg("tool_call", f"{AGENT_NAME}: {name}")
+                return result
             except asyncio.CancelledError:
-                # ESC in Claude Code cancels the in-flight task. Catch here
-                # to prevent cascade through FastMCP into the event loop.
-                # Return an error dict instead of propagating BaseException.
                 log.debug(f"[meshcode] tool {name} cancelled by client (ESC)")
                 return {"error": "cancelled_by_client", "tool": name}
             except Exception as e:
@@ -728,7 +756,10 @@ def with_working_status(func):
                 _est_tokens = sum(len(str(v)) for v in kwargs.values()) // 4
                 _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys()), "estimated_tokens": _est_tokens})
             try:
-                return func(*args, **kwargs)
+                result = func(*args, **kwargs)
+                if not skip and name not in _ACTIVITY_LOG_SKIP:
+                    _log_activity_bg("tool_call", f"{AGENT_NAME}: {name}")
+                return result
             except Exception as e:
                 if not skip:
                     _auto_learn_error(name, e, list(kwargs.keys()))
@@ -1506,6 +1537,7 @@ async def lifespan(_app):
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": _SDK_VERSION})
             be.set_status(_PROJECT_ID, AGENT_NAME, "idle", "MCP session active", api_key=_get_api_key())
             log.info(f"[meshcode] Agent {AGENT_NAME} online — initial heartbeat sent")
+            _log_activity_bg("agent_online", f"{AGENT_NAME} came online")
             break
         except Exception as e:
             log.warning(f"initial heartbeat attempt {_attempt+1} failed: {e}")
@@ -2072,6 +2104,9 @@ async def meshcode_wait(timeout_seconds: int = 20, include_acks: bool = False) -
                 # Real message arrived — return to agent for processing
                 _set_state("online", "")
                 _CONSECUTIVE_IDLE_SECONDS = 0
+                _msg_count = len(result.get("messages", []))
+                if _msg_count:
+                    _log_activity_bg("message_delivered", f"{AGENT_NAME} received {_msg_count} message(s)")
                 break
 
             if result.get("timed_out"):

meshcode-2.10.64/meshcode/quickstart.py

@@ -0,0 +1,148 @@
+"""MeshCode Quickstart Wizard — one command to go from zero to running agent.
+
+Usage: meshcode quickstart
+
+Flow:
+1. Ask for API key (or detect from config)
+2. Ask for project name (or create new)
+3. Ask for agent name + role
+4. Auto-run: register → setup → run
+"""
+import sys
+import os
+import json
+from pathlib import Path
+
+
+def _input_with_default(prompt: str, default: str = "") -> str:
+    """Input with default value shown in brackets."""
+    if default:
+        raw = input(f"{prompt} [{default}]: ").strip()
+        return raw if raw else default
+    return input(f"{prompt}: ").strip()
+
+
+def cmd_quickstart() -> int:
+    """Interactive quickstart wizard."""
+    print()
+    print("  ╔══════════════════════════════════════╗")
+    print("  ║     MeshCode Quickstart Wizard       ║")
+    print("  ║  From zero to running agent in 60s   ║")
+    print("  ╚══════════════════════════════════════╝")
+    print()
+
+    # Step 1: API key
+    config_dir = Path.home() / ".meshcode"
+    existing_key = None
+    try:
+        profile = config_dir / "profile_meta.json"
+        if profile.exists():
+            meta = json.loads(profile.read_text())
+            existing_key = meta.get("api_key")
+            email = meta.get("email", "unknown")
+            print(f"  [+] Already logged in as {email}")
+    except Exception:
+        pass
+
+    if not existing_key:
+        print("  Step 1: Enter your API key")
+        print("  (Get one at meshcode.io/dashboard → Settings → API Keys)")
+        print()
+        api_key = input("  API key: ").strip()
+        if not api_key:
+            print("  [!] API key required. Get one at meshcode.io/dashboard")
+            return 1
+        # Login
+        try:
+            from meshcode.meshcode_mcp import backend as be
+            # Validate key
+            result = be.sb_rpc("mc_validate_api_key", {"p_api_key": api_key})
+            if isinstance(result, dict) and result.get("error"):
+                print(f"  [x] Invalid API key: {result.get('error')}")
+                return 1
+            print("  [+] API key valid!")
+            # Save
+            config_dir.mkdir(parents=True, exist_ok=True)
+            (config_dir / "profile_meta.json").write_text(json.dumps({
+                "api_key": api_key,
+                "email": result.get("email", "unknown"),
+            }))
+        except Exception as e:
+            print(f"  [x] Could not validate: {e}")
+            print("  Continuing anyway — key will be verified on run.")
+            config_dir.mkdir(parents=True, exist_ok=True)
+            (config_dir / "profile_meta.json").write_text(json.dumps({"api_key": api_key}))
+    else:
+        api_key = existing_key
+
+    print()
+
+    # Step 2: Project
+    print("  Step 2: Choose your meshwork (project)")
+    try:
+        from meshcode.meshcode_mcp import backend as be
+        projects = be.sb_rpc("mc_list_user_projects", {"p_api_key": api_key})
+        if isinstance(projects, dict) and projects.get("projects"):
+            proj_list = projects["projects"]
+            print(f"  Your meshworks: {', '.join(p['name'] for p in proj_list[:5])}")
+            project = _input_with_default("  Meshwork name", proj_list[0]["name"])
+        else:
+            project = _input_with_default("  New meshwork name", "my-team")
+    except Exception:
+        project = _input_with_default("  Meshwork name", "my-team")
+
+    print()
+
+    # Step 3: Agent
+    print("  Step 3: Create your agent")
+    agent_name = _input_with_default("  Agent name", "assistant")
+    role = _input_with_default("  Agent role", "General-purpose AI assistant")
+
+    print()
+    print(f"  Creating {agent_name} in {project}...")
+    print()
+
+    # Step 4: Setup + Run
+    try:
+        # Register agent
+        from meshcode.meshcode_mcp import backend as be
+        result = be.register_agent(project, agent_name, role, api_key=api_key)
+        if isinstance(result, dict) and result.get("error"):
+            if "already registered" in str(result.get("error", "")).lower():
+                print(f"  [+] Agent {agent_name} already exists — reusing")
+            else:
+                print(f"  [!] Registration: {result.get('error')}")
+        else:
+            print(f"  [+] Agent {agent_name} registered!")
+    except Exception as e:
+        print(f"  [!] Registration note: {e}")
+
+    # Run setup
+    print(f"  [+] Setting up MCP connection...")
+    try:
+        import subprocess
+        subprocess.run(
+            [sys.executable, "-m", "meshcode", "setup", "claude", project, agent_name, role],
+            check=False
+        )
+    except Exception as e:
+        print(f"  [!] Setup: {e}")
+
+    print()
+    print("  ╔══════════════════════════════════════╗")
+    print(f"  ║  Agent '{agent_name}' is ready!       ")
+    print("  ╚══════════════════════════════════════╝")
+    print()
+    print("  Next steps:")
+    print(f"  1. Open Claude Code and start chatting")
+    print(f"  2. Your agent will auto-connect via MCP")
+    print(f"  3. Or run manually: meshcode run {project} {agent_name}")
+    print()
+
+    # Ask if they want to run now
+    run_now = input("  Start agent now? [Y/n]: ").strip().lower()
+    if run_now in ("", "y", "yes"):
+        print(f"\n  Starting {agent_name}...")
+        os.execvp(sys.executable, [sys.executable, "-m", "meshcode", "run", project, agent_name])
+
+    return 0

{meshcode-2.10.62 → meshcode-2.10.64}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.62 → meshcode-2.10.64}/meshcode.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ meshcode/launcher.py
 meshcode/launcher_install.py
 meshcode/preferences.py
 meshcode/protocol_v2.py
+meshcode/quickstart.py
 meshcode/run_agent.py
 meshcode/secrets.py
 meshcode/self_update.py

{meshcode-2.10.62 → meshcode-2.10.64}/pyproject.toml

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