@dudousxd/adonis-authkit-server 0.3.0 → 0.5.0

package/build/src/accounts/lucid_store/core.js

@@ -1,9 +1,12 @@
 import { randomBytes } from 'node:crypto';
 import { DateTime } from 'luxon';
+/** Prefixo do token de troca de e-mail (reaproveita a coluna emailVerificationToken). */
+const EMAIL_CHANGE_PREFIX = 'ec:';
 /**
  * Núcleo SEMPRE presente do {@link CoreAccountStore} sobre um model Lucid:
- * identidade, cadastro, reset de senha, verificação de e-mail e administração
- * (listagem paginada + roles globais).
+ * identidade, cadastro, reset de senha, verificação de e-mail, administração
+ * (listagem paginada + roles globais) e o self-service de segurança
+ * ({@link AccountSecurityCapability}: trocar senha/e-mail).
  */
 export function buildCore(ctx) {
     const { Model, toAccount } = ctx;
@@ -66,6 +69,10 @@ export function buildCore(ctx) {
         async consumeEmailVerificationToken(token) {
             if (!token)
                 return false;
+            // Tokens de troca de e-mail (`ec:`) NÃO são verificações de cadastro — só o
+            // fluxo de confirmEmailChange pode consumi-los.
+            if (token.startsWith(EMAIL_CHANGE_PREFIX))
+                return false;
             const row = await Model.query().where('emailVerificationToken', token).first();
             if (!row)
                 return false;
@@ -104,5 +111,63 @@ export function buildCore(ctx) {
             row.globalRoles = roles;
             await row.save();
         },
+        // ----- Self-service de segurança (console de conta) -----
+        async changePassword(accountId, newPassword) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            // O hash acontece no @beforeSave do mixin withAuthUser ao detectar $dirty.password.
+            row.password = newPassword;
+            await row.save();
+            return true;
+        },
+        async requestEmailChange(accountId, newEmail) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return null;
+            // Não permite tomar um e-mail já usado por OUTRA conta.
+            const taken = await Model.query().where('email', newEmail).first();
+            if (taken && taken.id !== row.id)
+                return null;
+            // Token = `ec:<base64url(newEmail)>:<random>`. Reaproveita a coluna
+            // emailVerificationToken (sem migração nova); o prefixo `ec:` distingue do
+            // token de verificação de cadastro. O e-mail viaja codificado no próprio
+            // token, então não precisamos de coluna extra para o "pending email".
+            const encodedEmail = Buffer.from(newEmail, 'utf8').toString('base64url');
+            const token = `${EMAIL_CHANGE_PREFIX}${encodedEmail}:${randomBytes(24).toString('hex')}`;
+            row.emailVerificationToken = token;
+            await row.save();
+            return { token, account: toAccount(row), newEmail };
+        },
+        async confirmEmailChange(token) {
+            if (!token || !token.startsWith(EMAIL_CHANGE_PREFIX))
+                return { ok: false };
+            const parts = token.split(':');
+            // Forma esperada: ['ec', '<b64email>', '<random>']
+            if (parts.length !== 3)
+                return { ok: false };
+            let newEmail;
+            try {
+                newEmail = Buffer.from(parts[1], 'base64url').toString('utf8');
+            }
+            catch {
+                return { ok: false };
+            }
+            if (!newEmail)
+                return { ok: false };
+            const row = await Model.query().where('emailVerificationToken', token).first();
+            if (!row)
+                return { ok: false };
+            // Defesa contra corrida: o e-mail pode ter sido tomado entre o pedido e a
+            // confirmação por outra conta.
+            const taken = await Model.query().where('email', newEmail).first();
+            if (taken && taken.id !== row.id)
+                return { ok: false };
+            row.email = newEmail;
+            row.emailVerifiedAt = DateTime.now();
+            row.emailVerificationToken = null;
+            await row.save();
+            return { ok: true, account: toAccount(row), newEmail };
+        },
     };
 }

package/build/src/adapters/adapter_contract.d.ts

@@ -11,6 +11,11 @@ export interface EnumeratedClient {
     clientId: string;
     payload: Record<string, unknown>;
 }
+/** Um artefato OIDC enumerado de um model qualquer (id + payload persistido). */
+export interface EnumeratedArtifact {
+    id: string;
+    payload: Record<string, unknown>;
+}
 /** Contrato que o oidc-provider espera de um adapter (um por model). */
 export interface OidcAdapter {
     upsert(id: string, payload: OidcPayload, expiresIn: number): Promise<void>;
@@ -25,6 +30,18 @@ export interface OidcAdapter {
      * pelo console admin, para listar clients persistidos (registro dinâmico/CRUD).
      * Capacidade OPCIONAL (estilo `AuditSink.list`): adapters que não conseguem
      * enumerar de forma barata omitem o método e a UI degrada graciosamente.
+     *
+     * @deprecated Use {@link list} (genérico). Mantido por compat: quando presente,
+     * delega para `list()` (o adapter é sempre instanciado com `model = 'Client'`).
      */
     listClients?(): Promise<EnumeratedClient[]>;
+    /**
+     * Enumeração GENÉRICA dos artefatos do model deste adapter (id + payload). Usada
+     * pelo console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens
+     * (sessões ativas + revogação). Capacidade OPCIONAL (estilo `AuditSink.list`):
+     * adapters que não conseguem enumerar de forma barata omitem o método e a UI
+     * degrada graciosamente. O adapter já é escopado a UM model na construção
+     * (`new AdapterClass(model)`), então não recebe parâmetro.
+     */
+    list?(): Promise<EnumeratedArtifact[]>;
 }

package/build/src/adapters/database_adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from '@adonisjs/lucid/database';
-import type { EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
+import type { EnumeratedArtifact, EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
 export declare class DatabaseAdapter implements OidcAdapter {
     #private;
     private name;
@@ -13,10 +13,14 @@ export declare class DatabaseAdapter implements OidcAdapter {
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
     /**
-     * Enumera os clients persistidos (registro dinâmico ou CRUD do console admin).
-     * Filtra por `model_name = this.name` (sempre 'Client' aqui) e descarta linhas
-     * expiradas — clients são persistidos sem TTL (`expires_at` NULL), então isso
-     * só é uma rede de segurança caso algum dia algo grave o model com expiração.
+     * Enumeração genérica dos artefatos do model deste adapter (id + payload).
+     * Filtra por `model_name = this.name` e descarta linhas expiradas. Usada pelo
+     * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
+     */
+    list(): Promise<EnumeratedArtifact[]>;
+    /**
+     * Compat: enumera os clients persistidos. Delega para {@link list} (o adapter é
+     * instanciado com `model_name = 'Client'`), reprojetando `id` → `clientId`.
      */
     listClients(): Promise<EnumeratedClient[]>;
 }

package/build/src/adapters/database_adapter.js

@@ -61,20 +61,27 @@ export class DatabaseAdapter {
         await this.db.query().from(TABLE).where('grant_id', grantId).delete();
     }
     /**
-     * Enumera os clients persistidos (registro dinâmico ou CRUD do console admin).
-     * Filtra por `model_name = this.name` (sempre 'Client' aqui) e descarta linhas
-     * expiradas — clients são persistidos sem TTL (`expires_at` NULL), então isso
-     * só é uma rede de segurança caso algum dia algo grave o model com expiração.
+     * Enumeração genérica dos artefatos do model deste adapter (id + payload).
+     * Filtra por `model_name = this.name` e descarta linhas expiradas. Usada pelo
+     * console admin para listar `Client` (CRUD) e `Session`/`Grant`/tokens.
      */
-    async listClients() {
+    async list() {
         const rows = await this.#query().orderBy('id', 'asc');
         const now = Date.now();
         const result = [];
         for (const row of rows) {
             if (row.expires_at && new Date(row.expires_at).getTime() <= now)
                 continue;
-            result.push({ clientId: row.id, payload: JSON.parse(row.payload) });
+            result.push({ id: row.id, payload: JSON.parse(row.payload) });
         }
         return result;
     }
+    /**
+     * Compat: enumera os clients persistidos. Delega para {@link list} (o adapter é
+     * instanciado com `model_name = 'Client'`), reprojetando `id` → `clientId`.
+     */
+    async listClients() {
+        const rows = await this.list();
+        return rows.map((r) => ({ clientId: r.id, payload: r.payload }));
+    }
 }

package/build/src/adapters/redis_adapter.d.ts

@@ -1,5 +1,5 @@
 import type { Redis } from 'ioredis';
-import type { EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
+import type { EnumeratedArtifact, EnumeratedClient, OidcAdapter, OidcPayload } from './adapter_contract.js';
 export declare class RedisAdapter implements OidcAdapter {
     #private;
     private name;
@@ -14,10 +14,16 @@ export declare class RedisAdapter implements OidcAdapter {
     destroy(id: string): Promise<void>;
     revokeByGrantId(grantId: string): Promise<void>;
     /**
-     * Enumera os clients persistidos via SCAN sobre o prefixo de chave do model
-     * (`<prefix>:Client:*`). É limpo porque cada artefato é uma chave única já
-     * namespaceada por `prefix` + `name`; SCAN é não-bloqueante (cursor) ao
-     * contrário de KEYS. Usado apenas pelo console admin (model 'Client').
+     * Enumeração genérica dos artefatos do model deste adapter via SCAN sobre o
+     * prefixo de chave do model (`<prefix>:<name>:*`). É limpo porque cada artefato
+     * é uma chave única já namespaceada por `prefix` + `name`; SCAN é não-bloqueante
+     * (cursor) ao contrário de KEYS. Usado pelo console admin (`Client`, `Session`,
+     * `Grant`, tokens).
+     */
+    list(): Promise<EnumeratedArtifact[]>;
+    /**
+     * Compat: enumera os clients persistidos. Delega para {@link list} (o adapter é
+     * instanciado com `name = 'Client'`), reprojetando `id` → `clientId`.
      */
     listClients(): Promise<EnumeratedClient[]>;
 }

package/build/src/adapters/redis_adapter.js

@@ -93,12 +93,13 @@ export class RedisAdapter {
         await multi.exec();
     }
     /**
-     * Enumera os clients persistidos via SCAN sobre o prefixo de chave do model
-     * (`<prefix>:Client:*`). É limpo porque cada artefato é uma chave única já
-     * namespaceada por `prefix` + `name`; SCAN é não-bloqueante (cursor) ao
-     * contrário de KEYS. Usado apenas pelo console admin (model 'Client').
+     * Enumeração genérica dos artefatos do model deste adapter via SCAN sobre o
+     * prefixo de chave do model (`<prefix>:<name>:*`). É limpo porque cada artefato
+     * é uma chave única já namespaceada por `prefix` + `name`; SCAN é não-bloqueante
+     * (cursor) ao contrário de KEYS. Usado pelo console admin (`Client`, `Session`,
+     * `Grant`, tokens).
      */
-    async listClients() {
+    async list() {
         const prefix = `${this.prefix}:${this.name}:`;
         const result = [];
         let cursor = '0';
@@ -110,12 +111,20 @@ export class RedisAdapter {
                 if (!data)
                     continue;
                 result.push({
-                    clientId: key.slice(prefix.length),
+                    id: key.slice(prefix.length),
                     payload: JSON.parse(data),
                 });
             }
         } while (cursor !== '0');
-        result.sort((a, b) => a.clientId.localeCompare(b.clientId));
+        result.sort((a, b) => a.id.localeCompare(b.id));
         return result;
     }
+    /**
+     * Compat: enumera os clients persistidos. Delega para {@link list} (o adapter é
+     * instanciado com `name = 'Client'`), reprojetando `id` → `clientId`.
+     */
+    async listClients() {
+        const rows = await this.list();
+        return rows.map((r) => ({ clientId: r.id, payload: r.payload }));
+    }
 }

package/build/src/audit/audit_sink.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tipos de eventos de auditoria relevantes para segurança emitidos pelo IdP.
  */
-export type AuditEventType = 'login.success' | 'login.failure' | 'signup' | 'password_reset.issued' | 'password_reset.consumed' | 'pat.issued' | 'pat.revoked' | 'pat.used' | 'impersonation' | 'mfa.enabled' | 'mfa.disabled' | 'account.locked' | 'passkey.registered' | 'passkey.removed' | 'email_verification.issued' | 'email_verification.consumed' | 'client.created' | 'client.updated' | 'client.deleted';
+export type AuditEventType = 'login.success' | 'login.failure' | 'signup' | 'password_reset.issued' | 'password_reset.consumed' | 'pat.issued' | 'pat.revoked' | 'pat.used' | 'impersonation' | 'mfa.enabled' | 'mfa.disabled' | 'account.locked' | 'passkey.registered' | 'passkey.removed' | 'email_verification.issued' | 'email_verification.consumed' | 'client.created' | 'client.updated' | 'client.deleted' | 'session.revoked_all' | 'password.changed' | 'email.change_requested' | 'email.changed' | 'login.new_ip_notified';
 /**
  * Evento de auditoria a registrar. O timestamp é definido pelo sink (não aqui).
  */

package/build/src/define_config.d.ts

@@ -89,6 +89,22 @@ export interface ResolvedLockoutConfig {
     store?: string;
 }
 export declare function resolveLockout(input?: LockoutConfigInput): ResolvedLockoutConfig;
+/**
+ * Notificações de segurança por e-mail (best-effort, fire-and-forget). Hoje cobre
+ * o alerta de NOVO acesso (login de um IP nunca visto antes para a conta).
+ */
+export interface NotificationsConfigInput {
+    /**
+     * Envia um e-mail "novo acesso à sua conta" quando um login bem-sucedido vem de
+     * um IP sem `login.success` anterior para a conta. Default: true. A checagem do
+     * histórico usa o `audit.list` (degrada para no-op se o sink não consulta).
+     */
+    newLoginEmail?: boolean;
+}
+export interface ResolvedNotificationsConfig {
+    newLoginEmail: boolean;
+}
+export declare function resolveNotifications(input?: NotificationsConfigInput): ResolvedNotificationsConfig;
 /**
  * Registro dinâmico de clients (OIDC Dynamic Client Registration — RFC 7591).
  *
@@ -123,6 +139,72 @@ export interface ResolvedDynamicRegistrationConfig {
  * (RFC 7591) — `management: true` com `enabled: false` é um erro de configuração.
  */
 export declare function resolveDynamicRegistration(input?: DynamicRegistrationConfigInput): ResolvedDynamicRegistrationConfig;
+/**
+ * Device Authorization Grant (RFC 8628). Quando habilitado, o oidc-provider expõe
+ * o `device_authorization_endpoint` (`/device/auth`) e a tela de verificação de
+ * user-code (`/device`). O grant `urn:ietf:params:oauth:grant-type:device_code`
+ * deve ser concedido ao client (lista `grants`) para o fluxo funcionar.
+ */
+export interface DeviceFlowConfigInput {
+    /** Liga o Device Authorization Grant. Default: false. */
+    enabled: boolean;
+}
+export interface ResolvedDeviceFlowConfig {
+    enabled: boolean;
+}
+export declare function resolveDeviceFlow(input?: DeviceFlowConfigInput): ResolvedDeviceFlowConfig;
+/**
+ * DPoP — Demonstrating Proof of Possession (RFC 9449). Quando habilitado, o
+ * oidc-provider aceita DPoP proofs e emite tokens sender-constrained
+ * (`token_type: DPoP`, com `cnf.jkt`). A discovery passa a anunciar
+ * `dpop_signing_alg_values_supported`. Os resolvers do authkit-client aceitam o
+ * token via introspecção (a cnf viaja no resultado) — a geração de provas DPoP no
+ * client está fora de escopo (documentado como trabalho futuro).
+ */
+export interface DpopConfigInput {
+    /** Liga o DPoP. Default: false. */
+    enabled: boolean;
+}
+export interface ResolvedDpopConfig {
+    enabled: boolean;
+}
+export declare function resolveDpop(input?: DpopConfigInput): ResolvedDpopConfig;
+/**
+ * PAR — Pushed Authorization Requests (RFC 9126). Quando habilitado, o
+ * oidc-provider expõe o `pushed_authorization_request_endpoint` (`/request`): o
+ * client POSTa os parâmetros de authorize e recebe um `request_uri` opaco para
+ * usar no `/auth`. Com `requirePushedAuthorizationRequests`, o `/auth` SÓ aceita
+ * requests via `request_uri` (parâmetros inline são rejeitados).
+ */
+export interface ParConfigInput {
+    /** Liga o PAR. Default: false. */
+    enabled: boolean;
+    /** Exige que TODO authorize venha via request_uri do PAR. Default: false. */
+    requirePushedAuthorizationRequests?: boolean;
+}
+export interface ResolvedParConfig {
+    enabled: boolean;
+    requirePushedAuthorizationRequests: boolean;
+}
+export declare function resolvePar(input?: ParConfigInput): ResolvedParConfig;
+/**
+ * Step-up authentication via `acr_values` (MVP pragmático de MFA por requisição).
+ * Quando o client solicita `acr_values` contendo `mfaAcr`, o login EXIGE o 2º
+ * fator: contas com MFA enrolado passam pelo desafio (o `acr` do id_token vira
+ * `mfaAcr` e `amr` recebe `['mfa', método]`); contas SEM MFA enrolado têm o login
+ * bloqueado naquela requisição com a instrução de configurar MFA no console.
+ */
+export interface StepUpConfigInput {
+    /** Lista de acr_values anunciados como suportados (discovery). */
+    acrValues?: string[];
+    /** O acr que dispara a exigência de MFA. Default: 'urn:authkit:mfa'. */
+    mfaAcr?: string;
+}
+export interface ResolvedStepUpConfig {
+    acrValues: string[];
+    mfaAcr: string;
+}
+export declare function resolveStepUp(input?: StepUpConfigInput): ResolvedStepUpConfig;
 /**
  * Console admin opt-in do IdP (B6). Quando habilitado, monta o grupo `/admin/*`
  * (dashboard, usuários/papéis, clients, audit) atrás de um guard que exige sessão
@@ -193,6 +275,8 @@ export interface AuthServerConfigInput {
     rateLimit?: RateLimitConfigInput;
     /** Bloqueio progressivo de conta por email em falhas repetidas. Default: ligado (no-op sem limiter). */
     lockout?: LockoutConfigInput;
+    /** Notificações de segurança por e-mail (alerta de novo acesso). Default: ligado. */
+    notifications?: NotificationsConfigInput;
     /** Hooks de e-mail (reset de senha / verificação). Opcional — fallback de log em dev. */
     mail?: MailHooks;
     /** Sink de auditoria (best-effort). Opcional — quando ausente, auditoria é no-op. */
@@ -213,6 +297,14 @@ export interface AuthServerConfigInput {
      * os clients registrados são persistidos pelo mesmo adapter OIDC.
      */
     dynamicRegistration?: DynamicRegistrationConfigInput;
+    /** Device Authorization Grant (RFC 8628). Default: desligado. */
+    deviceFlow?: DeviceFlowConfigInput;
+    /** DPoP — sender-constrained tokens (RFC 9449). Default: desligado. */
+    dpop?: DpopConfigInput;
+    /** Pushed Authorization Requests (RFC 9126). Default: desligado. */
+    par?: ParConfigInput;
+    /** Step-up auth via acr_values (MFA por requisição). Default: vazio (só o mfaAcr derivado). */
+    stepUp?: StepUpConfigInput;
     /**
      * Console admin do IdP (B6). Default: desligado. Quando ligado, o host também
      * deve passar `admin: true` em {@link AuthHostOptions} no registro de rotas
@@ -250,12 +342,22 @@ export interface ResolvedServerConfig {
     rateLimit: ResolvedRateLimitConfig;
     /** Bloqueio progressivo de conta resolvido (sempre presente; default ligado). */
     lockout: ResolvedLockoutConfig;
+    /** Notificações de segurança resolvidas (sempre presente; default ligado). */
+    notifications: ResolvedNotificationsConfig;
     mail?: MailHooks;
     audit?: AuditSink;
     mfaIssuer: string;
     /** RP de WebAuthn resolvido (sempre presente; derivado do issuer por default). */
     webauthn: ResolvedWebauthnConfig;
     dynamicRegistration: ResolvedDynamicRegistrationConfig;
+    /** Device Authorization Grant resolvido (default desligado). */
+    deviceFlow: ResolvedDeviceFlowConfig;
+    /** DPoP resolvido (default desligado). */
+    dpop: ResolvedDpopConfig;
+    /** PAR resolvido (default desligado). */
+    par: ResolvedParConfig;
+    /** Step-up auth resolvido (mfaAcr sempre presente). */
+    stepUp: ResolvedStepUpConfig;
     /** Console admin resolvido (sempre presente; default desligado). */
     admin: ResolvedAdminConfig;
     /** Catálogo de mensagens ativo (locale resolvido), pronto para os renderers. */

package/build/src/define_config.js

@@ -1,5 +1,6 @@
 import { configProvider } from '@adonisjs/core';
 import { generateJwks } from './keys/jwks_manager.js';
+import { ensureKeystore } from './keys/keystore.js';
 import { adapters } from './adapters/factory.js';
 import { resolveMessages } from './host/i18n.js';
 export { adapters };
@@ -26,6 +27,11 @@ export function resolveLockout(input) {
         store: input?.store,
     };
 }
+export function resolveNotifications(input) {
+    return {
+        newLoginEmail: input?.newLoginEmail ?? true,
+    };
+}
 /**
  * Resolve a config de registro dinâmico e VALIDA invariantes em tempo de resolução.
  * O Registration Management (RFC 7592) só faz sentido com o registro habilitado
@@ -45,6 +51,24 @@ export function resolveDynamicRegistration(input) {
         management,
     };
 }
+export function resolveDeviceFlow(input) {
+    return { enabled: input?.enabled ?? false };
+}
+export function resolveDpop(input) {
+    return { enabled: input?.enabled ?? false };
+}
+export function resolvePar(input) {
+    return {
+        enabled: input?.enabled ?? false,
+        requirePushedAuthorizationRequests: input?.requirePushedAuthorizationRequests ?? false,
+    };
+}
+export function resolveStepUp(input) {
+    const mfaAcr = input?.mfaAcr ?? 'urn:authkit:mfa';
+    // Garante que o mfaAcr esteja sempre na lista anunciada como suportada.
+    const acrValues = Array.from(new Set([...(input?.acrValues ?? []), mfaAcr]));
+    return { acrValues, mfaAcr };
+}
 export function resolveAdmin(input) {
     return {
         enabled: input?.enabled ?? false,
@@ -86,9 +110,23 @@ export function toSeconds(value, fallback) {
 export function defineConfig(config) {
     return configProvider.create(async (app) => {
         const AdapterClass = await config.adapter.resolver(app);
-        const jwks = config.jwks.source === 'managed'
-            ? await generateJwks(config.jwks.algorithm ?? 'RS256')
-            : { keys: config.jwks.keys ?? [] };
+        let jwks;
+        if (config.jwks.source === 'managed') {
+            const alg = config.jwks.algorithm ?? 'RS256';
+            if (config.jwks.store) {
+                // keystore persistido em arquivo: chaves sobrevivem a restarts + rotacionáveis.
+                const storePath = app.makePath(config.jwks.store);
+                const store = await ensureKeystore(storePath, alg);
+                jwks = { keys: store.keys };
+            }
+            else {
+                // managed efêmero: uma chave nova por boot.
+                jwks = await generateJwks(alg);
+            }
+        }
+        else {
+            jwks = { keys: config.jwks.keys ?? [] };
+        }
         return {
             issuer: config.issuer,
             AdapterClass,
@@ -117,11 +155,16 @@ export function defineConfig(config) {
             patIntrospectionSecret: config.patIntrospectionSecret,
             rateLimit: resolveRateLimit(config.rateLimit),
             lockout: resolveLockout(config.lockout),
+            notifications: resolveNotifications(config.notifications),
             mail: config.mail,
             audit: config.audit,
             mfaIssuer: config.mfaIssuer ?? 'AuthKit',
             webauthn: resolveWebauthn(config.issuer, config.mfaIssuer ?? 'AuthKit', config.webauthn),
             dynamicRegistration: resolveDynamicRegistration(config.dynamicRegistration),
+            deviceFlow: resolveDeviceFlow(config.deviceFlow),
+            dpop: resolveDpop(config.dpop),
+            par: resolvePar(config.par),
+            stepUp: resolveStepUp(config.stepUp),
             admin: resolveAdmin(config.admin),
             messages: resolveMessages(config.i18n),
             locale: config.i18n?.locale ?? 'pt-BR',

package/build/src/doctor/checks.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Funções puras de verificação para `node ace authkit:doctor`. Não dependem do
+ * Ace nem do container — recebem objetos simples para serem testáveis em
+ * isolamento. O comando `authkit:doctor` só coleta o ambiente e imprime os
+ * resultados destas funções.
+ */
+export type FindingLevel = 'ok' | 'warn' | 'error';
+export interface Finding {
+    level: FindingLevel;
+    message: string;
+}
+/** Entrada mínima necessária para rodar os checks (subconjunto da config AuthKit). */
+export interface DoctorInput {
+    /** A config `authkit` resolvida pelo container, ou null se não resolver. */
+    authkitConfig: Record<string, any> | null;
+    /** A config `session` do app (config('session')), ou null se ausente. */
+    sessionConfig: Record<string, any> | null;
+    /** Resultado de tentar resolver cada peer (true = importável). */
+    peers: {
+        session: boolean;
+        shield: boolean;
+        ally: boolean;
+        limiter: boolean;
+    };
+}
+/** config('authkit') resolve? */
+export declare function checkConfigResolves(input: DoctorInput): Finding;
+/** issuer é uma URL válida e seu pathname casa com o mountPath. */
+export declare function checkIssuer(input: DoctorInput): Finding[];
+/** Pelo menos um client com redirectUris. */
+export declare function checkClients(input: DoctorInput): Finding;
+/** accountStore presente + quais capacidades implementa. */
+export declare function checkAccountStore(input: DoctorInput): Finding[];
+/** session provider configurado + warn se cookie store com tokenSets grandes. */
+export declare function checkSession(input: DoctorInput): Finding[];
+/** Hint de exceções de CSRF do shield para o mountPath. */
+export declare function checkShield(input: DoctorInput): Finding;
+/** ally só é necessário quando social está configurado. */
+export declare function checkAlly(input: DoctorInput): Finding;
+/** rateLimit ligado mas @adonisjs/limiter ausente → warn. */
+export declare function checkRateLimit(input: DoctorInput): Finding;
+/** admin.enabled mas sem roles → warn. */
+export declare function checkAdmin(input: DoctorInput): Finding | null;
+/** webauthn rpId deve casar com o host do issuer. */
+export declare function checkWebauthn(input: DoctorInput): Finding | null;
+/** info sobre rotação quando jwks é managed. */
+export declare function checkJwks(input: DoctorInput): Finding | null;
+/** Roda todos os checks e devolve a lista plana de findings. */
+export declare function runAllChecks(input: DoctorInput): Finding[];
+/** Há algum finding de nível 'error'? (define o exit code). */
+export declare function hasErrors(findings: Finding[]): boolean;