@adonis-agora/authkit-server 0.34.0

package/build/src/host/console_session.js

@@ -0,0 +1,36 @@
+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
+ * adonis-telescope, rotas administrativas próprias, etc).
+ *
+ * Use estes helpers em vez de ler `ctx.session` com a key interna —
+ * eles são contrato público e continuam funcionando se o mecanismo de
+ * sessão mudar.
+ */
+/**
+ * Retorna o id da conta logada no console (ou `null` quando não há
+ * sessão).
+ */
+export function getAccountId(ctx) {
+    const accountId = ctx.session?.get(ACCOUNT_SESSION_KEY);
+    return accountId ?? null;
+}
+/**
+ * `true` quando o request carrega uma sessão de conta do console.
+ */
+export function hasAccountSession(ctx) {
+    return getAccountId(ctx) !== null;
+}
+/**
+ * URL do login do console, com `return_to` opcional de volta ao destino
+ * original após autenticar.
+ *
+ * @example
+ * consoleLoginUrl('/telescope') // => '/account/login?return_to=%2Ftelescope'
+ */
+export function consoleLoginUrl(returnTo) {
+    if (!returnTo)
+        return '/account/login';
+    return `/account/login?return_to=${encodeURIComponent(returnTo)}`;
+}

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

@@ -0,0 +1,15 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * 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
+ * config estática ou do payload do adapter) e permite revogar o acesso de um
+ * client (destrói os grants + AT/RT daquele client). Degrada graciosamente quando
+ * o adapter OIDC não enumera (`list`), espelhando o console admin.
+ */
+export default class AccountAppsController {
+    /** GET /account/apps — lista os apps com acesso (grants) da conta logada. */
+    index(ctx: HttpContext): Promise<any>;
+    /** POST /account/apps/:clientId/revoke — revoga o acesso de um client. */
+    revoke(ctx: HttpContext): Promise<void>;
+}

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

@@ -0,0 +1,61 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { AdminSessionsService } from '../admin_sessions_service.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
+ * config estática ou do payload do adapter) e permite revogar o acesso de um
+ * client (destrói os grants + AT/RT daquele client). Degrada graciosamente quando
+ * o adapter OIDC não enumera (`list`), espelhando o console admin.
+ */
+export default class AccountAppsController {
+    /** GET /account/apps — lista os apps com acesso (grants) da conta logada. */
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const sessions = new AdminSessionsService(service);
+        const supported = sessions.canList;
+        const grantList = supported ? await sessions.listGrants(accountId) : [];
+        // Resolve o nome amigável do client: clientId é o fallback (config estática não
+        // carrega um display name).
+        const nameOf = (clientId) => clientId ?? '';
+        const revoked = ctx.session.flashMessages.get('appRevoked');
+        return render(ctx, 'account/apps', {
+            csrfToken: ctx.request.csrfToken,
+            supported,
+            revoked: revoked ?? null,
+            apps: grantList
+                .filter((g) => !!g.clientId)
+                .map((g) => ({
+                clientId: g.clientId,
+                name: nameOf(g.clientId),
+                accessTokens: g.accessTokens,
+                refreshTokens: g.refreshTokens,
+            })),
+        });
+    }
+    /** POST /account/apps/:clientId/revoke — revoga o acesso de um client. */
+    async revoke(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const clientId = ctx.request.param('clientId');
+        const sessions = new AdminSessionsService(service);
+        const result = await sessions.revokeClientGrants(accountId, clientId);
+        await cfg.audit?.record({
+            type: 'grant.revoked_by_user',
+            accountId,
+            clientId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: {
+                grants: result.grants,
+                accessTokens: result.accessTokens,
+                refreshTokens: result.refreshTokens,
+            },
+        });
+        ctx.session.flash('appRevoked', cfg.messages['account.apps.revoked'] ?? 'account.apps.revoked');
+        return ctx.response.redirect('/account/apps');
+    }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ *
+ * 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 type { HttpContext } from '@adonisjs/core/http';
+export default class AccountConfirmController {
+    show(ctx: HttpContext): Promise<any>;
+    confirm(ctx: HttpContext): Promise<void>;
+    passkeyOptions(ctx: HttpContext): Promise<any>;
+    passkeyConfirm(ctx: HttpContext): Promise<void>;
+    /**
+     * Verifica se a conta é "passwordless" (sem hash de senha definido).
+     * Fail-safe: retorna `false` quando não é possível determinar.
+     */
+    private isPasswordless;
+}

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

@@ -0,0 +1,144 @@
+/**
+ * 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.
+ *
+ * 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';
+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', {
+            csrfToken: ctx.request.csrfToken,
+            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' },
+        });
+        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_mfa_controller.d.ts

@@ -0,0 +1,28 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * 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.
+ */
+export default class AccountMfaController {
+    /** GET /account/mfa — estado atual; oferece enroll se desligado. */
+    index(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /account/mfa/passkeys/options — gera as opções de registro de passkey
+     * (JSON), guarda o challenge na sessão e devolve as opções para o browser.
+     */
+    passkeyRegisterOptions(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /account/mfa/passkeys/verify — verifica a resposta de registro do browser
+     * contra o challenge guardado; em caso de sucesso persiste a credencial e habilita MFA.
+     */
+    passkeyRegisterVerify(ctx: HttpContext): Promise<unknown>;
+    /** POST /account/mfa/passkeys/:id/remove — remove uma passkey da conta. */
+    passkeyRemove(ctx: HttpContext): Promise<unknown>;
+    /** POST /account/mfa/enroll — gera segredo pendente + QR e mostra a confirmação. */
+    enroll(ctx: HttpContext): Promise<any>;
+    /** POST /account/mfa/confirm — confirma o código; sucesso = ativa e mostra recovery codes. */
+    confirm(ctx: HttpContext): Promise<any>;
+    /** POST /account/mfa/disable — desliga o MFA. */
+    disable(ctx: HttpContext): Promise<unknown>;
+}

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

@@ -0,0 +1,208 @@
+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 { resolveRuntimeSettings } from '../runtime_settings.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';
+/**
+ * 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.
+ */
+export default class AccountMfaController {
+    /** GET /account/mfa — estado atual; oferece enroll se desligado. */
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const state = (await cfg.accountStore.getMfaState?.(userId)) ?? { enabled: false };
+        const recoveryCodes = ctx.session.flashMessages.get('recoveryCodes');
+        // 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', {
+            csrfToken: ctx.request.csrfToken,
+            enabled: state.enabled,
+            recoveryCodes: recoveryCodes ?? null,
+            passkeysSupported,
+            passkeys,
+        });
+    }
+    /**
+     * POST /account/mfa/passkeys/options — gera as opções de registro de passkey
+     * (JSON), guarda o challenge na sessão e devolve as opções para o browser.
+     */
+    async passkeyRegisterOptions(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.generatePasskeyRegistrationOptions?.(userId);
+        if (!generated) {
+            return ctx.response.notFound({
+                message: translate(cfg.messages, 'errors.passkeys_unavailable'),
+            });
+        }
+        ctx.session.put(PASSKEY_REG_CHALLENGE_KEY, generated.challenge);
+        return generated.options;
+    }
+    /**
+     * POST /account/mfa/passkeys/verify — verifica a resposta de registro do browser
+     * contra o challenge guardado; em caso de sucesso persiste a credencial e habilita MFA.
+     */
+    async passkeyRegisterVerify(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        // Sudo mode gate.
+        const sudoSettingsPkAdd = await resolveRuntimeSettings(ctx);
+        const sudoResultPkAdd = await requireSudo(ctx, sudoSettingsPkAdd);
+        if (sudoResultPkAdd !== true)
+            return sudoResultPkAdd;
+        const challenge = ctx.session.get(PASSKEY_REG_CHALLENGE_KEY);
+        if (!challenge) {
+            return ctx.response.badRequest({
+                message: translate(cfg.messages, 'errors.challenge_expired'),
+            });
+        }
+        const body = ctx.request.input('response', ctx.request.body());
+        const ok = (await cfg.accountStore.verifyPasskeyRegistration?.(userId, body, challenge)) ?? false;
+        ctx.session.forget(PASSKEY_REG_CHALLENGE_KEY);
+        if (!ok) {
+            return ctx.response.badRequest({ message: translate(cfg.messages, 'errors.invalid_code') });
+        }
+        await cfg.audit?.record({
+            type: 'mfa.enabled',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { method: 'webauthn' },
+        });
+        await cfg.audit?.record({
+            type: 'passkey.registered',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        // Notificações de segurança: passkey_added + mfa_enabled (best-effort).
+        const accountForNotice = await cfg.accountStore.findById(userId);
+        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);
+        }
+        return { ok: true };
+    }
+    /** POST /account/mfa/passkeys/:id/remove — remove uma passkey da conta. */
+    async passkeyRemove(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        // Sudo mode gate.
+        const sudoSettingsPkRm = await resolveRuntimeSettings(ctx);
+        const sudoResultPkRm = await requireSudo(ctx, sudoSettingsPkRm);
+        if (sudoResultPkRm !== true)
+            return sudoResultPkRm;
+        const credentialId = ctx.request.param('id');
+        await cfg.accountStore.removePasskey?.(userId, credentialId);
+        await cfg.audit?.record({
+            type: 'passkey.removed',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { credentialId },
+        });
+        // 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);
+        }
+        return ctx.response.redirect('/account/mfa');
+    }
+    /** POST /account/mfa/enroll — gera segredo pendente + QR e mostra a confirmação. */
+    async enroll(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);
+        // Sudo mode gate.
+        const sudoSettingsEnroll = await resolveRuntimeSettings(ctx);
+        const sudoResultEnroll = await requireSudo(ctx, sudoSettingsEnroll);
+        if (sudoResultEnroll !== true)
+            return sudoResultEnroll;
+        const started = await cfg.accountStore.startTotpEnrollment?.(userId);
+        if (!started) {
+            return ctx.response.redirect('/account/mfa');
+        }
+        // QR renderizado server-side como data-URL e passado como prop.
+        const qrDataUrl = await QRCode.toDataURL(started.otpauthUri);
+        return render(ctx, 'account/mfa', {
+            csrfToken: ctx.request.csrfToken,
+            enabled: false,
+            enrolling: true,
+            secret: started.secret,
+            qrDataUrl,
+            recoveryCodes: null,
+        });
+    }
+    /** POST /account/mfa/confirm — confirma o código; sucesso = ativa e mostra recovery codes. */
+    async confirm(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 { code } = ctx.request.only(['code']);
+        const result = (await cfg.accountStore.confirmTotpEnrollment?.(userId, code)) ?? { ok: false };
+        if (!result.ok) {
+            // 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', {
+                csrfToken: ctx.request.csrfToken,
+                enabled: false,
+                enrolling: true,
+                secret: null,
+                qrDataUrl: null,
+                error: translate(cfg.messages, 'errors.invalid_code'),
+                recoveryCodes: null,
+            });
+        }
+        await cfg.audit?.record({
+            type: 'mfa.enabled',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        // 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);
+        }
+        // Mostra os recovery codes UMA vez (flash) e volta pro estado "ativado".
+        ctx.session.flash('recoveryCodes', result.recoveryCodes ?? []);
+        return ctx.response.redirect('/account/mfa');
+    }
+    /** POST /account/mfa/disable — desliga o MFA. */
+    async disable(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        // Sudo mode gate.
+        const sudoSettingsDisable = await resolveRuntimeSettings(ctx);
+        const sudoResultDisable = await requireSudo(ctx, sudoSettingsDisable);
+        if (sudoResultDisable !== true)
+            return sudoResultDisable;
+        await cfg.accountStore.disableMfa?.(userId);
+        await cfg.audit?.record({
+            type: 'mfa.disabled',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        // 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);
+        }
+        return ctx.response.redirect('/account/mfa');
+    }
+}

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

@@ -0,0 +1,80 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Console de conta — Organizations. Server-rendered, padrão dos outros controllers
+ * de conta (account_tokens_controller, account_security_controller, etc.).
+ *
+ * Rotas montadas em register_auth_host quando supportsOrganizations(store) — capability-probed.
+ * O guard `accountGuard` (já existente) protege todas as rotas de /account/* abaixo.
+ */
+export default class AccountOrgsController {
+    index(ctx: HttpContext): Promise<any>;
+    /** POST /account/orgs — criar nova org (requer allowSelfCreate). */
+    store(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/:id/activate — define org ativa (valida membership). */
+    activate(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/deactivate — remove org ativa. */
+    deactivate(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/:id/leave — sai da org (verifica last_owner). */
+    leave(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/:id/invite — convida membro por e-mail. */
+    invite(ctx: HttpContext): Promise<void>;
+    /** GET /account/orgs/invitations/:token/accept — mostra tela de aceite. */
+    showAcceptInvitation(ctx: HttpContext): Promise<any>;
+    /** POST /account/orgs/invitations/:token/accept — processa aceite. */
+    acceptInvitation(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/:id/members/:accountId/remove */
+    removeMember(ctx: HttpContext): Promise<void>;
+    /** POST /account/orgs/:id/invitations/:invId/revoke */
+    revokeInvitation(ctx: HttpContext): Promise<void>;
+    /**
+     * GET /account/orgs/json — lista as orgs do usuário logado com papel + se ativa.
+     * Usado pelo hook `useOrganizations()`.
+     */
+    listJson(ctx: HttpContext): Promise<void | {
+        supported: boolean;
+        activeOrgId: any;
+        orgs: {
+            id: string;
+            name: string;
+            slug: string;
+            logoUrl: string | null;
+            role: string;
+            isActive: boolean;
+        }[];
+    }>;
+    /**
+     * GET /account/orgs/:id/json — detalhes da org ativa (para uso pelo hook `useOrganization()`).
+     * Só retorna se o usuário é membro.
+     */
+    showJson(ctx: HttpContext): Promise<void | {
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        role: string;
+        canManage: boolean;
+        members: {
+            accountId: string;
+            email: string | null;
+            role: string;
+            joinedAt: string;
+        }[];
+    }>;
+    /**
+     * GET /account/orgs/invitations/json — lista convites pendentes pro e-mail do usuário logado.
+     * Usado pelo hook `useOrgInvitations()`.
+     */
+    listInvitationsJson(ctx: HttpContext): Promise<void | {
+        invitations: {
+            id: string;
+            organizationId: string;
+            orgName: string;
+            orgSlug: string;
+            email: string;
+            role: string;
+            expiresAt: string;
+            createdAt: string;
+        }[];
+    }>;
+}