diff --git a/app/main.py b/app/main.py
index fef258c..d77aef8 100644
--- a/app/main.py
+++ b/app/main.py
@@ -26,6 +26,13 @@ from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
from app import oidc
+# The oidc module is SHARED (byte-identical copy of the canonical
+# ops-docs: scripts/shared/oidc_client.py — see tests/test_oidc_sync.py);
+# this app's identity (logger name, session cookie, session salt) is set
+# here. The cookie name and salt are the app's historical values, so
+# existing sessions survive the consolidation.
+oidc.configure("member-dashboard", "member_oidc_session", "member-dashboard-oidc-session")
+
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("member-dashboard")
@@ -1035,9 +1042,11 @@ function renderGuests(d) {
$('guest-trail').innerHTML = trail.map(t => {
const who = t.name ? escapeHtml(t.name) + ' · ' + escapeHtml(t.recipient) : escapeHtml(t.recipient);
const when = t.decided_at ? 'Decided ' + fmtDay(t.decided_at) : 'Sent ' + fmtDay(t.created_at);
- // `state` carries the portal's derived display state — 'invited' while the
- // guest has not accepted their setup invite (never 'active' before that).
- // Older payloads carry status only; fall back to it.
+ // `state` carries the portal's derived display state — the SINGLE
+ // derivation lives in the portal (tested there) and this page derives
+ // nothing: 'invited' while the guest has not accepted their setup invite
+ // (never 'active' before that), else the ledger status. Older payloads
+ // carry status only; fall back to it.
return '
' +
'
' + who + '
' +
'
' + when + '
' +
diff --git a/app/oidc.py b/app/oidc.py
index ecdde66..c645ee9 100644
--- a/app/oidc.py
+++ b/app/oidc.py
@@ -1,7 +1,12 @@
-"""OIDC client for Cloudron's OpenID Connect addon.
+"""OIDC client for Cloudron's OpenID Connect addon — ONE shared module.
-Implements the authorization-code flow against Cloudron's built-in OIDC
-provider, so the app no longer depends on the proxyAuth header wall.
+This file is the SINGLE SOURCE for the two thin Cloudron apps that implement
+the authorization-code flow themselves (admin-panel, member-dashboard). The
+copies in those repos' app/oidc.py are byte-identical to this file — verified
+by ops-docs/scripts/check-oidc-sync.py and enforced by each repo's
+tests/test_oidc_sync.py — so a fix lands here, is synced to both repos, and
+can never drift. Do not edit a repo copy directly: sync-oidc-module.sh
+overwrites it, and the pin test goes red on any hand edit.
Cloudron exports these env vars (they change on every restart — read per-call,
never cache at import):
@@ -16,8 +21,16 @@ never cache at import):
CLOUDRON_APP_DOMAIN the app's public domain
Identity: Cloudron's `sub` claim is the username (the unique user identifier).
-We use `sub` (username) as the identity — the portal's broker accepts it as
-`X-Member-User` and resolves username → email.
+We use `sub` as the identity; each host app decides what it authorizes — the
+panel matches it against its ADMIN_USERNAMES allowlist, the dashboard
+forwards it to the portal's broker as `X-Member-User` (which resolves
+username → email).
+
+Per-app identity: the ONLY differences the two copies used to carry were the
+logger name, the session cookie name and the session salt. The host app now
+supplies those via configure() at import time (see each app's main.py), which
+keeps this file byte-identical everywhere while preserving each app's
+existing cookie names and salts (so existing sessions survive a redeploy).
"""
import os
@@ -29,15 +42,44 @@ import httpx
from authlib.jose import JsonWebToken, JsonWebKey
from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired
-logger = logging.getLogger("member-dashboard")
+# Per-app identity — set by the host app at import time via configure().
+# The unset sentinels below are loud on purpose: a copy that reaches a
+# request without its host app having configured itself is a sync/setup bug.
+APP_NAME = "unset-app"
+SESSION_COOKIE = "unset_oidc_session"
+_SESSION_SALT = "unset-oidc-session"
-# Session cookie name + max age (8 hours, roughly a working day).
-SESSION_COOKIE = "member_oidc_session"
-SESSION_MAX_AGE = 60 * 60 * 8
+SESSION_MAX_AGE = 60 * 60 * 8 # 8 hours, roughly a working day
SCOPES = "openid profile email"
+def configure(app_name: str, session_cookie: str, session_salt: str) -> None:
+ """Set this app's identity. The host app MUST call this at import time."""
+ global APP_NAME, SESSION_COOKIE, _SESSION_SALT
+ APP_NAME = app_name
+ SESSION_COOKIE = session_cookie
+ _SESSION_SALT = session_salt
+
+
+class _LazyLogger:
+ """Resolves at CALL time, not import time.
+
+ The host app calls configure() AFTER this module is imported (from its
+ main.py), so an eagerly-created module-level logger would bind the
+ 'unset-app' sentinel name and every OIDC log line would carry the wrong
+ attribution. Logging through this proxy reads the configured APP_NAME
+ when the line is actually emitted; logging.getLogger caches by name, so
+ the per-call lookup is free.
+ """
+
+ def __getattr__(self, name):
+ return getattr(logging.getLogger(APP_NAME), name)
+
+
+logger = _LazyLogger()
+
+
def _oidc_env(name: str) -> str:
return os.environ.get(name, "").strip()
@@ -55,7 +97,7 @@ def _session_serializer() -> URLSafeTimedSerializer:
# Derive a stable, secret signing key from the OIDC client secret (already
# a secret the app holds, and stable across restarts).
secret = _oidc_env("CLOUDRON_OIDC_CLIENT_SECRET") or _secrets.token_urlsafe(32)
- return URLSafeTimedSerializer(secret, salt="member-dashboard-oidc-session")
+ return URLSafeTimedSerializer(secret, salt=_SESSION_SALT)
def _redirect_uri(request_host: str) -> str:
diff --git a/dashboard-guests-harness.js b/dashboard-guests-harness.js
new file mode 100644
index 0000000..5dc9f10
--- /dev/null
+++ b/dashboard-guests-harness.js
@@ -0,0 +1,65 @@
+// Harness for the member dashboard's GUEST TRAIL (the member's own invite
+// history), run through the panel's vendored checker:
+// bash ../admin-panel/tests/check-page-js.sh app/main.py dashboard-guests-harness.js
+//
+// The portal derives the trail's display state (the SINGLE derivation, tested
+// in the portal's tests/test_guest_invited_state.py); this page CONSUMES it:
+// * state='invited' wins even though the ledger status underneath is still
+// 'active' — a provisioned-but-not-set-up guest is never 'active';
+// * state carries the ledger status once accepted/ended (expired ...);
+// * an older payload with status only falls back to it (the thin shim).
+// The checker evals in CommonJS (no top-level await), so the body is wrapped.
+const assert = (cond, msg) => { if (!cond) { console.error("FAIL: " + msg); process.exit(1); } };
+const count = (s, re) => (String(s).match(re) || []).length;
+
+async function runRender(payload) {
+ globalThis.fetch = async () => ({ status: 200, json: async () => payload });
+ await loadGuests();
+}
+
+(async () => {
+ // New payload: the portal serves `state` on every trail entry.
+ await runRender({
+ eligible: false,
+ next_eligible_at: "2026-12-15T00:00:00Z",
+ trail: [
+ { kind: "guest", recipient: "pending@example.com", created_at: "2026-11-10 10:00:00",
+ status: "active", state: "invited" },
+ { kind: "guest", recipient: "lapsed@example.com", created_at: "2026-09-01 10:00:00",
+ decided_at: "2026-10-30 10:00:00", status: "expired", state: "expired" },
+ ],
+ });
+ {
+ const t = document.getElementById("guest-trail").innerHTML;
+ assert(/gpill invited[^>]*>Invited — awaiting setupactive guest]*>ended — time ran out]*>active guest { console.error("FAIL: " + (e && e.stack || e)); process.exit(1); });
diff --git a/tests/test_oidc_sync.py b/tests/test_oidc_sync.py
new file mode 100644
index 0000000..a780127
--- /dev/null
+++ b/tests/test_oidc_sync.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""oidc.py sync pin — the repo copy is byte-identical to the canonical module.
+
+WHY THIS EXISTS
+ app/oidc.py is a byte-identical copy of the canonical module
+ (co-op/ops-docs repo: scripts/shared/oidc_client.py) — the single source for
+ the OIDC client the thin apps ship copies of, so their login never depends
+ on another app being up. This test pins the copy to the canonical revision
+ recorded below: ANY hand edit to app/oidc.py breaks the pin and goes red.
+ To change the module, edit the canonical file and run
+ ops-docs/scripts/sync-oidc-module.sh, which re-copies and re-pins both
+ repos in one step (check-oidc-sync.py is the pre-deploy gate).
+
+ Generated by sync-oidc-module.sh — do not edit by hand.
+
+Run: python3 tests/test_oidc_sync.py
+"""
+import hashlib
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+CANONICAL_SHA256 = "0b17a491b26bceab42fc95f1a091cee50b7ab298096e99ac7b09c771ce99cd55"
+EXPECTED_CONFIGURE = '''oidc.configure("member-dashboard", "member_oidc_session", "member-dashboard-oidc-session")'''
+
+failures = []
+
+copy = ROOT / "app" / "oidc.py"
+if not copy.exists():
+ failures.append("app/oidc.py missing")
+else:
+ got = hashlib.sha256(copy.read_bytes()).hexdigest()
+ if got == CANONICAL_SHA256:
+ print(f"ok - app/oidc.py matches the pinned canonical revision ({got[:16]}…)")
+ else:
+ failures.append(
+ "app/oidc.py DRIFTED from the pinned canonical revision\n"
+ f" pinned {CANONICAL_SHA256}\n"
+ f" actual {got}\n"
+ " fix: edit the canonical module (ops-docs: scripts/shared/oidc_client.py) "
+ "and run ops-docs/scripts/sync-oidc-module.sh — never hand-edit the copy.")
+
+main_src = (ROOT / "app" / "main.py")
+if not main_src.exists():
+ failures.append("app/main.py missing")
+elif EXPECTED_CONFIGURE not in main_src.read_text():
+ failures.append(
+ "app/main.py does not configure this app's oidc identity:\n"
+ f" expected literal: {EXPECTED_CONFIGURE}")
+
+if failures:
+ print()
+ print("FAILED: " + ", ".join(failures))
+ sys.exit(1)
+print("oidc sync pin: OK")