@adonis-agora/authkit-server 0.44.0 → 0.46.0

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

@@ -1,144 +1,56 @@
 /**
  * Sudo mode — tela de confirmação de identidade (/account/confirm).
  *
- * GET  /account/confirm  → exibe o formulário de senha (e opção de passkey se disponível).
- * POST /account/confirm  → verifica a senha e, se correta, marca o sudo na sessão.
- * POST /account/confirm/passkey/options → gera as opções de autenticação.
- * POST /account/confirm/passkey         → verifica a resposta da passkey e marca o sudo.
+ * O GET lista os métodos DISPONÍVEIS para a conta (SPI `SudoMethod`); a
+ * verificação de cada um vive no próprio método, nas rotas que ele registra.
+ * Este controller não verifica credencial nem chama `markSudo`.
  *
  * A tela está atrás do `accountGuard` (requer sessão de conta ativa).
- * Após confirmação, redireciona para `return_to` (validado) ou para `/account/tokens`.
  */
 import '../augmentations.js';
-import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
-import { translate } from '../i18n.js';
-import { supportsPasskeys } from '../../accounts/account_store.js';
-import { markSudo } from '../sudo_mode.js';
-import { validateReturnTo } from './account_session_controller.js';
-import { accountHome } from '../account_home.js';
-/** Chave de sessão para o challenge de passkey no confirm. */
-const CONFIRM_PASSKEY_CHALLENGE_KEY = 'authkit_confirm_passkey_challenge';
+import { resolveAvailableMethods, configuredSudoMethods, isSudoMethodMounted, sudoContextFrom, LAST_METHOD_SESSION_KEY, } 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
+ * antigo segue valendo para quem já o importava.
+ */
+export { sudoContextFrom };
 export default class AccountConfirmController {
     async show(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 passkeyAvailable = supportsPasskeys(cfg.accountStore)
-            ? (await cfg.accountStore.listPasskeys(userId)).length > 0
-            : false;
-        // Conta passwordless: sem hash de senha (campo `password` vazio/null no model).
-        // Verificamos indiretamente: verifyCredentials com senha fictícia vai falhar,
-        // mas precisamos saber se a conta TEM senha. Abordagem: a conta é "passwordless"
-        // se o store suporta passkeys, a conta tem pelo menos uma passkey E não tem
-        // hash de senha — mas sem expor o hash, usamos uma flag do store se disponível.
-        // Fallback conservador: assumimos que a conta tem senha se não soubermos.
-        const passwordless = await this.isPasswordless(cfg, userId);
-        const rawReturnTo = ctx.request.qs?.()?.return_to ?? ctx.request.input?.('return_to');
-        const returnTo = validateReturnTo(rawReturnTo);
-        return render(ctx, 'account/confirm', {
+        const c = await sudoContextFrom(ctx);
+        const available = await resolveAvailableMethods(c, configuredSudoMethods(c.cfg));
+        const methods = await Promise.all(available.map(async (m) => ({ id: m.id, ...(await m.describe(c)) })));
+        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
+        // rotas são montadas em tempo de registro, por `registerAuthHost`. Se as
+        // duas listas divergirem, a tela mostra um método cujo endpoint não existe
+        // — falha silenciosa e confusa. Avisa alto, uma vez por render.
+        //
+        // Só o caso de config EXPLÍCITA chega aqui divergindo: sem config,
+        // `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');
+            }
+        }
+        return c.cfg.render(ctx, 'account/confirm', {
             csrfToken: ctx.request.csrfToken,
-            returnTo,
+            returnTo: c.returnTo,
             error: ctx.session.flashMessages.get('confirmError') ?? null,
-            passwordless,
-            passkeyAvailable,
-        });
-    }
-    async confirm(ctx) {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const cfg = service.config;
-        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        const account = await cfg.accountStore.findById(userId);
-        const rawReturnTo = ctx.request.input?.('return_to');
-        const returnTo = validateReturnTo(rawReturnTo);
-        const { password } = ctx.request.only(['password']);
-        if (!password || !account) {
-            ctx.session.flash('confirmError', translate(cfg.messages, 'account.confirm.error'));
-            return ctx.response.redirect(`/account/confirm${returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : ''}`);
-        }
-        const verified = await cfg.accountStore.verifyCredentials(account.email, password);
-        if (!verified) {
-            ctx.session.flash('confirmError', translate(cfg.messages, 'account.confirm.error'));
-            return ctx.response.redirect(`/account/confirm${returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : ''}`);
-        }
-        // Confirmado: marca o sudo na sessão.
-        markSudo(ctx);
-        await cfg.audit?.record({
-            type: 'sudo.confirmed',
-            accountId: userId,
-            ip: ctx.request.ip?.() ?? null,
-            metadata: { method: 'password' },
-        });
-        return ctx.response.redirect(returnTo ?? accountHome(cfg));
-    }
-    async passkeyOptions(ctx) {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const cfg = service.config;
-        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        const generated = await cfg.accountStore.generatePasskeyAuthenticationOptions?.(userId);
-        if (!generated) {
-            return ctx.response.notFound({
-                message: translate(cfg.messages, 'errors.no_passkey_registered'),
-            });
-        }
-        ctx.session.put(CONFIRM_PASSKEY_CHALLENGE_KEY, generated.challenge);
-        return generated.options;
-    }
-    async passkeyConfirm(ctx) {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const cfg = service.config;
-        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        const challenge = ctx.session.get(CONFIRM_PASSKEY_CHALLENGE_KEY);
-        const rawReturnTo = ctx.request.input?.('return_to');
-        const returnTo = validateReturnTo(rawReturnTo);
-        if (!challenge) {
-            ctx.session.flash('confirmError', translate(cfg.messages, 'account.confirm.passkey_error'));
-            return ctx.response.redirect(`/account/confirm${returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : ''}`);
-        }
-        const raw = ctx.request.input('response');
-        let parsed = null;
-        try {
-            parsed = raw ? JSON.parse(raw) : null;
-        }
-        catch {
-            parsed = null;
-        }
-        const ok = parsed
-            ? ((await cfg.accountStore.verifyPasskeyAuthentication?.(userId, parsed, challenge)) ?? false)
-            : false;
-        ctx.session.forget(CONFIRM_PASSKEY_CHALLENGE_KEY);
-        if (!ok) {
-            ctx.session.flash('confirmError', translate(cfg.messages, 'account.confirm.passkey_error'));
-            return ctx.response.redirect(`/account/confirm${returnTo ? `?return_to=${encodeURIComponent(returnTo)}` : ''}`);
-        }
-        // Passkey confirmada: marca o sudo.
-        markSudo(ctx);
-        await cfg.audit?.record({
-            type: 'sudo.confirmed',
-            accountId: userId,
-            ip: ctx.request.ip?.() ?? null,
-            metadata: { method: 'passkey' },
+            // `confirmNotice` é flashado por `magic_link.ts` ao enviar o link (já
+            // traduzido, mesmo padrão de `confirmError`). Sem repassar aqui, quem
+            // pede o link volta para a tela sem nenhum feedback de que o e-mail saiu.
+            notice: ctx.session.flashMessages.get('confirmNotice') ?? null,
+            methods,
+            preferredId: ctx.session.get(LAST_METHOD_SESSION_KEY) ?? null,
         });
-        return ctx.response.redirect(returnTo ?? accountHome(cfg));
-    }
-    /**
-     * Verifica se a conta é "passwordless" (sem hash de senha definido).
-     * Fail-safe: retorna `false` quando não é possível determinar.
-     */
-    async isPasswordless(cfg, accountId) {
-        try {
-            // Se o store expõe __getRawRow, verificamos se o hash de senha está vazio.
-            const row = await cfg.accountStore.__getRawRow?.(accountId);
-            if (row) {
-                const pw = row.password;
-                // Hash vazio ou nulo → passwordless.
-                if (!pw || pw === '')
-                    return true;
-            }
-            return false;
-        }
-        catch {
-            return false;
-        }
     }
 }

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

@@ -3,7 +3,7 @@ import { ACCOUNT_SESSION_KEY } from "../middleware/account_auth.js";
 import { supportsAccountSecurity, supportsAccountDeletion, supportsProfile, supportsPasswordHistory, } from "../../accounts/account_store.js";
 import { changePasswordValidator, changeEmailValidator, deleteAccountValidator, updateProfileValidator, } from "../validators.js";
 import { sendEmailChangeConfirmationEmail, sendEmailChangeNoticeEmail, sendEmailChangedCompletedEmail, } from "../default_mailer.js";
-import { storeAvatar, isDriveAvailable, AvatarUploadError, } from "../avatar_storage.js";
+import { storeAvatar, isAvatarUploadSupported, AvatarUploadError, } from "../avatar_storage.js";
 import { translate } from "../i18n.js";
 import { TRUSTED_DEVICE_COOKIE } from "../trusted_device.js";
 import { AccountDeletionService } from "../account_deletion_service.js";
@@ -67,8 +67,8 @@ export default class AccountSecurityController {
             csrfToken: ctx.request.csrfToken,
             supported: supportsAccountSecurity(cfg.accountStore),
             profileSupported: supportsProfile(cfg.accountStore),
-            // Só mostramos o input de arquivo se o drive do app estiver disponível.
-            avatarUploadSupported: await isDriveAvailable(),
+            // Só mostramos o input de arquivo se ALGUM backend (drive OU media) puder armazenar.
+            avatarUploadSupported: await isAvatarUploadSupported(cfg.uploads),
             email: account?.email ?? "",
             name: account?.name ?? "",
             avatarUrl: account?.avatarUrl ?? "",

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

@@ -108,10 +108,26 @@ export default class AccountSessionController {
         const cfg = service.config;
         // M6: não basta `forget(ACCOUNT_SESSION_KEY)` — sobravam na sessão
         // `authkit_sudo_at` (sudo), `authkit_last_seen` e qualquer outro estado
-        // sensível, com o session id INALTERADO. Regenerar a sessão troca o id E
-        // descarta todos os dados antigos (sudo/last-seen inclusos), destruindo de
-        // fato a sessão de privilégio. Mantemos o `forget` explícito por garantia
-        // (belt-and-braces) caso o store de sessão não suporte regenerate.
+        // sensível, com o session id INALTERADO. Regenerar troca o id do cookie,
+        // o que invalida o identificador antigo.
+        //
+        // ATENÇÃO ao que `regenerate()` NÃO faz: ele NÃO descarta os dados. O
+        // AdonisJS MIGRA o conteúdo da sessão para o id novo (é o mesmo
+        // comportamento descrito no M5 do login, e é por isso que o estado de
+        // pré-login sobrevive lá). Quem apaga estado aqui é o `forget` explícito —
+        // não o `regenerate`.
+        //
+        // Consequência de projeto: TODO dado sensível guardado na sessão precisa
+        // ser VINCULADO À CONTA que o gravou (ex.: `accountId` no pendente do
+        // magic link de sudo, na vinculação do challenge de passkey e na marca de
+        // sudo — `SUDO_ACCOUNT_SESSION_KEY`). Confiar que ele "some no logout" é
+        // falso — num navegador compartilhado ele sobrevive ao logout de A e ao
+        // login de B.
+        //
+        // A marca de sudo era a EXCEÇÃO à própria regra declarada aqui: só o
+        // timestamp, sem dono. Passou a ser vinculada — por isso este `forget`
+        // continua sendo só do `ACCOUNT_SESSION_KEY`: trocada a conta, a marca de
+        // sudo remanescente já não vale para ninguém.
         ctx.session.forget(ACCOUNT_SESSION_KEY);
         await ctx.session.regenerate();
         // Opt-in: espelha o logout no guard de @adonisjs/auth (ver adonisAuth em define_config.ts).

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

@@ -0,0 +1,22 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET /authkit/assets/webauthn.js
+ *
+ * Serve o `@simplewebauthn/browser` a partir do próprio host, substituindo o
+ * import de `cdn.jsdelivr.net` que as views de login/MFA/confirm faziam.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: é asset estático necessário na tela de
+ * login, ou seja, antes de existir qualquer sessão. Também não pode viver sob
+ * o prefixo do console admin (que é opt-in) — `login.edge` e
+ * `mfa-challenge.edge` precisam do script mesmo num host sem console.
+ */
+export default class WebauthnAssetController {
+    handle(ctx: HttpContext): Promise<void>;
+}
+/**
+ * Limpa o cache do bundle. Existe para os testes conseguirem exercitar tanto o
+ * caminho feliz quanto o 404 no mesmo processo.
+ *
+ * @internal
+ */
+export declare function resetWebauthnAssetCache(): void;

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

@@ -0,0 +1,66 @@
+import { readFile } from 'node:fs/promises';
+/**
+ * URL do bundle ESM do `@simplewebauthn/browser` empacotado por
+ * `scripts/build_webauthn.mjs`.
+ *
+ * ⚠️ RESOLVIDO VIA `import.meta.url`, NUNCA relativo ao cwd. Os apps que
+ * consomem este pacote rodam `pnpm deploy --legacy`, que remonta a árvore de
+ * `node_modules` num diretório novo — um caminho relativo ao cwd do host
+ * apontaria para o lugar errado e a rota daria 404 em produção. Ancorado no
+ * módulo, o caminho segue o pacote para onde quer que ele seja copiado.
+ *
+ * Funciona nos dois layouts porque o bundle é commitado em `src/host/assets/`
+ * e copiado para `build/src/host/assets/` pelo script `build`:
+ *   dev   → src/host/controllers/…       → src/host/assets/webauthn.js
+ *   build → build/src/host/controllers/… → build/src/host/assets/webauthn.js
+ */
+const BUNDLE_URL = new URL('../assets/webauthn.js', import.meta.url);
+/**
+ * Cache do conteúdo do bundle. É imutável por versão do pacote — ler do disco
+ * a cada request de tela de login não compra nada.
+ *
+ * `null` = ainda não lido. `false` = lido e ausente (404 memoizado); sem isso
+ * um bundle faltando viraria um `readFile` que falha por request.
+ */
+let cached = null;
+/**
+ * GET /authkit/assets/webauthn.js
+ *
+ * Serve o `@simplewebauthn/browser` a partir do próprio host, substituindo o
+ * import de `cdn.jsdelivr.net` que as views de login/MFA/confirm faziam.
+ *
+ * SEM AUTENTICAÇÃO, e é intencional: é asset estático necessário na tela de
+ * login, ou seja, antes de existir qualquer sessão. Também não pode viver sob
+ * o prefixo do console admin (que é opt-in) — `login.edge` e
+ * `mfa-challenge.edge` precisam do script mesmo num host sem console.
+ */
+export default class WebauthnAssetController {
+    async handle(ctx) {
+        if (cached === null) {
+            try {
+                cached = await readFile(BUNDLE_URL);
+            }
+            catch {
+                cached = false;
+            }
+        }
+        if (cached === false) {
+            // 404 limpo: o bundle não foi gerado (`node scripts/build_webauthn.mjs`).
+            // A tela degrada para os demais fatores em vez de estourar 500.
+            return ctx.response.notFound();
+        }
+        return ctx.response
+            .type('text/javascript')
+            .header('Cache-Control', 'public, max-age=31536000, immutable')
+            .send(cached);
+    }
+}
+/**
+ * Limpa o cache do bundle. Existe para os testes conseguirem exercitar tanto o
+ * caminho feliz quanto o 404 no mesmo processo.
+ *
+ * @internal
+ */
+export function resetWebauthnAssetCache() {
+    cached = null;
+}

package/build/src/host/durable/account_deletion_workflow.js

@@ -75,7 +75,7 @@ export function defineAccountDeletionWorkflow(deps) {
         result.orgMemberships = orgResult.orgMemberships;
         result.orgInvitations = orgResult.orgInvitations;
         // 7) Avatar no drive.
-        result.avatarDeleted = (await ctx.step("delete.avatar", async () => deleteAccountAvatar((await deps.oidc()).config, snapshot.avatarUrl))).avatarDeleted;
+        result.avatarDeleted = (await ctx.step("delete.avatar", async () => deleteAccountAvatar((await deps.oidc()).config, accountId, snapshot.avatarUrl))).avatarDeleted;
         // 8) Anonimiza o histórico de audit.
         result.auditAnonymized = (await ctx.step("anonymize.audit", async () => anonymizeAudit((await deps.oidc()).config, accountId))).auditAnonymized;
         // 9) Deleta a linha da conta (ÚLTIMA etapa, forward-only).

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

@@ -560,6 +560,13 @@ export declare const DEFAULT_MESSAGES: {
     "account.confirm.error": string;
     "account.confirm.passkey_error": string;
     "account.confirm.passwordless_notice": string;
+    "account.confirm.method.password": string;
+    "account.confirm.method.passkey": string;
+    "account.confirm.method.magic_link": string;
+    "account.confirm.method.oidc_step_up": string;
+    "account.confirm.magic_link_sent": string;
+    "account.confirm.no_methods": string;
+    "account.confirm.preferred_badge": string;
     "admin.settings.sudo_mode_section": string;
     "admin.settings.sudo_mode_intro": string;
     "admin.settings.sudo_mode_from_config": string;
@@ -1242,6 +1249,13 @@ export declare const PT_BR_MESSAGES: {
     "account.confirm.error": string;
     "account.confirm.passkey_error": string;
     "account.confirm.passwordless_notice": string;
+    "account.confirm.method.password": string;
+    "account.confirm.method.passkey": string;
+    "account.confirm.method.magic_link": string;
+    "account.confirm.method.oidc_step_up": string;
+    "account.confirm.magic_link_sent": string;
+    "account.confirm.no_methods": string;
+    "account.confirm.preferred_badge": string;
     "admin.settings.sudo_mode_section": string;
     "admin.settings.sudo_mode_intro": string;
     "admin.settings.sudo_mode_from_config": string;

package/build/src/host/i18n.js

@@ -605,6 +605,14 @@ export const DEFAULT_MESSAGES = {
     "account.confirm.error": "Incorrect password.",
     "account.confirm.passkey_error": "Could not authenticate with the passkey. Please try again.",
     "account.confirm.passwordless_notice": "This account does not have a password. Please add a passkey to use sudo-protected features.",
+    // Rótulos dos métodos do SPI de sudo (account/confirm.edge, um bloco por método disponível).
+    "account.confirm.method.password": "Confirm with your password",
+    "account.confirm.method.passkey": "Confirm with a passkey",
+    "account.confirm.method.magic_link": "Email me a confirmation link",
+    "account.confirm.method.oidc_step_up": "Sign in again to confirm",
+    "account.confirm.magic_link_sent": "We sent a confirmation link to your email. It expires in 5 minutes.",
+    "account.confirm.no_methods": "No confirmation method is available for this account. Contact support.",
+    "account.confirm.preferred_badge": "Used last time",
     // Admin settings — sudo_mode card.
     "admin.settings.sudo_mode_section": "Sudo mode (identity confirmation)",
     "admin.settings.sudo_mode_intro": "When enabled, sensitive actions (password change, email change, account deletion, MFA/passkey management, PAT creation/revocation) require the user to confirm their password. The confirmation is valid for a configurable grace period.",
@@ -1359,6 +1367,14 @@ export const PT_BR_MESSAGES = {
     "account.confirm.error": "Senha incorreta.",
     "account.confirm.passkey_error": "Não foi possível autenticar com a passkey. Tente novamente.",
     "account.confirm.passwordless_notice": "Esta conta não possui senha. Adicione uma passkey para usar funcionalidades protegidas.",
+    // Rótulos dos métodos do SPI de sudo (account/confirm.edge, um bloco por método disponível).
+    "account.confirm.method.password": "Confirmar com a senha",
+    "account.confirm.method.passkey": "Confirmar com passkey",
+    "account.confirm.method.magic_link": "Receber link de confirmação por e-mail",
+    "account.confirm.method.oidc_step_up": "Entrar de novo para confirmar",
+    "account.confirm.magic_link_sent": "Enviamos um link de confirmação para o seu e-mail. Ele expira em 5 minutos.",
+    "account.confirm.no_methods": "Nenhum método de confirmação está disponível para esta conta. Fale com o suporte.",
+    "account.confirm.preferred_badge": "Usado da última vez",
     // Admin settings — sudo_mode card (pt-BR).
     "admin.settings.sudo_mode_section": "Modo sudo (confirmação de identidade)",
     "admin.settings.sudo_mode_intro": "Quando habilitado, ações sensíveis (troca de senha, troca de e-mail, exclusão de conta, gerência de MFA/passkey, criação/revogação de PAT) exigem que o usuário confirme sua senha. A confirmação é válida por um período de graça configurável.",

package/build/src/host/impersonation_session.js

@@ -98,6 +98,14 @@ export async function startImpersonation(ctx, params) {
     // Anti-fixation: rotaciona o id da sessão (mantém os dados) antes de gravar a
     // nova identidade. Mesmo padrão do consumidor real no RP.
     await ctx.session.regenerate();
+    // ESCALAÇÃO DE PRIVILÉGIO (fechada por vinculação): trocar a conta aqui NÃO
+    // pode carregar junto o sudo que o admin confirmou sobre a PRÓPRIA conta —
+    // senão ele entraria personificando já com a graça aberta sobre a conta
+    // alheia (exportar/excluir dados, MFA, PATs). Não limpamos a marca aqui: ela
+    // é vinculada à conta que a confirmou (`SUDO_ACCOUNT_SESSION_KEY`), então
+    // `isSudoActive` a recusa sozinho assim que `ACCOUNT_SESSION_KEY` muda. A
+    // garantia é estrutural — vale para qualquer troca de conta futura, sem
+    // depender de um `forget` lembrado em cada nova transição.
     ctx.session.put(IMPERSONATOR_SESSION_KEY, impersonatorId);
     ctx.session.put(ACCOUNT_SESSION_KEY, params.targetId);
 }
@@ -122,6 +130,13 @@ export async function stopImpersonation(ctx) {
     if (!impersonatorId)
         return;
     await ctx.session.regenerate();
+    // Simétrico ao `startImpersonation`: o sudo obtido ENQUANTO personificava
+    // ficaria valendo sobre a conta do admin ao voltar. A vinculação corta isso —
+    // aquela marca aponta para a conta personificada e morre com a volta.
+    //
+    // Nota: se o admin tinha sudo sobre a própria conta ANTES de personificar e a
+    // graça ainda não venceu, ele volta valendo. Correto e intencional: é a
+    // confirmação dele, sobre a conta dele, dentro da janela dele.
     ctx.session.put(ACCOUNT_SESSION_KEY, impersonatorId);
     ctx.session.forget(IMPERSONATOR_SESSION_KEY);
     ctx.session.forget(ADMIN_ACCESS_TOKEN_SESSION_KEY);

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

@@ -20,6 +20,16 @@ export interface AuthThrottles {
      * de tentativas vindas do MESMO IP independentemente de qual key foi usada (M8).
      */
     adminIp: ThrottleMiddleware;
+    /**
+     * Throttle das rotas dos métodos de sudo (`/account/confirm/*`), keyed por IP
+     * como o `login` — e com os MESMOS limites — mas em bucket PRÓPRIO.
+     *
+     * A separação é o ponto: `login` mede um anônimo tentando adivinhar
+     * credenciais, `sudo` mede um usuário já autenticado reprovando a própria
+     * identidade. Ver `ResolvedRateLimitConfig.sudo` para o porquê de os dois
+     * orçamentos não poderem se consumir.
+     */
+    sudo: ThrottleMiddleware;
 }
 /**
  * Service do `@adonisjs/limiter` resolvido de forma preguiçosa. Tipado como `any`

package/build/src/host/rate_limit.js

@@ -90,5 +90,11 @@ export function createAuthThrottles(config) {
         adminIp: buildThrottle('authkit_admin_ip', config.adminIp, config.store, (ctx) => {
             return `admin-ip:${ctx.request.ip?.() ?? 'unknown'}`;
         }),
+        // Rotas dos métodos de sudo: keyed por IP (default do HttpLimiter), igual ao
+        // login. O que separa os dois é o NOME do bucket — o limiter namespaceia a
+        // contagem por nome, então `authkit_login` e `authkit_sudo` nunca somam,
+        // mesmo vindo do mesmo IP. Sem `usingKey` próprio de propósito: inventar uma
+        // key aqui seria mudar o EIXO da contagem, e o eixo certo continua sendo o IP.
+        sudo: buildThrottle('authkit_sudo', config.sudo, config.store),
     };
 }

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

@@ -1,5 +1,6 @@
 import type { Router } from '@adonisjs/core/http';
 import type { AuthSocialConfig, RateLimitConfigInput } from '../define_config.js';
+import type { SudoMethod } from './sudo/types.js';
 /** Chave da sessão Adonis que registra o timestamp da última atividade (idle timeout). */
 export declare const ACCOUNT_LAST_SEEN_KEY = "authkit_last_seen";
 /**
@@ -89,6 +90,24 @@ export interface AuthHostOptions {
     adminApi?: boolean | {
         prefix?: string;
     };
+    /**
+     * Métodos de sudo cujas rotas devem ser montadas. Necessário aqui (e não só
+     * no config) porque a decisão de MONTAR rotas acontece em tempo de registro,
+     * antes de o config lazy resolver — mesma razão de `social`/`admin`/`rateLimit`.
+     * Espelhe o `sudo.methods` de config/authkit.ts.
+     *
+     * SUBSTITUI os defaults, não acrescenta: a lista é do host. Quem quer manter
+     * senha/passkey ao lado do método novo os inclui explicitamente
+     * (`[sudoMethods.password(), sudoMethods.passkey(), meuMetodo()]`).
+     *
+     * Sem esta opção, `config.sudo.methods` conseguiria OFERECER um método na
+     * tela mas nunca montar seu endpoint — a opção aparece e dá 404. Falha
+     * fechada, mas é a promessa do SPI pela metade; `magicLink()` em particular
+     * não teria como ser alcançado em runtime.
+     *
+     * Ausente → `[password(), passkey()]`.
+     */
+    sudoMethods?: SudoMethod[];
 }
 /**
  * Monta todas as rotas do host-kit do Authorization Server numa chamada.

package/build/src/host/register_auth_host.js

@@ -8,6 +8,19 @@ import { setAdminPrefix, normalizeAdminPrefix, setAdminApiPrefix, normalizeAdmin
 import { resolveRuntimeSettings } from './runtime_settings.js';
 import { resolveEffectiveSessionPolicy } from './runtime_toggles.js';
 import { getAuthHostConfig } from './auth_host_config.js';
+import { completeSudo, fail, guardSudoRoutes, sudoContextFrom, setMountedSudoMethods, } from './sudo/runtime.js';
+import { password as sudoPassword } from './sudo/methods/password.js';
+import { passkey as sudoPasskey } from './sudo/methods/passkey.js';
+/**
+ * Métodos de sudo montados quando o host não passa `sudoMethods` —
+ * comportamento histórico (senha + passkey).
+ *
+ * PONTO ÚNICO. A tela não tem mais uma cópia desta lista: sem
+ * `config.sudo.methods`, `configuredSudoMethods` cai no que FOI MONTADO, ou
+ * seja, no resultado do `??` abaixo. Duas listas de default é como os dois
+ * lados divergiam.
+ */
+const SUDO_METHOD_DEFAULTS = [sudoPassword(), sudoPasskey()];
 /** Chave da sessão Adonis que registra o timestamp da última atividade (idle timeout). */
 export const ACCOUNT_LAST_SEEN_KEY = 'authkit_last_seen';
 /**
@@ -138,6 +151,7 @@ const C = {
     accountMfa: () => import('./controllers/account_mfa_controller.js'),
     accountOrgs: () => import('./controllers/account_orgs_controller.js'),
     accountConfirm: () => import('./controllers/account_confirm_controller.js'),
+    webauthnAsset: () => import('./controllers/webauthn_asset_controller.js'),
     // Console React JSON API (session-authed, under {prefix}/api/*).
     consoleShell: () => import('./admin_console/admin_shell_controller.js'),
     consoleOverview: () => import('./admin_console/console_overview_controller.js'),
@@ -188,6 +202,25 @@ export function registerAuthHost(router, opts = {}) {
         if (throttles)
             route.use([throttles.introspection]);
     };
+    // Bucket PRÓPRIO das rotas de sudo. Antes elas levavam o `withLogin`, o que
+    // funcionava mas somava dois orçamentos que medem coisas diferentes: login é
+    // um anônimo adivinhando credenciais, sudo é um usuário JÁ autenticado
+    // reprovando a própria identidade. Ver `ResolvedRateLimitConfig.sudo`.
+    const withSudo = (route) => {
+        if (throttles)
+            route.use([throttles.sudo]);
+    };
+    // ─── Assets estáticos do host-kit (públicos, sem autenticação) ─────────────
+    // Bundle do @simplewebauthn/browser servido pelo próprio app, no lugar do
+    // import de CDN público que as views de login/MFA/confirm faziam.
+    //
+    // Path FIXO e no topo, de propósito:
+    //  • não pode viver sob o prefixo do console admin (`admin` é opt-in) —
+    //    login.edge e mfa-challenge.edge precisam do script em qualquer host;
+    //  • sem guard, porque é carregado NA tela de login, antes de haver sessão;
+    //  • registrado ANTES do wildcard `${mount}/*` para que nenhum mountPath
+    //    agressivo (ex.: '/') consiga engolir o asset e quebrar o login.
+    router.get('/authkit/assets/webauthn.js', [C.webauthnAsset]).as('authkit.assets.webauthn');
     // Provider OIDC (wildcard + root) — o que registerOidcRoutes fazia.
     router.any(`${mount}/*`, [C.oidc]).as('authkit.oidc.wildcard');
     router.any(mount, [C.oidc]).as('authkit.oidc.root');
@@ -269,11 +302,46 @@ export function registerAuthHost(router, opts = {}) {
         router.post('/account/mfa/passkeys/options', [C.accountMfa, 'passkeyRegisterOptions']);
         router.post('/account/mfa/passkeys/verify', [C.accountMfa, 'passkeyRegisterVerify']);
         router.post('/account/mfa/passkeys/:id/remove', [C.accountMfa, 'passkeyRemove']);
-        // Sudo mode (confirm identity): GET exibe o formulário; POST verifica a senha.
+        // Sudo mode (confirm identity): o GET lista os métodos; cada método
+        // registra suas próprias rotas de verificação (SPI `SudoMethod`).
         router.get('/account/confirm', [C.accountConfirm, 'show']);
-        router.post('/account/confirm', [C.accountConfirm, 'confirm']);
-        router.post('/account/confirm/passkey/options', [C.accountConfirm, 'passkeyOptions']);
-        router.post('/account/confirm/passkey', [C.accountConfirm, 'passkeyConfirm']);
+        // Rotas próprias dos métodos de sudo — DENTRO do grupo com `accountGuard`.
+        // O guard não é só "tem sessão": ele roda `checkAndRefreshIdle`, que apaga
+        // a sessão vencida por idle e refresca `authkit_last_seen`. Fora do grupo,
+        // uma sessão já vencida (ainda não colhida) podia postar a senha correta e
+        // receber `markSudo` — e as rotas de sudo não refrescavam o last-seen.
+        // Nenhum método built-in é alcançável por GET vindo de e-mail: o token de
+        // sudo por magic link vive na PRÓPRIA sessão, então o usuário precisa
+        // estar logado no mesmo navegador de qualquer forma. Um método que
+        // genuinamente não puder ficar sob o guard precisa de uma decisão
+        // explícita, não de mover todos para fora.
+        const helpers = {
+            contextFrom: sudoContextFrom,
+            completeSudo,
+            fail,
+        };
+        const sudoMethodsToMount = opts?.sudoMethods ?? SUDO_METHOD_DEFAULTS;
+        for (const method of sudoMethodsToMount) {
+            // `guardSudoRoutes` embrulha os handlers que o método registrar, para
+            // que `config.sudo.methods` os desabilite de fato mesmo que o método
+            // não tenha checado nada por dentro. Ver o docblock lá.
+            //
+            // `withSudo` vai junto: TODA rota de um método de sudo leva o throttle
+            // do bucket de SUDO (no-op sem rate-limit). Não é adorno — o POST que
+            // emite o magic link de sudo dispara um e-mail por chamada, e o
+            // `accountGuard` sozinho só exige uma sessão viva, que o abusador tem.
+            // Aplicar aqui, no wrapper, cobre também os métodos customizados, que
+            // não teriam como pedir throttle pelo `SudoRouteHelpers`.
+            //
+            // Bucket próprio, não o de login: mesmos limites, contagem separada —
+            // errar a senha na tela de confirmação não pode gastar o orçamento de
+            // login do IP, nem vice-versa.
+            method.register?.(guardSudoRoutes(router, method.id, helpers, withSudo), helpers);
+        }
+        // A lista montada é a fonte de verdade dos DOIS lados quando o host não
+        // configura `config.sudo.methods`: a tela oferece exatamente isto, e os
+        // handlers aceitam exatamente isto.
+        setMountedSudoMethods(sudoMethodsToMount);
         // Organizations (multi-tenancy) — sempre montadas; controller retorna 404/403 sem tabelas.
         router.get('/account/orgs', [C.accountOrgs, 'index']);
         router.post('/account/orgs', [C.accountOrgs, 'store']);