arkaos 3.70.10 → 3.71.1

package/VERSION

@@ -1 +1 @@
-3.70.10
+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/core/terminal/session.py

@@ -46,6 +46,13 @@ def _default_cwd() -> str:
     return os.path.expanduser("~")
 
 
+# v3.71.0 — in-memory scrollback so a reconnecting client (after the
+# operator navigates away or reloads the dashboard) can replay recent
+# output and find its session as it left it. Bounded, RAM-only, cleared
+# on close, never written to disk and never sent to the audit log.
+DEFAULT_SCROLLBACK_BYTES = 512 * 1024
+
+
 class TerminalSession:
     """A single forked PTY + the bookkeeping needed to drive it.
 
@@ -60,6 +67,7 @@ class TerminalSession:
         cwd: str,
         cols: int = 120,
         rows: int = 32,
+        scrollback_bytes: int = DEFAULT_SCROLLBACK_BYTES,
     ) -> None:
         self.session_id = session_id
         self.shell = shell
@@ -68,6 +76,8 @@ class TerminalSession:
         self.last_activity = time.monotonic()
         self.exit_code: Optional[int] = None
         self.title: str = ""
+        self.scrollback_max = max(0, int(scrollback_bytes))
+        self._scrollback = bytearray()
         self._closed = False
         self.pid, self.master_fd = pty.fork()
         if self.pid == 0:
@@ -104,8 +114,21 @@ class TerminalSession:
             raise
         if data:
             self.last_activity = time.monotonic()
+            self._record(data)
         return data
 
+    def _record(self, data: bytes) -> None:
+        """Append output to the bounded scrollback, evicting the oldest."""
+        if self.scrollback_max <= 0:
+            return
+        self._scrollback += data
+        if len(self._scrollback) > self.scrollback_max:
+            del self._scrollback[: -self.scrollback_max]
+
+    def scrollback(self) -> bytes:
+        """Snapshot of recent output, for replay on (re)connect."""
+        return bytes(self._scrollback)
+
     def write(self, data: bytes) -> int:
         if self._closed or self.master_fd < 0 or not data:
             return 0
@@ -172,6 +195,7 @@ class TerminalSession:
             except OSError:
                 pass
             self.master_fd = -1
+        self._scrollback.clear()
         self._closed = True
 
     def to_dict(self) -> dict[str, Any]:
@@ -207,6 +231,9 @@ class TerminalSessionManager:
         self.idle_timeout_s = int(
             os.environ.get("ARKAOS_TERMINAL_IDLE_S", idle_default)
         )
+        self.scrollback_bytes = int(
+            os.environ.get("ARKAOS_TERMINAL_SCROLLBACK_BYTES", DEFAULT_SCROLLBACK_BYTES)
+        )
         self._sessions: dict[str, TerminalSession] = {}
 
     def create(
@@ -230,6 +257,7 @@ class TerminalSessionManager:
             cwd=chosen_cwd,
             cols=cols,
             rows=rows,
+            scrollback_bytes=self.scrollback_bytes,
         )
         self._sessions[sid] = session
         audit.log_start(sid, chosen_shell, chosen_cwd)