@adonis-agora/authkit-server 0.53.0 → 0.55.0

package/build/src/host/default_mailer.js

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import { accountPath } from './account_paths.js';
 import { renderTransactionalEmail } from './email_templates.js';
 import { resolveMessages, translate } from './i18n.js';
+import { authkitOrigin } from './origin.js';
 let mailServicePromise;
 /**
  * Importa o service de mail do HOST de forma preguiçosa e fail-safe.
@@ -174,11 +175,11 @@ export async function sendEmailChangeConfirmationEmail(ctx, 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 async function sendNewLoginEmail(ctx, data) {
+export async function sendNewLoginEmail(ctx, cfg, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const intro = [
             translate(t, 'mail.new_login.intro'),
             translate(t, 'mail.new_login.when', { date: data.when }),
@@ -208,11 +209,11 @@ export async function sendNewLoginEmail(ctx, 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 async function sendNewDeviceLoginEmail(ctx, data) {
+export async function sendNewDeviceLoginEmail(ctx, cfg, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const lines = [
             translate(t, 'mail.new_login.intro'),
             translate(t, 'mail.new_login.when', { date: data.when }),
@@ -293,16 +294,68 @@ export async function sendMagicLinkEmail(ctx, data) {
         ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar magic link de login');
     }
 }
+/**
+ * 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 async function sendSudoLinkEmail(ctx, data) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.sudo_link.subject'),
+            heading: translate(t, 'mail.sudo_link.heading'),
+            intro: translate(t, 'mail.sudo_link.intro'),
+            ctaLabel: translate(t, 'mail.sudo_link.cta'),
+            ctaUrl: data.sudoUrl,
+            footnote: translate(t, 'mail.sudo_link.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger?.info({ sudoUrl: data.sudoUrl, email: data.email }, 'authkit: link de confirmação de identidade (dev — @adonisjs/mail ausente)');
+        }
+        return true;
+    }
+    catch (error) {
+        ctx.logger?.error({ err: error, email: data.email }, 'authkit: falha ao enviar link de confirmação de identidade');
+        return false;
+    }
+}
 /**
  * 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 async function sendEmailChangeNoticeEmail(ctx, data) {
+export async function sendEmailChangeNoticeEmail(ctx, cfg, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const content = renderTransactionalEmail({
             brand,
             locale,
@@ -328,11 +381,11 @@ export async function sendEmailChangeNoticeEmail(ctx, 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 async function sendEmailChangedCompletedEmail(ctx, data) {
+export async function sendEmailChangedCompletedEmail(ctx, cfg, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const content = renderTransactionalEmail({
             brand,
             locale,
@@ -361,11 +414,11 @@ export async function sendEmailChangedCompletedEmail(ctx, data) {
  * MFA habilitado/desabilitado, passkey adicionada/removida, e-mail alterado).
  * Best-effort: no fallback (sem mail) loga o evento; nunca lança.
  */
-export async function sendSecurityNoticeEmail(ctx, data) {
+export async function sendSecurityNoticeEmail(ctx, cfg, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const origin = authkitOrigin(cfg);
         const kindKey = `mail.security_notice.kind_${data.kind}`;
         const kindLabel = translate(t, kindKey);
         const intro = [

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

@@ -530,6 +530,11 @@ export declare const DEFAULT_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
+    'mail.sudo_link.subject': string;
+    'mail.sudo_link.heading': string;
+    'mail.sudo_link.intro': string;
+    'mail.sudo_link.cta': string;
+    'mail.sudo_link.fallback': string;
     'mail.new_login.subject': string;
     'mail.new_login.heading': string;
     'mail.new_login.intro': string;
@@ -1243,6 +1248,11 @@ export declare const PT_BR_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
+    'mail.sudo_link.subject': string;
+    'mail.sudo_link.heading': string;
+    'mail.sudo_link.intro': string;
+    'mail.sudo_link.cta': string;
+    'mail.sudo_link.fallback': string;
     'mail.new_login.subject': string;
     'mail.new_login.heading': string;
     'mail.new_login.intro': string;

package/build/src/host/i18n.js

@@ -573,6 +573,16 @@ export const DEFAULT_MESSAGES = {
     'mail.magic_link.code_subject': 'Your login code',
     'mail.magic_link.code_intro': 'Use the code below to sign in. It expires shortly and can be used once.',
     'mail.magic_link.code_only_label': 'Enter this code to sign in:',
+    // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo). Copy DISTINTA da do magic link de
+    // login de propósito: este link não autentica ninguém — quem o abre já está
+    // logado e só reprova que é quem diz ser. Prometer "entre na sua conta" num
+    // e-mail que não faz login é o tipo de erro que ensina o usuário a clicar em
+    // qualquer link de "acesso" que chegue.
+    'mail.sudo_link.subject': 'Confirm it is you',
+    'mail.sudo_link.heading': 'Confirm your identity',
+    'mail.sudo_link.intro': 'You asked to confirm your identity before a sensitive account action. Click the button below to continue. The link expires in 5 minutes, can be used once and only works in the browser that requested it.',
+    'mail.sudo_link.cta': 'Confirm identity',
+    'mail.sudo_link.fallback': 'If you did not request this, you can ignore this email — nothing was changed.',
     'mail.new_login.subject': 'New login to your account',
     'mail.new_login.heading': 'New login detected',
     'mail.new_login.intro': 'We detected a new login to your account.',
@@ -1365,6 +1375,12 @@ export const PT_BR_MESSAGES = {
     'mail.magic_link.code_subject': 'Seu código de login',
     'mail.magic_link.code_intro': 'Use o código abaixo para entrar. Ele expira em instantes e serve para um único acesso.',
     'mail.magic_link.code_only_label': 'Digite este código para entrar:',
+    // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo) — ver o comentário no catálogo `en`.
+    'mail.sudo_link.subject': 'Confirme que é você',
+    'mail.sudo_link.heading': 'Confirme sua identidade',
+    'mail.sudo_link.intro': 'Você pediu para confirmar sua identidade antes de uma ação sensível da conta. Clique no botão abaixo para continuar. O link expira em 5 minutos, serve uma única vez e só funciona no navegador que o pediu.',
+    'mail.sudo_link.cta': 'Confirmar identidade',
+    'mail.sudo_link.fallback': 'Se você não solicitou isso, pode ignorar este e-mail — nada mudou.',
     'mail.new_login.subject': 'Novo login na sua conta',
     'mail.new_login.heading': 'Novo login detectado',
     'mail.new_login.intro': 'Detectamos um novo login na sua conta.',

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

@@ -1,4 +1,4 @@
-import type { AuthAccount } from '../accounts/account_store.js';
+import type { AccountStore, AuthAccount } from '../accounts/account_store.js';
 import type { AuditSink } from '../audit/audit_sink.js';
 import type { ResolvedServerConfig } from '../define_config.js';
 import type { SettingsCapability } from './runtime_settings.js';
@@ -23,7 +23,7 @@ export declare function isEmailUnverifiedBlock(cfg: ResolvedServerConfig, accoun
  *
  * @returns true se a senha expirou e deve ser trocada antes de completar o login.
  */
-export declare function isPasswordExpired(cfg: ResolvedServerConfig, accountId: string, settings: SettingsCapability): Promise<boolean>;
+export declare function isPasswordExpired(cfg: Pick<ResolvedServerConfig, 'accountStore'>, accountId: string, settings: SettingsCapability): Promise<boolean>;
 /**
  * Verifica se a conta está expirada por inatividade (account_expiration setting).
  *
@@ -43,6 +43,92 @@ export declare function isAccountExpired(audit: AuditSink | null | undefined, ac
 export interface LoginAttemptLogger {
     warn(obj: unknown, msg?: string): void;
 }
+/**
+ * Motivo pelo qual um login foi recusado no gate de status de conta,
+ * compartilhado por TODOS os fluxos de login (senha, magic link, OTP,
+ * passkey, social, token-exchange/impersonation) — não só o de senha.
+ */
+export type AccountStatusReason = 'disabled' | 'password_expired' | 'account_expired';
+/** Resultado do gate de status de conta. Discriminado por `allowed`. */
+export type LoginAllowedResult = {
+    allowed: true;
+} | {
+    allowed: false;
+    reason: AccountStatusReason;
+};
+/**
+ * Subconjunto de {@link ResolvedServerConfig} que o gate de status precisa: o
+ * accountStore (para as capacidades opcionais) e o audit sink (para os
+ * `login.failure`/`password.expired_change_forced`/`account.expired_login_blocked`
+ * emitidos). Estrutural — qualquer `ResolvedServerConfig` serve aqui sem cast;
+ * chamadores fora do host (ex.: `token_exchange.ts`, que não tem o
+ * `ResolvedServerConfig` inteiro em mãos) podem montar só este pedaço.
+ */
+export interface LoginAllowedConfig {
+    accountStore: AccountStore;
+    audit?: AuditSink;
+}
+/** Entrada comum aos dois gates de status (`assertAccountEnabled`/`assertAccountNotExpired`). */
+export interface LoginAllowedInput {
+    email: string;
+    ip: string | null;
+    /** `clientId` só entra no evento de auditoria quando o fluxo o fornece (mesma regra do resto do arquivo). */
+    clientId?: string | null;
+    /** Ausente → password-expiry/account-expiry ficam no-op (precisam da runtime setting). */
+    settings?: SettingsCapability;
+    /**
+     * `true` → o chamador declara ser um fluxo SEM senha, e a checagem de senha
+     * vencida (`password_expiration`) é pulada. A de conta expirada por
+     * inatividade (`account_expiration`) continua valendo normalmente.
+     *
+     * Existe porque a expiração de senha pressupõe duas coisas: que a conta TEM
+     * senha, e que o fluxo tem um passo de troca obrigatória para onde mandar o
+     * usuário. `isPasswordExpired` trata `password_changed_at` NULL como vencida
+     * (seguro no fluxo de senha, que força a troca na 1ª vez) — num fluxo que não
+     * tem nenhuma das duas, isso recusa contas que nunca tiveram senha e não lhes
+     * oferece saída alguma.
+     *
+     * Default (ausente/`false`) = a checagem se aplica.
+     */
+    passwordless?: boolean;
+    logger?: LoginAttemptLogger;
+}
+/**
+ * Gate 1/2: conta desabilitada. Extraído de {@link attemptPasswordLogin}
+ * (bloco `isDisabled` original) para ser reutilizável por TODO fluxo que
+ * finaliza um login (`completeLogin`), não só o de senha.
+ *
+ * Capability-probed via `supportsAccountStatus` — store sem a capacidade
+ * degrada para "allowed" (comportamento preservado exatamente).
+ */
+export declare function assertAccountEnabled(cfg: LoginAllowedConfig, accountId: string, input: LoginAllowedInput): Promise<LoginAllowedResult>;
+/**
+ * Gate 2/2: senha vencida (password_expiration) e conta expirada por
+ * inatividade (account_expiration). Extraído dos blocos originais de
+ * {@link attemptPasswordLogin} que seguiam o gate de e-mail não verificado.
+ *
+ * Capability/setting-probed: sem `input.settings`, ambas as checagens são
+ * no-op (mesma guarda `if (input.settings)` do código original).
+ *
+ * `input.passwordless === true` pula APENAS a checagem de senha vencida — ver
+ * {@link LoginAllowedInput.passwordless}. A expiração por inatividade continua.
+ */
+export declare function assertAccountNotExpired(cfg: LoginAllowedConfig, accountId: string, input: LoginAllowedInput): Promise<LoginAllowedResult>;
+/**
+ * Gate combinado (disabled → password_expired → account_expired), na ordem
+ * canônica. É o que os fluxos passwordless (magic link, OTP, passkey, social)
+ * e o token-exchange (impersonation) chamam UMA VEZ, imediatamente antes de
+ * `completeLogin` — eles não têm o gate de e-mail-não-verificado intercalado
+ * entre o disabled-check e os expiry-checks como `attemptPasswordLogin` tem,
+ * então uma chamada única e sequencial é observacionalmente idêntica a chamar
+ * os dois gates separados nessa ordem.
+ *
+ * `attemptPasswordLogin` NÃO usa este combinado — chama `assertAccountEnabled`
+ * e `assertAccountNotExpired` separadamente, com o gate de e-mail não
+ * verificado (`isEmailUnverifiedBlock`) intercalado entre os dois, para
+ * preservar a ordem de checagens original byte-a-byte.
+ */
+export declare function assertLoginAllowed(cfg: LoginAllowedConfig, accountId: string, input: LoginAllowedInput): Promise<LoginAllowedResult>;
 /** Entrada de uma tentativa de login por senha (keyed por email). */
 export interface PasswordLoginInput {
     email: string;

package/build/src/host/login_attempt.js

@@ -124,6 +124,83 @@ export async function isAccountExpired(audit, accountId, settings, logger) {
         return false;
     }
 }
+/**
+ * Gate 1/2: conta desabilitada. Extraído de {@link attemptPasswordLogin}
+ * (bloco `isDisabled` original) para ser reutilizável por TODO fluxo que
+ * finaliza um login (`completeLogin`), não só o de senha.
+ *
+ * Capability-probed via `supportsAccountStatus` — store sem a capacidade
+ * degrada para "allowed" (comportamento preservado exatamente).
+ */
+export async function assertAccountEnabled(cfg, accountId, input) {
+    const { email, ip, clientId } = input;
+    if (supportsAccountStatus(cfg.accountStore) && (await cfg.accountStore.isDisabled(accountId))) {
+        await cfg.audit?.record(clientId !== undefined
+            ? {
+                type: 'login.failure',
+                email,
+                ip,
+                clientId,
+                metadata: { reason: 'disabled' },
+            }
+            : { type: 'login.failure', email, ip, metadata: { reason: 'disabled' } });
+        return { allowed: false, reason: 'disabled' };
+    }
+    return { allowed: true };
+}
+/**
+ * Gate 2/2: senha vencida (password_expiration) e conta expirada por
+ * inatividade (account_expiration). Extraído dos blocos originais de
+ * {@link attemptPasswordLogin} que seguiam o gate de e-mail não verificado.
+ *
+ * Capability/setting-probed: sem `input.settings`, ambas as checagens são
+ * no-op (mesma guarda `if (input.settings)` do código original).
+ *
+ * `input.passwordless === true` pula APENAS a checagem de senha vencida — ver
+ * {@link LoginAllowedInput.passwordless}. A expiração por inatividade continua.
+ */
+export async function assertAccountNotExpired(cfg, accountId, input) {
+    const { email, ip, clientId, settings, logger } = input;
+    if (settings && input.passwordless !== true) {
+        const expired = await isPasswordExpired(cfg, accountId, settings);
+        if (expired) {
+            await cfg.audit?.record(clientId !== undefined
+                ? { type: 'password.expired_change_forced', accountId, email, ip, clientId }
+                : { type: 'password.expired_change_forced', accountId, email, ip });
+            return { allowed: false, reason: 'password_expired' };
+        }
+    }
+    if (settings) {
+        const expired = await isAccountExpired(cfg.audit, accountId, settings, logger);
+        if (expired) {
+            await cfg.audit?.record(clientId !== undefined
+                ? { type: 'account.expired_login_blocked', accountId, email, ip, clientId }
+                : { type: 'account.expired_login_blocked', accountId, email, ip });
+            return { allowed: false, reason: 'account_expired' };
+        }
+    }
+    return { allowed: true };
+}
+/**
+ * Gate combinado (disabled → password_expired → account_expired), na ordem
+ * canônica. É o que os fluxos passwordless (magic link, OTP, passkey, social)
+ * e o token-exchange (impersonation) chamam UMA VEZ, imediatamente antes de
+ * `completeLogin` — eles não têm o gate de e-mail-não-verificado intercalado
+ * entre o disabled-check e os expiry-checks como `attemptPasswordLogin` tem,
+ * então uma chamada única e sequencial é observacionalmente idêntica a chamar
+ * os dois gates separados nessa ordem.
+ *
+ * `attemptPasswordLogin` NÃO usa este combinado — chama `assertAccountEnabled`
+ * e `assertAccountNotExpired` separadamente, com o gate de e-mail não
+ * verificado (`isEmailUnverifiedBlock`) intercalado entre os dois, para
+ * preservar a ordem de checagens original byte-a-byte.
+ */
+export async function assertLoginAllowed(cfg, accountId, input) {
+    const enabled = await assertAccountEnabled(cfg, accountId, input);
+    if (!enabled.allowed)
+        return enabled;
+    return assertAccountNotExpired(cfg, accountId, input);
+}
 /**
  * Sequência canônica de login por senha + bloqueio progressivo, compartilhada
  * pelos dois fluxos que pedem senha (interaction OIDC e console de conta):
@@ -165,17 +242,14 @@ export async function attemptPasswordLogin(cfg, input) {
     // Conta desabilitada: rejeita o login (mesmo com senha correta). A capacidade é
     // opcional — só checada quando o store a implementa. Emite `login.failure` (com
     // motivo `disabled` no metadata) e NÃO registra falha no lockout (não é tentativa
-    // de adivinhar senha).
-    if (supportsAccountStatus(cfg.accountStore) && (await cfg.accountStore.isDisabled(account.id))) {
-        await cfg.audit?.record(input.clientId !== undefined
-            ? {
-                type: 'login.failure',
-                email,
-                ip,
-                clientId: input.clientId,
-                metadata: { reason: 'disabled' },
-            }
-            : { type: 'login.failure', email, ip, metadata: { reason: 'disabled' } });
+    // de adivinhar senha). Extraído em `assertAccountEnabled` — reutilizado por TODO
+    // fluxo de login (magic link, OTP, passkey, social, token-exchange), não só este.
+    const enabledCheck = await assertAccountEnabled(cfg, account.id, {
+        email,
+        ip,
+        clientId: input.clientId,
+    });
+    if (!enabledCheck.allowed) {
         return { ok: false, locked: false, disabled: true };
     }
     // E-mail não verificado (LGPD/compliance): rejeita o login se a política exige
@@ -194,45 +268,24 @@ export async function attemptPasswordLogin(cfg, input) {
             : { type: 'login.failure', email, ip, metadata: { reason: 'unverified' } });
         return { ok: false, locked: false, unverified: true };
     }
-    // Senha expirada (password expiration): se a senha está vencida, sinaliza ao
-    // controller para forçar a troca ANTES de completar o login.
-    // Capability-probed: sem `getPasswordChangedAt` ou sem a setting → no-op.
-    if (input.settings) {
-        const expired = await isPasswordExpired(cfg, account.id, input.settings);
-        if (expired) {
-            // Não é uma falha de credenciais — limpa o contador.
-            await lockout.clearFailures(email);
-            await cfg.audit?.record(input.clientId !== undefined
-                ? {
-                    type: 'password.expired_change_forced',
-                    accountId: account.id,
-                    email,
-                    ip,
-                    clientId: input.clientId,
-                }
-                : { type: 'password.expired_change_forced', accountId: account.id, email, ip });
+    // Senha expirada (password expiration) e conta expirada por inatividade
+    // (account_expiration): extraído em `assertAccountNotExpired`, na mesma ordem
+    // e com os mesmos eventos de auditoria do código original. Capability/setting
+    // -probed internamente (sem `input.settings` → no-op, como antes).
+    const expiryCheck = await assertAccountNotExpired(cfg, account.id, {
+        email,
+        ip,
+        clientId: input.clientId,
+        settings: input.settings,
+        logger: input.logger,
+    });
+    if (!expiryCheck.allowed) {
+        // Nenhuma das duas é falha de credenciais — limpa o contador.
+        await lockout.clearFailures(email);
+        if (expiryCheck.reason === 'password_expired') {
             return { ok: false, locked: false, passwordExpired: true, account: account };
         }
-    }
-    // Conta expirada por inatividade (account_expiration setting): bloqueia o login
-    // se a conta não teve login.success há mais de `inactiveDays` dias (via audit).
-    // Capability-probed: sem audit.list ou sem setting → no-op.
-    // Reativação: fluxo de reset de senha (link exibido pelo controller na mensagem).
-    if (input.settings) {
-        const expired = await isAccountExpired(cfg.audit, account.id, input.settings, input.logger);
-        if (expired) {
-            await lockout.clearFailures(email);
-            await cfg.audit?.record(input.clientId !== undefined
-                ? {
-                    type: 'account.expired_login_blocked',
-                    accountId: account.id,
-                    email,
-                    ip,
-                    clientId: input.clientId,
-                }
-                : { type: 'account.expired_login_blocked', accountId: account.id, email, ip });
-            return { ok: false, locked: false, accountExpired: true };
-        }
+        return { ok: false, locked: false, accountExpired: true };
     }
     // Senha correta: limpa o contador de falhas (o lockout protege a etapa de senha).
     await lockout.clearFailures(email);

package/build/src/host/login_notify.js

@@ -98,7 +98,7 @@ async function notifyNewDevice(ctx, cfg, data) {
         });
         return;
     }
-    await sendNewDeviceLoginEmail(ctx, {
+    await sendNewDeviceLoginEmail(ctx, cfg, {
         email: data.email,
         ip: data.ip,
         userAgent: data.userAgent,
@@ -132,7 +132,7 @@ async function maybeNotifyNewLogin(ctx, cfg, data) {
     if (sameIpCount > 1)
         return;
     const when = new Date().toISOString();
-    await sendNewLoginEmail(ctx, { email, ip, when });
+    await sendNewLoginEmail(ctx, cfg, { email, ip, when });
     await cfg.audit?.record({
         type: 'login.new_ip_notified',
         accountId,

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

@@ -0,0 +1,112 @@
+import type { symbols } from '@adonisjs/auth';
+import type { AuthClientResponse, GuardConfigProvider, GuardContract } from '@adonisjs/auth/types';
+import type { SessionUserProviderContract } from '@adonisjs/auth/types/session';
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ConfigProvider } from '@adonisjs/core/types';
+import type { EmitterLike } from '@adonisjs/core/types/events';
+type RealUser<UserProvider> = UserProvider extends SessionUserProviderContract<infer U> ? U : never;
+/**
+ * Construtor do `E_UNAUTHORIZED_ACCESS` do `@adonisjs/auth` — a MESMA classe que
+ * os guards nativos lançam (`static status = 401`, `redirectTo`, renderers
+ * html/json/jsonapi). Tipado à mão porque o pacote não pode ser importado
+ * estaticamente daqui (peer opcional).
+ */
+export type UnauthorizedAccessConstructor = new (message: string, options: {
+    guardDriverName: string;
+    redirectTo?: string;
+}) => Error;
+/**
+ * Captura o `E_UNAUTHORIZED_ACCESS` real do `@adonisjs/auth` sem import
+ * estático. Chamado no boot pelo {@link oidcRpGuard} (falha cedo e com uma
+ * mensagem útil se o peer não estiver instalado) e, como rede de segurança, na
+ * primeira `authenticate()` de um guard construído à mão.
+ */
+export declare function loadUnauthorizedAccess(): Promise<UnauthorizedAccessConstructor>;
+export type OidcRpGuardOptions<UserProvider extends SessionUserProviderContract<unknown>> = {
+    provider: UserProvider | ConfigProvider<UserProvider>;
+    sessionKey?: string;
+};
+export type OidcRpGuardEvents<User> = {
+    'oidc_rp:login_succeeded': {
+        ctx: HttpContext;
+        guardName: string;
+        user: User;
+    };
+    'oidc_rp:authentication_succeeded': {
+        ctx: HttpContext;
+        guardName: string;
+        user: User;
+    };
+    'oidc_rp:authentication_failed': {
+        ctx: HttpContext;
+        guardName: string;
+    };
+    'oidc_rp:logged_out': {
+        ctx: HttpContext;
+        guardName: string;
+        user: User | null;
+    };
+};
+/**
+ * Guard de `@adonisjs/auth` pra Relying Parties OIDC — o app não autentica
+ * ninguém (sem senha, sem remember-me); a identidade vem da sessão gravada
+ * pelo callback OIDC (`account_user_id`). O guard só LÊ essa chave e resolve
+ * o user via provider.
+ *
+ * ```ts
+ * // config/auth.ts
+ * import { oidcRpGuard } from '@adonis-agora/authkit-server'
+ * import { sessionUserProvider } from '@adonisjs/auth/session'
+ *
+ * const authConfig = defineConfig({
+ *   default: 'web',
+ *   guards: {
+ *     web: oidcRpGuard({
+ *       provider: sessionUserProvider({ model: () => import('#models/user') }),
+ *     }),
+ *   },
+ * })
+ * ```
+ *
+ * O callback OIDC do RP chama `ctx.auth.use('web').login(user)` pra gravar a
+ * sessão; a partir daí `ctx.auth.user`, `auth.check()`, `middleware.auth()` —
+ * tudo funciona nativamente.
+ */
+export declare class OidcRpGuard<UserProvider extends SessionUserProviderContract<unknown>> implements GuardContract<RealUser<UserProvider>> {
+    #private;
+    [symbols.GUARD_KNOWN_EVENTS]: OidcRpGuardEvents<RealUser<UserProvider>>;
+    driverName: "oidc_rp";
+    authenticationAttempted: boolean;
+    isAuthenticated: boolean;
+    isLoggedOut: boolean;
+    user?: RealUser<UserProvider>;
+    constructor(name: string, ctx: HttpContext, sessionKey: string, emitter: EmitterLike<OidcRpGuardEvents<RealUser<UserProvider>>>, userProvider: UserProvider, unauthorized?: UnauthorizedAccessConstructor);
+    getUserOrFail(): RealUser<UserProvider>;
+    /**
+     * Grava a identidade na sessão. Chamado pelo callback OIDC após validar o
+     * grant — o guard NÃO verifica credenciais, só persiste o id do user.
+     */
+    login(user: RealUser<UserProvider>): Promise<void>;
+    /**
+     * Limpa a identidade da sessão. O RP-initiated logout (redirect pro
+     * `end_session` do issuer) é responsabilidade do controller — o guard só
+     * cuida da sessão local.
+     */
+    logout(): Promise<void>;
+    authenticate(): Promise<RealUser<UserProvider>>;
+    /**
+     * `authenticate()` sem lançar — mas SÓ para falha de autenticação. Igual ao
+     * `SessionGuard` nativo: engole apenas `E_UNAUTHORIZED_ACCESS` e relança o
+     * resto. Um `catch` cego aqui transformava uma queda do banco dentro de
+     * `provider.findById` em "não logado" para todo mundo, sem nada nos logs.
+     */
+    check(): Promise<boolean>;
+    authenticateAsClient(user: RealUser<UserProvider>): Promise<AuthClientResponse>;
+}
+/**
+ * Factory de config pro `oidcRpGuard` — mesmo padrão do `sessionGuard()` de
+ * `@adonisjs/auth/session`. Retorna um `GuardConfigProvider` que o
+ * `defineConfig` de `config/auth.ts` resolve no boot.
+ */
+export declare function oidcRpGuard<UserProvider extends SessionUserProviderContract<unknown>>(config: OidcRpGuardOptions<UserProvider>): GuardConfigProvider<(ctx: HttpContext) => OidcRpGuard<UserProvider>>;
+export {};