@dudousxd/adonis-authkit-server 0.2.0 → 0.4.0

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_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_clients_controller.d.ts

@@ -1,10 +1,24 @@
 import '../../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
 /**
- * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
- * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
- * aqui — a view informa isso quando o registro dinâmico está ligado.
+ * CRUD de clients OIDC no console admin. Mostra os clients ESTÁTICOS da config
+ * (somente leitura, rotulados) lado a lado com os clients DINÂMICOS persistidos
+ * no adapter (registro dinâmico/RFC 7591 + os criados aqui). Quando o adapter não
+ * suporta enumeração (`listClients`), a seção dinâmica degrada graciosamente —
+ * espelhando o padrão da tela de auditoria.
  */
 export default class AdminClientsController {
     index(ctx: HttpContext): Promise<any>;
+    /** Formulário de criação. */
+    create(ctx: HttpContext): Promise<any>;
+    /** Persiste um client novo; mostra o secret UMA vez via flash. */
+    store(ctx: HttpContext): Promise<void>;
+    /** Formulário de edição de um client persistido. */
+    edit(ctx: HttpContext): Promise<any>;
+    /** Atualiza metadata editável (NÃO o secret). */
+    update(ctx: HttpContext): Promise<void>;
+    /** Regenera o secret de um client confidencial; mostra o novo valor UMA vez. */
+    regenerateSecret(ctx: HttpContext): Promise<void>;
+    /** Remove um client persistido. */
+    destroy(ctx: HttpContext): Promise<void>;
 }

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

@@ -1,24 +1,178 @@
 import '../../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../../middleware/account_auth.js';
+import { AdminClientsService, } from '../../admin_clients_service.js';
+const VALID_GRANTS = ['authorization_code', 'refresh_token', 'client_credentials'];
+const VALID_AUTH_METHODS = [
+    'client_secret_basic',
+    'client_secret_post',
+    'none',
+];
+/** Normaliza um textarea (1 item por linha) numa lista sem vazios nem duplicatas. */
+function parseLines(raw) {
+    return Array.from(new Set(String(raw ?? '')
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0)));
+}
+/** Lê os grants marcados no form (checkboxes); cai no default quando nenhum. */
+function parseGrants(ctx) {
+    const raw = ctx.request.input('grant_types', []);
+    const arr = Array.isArray(raw) ? raw : [raw];
+    const filtered = arr.filter((g) => VALID_GRANTS.includes(g));
+    return filtered.length ? filtered : ['authorization_code', 'refresh_token'];
+}
+function parseAuthMethod(ctx) {
+    const raw = ctx.request.input('token_endpoint_auth_method', 'client_secret_basic');
+    return (VALID_AUTH_METHODS.includes(raw)
+        ? raw
+        : 'client_secret_basic');
+}
+function readInput(ctx) {
+    return {
+        clientId: ctx.request.input('client_id', '').trim() || undefined,
+        redirectUris: parseLines(ctx.request.input('redirect_uris')),
+        postLogoutRedirectUris: parseLines(ctx.request.input('post_logout_redirect_uris')),
+        grantTypes: parseGrants(ctx),
+        tokenEndpointAuthMethod: parseAuthMethod(ctx),
+    };
+}
 /**
- * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
- * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
- * aqui — a view informa isso quando o registro dinâmico está ligado.
+ * CRUD de clients OIDC no console admin. Mostra os clients ESTÁTICOS da config
+ * (somente leitura, rotulados) lado a lado com os clients DINÂMICOS persistidos
+ * no adapter (registro dinâmico/RFC 7591 + os criados aqui). Quando o adapter não
+ * suporta enumeração (`listClients`), a seção dinâmica degrada graciosamente —
+ * espelhando o padrão da tela de auditoria.
  */
 export default class AdminClientsController {
     async index(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const render = cfg.render;
+        const admin = new AdminClientsService(service);
+        const dynamicSupported = admin.canList;
+        const dynamicClients = dynamicSupported ? await admin.list() : [];
+        const createdSecret = ctx.session.flashMessages.get('createdClientSecret');
         return render(ctx, 'admin/clients', {
             csrfToken: ctx.request.csrfToken,
             dynamicEnabled: cfg.dynamicRegistration.enabled,
-            clients: cfg.clients.map((c) => ({
+            dynamicSupported,
+            createdSecret: createdSecret ?? null,
+            staticClients: cfg.clients.map((c) => ({
                 clientId: c.clientId,
                 confidential: !!c.clientSecret,
                 grants: c.grants ?? ['authorization_code', 'refresh_token'],
                 redirectUris: c.redirectUris ?? [],
                 postLogoutRedirectUris: c.postLogoutRedirectUris ?? [],
             })),
+            dynamicClients,
+        });
+    }
+    /** Formulário de criação. */
+    async create(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        return render(ctx, 'admin/client_form', {
+            csrfToken: ctx.request.csrfToken,
+            mode: 'create',
+            client: {
+                clientId: '',
+                redirectUris: [],
+                postLogoutRedirectUris: [],
+                grants: ['authorization_code', 'refresh_token'],
+                tokenEndpointAuthMethod: 'client_secret_basic',
+            },
+        });
+    }
+    /** Persiste um client novo; mostra o secret UMA vez via flash. */
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const input = readInput(ctx);
+        const created = await admin.create(input);
+        if (created.clientSecret) {
+            ctx.session.flash('createdClientSecret', {
+                clientId: created.clientId,
+                clientSecret: created.clientSecret,
+            });
+        }
+        await cfg.audit?.record({
+            type: 'client.created',
+            clientId: created.clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Formulário de edição de um client persistido. */
+    async edit(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        const client = await admin.find(clientId);
+        if (!client)
+            return ctx.response.redirect('/admin/clients');
+        return render(ctx, 'admin/client_form', {
+            csrfToken: ctx.request.csrfToken,
+            mode: 'edit',
+            client,
+        });
+    }
+    /** Atualiza metadata editável (NÃO o secret). */
+    async update(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        const existing = await admin.find(clientId);
+        if (!existing)
+            return ctx.response.redirect('/admin/clients');
+        const input = { ...readInput(ctx), clientId };
+        await admin.update(clientId, input);
+        await cfg.audit?.record({
+            type: 'client.updated',
+            clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Regenera o secret de um client confidencial; mostra o novo valor UMA vez. */
+    async regenerateSecret(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        try {
+            const secret = await admin.regenerateSecret(clientId);
+            ctx.session.flash('createdClientSecret', { clientId, clientSecret: secret });
+            await cfg.audit?.record({
+                type: 'client.updated',
+                clientId,
+                actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { action: 'regenerate_secret' },
+            });
+        }
+        catch {
+            // client inexistente ou public — sem secret a regenerar; volta silenciosamente.
+        }
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Remove um client persistido. */
+    async destroy(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        await admin.delete(clientId);
+        await cfg.audit?.record({
+            type: 'client.deleted',
+            clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
         });
+        return ctx.response.redirect('/admin/clients');
     }
 }

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>;
+}

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;
     /**