@adonis-agora/authkit-server 0.54.0 → 0.55.0

package/build/src/host/console_session.js

@@ -1,4 +1,5 @@
 import { getAccountLoginUrl } from './account_login_url.js';
+import { impersonationState } from './impersonation_session.js';
 import { ACCOUNT_SESSION_KEY } from './middleware/account_auth.js';
 /**
  * Helpers públicos para integrar a sessão do console do AuthKit com
@@ -10,13 +11,56 @@ import { ACCOUNT_SESSION_KEY } from './middleware/account_auth.js';
  * sessão mudar.
  */
 /**
- * Retorna o id da conta logada no console (ou `null` quando não há
- * sessão).
+ * Retorna o id da conta que o request está representando no console (ou `null`
+ * quando não há sessão).
+ *
+ * ATENÇÃO: com impersonation ativa isto é a conta PERSONIFICADA, não o admin
+ * que a personificou. É o comportamento certo para "como qual conta este
+ * request está agindo?" e é a entrada ERRADA para uma checagem de
+ * permissão/role — para isso use `realAccountId`.
  */
 export function getAccountId(ctx) {
     const accountId = ctx.session?.get(ACCOUNT_SESSION_KEY);
     return accountId ?? null;
 }
+/**
+ * Retorna o id do HUMANO real por trás do request — o id que uma decisão de
+ * autorização deve usar.
+ *
+ * ```
+ * impersonation ativa  → o id do impersonator (o admin real)
+ * sem impersonation    → o id da conta logada
+ * sem sessão           → null
+ * ```
+ *
+ * USE ESTE em qualquer checagem de permissão/role ("esta pessoa é admin?",
+ * "esta pessoa pode aprovar isto?"). Use `getAccountId` só para responder
+ * "como qual conta este request está agindo?" (queries com escopo no alvo,
+ * UI, banner de impersonation).
+ *
+ * POR QUE ISSO EXISTE. Durante uma impersonation, `getAccountId` devolve a
+ * conta PERSONIFICADA — é o comportamento correto dele e o resto do app
+ * depende disso. Mas ele é, por isso mesmo, a entrada ERRADA para um role
+ * check: perguntar "o `getAccountId` é admin?" com impersonation ativa
+ * pergunta sobre o usuário personificado e, quando ele por acaso for admin,
+ * entrega os privilégios do admin a quem está sendo personificado — e, no
+ * sentido inverso, faz o admin real perder o próprio acesso. `realAccountId`
+ * ignora a troca de conta e responde sempre sobre quem está de fato dirigindo
+ * a sessão.
+ *
+ * @example
+ * // gate de /admin: a pessoa por trás do request é admin?
+ * const id = realAccountId(ctx)
+ * if (!id || !(await authz.hasRole(id, 'admin'))) throw new Error('forbidden')
+ */
+export function realAccountId(ctx) {
+    // Sem sessão não há nem impersonation nem conta: mesma tolerância do
+    // `getAccountId` (que usa `ctx.session?.`), pois `impersonationState` assume
+    // uma sessão presente.
+    if (!ctx.session)
+        return null;
+    return impersonationState(ctx).impersonatorId ?? getAccountId(ctx);
+}
 /**
  * `true` quando o request carrega uma sessão de conta do console.
  */

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

@@ -112,13 +112,13 @@ export default class AccountMfaController {
                 kind: 'passkey_added',
                 ip,
                 timestamp: ts,
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
             await dispatchSecurityNotice(ctx, {
                 account: { id: userId, email: accountForNotice.email },
                 kind: 'mfa_enabled',
                 ip,
                 timestamp: ts,
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         // Resposta DUAL. A cerimônia WebAuthn da tela built-in (`mfa.edge`) chama
         // este endpoint por `fetch` e só olha `res.ok` — mas um `<form>` HTML
@@ -158,7 +158,7 @@ export default class AccountMfaController {
                 kind: 'passkey_removed',
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         return ctx.response.redirect(accountPath('mfa'));
     }
@@ -225,7 +225,7 @@ export default class AccountMfaController {
                 kind: 'mfa_enabled',
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         // Mostra os recovery codes UMA vez (flash) e volta pro estado "ativado".
         ctx.session.flash('recoveryCodes', result.recoveryCodes ?? []);
@@ -255,7 +255,7 @@ export default class AccountMfaController {
                 kind: 'mfa_disabled',
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         return ctx.response.redirect(accountPath('mfa'));
     }

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

@@ -4,6 +4,7 @@ import { getAccountLoginUrl } from '../account_login_url.js';
 import { accountPath } from '../account_paths.js';
 import { ACTIVE_ORG_COOKIE, ACTIVE_ORG_COOKIE_TTL, encodeActiveOrgCookie, } from '../active_org_cookie.js';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { isRoleInCatalog } from '../runtime_toggles.js';
 /**
@@ -190,7 +191,7 @@ export default class AccountOrgsController {
         // Dispara e-mail via mail hook (best-effort)
         if (cfg.mail?.onOrgInvitation) {
             const org = await store.findOrgById(params.id);
-            const acceptUrl = `${ctx.request.protocol()}://${ctx.request.host()}${accountPath('orgs')}/invitations/${token}/accept`;
+            const acceptUrl = `${authkitOrigin(cfg)}${accountPath('orgs')}/invitations/${token}/accept`;
             try {
                 await cfg.mail.onOrgInvitation({
                     email,

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

@@ -11,6 +11,7 @@ import { AvatarUploadError, isAvatarUploadSupported, storeAvatar } from '../avat
 import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail, sendEmailChangedCompletedEmail, } from '../default_mailer.js';
 import { translate } from '../i18n.js';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from '../runtime_toggles.js';
 import { dispatchSecurityNotice } from '../security_notice_service.js';
@@ -366,7 +367,7 @@ export default class AccountSecurityController {
                 kind: 'password_changed',
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         ctx.session.flash('passwordChanged', translate(cfg.messages, 'account.security.password_changed'));
         return ctx.response.redirect(accountPath('security'));
@@ -417,7 +418,7 @@ export default class AccountSecurityController {
             email: newEmail,
             ip: ctx.request.ip?.() ?? null,
         });
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const confirmUrl = `${origin}${accountPath('emailConfirm')}?token=${encodeURIComponent(issued.token)}`;
         // 1. Link de confirmação → NOVO e-mail (hook onEmailChangeConfirm > onEmailVerification > default).
         if (cfg.mail?.onEmailChangeConfirm) {
@@ -448,7 +449,7 @@ export default class AccountSecurityController {
                 await cfg.mail.onEmailChangeNotice({ email: account.email, newEmail });
             }
             else {
-                await sendEmailChangeNoticeEmail(ctx, {
+                await sendEmailChangeNoticeEmail(ctx, cfg, {
                     email: account.email,
                     newEmail,
                 });
@@ -530,7 +531,7 @@ export default class AccountSecurityController {
                     .catch(() => { });
             }
             else {
-                await sendEmailChangedCompletedEmail(ctx, {
+                await sendEmailChangedCompletedEmail(ctx, cfg, {
                     oldEmail: result.oldEmail,
                     newEmail: result.newEmail,
                 });
@@ -542,7 +543,7 @@ export default class AccountSecurityController {
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
                 metadata: { oldEmail: result.oldEmail, newEmail: result.newEmail },
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         return render(ctx, 'account/email-confirmed', { ok: result.ok });
     }

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

@@ -6,28 +6,35 @@ import { brandFor, isFirstParty } from '../branding.js';
 import { sendMagicLinkEmail } from '../default_mailer.js';
 import { sendOtpUnlockEmail } from '../default_mailer.js';
 import { translate } from '../i18n.js';
-import { attemptPasswordLogin, isEmailUnverifiedBlock } from '../login_attempt.js';
+import { assertLoginAllowed, attemptPasswordLogin, isEmailUnverifiedBlock, } from '../login_attempt.js';
 import { magicChannelProp, normalizeLoginChannel } from '../login_channel.js';
 import { notifyLoginSuccess } from '../login_notify.js';
+import { authkitOrigin } from '../origin.js';
 import { createOtpLockout, generateOtpUnlockToken, rawToDbOtpUnlockToken, resolveEffectiveOtpLockout, } from '../otp_lockout.js';
-import { RuntimeSettings, resolveRuntimeSettings } from '../runtime_settings.js';
+import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods, resolveEffectiveMaintenanceMode, resolveEffectiveRegistration, resolveEffectiveSessionPolicy, } from '../runtime_toggles.js';
 import { TRUSTED_DEVICE_COOKIE, buildTrustedDevicePayload, isTrustedDeviceValid, } from '../trusted_device.js';
 /**
- * Best-effort: returns a RuntimeSettings backed by the container DB, or a no-op
- * fallback. Contrato NON-NULL preservado — é chamado 6× passando direto p/
- * funções que exigem `SettingsCapability` non-null. Reusa a fábrica canônica
- * `resolveRuntimeSettings` e degrada para o RuntimeSettings no-op (probe via
- * SELECT lança → tabela ausente → config fallback) quando a resolução falha.
+ * Chave i18n do erro de status de conta (disabled/expired) compartilhada pelos
+ * fluxos passwordless (magic link, OTP, passkey).
+ *
+ * O braço `password_expired` é HOJE inalcançável por estes três: eles passam
+ * `passwordless: true` ao gate, que pula a checagem de senha vencida (plan 012 —
+ * uma conta sem senha ficava trancada, porque estes fluxos não têm o passo de
+ * troca obrigatória para onde mandá-la). Ele permanece aqui porque
+ * {@link AccountStatusReason} é exaustivo e um chamador futuro pode não passar a
+ * flag; reaproveita o texto do passo de troca (`login.password_expired_intro`)
+ * em vez de inventar uma chave nova.
  */
-async function getRuntimeSettings(ctx) {
-    const rs = await resolveRuntimeSettings(ctx);
-    return (rs ??
-        new RuntimeSettings({
-            table: () => {
-                throw new Error('no-op');
-            },
-        }));
+function accountStatusErrorKey(reason) {
+    switch (reason) {
+        case 'disabled':
+            return 'errors.account_disabled';
+        case 'account_expired':
+            return 'errors.account_expired';
+        case 'password_expired':
+            return 'login.password_expired_intro';
+    }
 }
 const SESSION_KEY = 'authkit_login_email';
 /** accountId aguardando o 2º fator depois da senha verificada. */
@@ -51,7 +58,7 @@ export default class AuthInteractionController {
      * maintenance) para evitar uma segunda resolução; ausente, resolve sob demanda.
      */
     async #loginMethods(ctx, cfg, runtimeSettings) {
-        const settings = runtimeSettings ?? (await getRuntimeSettings(ctx));
+        const settings = runtimeSettings ?? (await resolveRuntimeSettingsOrNoop(ctx));
         const magicLinkCapableConfig = cfg.passwordless.magicLink && supportsMagicLink(cfg.accountStore);
         const authMethods = await resolveEffectiveAuthMethods(settings, {
             configuredSocialProviders: cfg.social?.providers ?? [],
@@ -75,7 +82,7 @@ export default class AuthInteractionController {
         // Maintenance mode: verifica se é uma conta admin antes de bloquear.
         // Contas admin continuam podendo logar para que o operador possa desligar a
         // manutenção via console. Contas comuns veem a tela de manutenção.
-        const runtimeSettingsForMaintenance = await getRuntimeSettings(ctx);
+        const runtimeSettingsForMaintenance = await resolveRuntimeSettingsOrNoop(ctx);
         const maintenance = await resolveEffectiveMaintenanceMode(runtimeSettingsForMaintenance);
         if (maintenance.enabled) {
             // Verifica se já há uma conta admin na sessão (já autenticado) OU
@@ -145,7 +152,7 @@ export default class AuthInteractionController {
         const passkeyFirstCapable = cfg.passwordless.passkeyFirst && !!acc && (await this.hasPasskeys(cfg, acc.id));
         const passkeyFirstAvailable = authMethods.passkey && passkeyFirstCapable;
         // Effective bot protection: may be overridden at runtime via auth_settings.
-        const effectiveBot = await resolveEffectiveBotProtection(cfg.botProtection, await getRuntimeSettings(ctx));
+        const effectiveBot = await resolveEffectiveBotProtection(cfg.botProtection, await resolveRuntimeSettingsOrNoop(ctx));
         // Session policy: resolve para exibir o checkbox "manter conectado".
         const sessionPolicyForShow = await resolveEffectiveSessionPolicy(runtimeSettingsForMaintenance, cfg.ttl?.session ? Math.ceil(cfg.ttl.session / 3600) : undefined);
         return render(ctx, 'login', {
@@ -191,7 +198,7 @@ export default class AuthInteractionController {
         const ip = ctx.request.ip?.() ?? null;
         const clientId = details.params.client_id ?? null;
         // Resolve runtime settings (reutilizado por bot + maintenance + verifiedEmail + session_policy).
-        const runtimeSettings = await getRuntimeSettings(ctx);
+        const runtimeSettings = await resolveRuntimeSettingsOrNoop(ctx);
         // Maintenance mode: verifica se a conta que tenta logar é admin.
         // Admins CONTINUAM podendo logar (senão o operador se tranca fora).
         // A verificação de role acontece APÓS as credenciais (senha correta primeiro).
@@ -411,7 +418,7 @@ export default class AuthInteractionController {
         }
         const { code, recoveryCode } = ctx.request.only(['code', 'recoveryCode']);
         // Resolve OTP lockout settings (fail-safe).
-        const runtimeForOtp = await getRuntimeSettings(ctx);
+        const runtimeForOtp = await resolveRuntimeSettingsOrNoop(ctx);
         const otpLockoutCfg = await resolveEffectiveOtpLockout(runtimeForOtp);
         const otpLockout = createOtpLockout(otpLockoutCfg, ctx.logger);
         // Verifica se o fator OTP está travado ANTES de tentar verificar.
@@ -572,7 +579,7 @@ export default class AuthInteractionController {
                 row.passwordResetExpiresAt = DateTime.now().plus({ hours: unlockTtlHours });
                 await row.save();
             }
-            const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+            const origin = authkitOrigin(cfg);
             const unlockUrl = `${origin}/auth/otp-unlock/${encodeURIComponent(raw)}`;
             if (cfg.mail?.onOtpUnlock) {
                 await cfg.mail.onOtpUnlock({ email: account.email, unlockUrl, token: raw }).catch(() => { });
@@ -655,7 +662,7 @@ export default class AuthInteractionController {
                         clientId,
                     });
                 }
-                const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+                const origin = authkitOrigin(cfg);
                 const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
                 if (cfg.mail?.onMagicLink) {
                     await cfg.mail.onMagicLink({ email, magicUrl, token: issued.token, code, channel });
@@ -710,7 +717,7 @@ export default class AuthInteractionController {
         }
         // E-mail não verificado (LGPD/compliance): mesmo com o link válido, não
         // materializa a sessão se a política exige verificação. Volta ao login com erro.
-        const magicLinkRuntimeSettings = await getRuntimeSettings(ctx);
+        const magicLinkRuntimeSettings = await resolveRuntimeSettingsOrNoop(ctx);
         if (await isEmailUnverifiedBlock(cfg, acc.id, magicLinkRuntimeSettings)) {
             await cfg.audit?.record({
                 type: 'login.failure',
@@ -732,6 +739,39 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.email_unverified'),
             });
         }
+        // Status da conta (disabled/expired): mesmo gate de `attemptPasswordLogin`,
+        // agora aplicado ao magic link (o botão "desabilitar" no admin console não
+        // tinha efeito nenhum aqui antes desta checagem). Emite o MESMO evento
+        // `login.failure`/`account.expired_login_blocked` que o fluxo de senha
+        // (auditoria uniforme entre fluxos).
+        //
+        // `passwordless: true` — este fluxo não usa senha e não tem como levar o
+        // usuário à troca obrigatória: o único caminho até `step: 'password_expired'`
+        // passa por `attemptPasswordLogin`, que exige a senha CORRETA antes de
+        // classificar a expiração. Uma conta que nunca definiu senha
+        // (`password_changed_at` NULL, que `isPasswordExpired` trata como vencida)
+        // só poderia pedir outro magic link e cair no mesmo bloqueio. Ver
+        // `LoginAllowedInput.passwordless`.
+        const magicLinkStatusGate = await assertLoginAllowed(cfg, acc.id, {
+            email: acc.email,
+            ip,
+            clientId,
+            settings: magicLinkRuntimeSettings,
+            passwordless: true,
+        });
+        if (!magicLinkStatusGate.allowed) {
+            const render = cfg.render;
+            return render(ctx, 'login', {
+                ...(await this.#loginMethods(ctx, cfg)),
+                uid,
+                csrfToken: ctx.request.csrfToken,
+                step: 'password',
+                email: acc.email,
+                account: null,
+                brand: brandFor(cfg.branding, clientId ?? undefined, undefined),
+                error: translate(cfg.messages, accountStatusErrorKey(magicLinkStatusGate.reason)),
+            });
+        }
         await notifyLoginSuccess(ctx, cfg, {
             accountId: acc.id,
             email: acc.email,
@@ -791,7 +831,7 @@ export default class AuthInteractionController {
         if (result.status === 'ok') {
             // E-mail não verificado (LGPD): mesmo com código válido, não materializa a
             // sessão se a política exige verificação. Espelha o magicLinkConsume.
-            const runtimeSettings = await getRuntimeSettings(ctx);
+            const runtimeSettings = await resolveRuntimeSettingsOrNoop(ctx);
             if (await isEmailUnverifiedBlock(cfg, result.account.id, runtimeSettings)) {
                 await cfg.audit?.record({
                     type: 'login.failure',
@@ -812,6 +852,32 @@ export default class AuthInteractionController {
                     error: translate(cfg.messages, 'errors.email_unverified'),
                 });
             }
+            // Status da conta (disabled/expired): mesmo gate de `attemptPasswordLogin`,
+            // agora aplicado ao login por OTP. Emite o MESMO evento de auditoria que o
+            // fluxo de senha (uniforme entre fluxos).
+            //
+            // `passwordless: true` — mesmo raciocínio do magic link (o OTP é o outro
+            // metade do mesmo e-mail): fluxo sem senha e sem passo de troca
+            // obrigatória alcançável. Ver `LoginAllowedInput.passwordless`.
+            const otpStatusGate = await assertLoginAllowed(cfg, result.account.id, {
+                email: result.account.email,
+                ip,
+                clientId,
+                settings: runtimeSettings,
+                passwordless: true,
+            });
+            if (!otpStatusGate.allowed) {
+                return render(ctx, 'login', {
+                    ...(await this.#loginMethods(ctx, cfg)),
+                    uid,
+                    csrfToken: ctx.request.csrfToken,
+                    step: 'password',
+                    email: result.account.email,
+                    account: null,
+                    brand,
+                    error: translate(cfg.messages, accountStatusErrorKey(otpStatusGate.reason)),
+                });
+            }
             await cfg.audit?.record({
                 type: 'login.otp_verified',
                 accountId: result.account.id,
@@ -988,7 +1054,7 @@ export default class AuthInteractionController {
         // E-mail não verificado (LGPD/compliance): bloqueia mesmo com a passkey válida.
         // Relevante sobretudo no passkey-first (a etapa de senha — que também checa —
         // não rodou). Volta à tela de desafio com o erro.
-        const passkeyRuntimeSettings = await getRuntimeSettings(ctx);
+        const passkeyRuntimeSettings = await resolveRuntimeSettingsOrNoop(ctx);
         if (await isEmailUnverifiedBlock(cfg, accountId, passkeyRuntimeSettings)) {
             await cfg.audit?.record({
                 type: 'login.failure',
@@ -1007,6 +1073,36 @@ export default class AuthInteractionController {
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
         }
+        // Status da conta (disabled/expired): mesmo gate de `attemptPasswordLogin`,
+        // agora aplicado ao passkey (cobre sobretudo o passkey-first, que nunca passa
+        // pelo fluxo de senha). Emite o MESMO evento de auditoria que os outros fluxos.
+        //
+        // `passwordless: true` — no passkey-first é o dead-end mais duro dos três:
+        // a view de erro é a `mfa-challenge`, que só oferece o desafio da passkey
+        // (nem campo de senha nem os outros métodos de login), então uma conta sem
+        // senha ficaria trancada sem NENHUMA ação possível. No modo MFA (pós-senha)
+        // a flag é inócua: `attemptPasswordLogin` já rodou a checagem de senha
+        // vencida e desviou para `step: 'password_expired'` antes de chegar aqui.
+        // Ver `LoginAllowedInput.passwordless`.
+        const passkeyAccount = await cfg.accountStore.findById(accountId);
+        const passkeyStatusGate = await assertLoginAllowed(cfg, accountId, {
+            email: passkeyAccount?.email ?? '',
+            ip,
+            clientId,
+            settings: passkeyRuntimeSettings,
+            passwordless: true,
+        });
+        if (!passkeyStatusGate.allowed) {
+            return render(ctx, 'mfa-challenge', {
+                uid: ctx.request.param('uid'),
+                csrfToken: ctx.request.csrfToken,
+                error: translate(cfg.messages, accountStatusErrorKey(passkeyStatusGate.reason)),
+                brand,
+                passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
+            });
+        }
         // Passkey OK: opcionalmente confia neste dispositivo (checkbox no challenge).
         await this.maybeTrustDevice(ctx, cfg, accountId);
         ctx.session.forget(MFA_PENDING_KEY);
@@ -1177,7 +1273,7 @@ export default class AuthInteractionController {
                 return render(ctx, 'otp-unlock', { ok: false, expired: true });
             }
             // Token válido: zera o lock OTP + limpa o token do DB.
-            const runtimeForOtp = await getRuntimeSettings(ctx);
+            const runtimeForOtp = await resolveRuntimeSettingsOrNoop(ctx);
             const otpLockoutCfg = await resolveEffectiveOtpLockout(runtimeForOtp);
             const otpLockout = createOtpLockout(otpLockoutCfg, ctx.logger);
             await otpLockout.unlock(row.id);

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

@@ -6,6 +6,7 @@ import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protec
 import { brandFor } from '../branding.js';
 import { sendEmailVerificationEmail, sendMagicLinkEmail, sendPasswordResetEmail, } from '../default_mailer.js';
 import { translate } from '../i18n.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';
@@ -187,7 +188,7 @@ export default class AuthRegistrationController {
                     email: data.email,
                     ip: ctx.request.ip?.() ?? null,
                 });
-                const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+                const origin = authkitOrigin(cfg);
                 const verifyUrl = `${origin}/auth/verify-email?token=${issued.token}`;
                 // Hook do config tem prioridade (override); senão usa o mailer default do host.
                 if (cfg.mail?.onEmailVerification) {
@@ -234,7 +235,7 @@ export default class AuthRegistrationController {
         // Emite + envia o magic link (mesma construção do login por magic link).
         const issued = await accountStore.issueMagicLinkToken(data.email);
         if (issued) {
-            const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+            const origin = authkitOrigin(cfg);
             const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
             if (cfg.mail?.onMagicLink) {
                 await cfg.mail.onMagicLink({ email: data.email, magicUrl, token: issued.token });
@@ -328,7 +329,7 @@ export default class AuthRegistrationController {
                 email,
                 ip: ctx.request.ip?.() ?? null,
             });
-            const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+            const origin = authkitOrigin(cfg);
             const url = `${origin}/auth/reset-password?token=${result.token}`;
             // Hook do config tem prioridade (override); senão usa o mailer default do host.
             if (cfg.mail?.onPasswordReset) {
@@ -430,7 +431,7 @@ export default class AuthRegistrationController {
                 kind: 'password_changed',
                 ip: ctx.request.ip?.() ?? null,
                 timestamp: new Date().toISOString(),
-            }, cfg.mail, cfg.audit);
+            }, cfg.mail, cfg.audit, cfg);
         }
         return render(ctx, 'reset', {
             token: '',

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

@@ -1,6 +1,8 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
 import { supportsProviderIdentity } from '../../accounts/account_store.js';
+import { assertLoginAllowed } from '../login_attempt.js';
+import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 const UID_SESSION_KEY = 'authkit_social_uid';
 /**
  * `AllyService.use()` é tipado contra a interface `SocialProviders`, que só é
@@ -81,6 +83,41 @@ export default class AuthSocialController {
             });
             user = created;
         }
+        // Status da conta: mesmo gate compartilhado dos demais fluxos de login. O
+        // callback já voltou do provider OAuth — não há passo de formulário para
+        // re-renderizar um erro, então seguimos a convenção deste controller e
+        // redirecionamos de volta ao login.
+        //
+        // O QUE ESTE CAMINHO APLICA:
+        //  - `disabled` → recusa (evento `login.failure` com `reason: 'disabled'`).
+        //  - `account_expiration` (inatividade) → recusa (evento
+        //    `account.expired_login_blocked`). Isto exige `settings`: sem eles,
+        //    `assertAccountNotExpired` deixa AMBAS as checagens de expiração como
+        //    no-op, e era exatamente esse o bug — uma política de controle de acesso
+        //    valendo em todo lugar menos no "Continue with Google".
+        //
+        // O QUE ESTE CAMINHO **NÃO** APLICA (`passwordless: true`):
+        //  - `password_expiration`. Este é um fluxo SEM senha: a conta pode nunca ter
+        //    definido uma (login social puro → `password_changed_at` NULL, que
+        //    `isPasswordExpired` trata como "vencida"), e este controller não tem um
+        //    passo de troca obrigatória para onde mandar o usuário — só sabe
+        //    redirecionar de volta ao login. Aplicar a checagem aqui trancaria
+        //    permanentemente todo usuário social-only assim que o operador ligasse a
+        //    política, devolvendo-o a uma tela sem senha nenhuma que pudesse trocar.
+        //
+        // `resolveRuntimeSettingsOrNoop` degrada para um RuntimeSettings no-op quando
+        // não há tabela de settings — host sem a migração continua logando por social.
+        const settings = await resolveRuntimeSettingsOrNoop(ctx);
+        const statusGate = await assertLoginAllowed(cfg, user.id, {
+            email: user.email,
+            ip: ctx.request.ip?.() ?? null,
+            settings,
+            passwordless: true,
+        });
+        if (!statusGate.allowed) {
+            ctx.session.forget(UID_SESSION_KEY);
+            return ctx.response.redirect(backToLogin);
+        }
         ctx.session.forget(UID_SESSION_KEY);
         // 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.

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

@@ -1,4 +1,5 @@
 import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedServerConfig } from '../define_config.js';
 /**
  * Envio de e-mail default do host-kit, usando o mailer `default` do host via
  * `@adonisjs/mail`. Permite que o dev não escreva nenhum hook: por padrão os
@@ -40,7 +41,7 @@ export declare function sendEmailChangeConfirmationEmail(ctx: HttpContext, data:
  * Envia o e-mail de alerta de NOVO acesso à conta (login de um IP novo).
  * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export declare function sendNewLoginEmail(ctx: HttpContext, data: {
+export declare function sendNewLoginEmail(ctx: HttpContext, cfg: ResolvedServerConfig, data: {
     email: string;
     ip: string;
     when: string;
@@ -49,7 +50,7 @@ export declare function sendNewLoginEmail(ctx: HttpContext, data: {
  * Envia o e-mail de alerta de NOVO DISPOSITIVO (login sem cookie de dispositivo
  * confiável). Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export declare function sendNewDeviceLoginEmail(ctx: HttpContext, data: {
+export declare function sendNewDeviceLoginEmail(ctx: HttpContext, cfg: ResolvedServerConfig, data: {
     email: string;
     ip?: string | null;
     userAgent?: string | null;
@@ -65,12 +66,42 @@ export declare function sendMagicLinkEmail(ctx: HttpContext, data: {
     code?: string;
     channel?: 'code' | 'link';
 }): Promise<void>;
+/**
+ * Envia o link de CONFIRMAÇÃO DE IDENTIDADE (sudo) pelo mailer default do host.
+ *
+ * POR QUE EXISTE. `sudoMethods.magicLink()` dependia EXCLUSIVAMENTE do hook
+ * `mail.onSudoLink`, e sem ele o método se declarava indisponível. Num host
+ * passwordless isso fechava o deadlock: sem senha, sem passkey e sem hook, a
+ * tela `/account/confirm` não tinha um único método satisfazível — e o usuário
+ * ficava trancado fora de exportar/excluir os próprios dados, do MFA, dos PATs
+ * e da troca de e-mail, inclusive do cadastro de passkey que destravaria tudo.
+ *
+ * A postura aqui é a MESMA de todos os outros e-mails da lib (reset de senha,
+ * verificação, magic link de login, avisos de segurança): o hook do host, quando
+ * existe, tem prioridade; sem hook, o próprio host-kit envia pelo mailer default
+ * (`@adonisjs/mail`) com branding e i18n; sem mailer, loga o link (dev).
+ *
+ * O TOKEN continua sendo o de sudo — emitido e verificado em
+ * `sudo/methods/magic_link.ts`, hasheado na sessão que pediu, de uso único,
+ * 5 min, vinculado ao `accountId` emissor. Isto aqui é só ENTREGA; nada é
+ * compartilhado com o token de login.
+ *
+ * @returns `true` quando o e-mail foi entregue ao mailer (ou logado no fallback
+ * de dev) e `false` quando o envio falhou de verdade. O chamador PRECISA disso:
+ * ao contrário dos outros e-mails da lib, um link de sudo que não saiu tem de
+ * apagar o pendente da sessão e recusar — flashar "link enviado" deixaria o
+ * usuário esperando um e-mail que nunca vem, na tela que já é o gargalo dele.
+ */
+export declare function sendSudoLinkEmail(ctx: HttpContext, data: {
+    email: string;
+    sudoUrl: string;
+}): Promise<boolean>;
 /**
  * Envia o e-mail de aviso de segurança ao e-mail ATUAL quando uma troca de
  * e-mail é solicitada ("Alguém pediu troca para X — se não foi você...").
  * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export declare function sendEmailChangeNoticeEmail(ctx: HttpContext, data: {
+export declare function sendEmailChangeNoticeEmail(ctx: HttpContext, cfg: ResolvedServerConfig, data: {
     email: string;
     newEmail: string;
 }): Promise<void>;
@@ -79,7 +110,7 @@ export declare function sendEmailChangeNoticeEmail(ctx: HttpContext, data: {
  * troca foi concluída ("Seu e-mail foi alterado de A para B — se não foi você...").
  * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export declare function sendEmailChangedCompletedEmail(ctx: HttpContext, data: {
+export declare function sendEmailChangedCompletedEmail(ctx: HttpContext, cfg: ResolvedServerConfig, data: {
     oldEmail: string;
     newEmail: string;
 }): Promise<void>;
@@ -88,7 +119,7 @@ export declare function sendEmailChangedCompletedEmail(ctx: HttpContext, data: {
  * MFA habilitado/desabilitado, passkey adicionada/removida, e-mail alterado).
  * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export declare function sendSecurityNoticeEmail(ctx: HttpContext, data: {
+export declare function sendSecurityNoticeEmail(ctx: HttpContext, cfg: ResolvedServerConfig, data: {
     email: string;
     kind: 'password_changed' | 'mfa_enabled' | 'mfa_disabled' | 'passkey_added' | 'passkey_removed' | 'email_changed';
     timestamp: string;