@dudousxd/adonis-authkit-server 0.3.0 → 0.5.0

package/build/src/host/controllers/admin/admin_sessions_controller.js

@@ -0,0 +1,64 @@
+import '../../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../../middleware/account_auth.js';
+import { AdminSessionsService } from '../../admin_sessions_service.js';
+/**
+ * Inspeção/revogação das sessões e grants ativos de uma conta no console admin.
+ * Lista as `Session` (logins do IdP) + os `Grant` (autorizações por client) da
+ * conta, com a contagem de access/refresh tokens por grant. Degrada graciosamente
+ * quando o adapter OIDC não enumera (`list`), espelhando o CRUD de clients.
+ */
+export default class AdminSessionsController {
+    /** GET /admin/users/:id/sessions — lista sessões + grants da conta. */
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const accountId = ctx.request.param('id');
+        const account = await cfg.accountStore.findById(accountId);
+        const sessions = new AdminSessionsService(service);
+        const supported = sessions.canList;
+        const sessionList = supported ? await sessions.listSessions(accountId) : [];
+        const grantList = supported ? await sessions.listGrants(accountId) : [];
+        const revoked = ctx.session.flashMessages.get('sessionsRevoked');
+        return render(ctx, 'admin/sessions', {
+            csrfToken: ctx.request.csrfToken,
+            supported,
+            accountId,
+            email: account?.email ?? '',
+            revoked: revoked ?? null,
+            sessions: sessionList.map((s) => ({
+                id: s.id,
+                loginTs: s.loginTs ? new Date(s.loginTs * 1000).toISOString() : '',
+                amr: (s.amr ?? []).join(', '),
+            })),
+            grants: grantList.map((g) => ({
+                id: g.id,
+                clientId: g.clientId ?? '',
+                accessTokens: g.accessTokens,
+                refreshTokens: g.refreshTokens,
+            })),
+        });
+    }
+    /** POST /admin/users/:id/revoke-sessions — destrói sessões + grants da conta. */
+    async revoke(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const accountId = ctx.request.param('id');
+        const sessions = new AdminSessionsService(service);
+        const result = await sessions.revokeAll(accountId);
+        await cfg.audit?.record({
+            type: 'session.revoked_all',
+            accountId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: {
+                sessions: result.sessions,
+                grants: result.grants,
+                accessTokens: result.accessTokens,
+                refreshTokens: result.refreshTokens,
+            },
+        });
+        ctx.session.flash('sessionsRevoked', result);
+        return ctx.response.redirect(`/admin/users/${accountId}/sessions`);
+    }
+}

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

@@ -19,6 +19,17 @@ export default class AuthInteractionController {
      * OU um recovery code (`recoveryCode`). Em caso de sucesso finaliza a interaction.
      */
     mfaVerify(ctx: HttpContext): Promise<any>;
+    /**
+     * true se o authorize request exige MFA via acr_values (contém o mfaAcr da
+     * config de step-up). `acr_values` é a string separada por espaços padrão OIDC.
+     */
+    private acrRequiresMfa;
+    /**
+     * Monta o acr/amr do step-up quando o client solicitou o mfaAcr e um 2º fator
+     * foi verificado. `method` é o método do segundo fator (totp/recovery/webauthn).
+     * Retorna `undefined` quando não há step-up — completeLogin usa o default.
+     */
+    private stepUpExtra;
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     private hasPasskeys;
     /**

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

@@ -2,6 +2,7 @@ import '../augmentations.js';
 import { brandFor, isFirstParty } from '../branding.js';
 import { translate } from '../i18n.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
+import { notifyLoginSuccess } from '../login_notify.js';
 import { supportsPasskeys } from '../../accounts/account_store.js';
 const SESSION_KEY = 'authkit_login_email';
 /** accountId aguardando o 2º fator depois da senha verificada. */
@@ -106,10 +107,25 @@ export default class AuthInteractionController {
             });
         }
         const acc = result.account;
-        // MFA gate: se a conta tem TOTP ativo, NÃO finaliza a interaction agora —
-        // guarda o accountId pendente na sessão e renderiza o desafio do 2º fator.
+        // Step-up auth (acr_values): o client pode EXIGIR MFA nesta requisição
+        // solicitando o `mfaAcr` em acr_values, mesmo que a conta tenha MFA opcional.
+        const mfaRequired = this.acrRequiresMfa(cfg, details);
+        // MFA gate: força o 2º fator se a conta tem TOTP ativo OU se o client exige MFA
+        // via acr. Não finaliza a interaction agora — guarda o accountId pendente.
         const mfa = (await cfg.accountStore.getMfaState?.(acc.id)) ?? { enabled: false };
-        if (mfa.enabled) {
+        if (mfa.enabled || mfaRequired) {
+            if (mfaRequired && !mfa.enabled) {
+                // Client exige MFA mas a conta não tem MFA enrolado: bloqueia este login
+                // com a instrução de configurar MFA no console (não há 2º fator a desafiar).
+                return render(ctx, 'mfa-challenge', {
+                    uid: ctx.request.param('uid'),
+                    csrfToken: ctx.request.csrfToken,
+                    brand,
+                    passkeyAvailable: false,
+                    error: translate(cfg.messages, 'mfa_challenge.required_no_enrollment'),
+                    noEnrollment: true,
+                });
+            }
             ctx.session.put(MFA_PENDING_KEY, acc.id);
             // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
             // tem ao menos uma credencial registrada.
@@ -123,7 +139,7 @@ export default class AuthInteractionController {
         }
         // Sem MFA: finaliza a interaction (escreve o 303 de volta para o client).
         await service.interactions.completeLogin(ctx, acc.id);
-        await cfg.audit?.record({ type: 'login.success', accountId: acc.id, email, ip, clientId });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip, clientId });
         // Clean up the session key after a successful login.
         ctx.session.forget(SESSION_KEY);
     }
@@ -174,14 +190,38 @@ export default class AuthInteractionController {
         // Sucesso no 2º fator: finaliza a interaction para o accountId pendente.
         ctx.session.forget(MFA_PENDING_KEY);
         ctx.session.forget(SESSION_KEY);
-        await cfg.audit?.record({
-            type: 'login.success',
+        await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
             clientId,
             metadata: { mfa: usedRecovery ? 'recovery' : 'totp' },
         });
-        await service.interactions.completeLogin(ctx, accountId);
+        // Step-up: um 2º fator foi de fato verificado — carimba acr/amr no id_token
+        // se o client solicitou o mfaAcr nesta requisição.
+        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, usedRecovery ? 'recovery' : 'totp'));
+    }
+    /**
+     * true se o authorize request exige MFA via acr_values (contém o mfaAcr da
+     * config de step-up). `acr_values` é a string separada por espaços padrão OIDC.
+     */
+    acrRequiresMfa(cfg, details) {
+        const mfaAcr = cfg.stepUp?.mfaAcr;
+        if (!mfaAcr)
+            return false;
+        const raw = details?.params?.acr_values;
+        if (typeof raw !== 'string' || !raw)
+            return false;
+        return raw.split(/\s+/).includes(mfaAcr);
+    }
+    /**
+     * Monta o acr/amr do step-up quando o client solicitou o mfaAcr e um 2º fator
+     * foi verificado. `method` é o método do segundo fator (totp/recovery/webauthn).
+     * Retorna `undefined` quando não há step-up — completeLogin usa o default.
+     */
+    stepUpExtra(cfg, details, method) {
+        if (!this.acrRequiresMfa(cfg, details))
+            return undefined;
+        return { acr: cfg.stepUp.mfaAcr, amr: ['mfa', method] };
     }
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     async hasPasskeys(cfg, accountId) {
@@ -200,11 +240,15 @@ export default class AuthInteractionController {
         const cfg = service.config;
         const accountId = ctx.session.get(MFA_PENDING_KEY);
         if (!accountId) {
-            return ctx.response.badRequest({ message: 'Sessão expirada' });
+            return ctx.response.badRequest({
+                message: translate(cfg.messages, 'errors.session_expired'),
+            });
         }
         const generated = await cfg.accountStore.generatePasskeyAuthenticationOptions?.(accountId);
         if (!generated) {
-            return ctx.response.notFound({ message: 'Nenhuma passkey registrada' });
+            return ctx.response.notFound({
+                message: translate(cfg.messages, 'errors.no_passkey_registered'),
+            });
         }
         ctx.session.put(PASSKEY_AUTH_CHALLENGE_KEY, generated.challenge);
         return generated.options;
@@ -261,14 +305,13 @@ export default class AuthInteractionController {
         }
         ctx.session.forget(MFA_PENDING_KEY);
         ctx.session.forget(SESSION_KEY);
-        await cfg.audit?.record({
-            type: 'login.success',
+        await notifyLoginSuccess(ctx, cfg, {
             accountId,
             ip,
             clientId,
             metadata: { mfa: 'webauthn' },
         });
-        await service.interactions.completeLogin(ctx, accountId);
+        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, 'webauthn'));
     }
     /**
      * GET /auth/interaction/:uid/switch

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

@@ -28,6 +28,23 @@ export declare function sendPasswordResetEmail(ctx: HttpContext, data: {
     email: string;
     resetUrl: string;
 }): Promise<void>;
+/**
+ * Envia o e-mail de confirmação de TROCA de e-mail para o NOVO endereço.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export declare function sendEmailChangeConfirmationEmail(ctx: HttpContext, data: {
+    email: string;
+    confirmUrl: string;
+}): Promise<void>;
+/**
+ * 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: {
+    email: string;
+    ip: string;
+    when: string;
+}): Promise<void>;
 /**
  * Envia o e-mail de verificação pelo mailer default do host.
  * Best-effort: no fallback (sem mail) loga o link; nunca lança.

package/build/src/host/default_mailer.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { renderTransactionalEmail } from './email_templates.js';
+import { resolveMessages, translate, } from './i18n.js';
 let mailServicePromise;
 /**
  * Importa o service de mail do HOST de forma preguiçosa e fail-safe.
@@ -78,6 +79,22 @@ function resolveBrand(ctx) {
     }
     return { appName: 'AuthKit' };
 }
+/**
+ * Resolve o catálogo de mensagens i18n a partir do `config/authkit.ts` (i18n).
+ * Cai no default (`en`) se a config não for resolvível. Usado para localizar
+ * os e-mails transacionais (assunto/cabeçalho/corpo).
+ */
+function resolveMailMessages(ctx) {
+    try {
+        const resolver = ctx.containerResolver;
+        const i18n = resolver.app?.config?.get?.('authkit')?.i18n;
+        return { messages: resolveMessages(i18n), locale: i18n?.locale ?? 'en' };
+    }
+    catch {
+        // sem config authkit resolvível — usa o default `en`.
+        return { messages: resolveMessages(), locale: 'en' };
+    }
+}
 async function sendEmail(ctx, to, content) {
     const mail = await loadMail();
     if (!mail)
@@ -97,14 +114,17 @@ async function sendEmail(ctx, to, content) {
 export async function sendPasswordResetEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Redefinição de senha',
-            heading: 'Redefinição de senha',
-            intro: `Recebemos um pedido para redefinir a senha da sua conta em ${brand.appName}. Clique no botão abaixo para escolher uma nova senha. Se não foi você, ignore este e-mail.`,
-            ctaLabel: 'Redefinir senha',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.reset.subject'),
+            heading: translate(t, 'mail.reset.heading'),
+            intro: translate(t, 'mail.reset.intro'),
+            ctaLabel: translate(t, 'mail.reset.cta'),
             ctaUrl: data.resetUrl,
-            footnote: 'Por segurança, este link expira em breve e só pode ser usado uma vez.',
+            footnote: translate(t, 'mail.reset.fallback'),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
@@ -115,6 +135,68 @@ export async function sendPasswordResetEmail(ctx, data) {
         ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar e-mail de redefinição de senha');
     }
 }
+/**
+ * Envia o e-mail de confirmação de TROCA de e-mail para o NOVO endereço.
+ * Best-effort: no fallback (sem mail) loga o link; nunca lança.
+ */
+export async function sendEmailChangeConfirmationEmail(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.email_change.subject'),
+            heading: translate(t, 'mail.email_change.heading'),
+            intro: translate(t, 'mail.email_change.intro'),
+            ctaLabel: translate(t, 'mail.email_change.cta'),
+            ctaUrl: data.confirmUrl,
+            footnote: translate(t, 'mail.email_change.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ confirmUrl: data.confirmUrl, email: data.email }, 'authkit: link de confirmação de troca de e-mail (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar confirmação de troca de e-mail');
+    }
+}
+/**
+ * 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) {
+    try {
+        const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const intro = [
+            translate(t, 'mail.new_login.intro'),
+            translate(t, 'mail.new_login.when', { date: data.when }),
+            translate(t, 'mail.new_login.ip', { ip: data.ip }),
+        ].join(' ');
+        const content = renderTransactionalEmail({
+            brand,
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.new_login.subject'),
+            heading: translate(t, 'mail.new_login.heading'),
+            intro,
+            ctaLabel: translate(t, 'account.security.title'),
+            ctaUrl: `${origin}/account/security`,
+            footnote: translate(t, 'mail.new_login.fallback'),
+        });
+        const sent = await sendEmail(ctx, data.email, content);
+        if (!sent) {
+            ctx.logger.info({ ip: data.ip, email: data.email }, 'authkit: alerta de novo acesso (dev — @adonisjs/mail ausente)');
+        }
+    }
+    catch (error) {
+        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar alerta de novo acesso');
+    }
+}
 /**
  * Envia o e-mail de verificação pelo mailer default do host.
  * Best-effort: no fallback (sem mail) loga o link; nunca lança.
@@ -122,12 +204,15 @@ export async function sendPasswordResetEmail(ctx, data) {
 export async function sendEmailVerificationEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
+        const { messages: t, locale } = resolveMailMessages(ctx);
         const content = renderTransactionalEmail({
             brand,
-            subject: 'Verifique seu e-mail',
-            heading: 'Confirme seu e-mail',
-            intro: `Bem-vindo(a) ao ${brand.appName}! Confirme seu endereço de e-mail clicando no botão abaixo para ativar sua conta.`,
-            ctaLabel: 'Verificar e-mail',
+            locale,
+            linkFallback: translate(t, 'mail.common.link_fallback'),
+            subject: translate(t, 'mail.verify.subject'),
+            heading: translate(t, 'mail.verify.heading'),
+            intro: translate(t, 'mail.verify.intro'),
+            ctaLabel: translate(t, 'mail.verify.cta'),
             ctaUrl: data.verifyUrl,
         });
         const sent = await sendEmail(ctx, data.email, content);

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

@@ -30,6 +30,10 @@ interface EmailTemplateInput {
     ctaUrl: string;
     /** Linha auxiliar abaixo do botão (ex.: validade do link). */
     footnote?: string;
+    /** Texto que precede o link de fallback (i18n). Default em inglês. */
+    linkFallback?: string;
+    /** Locale do documento HTML (atributo `lang`). Default: 'en'. */
+    locale?: string;
 }
 export declare function renderTransactionalEmail(input: EmailTemplateInput): EmailContent;
 export {};

package/build/src/host/email_templates.js

@@ -21,8 +21,11 @@ export function renderTransactionalEmail(input) {
     const accent = input.brand.accent || FALLBACK_ACCENT;
     const company = input.brand.company || appName;
     const year = '©'; // ano resolvido fora (sem Date.* aqui); rodapé usa só o nome.
+    const lang = input.locale || 'en';
+    const linkFallback = input.linkFallback ||
+        'If the button does not work, copy and paste this link into your browser:';
     const html = `<!doctype html>
-<html lang="pt-BR">
+<html lang="${esc(lang)}">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -42,7 +45,7 @@ export function renderTransactionalEmail(input) {
 <a href="${esc(input.ctaUrl)}" style="display:inline-block;padding:12px 24px;font-size:15px;font-weight:600;color:#ffffff;text-decoration:none;border-radius:8px;">${esc(input.ctaLabel)}</a>
 </td></tr></table>
 ${input.footnote ? `<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">${esc(input.footnote)}</p>` : ''}
-<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">Se o botão não funcionar, copie e cole este link no navegador:<br><a href="${esc(input.ctaUrl)}" style="color:${esc(accent)};word-break:break-all;">${esc(input.ctaUrl)}</a></p>
+<p style="margin:24px 0 0;font-size:13px;line-height:1.5;color:#6b7280;">${esc(linkFallback)}<br><a href="${esc(input.ctaUrl)}" style="color:${esc(accent)};word-break:break-all;">${esc(input.ctaUrl)}</a></p>
 </td></tr>
 <tr><td style="padding:24px 28px 28px;border-top:1px solid #f3f4f6;">
 <p style="margin:0;font-size:12px;line-height:1.5;color:#9ca3af;">${esc(company)} ${year}</p>