arkaos 3.71.0 → 3.71.1

package/VERSION

@@ -1 +1 @@
-3.71.0
+3.71.1

package/core/terminal/__init__.py

@@ -16,6 +16,7 @@ from core.terminal.session import (
 )
 from core.terminal.audit import log_end, log_start
 from core.terminal.token import current_token
+from core.terminal.connections import ConnectionRegistry
 
 __all__ = [
     "TerminalSession",
@@ -24,4 +25,5 @@ __all__ = [
     "log_start",
     "log_end",
     "current_token",
+    "ConnectionRegistry",
 ]

package/core/terminal/connections.py

@@ -0,0 +1,46 @@
+"""Single active WebSocket connection per terminal session (v3.71.1).
+
+asyncio allows only one reader per fd, so two concurrent WebSockets on the
+same session would fight over the PTY master fd and the scrollback replay
+could duplicate output. This registry enforces "latest wins": a new
+connection supersedes the previous one (which the endpoint then closes),
+and release is guarded so a superseded connection's teardown cannot evict
+its replacement.
+
+Pure bookkeeping — no FastAPI import, so it's unit-testable standalone.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class ConnectionRegistry:
+    """Tracks the one live connection per session id."""
+
+    def __init__(self) -> None:
+        self._active: dict[str, Any] = {}
+
+    def acquire(self, session_id: str, conn: Any) -> Optional[Any]:
+        """Make ``conn`` the active connection for ``session_id``.
+
+        Returns the connection it superseded (for the caller to close), or
+        ``None`` when there was none / it was already active.
+        """
+        old = self._active.get(session_id)
+        self._active[session_id] = conn
+        return old if old is not conn else None
+
+    def release(self, session_id: str, conn: Any) -> bool:
+        """Drop ``conn`` iff it is still the active connection.
+
+        Returns whether it was — the caller should only tear down shared
+        resources (the fd reader) when this is ``True``.
+        """
+        if self._active.get(session_id) is conn:
+            del self._active[session_id]
+            return True
+        return False
+
+    def is_active(self, session_id: str, conn: Any) -> bool:
+        return self._active.get(session_id) is conn

package/dashboard/package.json

@@ -8,7 +8,8 @@
     "preview": "nuxt preview",
     "postinstall": "nuxt prepare",
     "lint": "eslint .",
-    "typecheck": "nuxt typecheck"
+    "typecheck": "nuxt typecheck",
+    "test:e2e": "playwright test"
   },
   "dependencies": {
     "@iconify-json/lucide": "^1.2.100",
@@ -34,6 +35,7 @@
   },
   "devDependencies": {
     "@nuxt/eslint": "^1.15.2",
+    "@playwright/test": "^1.60.0",
     "eslint": "^10.1.0",
     "typescript": "^6.0.2",
     "vue-tsc": "^3.2.6"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "3.71.0",
+  "version": "3.71.1",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "3.71.0"
+version = "3.71.1"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}

package/scripts/dashboard-api.py

@@ -2282,6 +2282,12 @@ def _terminal_origin_ok(origin: str) -> bool:
     )
 
 
+# v3.71.1 — enforce a single live WebSocket per session (latest wins), so a
+# reload or a second tab can't fight over the one PTY fd reader.
+from core.terminal.connections import ConnectionRegistry as _TerminalConnRegistry
+_terminal_conns = _TerminalConnRegistry()
+
+
 @app.get("/api/terminal/token")
 def terminal_token_endpoint():
     """Return the per-process bearer token used in WS handshakes.
@@ -2366,6 +2372,16 @@ async def ws_terminal(ws: WebSocket, session_id: str, token: str = Query("")):
 
     await ws.accept()
 
+    # v3.71.1 — single live connection per session: a newer connection
+    # (a reload, or a second tab) supersedes the previous one, which we
+    # close so it stops pumping the shared PTY fd.
+    superseded = _terminal_conns.acquire(session_id, ws)
+    if superseded is not None:
+        try:
+            await superseded.close(code=4409, reason="superseded by a newer connection")
+        except Exception:
+            pass
+
     # v3.71.0 — replay recent scrollback so a client reconnecting after
     # the operator navigated away / reloaded restores its session as it
     # left it. Sent before the live reader is attached, so the historical
@@ -2437,10 +2453,13 @@ async def ws_terminal(ws: WebSocket, session_id: str, token: str = Query("")):
         pass
     finally:
         pump_task.cancel()
-        try:
-            loop.remove_reader(session.master_fd)
-        except (ValueError, OSError):
-            pass
+        # Only the still-active connection owns the fd reader — a superseded
+        # connection tearing down must not remove its replacement's reader.
+        if _terminal_conns.release(session_id, ws):
+            try:
+                loop.remove_reader(session.master_fd)
+            except (ValueError, OSError):
+                pass
 
 
 @app.on_event("startup")