@adonis-agora/authkit-server 0.90.2 → 1.0.0-rc.1

package/build/src/console_authorize.js

@@ -0,0 +1,85 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+function isAuthorizerClass(value) {
+    return (typeof value === 'function' &&
+        typeof value.prototype?.authorize === 'function');
+}
+function isLazyModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'default' in value &&
+        isAuthorizerClass(value.default));
+}
+export function normalizeConsoleAuthorizeResult(result) {
+    if (result === true)
+        return { allowed: true };
+    if (typeof result === 'object' && result !== null) {
+        const r = result;
+        if (typeof r.redirectTo === 'string' && r.redirectTo.length > 0) {
+            return { allowed: false, status: 401, redirectTo: r.redirectTo };
+        }
+        if (r.allowed === true)
+            return { allowed: true };
+        if (r.allowed === false && r.reason === 'unauthenticated') {
+            return { allowed: false, status: 401 };
+        }
+    }
+    // `false`, `{ allowed: false }` and anything unrecognized deny.
+    return { allowed: false, status: 403 };
+}
+async function runClass(Authorizer, ctx) {
+    const instance = (await ctx.containerResolver.make(Authorizer));
+    return instance.authorize(ctx);
+}
+/**
+ * Turns a `ConsoleAuthorize` into a checker returning a normalized decision.
+ * A class is built through the container (so `@inject()` works); a lazy import
+ * runs once and its class is remembered. A thrown error is a denial (403).
+ */
+export function resolveConsoleAuthorize(authorize) {
+    let lazyClass;
+    return async (ctx) => {
+        try {
+            if (isAuthorizerClass(authorize)) {
+                return normalizeConsoleAuthorizeResult(await runClass(authorize, ctx));
+            }
+            if (lazyClass)
+                return normalizeConsoleAuthorizeResult(await runClass(lazyClass, ctx));
+            const result = await authorize(ctx);
+            if (isLazyModule(result)) {
+                lazyClass = result.default;
+                return normalizeConsoleAuthorizeResult(await runClass(lazyClass, ctx));
+            }
+            return normalizeConsoleAuthorizeResult(result);
+        }
+        catch (error) {
+            ctx.logger?.warn?.({ err: error }, 'console authorize threw; access denied');
+            return { allowed: false, status: 403 };
+        }
+    };
+}
+/**
+ * A `ConsoleAuthorize` that lets in requests carrying `Authorization: Bearer <token>`.
+ * The comparison is timing-safe. Anything else is `{ allowed: false, reason: 'unauthenticated' }`.
+ * Throws when `token` is empty, so a missing env var fails at config time.
+ *
+ * ```ts
+ * authorize: authorizeByToken({ token: env.get('CONSOLE_TOKEN') })
+ * ```
+ */
+export function authorizeByToken(options) {
+    const token = options?.token;
+    if (typeof token !== 'string' || token.length === 0) {
+        throw new Error('authorizeByToken: `token` is empty. Set it (e.g. env CONSOLE_TOKEN).');
+    }
+    const expected = createHash('sha256').update(token).digest();
+    return (ctx) => {
+        const header = ctx.request.header('authorization');
+        const match = typeof header === 'string' ? /^Bearer\s+(.+)$/i.exec(header.trim()) : null;
+        if (match) {
+            const given = createHash('sha256').update(match[1]).digest();
+            if (timingSafeEqual(given, expected))
+                return { allowed: true };
+        }
+        return { allowed: false, reason: 'unauthenticated' };
+    };
+}

package/build/src/define_config.d.ts

@@ -1,9 +1,10 @@
-import type { AccessTokenFormat, AccessTokensConfig, ClientConfig, JwksConfig, KeystoreStoreConfig, ObservabilityConfig, TtlConfig } from '@adonis-agora/authkit-core';
+import type { AccessTokenFormat, AccessTokensConfig, JwksConfig, KeystoreStoreConfig, ObservabilityConfig, TtlConfig } from '@adonis-agora/authkit-core';
 import type { HttpContext } from '@adonisjs/core/http';
 import type { AccountStore, AuthAccount } from './accounts/account_store.js';
 import { type AdapterFactory, adapters, type OidcAdapterClass } from './adapters/factory.js';
 import { type PersonalAgentsConfigInput, type ResolvedPersonalAgentsConfig } from './agents/config.js';
 import type { AuditSink } from './audit/audit_sink.js';
+import type { ConsoleAuthorize } from './console_authorize.js';
 import { type EventsConfigInput } from './events/dispatcher.js';
 import { type BotProtectionConfigInput, type ResolvedBotProtectionConfig } from './host/bot_protection.js';
 import { type BrandingConfig } from './host/branding.js';
@@ -14,6 +15,7 @@ import type { ResolveGeo } from './host/geo.js';
 import { type AuthMessages, type I18nConfig } from './host/i18n.js';
 import { type OtpLoginConfigInput, type ResolvedOtpLoginConfig } from './host/otp_login.js';
 import type { AuthHostOptions } from './host/register_auth_host.js';
+import type { AuthkitScreenRenderer } from './host/screen_props.js';
 import type { SudoMethod } from './host/sudo/types.js';
 import { type ResolvedTrustedDevicesConfig, type TrustedDevicesConfigInput } from './host/trusted_device.js';
 import type { WhatsappCodeSenderBinding } from './host/whatsapp_code_sender.js';
@@ -354,8 +356,8 @@ export declare function resolveNotifications(): ResolvedNotificationsConfig;
  *
  * Quando habilitado, o oidc-provider expõe o endpoint de registro (`/reg`) e os
  * clients criados ali são PERSISTIDOS pelo MESMO adapter usado para os demais
- * artefatos OIDC. Assim, clients dinâmicos coexistem com os `clients` estáticos
- * da config e ficam disponíveis para uma futura UI admin que gerencia clients no DB.
+ * artefatos OIDC, junto dos clients criados pelo console admin, pela Admin API e
+ * pelo `node ace authkit:clients:create`.
  */
 export interface DynamicRegistrationConfigInput {
     /** Liga o endpoint de registro dinâmico. Default: false (comportamento atual). */
@@ -707,12 +709,21 @@ export interface AdminConfigInput {
      * default é decisão de major, mesma regra de `impersonation`).
      */
     impersonateAdmins?: boolean;
+    /**
+     * Access check for the console, run after `roles` (both must pass), on the shell
+     * and on every `{prefix}/api/*` route. An inline function, an authorizer class
+     * (`@inject()` works), a lazy import (`() => import('#policies/...')`) or
+     * `authorizeByToken({ token })`. Omitted: open outside production, 403 in production.
+     */
+    authorize?: ConsoleAuthorize;
 }
 export interface ResolvedAdminConfig {
     enabled: boolean;
     roles: string[];
     impersonation: boolean;
     impersonateAdmins: boolean;
+    /** `admin.authorize` as configured, or `null` when omitted. */
+    authorize: ConsoleAuthorize | null;
 }
 export declare function resolveAdmin(input?: AdminConfigInput): ResolvedAdminConfig;
 /**
@@ -872,13 +883,6 @@ export interface AuthServerConfigInput {
     session?: {
         adapter?: AdapterFactory;
     };
-    /**
-     * Clientes OIDC pré-carregados no provider ao subir. Útil para testes e
-     * migrações pontuais. Para uso em produção, gerencie clients via console admin
-     * ou Admin API (`node ace authkit:clients:create`).
-     * @internal
-     */
-    clients?: ClientConfig[];
     /**
      * Config de JWKS, ou `'auto'` (recomendado p/ deploys efêmeros): se a env
      * `AUTHKIT_JWKS` (JSON `{"keys":[...]}`) estiver presente, usa-a inline
@@ -1231,8 +1235,16 @@ export interface AuthServerConfigInput {
      * expiração), e o "Sair" do console encerra também a sessão do IdP. Contas
      * desabilitadas não entram. Operações sensíveis continuam pedindo sudo.
      *
-     * Default `false`: o console só aceita a própria sessão (`POST /account/login`),
-     * como sempre.
+     * Default `true`: o console é mais um app do IdP. Sem sessão, `/account/*` e o
+     * console admin mandam o visitante para o login do IdP (`/auth/console/sso`,
+     * client interno `authkit-console`) e voltam com o console aberto. Um único
+     * login, como no Keycloak, Okta e Google; o que protege as operações
+     * sensíveis é o sudo, não um segundo login.
+     *
+     * `false`: o console só aceita a própria sessão (`POST /account/login`, por
+     * senha). Com `authMethods: { password: false }` isso deixa o console sem
+     * nenhum jeito de entrar, então o boot recusa a combinação, a menos que
+     * `routes.accountLoginUrl` aponte para um login do próprio host.
      */
     accountSession?: {
         acceptIdpSession?: boolean;
@@ -1256,7 +1268,6 @@ export interface ResolvedServerConfig {
      * `session.adapter` no input é a MESMA classe do `AdapterClass`.
      */
     SessionAdapterClass: OidcAdapterClass;
-    clients: ClientConfig[];
     jwks: {
         keys: Record<string, any>[];
     };
@@ -1296,7 +1307,8 @@ export interface ResolvedServerConfig {
     mountPath: string;
     /** Destino default pós-confirmação do console (sudo mode) e demais fallbacks de conta. Default: '/account/security'. */
     accountHome?: string;
-    render?: AuthHostRenderer;
+    /** O renderer das telas, tipado por view (ver `AuthkitScreenProps`). */
+    render?: AuthkitScreenRenderer;
     /** Recuperação de sessão de interaction perdida resolvida (default `{ mode: 'screen' }`). */
     interactionRecovery: ResolvedInteractionRecoveryConfig;
     /** Branding resolvido: sempre presente (default neutro quando o host não declara `branding`). */

package/build/src/define_config.js

@@ -193,6 +193,7 @@ export function resolveAdmin(input) {
         // registrado). Ver o docblock de `AdminConfigInput.impersonation`.
         impersonation: input?.impersonation !== false,
         impersonateAdmins: input?.impersonateAdmins !== false,
+        authorize: input?.authorize ?? null,
     };
 }
 /** Lê API keys de `AUTHKIT_ADMIN_API_KEY` (uma ou várias, separadas por vírgula). */
@@ -387,7 +388,6 @@ export function defineConfig(config) {
             issuer: config.issuer,
             AdapterClass,
             SessionAdapterClass,
-            clients: config.clients ?? [],
             jwks: jwks,
             jwksConfig,
             ttl: {
@@ -419,7 +419,9 @@ export function defineConfig(config) {
             // importa `edge.js` eagerly, então é seguro construir mesmo em hosts
             // sem o peer opcional instalado (só quebraria se a request realmente
             // chegasse sem Edge configurado, exatamente como hoje).
-            render: config.render ?? edgeRenderer(),
+            // O renderer do host recebe `(ctx, view, props)`; aqui ele é tipado por view para que
+            // os controllers não possam divergir de `AuthkitScreenProps`.
+            render: (config.render ?? edgeRenderer()),
             // Recuperação de sessão de interaction perdida: default gracioso 'screen'
             // (tela themeável `session-expired`); 'redirect' opt-in para 302 ao login.
             interactionRecovery: {
@@ -495,7 +497,7 @@ export function defineConfig(config) {
             lockedRouteOptions: deriveLockedRouteOptions(config),
             // Opt-in: ausente = authkit nunca toca `ctx.auth` (comportamento de sempre).
             adonisAuth: config.adonisAuth,
-            accountSession: { acceptIdpSession: config.accountSession?.acceptIdpSession === true },
+            accountSession: { acceptIdpSession: config.accountSession?.acceptIdpSession !== false },
         };
     });
 }

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

@@ -41,13 +41,12 @@ 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[];
 /**
- * Clients: verifica que não há clients estáticos no config (clients são 100%
- * runtime via console admin / Admin API).
+ * Clients: vivem no adapter, gerenciados pelo console admin / Admin API /
+ * `node ace authkit:clients:create`.
  */
 export declare function checkClients(input: DoctorInput): Finding;
 /**
- * Aviso de adapter volátil. Como clients são 100% runtime (sem config estático),
- * um adapter volátil (Redis sem persistência, in-memory) pode perder os clients
+ * Aviso de adapter volátil. Como os clients vivem no adapter, um adapter volátil (Redis sem persistência, in-memory) pode perder os clients
  * num restart sem aviso prévio.
  *
  * Detecção de volatilidade: o `AdapterClass` é inspecionado estruturalmente:
@@ -88,7 +87,7 @@ export declare function checkOtpLockout(input: DoctorInput): Finding | null;
 export declare function checkSudoMode(_input: DoctorInput): Finding | null;
 /** rateLimit ligado mas @adonisjs/limiter ausente → warn. */
 export declare function checkRateLimit(input: DoctorInput): Finding;
-/** admin.enabled mas sem roles → warn. Reporta o modo de UI ativo. */
+/** admin.enabled mas sem roles, ou sem `admin.authorize` → warn. Reporta o modo de UI ativo. */
 export declare function checkAdmin(input: DoctorInput): Finding | null;
 /** requireVerifiedEmail ligado mas o store não sabe checar verificação → warn. */
 export declare function checkRequireVerifiedEmail(input: DoctorInput): Finding | null;
@@ -215,6 +214,12 @@ export declare function checkPasskeyAutofill(input: DoctorInput): Finding | null
  * de TERCEIROS precisa saber que existe uma lista para fechar.
  */
 export declare function checkFirstPartyClients(input: DoctorInput): Finding | null;
+/**
+ * Como se entra no console de conta e no console admin. O default é o login do
+ * IdP (SSO, `accountSession.acceptIdpSession`); desligado, o console só tem o
+ * login próprio por senha.
+ */
+export declare function checkConsoleSignIn(input: DoctorInput): Finding | null;
 /**
  * Finding da idade da chave de assinatura managed. `ageDays === null` (sem
  * keystore em arquivo/cofre) → no-op `ok`. Acima de `maxAgeDays` → `warn`.

package/build/src/doctor/checks.js

@@ -48,22 +48,20 @@ export function checkIssuer(input) {
     return findings;
 }
 /**
- * Clients: verifica que não há clients estáticos no config (clients são 100%
- * runtime via console admin / Admin API).
+ * Clients: vivem no adapter, gerenciados pelo console admin / Admin API /
+ * `node ace authkit:clients:create`.
  */
 export function checkClients(input) {
     const cfg = input.authkitConfig;
     if (!cfg)
         return { level: 'error', message: 'no config to validate clients.' };
-    // clients sempre é [] no config resolvido — info apenas.
     return {
         level: 'ok',
         message: 'clients are managed at runtime via admin console / Admin API — use `node ace authkit:clients:create` to add clients.',
     };
 }
 /**
- * Aviso de adapter volátil. Como clients são 100% runtime (sem config estático),
- * um adapter volátil (Redis sem persistência, in-memory) pode perder os clients
+ * Aviso de adapter volátil. Como os clients vivem no adapter, um adapter volátil (Redis sem persistência, in-memory) pode perder os clients
  * num restart sem aviso prévio.
  *
  * Detecção de volatilidade: o `AdapterClass` é inspecionado estruturalmente:
@@ -98,9 +96,9 @@ export function checkAdapterVolatility(input) {
     // Adapter desconhecido ou volátil (Redis, memory, custom) — warn informativo.
     return {
         level: 'warn',
-        message: 'No static clients in config: if the OIDC adapter is volatile (Redis without AOF/RDB, in-memory, etc.), ' +
+        message: 'Clients live in the OIDC adapter: if it is volatile (Redis without AOF/RDB, in-memory, etc.), ' +
             'clients managed via console/API will be lost on restart. ' +
-            'Use a persistent adapter (DatabaseAdapter) or keep static clients as a fallback.',
+            'Use a persistent adapter (DatabaseAdapter).',
     };
 }
 /** accountStore presente + quais capacidades implementa. */
@@ -313,7 +311,7 @@ export function checkRateLimit(input) {
     }
     return { level: 'ok', message: 'rate-limiting on and @adonisjs/limiter available.' };
 }
-/** admin.enabled mas sem roles → warn. Reporta o modo de UI ativo. */
+/** admin.enabled mas sem roles, ou sem `admin.authorize` → warn. Reporta o modo de UI ativo. */
 export function checkAdmin(input) {
     const admin = input.authkitConfig?.admin;
     if (!admin || admin.enabled !== true)
@@ -325,6 +323,12 @@ export function checkAdmin(input) {
             message: 'admin console on, but no `admin.roles` — nobody will have access (the default ["ADMIN"] was not resolved here).',
         };
     }
+    if (!admin.authorize) {
+        return {
+            level: 'warn',
+            message: `admin console on for roles: ${roles.join(', ')}, but no \`admin.authorize\` — it is open outside production and denies every request in production. Set \`admin.authorize\` in config/authkit.ts.`,
+        };
+    }
     return {
         level: 'ok',
         message: `admin console on for roles: ${roles.join(', ')} (React SPA self-contained — JSON API under {prefix}/api/*).`,
@@ -910,6 +914,43 @@ export function checkFirstPartyClients(input) {
         message: `firstPartyClients: ${allowlist.length} client(s) receive the roles/organization claims (${allowlist.join(', ')}).`,
     };
 }
+/**
+ * Como se entra no console de conta e no console admin. O default é o login do
+ * IdP (SSO, `accountSession.acceptIdpSession`); desligado, o console só tem o
+ * login próprio por senha.
+ */
+export function checkConsoleSignIn(input) {
+    const cfg = input.authkitConfig;
+    if (!cfg)
+        return null;
+    const sso = cfg.accountSession?.acceptIdpSession !== false;
+    const passwordOff = cfg.authMethods?.password === false;
+    const routes = typeof cfg.routes === 'object' && cfg.routes ? cfg.routes : undefined;
+    if (!sso && passwordOff && !routes?.accountLoginUrl) {
+        return {
+            level: 'warn',
+            message: 'The account and admin consoles have no way to sign in unless `registerAuthHost` gets an ' +
+                '`accountLoginUrl`: `accountSession.acceptIdpSession` is false and password login is off ' +
+                '(`authMethods: { password: false }`), and route registration refuses to start without ' +
+                'one. Remove `acceptIdpSession: false` so the consoles sign in through the IdP, or point ' +
+                '`accountLoginUrl` at a login route of your app.',
+        };
+    }
+    if (!sso) {
+        return {
+            level: 'warn',
+            message: 'The consoles use their own password login (`accountSession.acceptIdpSession: false`): ' +
+                'users sign in twice, and passwordless accounts cannot open them. The default (SSO through ' +
+                'the IdP login) is recommended; sensitive operations still ask for sudo.',
+        };
+    }
+    return {
+        level: 'ok',
+        message: 'The consoles sign in through the IdP login (SSO). Sensitive operations ask for sudo. ' +
+            'Make sure admin accounts have MFA enrolled (or require it for everyone with ' +
+            '`mfa.requiredFactors`).',
+    };
+}
 /**
  * Finding da idade da chave de assinatura managed. `ageDays === null` (sem
  * keystore em arquivo/cofre) → no-op `ok`. Acima de `maxAgeDays` → `warn`.
@@ -1009,6 +1050,9 @@ export function runAllChecks(input) {
     const firstPartyClients = checkFirstPartyClients(input);
     if (firstPartyClients)
         findings.push(firstPartyClients);
+    const consoleSignIn = checkConsoleSignIn(input);
+    if (consoleSignIn)
+        findings.push(consoleSignIn);
     return findings;
 }
 /** Há algum finding de nível 'error'? (define o exit code). */

package/build/src/host/account_api/account_api_controller.d.ts

@@ -144,6 +144,7 @@ export default class AccountApiController {
         apps: {
             clientId: string;
             name: string;
+            logoUrl: string | null;
             accessTokens: number;
             refreshTokens: number;
         }[];
@@ -263,7 +264,7 @@ export default class AccountApiController {
         ok: boolean;
         revoked: string;
     }>;
-    /** Lista orgs do usuário logado. Alias consolidado dos /account/orgs/json existentes. */
+    /** Lista orgs do usuário logado. */
     listOrgs(ctx: HttpContext): Promise<{
         supported: boolean;
         activeOrgId: any;

package/build/src/host/account_api/account_api_controller.js

@@ -27,7 +27,7 @@
  *   GET  /account/api/orgs/:id             → detalhe de org (requer membership)
  *   GET  /account/api/orgs/invitations     → convites pendentes
  */
-import { clientDisplayNames } from '../client_names.js';
+import { clientDisplayInfo } from '../client_names.js';
 import '../augmentations.js';
 import { supportsAccountSecurity, supportsLoginMethodsPreference, supportsMagicLink, supportsOrganizations, supportsPasskeys, supportsProfile, supportsRecoveryCodeCount, supportsRecoveryCodeRegeneration, } from '../../accounts/account_store.js';
 import { personalAgentsFor } from '../../agents/runtime.js';
@@ -403,13 +403,6 @@ export default class AccountApiController {
                 oldEmail: account?.email ?? '',
             });
         }
-        else if (cfg.mail?.onEmailVerification) {
-            await cfg.mail.onEmailVerification({
-                email: newEmail,
-                verifyUrl: confirmUrl,
-                token: issued.token,
-            });
-        }
         else {
             await sendEmailChangeConfirmationEmail(ctx, { email: newEmail, confirmUrl });
         }
@@ -577,14 +570,15 @@ export default class AccountApiController {
             return { supported: false, apps: [] };
         }
         const grants = await adminSessions.listGrants(userId);
-        const names = await clientDisplayNames(service, grants.map((g) => g.clientId).filter((id) => !!id));
+        const info = await clientDisplayInfo(service, grants.map((g) => g.clientId).filter((id) => !!id));
         return {
             supported: true,
             apps: grants
                 .filter((g) => !!g.clientId)
                 .map((g) => ({
                 clientId: g.clientId,
-                name: names.get(g.clientId) ?? g.clientId,
+                name: info.get(g.clientId)?.name ?? g.clientId,
+                logoUrl: info.get(g.clientId)?.logoUrl ?? null,
                 accessTokens: g.accessTokens,
                 refreshTokens: g.refreshTokens,
             })),
@@ -934,7 +928,7 @@ export default class AccountApiController {
         return { ok: true, revoked: patId };
     }
     // ─── GET /account/api/orgs ───────────────────────────────────────────────
-    /** Lista orgs do usuário logado. Alias consolidado dos /account/orgs/json existentes. */
+    /** Lista orgs do usuário logado. */
     async listOrgs(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;

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

@@ -10,26 +10,30 @@ export default class ApiClientsController {
         data: {
             clientId: string;
             confidential: boolean;
-            grants: string[];
+            grantTypes: string[];
             redirectUris: string[];
             postLogoutRedirectUris: string[];
             tokenEndpointAuthMethod: string;
             applicationType: import("../client_metadata.js").ApplicationType;
             backchannelLogoutUri: string | null;
             backchannelLogoutSessionRequired: boolean;
+            clientName: string | null;
+            logoUri: string | null;
         }[];
         canList: boolean;
     }>;
     show(ctx: HttpContext): Promise<void | {
         clientId: string;
         confidential: boolean;
-        grants: string[];
+        grantTypes: string[];
         redirectUris: string[];
         postLogoutRedirectUris: string[];
         tokenEndpointAuthMethod: string;
         applicationType: import("../client_metadata.js").ApplicationType;
         backchannelLogoutUri: string | null;
         backchannelLogoutSessionRequired: boolean;
+        clientName: string | null;
+        logoUri: string | null;
     }>;
     store(ctx: HttpContext): Promise<void | {
         clientId: string;
@@ -38,13 +42,15 @@ export default class ApiClientsController {
     update(ctx: HttpContext): Promise<void | {
         clientId: string;
         confidential: boolean;
-        grants: string[];
+        grantTypes: string[];
         redirectUris: string[];
         postLogoutRedirectUris: string[];
         tokenEndpointAuthMethod: string;
         applicationType: import("../client_metadata.js").ApplicationType;
         backchannelLogoutUri: string | null;
         backchannelLogoutSessionRequired: boolean;
+        clientName: string | null;
+        logoUri: string | null;
     }>;
     regenerateSecret(ctx: HttpContext): Promise<void | {
         clientId: any;

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

@@ -31,13 +31,15 @@ export declare function userDtoWithRoles(cfg: Parameters<typeof resolveAccountRo
 export declare function clientDto(client: AdminClient): {
     clientId: string;
     confidential: boolean;
-    grants: string[];
+    grantTypes: string[];
     redirectUris: string[];
     postLogoutRedirectUris: string[];
     tokenEndpointAuthMethod: string;
     applicationType: import("../client_metadata.ts").ApplicationType;
     backchannelLogoutUri: string | null;
     backchannelLogoutSessionRequired: boolean;
+    clientName: string | null;
+    logoUri: string | null;
 };
 /** Inclui o secret (mostrado UMA vez) em create/regenerate. */
 export declare function createdClientDto(created: CreatedClient): {

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

@@ -23,13 +23,15 @@ export function clientDto(client) {
     return {
         clientId: client.clientId,
         confidential: client.confidential,
-        grants: client.grants,
+        grantTypes: client.grantTypes,
         redirectUris: client.redirectUris,
         postLogoutRedirectUris: client.postLogoutRedirectUris,
         tokenEndpointAuthMethod: client.tokenEndpointAuthMethod,
         applicationType: client.applicationType,
         backchannelLogoutUri: client.backchannelLogoutUri ?? null,
         backchannelLogoutSessionRequired: client.backchannelLogoutSessionRequired ?? false,
+        clientName: client.clientName,
+        logoUri: client.logoUri,
     };
 }
 /** Inclui o secret (mostrado UMA vez) em create/regenerate. */

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

@@ -18,8 +18,13 @@ export interface ClientInput {
     /**
      * 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).
+     * Num update, `null` remove a URI; ausente (`undefined`) preserva a atual.
      */
-    backchannelLogoutUri?: string;
+    backchannelLogoutUri?: string | null;
+    /** `client_name`: the name people see on consent and authorized-app screens. `null` removes it. */
+    clientName?: string | null;
+    /** `logo_uri`: the client's logo URL. `null` removes it. */
+    logoUri?: string | null;
     /**
      * Quando `true`, exige que o `logout_token` inclua a claim `sid`. Ignorado quando
      * `backchannelLogoutUri` não está definido.
@@ -30,7 +35,7 @@ export interface ClientInput {
 export interface AdminClient {
     clientId: string;
     confidential: boolean;
-    grants: string[];
+    grantTypes: string[];
     redirectUris: string[];
     postLogoutRedirectUris: string[];
     tokenEndpointAuthMethod: string;
@@ -40,6 +45,10 @@ export interface AdminClient {
     backchannelLogoutUri?: string;
     /** Exige sid no logout_token (opcional). */
     backchannelLogoutSessionRequired?: boolean;
+    /** `client_name` registrado, ou `null`. */
+    clientName: string | null;
+    /** `logo_uri` registrado, ou `null`. */
+    logoUri: string | null;
 }
 /** Resultado de uma criação: o client + o secret em claro (mostrado UMA vez). */
 export interface CreatedClient {
@@ -73,9 +82,8 @@ export declare class AdminClientsService {
      */
     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.
+     * Cria um client com um `clientSecret` fornecido externamente (em vez de gerar
+     * um aleatório) — ex.: para manter o secret que os RPs já usam.
      *
      * Para clients públicos (auth method `none`), `providedSecret` é ignorado.
      * Lança se o `clientId` já existir no adapter — chame `find` antes.