@adonis-agora/authkit-server 0.74.0 → 0.76.0

package/build/src/mcp/mcp_oauth.js

@@ -0,0 +1,154 @@
+import { resolveRedirectUriPolicy } from '../provider/registration_policy.js';
+/** Callbacks dos clientes MCP conhecidos. Loopback (Claude Code, CLIs) já entra pela política. */
+export const MCP_CLIENT_REDIRECTS = {
+    loopback: true,
+    exact: [
+        'https://claude.ai/api/mcp/auth_callback',
+        'https://claude.com/api/mcp/auth_callback',
+        'https://chatgpt.com/connector_platform_oauth_redirect',
+        'https://vscode.dev/redirect',
+        'https://insiders.vscode.dev/redirect',
+    ],
+    appSchemes: ['cursor', 'vscode', 'vscode-insiders'],
+    anyHttps: false,
+};
+/** Escopos de um token de servidor MCP: identidade + refresh. */
+export const MCP_RESOURCE_SCOPES = ['openid', 'profile', 'email', 'offline_access'];
+export function resolveMcpOAuth(input) {
+    const options = typeof input === 'object' ? input : {};
+    const extra = options.redirectUris ?? {};
+    return {
+        enabled: input === true || typeof input === 'object',
+        redirectUriPolicy: resolveRedirectUriPolicy({
+            loopback: extra.loopback ?? MCP_CLIENT_REDIRECTS.loopback,
+            exact: [...new Set([...MCP_CLIENT_REDIRECTS.exact, ...(extra.exact ?? [])])],
+            appSchemes: [...new Set([...MCP_CLIENT_REDIRECTS.appSchemes, ...(extra.appSchemes ?? [])])],
+            anyHttps: extra.anyHttps ?? MCP_CLIENT_REDIRECTS.anyHttps,
+        }),
+        resources: [...(options.resources ?? [])],
+    };
+}
+/**
+ * Registro em runtime — um slot global, para que outra lib (o MCP do `@adonis-agora/agent`) se
+ * registre sem importar esta: o contrato é o símbolo, não o módulo.
+ */
+const REGISTRY = Symbol.for('@adonis-agora/oauth:resources');
+function registry() {
+    const slot = globalThis;
+    if (!Array.isArray(slot[REGISTRY]))
+        slot[REGISTRY] = [];
+    return slot[REGISTRY];
+}
+export function registerOAuthResource(resource) {
+    if (!resource.url && !resource.path) {
+        throw new Error('authkit: registerOAuthResource precisa de `url` ou `path`.');
+    }
+    registry().push({ ...resource });
+}
+export function registeredOAuthResources() {
+    return registry();
+}
+const trim = (value) => value.replace(/\/+$/, '');
+function normalizePath(path) {
+    return `/${path.replace(/^\/+|\/+$/g, '')}`;
+}
+/**
+ * O resource MCP que `indicator` nomeia, ou `null`. Casa com `mcp.resources`, com uma URL
+ * registrada, ou com um `path` registrado na origem do issuer. Barra final tolerada.
+ */
+export function findMcpResource(indicator, issuer, config) {
+    if (!config.enabled)
+        return null;
+    let url;
+    try {
+        url = new URL(indicator);
+    }
+    catch {
+        return null;
+    }
+    const wanted = trim(url.href);
+    for (const declared of config.resources) {
+        if (trim(declared) === wanted)
+            return { audience: trim(declared), scopes: MCP_RESOURCE_SCOPES };
+    }
+    const issuerOrigin = new URL(issuer).origin;
+    for (const resource of registeredOAuthResources()) {
+        const scopes = resource.scopes ?? MCP_RESOURCE_SCOPES;
+        if (resource.url && trim(resource.url) === wanted)
+            return { audience: trim(resource.url), scopes };
+        if (resource.path &&
+            url.origin === issuerOrigin &&
+            trim(url.pathname) === normalizePath(resource.path) &&
+            !url.search) {
+            return { audience: wanted, scopes };
+        }
+    }
+    return null;
+}
+/**
+ * Registro de um cliente MCP: quem pede `refresh_token` ganha `openid offline_access` no escopo
+ * registrado, senão o provider recusaria pedi-los no authorize.
+ */
+export function mcpClientRegistration(metadata) {
+    const grants = Array.isArray(metadata.grant_types)
+        ? metadata.grant_types
+        : ['authorization_code'];
+    if (!grants.includes('refresh_token') || typeof metadata.scope !== 'string')
+        return metadata;
+    const scopes = metadata.scope.split(' ').filter(Boolean);
+    for (const needed of ['openid', 'offline_access']) {
+        if (!scopes.includes(needed))
+            scopes.push(needed);
+    }
+    return { ...metadata, scope: scopes.join(' ') };
+}
+/**
+ * `scope`/`prompt` do authorize de um cliente MCP para que saia um refresh token: `offline_access`
+ * no escopo e `consent` no prompt (sem ele o provider descarta o `offline_access`). `null` quando
+ * já estão lá. `prompt=none` pede "sem interação", o contrário de consentir: sai.
+ */
+export function withOfflineAccess(params) {
+    const scopes = String(params.scope ?? '')
+        .split(' ')
+        .filter(Boolean);
+    const prompts = String(params.prompt ?? '')
+        .split(' ')
+        .filter(Boolean);
+    const needsScope = !scopes.includes('offline_access');
+    const needsPrompt = !prompts.includes('consent');
+    if (!needsScope && !needsPrompt)
+        return null;
+    if (!scopes.includes('openid'))
+        scopes.unshift('openid');
+    if (needsScope)
+        scopes.push('offline_access');
+    const prompt = needsPrompt ? [...prompts.filter((p) => p !== 'none'), 'consent'] : prompts;
+    return { scope: scopes.join(' '), prompt: prompt.join(' ') };
+}
+/**
+ * Middleware do provider (Koa) que aplica {@link withOfflineAccess} ao `GET /auth` de um client
+ * registrado dinamicamente que tem o grant `refresh_token`.
+ */
+export function mcpAuthorizeMiddleware(provider) {
+    return async (ctx, next) => {
+        if (ctx.method !== 'GET' || ctx.path !== '/auth')
+            return next();
+        const query = ctx.query;
+        const clientId = typeof query.client_id === 'string' ? query.client_id : '';
+        if (!clientId || (query.response_type !== undefined && query.response_type !== 'code')) {
+            return next();
+        }
+        const client = await provider.Client.find(clientId).catch(() => undefined);
+        const metadata = client?.metadata?.() ?? {};
+        const grants = metadata.grant_types;
+        if (metadata.client_id_issued_at === undefined ||
+            !Array.isArray(grants) ||
+            !grants.includes('refresh_token')) {
+            return next();
+        }
+        const widened = withOfflineAccess(query);
+        if (widened)
+            ctx.query = { ...query, ...widened };
+        return next();
+    };
+}

package/build/src/provider/build_provider.js

@@ -2,9 +2,11 @@ import * as oidc from 'oidc-provider';
 import { pickModelAdapterClass } from '../adapters/factory.js';
 import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { assertClientMetadata } from '../host/client_metadata.js';
+import { findMcpResource, mcpAuthorizeMiddleware } from '../mcp/mcp_oauth.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
 import { registrationPolicyMiddleware } from './registration_policy.js';
+import { impersonationExtraClaims } from './token_exchange.js';
 /** Atualiza o holder mutável do TTL de sessão com os valores da setting. */
 export function updateSessionTtlHolder(holder, policy) {
     holder.rememberSec = Math.max(1, Math.floor(policy.rememberDays * 86400));
@@ -76,7 +78,8 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         const key = declaredResources.find((k) => k.replace(/\/+$/, '') === trimmed);
         return key ? { key, rc: at.resources[key] } : null;
     };
-    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0
+    const mcp = config.mcp;
+    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0 || mcp.enabled
         ? {
             resourceIndicators: {
                 enabled: true,
@@ -93,6 +96,15 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                 getResourceServerInfo: (_ctx, resourceIndicator, _client) => {
                     const found = findResource(resourceIndicator);
                     const isDefault = at.anyJwt && resourceIndicator === at.audience;
+                    // Servidores MCP (`mcp`): os declarados e os registrados em runtime.
+                    const mcpResource = found || isDefault ? null : findMcpResource(resourceIndicator, config.issuer, mcp);
+                    if (mcpResource) {
+                        return {
+                            scope: mcpResource.scopes.join(' '),
+                            audience: mcpResource.audience,
+                            accessTokenFormat: 'opaque',
+                        };
+                    }
                     if (!found && !isDefault) {
                         throw new oidc.errors.InvalidTarget(`resource indicator not allowed: ${resourceIndicator}`);
                     }
@@ -118,6 +130,10 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         }
         : {};
     const provider = new oidc.Provider(config.issuer, {
+        // O ator (`act`, RFC 8693) dos access tokens de impersonation — ver
+        // `impersonationExtraClaims` em `token_exchange.ts`. Sem isto o token trocado
+        // não se distingue de um token do próprio alvo no resource server.
+        extraTokenClaims: async (_ctx, token) => impersonationExtraClaims(token),
         // Dispatcher por modelo (suportado pelo oidc-provider: `Adapter` aceita
         // função `(name) => adapter` além de classe). Session-scoped vai pro
         // `SessionAdapterClass`, o resto pro `AdapterClass` — mesma regra de
@@ -336,6 +352,9 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             validate: dynReg.validateRegistration,
         }));
     }
+    // Refresh token dos clientes MCP registrados dinamicamente (ver mcp/mcp_oauth.ts).
+    if (mcp.enabled)
+        provider.use(mcpAuthorizeMiddleware(provider));
     provider.proxy = true;
     return provider;
 }

package/build/src/provider/oidc_service.d.ts

@@ -17,6 +17,14 @@ export declare class OidcService {
     get publicJwks(): {
         keys: Record<string, any>[];
     };
+    /**
+     * @internal JWKS PRIVADO em uso (mesmas chaves do `publicJwks`). Só para quem
+     * assina in-process com o keystore do IdP — tokens de delegação e recibos de
+     * personal agents. Troca junto com o provider numa rotação.
+     */
+    get signingJwks(): {
+        keys: Record<string, any>[];
+    };
     /** Pathname do issuer sem barra final (ex.: `/oidc`). Vazio quando montado na raiz. */
     readonly mountPath: string;
     readonly recorder: MetricsRecorder;

package/build/src/provider/oidc_service.js

@@ -14,6 +14,7 @@ export class OidcService {
     #callback;
     #interactions;
     #publicJwks;
+    #signingJwks;
     #appKey;
     get provider() {
         return this.#provider;
@@ -32,6 +33,14 @@ export class OidcService {
     get publicJwks() {
         return this.#publicJwks;
     }
+    /**
+     * @internal JWKS PRIVADO em uso (mesmas chaves do `publicJwks`). Só para quem
+     * assina in-process com o keystore do IdP — tokens de delegação e recibos de
+     * personal agents. Troca junto com o provider numa rotação.
+     */
+    get signingJwks() {
+        return this.#signingJwks;
+    }
     /** Pathname do issuer sem barra final (ex.: `/oidc`). Vazio quando montado na raiz. */
     mountPath;
     recorder;
@@ -181,6 +190,7 @@ export class OidcService {
                 // conta que acabou de desabilitar, recebendo tokens plenamente funcionais.
                 accountStore: config.accountStore,
                 audit: config.audit,
+                impersonateAdmins: config.admin.impersonateAdmins,
             });
         }
         // Quando o issuer tem um path (ex.: http://host/oidc), o provider precisa ser
@@ -215,6 +225,7 @@ export class OidcService {
         this.#callback = callback;
         this.#interactions = interactions;
         this.#publicJwks = toPublicJwks(jwks);
+        this.#signingJwks = jwks;
     }
     /**
      * Recarrega as chaves de assinatura AO VIVO: relê o keystore do cofre e reconstrói

package/build/src/provider/token_exchange.d.ts

@@ -56,5 +56,31 @@ export interface TokenExchangeDeps {
      * regra de todo o resto da lib — nunca quebra hosts com um store mínimo).
      */
     accountStore?: AccountStore;
+    /**
+     * Permite impersonar uma conta que TAMBÉM tem um dos `adminRoles`. Default
+     * `true` (back-compat). Com `false`, alvo admin vira `invalid_grant`: um admin
+     * não assume a identidade (e os tokens) de outro admin.
+     */
+    impersonateAdmins?: boolean;
 }
+/**
+ * Propriedade (não persistida) onde a troca marca o ator ANTES do `save()`. O
+ * `extraTokenClaims` do provider (`build_provider.ts`) a transforma em
+ * `extra.act` — é o único jeito de pôr claims no `extra` de um token opaco: o
+ * oidc-provider SOBRESCREVE `extra` com o retorno desse hook ao salvar.
+ */
+export declare const IMPERSONATION_ACTOR_PROP = "authkitImpersonationActor";
+/** `extraTokenClaims` do provider: `{ act }` para token de impersonation, nada para o resto. */
+export declare function impersonationExtraClaims(token: unknown): {
+    act: {
+        sub: string;
+    };
+} | undefined;
+/**
+ * O ator de um access token de impersonation: o `act` (RFC 8693 §4.1) gravado
+ * no `extra` do token trocado. `null` quando o token não é de impersonation.
+ */
+export declare function impersonationActorOf(token: {
+    extra?: unknown;
+} | null | undefined): string | null;
 export declare function registerTokenExchange(provider: any, deps: TokenExchangeDeps): void;

package/build/src/provider/token_exchange.js

@@ -2,6 +2,26 @@ import { errors } from 'oidc-provider';
 import { assertAccountEnabled } from '../host/login_attempt.js';
 const TOKEN_EXCHANGE = 'urn:ietf:params:oauth:grant-type:token-exchange';
 const ACCESS_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token';
+/**
+ * Propriedade (não persistida) onde a troca marca o ator ANTES do `save()`. O
+ * `extraTokenClaims` do provider (`build_provider.ts`) a transforma em
+ * `extra.act` — é o único jeito de pôr claims no `extra` de um token opaco: o
+ * oidc-provider SOBRESCREVE `extra` com o retorno desse hook ao salvar.
+ */
+export const IMPERSONATION_ACTOR_PROP = 'authkitImpersonationActor';
+/** `extraTokenClaims` do provider: `{ act }` para token de impersonation, nada para o resto. */
+export function impersonationExtraClaims(token) {
+    const actor = token?.[IMPERSONATION_ACTOR_PROP];
+    return typeof actor === 'string' && actor ? { act: { sub: actor } } : undefined;
+}
+/**
+ * O ator de um access token de impersonation: o `act` (RFC 8693 §4.1) gravado
+ * no `extra` do token trocado. `null` quando o token não é de impersonation.
+ */
+export function impersonationActorOf(token) {
+    const act = token?.extra?.act;
+    return typeof act?.sub === 'string' && act.sub ? act.sub : null;
+}
 /**
  * Interseção entre os scopes pedidos e os scopes permitidos do client (allowlist).
  * Preserva a ordem do pedido. Nunca excede a allowlist do client.
@@ -30,6 +50,12 @@ export function registerTokenExchange(provider, deps) {
         if (!subjectAt || subjectAt.isExpired) {
             throw new errors.InvalidGrant('subject_token invalid or expired');
         }
+        // Sem impersonation encadeada: um token que JÁ é de impersonation não vira
+        // subject de outra troca (o "ator" seria a conta personificada, e a trilha
+        // perderia quem de fato está agindo).
+        if (impersonationActorOf(subjectAt)) {
+            throw new errors.InvalidGrant('subject_token is already an impersonation token');
+        }
         // O subject_token DEVE ter sido emitido para o MESMO client autenticado: senão
         // um client B poderia trocar um AT emitido para o client A (cross-client).
         if (subjectAt.clientId !== client?.clientId) {
@@ -62,6 +88,9 @@ export function registerTokenExchange(provider, deps) {
         if (!target) {
             throw new errors.InvalidGrant('requested_subject not found');
         }
+        if (target.id === actor.id) {
+            throw new errors.InvalidGrant('requested_subject must be another account');
+        }
         // Status do alvo (disabled/expirado): mesmo gate de `attemptPasswordLogin`.
         // Sem isso, impersonar um alvo desabilitado mintava tokens funcionais para
         // uma identidade que o admin acreditava ter revogado. `accountStore` é
@@ -107,8 +136,6 @@ export function registerTokenExchange(provider, deps) {
             // Client sem allowlist declarada: comportamento atual preservado.
             scope = params.scope || DEFAULT_SCOPE;
         }
-        const at = new provider.AccessToken({ accountId: target.id, client, scope });
-        const accessToken = await at.save();
         // Token exchange is not tied to a browser session, so there is no active org
         // context here — roles are resolved for the impersonated target with clientId only.
         const roles = deps.resolveTokenRoles
@@ -117,6 +144,17 @@ export function registerTokenExchange(provider, deps) {
                 activeOrg: null,
             })
             : (target.globalRoles ?? []);
+        if (deps.impersonateAdmins === false && roles.some((r) => adminRoles.includes(r))) {
+            throw new errors.InvalidGrant('requested_subject is not impersonable');
+        }
+        // O ACCESS token (não só o id_token) carrega o ator: é o que o resource server
+        // vê a cada request (`oidcBearerGuard` → `impersonationState`/`realAccountId`).
+        // Sem isso, o token trocado era indistinguível de um token do próprio alvo, e
+        // toda regra "negado durante impersonation" deixava passar o app nativo.
+        // `extra` sai no JWT (formato jwt) e na introspecção (RFC 7662).
+        const at = new provider.AccessToken({ accountId: target.id, client, scope });
+        at[IMPERSONATION_ACTOR_PROP] = actor.id;
+        const accessToken = await at.save();
         const idToken = new provider.IdToken({
             sub: target.id,
             email: target.email,
@@ -134,7 +172,7 @@ export function registerTokenExchange(provider, deps) {
             email: target.email ?? null,
             clientId: client?.clientId ?? null,
             ip: ctx.req?.socket?.remoteAddress ?? null,
-            metadata: { scope },
+            metadata: { scope, jti: at.jti ?? null },
         });
         ctx.body = {
             access_token: accessToken,
@@ -143,6 +181,9 @@ export function registerTokenExchange(provider, deps) {
             expires_in: at.expiration ?? 3600,
             id_token: idTokenJwt,
             scope,
+            // RFC 8693 §4.1: o ator também no corpo da resposta (o `actSub` que o
+            // `requestTokenExchange` do host lê — antes ficava sempre vazio).
+            act: { sub: actor.id },
         };
     };
     provider.registerGrantType(TOKEN_EXCHANGE, handler, [

package/build/src/schema/ensure.js

@@ -203,6 +203,98 @@ const TABLES = [
             updated_at: (t) => t.timestamp('updated_at', { useTz: true }).nullable(),
         },
     },
+    /*
+     * As três tabelas de personal agents usam `dateTime(…, precision 3)` e não
+     * `timestamp`: no MySQL o TIMESTAMP sem fração arredonda o `last_polled_at`
+     * (um agente que respeita o `interval` levaria `slow_down`) e, com
+     * `explicit_defaults_for_timestamp=OFF`, o primeiro TIMESTAMP NOT NULL da
+     * tabela ganha `ON UPDATE CURRENT_TIMESTAMP` — marcar um refresh como usado
+     * reescreveria a validade dele. DATETIME não tem nenhum dos dois; no Postgres
+     * vira o mesmo `timestamptz`.
+     */
+    {
+        name: 'auth_agent_device_codes',
+        /**
+         * Pedidos de delegação de personal agents (device flow, RFC 8628). O
+         * `device_code` só existe como hash; o `user_code` é o que o usuário vê.
+         * Linhas expiradas são apagadas no próximo pedido.
+         */
+        create: (t) => {
+            t.string('id').primary();
+            t.string('device_code_hash', 64).notNullable().unique();
+            t.string('user_code', 16).notNullable().unique();
+            t.string('client_id', 2048).notNullable();
+            t.string('agent_sub').notNullable();
+            t.text('requested_scope').notNullable();
+            t.string('status', 16).notNullable();
+            t.string('account_id').nullable();
+            t.string('grant_id').nullable();
+            t.integer('interval_seconds').notNullable();
+            t.dateTime('last_polled_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable().index();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            device_code_hash: (t) => t.string('device_code_hash', 64),
+            user_code: (t) => t.string('user_code', 16),
+            client_id: (t) => t.string('client_id', 2048),
+            agent_sub: (t) => t.string('agent_sub'),
+            requested_scope: (t) => t.text('requested_scope'),
+            status: (t) => t.string('status', 16),
+            account_id: (t) => t.string('account_id').nullable(),
+            grant_id: (t) => t.string('grant_id').nullable(),
+            interval_seconds: (t) => t.integer('interval_seconds'),
+            last_polled_at: (t) => t.dateTime('last_polled_at', { useTz: true, precision: 3 }).nullable(),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
+    {
+        name: 'auth_agent_grants',
+        /**
+         * O que um usuário autorizou um personal agent a fazer na conta dele: um
+         * grant por (conta, agente, usuário do agente); aprovar mais scopes soma.
+         * `revoked_at` preenchido = revogado (os tokens param na próxima request).
+         */
+        create: (t) => {
+            t.string('id').primary();
+            t.string('account_id').notNullable().index();
+            t.string('client_id', 2048).notNullable();
+            t.string('agent_sub').notNullable();
+            t.text('scope').notNullable();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('revoked_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('updated_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            account_id: (t) => t.string('account_id'),
+            client_id: (t) => t.string('client_id', 2048),
+            agent_sub: (t) => t.string('agent_sub'),
+            scope: (t) => t.text('scope'),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            revoked_at: (t) => t.dateTime('revoked_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+            updated_at: (t) => t.dateTime('updated_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
+    {
+        name: 'auth_agent_refresh_tokens',
+        /** Refresh tokens dos grants de personal agents — só o hash, uso único. */
+        create: (t) => {
+            t.string('token_hash', 64).primary();
+            t.string('grant_id').notNullable().index();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('used_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            grant_id: (t) => t.string('grant_id').index(),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            used_at: (t) => t.dateTime('used_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
 ];
 /**
  * Probe searchPath-aware: `schema.hasTable` no Postgres ignora o

package/build/stubs/ui/react/pages/consent.tsx

@@ -9,14 +9,20 @@ export default function AuthkitConsent({
   params,
   csrfToken,
   brand,
+  clientName,
+  scopes = [],
 }: {
   uid: string;
   params: { client_id: string };
   csrfToken: string;
   brand?: AuthBrand;
+  /** O nome que o client registrou (ex.: "Claude Code"); sem ele, o `client_id`. */
+  clientName?: string;
+  /** Os escopos pedidos, com o rótulo de cada um. */
+  scopes?: { id: string; label: string }[];
 }) {
   const accent = brand?.accent ?? '#111827';
-  const appName = brand?.appName ?? params.client_id;
+  const appName = clientName ?? params.client_id;
 
   return (
     <AuthShell brand={brand}>
@@ -26,6 +32,16 @@ export default function AuthkitConsent({
         <p className="mt-2 text-sm text-gray-600">
           O app <strong>{appName}</strong> quer acessar sua conta.
         </p>
+        {scopes.length > 0 && (
+          <>
+            <p className="mt-4 text-sm font-medium text-gray-900">Ele vai poder:</p>
+            <ul className="mt-2 list-inside list-disc space-y-1 text-sm text-gray-600">
+              {scopes.map((scope) => (
+                <li key={scope.id}>{scope.label}</li>
+              ))}
+            </ul>
+          </>
+        )}
 
         <button
           type="submit"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.74.0",
+  "version": "0.76.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",

package/stubs/ui/react/pages/consent.tsx

@@ -9,14 +9,20 @@ export default function AuthkitConsent({
   params,
   csrfToken,
   brand,
+  clientName,
+  scopes = [],
 }: {
   uid: string;
   params: { client_id: string };
   csrfToken: string;
   brand?: AuthBrand;
+  /** O nome que o client registrou (ex.: "Claude Code"); sem ele, o `client_id`. */
+  clientName?: string;
+  /** Os escopos pedidos, com o rótulo de cada um. */
+  scopes?: { id: string; label: string }[];
 }) {
   const accent = brand?.accent ?? '#111827';
-  const appName = brand?.appName ?? params.client_id;
+  const appName = clientName ?? params.client_id;
 
   return (
     <AuthShell brand={brand}>
@@ -26,6 +32,16 @@ export default function AuthkitConsent({
         <p className="mt-2 text-sm text-gray-600">
           O app <strong>{appName}</strong> quer acessar sua conta.
         </p>
+        {scopes.length > 0 && (
+          <>
+            <p className="mt-4 text-sm font-medium text-gray-900">Ele vai poder:</p>
+            <ul className="mt-2 list-inside list-disc space-y-1 text-sm text-gray-600">
+              {scopes.map((scope) => (
+                <li key={scope.id}>{scope.label}</li>
+              ))}
+            </ul>
+          </>
+        )}
 
         <button
           type="submit"