muxplex 0.3.2__tar.gz → 0.3.4__tar.gz

{muxplex-0.3.2 → muxplex-0.3.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.3.4 (2026-04-13)
+
+### Bug Fixes
+- **Zero-session devices visible** — devices with no tmux sessions now show a "No sessions" status tile instead of being invisible
+- **Flapping prevention** — server-side cache of last-known-good federation results per remote; returns cached sessions for up to 3 consecutive failures before marking unreachable
+- **Status tiles show device name** — offline/unreachable tiles display the device name instead of blank (was passing session.name which is undefined for status entries)
+- **Status entries filtered from session list** — unreachable/auth_failed entries no longer render as blank session tiles in dashboard or sidebar
+- **remoteId=0 falsy bug in mobile sheet** — first remote instance (index 0) now works correctly in the mobile bottom sheet session switcher
+
+## v0.3.3 (2026-04-13)
+
+### Bug Fixes
+- **iOS/iPadOS touch scrolling** — fix touch scroll handling for Safari on iOS and iPadOS devices (PR #4, @samueljklee)
+
 ## v0.3.2 (2026-04-09)
 
 ### Bug Fixes

{muxplex-0.3.2 → muxplex-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muxplex
-Version: 0.3.2
+Version: 0.3.4
 Summary: Web-based tmux session dashboard — access all your tmux sessions from any browser
 Project-URL: Repository, https://github.com/bkrabach/muxplex
 Project-URL: Issues, https://github.com/bkrabach/muxplex/issues

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/frontend/app.js

@@ -530,6 +530,8 @@ function buildStatusTileHTML(deviceName, statusText, statusClass) {
 function getVisibleSessions(sessions) {
   var hidden = (_serverSettings && _serverSettings.hidden_sessions) || [];
   return (sessions || []).filter(function(s) {
+    // Skip status entries (unreachable, auth_failed) — rendered separately as status tiles
+    if (s.status) return false;
     if (hidden.length > 0 && hidden.includes(s.name)) {
       return false;
     }
@@ -758,8 +760,9 @@ function renderGrid(sessions) {
     // Build status tiles for auth_failed/unreachable sessions even when no regular sessions exist
     var statusTilesHtml = '';
     (sessions || []).forEach(function(session) {
-      if (session.status === 'auth_failed') statusTilesHtml += buildStatusTileHTML(session.name, 'Auth required', 'auth');
-      else if (session.status === 'unreachable') statusTilesHtml += buildStatusTileHTML(session.name, 'Offline', 'offline');
+      if (session.status === 'auth_failed') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'Auth required', 'auth');
+      else if (session.status === 'unreachable') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'Offline', 'offline');
+      else if (session.status === 'empty') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'No sessions', 'empty');
     });
     if (grid) grid.innerHTML = statusTilesHtml;
     // Only show empty-state when there are truly no tiles at all
@@ -798,11 +801,12 @@ function renderGrid(sessions) {
     html = ordered.map(function(session, index) { return buildTileHTML(session, index, mobile); }).join('');
   }
 
-  // Append status tiles for auth_failed and unreachable sessions
+  // Append status tiles for auth_failed, unreachable, and empty sessions
   var statusTilesHtml = '';
   (sessions || []).forEach(function(session) {
-    if (session.status === 'auth_failed') statusTilesHtml += buildStatusTileHTML(session.name, 'Auth required', 'auth');
-    else if (session.status === 'unreachable') statusTilesHtml += buildStatusTileHTML(session.name, 'Offline', 'offline');
+    if (session.status === 'auth_failed') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'Auth required', 'auth');
+    else if (session.status === 'unreachable') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'Offline', 'offline');
+    else if (session.status === 'empty') statusTilesHtml += buildStatusTileHTML(session.deviceName, 'No sessions', 'empty');
   });
   if (grid) grid.innerHTML = html + statusTilesHtml;
 
@@ -1847,7 +1851,7 @@ function renderSheetList() {
       (s.bell.seen_at === null || s.bell.last_fired_at > s.bell.seen_at);
     var isActive = s.name === _viewingSession;
     var escapedName = escapeHtml(s.name || '');
-    var remoteIdAttr = s.remoteId ? ' data-remote-id="' + escapeHtml(s.remoteId) + '"' : '';
+    var remoteIdAttr = s.remoteId != null ? ' data-remote-id="' + escapeHtml(s.remoteId) + '"' : '';
     return '<li class="sheet-item' + (isActive ? ' sheet-item--active' : '') + '"' +
       ' data-session="' + escapedName + '"' + remoteIdAttr + ' role="option">' +
       '<span class="sheet-item__name">' + escapedName + '</span>' +

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/frontend/style.css

@@ -1002,6 +1002,11 @@ body {
   border-style: dashed;
 }
 
+.source-tile--empty {
+  opacity: 0.6;
+  border-style: dashed;
+}
+
 .source-tile__name {
   font-size: 15px;
   font-weight: 600;

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/frontend/terminal.js

@@ -534,13 +534,15 @@ function setTerminalFontSize(size) {
 window._setTerminalFontSize = setTerminalFontSize;
 
 // ---------------------------------------------------------------------------
-// Android touch scroll — rAF-batched WheelEvent dispatch
-// Android batches touchmove events irregularly; dispatching one WheelEvent
+// Mobile touch scroll — rAF-batched WheelEvent dispatch
+// Mobile devices batch touchmove events irregularly; dispatching one WheelEvent
 // per frame (via requestAnimationFrame) smooths over burst delivery.
-// UA-gated: iOS and macOS are unaffected (they use mouse wheel natively).
+// Applies to Android, iOS, and iPadOS touch devices.
 // ---------------------------------------------------------------------------
-;(function initAndroidTerminalScroll() {
-  if (!/Android/i.test(navigator.userAgent)) return;
+;(function initMobileTerminalScroll() {
+  var isTouchDevice = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent) ||
+                      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+  if (!isTouchDevice) return;
 
   var container = document.getElementById('terminal-container');
   if (!container) return;

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/frontend/tests/test_app.mjs

@@ -626,7 +626,7 @@ test('renderGrid includes auth tile HTML when a session has auth_failed status',
 
   const sessions = [
     { name: 'my-session', snapshot: 'hello' },
-    { name: 'Workstation', status: 'auth_failed' },
+    { deviceName: 'Workstation', status: 'auth_failed' },
   ];
   app.renderGrid(sessions);
 
@@ -651,7 +651,7 @@ test('renderGrid includes offline tile HTML when a session has unreachable statu
 
   const sessions = [
     { name: 'my-session', snapshot: 'hello' },
-    { name: 'Dev Server', status: 'unreachable' },
+    { deviceName: 'Dev Server', status: 'unreachable' },
   ];
   app.renderGrid(sessions);
 
@@ -1604,6 +1604,20 @@ test('renderSheetList escapes HTML special chars in sheet-item__name span', () =
   globalThis.document.getElementById = origGetById;
 });
 
+// --- Fix 3: renderSheetList uses null check for remoteId (not falsy) ---
+
+test('renderSheetList uses null check for remoteId (not falsy)', () => {
+  const source = fs.readFileSync(new URL('../app.js', import.meta.url), 'utf8');
+  const fnStart = source.indexOf('function renderSheetList');
+  const fnEnd = source.indexOf('\n}\n', fnStart + 100);
+  const fnBody = source.substring(fnStart, fnEnd);
+  // Must use != null check, not truthy check
+  assert.ok(fnBody.includes('remoteId != null') || fnBody.includes('remoteId !== null'),
+    'renderSheetList must use null check for remoteId (0 is valid)');
+  assert.ok(!fnBody.match(/s\.remoteId\s*\?[^=]/),
+    'renderSheetList must NOT use truthy check for remoteId (0 is falsy)');
+});
+
 // --- Fix 2: openBottomSheet/closeBottomSheet use static backdrop binding ---
 
 test('openBottomSheet does not dynamically add click listener to sheet-backdrop', () => {
@@ -1769,6 +1783,37 @@ test('renderSidebar does nothing when view is not fullscreen', () => {
   globalThis.document.getElementById = origGetById;
 });
 
+// --- getVisibleSessions ---
+
+test('getVisibleSessions filters out entries with unreachable status (no name)', () => {
+  const sessions = [
+    { name: 'real-session', snapshot: '' },
+    { status: 'unreachable', remoteId: 0, deviceName: 'alienware-r13' },
+  ];
+  const result = app.getVisibleSessions(sessions);
+  assert.strictEqual(result.length, 1, 'should return only the real session');
+  assert.strictEqual(result[0].name, 'real-session');
+});
+
+test('getVisibleSessions filters out entries with auth_failed status', () => {
+  const sessions = [
+    { name: 'real-session', snapshot: '' },
+    { name: 'Workstation', status: 'auth_failed' },
+  ];
+  const result = app.getVisibleSessions(sessions);
+  assert.strictEqual(result.length, 1, 'auth_failed entry should be filtered out');
+  assert.strictEqual(result[0].name, 'real-session');
+});
+
+test('getVisibleSessions passes through sessions with no status field', () => {
+  const sessions = [
+    { name: 'alpha', snapshot: '' },
+    { name: 'beta', snapshot: '' },
+  ];
+  const result = app.getVisibleSessions(sessions);
+  assert.strictEqual(result.length, 2, 'normal sessions should all pass through');
+});
+
 // ─── initSidebar ─────────────────────────────────────────────────────────────
 
 test('initSidebar defaults to open (removes sidebar--collapsed) on wide screens when no stored value', () => {
@@ -4699,3 +4744,63 @@ test('updateFaviconBadge does not show activity for only-hidden sessions with be
   app._setServerSettings(null);
   app._setCurrentSessions([]);
 });
+
+// --- renderGrid: status tiles use deviceName not name ---
+
+test('renderGrid status tiles use session.deviceName not session.name for offline devices', () => {
+  // Status entries (unreachable/auth_failed) have deviceName but no name.
+  // buildStatusTileHTML must receive session.deviceName so the tile shows the device label.
+  const grid = { innerHTML: '' };
+  const emptyState = { style: {}, classList: { add() {}, remove() {} } };
+  const origGetById = globalThis.document.getElementById;
+  globalThis.document.getElementById = (id) => {
+    if (id === 'session-grid') return grid;
+    if (id === 'empty-state') return emptyState;
+    return null;
+  };
+
+  // An unreachable device: has deviceName but no name (as federation returns it)
+  app.renderGrid([{ status: 'unreachable', deviceName: 'my-server', remoteId: 1 }]);
+
+  assert.ok(grid.innerHTML.includes('my-server'),
+    'offline status tile HTML must include the deviceName "my-server"');
+
+  // Also verify an auth_failed device shows its deviceName
+  app.renderGrid([{ status: 'auth_failed', deviceName: 'auth-box', remoteId: 2 }]);
+  assert.ok(grid.innerHTML.includes('auth-box'),
+    'auth_failed status tile HTML must include the deviceName "auth-box"');
+
+  globalThis.document.getElementById = origGetById;
+});
+
+// --- renderGrid: status=empty shows "No sessions" tile ---
+
+test('renderGrid shows "No sessions" status tile for status=empty devices', () => {
+  // A device that is online but has zero tmux sessions returns
+  // {status: 'empty', deviceName: '...'} from the federation endpoint.
+  // renderGrid must render a status tile with the text "No sessions" (not blank).
+  //
+  // Before implementation: fails because neither status loop handles status === 'empty',
+  // so the tile is never rendered and grid.innerHTML stays empty.
+  const grid = { innerHTML: '' };
+  const emptyState = { style: {}, classList: { add() {}, remove() {} } };
+  const origGetById = globalThis.document.getElementById;
+  globalThis.document.getElementById = (id) => {
+    if (id === 'session-grid') return grid;
+    if (id === 'empty-state') return emptyState;
+    return null;
+  };
+
+  app.renderGrid([{ status: 'empty', deviceName: 'quiet-box', remoteId: 3 }]);
+
+  assert.ok(
+    grid.innerHTML.includes('No sessions'),
+    `renderGrid must include "No sessions" text for status=empty device, got: ${grid.innerHTML}`
+  );
+  assert.ok(
+    grid.innerHTML.includes('quiet-box'),
+    `renderGrid must include the deviceName "quiet-box" in the status tile, got: ${grid.innerHTML}`
+  );
+
+  globalThis.document.getElementById = origGetById;
+});

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/main.py

@@ -1182,6 +1182,13 @@ async def auth_mode_endpoint():
     return {"mode": _auth_mode, "user": username}
 
 
+# Module-level cache: remote_id → {"sessions": [...], "fail_count": int}
+# Populated by fetch_remote() on every successful poll; returned on transient failures
+# so a single slow/dropped request doesn't immediately evict a device from the UI.
+_federation_cache: dict[int, dict] = {}
+_FEDERATION_GRACE_FAILURES = 3  # consecutive failures before marking unreachable
+
+
 @app.get("/api/federation/sessions")
 async def federation_sessions(request: Request) -> list[dict]:
     """Fetch sessions from all instances (local + remotes) and merge.
@@ -1220,7 +1227,12 @@ async def federation_sessions(request: Request) -> list[dict]:
     http_client: httpx.AsyncClient = request.app.state.federation_client
 
     async def fetch_remote(i: int, remote: dict) -> list[dict]:
-        """Fetch /api/sessions from a remote instance, returning session dicts or a status entry."""
+        """Fetch /api/sessions from a remote instance, returning session dicts or a status entry.
+
+        On success: cache the result and return tagged sessions (or {status: 'empty'} if none).
+        On transient failure: return cached sessions for up to _FEDERATION_GRACE_FAILURES
+        consecutive failures before promoting to {status: 'unreachable'}.
+        """
         url: str = remote.get("url", "")
         key: str = remote.get("key", "")
         remote_name: str = remote.get("name", url)
@@ -1231,6 +1243,8 @@ async def federation_sessions(request: Request) -> list[dict]:
                 headers={"Authorization": f"Bearer {key}"} if key else {},
             )
             if resp.status_code in (401, 403):
+                # Auth failure — clear cache so stale data is not served
+                _federation_cache.pop(remote_id, None)
                 return [
                     {
                         "status": "auth_failed",
@@ -1241,7 +1255,7 @@ async def federation_sessions(request: Request) -> list[dict]:
             resp.raise_for_status()
             sessions = resp.json()
             # Tag each session with deviceName, remoteId, and unique sessionKey
-            return [
+            tagged = [
                 {
                     **s,
                     "deviceName": remote_name,
@@ -1250,7 +1264,24 @@ async def federation_sessions(request: Request) -> list[dict]:
                 }
                 for s in sessions
             ]
+            # Update cache on every successful poll (even empty)
+            _federation_cache[remote_id] = {"sessions": tagged, "fail_count": 0}
+            if not tagged:
+                # Device is online but has zero tmux sessions — show a status tile
+                # rather than making the device completely invisible.
+                return [
+                    {
+                        "status": "empty",
+                        "remoteId": remote_id,
+                        "deviceName": remote_name,
+                    }
+                ]
+            return tagged
         except httpx.HTTPStatusError:
+            cached = _federation_cache.get(remote_id)
+            if cached and cached["fail_count"] < _FEDERATION_GRACE_FAILURES:
+                cached["fail_count"] += 1
+                return cached["sessions"]
             return [
                 {
                     "status": "unreachable",
@@ -1260,6 +1291,10 @@ async def federation_sessions(request: Request) -> list[dict]:
             ]
         except Exception as exc:
             _log.warning("Unexpected error fetching remote %s: %s", url, exc)
+            cached = _federation_cache.get(remote_id)
+            if cached and cached["fail_count"] < _FEDERATION_GRACE_FAILURES:
+                cached["fail_count"] += 1
+                return cached["sessions"]
             return [
                 {
                     "status": "unreachable",

{muxplex-0.3.2 → muxplex-0.3.4}/muxplex/tests/test_api.py

@@ -41,6 +41,22 @@ def patch_startup_and_state(tmp_path, monkeypatch):
     monkeypatch.setattr("muxplex.main._poll_loop", noop_poll_loop)
 
 
+@pytest.fixture(autouse=True)
+def reset_federation_cache():
+    """Clear _federation_cache before and after each test.
+
+    The module-level _federation_cache persists across tests in the same process,
+    causing cross-test contamination: a test that populates the cache for remoteId=0
+    causes a later test (also using remoteId=0) to get stale cached data instead of
+    the expected unreachable status.
+    """
+    import muxplex.main as main_mod
+
+    main_mod._federation_cache.clear()
+    yield
+    main_mod._federation_cache.clear()
+
+
 # ---------------------------------------------------------------------------
 # Client fixture — TestClient with lifespan enabled
 # ---------------------------------------------------------------------------
@@ -3036,3 +3052,215 @@ def test_put_settings_sync_ignores_nonsyncable_keys(client, tmp_path, monkeypatc
     assert local["host"] == "127.0.0.1", (
         f"Non-syncable key 'host' must remain '127.0.0.1', got: {local['host']}"
     )
+
+
+# ---------------------------------------------------------------------------
+# fetch_remote: zero-session visibility and flapping grace period
+# ---------------------------------------------------------------------------
+
+
+def test_fetch_remote_returns_empty_status_for_zero_sessions(
+    client, monkeypatch, tmp_path
+):
+    """When remote /api/sessions returns [], federation returns {status: 'empty'} entry.
+
+    A device that is online but has zero tmux sessions must not vanish silently.
+    Instead, the endpoint must include a {status: 'empty', deviceName: ...} entry
+    so the frontend can render a 'No sessions' tile.
+
+    Before implementation: fails because the list comprehension returns [] for empty
+    session lists, and the empty list is flattened into nothing.
+    """
+    import json
+    from unittest.mock import MagicMock
+
+    import httpx
+
+    import muxplex.settings as settings_mod
+
+    settings_path = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_mod, "SETTINGS_PATH", settings_path)
+    settings_path.write_text(
+        json.dumps(
+            {
+                "remote_instances": [
+                    {
+                        "url": "http://empty-host:8088",
+                        "key": "secret",
+                        "name": "empty-host",
+                    }
+                ]
+            }
+        )
+    )
+    monkeypatch.setattr("muxplex.main.get_session_list", lambda: [])
+    monkeypatch.setattr("muxplex.main.get_snapshots", lambda: {})
+
+    mock_resp = MagicMock(spec=httpx.Response)
+    mock_resp.status_code = 200
+    mock_resp.json.return_value = []
+    mock_resp.raise_for_status.return_value = None
+
+    async def mock_get(*args, **kwargs):
+        return mock_resp
+
+    mock_fed_client = MagicMock()
+    mock_fed_client.get = mock_get
+    monkeypatch.setattr(client.app.state, "federation_client", mock_fed_client)
+
+    response = client.get("/api/federation/sessions")
+    assert response.status_code == 200
+    data = response.json()
+    assert len(data) == 1, (
+        f"Expected exactly one status entry for empty remote, got {len(data)} entries: {data}"
+    )
+    assert data[0].get("status") == "empty", (
+        f"Expected status='empty' for zero-session remote, got: {data[0].get('status')!r}"
+    )
+    assert data[0].get("deviceName") == "empty-host", (
+        f"Expected deviceName='empty-host', got: {data[0].get('deviceName')!r}"
+    )
+
+
+def test_fetch_remote_uses_cache_on_transient_failure(client, monkeypatch, tmp_path):
+    """When remote fails after a prior success, cached sessions are returned (grace period).
+
+    A single failed HTTP request must not immediately evict the device from the UI.
+    The server keeps the last-known-good result and returns it for up to
+    _FEDERATION_GRACE_FAILURES consecutive failures.
+
+    Before implementation: fails because fetch_remote has no cache — transient failure
+    immediately returns {status: 'unreachable'}.
+    """
+    import json
+    from unittest.mock import MagicMock
+
+    import httpx
+
+    import muxplex.main as main_mod
+    import muxplex.settings as settings_mod
+
+    # Reset module-level cache so this test starts clean
+    monkeypatch.setattr(main_mod, "_federation_cache", {})
+
+    settings_path = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_mod, "SETTINGS_PATH", settings_path)
+    settings_path.write_text(
+        json.dumps(
+            {
+                "remote_instances": [
+                    {"url": "http://remote:8088", "key": "k", "name": "cache-host"}
+                ]
+            }
+        )
+    )
+    monkeypatch.setattr("muxplex.main.get_session_list", lambda: [])
+    monkeypatch.setattr("muxplex.main.get_snapshots", lambda: {})
+
+    call_count = [0]
+
+    async def mock_get_stateful(*args, **kwargs):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            mock_resp = MagicMock(spec=httpx.Response)
+            mock_resp.status_code = 200
+            mock_resp.json.return_value = [{"name": "sess1"}, {"name": "sess2"}]
+            mock_resp.raise_for_status.return_value = None
+            return mock_resp
+        raise httpx.TimeoutException("timeout", request=MagicMock())
+
+    mock_fed_client = MagicMock()
+    mock_fed_client.get = mock_get_stateful
+    monkeypatch.setattr(client.app.state, "federation_client", mock_fed_client)
+
+    # First call: succeeds and populates cache
+    r1 = client.get("/api/federation/sessions")
+    assert r1.status_code == 200
+    d1 = [s for s in r1.json() if s.get("deviceName") == "cache-host"]
+    assert len(d1) == 2, f"First call must return 2 sessions, got {d1}"
+
+    # Second call: remote times out — cache should return the 2 cached sessions
+    r2 = client.get("/api/federation/sessions")
+    assert r2.status_code == 200
+    d2 = [s for s in r2.json() if s.get("deviceName") == "cache-host"]
+    assert len(d2) == 2, f"Within grace period, must return 2 cached sessions, got {d2}"
+    assert not any(s.get("status") == "unreachable" for s in d2), (
+        "Within grace period, cached sessions must be returned, not 'unreachable'"
+    )
+
+
+def test_fetch_remote_marks_unreachable_after_grace_period(
+    client, monkeypatch, tmp_path
+):
+    """After _FEDERATION_GRACE_FAILURES consecutive failures, device is marked unreachable.
+
+    The grace period prevents flapping, but must not hide a genuinely offline device
+    indefinitely. After 3 consecutive failures the next poll must return
+    {status: 'unreachable'}.
+
+    Before implementation: fails because there is no cache at all — unreachable is
+    returned immediately on first failure.
+    """
+    import json
+    from unittest.mock import MagicMock
+
+    import httpx
+
+    import muxplex.main as main_mod
+    import muxplex.settings as settings_mod
+
+    # Reset module-level cache so this test starts clean
+    monkeypatch.setattr(main_mod, "_federation_cache", {})
+
+    settings_path = tmp_path / "settings.json"
+    monkeypatch.setattr(settings_mod, "SETTINGS_PATH", settings_path)
+    settings_path.write_text(
+        json.dumps(
+            {
+                "remote_instances": [
+                    {"url": "http://remote:8088", "key": "k", "name": "grace-host"}
+                ]
+            }
+        )
+    )
+    monkeypatch.setattr("muxplex.main.get_session_list", lambda: [])
+    monkeypatch.setattr("muxplex.main.get_snapshots", lambda: {})
+
+    call_count = [0]
+
+    async def mock_get_stateful(*args, **kwargs):
+        call_count[0] += 1
+        if call_count[0] == 1:
+            mock_resp = MagicMock(spec=httpx.Response)
+            mock_resp.status_code = 200
+            mock_resp.json.return_value = [{"name": "sess1"}]
+            mock_resp.raise_for_status.return_value = None
+            return mock_resp
+        raise httpx.TimeoutException("timeout", request=MagicMock())
+
+    mock_fed_client = MagicMock()
+    mock_fed_client.get = mock_get_stateful
+    monkeypatch.setattr(client.app.state, "federation_client", mock_fed_client)
+
+    # Call 1: success — populates cache
+    r = client.get("/api/federation/sessions")
+    d = r.json()
+    assert any(s.get("name") == "sess1" for s in d), "Call 1 must return sess1"
+
+    # Calls 2-4 (failures 1-3): within grace period — must return cached sessions
+    for i in range(3):
+        r = client.get("/api/federation/sessions")
+        d = r.json()
+        host_entries = [s for s in d if s.get("deviceName") == "grace-host"]
+        assert not any(s.get("status") == "unreachable" for s in host_entries), (
+            f"Call {i + 2}: fail_count={i + 1} is within grace period — "
+            f"must return cached sessions, not 'unreachable'. Got: {host_entries}"
+        )
+
+    # Call 5 (failure 4): exceeds grace period — must return unreachable
+    r = client.get("/api/federation/sessions")
+    d = r.json()
+    host_entries = [s for s in d if s.get("deviceName") == "grace-host"]
+    assert any(s.get("status") == "unreachable" for s in host_entries), (
+        f"After exceeding grace period, device must be marked 'unreachable'. Got: {host_entries}"
+    )

{muxplex-0.3.2 → muxplex-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "muxplex"
-version = "0.3.2"
+version = "0.3.4"
 description = "Web-based tmux session dashboard — access all your tmux sessions from any browser"
 readme = "README.md"
 license = { text = "MIT" }