@adonis-agora/authkit-server 0.82.3 → 0.84.0

package/build/src/host/controllers/interaction_controller.js

@@ -1,5 +1,6 @@
 import '../augmentations.js';
 import { supportsLoginMethodsPreference, supportsMagicLink, supportsOtpLogin, supportsPasskeys, } from '../../accounts/account_store.js';
+import { resolveAccountRoles } from '../account_roles.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
@@ -9,6 +10,7 @@ import { beginCustomMfa, clearMfaFlow, customMfaViewProps, getMfaFlow, initializ
 import { sendMagicLinkEmail, sendOtpUnlockEmail } from '../default_mailer.js';
 import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
+import { readLastLoginMethod, rememberLastLoginMethod } from '../last_login_method.js';
 import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
 import { notifyLoginSuccess } from '../login_notify.js';
@@ -16,8 +18,19 @@ import { authkitOrigin } from '../origin.js';
 import { createOtpLockout, generateOtpUnlockToken, rawToDbOtpUnlockToken, resolveEffectiveOtpLockout, } from '../otp_lockout.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, resolveEffectiveSessionPolicy, } from '../runtime_toggles.js';
+import { SOCIAL_PENDING_KEY, SOCIAL_PENDING_TTL_MS, } from '../social_pending.js';
 import { buildTrustedDevicePayload, isTrustedDeviceValid, TRUSTED_DEVICE_COOKIE, } from '../trusted_device.js';
 import { normalizeUserLoginMethods, resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
+/**
+ * Conta com papel administrativo (`cfg.admin.roles`, default `['ADMIN']`) — o
+ * bypass do modo manutenção. Os papéis vêm de `resolveAccountRoles`, a mesma
+ * fonte do claim (`resolveTokenRoles`, ex.: authz), não só do `globalRoles`.
+ */
+async function isAdminAccount(cfg, account) {
+    const adminRoles = cfg.admin?.roles ?? ['ADMIN'];
+    const roles = await resolveAccountRoles(cfg, account);
+    return adminRoles.some((role) => roles.includes(role));
+}
 /**
  * Chave i18n do erro de status de conta (disabled/expired) compartilhada pelos
  * fluxos passwordless (magic link, OTP, passkey).
@@ -105,8 +118,7 @@ export default class AuthInteractionController {
         if (!status.allowed)
             return fail(accountStatusErrorKey(status.reason));
         const maintenance = await resolveEffectiveMaintenanceMode(settings);
-        if (maintenance.enabled &&
-            !(cfg.admin?.roles ?? ['ADMIN']).some((role) => (account.globalRoles ?? []).includes(role))) {
+        if (maintenance.enabled && !(await isAdminAccount(cfg, account))) {
             return render(ctx, 'maintenance', {
                 uid: details.uid,
                 csrfToken: ctx.request.csrfToken,
@@ -114,6 +126,7 @@ export default class AuthInteractionController {
                 message: maintenance.message ?? translate(cfg.messages, 'maintenance.default_message'),
             });
         }
+        rememberLastLoginMethod(ctx, cfg, `custom:${input.method}`);
         const gate = await this.secondFactorGate(ctx, cfg, account.id, details, input.method, input.factorId, input.remember, input.passwordless === true);
         if (gate.kind === 'challenge') {
             ctx.session.put(MFA_CUSTOM_PRIMARY_KEY, {
@@ -164,6 +177,8 @@ export default class AuthInteractionController {
             authMethods,
             magicLinkAvailable: authMethods.magicLink && magicLinkCapableConfig,
             otpEnabled,
+            // Selo "último usado": método com que ESTE dispositivo entrou da última vez.
+            lastUsedLoginMethod: readLastLoginMethod(ctx, cfg),
         };
     }
     /**
@@ -468,9 +483,7 @@ export default class AuthInteractionController {
         // Contas admin (role em cfg.admin.roles) CONTINUAM podendo logar.
         // Contas comuns são bloqueadas com a tela de manutenção.
         if (maintenance.enabled) {
-            const adminRoles = cfg.admin?.roles ?? ['ADMIN'];
-            const accountRoles = acc.globalRoles ?? [];
-            const isAdmin = adminRoles.some((r) => accountRoles.includes(r));
+            const isAdmin = await isAdminAccount(cfg, acc);
             if (!isAdmin) {
                 return render(ctx, 'maintenance', {
                     uid: details.uid,
@@ -486,6 +499,7 @@ export default class AuthInteractionController {
         // Gate do 2º fator — a MESMA regra dos três caminhos de login (ver
         // `secondFactorGate`). Quando desafia, não finaliza a interaction: guarda o
         // accountId pendente e devolve a tela.
+        rememberLastLoginMethod(ctx, cfg, 'password');
         const gate = await this.secondFactorGate(ctx, cfg, acc.id, details, 'pwd');
         if (gate.kind === 'challenge')
             return gate.response;
@@ -563,9 +577,9 @@ export default class AuthInteractionController {
             ...(used.has('webauthn') ? { passkeyAvailable: false } : {}),
         });
     }
-    async configuredMfaGate(ctx, cfg, accountId, details, primary, primaryFactorId, rememberRequested, passwordless = primary !== 'pwd') {
+    async configuredMfaGate(ctx, cfg, accountId, details, primary, primaryFactorId, rememberRequested, passwordless = primary !== 'pwd', forceRequired = false) {
         const requiredFactors = cfg.mfa?.requiredFactors ?? 2;
-        const mfaRequired = this.acrRequiresMfa(cfg, details) || cfg.mfa?.requiredFactors !== undefined;
+        const mfaRequired = forceRequired || this.acrRequiresMfa(cfg, details) || cfg.mfa?.requiredFactors !== undefined;
         const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
         const enrolledTotp = mfa.totp ?? mfa.enabled;
         const enrolledPasskey = await this.hasPasskeys(cfg, accountId);
@@ -736,8 +750,7 @@ export default class AuthInteractionController {
             });
         }
         const maintenance = await resolveEffectiveMaintenanceMode(settings);
-        if (maintenance.enabled &&
-            !(cfg.admin?.roles ?? ['ADMIN']).some((role) => (account.globalRoles ?? []).includes(role))) {
+        if (maintenance.enabled && !(await isAdminAccount(cfg, account))) {
             return cfg.render(ctx, 'maintenance', {
                 uid: flow.uid,
                 csrfToken: ctx.request.csrfToken,
@@ -950,12 +963,12 @@ export default class AuthInteractionController {
      *  - caso geral → `challenge`, com o accountId em `MFA_PENDING_KEY` e o fator
      *    primário (`primary`) em `MFA_PRIMARY_KEY`.
      */
-    async secondFactorGate(ctx, cfg, accountId, details, primary, primaryFactorId = primary, rememberRequested, passwordless = primary !== 'pwd') {
+    async secondFactorGate(ctx, cfg, accountId, details, primary, primaryFactorId = primary, rememberRequested, passwordless = primary !== 'pwd', forceRequired = false) {
         ctx.session.forget(MFA_CUSTOM_PRIMARY_KEY);
         clearMfaFlow(ctx);
         if (cfg.mfa)
-            return this.configuredMfaGate(ctx, cfg, accountId, details, primary, primaryFactorId, rememberRequested, passwordless);
-        const mfaRequired = this.acrRequiresMfa(cfg, details);
+            return this.configuredMfaGate(ctx, cfg, accountId, details, primary, primaryFactorId, rememberRequested, passwordless, forceRequired);
+        const mfaRequired = forceRequired || this.acrRequiresMfa(cfg, details);
         const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
         // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
         // tem ao menos uma credencial registrada.
@@ -1212,6 +1225,32 @@ export default class AuthInteractionController {
      * Consome o magic link. Em sucesso finaliza o login (amr `['email']`). Token
      * inválido/expirado volta ao início do login.
      */
+    /**
+     * GET /auth/interaction/:uid/social/continue — segunda metade do login social
+     * quando a conta deve o 2º fator (ver `AuthSocialController#callback`). Lê o
+     * login pendente da sessão UMA vez, confere que é desta interaction e passa
+     * pelo mesmo `secondFactorGate` dos outros fluxos, com `fed` como fator
+     * primário no `amr`.
+     */
+    async socialContinue(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const uid = ctx.request.param('uid');
+        const pending = ctx.session.get(SOCIAL_PENDING_KEY);
+        ctx.session.forget(SOCIAL_PENDING_KEY);
+        const details = await service.interactions.details(ctx);
+        if (!pending ||
+            pending.uid !== uid ||
+            details.uid !== uid ||
+            details.prompt.name !== 'login' ||
+            Date.now() - pending.at > SOCIAL_PENDING_TTL_MS) {
+            return ctx.response.redirect(`/auth/interaction/${uid}`);
+        }
+        const gate = await this.secondFactorGate(ctx, cfg, pending.accountId, details, 'fed', 'fed', undefined, true, pending.required);
+        if (gate.kind === 'challenge')
+            return gate.response;
+        return service.interactions.completeLogin(ctx, pending.accountId, { amr: ['fed'] });
+    }
     async magicLinkConsume(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
@@ -1315,6 +1354,7 @@ export default class AuthInteractionController {
             });
         }
         // Conta com segundo fator não termina o login só com o e-mail.
+        rememberLastLoginMethod(ctx, cfg, 'magic_link');
         const magicGate = await this.secondFactorGate(ctx, cfg, acc.id, await service.interactions.details(ctx), 'email');
         if (magicGate.kind === 'challenge')
             return magicGate.response;
@@ -1437,6 +1477,7 @@ export default class AuthInteractionController {
                 clientId,
             });
             // Conta com segundo fator não termina o login só com o código do e-mail.
+            rememberLastLoginMethod(ctx, cfg, 'otp');
             const otpGate = await this.secondFactorGate(ctx, cfg, result.account.id, await service.interactions.details(ctx), 'email');
             if (otpGate.kind === 'challenge')
                 return otpGate.response;
@@ -1704,6 +1745,11 @@ export default class AuthInteractionController {
                 return ctx.response.redirect(`/auth/interaction/${ctx.request.param('uid')}`);
             return this.finishVerifiedMfa(ctx, cfg, details, 'webauthn', 'webauthn');
         }
+        // Passkey como fator PRIMÁRIO (passkey-first/autofill). Como 2º fator ela não
+        // é o método com que a pessoa se identificou — o selo fica com o primário.
+        if (ctx.session.get(MFA_PENDING_KEY) !== accountId) {
+            rememberLastLoginMethod(ctx, cfg, 'passkey');
+        }
         if (cfg.mfa) {
             const gate = await this.secondFactorGate(ctx, cfg, accountId, details, 'webauthn');
             if (gate.kind === 'challenge')
@@ -1811,6 +1857,7 @@ export default class AuthInteractionController {
         // Senha trocada: limpa o step e finaliza o login.
         ctx.session.forget(PASSWORD_EXPIRED_KEY);
         // Verifica se precisa de MFA mesmo após a troca — mesma regra do resto.
+        rememberLastLoginMethod(ctx, cfg, 'password');
         const expiredGate = await this.secondFactorGate(ctx, cfg, accountId, details, 'pwd');
         if (expiredGate.kind === 'challenge')
             return expiredGate.response;

package/build/src/host/controllers/pat_introspection_controller.d.ts

@@ -14,7 +14,7 @@ export default class PatIntrospectionController {
         sub: any;
         email: any;
         name: any;
-        roles: any;
+        roles: string[];
         scopes: any;
         audience: any;
         exp: any;

package/build/src/host/controllers/pat_introspection_controller.js

@@ -1,4 +1,5 @@
 import { timingSafeEqual } from 'node:crypto';
+import { resolveAccountRoles } from '../account_roles.js';
 function bearerMatches(header, expected) {
     if (!header || !header.startsWith('Bearer '))
         return false;
@@ -47,7 +48,7 @@ export default class PatIntrospectionController {
             sub: account.id,
             email: account.email,
             name: account.name ?? null,
-            roles: account.globalRoles ?? [],
+            roles: await resolveAccountRoles(cfg, account),
             scopes: meta.scopes,
             audience: meta.audience,
             exp: meta.exp,

package/build/src/host/controllers/registration_controller.d.ts

@@ -6,6 +6,16 @@ export default class AuthRegistrationController {
     showSignup(ctx: HttpContext): Promise<any>;
     /** POST /auth/interaction/:uid/signup — cria o usuário e finaliza o login. */
     signup(ctx: HttpContext): Promise<any>;
+    /**
+     * GET /auth/interaction/:uid/signup/confirm?token= — o dono do e-mail abriu o
+     * link do cadastro passwordless. Cria a conta (e-mail já verificado: quem
+     * clicou provou a caixa de entrada) e conclui pelo fluxo de magic link, que
+     * aplica os mesmos gates do login (status, manutenção, 2º fator).
+     *
+     * Conta que já existe → o link é recusado e a pessoa volta ao login: é o que
+     * faz o link valer uma vez só, sem estado no banco.
+     */
+    signupConfirm(ctx: HttpContext): Promise<void>;
     /** GET /auth/forgot-password — tela standalone. */
     showForgot(ctx: HttpContext): Promise<any>;
     /** POST /auth/forgot-password — gera token e (dev) loga o link. Sempre responde sucesso (não vaza emails). */

package/build/src/host/controllers/registration_controller.js

@@ -1,15 +1,18 @@
 import '../augmentations.js';
 import { randomBytes } from 'node:crypto';
+import { supportsAccountDeletion, supportsMagicLink } from '../../accounts/account_store.js';
 import { PasswordPolicyError } from '../../password/password_manager.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor } from '../branding.js';
 import { sendEmailVerificationEmail, sendMagicLinkEmail, sendPasswordResetEmail, } from '../default_mailer.js';
 import { translate } from '../i18n.js';
+import { rememberLastLoginMethod } from '../last_login_method.js';
 import { authkitOrigin } from '../origin.js';
 import { RuntimeSettings, resolveRuntimeSettings } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, } from '../runtime_toggles.js';
 import { dispatchSecurityNotice } from '../security_notice_service.js';
+import { issueSignupToken, readSignupToken } from '../signup_token.js';
 import { forgotPasswordValidator, passwordlessSignupValidator, resetPasswordValidator, signupValidator, } from '../validators.js';
 /**
  * Best-effort: returns a RuntimeSettings backed by the container DB, or a no-op
@@ -163,6 +166,8 @@ export default class AuthRegistrationController {
             ip: ctx.request.ip?.() ?? null,
             clientId: details.params.client_id ?? null,
         });
+        // Conta nova entra por senha: o selo "último usado" já nasce no método certo.
+        rememberLastLoginMethod(ctx, cfg, 'password');
         // Finaliza a interaction como login (interactionFinished escreve o redirect 303 que
         // retoma o authorize; o form nativo da tela segue esse redirect no sucesso).
         const result = await service.interactions.login(ctx, {
@@ -170,6 +175,13 @@ export default class AuthRegistrationController {
             password: data.password,
         });
         if (!result.ok) {
+            // A conta acabou de nascer e o login dela falhou: sem desfazer, a pessoa
+            // ficaria com um e-mail "já cadastrado" numa conta em que nunca entrou.
+            if (created && supportsAccountDeletion(accountStore)) {
+                await accountStore.deleteAccount(created.id).catch((error) => {
+                    ctx.logger.error({ err: error, accountId: created.id }, 'authkit: falha ao desfazer conta após signup sem login');
+                });
+            }
             return render(ctx, 'signup', {
                 uid: ctx.request.param('uid'),
                 csrfToken: ctx.request.csrfToken,
@@ -206,47 +218,46 @@ export default class AuthRegistrationController {
         }
     }
     /**
-     * Cadastro passwordless: valida e-mail + nome, cria a conta (senha random
-     * inutilizável) se ainda não existe, emite um magic link e o envia. Sempre
-     * responde "link enviado" (anti-enumeração), exista a conta ou não. Consumir o
-     * link finaliza o login pelo fluxo de magic link já existente (GET /magic).
+     * Cadastro passwordless: valida e-mail + nome e envia um link. Conta existente
+     * recebe um magic link de login; e-mail novo recebe o link de confirmação do
+     * cadastro (`signupConfirm`), e só então a conta é criada. Sempre responde
+     * "link enviado" (anti-enumeração), exista a conta ou não.
      */
     async #passwordlessSignup(ctx, deps) {
-        const { cfg, brand, details } = deps;
+        const { cfg, brand } = deps;
         const render = cfg.render;
         const accountStore = cfg.accountStore;
         const uid = ctx.request.param('uid');
         const data = await ctx.request.validateUsing(passwordlessSignupValidator);
-        // Cria a conta se ainda não existe. Senha random inutilizável: o login é 100%
-        // passwordless (mesmo precedente das contas criadas por identidade social).
+        const origin = authkitOrigin(cfg);
         const existing = await accountStore.findByEmail(data.email);
-        if (!existing) {
-            const created = await accountStore.create({
-                email: data.email,
-                fullName: data.fullName,
-                password: randomBytes(24).toString('hex'),
-            });
-            await cfg.audit?.record({
-                type: 'signup',
-                accountId: created.id,
-                email: data.email,
-                ip: ctx.request.ip?.() ?? null,
-                clientId: details.params.client_id ?? null,
-            });
+        if (existing) {
+            // Conta já existe: o "cadastro" vira um login por magic link.
+            // `data.email` já é a forma normalizada, a mesma do login.
+            const issued = await accountStore.issueMagicLinkToken(data.email);
+            if (issued) {
+                const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+                const to = issued.account.email;
+                if (cfg.mail?.onMagicLink) {
+                    await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token });
+                }
+                else {
+                    await sendMagicLinkEmail(ctx, { email: to, magicUrl });
+                }
+            }
         }
-        // Emite + envia o magic link (mesma construção do login por magic link).
-        // `data.email` já é a forma normalizada — a mesma sob a qual a conta foi
-        // encontrada acima ou acabou de ser criada.
-        const issued = await accountStore.issueMagicLinkToken(data.email);
-        if (issued) {
-            const origin = authkitOrigin(cfg);
-            const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
-            const to = issued.account.email;
+        else {
+            // Conta nova: NÃO cria aqui. O link de confirmação leva e-mail + nome num
+            // token cifrado; a conta só nasce quando o dono do e-mail o abre
+            // (`signupConfirm`). Um envio que falha não deixa conta órfã, e digitar o
+            // e-mail de outra pessoa não cria nada.
+            const token = await issueSignupToken({ email: data.email, fullName: data.fullName ?? null });
+            const magicUrl = `${origin}/auth/interaction/${uid}/signup/confirm?token=${encodeURIComponent(token)}`;
             if (cfg.mail?.onMagicLink) {
-                await cfg.mail.onMagicLink({ email: to, magicUrl, token: issued.token });
+                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token, kind: 'signup' });
             }
             else {
-                await sendMagicLinkEmail(ctx, { email: to, magicUrl });
+                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl });
             }
         }
         // Resposta uniforme: "enviamos um link" (não vaza existência da conta).
@@ -257,6 +268,62 @@ export default class AuthRegistrationController {
             magicLinkSent: true,
         });
     }
+    /**
+     * GET /auth/interaction/:uid/signup/confirm?token= — o dono do e-mail abriu o
+     * link do cadastro passwordless. Cria a conta (e-mail já verificado: quem
+     * clicou provou a caixa de entrada) e conclui pelo fluxo de magic link, que
+     * aplica os mesmos gates do login (status, manutenção, 2º fator).
+     *
+     * Conta que já existe → o link é recusado e a pessoa volta ao login: é o que
+     * faz o link valer uma vez só, sem estado no banco.
+     */
+    async signupConfirm(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const accountStore = cfg.accountStore;
+        const uid = ctx.request.param('uid');
+        const backToLogin = `/auth/interaction/${uid}`;
+        const token = ctx.request.qs().token ?? '';
+        if (!cfg.passwordless?.signup || !supportsMagicLink(accountStore) || !token) {
+            return ctx.response.redirect(backToLogin);
+        }
+        const runtimeSettings = await getRuntimeSettings(ctx);
+        const registrationEnabled = await resolveEffectiveRegistration(cfg.registration?.enabled ?? true, runtimeSettings);
+        if (!registrationEnabled)
+            return ctx.response.redirect(backToLogin);
+        const claim = await readSignupToken(token);
+        if (!claim)
+            return ctx.response.redirect(backToLogin);
+        if (await accountStore.findByEmail(claim.email))
+            return ctx.response.redirect(backToLogin);
+        let created;
+        try {
+            created = await accountStore.create({
+                email: claim.email,
+                fullName: claim.fullName,
+                password: randomBytes(24).toString('hex'),
+                emailVerified: true,
+            });
+        }
+        catch (error) {
+            // Dois cliques simultâneos: o segundo perde na unicidade do e-mail.
+            if (await accountStore.findByEmail(claim.email))
+                return ctx.response.redirect(backToLogin);
+            throw error;
+        }
+        const details = await service.interactions.details(ctx);
+        await cfg.audit?.record({
+            type: 'signup',
+            accountId: created.id,
+            email: claim.email,
+            ip: ctx.request.ip?.() ?? null,
+            clientId: details.params.client_id ?? null,
+        });
+        const issued = await accountStore.issueMagicLinkToken(claim.email);
+        if (!issued)
+            return ctx.response.redirect(backToLogin);
+        return ctx.response.redirect(`/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`);
+    }
     /** GET /auth/forgot-password — tela standalone. */
     async showForgot(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');

package/build/src/host/controllers/social_controller.js

@@ -1,10 +1,13 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
 import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, supportsProviderIdentity, } from '../../accounts/account_store.js';
+import { resolveAccountRoles } from '../account_roles.js';
 import { normalizeEmailIdentifier } from '../email_identifier.js';
+import { rememberLastLoginMethod } from '../last_login_method.js';
 import { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
+import { SOCIAL_PENDING_KEY } from '../social_pending.js';
 import { resolveEffectiveUserLoginMethods, } from '../user_login_methods.js';
 const UID_SESSION_KEY = 'authkit_social_uid';
 /**
@@ -29,6 +32,31 @@ async function resolveGlobalAuthMethodsForUser(cfg, settings) {
         configOverrides: cfg.authMethods,
     });
 }
+/**
+ * Política de 2º fator do login social para esta conta (ver
+ * `AuthSocialConfig.secondFactor`). Default `'enrolled'`. Os papéis passados à
+ * função vêm de `resolveAccountRoles` (o `resolveTokenRoles` do host, ex.: authz).
+ */
+async function resolveSecondFactorPolicy(cfg, account) {
+    const policy = cfg.social?.secondFactor ?? 'enrolled';
+    if (typeof policy !== 'function')
+        return policy;
+    return await policy({
+        id: account.id,
+        email: account.email,
+        roles: await resolveAccountRoles(cfg, account),
+    });
+}
+/** true se a conta tem TOTP confirmado ou ao menos uma passkey. */
+async function hasEnrolledSecondFactor(store, accountId) {
+    const mfa = (await store.getMfaState?.(accountId)) ?? { enabled: false };
+    if (mfa.totp ?? mfa.enabled)
+        return true;
+    if (!supportsPasskeys(store))
+        return false;
+    const list = await store.listPasskeys(accountId);
+    return Array.isArray(list) && list.length > 0;
+}
 export default class AuthSocialController {
     /** GET /auth/:provider/redirect/:uid — guarda o uid e redireciona para o provider OAuth. */
     async redirect(ctx) {
@@ -70,6 +98,20 @@ export default class AuthSocialController {
         //  2. Senão, e-mail conhecido → acha por e-mail e LIGA a identidade (linking).
         //  3. Senão → cria conta nova e liga a identidade.
         let user = await store.findByProviderIdentity(provider, profile.id);
+        // E-mail que o provider declara NÃO verificado não identifica ninguém: ligar
+        // por ele entregaria a conta de quem é dono do endereço a quem só o digitou
+        // no provider. `unsupported`/ausente (provider que não informa) segue valendo.
+        const emailUnverified = profile.emailVerificationState === 'unverified';
+        if (!user && email && emailUnverified) {
+            await cfg.audit?.record({
+                type: 'login.failure',
+                email,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { stage: 'social', provider, reason: 'provider_email_unverified' },
+            });
+            ctx.session.forget(UID_SESSION_KEY);
+            return ctx.response.redirect(backToLogin);
+        }
         if (!user && email) {
             // Busca pela MESMA forma normalizada que o login usa. Uma conta gravada
             // com outra grafia não é encontrada aqui e a pessoa ganharia uma SEGUNDA
@@ -95,7 +137,8 @@ export default class AuthSocialController {
                 email,
                 password: randomUUID(),
                 fullName: profile.name ?? null,
-                emailVerified: true,
+                // Só o provider que confirma o e-mail o torna verificado aqui.
+                emailVerified: profile.emailVerificationState === 'verified',
             });
             await store.linkProviderIdentity({
                 accountId: created.id,
@@ -154,6 +197,26 @@ export default class AuthSocialController {
             }
         }
         ctx.session.forget(UID_SESSION_KEY);
+        rememberLastLoginMethod(ctx, cfg, `social:${provider}`);
+        // 2º fator: o provider provou a identidade, mas quem cadastrou TOTP/passkey
+        // aqui espera que o fator valha também neste caminho. O desafio mora no
+        // interaction controller (mesmo gate de senha/magic link/OTP), então este
+        // passo só registra o login pendente e manda o browser para lá.
+        const policy = await resolveSecondFactorPolicy(cfg, user);
+        const needsGate = policy === 'required' ||
+            (policy === 'enrolled' && (!!cfg.mfa || (await hasEnrolledSecondFactor(store, user.id))));
+        if (needsGate) {
+            if (!uid)
+                return ctx.response.redirect(backToLogin);
+            const pending = {
+                accountId: user.id,
+                uid,
+                required: policy === 'required',
+                at: Date.now(),
+            };
+            ctx.session.put(SOCIAL_PENDING_KEY, pending);
+            return ctx.response.redirect(`/auth/interaction/${uid}/social/continue`);
+        }
         // Conclui a interaction OIDC para este usuário (escreve o 303 de volta ao authorize).
         // O cookie de interaction (path '/') sobrevive ao round-trip do provider OAuth.
         await service.interactions.completeLogin(ctx, user.id);

package/build/src/host/i18n.d.ts

@@ -50,6 +50,7 @@ export declare const DEFAULT_MESSAGES: {
     'login.magic_link_sent': string;
     'signup.magic_link_sent': string;
     'login.passkey_button': string;
+    'login.last_used': string;
     'login.otp_label': string;
     'login.otp_placeholder': string;
     'login.otp_submit': string;
@@ -809,6 +810,7 @@ export declare const PT_BR_MESSAGES: {
     'login.magic_link_sent': string;
     'signup.magic_link_sent': string;
     'login.passkey_button': string;
+    'login.last_used': string;
     'login.otp_label': string;
     'login.otp_placeholder': string;
     'login.otp_submit': string;

package/build/src/host/i18n.js

@@ -41,6 +41,8 @@ export const DEFAULT_MESSAGES = {
     'login.magic_link_sent': 'If the account exists, we sent you a login link.',
     'signup.magic_link_sent': 'Check your email — we sent you a link to finish creating your account.',
     'login.passkey_button': 'Sign in with a passkey',
+    // Selo do método com que este dispositivo entrou da última vez.
+    'login.last_used': 'Last used',
     // Login por OTP (código digitável).
     'login.otp_label': 'Enter the login code from the email',
     'login.otp_placeholder': '000000',
@@ -891,6 +893,7 @@ export const PT_BR_MESSAGES = {
     'login.magic_link_sent': 'Se a conta existir, enviamos um link de login.',
     'signup.magic_link_sent': 'Enviamos um link para o seu e-mail. Abra-o para concluir o cadastro.',
     'login.passkey_button': 'Entrar com passkey',
+    'login.last_used': 'Último usado',
     // Login por OTP (código digitável).
     'login.otp_label': 'Digite o código de login do e-mail',
     'login.otp_placeholder': '000000',

package/build/src/host/last_login_method.d.ts

@@ -0,0 +1,67 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * "Último método usado" no login (o selo "Last used" do Cloudflare, Vercel, Clerk…).
+ *
+ * O método fica num cookie DESTE DISPOSITIVO, não na conta. É de propósito:
+ *  - o passo 1 (identifier) ainda não sabe quem é o usuário, e é exatamente ali
+ *    que o selo mais ajuda ("da última vez você entrou com Google");
+ *  - guardar por conta e mostrar no passo 2 diria a quem digita um e-mail qualquer
+ *    como aquela conta entra — vazamento de enumeração. O cookie só conta ao
+ *    próprio browser o que ele mesmo fez.
+ *
+ * O cookie não carrega identidade nenhuma (nem e-mail, nem accountId), só o método.
+ * É puramente de SUPERFÍCIE: a tela destaca um botão, mas nada no fluxo muda — os
+ * métodos oferecidos continuam vindo de `authMethods`, e um valor adulterado no
+ * cookie só destaca outro botão (ou nenhum, se não passar na validação).
+ *
+ * Gravado quando o fator PRIMÁRIO é aceito. Numa conta com 2º fator, isso acontece
+ * antes do desafio de MFA: o selo responde "como você se identificou", que é o
+ * botão que a pessoa procura na próxima vez.
+ */
+/** Nome do cookie do último método de login. */
+export declare const LAST_LOGIN_METHOD_COOKIE = "authkit_last_login";
+/**
+ * Método de login primário. `social:<provider>` e `custom:<id>` carregam o id do
+ * provedor/método para a tela destacar o botão certo entre vários.
+ */
+export type LastLoginMethod = 'password' | 'magic_link' | 'otp' | 'passkey' | `social:${string}` | `custom:${string}`;
+/**
+ * Valida um valor lido do cookie. Só os métodos conhecidos passam; qualquer outra
+ * coisa (ausente, lixo, valor adulterado) vira `undefined` — sem selo.
+ */
+export declare function normalizeLastLoginMethod(raw: unknown): LastLoginMethod | undefined;
+/**
+ * Lê o último método deste dispositivo para a tela de login. Fail-safe: feature
+ * desligada, ctx sem cookies ou qualquer erro → `undefined` (sem selo).
+ */
+export declare function readLastLoginMethod(ctx: HttpContext, cfg: {
+    login?: {
+        lastUsedMethod?: boolean;
+    };
+}): LastLoginMethod | undefined;
+/**
+ * Registra o método primário que acabou de ser aceito. Grava via resposta do
+ * Adonis; quando o login termina no `interactionFinished` (que encerra a resposta
+ * crua), o `completeLogin` repassa o cookie pendente — ver
+ * {@link relayPendingCookies}. Best-effort: nunca derruba o login.
+ */
+export declare function rememberLastLoginMethod(ctx: HttpContext, cfg: {
+    login?: {
+        lastUsedMethod?: boolean;
+    };
+}, method: LastLoginMethod): void;
+/**
+ * Repassa os `Set-Cookie` que o handler gravou na resposta do Adonis para a
+ * resposta crua do Node.
+ *
+ * O Adonis só escreve os headers no `finish()`, depois do handler. Mas o
+ * `interactionFinished` do oidc-provider escreve o 303 e dá `res.end()` direto na
+ * resposta crua — quando o Adonis chega no `finish()`, a resposta já saiu e todo
+ * cookie gravado via `ctx.response.cookie()` no mesmo request é descartado em
+ * silêncio. Chamado pelo `completeLogin` logo antes do `interactionFinished`.
+ *
+ * Os cookies saem do Adonis ao serem repassados, então não há como irem em dobro.
+ * O `Set-Cookie` que o próprio oidc-provider grava depois é ACRESCENTADO aos
+ * existentes (a lib `cookies` do Koa preserva o header), então nada se perde.
+ */
+export declare function relayPendingCookies(ctx: HttpContext): void;