pgkiln 0.59.0 → 0.60.0

package/src/builder/i18n/fr.ts

@@ -1711,4 +1711,77 @@ export const fr: BuilderMessages = {
   'dev.not_found': 'Introuvable.',
   'dev.role_changed': 'Rôle modifié.',
   'dev.removed': 'Développeur retiré.',
+  // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
+  'mfa.menu': 'Connexion à deux facteurs',
+  'mfa.title': 'Sécurité',
+  'mfa.intro': 'Connectez-vous avec un code d’une application d’authentification après votre mot de passe. Les codes de récupération vous laissent entrer si vous perdez le téléphone.',
+  'mfa.required_you': 'Votre administrateur exige la connexion à deux facteurs : ajoutez une application d’authentification.',
+  'mfa.banner': 'La connexion à deux facteurs est obligatoire. Configurez-la avant le {date} : {link}',
+  'mfa.set_up_now': 'configurer maintenant',
+  'mfa.apps': 'Applications d’authentification',
+  'mfa.app_name': 'Nom',
+  'mfa.app_default': 'Téléphone',
+  'mfa.added': 'Ajoutée',
+  'mfa.last_used': 'Dernière utilisation',
+  'mfa.no_apps': 'Pas encore d’application d’authentification : vous vous connectez avec votre mot de passe seul.',
+  'mfa.add_app': 'Ajouter une application d’authentification',
+  'mfa.no_key': 'La connexion à deux facteurs a besoin de la clé de l’instance (PGKILN_SECRET_KEY) pour stocker le secret de l’application.',
+  'mfa.scan': 'Scannez le code QR avec une application d’authentification.',
+  'mfa.or_enter': 'Ou saisissez cette clé à la main :',
+  'mfa.enter_code': 'Saisissez le code à 6 chiffres affiché par l’application.',
+  'mfa.qr_label': 'Code QR pour l’application d’authentification',
+  'mfa.confirm_app': 'Confirmer et activer',
+  'mfa.cancel_setup': 'Annuler',
+  'mfa.setup_expired': 'La configuration a pris trop de temps : recommencez.',
+  'mfa.wrong_setup': 'Ce code ne correspond pas : vérifiez l’heure de votre téléphone et essayez le code suivant.',
+  'mfa.app_added': 'Application d’authentification ajoutée : désormais, vous vous connectez aussi avec un code.',
+  'mfa.remove': 'Supprimer',
+  'mfa.remove_app': 'Supprimer cette application',
+  'mfa.your_password': 'Votre mot de passe',
+  'mfa.wrong_password': 'Mot de passe incorrect.',
+  'mfa.cannot_remove_required': 'La connexion à deux facteurs est obligatoire pour vous : ajoutez une autre application avant de supprimer celle-ci.',
+  'mfa.cannot_remove_admin': 'Au moins deux administrateurs (ou tous, s’ils sont moins nombreux) doivent garder la connexion à deux facteurs tant que la règle est active.',
+  'mfa.keep_admins': 'Pas maintenant : la règle à deux facteurs exige au moins deux administrateurs avec la connexion à deux facteurs (ou tous, s’ils sont moins nombreux).',
+  'mfa.removed': 'Application d’authentification supprimée.',
+  'mfa.codes_title': 'Codes de récupération',
+  'mfa.codes_once': 'Conservez ces codes en lieu sûr, loin de votre téléphone. Chacun remplace une fois un code de l’application. Ils ne sont affichés que maintenant.',
+  'mfa.codes_saved': 'J’ai conservé ces codes',
+  'mfa.codes_done': 'Terminé',
+  'mfa.codes_kept': 'Codes de récupération conservés.',
+  'mfa.codes_left': 'Codes de récupération inutilisés : {n}.',
+  'mfa.codes_after': 'Vous recevez des codes de récupération en ajoutant une application d’authentification.',
+  'mfa.codes_low': 'Il reste peu de codes de récupération : créez-en de nouveaux.',
+  'mfa.codes_new': 'Nouveaux codes de récupération',
+  'mfa.codes_new_confirm': 'Créer de nouveaux codes de récupération ? Les anciens ne fonctionneront plus.',
+  'mfa.expired': 'La connexion a pris trop de temps : reconnectez-vous.',
+  'mfa.step_title': 'Connexion à deux facteurs',
+  'mfa.step_intro': 'Saisissez le code de votre application d’authentification pour {user}.',
+  'mfa.code': 'Code',
+  'mfa.code_help': '6 chiffres de l’application, ou l’un de vos codes de récupération.',
+  'mfa.verify': 'Vérifier',
+  'mfa.cancel': 'Retour à la connexion',
+  'mfa.locked_out': 'Téléphone et codes perdus ? Demandez à un administrateur de réinitialiser votre connexion à deux facteurs.',
+  'mfa.wrong': 'Ce code est incorrect ou a déjà été utilisé.',
+  'mfa.column': 'Deux facteurs',
+  'mfa.on': 'activée',
+  'mfa.off': 'désactivée',
+  'mfa.reset': 'Réinitialiser',
+  'mfa.reason': 'Motif',
+  'mfa.reset_help': 'Supprime les applications et codes de récupération de {user} et le déconnecte. Journalisé ; les administrateurs sont prévenus par e-mail.',
+  'mfa.reset_btn': 'Réinitialiser la connexion à deux facteurs',
+  'mfa.reason_needed': 'Indiquez un motif pour la réinitialisation.',
+  'mfa.reset_done': 'Connexion à deux facteurs de {user} réinitialisée.',
+  'mfa.policy_title': 'Connexion à deux facteurs',
+  'mfa.policy_label': 'Exiger la connexion à deux facteurs pour',
+  'mfa.policy_off': 'Personne (facultatif)',
+  'mfa.policy_admins': 'Administrateurs',
+  'mfa.policy_all': 'Tous les développeurs',
+  'mfa.grace': 'Délai de grâce (jours)',
+  'mfa.grace_help': 'Les développeurs sans application voient un rappel jusque-là ; ensuite, seulement leur page Sécurité.',
+  'mfa.policy_help': 'Administrateurs avec la connexion à deux facteurs : {enrolled} sur {admins}. L’exiger demande au moins deux d’entre eux (ou tous, s’ils sont moins nombreux).',
+  'mfa.policy_save': 'Enregistrer',
+  'mfa.policy_saved': 'Règle à deux facteurs enregistrée.',
+  'mfa.policy_needs_admins': 'D’abord, au moins deux administrateurs (ou tous, s’ils sont moins nombreux) configurent la connexion à deux facteurs, pour que personne ne reste bloqué seul.',
+  'mfa.without': 'Sans connexion à deux facteurs : {list}.',
+  'mfa.cli_note': 'Bloqué ? Sur le serveur : pgkiln admin reset-2fa <developer> ou pgkiln admin set-2fa-policy off.',
 };

package/src/builder/i18n/nl.ts

@@ -1711,4 +1711,77 @@ export const nl: BuilderMessages = {
   'dev.not_found': 'Niet gevonden.',
   'dev.role_changed': 'Rol gewijzigd.',
   'dev.removed': 'Ontwikkelaar verwijderd.',
+  // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
+  'mfa.menu': 'Aanmelden in twee stappen',
+  'mfa.title': 'Beveiliging',
+  'mfa.intro': 'Meld u na uw wachtwoord aan met een code uit een authenticator-app. Met herstelcodes komt u binnen als u de telefoon kwijtraakt.',
+  'mfa.required_you': 'Uw beheerder vereist aanmelden in twee stappen: voeg een authenticator-app toe.',
+  'mfa.banner': 'Aanmelden in twee stappen is verplicht. Stel het in vóór {date}: {link}',
+  'mfa.set_up_now': 'nu instellen',
+  'mfa.apps': 'Authenticator-apps',
+  'mfa.app_name': 'Naam',
+  'mfa.app_default': 'Telefoon',
+  'mfa.added': 'Toegevoegd',
+  'mfa.last_used': 'Laatst gebruikt',
+  'mfa.no_apps': 'Nog geen authenticator-app: u meldt zich alleen met uw wachtwoord aan.',
+  'mfa.add_app': 'Authenticator-app toevoegen',
+  'mfa.no_key': 'Aanmelden in twee stappen heeft de instantiesleutel (PGKILN_SECRET_KEY) nodig om het geheim van de app op te slaan.',
+  'mfa.scan': 'Scan de QR-code met een authenticator-app.',
+  'mfa.or_enter': 'Of voer deze sleutel met de hand in:',
+  'mfa.enter_code': 'Voer de 6-cijferige code uit de app in.',
+  'mfa.qr_label': 'QR-code voor de authenticator-app',
+  'mfa.confirm_app': 'Bevestigen en inschakelen',
+  'mfa.cancel_setup': 'Annuleren',
+  'mfa.setup_expired': 'Het instellen duurde te lang: begin opnieuw.',
+  'mfa.wrong_setup': 'Die code klopt niet: controleer de tijd op uw telefoon en probeer de volgende code.',
+  'mfa.app_added': 'Authenticator-app toegevoegd: voortaan meldt u zich ook met een code aan.',
+  'mfa.remove': 'Verwijderen',
+  'mfa.remove_app': 'Deze app verwijderen',
+  'mfa.your_password': 'Uw wachtwoord',
+  'mfa.wrong_password': 'Onjuist wachtwoord.',
+  'mfa.cannot_remove_required': 'Aanmelden in twee stappen is voor u verplicht: voeg eerst een andere app toe.',
+  'mfa.cannot_remove_admin': 'Minstens twee beheerders (of alle, als het er minder zijn) moeten aanmelden in twee stappen houden zolang het beleid aan staat.',
+  'mfa.keep_admins': 'Nu niet: het beleid vereist minstens twee beheerders met aanmelden in twee stappen (of alle, als het er minder zijn).',
+  'mfa.removed': 'Authenticator-app verwijderd.',
+  'mfa.codes_title': 'Herstelcodes',
+  'mfa.codes_once': 'Bewaar deze codes op een veilige plek, niet bij uw telefoon. Elke code vervangt één keer een app-code. Ze worden alleen nu getoond.',
+  'mfa.codes_saved': 'Ik heb deze codes bewaard',
+  'mfa.codes_done': 'Klaar',
+  'mfa.codes_kept': 'Herstelcodes bewaard.',
+  'mfa.codes_left': 'Ongebruikte herstelcodes: {n}.',
+  'mfa.codes_after': 'U krijgt herstelcodes zodra u een authenticator-app toevoegt.',
+  'mfa.codes_low': 'Nog maar weinig herstelcodes: maak nieuwe.',
+  'mfa.codes_new': 'Nieuwe herstelcodes',
+  'mfa.codes_new_confirm': 'Nieuwe herstelcodes maken? De oude werken dan niet meer.',
+  'mfa.expired': 'Het aanmelden duurde te lang: meld u opnieuw aan.',
+  'mfa.step_title': 'Aanmelden in twee stappen',
+  'mfa.step_intro': 'Voer de code uit uw authenticator-app voor {user} in.',
+  'mfa.code': 'Code',
+  'mfa.code_help': '6 cijfers uit de app, of een van uw herstelcodes.',
+  'mfa.verify': 'Controleren',
+  'mfa.cancel': 'Terug naar aanmelden',
+  'mfa.locked_out': 'Telefoon en codes kwijt? Vraag een beheerder uw aanmelden in twee stappen te resetten.',
+  'mfa.wrong': 'Die code klopt niet of is al gebruikt.',
+  'mfa.column': 'Twee stappen',
+  'mfa.on': 'aan',
+  'mfa.off': 'uit',
+  'mfa.reset': 'Resetten',
+  'mfa.reason': 'Reden',
+  'mfa.reset_help': 'Verwijdert de apps en herstelcodes van {user} en meldt deze af. Wordt gelogd; de beheerders krijgen een e-mail.',
+  'mfa.reset_btn': 'Aanmelden in twee stappen resetten',
+  'mfa.reason_needed': 'Geef een reden voor de reset.',
+  'mfa.reset_done': 'Aanmelden in twee stappen van {user} gereset.',
+  'mfa.policy_title': 'Aanmelden in twee stappen',
+  'mfa.policy_label': 'Aanmelden in twee stappen verplicht voor',
+  'mfa.policy_off': 'Niemand (optioneel)',
+  'mfa.policy_admins': 'Beheerders',
+  'mfa.policy_all': 'Alle ontwikkelaars',
+  'mfa.grace': 'Overgangsperiode (dagen)',
+  'mfa.grace_help': 'Ontwikkelaars zonder app zien tot dan een herinnering; daarna alleen hun Beveiligingspagina.',
+  'mfa.policy_help': 'Beheerders met aanmelden in twee stappen: {enrolled} van {admins}. Verplichten kan pas met minstens twee (of alle, als het er minder zijn).',
+  'mfa.policy_save': 'Opslaan',
+  'mfa.policy_saved': 'Beleid voor twee stappen opgeslagen.',
+  'mfa.policy_needs_admins': 'Eerst moeten minstens twee beheerders (of alle, als het er minder zijn) aanmelden in twee stappen instellen, zodat niemand alleen buitengesloten raakt.',
+  'mfa.without': 'Zonder aanmelden in twee stappen: {list}.',
+  'mfa.cli_note': 'Buitengesloten? Op de server: pgkiln admin reset-2fa <developer> of pgkiln admin set-2fa-policy off.',
 };

package/src/builder/i18n/pt.ts

@@ -1711,4 +1711,77 @@ export const pt: BuilderMessages = {
   'dev.not_found': 'Não encontrado.',
   'dev.role_changed': 'Papel alterado.',
   'dev.removed': 'Desenvolvedor removido.',
+  // ------------------------------------------------------------ Security: two-factor sign-in (sprint 126)
+  'mfa.menu': 'Login em duas etapas',
+  'mfa.title': 'Segurança',
+  'mfa.intro': 'Entre com um código de um aplicativo autenticador depois da senha. Os códigos de recuperação permitem entrar se você perder o telefone.',
+  'mfa.required_you': 'Seu administrador exige login em duas etapas: adicione um aplicativo autenticador.',
+  'mfa.banner': 'O login em duas etapas é obrigatório. Configure-o antes de {date}: {link}',
+  'mfa.set_up_now': 'configurar agora',
+  'mfa.apps': 'Aplicativos autenticadores',
+  'mfa.app_name': 'Nome',
+  'mfa.app_default': 'Telefone',
+  'mfa.added': 'Adicionado',
+  'mfa.last_used': 'Último uso',
+  'mfa.no_apps': 'Nenhum aplicativo autenticador ainda: você entra apenas com sua senha.',
+  'mfa.add_app': 'Adicionar um aplicativo autenticador',
+  'mfa.no_key': 'O login em duas etapas precisa da chave da instância (PGKILN_SECRET_KEY) para guardar o segredo do aplicativo.',
+  'mfa.scan': 'Leia o código QR com um aplicativo autenticador.',
+  'mfa.or_enter': 'Ou digite esta chave à mão:',
+  'mfa.enter_code': 'Digite o código de 6 dígitos que o aplicativo mostra.',
+  'mfa.qr_label': 'Código QR para o aplicativo autenticador',
+  'mfa.confirm_app': 'Confirmar e ativar',
+  'mfa.cancel_setup': 'Cancelar',
+  'mfa.setup_expired': 'A configuração demorou demais: comece de novo.',
+  'mfa.wrong_setup': 'Esse código não confere: verifique a hora do telefone e tente o próximo código.',
+  'mfa.app_added': 'Aplicativo autenticador adicionado: a partir de agora você entra também com um código.',
+  'mfa.remove': 'Remover',
+  'mfa.remove_app': 'Remover este aplicativo',
+  'mfa.your_password': 'Sua senha',
+  'mfa.wrong_password': 'Senha incorreta.',
+  'mfa.cannot_remove_required': 'O login em duas etapas é obrigatório para você: adicione outro aplicativo antes de remover este.',
+  'mfa.cannot_remove_admin': 'Pelo menos dois administradores (ou todos, se forem menos) devem manter o login em duas etapas enquanto a política estiver ativa.',
+  'mfa.keep_admins': 'Agora não: a política exige pelo menos dois administradores com login em duas etapas (ou todos, se forem menos).',
+  'mfa.removed': 'Aplicativo autenticador removido.',
+  'mfa.codes_title': 'Códigos de recuperação',
+  'mfa.codes_once': 'Guarde estes códigos em local seguro, longe do telefone. Cada um substitui uma vez um código do aplicativo. Eles são mostrados só agora.',
+  'mfa.codes_saved': 'Guardei estes códigos',
+  'mfa.codes_done': 'Concluído',
+  'mfa.codes_kept': 'Códigos de recuperação guardados.',
+  'mfa.codes_left': 'Códigos de recuperação não usados: {n}.',
+  'mfa.codes_after': 'Você recebe códigos de recuperação ao adicionar um aplicativo autenticador.',
+  'mfa.codes_low': 'Restam poucos códigos de recuperação: gere novos.',
+  'mfa.codes_new': 'Novos códigos de recuperação',
+  'mfa.codes_new_confirm': 'Gerar novos códigos de recuperação? Os antigos deixam de funcionar.',
+  'mfa.expired': 'O login demorou demais: entre novamente.',
+  'mfa.step_title': 'Login em duas etapas',
+  'mfa.step_intro': 'Digite o código do seu aplicativo autenticador para {user}.',
+  'mfa.code': 'Código',
+  'mfa.code_help': '6 dígitos do aplicativo ou um dos seus códigos de recuperação.',
+  'mfa.verify': 'Verificar',
+  'mfa.cancel': 'Voltar ao login',
+  'mfa.locked_out': 'Perdeu o telefone e os códigos? Peça a um administrador para redefinir seu login em duas etapas.',
+  'mfa.wrong': 'Esse código não está certo ou já foi usado.',
+  'mfa.column': 'Duas etapas',
+  'mfa.on': 'ativado',
+  'mfa.off': 'desativado',
+  'mfa.reset': 'Redefinir',
+  'mfa.reason': 'Motivo',
+  'mfa.reset_help': 'Remove os aplicativos e códigos de recuperação de {user} e encerra a sessão. Fica registrado; os administradores recebem um e-mail.',
+  'mfa.reset_btn': 'Redefinir o login em duas etapas',
+  'mfa.reason_needed': 'Informe um motivo para a redefinição.',
+  'mfa.reset_done': 'Login em duas etapas de {user} redefinido.',
+  'mfa.policy_title': 'Login em duas etapas',
+  'mfa.policy_label': 'Exigir login em duas etapas de',
+  'mfa.policy_off': 'Ninguém (opcional)',
+  'mfa.policy_admins': 'Administradores',
+  'mfa.policy_all': 'Todos os desenvolvedores',
+  'mfa.grace': 'Período de carência (dias)',
+  'mfa.grace_help': 'Desenvolvedores sem aplicativo veem um lembrete até lá; depois, só a página de Segurança.',
+  'mfa.policy_help': 'Administradores com login em duas etapas: {enrolled} de {admins}. Para exigir é preciso pelo menos dois (ou todos, se forem menos).',
+  'mfa.policy_save': 'Salvar',
+  'mfa.policy_saved': 'Política de duas etapas salva.',
+  'mfa.policy_needs_admins': 'Primeiro, pelo menos dois administradores (ou todos, se forem menos) configuram o login em duas etapas, para ninguém ficar bloqueado sozinho.',
+  'mfa.without': 'Sem login em duas etapas: {list}.',
+  'mfa.cli_note': 'Bloqueado? No servidor: pgkiln admin reset-2fa <developer> ou pgkiln admin set-2fa-policy off.',
 };

package/src/builder/instance.ts

@@ -3,6 +3,7 @@ import { html } from '../html.ts';
 import { configurationValue, CONFIGURATION, INSTANCE_SETTINGS, instanceSetting, origin, refreshInstanceSettings, saveInstanceSettings } from '../instance.ts';
 import { clientIp, logActivity, type Session } from '../session.ts';
 import { isAdmin } from './locks.ts';
+import { policyRegion } from './security.ts';
 import { releaseCheckRegion } from './workspace-home.ts';
 import { back, BASE, csrf, developer, flash, region, send, shell, type Req } from './ui.ts';
 
@@ -39,6 +40,7 @@ export async function instanceRoutes(app: FastifyInstance) {
           })}</div>
           <div class="buttons"><button class="btn btn-hot">Save</button></div></form>`)}
         ${await releaseCheckRegion(s)}
+        ${await policyRegion(s)}
         ${region('Configuration', html`<p class="muted u-mt0">Environment variables of this server (chapter 1 of the guide). Secrets show only whether they are set.</p>
           <div class="table-wrap"><table class="report report-reflow"><thead><tr><th>Variable</th><th>Value</th><th>Purpose</th></tr></thead>
           <tbody>${CONFIGURATION.map((c) => {

package/src/builder/routes.ts

@@ -19,6 +19,7 @@ import { appOr404 } from './forms.ts';
 import { docToFiles, filesToZip } from '../appfiles.ts';
 import { homeRoutes, rememberApp } from './home.ts';
 import { currentWorkspace, placeApp, workshopDb, workspaceRoutes } from './workspaces.ts';
+import { securityRoutes } from './security.ts';
 import { instanceRoutes } from './instance.ts';
 import { saveTimeZoneSettings, timeZoneSettings } from './globalization.ts';
 import { WIZARD_KINDS, wizardRoutes, wizardTables } from './wizards.ts';
@@ -26,6 +27,7 @@ import { appFromFileRoutes } from './appfromfile.ts';
 import { clearDevbar } from '../runtime/devbar.ts';
 import { EMAIL } from './find-workspace.ts';
 import { cookieLanguage, LANG_COOKIE, tr, translatorFor, validBuilderLanguage } from './i18n.ts';
+import { checkSecondFactor, codesLeft, hasFactor, leavesTooFewAdmins } from '../mfa.ts';
 import { chooseLanguage, langCookieOptions, languageRoutes, signInLanguageLinks } from './language.ts';
 
 // Builder pages: sign-in, workspace and app home, settings, activity and
@@ -148,27 +150,124 @@ export async function builderRoutes(app: FastifyInstance) {
       flash(s, tx(workspace ? 'signin.invalid_ws' : 'signin.invalid'), 'error');
       return back(reply, s, again);
     }
+    // (sprint 126, SEC-2) a developer with a second factor: the password was right, the session comes after the code
+    if (await hasFactor(dev.username)) {
+      s.state.__MFA = JSON.stringify({ u: dev.username, ws: ws ? String(ws.id) : null, w: workspace, next, remember: req.body?.remember === '1', weak: password === 'admin' || password === dev.username, at: Date.now() });
+      await saveState(s);
+      return reply.redirect(`${BASE}/login/2fa`, 303);
+    }
+    return finishSignIn(req, reply, s, { username: dev.username, language: dev.language }, { ws: ws ? String(ws.id) : null, workspace, next, remember: req.body?.remember === '1', weak: password === 'admin' || password === dev.username, picked, detail: 'builder' });
+  });
+
+  /** The session after a successful sign-in (password, and the second factor when the developer has one). */
+  async function finishSignIn(req: Req, reply: Parameters<typeof back>[0], s: Awaited<ReturnType<typeof getSession>>, dev: { username: string; language: string | null },
+    o: { ws: string | null; workspace: string; next: string; remember: boolean; weak: boolean; picked: ReturnType<typeof validBuilderLanguage>; detail: string }) {
+    const ip = clientIp(req);
+    const { picked, next, workspace } = o;
     await destroySession(reply, s, BASE);
     const ns = await createSession(reply, null, BASE, dev.username);
     // the builder theme chosen earlier on this device
     const theme = validTheme(req.cookies?.[THEME_COOKIE]);
     if (theme) ns.state.__BTHEME = theme;
-    if (ws) ns.state.__WS = String(ws.id);
+    if (o.ws) ns.state.__WS = o.ws;
     // (sprint 121) the builder language: a link chosen on the sign-in page is stored for the developer; else theirs
     if (picked) await chooseLanguage(reply, ns, picked);
     else {
       ns.state.__BLANG = validBuilderLanguage(dev.language) ?? 'en';
       if (dev.language && ns.state.__BLANG !== 'en') reply.setCookie(LANG_COOKIE, ns.state.__BLANG, langCookieOptions());
     }
-    if (password === 'admin' || password === dev.username) ns.state.__WEAK = '1';
+    if (o.weak) ns.state.__WEAK = '1';
     await saveState(ns);
-    if (req.body?.remember === '1')
+    if (o.remember)
       reply.setCookie(REMEMBER_COOKIE, Buffer.from(JSON.stringify({ w: workspace, u: dev.username })).toString('base64url'), {
         path: BASE, httpOnly: true, sameSite: 'lax', maxAge: 365 * 24 * 3600, secure: process.env.COOKIE_SECURE === 'true',
       });
     else reply.clearCookie(REMEMBER_COOKIE, { path: BASE });
-    logActivity({ username: dev.username, event: 'login', ip, detail: 'builder' });
+    logActivity({ username: dev.username, event: 'login', ip, detail: o.detail });
     return reply.redirect(next, 303);
+  }
+
+  // (sprint 126, SEC-2) the second step: a code from the authenticator app, or a recovery code
+  const MFA_SECONDS = 300;
+  const pendingMfa = (s: { state: Record<string, any> }) => {
+    try {
+      const p = JSON.parse(String(s.state.__MFA ?? ''));
+      return p && typeof p.u === 'string' && Date.now() - Number(p.at) < MFA_SECONDS * 1000 ? p as { u: string; ws: string | null; w: string; next: string; remember: boolean; weak: boolean } : null;
+    } catch {
+      return null;
+    }
+  };
+  app.get(`${BASE}/login/2fa`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    if (s.username) return reply.redirect(`${BASE}/home`);
+    const p = pendingMfa(s);
+    const tx = translatorFor(validBuilderLanguage(s.state.__BLANG) ?? cookieLanguage(req));
+    if (!p) {
+      delete s.state.__MFA;
+      flash(s, tx('mfa.expired'), 'error');
+      return back(reply, s, `${BASE}/login`);
+    }
+    const error = takeFlash(s, '__ERROR');
+    await saveState(s);
+    return reply.type('text/html').send(documentShell(
+      `${tx('mfa.step_title')} · ${tx('shell.builder')}`,
+      html`<main class="signin">
+        <section class="signin-hero" aria-label="pgkiln">
+          <span class="signin-logo" aria-hidden="true">${brandMark()}</span>
+          <h1 class="signin-title">pgkiln</h1>
+          <p class="signin-tagline">${tx('signin.tagline')}</p>
+        </section>
+        <section class="signin-panel">
+          <form method="post" class="signin-form">
+            <h2>${tx('mfa.step_title')}</h2>
+            <p class="muted u-mt0">${tx('mfa.step_intro', { user: p.u })}</p>
+            ${error ? html`<div class="alert alert-error" role="alert">${error}</div>` : ''}
+            ${csrf(s)}
+            <div class="field signin-field"><label class="label" for="f_code">${tx('mfa.code')}</label>
+              <div class="signin-input">${icon('key')}<input id="f_code" name="code" required autocomplete="one-time-code" autofocus maxlength="20" spellcheck="false" autocapitalize="off"></div>
+              <small class="help">${tx('mfa.code_help')}</small></div>
+            <button class="btn btn-hot signin-submit">${tx('mfa.verify')}</button>
+            <p class="muted small signin-hint"><a href="${BASE}/login">${tx('mfa.cancel')}</a> · ${tx('mfa.locked_out')}</p>
+          </form>
+        </section>
+      </main>`,
+      'login-body ide-login signin-body', {}, builderHead(),
+      { theme: validTheme(req.cookies?.[THEME_COOKIE]) ?? 'dark', lang: tx.lang },
+    ));
+  });
+  app.post(`${BASE}/login/2fa`, async (req: Req, reply) => {
+    const s = await getSession(req, reply, null, BASE);
+    const ip = clientIp(req);
+    const picked = validBuilderLanguage(s.state.__BLANG);
+    const tx = translatorFor(picked ?? cookieLanguage(req));
+    const p = pendingMfa(s);
+    if (req.body?.__csrf !== s.csrf_token || !p) {
+      delete s.state.__MFA;
+      flash(s, tx(p ? 'signin.expired' : 'mfa.expired'), 'error');
+      return back(reply, s, `${BASE}/login`);
+    }
+    if (await loginThrottled(null, p.u, ip)) {
+      logActivity({ username: p.u, event: 'login_locked', ip, detail: 'builder 2fa' });
+      delete s.state.__MFA;
+      flash(s, tx('signin.throttled'), 'error');
+      return back(reply, s, `${BASE}/login`);
+    }
+    const ok = await checkSecondFactor(p.u, String(req.body?.code ?? '').slice(0, 40));
+    if (!ok) {
+      // counts with the failed passwords (lockout after the same number of attempts)
+      await logActivity({ username: p.u, event: 'login_failed', ip, detail: 'builder 2fa' });
+      flash(s, tx('mfa.wrong'), 'error');
+      return back(reply, s, `${BASE}/login/2fa`);
+    }
+    const dev = await owner.one<{ username: string; language: string | null }>('select username, language from meta.developer where username = $1', [p.u]);
+    if (!dev) return back(reply, s, `${BASE}/login`);
+    if (ok.kind === 'recovery') {
+      const left = await codesLeft(p.u);
+      await logActivity({ username: p.u, event: '2fa_recovery_used', ip, detail: `${left} left` });
+      // to the Security page: one code fewer, maybe time for new ones
+      return finishSignIn(req, reply, s, dev, { ws: p.ws, workspace: p.w, next: `${BASE}/security`, remember: p.remember, weak: p.weak, picked, detail: 'builder 2fa (recovery code)' });
+    }
+    return finishSignIn(req, reply, s, dev, { ws: p.ws, workspace: p.w, next: p.next, remember: p.remember, weak: p.weak, picked, detail: 'builder 2fa' });
   });
 
   app.post(`${BASE}/logout`, async (req: Req, reply) => {
@@ -205,6 +304,7 @@ export async function builderRoutes(app: FastifyInstance) {
   await languageRoutes(app);
   await workspaceRoutes(app);
   await instanceRoutes(app);
+  await securityRoutes(app);
   await wizardRoutes(app);
   await appFromFileRoutes(app);
 
@@ -686,7 +786,8 @@ export async function builderRoutes(app: FastifyInstance) {
   app.get(`${BASE}/developers`, async (req: Req, reply) => {
     const s = await developer(req, reply);
     if (!s) return;
-    const devs = (await owner.query('select username, is_admin, email from meta.developer order by 1')).rows;
+    const devs = (await owner.query(`select username, is_admin, email, exists (select 1 from meta.developer_factor f where f.username = d.username) as mfa
+                                       from meta.developer d order by 1`)).rows;
     const admin = devs.some((d) => d.username === s.username && d.is_admin);
     const me = devs.find((d) => d.username === s.username);
     const tx = tr(s);
@@ -703,11 +804,14 @@ export async function builderRoutes(app: FastifyInstance) {
           <div class="buttons"><button class="btn">${tx('dev.save')}</button></div></form>`)}
         ${region(tx('dev.accounts'), html`
           <p class="muted u-mt0">${tx('dev.accounts_help')}</p>
-          <div class="table-wrap"><table class="report report-reflow"><thead><tr><th>${tx('dev.username')}</th><th>${tx('dev.role')}</th><th>${tx('dev.email_col')}</th><th></th></tr></thead><tbody>
+          <div class="table-wrap"><table class="report report-reflow"><thead><tr><th>${tx('dev.username')}</th><th>${tx('dev.role')}</th><th>${tx('dev.email_col')}</th><th>${tx('mfa.column')}</th><th></th></tr></thead><tbody>
             ${devs.map((d) => html`<tr><td data-label="${tx('dev.username')}">${d.username}${d.username === s.username ? ` ${tx('dev.you')}` : ''}</td><td data-label="${tx('dev.role')}">${d.is_admin ? tx('dev.administrator') : tx('dev.developer')}</td>
               <td data-label="${tx('dev.email_col')}">${admin && d.username !== s.username
                 ? html`<form method="post" action="${BASE}/developers/email" class="search u-m0 u-mwnone">${csrf(s)}<input type="hidden" name="username" value="${d.username}"><input name="email" type="email" value="${d.email ?? ''}" aria-label="${tx('dev.email_of', { user: d.username })}" placeholder="${tx('dev.none')}"><button class="btn">${tx('dev.save')}</button></form>`
-                : html`<span class="wrap-anywhere">${d.email ?? ''}</span>`}</td><td>${d.username === s.username || !admin ? '' : html`
+                : html`<span class="wrap-anywhere">${d.email ?? ''}</span>`}</td>
+              <td data-label="${tx('mfa.column')}">${d.mfa ? html`${icon('lock')} ${tx('mfa.on')}${admin && d.username !== s.username ? html` <details class="menu u-inline"><summary class="link-button">${tx('mfa.reset')}</summary><div class="menu-panel"><form method="post" action="${BASE}/developers/reset-2fa" class="menu-section">${csrf(s)}<input type="hidden" name="username" value="${d.username}">
+                  ${input(`reason_${d.username}`.replace(/[^\w]/g, '_'), tx('mfa.reason'), '', { required: true, help: tx('mfa.reset_help', { user: d.username }) })}
+                  <button class="btn btn-sm btn-danger">${tx('mfa.reset_btn')}</button></form></div></details>` : ''}` : html`<span class="muted">${tx('mfa.off')}</span>`}</td><td>${d.username === s.username || !admin ? '' : html`
               <form method="post" action="${BASE}/developers/admin" class="u-inline">${csrf(s)}<input type="hidden" name="username" value="${d.username}"><input type="hidden" name="is_admin" value="${d.is_admin ? 'false' : 'true'}"><button class="link-button">${d.is_admin ? tx('dev.make_dev') : tx('dev.make_admin')}</button></form>
               · <form method="post" action="${BASE}/developers/delete" class="u-inline">${csrf(s)}<input type="hidden" name="username" value="${d.username}"><button class="link-button" data-confirm="${tx('dev.remove_confirm', { user: d.username })}">${tx('dev.remove')}</button></form>`}</td></tr>`)}
           </tbody></table></div>
@@ -791,6 +895,10 @@ export async function builderRoutes(app: FastifyInstance) {
     if (!s) return;
     if (!(await isAdmin(s.username))) return reply.code(403).send('Only administrators change roles.');
     if (req.body?.username && req.body.username !== s.username) {
+      if (req.body.is_admin !== 'true' && (await leavesTooFewAdmins(req.body.username))) {
+        flash(s, tr(s)('mfa.keep_admins'), 'error');
+        return back(reply, s, `${BASE}/developers`);
+      }
       await owner.query('update meta.developer set is_admin = $2 where username = $1', [req.body.username, req.body.is_admin === 'true']);
       flash(s, tr(s)('dev.role_changed'));
     }
@@ -802,6 +910,10 @@ export async function builderRoutes(app: FastifyInstance) {
     if (!s) return;
     if (!(await isAdmin(s.username))) return reply.code(403).send('Only administrators remove developers.');
     if (req.body?.username && req.body.username !== s.username) {
+      if (await leavesTooFewAdmins(req.body.username)) {
+        flash(s, tr(s)('mfa.keep_admins'), 'error');
+        return back(reply, s, `${BASE}/developers`);
+      }
       await owner.query('delete from meta.developer where username = $1', [req.body.username]);
       await owner.query('delete from meta.session where app_id is null and username = $1', [req.body.username]);
       flash(s, tr(s)('dev.removed'));