@dudousxd/adonis-authkit-server 0.3.0 → 0.4.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) {
@@ -261,14 +301,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

@@ -115,6 +115,57 @@ 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 content = renderTransactionalEmail({
+            brand,
+            subject: 'Confirme seu novo e-mail',
+            heading: 'Confirme seu novo e-mail',
+            intro: `Recebemos um pedido para alterar o e-mail da sua conta em ${brand.appName} para este endereço. Clique no botão abaixo para confirmar a alteração. Se não foi você, ignore este e-mail — nada será alterado.`,
+            ctaLabel: 'Confirmar novo e-mail',
+            ctaUrl: data.confirmUrl,
+            footnote: 'Por segurança, este link expira em breve e só pode ser usado uma vez.',
+        });
+        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 origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const content = renderTransactionalEmail({
+            brand,
+            subject: 'Novo acesso à sua conta',
+            heading: 'Novo acesso à sua conta',
+            intro: `Detectamos um novo acesso à sua conta em ${brand.appName} a partir do IP ${data.ip} em ${data.when}. Se foi você, nenhuma ação é necessária. Se não reconhece este acesso, altere sua senha imediatamente.`,
+            ctaLabel: 'Acessar minha conta',
+            ctaUrl: `${origin}/account/security`,
+            footnote: 'Você está recebendo este alerta porque um login foi feito de um endereço de IP não visto antes.',
+        });
+        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.

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

@@ -90,6 +90,7 @@ export declare const DEFAULT_MESSAGES: {
     'account.tokens.page_title': string;
     'account.tokens.title': string;
     'account.tokens.logout': string;
+    'account.tokens.security': string;
     'account.tokens.created_notice': string;
     'account.tokens.name_placeholder': string;
     'account.tokens.create': string;
@@ -100,6 +101,28 @@ export declare const DEFAULT_MESSAGES: {
     'account.tokens.scopes': string;
     'account.tokens.audience': string;
     'account.tokens.revoke': string;
+    'account.security.page_title': string;
+    'account.security.title': string;
+    'account.security.logout': string;
+    'account.security.current_email': string;
+    'account.security.not_supported': string;
+    'account.security.password_section': string;
+    'account.security.current_password_label': string;
+    'account.security.new_password_label': string;
+    'account.security.change_password_submit': string;
+    'account.security.password_changed': string;
+    'account.security.email_section': string;
+    'account.security.email_intro': string;
+    'account.security.new_email_label': string;
+    'account.security.email_password_label': string;
+    'account.security.change_email_submit': string;
+    'account.security.email_change_requested': string;
+    'account.security.email_changed': string;
+    'account.email_confirmed.page_title': string;
+    'account.email_confirmed.ok_title': string;
+    'account.email_confirmed.ok_body': string;
+    'account.email_confirmed.invalid_title': string;
+    'account.email_confirmed.invalid_body': string;
     'account.mfa.page_title': string;
     'account.mfa.title': string;
     'account.mfa.logout': string;
@@ -140,6 +163,23 @@ export declare const DEFAULT_MESSAGES: {
     'admin.users.empty': string;
     'admin.users.roles_placeholder': string;
     'admin.users.save_roles': string;
+    'admin.users.sessions': string;
+    'admin.sessions.page_title': string;
+    'admin.sessions.title': string;
+    'admin.sessions.account': string;
+    'admin.sessions.back': string;
+    'admin.sessions.not_supported': string;
+    'admin.sessions.revoked_notice': string;
+    'admin.sessions.sessions_section': string;
+    'admin.sessions.sessions_empty': string;
+    'admin.sessions.session_login_ts': string;
+    'admin.sessions.session_amr': string;
+    'admin.sessions.grants_section': string;
+    'admin.sessions.grants_empty': string;
+    'admin.sessions.grant_client': string;
+    'admin.sessions.grant_tokens': string;
+    'admin.sessions.revoke_all': string;
+    'admin.sessions.revoke_confirm': string;
     'admin.clients.page_title': string;
     'admin.clients.title': string;
     'admin.clients.empty': string;
@@ -185,6 +225,19 @@ export declare const DEFAULT_MESSAGES: {
     'admin.pagination.page': string;
     'admin.pagination.prev': string;
     'admin.pagination.next': string;
+    'device.input.title': string;
+    'device.input.intro': string;
+    'device.input.submit': string;
+    'device.input.error_invalid': string;
+    'device.input.error_aborted': string;
+    'device.input.error_generic': string;
+    'device.confirm.title': string;
+    'device.confirm.body': string;
+    'device.confirm.submit': string;
+    'device.confirm.abort': string;
+    'device.success.title': string;
+    'device.success.body': string;
+    'mfa_challenge.required_no_enrollment': string;
     'errors.invalid_credentials': string;
     'errors.invalid_code': string;
     'errors.email_taken': string;

package/build/src/host/i18n.js

@@ -90,6 +90,7 @@ export const DEFAULT_MESSAGES = {
     'account.tokens.page_title': 'Tokens de acesso',
     'account.tokens.title': 'Tokens de acesso',
     'account.tokens.logout': 'Sair',
+    'account.tokens.security': 'Segurança',
     'account.tokens.created_notice': 'Token criado — copie agora, não será mostrado de novo:',
     'account.tokens.name_placeholder': 'Nome do token (ex.: CI deploy)',
     'account.tokens.create': 'Criar',
@@ -100,6 +101,30 @@ export const DEFAULT_MESSAGES = {
     'account.tokens.scopes': 'Escopos: {scopes}',
     'account.tokens.audience': 'Audiência: {audience}',
     'account.tokens.revoke': 'Revogar',
+    // Console de conta — segurança (account/security): senha + e-mail.
+    'account.security.page_title': 'Segurança da conta',
+    'account.security.title': 'Segurança da conta',
+    'account.security.logout': 'Sair',
+    'account.security.current_email': 'E-mail atual: {email}',
+    'account.security.not_supported': 'A troca de senha e e-mail não está disponível nesta instalação.',
+    'account.security.password_section': 'Trocar senha',
+    'account.security.current_password_label': 'Senha atual',
+    'account.security.new_password_label': 'Nova senha',
+    'account.security.change_password_submit': 'Trocar senha',
+    'account.security.password_changed': 'Senha alterada com sucesso.',
+    'account.security.email_section': 'Trocar e-mail',
+    'account.security.email_intro': 'Enviaremos um link de confirmação para o novo endereço. A troca só é aplicada após a confirmação.',
+    'account.security.new_email_label': 'Novo e-mail',
+    'account.security.email_password_label': 'Senha atual',
+    'account.security.change_email_submit': 'Solicitar troca de e-mail',
+    'account.security.email_change_requested': 'Enviamos um link de confirmação para {email}. Clique nele para concluir a troca.',
+    'account.security.email_changed': 'E-mail alterado com sucesso.',
+    // Confirmação de troca de e-mail (account/email-confirmed).
+    'account.email_confirmed.page_title': 'Confirmação de e-mail',
+    'account.email_confirmed.ok_title': 'E-mail alterado',
+    'account.email_confirmed.ok_body': 'Seu novo e-mail foi confirmado e já está ativo.',
+    'account.email_confirmed.invalid_title': 'Link inválido',
+    'account.email_confirmed.invalid_body': 'O link de confirmação é inválido ou já foi utilizado.',
     // Console de conta — MFA (account/mfa).
     'account.mfa.page_title': 'Verificação em duas etapas',
     'account.mfa.title': 'Verificação em duas etapas',
@@ -145,6 +170,24 @@ export const DEFAULT_MESSAGES = {
     'admin.users.empty': 'Nenhum usuário encontrado.',
     'admin.users.roles_placeholder': 'Papéis (separados por vírgula)',
     'admin.users.save_roles': 'Salvar papéis',
+    'admin.users.sessions': 'Sessões',
+    // Console admin — sessões/grants ativos de uma conta.
+    'admin.sessions.page_title': 'Sessões ativas',
+    'admin.sessions.title': 'Sessões ativas',
+    'admin.sessions.account': 'Conta: {email}',
+    'admin.sessions.back': 'Voltar para usuários',
+    'admin.sessions.not_supported': 'O adapter OIDC configurado não suporta enumeração — a inspeção de sessões fica indisponível.',
+    'admin.sessions.revoked_notice': 'Revogado: {sessions} sessão(ões), {grants} grant(s), {accessTokens} access token(s), {refreshTokens} refresh token(s).',
+    'admin.sessions.sessions_section': 'Sessões (login no IdP)',
+    'admin.sessions.sessions_empty': 'Nenhuma sessão ativa.',
+    'admin.sessions.session_login_ts': 'Login: {date}',
+    'admin.sessions.session_amr': 'Métodos: {amr}',
+    'admin.sessions.grants_section': 'Grants (autorizações por client)',
+    'admin.sessions.grants_empty': 'Nenhum grant ativo.',
+    'admin.sessions.grant_client': 'Client: {clientId}',
+    'admin.sessions.grant_tokens': '{accessTokens} access · {refreshTokens} refresh',
+    'admin.sessions.revoke_all': 'Revogar todas as sessões e grants',
+    'admin.sessions.revoke_confirm': 'Revogar todas as sessões e grants desta conta? O usuário precisará entrar novamente e os tokens emitidos deixarão de funcionar.',
     // Console admin — clients.
     'admin.clients.page_title': 'Clients OAuth',
     'admin.clients.title': 'Clients OAuth',
@@ -193,6 +236,21 @@ export const DEFAULT_MESSAGES = {
     'admin.pagination.page': 'Página {page} de {total}',
     'admin.pagination.prev': 'Anterior',
     'admin.pagination.next': 'Próxima',
+    // Device Authorization Grant (RFC 8628) — telas servidas pelo oidc-provider.
+    'device.input.title': 'Entrar no dispositivo',
+    'device.input.intro': 'Digite o código exibido no seu dispositivo.',
+    'device.input.submit': 'Continuar',
+    'device.input.error_invalid': 'O código informado está incorreto. Tente novamente.',
+    'device.input.error_aborted': 'A solicitação de login foi interrompida.',
+    'device.input.error_generic': 'Ocorreu um erro ao processar sua solicitação.',
+    'device.confirm.title': 'Confirmar dispositivo',
+    'device.confirm.body': 'O código abaixo deve estar sendo exibido no seu dispositivo. Confirme apenas se reconhecê-lo.',
+    'device.confirm.submit': 'Continuar',
+    'device.confirm.abort': 'Cancelar',
+    'device.success.title': 'Login concluído',
+    'device.success.body': 'Login realizado com sucesso. Você já pode voltar ao dispositivo.',
+    // Step-up auth (acr_values): cliente exige MFA mas a conta não tem MFA enrolado.
+    'mfa_challenge.required_no_enrollment': 'Este cliente exige verificação em duas etapas. Configure o MFA no console da sua conta para continuar.',
     // Mensagens de erro/flash produzidas pelos controllers.
     'errors.invalid_credentials': 'Credenciais inválidas',
     'errors.invalid_code': 'Código inválido',

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

@@ -0,0 +1,20 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedServerConfig } from '../define_config.js';
+/** Dados de um login bem-sucedido a auditar/notificar. */
+export interface LoginSuccessInput {
+    accountId: string;
+    email?: string | null;
+    ip?: string | null;
+    clientId?: string | null;
+    /** Metadata extra a anexar ao evento login.success (ex.: { mfa: 'totp' }). */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Centraliza o pós-login bem-sucedido: registra o evento `login.success` e dispara
+ * (best-effort) o alerta de NOVO acesso quando o IP nunca foi visto para a conta.
+ *
+ * É fire-and-forget e FAIL-SAFE: a notificação roda DEPOIS do audit e qualquer erro
+ * é engolido — NUNCA bloqueia nem lança no caminho do login. Substitui as chamadas
+ * `cfg.audit?.record({ type: 'login.success', ... })` espalhadas pelos controllers.
+ */
+export declare function notifyLoginSuccess(ctx: HttpContext, cfg: ResolvedServerConfig, input: LoginSuccessInput): Promise<void>;

package/build/src/host/login_notify.js

@@ -0,0 +1,71 @@
+import { sendNewLoginEmail } from './default_mailer.js';
+/**
+ * Centraliza o pós-login bem-sucedido: registra o evento `login.success` e dispara
+ * (best-effort) o alerta de NOVO acesso quando o IP nunca foi visto para a conta.
+ *
+ * É fire-and-forget e FAIL-SAFE: a notificação roda DEPOIS do audit e qualquer erro
+ * é engolido — NUNCA bloqueia nem lança no caminho do login. Substitui as chamadas
+ * `cfg.audit?.record({ type: 'login.success', ... })` espalhadas pelos controllers.
+ */
+export async function notifyLoginSuccess(ctx, cfg, input) {
+    const { accountId, email, ip, clientId, metadata } = input;
+    // 1) Audit do login.success (mesmo formato de antes).
+    await cfg.audit?.record({
+        type: 'login.success',
+        accountId,
+        email: email ?? null,
+        ip: ip ?? null,
+        clientId: clientId ?? null,
+        metadata,
+    });
+    // 2) Alerta de novo acesso (opt-out via notifications.newLoginEmail: false).
+    if (!cfg.notifications.newLoginEmail)
+        return;
+    // Fire-and-forget: nunca propaga erro pro caminho do login.
+    void (async () => {
+        // Resolve o e-mail quando o caller não o forneceu (ex.: fluxo de MFA só tem o
+        // accountId em escopo). Best-effort.
+        let resolvedEmail = email ?? null;
+        if (!resolvedEmail) {
+            resolvedEmail = (await cfg.accountStore.findById(accountId))?.email ?? null;
+        }
+        await maybeNotifyNewLogin(ctx, cfg, { accountId, email: resolvedEmail, ip: ip ?? null });
+    })().catch((error) => {
+        ctx.logger.error({ err: error, accountId }, 'authkit: falha no alerta de novo acesso');
+    });
+}
+/**
+ * Verifica se o IP é novo para a conta (consultando o audit sink por
+ * `login.success` do subject) e, se for, envia o e-mail de alerta + audita
+ * `login.new_ip_notified`. Degrada para no-op quando: sem IP, sem e-mail, sem
+ * sink consultável (`list`), ou já houve um login.success deste IP antes.
+ */
+async function maybeNotifyNewLogin(ctx, cfg, data) {
+    const { accountId, email, ip } = data;
+    if (!ip || !email)
+        return;
+    // Sem consulta do histórico não dá pra decidir se o IP é novo → no-op.
+    if (typeof cfg.audit?.list !== 'function')
+        return;
+    // Lê o histórico de login.success do subject. O evento ATUAL já foi gravado por
+    // notifyLoginSuccess, então um IP visto antes aparece com count >= 2 para o IP.
+    // Buscamos uma página ampla e contamos as ocorrências deste IP.
+    const page = await cfg.audit.list({
+        type: 'login.success',
+        subject: accountId,
+        page: 1,
+        limit: 200,
+    });
+    const sameIpCount = page.data.filter((e) => e.ip === ip).length;
+    // > 1 significa que já havia um login.success deste IP antes do atual → não é novo.
+    if (sameIpCount > 1)
+        return;
+    const when = new Date().toISOString();
+    await sendNewLoginEmail(ctx, { email, ip, when });
+    await cfg.audit?.record({
+        type: 'login.new_ip_notified',
+        accountId,
+        email,
+        ip,
+    });
+}

package/build/src/host/register_auth_host.js

@@ -52,9 +52,11 @@ const C = {
     patIntrospection: () => import('./controllers/pat_introspection_controller.js'),
     accountSession: () => import('./controllers/account_session_controller.js'),
     accountTokens: () => import('./controllers/account_tokens_controller.js'),
+    accountSecurity: () => import('./controllers/account_security_controller.js'),
     accountMfa: () => import('./controllers/account_mfa_controller.js'),
     adminDashboard: () => import('./controllers/admin/admin_dashboard_controller.js'),
     adminUsers: () => import('./controllers/admin/admin_users_controller.js'),
+    adminSessions: () => import('./controllers/admin/admin_sessions_controller.js'),
     adminClients: () => import('./controllers/admin/admin_clients_controller.js'),
     adminAudit: () => import('./controllers/admin/admin_audit_controller.js'),
 };
@@ -108,12 +110,19 @@ export function registerAuthHost(router, opts) {
     router.get('/account/login', [C.accountSession, 'show']);
     router.post('/account/login', [C.accountSession, 'login']);
     router.post('/account/logout', [C.accountSession, 'logout']);
+    // Confirmação de troca de e-mail (standalone, GET-only — consome o token do link;
+    // pode ser aberta em outro dispositivo, então NÃO exige sessão).
+    router.get('/account/email/confirm', [C.accountSecurity, 'confirmEmail']);
     // Rotas de tokens protegidas por AccountAuthMiddleware (redireciona para /account/login se não autenticado).
     router
         .group(() => {
         router.get('/account/tokens', [C.accountTokens, 'index']);
         router.post('/account/tokens', [C.accountTokens, 'store']);
         router.post('/account/tokens/:id/revoke', [C.accountTokens, 'destroy']);
+        // Segurança da conta: trocar senha + solicitar troca de e-mail.
+        router.get('/account/security', [C.accountSecurity, 'index']);
+        router.post('/account/security/password', [C.accountSecurity, 'changePassword']);
+        router.post('/account/security/email', [C.accountSecurity, 'changeEmail']);
         // MFA / TOTP (enrollment, confirmação, disable).
         router.get('/account/mfa', [C.accountMfa, 'index']);
         router.post('/account/mfa/enroll', [C.accountMfa, 'enroll']);
@@ -132,6 +141,9 @@ export function registerAuthHost(router, opts) {
             router.get('/admin', [C.adminDashboard, 'index']);
             router.get('/admin/users', [C.adminUsers, 'index']);
             router.post('/admin/users/:id/roles', [C.adminUsers, 'updateRoles']);
+            // Sessões/grants ativos da conta + revogação em massa.
+            router.get('/admin/users/:id/sessions', [C.adminSessions, 'index']);
+            router.post('/admin/users/:id/revoke-sessions', [C.adminSessions, 'revoke']);
             router.get('/admin/clients', [C.adminClients, 'index']);
             // CRUD de clients OIDC (adapter-backed). `/new` ANTES de `:id` p/ não casar
             // "new" como id; todas as escritas são POST (com _csrf na view).

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

@@ -37,3 +37,35 @@ export declare const resetPasswordValidator: import("@vinejs/vine").VineValidato
     password: string;
     token: string;
 }>, Record<string, any> | undefined>;
+/**
+ * Troca de senha no console de conta. A regra da nova senha espelha o
+ * signupValidator (min 8, max 255); a senha atual é confirmada à parte via
+ * verifyCredentials.
+ */
+export declare const changePasswordValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
+    currentPassword: import("@vinejs/vine").VineString;
+    newPassword: import("@vinejs/vine").VineString;
+}, {
+    currentPassword: string;
+    newPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+}>, Record<string, any> | undefined>;
+/** Troca de e-mail no console de conta: senha atual + o novo e-mail. */
+export declare const changeEmailValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
+    currentPassword: import("@vinejs/vine").VineString;
+    newEmail: import("@vinejs/vine").VineString;
+}, {
+    newEmail: string;
+    currentPassword: string;
+}, {
+    newEmail: string;
+    currentPassword: string;
+}, {
+    newEmail: string;
+    currentPassword: string;
+}>, Record<string, any> | undefined>;

package/build/src/host/validators.js

@@ -11,3 +11,17 @@ export const resetPasswordValidator = vine.compile(vine.object({
     token: vine.string().trim().minLength(1),
     password: vine.string().minLength(8).maxLength(255),
 }));
+/**
+ * Troca de senha no console de conta. A regra da nova senha espelha o
+ * signupValidator (min 8, max 255); a senha atual é confirmada à parte via
+ * verifyCredentials.
+ */
+export const changePasswordValidator = vine.compile(vine.object({
+    currentPassword: vine.string().minLength(1),
+    newPassword: vine.string().minLength(8).maxLength(255),
+}));
+/** Troca de e-mail no console de conta: senha atual + o novo e-mail. */
+export const changeEmailValidator = vine.compile(vine.object({
+    currentPassword: vine.string().minLength(1),
+    newEmail: vine.string().trim().email().normalizeEmail(),
+}));