@adonis-agora/authkit-server 0.34.0

package/build/src/host/admin_api/dto.d.ts

@@ -0,0 +1,131 @@
+import type { AuthAccount } from '../../accounts/account_store.js';
+import type { OrgSummary, OrgMember, OrgInvitation } from '../../accounts/account_store.js';
+import type { OrgDetail } from './admin_orgs_service.js';
+import type { AdminClient, CreatedClient } from '../admin_clients_service.js';
+import type { AdminSession, AdminGrant } from '../admin_sessions_service.js';
+import type { StoredAuditEvent } from '../../audit/audit_sink.js';
+/** Projeta uma conta para a forma JSON (camelCase) da Admin REST API. */
+export declare function userDto(account: AuthAccount, disabled?: boolean): {
+    id: string;
+    email: string;
+    name: string | null;
+    avatarUrl: string | null;
+    globalRoles: string[];
+    disabled: boolean;
+};
+export declare function clientDto(client: AdminClient): {
+    clientId: string;
+    confidential: boolean;
+    grants: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    tokenEndpointAuthMethod: string;
+    backchannelLogoutUri: string | null;
+    backchannelLogoutSessionRequired: boolean;
+};
+/** Inclui o secret (mostrado UMA vez) em create/regenerate. */
+export declare function createdClientDto(created: CreatedClient): {
+    clientId: string;
+    clientSecret: string | null;
+};
+export declare function sessionDto(session: AdminSession): {
+    id: string;
+    accountId: string;
+    email: string | null;
+    loginTs: number | null;
+    amr: string[];
+    userAgent: string | null;
+    browser: string | null;
+    os: string | null;
+    ip: string | null;
+    location: string | null;
+};
+export declare function grantDto(grant: AdminGrant): {
+    id: string;
+    accountId: string;
+    clientId: string | null;
+    accessTokens: number;
+    refreshTokens: number;
+};
+export declare function auditDto(event: StoredAuditEvent): {
+    id: string;
+    type: import("../../audit/audit_sink.js").AuditEventType;
+    accountId: string | null;
+    email: string | null;
+    clientId: string | null;
+    actorId: string | null;
+    ip: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string | null;
+};
+export declare function orgDto(org: OrgSummary & {
+    memberCount?: number;
+}): {
+    memberCount?: number | undefined;
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+};
+export declare function orgMemberDto(member: OrgMember): {
+    accountId: string;
+    email: string | null;
+    role: string;
+    joinedAt: string;
+};
+export declare function orgInvitationDto(inv: OrgInvitation): {
+    id: string;
+    organizationId: string;
+    email: string;
+    role: string;
+    invitedBy: string;
+    expiresAt: string;
+    acceptedAt: string | null;
+    createdAt: string;
+};
+export declare function orgDetailDto(detail: OrgDetail): {
+    members: {
+        accountId: string;
+        email: string | null;
+        role: string;
+        joinedAt: string;
+    }[];
+    pendingInvitations: {
+        id: string;
+        organizationId: string;
+        email: string;
+        role: string;
+        invitedBy: string;
+        expiresAt: string;
+        acceptedAt: string | null;
+        createdAt: string;
+    }[];
+    memberCount?: number | undefined;
+    id: string;
+    name: string;
+    slug: string;
+    logoUrl: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+};
+/** Envelope de erro padrão da Admin REST API. */
+export declare function apiError(code: string, message: string, details?: Record<string, unknown>): {
+    error: {
+        details?: Record<string, unknown> | undefined;
+        code: string;
+        message: string;
+    };
+};
+import type { SettingRow } from '../runtime_settings.js';
+export declare function settingDto(row: SettingRow): {
+    lockedBy?: "config" | undefined;
+    key: string;
+    organizationId: string | null;
+    value: unknown;
+    updatedAt: string | null;
+    updatedBy: string | null;
+    /** Travada via defineConfig → UI deve desabilitar a edição e mostrar aviso. */
+    locked: boolean;
+};

package/build/src/host/admin_api/dto.js

@@ -0,0 +1,122 @@
+/** Projeta uma conta para a forma JSON (camelCase) da Admin REST API. */
+export function userDto(account, disabled = false) {
+    return {
+        id: account.id,
+        email: account.email,
+        name: account.name ?? null,
+        avatarUrl: account.avatarUrl ?? null,
+        globalRoles: account.globalRoles ?? [],
+        disabled,
+    };
+}
+export function clientDto(client) {
+    return {
+        clientId: client.clientId,
+        confidential: client.confidential,
+        grants: client.grants,
+        redirectUris: client.redirectUris,
+        postLogoutRedirectUris: client.postLogoutRedirectUris,
+        tokenEndpointAuthMethod: client.tokenEndpointAuthMethod,
+        backchannelLogoutUri: client.backchannelLogoutUri ?? null,
+        backchannelLogoutSessionRequired: client.backchannelLogoutSessionRequired ?? false,
+    };
+}
+/** Inclui o secret (mostrado UMA vez) em create/regenerate. */
+export function createdClientDto(created) {
+    return {
+        clientId: created.clientId,
+        clientSecret: created.clientSecret ?? null,
+    };
+}
+export function sessionDto(session) {
+    return {
+        id: session.id,
+        accountId: session.accountId,
+        email: session.email ?? null,
+        loginTs: session.loginTs ?? null,
+        amr: session.amr ?? [],
+        userAgent: session.userAgent ?? null,
+        browser: session.browser ?? null,
+        os: session.os ?? null,
+        ip: session.ip ?? null,
+        location: session.location ?? null,
+    };
+}
+export function grantDto(grant) {
+    return {
+        id: grant.id,
+        accountId: grant.accountId,
+        clientId: grant.clientId ?? null,
+        accessTokens: grant.accessTokens,
+        refreshTokens: grant.refreshTokens,
+    };
+}
+export function auditDto(event) {
+    return {
+        id: event.id,
+        type: event.type,
+        accountId: event.accountId ?? null,
+        email: event.email ?? null,
+        clientId: event.clientId ?? null,
+        actorId: event.actorId ?? null,
+        ip: event.ip ?? null,
+        metadata: event.metadata ?? null,
+        createdAt: event.createdAt instanceof Date ? event.createdAt.toISOString() : event.createdAt,
+    };
+}
+export function orgDto(org) {
+    return {
+        id: org.id,
+        name: org.name,
+        slug: org.slug,
+        logoUrl: org.logoUrl ?? null,
+        metadata: org.metadata ?? null,
+        createdAt: org.createdAt,
+        ...(org.memberCount !== undefined ? { memberCount: org.memberCount } : {}),
+    };
+}
+export function orgMemberDto(member) {
+    return {
+        accountId: member.accountId,
+        email: member.email ?? null,
+        role: member.role,
+        joinedAt: member.joinedAt,
+    };
+}
+export function orgInvitationDto(inv) {
+    return {
+        id: inv.id,
+        organizationId: inv.organizationId,
+        email: inv.email,
+        role: inv.role,
+        invitedBy: inv.invitedBy,
+        expiresAt: inv.expiresAt,
+        acceptedAt: inv.acceptedAt ?? null,
+        createdAt: inv.createdAt,
+    };
+}
+export function orgDetailDto(detail) {
+    return {
+        ...orgDto(detail),
+        members: detail.members.map(orgMemberDto),
+        pendingInvitations: detail.pendingInvitations.map(orgInvitationDto),
+    };
+}
+/** Envelope de erro padrão da Admin REST API. */
+export function apiError(code, message, details) {
+    return { error: { code, message, ...(details ? { details } : {}) } };
+}
+import { isSettingLocked } from '../config_locks.js';
+export function settingDto(row) {
+    const locked = isSettingLocked(row.key);
+    return {
+        key: row.key,
+        organizationId: row.organizationId ?? null,
+        value: row.value,
+        updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : (row.updatedAt ?? null),
+        updatedBy: row.updatedBy ?? null,
+        /** Travada via defineConfig → UI deve desabilitar a edição e mostrar aviso. */
+        locked,
+        ...(locked ? { lockedBy: 'config' } : {}),
+    };
+}

package/build/src/host/admin_api/token_verify_service.d.ts

@@ -0,0 +1,34 @@
+import type { ResolvedServerConfig } from '../../define_config.js';
+/** Resultado de introspecção genérica (PAT ou opaque access token). */
+export type VerifyResult = {
+    active: false;
+} | {
+    active: true;
+    /** 'pat' (Personal Access Token) ou 'access_token' (opaque AT do provider). */
+    tokenType: 'pat' | 'access_token';
+    sub: string;
+    email?: string | null;
+    name?: string | null;
+    roles?: string[];
+    scopes?: string[];
+    audience?: string | string[] | null;
+    clientId?: string | null;
+    exp?: number | null;
+};
+/**
+ * Introspecção genérica de token usada pela Admin REST API (`POST /tokens/verify`).
+ * Roteia por prefixo: tokens `pat_...` vão pelo {@link PatStore} (mesma rota do
+ * `/authkit/pat/introspect`); os demais são tratados como opaque access tokens e
+ * resolvidos pelo `AccessToken.find` do oidc-provider. Sempre best-effort: token
+ * desconhecido/expirado → `{ active: false }`.
+ */
+export declare class TokenVerifyService {
+    #private;
+    private cfg;
+    /** Provider do oidc-provider (service.provider) — para opaque AT. */
+    private provider;
+    constructor(cfg: ResolvedServerConfig, 
+    /** Provider do oidc-provider (service.provider) — para opaque AT. */
+    provider: any);
+    verify(token: string): Promise<VerifyResult>;
+}

package/build/src/host/admin_api/token_verify_service.js

@@ -0,0 +1,74 @@
+/**
+ * Introspecção genérica de token usada pela Admin REST API (`POST /tokens/verify`).
+ * Roteia por prefixo: tokens `pat_...` vão pelo {@link PatStore} (mesma rota do
+ * `/authkit/pat/introspect`); os demais são tratados como opaque access tokens e
+ * resolvidos pelo `AccessToken.find` do oidc-provider. Sempre best-effort: token
+ * desconhecido/expirado → `{ active: false }`.
+ */
+export class TokenVerifyService {
+    cfg;
+    provider;
+    constructor(cfg, 
+    /** Provider do oidc-provider (service.provider) — para opaque AT. */
+    provider) {
+        this.cfg = cfg;
+        this.provider = provider;
+    }
+    async verify(token) {
+        if (!token || typeof token !== 'string')
+            return { active: false };
+        if (token.startsWith('pat_'))
+            return this.#verifyPat(token);
+        return this.#verifyAccessToken(token);
+    }
+    async #verifyPat(token) {
+        if (!this.cfg.patStore)
+            return { active: false };
+        const meta = await this.cfg.patStore.findActiveByToken(token);
+        if (!meta)
+            return { active: false };
+        const account = await this.cfg.accountStore.findById(meta.accountId);
+        if (!account)
+            return { active: false };
+        return {
+            active: true,
+            tokenType: 'pat',
+            sub: account.id,
+            email: account.email,
+            name: account.name ?? null,
+            roles: account.globalRoles ?? [],
+            scopes: meta.scopes,
+            audience: meta.audience,
+            exp: meta.exp,
+        };
+    }
+    async #verifyAccessToken(token) {
+        let at;
+        try {
+            at = await this.provider?.AccessToken?.find(token);
+        }
+        catch {
+            return { active: false };
+        }
+        if (!at)
+            return { active: false };
+        // O oidc-provider expira artefatos sozinho; isExpired/exp como guarda extra.
+        if (typeof at.isExpired === 'boolean' && at.isExpired)
+            return { active: false };
+        const sub = at.accountId ?? '';
+        const account = sub ? await this.cfg.accountStore.findById(sub) : null;
+        const scopes = typeof at.scope === 'string' ? at.scope.split(' ').filter(Boolean) : [];
+        return {
+            active: true,
+            tokenType: 'access_token',
+            sub,
+            email: account?.email ?? null,
+            name: account?.name ?? null,
+            roles: account?.globalRoles ?? [],
+            scopes,
+            audience: at.aud ?? null,
+            clientId: at.clientId ?? null,
+            exp: typeof at.exp === 'number' ? at.exp : null,
+        };
+    }
+}

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

@@ -0,0 +1,88 @@
+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;
+    /**
+     * Endpoint de OIDC Back-Channel Logout do RP. Quando definido, o IdP envia um
+     * `logout_token` para esta URI ao encerrar a sessão/grant do usuário (RFC 7644).
+     */
+    backchannelLogoutUri?: string;
+    /**
+     * Quando `true`, exige que o `logout_token` inclua a claim `sid`. Ignorado quando
+     * `backchannelLogoutUri` não está definido.
+     */
+    backchannelLogoutSessionRequired?: boolean;
+}
+/** Client persistido, apresentado ao console admin. */
+export interface AdminClient {
+    clientId: string;
+    confidential: boolean;
+    grants: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+    tokenEndpointAuthMethod: string;
+    /** Endpoint de OIDC Back-Channel Logout (opcional). */
+    backchannelLogoutUri?: string;
+    /** Exige sid no logout_token (opcional). */
+    backchannelLogoutSessionRequired?: boolean;
+}
+/** 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 `list` 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>;
+    /**
+     * Cria um client PRESERVANDO um `clientSecret` fornecido externamente (em vez de
+     * gerar um aleatório). Útil para migração de clients estáticos do config, onde o
+     * secret original deve ser preservado para não quebrar apps já configurados.
+     *
+     * Para clients públicos (auth method `none`), `providedSecret` é ignorado.
+     * Lança se o `clientId` já existir no adapter — chame `find` antes.
+     */
+    createWithSecret(input: ClientInput, providedSecret: string | undefined): 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: Partial<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,181 @@
+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 `list` 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';
+    }
+    /** Lista os clients persistidos (vazio quando o adapter não enumera; cheque canList). */
+    async list() {
+        if (this.#adapter.list) {
+            const rows = await this.#adapter.list();
+            return rows.map((r) => this.#present({ clientId: r.id, payload: r.payload }));
+        }
+        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 };
+    }
+    /**
+     * Cria um client PRESERVANDO um `clientSecret` fornecido externamente (em vez de
+     * gerar um aleatório). Útil para migração de clients estáticos do config, onde o
+     * secret original deve ser preservado para não quebrar apps já configurados.
+     *
+     * Para clients públicos (auth method `none`), `providedSecret` é ignorado.
+     * Lança se o `clientId` já existir no adapter — chame `find` antes.
+     */
+    async createWithSecret(input, providedSecret) {
+        const clientId = (input.clientId ?? '').trim() || randomId();
+        const confidential = !PUBLIC_AUTH_METHODS.has(input.tokenEndpointAuthMethod);
+        const clientSecret = confidential ? (providedSecret ?? randomId()) : undefined;
+        const payload = this.#buildPayload(clientId, input, clientSecret);
+        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;
+        // MERGE (PATCH de verdade): campos não enviados (undefined) preservam o valor
+        // atual do client. Sem isto, um update parcial reseta tudo que não veio no body
+        // (ex.: não mandar tokenEndpointAuthMethod virava confidential; não mandar
+        // grantTypes derrubava token-exchange).
+        const merged = {
+            clientId,
+            redirectUris: input.redirectUris ?? (existing.redirect_uris ?? []),
+            postLogoutRedirectUris: input.postLogoutRedirectUris ?? (existing.post_logout_redirect_uris ?? []),
+            grantTypes: input.grantTypes ?? (existing.grant_types ?? []),
+            tokenEndpointAuthMethod: input.tokenEndpointAuthMethod ??
+                (existing.token_endpoint_auth_method ?? 'client_secret_basic'),
+            backchannelLogoutUri: input.backchannelLogoutUri ?? existing.backchannel_logout_uri,
+            backchannelLogoutSessionRequired: input.backchannelLogoutSessionRequired ??
+                existing.backchannel_logout_session_required,
+        };
+        const confidential = !PUBLIC_AUTH_METHODS.has(merged.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, merged, 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;
+        if (input.backchannelLogoutUri) {
+            payload.backchannel_logout_uri = input.backchannelLogoutUri;
+            if (input.backchannelLogoutSessionRequired !== undefined) {
+                payload.backchannel_logout_session_required = input.backchannelLogoutSessionRequired;
+            }
+        }
+        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';
+        const result = {
+            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,
+        };
+        if (p.backchannel_logout_uri) {
+            result.backchannelLogoutUri = p.backchannel_logout_uri;
+            result.backchannelLogoutSessionRequired =
+                p.backchannel_logout_session_required ?? false;
+        }
+        return result;
+    }
+}

package/build/src/host/admin_console/admin_shell_controller.d.ts

@@ -0,0 +1,27 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Controla o serving do console admin React (Missão B).
+ *
+ * `serve`       — serve o shell HTML (SPA) para TODAS as rotas de página do console.
+ * `serveAsset`  — serve arquivos estáticos do build (JS/CSS/fonts/images) com cache.
+ *
+ * O shell HTML é o index.html produzido pelo Vite build em `build/host/ui-dist/`.
+ * O servidor injeta `window.__AUTHKIT__` e reescreve o placeholder de base dinâmica
+ * `/__AUTHKIT_BASE__/` → `${adminBase}/assets/` para que todos os imports de assets
+ * Vite resolvam corretamente independente do prefixo admin configurado.
+ *
+ * Se o dist não existir (ambiente de dev sem build prévia), serve o placeholder HTML
+ * legado de `src/host/ui/admin.html` com uma mensagem de instrução.
+ */
+export default class AdminShellController {
+    /**
+     * GET {prefix}   — serve o shell HTML da SPA.
+     * GET {prefix}/* — idem (qualquer rota de página é tratada pela SPA via hash-routing).
+     */
+    serve(ctx: HttpContext): Promise<void>;
+    /**
+     * GET {prefix}/assets/:file(*) — serve assets estáticos do Vite build.
+     * Os assets do Vite têm hash no nome → cache agressivo (1 ano).
+     */
+    serveAsset(ctx: HttpContext): Promise<void>;
+}