agent-framework-lib 0.8.9__tar.gz → 0.8.9.post2__tar.gz

{agent_framework_lib-0.8.9/agent_framework_lib.egg-info → agent_framework_lib-0.8.9.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.9
+Version: 0.8.9.post2
 Summary: A comprehensive Python framework for building and serving conversational AI agents with FastAPI
 Author-email: Sebastian Pavel <sebastian@cinco.ai>, Elliott Girard <elliott.girard@icloud.com>
 Maintainer-email: Sebastian Pavel <sebastian@cinco.ai>

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/security/authz.py

@@ -86,26 +86,44 @@ def resolve_effective_user_id(current_user: str, requested_user_id: str | None)
     return current_user
 
 
-def is_owner(resource_user_id: str | None, principal: str) -> bool:
-    """Vérifie que ``principal`` possède la ressource.
+def is_owner(
+    resource_user_id: str | None,
+    principal: str,
+    *,
+    is_admin: bool = False,
+) -> bool:
+    """Vérifie que ``principal`` possède la ressource (autorisation role-based).
+
+    Le ``principal`` passé DOIT être l'**utilisateur effectif** de la requête
+    (résolu via :func:`resolve_effective_user_id`), pas le pseudo-principal d'une
+    clé API partagée par un portail. L'accès cross-utilisateur n'est accordé que
+    via le **rôle admin** (``is_admin=True``), pas par la confiance accordée à
+    tout détenteur de clé.
+
+    Note (changement de modèle) : le court-circuit historique
+    ``trust_client_user_id() -> True`` est **supprimé**. ``AUTH_TRUST_CLIENT_USER_ID``
+    ne sert plus qu'à *résoudre* l'utilisateur effectif (honorer le ``user_id``
+    fourni par un portail de confiance) dans :func:`resolve_effective_user_id` ;
+    il n'autorise plus, à lui seul, l'accès aux ressources d'autrui.
 
     Args:
         resource_user_id: Identifiant du propriétaire de la ressource
             (``None`` si la ressource n'a pas de propriétaire connu).
-        principal: Identité authentifiée demandant l'accès.
+        principal: Identité **effective** demandant l'accès.
+        is_admin: ``True`` si l'appelant est authentifié comme admin (rôle
+            privilégié QA/support) — court-circuite la vérification de propriété.
 
     Returns:
-        ``True`` si le principal possède la ressource, si le mode développement
-        est actif et que le principal est ``"anonymous"`` (compat mono-utilisateur),
-        ou si le client est de confiance (``AUTH_TRUST_CLIENT_USER_ID`` — le portail
-        de confiance peut accéder aux ressources de n'importe quel end-user).
+        ``True`` si l'appelant est admin, si ``principal`` possède la ressource,
+        ou si le mode développement est actif et que ``principal`` est
+        ``"anonymous"`` (compat mono-utilisateur). ``False`` sinon.
     """
+    if is_admin:
+        return True
     if resource_user_id is not None and resource_user_id == principal:
         return True
     if dev_mode_enabled() and principal == ANONYMOUS_PRINCIPAL:
         return True
-    if trust_client_user_id():
-        return True
     return False
 
 

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/utils/post_install.py

@@ -1076,6 +1076,70 @@ def _find_local_wheel() -> Path | None:
     return None
 
 
+_IMAGE_PIN_NAME = "sandbox-image-pin"
+
+
+def _ensure_image_pin(tag: str) -> None:
+    """Keep a tiny container running off the CURRENT sandbox image so an external
+    ``docker image prune`` / ``docker system prune`` cannot remove it.
+
+    A running container's image — AND its tag — survive a prune. The pin is
+    (re)created whenever it is missing OR points at a different image id, because
+    ``docker build -t <tag>`` moves the tag to a NEW image and leaves a stale pin
+    on the old one (then the new, unpinned, tagged image gets pruned → the tag
+    vanishes → ``ImagePullFailed`` on the next sandbox). Re-pinning the freshly
+    built/current image right here closes that window on every boot and rebuild.
+    Best-effort: never fatal, never blocks the agent.
+    """
+    if not _docker_ok():
+        return
+    try:
+        tag_inspect = subprocess.run(
+            ["docker", "image", "inspect", "-f", "{{.Id}}", tag],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if tag_inspect.returncode != 0:
+            return  # tag not present locally — nothing to pin
+        want = (tag_inspect.stdout or "").strip()
+        pin = subprocess.run(
+            ["docker", "inspect", "-f", "{{.State.Running}} {{.Image}}", _IMAGE_PIN_NAME],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if pin.returncode == 0:
+            running, _, img = (pin.stdout or "").strip().partition(" ")
+            if running == "true" and img == want:
+                return  # already pinned to the current image — nothing to do
+        subprocess.run(["docker", "rm", "-f", _IMAGE_PIN_NAME], capture_output=True, timeout=30)
+        r = subprocess.run(
+            [
+                "docker",
+                "run",
+                "-d",
+                "--name",
+                _IMAGE_PIN_NAME,
+                "--restart",
+                "always",
+                "--entrypoint",
+                "sleep",
+                tag,
+                "infinity",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if r.returncode == 0:
+            logger.info("[sandbox] pinned image %s (prune-proof) via %s", tag, _IMAGE_PIN_NAME)
+        else:
+            logger.warning("[sandbox] image pin failed: %s", (r.stderr or "")[-200:])
+    except Exception as exc:  # noqa: BLE001 — pinning must never break startup
+        logger.warning("[sandbox] image pin error: %s", exc)
+
+
 def _render_sandbox_dockerfile(install_line: str, version: str = "") -> str:
     """Self-contained Dockerfile for the per-session sandbox image.
 
@@ -1131,6 +1195,7 @@ def ensure_sandbox_image(tag: str = _SANDBOX_IMAGE_TAG) -> tuple[bool, str | Non
     if _sandbox_image_exists(tag) and not force:
         built_version = _sandbox_image_version(tag)
         if built_version == _afl_version:
+            _ensure_image_pin(tag)  # keep it prune-proof even when no rebuild is needed
             return True, None
         logger.info(
             "[sandbox] image %s built for version %r != package %r — rebuilding",
@@ -1173,6 +1238,7 @@ def ensure_sandbox_image(tag: str = _SANDBOX_IMAGE_TAG) -> tuple[bool, str | Non
     finally:
         shutil.rmtree(build_dir, ignore_errors=True)
     if r.returncode == 0:
+        _ensure_image_pin(tag)  # pin the freshly built image so a prune can't drop the tag
         return True, None
     return False, f"sandbox image build failed: {r.stderr[-400:]}"
 

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/web/admin_auth.py

@@ -14,7 +14,12 @@ import secrets
 from datetime import datetime, timedelta, timezone
 
 from fastapi import Depends, HTTPException, status
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.security import (
+    HTTPAuthorizationCredentials,
+    HTTPBasic,
+    HTTPBasicCredentials,
+    HTTPBearer,
+)
 
 from .admin_models import AdminAuthResponse
 
@@ -28,6 +33,10 @@ TOKEN_PREFIX = "admin_"
 # Security scheme for admin endpoints
 admin_bearer_security = HTTPBearer(auto_error=False)
 
+# Basic-auth extraction for the unified admin role (``require_admin``). Optional so
+# a request without Basic credentials is not rejected before the Bearer path runs.
+admin_basic_security = HTTPBasic(auto_error=False)
+
 # In-memory token store (in production, consider using Redis or similar)
 # Format: {token_hash: {"expires_at": datetime, "created_at": datetime}}
 _admin_tokens: dict[str, dict[str, datetime]] = {}
@@ -240,6 +249,66 @@ async def get_admin_user(
     return "admin"
 
 
+async def require_admin(
+    bearer_credentials: HTTPAuthorizationCredentials | None = Depends(admin_bearer_security),
+    basic_credentials: HTTPBasicCredentials | None = Depends(admin_basic_security),
+) -> str:
+    """Authorize an admin caller via EITHER channel of the single admin secret.
+
+    Two admin entry points exist in the UI: the admin-panel **Bearer** token
+    (minted from ``ADMIN_PASSWORD`` via ``/api/admin/auth/verify``) and HTTP
+    **Basic** credentials whose password is the admin password. Both ultimately
+    prove knowledge of ``ADMIN_PASSWORD``; this dependency accepts either so an
+    operator does not need a second, separate credential to mutate skills. No new
+    secret is introduced.
+
+    Args:
+        bearer_credentials: Optional Bearer token (admin session token).
+        basic_credentials: Optional HTTP Basic credentials.
+
+    Returns:
+        The string ``"admin"`` when authorized.
+
+    Raises:
+        HTTPException: 401 when neither channel proves admin authority.
+    """
+    if bearer_credentials and validate_admin_token(bearer_credentials.credentials):
+        return "admin"
+    if basic_credentials and verify_admin_password(basic_credentials.password):
+        return "admin"
+
+    logger.warning(
+        "[ADMIN AUTH] Admin authorization refused: no valid admin token nor admin "
+        "Basic credential."
+    )
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Admin authentication required",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+
+async def get_optional_admin(
+    bearer_credentials: HTTPAuthorizationCredentials | None = Depends(admin_bearer_security),
+    basic_credentials: HTTPBasicCredentials | None = Depends(admin_basic_security),
+) -> bool:
+    """Non-raising admin probe: ``True`` iff the caller proves admin authority.
+
+    Same acceptance as :func:`require_admin` (admin Bearer token OR HTTP Basic
+    with the admin password) but returns a boolean instead of raising, so a
+    regular resource endpoint can grant the admin role (cross-user access) when
+    present while still serving non-admin owners normally.
+
+    Returns:
+        ``True`` when a valid admin credential is present, ``False`` otherwise.
+    """
+    if bearer_credentials and validate_admin_token(bearer_credentials.credentials):
+        return True
+    if basic_credentials and verify_admin_password(basic_credentials.password):
+        return True
+    return False
+
+
 def authenticate_admin(password: str) -> AdminAuthResponse:
     """
     Authenticate an admin user with password and return a session token.

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/web/modern_ui.html

@@ -4341,6 +4341,16 @@
                     }
                 },
 
+                adminAuthHeader() {
+                    // Skill mutations require the admin role (backend: require_admin).
+                    // Prefer the admin-panel Bearer token; fall back to the Basic admin
+                    // credential. Either proves ADMIN_PASSWORD. Returns {} if neither is
+                    // present (the request will then be correctly rejected with 401).
+                    if (this.adminPanelToken) return { 'Authorization': 'Bearer ' + this.adminPanelToken };
+                    if (this.adminToken) return { 'Authorization': 'Basic ' + this.adminToken };
+                    return {};
+                },
+
                 async saveSkill() {
                     const splitList = (s) => s ? s.split(',').map(x => x.trim()).filter(Boolean) : [];
                     const body = {
@@ -4361,13 +4371,13 @@
                         if (this.skillsView === 'create') {
                             response = await fetch(BASE_PATH + '/api/skills', {
                                 method: 'POST',
-                                headers: { 'Content-Type': 'application/json' },
+                                headers: { 'Content-Type': 'application/json', ...this.adminAuthHeader() },
                                 body: JSON.stringify(body),
                             });
                         } else {
                             response = await fetch(BASE_PATH + '/api/skills/' + encodeURIComponent(this.skillEditName), {
                                 method: 'PUT',
-                                headers: { 'Content-Type': 'application/json' },
+                                headers: { 'Content-Type': 'application/json', ...this.adminAuthHeader() },
                                 body: JSON.stringify(body),
                             });
                         }
@@ -4383,7 +4393,7 @@
                                         formData.append('file', pf.file);
                                         const resp = await fetch(
                                             BASE_PATH + '/api/skills/' + encodeURIComponent(skillName) + '/files',
-                                            { method: 'POST', body: formData }
+                                            { method: 'POST', headers: { ...this.adminAuthHeader() }, body: formData }
                                         );
                                         if (!resp.ok) {
                                             const err = await resp.json().catch(() => ({}));
@@ -4411,7 +4421,7 @@
 
                 async deleteSkill(name) {
                     try {
-                        const response = await fetch(BASE_PATH + '/api/skills/' + encodeURIComponent(name), { method: 'DELETE' });
+                        const response = await fetch(BASE_PATH + '/api/skills/' + encodeURIComponent(name), { method: 'DELETE', headers: { ...this.adminAuthHeader() } });
                         if (response.ok) {
                             this.skillDeleteConfirm = null;
                             await this.loadSkills();
@@ -4479,7 +4489,7 @@
                             formData.append('file', file);
                             const resp = await fetch(
                                 BASE_PATH + '/api/skills/' + encodeURIComponent(this.skillEditName) + '/files',
-                                { method: 'POST', body: formData }
+                                { method: 'POST', headers: { ...this.adminAuthHeader() }, body: formData }
                             );
                             if (!resp.ok) {
                                 const err = await resp.json().catch(() => ({}));
@@ -4499,7 +4509,7 @@
                     try {
                         const resp = await fetch(
                             BASE_PATH + '/api/skills/' + encodeURIComponent(this.skillEditName) + '/files/' + encodeURIComponent(filename),
-                            { method: 'DELETE' }
+                            { method: 'DELETE', headers: { ...this.adminAuthHeader() } }
                         );
                         if (resp.ok) {
                             await this.refreshSkillFiles();
@@ -11979,8 +11989,12 @@
                 async downloadFile(fileId) {
                     console.log('[downloadFile] Downloading file:', fileId);
                     try {
-                        const headers = {};
-                        const response = await fetch(`${BASE_PATH}/files/${fileId}/download`, {
+                        // Scope to the viewed end-user (honored by the server for a
+                        // trusted portal) + carry the admin credential so an admin can
+                        // download any user's file (role-based authz on the endpoint).
+                        const scope = this.selectedUserId ? `?user_id=${encodeURIComponent(this.selectedUserId)}` : '';
+                        const headers = { ...this.adminAuthHeader() };
+                        const response = await fetch(`${BASE_PATH}/files/${fileId}/download${scope}`, {
                             method: 'GET',
                             headers: headers
                         });
@@ -12299,7 +12313,10 @@
 
                 async downloadFileFromPanel(file) {
                     try {
-                        const response = await fetch(`${BASE_PATH}/files/${file.file_id}/download`);
+                        const scope = this.selectedUserId ? `?user_id=${encodeURIComponent(this.selectedUserId)}` : '';
+                        const response = await fetch(`${BASE_PATH}/files/${file.file_id}/download${scope}`, {
+                            headers: { ...this.adminAuthHeader() },
+                        });
                         if (response.ok) {
                             const blob = await response.blob();
                             const url = window.URL.createObjectURL(blob);

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/web/server.py

@@ -1831,6 +1831,7 @@ if OTEL_TRACING_ENABLED:
 # and configuration management. It requires Elasticsearch to be enabled.
 # The router's endpoints handle ES availability through the require_elasticsearch dependency,
 # returning HTTP 503 when ES is not available.
+from .admin_auth import get_optional_admin  # noqa: E402  (admin role probe for file endpoints)
 from .admin_router import admin_router
 
 
@@ -5368,12 +5369,17 @@ async def upload_file(
 async def download_file(
     file_id: str,
     inline: bool = Query(False, description="If true, display inline instead of forcing download"),
+    user_id: str | None = Query(
+        None, description="End-user the request acts for (honored from a trusted portal)"
+    ),
     current_user: str = Depends(get_current_user),
+    is_admin: bool = Depends(get_optional_admin),
 ):
     """Download file from storage. Use ?inline=true to display in browser instead of downloading."""
     try:
+        effective_user = resolve_effective_user_id(current_user, user_id)
         logger.info(
-            f"🔽 DOWNLOAD ENDPOINT - Attempting to download file: {file_id} for user: {current_user}, inline={inline}"
+            f"🔽 DOWNLOAD ENDPOINT - Attempting to download file: {file_id} for user: {effective_user}, inline={inline}"
         )
 
         # Check if file storage manager is available
@@ -5387,12 +5393,12 @@ async def download_file(
             f"📄 DOWNLOAD ENDPOINT - File metadata: mime_type={metadata.mime_type}, storage_path={metadata.storage_path}"
         )
 
-        # Object-level authorization: only the owner (or anonymous in dev-mode)
-        # may access the file. Respond 404 instead of 403 to avoid disclosing
-        # the file's existence to non-owners.
-        if not is_owner(metadata.user_id, current_user):
+        # Object-level authorization: the effective end-user must own the file, or
+        # the caller must be admin (QA/support). Respond 404 instead of 403 to
+        # avoid disclosing the file's existence to non-owners.
+        if not is_owner(metadata.user_id, effective_user, is_admin=is_admin):
             logger.warning(
-                f"🚫 DOWNLOAD ENDPOINT - User {current_user} not owner of file {file_id}"
+                f"🚫 DOWNLOAD ENDPOINT - User {effective_user} not owner of file {file_id}"
             )
             raise HTTPException(status_code=404, detail="File not found")
 
@@ -5422,9 +5428,11 @@ async def download_file(
 async def view_file(
     file_id: str,
     token: str | None = Query(None, description="Signed short-lived view token bound to file_id"),
+    user_id: str | None = Query(None, description="End-user the request acts for"),
     basic_credentials: HTTPBasicCredentials | None = Depends(basic_security),
     bearer_credentials: HTTPAuthorizationCredentials | None = Depends(bearer_security),
     x_api_key: str | None = Header(None, alias="X-API-Key"),
+    is_admin: bool = Depends(get_optional_admin),
 ):
     """View file inline in browser (for displaying images in chat, etc.).
 
@@ -5492,7 +5500,13 @@ async def view_file(
                 )
             except HTTPException:
                 principal = None
-            if principal is not None and is_owner(metadata.user_id, principal):
+            # Admin (QA/support) may view any file; otherwise the effective
+            # end-user (portal-honored user_id) must own it. ``principal`` may be
+            # None — an admin Bearer-only request still authorizes via is_admin.
+            effective_user = (
+                resolve_effective_user_id(principal, user_id) if principal is not None else ""
+            )
+            if is_owner(metadata.user_id, effective_user, is_admin=is_admin):
                 authorized = True
 
         if not authorized:
@@ -5519,18 +5533,24 @@ async def view_file(
 
 
 @app.get("/files/{file_id}/metadata")
-async def get_file_metadata(file_id: str, current_user: str = Depends(get_current_user)):
+async def get_file_metadata(
+    file_id: str,
+    user_id: str | None = Query(None, description="End-user the request acts for"),
+    current_user: str = Depends(get_current_user),
+    is_admin: bool = Depends(get_optional_admin),
+):
     """Get file metadata"""
     try:
+        effective_user = resolve_effective_user_id(current_user, user_id)
         metadata = await app.state.file_storage_manager.get_file_metadata(file_id)
 
         if not metadata:
             raise HTTPException(status_code=404, detail="File not found")
 
-        # Object-level authorization: non-owners get 404 (existence not disclosed).
-        if not is_owner(metadata.user_id, current_user):
+        # Object-level authorization: effective end-user must own the file, or admin.
+        if not is_owner(metadata.user_id, effective_user, is_admin=is_admin):
             logger.warning(
-                f"🚫 METADATA ENDPOINT - User {current_user} not owner of file {file_id}"
+                f"🚫 METADATA ENDPOINT - User {effective_user} not owner of file {file_id}"
             )
             raise HTTPException(status_code=404, detail="File not found")
 
@@ -5557,17 +5577,25 @@ async def get_file_metadata(file_id: str, current_user: str = Depends(get_curren
 
 
 @app.get("/files/{file_id}/preview")
-async def preview_file(file_id: str, current_user: str = Depends(get_current_user)):
+async def preview_file(
+    file_id: str,
+    user_id: str | None = Query(None, description="End-user the request acts for"),
+    current_user: str = Depends(get_current_user),
+    is_admin: bool = Depends(get_optional_admin),
+):
     """Preview file content optimized for UI display"""
     try:
+        effective_user = resolve_effective_user_id(current_user, user_id)
         # First check if file exists and get metadata
         metadata = await app.state.file_storage_manager.get_file_metadata(file_id)
         if not metadata:
             raise HTTPException(status_code=404, detail="File not found")
 
-        # Object-level authorization: non-owners get 404 (existence not disclosed).
-        if not is_owner(metadata.user_id, current_user):
-            logger.warning(f"🚫 PREVIEW ENDPOINT - User {current_user} not owner of file {file_id}")
+        # Object-level authorization: effective end-user must own the file, or admin.
+        if not is_owner(metadata.user_id, effective_user, is_admin=is_admin):
+            logger.warning(
+                f"🚫 PREVIEW ENDPOINT - User {effective_user} not owner of file {file_id}"
+            )
             raise HTTPException(status_code=404, detail="File not found")
 
         # Get the file content
@@ -5716,9 +5744,15 @@ async def list_files(
 
 
 @app.delete("/files/{file_id}")
-async def delete_file(file_id: str, current_user: str = Depends(get_current_user)):
+async def delete_file(
+    file_id: str,
+    user_id: str | None = Query(None, description="End-user the request acts for"),
+    current_user: str = Depends(get_current_user),
+    is_admin: bool = Depends(get_optional_admin),
+):
     """Delete file from storage"""
     try:
+        effective_user = resolve_effective_user_id(current_user, user_id)
         # Fetch metadata first to enforce object-level authorization before
         # any destructive operation. Missing or non-owned files yield 404
         # (existence not disclosed to non-owners).
@@ -5726,8 +5760,10 @@ async def delete_file(file_id: str, current_user: str = Depends(get_current_user
         if not metadata:
             raise HTTPException(status_code=404, detail="File not found")
 
-        if not is_owner(metadata.user_id, current_user):
-            logger.warning(f"🚫 DELETE ENDPOINT - User {current_user} not owner of file {file_id}")
+        if not is_owner(metadata.user_id, effective_user, is_admin=is_admin):
+            logger.warning(
+                f"🚫 DELETE ENDPOINT - User {effective_user} not owner of file {file_id}"
+            )
             raise HTTPException(status_code=404, detail="File not found")
 
         success = await app.state.file_storage_manager.delete_file(file_id)

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/agent_framework/web/skills_router.py

@@ -9,8 +9,9 @@ The router is split into two authorization tiers:
 - read endpoints (listing, detail, file download, read-only validation) require
   any authenticated principal (``get_current_user``) ;
 - mutation endpoints (create, update, delete, file upload/delete) require admin
-  authentication (``get_admin_user``), since skill content can carry executable
-  code that is later run by agents.
+  authentication (``require_admin``: admin Bearer token OR HTTP Basic with the
+  admin password), since skill content can carry executable code that is later
+  run by agents.
 
 Both tiers are aggregated under the public ``skills_router`` so the registered
 paths and the import surface used by ``web/server.py`` remain unchanged.
@@ -48,7 +49,7 @@ from agent_framework.skills.custom_skill_manager import (
     SkillNotFoundError,
 )
 
-from .admin_auth import get_admin_user
+from .admin_auth import require_admin
 
 
 logger = logging.getLogger(__name__)
@@ -186,11 +187,13 @@ read_router = APIRouter(
 
 # Mutation tier: admin authentication required. Writing skill content can
 # introduce code that agents later execute, so mutations are gated behind the
-# stronger admin credential.
+# stronger admin credential. ``require_admin`` accepts either the admin Bearer
+# token OR HTTP Basic carrying the admin password (single ADMIN_PASSWORD secret),
+# so the /ui can mutate skills via whichever admin credential it holds.
 mutation_router = APIRouter(
     prefix="/api/skills",
     tags=["skills"],
-    dependencies=[Depends(get_admin_user)],
+    dependencies=[Depends(require_admin)],
 )
 
 # Public aggregator preserving the import surface used by ``web/server.py``.

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2/agent_framework_lib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.9
+Version: 0.8.9.post2
 Summary: A comprehensive Python framework for building and serving conversational AI agents with FastAPI
 Author-email: Sebastian Pavel <sebastian@cinco.ai>, Elliott Girard <elliott.girard@icloud.com>
 Maintainer-email: Sebastian Pavel <sebastian@cinco.ai>

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/docs/SECURITY_HARDENING.md

@@ -15,13 +15,25 @@ protègent les secrets, les tenants et le conteneur — aucune ne dépend des au
 - Méthodes acceptées : Basic Auth, clé API (`Authorization: Bearer` ou `X-API-Key`),
   et le **jeton de session scopé** (`X-Session-Token`, voir §4).
 - Mode dev non authentifié : `AUTH_DEV_MODE=true` uniquement (jamais en prod).
+- **Autorisation role-based (propriété + rôle admin)** : l'accès à une ressource
+  (sessions, fichiers) est accordé si l'**utilisateur effectif** en est propriétaire
+  (`is_owner`) OU si l'appelant a le **rôle admin**. `AUTH_TRUST_CLIENT_USER_ID`
+  (défaut `true`) ne fait que **résoudre** l'utilisateur effectif depuis le `user_id`
+  fourni par un portail de confiance — il n'**autorise** plus l'accès cross-user. Les
+  endpoints fichier (`/files/{id}/download|view|metadata|preview`, `DELETE /files/{id}`)
+  acceptent `?user_id=` et vérifient la propriété contre cet utilisateur effectif.
+  L'accès cross-user (QA/support : voir/télécharger les fichiers ou sessions d'un autre
+  end-user, créer/éditer des skills) passe par le **rôle admin** : token Bearer admin
+  (`POST /api/admin/auth/verify` avec `ADMIN_PASSWORD`) OU HTTP Basic portant
+  `ADMIN_PASSWORD`.
 
 | Variable | Défaut | Rôle |
 |----------|--------|------|
 | `AUTH_DEV_MODE` | `false` | Seul commutateur autorisant l'accès non authentifié (principal `anonymous`). |
 | `REQUIRE_AUTH` | — | Câblage des mécanismes basic/API key. |
+| `AUTH_TRUST_CLIENT_USER_ID` | `true` | Portail de confiance : **résout** l'utilisateur effectif depuis le `user_id` client (n'autorise PAS l'accès cross-user). `false` = lie chaque requête au principal authentifié. |
 | `BASIC_AUTH_USERNAME` / `BASIC_AUTH_PASSWORD` | — | Basic auth ; **aucun défaut fonctionnel** (voie désactivée si non défini). |
-| `ADMIN_PASSWORD` | — | Accès admin ; voie désactivée si non défini. |
+| `ADMIN_PASSWORD` | — | **Rôle admin** : impersonation cross-user (QA/support) + mutations skills. Voie désactivée si non défini. |
 | `API_KEYS` | — | Clés API maître (CSV). N'est plus exposée au shell par défaut (voir §4). |
 | `CORS_ALLOWED_ORIGINS` / `CORS_ALLOW_ALL` | localhost sûr | Origines CORS ; jamais `*`+credentials simultanés. |
 
@@ -123,6 +135,10 @@ pendant ≤ TTL (éphémère, mono-session, borné) — jamais la clé maître.
 - Stockage physique **par utilisateur** : `files/<user>_<hash>/…` (au lieu d'un
   dossier à plat). Défense en profondeur en plus du contrôle `is_owner` au niveau
   API. Lecture des fichiers existants (à plat) préservée.
+- Contrôle d'accès API **role-based** (cf. §1) : les endpoints fichier vérifient la
+  propriété contre l'**utilisateur effectif** (résolu depuis `?user_id=` quand
+  `AUTH_TRUST_CLIENT_USER_ID=true`) ; un end-user n'accède qu'à ses propres fichiers
+  (404 sinon). Le **rôle admin** court-circuite la propriété (QA/support).
 - `AGENT_OUTPUT_DIR` cloisonné par `user/session`, nettoyé après chaque appel.
 
 | Variable | Défaut | Rôle |
@@ -158,7 +174,8 @@ admin (`SECURITY_THREAT_DETECTED` via le webhook), sans invoquer l'agent.
 ```bash
 AUTH_DEV_MODE=false                 # auth obligatoire
 BASIC_AUTH_PASSWORD=<fort>          # ou API_KEYS=<...>
-ADMIN_PASSWORD=<fort>
+ADMIN_PASSWORD=<fort>               # active le rôle admin (impersonation QA/support + skills)
+AUTH_TRUST_CLIENT_USER_ID=true      # portail de confiance (résout user_id) ; false si clients non fiables
 CORS_ALLOWED_ORIGINS=https://app.exemple.com
 SECRET_REDACTION_ENCODINGS=true
 SHELL_RESOURCE_LIMITS=true

{agent_framework_lib-0.8.9 → agent_framework_lib-0.8.9.post2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-framework-lib"
-version = "0.8.9"
+version = "0.8.9post2"
 description = "A comprehensive Python framework for building and serving conversational AI agents with FastAPI"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}