soliplex 0.87__tar.gz → 0.88__tar.gz

{soliplex-0.87/src/soliplex.egg-info → soliplex-0.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soliplex
-Version: 0.87
+Version: 0.88
 Summary: An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface.
 Author-email: Enfold <info@enfoldsystems.net>
 Classifier: Programming Language :: Python :: 3

{soliplex-0.87 → soliplex-0.88}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.87"
+version = "0.88"
 description = "An AI-powered Retrieval-Augmented Generation (RAG) system with a modern web interface."
 authors = [{ name = "Enfold", email = "info@enfoldsystems.net" }]
 readme = "README.md"

{soliplex-0.87 → soliplex-0.88}/src/soliplex/agui/__init__.py

@@ -261,6 +261,20 @@ class Thread(abc.ABC):
         """Return runs for this thread"""
 
 
+class ThreadPagePosition(typing.NamedTuple):
+    """Where one page of a cross-room thread listing ended.
+
+    The listing's own sort key, so the next page resumes strictly after
+    it no matter what was created, deleted or reordered in between.
+    """
+
+    last_activity: datetime.datetime
+    """The last thread's activity time"""
+
+    thread_id: str
+    """The last thread's ID, ordering threads sharing that time"""
+
+
 class ThreadStorage(abc.ABC):
     @abc.abstractmethod
     async def list_user_threads(
@@ -275,6 +289,39 @@ class ThreadStorage(abc.ABC):
         in that room.
         """
 
+    @abc.abstractmethod
+    async def list_user_threads_page(
+        self,
+        *,
+        user_name: str,
+        room_ids: list[str],
+        limit: int,
+        after: ThreadPagePosition | None = None,
+    ) -> tuple[
+        list[tuple[Thread, datetime.datetime]],
+        ThreadPagePosition | None,
+    ]:
+        """Return one page of the user's threads across several rooms.
+
+        Unlike 'list_user_threads', which is scoped to a single room,
+        this spans every room in 'room_ids' -- the caller is responsible
+        for having already filtered those to the rooms the user may see.
+        An empty 'room_ids' therefore yields an empty page rather than
+        every room's threads.
+
+        Threads are ordered by their own last activity, most recent
+        first: the latest of each run's finish (or, while unfinished, its
+        start), falling back to the thread's creation for a thread with
+        no runs. Each thread comes back paired with that time.
+
+        Paging is by position rather than by offset: 'after' is the
+        position of the last thread on the previous page, and the second
+        element returned is the position to pass for the next page, or
+        'None' when this page is the last. A thread created, deleted or
+        moved to the top by new activity between two requests therefore
+        never shifts the rest of the listing under the reader.
+        """
+
     @abc.abstractmethod
     async def get_thread(
         self,

{soliplex-0.87 → soliplex-0.88}/src/soliplex/agui/persistence.py

@@ -125,6 +125,95 @@ class ThreadStorage(agui.ThreadStorage):
             result = await session.scalars(query)
         return result
 
+    async def list_user_threads_page(
+        self,
+        *,
+        user_name: str,
+        room_ids: list[str],
+        limit: int,
+        after: agui.ThreadPagePosition | None = None,
+    ) -> tuple[
+        list[tuple[agui_schema.Thread, datetime.datetime]],
+        agui.ThreadPagePosition | None,
+    ]:
+        room_ids = list(room_ids)
+
+        if not room_ids:
+            # No accessible rooms: short-circuit rather than emitting an
+            # 'IN ()', which SQLAlchemy warns about and which reads as
+            # "unfiltered" to anyone skimming the SQL.
+            return [], None
+
+        async with self.session as session:
+            # One row per thread: a grouped subquery rather than joining
+            # runs directly, which would multiply each thread by its run
+            # count and corrupt LIMIT.
+            thread_activity = (
+                sqla_sql.select(
+                    agui_schema.Run.thread_id_.label("thread_id_"),
+                    _LAST_ACTIVITY.label("last_activity"),
+                )
+                .join(agui_schema.Run.thread)
+                .where(agui_schema.Thread.user_name == user_name)
+                .group_by(agui_schema.Run.thread_id_)
+                .subquery()
+            )
+
+            # A thread with no runs yet is as recent as its creation.
+            activity = sqla_sql.func.coalesce(
+                thread_activity.c.last_activity,
+                agui_schema.Thread.created,
+            )
+
+            query = (
+                sqla_sql.select(agui_schema.Thread, activity)
+                .outerjoin(
+                    thread_activity,
+                    thread_activity.c.thread_id_ == agui_schema.Thread.id_,
+                )
+                .where(agui_schema.Thread.user_name == user_name)
+                .where(agui_schema.Thread.room_id.in_(room_ids))
+            )
+
+            if after is not None:
+                # Strictly past the previous page's last thread in the
+                # same order the page is sorted in; spelled out rather
+                # than as a row-value comparison, which not every
+                # backend supports.
+                query = query.where(
+                    sqla_sql.or_(
+                        activity < after.last_activity,
+                        sqla_sql.and_(
+                            activity == after.last_activity,
+                            agui_schema.Thread.thread_id < after.thread_id,
+                        ),
+                    )
+                )
+
+            # One row past the page says whether another page follows,
+            # without a separate count.
+            query = query.order_by(
+                activity.desc(),
+                agui_schema.Thread.thread_id.desc(),
+            ).limit(limit + 1)
+
+            rows = [
+                (a_thread, _as_utc(last_activity))
+                for a_thread, last_activity in (
+                    await session.execute(query)
+                ).all()
+            ]
+
+        if len(rows) <= limit:
+            return rows, None
+
+        rows = rows[:limit]
+        last_thread, last_activity = rows[-1]
+        return rows, agui.ThreadPagePosition(
+            last_activity=last_activity,
+            thread_id=last_thread.thread_id,
+        )
+
     async def get_thread(
         self,
         *,

{soliplex-0.87 → soliplex-0.88}/src/soliplex/authn.py

@@ -13,6 +13,7 @@ from fastapi import security
 
 from soliplex import installation
 from soliplex import loggers
+from soliplex import token_mint
 from soliplex.config import authsystem as config_authsystem
 
 UserClaims = dict[str, typing.Any]
@@ -28,6 +29,9 @@ _oauth = None
 
 JWT_VALIDATION_NO_TOKEN = "JWT validation failed (no token)"
 JWT_VALIDATION_INVALID_TOKEN = "JWT validation failed (invalid token)"
+SERVICE_TOKEN_VALIDATION_INVALID_TOKEN = (
+    "Service token validation failed (invalid token)"
+)
 
 INSECURE_COOKIES_ENV_VAR = "_SOLIPLEX_INSECURE_SESSION_COOKIE"
 
@@ -41,6 +45,8 @@ AUTHN_COOKIE_ALWAYS_CLAIMS = ("sub",)
 # as the budget for the serialized value alone.
 AUTHN_COOKIE_MAX_SIZE = 4000
 
+SERVICE_TOKEN_SECRET_NAME = "URL_SAFE_TOKEN_SECRET"
+
 
 def _get_authsystem_config(
     *,
@@ -113,6 +119,25 @@ def authenticate(
 
         errors[auth_system.id] = msg
 
+    claims, service_token_reason = token_mint.load_service_token(
+        the_installation.get_secret(SERVICE_TOKEN_SECRET_NAME),
+        token,
+    )
+    if claims is not None:
+        return claims
+
+    if service_token_reason != loggers.AUTHN_SERVICE_TOKEN_BAD_SIGNATURE:
+        # The signature verified, so the token is a service token:
+        # report the error accordingly.
+        logger.error(
+            loggers.AUTHN_SERVICE_TOKEN_INVALID,
+            reason=service_token_reason,
+        )
+        raise fastapi.HTTPException(
+            status_code=401,
+            detail=SERVICE_TOKEN_VALIDATION_INVALID_TOKEN,
+        )
+
     for oidc_system_id, msg in errors.items():
         logger.error(
             loggers.AUTHN_JWT_INVALID,
@@ -120,6 +145,11 @@ def authenticate(
             reason=msg,
         )
 
+    logger.error(
+        loggers.AUTHN_SERVICE_TOKEN_INVALID,
+        reason=service_token_reason,
+    )
+
     raise fastapi.HTTPException(
         status_code=401,
         detail=JWT_VALIDATION_INVALID_TOKEN,

{soliplex-0.87 → soliplex-0.88}/src/soliplex/authz/__init__.py

@@ -218,6 +218,22 @@ class AdminUserPolicy(abc.ABC):
     async def clear_admin_user_discriminators(self):
         """Remove all admin user discriminators from the admin users table."""
 
+    @abc.abstractmethod
+    async def is_admin(
+        self,
+        user_token: UserToken,
+    ) -> bool:
+        """Is the user represented by 'user_token' an admin user?
+
+        Matches 'user_token' against each admin entry's JSONPath query;
+        the user is an admin when any query matches.
+
+        This test is for *non-audit* checks, e.g. to support whether
+        the frontend offers an admin-only option:  it is not intended
+        for use where an actual admin operation is performed (see
+        'check_admin_access' for that case).
+        """
+
     @abc.abstractmethod
     async def check_admin_access(
         self,
@@ -226,11 +242,13 @@ class AdminUserPolicy(abc.ABC):
         resource: str,
         action: str,
     ) -> bool:
-        """Is the user represented by 'user_token' an admin user?
+        """Validate that the user represented by 'user_token' is an admin user
 
-        Matches 'user_token' against each admin entry's JSONPath query;
-        the user is an admin when any query matches. 'resource' / 'action'
-        name the privileged operation being gated (for the audit record).
+        This check is called at the point that an auditable admin action
+        is being performed.  It calls the non-audit 'is_admin' check, and then
+        creates the audit record, identifying the privileged operation being
+        gated using 'resource' / 'action'. Finally, it returns the result
+        from 'is_admin'.
         """
 
 
@@ -238,14 +256,14 @@ class RoomAuthorizationPolicy(abc.ABC):
     """Protocol for checking / managing room authorization policies."""
 
     @abc.abstractmethod
-    async def check_room_access(
+    async def has_room_permission(
         self,
         room_id: str,
         user_token: UserToken | None,
         *,
         permission: Permission,
     ) -> bool:
-        """Can the user represented by 'user_token' access a room?
+        """Does the user have a 'permission' on a given room?
 
         For a room with an authorization policy, return whether the result
         of its ``check_token`` for the user token and permission is ALLOW.
@@ -255,6 +273,29 @@ class RoomAuthorizationPolicy(abc.ABC):
         - Return True for READ (such rooms are public for read).
 
         - Return False for WRITE and ADMIN.
+
+        This test is for *non-audit* checks, e.g. to support whether
+        the frontend offers an option which would require the permission:
+        it is not intended for use where the actual gated operation is
+        performed (see 'check_room_access' for that case).
+        """
+
+    @abc.abstractmethod
+    async def check_room_access(
+        self,
+        room_id: str,
+        user_token: UserToken | None,
+        *,
+        permission: Permission,
+    ) -> bool:
+        """Validate that the user has the required permission for a room.
+
+        Calls the non-audit 'has_room_permission' check first.
+
+        This check is called at the point that an auditable action
+        is being performed.  It calls the non-audit 'has_room_permission'
+        check, and then creates the audit record, identifying the required
+        permission.  Finally, it returns the result from 'has_room_permission'.
         """
 
     @abc.abstractmethod

{soliplex-0.87 → soliplex-0.88}/src/soliplex/authz/persistence.py

@@ -217,6 +217,17 @@ class AdminUserPolicy(_SessionPolicy, authz.AdminUserPolicy):
                 await session.delete(admin_user)
         self._audit.admin_users_cleared()
 
+    async def is_admin(
+        self,
+        user_token: authz.UserToken,
+    ) -> bool:
+        """Is the user represented by 'user_token' an admin user?
+
+        This test does not create an audit record.
+        """
+        async with self.session as session:
+            return await _user_is_admin(user_token, session)
+
     async def check_admin_access(
         self,
         user_token: authz.UserToken,
@@ -224,13 +235,14 @@ class AdminUserPolicy(_SessionPolicy, authz.AdminUserPolicy):
         resource: str,
         action: str,
     ) -> bool:
-        """Is the user represented by 'user_token' an admin user?
+        """Validate admin access at point of privileged use.
+
+        Calls the non-audit 'is_admin' query first.
 
         'resource' / 'action' name the privileged operation being gated;
         they are folded into the emitted 'admin access' audit record.
         """
-        async with self.session as session:
-            is_admin = await _user_is_admin(user_token, session)
+        is_admin = await self.is_admin(user_token)
         if is_admin:
             self._audit.admin_access_allowed(resource=resource, action=action)
         else:
@@ -248,14 +260,14 @@ class RoomAuthorizationPolicy(_SessionPolicy, authz.RoomAuthorizationPolicy):
         self._audit = loggers.RoomAuthzAuditLog(claims=claims)
         self._access_audit = loggers.RoomAccessAuditLog(claims=claims)
 
-    async def check_room_access(
+    async def has_room_permission(
         self,
         room_id: str,
         user_token: authz.UserToken | None,
         *,
         permission: authz.Permission,
     ) -> bool:
-        """Can the user represented by 'user_token' access a room?
+        """Does the user have a 'permission' on a given room?
 
         For a room with an authorization policy, return whether the result
         of its ``check_token`` for the user token and permission is ALLOW.
@@ -265,6 +277,8 @@ class RoomAuthorizationPolicy(_SessionPolicy, authz.RoomAuthorizationPolicy):
         - Return True for READ (such rooms are public for read).
 
         - Return False for WRITE and ADMIN.
+
+        This test does *not* create an audit record.
         """
         async with self.session as session:
             policy = await _find_room_policy(room_id, session)
@@ -274,9 +288,28 @@ class RoomAuthorizationPolicy(_SessionPolicy, authz.RoomAuthorizationPolicy):
                 allow_deny = policy.check_token(
                     user_token, permission=permission
                 )
-                result = allow_deny == authz.AllowDeny.ALLOW
+                return allow_deny == authz.AllowDeny.ALLOW
             else:
-                result = permission is authz.Permission.READ
+                return permission is authz.Permission.READ
+
+    async def check_room_access(
+        self,
+        room_id: str,
+        user_token: authz.UserToken | None,
+        *,
+        permission: authz.Permission,
+    ) -> bool:
+        """Validate that the user has the required permission for a room.
+
+        Calls the non-audit 'has_room_permission' check first.
+
+        Creates an audit record.
+        """
+        result = await self.has_room_permission(
+            room_id,
+            user_token,
+            permission=permission,
+        )
 
         if result:
             self._access_audit.room_access_allowed(

{soliplex-0.87 → soliplex-0.88}/src/soliplex/cli/main.py

@@ -21,6 +21,7 @@ from soliplex.cli import database
 from soliplex.cli import ollama
 from soliplex.cli import room_authz
 from soliplex.cli import serve
+from soliplex.cli import service_token
 from soliplex.cli import types
 from soliplex.config import installation as config_installation
 
@@ -101,6 +102,7 @@ the_cli.add_typer(database.app)
 the_cli.add_typer(admin_users.app)
 the_cli.add_typer(room_authz.app)
 the_cli.add_typer(ollama.app)
+the_cli.add_typer(service_token.app)
 
 
 misc_app = typer.Typer()