meshcode 2.10.63__tar.gz → 2.10.65__tar.gz

{meshcode-2.10.63 → meshcode-2.10.65}/PKG-INFO

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

{meshcode-2.10.63 → meshcode-2.10.65}/meshcode/__init__.py

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

{meshcode-2.10.63 → meshcode-2.10.65}/meshcode/comms_v4.py

@@ -1467,8 +1467,34 @@ def show_board(project):
     print(f" {project.upper()} — Board")
     print(f"{'='*60}")
     for a in agents:
-        icon = {"online": "●", "working": "▶", "blocked": "■", "standby": "◆", "idle": "○", "done": "✓"}.get(a.get("status", ""), "?")
+        icon = {"online": "●", "working": "▶", "blocked": "■", "standby": "◆",
+                "idle": "○", "done": "✓", "sleeping": "☾", "offline": "✗",
+                "waiting": "◎"}.get(a.get("status", ""), "?")
         print(f"  {icon} {a['name']:<14} {a.get('status','?'):<10} {a.get('task','')}")
+
+    # Enhanced: show health + tasks + activity from dashboard summary
+    if _ak:
+        try:
+            summary = sb_rpc("mc_get_dashboard_summary", {"p_api_key": _ak})
+            if isinstance(summary, dict) and summary.get("ok"):
+                h = summary.get("health", {})
+                print(f"\n{'-'*60}")
+                print(f"  Health: {h.get('active_agents',0)}/{h.get('total_agents',0)} agents active"
+                      f"  |  {h.get('open_tasks',0)} open tasks"
+                      f"  |  {h.get('messages_today',0)} messages today")
+                tasks = summary.get("tasks", [])
+                if tasks:
+                    print(f"\n  Open tasks:")
+                    for t in tasks[:5]:
+                        prio_icon = {"urgent": "!!", "high": "!", "normal": " ", "low": "."}.get(t.get("priority", ""), " ")
+                        print(f"    [{prio_icon}] {t.get('title','')[:50]}  ({t.get('assignee','?')})")
+                activity = summary.get("activity", [])
+                if activity:
+                    print(f"\n  Recent activity:")
+                    for e in activity[:5]:
+                        print(f"    {e.get('agent','?')}: {e.get('summary','')[:50]}")
+        except Exception:
+            pass
     print()
 
 
@@ -2040,11 +2066,11 @@ def cmd_doctor(flags, pos):
     else:
         fail("API key", "not found. Run: meshcode login <api_key>")
 
-    # 4c. MCP server import test
+    # 4c. MCP server import test (lightweight — only test backend, not full server)
     try:
         import importlib
-        _mod = importlib.import_module("meshcode.meshcode_mcp.server")
-        ok("MCP server", "module imports cleanly")
+        _mod = importlib.import_module("meshcode.meshcode_mcp.backend")
+        ok("MCP server", "core module imports cleanly")
     except Exception as e:
         fail("MCP server", f"import error: {e}. Run: pip install --upgrade meshcode")
 
@@ -2576,6 +2602,17 @@ if __name__ == "__main__":
         pass
 
     if len(sys.argv) < 2:
+        # First-run detection: no credentials = new user
+        _config = Path.home() / ".meshcode"
+        _has_creds = (_config / "profile_meta.json").exists() if _config.exists() else False
+        if not _has_creds:
+            print()
+            print("  Welcome to MeshCode!")
+            print("  First time? Run: meshcode quickstart")
+            print("  Already have an API key? Run: meshcode login <api_key>")
+            print("  Need help? Run: meshcode doctor")
+            print()
+            sys.exit(0)
         show_help()
         sys.exit(0)
 
@@ -3337,6 +3374,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:
@@ -3392,7 +3434,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.63 → meshcode-2.10.65}/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.65/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.63 → meshcode-2.10.65}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.10.63 → meshcode-2.10.65}/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.63 → meshcode-2.10.65}/pyproject.toml

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