@adonis-agora/authkit-server 0.46.0 → 0.48.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.d.ts

@@ -55,7 +55,9 @@ export declare class AdminSessionsService {
      * a sessão na próxima request — INSTANTÂNEO, sem esperar o refresh token falhar.
      *
      * Best-effort: a destruição de grants/tokens acima já é a fonte da verdade; esta
-     * linha só acelera o efeito nos clients. Falha (tabela ausente) é silenciosa.
+     * linha só acelera o efeito nos clients. Falha (tabela ausente / lucid indisponível)
+     * NÃO propaga — mas NUNCA é silenciosa: é logada em `error`, porque uma revogação de
+     * sessão que não persiste é um risco de segurança que não pode ficar invisível.
      *
      * @param accountId Conta cujas sessões devem ser derrubadas (gravado em `sub`).
      * @param revokedAt Timestamp da revogação. Default: agora. A checagem do client

package/build/src/host/admin_sessions_service.js

@@ -1,3 +1,4 @@
+import { getBootedApp } from '../../services/booted_app.js';
 /**
  * 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
@@ -32,7 +33,9 @@ export class AdminSessionsService {
      * a sessão na próxima request — INSTANTÂNEO, sem esperar o refresh token falhar.
      *
      * Best-effort: a destruição de grants/tokens acima já é a fonte da verdade; esta
-     * linha só acelera o efeito nos clients. Falha (tabela ausente) é silenciosa.
+     * linha só acelera o efeito nos clients. Falha (tabela ausente / lucid indisponível)
+     * NÃO propaga — mas NUNCA é silenciosa: é logada em `error`, porque uma revogação de
+     * sessão que não persiste é um risco de segurança que não pode ficar invisível.
      *
      * @param accountId Conta cujas sessões devem ser derrubadas (gravado em `sub`).
      * @param revokedAt Timestamp da revogação. Default: agora. A checagem do client
@@ -43,7 +46,16 @@ export class AdminSessionsService {
      */
     async recordSubRevocation(accountId, revokedAt = new Date()) {
         try {
-            const db = (await import('@adonisjs/lucid/services/db')).default;
+            // Resolve o Lucid pelo ALIAS STRING `'lucid.db'` (o mesmo idioma de
+            // `runtime_settings.ts` e do provider), NUNCA por `import('@adonisjs/lucid/services/db')`
+            // — esse resolve a CLASSE `Database` e a usa como TOKEN do container. Com duas cópias
+            // físicas do lucid na árvore do host (pins distintos ou o mesmo pin sob peer sets
+            // distintos, que o pnpm materializa em diretórios separados) os tokens-classe diferem, o
+            // `make()` falha (`Cannot construct "[class Database]"`) e a gravação era engolida em
+            // SILÊNCIO por este catch — a pior variante do bug. Um token string não pode ser
+            // duplicado. O app vem do provider (ver `services/booted_app.ts`), não de `services/app`.
+            const app = getBootedApp();
+            const db = await app.container.make('lucid.db');
             const conn = this.#schemaConnection
                 ? db.connection(this.#schemaConnection)
                 : db.connection();
@@ -53,8 +65,28 @@ export class AdminSessionsService {
                 revoked_at: revokedAt,
             });
         }
+        catch (error) {
+            // A invalidação server-side (destruição de grants/tokens) já é a fonte da verdade, então
+            // NÃO propagamos. Mas NUNCA engolimos em silêncio: logamos em `error` para que a falha da
+            // propagação cookie-based (tabela ausente, lucid indisponível, provider não registrado)
+            // seja visível — uma revogação que não persiste é um risco de segurança invisível.
+            await this.#logRevocationFailure(accountId, error);
+        }
+    }
+    /**
+     * Loga (best-effort, sem nunca lançar) a falha de {@link recordSubRevocation}. Prefere o
+     * `logger` do container; se ele não puder ser resolvido (ex.: o próprio `getBootedApp()` foi o
+     * que falhou), cai em `console.error` — a falha PRECISA aparecer em algum lugar.
+     */
+    async #logRevocationFailure(accountId, error) {
+        const msg = 'authkit: falha ao gravar a revogação por sub (auth_session_revocations) — a propagação cookie-based da revogação de sessão não foi persistida';
+        try {
+            const logger = await getBootedApp().container.make('logger');
+            logger.error({ err: error, accountId }, msg);
+        }
         catch {
-            /* tabela ausente / lucid indisponível — a invalidação server-side ainda vale */
+            // eslint-disable-next-line no-console
+            console.error(msg, { accountId, error });
         }
     }
     /** Indica se o adapter suporta enumeração (capacidade opcional). */
@@ -198,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.d.ts

@@ -21,6 +21,10 @@ export declare function hasAccountSession(ctx: HttpContext): boolean;
  * URL do login do console, com `return_to` opcional de volta ao destino
  * original após autenticar.
  *
+ * Respeita a opção `accountLoginUrl` de `registerAuthHost`: quando o host
+ * desmontou a tela `account/login` e apontou para a própria rota de login
+ * (ex.: `/login`), este helper usa esse destino. Default `/account/login`.
+ *
  * @example
  * consoleLoginUrl('/telescope') // => '/account/login?return_to=%2Ftelescope'
  */

package/build/src/host/console_session.js

@@ -1,3 +1,4 @@
+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
@@ -26,11 +27,17 @@ export function hasAccountSession(ctx) {
  * URL do login do console, com `return_to` opcional de volta ao destino
  * original após autenticar.
  *
+ * Respeita a opção `accountLoginUrl` de `registerAuthHost`: quando o host
+ * desmontou a tela `account/login` e apontou para a própria rota de login
+ * (ex.: `/login`), este helper usa esse destino. Default `/account/login`.
+ *
  * @example
  * consoleLoginUrl('/telescope') // => '/account/login?return_to=%2Ftelescope'
  */
 export function consoleLoginUrl(returnTo) {
+    const loginUrl = getAccountLoginUrl();
     if (!returnTo)
-        return '/account/login';
-    return `/account/login?return_to=${encodeURIComponent(returnTo)}`;
+        return loginUrl;
+    const sep = loginUrl.includes('?') ? '&' : '?';
+    return `${loginUrl}${sep}return_to=${encodeURIComponent(returnTo)}`;
 }

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,10 +34,7 @@ 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', {

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.
@@ -90,8 +106,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 +152,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,7 +174,7 @@ 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);
@@ -176,11 +217,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 +247,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'));
     }
 }