Skip to content
SHC Docs

SSO auto-redirect: the fleet coverage matrix

Layer 10. Edge. Edge

Status: MEASURED INVENTORY, 2026-08-10. Nothing in this document arms anything. Every app named here keeps ssoAutoRedirect defaulting to false, and every native knob keeps its own default of false.

Companion to docs/proposals/sso-auto-redirect.md, which is the SPEC and the authority on every verdict it states. This document is the CATALOGUE-WIDE answer to one question the proposal never answers directly:

Given that the mechanism shipped, how much of my fleet would actually auto-redirect if I turned it on, and why is that number not “all of it”?

Denominator: the 43 SSO-plugged apps (an oidc.plug.yaml or a saml.plug.yaml), which is the corpus TestEverySSOPluggedAppIsNamedInTheAutoRedirectAudit enforces. Three of those 43 have no login surface at all by design (identity-broker, mailbox-reconciler, nextcloud-picker), leaving 40 apps with a login surface.

countwhat it means
Could auto-redirect today24the mechanism is shipped AND wired in the app. An operator flips a flag; no code lands first.
Need a sibling lane’s work first6a mechanism is available and measured, but nothing is declared or wired yet.
Structurally excluded10measured to fail an author check in a way no declaration can fix at the pinned version.

24 + 6 + 10 = 40. Adding agent-canvas and graphiti (forward-auth gated, so already auto-redirecting, but carrying no SSO plug and therefore outside the 43) the fleet-wide “does or could auto-redirect today” figure is 27.

All 16 native-knob vars were re-read from vars.yaml on 2026-08-10 and every one of them is false:

keycloak.autoRedirect librechat windmill wordpress nextcloud matrix gitea
gitlab paperless immich ciso-assistant
defectdojo-classic wazuh
oidcOnly journiv
ssoOnly vaultwarden penpot
keycloak.makeDefault midpoint midpoint-classic

penpot joined that ssoOnly row on 2026-08-15 and is the one entry in it that is not in bucket 1: it is a bucket-3 app for AUTO-REDIRECT (the exclusion below is unchanged and unchangeable at this pin) that nonetheless has a native FORCE-SSO knob. The two are different mechanisms and only one of them was ever excluded; see “penpot’s native knob” under bucket 3. It brings the native-knob count to 17.

★ Why the fleet does not auto-redirect, in one paragraph

Section titled “★ Why the fleet does not auto-redirect, in one paragraph”

Not because coverage is thin: 24 of 40 are ready. Because there are two different operator surfaces and only one of them is documented as the operator surface. The proposal says the opt-in is a scoped config key, deliberately not a var:

Terminal window
shc config set --deployment <d> ssoAutoRedirect true

That key is read in exactly one place: ce/modules/app/ingress_materialize.go, gating the edge router built from an app.yaml sso_redirect: block. It reaches 6 apps. The other 16 were shipped as Implementation A and read a per-app var (vars.keycloak.autoRedirect, oidcOnly, ssoOnly, makeDefault) consumed by the app’s own compose template. shc config set ssoAutoRedirect true does not arm a single one of them, and it fails silently, because a config key with no reader is indistinguishable from a config key whose readers all declined.

An owner who armed four apps in a row and saw four login pages was most likely arming through the documented key against apps that only listen on the undocumented one.

The second-order reason is that rollout steps 1-3 of the proposal were executed after all, by other lanes, over 2026-08-07..10, in a shape the proposal was never updated to describe. The proposal still reads as though only Implementation C shipped with frappe as its single consumer. That is no longer true and has not been true for days.

  • A: the app’s own native auto-login setting, rendered by its compose/config template from a per-app var. Armed by a --var, applied by a redeploy.
  • B: a Traefik narrow redirect from app.yaml sso_redirect: {login_path, sso_start}. Armed by the scoped ssoAutoRedirect key, applied on the next ingress sweep.
  • C: sso_redirect: {login_path, sso_selector}, the response injector, for apps whose SSO href is minted per render. Same arming as B.
  • T1: forward-auth gate (access: gated). Not a tier of this feature: an unauthenticated browser is already redirected to Keycloak with no flag at all.
  • NONE-structural: measured to be unreachable by any of the above at the pinned version.

“Declared?” answers whether the app ships the wiring today, not whether it is on. Everything below is off.

1a. Edge router declared, armed by ssoAutoRedirect (6)

Section titled “1a. Edge router declared, armed by ssoAutoRedirect (6)”
apppinnedSSOmechdeclaredbypass (check 4)logout-safe (check 5)verdict
kutt3.2oidcByes?sso=falseyes: logout lands on /, not /loginREADY
affine0.27oidcB + launcher autoyes?sso=falseno: no end_session in the 0.27.3 bundleREADY, logout debt
affine-rs1.0oidcB + launcher autoyes?sso=falseno: no RP-initiated logout either sideREADY, logout debt
huly0.7oidcByes?sso=falseno: loops without a page loadREADY, logout debt
windmill1.776.0oidcB and Ayes (both)/user/login?no_sso=1no: unread at the pinREADY, logout debt
frappe15.118oidcCyes/login?sso=falseno: logout() never calls end_sessionREADY, logout debt

Five of these six fail check 5. That is recorded, argued and guarded in tests/unit/catalog/sso_logout_declaration_test.go’s ssoLogoutTradeAccepted map, and four of the five rows there say “OWED, NOT ACCEPTED”, meaning nobody has yet read the pinned version to find out whether it can end the IdP session. Arming these before the anti-bounce latch reaches the estates means logout signs the user straight back in.

1b. Native knob wired, armed by a per-app var (16)

Section titled “1b. Native knob wired, armed by a per-app var (16)”
apppinnedSSOmechvarbypass (check 4)logout-safe (check 5)
gitlab18.11oidcAkeycloak.autoRedirect/users/sign_in?auto_sign_in=falseyes: the zzz_shc_oidc_logout.rb initializer sends sign-out on to Keycloak’s end-session endpoint with id_token_hint
nextcloud34oidcAkeycloak.autoRedirect/login?direct=1yes: user_oidc single_logout
librechat0.8oidcA + B/auto (2026-08-17)keycloak.autoRedirect/login?redirect=false: one URL stops BOTH halves: bypass_query: redirect at the edge, the same key the shell readsyes: OPENID_USE_END_SESSION_ENDPOINT
matrix1.158oidcAkeycloak.autoRedirectNONE (declared closed_by)yes: logout_redirect_url
wazuh4.14oidcAkeycloak.autoRedirectNONE (declared closed_by)yes: logout_url
gitea1.27oidcAkeycloak.autoRedirectNONE (declared closed_by)no: trade accepted at 1.27.1
immich3.0oidcAkeycloak.autoRedirect/auth/login?autoLaunch=0app-side; trade accepted
paperless3.0oidcAkeycloak.autoRedirect/accounts/login/?loggedout=1trade accepted: logout lands off the SSO path
wordpress6.9oidcAkeycloak.autoRedirect/wp-login.php?login-error=1yes: endpoint_end_session
defectdojo-classic2.58oidcAkeycloak.autoRedirect/login?force_login_formno: trade accepted at 2.58.4
ciso-assistant3.20.8oidcA (caddy 302)keycloak.autoRedirectany query string, e.g. /login?local=1yes: "slo_enabled": True
journiv0.1.0-beta.23oidcAoidcOnlyNONE (declared closed_by)no: OWED, unread
vaultwarden1.37oidcAssoOnlyNONE (declared closed_by)no: OWED, unread
midpoint4.10oidcAkeycloak.makeDefault★ UNDECLARED: see belowUNMEASURED
midpoint-classic4.8oidcAkeycloak.makeDefault★ UNDECLARED: see belowUNMEASURED
netbird0.76oidcalready-onNoneno local accounts existn/a

mautic (7.1, saml) belongs to the same “already auto-redirecting once the plug is connected” class as netbird; its MainEntryPoint fires unconditionally, escape /s/login. It is counted in bucket 1 as the 24th app.

★★ The two rows that are a live defect: midpoint and midpoint-classic

Section titled “★★ The two rows that are a live defect: midpoint and midpoint-classic”

Both apps ship vars.keycloak.makeDefault: “Make the OIDC sequence the default for the GUI channel instead of the internal login form”. That is an SSO-arming, lockout-shaped switch by every definition this catalogue uses. Neither guard can see it, because both name-lists are spelled out longhand and makeDefault is in neither:

sso_logout_declaration_test.go ssoArmingVars = autoRedirect, ssoOnly, oidcOnly
local_login_declaration_test.go lockoutShapedVars = autoRedirect, ssoOnly, oidcOnly,
forceSso, force_sso

Consequences, both silent:

  1. Neither app declares local_login: closed_by:, so a restored midPoint whose GUI default sequence is OIDC will not emit X200042NOLOGIN. The G8 post-restore usable-login check reports it fine.
  2. Neither app is in ssoLogoutTradeAccepted, so the logout invariant passes over an app that arms SSO and configures no end-session path.

Both guards go green on midpoint today for the same reason the 2026-08-02 sweep went green without sonarqube: the corpus definition, not the app.

Measured 2026-08-10 against evolveum/midpoint:4.10.3-alpine (the pinned digest), booted on postgres with the stock security policy and no OIDC configured:

GET /midpoint/ 302 -> /midpoint/self/dashboard
GET /midpoint/login 302 -> /midpoint/login?0 (Wicket page versioning)
GET /midpoint/auth/emergency 302 -> /midpoint/login
GET /midpoint/auth/oidc 302 -> /midpoint/login
GET /midpoint/logout 302 -> /midpoint/login <-- check 5

Two readings, and they point in opposite directions:

  • Implementation B must not be declared for midPoint. Logout lands on /midpoint/login carrying no bypass query. A router anchored at ^{{ path('midpoint') }}/midpoint/login$ matches that hop, so signing out would 302 into the IdP and Keycloak’s live cookie would sign the user back in. That is the sonarqube shape exactly, and check 5 alone is disqualifying.
  • Implementation A is unaffected by that, because makeDefault moves the default sequence, and midPoint owns its own post-logout landing. What is unmeasured is whether the OIDC sequence ends the Keycloak session, and whether a break-glass sequence stays reachable. With the stock policy /midpoint/auth/emergency is not a distinct door; it bounces to the same login page.

Owed, and deliberately not done in this document (it edits app.yaml, which is a different lane’s consent): add makeDefault to both name lists, and either declare local_login: closed_by: [keycloak.makeDefault] on both midpoint apps or record the bypass that makes it survivable. Do not do one without the other: a closed_by on an app that does have a door is the false alarm that teaches operators to ignore the true ones.

Bucket 2: a mechanism exists, nothing is wired (6)

Section titled “Bucket 2: a mechanism exists, nothing is wired (6)”

Nothing here may be armed; each needs a lane to land a declaration first.

apppinnedSSOmech availablewhat is missing
superset6.1.0oidcB, measureda sso_redirect: declaration, and a logout fix first
mailcow2026.07aoidcA (force_sso)the knob is not wired to a var; and its login form is inline on /
peertube8.2oidcA (redirect_on_single_external_auth)not wired to a var
matomo5oidcUNMEASUREDnever audited past “no knob at pin”
postiz2.23oidcUNMEASUREDnever audited past “no knob at pin”
ivatar2.1oidcUNMEASUREDnever audited past “no knob at pin”

superset 6.1.0: MEASURED, and it is the best remaining candidate

Section titled “superset 6.1.0: MEASURED, and it is the best remaining candidate”

Measured 2026-08-10 by reading the shipped code inside the pinned image apache/superset:6.1.0@sha256:fb34645…, which carries flask-appbuilder 5.0.2. The app flips AUTH_TYPE = AUTH_OAUTH with a single provider literally named keycloak (compose.yaml), so the entry path is fixed by the app and needs no providerSlug plug field.

checkverdictevidence
1. login_path server-visiblepass/login/ is a server-rendered Jinja template, not an SPA route. FAB routes @expose("/login/").
2. plain GET, state minted server-sidepass@expose("/login/<provider>") → session["oauth_state"] = random_state then authorize_redirect(...). The state is a JWT and the verifier lives in the Flask session cookie. A 302 to /login/keycloak is byte-identical to a human clicking the button.
3. stable URLpass/login/keycloak is fixed; no per-render token.
4. bypass reaches the local form★ fail, and not for the usual reasonsee below
5. logout does not land on login_path★ fail, fixablesee below

Check 5. AuthOAuthView inherits logout() from AuthView: logout_user() then redirect(config.get("LOGOUT_REDIRECT_URL", get_url_for_index)). LOGOUT_REDIRECT_URL is absent from /app/superset/config.py at this pin (verified by importing the module inside the image) so logout lands on the index, which for an anonymous user bounces to /login/. Declaring B today would reintroduce the sonarqube logout loop.

Unlike sonarqube, this one has a fix that is a one-line app change: set LOGOUT_REDIRECT_URL to Keycloak’s end_session_endpoint. It moves the post-logout landing off login_path and delivers RP-initiated logout, clearing check 5 and the logout invariant in the same stroke. Nothing upstream has to change.

Check 4 is the real blocker and it is worth stating loudly. Under AUTH_TYPE = AUTH_OAUTH, FAB renders login_oauth.html, which contains only provider buttons; there is no username/password form at all. So /login/?sso=false reaches a page, but not a credential door. This is not a consequence of auto-redirect: binding the oidc integration to superset already closes local login today, unconditionally, with no var involved. Superset therefore needs a local_login: declaration on the integration edge regardless of whether auto-redirect is ever declared, and it has none.

Implementation C is structurally impossible here, which is worth recording so nobody tries it as a workaround for check 4. The template’s provider button carries no href:

<a id="btn-signin-{{provider.name}}" class="btn btn-primary btn-block" type="submit">

with navigation supplied by a click listener. The selector injector would find the element, read no href, log SSOSEL-NOHREF and serve the page unchanged forever, a declaration that is inert rather than wrong, which is the harder failure to notice.

Bucket 3: structurally excluded, measured (10)

Section titled “Bucket 3: structurally excluded, measured (10)”
apppinnedSSOfailing checkevidence
sonarqube26.7saml5 and 6logout and permission-denial both funnel to /sessions/new; no SAML SLO at the pin. exclude_query answers 6; 5 is the binding blocker.
dependency-track5.0oidc2PKCE verifier minted in the browser and never leaves browser storage; served HTML carries no <a>.
penpot2.17oidc1 and 2 (EDGE only)login page is the SPA fragment /#/auth/login, never sent to the server; /api/auth/oidc is :allowed-methods #{:post} and answers 200 JSON. Both refusals are PERMANENT for the edge grades. ★ CLICK grade declared 2026-08-22: see below. ★ has a native FORCE-SSO knob: see below.
glitchtip6.2.5oidc2★ newly measured: see below
minio-classic2025.4.22oidc2★ newly measured: see below
minio2025.9.7oidc2returns JSON for the SPA to navigate itself.
supabase2.0oidc2POST-only initiation (proposal, 2026-08-02).
highlight0.5.6oidc1SPA shell, no server-visible login path (fleet path table).
monica4.1oidcn/ahas no SSO at 4.1.2: the keycloak vars are reserved for the unreleased v5.
blockscout9.0.2oidcn/athe sso plug is inert at the pin: ACCOUNT_KEYCLOAK_* exists upstream only from v10.1.0.

The last two are excluded because there is no working SSO to redirect into, not because the redirect mechanism fails. They are bugs tracked by the proposal, restated here so the count is honest.

Two corrections to penpot’s row, both made 2026-08-15 by reading the pinned penpotapp/backend:2.17.0 jar (digest sha256:471cdebf185b…) rather than re-copying the audit:

  • the old evidence cited GET /api/rpc/command/login-with-oidc → 405. That 405 is real and proves nothing: app/rpc.clj raises :method-not-allowed for any GET on /api/rpc/command/<name> not beginning get-, before the handler is looked up, so a nonexistent command answers it too. login-with-oidc was never an RPC method. The real refusal is the route table in app/auth/oidc.clj (["" {:allowed-methods #{:post}}]) and auth-handler ending {::yres/status 200 ::yres/body {:redirect-uri …}}. app.yaml has carried the correction since 2026-08-11; this table had not.
  • the row said nothing about force-SSO, and readers took bucket 3 to mean “penpot can do nothing here”. It cannot AUTO-REDIRECT. It can go SSO-only.

★ A third correction, 2026-08-22: it CAN auto-redirect, on the click grade. Both refusals above are about the EDGE and both remain permanent: a fragment is never transmitted, and l.replace() can only GET. The CLICK grade (sso_click_selector:) navigates nowhere: it waits for penpot’s own SSO control and presses it, and the page issues that POST itself with penpot’s own state. What made it possible was one plugin field, match_hash: true, which moves the injected payload’s route string from location.pathname to pathname + hash, necessary here because penpot’s login screen and a signed-in user’s dashboard share the pathname /, and because the PV/LO logout-transition latch is keyed on that same string and would otherwise never fire on a hash-routed logout. The mode is off by default and penpot is its only caller (swept: it is the catalogue’s only fragment-routed login). The declaration is login_path: "(?i)^/#/auth/login"

  • match_hash: true + sso_click_selector: "a.main_ui_auth_login__btn-oidc-auth" + launcher: auto, ledgered in tests/unit/catalog/sso_click_selector_test.go.

★ penpot’s native knob: bucket 3 for redirect, bucket 1b for force-SSO

Section titled “★ penpot’s native knob: bucket 3 for redirect, bucket 1b for force-SSO”

--var ssoOnly=true renders disable-login-with-password in place of enable-login-with-password into PENPOT_FLAGS on both penpot services, which is upstream’s own force-SSO flag and closes both surfaces at once:

  • app/common/flags.cljc:209: parse folds the list left and disable-X is (disj result :X); app/config.clj:298 passes PENPOT_FLAGS last, so the token beats the :enable-login-with-password in flags/default.
  • app/rpc/commands/auth.clj:56-63: the RPC raises :restriction/:login-disabled, so a hand-crafted POST is refused too.
  • app/main/ui/auth/login.cljs:257-260 (from the shipped main-auth.js.map): the SPA renders login-form* only on :login/:login-with-password/ :login-with-ldap, so the page becomes the OIDC button and nothing else.

It is a one-button login page, not a 302: the mailcow/vaultwarden class (bucket 1b), and the fragment-routing exclusion above is untouched by it. The knob is gated on a bound oidc integration (local_login.gated_on_edge: true) because penpot has no third state: closing the form with no IdP wired renders a login page carrying neither a form nor a button. It ships false, is deaf to the fleet-wide ssoAutoRedirect key (a lockout decision, not a redirect preference), and has no bypass: local_login.closed_by: [ssoOnly]. Pinned by tests/unit/catalog/penpot_sso_only_test.go.

Penpot’s logout was read at the same time and is a finding, not a trade: app/auth/oidc.clj:56 takes end_session_endpoint off the IdP’s own discovery document and ::logout (auth.clj:143-169) answers a :redirect-uri to it, so penpot does RP-initiated logout in app code with no app setting to write, the immich/journiv shape, recorded in ssoLogoutTradeAccepted.

★ glitchtip 6.2.5: the proposal’s “inconclusive” row, now resolved

Section titled “★ glitchtip 6.2.5: the proposal’s “inconclusive” row, now resolved”

The proposal recorded glitchtip as inconclusive: probed read-only on a live estate, every path returned an identical 5847-byte shell, so the backend routes were not observable. It asked for a local bring-up. Done 2026-08-10: glitchtip/glitchtip:6.2.5 on postgres 16 and valkey, with the socialaccount_socialapp row written exactly as the app’s oidc.plug.yaml writes it (provider='openid_connect', provider_id='keycloak', settings={'server_url': …}).

GET / 200 28671 bytes
GET /login 200 28671 bytes (identical)
GET /profile 200 28671 bytes (identical)
GET /accounts/oidc/keycloak/login/ 404
GET /accounts/oidc/keycloak/login/callback/ 302 -> /login?socialLoginError=true
GET /_allauth/browser/v1/auth/provider/redirect 405

and, read out of the running app:

SOCIALACCOUNT_LOGIN_ON_GET = False

Check 2 fails, decisively and twice over. The SPA’s real initiation is POST /_allauth/browser/v1/auth/provider/redirect: 405 on GET, exactly as the app’s own plug comment documents. And even the allauth provider-login route, which does resolve in the URLconf (allauth_async.urls.view, kwargs {'provider_id': 'keycloak'}), cannot serve as sso_start: with LOGIN_ON_GET = False allauth 65.16.1 does not 302 on a GET, it renders an intermediate auto-POST form. A Traefik redirect cannot enter that flow.

Implementation C cannot rescue it: the served /login HTML contains zero <a> elements and not one occurrence of keycloak, oidc, provider or socialaccount. The button is Angular-rendered. Same terminal state as dependency-track, reached by a different road.

★ The generalisation is worth more than the row. Any django-allauth app at allauth ≥ 0.55 ships SOCIALACCOUNT_LOGIN_ON_GET = False by default, and therefore fails check 2 on its provider-login route. Check that setting before auditing an allauth app, not the route’s HTTP status.

★ minio-classic 2025.4.22: inheritance confirmed, no longer assumed

Section titled “★ minio-classic 2025.4.22: inheritance confirmed, no longer assumed”

The proposal listed minio-classic as “not audited; expected to inherit minio’s check-2 failure, unverified”. Measured 2026-08-10 against the pinned minio/minio:RELEASE.2025-04-22T22-12-26Z with a reachable discovery document:

GET / 200 1309 bytes
GET /login 200 1309 bytes (identical shell, zero <a> elements)
GET /oauth_callback 200 1309 bytes (identical)
GET /api/v1/login 406 to a text/html Accept; JSON body regardless:
{"loginStrategy":"redirect",
"redirectRules":[{"displayName":"Keycloak",
"redirect":"http://…/protocol/openid-connect/auth?client_id=minio&…&state=…"}]}

MinIO does mint the authorize URL and the state server-side; the failure is purely one of transport: the URL is handed to the SPA as JSON for it to navigate itself. There is no server-side GET that 302s, and the console shell carries no anchor for a selector to read. Check 2 fails. Inheritance from minio is now measured rather than expected.

Incidental, and load-bearing for anyone reproducing this: MinIO refuses to finish booting while OIDC discovery is unreachable, retrying Unable to initialize OpenID forever. A dead Keycloak does not degrade MinIO to local-only login; it prevents the service starting at all. That is a bigger operational fact than anything in this row.

Not applicable: no login surface (3 of the 43)

Section titled “Not applicable: no login surface (3 of the 43)”
appwhy
identity-brokerin-cluster sidecar; publicUrl is published empty. Its oidc edge validates tokens minted elsewhere; no browser ever lands on a login page it serves.
mailbox-reconcilerheadless daemon, no ingress, no HTTP listener. Its oidc plug is only the carrier of Keycloak’s admin credentials.
nextcloud-pickersee the decision below.

nextcloud-picker: the design decision the proposal said was owed

Section titled “nextcloud-picker: the design decision the proposal said was owed”

The proposal deferred this: “it is an embeddable iframe bridge, not a destination app; auto-redirecting an iframe’s login into a top-level IdP flow is a different question, and needs deciding before it is measured.”

Decision: out of scope, and structurally so: do not measure it, do not declare it. Two independent reasons, either sufficient:

  1. It has no login page to redirect. The app owns exactly one browser-facing OIDC route, its callback ({{ url('picker') }}/oidc/callback, scoped deliberately tight because this client is the subject of a token exchange for the Nextcloud audience). There is no login form and no login_path for a router to anchor to.
  2. A top-level IdP flow inside a third-party iframe cannot complete anyway. Keycloak serves its login page with frame-ancestors limited to itself; an embedded picker navigating its own frame to the authorize endpoint gets a refusal, not a login. The picker’s session is established by its embedder’s flow, not by one it starts.

This closes the row rather than leaving it open. If the picker ever grows a standalone destination mode, that mode is a new app.yaml question and this decision does not bind it.

addons/ ships four apps; postgres and traefik have no browser login surface (traefik’s dashboard is a var-gated panel, not an authenticated app).

apppinnedSSOmechverdict
keycloak26.7it is the IdPn/aN/A by construction: auto-redirecting Keycloak into itself is not a coherent request.
openobserve0.91.5oidc, via a bundled Dex sidecar, enterprise build onlyNONE-structuralthe auto-login flag is compiled into the SaaS build only (proposal, 2026-08-02). On the OSS arm there is no SSO at all. Root email+password stays as break-glass.

Apps with no SSO plug and therefore no row

Section titled “Apps with no SSO plug and therefore no row”

The catalogue holds 91 apps. 43 carry an SSO plug; the other 48 carry neither an oidc nor a saml plug and are out of scope by definition:

  • 23 datastore / shim standalones: clickhouse, ethereum, gitlab-runner, hockeypuck, kubo, mail, mariadb, mongodb, mysql, nginx, ollama, pmm, redis, s3, and the nine external-* shims. No browser login surface at all.
  • 4 headless bridges / sidecars: gitlab-huly, huly-matrix-notifier, hookshot, crowdsec.
  • 3 test fixtures: test-data, test-simple, whoami.
  • 2 forward-auth gated apps: agent-canvas, graphiti. See below.
  • 15 apps that simply have no SSO yet: defectdojo (3.x), dify, docuseal, fleet, fusionpbx, greenbone, hyperswitch, jellyfin, keygen, medusa, metabase, plane, pulp, shlink, uptime-kuma. These are the real growth edge of this matrix: each one becomes a row here the day it gains a plug.

agent-canvas and graphiti deserve their own line: both are access: gated, so their unauthenticated browsers are already redirected to Keycloak by forward-auth, with no flag and no declaration. They sit outside the 43-app denominator only because a gated app needs no SSO plug of its own, but operationally they are the tier-1 answer, not a gap. Counting them, the fleet has 27 apps that auto-redirect or could today, not 24.

★ openreplay: a verdict, and a stale comment worth fixing

Section titled “★ openreplay: a verdict, and a stale comment worth fixing”

The proposal lists openreplay 1.27 as “not audited”. It does not need this feature: apps/flagship/openreplay/app.yaml declares

access: gated
ungated_paths:
- /ingest/
- /script/

so its dashboard already auto-redirects to Keycloak through forward-auth. Counted in bucket 1’s tier-1 group.

Two things a future auditor should not trip over:

  • The app.yaml comment above that block is stale. It reads “OpenReplay does NOT ship an oidc.plug; it rides the gate.” The app does ship oidc.plug.yaml, targeting an SHC soft-fork image that adds an additive OIDC login router to the AGPL tree. The prose and the directory disagree, and the prose is the older one.
  • That combination is the RULING T-1b shape, and it is an open question rather than a finding here. The proposal’s tier-1 rule says forward-auth “must NOT front native-OIDC apps” (it 401s non-HTML traffic and mangles WebSocket upgrades) and openreplay is now both gated and natively OIDC. ungated_paths carves out the tracker ingest, so the measured affine-rs failure mode may not apply. Not measured here. It wants the same EMP-A style upgrade probe affine-rs got before anyone concludes either way.

Listed so silence is not mistaken for a verdict, the defect class this whole programme exists to close.

apppinnedwhat is unmeasuredwhy not closed here
midpoint / midpoint-classic4.10 / 4.8checks 4 and 5 with OIDC configuredthe app documents seeding the SecurityPolicy and setting globalSecurityPolicyRef as MANUAL steps, and it needs a live Keycloak. The login-surface and logout-landing probes above were run without OIDC; they are properties of the app and stand.
matomo, postiz, ivatar5, 2.23, 2.1everything past “no native knob at the pin”the 2026-08-02 sweep recorded the configuration answer only. Whether a GET-able OIDC entry exists was never asked.
defectdojo-classic2.58nothing blocking; it has knob Alisted because it sits in the proposal’s not yet audited table for the sso_redirect question, which is the wrong question for it.
openreplay1.27the gated-plus-native-OIDC interactionsee above.
midpoint-classic runtime4.8the 4.10 probes were not repeated on 4.8the arming var is confirmed present in the app; the runtime shape is assumed to match and is marked as such.

What this document deliberately did not do

Section titled “What this document deliberately did not do”
  • Nothing was armed. No app.yaml, compose.yaml or vars.yaml was touched on this branch; ssoAutoRedirect and every native knob keep their false defaults. Arming is an owner decision and is gated on the anti-bounce latch reaching the estates: landed, not rolled. Arming before it rolls means logout signs the user straight back in, which is precisely the failure five of the six declared apps already carry.
  • No verdict in the proposal was overturned without re-measuring. The three rows this document changes (glitchtip, minio-classic, superset) each carry their transcript. midpoint’s is new, not a contradiction.
  • The two owed app.yaml edits are named, not made: makeDefault in both guard name-lists plus a local_login decision on midpoint, and a local_login decision for superset’s AUTH_OAUTH edge. Both edit apps other lanes own.

All local, no estate contact, pinned images only.

Terminal window
# glitchtip
docker run -d --name gt --network N -e DATABASE_URL=… -e VALKEY_URL=… \
glitchtip/glitchtip:6.2.5
docker exec gt python /code/manage.py shell -c \
"from allauth.socialaccount import app_settings as s; print(s.LOGIN_ON_GET)"
# minio-classic (needs a reachable discovery document or it never boots)
docker run -d --name mc -e MINIO_IDENTITY_OPENID_CONFIG_URL=… \
minio/minio:RELEASE.2025-04-22T22-12-26Z server /data --console-address :9001
curl -s http://mc:9001/api/v1/login
# superset (read the shipped code; no bring-up needed)
docker run --rm --entrypoint sh apache/superset:6.1.0 -c \
'python -c "import flask_appbuilder,os;print(open(os.path.join(os.path.dirname(flask_appbuilder.__file__),\"security\",\"views.py\")).read())"'
# midpoint
docker run -d --name mp -e MP_SET_midpoint_repository_jdbcUrl=… \
evolveum/midpoint:4.10.3-alpine
curl -s -o /dev/null -w '%{http_code} %{redirect_url}' http://mp:8080/midpoint/logout