pgkiln 0.62.0 → 0.64.0

package/src/builder/builder-sso.ts

@@ -0,0 +1,135 @@
+import type { FastifyInstance } from 'fastify';
+import { owner } from '../db.ts';
+import { html, raw, type Raw } from '../html.ts';
+import { icon } from '../icons.ts';
+import { clientIp, logActivity, type Session } from '../session.ts';
+import { breakGlassAdmins, builderSources, identitiesOf, ssoRequired } from '../devsso.ts';
+import { isAdmin } from './locks.ts';
+import { tr } from './i18n.ts';
+import { administrator, back, BASE, csrf, developer, flash, input, region, type Req } from './ui.ts';
+
+// (sprint 129, SEC-1) Builder sign-in through identity providers and LDAP directories (devsso.ts):
+//  * Users → Identity providers / LDAP directories → "Builder sign-in": on or off, creating developers,
+//    linking existing ones, the groups; the developers linked there;
+//  * Security: the developer's own identities, "Link" for each provider, "Unlink";
+//  * Developers: break-glass administrators (they may use the pgkiln password where a workspace
+//    requires single sign-on).
+
+type Kind = 'provider' | 'directory';
+const TABLE = { provider: 'meta.auth_provider', directory: 'meta.ldap_directory' } as const;
+const COLUMN = { provider: 'provider_id', directory: 'directory_id' } as const;
+const PATH = { provider: 'providers', directory: 'directories' } as const;
+
+const check = (name: string, label: string, on: boolean, help?: string) =>
+  html`<div class="field"><label class="check"><input type="checkbox" name="${name}" value="true"${on ? raw(' checked') : ''}> ${label}</label>${help ? html`<small class="help">${help}</small>` : ''}</div>`;
+
+/** The "Builder sign-in" region of a provider's or directory's page. */
+export async function builderSignInRegion(s: Session, kind: Kind, row: { id: number; builder: boolean; builder_auto_create: boolean; builder_link_existing: boolean; builder_group: string | null; builder_admin_group: string | null }): Promise<Raw> {
+  const tx = tr(s);
+  const linked = (await owner.query<{ id: number; username: string; linked_at: string }>(
+    `select id, username, linked_at from meta.developer_identity where ${COLUMN[kind]} = $1 order by username`, [row.id])).rows;
+  return region(tx('bsso.title'), html`<p class="muted u-mt0">${tx('bsso.intro')}</p>
+    <form method="post" action="${BASE}/users/${PATH[kind]}/${row.id}/builder">${csrf(s)}
+      ${check('builder', tx('bsso.on'), row.builder, tx('bsso.on_help'))}
+      ${check('builder_auto_create', tx('bsso.auto_create'), row.builder_auto_create, tx('bsso.auto_create_help'))}
+      ${check('builder_link_existing', tx('bsso.link_existing'), row.builder_link_existing, tx('bsso.link_existing_help'))}
+      <div class="form-grid">
+        ${input('builder_group', tx('bsso.group'), row.builder_group ?? '', { help: tx('bsso.group_help') })}
+        ${input('builder_admin_group', tx('bsso.admin_group'), row.builder_admin_group ?? '', { help: tx('bsso.admin_group_help') })}
+      </div>
+      <div class="buttons"><button class="btn">${tx('bsso.save')}</button></div></form>
+    <h3>${tx('bsso.linked')}</h3>
+    ${linked.length
+      ? html`<ul class="plain-list">${linked.map((l) => html`<li>${icon('user')} ${l.username} <span class="muted small">${String(l.linked_at).slice(0, 10)}</span>
+          <form method="post" action="${BASE}/developers/identity/${l.id}/unlink" class="u-inline">${csrf(s)}<button class="link-button" data-confirm="${tx('bsso.unlink_confirm', { user: l.username })}">${tx('bsso.unlink')}</button></form></li>`)}</ul>`
+      : html`<p class="muted">${tx('bsso.none_linked')}</p>`}`, '', 'builder-sign-in');
+}
+
+/** The Security page's region: the developer's identities, and the providers to link. */
+export async function identitiesRegion(s: Session, linkedNow: string | undefined): Promise<Raw | ''> {
+  const tx = tr(s);
+  const [mine, sources] = await Promise.all([identitiesOf(s.username!), builderSources()]);
+  if (!mine.length && !sources.providers.length && !sources.directories.length) return '';
+  const linkable = sources.providers.filter((p) => !mine.some((m) => m.kind === 'provider' && m.source === p.name));
+  const linked = linkedNow ? mine.find((m) => m.kind === 'provider' && m.source === linkedNow) : undefined;
+  return region(tx('bsso.yours'), html`<p class="muted u-mt0">${tx('bsso.yours_intro')}</p>
+    ${linked ? html`<div class="alert alert-success" role="status">${tx('bsso.linked_now', { provider: linked.display_name })}</div>` : ''}
+    ${mine.length
+      ? html`<ul class="plain-list">${mine.map((m) => html`<li>${icon(m.kind === 'provider' ? 'log-in' : 'server')} ${m.display_name} <span class="muted small">${String(m.linked_at).slice(0, 10)}</span>
+          <form method="post" action="${BASE}/developers/identity/${m.id}/unlink" class="u-inline">${csrf(s)}<button class="link-button" data-confirm="${tx('bsso.unlink_mine_confirm', { provider: m.display_name })}">${tx('bsso.unlink')}</button></form></li>`)}</ul>`
+      : html`<p class="muted">${tx('bsso.none_yours')}</p>`}
+    ${linkable.map((p) => html`<form method="post" action="${BASE}/security/link/${p.name}" class="u-inline">${csrf(s)}<button class="btn">${icon('link')} ${tx('bsso.link', { provider: p.display_name })}</button></form> `)}
+    ${sources.directories.length ? html`<p class="muted small">${tx('bsso.directories_note')}</p>` : ''}`, '', 'identities');
+}
+
+/** Would this change leave a workspace that requires single sign-on without a break-glass administrator? */
+export async function leavesNoBreakGlass(username: string) {
+  if (!(await owner.one('select 1 as ok from meta.workspace where sso_only limit 1'))) return false;
+  const left = (await breakGlassAdmins()).filter((u) => u !== username);
+  return left.length === 0;
+}
+
+export async function builderSsoRoutes(app: FastifyInstance) {
+  for (const kind of ['provider', 'directory'] as Kind[])
+    app.post(`${BASE}/users/${PATH[kind]}/:id(^\\d{1,9}$)/builder`, async (req: Req, reply) => {
+      const s = await administrator(req, reply, kind === 'provider' ? 'Identity providers' : 'LDAP directories');
+      if (!s) return;
+      const b = req.body ?? {};
+      const group = (v: unknown) => String(v ?? '').trim().slice(0, 200) || null;
+      const on = b.builder === 'true';
+      const r = await owner.one<{ name: string }>(
+        `update ${TABLE[kind]} set builder = $2, builder_auto_create = $3, builder_link_existing = $4, builder_group = $5, builder_admin_group = $6
+          where id = $1 returning name`,
+        [req.params.id, on, b.builder_auto_create === 'true', b.builder_link_existing === 'true', group(b.builder_group), group(b.builder_admin_group)],
+      );
+      if (!r) return reply.code(404).send('Not found');
+      await logActivity({ username: s.username, event: 'sso_policy', ip: clientIp(req), detail: `${kind} ${r.name}: builder sign-in ${on ? 'on' : 'off'}` });
+      flash(s, tr(s)('bsso.saved'));
+      return back(reply, s, `${BASE}/users/${PATH[kind]}/${req.params.id}#builder-sign-in`);
+    });
+
+  // unlinking: the developer's own identity, or any for an administrator
+  app.post(`${BASE}/developers/identity/:id(^\\d{1,9}$)/unlink`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    const tx = tr(s);
+    const i = await owner.one<{ username: string; provider_id: number | null; directory_id: number | null }>('select username, provider_id, directory_id from meta.developer_identity where id = $1', [req.params.id]);
+    const admin = await isAdmin(s.username);
+    if (!i || (i.username !== s.username && !admin)) return reply.code(404).send('Not found');
+    const where = i.username === s.username ? `${BASE}/security#identities` : `${BASE}/users/${i.provider_id ? 'providers' : 'directories'}/${i.provider_id ?? i.directory_id}#builder-sign-in`;
+    // the last identity of a developer who must use single sign-on: they could not sign in any more
+    const only = await owner.one<{ n: number }>('select count(*)::int as n from meta.developer_identity where username = $1', [i.username]);
+    if (only!.n <= 1 && (await ssoRequired(i.username))) {
+      flash(s, tx('bsso.keep_one'), 'error');
+      return back(reply, s, where);
+    }
+    await owner.query('delete from meta.developer_identity where id = $1', [req.params.id]);
+    await logActivity({ username: s.username, event: 'sso_unlinked', ip: clientIp(req), detail: `${i.username}: ${i.provider_id ? `provider ${i.provider_id}` : `directory ${i.directory_id}`}` });
+    flash(s, tx('bsso.unlinked'));
+    return back(reply, s, where);
+  });
+
+  // break-glass: administrators only, for administrators
+  app.post(`${BASE}/developers/break-glass`, async (req: Req, reply) => {
+    const s = await developer(req, reply);
+    if (!s) return;
+    if (!(await isAdmin(s.username))) return reply.code(403).send('Only administrators change break-glass access.');
+    const tx = tr(s);
+    const username = String(req.body?.username ?? '');
+    const on = req.body?.break_glass === 'true';
+    const d = await owner.one<{ is_admin: boolean }>('select is_admin from meta.developer where username = $1', [username]);
+    if (!d) return reply.code(404).send('Not found');
+    if (on && !d.is_admin) {
+      flash(s, tx('bsso.break_glass_admins'), 'error');
+      return back(reply, s, `${BASE}/developers`);
+    }
+    if (!on && (await leavesNoBreakGlass(username))) {
+      flash(s, tx('bsso.keep_break_glass'), 'error');
+      return back(reply, s, `${BASE}/developers`);
+    }
+    await owner.query('update meta.developer set break_glass = $2 where username = $1', [username, on]);
+    await logActivity({ username: s.username, event: 'sso_policy', ip: clientIp(req), detail: `${username}: break-glass ${on ? 'on' : 'off'}` });
+    flash(s, tx(on ? 'bsso.break_glass_on' : 'bsso.break_glass_off', { user: username }));
+    return back(reply, s, `${BASE}/developers`);
+  });
+}

package/src/builder/i18n/de.ts

@@ -1820,4 +1820,60 @@ export const de: BuilderMessages = {
   'wsp.mfa_save': 'Zwei-Faktor-Regel speichern',
   'wsp.mfa_on': 'Die Entwickler dieses Workspace brauchen die Zwei-Faktor-Anmeldung.',
   'wsp.mfa_off': 'Der Workspace verlangt keine Zwei-Faktor-Anmeldung mehr (die Richtlinie der Instanz gilt weiter).',
+  'signin.method': 'Anmelden mit',
+  'signin.method_pgkiln': 'pgkiln-Konto',
+  'signin.with': 'Mit {provider} anmelden',
+  'signin.ldap_unavailable': '{directory} ist nicht erreichbar. Versuchen Sie es später erneut.',
+  'signin.sso_required': 'Ihr Workspace verlangt Single Sign-on: Melden Sie sich über Ihren Identitätsanbieter an.',
+  'signin.sso_unavailable': '{provider} ist nicht erreichbar. Versuchen Sie es später erneut.',
+  'bsso.title': 'Builder-Anmeldung',
+  'bsso.intro': 'Entwickler können sich auch mit diesem Anbieter im Builder anmelden. Sie werden über die verknüpfte Identität gefunden, nie nur über den Namen.',
+  'bsso.on': 'Entwickler können sich damit im Builder anmelden',
+  'bsso.on_help': 'Die Anmeldeseite zeigt ihn an. Bei dieser Anmeldung entfällt der zweite Faktor von pgkiln: Der Anbieter entscheidet.',
+  'bsso.auto_create': 'Entwickler bei der ersten Anmeldung anlegen',
+  'bsso.auto_create_help': 'Für Mitglieder der unten angegebenen Entwicklergruppe (alle, wenn sie leer ist). Neue Entwickler kommen in den Default-Workspace.',
+  'bsso.link_existing': 'Vorhandenen Entwickler mit demselben Benutzernamen verknüpfen',
+  'bsso.link_existing_help': 'Einmalig, bei der ersten Anmeldung; nie ein Notfall-Administrator. Nur einschalten, wenn Sie den Benutzernamen des Anbieters vertrauen. Sonst verknüpfen Entwickler die Identität auf ihrer Sicherheitsseite.',
+  'bsso.group': 'Entwicklergruppe',
+  'bsso.group_help': 'Nur ihre Mitglieder erhalten ein Entwicklerkonto. Leer: alle, die der Anbieter anmeldet.',
+  'bsso.admin_group': 'Administratorengruppe',
+  'bsso.admin_group_help': 'Wenn gesetzt, sind ihre Mitglieder Administratoren der Instanz und andere nicht, geprüft bei jeder Anmeldung (Notfall-Administratoren behalten ihre Rolle).',
+  'bsso.save': 'Builder-Anmeldung speichern',
+  'bsso.saved': 'Builder-Anmeldung gespeichert.',
+  'bsso.linked': 'Verknüpfte Entwickler',
+  'bsso.none_linked': 'Noch kein Entwickler verknüpft.',
+  'bsso.unlink': 'Verknüpfung lösen',
+  'bsso.unlink_confirm': '{user} lösen? Die Person meldet sich mit dem Kennwort an oder verknüpft erneut.',
+  'bsso.unlink_mine_confirm': '{provider} lösen? Sie können erneut verknüpfen.',
+  'bsso.unlinked': 'Die Identität ist nicht mehr verknüpft.',
+  'bsso.keep_one': 'Ein Workspace verlangt von diesem Entwickler Single Sign-on: Behalten Sie eine verknüpfte Identität.',
+  'bsso.yours': 'Single Sign-on',
+  'bsso.yours_intro': 'Die Identitätsanbieter, mit denen Sie sich im Builder anmelden können.',
+  'bsso.none_yours': 'Noch keine Identität verknüpft.',
+  'bsso.link': '{provider} verknüpfen',
+  'bsso.linked_now': '{provider} ist verknüpft: Sie können sich damit anmelden.',
+  'bsso.directories_note': 'Ein LDAP-Verzeichnis wird bei der ersten Anmeldung damit verknüpft (ein Administrator erlaubt das pro Verzeichnis).',
+  'bsso.break_glass': 'Notfallzugang',
+  'bsso.break_glass_help': 'Darf sich mit dem pgkiln-Kennwort anmelden, wo ein Workspace Single Sign-on verlangt – für den Fall, dass der Identitätsanbieter ausfällt.',
+  'bsso.break_glass_make': 'Notfallzugang geben',
+  'bsso.break_glass_remove': 'Notfallzugang entziehen',
+  'bsso.break_glass_on': '{user} ist Notfall-Administrator. Richten Sie auch einen zweiten Faktor ein.',
+  'bsso.break_glass_off': '{user} ist kein Notfall-Administrator mehr.',
+  'bsso.break_glass_admins': 'Nur Administratoren können Notfallzugang haben.',
+  'bsso.keep_break_glass': 'Ein Workspace verlangt Single Sign-on: Behalten Sie mindestens einen Notfall-Administrator.',
+  'wsp.sso': 'Single Sign-on',
+  'wsp.sso_only': 'Die Entwickler dieses Workspace müssen sich über einen Identitätsanbieter anmelden',
+  'wsp.sso_only_help': 'Oder ein LDAP-Verzeichnis. Das pgkiln-Kennwort und ein Passkey allein werden abgelehnt, außer für Notfall-Administratoren. `pgkiln admin builder-sign-in password` schaltet es ab.',
+  'wsp.sso_unlinked': 'Noch keine verknüpfte Identität (können sich nicht anmelden): {list}.',
+  'wsp.sso_save': 'Single-Sign-on-Regel speichern',
+  'wsp.sso_on': 'Die Entwickler dieses Workspace müssen Single Sign-on verwenden.',
+  'wsp.sso_off': 'Die Entwickler des Workspace dürfen wieder das pgkiln-Kennwort verwenden.',
+  'wsp.sso_no_break_glass': 'Geben Sie zuerst einem Administrator Notfallzugang (Entwickler), damit sich jemand anmelden kann, wenn der Identitätsanbieter ausfällt.',
+  'wsp.sso_link_first': 'Verknüpfen Sie zuerst auf Ihrer Sicherheitsseite eine Identität, sonst könnten Sie sich selbst nicht anmelden.',
+  'us.mfa_title': 'Zwei-Faktor-Anmeldung',
+  'us.mfa_status': 'Authenticator-Apps: {n}. Verbleibende Wiederherstellungscodes: {codes}.',
+  'us.mfa_none': 'Noch keine Authenticator-App.',
+  'us.mfa_reset_help': 'Entfernt die Authenticator-Apps und Wiederherstellungscodes von {user} und meldet das Konto überall ab. Wo eine Anwendung die Zwei-Faktor-Anmeldung verlangt, wird bei der nächsten Anmeldung eine neue App hinzugefügt. Wird protokolliert.',
+  'us.mfa_reset_done': 'Die Zwei-Faktor-Anmeldung von {user} wurde zurückgesetzt.',
+  'us.mfa_reason_needed': 'Geben Sie einen Grund für das Zurücksetzen an.',
 };

package/src/builder/i18n/en.ts

@@ -1823,4 +1823,60 @@ export const en = {
   'wsp.mfa_save': 'Save two-factor rule',
   'wsp.mfa_on': 'This workspace’s developers need two-factor sign-in.',
   'wsp.mfa_off': 'The workspace no longer requires two-factor sign-in (the instance’s policy still applies).',
+  'signin.method': 'Sign in with',
+  'signin.method_pgkiln': 'pgkiln account',
+  'signin.with': 'Sign in with {provider}',
+  'signin.ldap_unavailable': '{directory} cannot be reached. Try again later.',
+  'signin.sso_required': 'Your workspace requires single sign-on: use your identity provider.',
+  'signin.sso_unavailable': '{provider} cannot be reached. Try again later.',
+  'bsso.title': 'Builder sign-in',
+  'bsso.intro': 'Developers can sign in to the builder with this provider too. They are found by the identity they linked, never by name alone.',
+  'bsso.on': 'Developers can sign in to the builder with it',
+  'bsso.on_help': 'The sign-in page shows it. Signing in this way skips pgkiln’s own second factor: the provider decides.',
+  'bsso.auto_create': 'Create developers on their first sign-in',
+  'bsso.auto_create_help': 'For members of the developers group below (anyone, when it is empty). New developers join the Default workspace.',
+  'bsso.link_existing': 'Link an existing developer with the same user name',
+  'bsso.link_existing_help': 'Once, on the first sign-in; never a break-glass administrator. Turn it on only when the provider’s user names are yours to trust. Otherwise developers link the identity on their Security page.',
+  'bsso.group': 'Developers group',
+  'bsso.group_help': 'Only its members get a developer account. Empty: anyone the provider signs in.',
+  'bsso.admin_group': 'Administrators group',
+  'bsso.admin_group_help': 'When set, its members are instance administrators and others are not, checked at every sign-in (break-glass administrators keep their role).',
+  'bsso.save': 'Save builder sign-in',
+  'bsso.saved': 'Builder sign-in saved.',
+  'bsso.linked': 'Linked developers',
+  'bsso.none_linked': 'No developer is linked yet.',
+  'bsso.unlink': 'Unlink',
+  'bsso.unlink_confirm': 'Unlink {user}? They sign in with the password, or link again.',
+  'bsso.unlink_mine_confirm': 'Unlink {provider}? You can link it again.',
+  'bsso.unlinked': 'The identity is unlinked.',
+  'bsso.keep_one': 'A workspace requires single sign-on of this developer: keep one linked identity.',
+  'bsso.yours': 'Single sign-on',
+  'bsso.yours_intro': 'The identity providers you can sign in to the builder with.',
+  'bsso.none_yours': 'No identity linked yet.',
+  'bsso.link': 'Link {provider}',
+  'bsso.linked_now': '{provider} is linked: you can sign in with it.',
+  'bsso.directories_note': 'An LDAP directory is linked when you first sign in with it (an administrator allows that per directory).',
+  'bsso.break_glass': 'break-glass',
+  'bsso.break_glass_help': 'May sign in with the pgkiln password where a workspace requires single sign-on, for when the identity provider fails.',
+  'bsso.break_glass_make': 'Make break-glass',
+  'bsso.break_glass_remove': 'Remove break-glass',
+  'bsso.break_glass_on': '{user} is a break-glass administrator. Give them a second factor too.',
+  'bsso.break_glass_off': '{user} is no longer a break-glass administrator.',
+  'bsso.break_glass_admins': 'Only administrators can have break-glass access.',
+  'bsso.keep_break_glass': 'A workspace requires single sign-on: keep at least one break-glass administrator.',
+  'wsp.sso': 'Single sign-on',
+  'wsp.sso_only': 'This workspace’s developers must sign in through an identity provider',
+  'wsp.sso_only_help': 'Or an LDAP directory. The pgkiln password and a passkey alone are refused, except for break-glass administrators. `pgkiln admin builder-sign-in password` turns it off.',
+  'wsp.sso_unlinked': 'No linked identity yet (they cannot sign in): {list}.',
+  'wsp.sso_save': 'Save single sign-on rule',
+  'wsp.sso_on': 'This workspace’s developers must use single sign-on.',
+  'wsp.sso_off': 'The workspace’s developers may use the pgkiln password again.',
+  'wsp.sso_no_break_glass': 'Make an administrator break-glass first (Developers), so someone can still sign in when the identity provider fails.',
+  'wsp.sso_link_first': 'Link an identity on your Security page first, or you could not sign in yourself.',
+  'us.mfa_title': 'Two-factor sign-in',
+  'us.mfa_status': 'Authenticator apps: {n}. Recovery codes left: {codes}.',
+  'us.mfa_none': 'No authenticator app yet.',
+  'us.mfa_reset_help': 'Removes the authenticator apps and recovery codes of {user} and signs them out everywhere. Where an application requires two-factor sign-in, they add a new app at their next sign-in. Logged.',
+  'us.mfa_reset_done': 'Two-factor sign-in of {user} was reset.',
+  'us.mfa_reason_needed': 'Give a reason for the reset.',
 } as const;

package/src/builder/i18n/es.ts

@@ -1820,4 +1820,60 @@ export const es: BuilderMessages = {
   'wsp.mfa_save': 'Guardar la regla de dos pasos',
   'wsp.mfa_on': 'Los desarrolladores de este espacio de trabajo necesitan el inicio de sesión en dos pasos.',
   'wsp.mfa_off': 'El espacio de trabajo ya no exige el inicio de sesión en dos pasos (la política de la instancia sigue vigente).',
+  'signin.method': 'Iniciar sesión con',
+  'signin.method_pgkiln': 'Cuenta de pgkiln',
+  'signin.with': 'Iniciar sesión con {provider}',
+  'signin.ldap_unavailable': 'No se puede acceder a {directory}. Inténtelo más tarde.',
+  'signin.sso_required': 'Su espacio de trabajo exige el inicio de sesión único: use su proveedor de identidad.',
+  'signin.sso_unavailable': 'No se puede acceder a {provider}. Inténtelo más tarde.',
+  'bsso.title': 'Inicio de sesión en el builder',
+  'bsso.intro': 'Los desarrolladores también pueden iniciar sesión en el builder con este proveedor. Se les identifica por la identidad vinculada, nunca solo por el nombre.',
+  'bsso.on': 'Los desarrolladores pueden iniciar sesión en el builder con él',
+  'bsso.on_help': 'La página de inicio de sesión lo muestra. Así se omite el segundo factor propio de pgkiln: decide el proveedor.',
+  'bsso.auto_create': 'Crear desarrolladores en su primer inicio de sesión',
+  'bsso.auto_create_help': 'Para los miembros del grupo de desarrolladores de abajo (cualquiera, si está vacío). Los nuevos desarrolladores entran en el espacio de trabajo Default.',
+  'bsso.link_existing': 'Vincular un desarrollador existente con el mismo nombre de usuario',
+  'bsso.link_existing_help': 'Una vez, en el primer inicio de sesión; nunca un administrador de emergencia. Actívelo solo si confía en los nombres de usuario del proveedor. Si no, los desarrolladores vinculan la identidad en su página de seguridad.',
+  'bsso.group': 'Grupo de desarrolladores',
+  'bsso.group_help': 'Solo sus miembros reciben una cuenta de desarrollador. Vacío: cualquiera que el proveedor autentique.',
+  'bsso.admin_group': 'Grupo de administradores',
+  'bsso.admin_group_help': 'Si se indica, sus miembros son administradores de la instancia y los demás no; se comprueba en cada inicio de sesión (los administradores de emergencia conservan su rol).',
+  'bsso.save': 'Guardar el inicio de sesión en el builder',
+  'bsso.saved': 'Inicio de sesión en el builder guardado.',
+  'bsso.linked': 'Desarrolladores vinculados',
+  'bsso.none_linked': 'Aún no hay ningún desarrollador vinculado.',
+  'bsso.unlink': 'Desvincular',
+  'bsso.unlink_confirm': '¿Desvincular a {user}? Iniciará sesión con la contraseña o volverá a vincular.',
+  'bsso.unlink_mine_confirm': '¿Desvincular {provider}? Puede volver a vincularlo.',
+  'bsso.unlinked': 'La identidad está desvinculada.',
+  'bsso.keep_one': 'Un espacio de trabajo exige a este desarrollador el inicio de sesión único: mantenga una identidad vinculada.',
+  'bsso.yours': 'Inicio de sesión único',
+  'bsso.yours_intro': 'Los proveedores de identidad con los que puede iniciar sesión en el builder.',
+  'bsso.none_yours': 'Aún no hay ninguna identidad vinculada.',
+  'bsso.link': 'Vincular {provider}',
+  'bsso.linked_now': '{provider} está vinculado: puede iniciar sesión con él.',
+  'bsso.directories_note': 'Un directorio LDAP se vincula la primera vez que inicia sesión con él (un administrador lo permite por directorio).',
+  'bsso.break_glass': 'de emergencia',
+  'bsso.break_glass_help': 'Puede iniciar sesión con la contraseña de pgkiln donde un espacio de trabajo exige el inicio de sesión único, por si falla el proveedor de identidad.',
+  'bsso.break_glass_make': 'Dar acceso de emergencia',
+  'bsso.break_glass_remove': 'Quitar acceso de emergencia',
+  'bsso.break_glass_on': '{user} es administrador de emergencia. Configúrele también un segundo factor.',
+  'bsso.break_glass_off': '{user} ya no es administrador de emergencia.',
+  'bsso.break_glass_admins': 'Solo los administradores pueden tener acceso de emergencia.',
+  'bsso.keep_break_glass': 'Un espacio de trabajo exige el inicio de sesión único: mantenga al menos un administrador de emergencia.',
+  'wsp.sso': 'Inicio de sesión único',
+  'wsp.sso_only': 'Los desarrolladores de este espacio de trabajo deben iniciar sesión mediante un proveedor de identidad',
+  'wsp.sso_only_help': 'O un directorio LDAP. Se rechazan la contraseña de pgkiln y una llave de acceso sola, salvo para los administradores de emergencia. `pgkiln admin builder-sign-in password` lo desactiva.',
+  'wsp.sso_unlinked': 'Aún sin identidad vinculada (no pueden iniciar sesión): {list}.',
+  'wsp.sso_save': 'Guardar la regla de inicio de sesión único',
+  'wsp.sso_on': 'Los desarrolladores de este espacio de trabajo deben usar el inicio de sesión único.',
+  'wsp.sso_off': 'Los desarrolladores del espacio de trabajo pueden volver a usar la contraseña de pgkiln.',
+  'wsp.sso_no_break_glass': 'Primero dé acceso de emergencia a un administrador (Desarrolladores), para que alguien pueda entrar si falla el proveedor de identidad.',
+  'wsp.sso_link_first': 'Vincule primero una identidad en su página de seguridad, o usted mismo no podría iniciar sesión.',
+  'us.mfa_title': 'Inicio de sesión en dos pasos',
+  'us.mfa_status': 'Aplicaciones de autenticación: {n}. Códigos de recuperación restantes: {codes}.',
+  'us.mfa_none': 'Aún no hay ninguna aplicación de autenticación.',
+  'us.mfa_reset_help': 'Quita las aplicaciones de autenticación y los códigos de recuperación de {user} y cierra todas sus sesiones. Donde una aplicación exija el inicio de sesión en dos pasos, añadirá una aplicación nueva en su próximo inicio de sesión. Queda registrado.',
+  'us.mfa_reset_done': 'Se restableció el inicio de sesión en dos pasos de {user}.',
+  'us.mfa_reason_needed': 'Indique un motivo para el restablecimiento.',
 };

package/src/builder/i18n/fr.ts

@@ -1820,4 +1820,60 @@ export const fr: BuilderMessages = {
   'wsp.mfa_save': 'Enregistrer la règle à deux facteurs',
   'wsp.mfa_on': 'Les développeurs de cet espace de travail ont besoin de la connexion à deux facteurs.',
   'wsp.mfa_off': 'L’espace de travail n’exige plus la connexion à deux facteurs (la politique de l’instance s’applique toujours).',
+  'signin.method': 'Se connecter avec',
+  'signin.method_pgkiln': 'Compte pgkiln',
+  'signin.with': 'Se connecter avec {provider}',
+  'signin.ldap_unavailable': '{directory} est injoignable. Réessayez plus tard.',
+  'signin.sso_required': 'Votre espace de travail exige l’authentification unique : utilisez votre fournisseur d’identité.',
+  'signin.sso_unavailable': '{provider} est injoignable. Réessayez plus tard.',
+  'bsso.title': 'Connexion au builder',
+  'bsso.intro': 'Les développeurs peuvent aussi se connecter au builder avec ce fournisseur. Ils sont reconnus par l’identité liée, jamais par le seul nom.',
+  'bsso.on': 'Les développeurs peuvent s’en servir pour se connecter au builder',
+  'bsso.on_help': 'La page de connexion l’affiche. Cette connexion se passe du second facteur de pgkiln : le fournisseur décide.',
+  'bsso.auto_create': 'Créer les développeurs à leur première connexion',
+  'bsso.auto_create_help': 'Pour les membres du groupe de développeurs ci-dessous (tout le monde s’il est vide). Les nouveaux développeurs rejoignent l’espace de travail Default.',
+  'bsso.link_existing': 'Lier un développeur existant ayant le même nom d’utilisateur',
+  'bsso.link_existing_help': 'Une fois, à la première connexion ; jamais un administrateur de secours. À activer seulement si vous faites confiance aux noms d’utilisateur du fournisseur. Sinon, les développeurs lient l’identité sur leur page Sécurité.',
+  'bsso.group': 'Groupe des développeurs',
+  'bsso.group_help': 'Seuls ses membres reçoivent un compte de développeur. Vide : toute personne que le fournisseur connecte.',
+  'bsso.admin_group': 'Groupe des administrateurs',
+  'bsso.admin_group_help': 'Si renseigné, ses membres sont administrateurs de l’instance et les autres non, vérifié à chaque connexion (les administrateurs de secours gardent leur rôle).',
+  'bsso.save': 'Enregistrer la connexion au builder',
+  'bsso.saved': 'Connexion au builder enregistrée.',
+  'bsso.linked': 'Développeurs liés',
+  'bsso.none_linked': 'Aucun développeur n’est encore lié.',
+  'bsso.unlink': 'Délier',
+  'bsso.unlink_confirm': 'Délier {user} ? La personne se connecte avec le mot de passe ou lie à nouveau.',
+  'bsso.unlink_mine_confirm': 'Délier {provider} ? Vous pourrez le lier à nouveau.',
+  'bsso.unlinked': 'L’identité est déliée.',
+  'bsso.keep_one': 'Un espace de travail exige l’authentification unique de ce développeur : gardez une identité liée.',
+  'bsso.yours': 'Authentification unique',
+  'bsso.yours_intro': 'Les fournisseurs d’identité avec lesquels vous pouvez vous connecter au builder.',
+  'bsso.none_yours': 'Aucune identité liée pour l’instant.',
+  'bsso.link': 'Lier {provider}',
+  'bsso.linked_now': '{provider} est lié : vous pouvez vous connecter avec.',
+  'bsso.directories_note': 'Un annuaire LDAP est lié à votre première connexion avec lui (un administrateur l’autorise par annuaire).',
+  'bsso.break_glass': 'de secours',
+  'bsso.break_glass_help': 'Peut se connecter avec le mot de passe pgkiln là où un espace de travail exige l’authentification unique, au cas où le fournisseur d’identité tombe en panne.',
+  'bsso.break_glass_make': 'Donner l’accès de secours',
+  'bsso.break_glass_remove': 'Retirer l’accès de secours',
+  'bsso.break_glass_on': '{user} est administrateur de secours. Donnez-lui aussi un second facteur.',
+  'bsso.break_glass_off': '{user} n’est plus administrateur de secours.',
+  'bsso.break_glass_admins': 'Seuls les administrateurs peuvent avoir l’accès de secours.',
+  'bsso.keep_break_glass': 'Un espace de travail exige l’authentification unique : gardez au moins un administrateur de secours.',
+  'wsp.sso': 'Authentification unique',
+  'wsp.sso_only': 'Les développeurs de cet espace de travail doivent se connecter via un fournisseur d’identité',
+  'wsp.sso_only_help': 'Ou un annuaire LDAP. Le mot de passe pgkiln et une clé d’accès seule sont refusés, sauf pour les administrateurs de secours. `pgkiln admin builder-sign-in password` le désactive.',
+  'wsp.sso_unlinked': 'Pas encore d’identité liée (ne peuvent pas se connecter) : {list}.',
+  'wsp.sso_save': 'Enregistrer la règle d’authentification unique',
+  'wsp.sso_on': 'Les développeurs de cet espace de travail doivent utiliser l’authentification unique.',
+  'wsp.sso_off': 'Les développeurs de l’espace de travail peuvent de nouveau utiliser le mot de passe pgkiln.',
+  'wsp.sso_no_break_glass': 'Donnez d’abord l’accès de secours à un administrateur (Développeurs), pour que quelqu’un puisse se connecter si le fournisseur d’identité tombe en panne.',
+  'wsp.sso_link_first': 'Liez d’abord une identité sur votre page Sécurité, sinon vous ne pourriez plus vous connecter.',
+  'us.mfa_title': 'Connexion à deux facteurs',
+  'us.mfa_status': 'Applications d’authentification : {n}. Codes de récupération restants : {codes}.',
+  'us.mfa_none': 'Aucune application d’authentification pour l’instant.',
+  'us.mfa_reset_help': 'Supprime les applications d’authentification et les codes de récupération de {user} et le déconnecte partout. Là où une application exige la connexion à deux facteurs, une nouvelle application est ajoutée à la prochaine connexion. Journalisé.',
+  'us.mfa_reset_done': 'La connexion à deux facteurs de {user} a été réinitialisée.',
+  'us.mfa_reason_needed': 'Indiquez la raison de la réinitialisation.',
 };

package/src/builder/i18n/nl.ts

@@ -1820,4 +1820,60 @@ export const nl: BuilderMessages = {
   'wsp.mfa_save': 'Tweestapsregel opslaan',
   'wsp.mfa_on': 'De ontwikkelaars van deze werkruimte hebben tweestapsaanmelding nodig.',
   'wsp.mfa_off': 'De werkruimte verplicht geen tweestapsaanmelding meer (het beleid van de instantie blijft gelden).',
+  'signin.method': 'Aanmelden met',
+  'signin.method_pgkiln': 'pgkiln-account',
+  'signin.with': 'Aanmelden met {provider}',
+  'signin.ldap_unavailable': '{directory} is niet bereikbaar. Probeer het later opnieuw.',
+  'signin.sso_required': 'Uw werkruimte vereist single sign-on: gebruik uw identiteitsprovider.',
+  'signin.sso_unavailable': '{provider} is niet bereikbaar. Probeer het later opnieuw.',
+  'bsso.title': 'Aanmelden bij de builder',
+  'bsso.intro': 'Ontwikkelaars kunnen met deze provider ook bij de builder aanmelden. Ze worden gevonden via de gekoppelde identiteit, nooit alleen via de naam.',
+  'bsso.on': 'Ontwikkelaars kunnen hiermee bij de builder aanmelden',
+  'bsso.on_help': 'De aanmeldpagina toont hem. Zo aanmelden slaat de eigen tweede factor van pgkiln over: de provider beslist.',
+  'bsso.auto_create': 'Ontwikkelaars aanmaken bij hun eerste aanmelding',
+  'bsso.auto_create_help': 'Voor leden van de ontwikkelaarsgroep hieronder (iedereen als die leeg is). Nieuwe ontwikkelaars komen in de werkruimte Default.',
+  'bsso.link_existing': 'Een bestaande ontwikkelaar met dezelfde gebruikersnaam koppelen',
+  'bsso.link_existing_help': 'Eenmalig, bij de eerste aanmelding; nooit een noodbeheerder. Zet het alleen aan als u de gebruikersnamen van de provider vertrouwt. Anders koppelen ontwikkelaars de identiteit op hun beveiligingspagina.',
+  'bsso.group': 'Ontwikkelaarsgroep',
+  'bsso.group_help': 'Alleen de leden krijgen een ontwikkelaarsaccount. Leeg: iedereen die de provider aanmeldt.',
+  'bsso.admin_group': 'Beheerdersgroep',
+  'bsso.admin_group_help': 'Indien ingevuld zijn de leden beheerder van de instantie en anderen niet, gecontroleerd bij elke aanmelding (noodbeheerders houden hun rol).',
+  'bsso.save': 'Aanmelden bij de builder opslaan',
+  'bsso.saved': 'Aanmelden bij de builder opgeslagen.',
+  'bsso.linked': 'Gekoppelde ontwikkelaars',
+  'bsso.none_linked': 'Nog geen ontwikkelaar gekoppeld.',
+  'bsso.unlink': 'Ontkoppelen',
+  'bsso.unlink_confirm': '{user} ontkoppelen? Diegene meldt zich aan met het wachtwoord of koppelt opnieuw.',
+  'bsso.unlink_mine_confirm': '{provider} ontkoppelen? U kunt het opnieuw koppelen.',
+  'bsso.unlinked': 'De identiteit is ontkoppeld.',
+  'bsso.keep_one': 'Een werkruimte vereist single sign-on van deze ontwikkelaar: houd één gekoppelde identiteit.',
+  'bsso.yours': 'Single sign-on',
+  'bsso.yours_intro': 'De identiteitsproviders waarmee u bij de builder kunt aanmelden.',
+  'bsso.none_yours': 'Nog geen identiteit gekoppeld.',
+  'bsso.link': '{provider} koppelen',
+  'bsso.linked_now': '{provider} is gekoppeld: u kunt ermee aanmelden.',
+  'bsso.directories_note': 'Een LDAP-directory wordt gekoppeld als u er voor het eerst mee aanmeldt (een beheerder staat dat per directory toe).',
+  'bsso.break_glass': 'noodtoegang',
+  'bsso.break_glass_help': 'Mag met het pgkiln-wachtwoord aanmelden waar een werkruimte single sign-on vereist, voor als de identiteitsprovider uitvalt.',
+  'bsso.break_glass_make': 'Noodtoegang geven',
+  'bsso.break_glass_remove': 'Noodtoegang intrekken',
+  'bsso.break_glass_on': '{user} is noodbeheerder. Geef diegene ook een tweede factor.',
+  'bsso.break_glass_off': '{user} is geen noodbeheerder meer.',
+  'bsso.break_glass_admins': 'Alleen beheerders kunnen noodtoegang hebben.',
+  'bsso.keep_break_glass': 'Een werkruimte vereist single sign-on: houd minstens één noodbeheerder.',
+  'wsp.sso': 'Single sign-on',
+  'wsp.sso_only': 'De ontwikkelaars van deze werkruimte moeten aanmelden via een identiteitsprovider',
+  'wsp.sso_only_help': 'Of een LDAP-directory. Het pgkiln-wachtwoord en alleen een passkey worden geweigerd, behalve voor noodbeheerders. `pgkiln admin builder-sign-in password` zet het uit.',
+  'wsp.sso_unlinked': 'Nog geen gekoppelde identiteit (kunnen niet aanmelden): {list}.',
+  'wsp.sso_save': 'Single-sign-onregel opslaan',
+  'wsp.sso_on': 'De ontwikkelaars van deze werkruimte moeten single sign-on gebruiken.',
+  'wsp.sso_off': 'De ontwikkelaars van de werkruimte mogen weer het pgkiln-wachtwoord gebruiken.',
+  'wsp.sso_no_break_glass': 'Geef eerst een beheerder noodtoegang (Ontwikkelaars), zodat iemand kan aanmelden als de identiteitsprovider uitvalt.',
+  'wsp.sso_link_first': 'Koppel eerst een identiteit op uw beveiligingspagina, anders kunt u zelf niet aanmelden.',
+  'us.mfa_title': 'Aanmelden in twee stappen',
+  'us.mfa_status': 'Authenticator-apps: {n}. Resterende herstelcodes: {codes}.',
+  'us.mfa_none': 'Nog geen authenticator-app.',
+  'us.mfa_reset_help': 'Verwijdert de authenticator-apps en herstelcodes van {user} en meldt het account overal af. Waar een applicatie aanmelden in twee stappen vereist, voegt de gebruiker bij de volgende aanmelding een nieuwe app toe. Wordt gelogd.',
+  'us.mfa_reset_done': 'Aanmelden in twee stappen van {user} is gereset.',
+  'us.mfa_reason_needed': 'Geef een reden voor de reset.',
 };

package/src/builder/i18n/pt.ts

@@ -1820,4 +1820,60 @@ export const pt: BuilderMessages = {
   'wsp.mfa_save': 'Salvar a regra de duas etapas',
   'wsp.mfa_on': 'Os desenvolvedores deste espaço de trabalho precisam do login em duas etapas.',
   'wsp.mfa_off': 'O espaço de trabalho já não exige login em duas etapas (a política da instância continua valendo).',
+  'signin.method': 'Entrar com',
+  'signin.method_pgkiln': 'Conta do pgkiln',
+  'signin.with': 'Entrar com {provider}',
+  'signin.ldap_unavailable': 'Não é possível acessar {directory}. Tente mais tarde.',
+  'signin.sso_required': 'Seu espaço de trabalho exige login único: use seu provedor de identidade.',
+  'signin.sso_unavailable': 'Não é possível acessar {provider}. Tente mais tarde.',
+  'bsso.title': 'Login no builder',
+  'bsso.intro': 'Os desenvolvedores também podem entrar no builder com este provedor. Eles são reconhecidos pela identidade vinculada, nunca só pelo nome.',
+  'bsso.on': 'Os desenvolvedores podem entrar no builder com ele',
+  'bsso.on_help': 'A página de login o mostra. Entrar assim dispensa o segundo fator do próprio pgkiln: o provedor decide.',
+  'bsso.auto_create': 'Criar desenvolvedores no primeiro login',
+  'bsso.auto_create_help': 'Para membros do grupo de desenvolvedores abaixo (qualquer um, se estiver vazio). Novos desenvolvedores entram no espaço de trabalho Default.',
+  'bsso.link_existing': 'Vincular um desenvolvedor existente com o mesmo nome de usuário',
+  'bsso.link_existing_help': 'Uma vez, no primeiro login; nunca um administrador de emergência. Ative só se confiar nos nomes de usuário do provedor. Caso contrário, os desenvolvedores vinculam a identidade na página de segurança.',
+  'bsso.group': 'Grupo de desenvolvedores',
+  'bsso.group_help': 'Só seus membros recebem uma conta de desenvolvedor. Vazio: qualquer pessoa que o provedor autentique.',
+  'bsso.admin_group': 'Grupo de administradores',
+  'bsso.admin_group_help': 'Se preenchido, seus membros são administradores da instância e os demais não, verificado a cada login (administradores de emergência mantêm a função).',
+  'bsso.save': 'Salvar o login no builder',
+  'bsso.saved': 'Login no builder salvo.',
+  'bsso.linked': 'Desenvolvedores vinculados',
+  'bsso.none_linked': 'Ainda não há desenvolvedor vinculado.',
+  'bsso.unlink': 'Desvincular',
+  'bsso.unlink_confirm': 'Desvincular {user}? A pessoa entra com a senha ou vincula de novo.',
+  'bsso.unlink_mine_confirm': 'Desvincular {provider}? Você pode vinculá-lo de novo.',
+  'bsso.unlinked': 'A identidade foi desvinculada.',
+  'bsso.keep_one': 'Um espaço de trabalho exige login único deste desenvolvedor: mantenha uma identidade vinculada.',
+  'bsso.yours': 'Login único',
+  'bsso.yours_intro': 'Os provedores de identidade com que você pode entrar no builder.',
+  'bsso.none_yours': 'Ainda não há identidade vinculada.',
+  'bsso.link': 'Vincular {provider}',
+  'bsso.linked_now': '{provider} está vinculado: você pode entrar com ele.',
+  'bsso.directories_note': 'Um diretório LDAP é vinculado no primeiro login com ele (um administrador permite isso por diretório).',
+  'bsso.break_glass': 'de emergência',
+  'bsso.break_glass_help': 'Pode entrar com a senha do pgkiln onde um espaço de trabalho exige login único, para quando o provedor de identidade falhar.',
+  'bsso.break_glass_make': 'Dar acesso de emergência',
+  'bsso.break_glass_remove': 'Remover acesso de emergência',
+  'bsso.break_glass_on': '{user} é administrador de emergência. Configure também um segundo fator.',
+  'bsso.break_glass_off': '{user} não é mais administrador de emergência.',
+  'bsso.break_glass_admins': 'Só administradores podem ter acesso de emergência.',
+  'bsso.keep_break_glass': 'Um espaço de trabalho exige login único: mantenha pelo menos um administrador de emergência.',
+  'wsp.sso': 'Login único',
+  'wsp.sso_only': 'Os desenvolvedores deste espaço de trabalho devem entrar por um provedor de identidade',
+  'wsp.sso_only_help': 'Ou um diretório LDAP. A senha do pgkiln e uma chave de acesso sozinha são recusadas, exceto para administradores de emergência. `pgkiln admin builder-sign-in password` desativa.',
+  'wsp.sso_unlinked': 'Ainda sem identidade vinculada (não podem entrar): {list}.',
+  'wsp.sso_save': 'Salvar a regra de login único',
+  'wsp.sso_on': 'Os desenvolvedores deste espaço de trabalho devem usar login único.',
+  'wsp.sso_off': 'Os desenvolvedores do espaço de trabalho podem voltar a usar a senha do pgkiln.',
+  'wsp.sso_no_break_glass': 'Primeiro dê acesso de emergência a um administrador (Desenvolvedores), para que alguém possa entrar se o provedor de identidade falhar.',
+  'wsp.sso_link_first': 'Vincule primeiro uma identidade na sua página de segurança, ou você mesmo não conseguiria entrar.',
+  'us.mfa_title': 'Login em duas etapas',
+  'us.mfa_status': 'Aplicativos autenticadores: {n}. Códigos de recuperação restantes: {codes}.',
+  'us.mfa_none': 'Nenhum aplicativo autenticador ainda.',
+  'us.mfa_reset_help': 'Remove os aplicativos autenticadores e os códigos de recuperação de {user} e encerra todas as sessões. Onde um aplicativo exigir login em duas etapas, um novo aplicativo será adicionado no próximo login. Registrado.',
+  'us.mfa_reset_done': 'O login em duas etapas de {user} foi redefinido.',
+  'us.mfa_reason_needed': 'Informe um motivo para a redefinição.',
 };

package/src/builder/ldap.ts

@@ -3,6 +3,7 @@ import { owner } from '../db.ts';
 import { html, raw } from '../html.ts';
 import { testDirectory, type Directory } from '../ldap.ts';
 import { administrator, back, BASE, csrf, flash, input, region, send, shell, type Req } from './ui.ts';
+import { builderSignInRegion } from './builder-sso.ts';
 
 // Users → LDAP directories: the directories an application's password form
 // can check (enabled per app under Settings → Sign-in methods). The bind
@@ -114,6 +115,7 @@ export async function ldapRoutes(app: FastifyInstance) {
           <form method="post" action="${BASE}/users/directories/${d.id}/test" class="search u-mwnone">${csrf(s)}
             <input name="username" placeholder="Username (optional)" aria-label="Username to look up" maxlength="100">
             <button class="btn">Test</button></form>`)}
+        ${await builderSignInRegion(s, 'directory', d)}
       </div>`;
     return send(reply, s, shell(s, d.display_name, [['Users', `${BASE}/users`], ['LDAP directories', `${BASE}/users/directories`], [d.display_name]], main, 'users'));
   });

package/src/builder/login-page.ts

@@ -1,12 +1,15 @@
 import type { FastifyInstance } from 'fastify';
 import { owner } from '../db.ts';
+import { APP_MFA, type AppMfa } from '../account-mfa.ts';
 import { html, raw } from '../html.ts';
+import { secretKeyConfigured } from '../secrets.ts';
 import { back, BASE, developer, flash, type Req } from './ui.ts';
 
 // Application settings → Sign-in methods (migration 087): the application's
 // own login page (APEX: the login page, usually 9999) and "Forgot password?".
 // "Create login page" adds a minimal public page with a login region and
-// makes it the login page.
+// makes it the login page. (sprint 130, SEC-3) Two-factor sign-in for the
+// application's users: off, optional, required, or required for some roles.
 
 interface AppRow {
   id: number;
@@ -15,6 +18,8 @@ interface AppRow {
   local_login: boolean;
   login_page: number | null;
   password_reset: boolean;
+  mfa: AppMfa;
+  mfa_roles: string[];
 }
 
 /** The fields in the settings form. */
@@ -41,14 +46,33 @@ export async function loginSettingsFields(a: AppRow) {
             ? html`Sent through mail service ${mail!.service} as ${mail!.from_address}.`
             : html`<strong>Not offered yet:</strong> the application needs an enabled mail service with a From address (Workspace utilities → Mail services).`}
           Only for the user directory's own passwords: not for LDAP, single sign-on, database accounts or custom authentication.</small></div>
+    </div>
+    <h3 id="two-factor">Two-factor sign-in</h3>
+    <div class="form-grid">
+      <div class="field"><label class="label" for="f_mfa">Second step</label>
+        <select id="f_mfa" name="mfa" aria-describedby="f_mfa_help">${(APP_MFA as string[]).map((m) => opt(m, MFA_LABELS[m as AppMfa], a.mfa))}</select>
+        <small class="help" id="f_mfa_help">After the password (or an LDAP directory), users give a code from an authenticator app or a recovery code. They add the app on <em>My account</em>, or while signing in when it is required. An identity provider asks for its own second factor. Accounts share their apps across applications.
+          ${secretKeyConfigured() ? '' : html`<strong>Not available yet:</strong> the server needs <code>PGKILN_SECRET_KEY</code> to keep the apps' secrets.`}</small></div>
+      <div class="field"><label class="label" for="f_mfa_roles">Required for roles</label>
+        <input id="f_mfa_roles" name="mfa_roles" value="${(a.mfa_roles ?? []).join(', ')}" placeholder="admin, manager" aria-describedby="f_mfa_roles_help">
+        <small class="help" id="f_mfa_roles_help">With <em>Required for some roles</em>: users with one of these roles must use it, others may.</small></div>
     </div>`;
 }
 
+const MFA_LABELS: Record<AppMfa, string> = { off: 'Off', optional: 'Optional (users may add an app)', required: 'Required', roles: 'Required for some roles' };
+
 /** Save them (with the rest of the settings form). */
 export async function saveLoginSettings(appId: string, b: Record<string, string | undefined>) {
   const page = b.login_page?.trim() ? Number(b.login_page) : null;
   if (page !== null && !(await owner.one('select 1 from meta.page where app_id = $1 and page_no = $2', [appId, page]))) throw new Error(`Login page: there is no page ${b.login_page}.`);
-  await owner.query('update meta.app set login_page = $2, password_reset = $3 where id = $1', [appId, page, b.password_reset === 'true']);
+  const mfa = (APP_MFA as string[]).includes(b.mfa ?? '') ? (b.mfa as AppMfa) : 'off';
+  const roles = [...new Set((b.mfa_roles ?? '').split(',').map((r) => r.trim().toLowerCase()).filter(Boolean))];
+  if (roles.some((r) => r.length > 100)) throw new Error('Two-factor sign-in: a role name is too long.');
+  if (mfa === 'roles' && !roles.length) throw new Error('Two-factor sign-in: name the roles that must use it.');
+  // without the instance key, users could not add an app: requiring one would lock them out
+  if ((mfa === 'required' || mfa === 'roles') && !secretKeyConfigured()) throw new Error('Two-factor sign-in: the server needs PGKILN_SECRET_KEY before it can be required.');
+  await owner.query('update meta.app set login_page = $2, password_reset = $3, mfa = $4, mfa_roles = $5 where id = $1',
+    [appId, page, b.password_reset === 'true', mfa, roles]);
 }
 
 export async function loginPageRoutes(app: FastifyInstance) {