@adonis-agora/authkit-server 0.47.0 → 0.49.0

package/build/src/host/admin_console/console_users_controller.js

@@ -1,13 +1,13 @@
-import "../augmentations.js";
-import { AdminUsersService } from "../admin_api/admin_users_service.js";
-import { AdminSessionsService } from "../admin_sessions_service.js";
-import { enrichSessionsWithContext } from "../session_context.js";
-import { resolveRuntimeSettings } from "../runtime_settings.js";
-import { resolveEffectiveRolesCatalog } from "../runtime_toggles.js";
-import { userDto, sessionDto, grantDto, apiError } from "../admin_api/dto.js";
-import { ACCOUNT_SESSION_KEY } from "../middleware/account_auth.js";
-import { supportsAccountDeletion, supportsAccountStatus, } from "../../accounts/account_store.js";
-import { adminUserCreateValidator, adminUserRolesValidator, } from "../admin_validators.js";
+import '../augmentations.js';
+import { supportsAccountDeletion, supportsAccountStatus } from '../../accounts/account_store.js';
+import { AdminUsersService } from '../admin_api/admin_users_service.js';
+import { apiError, grantDto, sessionDto, userDto } from '../admin_api/dto.js';
+import { AdminSessionsService } from '../admin_sessions_service.js';
+import { adminUserCreateValidator, adminUserRolesValidator } from '../admin_validators.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { resolveEffectiveRolesCatalog } from '../runtime_toggles.js';
+import { enrichSessionsWithContext } from '../session_context.js';
 const PAGE_SIZE = 20;
 /**
  * Endpoints JSON de usuários do console admin React.
@@ -28,12 +28,11 @@ const PAGE_SIZE = 20;
 export default class ConsoleUsersController {
     /** GET {prefix}/api/users */
     async index(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
-        const search = ctx.request.input("search", "").trim();
-        const page = Math.max(1, Number.parseInt(ctx.request.input("page", "1"), 10) || 1);
-        const perPage = Math.max(1, Math.min(100, Number.parseInt(ctx.request.input("perPage", String(PAGE_SIZE)), 10) ||
-            PAGE_SIZE));
+        const search = ctx.request.input('search', '').trim();
+        const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
+        const perPage = Math.max(1, Math.min(100, Number.parseInt(ctx.request.input('perPage', String(PAGE_SIZE)), 10) || PAGE_SIZE));
         const result = await cfg.accountStore.listAccounts({
             search,
             page,
@@ -45,12 +44,12 @@ export default class ConsoleUsersController {
     }
     /** GET {prefix}/api/users/:id */
     async show(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await cfg.accountStore.findById(id);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         const users = new AdminUsersService(cfg);
         const disabled = await users.isDisabled(id);
         // Sessões ativas (degradam quando adapter não enumera).
@@ -82,7 +81,7 @@ export default class ConsoleUsersController {
     }
     /** POST {prefix}/api/users */
     async store(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
         const ip = ctx.request.ip?.() ?? null;
@@ -93,45 +92,45 @@ export default class ConsoleUsersController {
             name: name ?? null,
             password: password ?? null,
             invite: invite ?? false,
-        }, { actorId, ip, source: "admin" });
+        }, { actorId, ip, source: 'admin' });
         if (!result.ok) {
-            if (result.reason === "password_policy") {
-                return ctx.response.badRequest(apiError("password_policy", cfg.messages[result.messageKey] ?? result.messageKey));
+            if (result.reason === 'password_policy') {
+                return ctx.response.badRequest(apiError('password_policy', cfg.messages[result.messageKey] ?? result.messageKey));
             }
-            return ctx.response.conflict(apiError("email_taken", "Já existe uma conta com este e-mail."));
+            return ctx.response.conflict(apiError('email_taken', 'Já existe uma conta com este e-mail.'));
         }
         ctx.response.status(201);
         return { ...userDto(result.account), invited: result.invited };
     }
     /** PATCH {prefix}/api/users/:id/roles */
     async updateRoles(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await cfg.accountStore.findById(id);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
         const { roles: rolesInput } = await ctx.request.validateUsing(adminUserRolesValidator);
         const roles = Array.from(new Set((rolesInput ?? []).map((r) => r.trim()).filter(Boolean)));
         const users = new AdminUsersService(cfg);
         // Proteções de escalonamento/lockout: último admin + auto-rebaixamento.
         const guard = await users.guardGlobalRolesChange(id, roles, actorId);
-        if (guard === "last_admin") {
+        if (guard === 'last_admin') {
             return ctx.response
                 .status(409)
-                .send(apiError("last_admin", "Não é possível remover a última conta com a role de administrador."));
+                .send(apiError('last_admin', 'Não é possível remover a última conta com a role de administrador.'));
         }
-        if (guard === "cannot_self_demote") {
+        if (guard === 'cannot_self_demote') {
             return ctx.response
                 .status(409)
-                .send(apiError("cannot_self_demote", "Você não pode remover a sua própria role de administrador."));
+                .send(apiError('cannot_self_demote', 'Você não pode remover a sua própria role de administrador.'));
         }
         // Resolve RuntimeSettings para validação contra catálogo (fail-safe).
         const runtimeSettings = await resolveRuntimeSettings(ctx);
         const errorKey = await users.setGlobalRolesValidated(id, roles, runtimeSettings);
         if (errorKey) {
-            return ctx.response.badRequest(apiError("invalid_role", cfg.messages[errorKey] ?? errorKey));
+            return ctx.response.badRequest(apiError('invalid_role', cfg.messages[errorKey] ?? errorKey));
         }
         const updated = await cfg.accountStore.findById(id);
         const disabled = await users.isDisabled(id);
@@ -146,24 +145,24 @@ export default class ConsoleUsersController {
         return this.#setStatus(ctx, false);
     }
     async #setStatus(ctx, disable) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
         const ip = ctx.request.ip?.() ?? null;
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const account = await cfg.accountStore.findById(id);
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         const users = new AdminUsersService(cfg);
         const applied = await users.setStatus(id, disable, {
             actorId,
             ip,
-            source: "admin",
+            source: 'admin',
         });
         if (!applied) {
             return ctx.response
                 .status(409)
-                .send(apiError("capability_unsupported", "O store não suporta habilitar/desabilitar contas."));
+                .send(apiError('capability_unsupported', 'O store não suporta habilitar/desabilitar contas.'));
         }
         const updated = await cfg.accountStore.findById(id);
         const disabled = await users.isDisabled(id);
@@ -171,41 +170,41 @@ export default class ConsoleUsersController {
     }
     /** POST {prefix}/api/users/:id/reset-password */
     async resetPassword(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
         const ip = ctx.request.ip?.() ?? null;
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const users = new AdminUsersService(cfg);
         const account = await users.resetPassword(ctx, id, {
             actorId,
             ip,
-            source: "admin",
+            source: 'admin',
         });
         if (!account)
-            return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
         return { ok: true, email: account.email };
     }
     /** DELETE {prefix}/api/users/:id */
     async destroy(ctx) {
-        const service = await ctx.containerResolver.make("authkit.server");
+        const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
         const ip = ctx.request.ip?.() ?? null;
-        const id = ctx.request.param("id");
+        const id = ctx.request.param('id');
         const users = new AdminUsersService(cfg);
         // OPT-IN durável: passa o enqueue (cascade async); senão delete() roda síncrono.
         const enqueue = cfg.accountLifecycle?.durable
-            ? (await import("../durable/index.js")).enqueueDeletionVia(ctx.containerResolver)
+            ? (await import('../durable/index.js')).enqueueDeletionVia(ctx.containerResolver)
             : undefined;
-        const outcome = await users.delete(service, id, { actorId, ip, source: "admin" }, enqueue);
+        const outcome = await users.delete(service, id, { actorId, ip, source: 'admin' }, enqueue);
         if (!outcome.ok) {
-            if (outcome.reason === "not_found") {
-                return ctx.response.notFound(apiError("not_found", "Usuário não encontrado."));
+            if (outcome.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
             }
             return ctx.response
                 .status(409)
-                .send(apiError("capability_unsupported", "O store não suporta deleção de contas."));
+                .send(apiError('capability_unsupported', 'O store não suporta deleção de contas.'));
         }
         return { ok: true, deleted: id };
     }

package/build/src/host/admin_prefix.js

@@ -22,7 +22,7 @@ let _prefix = DEFAULT_ADMIN_PREFIX;
 export function normalizeAdminPrefix(raw) {
     let p = raw.trim();
     if (!p.startsWith('/'))
-        p = '/' + p;
+        p = `/${p}`;
     p = p.replace(/\/+$/, '');
     return p || '/';
 }
@@ -53,7 +53,7 @@ let _apiPrefix = DEFAULT_ADMIN_API_PREFIX;
 export function normalizeAdminApiPrefix(raw) {
     let p = raw.trim();
     if (!p.startsWith('/'))
-        p = '/' + p;
+        p = `/${p}`;
     p = p.replace(/\/+$/, '');
     return p || '/';
 }

package/build/src/host/admin_sessions_service.js

@@ -230,9 +230,7 @@ export class AdminSessionsService {
         //
         // Sem sessão preservada (exceptSessionId não encontrado / sem loginTs), caímos
         // no default (`now`) — não há sessão nova a proteger nesse caminho.
-        const cutoff = typeof preserved?.loginTs === 'number'
-            ? new Date((preserved.loginTs - 1) * 1000)
-            : undefined;
+        const cutoff = typeof preserved?.loginTs === 'number' ? new Date((preserved.loginTs - 1) * 1000) : undefined;
         await this.recordSubRevocation(accountId, cutoff);
         return {
             sessions: sessionsToRevoke.length,

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

@@ -1,6 +1,6 @@
 import type { HttpContext } from '@adonisjs/core/http';
-import type { ResolvedServerConfig } from '../define_config.js';
 import type { AuthAccount } from '../accounts/account_store.js';
+import type { ResolvedServerConfig } from '../define_config.js';
 /**
  * Sincroniza `ctx.auth` (`@adonisjs/auth`) com um login bem-sucedido no console
  * de conta do authkit. Ver `adonisAuth` em `define_config.ts` pro porquê: sem

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

@@ -1,5 +1,5 @@
-import type { ConfigProvider } from '@adonisjs/core/types';
 import type { SessionUserProviderContract } from '@adonisjs/auth/types/session';
+import type { ConfigProvider } from '@adonisjs/core/types';
 import type { AuthAccount } from '../accounts/account_store.js';
 /**
  * User provider de `@adonisjs/auth` (session guard) apoiado no `accountStore`

package/build/src/host/app_key.js

@@ -4,7 +4,7 @@ import { RuntimeException } from '@adonisjs/core/exceptions';
  * LAZY do `register()`) para o erro de `appKey` ausente — um só lugar para
  * editar o texto, e garante que os dois caminhos falem exatamente a mesma coisa.
  */
-export const MISSING_APP_KEY_MESSAGE = 'APP_KEY ausente: defina `export const appKey = new Secret(env.get(\'APP_KEY\'))` em config/app.ts. ' +
+export const MISSING_APP_KEY_MESSAGE = "APP_KEY ausente: defina `export const appKey = new Secret(env.get('APP_KEY'))` em config/app.ts. " +
     'O @adonis-agora/authkit-server precisa dele para assinar os cookies do oidc-provider (NÃO usa config/encryption.ts).';
 /**
  * Lê e valida `app.appKey` (usado pelo oidc-provider para assinar cookies via

package/build/src/host/avatar_storage.js

@@ -43,9 +43,7 @@ let mediaModulePromise;
 async function loadMedia() {
     if (!mediaModulePromise) {
         const specifier = '@adonis-agora/media/single-file';
-        mediaModulePromise = import(__rewriteRelativeImportExtension(specifier))
-            .then((mod) => mod ?? null)
-            .catch(() => null);
+        mediaModulePromise = import(__rewriteRelativeImportExtension(specifier)).then((mod) => mod ?? null).catch(() => null);
     }
     return mediaModulePromise;
 }

package/build/src/host/config_locks.js

@@ -48,9 +48,7 @@ export class SettingLockedError extends Error {
     code = 'E_SETTING_LOCKED';
     key;
     constructor(key) {
-        super(`A setting "${key}" foi definida via defineConfig() e está travada — ` +
-            `não pode ser alterada em runtime (console/Admin API). ` +
-            `Remova-a do defineConfig para liberar a edição pela UI.`);
+        super(`A setting "${key}" foi definida via defineConfig() e está travada — não pode ser alterada em runtime (console/Admin API). Remova-a do defineConfig para liberar a edição pela UI.`);
         this.name = 'SettingLockedError';
         this.key = key;
     }

package/build/src/host/console_session.js

@@ -1,5 +1,5 @@
-import { ACCOUNT_SESSION_KEY } from './middleware/account_auth.js';
 import { getAccountLoginUrl } from './account_login_url.js';
+import { ACCOUNT_SESSION_KEY } from './middleware/account_auth.js';
 /**
  * Helpers públicos para integrar a sessão do console do AuthKit com
  * qualquer coisa fora do pacote (ex.: proteger o dashboard do

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

@@ -1,6 +1,7 @@
 import '../augmentations.js';
-import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { accountPath } from '../account_paths.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 /**
  * Self-service de consentimento ("apps com acesso") no console de conta. Lista os
  * Grants da própria conta agrupados por client (resolvendo o nome do client da
@@ -56,6 +57,6 @@ export default class AccountAppsController {
             },
         });
         ctx.session.flash('appRevoked', cfg.messages['account.apps.revoked'] ?? 'account.apps.revoked');
-        return ctx.response.redirect('/account/apps');
+        return ctx.response.redirect(accountPath('apps'));
     }
 }

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

@@ -8,7 +8,7 @@
  * A tela está atrás do `accountGuard` (requer sessão de conta ativa).
  */
 import '../augmentations.js';
-import { resolveAvailableMethods, configuredSudoMethods, isSudoMethodMounted, sudoContextFrom, LAST_METHOD_SESSION_KEY, } from '../sudo/runtime.js';
+import { LAST_METHOD_SESSION_KEY, configuredSudoMethods, isSudoMethodMounted, resolveAvailableMethods, sudoContextFrom, } from '../sudo/runtime.js';
 /**
  * Reexport de compatibilidade. O construtor canônico do `SudoContext` vive em
  * `sudo/runtime.ts` (é runtime do SPI, não detalhe da tela); este caminho
@@ -23,7 +23,6 @@ export default class AccountConfirmController {
         if (!methods.length) {
             // Nenhum método disponível é erro de CONFIGURAÇÃO do host, não usuário
             // preso: a tela informa e o log aponta o problema.
-            ;
             ctx.logger?.error({ accountId: c.accountId }, 'authkit: nenhum método de sudo disponível para a conta — verifique config.sudo.methods');
         }
         // FLAG-DRIFT: `config.sudo.methods` decide o que a tela OFERECE, mas as
@@ -35,13 +34,10 @@ export default class AccountConfirmController {
         // `configuredSudoMethods` devolve a própria lista montada.
         for (const m of methods) {
             if (!isSudoMethodMounted(m.id)) {
-                ;
-                ctx.logger?.warn({ method: m.id }, `authkit: método de sudo "${m.id}" está em config.sudo.methods mas não teve ` +
-                    'rotas montadas por registerAuthHost — a tela vai oferecer uma opção cujo ' +
-                    'endpoint não existe');
+                ctx.logger?.warn({ method: m.id }, `authkit: método de sudo "${m.id}" está em config.sudo.methods mas não teve rotas montadas por registerAuthHost — a tela vai oferecer uma opção cujo endpoint não existe`);
             }
         }
-        return c.cfg.render(ctx, 'account/confirm', {
+        const props = {
             csrfToken: ctx.request.csrfToken,
             returnTo: c.returnTo,
             error: ctx.session.flashMessages.get('confirmError') ?? null,
@@ -51,6 +47,7 @@ export default class AccountConfirmController {
             notice: ctx.session.flashMessages.get('confirmNotice') ?? null,
             methods,
             preferredId: ctx.session.get(LAST_METHOD_SESSION_KEY) ?? null,
-        });
+        };
+        return c.cfg.render(ctx, 'account/confirm', props);
     }
 }

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

@@ -1,13 +1,29 @@
 import '../augmentations.js';
 import QRCode from 'qrcode';
-import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
-import { translate } from '../i18n.js';
 import { supportsPasskeys } from '../../accounts/account_store.js';
-import { dispatchSecurityNotice } from '../security_notice_service.js';
+import { accountPath } from '../account_paths.js';
+import { translate } from '../i18n.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { dispatchSecurityNotice } from '../security_notice_service.js';
 import { requireSudo } from '../sudo_mode.js';
 /** Desafio WebAuthn pendente (registro) guardado na sessão entre begin/finish. */
 const PASSKEY_REG_CHALLENGE_KEY = 'authkit_passkey_reg_challenge';
+/**
+ * `true` quando a requisição é uma NAVEGAÇÃO (form/browser) e não um XHR/fetch:
+ * o cliente aceita `text/html` e NÃO pede explicitamente `application/json`.
+ *
+ * Endpoints duais (JSON para o app React / redirect para o `<form>` clássico)
+ * decidem a resposta por aqui. Um `fetch` sem `Accept` explícito manda coringa
+ * (`*` + `/` + `*`) → não é navegação → JSON (mantém o comportamento de sempre
+ * da `mfa.edge`).
+ */
+function isNavigationRequest(ctx) {
+    const accept = (ctx.request.header('accept') ?? '').toLowerCase();
+    const wantsJson = accept.includes('application/json');
+    const wantsHtml = accept.includes('text/html');
+    return wantsHtml && !wantsJson;
+}
 /**
  * Console de MFA da conta (atrás do account_auth middleware). Enrollment TOTP
  * com QR, confirmação com código, exibição única dos recovery codes e disable.
@@ -24,13 +40,14 @@ export default class AccountMfaController {
         // Passkeys disponíveis quando o store as suporta (model de credenciais wired).
         const passkeysSupported = supportsPasskeys(cfg.accountStore);
         const passkeys = passkeysSupported ? await cfg.accountStore.listPasskeys(userId) : [];
-        return render(ctx, 'account/mfa', {
+        const props = {
             csrfToken: ctx.request.csrfToken,
             enabled: state.enabled,
             recoveryCodes: recoveryCodes ?? null,
             passkeysSupported,
             passkeys,
-        });
+        };
+        return render(ctx, 'account/mfa', props);
     }
     /**
      * POST /account/mfa/passkeys/options — gera as opções de registro de passkey
@@ -90,8 +107,28 @@ export default class AccountMfaController {
         if (accountForNotice) {
             const ts = new Date().toISOString();
             const ip = ctx.request.ip?.() ?? null;
-            await dispatchSecurityNotice(ctx, { account: { id: userId, email: accountForNotice.email }, kind: 'passkey_added', ip, timestamp: ts }, cfg.mail, cfg.audit);
-            await dispatchSecurityNotice(ctx, { account: { id: userId, email: accountForNotice.email }, kind: 'mfa_enabled', ip, timestamp: ts }, cfg.mail, cfg.audit);
+            await dispatchSecurityNotice(ctx, {
+                account: { id: userId, email: accountForNotice.email },
+                kind: 'passkey_added',
+                ip,
+                timestamp: ts,
+            }, cfg.mail, cfg.audit);
+            await dispatchSecurityNotice(ctx, {
+                account: { id: userId, email: accountForNotice.email },
+                kind: 'mfa_enabled',
+                ip,
+                timestamp: ts,
+            }, cfg.mail, cfg.audit);
+        }
+        // Resposta DUAL. A cerimônia WebAuthn da tela built-in (`mfa.edge`) chama
+        // este endpoint por `fetch` e só olha `res.ok` — mas um `<form>` HTML
+        // clássico (progressive enhancement, ou host que POSTa a assertion sem JS)
+        // fica encarando o JSON `{ok:true}` cru. Navegação (o cliente ACEITA HTML e
+        // NÃO pede JSON) → redirect para a tela de MFA (respeitando `accountRoutes`);
+        // XHR/fetch → JSON de sempre. O fetch da view manda Accept coringa, então
+        // cai no ramo JSON e continua funcionando.
+        if (isNavigationRequest(ctx)) {
+            return ctx.response.redirect(accountPath('mfa'));
         }
         return { ok: true };
     }
@@ -116,9 +153,14 @@ export default class AccountMfaController {
         // Notificação de segurança: passkey_removed (best-effort).
         const accountForNotice = await cfg.accountStore.findById(userId);
         if (accountForNotice) {
-            await dispatchSecurityNotice(ctx, { account: { id: userId, email: accountForNotice.email }, kind: 'passkey_removed', ip: ctx.request.ip?.() ?? null, timestamp: new Date().toISOString() }, cfg.mail, cfg.audit);
+            await dispatchSecurityNotice(ctx, {
+                account: { id: userId, email: accountForNotice.email },
+                kind: 'passkey_removed',
+                ip: ctx.request.ip?.() ?? null,
+                timestamp: new Date().toISOString(),
+            }, cfg.mail, cfg.audit);
         }
-        return ctx.response.redirect('/account/mfa');
+        return ctx.response.redirect(accountPath('mfa'));
     }
     /** POST /account/mfa/enroll — gera segredo pendente + QR e mostra a confirmação. */
     async enroll(ctx) {
@@ -133,18 +175,19 @@ export default class AccountMfaController {
             return sudoResultEnroll;
         const started = await cfg.accountStore.startTotpEnrollment?.(userId);
         if (!started) {
-            return ctx.response.redirect('/account/mfa');
+            return ctx.response.redirect(accountPath('mfa'));
         }
         // QR renderizado server-side como data-URL e passado como prop.
         const qrDataUrl = await QRCode.toDataURL(started.otpauthUri);
-        return render(ctx, 'account/mfa', {
+        const props = {
             csrfToken: ctx.request.csrfToken,
             enabled: false,
             enrolling: true,
             secret: started.secret,
             qrDataUrl,
             recoveryCodes: null,
-        });
+        };
+        return render(ctx, 'account/mfa', props);
     }
     /** POST /account/mfa/confirm — confirma o código; sucesso = ativa e mostra recovery codes. */
     async confirm(ctx) {
@@ -158,7 +201,7 @@ export default class AccountMfaController {
             // Reenvia o passo de confirmação com erro SEM regenerar o segredo pendente
             // (o usuário já escaneou o QR; um novo segredo invalidaria o app autenticador).
             // Mostra só o campo de código para nova tentativa.
-            return render(ctx, 'account/mfa', {
+            const props = {
                 csrfToken: ctx.request.csrfToken,
                 enabled: false,
                 enrolling: true,
@@ -166,7 +209,8 @@ export default class AccountMfaController {
                 qrDataUrl: null,
                 error: translate(cfg.messages, 'errors.invalid_code'),
                 recoveryCodes: null,
-            });
+            };
+            return render(ctx, 'account/mfa', props);
         }
         await cfg.audit?.record({
             type: 'mfa.enabled',
@@ -176,11 +220,16 @@ export default class AccountMfaController {
         // Notificação de segurança: mfa_enabled (best-effort).
         const accountForMfaNotice = await cfg.accountStore.findById(userId);
         if (accountForMfaNotice) {
-            await dispatchSecurityNotice(ctx, { account: { id: userId, email: accountForMfaNotice.email }, kind: 'mfa_enabled', ip: ctx.request.ip?.() ?? null, timestamp: new Date().toISOString() }, cfg.mail, cfg.audit);
+            await dispatchSecurityNotice(ctx, {
+                account: { id: userId, email: accountForMfaNotice.email },
+                kind: 'mfa_enabled',
+                ip: ctx.request.ip?.() ?? null,
+                timestamp: new Date().toISOString(),
+            }, cfg.mail, cfg.audit);
         }
         // Mostra os recovery codes UMA vez (flash) e volta pro estado "ativado".
         ctx.session.flash('recoveryCodes', result.recoveryCodes ?? []);
-        return ctx.response.redirect('/account/mfa');
+        return ctx.response.redirect(accountPath('mfa'));
     }
     /** POST /account/mfa/disable — desliga o MFA. */
     async disable(ctx) {
@@ -201,8 +250,13 @@ export default class AccountMfaController {
         // Notificação de segurança: mfa_disabled (best-effort).
         const accountForDisableNotice = await cfg.accountStore.findById(userId);
         if (accountForDisableNotice) {
-            await dispatchSecurityNotice(ctx, { account: { id: userId, email: accountForDisableNotice.email }, kind: 'mfa_disabled', ip: ctx.request.ip?.() ?? null, timestamp: new Date().toISOString() }, cfg.mail, cfg.audit);
+            await dispatchSecurityNotice(ctx, {
+                account: { id: userId, email: accountForDisableNotice.email },
+                kind: 'mfa_disabled',
+                ip: ctx.request.ip?.() ?? null,
+                timestamp: new Date().toISOString(),
+            }, cfg.mail, cfg.audit);
         }
-        return ctx.response.redirect('/account/mfa');
+        return ctx.response.redirect(accountPath('mfa'));
     }
 }