meshcode 2.0.8__tar.gz → 2.1.0__tar.gz

{meshcode-2.0.8 → meshcode-2.1.0}/PKG-INFO

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

{meshcode-2.0.8 → meshcode-2.1.0}/meshcode/__init__.py

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

{meshcode-2.0.8 → meshcode-2.1.0}/meshcode/meshcode_mcp/backend.py

@@ -105,6 +105,29 @@ def sb_update(table: str, filters: str, updates: Dict) -> Any:
     return _request("PATCH", f"{table}?{filters}", data=updates, prefer="return=representation")
 
 
+# Session recording config — set by MCP server at boot
+_recording_enabled = False
+_recording_api_key = ""
+_recording_project_id = ""
+_recording_agent_name = ""
+_recording_session_id = ""
+
+# RPCs that should NOT be recorded (internal/heartbeat/recording itself)
+_SKIP_RECORDING = {"mc_heartbeat", "mc_record_event", "mc_agent_set_status_by_api_key",
+                    "mc_acquire_agent_lease", "mc_release_agent_lease"}
+
+
+def enable_recording(api_key: str, project_id: str, agent_name: str, session_id: str):
+    """Called by MCP server at boot to enable session recording."""
+    global _recording_enabled, _recording_api_key, _recording_project_id
+    global _recording_agent_name, _recording_session_id
+    _recording_enabled = True
+    _recording_api_key = api_key
+    _recording_project_id = project_id
+    _recording_agent_name = agent_name
+    _recording_session_id = session_id
+
+
 def sb_rpc(fn_name: str, params: Dict) -> Any:
     url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
     body = json.dumps(params).encode("utf-8")
@@ -112,16 +135,57 @@ def sb_rpc(fn_name: str, params: Dict) -> Any:
     try:
         with urlopen(req, timeout=10) as resp:
             raw = resp.read().decode("utf-8")
-            return json.loads(raw) if raw.strip() else None
+            result = json.loads(raw) if raw.strip() else None
     except HTTPError as e:
         err = e.read().decode("utf-8", errors="replace")
         try:
-            return {"_error": json.loads(err).get("message", err[:200])}
+            result = {"_error": json.loads(err).get("message", err[:200])}
         except Exception:
-            return {"_error": err[:200]}
+            result = {"_error": err[:200]}
+        # Record errors too
+        if _recording_enabled and fn_name not in _SKIP_RECORDING:
+            _bg_record("error", {"rpc": fn_name, "error": str(err)[:200]})
+        return result
     except URLError as e:
         return {"_error": str(e.reason)}
 
+    # Auto-record tool calls to session events (hot-reloadable)
+    if _recording_enabled and fn_name not in _SKIP_RECORDING:
+        _bg_record("tool_call", {"rpc": fn_name})
+
+    return result
+
+
+def _bg_record(event_type: str, payload: dict):
+    """Background-thread recording — never blocks the caller."""
+    import threading
+    def _do():
+        try:
+            sb_rpc_raw("mc_record_event", {
+                "p_api_key": _recording_api_key,
+                "p_project_id": _recording_project_id,
+                "p_agent_name": _recording_agent_name,
+                "p_session_id": _recording_session_id,
+                "p_event_type": event_type,
+                "p_payload": payload,
+            })
+        except Exception:
+            pass
+    threading.Thread(target=_do, daemon=True).start()
+
+
+def sb_rpc_raw(fn_name: str, params: Dict) -> Any:
+    """Raw RPC call without recording (to avoid infinite recursion)."""
+    url = f"{SUPABASE_URL}/rest/v1/rpc/{fn_name}"
+    body = json.dumps(params).encode("utf-8")
+    req = Request(url, data=body, method="POST", headers=_headers(content_profile=False))
+    try:
+        with urlopen(req, timeout=10) as resp:
+            raw = resp.read().decode("utf-8")
+            return json.loads(raw) if raw.strip() else None
+    except Exception:
+        return None
+
 
 # ============================================================
 # Project + agent helpers

{meshcode-2.0.8 → meshcode-2.1.0}/meshcode/meshcode_mcp/server.py

@@ -406,12 +406,10 @@ def with_working_status(func):
                 return await func(*args, **kwargs)
             finally:
                 if not skip:
-                    global _last_tool_at, _working_timer
+                    global _last_tool_at
                     _last_tool_at = _time.time()
-                    # Stay WORKING with 60s cooldown — covers LLM thinking between tools
-                    _working_timer = _threading.Timer(_WORKING_COOLDOWN_S, _working_to_online)
-                    _working_timer.daemon = True
-                    _working_timer.start()
+                    # Don't flip to online here — CPU-based detection in heartbeat
+                    # will handle the transition when LLM stops generating
         return awrapper
     else:
         @_functools.wraps(func)
@@ -688,6 +686,24 @@ async def _on_new_message(msg: Dict[str, Any]) -> None:
 _heartbeat_stop = _threading.Event()
 
 
+def _get_parent_cpu() -> float:
+    """Check parent process CPU usage to detect if LLM is actively generating."""
+    try:
+        import subprocess as _sp, platform as _pl
+        ppid = os.getppid()
+        if _pl.system() == "Windows":
+            r = _sp.run(["wmic", "process", "where", f"processid={ppid}", "get", "percentprocessortime"],
+                       capture_output=True, text=True, timeout=5)
+            lines = [l.strip() for l in r.stdout.strip().split("\n") if l.strip()]
+            return float(lines[-1]) if len(lines) > 1 else 0.0
+        else:
+            r = _sp.run(["ps", "-p", str(ppid), "-o", "%cpu"], capture_output=True, text=True, timeout=5)
+            lines = [l.strip() for l in r.stdout.strip().split("\n") if l.strip()]
+            return float(lines[-1]) if len(lines) > 1 else 0.0
+    except Exception:
+        return 0.0
+
+
 def _heartbeat_thread_fn():
     """Heartbeat in a DAEMON THREAD — independent of asyncio event loop.
 
@@ -699,10 +715,20 @@ 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"})
-            # Idle detection: only from online state (NOT waiting or working)
-            # Agents in meshcode_wait should stay WAITING, not flip to IDLE
-            if _current_state == "online" and (_time.time() - _last_tool_at) > _IDLE_THRESHOLD_S:
-                _set_state("idle", f"idle ({int((_time.time() - _last_tool_at) / 60)}m)")
+
+            # CPU-based status detection: check parent process (editor/LLM) CPU usage
+            if _current_state not in ("waiting",):  # Don't override explicit WAITING
+                parent_cpu = _get_parent_cpu()
+                if parent_cpu > 5.0:
+                    # LLM is actively generating tokens
+                    if _current_state != "working":
+                        _set_state("working", "generating response")
+                elif _current_state == "working" and parent_cpu <= 5.0:
+                    # LLM just finished — flip to online
+                    _set_state("online", "")
+                elif _current_state == "online" 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, _current_state, _current_tool)
@@ -762,6 +788,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}")
+    # Enable session recording in backend.py (hot-reloadable)
+    try:
+        be.enable_recording(_get_api_key(), _PROJECT_ID, AGENT_NAME, _SESSION_ID)
+    except Exception:
+        pass
     _record_event_bg("boot", {"agent": AGENT_NAME, "project": PROJECT_NAME, "session_id": _SESSION_ID})
     try:
         yield {"realtime": _REALTIME}

{meshcode-2.0.8 → meshcode-2.1.0}/meshcode.egg-info/PKG-INFO

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

{meshcode-2.0.8 → meshcode-2.1.0}/pyproject.toml

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