diff --git a/CHANGELOG.md b/CHANGELOG.md index 53fc8f8..156e4c0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,14 @@ +## 0.47.0 — 2026-11-18 — Connexions personnelles : chaque utilisateur connecte SA forge + +Demande de Bruno : l'authentification de la suite est centralisée et multi-utilisateurs, mais dans Kanbante tout le monde agissait avec le même accès Gitea (la connexion globale de l'instance). Désormais, chacun connecte son propre gestionnaire de sources et agit avec son propre accès. + +- **Filtrage par utilisateur** (`_connection_visible_to`, `_visible_connection_ids`) : dans toutes les vues interactives (tableau de bord, projets de l'espace, boards, archives, Mes issues, En vol…), un membre ordinaire ne voit et n'utilise **que ses connexions personnelles** ; les connexions globales (sans propriétaire, dont la connexion héritée n° 1) sont réservées aux administrateurs. Le repli historique de résolution des boards ne sert plus le client hérité à un membre qui n'y a pas droit : le projet lui est **introuvable (404)**. Les rituels d'arrière-plan (briefing, digest, MCP, instantanés) ne passent pas par ce filtre — ils relèvent du service, inchangés. +- **Panneau personnel simplifié** : une connexion créée depuis le profil est **attachée automatiquement à l'espace courant** (avant : « ajoute-la à un espace ou demande à un admin ») ; les connexions personnelles créées avant la 0.47.0 sont rattachées toutes seules à l'espace courant de leur propriétaire. La section « Mes connexions personnelles » du profil donne les liens directs de création de jeton (Gitea de la suite, GitHub, portée « repo »). +- **Aide à la première connexion** : un membre sans aucune connexion personnelle active est accueilli par un écran dédié plutôt que par un tableau de bord vide — explication en 3 étapes, boutons d'ouverture de la page des jetons de chaque forge (Gitea pré-rempli sur l'instance de la suite, GitHub), et formulaire de première connexion : le jeton est **testé contre la forge avant tout enregistrement** (en cas d'échec, rien n'est créé et l'erreur s'affiche) ; en cas de succès, le compte détecté est renseigné, la connexion est attachée et l'utilisateur arrive sur ses dépôts avec un message de bienvenue. +- **Incident de parcours corrigé** : la sonde de test de l'onboarding omettait le `slug` qu'exige `build_client` — 500 en conditions réelles, invisible des tests qui patchent le constructeur. Corrigé, avec un test de régression qui exerce le vrai `build_client`. +- **Tests** : `tests/test_connexions_personnelles.py` (7) — onboarding du membre neuf, admin inchangé, première connexion testée/attachée/affichée, mauvais jeton refusé sans rien enregistrer, isolation complète entre deux membres (vues, profil, board en 404), attache automatique depuis le profil, sonde compatible avec le vrai constructeur. Suite complète comparée à l'arbre vierge : aucun échec nouveau (les 4 échecs barre/mobile sont préexistants sur main). +- **Vérification réelle** (compte Gitea de test « kbtest », supprimé après coup) : écran d'aide à l'arrivée, connexion avec son vrai jeton → tableau de bord ne montrant que `kbtest/projet-de-kbtest` et sa tâche ; aucun dépôt de Bruno ; board d'un dépôt privé d'autrui introuvable. (`Projets/kanbante` étant public, son board reste lisible avec le jeton de kbtest — c'est la permission de la forge, comme sur le site Gitea lui-même.) + ## 0.46.11 — 2026-11-16 — SSO : plus aucune sortie nue, « aucun » seulement si décidé, pont inerte signalé Ronde 2 du cas réel (dev de Bruno) : la 0.46.10 déployée, le bouton SSO ramenait toujours le compte « bruno » au formulaire **nu** — URL `/login` sans paramètre, aucun message — alors que son cookie draco était valide (lu par ShaarIt et TikTak dans le même navigateur). Énumération complète des sorties de la chaîne d'entrée draco (pont, middleware de cohérence #150, entrée automatique 0.46.8, registre des rôles, révocations, rattachement/conflit, re-liaison) et reproduction en pile fidèle de chaque état candidat : la seule variante qui reproduit le symptôme à l'identique est **`DRACO_SESSION_SECRET` absent du conteneur Kanbante** — draco inerte, `claims_for` toujours None, le pont prenait la sortie « jeton absent » vers `/login` nu, pendant que le bouton SSO continuait d'être rendu. Les autres candidates sont signalées ou servent un compte (rôle explicite → 403 lu ; conflit → message dans la page finale ; jeton révoqué → `draco=invalide` ; session du clone « bruno-2 » → le clone est servi). La cause racine est donc un état du conteneur, mais le code taisait l'échec : c'est ce silence qui est corrigé ici, pour que le prochain écart de configuration se lise à l'écran au lieu de se deviner. diff --git a/VERSION b/VERSION index 3724114..421ab54 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.46.11 +0.47.0 diff --git a/app/main.py b/app/main.py index f2df891..06af3dc 100644 --- a/app/main.py +++ b/app/main.py @@ -30,7 +30,7 @@ from pathlib import Path from urllib.parse import quote import httpx -from fastapi import FastAPI, File, Form, Request, UploadFile +from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile from fastapi.responses import ( HTMLResponse, JSONResponse, @@ -1418,7 +1418,7 @@ async def _archive_target(request: Request, conn_id: int, repo_full_name: str): parts = _split_full_name(repo_full_name) if workspace is None or parts is None: return None - if conn_id not in models.workspace_connection_ids(workspace["id"]): + if conn_id not in _visible_connection_ids(request, workspace["id"]): return None client = _forge_client(conn_id) return client, workspace, parts[0], parts[1] @@ -1469,7 +1469,7 @@ async def archives_local_bulk(request: Request, csrf_token: str = Form("")): cid = int(cid_raw) except ValueError: continue - if cid not in models.workspace_connection_ids(workspace["id"]): + if cid not in _visible_connection_ids(request, workspace["id"]): continue models.set_local_archived(workspace["id"], cid, full_name, True) count += 1 @@ -1669,6 +1669,105 @@ def _current_workspace(request: Request): return workspaces[0], None +# ── Connexions personnelles (0.47.0) ───────────────────── +# Demande de Bruno (2026-11-18) : chaque utilisateur connecte +# SON gestionnaire de sources (Gitea, GitHub) et agit avec SON +# accès — plus question que tous les comptes partagent la +# connexion Gitea historique de l'instance. + + +def _connection_visible_to(row: dict | None, user: dict | None) -> bool: + """Cette connexion est-elle utilisable par cet utilisateur + dans les vues interactives ? + + - opérateur d'environnement (aucun compte en base) : tout, + comme avant ; + - connexion personnelle (owner_user_id) : son seul + propriétaire ; + - connexion globale (sans propriétaire, ex. la connexion + héritée n° 1) : les administrateurs seulement — un membre + ordinaire ne doit plus voir ni manipuler les dépôts d'un + autre accès forge. Les rituels d'arrière-plan (briefing, + digest, MCP, instantanés) ne passent pas par ce filtre : + ils relèvent du service, pas d'un utilisateur. + """ + if row is None: + return False + if user is None or user.get("id") is None: + return True + owner = row.get("owner_user_id") + if owner is not None: + return owner == user["id"] + return user.get("role") == "admin" + + +def _visible_connection_ids(request: Request, workspace_id: int) -> list[int]: + """Connexions de l'espace que l'utilisateur courant peut + réellement utiliser (voir _connection_visible_to).""" + user = _current_user(request) + return [ + cid + for cid in models.workspace_connection_ids(workspace_id) + if _connection_visible_to(models.get_connection(cid), user) + ] + + +def _personal_connections(user: dict | None) -> list[dict]: + if user is None or user.get("id") is None: + return [] + return [ + row + for row in models.list_connections() + if row.get("owner_user_id") == user["id"] + ] + + +def _needs_connection_onboarding(request: Request) -> bool: + """Vrai pour un membre ordinaire sans aucune connexion + personnelle active : ses vues seraient vides, l'écran + d'aide à la connexion doit le prendre en charge.""" + user = _current_user(request) + if user is None or user.get("id") is None: + return False + if user.get("role") == "admin": + return False + return not any( + row.get("enabled") for row in _personal_connections(user) + ) + + +def _attach_connection_for_user( + request: Request, conn_id: int +) -> None: + """Attache une connexion personnelle à l'espace courant de + son propriétaire : elle devient utilisable immédiatement, + sans passage par l'administration des espaces.""" + workspace, _role = _current_workspace(request) + if workspace is None: + return + ids = models.workspace_connection_ids(workspace["id"]) + if conn_id not in ids: + models.set_workspace_connections( + workspace["id"], ids + [conn_id] + ) + + +def _ensure_personal_attached(request: Request, workspace: dict) -> None: + """Auto-réparation : les connexions personnelles créées + avant la 0.47.0 n'étaient attachées à aucun espace — on les + rattache à l'espace courant de leur propriétaire.""" + user = _current_user(request) + mine = [ + row["id"] for row in _personal_connections(user) if row.get("enabled") + ] + if not mine: + return + ids = models.workspace_connection_ids(workspace["id"]) + missing = [cid for cid in mine if cid not in ids] + if missing: + models.set_workspace_connections(workspace["id"], ids + missing) + + @app.post("/workspace/switch") async def workspace_switch( request: Request, @@ -2709,6 +2808,7 @@ def _render_profile(request: Request, user: dict, msg: str = "", err: str = "", return render( request, "profile.html", profile_user=user, + gitea_base=get_settings().gitea_url, memberships=( models.user_workspaces(user["id"]) if user.get("id") is not None @@ -2863,7 +2963,7 @@ async def profile_create_connection( slug = _unique_slug( _slugify(f"{user['username']}-{name}"), "connections" ) - models.create_connection( + conn_id = models.create_connection( slug=slug, kind="github" if kind == "github" else "gitea", name=name, @@ -2871,6 +2971,7 @@ async def profile_create_connection( token_encrypted=forge_crypto.encrypt_token(token) if token else "", owner_user_id=user["id"], ) + _attach_connection_for_user(request, conn_id) models.log_admin(user["id"], "connection.personal.create", slug) return RedirectResponse( "/profile?msg=Connexion+personnelle+ajout%C3%A9e", status_code=303 @@ -2913,6 +3014,107 @@ async def profile_test_connection( return RedirectResponse(f"/profile?{key}={_q(message)}", status_code=303) +# ── Aide à la première connexion (0.47.0) ──────────────── + + +def _render_onboarding( + request: Request, msg: str = "", err: str = "", form: dict | None = None +): + """Écran d'accueil d'un membre sans connexion personnelle : + il explique, donne les liens directs de création de jeton + et propose le formulaire de première connexion.""" + settings = get_settings() + return render( + request, "onboarding.html", + gitea_base=settings.gitea_url, + form=form or {}, + msg=msg, err=err, + ) + + +@app.post("/onboarding/connect") +async def onboarding_connect( + request: Request, + kind: str = Form("gitea"), + name: str = Form(""), + base_url: str = Form(""), + token: str = Form(""), + csrf_token: str = Form(""), +): + """Première connexion d'un utilisateur : le jeton est + TESTÉ contre la forge avant tout enregistrement — en cas + d'échec, rien n'est créé et l'écran d'aide se réaffiche + avec l'erreur. En cas de succès, la connexion personnelle + est créée (compte détecté renseigné) et attachée à + l'espace courant : l'utilisateur voit ses dépôts tout de + suite.""" + user = _current_user(request) + if user is None or user.get("id") is None: + return RedirectResponse("/", status_code=303) + if not _csrf_valid(request, csrf_token): + return _csrf_error() + from app import forge_crypto + + kind = "github" if kind == "github" else "gitea" + name = name.strip() or ("Mon GitHub" if kind == "github" else "Mon Gitea") + base_url = base_url.strip().rstrip("/") + token = token.strip() + form = {"kind": kind, "name": name, "base_url": base_url} + if not base_url or not token: + return _render_onboarding( + request, err="URL de la forge et jeton d'accès requis", + form=form, + ) + # Ligne synthétique complète : build_client lit aussi le + # slug (une première version sans slug donnait un 500 en + # conditions réelles — les tests patchaient build_client). + probe = { + "id": 0, + "slug": "sonde", + "kind": kind, + "base_url": base_url, + "token_encrypted": forge_crypto.encrypt_token(token), + "account_login": "", + } + client = connections_service.build_client(probe) + try: + forge_user = await client.get_user() + login = ( + forge_user.get("login") or forge_user.get("username") or "" + ) + except Exception as exc: + return _render_onboarding( + request, + err=( + "Connexion impossible avec ce jeton : " + f"{exc} — vérifie l'URL, le jeton et ses portées." + ), + form=form, + ) + finally: + await client.aclose() + slug = _unique_slug( + _slugify(f"{user['username']}-{name}"), "connections" + ) + conn_id = models.create_connection( + slug=slug, + kind=kind, + name=name, + base_url=base_url, + token_encrypted=probe["token_encrypted"], + account_login=login, + owner_user_id=user["id"], + ) + _attach_connection_for_user(request, conn_id) + models.log_admin(user["id"], "connection.personal.create", slug) + from urllib.parse import quote as _q + + return RedirectResponse( + f"/?msg={_q(f'Connexion établie : {login or name} — bienvenue !')}", + status_code=303, + ) + + # ── Live updates (SSE hub) ───────────────────────────────── class LiveHub: @@ -3347,7 +3549,7 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str): ws_id = workspace["id"] if workspace else 1 full_name = f"{owner}/{repo}" if workspace: - conn_ids = models.workspace_connection_ids(ws_id) + conn_ids = _visible_connection_ids(request, ws_id) if len(conn_ids) == 1: cid = conn_ids[0] return _forge_client(cid), cid, ws_id @@ -3361,7 +3563,17 @@ async def _resolve_board_scope(request: Request, owner: str, repo: str): continue if full_name in names: return client, cid, ws_id - return gitea, registry.default_id, ws_id + # Repli historique : le client hérité n'est servi qu'aux + # utilisateurs autorisés sur la connexion par défaut — + # jamais à un membre qui n'a pas accès à cette forge. + if _connection_visible_to( + models.get_connection(registry.default_id), _current_user(request) + ): + return gitea, registry.default_id, ws_id + raise HTTPException( + status_code=404, + detail="Projet introuvable pour vos connexions", + ) async def _workspace_repos( @@ -3377,6 +3589,7 @@ async def _workspace_repos( workspace, _role = _current_workspace(request) if workspace is None: return [], None + _ensure_personal_attached(request, workspace) ws_id = workspace["id"] selection = set(models.workspace_project_selection(ws_id)) locally_archived = { @@ -3384,7 +3597,7 @@ async def _workspace_repos( for r in models.list_local_archived(ws_id) } repos: list[dict] = [] - conn_ids = models.workspace_connection_ids(ws_id) + conn_ids = _visible_connection_ids(request, ws_id) for cid in conn_ids: client = _forge_client(cid) row = models.get_connection(cid) @@ -3503,19 +3716,26 @@ def _health_dot(health: dict) -> dict: @app.get("/", response_class=HTMLResponse) -async def dashboard(request: Request): +async def dashboard(request: Request, msg: str = "", err: str = ""): """Main dashboard — all projects at a glance. Since 0.24.0 the projects are those of the CURRENT WORKSPACE (its connections, its selection, its local archives excluded); each card carries its connection badge. """ + # 0.47.0 : un membre sans connexion personnelle est pris + # en charge par l'écran d'aide à la connexion plutôt que + # par un tableau de bord vide (ou pire, alimenté par + # l'accès forge d'un autre). + if _needs_connection_onboarding(request): + return _render_onboarding(request, msg=msg, err=err) repos, workspace = await _workspace_repos(request) active, inactive, archived = classify_repos(repos) ws_id = workspace["id"] if workspace else 1 + visible_ids = _visible_connection_ids(request, ws_id) starred_keys: set[tuple[int, str]] = set() if workspace: - for cid in models.workspace_connection_ids(ws_id): + for cid in visible_ids: try: client = _forge_client(cid) for r in await client.list_starred(): @@ -3591,7 +3811,8 @@ async def dashboard(request: Request): column_keys=bcols.keys(ws_id), active_window_days=get_settings().active_window_days, metrics=get_metrics(window_days=30), - multi_conn=len(models.workspace_connection_ids(ws_id)) > 1, + multi_conn=len(visible_ids) > 1, + msg=msg, err=err, ) diff --git a/app/templates/dashboard.html b/app/templates/dashboard.html index 1d4db49..698f885 100644 --- a/app/templates/dashboard.html +++ b/app/templates/dashboard.html @@ -45,6 +45,8 @@ }
+ {% if msg %}

{{ msg }}

{% endif %} + {% if err %}

{{ err }}

{% endif %}