meshcode 2.0.4__tar.gz → 2.0.6__tar.gz

{meshcode-2.0.4 → meshcode-2.0.6}/PKG-INFO

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

{meshcode-2.0.4 → meshcode-2.0.6}/meshcode/__init__.py

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

{meshcode-2.0.4 → meshcode-2.0.6}/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.4 → meshcode-2.0.6}/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.4 → meshcode-2.0.6}/meshcode/meshcode_mcp/realtime.py

@@ -216,6 +216,10 @@ class RealtimeListener:
                         except Exception as e:
                             log.warning(f"notify_callback failed: {e}")
 
+    def peek(self) -> list:
+        """Return queued messages without removing them."""
+        return list(self.queue)
+
     def drain(self) -> list:
         """Pop and return all queued messages."""
         out = list(self.queue)

{meshcode-2.0.4 → meshcode-2.0.6}/meshcode/meshcode_mcp/server.py

@@ -145,6 +145,28 @@ 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.
@@ -307,13 +329,21 @@ if not _flip_status("idle", ""):
 
 
 # ============================================================
-# Working/idle status decorator for @mcp.tool() functions.
-# Fire-and-forget flips so tool execution is never blocked.
+# Automatic Agent Status State Machine
+# States: ONLINE → WORKING → ONLINE → WAITING → ONLINE → IDLE → OFFLINE
+# Transitions driven by tool calls and meshcode_wait, not the LLM.
 # ============================================================
 import functools as _functools
 import threading as _threading
+import time as _time
 
 _flip_lock = _threading.Lock()
+_current_state = "online"
+_last_tool_at = _time.time()
+_current_tool = ""
+_IDLE_THRESHOLD_S = 120  # seconds without tool call → IDLE
+_PROCESSING_COOLDOWN_S = 15  # seconds after tool returns before flipping to ONLINE
+_processing_timer: Optional[_threading.Timer] = None
 
 
 async def _async_flip_status(status: str, task: str = "") -> None:
@@ -340,6 +370,28 @@ def _schedule_flip(status: str, task: str = "") -> None:
         ).start()
 
 
+def _set_state(state: str, tool: str = "") -> None:
+    """Update the state machine and broadcast to dashboard."""
+    global _current_state, _current_tool, _last_tool_at, _processing_timer
+    # Cancel any pending processing→online timer
+    if _processing_timer is not None:
+        _processing_timer.cancel()
+        _processing_timer = None
+    _current_state = state
+    _current_tool = tool
+    if state == "working":
+        _last_tool_at = _time.time()
+    _schedule_flip(state, tool)
+
+
+def _processing_to_online() -> None:
+    """Called after PROCESSING cooldown expires — flip to ONLINE."""
+    global _processing_timer
+    _processing_timer = None
+    if _current_state == "processing":
+        _set_state("online", "")
+
+
 def with_working_status(func):
     name = func.__name__
     skip = (name == "meshcode_wait")
@@ -348,24 +400,37 @@ def with_working_status(func):
         async def awrapper(*args, **kwargs):
             _check_hot_reload()
             if not skip:
-                _schedule_flip("working", name)
+                _set_state("working", name)
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
             try:
                 return await func(*args, **kwargs)
             finally:
                 if not skip:
-                    _schedule_flip("idle", "")
+                    global _last_tool_at, _processing_timer
+                    _last_tool_at = _time.time()
+                    # Enter PROCESSING cooldown — stays green for 15s
+                    _set_state("processing", "processing...")
+                    _processing_timer = _threading.Timer(_PROCESSING_COOLDOWN_S, _processing_to_online)
+                    _processing_timer.daemon = True
+                    _processing_timer.start()
         return awrapper
     else:
         @_functools.wraps(func)
         def swrapper(*args, **kwargs):
             _check_hot_reload()
             if not skip:
-                _schedule_flip("working", name)
+                _set_state("working", name)
+                _record_event_bg("tool_call", {"tool": name, "args_keys": list(kwargs.keys())})
             try:
                 return func(*args, **kwargs)
             finally:
                 if not skip:
-                    _schedule_flip("idle", "")
+                    global _last_tool_at, _processing_timer
+                    _last_tool_at = _time.time()
+                    _set_state("processing", "processing...")
+                    _processing_timer = _threading.Timer(_PROCESSING_COOLDOWN_S, _processing_to_online)
+                    _processing_timer.daemon = True
+                    _processing_timer.start()
         return swrapper
 
 
@@ -635,9 +700,13 @@ def _heartbeat_thread_fn():
     while not _heartbeat_stop.is_set():
         try:
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": "2.0.0"})
-            # Also ensure status is at least "idle" (not "offline") between tool calls
+            # Idle detection: only from online/processing states (NOT waiting)
+            # Agents in meshcode_wait should stay WAITING, not flip to IDLE
+            if _current_state in ("online", "processing") and (_time.time() - _last_tool_at) > _IDLE_THRESHOLD_S:
+                _set_state("idle", f"idle ({int((_time.time() - _last_tool_at) / 60)}m)")
+            # Sync current state to DB (in case realtime missed it)
             try:
-                be.set_status(_PROJECT_ID, AGENT_NAME, "idle", "")
+                be.set_status(_PROJECT_ID, AGENT_NAME, _current_state, _current_tool)
             except Exception:
                 pass
             if _REALTIME and not _REALTIME.is_connected:
@@ -694,9 +763,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)
@@ -835,8 +906,12 @@ async def meshcode_wait(timeout_seconds: int = 120, include_acks: bool = False)
     """
     global _IN_WAIT
     _IN_WAIT = True
+    _set_state("waiting", "listening for messages")
     try:
-        return await _meshcode_wait_inner(actual_timeout=max(1, int(timeout_seconds)), include_acks=include_acks)
+        result = await _meshcode_wait_inner(actual_timeout=max(1, int(timeout_seconds)), include_acks=include_acks)
+        if result.get("got_message"):
+            _set_state("online", "")
+        return result
     finally:
         _IN_WAIT = False
 
@@ -935,14 +1010,18 @@ def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
     the realtime listener connected).
     """
     pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
-    realtime_buffered = _REALTIME.drain() if _REALTIME else []
-    deduped = _filter_and_mark(realtime_buffered)
+    # Peek at realtime buffer WITHOUT draining — check is non-destructive
+    realtime_buffered = _REALTIME.peek() if _REALTIME else []
+    # Don't mark as seen — meshcode_check is a peek, not a consume
+    deduped = [m for m in realtime_buffered if _seen_key(m) not in _SEEN_MSG_IDS]
 
     # Fallback: if realtime buffer is empty but DB has pending messages,
-    # fetch them from the DB so they're not invisible to the agent.
+    # fetch them from the DB. Use mark_read=False so meshcode_check is a
+    # non-destructive peek — messages stay pending until meshcode_wait or
+    # meshcode_read consumes them.
     if not deduped and pending > 0:
-        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME)
-        deduped = _filter_and_mark([
+        raw = be.read_inbox(_PROJECT_ID, AGENT_NAME, mark_read=False)
+        deduped = [
             {
                 "from": m["from_agent"],
                 "type": m.get("type", "msg"),
@@ -952,7 +1031,8 @@ def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
                 "parent_id": m.get("parent_msg_id"),
             }
             for m in raw
-        ])
+            if _seen_key({"id": m.get("id"), "from": m.get("from_agent"), "payload": m.get("payload", {}), "ts": m.get("created_at")}) not in _SEEN_MSG_IDS
+        ]
 
     split = _split_messages(deduped)
     if not include_acks:

{meshcode-2.0.4 → meshcode-2.0.6}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.0.4 → meshcode-2.0.6}/pyproject.toml

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