@dudousxd/adonis-authkit-server 0.3.0 → 0.5.0

package/build/src/doctor/checks.js

@@ -0,0 +1,231 @@
+/**
+ * Funções puras de verificação para `node ace authkit:doctor`. Não dependem do
+ * Ace nem do container — recebem objetos simples para serem testáveis em
+ * isolamento. O comando `authkit:doctor` só coleta o ambiente e imprime os
+ * resultados destas funções.
+ */
+/** Type guard estrutural: o store expõe um método (capacidade presente). */
+function has(store, method) {
+    return !!store && typeof store[method] === 'function';
+}
+/** config('authkit') resolve? */
+export function checkConfigResolves(input) {
+    if (!input.authkitConfig) {
+        return {
+            level: 'error',
+            message: "config('authkit') não resolveu — config/authkit.ts está ausente ou inválido.",
+        };
+    }
+    return { level: 'ok', message: "config('authkit') resolvido." };
+}
+/** issuer é uma URL válida e seu pathname casa com o mountPath. */
+export function checkIssuer(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return [];
+    const issuer = cfg.issuer;
+    const mountPath = cfg.mountPath ?? '/oidc';
+    if (typeof issuer !== 'string' || issuer.length === 0) {
+        return [{ level: 'error', message: 'issuer ausente na config.' }];
+    }
+    let url;
+    try {
+        url = new URL(issuer);
+    }
+    catch {
+        return [{ level: 'error', message: `issuer não é uma URL válida: "${issuer}".` }];
+    }
+    const findings = [{ level: 'ok', message: `issuer válido: ${url.origin}${url.pathname}` }];
+    const normalize = (p) => (p.endsWith('/') ? p.slice(0, -1) : p) || '/';
+    if (normalize(url.pathname) !== normalize(mountPath)) {
+        findings.push({
+            level: 'warn',
+            message: `O pathname do issuer ("${url.pathname}") difere do mountPath ("${mountPath}"). As rotas OIDC podem não casar com as URLs anunciadas no discovery.`,
+        });
+    }
+    return findings;
+}
+/** Pelo menos um client com redirectUris. */
+export function checkClients(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return { level: 'error', message: 'sem config para validar clients.' };
+    const clients = Array.isArray(cfg.clients) ? cfg.clients : [];
+    if (clients.length === 0) {
+        return { level: 'error', message: 'nenhum client configurado em `clients`.' };
+    }
+    const withRedirects = clients.filter((c) => Array.isArray(c?.redirectUris) && c.redirectUris.length > 0);
+    if (withRedirects.length === 0) {
+        return {
+            level: 'error',
+            message: `${clients.length} client(s) configurado(s), mas nenhum tem redirectUris.`,
+        };
+    }
+    return { level: 'ok', message: `${withRedirects.length}/${clients.length} client(s) com redirectUris.` };
+}
+/** accountStore presente + quais capacidades implementa. */
+export function checkAccountStore(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return [];
+    const store = cfg.accountStore;
+    if (!store) {
+        return [{ level: 'error', message: 'accountStore ausente — obrigatório.' }];
+    }
+    const findings = [{ level: 'ok', message: 'accountStore presente.' }];
+    const caps = [];
+    if (has(store, 'getMfaState'))
+        caps.push('MFA');
+    if (has(store, 'listPasskeys'))
+        caps.push('passkeys/WebAuthn');
+    if (has(store, 'findByProviderIdentity'))
+        caps.push('account-linking');
+    if (has(store, 'changePassword'))
+        caps.push('account-security');
+    findings.push({
+        level: 'ok',
+        message: caps.length
+            ? `Capacidades opcionais: ${caps.join(', ')}.`
+            : 'Apenas o núcleo do accountStore (sem MFA/passkeys/linking/security).',
+    });
+    return findings;
+}
+/** session provider configurado + warn se cookie store com tokenSets grandes. */
+export function checkSession(input) {
+    if (!input.peers.session) {
+        return [
+            {
+                level: 'error',
+                message: '@adonisjs/session não é importável — instale-o (peer obrigatório).',
+            },
+        ];
+    }
+    if (!input.sessionConfig) {
+        return [{ level: 'warn', message: "config('session') ausente — o provider de sessão pode não estar configurado." }];
+    }
+    const findings = [{ level: 'ok', message: 'provider de sessão configurado.' }];
+    const driver = input.sessionConfig.store ?? input.sessionConfig.driver;
+    if (driver === 'cookie') {
+        findings.push({
+            level: 'warn',
+            message: 'session store = cookie: token sets grandes podem estourar o limite de 4KB do cookie. Prefira `redis`/`file` em produção.',
+        });
+    }
+    return findings;
+}
+/** Hint de exceções de CSRF do shield para o mountPath. */
+export function checkShield(input) {
+    if (!input.peers.shield) {
+        return { level: 'error', message: '@adonisjs/shield não é importável — instale-o (peer obrigatório).' };
+    }
+    const mountPath = input.authkitConfig?.mountPath ?? '/oidc';
+    return {
+        level: 'warn',
+        message: `Garanta que as rotas POST do IdP sob "${mountPath}" estejam nas exceções de CSRF do shield (ex.: endpoint /token), senão chamadas server-to-server falham.`,
+    };
+}
+/** ally só é necessário quando social está configurado. */
+export function checkAlly(input) {
+    const social = input.authkitConfig?.social;
+    const usesSocial = !!social && (Array.isArray(social.providers) ? social.providers.length > 0 : Object.keys(social).length > 0);
+    if (!usesSocial) {
+        return { level: 'ok', message: 'login social não configurado — @adonisjs/ally é opcional.' };
+    }
+    if (!input.peers.ally) {
+        return { level: 'error', message: 'login social configurado, mas @adonisjs/ally não é importável.' };
+    }
+    return { level: 'ok', message: 'login social configurado e @adonisjs/ally disponível.' };
+}
+/** rateLimit ligado mas @adonisjs/limiter ausente → warn. */
+export function checkRateLimit(input) {
+    const cfg = input.authkitConfig;
+    const rateLimit = cfg?.rateLimit;
+    const enabled = rateLimit === undefined ? true : rateLimit?.enabled !== false;
+    if (!enabled) {
+        return { level: 'ok', message: 'rate-limiting desligado por config.' };
+    }
+    if (!input.peers.limiter) {
+        return {
+            level: 'warn',
+            message: 'rate-limiting está ligado (default), mas @adonisjs/limiter não é importável — vira no-op (sem proteção anti-brute-force).',
+        };
+    }
+    return { level: 'ok', message: 'rate-limiting ligado e @adonisjs/limiter disponível.' };
+}
+/** admin.enabled mas sem roles → warn. */
+export function checkAdmin(input) {
+    const admin = input.authkitConfig?.admin;
+    if (!admin || admin.enabled !== true)
+        return null;
+    const roles = Array.isArray(admin.roles) ? admin.roles : [];
+    if (roles.length === 0) {
+        return {
+            level: 'warn',
+            message: 'console admin ligado, mas sem `admin.roles` — ninguém terá acesso (default ["ADMIN"] não foi resolvido aqui).',
+        };
+    }
+    return { level: 'ok', message: `console admin ligado para roles: ${roles.join(', ')}.` };
+}
+/** webauthn rpId deve casar com o host do issuer. */
+export function checkWebauthn(input) {
+    const cfg = input.authkitConfig;
+    const webauthn = cfg?.webauthn;
+    if (!webauthn || !webauthn.rpId)
+        return null;
+    const issuer = cfg.issuer;
+    if (typeof issuer !== 'string')
+        return null;
+    let host;
+    try {
+        host = new URL(issuer).hostname;
+    }
+    catch {
+        return null;
+    }
+    if (webauthn.rpId !== host) {
+        return {
+            level: 'warn',
+            message: `webauthn.rpId ("${webauthn.rpId}") difere do host do issuer ("${host}") — as passkeys não validarão no browser.`,
+        };
+    }
+    return { level: 'ok', message: `webauthn.rpId casa com o host do issuer (${host}).` };
+}
+/** info sobre rotação quando jwks é managed. */
+export function checkJwks(input) {
+    const jwks = input.authkitConfig?.jwks;
+    if (!jwks)
+        return null;
+    if (jwks.source === 'managed') {
+        return {
+            level: 'ok',
+            message: 'jwks managed — rotacione as chaves de assinatura com `node ace authkit:rotate-keys` (use --store para persistir entre boots).',
+        };
+    }
+    return { level: 'ok', message: 'jwks fornecido inline (source=jwks).' };
+}
+/** Roda todos os checks e devolve a lista plana de findings. */
+export function runAllChecks(input) {
+    const findings = [];
+    findings.push(checkConfigResolves(input));
+    findings.push(...checkIssuer(input));
+    findings.push(checkClients(input));
+    findings.push(...checkAccountStore(input));
+    findings.push(...checkSession(input));
+    findings.push(checkShield(input));
+    findings.push(checkAlly(input));
+    findings.push(checkRateLimit(input));
+    const admin = checkAdmin(input);
+    if (admin)
+        findings.push(admin);
+    const webauthn = checkWebauthn(input);
+    if (webauthn)
+        findings.push(webauthn);
+    const jwks = checkJwks(input);
+    if (jwks)
+        findings.push(jwks);
+    return findings;
+}
+/** Há algum finding de nível 'error'? (define o exit code). */
+export function hasErrors(findings) {
+    return findings.some((f) => f.level === 'error');
+}

package/build/src/host/admin_clients_service.js

@@ -25,14 +25,21 @@ export class AdminClientsService {
     }
     /** Indica se o adapter suporta enumeração (capacidade opcional). */
     get canList() {
-        return typeof this.#adapter.listClients === 'function';
+        return typeof this.#adapter.list === 'function' || typeof this.#adapter.listClients === 'function';
     }
     /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
     async list() {
-        if (!this.#adapter.listClients)
-            return [];
-        const rows = await this.#adapter.listClients();
-        return rows.map((r) => this.#present(r));
+        // Prefere a enumeração genérica `list`; cai no `listClients` legado se for o
+        // único disponível (adapters customizados antigos).
+        if (this.#adapter.list) {
+            const rows = await this.#adapter.list();
+            return rows.map((r) => this.#present({ clientId: r.id, payload: r.payload }));
+        }
+        if (this.#adapter.listClients) {
+            const rows = await this.#adapter.listClients();
+            return rows.map((r) => this.#present(r));
+        }
+        return [];
     }
     /** Lê um client persistido pelo client_id (undefined quando não existe). */
     async find(clientId) {

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

@@ -0,0 +1,63 @@
+import type { OidcService } from '../provider/oidc_service.js';
+/** Uma sessão ativa do IdP (login do usuário no provider), apresentada ao admin. */
+export interface AdminSession {
+    /** Id do artefato `Session` no adapter. */
+    id: string;
+    accountId: string;
+    /** Epoch (segundos) do login, quando presente no payload. */
+    loginTs?: number;
+    /** Métodos de autenticação registrados na sessão (amr), quando presentes. */
+    amr?: string[];
+}
+/** Um grant (autorização concedida a um client), com a contagem de tokens vivos. */
+export interface AdminGrant {
+    /** Id do artefato `Grant` no adapter (== grantId dos tokens). */
+    id: string;
+    accountId: string;
+    clientId?: string;
+    /** Tokens de acesso vivos que referenciam este grant. */
+    accessTokens: number;
+    /** Refresh tokens vivos que referenciam este grant. */
+    refreshTokens: number;
+}
+/** Resultado de uma revogação em massa das sessões/grants de uma conta. */
+export interface RevokeResult {
+    sessions: number;
+    grants: number;
+    accessTokens: number;
+    refreshTokens: number;
+}
+/**
+ * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta,
+ * persistidos pelo oidc-provider via o MESMO `AdapterClass` (mesmo padrão do
+ * {@link AdminClientsService}). Encapsula:
+ *   - a enumeração via a capacidade opcional `list` do adapter (degrada quando
+ *     ausente, igual ao CRUD de clients);
+ *   - a destruição das sessões + grants da conta. Destruir um grant CASCATEIA a
+ *     invalidação dos tokens no oidc-provider: os consumidores de access/refresh
+ *     token carregam `Grant.find(token.grantId)` e lançam `InvalidToken('grant not
+ *     found')` quando o grant some (verificado em oidc-provider v9). Mesmo assim,
+ *     por garantia (belt-and-braces), também destruímos as linhas de AT/RT que
+ *     referenciam os grants revogados quando o adapter enumera.
+ */
+export declare class AdminSessionsService {
+    #private;
+    constructor(oidc: OidcService);
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList(): boolean;
+    /** Lista as sessões ativas da conta (vazio quando o adapter não enumera). */
+    listSessions(accountId: string): Promise<AdminSession[]>;
+    /**
+     * Lista os grants da conta, com a contagem de access/refresh tokens vivos que
+     * referenciam cada grant (`payload.grantId`). As contagens são baratas (uma
+     * enumeração de cada model token), feitas só quando o adapter enumera.
+     */
+    listGrants(accountId: string): Promise<AdminGrant[]>;
+    /**
+     * Revoga TODAS as sessões e grants da conta. Destruir os grants já invalida os
+     * tokens (cascata via `grant not found`); ainda assim, quando o adapter enumera,
+     * destruímos explicitamente as linhas de AT/RT desses grants (belt-and-braces),
+     * deixando o store limpo. Retorna as contagens do que foi removido.
+     */
+    revokeAll(accountId: string): Promise<RevokeResult>;
+}

package/build/src/host/admin_sessions_service.js

@@ -0,0 +1,127 @@
+/**
+ * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta,
+ * persistidos pelo oidc-provider via o MESMO `AdapterClass` (mesmo padrão do
+ * {@link AdminClientsService}). Encapsula:
+ *   - a enumeração via a capacidade opcional `list` do adapter (degrada quando
+ *     ausente, igual ao CRUD de clients);
+ *   - a destruição das sessões + grants da conta. Destruir um grant CASCATEIA a
+ *     invalidação dos tokens no oidc-provider: os consumidores de access/refresh
+ *     token carregam `Grant.find(token.grantId)` e lançam `InvalidToken('grant not
+ *     found')` quando o grant some (verificado em oidc-provider v9). Mesmo assim,
+ *     por garantia (belt-and-braces), também destruímos as linhas de AT/RT que
+ *     referenciam os grants revogados quando o adapter enumera.
+ */
+export class AdminSessionsService {
+    #AdapterClass;
+    constructor(oidc) {
+        this.#AdapterClass = oidc.config.AdapterClass;
+    }
+    #adapter(model) {
+        return new this.#AdapterClass(model);
+    }
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList() {
+        return typeof this.#adapter('Session').list === 'function';
+    }
+    async #listModel(model) {
+        const adapter = this.#adapter(model);
+        if (!adapter.list)
+            return [];
+        return adapter.list();
+    }
+    /** Lista as sessões ativas da conta (vazio quando o adapter não enumera). */
+    async listSessions(accountId) {
+        const rows = await this.#listModel('Session');
+        return rows
+            .filter((r) => r.payload.accountId === accountId)
+            .map((r) => ({
+            id: r.id,
+            accountId,
+            loginTs: r.payload.loginTs,
+            amr: r.payload.amr ?? undefined,
+        }));
+    }
+    /**
+     * Lista os grants da conta, com a contagem de access/refresh tokens vivos que
+     * referenciam cada grant (`payload.grantId`). As contagens são baratas (uma
+     * enumeração de cada model token), feitas só quando o adapter enumera.
+     */
+    async listGrants(accountId) {
+        const rows = await this.#listModel('Grant');
+        const grants = rows.filter((r) => r.payload.accountId === accountId);
+        if (grants.length === 0)
+            return [];
+        const atByGrant = await this.#countByGrant('AccessToken');
+        const rtByGrant = await this.#countByGrant('RefreshToken');
+        return grants.map((g) => ({
+            id: g.id,
+            accountId,
+            clientId: g.payload.clientId,
+            accessTokens: atByGrant.get(g.id) ?? 0,
+            refreshTokens: rtByGrant.get(g.id) ?? 0,
+        }));
+    }
+    /** Conta artefatos de um model token agrupados por `grantId`. */
+    async #countByGrant(model) {
+        const rows = await this.#listModel(model);
+        const map = new Map();
+        for (const r of rows) {
+            const gid = r.payload.grantId;
+            if (!gid)
+                continue;
+            map.set(gid, (map.get(gid) ?? 0) + 1);
+        }
+        return map;
+    }
+    /**
+     * Revoga TODAS as sessões e grants da conta. Destruir os grants já invalida os
+     * tokens (cascata via `grant not found`); ainda assim, quando o adapter enumera,
+     * destruímos explicitamente as linhas de AT/RT desses grants (belt-and-braces),
+     * deixando o store limpo. Retorna as contagens do que foi removido.
+     */
+    async revokeAll(accountId) {
+        const sessionAdapter = this.#adapter('Session');
+        const grantAdapter = this.#adapter('Grant');
+        const sessions = await this.listSessions(accountId);
+        for (const s of sessions) {
+            await sessionAdapter.destroy(s.id);
+        }
+        const grants = await this.listGrants(accountId);
+        const grantIds = new Set(grants.map((g) => g.id));
+        let accessTokens = 0;
+        let refreshTokens = 0;
+        // Belt-and-braces: destrói as linhas de token que referenciam os grants alvo
+        // ANTES de destruir os grants (quando o adapter enumera).
+        accessTokens = await this.#destroyTokensOfGrants('AccessToken', grantIds);
+        refreshTokens = await this.#destroyTokensOfGrants('RefreshToken', grantIds);
+        for (const g of grants) {
+            // `revokeByGrantId` derruba os artefatos ligados ao grant (no Redis isso
+            // limpa a lista do grant; no DB apaga as linhas com `grant_id`); `destroy`
+            // remove o próprio artefato `Grant`.
+            await grantAdapter.revokeByGrantId(g.id);
+            await grantAdapter.destroy(g.id);
+        }
+        return {
+            sessions: sessions.length,
+            grants: grants.length,
+            accessTokens,
+            refreshTokens,
+        };
+    }
+    /** Destrói (quando enumerável) os artefatos de um model token cujos grantId estão em `grantIds`. */
+    async #destroyTokensOfGrants(model, grantIds) {
+        const adapter = this.#adapter(model);
+        if (!adapter.list)
+            return 0;
+        const rows = await adapter.list();
+        let count = 0;
+        for (const r of rows) {
+            const gid = r.payload.grantId;
+            if (gid && grantIds.has(gid)) {
+                await adapter.destroy(r.id);
+                count++;
+            }
+        }
+        return count;
+    }
+}

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

@@ -39,7 +39,9 @@ export default class AccountMfaController {
         const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
         const generated = await cfg.accountStore.generatePasskeyRegistrationOptions?.(userId);
         if (!generated) {
-            return ctx.response.notFound({ message: 'Passkeys indisponíveis' });
+            return ctx.response.notFound({
+                message: translate(cfg.messages, 'errors.passkeys_unavailable'),
+            });
         }
         ctx.session.put(PASSKEY_REG_CHALLENGE_KEY, generated.challenge);
         return generated.options;
@@ -54,7 +56,9 @@ export default class AccountMfaController {
         const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
         const challenge = ctx.session.get(PASSKEY_REG_CHALLENGE_KEY);
         if (!challenge) {
-            return ctx.response.badRequest({ message: 'Desafio expirado' });
+            return ctx.response.badRequest({
+                message: translate(cfg.messages, 'errors.challenge_expired'),
+            });
         }
         const body = ctx.request.input('response', ctx.request.body());
         const ok = (await cfg.accountStore.verifyPasskeyRegistration?.(userId, body, challenge)) ?? false;

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

@@ -0,0 +1,16 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Self-service de segurança da conta (console de conta): trocar a senha e o
+ * e-mail. A troca de senha exige a senha ATUAL (verifyCredentials). A troca de
+ * e-mail exige a senha atual e dispara um link de confirmação para o NOVO
+ * endereço (consumido em GET /account/email/confirm). Degrada graciosamente se o
+ * store não suportar a capacidade ({@link supportsAccountSecurity}).
+ */
+export default class AccountSecurityController {
+    index(ctx: HttpContext): Promise<any>;
+    changePassword(ctx: HttpContext): Promise<void>;
+    changeEmail(ctx: HttpContext): Promise<void>;
+    /** GET /account/email/confirm?token=... — consome o token e aplica o novo e-mail. */
+    confirmEmail(ctx: HttpContext): Promise<any>;
+}

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

@@ -0,0 +1,119 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { supportsAccountSecurity } from '../../accounts/account_store.js';
+import { changePasswordValidator, changeEmailValidator } from '../validators.js';
+import { sendEmailChangeConfirmationEmail } from '../default_mailer.js';
+import { translate } from '../i18n.js';
+/**
+ * Self-service de segurança da conta (console de conta): trocar a senha e o
+ * e-mail. A troca de senha exige a senha ATUAL (verifyCredentials). A troca de
+ * e-mail exige a senha atual e dispara um link de confirmação para o NOVO
+ * endereço (consumido em GET /account/email/confirm). Degrada graciosamente se o
+ * store não suportar a capacidade ({@link supportsAccountSecurity}).
+ */
+export default class AccountSecurityController {
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const account = await cfg.accountStore.findById(userId);
+        return render(ctx, 'account/security', {
+            csrfToken: ctx.request.csrfToken,
+            supported: supportsAccountSecurity(cfg.accountStore),
+            email: account?.email ?? '',
+            passwordChanged: ctx.session.flashMessages.get('passwordChanged') ?? null,
+            emailChangeRequested: ctx.session.flashMessages.get('emailChangeRequested') ?? null,
+            emailChanged: ctx.session.flashMessages.get('emailChanged') ?? null,
+            error: ctx.session.flashMessages.get('securityError') ?? null,
+        });
+    }
+    async changePassword(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        if (!supportsAccountSecurity(store)) {
+            return ctx.response.redirect('/account/security');
+        }
+        const { currentPassword, newPassword } = await ctx.request.validateUsing(changePasswordValidator);
+        const account = await store.findById(userId);
+        // Confirma a senha ATUAL pelo e-mail da conta.
+        const verified = account
+            ? await store.verifyCredentials(account.email, currentPassword)
+            : null;
+        if (!verified) {
+            ctx.session.flash('securityError', translate(cfg.messages, 'errors.invalid_credentials'));
+            return ctx.response.redirect('/account/security');
+        }
+        await store.changePassword(userId, newPassword);
+        await cfg.audit?.record({
+            type: 'password.changed',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        ctx.session.flash('passwordChanged', translate(cfg.messages, 'account.security.password_changed'));
+        return ctx.response.redirect('/account/security');
+    }
+    async changeEmail(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        if (!supportsAccountSecurity(store)) {
+            return ctx.response.redirect('/account/security');
+        }
+        const { currentPassword, newEmail } = await ctx.request.validateUsing(changeEmailValidator);
+        const account = await store.findById(userId);
+        const verified = account
+            ? await store.verifyCredentials(account.email, currentPassword)
+            : null;
+        if (!verified) {
+            ctx.session.flash('securityError', translate(cfg.messages, 'errors.invalid_credentials'));
+            return ctx.response.redirect('/account/security');
+        }
+        const issued = await store.requestEmailChange(userId, newEmail);
+        if (!issued) {
+            ctx.session.flash('securityError', translate(cfg.messages, 'errors.email_taken'));
+            return ctx.response.redirect('/account/security');
+        }
+        await cfg.audit?.record({
+            type: 'email.change_requested',
+            accountId: userId,
+            email: newEmail,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const confirmUrl = `${origin}/account/email/confirm?token=${encodeURIComponent(issued.token)}`;
+        // Hook do config tem prioridade (override); senão usa o mailer default do host.
+        if (cfg.mail?.onEmailVerification) {
+            await cfg.mail.onEmailVerification({ email: newEmail, verifyUrl: confirmUrl, token: issued.token });
+        }
+        else {
+            await sendEmailChangeConfirmationEmail(ctx, { email: newEmail, confirmUrl });
+        }
+        ctx.session.flash('emailChangeRequested', translate(cfg.messages, 'account.security.email_change_requested', { email: newEmail }));
+        return ctx.response.redirect('/account/security');
+    }
+    /** GET /account/email/confirm?token=... — consome o token e aplica o novo e-mail. */
+    async confirmEmail(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const render = cfg.render;
+        if (!supportsAccountSecurity(store)) {
+            return render(ctx, 'account/email-confirmed', { ok: false });
+        }
+        const token = ctx.request.qs().token ?? '';
+        const result = await store.confirmEmailChange(token);
+        if (result.ok) {
+            await cfg.audit?.record({
+                type: 'email.changed',
+                accountId: result.account.id,
+                email: result.newEmail,
+                ip: ctx.request.ip?.() ?? null,
+            });
+        }
+        return render(ctx, 'account/email-confirmed', { ok: result.ok });
+    }
+}

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

@@ -2,6 +2,7 @@ import '../augmentations.js';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 import { translate } from '../i18n.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
+import { notifyLoginSuccess } from '../login_notify.js';
 export default class AccountSessionController {
     async show(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
@@ -32,7 +33,7 @@ export default class AccountSessionController {
         }
         const acc = result.account;
         ctx.session.put(ACCOUNT_SESSION_KEY, acc.id);
-        await cfg.audit?.record({ type: 'login.success', accountId: acc.id, email, ip });
+        await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip });
         return ctx.response.redirect('/account/tokens');
     }
     async logout(ctx) {

package/build/src/host/controllers/admin/admin_sessions_controller.d.ts

@@ -0,0 +1,14 @@
+import '../../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * 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. */
+    index(ctx: HttpContext): Promise<any>;
+    /** POST /admin/users/:id/revoke-sessions — destrói sessões + grants da conta. */
+    revoke(ctx: HttpContext): Promise<void>;
+}