@dudousxd/adonis-authkit-server 0.5.0 → 0.7.0

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

@@ -60,4 +60,12 @@ export declare class AdminSessionsService {
      * deixando o store limpo. Retorna as contagens do que foi removido.
      */
     revokeAll(accountId: string): Promise<RevokeResult>;
+    /**
+     * Revoga os grants de uma conta para UM client específico (+ tokens ligados),
+     * deixando os demais clients intactos. Reaproveita a lógica de {@link revokeAll}
+     * restrita ao `clientId`. Usado pelo self-service de consentimento
+     * (/account/apps) e por qualquer revogação granular do admin. Retorna as
+     * contagens do que foi removido.
+     */
+    revokeClientGrants(accountId: string, clientId: string): Promise<RevokeResult>;
 }

package/build/src/host/admin_sessions_service.js

@@ -108,6 +108,25 @@ export class AdminSessionsService {
             refreshTokens,
         };
     }
+    /**
+     * Revoga os grants de uma conta para UM client específico (+ tokens ligados),
+     * deixando os demais clients intactos. Reaproveita a lógica de {@link revokeAll}
+     * restrita ao `clientId`. Usado pelo self-service de consentimento
+     * (/account/apps) e por qualquer revogação granular do admin. Retorna as
+     * contagens do que foi removido.
+     */
+    async revokeClientGrants(accountId, clientId) {
+        const grantAdapter = this.#adapter('Grant');
+        const grants = (await this.listGrants(accountId)).filter((g) => g.clientId === clientId);
+        const grantIds = new Set(grants.map((g) => g.id));
+        const accessTokens = await this.#destroyTokensOfGrants('AccessToken', grantIds);
+        const refreshTokens = await this.#destroyTokensOfGrants('RefreshToken', grantIds);
+        for (const g of grants) {
+            await grantAdapter.revokeByGrantId(g.id);
+            await grantAdapter.destroy(g.id);
+        }
+        return { sessions: 0, grants: grants.length, accessTokens, refreshTokens };
+    }
     /** Destrói (quando enumerável) os artefatos de um model token cujos grantId estão em `grantIds`. */
     async #destroyTokensOfGrants(model, grantIds) {
         const adapter = this.#adapter(model);

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

@@ -0,0 +1,58 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedUploadsConfig } from '../define_config.js';
+/**
+ * Upload de avatar do host-kit usando o `@adonisjs/drive` JÁ configurado no app.
+ * Mesmo princípio do default_mailer/rate_limit: por padrão usamos a infra do
+ * host (o disk DEFAULT do drive do app), sem o dev precisar escrever nada; tudo
+ * é sobreponível via `config/authkit.ts` (`uploads.avatars`).
+ *
+ * Best-effort / fail-safe: se `@adonisjs/drive` não estiver instalado/configurado,
+ * {@link storeAvatar} retorna `null` e a feature degrada para o input de URL.
+ * Nunca lança na request por causa de drive ausente.
+ */
+/**
+ * Service do `@adonisjs/drive` resolvido de forma preguiçosa. Tipado como `any` de
+ * propósito: a lib NÃO depende do drive em tempo de compilação (peer/opt-in).
+ */
+type DriveService = any;
+/**
+ * Permite reapontar/limpar o loader do drive (usado em testes).
+ * @internal
+ */
+export declare function __setDriveLoaderForTests(fn: (() => Promise<DriveService | null>) | undefined): void;
+/** Erro de validação do upload (mensagem já localizada no controller). */
+export declare class AvatarUploadError extends Error {
+    reason: 'extname' | 'size';
+    constructor(reason: 'extname' | 'size', message: string);
+}
+/** File de multipart mínimo que precisamos do `request.file('avatar')`. */
+export interface UploadedAvatar {
+    extname?: string | null;
+    size?: number;
+    /** Caminho temporário (drive lê daqui para stream). */
+    tmpPath?: string | null;
+    /** Move o arquivo para um disk do drive (API v3+). */
+    moveToDisk?: (key: string, options?: {
+        disk?: string;
+    }) => Promise<void>;
+}
+/**
+ * Indica se o drive do app está disponível (para a view decidir mostrar o input
+ * de arquivo). Best-effort: nunca lança.
+ */
+export declare function isDriveAvailable(): Promise<boolean>;
+/**
+ * Armazena o avatar no drive do host e retorna a URL pública.
+ *
+ * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
+ * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ *
+ * Nunca lança por causa de drive ausente; só lança em validação.
+ */
+export declare function storeAvatar(_ctx: HttpContext, cfg: ResolvedUploadsConfig, file: UploadedAvatar, accountId: string, messages: {
+    extname: string;
+    size: string;
+}): Promise<string | null>;
+export {};

package/build/src/host/avatar_storage.js

@@ -0,0 +1,125 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+let driveServicePromise;
+/**
+ * Importa o service de drive do HOST de forma preguiçosa e fail-safe.
+ * Se `@adonisjs/drive` não estiver instalado, resolve `null`.
+ */
+async function loadDrive() {
+    if (!driveServicePromise) {
+        // Indireção via variável: o `@adonisjs/drive` é peer/opcional e pode não estar
+        // instalado na lib, então o specifier não é resolvido em build-time.
+        const specifier = '@adonisjs/drive/services/main';
+        driveServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod.default ?? null)
+            .catch(() => null);
+    }
+    return driveServicePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do drive (usado em testes).
+ * @internal
+ */
+export function __setDriveLoaderForTests(fn) {
+    if (fn) {
+        driveServicePromise = fn();
+    }
+    else {
+        driveServicePromise = undefined;
+    }
+}
+/** Extensões aceitas para o avatar (imagem raster comum). */
+const ALLOWED_EXTNAMES = ['jpg', 'jpeg', 'png', 'webp'];
+/** Erro de validação do upload (mensagem já localizada no controller). */
+export class AvatarUploadError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'AvatarUploadError';
+    }
+}
+/**
+ * Indica se o drive do app está disponível (para a view decidir mostrar o input
+ * de arquivo). Best-effort: nunca lança.
+ */
+export async function isDriveAvailable() {
+    return (await loadDrive()) !== null;
+}
+/**
+ * Resolve a extensão validada do arquivo enviado.
+ * Lança {@link AvatarUploadError} se ext/size forem inválidos.
+ */
+function validate(file, cfg, messages) {
+    const ext = (file.extname ?? '').toLowerCase().replace(/^\./, '');
+    if (!ALLOWED_EXTNAMES.includes(ext)) {
+        throw new AvatarUploadError('extname', messages.extname);
+    }
+    const maxBytes = cfg.avatars.maxSizeMb * 1024 * 1024;
+    if (typeof file.size === 'number' && file.size > maxBytes) {
+        throw new AvatarUploadError('size', messages.size);
+    }
+    return ext;
+}
+/**
+ * Gera uma chave única para o avatar dentro do diretório configurado.
+ * `${directory}/${accountId}-${random}.${ext}`
+ */
+function buildKey(cfg, accountId, ext) {
+    const random = Math.random().toString(36).slice(2, 10);
+    return `${cfg.avatars.directory}/${accountId}-${random}.${ext}`;
+}
+/**
+ * Armazena o avatar no drive do host e retorna a URL pública.
+ *
+ * - Valida extensão (jpg/jpeg/png/webp) e tamanho (≤ maxSizeMb) — lança
+ *   {@link AvatarUploadError} se inválido (o controller traduz/flasha).
+ * - Usa o disk configurado em `uploads.avatars.disk` ou o disk DEFAULT do app.
+ * - Se o drive estiver ausente/não-configurado → retorna `null` (degrada para URL).
+ *
+ * Nunca lança por causa de drive ausente; só lança em validação.
+ */
+export async function storeAvatar(_ctx, cfg, file, accountId, messages) {
+    const drive = await loadDrive();
+    if (!drive)
+        return null;
+    const ext = validate(file, cfg, messages);
+    // Resolve o disk: o configurado, ou o DEFAULT do drive do app.
+    let disk;
+    try {
+        disk = cfg.avatars.disk ? drive.use(cfg.avatars.disk) : drive.use();
+    }
+    catch {
+        // disk inválido/não-configurado — degrada para URL.
+        return null;
+    }
+    if (!disk)
+        return null;
+    const key = buildKey(cfg, accountId || 'account', ext);
+    // API @adonisjs/drive v3+: o file de multipart move-se direto para o disk.
+    // `moveToDisk` lê do tmpPath e usa o disk informado (ou o default da config).
+    if (typeof file.moveToDisk === 'function') {
+        await file.moveToDisk(key, cfg.avatars.disk ? { disk: cfg.avatars.disk } : undefined);
+    }
+    else if (file.tmpPath) {
+        // Fallback: lê do tmpPath e escreve via putStream no disk resolvido.
+        const fs = await import('node:fs');
+        await disk.putStream(key, fs.createReadStream(file.tmpPath));
+    }
+    else {
+        return null;
+    }
+    try {
+        return await disk.getUrl(key);
+    }
+    catch {
+        // disk sem getUrl público — retorna a key como referência relativa.
+        return key;
+    }
+}

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_security_controller.d.ts

@@ -9,6 +9,15 @@ import type { HttpContext } from '@adonisjs/core/http';
  */
 export default class AccountSecurityController {
     index(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /account/security/trusted-devices/revoke
+     * Limpa o cookie de dispositivo confiável DESTE navegador (o MFA volta a ser
+     * exigido aqui). Revogação global por-dispositivo não existe sem estado
+     * server-side; re-enrolar o MFA invalida a confiança em TODOS os dispositivos.
+     */
+    revokeTrustedDevices(ctx: HttpContext): Promise<void>;
+    /** POST /account/security/profile — atualiza nome + avatar do próprio perfil. */
+    updateProfile(ctx: HttpContext): Promise<void>;
     changePassword(ctx: HttpContext): Promise<void>;
     changeEmail(ctx: HttpContext): Promise<void>;
     /** GET /account/email/confirm?token=... — consome o token e aplica o novo e-mail. */

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

@@ -1,9 +1,11 @@
 import '../augmentations.js';
 import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
-import { supportsAccountSecurity } from '../../accounts/account_store.js';
-import { changePasswordValidator, changeEmailValidator } from '../validators.js';
+import { supportsAccountSecurity, supportsProfile } from '../../accounts/account_store.js';
+import { changePasswordValidator, changeEmailValidator, updateProfileValidator } from '../validators.js';
 import { sendEmailChangeConfirmationEmail } from '../default_mailer.js';
+import { storeAvatar, isDriveAvailable, AvatarUploadError } from '../avatar_storage.js';
 import { translate } from '../i18n.js';
+import { TRUSTED_DEVICE_COOKIE } from '../trusted_device.js';
 /**
  * Self-service de segurança da conta (console de conta): trocar a senha e o
  * e-mail. A troca de senha exige a senha ATUAL (verifyCredentials). A troca de
@@ -21,13 +23,93 @@ export default class AccountSecurityController {
         return render(ctx, 'account/security', {
             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(),
             email: account?.email ?? '',
+            name: account?.name ?? '',
+            avatarUrl: account?.avatarUrl ?? '',
             passwordChanged: ctx.session.flashMessages.get('passwordChanged') ?? null,
             emailChangeRequested: ctx.session.flashMessages.get('emailChangeRequested') ?? null,
             emailChanged: ctx.session.flashMessages.get('emailChanged') ?? null,
+            profileUpdated: ctx.session.flashMessages.get('profileUpdated') ?? null,
             error: ctx.session.flashMessages.get('securityError') ?? null,
+            trustedDevicesEnabled: cfg.trustedDevices.enabled,
+            trustedDevicesRevoked: ctx.session.flashMessages.get('trustedDevicesRevoked') ?? null,
         });
     }
+    /**
+     * POST /account/security/trusted-devices/revoke
+     * Limpa o cookie de dispositivo confiável DESTE navegador (o MFA volta a ser
+     * exigido aqui). Revogação global por-dispositivo não existe sem estado
+     * server-side; re-enrolar o MFA invalida a confiança em TODOS os dispositivos.
+     */
+    async revokeTrustedDevices(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        ctx.response.clearCookie(TRUSTED_DEVICE_COOKIE);
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        await cfg.audit?.record({
+            type: 'trusted_device.revoked',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        ctx.session.flash('trustedDevicesRevoked', translate(cfg.messages, 'account.security.trusted_devices_revoked'));
+        return ctx.response.redirect('/account/security');
+    }
+    /** POST /account/security/profile — atualiza nome + avatar do próprio perfil. */
+    async updateProfile(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        if (!supportsProfile(store)) {
+            return ctx.response.redirect('/account/security');
+        }
+        const { name, avatarUrl } = await ctx.request.validateUsing(updateProfileValidator);
+        // Upload de avatar via o drive do app (opt-in pela presença do arquivo).
+        // Se um arquivo for enviado e o drive estiver disponível, a URL resultante
+        // tem prioridade sobre o input de URL; senão caímos no avatarUrl (texto).
+        let resolvedAvatarUrl = avatarUrl ?? null;
+        let via = 'url';
+        const file = ctx.request.file('avatar', {
+            size: `${cfg.uploads.avatars.maxSizeMb}mb`,
+            extnames: ['jpg', 'jpeg', 'png', 'webp'],
+        });
+        if (file) {
+            try {
+                const uploadedUrl = await storeAvatar(ctx, cfg.uploads, file, userId, {
+                    extname: translate(cfg.messages, 'account.profile.avatar_invalid_type'),
+                    size: translate(cfg.messages, 'account.profile.avatar_too_large'),
+                });
+                if (uploadedUrl) {
+                    resolvedAvatarUrl = uploadedUrl;
+                    via = 'upload';
+                }
+            }
+            catch (error) {
+                if (error instanceof AvatarUploadError) {
+                    ctx.session.flash('securityError', error.message);
+                    return ctx.response.redirect('/account/security');
+                }
+                throw error;
+            }
+        }
+        // Campos ausentes no form viram string vazia (limpa o valor); enviamos null
+        // para limpar, ou o valor trimado.
+        await store.updateProfile(userId, {
+            name: name ?? null,
+            avatarUrl: resolvedAvatarUrl,
+        });
+        await cfg.audit?.record({
+            type: 'profile.updated',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { via },
+        });
+        ctx.session.flash('profileUpdated', translate(cfg.messages, 'account.profile.updated'));
+        return ctx.response.redirect('/account/security');
+    }
     async changePassword(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;

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

@@ -28,7 +28,9 @@ export default class AccountSessionController {
                     ? translate(cfg.messages, 'errors.account_locked', {
                         seconds: result.retryAfterSec ?? 0,
                     })
-                    : translate(cfg.messages, 'errors.invalid_credentials'),
+                    : result.disabled
+                        ? translate(cfg.messages, 'errors.account_disabled')
+                        : translate(cfg.messages, 'errors.invalid_credentials'),
             });
         }
         const acc = result.account;

package/build/src/host/controllers/admin/admin_users_controller.d.ts

@@ -6,6 +6,19 @@ import type { HttpContext } from '@adonisjs/core/http';
  * vírgula no formulário e normalizadas aqui.
  */
 export default class AdminUsersController {
+    #private;
     index(ctx: HttpContext): Promise<any>;
+    /**
+     * POST /admin/users — cria uma conta. Se `password` for informado, a conta já
+     * nasce com senha. Senão, emite um token de reset e envia o e-mail (o usuário
+     * define a própria senha) — fluxo "create + invite". Audita `user.created`.
+     */
+    store(ctx: HttpContext): Promise<void>;
+    /** POST /admin/users/:id/reset-password — emite token de reset + envia e-mail. */
+    resetPassword(ctx: HttpContext): Promise<void>;
+    /** POST /admin/users/:id/disable — desabilita a conta (bloqueia login). */
+    disable(ctx: HttpContext): Promise<void>;
+    /** POST /admin/users/:id/enable — reabilita a conta. */
+    enable(ctx: HttpContext): Promise<void>;
     updateRoles(ctx: HttpContext): Promise<void>;
 }

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

@@ -1,4 +1,9 @@
 import '../../augmentations.js';
+import { randomBytes } from 'node:crypto';
+import { supportsAccountStatus } from '../../../accounts/account_store.js';
+import { ACCOUNT_SESSION_KEY } from '../../middleware/account_auth.js';
+import { adminCreateUserValidator } from '../../validators.js';
+import { sendPasswordResetEmail } from '../../default_mailer.js';
 const PAGE_SIZE = 20;
 /**
  * Gestão de usuários do IdP: listagem paginada com busca por e-mail e edição das
@@ -14,21 +19,149 @@ export default class AdminUsersController {
         const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
         const result = await cfg.accountStore.listAccounts({ search, page, limit: PAGE_SIZE });
         const totalPages = Math.max(1, Math.ceil(result.total / PAGE_SIZE));
+        const store = cfg.accountStore;
+        const statusSupported = supportsAccountStatus(store);
+        // Resolve o estado de disabled por conta (só quando suportado).
+        const disabledMap = new Map();
+        if (statusSupported) {
+            for (const u of result.data) {
+                disabledMap.set(u.id, await store.isDisabled(u.id));
+            }
+        }
         return render(ctx, 'admin/users', {
             csrfToken: ctx.request.csrfToken,
             search,
             page,
             totalPages,
             total: result.total,
+            statusSupported,
+            created: ctx.session.flashMessages.get('userCreated') ?? null,
+            resetSent: ctx.session.flashMessages.get('resetSent') ?? null,
+            statusChanged: ctx.session.flashMessages.get('statusChanged') ?? null,
+            error: ctx.session.flashMessages.get('usersError') ?? null,
             users: result.data.map((u) => ({
                 id: u.id,
                 email: u.email,
                 name: u.name ?? '',
                 roles: u.globalRoles ?? [],
                 rolesText: (u.globalRoles ?? []).join(', '),
+                disabled: disabledMap.get(u.id) ?? false,
             })),
         });
     }
+    /**
+     * POST /admin/users — cria uma conta. Se `password` for informado, a conta já
+     * nasce com senha. Senão, emite um token de reset e envia o e-mail (o usuário
+     * define a própria senha) — fluxo "create + invite". Audita `user.created`.
+     */
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const actorId = ctx.session.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const { email, name, password } = await ctx.request.validateUsing(adminCreateUserValidator);
+        const existing = await store.findByEmail(email);
+        if (existing) {
+            ctx.session.flash('usersError', cfg.messages['errors.email_taken'] ?? 'errors.email_taken');
+            return ctx.response.redirect('/admin/users');
+        }
+        // Sem senha informada: cria com uma senha aleatória forte (descartável) e
+        // dispara o fluxo de reset para o usuário definir a sua.
+        const initialPassword = password ?? randomBytes(24).toString('hex');
+        const account = await store.create({ email, password: initialPassword, fullName: name ?? null });
+        await cfg.audit?.record({
+            type: 'user.created',
+            accountId: account.id,
+            email,
+            actorId,
+            ip,
+            metadata: { invited: !password },
+        });
+        if (!password) {
+            await this.#sendResetEmail(ctx, cfg, email);
+        }
+        ctx.session.flash('userCreated', cfg.messages['admin.users.created'] ?? 'admin.users.created');
+        return ctx.response.redirect('/admin/users');
+    }
+    /** POST /admin/users/:id/reset-password — emite token de reset + envia e-mail. */
+    async resetPassword(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const actorId = ctx.session.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const accountId = ctx.request.param('id');
+        const account = await store.findById(accountId);
+        if (account) {
+            await this.#sendResetEmail(ctx, cfg, account.email);
+            await cfg.audit?.record({
+                type: 'user.password_reset_sent',
+                accountId,
+                email: account.email,
+                actorId,
+                ip,
+            });
+        }
+        ctx.session.flash('resetSent', cfg.messages['admin.users.reset_sent'] ?? 'admin.users.reset_sent');
+        return this.#redirectBack(ctx);
+    }
+    /** POST /admin/users/:id/disable — desabilita a conta (bloqueia login). */
+    async disable(ctx) {
+        return this.#toggleStatus(ctx, true);
+    }
+    /** POST /admin/users/:id/enable — reabilita a conta. */
+    async enable(ctx) {
+        return this.#toggleStatus(ctx, false);
+    }
+    async #toggleStatus(ctx, disable) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const store = cfg.accountStore;
+        const actorId = ctx.session.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const accountId = ctx.request.param('id');
+        if (supportsAccountStatus(store)) {
+            if (disable)
+                await store.disableAccount(accountId);
+            else
+                await store.enableAccount(accountId);
+            await cfg.audit?.record({
+                type: disable ? 'user.disabled' : 'user.enabled',
+                accountId,
+                actorId,
+                ip,
+            });
+            ctx.session.flash('statusChanged', cfg.messages[disable ? 'admin.users.disabled' : 'admin.users.enabled'] ??
+                (disable ? 'admin.users.disabled' : 'admin.users.enabled'));
+        }
+        return this.#redirectBack(ctx);
+    }
+    /** Emite o token de reset e dispara o e-mail (hook do config tem prioridade). */
+    async #sendResetEmail(ctx, cfg, email) {
+        const issued = await cfg.accountStore.issuePasswordResetToken(email);
+        if (!issued)
+            return;
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const resetUrl = `${origin}/auth/reset-password?token=${encodeURIComponent(issued.token)}`;
+        if (cfg.mail?.onPasswordReset) {
+            await cfg.mail.onPasswordReset({ email, resetUrl, token: issued.token });
+        }
+        else {
+            await sendPasswordResetEmail(ctx, { email, resetUrl });
+        }
+    }
+    #redirectBack(ctx) {
+        const search = ctx.request.input('search', '').trim();
+        const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
+        const qs = new URLSearchParams();
+        if (search)
+            qs.set('search', search);
+        if (page > 1)
+            qs.set('page', String(page));
+        const query = qs.toString();
+        return ctx.response.redirect(`/admin/users${query ? `?${query}` : ''}`);
+    }
     async updateRoles(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;

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

@@ -32,6 +32,38 @@ export default class AuthInteractionController {
     private stepUpExtra;
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     private hasPasskeys;
+    /**
+     * Lê o cookie de dispositivo confiável (encriptado, appKey-backed) e valida que
+     * pertence a `accountId`, não expirou e é posterior ao último (re)enrollment de
+     * MFA. Step-up NÃO chama isto (força sempre o MFA). Best-effort: qualquer erro de
+     * leitura → não confiável.
+     */
+    private checkTrustedDevice;
+    /**
+     * Se o checkbox "confiar neste dispositivo" foi marcado E o mecanismo está ligado,
+     * grava o cookie encriptado de confiança para a conta (skip MFA por N dias).
+     */
+    private maybeTrustDevice;
+    /**
+     * accountId para uma cerimônia de passkey no login. Prioriza o accountId pendente
+     * do MFA (passkey como 2º fator). Quando ausente e o passkey-first está ligado,
+     * resolve a conta pelo e-mail guardado na sessão (passkey ANTES da senha) — só se
+     * a conta existe E tem ao menos uma passkey.
+     */
+    private resolvePasskeyAccountId;
+    /**
+     * POST /auth/interaction/:uid/magic
+     * Magic link: lê o e-mail da sessão (passwordless.magicLink ligado), emite um
+     * token de uso único e dispara o e-mail. SEMPRE renderiza "link enviado",
+     * independentemente de a conta existir (anti-enumeração). Throttled como o login.
+     */
+    magicLinkRequest(ctx: HttpContext): Promise<any>;
+    /**
+     * GET /auth/interaction/:uid/magic?token=...
+     * Consome o magic link. Em sucesso finaliza o login (amr `['email']`). Token
+     * inválido/expirado volta ao início do login.
+     */
+    magicLinkConsume(ctx: HttpContext): Promise<void>;
     /**
      * POST /auth/interaction/:uid/passkey/options
      * Gera as opções de autenticação por passkey para o accountId pendente do MFA,