fred-core 3.4.4__tar.gz → 3.4.7__tar.gz

{fred_core-3.4.4 → fred_core-3.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-core
-Version: 3.4.4
+Version: 3.4.7
 Summary: Core shared utilities for Fred backends (config, storage, security, and runtime helpers).
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/__init__.py

@@ -11,6 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from fred_core.conversion import (
+    DEFAULT_PPTX_PDF_TIMEOUT_SECONDS,
+    convert_pptx_bytes_to_pdf,
+    convert_pptx_file_to_pdf,
+)
 from fred_core.documents import (
     AccessInfo,
     BaseDocumentMetadataStore,
@@ -208,6 +213,10 @@ __all__ = [
     "GcuVersionsType",
     "get_user_store",
     "get_config",
+    # conversion
+    "DEFAULT_PPTX_PDF_TIMEOUT_SECONDS",
+    "convert_pptx_bytes_to_pdf",
+    "convert_pptx_file_to_pdf",
     "TeamMetadata",
     "TeamMetadataPatch",
     "TeamMetadataStore",

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/common/__init__.py

@@ -20,6 +20,7 @@ from .config_loader import (
 )
 from .env import coerce_bool, read_env_bool
 from .fastapi_handlers import register_exception_handlers
+from .gcs_client import build_gcs_client
 from .lru_cache import ThreadSafeLRUCache
 from .resilient_sink import ResilientSinkStore
 from .structures import (
@@ -64,6 +65,7 @@ __all__ = [
     "ResilientSinkStore",
     "TemporalSchedulerConfig",
     "ThreadSafeLRUCache",
+    "build_gcs_client",
     "coerce_bool",
     "load_configuration_with_config_files",
     "parse_yaml_mapping_file",

fred_core-3.4.7/fred_core/common/gcs_client.py

@@ -0,0 +1,52 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import google.auth
+from google.api_core.client_options import ClientOptions
+from google.cloud import storage
+
+
+def build_gcs_client(project_id: Optional[str] = None) -> storage.Client:
+    """Build a GCS client whose universe domain matches the loaded ADC credentials.
+
+    Why this exists:
+    - Bare ``storage.Client(project=project_id)`` implicitly assumes the
+      ``googleapis.com`` universe domain. Under Trusted Partner Cloud /
+      sovereign deployments (e.g. S3NS, the Thales/Google joint venture cloud
+      in France), Workload Identity Federation ADC credentials declare a
+      different universe domain (e.g. ``s3nsapis.fr``), and the client raises
+      ``google.api_core.universe.UniverseMismatchError`` the moment it tries
+      to authenticate: "The configured universe domain (googleapis.com) does
+      not match the universe domain found in the credentials (s3nsapis.fr)."
+    - Explicitly loading ADC and mirroring ``credentials.universe_domain``
+      into ``client_options`` makes every GCS-backed store portable across
+      public GCP and sovereign GCP variants with zero extra configuration —
+      the client always trusts whatever universe the credentials actually
+      belong to instead of assuming the public default.
+
+    Used by every native-GCS backend (fred-core's content store and virtual
+    filesystem, knowledge-flow's content store and file store) so the fix
+    lives in one place.
+    """
+
+    credentials, adc_project = google.auth.default()
+    return storage.Client(
+        project=project_id or adc_project,
+        credentials=credentials,
+        client_options=ClientOptions(universe_domain=credentials.universe_domain),
+    )

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/common/utils.py

@@ -14,11 +14,12 @@
 
 import logging
 import uuid
+from typing import NoReturn
 
 from fastapi import HTTPException
 
 
-def raise_internal_error(logger: logging.Logger, msg: str, exc: Exception):
+def raise_internal_error(logger: logging.Logger, msg: str, exc: Exception) -> NoReturn:
     """
     Raise a FastAPI HTTPException (500) while logging the full exception with a unique error ID.
 

fred_core-3.4.7/fred_core/conversion/__init__.py

@@ -0,0 +1,25 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from fred_core.conversion.pptx_pdf import (
+    DEFAULT_PPTX_PDF_TIMEOUT_SECONDS,
+    convert_pptx_bytes_to_pdf,
+    convert_pptx_file_to_pdf,
+)
+
+__all__ = [
+    "DEFAULT_PPTX_PDF_TIMEOUT_SECONDS",
+    "convert_pptx_bytes_to_pdf",
+    "convert_pptx_file_to_pdf",
+]

fred_core-3.4.7/fred_core/conversion/pptx_pdf.py

@@ -0,0 +1,147 @@
+# Copyright Thales 2026
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Shared, best-effort PPTX→PDF conversion using headless LibreOffice.
+
+Why this lives in ``fred-core``:
+- Both Knowledge Flow (slide vision enrichment) and the Agentic PPT-filler preview
+  need the exact same ``soffice`` invocation. Keeping one implementation here means
+  there is a single place to harden (timeout, error handling) instead of two drifting
+  ``subprocess.run`` calls.
+
+Contract:
+- The conversion is **best-effort**: any failure (missing ``soffice``, a non-zero exit,
+  a timeout, or no PDF produced) returns ``None`` (for the bytes helper) rather than
+  raising through the caller. Callers decide how to degrade — the preview pane, for
+  instance, still returns the ``.pptx`` when the PDF cannot be produced.
+- The bytes helper (:func:`convert_pptx_bytes_to_pdf`) is **async and bounded**: it runs
+  ``soffice`` off the event loop via ``asyncio.to_thread`` with a timeout, so it is safe
+  to call from an async tool without stalling the turn.
+
+``soffice`` is expected to be installed in both backend images.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import shutil
+import subprocess  # nosec: controlled command arguments, shell=False
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# LibreOffice can occasionally hang (font server, first-run profile init). A bounded
+# timeout keeps a stuck conversion from stalling an async agent turn indefinitely.
+DEFAULT_PPTX_PDF_TIMEOUT_SECONDS = 60.0
+
+# Same export filter the Knowledge Flow processor has used in production: embed standard
+# fonts and pin the PDF version so the rendered deck is faithful across viewers.
+_PDF_EXPORT_FILTER = "pdf:writer_pdf_Export:EmbedStandardFonts=True,SelectPdfVersion=1"
+
+
+def convert_pptx_file_to_pdf(
+    pptx_path: Path,
+    timeout_seconds: float = DEFAULT_PPTX_PDF_TIMEOUT_SECONDS,
+) -> Path | None:
+    """Convert a ``.pptx`` file to a PDF next to it using headless LibreOffice.
+
+    Blocking; returns the produced ``.pdf`` path, or ``None`` when ``soffice`` is
+    missing, fails, times out, or produces no file. Prefer :func:`convert_pptx_bytes_to_pdf`
+    from async code — this variant exists for synchronous callers (e.g. the Knowledge Flow
+    slide renderer) that already own a temp directory.
+    """
+    pdf_path = pptx_path.with_suffix(".pdf")
+    soffice_path = shutil.which("soffice")
+    if not soffice_path:
+        logger.error(
+            "[PPTX2PDF] LibreOffice (soffice) is not installed or not in PATH."
+        )
+        return None
+
+    try:
+        subprocess.run(  # nosec: controlled command arguments, shell=False
+            [
+                soffice_path,
+                "--headless",
+                "--nologo",
+                "--nofirststartwizard",
+                "--convert-to",
+                _PDF_EXPORT_FILTER,
+                "--outdir",
+                str(pptx_path.parent),
+                str(pptx_path),
+            ],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=timeout_seconds,
+        )
+    except subprocess.TimeoutExpired:
+        logger.error(
+            "[PPTX2PDF] LibreOffice conversion timed out after %.0fs.", timeout_seconds
+        )
+        return None
+    except subprocess.CalledProcessError as exc:
+        logger.error(
+            "[PPTX2PDF] LibreOffice conversion failed: %s",
+            exc.stderr.decode(errors="ignore") if exc.stderr else exc,
+        )
+        return None
+
+    if pdf_path.exists():
+        logger.info("[PPTX2PDF] Converted PPTX to PDF: %s", pdf_path)
+        return pdf_path
+
+    logger.warning("[PPTX2PDF] Conversion completed but PDF not found: %s", pdf_path)
+    return None
+
+
+async def convert_pptx_bytes_to_pdf(
+    pptx_bytes: bytes,
+    timeout_seconds: float = DEFAULT_PPTX_PDF_TIMEOUT_SECONDS,
+) -> bytes | None:
+    """Convert in-memory ``.pptx`` bytes to PDF bytes, off the event loop and bounded.
+
+    Returns the PDF bytes, or ``None`` when the conversion is unavailable or fails (missing
+    ``soffice``, non-zero exit, timeout, or no PDF produced). Never raises for a conversion
+    problem, so a caller can treat the preview as best-effort.
+
+    Example:
+    ```python
+    pdf = await convert_pptx_bytes_to_pdf(filled_bytes)
+    if pdf is None:
+        ...  # keep the .pptx, skip the preview
+    ```
+    """
+
+    def _run() -> bytes | None:
+        with tempfile.TemporaryDirectory(prefix="pptx2pdf-") as tmp:
+            pptx_path = Path(tmp) / "deck.pptx"
+            pptx_path.write_bytes(pptx_bytes)
+            pdf_path = convert_pptx_file_to_pdf(
+                pptx_path, timeout_seconds=timeout_seconds
+            )
+            if pdf_path is None:
+                return None
+            return pdf_path.read_bytes()
+
+    try:
+        return await asyncio.to_thread(_run)
+    except (
+        Exception
+    ):  # pragma: no cover - defensive: never let conversion break the caller
+        logger.exception("[PPTX2PDF] Unexpected error during PPTX→PDF conversion.")
+        return None

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/filesystem/gcs_filesystem.py

@@ -17,12 +17,12 @@ import re
 import time
 from typing import List, Optional, Set
 
+from fred_core.common.gcs_client import build_gcs_client
 from fred_core.filesystem.structures import (
     BaseFilesystem,
     FilesystemResourceInfo,
     FilesystemResourceInfoResult,
 )
-from google.cloud import storage
 from google.cloud.exceptions import NotFound
 
 logger = logging.getLogger(__name__)
@@ -67,9 +67,7 @@ class GcsFilesystem(BaseFilesystem):
         # Prefix injected externally by the app if needed (mirrors MinioFilesystem).
         self.prefix: str | None = None
 
-        self.client = (
-            storage.Client(project=project_id) if project_id else storage.Client()
-        )
+        self.client = build_gcs_client(project_id)
         self.bucket = self.client.bucket(bucket_name)
 
     def health_check(self) -> dict:
@@ -222,12 +220,14 @@ class GcsFilesystem(BaseFilesystem):
             except NotFound:
                 logger.warning("[GCS_DELETE] already gone: %s", blob.name)
 
-        # Delete the object itself and a possible directory marker.
+        # Delete the object itself and a possible directory marker. The marker in
+        # particular may simply never have existed, so NotFound here is routine,
+        # not warning-worthy.
         for key in (resolved, prefix):
             try:
                 self.bucket.blob(key).delete()
             except NotFound:
-                pass
+                logger.debug("[GCS_DELETE] already gone: %s", key)
 
     async def print_root_dir(self) -> str:
         """Return the logical root URI in ``gs://bucket/prefix`` form."""

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/security/models.py

@@ -63,8 +63,17 @@ class Resource(str, Enum):
     ORGANIZATION = "organization"
 
 
-class AuthorizationError(Exception):
-    """Raised when a user is not authorized to perform an action."""
+class AuthorizationError(PermissionError):
+    """Raised when a user is not authorized to perform an action.
+
+    Inherits from the builtin `PermissionError` (not bare `Exception`) so that
+    every call site's `except PermissionError` — the standard ReBAC-denial ->
+    403 mapping — also catches this without needing its own `except
+    AuthorizationError` clause. Without this, a denial raised via
+    `check_permission_or_raise` (which raises `AuthorizationError`) falls
+    through to a generic `except Exception` handler and surfaces as an
+    unhandled 500 instead of 403 wherever only `PermissionError` is caught.
+    """
 
     def __init__(
         self,

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/security/oidc.py

@@ -50,6 +50,15 @@ CLOCK_SKEW_SECONDS = int(os.getenv("FRED_JWT_CLOCK_SKEW", "0"))  # optional leew
 JWT_CACHE_ENABLED = read_env_bool("FRED_JWT_CACHE_ENABLED", default=True)
 JWT_CACHE_TTL_SECONDS = int(os.getenv("FRED_JWT_CACHE_TTL", "60"))
 JWT_CACHE_MAX_SIZE = int(os.getenv("FRED_JWT_CACHE_SIZE", "512"))
+# Application-side ceiling on token lifetime (exp - iat), independent of
+# whatever an IdP was configured to issue. Unlike STRICT_ISSUER/STRICT_AUDIENCE
+# (opt-in, gated behind the c3 profile, never enabled by any config in this
+# repo), this stays on by default: a misconfigured or unfamiliar IdP issuing
+# long-lived tokens should not be silently trusted. Fred's own M2M provider
+# (`backend_to_backend_auth.py`) already mints short-lived, auto-refreshed
+# tokens per call, so this does not affect normal service-to-service traffic
+# — raise the env var if a deployment genuinely needs a longer ceiling.
+MAX_TOKEN_LIFETIME_SECONDS = int(os.getenv("FRED_JWT_MAX_LIFETIME_SECONDS", "3600"))
 
 # Initialize global variables (to be set later)
 KEYCLOAK_ENABLED = False
@@ -404,6 +413,50 @@ def decode_jwt(token: str) -> KeycloakUser:
             headers={"WWW-Authenticate": "Bearer error='invalid_token'"},
         )
 
+    # Defense-in-depth ceiling on token lifetime, independent of the issuing
+    # IdP's own configuration (see MAX_TOKEN_LIFETIME_SECONDS docstring above).
+    # `verify_exp` above only rejects a token that has already expired; this
+    # additionally rejects one that was never supposed to live this long in
+    # the first place, regardless of whether it currently happens to still be
+    # valid.
+    iat, exp = payload.get("iat"), payload.get("exp")
+    if isinstance(iat, (int, float)) and isinstance(exp, (int, float)):
+        lifetime_seconds = exp - iat
+        if lifetime_seconds < 0:
+            # `verify_exp` above only checks exp against "now" — it does not
+            # relate exp to iat, so a token claiming iat after its own exp
+            # (malformed, or a confused/misconfigured IdP) can still pass it
+            # as long as exp itself is still in the future. That negative
+            # lifetime would otherwise fail the ">" ceiling check below
+            # silently instead of being rejected.
+            logger.warning(
+                "[AUTH] JWT has negative lifetime (exp before iat): iat=%s exp=%s sub=%s",
+                iat,
+                exp,
+                payload.get("sub"),
+            )
+            raise HTTPException(
+                status_code=401,
+                detail="Token has invalid iat/exp claims",
+                headers={
+                    "WWW-Authenticate": "Bearer error='invalid_token', error_description='exp before iat'"
+                },
+            )
+        if lifetime_seconds > MAX_TOKEN_LIFETIME_SECONDS:
+            logger.warning(
+                "[AUTH] JWT lifetime exceeds policy ceiling: lifetime=%ss max=%ss sub=%s",
+                lifetime_seconds,
+                MAX_TOKEN_LIFETIME_SECONDS,
+                payload.get("sub"),
+            )
+            raise HTTPException(
+                status_code=401,
+                detail="Token lifetime exceeds the maximum permitted duration",
+                headers={
+                    "WWW-Authenticate": "Bearer error='invalid_token', error_description='token lifetime too long'"
+                },
+            )
+
     # Extract client roles
     client_roles = []
     if "resource_access" in payload:

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/security/rebac/rebac_engine.py

@@ -21,6 +21,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Iterable
 
+from fred_core.common.team_id import is_personal_team_id, personal_team_id
 from fred_core.logs.audit_log import emit_audit_log
 from fred_core.security.models import AuthorizationError, Resource
 from fred_core.security.structure import KeycloakUser
@@ -166,9 +167,21 @@ class TeamPermission(str, Enum):
 
 # Team permissions a `service_agent` caller is allowed to satisfy without an OpenFGA
 # relation (RFC EVAL-AUTH, Solution A). Read-only: the evaluation worker executes
-# agents (gated by CAN_READ) and never mutates a team. Any write permission falls
-# through to the normal ReBAC check and is therefore denied.
-SERVICE_AGENT_ALLOWED_TEAM_PERMISSIONS = frozenset({TeamPermission.CAN_READ})
+# agents and prepares their execution context, never mutates a team. Any write
+# permission falls through to the normal ReBAC check and is therefore denied.
+#
+# CAN_USE_TEAM_AGENTS (2026-07-20, AGENT-EVALUATION-RFC.md §8.6): added after an
+# AUTHZ-05 review moved `POST .../agent-instances/{id}/prepare-execution` from
+# CAN_READ to CAN_USE_TEAM_AGENTS (real prompt content leak, product/api.py) without
+# updating this allowlist to match — the evaluation worker's M2M identity, which
+# structurally never holds a team relation, was then unconditionally denied on every
+# run case. Safe to include: CAN_USE_TEAM_AGENTS gates read/prepare only, never a
+# mutation, and the leak concern that moved prepare-execution off CAN_READ
+# (`context_prompt_text`) never applies to the worker's calls — they never pass
+# `session_id`, the only way that field is populated.
+SERVICE_AGENT_ALLOWED_TEAM_PERMISSIONS = frozenset(
+    {TeamPermission.CAN_READ, TeamPermission.CAN_USE_TEAM_AGENTS}
+)
 
 
 class AgentPermission(str, Enum):
@@ -346,6 +359,7 @@ class RebacEngine(ABC):
         - Save `team thales owner tag cir`.
         Returns a backend-specific consistency token when available.
         """
+        self._reject_unsanctioned_personal_team_write(relation)
         token = await self._persist_relation(relation)
         if self.enabled:
             emit_audit_log(
@@ -357,6 +371,48 @@ class RebacEngine(ABC):
             )
         return token
 
+    @staticmethod
+    def _reject_unsanctioned_personal_team_write(relation: Relation) -> None:
+        """Enforce the personal-team tuple invariant at the one audited write chokepoint.
+
+        A personal team (`personal-<uid>`) is a real ReBAC team object (AUTHZ-08),
+        but the *only* tuples ever allowed to name one are:
+        - the owner's own `team_editor` grant, self-healed by
+          `_ensure_personal_team_editor` on first touch;
+        - the structural `organization -> team` edge written by
+          `ensure_team_organization_relations` (same shape used for every team).
+
+        Every other shape — a different user, an elevated role, another relation
+        type — is refused here, unconditionally, regardless of caller. This is
+        what makes writing a real tuple for personal teams safe: no admin API,
+        import/export path, or future caller can ever grant (or be tricked into
+        granting) access to someone else's personal space, because there is
+        exactly one write chokepoint (`add_relation`) and it only recognizes
+        these two shapes for personal-team resources.
+        """
+        if relation.resource.type != Resource.TEAM or not is_personal_team_id(
+            relation.resource.id
+        ):
+            return
+        is_owner_editor_grant = (
+            relation.subject.type == Resource.USER
+            and relation.relation == RelationType.TEAM_EDITOR
+            and relation.resource.id == personal_team_id(relation.subject.id)
+        )
+        is_organization_edge = (
+            relation.subject.type == Resource.ORGANIZATION
+            and relation.subject.id == ORGANIZATION_ID
+            and relation.relation == RelationType.ORGANIZATION
+        )
+        if is_owner_editor_grant or is_organization_edge:
+            return
+        raise ValueError(
+            f"Refusing to write {relation.relation.value} for "
+            f"{relation.subject.type.value}:{relation.subject.id} onto personal "
+            f"team {relation.resource.id!r} — only the space's own owner may hold "
+            f"team_editor there, and it is provisioned automatically."
+        )
+
     @abstractmethod
     async def _persist_relation(self, relation: Relation) -> str | None:
         """Backend-specific write for one relation.
@@ -598,10 +654,21 @@ class RebacEngine(ABC):
         consistency_token: str | None = None,
     ) -> list[RebacReference] | RebacDisabledResult:
         """List resources a user can access for one permission."""
+        resource_type = _resource_for_permission(permission)
+        # Self-heal the caller's own personal-team tuple before enumerating
+        # (AUTHZ-08 follow-up): `lookup_resources`/OpenFGA `ListObjects` never
+        # goes through `has_user_permission`/`check_user_team_permission_or_raise`,
+        # so without this a first-touch user's own personal team was silently
+        # missing from "list my teams" results (e.g. the `/fs` virtual `/teams`
+        # directory) until some other check-triggering call happened to
+        # provision it first.
+        await self._ensure_personal_team_editor(
+            user, resource_type, personal_team_id(user.uid)
+        )
         return await self.lookup_resources(
             subject=RebacReference(Resource.USER, user.uid),
             permission=permission,
-            resource_type=_resource_for_permission(permission),
+            resource_type=resource_type,
             consistency_token=consistency_token,
         )
 
@@ -617,6 +684,38 @@ class RebacEngine(ABC):
     ) -> bool:
         """Return `True` when a subject is authorized for an action."""
 
+    async def _ensure_personal_team_editor(
+        self, user: KeycloakUser, resource_type: Resource, resource_id: str
+    ) -> None:
+        """Self-heal a personal team's own `team_editor` tuple on first touch (AUTHZ-08).
+
+        Personal teams (`personal-<uid>`) are real ReBAC team objects, but carry
+        no tuple until the owner's first permission check touches one — this
+        lazily provisions exactly one (`user:<uid> team_editor team:personal-
+        <uid>`), matching `build_personal_team`'s hardcoded permission set
+        (`can_read`, `can_update_resources`, `can_update_agents` — all implied
+        by `team_editor`). Runs before every `check_user_permission_or_raise`/
+        `has_user_permission` call so it applies uniformly across every backend,
+        with no per-caller special-casing.
+
+        Never provisions for another user's personal team — `add_relation`'s own
+        write-guard would refuse that shape regardless, but this check avoids
+        even attempting (and audit-logging) a doomed write on every such call.
+        """
+        if not self.enabled or resource_type != Resource.TEAM:
+            return
+        if not is_personal_team_id(resource_id):
+            return
+        if resource_id != personal_team_id(user.uid):
+            return
+        team_ref = RebacReference(Resource.TEAM, resource_id)
+        user_ref = RebacReference(Resource.USER, user.uid)
+        if await self.has_direct_relation(user_ref, RelationType.TEAM_EDITOR, team_ref):
+            return
+        await self.add_user_relation(
+            user, RelationType.TEAM_EDITOR, Resource.TEAM, resource_id
+        )
+
     async def has_user_permission(
         self,
         user: KeycloakUser,
@@ -627,6 +726,7 @@ class RebacEngine(ABC):
     ) -> bool:
         """Check one permission for one user/resource pair."""
         resource_type = _resource_for_permission(permission)
+        await self._ensure_personal_team_editor(user, resource_type, resource_id)
         return await self.has_permission(
             RebacReference(Resource.USER, user.uid),
             permission,
@@ -680,6 +780,7 @@ class RebacEngine(ABC):
     ) -> None:
         """User-focused wrapper around `check_permission_or_raise`."""
         resource_type = _resource_for_permission(permission)
+        await self._ensure_personal_team_editor(user, resource_type, resource_id)
         await self.check_permission_or_raise(
             RebacReference(Resource.USER, user.uid),
             permission,

{fred_core-3.4.4 → fred_core-3.4.7}/fred_core/store/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from fred_core.store.base_content_store import ContentStore
+from fred_core.store.gcs_content_store import GcsContentStore
 from fred_core.store.local_content_store import LocalContentStore
 from fred_core.store.minio_content_store import MinioContentStore
 from fred_core.store.opensearch_mapping_validator import (
@@ -23,6 +24,7 @@ from fred_core.store.vector_search import VectorSearchHit
 
 __all__ = [
     "ContentStore",
+    "GcsContentStore",
     "LocalContentStore",
     "MappingValidationError",
     "MinioContentStore",