@dudousxd/adonis-authkit-server 0.1.0

package/build/src/host/account_lockout.js

@@ -0,0 +1,185 @@
+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 limiterServicePromise;
+/**
+ * Importa o service do limiter do HOST de forma preguiçosa e fail-safe (mesmo
+ * padrão de `rate_limit.ts`). Resolve `null` quando o limiter não está disponível.
+ */
+async function loadLimiter() {
+    if (!limiterServicePromise) {
+        const specifier = '@adonisjs/limiter/services/main';
+        limiterServicePromise = import(__rewriteRelativeImportExtension(specifier))
+            .then((mod) => mod.default ?? null)
+            .catch(() => null);
+    }
+    return limiterServicePromise;
+}
+/**
+ * Permite reapontar/limpar o loader do limiter (usado em testes).
+ * @internal
+ */
+export function __setLockoutLimiterLoaderForTests(fn) {
+    if (fn) {
+        limiterServicePromise = fn();
+    }
+    else {
+        limiterServicePromise = undefined;
+    }
+}
+/** Normaliza o email para virar chave estável (lowercase + trim). */
+function normalizeEmail(email) {
+    return (email ?? '').trim().toLowerCase();
+}
+/**
+ * Backoff progressivo PURO (sem I/O — fácil de testar): a duração do lock cresce
+ * com o número de locks já ocorridos para a chave: `base * 2^(lockCount-1)`,
+ * limitada a `maxLockoutSec`. `lockCount` é 1-based (1 = primeiro lock).
+ */
+export function computeLockoutSec(lockCount, cfg) {
+    const n = Math.max(1, lockCount);
+    const grown = cfg.baseLockoutSec * 2 ** (n - 1);
+    return Math.min(grown, cfg.maxLockoutSec);
+}
+/**
+ * Helper de lockout amarrado a uma config resolvida. Cada método é fail-safe:
+ * resolve o limiter preguiçosamente e degrada para no-op quando ele está ausente
+ * ou quando `cfg.enabled === false`.
+ */
+export class AccountLockout {
+    cfg;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    failKey(email) {
+        return `authkit_lockout_fail:${email}`;
+    }
+    lockKey(email) {
+        return `authkit_lockout:${email}`;
+    }
+    countKey(email) {
+        return `authkit_lockout_count:${email}`;
+    }
+    /**
+     * Resolve o limiter (ou `null`). Retorna `null` também quando lockout está
+     * desligado por config — assim o caminho de no-op é o mesmo.
+     */
+    async limiter() {
+        if (!this.cfg.enabled)
+            return null;
+        return loadLimiter();
+    }
+    /** Store de contagem de falhas (janela deslizante de `windowSec`). */
+    failStore(limiter) {
+        const opts = { requests: this.cfg.maxAttempts, duration: this.cfg.windowSec };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /**
+     * Store da contagem de locks. A janela é longa (mantém o histórico de locks por
+     * um tempo para o backoff progressivo crescer entre locks sucessivos).
+     */
+    countStore(limiter) {
+        const opts = { requests: 1_000_000, duration: this.cfg.maxLockoutSec * 4 };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /**
+     * Store dedicado a marcar a chave como bloqueada. `requests: 1` + `block(...)`
+     * com a duração progressiva; `isBlocked`/`availableIn` consultam o estado.
+     */
+    lockStore(limiter) {
+        const opts = { requests: 1, duration: this.cfg.maxLockoutSec };
+        return this.cfg.store ? limiter.use(this.cfg.store, opts) : limiter.use(opts);
+    }
+    /** `true`/retryAfter quando a conta está bloqueada. Fail-safe: `{ locked: false }`. */
+    async isLocked(email) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return { locked: false };
+        const limiter = await this.limiter();
+        if (!limiter)
+            return { locked: false };
+        try {
+            const store = this.lockStore(limiter);
+            const blocked = await store.isBlocked(this.lockKey(key));
+            if (!blocked)
+                return { locked: false };
+            const retryAfterSec = await store.availableIn(this.lockKey(key));
+            return { locked: true, retryAfterSec };
+        }
+        catch {
+            // Falha do limiter NUNCA derruba o login — degrada para "não bloqueado".
+            return { locked: false };
+        }
+    }
+    /**
+     * Registra uma falha de login. Ao cruzar `maxAttempts` dentro da janela, marca
+     * a chave como bloqueada com TTL progressivo e incrementa a contagem de locks.
+     * Emite `account.locked` UMA vez (na transição), não a cada tentativa bloqueada.
+     */
+    async recordFailure(email, audit) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return;
+        const limiter = await this.limiter();
+        if (!limiter)
+            return;
+        try {
+            // Se já está bloqueada, não conta de novo nem reemite o evento.
+            const lockStore = this.lockStore(limiter);
+            if (await lockStore.isBlocked(this.lockKey(key)))
+                return;
+            const failStore = this.failStore(limiter);
+            const res = await failStore.increment(this.failKey(key));
+            // `consumed` = falhas acumuladas na janela. Bloqueia ao atingir o teto.
+            const consumed = res?.consumed ?? 0;
+            if (consumed < this.cfg.maxAttempts)
+                return;
+            // Transição para bloqueado: incrementa a contagem de locks e calcula o TTL.
+            const countStore = this.countStore(limiter);
+            const countRes = await countStore.increment(this.countKey(key));
+            const lockCount = countRes?.consumed ?? 1;
+            const lockoutSec = computeLockoutSec(lockCount, this.cfg);
+            await lockStore.block(this.lockKey(key), lockoutSec);
+            // Zera o contador de falhas (a contagem recomeça após o lock).
+            await failStore.delete(this.failKey(key));
+            await audit?.sink?.record({
+                type: 'account.locked',
+                email: key,
+                ip: audit?.ip ?? null,
+                metadata: { lockCount, lockoutSec },
+            });
+        }
+        catch {
+            // Best-effort: nunca propaga erro do limiter para o caminho da request.
+        }
+    }
+    /**
+     * Limpa o estado de falhas após um login bem-sucedido. Remove o contador de
+     * falhas e o lock; mantém a contagem de locks (histórico para o backoff) — ela
+     * expira naturalmente pela janela longa do `countStore`.
+     */
+    async clearFailures(email) {
+        const key = normalizeEmail(email);
+        if (!key)
+            return;
+        const limiter = await this.limiter();
+        if (!limiter)
+            return;
+        try {
+            await this.failStore(limiter).delete(this.failKey(key));
+            await this.lockStore(limiter).delete(this.lockKey(key));
+        }
+        catch {
+            // no-op fail-safe
+        }
+    }
+}
+/** Fabrica o helper de lockout a partir da config resolvida. */
+export function createAccountLockout(cfg) {
+    return new AccountLockout(cfg);
+}

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

@@ -0,0 +1 @@
+export {};

package/build/src/host/augmentations.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+export interface ClientBrand {
+    appName: string;
+    accent: string;
+    accentSoft: string;
+    tagline: string;
+    company?: string;
+    audienceLabel?: string;
+}
+export interface BrandingConfig {
+    company: string;
+    clients: Record<string, Omit<ClientBrand, 'company' | 'audienceLabel'>>;
+    default: Omit<ClientBrand, 'company' | 'audienceLabel'>;
+    firstParty: string[];
+    audienceLabels?: Record<string, string>;
+}
+export declare function isFirstParty(cfg: BrandingConfig, clientId: string | undefined): boolean;
+export declare function brandFor(cfg: BrandingConfig, clientId: string | undefined, audience?: string): ClientBrand;

package/build/src/host/branding.js

@@ -0,0 +1,8 @@
+export function isFirstParty(cfg, clientId) {
+    return !!clientId && cfg.firstParty.includes(clientId);
+}
+export function brandFor(cfg, clientId, audience) {
+    const base = (clientId && cfg.clients[clientId]) || cfg.default;
+    const label = audience ? cfg.audienceLabels?.[audience] : undefined;
+    return { ...base, company: cfg.company, ...(label ? { audienceLabel: label } : {}) };
+}

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

@@ -0,0 +1,30 @@
+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<void | {
+        ok: boolean;
+    }>;
+    /** POST /account/mfa/passkeys/:id/remove — remove uma passkey da conta. */
+    passkeyRemove(ctx: HttpContext): Promise<void>;
+    /** 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<void>;
+}

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

@@ -0,0 +1,157 @@
+import '../augmentations.js';
+import QRCode from 'qrcode';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { translate } from '../i18n.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 = typeof cfg.accountStore.listPasskeys === 'function';
+        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: 'Passkeys indisponíveis' });
+        }
+        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);
+        const challenge = ctx.session.get(PASSKEY_REG_CHALLENGE_KEY);
+        if (!challenge) {
+            return ctx.response.badRequest({ message: 'Desafio expirado' });
+        }
+        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,
+        });
+        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);
+        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 },
+        });
+        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);
+        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,
+        });
+        // 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);
+        await cfg.accountStore.disableMfa?.(userId);
+        await cfg.audit?.record({
+            type: 'mfa.disabled',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return ctx.response.redirect('/account/mfa');
+    }
+}

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

@@ -0,0 +1,7 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+export default class AccountSessionController {
+    show(ctx: HttpContext): Promise<any>;
+    login(ctx: HttpContext): Promise<any>;
+    logout(ctx: HttpContext): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { translate } from '../i18n.js';
+import { createAccountLockout } from '../account_lockout.js';
+export default class AccountSessionController {
+    async show(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        if (ctx.session.get(ACCOUNT_SESSION_KEY)) {
+            return ctx.response.redirect('/account/tokens');
+        }
+        return render(ctx, 'account/login', { csrfToken: ctx.request.csrfToken });
+    }
+    async login(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const { email, password } = ctx.request.only(['email', 'password']);
+        const ip = ctx.request.ip?.() ?? null;
+        const lockout = createAccountLockout(cfg.lockout);
+        // Bloqueio progressivo: se a conta está travada, nem verifica a senha.
+        const lock = await lockout.isLocked(email);
+        if (lock.locked) {
+            return render(ctx, 'account/login', {
+                csrfToken: ctx.request.csrfToken,
+                error: translate(cfg.messages, 'errors.account_locked', {
+                    seconds: lock.retryAfterSec ?? 0,
+                }),
+            });
+        }
+        const acc = await cfg.accountStore.verifyCredentials(email, password);
+        if (!acc) {
+            await cfg.audit?.record({ type: 'login.failure', email, ip });
+            await lockout.recordFailure(email, { sink: cfg.audit, ip });
+            return render(ctx, 'account/login', {
+                csrfToken: ctx.request.csrfToken,
+                error: translate(cfg.messages, 'errors.invalid_credentials'),
+            });
+        }
+        await lockout.clearFailures(email);
+        ctx.session.put(ACCOUNT_SESSION_KEY, acc.id);
+        await cfg.audit?.record({ type: 'login.success', accountId: acc.id, email, ip });
+        return ctx.response.redirect('/account/tokens');
+    }
+    async logout(ctx) {
+        ctx.session.forget(ACCOUNT_SESSION_KEY);
+        return ctx.response.redirect('/account/login');
+    }
+}

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

@@ -0,0 +1,7 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+export default class AccountTokensController {
+    index(ctx: HttpContext): Promise<any>;
+    store(ctx: HttpContext): Promise<void>;
+    destroy(ctx: HttpContext): Promise<void>;
+}

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

@@ -0,0 +1,55 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+export default class AccountTokensController {
+    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 tokens = await cfg.patStore.listForAccount(userId);
+        const createdToken = ctx.session.flashMessages.get('createdToken');
+        return render(ctx, 'account/tokens', {
+            csrfToken: ctx.request.csrfToken,
+            createdToken: createdToken ?? null,
+            tokens: tokens.map((t) => ({
+                id: t.id,
+                name: t.name,
+                scopes: t.scopes,
+                audience: t.audience,
+                lastUsedAt: t.lastUsedAt,
+                createdAt: t.createdAt,
+            })),
+        });
+    }
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const { name } = ctx.request.only(['name']);
+        const { token, pat } = await cfg.patStore.issue({ accountId: userId, name: name || 'Token' });
+        ctx.session.flash('createdToken', token);
+        await cfg.audit?.record({
+            type: 'pat.issued',
+            accountId: userId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { patId: pat.id, name: pat.name },
+        });
+        return ctx.response.redirect('/account/tokens');
+    }
+    async destroy(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const patId = ctx.request.param('id');
+        const revoked = await cfg.patStore.revoke(userId, patId);
+        if (revoked) {
+            await cfg.audit?.record({
+                type: 'pat.revoked',
+                accountId: userId,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { patId },
+            });
+        }
+        return ctx.response.redirect('/account/tokens');
+    }
+}

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

@@ -0,0 +1,10 @@
+import '../../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Log de auditoria do IdP, paginado e filtrável por tipo e subject (accountId).
+ * Degrada graciosamente quando o sink configurado não suporta consulta: a view
+ * mostra "consulta não suportada" em vez de uma lista.
+ */
+export default class AdminAuditController {
+    index(ctx: HttpContext): Promise<any>;
+}

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

@@ -0,0 +1,56 @@
+import '../../augmentations.js';
+const PAGE_SIZE = 20;
+/**
+ * Log de auditoria do IdP, paginado e filtrável por tipo e subject (accountId).
+ * Degrada graciosamente quando o sink configurado não suporta consulta: a view
+ * mostra "consulta não suportada" em vez de uma lista.
+ */
+export default class AdminAuditController {
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        const supported = typeof cfg.audit?.list === 'function';
+        const type = ctx.request.input('type', '').trim();
+        const subject = ctx.request.input('subject', '').trim();
+        const page = Math.max(1, Number.parseInt(ctx.request.input('page', '1'), 10) || 1);
+        if (!supported) {
+            return render(ctx, 'admin/audit', {
+                csrfToken: ctx.request.csrfToken,
+                supported: false,
+                type,
+                subject,
+                page: 1,
+                totalPages: 1,
+                total: 0,
+                events: [],
+            });
+        }
+        const result = await cfg.audit.list({
+            page,
+            limit: PAGE_SIZE,
+            type: type || undefined,
+            subject: subject || undefined,
+        });
+        const totalPages = Math.max(1, Math.ceil(result.total / PAGE_SIZE));
+        return render(ctx, 'admin/audit', {
+            csrfToken: ctx.request.csrfToken,
+            supported: true,
+            type,
+            subject,
+            page,
+            totalPages,
+            total: result.total,
+            events: result.data.map((e) => ({
+                id: e.id,
+                type: e.type,
+                accountId: e.accountId ?? '',
+                email: e.email ?? '',
+                clientId: e.clientId ?? '',
+                actorId: e.actorId ?? '',
+                ip: e.ip ?? '',
+                createdAt: e.createdAt ? String(e.createdAt) : '',
+            })),
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import '../../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
+ * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
+ * aqui — a view informa isso quando o registro dinâmico está ligado.
+ */
+export default class AdminClientsController {
+    index(ctx: HttpContext): Promise<any>;
+}

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

@@ -0,0 +1,24 @@
+import '../../augmentations.js';
+/**
+ * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
+ * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
+ * aqui — a view informa isso quando o registro dinâmico está ligado.
+ */
+export default class AdminClientsController {
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        return render(ctx, 'admin/clients', {
+            csrfToken: ctx.request.csrfToken,
+            dynamicEnabled: cfg.dynamicRegistration.enabled,
+            clients: cfg.clients.map((c) => ({
+                clientId: c.clientId,
+                confidential: !!c.clientSecret,
+                grants: c.grants ?? ['authorization_code', 'refresh_token'],
+                redirectUris: c.redirectUris ?? [],
+                postLogoutRedirectUris: c.postLogoutRedirectUris ?? [],
+            })),
+        });
+    }
+}

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

@@ -0,0 +1,10 @@
+import '../../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Dashboard do console admin: contagens-resumo (usuários, clients estáticos) e
+ * os eventos de auditoria mais recentes. Degrada graciosamente quando o sink de
+ * auditoria não suporta consulta (`list` ausente).
+ */
+export default class AdminDashboardController {
+    index(ctx: HttpContext): Promise<any>;
+}