@adonis-agora/authkit-server 0.68.4 → 0.69.0

package/build/index.d.ts

@@ -68,6 +68,7 @@ export type { ResolveGeo } from './src/host/geo.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export type { AuthMessages, I18nConfig } from './src/host/i18n.js';
 export { BUILTIN_MESSAGES, DEFAULT_LOCALE, DEFAULT_MESSAGES, PT_BR_MESSAGES, resolveMessages, translate, } from './src/host/i18n.js';
+export { ensureConsoleSession } from './src/host/idp_session_bridge.js';
 export type { ImpersonationClientLike, ImpersonationPanel } from './src/host/impersonation.js';
 export { buildImpersonationPanel } from './src/host/impersonation.js';
 export type { ImpersonationStartErrorCode, ImpersonationState, StartImpersonationParams, StopImpersonationOptions, TokenExchangeResult, } from './src/host/impersonation_session.js';
@@ -122,6 +123,7 @@ export { lucidPatStore } from './src/pat/lucid_pat_store.js';
 export type { IssuePatInput, PatRecord, PatStore } from './src/pat/pat_store.js';
 export { generatePatToken, hashPatToken } from './src/pat/pat_tokens.js';
 export { OidcService } from './src/provider/oidc_service.js';
+export { checkClientRegistration, classifyRedirect, type RedirectUriPolicy, type RegistrationOperation, RegistrationPolicyError, type ResolvedRedirectUriPolicy, type ValidateRegistrationHook, } from './src/provider/registration_policy.js';
 export { registerOidcRoutes } from './src/register_routes.js';
 export type { EnsureSchemaOptions, EnsureSchemaReport } from './src/schema/ensure.js';
 export { ensureAuthkitSchema } from './src/schema/ensure.js';

package/build/index.js

@@ -51,6 +51,7 @@ export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from
 export { authkitCsrfExceptions } from './src/host/csrf.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export { BUILTIN_MESSAGES, DEFAULT_LOCALE, DEFAULT_MESSAGES, PT_BR_MESSAGES, resolveMessages, translate, } from './src/host/i18n.js';
+export { ensureConsoleSession } from './src/host/idp_session_bridge.js';
 export { buildImpersonationPanel } from './src/host/impersonation.js';
 // Session impersonation — RP-side glue that routes through the IdP's RFC 8693
 // token-exchange (the IdP validates the admin role + audits). See
@@ -110,6 +111,7 @@ export { __setFetchForTests as __setPwnedFetchForTests, isPasswordPwned, } from
 export { lucidPatStore } from './src/pat/lucid_pat_store.js';
 export { generatePatToken, hashPatToken } from './src/pat/pat_tokens.js';
 export { OidcService } from './src/provider/oidc_service.js';
+export { checkClientRegistration, classifyRedirect, RegistrationPolicyError, } from './src/provider/registration_policy.js';
 export { registerOidcRoutes } from './src/register_routes.js';
 export { ensureAuthkitSchema } from './src/schema/ensure.js';
 export { stubsRoot } from './stubs/main.js';

package/build/src/define_config.d.ts

@@ -14,6 +14,7 @@ import type { AuthHostOptions } from './host/register_auth_host.js';
 import type { SudoMethod } from './host/sudo/types.js';
 import { type ResolvedTrustedDevicesConfig, type TrustedDevicesConfigInput } from './host/trusted_device.js';
 import type { PatStore } from './pat/pat_store.js';
+import { type RedirectUriPolicy, type ResolvedRedirectUriPolicy, type ValidateRegistrationHook } from './provider/registration_policy.js';
 export type { AuthAccount };
 export { adapters };
 export type AuthHostRenderer = (ctx: HttpContext, view: string, props: Record<string, unknown>) => unknown;
@@ -305,11 +306,37 @@ export interface DynamicRegistrationConfigInput {
      * registrado via o `registration_access_token` devolvido no registro. Default: false.
      */
     management?: boolean;
+    /**
+     * Política de redirect URIs aplicada a TODO registro (`POST /reg`) e update
+     * (`PUT /reg/:id`) ANTES do oidc-provider. Com a política ativa, o client
+     * também fica restrito ao fluxo de código (`authorization_code` +
+     * `refresh_token`, `response_type=code`; PKCE já é obrigatório no IdP), e
+     * um client só-loopback/app instalado é registrado como `application_type: native`.
+     *
+     * Default:
+     *   - registro ABERTO (sem `initialAccessToken`): `{ loopback: true }` — só
+     *     `http://localhost|127.0.0.1|[::1]` em qualquer porta. Callbacks web de
+     *     fornecedores (ex.: `https://claude.ai/api/mcp/auth_callback`) e esquemas
+     *     de app (`cursor`, `vscode`) precisam ser listados em `exact`/`appSchemes`.
+     *   - registro com `initialAccessToken`: sem política (quem tem o IAT é confiável).
+     *
+     * `false` desliga a política explicitamente (comportamento puro do oidc-provider).
+     */
+    redirectUriPolicy?: RedirectUriPolicy | false;
+    /**
+     * Gancho do host rodado depois da política de redirect: valida/ajusta o
+     * metadata do registro. Lance {@link RegistrationPolicyError} para recusar com
+     * `400`; retorne um objeto para substituir o metadata.
+     */
+    validateRegistration?: ValidateRegistrationHook;
 }
 export interface ResolvedDynamicRegistrationConfig {
     enabled: boolean;
     initialAccessToken?: string;
     management: boolean;
+    /** `null` = sem política de redirect (oidc-provider puro). */
+    redirectUriPolicy: ResolvedRedirectUriPolicy | null;
+    validateRegistration?: ValidateRegistrationHook;
 }
 /**
  * Resolve a config de registro dinâmico e VALIDA invariantes em tempo de resolução.
@@ -635,6 +662,9 @@ export declare function resolveAdminApi(input?: AdminApiConfigInput): ResolvedAd
  * A role `'owner'` é reservada: uma org SEMPRE precisa de pelo menos um owner.
  * `allowSelfCreate`: se um usuário autenticado pode criar sua própria org (default false).
  * `invitationTtlHours`: TTL dos convites em horas (default 168 = 7 dias).
+ * Os três são o default estático da política; a setting `organizations_policy`
+ * os sobrescreve em runtime — exceto quando `organizations` está declarado no
+ * config, o que trava a setting e faz destes campos a política efetiva.
  * `claimStrategy: 'active'`: emite claims da org ATIVA da sessão (única estratégia implementada).
  */
 export interface OrganizationsConfigInput {
@@ -646,6 +676,21 @@ export interface OrganizationsConfigInput {
      * Default: 'active'.
      */
     claimStrategy?: 'active';
+    /**
+     * Catálogo de roles de org aceitas em convites/membros. `owner` é sempre
+     * garantido. Default: `['owner', 'admin', 'member']`.
+     *
+     * Declarar `organizations` TRAVA a setting `organizations_policy` (ver
+     * `config-locks`): com a chave travada, os campos de política daqui SÃO a
+     * política efetiva. Sem eles, a política trava no default da lib — era o
+     * que acontecia antes destes campos existirem (e.g. `allowSelfCreate` preso
+     * em `false`, sem jeito de ligar).
+     */
+    roles?: string[];
+    /** Usuário autenticado pode criar a própria org em `/account/orgs`. Default: false. */
+    allowSelfCreate?: boolean;
+    /** TTL dos convites em horas. Default: 168 (7 dias). */
+    invitationTtlHours?: number;
 }
 export interface ResolvedOrganizationsConfig {
     /** `undefined` = auto (decide em runtime pelo capability-probing do store). */
@@ -1061,6 +1106,22 @@ export interface AuthServerConfigInput {
     adonisAuth?: {
         guard: string;
     };
+    /**
+     * Sessão do console de conta (`/account/*`, e o `/admin/*`).
+     *
+     * `acceptIdpSession: true` — SSO: o console aceita a sessão ATIVA do IdP (o
+     * login feito na interaction OIDC — senha, magic link, OTP, passkey, social)
+     * em vez de pedir um segundo login. A sessão de console aberta assim fica
+     * amarrada à sessão do IdP: termina quando ela termina (logout OIDC,
+     * 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.
+     */
+    accountSession?: {
+        acceptIdpSession?: boolean;
+    };
 }
 export interface ResolvedServerConfig {
     issuer: string;
@@ -1204,6 +1265,10 @@ export interface ResolvedServerConfig {
     adonisAuth?: {
         guard: string;
     };
+    /** Sessão do console. Ver {@link AuthServerConfigInput.accountSession}. */
+    accountSession: {
+        acceptIdpSession: boolean;
+    };
 }
 export declare function toSeconds(value: string | number | undefined, fallback: number): number;
 /**

package/build/src/define_config.js

@@ -13,6 +13,7 @@ import { generateJwks } from './keys/jwks_manager.js';
 import { KeystoreCodec } from './keys/keystore_codec.js';
 import { loadEncryptionService } from './keys/keystore_crypto.js';
 import { KeystoreManager, resolveKeystoreVault } from './keys/keystore_manager.js';
+import { OPEN_REGISTRATION_REDIRECT_POLICY, resolveRedirectUriPolicy, } from './provider/registration_policy.js';
 export { adapters };
 const RATE_LIMIT_DEFAULTS = {
     login: { points: 10, duration: '1 min' },
@@ -64,10 +65,20 @@ export function resolveDynamicRegistration(input) {
             'dynamicRegistration.enabled: true (RFC 7591). Habilite o registro dinâmico ' +
             'ou desligue o management.');
     }
+    const declared = input?.redirectUriPolicy;
+    const redirectUriPolicy = declared === false
+        ? null
+        : declared
+            ? resolveRedirectUriPolicy(declared)
+            : input?.initialAccessToken
+                ? null
+                : { ...OPEN_REGISTRATION_REDIRECT_POLICY };
     return {
         enabled,
         initialAccessToken: input?.initialAccessToken,
         management,
+        redirectUriPolicy,
+        validateRegistration: input?.validateRegistration,
     };
 }
 export function resolveDeviceFlow(input) {
@@ -183,9 +194,11 @@ export function resolveAdminApi(input) {
 export function resolveOrganizations(input) {
     return {
         enabled: input?.enabled,
-        roles: ['owner', 'admin', 'member'],
-        allowSelfCreate: false,
-        invitationTtlHours: 168,
+        roles: input?.roles && input.roles.length > 0 ? input.roles : ['owner', 'admin', 'member'],
+        allowSelfCreate: input?.allowSelfCreate ?? false,
+        invitationTtlHours: typeof input?.invitationTtlHours === 'number' && input.invitationTtlHours >= 1
+            ? Math.floor(input.invitationTtlHours)
+            : 168,
         claimStrategy: input?.claimStrategy ?? 'active',
     };
 }
@@ -433,6 +446,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 },
         };
     });
 }

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

@@ -2,7 +2,7 @@ import { supportsOrganizations } from '../../accounts/account_store.js';
 import { ADMIN_LIST_DEFAULT_SIZE, LIST_FIRST_PAGE } from '../../pagination.js';
 import { accountPath } from '../account_paths.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
-import { isRoleInCatalog, resolveRoleCatalogList } from '../runtime_toggles.js';
+import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy, resolveRoleCatalogList, } from '../runtime_toggles.js';
 /**
  * Lógica de gestão de organizações compartilhada entre o console admin (HTML)
  * e a Admin REST API (JSON). Usada pelos `AdminOrgsController` e `ApiOrgsController`.
@@ -278,7 +278,8 @@ export class AdminOrgsService {
             email: input.email,
             role: input.role,
             invitedBy: actor.actorId ?? 'admin',
-            ttlHours: this.cfg.organizations.invitationTtlHours,
+            // TTL da política efetiva da org (setting org → global → config).
+            ttlHours: (await resolveEffectiveOrganizationsPolicy(settings, this.orgPolicyConfigDefaults(), orgId)).invitationTtlHours,
         });
         // Sends the invitation email (best-effort). The host hook wins when present;
         // otherwise the host-kit sends its own branded/translated email, like every

package/build/src/host/controllers/account_orgs_controller.js

@@ -5,9 +5,27 @@ import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { ACTIVE_ORG_COOKIE, ACTIVE_ORG_COOKIE_TTL, encodeActiveOrgCookie, } from '../active_org_cookie.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
+import { ensureConsoleSession } from '../idp_session_bridge.js';
 import { authkitOrigin } from '../origin.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
-import { isRoleInCatalog } from '../runtime_toggles.js';
+import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy, } from '../runtime_toggles.js';
+/** Defaults estáticos da política de org (config do host) — o fallback da setting. */
+function orgPolicyDefaults(cfg) {
+    return {
+        roles: cfg.organizations.roles,
+        allowSelfCreate: cfg.organizations.allowSelfCreate,
+        invitationTtlHours: cfg.organizations.invitationTtlHours,
+    };
+}
+/**
+ * Política EFETIVA de organizações: setting `organizations_policy` (org → global)
+ * → `config.organizations` → default da lib. É o que a doc promete; antes este
+ * controller lia só o config estático, e a setting não tinha efeito aqui.
+ */
+async function effectiveOrgPolicy(ctx, cfg, orgId) {
+    const settings = await resolveRuntimeSettings(ctx);
+    return resolveEffectiveOrganizationsPolicy(settings, orgPolicyDefaults(cfg), orgId);
+}
 /**
  * Console de conta — Organizations. Server-rendered, padrão dos outros controllers
  * de conta (account_tokens_controller, account_security_controller, etc.).
@@ -51,12 +69,13 @@ export default class AccountOrgsController {
             const members = canManage ? await store.listOrgMembers(org.id) : [];
             return { ...org, members, canManage, isActive: org.id === activeOrgId };
         }));
+        const policy = await effectiveOrgPolicy(ctx, cfg);
         const props = {
             supported: true,
             orgs: orgsWithMembers,
             pendingInvitations: invitationsWithOrg,
-            allowSelfCreate: cfg.organizations.allowSelfCreate,
-            availableRoles: cfg.organizations.roles,
+            allowSelfCreate: policy.allowSelfCreate,
+            availableRoles: policy.roles,
             messages,
             csrfToken: ctx.request.csrfToken,
         };
@@ -69,9 +88,10 @@ export default class AccountOrgsController {
         const cfg = service.config;
         const store = cfg.accountStore;
         const accountId = session.get(ACCOUNT_SESSION_KEY);
-        if (!supportsOrganizations(store) || !cfg.organizations.allowSelfCreate) {
+        if (!supportsOrganizations(store))
+            return response.forbidden();
+        if (!(await effectiveOrgPolicy(ctx, cfg)).allowSelfCreate)
             return response.forbidden();
-        }
         const name = request.input('name', '').trim();
         const slug = request.input('slug', '').trim();
         if (!name || !slug)
@@ -179,11 +199,7 @@ export default class AccountOrgsController {
         // config → defaults). Role fora do catálogo é rejeitada (não cria convite).
         // Usa o helper PURO `isRoleInCatalog` (mesmo ponto de verdade do caminho admin).
         const settings = await resolveRuntimeSettings(ctx);
-        const roleValid = await isRoleInCatalog(role, settings, {
-            roles: cfg.organizations.roles,
-            allowSelfCreate: cfg.organizations.allowSelfCreate,
-            invitationTtlHours: cfg.organizations.invitationTtlHours,
-        }, params.id);
+        const roleValid = await isRoleInCatalog(role, settings, orgPolicyDefaults(cfg), params.id);
         if (!roleValid) {
             return response.unprocessableEntity({
                 error: { code: 'invalid_role', message: 'Role inválida.' },
@@ -194,12 +210,14 @@ export default class AccountOrgsController {
         if (role === 'owner' && membership.role !== 'owner') {
             return response.forbidden();
         }
+        // TTL da política efetiva da org (setting org → global → config), não só do config.
+        const policy = await resolveEffectiveOrganizationsPolicy(settings, orgPolicyDefaults(cfg), params.id);
         const { invitation, token } = await store.createOrgInvitation({
             organizationId: params.id,
             email,
             role,
             invitedBy: accountId,
-            ttlHours: cfg.organizations.invitationTtlHours,
+            ttlHours: policy.invitationTtlHours,
         });
         // Sends the invitation email (best-effort). The host hook wins when present;
         // otherwise the host-kit sends its own branded/translated email, like every
@@ -243,6 +261,8 @@ export default class AccountOrgsController {
         const { createHash } = await import('node:crypto');
         if (!supportsOrganizations(store))
             return response.notFound();
+        // Rota fora do guard: a sessão do IdP (SSO) também vale, se configurado.
+        await ensureConsoleSession(ctx);
         const accountId = session.get(ACCOUNT_SESSION_KEY);
         if (!accountId) {
             // Não logado: redireciona para login (configurável) com return URL
@@ -272,6 +292,8 @@ export default class AccountOrgsController {
         const { createHash } = await import('node:crypto');
         if (!supportsOrganizations(store))
             return response.notFound();
+        // Rota fora do guard: a sessão do IdP (SSO) também vale, se configurado.
+        await ensureConsoleSession(ctx);
         const accountId = session.get(ACCOUNT_SESSION_KEY);
         if (!accountId)
             return response.redirect(getAccountLoginUrl());

package/build/src/host/controllers/account_session_controller.js

@@ -4,6 +4,7 @@ import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { syncAdonisAuthLogin, syncAdonisAuthLogout } from '../adonis_auth_sync.js';
 import { translate } from '../i18n.js';
+import { endBridgedIdpSession } from '../idp_session_bridge.js';
 import { attemptPasswordLogin } from '../login_attempt.js';
 import { notifyLoginSuccess } from '../login_notify.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
@@ -134,6 +135,9 @@ export default class AccountSessionController {
         // timestamp, sem dono. Passou a ser vinculada — por isso este `forget`
         // continua sendo só do `ACCOUNT_SESSION_KEY`: trocada a conta, a marca de
         // sudo remanescente já não vale para ninguém.
+        // Console aberto pela sessão do IdP (SSO): encerra também essa sessão, senão
+        // o próximo request reabriria o console pela ponte e o "Sair" não valeria.
+        await endBridgedIdpSession(ctx);
         ctx.session.forget(ACCOUNT_SESSION_KEY);
         await ctx.session.regenerate();
         // Opt-in: espelha o logout no guard de @adonisjs/auth (ver adonisAuth em define_config.ts).

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

@@ -0,0 +1,55 @@
+/**
+ * Ponte SSO: sessão do IdP → sessão do console de conta (`/account/*`, `/admin/*`).
+ *
+ * POR QUE EXISTE. São duas sessões diferentes no mesmo host:
+ *
+ *   - a sessão do IdP (oidc-provider): cookie `_session`, criada quando o
+ *     usuário completa a interaction de login do `/oidc/auth` (senha, magic
+ *     link, OTP, passkey, social). É ela que dá o SSO entre os clients OIDC;
+ *   - a sessão do console: a chave `ACCOUNT_SESSION_KEY` na sessão do Adonis,
+ *     criada SÓ pelo login do próprio console (`POST /account/login`).
+ *
+ * O login do IdP nunca escrevia a segunda, então um usuário que acabou de
+ * entrar num app OIDC (inclusive o próprio host, quando ele é IdP e RP ao mesmo
+ * tempo) e abria `/account/*` levava um SEGUNDO pedido de login.
+ *
+ * Com `accountSession.acceptIdpSession: true`, os guards do console aceitam a
+ * sessão ATIVA do IdP: sem sessão de console, mas com uma sessão do IdP válida
+ * (cookie assinado + registro no adapter, não expirado) de uma conta existente
+ * e habilitada, o console é aberto para essa conta. A ponte fica AMARRADA à
+ * sessão do IdP que a originou (o `uid` dela vai na sessão do Adonis): quando a
+ * sessão do IdP acaba (logout OIDC, expiração, troca de conta), o console
+ * derivado dela acaba junto no próximo request.
+ *
+ * Default `false`: quem não liga continua exatamente como antes.
+ */
+import type { HttpContext } from '@adonisjs/core/http';
+/** Chave da sessão Adonis com o `uid` da sessão do IdP que originou o console. */
+export declare const ACCOUNT_IDP_SESSION_KEY = "authkit_idp_session_uid";
+/** O que interessa de uma sessão do oidc-provider (instância do model `Session`). */
+interface IdpSession {
+    uid: string;
+    accountId?: string;
+    destroy(): Promise<void>;
+}
+/**
+ * Lê a sessão do IdP a partir do cookie do request (mesma leitura que o
+ * provider faz: cookie `_session` assinado com as keys do provider, e o registro
+ * no adapter, que já descarta expirados). `null` sem sessão logada.
+ */
+export declare function readIdpSession(ctx: HttpContext, service: any): Promise<IdpSession | null>;
+/**
+ * Garante a sessão do console, aceitando a sessão do IdP quando configurado.
+ * Devolve `true` quando o request tem (ou passou a ter) sessão de console.
+ *
+ * Sem `accountSession.acceptIdpSession`, é só "existe `ACCOUNT_SESSION_KEY`?" —
+ * o comportamento de sempre, sem tocar no provider.
+ */
+export declare function ensureConsoleSession(ctx: HttpContext): Promise<boolean>;
+/**
+ * Logout do console de uma sessão que veio da ponte: encerra também a sessão
+ * do IdP que a originou — senão o próximo request reabriria o console pela
+ * própria ponte e o "Sair" não teria efeito. No-op fora da ponte.
+ */
+export declare function endBridgedIdpSession(ctx: HttpContext): Promise<void>;
+export {};

package/build/src/host/idp_session_bridge.js

@@ -0,0 +1,108 @@
+import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { syncAdonisAuthLogin } from './adonis_auth_sync.js';
+import { impersonationState } from './impersonation_session.js';
+import { assertAccountEnabled } from './login_attempt.js';
+/** Chave da sessão Adonis com o `uid` da sessão do IdP que originou o console. */
+export const ACCOUNT_IDP_SESSION_KEY = 'authkit_idp_session_uid';
+/**
+ * Lê a sessão do IdP a partir do cookie do request (mesma leitura que o
+ * provider faz: cookie `_session` assinado com as keys do provider, e o registro
+ * no adapter, que já descarta expirados). `null` sem sessão logada.
+ */
+export async function readIdpSession(ctx, service) {
+    const provider = service?.provider;
+    if (!provider?.Session || typeof provider.createContext !== 'function')
+        return null;
+    try {
+        const kctx = provider.createContext(ctx.request.request, ctx.response.response);
+        const id = kctx.cookies.get(provider.cookieName('session'));
+        if (!id)
+            return null;
+        const session = (await provider.Session.find(id));
+        return session?.accountId ? session : null;
+    }
+    catch {
+        // Fail-safe: sem ponte (o guard segue para o login normal).
+        return null;
+    }
+}
+function acceptsIdpSession(service) {
+    return service?.config?.accountSession?.acceptIdpSession === true;
+}
+/** Id do humano por trás da sessão do console (impersonation → o admin real). */
+function realConsoleAccount(ctx, current) {
+    try {
+        return impersonationState(ctx).impersonatorId ?? current;
+    }
+    catch {
+        return current;
+    }
+}
+/**
+ * Garante a sessão do console, aceitando a sessão do IdP quando configurado.
+ * Devolve `true` quando o request tem (ou passou a ter) sessão de console.
+ *
+ * Sem `accountSession.acceptIdpSession`, é só "existe `ACCOUNT_SESSION_KEY`?" —
+ * o comportamento de sempre, sem tocar no provider.
+ */
+export async function ensureConsoleSession(ctx) {
+    const current = ctx.session?.get(ACCOUNT_SESSION_KEY);
+    const service = await ctx.containerResolver?.make('authkit.server').catch(() => null);
+    if (!acceptsIdpSession(service))
+        return Boolean(current);
+    const bridgedUid = ctx.session?.get(ACCOUNT_IDP_SESSION_KEY);
+    // Login próprio do console (não veio da ponte): intocado.
+    if (current && !bridgedUid)
+        return true;
+    const idp = await readIdpSession(ctx, service);
+    if (current && bridgedUid) {
+        if (idp && idp.uid === bridgedUid && idp.accountId === realConsoleAccount(ctx, current)) {
+            return true;
+        }
+        // A sessão do IdP que originou o console acabou (ou virou outra conta):
+        // encerra o console derivado dela. Se houver outra sessão do IdP viva, a
+        // ponte abaixo reabre para a conta dela.
+        ctx.session.forget(ACCOUNT_SESSION_KEY);
+        ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
+    }
+    if (!idp?.accountId)
+        return false;
+    const cfg = service.config;
+    const account = await cfg.accountStore.findById(idp.accountId);
+    if (!account)
+        return false;
+    const gate = await assertAccountEnabled(cfg, account.id, {
+        email: account.email ?? '',
+        ip: ctx.request.ip?.() ?? null,
+    });
+    if (!gate.allowed)
+        return false;
+    // Elevação anônimo → autenticado: troca o id da sessão (anti-fixation), como
+    // o login do console faz.
+    await ctx.session.regenerate();
+    ctx.session.put(ACCOUNT_SESSION_KEY, account.id);
+    ctx.session.put(ACCOUNT_IDP_SESSION_KEY, idp.uid);
+    await syncAdonisAuthLogin(ctx, cfg, account);
+    return true;
+}
+/**
+ * Logout do console de uma sessão que veio da ponte: encerra também a sessão
+ * do IdP que a originou — senão o próximo request reabriria o console pela
+ * própria ponte e o "Sair" não teria efeito. No-op fora da ponte.
+ */
+export async function endBridgedIdpSession(ctx) {
+    const bridgedUid = ctx.session?.get(ACCOUNT_IDP_SESSION_KEY);
+    if (!bridgedUid)
+        return;
+    ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
+    const service = await ctx.containerResolver?.make('authkit.server').catch(() => null);
+    const idp = await readIdpSession(ctx, service);
+    if (idp && idp.uid === bridgedUid) {
+        try {
+            await idp.destroy();
+        }
+        catch {
+            // best-effort
+        }
+    }
+}

package/build/src/host/middleware/account_auth.js

@@ -1,11 +1,12 @@
 import '../augmentations.js';
 import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
+import { ensureConsoleSession } from '../idp_session_bridge.js';
 export { ACCOUNT_SESSION_KEY };
 export default class AccountAuthMiddleware {
     async handle(ctx, next) {
-        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        if (!userId) {
+        // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
+        if (!(await ensureConsoleSession(ctx))) {
             // Destino configurável (`accountLoginUrl`): default `/account/login`.
             return ctx.response.redirect(getAccountLoginUrl());
         }

package/build/src/host/register_auth_host.js

@@ -7,6 +7,7 @@ import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
 import { adminApiGuard } from './admin_api/admin_api_guard.js';
 import { normalizeAdminApiPrefix, normalizeAdminPrefix, setAdminApiPrefix, setAdminPrefix, } from './admin_prefix.js';
 import { getAuthHostConfig, markAuthHostAutoMounted, wasAuthHostAutoMounted, } from './auth_host_config.js';
+import { ensureConsoleSession } from './idp_session_bridge.js';
 import { createAuthThrottles } from './rate_limit.js';
 import { resolveRuntimeSettings } from './runtime_settings.js';
 import { resolveEffectiveSessionPolicy } from './runtime_toggles.js';
@@ -113,7 +114,8 @@ function buildLoginRedirect(ctx, extra) {
  * /account/mfa acessíveis sem sessão.
  */
 const accountGuard = async (ctx, next) => {
-    if (!ctx.session?.get(ACCOUNT_SESSION_KEY)) {
+    // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
+    if (!(await ensureConsoleSession(ctx))) {
         return ctx.response.redirect(buildLoginRedirect(ctx));
     }
     // Idle timeout: encerra e redireciona com query param de motivo.
@@ -143,6 +145,8 @@ export const adminGuard = async (ctx, next) => {
     if (!cfg.admin.enabled) {
         return ctx.response.notFound();
     }
+    // Com `accountSession.acceptIdpSession`, a sessão do IdP também abre o console.
+    await ensureConsoleSession(ctx);
     const accountId = ctx.session?.get(ACCOUNT_SESSION_KEY);
     if (!accountId) {
         // `/account/login` é sempre o login da conta — NÃO muda com o prefixo admin.

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

@@ -762,11 +762,11 @@ export declare function resolveEffectiveRolesCatalog(settings: SettingsCapabilit
  *
  * Invariante mantida: 'owner' é sempre incluído na lista de roles (governance).
  *
- * @param settings - SettingsCapability
+ * @param settings - SettingsCapability, ou null (runtime settings indisponível → config/defaults)
  * @param configDefault - defaults estáticos do config do host
  * @param orgId - opcional; quando fornecido, tenta settings da org antes do global
  */
-export declare function resolveEffectiveOrganizationsPolicy(settings: SettingsCapability, configDefault?: OrganizationsPolicyConfigDefaults, orgId?: string | null): Promise<ResolvedOrganizationsPolicySetting>;
+export declare function resolveEffectiveOrganizationsPolicy(settings: SettingsCapability | null, configDefault?: OrganizationsPolicyConfigDefaults, orgId?: string | null): Promise<ResolvedOrganizationsPolicySetting>;
 /**
  * Resolve o CATÁLOGO efetivo de roles de org (lista de roles permitidas),
  * garantindo a invariante de governance: `owner` está sempre presente.

package/build/src/host/runtime_toggles.js

@@ -737,7 +737,7 @@ export async function resolveEffectiveRolesCatalog(settings, orgId) {
  *
  * Invariante mantida: 'owner' é sempre incluído na lista de roles (governance).
  *
- * @param settings - SettingsCapability
+ * @param settings - SettingsCapability, ou null (runtime settings indisponível → config/defaults)
  * @param configDefault - defaults estáticos do config do host
  * @param orgId - opcional; quando fornecido, tenta settings da org antes do global
  */
@@ -769,6 +769,8 @@ export async function resolveEffectiveOrganizationsPolicy(settings, configDefaul
             roles,
         };
     }
+    if (!settings)
+        return defaults;
     try {
         // Resolução org → global → defaults
         if (orgId) {

package/build/src/provider/build_provider.js

@@ -3,6 +3,7 @@ import { pickModelAdapterClass } from '../adapters/factory.js';
 import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
+import { registrationPolicyMiddleware } from './registration_policy.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));
@@ -47,18 +48,34 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             },
         }
         : {};
-    // Access Tokens RFC 9068 (JWT) via Resource Indicators (RFC 8707). Só montamos a
-    // feature quando ALGUM AT deve ser JWT — caso contrário (default opaque) o
-    // oidc-provider mantém o comportamento atual (AT opaco introspecionável) intocado.
+    // Resource Indicators (RFC 8707). A feature do oidc-provider é montada quando:
     //
-    // Um JWT AT no oidc-provider SEMPRE exige um resource indicator com `aud`: o
-    // `defaultResource` injeta a resource default (o `audience`, default issuer) quando
-    // o client não pede `resource` explicitamente, e o `getResourceServerInfo` descreve
-    // a API (scope/audience/formato/TTL) — onde `accessTokenFormat: 'jwt'` faz o token
-    // sair como JWS `typ: at+jwt` assinado com a chave corrente do JWKS.
+    //   - ALGUM AT deve ser JWT (RFC 9068): um JWT AT SEMPRE exige um resource com
+    //     `aud`, então o `defaultResource` injeta o `audience` (default issuer)
+    //     quando o client não pede `resource` — comportamento histórico; ou
+    //   - há `accessTokens.resources` declarados, mesmo todos OPACOS: clientes que
+    //     mandam `resource` (ex.: clientes MCP, cuja spec exige o parâmetro) passam
+    //     a ser aceitos. Sem `resource` no pedido, NADA muda: o `defaultResource`
+    //     devolve `undefined` e o AT continua o opaco de sempre (userinfo, sessão
+    //     web), sem `aud`.
+    //
+    // Nos dois casos o `resource` pedido é validado contra a lista declarada
+    // (chaves de `resources` + o `audience` no modo JWT): fora dela → `invalid_target`
+    // (RFC 8707 §2). O resource concedido fica registrado no Grant (consent) e no
+    // AT (`aud` = `audience` da resource), inclusive no token opaco, que continua
+    // encontrável por `AccessToken.find` e introspecionável.
     const at = config.accessTokens;
     const allScopes = ['openid', 'profile', 'email', 'offline_access', 'roles'];
-    const resourceIndicatorFeatures = at.anyJwt
+    const declaredResources = Object.keys(at.resources);
+    const findResource = (indicator) => {
+        if (at.resources[indicator])
+            return { key: indicator, rc: at.resources[indicator] };
+        // Tolerância à barra final (`https://app/mcp` ≡ `https://app/mcp/`).
+        const trimmed = indicator.replace(/\/+$/, '');
+        const key = declaredResources.find((k) => k.replace(/\/+$/, '') === trimmed);
+        return key ? { key, rc: at.resources[key] } : null;
+    };
+    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0
         ? {
             resourceIndicators: {
                 enabled: true,
@@ -67,14 +84,20 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                     // resources já concedidas — devolvemos para não falhar a request.
                     if (oneOf)
                         return oneOf;
-                    // Authorize/sem resource explícito: liga ao resource default (modo simples).
-                    return at.audience;
+                    // Authorize/sem resource explícito: no modo JWT, liga ao resource
+                    // default (modo simples). Só opaco: sem resource (AT de sempre).
+                    return at.anyJwt ? at.audience : undefined;
                 },
                 useGrantedResource: async () => true,
                 getResourceServerInfo: (_ctx, resourceIndicator, _client) => {
-                    const rc = at.resources[resourceIndicator];
-                    const format = rc?.format ?? (resourceIndicator === at.audience ? at.format : 'opaque');
-                    const audience = rc?.audience ?? resourceIndicator;
+                    const found = findResource(resourceIndicator);
+                    const isDefault = at.anyJwt && resourceIndicator === at.audience;
+                    if (!found && !isDefault) {
+                        throw new oidc.errors.InvalidTarget(`resource indicator not allowed: ${resourceIndicator}`);
+                    }
+                    const rc = found?.rc;
+                    const format = rc?.format ?? at.format;
+                    const audience = rc?.audience ?? found?.key ?? resourceIndicator;
                     const scope = (rc?.scopes ?? allScopes).join(' ');
                     const info = {
                         scope,
@@ -279,6 +302,15 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         writable: true,
         configurable: true,
     });
+    // Política do registro dinâmico (redirect URIs + só fluxo de código + gancho do
+    // host). Middleware PRÉ-rota: roda antes do `/reg` do provider, que sozinho
+    // aceitaria qualquer redirect sintaticamente válido. Ver registration_policy.ts.
+    if (dynReg.enabled && (dynReg.redirectUriPolicy || dynReg.validateRegistration)) {
+        provider.use(registrationPolicyMiddleware({
+            policy: dynReg.redirectUriPolicy,
+            validate: dynReg.validateRegistration,
+        }));
+    }
     provider.proxy = true;
     return provider;
 }

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

@@ -0,0 +1,99 @@
+/**
+ * Política do registro dinâmico de clients (RFC 7591 / RFC 7592).
+ *
+ * O oidc-provider, sozinho, aceita qualquer `redirect_uri` que passe na
+ * validação sintática de metadata (qualquer `https://…`, por exemplo). Com o
+ * registro ABERTO (sem Initial Access Token — o caso dos clientes MCP, que não
+ * têm como obter um IAT), isso deixa qualquer um registrar um client cujo
+ * callback é um domínio do atacante e usar a tela de consent do IdP como isca.
+ * O que protege o usuário é PARA ONDE o código de autorização pode ir.
+ *
+ * Esta política roda ANTES do provider (middleware Koa em `provider.use`), no
+ * `POST /reg` (criação) e no `PUT /reg/:clientId` (update do RFC 7592), e:
+ *
+ *   1. confere cada `redirect_uris` / `post_logout_redirect_uris` contra a
+ *      política (loopback, URLs exatas, esquemas de app instalado, https);
+ *   2. restringe o client ao fluxo de código (`authorization_code` +
+ *      `refresh_token`, `response_type=code`) — PKCE já é obrigatório no IdP;
+ *   3. normaliza `application_type: 'native'` quando todos os redirects são
+ *      loopback/app instalado (é o que o client é, e sem isso o oidc-provider
+ *      recusa esquema próprio);
+ *   4. chama o gancho `validateRegistration` do host, se houver.
+ *
+ * Funções puras + um middleware fino, para serem testadas isoladamente.
+ */
+/** Política de redirect URIs aceita no registro dinâmico. */
+export interface RedirectUriPolicy {
+    /**
+     * Aceita `http://localhost`, `http://127.0.0.1` e `http://[::1]` em QUALQUER
+     * porta e path (RFC 8252 §7.3 — apps nativos/CLIs escutam numa porta efêmera).
+     * Default: `true`.
+     */
+    loopback?: boolean;
+    /** URLs de callback aceitas por igualdade EXATA (ex.: callbacks de fornecedores). Default: `[]`. */
+    exact?: string[];
+    /**
+     * Esquemas privados de app instalado (RFC 8252 §7.1), sem o `:`, ex.:
+     * `['cursor', 'vscode']`. Default: `[]`.
+     */
+    appSchemes?: string[];
+    /**
+     * Aceita QUALQUER redirect `https://`. É o comportamento do oidc-provider sem
+     * política — só faz sentido com registro protegido por Initial Access Token.
+     * Default: `false`.
+     */
+    anyHttps?: boolean;
+}
+export interface ResolvedRedirectUriPolicy {
+    loopback: boolean;
+    exact: string[];
+    appSchemes: string[];
+    anyHttps: boolean;
+}
+/** Operação de registro que está sendo validada. */
+export type RegistrationOperation = 'create' | 'update';
+/**
+ * Gancho do host para validar/ajustar o metadata de um registro dinâmico,
+ * depois da política de redirect. Pode:
+ *   - retornar `void` → segue com o metadata como está;
+ *   - retornar um objeto → ele SUBSTITUI o metadata enviado ao provider;
+ *   - lançar {@link RegistrationPolicyError} → o registro é recusado com
+ *     `400 { error, error_description }`.
+ * Qualquer outro erro sobe (500).
+ */
+export type ValidateRegistrationHook = (metadata: Record<string, unknown>, info: {
+    operation: RegistrationOperation;
+    ctx: unknown;
+}) => void | Record<string, unknown> | Promise<void | Record<string, unknown>>;
+/** Erro de política: vira `400 { error: code, error_description: message }`. */
+export declare class RegistrationPolicyError extends Error {
+    readonly code: 'invalid_redirect_uri' | 'invalid_client_metadata';
+    constructor(code: 'invalid_redirect_uri' | 'invalid_client_metadata', description: string);
+}
+/** Default seguro do registro ABERTO: só loopback, nada de web arbitrário. */
+export declare const OPEN_REGISTRATION_REDIRECT_POLICY: ResolvedRedirectUriPolicy;
+export declare function resolveRedirectUriPolicy(input: RedirectUriPolicy): ResolvedRedirectUriPolicy;
+export type RedirectKind = 'loopback' | 'app' | 'web';
+/** Classifica um redirect pela política; `null` = fora dela. */
+export declare function classifyRedirect(uri: string, policy: ResolvedRedirectUriPolicy): RedirectKind | null;
+/**
+ * Confere o metadata de um registro contra a política. Devolve o metadata
+ * normalizado ou lança {@link RegistrationPolicyError}.
+ */
+export declare function checkClientRegistration(metadata: Record<string, unknown>, policy: ResolvedRedirectUriPolicy): Record<string, unknown>;
+/**
+ * Qual operação de registro o request atinge, com a MESMA regra de casamento do
+ * router do provider: case-insensitive e, se o path exato não casar, uma nova
+ * tentativa sem UMA barra final (`/reg/` ≡ `/reg`). `null` = não é registro.
+ */
+export declare function registrationOperation(method: string, path: string, foldedBase: string): RegistrationOperation | null;
+/**
+ * Middleware Koa (para `provider.use`) que aplica a política no registro
+ * dinâmico. `registrationPath` é o path da rota DENTRO do provider (default
+ * `/reg`; sob koa-mount o prefixo do issuer já foi removido).
+ */
+export declare function registrationPolicyMiddleware(options: {
+    policy: ResolvedRedirectUriPolicy | null;
+    validate?: ValidateRegistrationHook;
+    registrationPath?: string;
+}): (ctx: any, next: () => Promise<void>) => Promise<void>;

package/build/src/provider/registration_policy.js

@@ -0,0 +1,229 @@
+/**
+ * Política do registro dinâmico de clients (RFC 7591 / RFC 7592).
+ *
+ * O oidc-provider, sozinho, aceita qualquer `redirect_uri` que passe na
+ * validação sintática de metadata (qualquer `https://…`, por exemplo). Com o
+ * registro ABERTO (sem Initial Access Token — o caso dos clientes MCP, que não
+ * têm como obter um IAT), isso deixa qualquer um registrar um client cujo
+ * callback é um domínio do atacante e usar a tela de consent do IdP como isca.
+ * O que protege o usuário é PARA ONDE o código de autorização pode ir.
+ *
+ * Esta política roda ANTES do provider (middleware Koa em `provider.use`), no
+ * `POST /reg` (criação) e no `PUT /reg/:clientId` (update do RFC 7592), e:
+ *
+ *   1. confere cada `redirect_uris` / `post_logout_redirect_uris` contra a
+ *      política (loopback, URLs exatas, esquemas de app instalado, https);
+ *   2. restringe o client ao fluxo de código (`authorization_code` +
+ *      `refresh_token`, `response_type=code`) — PKCE já é obrigatório no IdP;
+ *   3. normaliza `application_type: 'native'` quando todos os redirects são
+ *      loopback/app instalado (é o que o client é, e sem isso o oidc-provider
+ *      recusa esquema próprio);
+ *   4. chama o gancho `validateRegistration` do host, se houver.
+ *
+ * Funções puras + um middleware fino, para serem testadas isoladamente.
+ */
+/** Erro de política: vira `400 { error: code, error_description: message }`. */
+export class RegistrationPolicyError extends Error {
+    code;
+    constructor(code, description) {
+        super(description);
+        this.name = 'RegistrationPolicyError';
+        this.code = code;
+    }
+}
+/** Default seguro do registro ABERTO: só loopback, nada de web arbitrário. */
+export const OPEN_REGISTRATION_REDIRECT_POLICY = Object.freeze({
+    loopback: true,
+    exact: [],
+    appSchemes: [],
+    anyHttps: false,
+});
+export function resolveRedirectUriPolicy(input) {
+    return {
+        loopback: input.loopback ?? true,
+        exact: [...(input.exact ?? [])],
+        appSchemes: (input.appSchemes ?? []).map((s) => s.replace(/:$/, '').toLowerCase()),
+        anyHttps: input.anyHttps ?? false,
+    };
+}
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Classifica um redirect pela política; `null` = fora dela. */
+export function classifyRedirect(uri, policy) {
+    let url;
+    try {
+        url = new URL(uri);
+    }
+    catch {
+        return null;
+    }
+    // Credencial embutida e fragmento nunca são redirect legítimo (RFC 6749 §3.1.2).
+    if (url.username || url.password || url.hash)
+        return null;
+    if (policy.loopback && url.protocol === 'http:' && LOOPBACK_HOSTS.has(url.hostname)) {
+        return 'loopback';
+    }
+    if (policy.exact.includes(uri))
+        return 'web';
+    const scheme = url.protocol.slice(0, -1).toLowerCase();
+    if (policy.appSchemes.includes(scheme))
+        return 'app';
+    if (policy.anyHttps && url.protocol === 'https:')
+        return 'web';
+    return null;
+}
+function stringList(value) {
+    if (value === undefined)
+        return null;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string'))
+        return null;
+    return value;
+}
+const ALLOWED_GRANTS = new Set(['authorization_code', 'refresh_token']);
+/**
+ * Confere o metadata de um registro contra a política. Devolve o metadata
+ * normalizado ou lança {@link RegistrationPolicyError}.
+ */
+export function checkClientRegistration(metadata, policy) {
+    const redirects = stringList(metadata.redirect_uris);
+    if (!redirects || redirects.length === 0) {
+        throw new RegistrationPolicyError('invalid_redirect_uri', 'redirect_uris is required');
+    }
+    const kinds = [];
+    for (const uri of redirects) {
+        const kind = classifyRedirect(uri, policy);
+        if (!kind) {
+            throw new RegistrationPolicyError('invalid_redirect_uri', `redirect_uri not allowed by the registration policy: ${uri}`);
+        }
+        kinds.push(kind);
+    }
+    if (metadata.post_logout_redirect_uris !== undefined) {
+        const logout = stringList(metadata.post_logout_redirect_uris);
+        if (!logout || logout.some((uri) => !classifyRedirect(uri, policy))) {
+            throw new RegistrationPolicyError('invalid_client_metadata', 'post_logout_redirect_uris not allowed by the registration policy');
+        }
+    }
+    const grants = metadata.grant_types === undefined ? ['authorization_code'] : stringList(metadata.grant_types);
+    if (!grants?.includes('authorization_code') || grants.some((g) => !ALLOWED_GRANTS.has(g))) {
+        throw new RegistrationPolicyError('invalid_client_metadata', 'only the authorization_code and refresh_token grant types are allowed');
+    }
+    const responses = metadata.response_types === undefined ? ['code'] : stringList(metadata.response_types);
+    if (responses?.length !== 1 || responses[0] !== 'code') {
+        throw new RegistrationPolicyError('invalid_client_metadata', 'only response_type=code is allowed');
+    }
+    const native = kinds.every((kind) => kind !== 'web');
+    return native && metadata.application_type === undefined
+        ? { ...metadata, application_type: 'native' }
+        : metadata;
+}
+/** Mesmo teto do `selective_body` do oidc-provider. */
+const BODY_LIMIT = 56 * 1024;
+/**
+ * Lê o corpo JSON do request. Quando o Adonis já parseou (a ponte do
+ * `OidcCallbackController` põe o objeto em `req.body`), usa-o; senão consome o
+ * stream. Devolve `undefined` quando não dá para interpretar como objeto — o
+ * provider segue e responde o erro de parse ele mesmo.
+ */
+async function readJsonBody(ctx) {
+    const req = ctx.req;
+    let raw;
+    if (req.readable && !req.readableEnded) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            size += chunk.length;
+            if (size > BODY_LIMIT)
+                return undefined;
+            chunks.push(chunk);
+        }
+        raw = Buffer.concat(chunks).toString('utf8');
+        // O stream foi consumido: o provider cai no fallback `req.body`.
+        req.body = raw;
+    }
+    else {
+        raw = req.body ?? ctx.request?.body;
+    }
+    if (typeof raw === 'string' || Buffer.isBuffer(raw)) {
+        try {
+            raw = JSON.parse(raw.toString());
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    return raw;
+}
+/**
+ * Case-folding IDÊNTICO ao do router do oidc-provider (`lib/helpers/router.js`,
+ * `fold`): o router casa rotas sem diferenciar maiúsculas. Comparar o path cru
+ * deixaria `POST /REG` chegar ao handler de registro sem passar pela política.
+ */
+function foldPath(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        if (value.charCodeAt(i) > 127) {
+            let out = '';
+            for (const char of value) {
+                const upper = char.toUpperCase();
+                out +=
+                    upper.length === 1 &&
+                        !((char.codePointAt(0) ?? 0) > 127 && (upper.codePointAt(0) ?? 0) < 128)
+                        ? upper
+                        : char;
+            }
+            return out;
+        }
+    }
+    return value.toUpperCase();
+}
+/**
+ * Qual operação de registro o request atinge, com a MESMA regra de casamento do
+ * router do provider: case-insensitive e, se o path exato não casar, uma nova
+ * tentativa sem UMA barra final (`/reg/` ≡ `/reg`). `null` = não é registro.
+ */
+export function registrationOperation(method, path, foldedBase) {
+    const folded = foldPath(path);
+    if (method === 'POST') {
+        const trimmed = folded.length > 1 && folded.endsWith('/') ? folded.slice(0, -1) : folded;
+        return folded === foldedBase || trimmed === foldedBase ? 'create' : null;
+    }
+    // `PUT <base>/:clientId` (RFC 7592). Mais largo que o router de propósito:
+    // tudo sob `<base>/` passa pela política.
+    if (method === 'PUT' && folded.startsWith(`${foldedBase}/`))
+        return 'update';
+    return null;
+}
+/**
+ * Middleware Koa (para `provider.use`) que aplica a política no registro
+ * dinâmico. `registrationPath` é o path da rota DENTRO do provider (default
+ * `/reg`; sob koa-mount o prefixo do issuer já foi removido).
+ */
+export function registrationPolicyMiddleware(options) {
+    const base = foldPath(options.registrationPath ?? '/reg');
+    return async (ctx, next) => {
+        const operation = registrationOperation(ctx.method, ctx.path, base);
+        if (!operation || !ctx.is('application/json'))
+            return next();
+        const metadata = await readJsonBody(ctx);
+        if (!metadata)
+            return next();
+        try {
+            let checked = options.policy ? checkClientRegistration(metadata, options.policy) : metadata;
+            if (options.validate) {
+                const replaced = await options.validate(checked, { operation, ctx });
+                if (replaced && typeof replaced === 'object')
+                    checked = replaced;
+            }
+            ctx.req.body = checked;
+        }
+        catch (error) {
+            if (!(error instanceof RegistrationPolicyError))
+                throw error;
+            ctx.status = 400;
+            ctx.set('cache-control', 'no-store');
+            ctx.body = { error: error.code, error_description: error.message };
+            return;
+        }
+        return next();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.68.4",
+  "version": "0.69.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",