meshcode 2.0.3__tar.gz → 2.0.5__tar.gz

{meshcode-2.0.3 → meshcode-2.0.5}/PKG-INFO

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

{meshcode-2.0.3 → meshcode-2.0.5}/meshcode/__init__.py

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

{meshcode-2.0.3 → meshcode-2.0.5}/meshcode/comms_v4.py

@@ -1634,14 +1634,15 @@ STATUS:
 HISTORY:
   history <proj> [count] [agent1,agent2]     Conversation log
 
-SETUP:
-  connect <proj> <name> [claude|codex]       One-command setup + hook install
+QUICK START:
+  go <agent> [--project <name>]              One command to connect (recommended)
   login <api_key>                            Authenticate with API key
 
-UNIVERSAL MULTI-CLIENT SETUP:
-  setup <client> <proj> <name> [role]        Install MCP server config for client
-                                             Clients: claude-code, cursor, cline,
-                                             claude-desktop
+SETUP (advanced):
+  setup <proj> <name> [role]                 Create workspace (auto by 'go')
+  run <agent> [--project <name>]             Launch agent (auto by 'go')
+  setup <client> <proj> <name> [role]        Legacy: global MCP config
+                                             Clients: claude-desktop
 
 CLEANUP:
   clear <proj> <name>                        Clear inbox
@@ -2042,10 +2043,11 @@ if __name__ == "__main__":
         _setup_dispatcher = importlib.import_module("meshcode.setup_clients").setup
         sys.exit(_setup_dispatcher(*sys.argv[2:]))
 
-    elif cmd == "run":
-        # meshcode run <agent> [--project <name>] [--editor claude|cursor|code]
+    elif cmd in ("run", "go"):
+        # meshcode go <agent> [--project <name>] [--editor claude|cursor|code]
+        # meshcode run <agent> (backwards compat, same as go)
         if len(sys.argv) < 3:
-            print("Usage: meshcode run <agent> [--project <name>] [--editor claude|cursor|code]")
+            print(f"Usage: meshcode {cmd} <agent> [--project <name>] [--editor claude|cursor|code]")
             sys.exit(1)
         agent = sys.argv[2]
         proj_override = flags.get("project")
@@ -2055,6 +2057,19 @@ if __name__ == "__main__":
             perm_override = "bypass"
         elif "--safe" in sys.argv:
             perm_override = "safe"
+        # Auth pre-check: if not logged in, prompt inline
+        api_key = _load_api_key_for_cli()
+        if not api_key:
+            print("[meshcode] Not logged in. Get your API key at: https://meshcode.io/settings")
+            try:
+                api_key = input("[meshcode] Paste your API key (mc_...): ").strip()
+            except (EOFError, KeyboardInterrupt):
+                api_key = ""
+            if api_key:
+                login(api_key)
+            else:
+                print("[meshcode] Login required. Run: meshcode login <api_key>")
+                sys.exit(1)
         import importlib
         _run = importlib.import_module("meshcode.run_agent").run
         sys.exit(_run(agent, project=proj_override, editor_override=editor_override, permission_override=perm_override))
@@ -2198,7 +2213,7 @@ if __name__ == "__main__":
             "register", "send", "broadcast", "read", "check", "watch",
             "board", "update", "status", "projects", "list", "ls",
             "history", "clear", "unregister", "connect", "disconnect",
-            "setup", "run", "invite", "join", "invites", "members",
+            "setup", "run", "go", "invite", "join", "invites", "members",
             "revoke-invite", "revoke-member", "login", "prefs", "launcher",
             "help", "profile", "validate-sessions", "wake-headless",
         ]

{meshcode-2.0.3 → meshcode-2.0.5}/meshcode/meshcode_mcp/backend.py

@@ -307,6 +307,18 @@ def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
     })
 
 
+def record_event(api_key, project_id, agent_name, session_id, event_type, payload=None):
+    """Fire-and-forget event recording for session replay."""
+    return sb_rpc("mc_record_event", {
+        "p_api_key": api_key,
+        "p_project_id": project_id,
+        "p_agent_name": agent_name,
+        "p_session_id": session_id,
+        "p_event_type": event_type,
+        "p_payload": payload or {},
+    })
+
+
 def get_history(project_id: str, limit: int = 20) -> List[Dict]:
     return sb_select(
         "mc_messages",

{meshcode-2.0.3 → meshcode-2.0.5}/meshcode/meshcode_mcp/server.py

@@ -145,6 +145,57 @@ def _split_messages(messages: List[Dict[str, Any]]) -> Dict[str, Any]:
 from . import backend as be
 from .realtime import RealtimeListener
 
+# ============================================================
+# Session Replay: unique session ID per MCP server boot.
+# Events are recorded in background threads (fire-and-forget).
+# ============================================================
+import uuid as _uuid
+_SESSION_ID = str(_uuid.uuid4())[:12]
+
+
+def _record_event_bg(event_type: str, payload: dict = None) -> None:
+    """Fire-and-forget: record a session event in background thread."""
+    try:
+        api_key = _get_api_key()
+        import threading
+        threading.Thread(
+            target=be.record_event,
+            args=(api_key, _PROJECT_ID, AGENT_NAME, _SESSION_ID, event_type, payload or {}),
+            daemon=True,
+        ).start()
+    except Exception:
+        pass
+
+
+# ============================================================
+# Hot-reload: detect when backend.py changes on disk (e.g. after
+# pip install --upgrade meshcode) and reload without restart.
+# Only backend.py is safe to reload (stateless). server.py has
+# module-level state that would be destroyed by reload.
+# ============================================================
+import importlib as _importlib
+_be_mtime: float = 0.0
+try:
+    _be_path = os.path.abspath(be.__file__)
+    _be_mtime = os.path.getmtime(_be_path)
+except Exception:
+    _be_path = ""
+
+
+def _check_hot_reload() -> None:
+    """If backend.py was modified since boot/last reload, reimport it."""
+    global _be_mtime, be
+    if not _be_path:
+        return
+    try:
+        current_mtime = os.path.getmtime(_be_path)
+        if current_mtime > _be_mtime:
+            _be_mtime = current_mtime
+            _importlib.reload(be)
+            log.info("[meshcode] Hot-reloaded backend.py (new version detected)")
+    except Exception as e:
+        log.debug(f"hot-reload check failed: {e}")
+
 try:
     from mcp.server.fastmcp import FastMCP
 except ImportError:
@@ -317,8 +368,10 @@ def with_working_status(func):
     if asyncio.iscoroutinefunction(func):
         @_functools.wraps(func)
         async def awrapper(*args, **kwargs):
+            _check_hot_reload()
             if not skip:
                 _schedule_flip("working", name)
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
             try:
                 return await func(*args, **kwargs)
             finally:
@@ -328,8 +381,10 @@ def with_working_status(func):
     else:
         @_functools.wraps(func)
         def swrapper(*args, **kwargs):
+            _check_hot_reload()
             if not skip:
                 _schedule_flip("working", name)
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
             try:
                 return func(*args, **kwargs)
             finally:
@@ -574,7 +629,10 @@ async def _on_new_message(msg: Dict[str, Any]) -> None:
     from_agent = msg.get("from") or msg.get("from_agent") or "unknown"
     payload = msg.get("payload") or {}
     preview = payload.get("text", "") if isinstance(payload, dict) else str(payload)
-    _try_auto_wake(from_agent, preview[:60])
+    try:
+        _try_auto_wake(from_agent, preview[:60])
+    except Exception:
+        pass  # auto-wake is best-effort, never block message handling
 
     try:
         srv = mcp._mcp_server  # FastMCP exposes the lowlevel server here
@@ -660,9 +718,11 @@ async def lifespan(_app):
     hb_thread = _threading.Thread(target=_heartbeat_thread_fn, daemon=True, name="meshcode-heartbeat")
     hb_thread.start()
     log.info(f"lifespan started — Realtime + heartbeat thread active for {AGENT_NAME}")
+    _record_event_bg("boot", {"agent": AGENT_NAME, "project": PROJECT_NAME, "session_id": _SESSION_ID})
     try:
         yield {"realtime": _REALTIME}
     finally:
+        _record_event_bg("shutdown", {"agent": AGENT_NAME, "session_id": _SESSION_ID})
         log.info("lifespan shutdown — stopping heartbeat + realtime + releasing lease")
         _heartbeat_stop.set()
         hb_thread.join(timeout=5)
@@ -852,7 +912,20 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         # Realtime unavailable — plain sleep fallback so we still honor timeout.
         await asyncio.sleep(actual_timeout)
 
-    return {"timed_out": True}
+    # On timeout, check for unclaimed tasks assigned to this agent
+    timeout_result: Dict[str, Any] = {"timed_out": True}
+    try:
+        api_key = _get_api_key()
+        open_tasks = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
+        if isinstance(open_tasks, dict) and open_tasks.get("ok"):
+            my_tasks = [t for t in open_tasks.get("tasks", [])
+                       if t.get("assignee") == AGENT_NAME and not t.get("claimed_by")]
+            if my_tasks:
+                timeout_result["unclaimed_tasks"] = len(my_tasks)
+                timeout_result["hint"] = f"You have {len(my_tasks)} unclaimed task(s) assigned to you. Run meshcode_tasks(status_filter='open') to see them."
+    except Exception:
+        pass
+    return timeout_result
 
 
 @mcp.tool()
@@ -995,9 +1068,22 @@ def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
     Returns: {"ok": true, "task_id": "...", "title": "..."}
     """
     api_key = _get_api_key()
-    return be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
+    result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
                            description=description, assignee=assignee,
                            priority=priority, parent_task_id=parent_task_id)
+    # Auto-notify assignee so they wake from meshcode_wait
+    if isinstance(result, dict) and result.get("ok") and assignee and assignee != "*" and assignee != AGENT_NAME:
+        try:
+            be.send_message(_PROJECT_ID, AGENT_NAME, assignee, {
+                "type": "task_assigned",
+                "task_id": result.get("task_id", ""),
+                "title": title,
+                "priority": priority,
+                "text": f"New {priority} task assigned to you: {title}",
+            }, msg_type="system")
+        except Exception:
+            pass  # best-effort notification
+    return result
 
 
 @mcp.tool()
@@ -1338,7 +1424,10 @@ def meshcode_remember(key: str, value: Any) -> Dict[str, Any]:
     })
     # Best-effort sync to Obsidian vault (if configured)
     if isinstance(result, dict) and result.get("ok"):
-        _sync_to_obsidian(key, json_value)
+        try:
+            _sync_to_obsidian(key, json_value)
+        except Exception:
+            pass  # Obsidian sync is best-effort, never block memory writes
     return result
 
 

{meshcode-2.0.3 → meshcode-2.0.5}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.0.3 → meshcode-2.0.5}/pyproject.toml

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