@dudousxd/adonis-authkit-server 0.2.0 → 0.4.0

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;

package/build/src/doctor/checks.js

@@ -0,0 +1,231 @@
+/**
+ * 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.
+ */
+/** Type guard estrutural: o store expõe um método (capacidade presente). */
+function has(store, method) {
+    return !!store && typeof store[method] === 'function';
+}
+/** config('authkit') resolve? */
+export function checkConfigResolves(input) {
+    if (!input.authkitConfig) {
+        return {
+            level: 'error',
+            message: "config('authkit') não resolveu — config/authkit.ts está ausente ou inválido.",
+        };
+    }
+    return { level: 'ok', message: "config('authkit') resolvido." };
+}
+/** issuer é uma URL válida e seu pathname casa com o mountPath. */
+export function checkIssuer(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return [];
+    const issuer = cfg.issuer;
+    const mountPath = cfg.mountPath ?? '/oidc';
+    if (typeof issuer !== 'string' || issuer.length === 0) {
+        return [{ level: 'error', message: 'issuer ausente na config.' }];
+    }
+    let url;
+    try {
+        url = new URL(issuer);
+    }
+    catch {
+        return [{ level: 'error', message: `issuer não é uma URL válida: "${issuer}".` }];
+    }
+    const findings = [{ level: 'ok', message: `issuer válido: ${url.origin}${url.pathname}` }];
+    const normalize = (p) => (p.endsWith('/') ? p.slice(0, -1) : p) || '/';
+    if (normalize(url.pathname) !== normalize(mountPath)) {
+        findings.push({
+            level: 'warn',
+            message: `O pathname do issuer ("${url.pathname}") difere do mountPath ("${mountPath}"). As rotas OIDC podem não casar com as URLs anunciadas no discovery.`,
+        });
+    }
+    return findings;
+}
+/** Pelo menos um client com redirectUris. */
+export function checkClients(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return { level: 'error', message: 'sem config para validar clients.' };
+    const clients = Array.isArray(cfg.clients) ? cfg.clients : [];
+    if (clients.length === 0) {
+        return { level: 'error', message: 'nenhum client configurado em `clients`.' };
+    }
+    const withRedirects = clients.filter((c) => Array.isArray(c?.redirectUris) && c.redirectUris.length > 0);
+    if (withRedirects.length === 0) {
+        return {
+            level: 'error',
+            message: `${clients.length} client(s) configurado(s), mas nenhum tem redirectUris.`,
+        };
+    }
+    return { level: 'ok', message: `${withRedirects.length}/${clients.length} client(s) com redirectUris.` };
+}
+/** accountStore presente + quais capacidades implementa. */
+export function checkAccountStore(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return [];
+    const store = cfg.accountStore;
+    if (!store) {
+        return [{ level: 'error', message: 'accountStore ausente — obrigatório.' }];
+    }
+    const findings = [{ level: 'ok', message: 'accountStore presente.' }];
+    const caps = [];
+    if (has(store, 'getMfaState'))
+        caps.push('MFA');
+    if (has(store, 'listPasskeys'))
+        caps.push('passkeys/WebAuthn');
+    if (has(store, 'findByProviderIdentity'))
+        caps.push('account-linking');
+    if (has(store, 'changePassword'))
+        caps.push('account-security');
+    findings.push({
+        level: 'ok',
+        message: caps.length
+            ? `Capacidades opcionais: ${caps.join(', ')}.`
+            : 'Apenas o núcleo do accountStore (sem MFA/passkeys/linking/security).',
+    });
+    return findings;
+}
+/** session provider configurado + warn se cookie store com tokenSets grandes. */
+export function checkSession(input) {
+    if (!input.peers.session) {
+        return [
+            {
+                level: 'error',
+                message: '@adonisjs/session não é importável — instale-o (peer obrigatório).',
+            },
+        ];
+    }
+    if (!input.sessionConfig) {
+        return [{ level: 'warn', message: "config('session') ausente — o provider de sessão pode não estar configurado." }];
+    }
+    const findings = [{ level: 'ok', message: 'provider de sessão configurado.' }];
+    const driver = input.sessionConfig.store ?? input.sessionConfig.driver;
+    if (driver === 'cookie') {
+        findings.push({
+            level: 'warn',
+            message: 'session store = cookie: token sets grandes podem estourar o limite de 4KB do cookie. Prefira `redis`/`file` em produção.',
+        });
+    }
+    return findings;
+}
+/** Hint de exceções de CSRF do shield para o mountPath. */
+export function checkShield(input) {
+    if (!input.peers.shield) {
+        return { level: 'error', message: '@adonisjs/shield não é importável — instale-o (peer obrigatório).' };
+    }
+    const mountPath = input.authkitConfig?.mountPath ?? '/oidc';
+    return {
+        level: 'warn',
+        message: `Garanta que as rotas POST do IdP sob "${mountPath}" estejam nas exceções de CSRF do shield (ex.: endpoint /token), senão chamadas server-to-server falham.`,
+    };
+}
+/** ally só é necessário quando social está configurado. */
+export function checkAlly(input) {
+    const social = input.authkitConfig?.social;
+    const usesSocial = !!social && (Array.isArray(social.providers) ? social.providers.length > 0 : Object.keys(social).length > 0);
+    if (!usesSocial) {
+        return { level: 'ok', message: 'login social não configurado — @adonisjs/ally é opcional.' };
+    }
+    if (!input.peers.ally) {
+        return { level: 'error', message: 'login social configurado, mas @adonisjs/ally não é importável.' };
+    }
+    return { level: 'ok', message: 'login social configurado e @adonisjs/ally disponível.' };
+}
+/** rateLimit ligado mas @adonisjs/limiter ausente → warn. */
+export function checkRateLimit(input) {
+    const cfg = input.authkitConfig;
+    const rateLimit = cfg?.rateLimit;
+    const enabled = rateLimit === undefined ? true : rateLimit?.enabled !== false;
+    if (!enabled) {
+        return { level: 'ok', message: 'rate-limiting desligado por config.' };
+    }
+    if (!input.peers.limiter) {
+        return {
+            level: 'warn',
+            message: 'rate-limiting está ligado (default), mas @adonisjs/limiter não é importável — vira no-op (sem proteção anti-brute-force).',
+        };
+    }
+    return { level: 'ok', message: 'rate-limiting ligado e @adonisjs/limiter disponível.' };
+}
+/** admin.enabled mas sem roles → warn. */
+export function checkAdmin(input) {
+    const admin = input.authkitConfig?.admin;
+    if (!admin || admin.enabled !== true)
+        return null;
+    const roles = Array.isArray(admin.roles) ? admin.roles : [];
+    if (roles.length === 0) {
+        return {
+            level: 'warn',
+            message: 'console admin ligado, mas sem `admin.roles` — ninguém terá acesso (default ["ADMIN"] não foi resolvido aqui).',
+        };
+    }
+    return { level: 'ok', message: `console admin ligado para roles: ${roles.join(', ')}.` };
+}
+/** webauthn rpId deve casar com o host do issuer. */
+export function checkWebauthn(input) {
+    const cfg = input.authkitConfig;
+    const webauthn = cfg?.webauthn;
+    if (!webauthn || !webauthn.rpId)
+        return null;
+    const issuer = cfg.issuer;
+    if (typeof issuer !== 'string')
+        return null;
+    let host;
+    try {
+        host = new URL(issuer).hostname;
+    }
+    catch {
+        return null;
+    }
+    if (webauthn.rpId !== host) {
+        return {
+            level: 'warn',
+            message: `webauthn.rpId ("${webauthn.rpId}") difere do host do issuer ("${host}") — as passkeys não validarão no browser.`,
+        };
+    }
+    return { level: 'ok', message: `webauthn.rpId casa com o host do issuer (${host}).` };
+}
+/** info sobre rotação quando jwks é managed. */
+export function checkJwks(input) {
+    const jwks = input.authkitConfig?.jwks;
+    if (!jwks)
+        return null;
+    if (jwks.source === 'managed') {
+        return {
+            level: 'ok',
+            message: 'jwks managed — rotacione as chaves de assinatura com `node ace authkit:rotate-keys` (use --store para persistir entre boots).',
+        };
+    }
+    return { level: 'ok', message: 'jwks fornecido inline (source=jwks).' };
+}
+/** Roda todos os checks e devolve a lista plana de findings. */
+export function runAllChecks(input) {
+    const findings = [];
+    findings.push(checkConfigResolves(input));
+    findings.push(...checkIssuer(input));
+    findings.push(checkClients(input));
+    findings.push(...checkAccountStore(input));
+    findings.push(...checkSession(input));
+    findings.push(checkShield(input));
+    findings.push(checkAlly(input));
+    findings.push(checkRateLimit(input));
+    const admin = checkAdmin(input);
+    if (admin)
+        findings.push(admin);
+    const webauthn = checkWebauthn(input);
+    if (webauthn)
+        findings.push(webauthn);
+    const jwks = checkJwks(input);
+    if (jwks)
+        findings.push(jwks);
+    return findings;
+}
+/** Há algum finding de nível 'error'? (define o exit code). */
+export function hasErrors(findings) {
+    return findings.some((f) => f.level === 'error');
+}

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

@@ -0,0 +1,65 @@
+import type { OidcService } from '../provider/oidc_service.js';
+/** Métodos de autenticação no token endpoint suportados pelo formulário admin. */
+export type TokenEndpointAuthMethod = 'client_secret_basic' | 'client_secret_post' | 'none';
+/** Entrada normalizada de um client gerenciável (vinda do formulário admin). */
+export interface ClientInput {
+    clientId?: string;
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    grantTypes: string[];
+    tokenEndpointAuthMethod: TokenEndpointAuthMethod;
+}
+/** Client persistido, apresentado ao console admin. */
+export interface AdminClient {
+    clientId: string;
+    confidential: boolean;
+    grants: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    tokenEndpointAuthMethod: string;
+}
+/** Resultado de uma criação: o client + o secret em claro (mostrado UMA vez). */
+export interface CreatedClient {
+    clientId: string;
+    /** undefined para public clients (sem secret). */
+    clientSecret?: string;
+}
+/**
+ * Serviço de CRUD de clients OIDC persistidos no adapter (model `Client`),
+ * usado pelo console admin. Encapsula:
+ *   - a montagem do payload NA FORMA EXATA que o oidc-provider espera (snake_case,
+ *     igual ao que o registro dinâmico — RFC 7591 — grava);
+ *   - a invalidação do cache de clients dinâmicos do provider após cada escrita
+ *     (ver {@link OidcService.evictDynamicClientCache});
+ *   - a enumeração via a capacidade opcional `listClients` do adapter.
+ */
+export declare class AdminClientsService {
+    #private;
+    private oidc;
+    constructor(oidc: OidcService);
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList(): boolean;
+    /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
+    list(): Promise<AdminClient[]>;
+    /** Lê um client persistido pelo client_id (undefined quando não existe). */
+    find(clientId: string): Promise<AdminClient | undefined>;
+    /**
+     * Cria um client. Gera client_id quando não informado; gera client_secret
+     * para clients confidenciais (auth method != 'none'). Retorna o secret em
+     * claro UMA vez (não é recuperável depois — o payload guarda o mesmo valor).
+     */
+    create(input: ClientInput): Promise<CreatedClient>;
+    /**
+     * Atualiza metadata editável (redirect/post-logout URIs, grants, auth method)
+     * PRESERVANDO o client_secret existente. Lança se o client não existe.
+     */
+    update(clientId: string, input: ClientInput): Promise<void>;
+    /**
+     * Regenera o client_secret de um client confidencial, preservando o resto da
+     * metadata. Retorna o novo secret em claro (mostrado UMA vez). Lança se o
+     * client não existe ou é public (auth method 'none').
+     */
+    regenerateSecret(clientId: string): Promise<string>;
+    /** Remove um client persistido e invalida o cache. */
+    delete(clientId: string): Promise<void>;
+}

package/build/src/host/admin_clients_service.js

@@ -0,0 +1,143 @@
+import { randomBytes } from 'node:crypto';
+/** Métodos públicos (sem segredo) — espelham os "non-secret" do oidc-provider. */
+const PUBLIC_AUTH_METHODS = new Set(['none']);
+/** Gera um identificador opaco no estilo do oidc-provider (~43 chars base64url). */
+function randomId() {
+    return randomBytes(32).toString('base64url');
+}
+/**
+ * Serviço de CRUD de clients OIDC persistidos no adapter (model `Client`),
+ * usado pelo console admin. Encapsula:
+ *   - a montagem do payload NA FORMA EXATA que o oidc-provider espera (snake_case,
+ *     igual ao que o registro dinâmico — RFC 7591 — grava);
+ *   - a invalidação do cache de clients dinâmicos do provider após cada escrita
+ *     (ver {@link OidcService.evictDynamicClientCache});
+ *   - a enumeração via a capacidade opcional `listClients` do adapter.
+ */
+export class AdminClientsService {
+    oidc;
+    #adapter;
+    constructor(oidc) {
+        this.oidc = oidc;
+        // O AdapterClass é o MESMO que o provider usa; instanciamos o model 'Client'
+        // para ler/gravar os mesmos artefatos que o oidc-provider persiste.
+        this.#adapter = new oidc.config.AdapterClass('Client');
+    }
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList() {
+        return typeof this.#adapter.list === 'function' || typeof this.#adapter.listClients === 'function';
+    }
+    /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
+    async list() {
+        // Prefere a enumeração genérica `list`; cai no `listClients` legado se for o
+        // único disponível (adapters customizados antigos).
+        if (this.#adapter.list) {
+            const rows = await this.#adapter.list();
+            return rows.map((r) => this.#present({ clientId: r.id, payload: r.payload }));
+        }
+        if (this.#adapter.listClients) {
+            const rows = await this.#adapter.listClients();
+            return rows.map((r) => this.#present(r));
+        }
+        return [];
+    }
+    /** Lê um client persistido pelo client_id (undefined quando não existe). */
+    async find(clientId) {
+        const payload = await this.#adapter.find(clientId);
+        if (!payload)
+            return undefined;
+        return this.#present({ clientId, payload: payload });
+    }
+    /**
+     * Cria um client. Gera client_id quando não informado; gera client_secret
+     * para clients confidenciais (auth method != 'none'). Retorna o secret em
+     * claro UMA vez (não é recuperável depois — o payload guarda o mesmo valor).
+     */
+    async create(input) {
+        const clientId = (input.clientId ?? '').trim() || randomId();
+        const confidential = !PUBLIC_AUTH_METHODS.has(input.tokenEndpointAuthMethod);
+        const clientSecret = confidential ? randomId() : undefined;
+        const payload = this.#buildPayload(clientId, input, clientSecret);
+        // expiresIn 0 => sem TTL (clients são permanentes, como no registro dinâmico).
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+        return { clientId, clientSecret };
+    }
+    /**
+     * Atualiza metadata editável (redirect/post-logout URIs, grants, auth method)
+     * PRESERVANDO o client_secret existente. Lança se o client não existe.
+     */
+    async update(clientId, input) {
+        const existing = await this.#adapter.find(clientId);
+        if (!existing)
+            throw new Error(`client ${clientId} não encontrado`);
+        const previousSecret = existing.client_secret;
+        const confidential = !PUBLIC_AUTH_METHODS.has(input.tokenEndpointAuthMethod);
+        // Mantém o secret atual se continua confidencial; se virou public, remove-o.
+        const clientSecret = confidential ? (previousSecret ?? randomId()) : undefined;
+        const payload = this.#buildPayload(clientId, input, clientSecret);
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+    }
+    /**
+     * Regenera o client_secret de um client confidencial, preservando o resto da
+     * metadata. Retorna o novo secret em claro (mostrado UMA vez). Lança se o
+     * client não existe ou é public (auth method 'none').
+     */
+    async regenerateSecret(clientId) {
+        const existing = await this.#adapter.find(clientId);
+        if (!existing)
+            throw new Error(`client ${clientId} não encontrado`);
+        const authMethod = existing.token_endpoint_auth_method ?? 'client_secret_basic';
+        if (PUBLIC_AUTH_METHODS.has(authMethod)) {
+            throw new Error(`client ${clientId} é public — não possui secret`);
+        }
+        const clientSecret = randomId();
+        const payload = { ...existing, client_secret: clientSecret };
+        await this.#adapter.upsert(clientId, payload, 0);
+        await this.oidc.evictDynamicClientCache();
+        return clientSecret;
+    }
+    /** Remove um client persistido e invalida o cache. */
+    async delete(clientId) {
+        await this.#adapter.destroy(clientId);
+        await this.oidc.evictDynamicClientCache();
+    }
+    /**
+     * Monta o payload na forma snake_case que o oidc-provider espera/persiste —
+     * verificada contra o que o registro dinâmico (RFC 7591) grava. As chaves de
+     * metadata não enviadas (subject_type, id_token_signed_response_alg, etc.) são
+     * preenchidas pelo Schema do provider ao construir o Client em `find`.
+     */
+    #buildPayload(clientId, input, clientSecret) {
+        const grantTypes = input.grantTypes.length
+            ? input.grantTypes
+            : ['authorization_code', 'refresh_token'];
+        // response_types: 'code' quando o fluxo de authorization_code está presente.
+        const responseTypes = grantTypes.includes('authorization_code') ? ['code'] : [];
+        const payload = {
+            client_id: clientId,
+            redirect_uris: input.redirectUris,
+            post_logout_redirect_uris: input.postLogoutRedirectUris,
+            grant_types: grantTypes,
+            response_types: responseTypes,
+            token_endpoint_auth_method: input.tokenEndpointAuthMethod,
+        };
+        if (clientSecret)
+            payload.client_secret = clientSecret;
+        return payload;
+    }
+    /** Projeta um payload persistido para a forma exibida no console admin. */
+    #present(row) {
+        const p = row.payload;
+        const authMethod = p.token_endpoint_auth_method ?? 'client_secret_basic';
+        return {
+            clientId: row.clientId,
+            confidential: !!p.client_secret,
+            grants: p.grant_types ?? ['authorization_code', 'refresh_token'],
+            redirectUris: p.redirect_uris ?? [],
+            postLogoutRedirectUris: p.post_logout_redirect_uris ?? [],
+            tokenEndpointAuthMethod: authMethod,
+        };
+    }
+}

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

@@ -0,0 +1,63 @@
+import type { OidcService } from '../provider/oidc_service.js';
+/** Uma sessão ativa do IdP (login do usuário no provider), apresentada ao admin. */
+export interface AdminSession {
+    /** Id do artefato `Session` no adapter. */
+    id: string;
+    accountId: string;
+    /** Epoch (segundos) do login, quando presente no payload. */
+    loginTs?: number;
+    /** Métodos de autenticação registrados na sessão (amr), quando presentes. */
+    amr?: string[];
+}
+/** Um grant (autorização concedida a um client), com a contagem de tokens vivos. */
+export interface AdminGrant {
+    /** Id do artefato `Grant` no adapter (== grantId dos tokens). */
+    id: string;
+    accountId: string;
+    clientId?: string;
+    /** Tokens de acesso vivos que referenciam este grant. */
+    accessTokens: number;
+    /** Refresh tokens vivos que referenciam este grant. */
+    refreshTokens: number;
+}
+/** Resultado de uma revogação em massa das sessões/grants de uma conta. */
+export interface RevokeResult {
+    sessions: number;
+    grants: number;
+    accessTokens: number;
+    refreshTokens: number;
+}
+/**
+ * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta,
+ * persistidos pelo oidc-provider via o MESMO `AdapterClass` (mesmo padrão do
+ * {@link AdminClientsService}). Encapsula:
+ *   - a enumeração via a capacidade opcional `list` do adapter (degrada quando
+ *     ausente, igual ao CRUD de clients);
+ *   - a destruição das sessões + grants da conta. Destruir um grant CASCATEIA a
+ *     invalidação dos tokens no oidc-provider: os consumidores de access/refresh
+ *     token carregam `Grant.find(token.grantId)` e lançam `InvalidToken('grant not
+ *     found')` quando o grant some (verificado em oidc-provider v9). Mesmo assim,
+ *     por garantia (belt-and-braces), também destruímos as linhas de AT/RT que
+ *     referenciam os grants revogados quando o adapter enumera.
+ */
+export declare class AdminSessionsService {
+    #private;
+    constructor(oidc: OidcService);
+    /** Indica se o adapter suporta enumeração (capacidade opcional). */
+    get canList(): boolean;
+    /** Lista as sessões ativas da conta (vazio quando o adapter não enumera). */
+    listSessions(accountId: string): Promise<AdminSession[]>;
+    /**
+     * Lista os grants da conta, com a contagem de access/refresh tokens vivos que
+     * referenciam cada grant (`payload.grantId`). As contagens são baratas (uma
+     * enumeração de cada model token), feitas só quando o adapter enumera.
+     */
+    listGrants(accountId: string): Promise<AdminGrant[]>;
+    /**
+     * Revoga TODAS as sessões e grants da conta. Destruir os grants já invalida os
+     * tokens (cascata via `grant not found`); ainda assim, quando o adapter enumera,
+     * destruímos explicitamente as linhas de AT/RT desses grants (belt-and-braces),
+     * deixando o store limpo. Retorna as contagens do que foi removido.
+     */
+    revokeAll(accountId: string): Promise<RevokeResult>;
+}