meshcode 2.11.128__tar.gz → 2.11.129__tar.gz

{meshcode-2.11.128 → meshcode-2.11.129}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: meshcode
-Version: 2.11.128
+Version: 2.11.129
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,17 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: mcp[cli]>=1.0.0
-Requires-Dist: websockets>=12.0
-Requires-Dist: realtime>=2.0.0
-Requires-Dist: keyring>=24.0
-Requires-Dist: cryptography>=41.0
 Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
-Requires-Dist: build>=1.0; extra == "dev"
-Requires-Dist: twine>=4; extra == "dev"
-Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode/__init__.py

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

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode/meshcode_mcp/backend.py

@@ -1327,6 +1327,17 @@ def task_complete(api_key, project_id, task_id, completing_agent, summary=""):
     })
 
 
+def feature_flag_enabled(api_key, flag_name):
+    """Agent-facing feature-flag check (mig478). The FE's mc_check_feature_flag
+    is auth.uid()-only, so agents use this api-key variant. Returns the raw
+    RPC dict ({"ok": true, "enabled": bool}); callers treat anything else as
+    disabled."""
+    return sb_rpc("mc_feature_flag_enabled", {
+        "p_api_key": api_key,
+        "p_flag_name": flag_name,
+    })
+
+
 # Per-(project,agent,session,event_type) min interval. Same idea as task_list:
 # fire-and-forget pollers that hammer record_event at >2/sec are throttled
 # client-side. Identical events within the window are dropped (returns

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode/meshcode_mcp/server.py

@@ -609,16 +609,53 @@ import uuid as _uuid
 _SESSION_ID = str(_uuid.uuid4())[:12]
 
 
+# DB F2.1 (task 7f016375): tool_call events are 82% of mc_session_events
+# storage and their only dashboard consumer (session replay / timeline) is
+# gated behind the ff_session_replay feature flag — so the WRITE is gated by
+# the same flag. Feature-flag gate, NOT sampling (a partial replay lies when
+# debugging). ONLY 'tool_call' is gated; lifecycle events (boot/shutdown/
+# error/status_change) always record. ORTHOGONAL to the 2.11.33 M3a throttle
+# in backend.record_event: that one limits the RATE of whatever is enabled,
+# this one decides IF tool_call records at all. The flag is also enforced
+# server-side inside mc_record_event (mig488) — that covers old clients; this
+# client cache just saves the network call. Fail-closed: unknown flag state
+# records nothing (storage emergency beats replay completeness).
+_FF_REPLAY_TTL_SEC = 600.0  # re-check the flag every 10 min per process
+_ff_replay_cache = {"enabled": None, "checked_mono": 0.0}
+
+
+def _session_replay_enabled() -> bool:
+    """Cached ff_session_replay lookup. Runs INSIDE the bg record thread, so a
+    slow/failed flag fetch never adds latency to a tool call."""
+    now = _time.monotonic()
+    cache = _ff_replay_cache
+    if cache["enabled"] is None or now - cache["checked_mono"] >= _FF_REPLAY_TTL_SEC:
+        try:
+            res = be.feature_flag_enabled(_get_api_key(), "ff_session_replay")
+            cache["enabled"] = bool(isinstance(res, dict) and res.get("enabled"))
+        except Exception:
+            # Keep the last known answer; with no answer yet, fail closed.
+            if cache["enabled"] is None:
+                cache["enabled"] = False
+        cache["checked_mono"] = now
+    return cache["enabled"]
+
+
 def _record_event_bg(event_type: str, payload: dict = None) -> None:
-    """Fire-and-forget: record a session event in background thread."""
+    """Fire-and-forget: record a session event in background thread.
+    'tool_call' events are dropped while ff_session_replay is off (task
+    7f016375); every other event type records unconditionally."""
     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()
+
+        def _record():
+            if event_type == "tool_call" and not _session_replay_enabled():
+                return
+            be.record_event(api_key, _PROJECT_ID, AGENT_NAME, _SESSION_ID,
+                            event_type, payload or {})
+
+        threading.Thread(target=_record, daemon=True).start()
     except Exception:
         pass
 

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode/secrets.py

@@ -97,12 +97,45 @@ def _probe_keyring() -> bool:
         _KEYRING_BACKEND_NAME = type(backend).__name__
         # Some installs report a "fail" backend on headless Linux. Probe with a
         # write+read+delete round trip on a sentinel key.
-        sentinel_key = "meshcode_probe_sentinel"
+        # BUG 6b28a32f: the sentinel MUST be unique per process. With a fixed
+        # name, N concurrent CLIs (hostd respawn sweeps spawn up to 3 in the
+        # same second) race set/get/delete on the SAME wincred entry — the
+        # loser reads None (or its delete raises because a sibling already
+        # deleted it) and wrongly concludes the keychain is unusable, which
+        # cascades into "[meshcode] Not logged in" + a dead terminal tab.
+        # Fast path (race-immune): if we can READ an existing entry, the
+        # backend is proven usable — no write probe needed. The write probe
+        # below is only for fresh installs with no entry yet (interactive
+        # `meshcode login`, single process, no concurrency).
+        try:
+            if keyring.get_password(SERVICE_NAME, DEFAULT_PROFILE):
+                _KEYRING_AVAILABLE = True
+                return True
+        except Exception:
+            pass
+        sentinel_key = f"meshcode_probe_{os.getpid()}_{_stdlib_secrets.token_hex(4)}"
         sentinel_val = "ok"
         try:
+            import time as _time
             keyring.set_password(SERVICE_NAME, sentinel_key, sentinel_val)
-            got = keyring.get_password(SERVICE_NAME, sentinel_key)
-            keyring.delete_password(SERVICE_NAME, sentinel_key)
+            # Windows CredMan has read-after-write visibility lag under
+            # concurrent vault access (verified 6b28a32f: CredWrite succeeds,
+            # immediate CredRead misses, the entry IS there later). Retry the
+            # read-back briefly before declaring the backend unusable.
+            got = None
+            for _attempt in range(4):
+                got = keyring.get_password(SERVICE_NAME, sentinel_key)
+                if got == sentinel_val:
+                    break
+                _time.sleep(0.05 * (_attempt + 1))
+            for _attempt in range(2):
+                try:
+                    keyring.delete_password(SERVICE_NAME, sentinel_key)
+                    break
+                except Exception:
+                    # cleanup failure does not mean the backend is unusable;
+                    # one delayed retry keeps orphan sentinels out of the vault
+                    _time.sleep(0.05)
             _KEYRING_AVAILABLE = (got == sentinel_val)
         except KeyringError:
             _KEYRING_AVAILABLE = False
@@ -218,15 +251,22 @@ def get_api_key(profile: str = DEFAULT_PROFILE) -> Optional[str]:
     1. Keychain entry (SERVICE_NAME, profile)
     2. ~/.meshcode/credentials.<profile>.json (fallback file from set_api_key)
     3. ~/.meshcode/credentials.json (legacy pre-1.4.1 file, default profile only)
+
+    BUG 6b28a32f: READS are no longer gated on _probe_keyring(). The probe
+    does a write+read+delete round trip, which is only meaningful before a
+    WRITE (set_api_key) — gating reads on it meant any transient probe
+    failure (concurrent-CLI sentinel race, vault hiccup) skipped a perfectly
+    healthy keychain entry and fell through to fallback files that were
+    migrated-and-shredded, producing a false "Not logged in". Just try the
+    read; it is its own probe.
     """
-    if _probe_keyring():
-        try:
-            import keyring  # type: ignore
-            val = keyring.get_password(SERVICE_NAME, profile)
-            if val:
-                return val
-        except Exception:
-            pass
+    try:
+        import keyring  # type: ignore
+        val = keyring.get_password(SERVICE_NAME, profile)
+        if val:
+            return val
+    except Exception:
+        pass
 
     # Fallback file for this profile
     fallback_path = Path.home() / ".meshcode" / f"credentials.{profile}.json"

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: meshcode
-Version: 2.11.128
+Version: 2.11.129
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT
@@ -18,17 +18,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: mcp[cli]>=1.0.0
-Requires-Dist: websockets>=12.0
-Requires-Dist: realtime>=2.0.0
-Requires-Dist: keyring>=24.0
-Requires-Dist: cryptography>=41.0
 Provides-Extra: test
-Requires-Dist: pytest>=8; extra == "test"
 Provides-Extra: dev
-Requires-Dist: build>=1.0; extra == "dev"
-Requires-Dist: twine>=4; extra == "dev"
-Requires-Dist: pytest>=8; extra == "dev"
 
 # MeshCode
 

{meshcode-2.11.128 → meshcode-2.11.129}/meshcode.egg-info/SOURCES.txt

@@ -87,6 +87,7 @@ tests/test_run_agent_no_server_import.py
 tests/test_security_regressions.py
 tests/test_self_update_user_site.py
 tests/test_sentinel.py
+tests/test_session_replay_gate.py
 tests/test_setup_path.py
 tests/test_sleep_signals.py
 tests/test_status_enum_coverage.py

{meshcode-2.11.128 → meshcode-2.11.129}/pyproject.toml

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

meshcode-2.11.129/tests/test_session_replay_gate.py

@@ -0,0 +1,153 @@
+"""
+Session-Replay tool_call Gate Tests (task 7f016375, DB F2.1)
+=============================================================
+tool_call events are 82% of mc_session_events storage; their only consumer
+(session replay / timeline) is feature-flagged. These tests pin the gate:
+
+  1. server.py: _record_event_bg drops 'tool_call' while ff_session_replay
+     is off, records it when on, and NEVER gates lifecycle events.
+  2. The flag lookup is cached (TTL) and fail-closed on first error.
+  3. mig478 SQL: mc_record_event gates ONLY tool_call; the flag seeds
+     disabled; the agent-facing flag RPC exists with grants.
+  4. The gate is a FLAG, not sampling — no random() anywhere in the path.
+
+Unit tests run fully offline (backend mocked). SQL checks parse migrations
+(pattern of test_security_regressions.py).
+
+Usage:
+    pytest tests/test_session_replay_gate.py -v
+"""
+
+import re
+import sys
+import time
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+MIGRATIONS_DIR = Path(__file__).parent.parent / "supabase" / "migrations"
+MIG478 = MIGRATIONS_DIR / "20260610_478_tool_call_replay_gate.sql"
+
+
+def _fresh_server():
+    """Import server with a clean flag cache. server.py is import-heavy but
+    side-effect-free at module level (asserted by test_boot_bug_regression)."""
+    from meshcode.meshcode_mcp import server
+    server._ff_replay_cache["enabled"] = None
+    server._ff_replay_cache["checked_mono"] = 0.0
+    return server
+
+
+def _run_record(server, event_type, flag_response):
+    """Call _record_event_bg with backend mocked; run the bg thread inline by
+    joining all threads it spawns. Returns the list of record_event calls."""
+    calls = []
+    import threading
+    started = []
+    orig_start = threading.Thread.start
+
+    def capture_start(self):
+        started.append(self)
+        orig_start(self)
+
+    with patch.object(server.be, "record_event",
+                      side_effect=lambda *a, **k: calls.append(a)), \
+         patch.object(server.be, "feature_flag_enabled",
+                      side_effect=flag_response), \
+         patch.object(server, "_get_api_key", return_value="mc_test_key"), \
+         patch.object(threading.Thread, "start", capture_start):
+        server._record_event_bg(event_type, {"tool": "x"})
+        for t in started:
+            t.join(timeout=5)
+    return calls
+
+
+class TestClientGate:
+    def test_tool_call_dropped_when_flag_off(self):
+        server = _fresh_server()
+        calls = _run_record(server, "tool_call",
+                            lambda *a: {"ok": True, "enabled": False})
+        assert calls == [], "tool_call recorded despite ff_session_replay off"
+
+    def test_tool_call_recorded_when_flag_on(self):
+        server = _fresh_server()
+        calls = _run_record(server, "tool_call",
+                            lambda *a: {"ok": True, "enabled": True})
+        assert len(calls) == 1 and calls[0][4] == "tool_call"
+
+    def test_lifecycle_events_never_gated(self):
+        for ev in ("boot", "shutdown", "error", "status_change"):
+            server = _fresh_server()
+
+            def explode(*a):
+                raise AssertionError(f"flag checked for lifecycle event {ev!r}")
+            calls = _run_record(server, ev, explode)
+            assert len(calls) == 1 and calls[0][4] == ev, (
+                f"lifecycle event {ev!r} must record unconditionally")
+
+    def test_fail_closed_on_first_flag_error(self):
+        server = _fresh_server()
+
+        def boom(*a):
+            raise OSError("network down")
+        calls = _run_record(server, "tool_call", boom)
+        assert calls == [], "flag fetch failure must fail CLOSED (no record)"
+
+    def test_flag_cached_within_ttl(self):
+        server = _fresh_server()
+        fetches = []
+
+        def counting(*a):
+            fetches.append(1)
+            return {"ok": True, "enabled": True}
+        _run_record(server, "tool_call", counting)
+        _run_record(server, "tool_call", counting)
+        assert len(fetches) == 1, (
+            f"flag fetched {len(fetches)}x within TTL — cache not working")
+
+    def test_no_sampling_anywhere(self):
+        """Commander condition 1: flag gate, NOT sampling."""
+        import inspect
+        from meshcode.meshcode_mcp import server
+        src = inspect.getsource(server._record_event_bg) + \
+            inspect.getsource(server._session_replay_enabled)
+        assert "random" not in src
+
+
+class TestMig478Sql:
+    SQL = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.SQL = MIG478.read_text(errors="replace")
+
+    def test_gate_only_wraps_tool_call(self):
+        body = re.search(r"FUNCTION public\.mc_record_event.*?\$\$;", self.SQL,
+                         re.DOTALL).group(0)
+        gate = re.search(r"IF p_event_type = 'tool_call' THEN(.*?)END IF;",
+                         body, re.DOTALL)
+        assert gate, "tool_call gate missing from mc_record_event"
+        assert "ff_session_replay" in gate.group(1)
+        # The INSERT must be OUTSIDE the gate so other event types still write.
+        after_gate = body[body.index(gate.group(0)) + len(gate.group(0)):]
+        assert "INSERT INTO meshcode.mc_session_events" in after_gate
+
+    def test_flag_seeds_disabled(self):
+        seed = re.search(r"INSERT INTO meshcode\.mc_global_config.*?ON CONFLICT",
+                         self.SQL, re.DOTALL).group(0)
+        assert "'ff_session_replay'" in seed
+        assert '"enabled": false' in seed
+        assert "DO NOTHING" in self.SQL.split("ON CONFLICT", 1)[1][:30]
+
+    def test_flag_rpc_exists_with_grants(self):
+        assert "FUNCTION public.mc_feature_flag_enabled" in self.SQL
+        assert re.search(
+            r"GRANT EXECUTE ON FUNCTION public\.mc_feature_flag_enabled.*?TO anon",
+            self.SQL)
+
+    def test_backend_wrapper_targets_new_rpc(self):
+        from meshcode.meshcode_mcp import backend as be
+        import inspect
+        src = inspect.getsource(be.feature_flag_enabled)
+        assert "mc_feature_flag_enabled" in src