@adonis-agora/authkit-server 0.73.0 → 0.75.0

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

@@ -1,12 +1,20 @@
 import '../augmentations.js';
 import { AdminClientsService } from '../admin_clients_service.js';
 import { clientCreateInput, clientInputValidator, clientPartialInput, } from '../admin_validators.js';
+import { ClientMetadataError } from '../client_metadata.js';
 import { apiError, clientDto, createdClientDto } from './dto.js';
 /** Resolve o serviço (== OidcService) + o AdminClientsService. */
 async function clientsService(ctx) {
     const service = await ctx.containerResolver.make('authkit.server');
     return { service, svc: new AdminClientsService(service) };
 }
+/**
+ * Metadata incoerente com o tipo de client (ex.: nativo com secret, redirect
+ * `myapp://` num client web) — 422, igual a um input que falha no Vine.
+ */
+function invalidMetadata(ctx, err) {
+    return ctx.response.unprocessableEntity(apiError('invalid_client_metadata', err.message));
+}
 /**
  * Recurso de clients OIDC da Admin REST API (R6). Reaproveita o
  * {@link AdminClientsService} (mesmo que o console B6). O secret é retornado UMA vez
@@ -31,7 +39,15 @@ export default class ApiClientsController {
     async store(ctx) {
         const { service, svc } = await clientsService(ctx);
         const input = clientCreateInput(await ctx.request.validateUsing(clientInputValidator));
-        const created = await svc.create(input);
+        let created;
+        try {
+            created = await svc.create(input);
+        }
+        catch (err) {
+            if (err instanceof ClientMetadataError)
+                return invalidMetadata(ctx, err);
+            throw err;
+        }
         await service.config.audit?.record({
             type: 'client.created',
             clientId: created.clientId,
@@ -47,7 +63,14 @@ export default class ApiClientsController {
         const existing = await svc.find(id);
         if (!existing)
             return ctx.response.notFound(apiError('not_found', 'Client não encontrado.'));
-        await svc.update(id, clientPartialInput(await ctx.request.validateUsing(clientInputValidator)));
+        try {
+            await svc.update(id, clientPartialInput(await ctx.request.validateUsing(clientInputValidator)));
+        }
+        catch (err) {
+            if (err instanceof ClientMetadataError)
+                return invalidMetadata(ctx, err);
+            throw err;
+        }
         await service.config.audit?.record({
             type: 'client.updated',
             clientId: id,

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

@@ -19,6 +19,7 @@ export declare function clientDto(client: AdminClient): {
     redirectUris: string[];
     postLogoutRedirectUris: string[];
     tokenEndpointAuthMethod: string;
+    applicationType: import("../client_metadata.ts").ApplicationType;
     backchannelLogoutUri: string | null;
     backchannelLogoutSessionRequired: boolean;
 };

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

@@ -17,6 +17,7 @@ export function clientDto(client) {
         redirectUris: client.redirectUris,
         postLogoutRedirectUris: client.postLogoutRedirectUris,
         tokenEndpointAuthMethod: client.tokenEndpointAuthMethod,
+        applicationType: client.applicationType,
         backchannelLogoutUri: client.backchannelLogoutUri ?? null,
         backchannelLogoutSessionRequired: client.backchannelLogoutSessionRequired ?? false,
     };

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

@@ -1,4 +1,5 @@
 import type { OidcService } from '../provider/oidc_service.js';
+import { type ApplicationType } from './client_metadata.js';
 /** Métodos de autenticação no token endpoint suportados pelo formulário admin. */
 export type TokenEndpointAuthMethod = 'client_secret_basic' | 'client_secret_post' | 'none';
 /** Entrada normalizada de um client gerenciável (vinda do formulário admin). */
@@ -8,6 +9,12 @@ export interface ClientInput {
     postLogoutRedirectUris: string[];
     grantTypes: string[];
     tokenEndpointAuthMethod: TokenEndpointAuthMethod;
+    /**
+     * `application_type` do client. Default `'web'`. `'native'` (RFC 8252) aceita
+     * redirect de esquema privado / https claimed / loopback e exige client público
+     * (`tokenEndpointAuthMethod: 'none'`). Ver `client_metadata.ts`.
+     */
+    applicationType?: ApplicationType;
     /**
      * 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).
@@ -27,6 +34,8 @@ export interface AdminClient {
     redirectUris: string[];
     postLogoutRedirectUris: string[];
     tokenEndpointAuthMethod: string;
+    /** `application_type` (payload sem a chave = `'web'`, o default do oidc-provider). */
+    applicationType: ApplicationType;
     /** Endpoint de OIDC Back-Channel Logout (opcional). */
     backchannelLogoutUri?: string;
     /** Exige sid no logout_token (opcional). */

package/build/src/host/admin_clients_service.js

@@ -1,4 +1,5 @@
 import { randomBytes } from 'node:crypto';
+import { assertClientMetadata } from './client_metadata.js';
 /** Métodos públicos (sem segredo) — espelham os "non-secret" do oidc-provider. */
 const PUBLIC_AUTH_METHODS = new Set(['none']);
 /** Gera um identificador opaco no estilo do oidc-provider (~43 chars base64url). */
@@ -96,6 +97,7 @@ export class AdminClientsService {
             tokenEndpointAuthMethod: input.tokenEndpointAuthMethod ??
                 existing.token_endpoint_auth_method ??
                 'client_secret_basic',
+            applicationType: input.applicationType ?? existing.application_type ?? 'web',
             backchannelLogoutUri: input.backchannelLogoutUri ?? existing.backchannel_logout_uri,
             backchannelLogoutSessionRequired: input.backchannelLogoutSessionRequired ??
                 existing.backchannel_logout_session_required,
@@ -131,6 +133,19 @@ export class AdminClientsService {
         await this.#adapter.destroy(clientId);
         await this.oidc.evictDynamicClientCache();
     }
+    /**
+     * Valida o input contra as regras do tipo de aplicação ANTES de gravar (ver
+     * `client_metadata.ts`). Lança `ClientMetadataError`.
+     */
+    #assertValid(input) {
+        assertClientMetadata({
+            applicationType: input.applicationType ?? 'web',
+            tokenEndpointAuthMethod: input.tokenEndpointAuthMethod,
+            grantTypes: input.grantTypes,
+            redirectUris: input.redirectUris,
+            postLogoutRedirectUris: input.postLogoutRedirectUris,
+        });
+    }
     /**
      * Monta o payload na forma snake_case que o oidc-provider espera/persiste —
      * verificada contra o que o registro dinâmico (RFC 7591) grava. As chaves de
@@ -138,6 +153,7 @@ export class AdminClientsService {
      * preenchidas pelo Schema do provider ao construir o Client em `find`.
      */
     #buildPayload(clientId, input, clientSecret) {
+        this.#assertValid(input);
         const grantTypes = input.grantTypes.length
             ? input.grantTypes
             : ['authorization_code', 'refresh_token'];
@@ -153,6 +169,10 @@ export class AdminClientsService {
         };
         if (clientSecret)
             payload.client_secret = clientSecret;
+        // Só grava a chave quando nativo: um client web continua com o payload de
+        // sempre (sem `application_type` o oidc-provider assume `web`).
+        if (input.applicationType === 'native')
+            payload.application_type = 'native';
         if (input.backchannelLogoutUri) {
             payload.backchannel_logout_uri = input.backchannelLogoutUri;
             if (input.backchannelLogoutSessionRequired !== undefined) {
@@ -172,6 +192,7 @@ export class AdminClientsService {
             redirectUris: p.redirect_uris ?? [],
             postLogoutRedirectUris: p.post_logout_redirect_uris ?? [],
             tokenEndpointAuthMethod: authMethod,
+            applicationType: p.application_type === 'native' ? 'native' : 'web',
         };
         if (p.backchannel_logout_uri) {
             result.backchannelLogoutUri = p.backchannel_logout_uri;

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

@@ -19,13 +19,14 @@ export default class ConsoleClientsController {
             redirectUris: string[];
             postLogoutRedirectUris: string[];
             tokenEndpointAuthMethod: string;
+            applicationType: import("../client_metadata.js").ApplicationType;
             backchannelLogoutUri: string | null;
             backchannelLogoutSessionRequired: boolean;
         }[];
         canList: boolean;
     }>;
     /** POST {prefix}/api/clients */
-    store(ctx: HttpContext): Promise<{
+    store(ctx: HttpContext): Promise<void | {
         clientId: string;
         clientSecret: string | null;
     }>;
@@ -37,6 +38,7 @@ export default class ConsoleClientsController {
         redirectUris: string[];
         postLogoutRedirectUris: string[];
         tokenEndpointAuthMethod: string;
+        applicationType: import("../client_metadata.js").ApplicationType;
         backchannelLogoutUri: string | null;
         backchannelLogoutSessionRequired: boolean;
     }>;

package/build/src/host/admin_console/console_clients_controller.js

@@ -2,6 +2,14 @@ import '../augmentations.js';
 import { apiError, clientDto, createdClientDto } from '../admin_api/dto.js';
 import { AdminClientsService } from '../admin_clients_service.js';
 import { clientCreateInput, clientInputValidator, clientPartialInput, } from '../admin_validators.js';
+import { ClientMetadataError } from '../client_metadata.js';
+/**
+ * Metadata incoerente com o tipo de client (ex.: nativo com secret, redirect
+ * `myapp://` num client web) — 422, igual a um input que falha no Vine.
+ */
+function invalidMetadata(ctx, err) {
+    return ctx.response.unprocessableEntity(apiError('invalid_client_metadata', err.message));
+}
 /**
  * Endpoints JSON de clients OIDC do console admin React.
  *
@@ -28,7 +36,15 @@ export default class ConsoleClientsController {
         const cfg = service.config;
         const svc = new AdminClientsService(service);
         const input = clientCreateInput(await ctx.request.validateUsing(clientInputValidator));
-        const created = await svc.create(input);
+        let created;
+        try {
+            created = await svc.create(input);
+        }
+        catch (err) {
+            if (err instanceof ClientMetadataError)
+                return invalidMetadata(ctx, err);
+            throw err;
+        }
         await cfg.audit?.record({
             type: 'client.created',
             clientId: created.clientId,
@@ -47,7 +63,14 @@ export default class ConsoleClientsController {
         const existing = await svc.find(id);
         if (!existing)
             return ctx.response.notFound(apiError('not_found', 'Client não encontrado.'));
-        await svc.update(id, clientPartialInput(await ctx.request.validateUsing(clientInputValidator)));
+        try {
+            await svc.update(id, clientPartialInput(await ctx.request.validateUsing(clientInputValidator)));
+        }
+        catch (err) {
+            if (err instanceof ClientMetadataError)
+                return invalidMetadata(ctx, err);
+            throw err;
+        }
         await cfg.audit?.record({
             type: 'client.updated',
             clientId: id,

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

@@ -1,4 +1,5 @@
 import type { ClientInput, TokenEndpointAuthMethod } from './admin_clients_service.js';
+import { type ApplicationType } from './client_metadata.js';
 /**
  * Input de client OIDC — serve create E update (PATCH). Tudo opcional: no create
  * o controller aplica defaults (ver {@link clientCreateInput}); no update os campos
@@ -8,6 +9,7 @@ import type { ClientInput, TokenEndpointAuthMethod } from './admin_clients_servi
  */
 export declare const clientInputValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
     clientId: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineString>;
+    applicationType: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineEnum<readonly ["web", "native"]>>;
     redirectUris: import("@vinejs/vine").OptionalModifier<import("@vinejs/vine").VineArray<import("@vinejs/vine").VineString>>;
     postLogoutRedirectUris: import("@vinejs/vine").OptionalModifier<import("@vinejs/vine").VineArray<import("@vinejs/vine").VineString>>;
     grantTypes: import("@vinejs/vine").OptionalModifier<import("@vinejs/vine").VineArray<import("@vinejs/vine").VineEnum<readonly ["authorization_code", "refresh_token", "client_credentials", "urn:ietf:params:oauth:grant-type:token-exchange"]>>>;
@@ -16,6 +18,7 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     backchannelLogoutUri: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineString>;
     backchannelLogoutSessionRequired: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineBoolean>;
 }, {
+    applicationType?: "native" | "web" | null | undefined;
     backchannelLogoutSessionRequired?: string | number | boolean | null | undefined;
     backchannelLogoutUri?: string | null | undefined;
     clientId?: string | null | undefined;
@@ -25,6 +28,7 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     redirectUris?: string[] | null | undefined;
     tokenEndpointAuthMethod?: "client_secret_basic" | "client_secret_post" | "none" | null | undefined;
 }, {
+    applicationType?: "native" | "web" | undefined;
     backchannelLogoutSessionRequired?: boolean | undefined;
     backchannelLogoutUri?: string | undefined;
     clientId?: string | undefined;
@@ -34,6 +38,7 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     redirectUris?: string[] | undefined;
     tokenEndpointAuthMethod?: "client_secret_basic" | "client_secret_post" | "none" | undefined;
 }, {
+    applicationType?: "native" | "web" | undefined;
     backchannelLogoutSessionRequired?: boolean | undefined;
     backchannelLogoutUri?: string | undefined;
     clientId?: string | undefined;
@@ -46,6 +51,7 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
 /** Forma validada de um client (saída do {@link clientInputValidator}). */
 export type ClientInputFields = {
     clientId?: string;
+    applicationType?: ApplicationType;
     redirectUris?: string[];
     postLogoutRedirectUris?: string[];
     grantTypes?: string[];
@@ -54,7 +60,11 @@ export type ClientInputFields = {
     backchannelLogoutUri?: string;
     backchannelLogoutSessionRequired?: boolean;
 };
-/** Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults. */
+/**
+ * Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults.
+ * Client nativo sem `tokenEndpointAuthMethod` explícito vira público (`none`); um
+ * nativo confidencial explícito é recusado pelo service (422).
+ */
 export declare function clientCreateInput(v: ClientInputFields): ClientInput;
 /**
  * Mapeia o input validado para um {@link ClientInput} PARCIAL (PATCH): só inclui

package/build/src/host/admin_validators.js

@@ -1,4 +1,5 @@
 import vine from '@vinejs/vine';
+import { APPLICATION_TYPES, redirectUriProblem } from './client_metadata.js';
 import { normalizeEmailIdentifier } from './email_identifier.js';
 /**
  * Validators VineJS dos recursos administrativos (Admin REST API + console admin).
@@ -42,8 +43,25 @@ const authMethod = vine.enum(['client_secret_basic', 'client_secret_post', 'none
  * (`require_tld:false`) p/ não rejeitar `localhost` ou hostnames internos legítimos.
  */
 const URL_OPTS = { require_protocol: true, require_tld: false, protocols: ['http', 'https'] };
-/** Array de URIs ABSOLUTAS http/https. Rejeita strings que não são URL válida. */
-const urlArray = vine.array(vine.string().trim().url(URL_OPTS));
+/**
+ * Regra de redirect URI ciente do `applicationType` do MESMO payload (RFC 8252):
+ * client web continua restrito a http/https (L10); client nativo aceita esquema
+ * privado (`com.example.app:/cb`), https claimed e loopback http. Sem o tipo no
+ * payload (PATCH parcial) só as regras universais valem aqui — URI absoluta, sem
+ * fragmento, sem `javascript:`/`data:`/… — e o `AdminClientsService` confere o
+ * resto contra o tipo EFETIVO do client (ver `client_metadata.ts`).
+ */
+const redirectUriRule = vine.createRule((value, _options, field) => {
+    if (typeof value !== 'string')
+        return;
+    const declared = field.data?.applicationType;
+    const type = declared === 'web' || declared === 'native' ? declared : undefined;
+    const problem = redirectUriProblem(value, type);
+    if (problem)
+        field.report(`The {{ field }} field ${problem}`, 'redirectUri', field);
+});
+/** Array de redirect URIs (ver {@link redirectUriRule}). Rejeita strings que não são URI válida. */
+const redirectUriArray = vine.array(vine.string().trim().use(redirectUriRule()));
 /**
  * Allowlist de grant_types aceitos no registro/edição de client (M10). Bloqueia
  * `implicit` (tokens no fragment da URL — sem PKCE/refresh) e qualquer valor fora
@@ -70,10 +88,12 @@ const grantTypeArray = vine.array(vine.enum(ALLOWED_GRANT_TYPES));
  */
 export const clientInputValidator = vine.compile(vine.object({
     clientId: vine.string().trim().optional(),
-    // redirect/postLogout: URIs ABSOLUTAS (L10). `vine.string().url()` rejeita
-    // valores que não são URL (ex.: 'javascript:...', paths relativos).
-    redirectUris: urlArray.optional(),
-    postLogoutRedirectUris: urlArray.optional(),
+    // `web` (default) ou `native` (RFC 8252 — app mobile/desktop, sempre público).
+    applicationType: vine.enum(APPLICATION_TYPES).optional(),
+    // redirect/postLogout: URIs ABSOLUTAS (L10), http/https para client web;
+    // esquema privado/loopback só para `native` (ver `redirectUriRule`).
+    redirectUris: redirectUriArray.optional(),
+    postLogoutRedirectUris: redirectUriArray.optional(),
     // grant_types restrito à allowlist; `implicit` e desconhecidos viram 422 (M10).
     grantTypes: grantTypeArray.optional(),
     grants: grantTypeArray.optional(),
@@ -82,14 +102,20 @@ export const clientInputValidator = vine.compile(vine.object({
     backchannelLogoutUri: vine.string().trim().url(URL_OPTS).optional(),
     backchannelLogoutSessionRequired: vine.boolean().optional(),
 }));
-/** Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults. */
+/**
+ * Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults.
+ * Client nativo sem `tokenEndpointAuthMethod` explícito vira público (`none`); um
+ * nativo confidencial explícito é recusado pelo service (422).
+ */
 export function clientCreateInput(v) {
+    const applicationType = v.applicationType ?? 'web';
     return {
         clientId: v.clientId?.trim() || undefined,
+        applicationType,
         redirectUris: v.redirectUris ?? [],
         postLogoutRedirectUris: v.postLogoutRedirectUris ?? [],
         grantTypes: v.grantTypes ?? v.grants ?? [],
-        tokenEndpointAuthMethod: v.tokenEndpointAuthMethod ?? 'client_secret_basic',
+        tokenEndpointAuthMethod: v.tokenEndpointAuthMethod ?? (applicationType === 'native' ? 'none' : 'client_secret_basic'),
         backchannelLogoutUri: v.backchannelLogoutUri || undefined,
         backchannelLogoutSessionRequired: v.backchannelLogoutSessionRequired,
     };
@@ -100,6 +126,8 @@ export function clientCreateInput(v) {
  */
 export function clientPartialInput(v) {
     const out = {};
+    if (v.applicationType !== undefined)
+        out.applicationType = v.applicationType;
     if (v.redirectUris !== undefined)
         out.redirectUris = v.redirectUris;
     if (v.postLogoutRedirectUris !== undefined)

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

@@ -0,0 +1,26 @@
+/** Registra a conta autenticada via bearer nesta request. */
+export declare function setBearerAccountId(ctx: object, accountId: string): void;
+/** Esquece a conta bearer desta request (falha de autenticação). */
+export declare function clearBearerAccountId(ctx: object): void;
+/**
+ * Id da conta autenticada via bearer nesta request, ou `null` quando nenhum
+ * `oidcBearerGuard` autenticou (ainda) a request.
+ */
+export declare function bearerAccountId(ctx: object): string | null;
+/**
+ * Impersonation carregada pelo access token bearer desta request: o ator
+ * (`act.sub`, o admin) e a expiração do token. Gravada pelo `oidcBearerGuard`
+ * só quando o token é de impersonation; lida por `impersonationState` e
+ * `realAccountId` quando não há sessão.
+ */
+export interface BearerImpersonation {
+    actorId: string;
+    /** Epoch em segundos do `exp` do token, quando conhecido. */
+    exp: number | null;
+    /** `jti` do token trocado, quando conhecido (correlaciona com a auditoria). */
+    jti: string | null;
+}
+/** Registra que o token bearer desta request é de impersonation. */
+export declare function setBearerImpersonation(ctx: object, value: BearerImpersonation): void;
+/** Impersonation do token bearer desta request, ou `null`. */
+export declare function bearerImpersonation(ctx: object): BearerImpersonation | null;

package/build/src/host/bearer_account.js

@@ -0,0 +1,38 @@
+/**
+ * Conta autenticada por `Authorization: Bearer` NESTA request — gravada pelo
+ * `oidcBearerGuard` quando ele autentica e lida pelo `getAccountId` como
+ * fallback da sessão.
+ *
+ * Um `WeakMap` keyed pelo próprio `HttpContext` (e não uma prop em `ctx`): nada
+ * de augmentation de `HttpContext` vazando pelo barrel (ver o porquê em
+ * `account_session_key.ts`), e o valor morre junto com a request.
+ *
+ * Mantenha este arquivo sem imports: `console_session.ts` (reexportado pelo
+ * barrel) depende dele.
+ */
+const bearerAccounts = new WeakMap();
+const bearerImpersonations = new WeakMap();
+/** Registra a conta autenticada via bearer nesta request. */
+export function setBearerAccountId(ctx, accountId) {
+    bearerAccounts.set(ctx, accountId);
+}
+/** Esquece a conta bearer desta request (falha de autenticação). */
+export function clearBearerAccountId(ctx) {
+    bearerAccounts.delete(ctx);
+    bearerImpersonations.delete(ctx);
+}
+/**
+ * Id da conta autenticada via bearer nesta request, ou `null` quando nenhum
+ * `oidcBearerGuard` autenticou (ainda) a request.
+ */
+export function bearerAccountId(ctx) {
+    return bearerAccounts.get(ctx) ?? null;
+}
+/** Registra que o token bearer desta request é de impersonation. */
+export function setBearerImpersonation(ctx, value) {
+    bearerImpersonations.set(ctx, value);
+}
+/** Impersonation do token bearer desta request, ou `null`. */
+export function bearerImpersonation(ctx) {
+    return bearerImpersonations.get(ctx) ?? null;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Regras de metadata de client que dependem do TIPO de aplicação (OIDC
+ * Registration §2, `application_type`) — compartilhadas pelo
+ * {@link AdminClientsService} (console admin, Admin REST API, CLI, import) e pelo
+ * validator Vine de `admin_validators.ts`.
+ *
+ * Espelham as regras que o próprio oidc-provider aplica ao montar o `Client`
+ * (`helpers/client_schema.js#redirectUris`). Checamos ANTES de persistir porque o
+ * provider só valida no `Client.find` — um client inválido gravado no adapter
+ * vira "client não encontrado" em runtime, sem mensagem útil para quem o criou.
+ *
+ * `native` segue a RFC 8252 (OAuth 2.0 for Native Apps):
+ *   - esquema privado (`com.example.app:/callback`, `myapp://auth`) — §7.1;
+ *   - https "claimed" (universal links / app links), nunca em loopback — §7.2;
+ *   - loopback `http://127.0.0.1:<qualquer porta>/…` (e `localhost`/`[::1]`) — §7.3.
+ *     O provider ignora a porta do loopback na comparação do redirect (§7.3), então
+ *     basta registrar `http://127.0.0.1/callback`.
+ *   - client PÚBLICO: um segredo embarcado num app instalado não é segredo (§8.5).
+ *     PKCE (S256) já é obrigatório para todo client neste issuer.
+ */
+/** Tipo de aplicação do client. `web` é o default histórico. */
+export type ApplicationType = 'web' | 'native';
+export declare const APPLICATION_TYPES: readonly ['web', 'native'];
+/**
+ * Metadata inválida para o tipo de client (ex.: client nativo com secret, redirect
+ * `myapp://` num client web). Os controllers traduzem em 422.
+ */
+export declare class ClientMetadataError extends Error {
+    constructor(message: string);
+}
+/**
+ * Problema de UMA redirect URI para o tipo de client, ou `null` quando ok.
+ *
+ * `applicationType` ausente = "ainda não sei" (PATCH que não mandou o tipo): só as
+ * regras universais (URI absoluta, sem fragmento, esquema não proibido). A regra
+ * por tipo roda depois, no service, com o tipo efetivo do client.
+ */
+export declare function redirectUriProblem(uri: string, applicationType?: ApplicationType): string | null;
+/** Entrada mínima para {@link assertClientMetadata}. */
+export interface ClientMetadataInput {
+    applicationType: ApplicationType;
+    tokenEndpointAuthMethod: string;
+    grantTypes: string[];
+    redirectUris: string[];
+    postLogoutRedirectUris: string[];
+}
+/**
+ * Valida a combinação tipo × autenticação × grants × redirects. Lança
+ * {@link ClientMetadataError} na primeira violação.
+ */
+export declare function assertClientMetadata(input: ClientMetadataInput): void;

package/build/src/host/client_metadata.js

@@ -0,0 +1,98 @@
+/**
+ * Regras de metadata de client que dependem do TIPO de aplicação (OIDC
+ * Registration §2, `application_type`) — compartilhadas pelo
+ * {@link AdminClientsService} (console admin, Admin REST API, CLI, import) e pelo
+ * validator Vine de `admin_validators.ts`.
+ *
+ * Espelham as regras que o próprio oidc-provider aplica ao montar o `Client`
+ * (`helpers/client_schema.js#redirectUris`). Checamos ANTES de persistir porque o
+ * provider só valida no `Client.find` — um client inválido gravado no adapter
+ * vira "client não encontrado" em runtime, sem mensagem útil para quem o criou.
+ *
+ * `native` segue a RFC 8252 (OAuth 2.0 for Native Apps):
+ *   - esquema privado (`com.example.app:/callback`, `myapp://auth`) — §7.1;
+ *   - https "claimed" (universal links / app links), nunca em loopback — §7.2;
+ *   - loopback `http://127.0.0.1:<qualquer porta>/…` (e `localhost`/`[::1]`) — §7.3.
+ *     O provider ignora a porta do loopback na comparação do redirect (§7.3), então
+ *     basta registrar `http://127.0.0.1/callback`.
+ *   - client PÚBLICO: um segredo embarcado num app instalado não é segredo (§8.5).
+ *     PKCE (S256) já é obrigatório para todo client neste issuer.
+ */
+export const APPLICATION_TYPES = ['web', 'native'];
+/** Hosts loopback reconhecidos (mesma lista do oidc-provider). */
+const LOOPBACKS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Esquemas NUNCA aceitos como redirect, qualquer que seja o tipo de client. */
+const FORBIDDEN_SCHEMES = new Set([
+    'javascript:',
+    'vbscript:',
+    'data:',
+    'blob:',
+    'file:',
+    'about:',
+]);
+/**
+ * Metadata inválida para o tipo de client (ex.: client nativo com secret, redirect
+ * `myapp://` num client web). Os controllers traduzem em 422.
+ */
+export class ClientMetadataError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ClientMetadataError';
+    }
+}
+/**
+ * Problema de UMA redirect URI para o tipo de client, ou `null` quando ok.
+ *
+ * `applicationType` ausente = "ainda não sei" (PATCH que não mandou o tipo): só as
+ * regras universais (URI absoluta, sem fragmento, esquema não proibido). A regra
+ * por tipo roda depois, no service, com o tipo efetivo do client.
+ */
+export function redirectUriProblem(uri, applicationType) {
+    const parsed = URL.parse(uri);
+    if (!parsed)
+        return 'deve ser uma URI absoluta';
+    if (uri.includes('#'))
+        return 'não pode conter fragmento (#)';
+    const { protocol, hostname } = parsed;
+    if (FORBIDDEN_SCHEMES.has(protocol))
+        return `não pode usar o esquema ${protocol.slice(0, -1)}`;
+    if (applicationType === 'web') {
+        if (protocol !== 'http:' && protocol !== 'https:') {
+            return 'client web só aceita URIs http/https (use applicationType "native" para apps mobile)';
+        }
+    }
+    else if (applicationType === 'native') {
+        if (protocol === 'http:' && !LOOPBACKS.has(hostname)) {
+            return 'client nativo com http só aceita loopback (127.0.0.1, [::1] ou localhost)';
+        }
+        if (protocol === 'https:' && LOOPBACKS.has(hostname)) {
+            return 'client nativo com https "claimed" não pode usar host loopback';
+        }
+    }
+    return null;
+}
+/**
+ * Valida a combinação tipo × autenticação × grants × redirects. Lança
+ * {@link ClientMetadataError} na primeira violação.
+ */
+export function assertClientMetadata(input) {
+    const type = input.applicationType;
+    if (type === 'native') {
+        if (input.tokenEndpointAuthMethod !== 'none') {
+            throw new ClientMetadataError('client nativo precisa ser público (tokenEndpointAuthMethod "none", sem secret) — RFC 8252 §8.5');
+        }
+        if (input.grantTypes.includes('client_credentials')) {
+            throw new ClientMetadataError('client nativo não pode usar client_credentials (não há secret para autenticar)');
+        }
+    }
+    for (const [label, uris] of [
+        ['redirectUris', input.redirectUris],
+        ['postLogoutRedirectUris', input.postLogoutRedirectUris],
+    ]) {
+        for (const uri of uris) {
+            const problem = redirectUriProblem(uri, type);
+            if (problem)
+                throw new ClientMetadataError(`${label}: "${uri}" ${problem}`);
+        }
+    }
+}

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

@@ -9,8 +9,18 @@ import type { HttpContext } from '@adonisjs/core/http';
  * sessão mudar.
  */
 /**
- * Retorna o id da conta que o request está representando no console (ou `null`
- * quando não há sessão).
+ * Retorna o id da conta que o request está representando (ou `null` quando não
+ * há identidade).
+ *
+ * Fonte, nesta ordem:
+ *   1. a sessão do console (`ACCOUNT_SESSION_KEY`) — o comportamento de sempre;
+ *   2. SEM sessão logada: a conta que um `oidcBearerGuard` autenticou NESTA
+ *      request via `Authorization: Bearer` (app nativo, SPA, serviço).
+ *
+ * O fallback (2) só existe depois que o guard bearer RODOU na request (ex.:
+ * `middleware.auth({ guards: ['web', 'api'] })` ou `auth.authenticateUsing`);
+ * um app que não usa o guard bearer continua exatamente como antes. A sessão
+ * sempre ganha: request com cookie de sessão E bearer responde pela sessão.
  *
  * ATENÇÃO: com impersonation ativa isto é a conta PERSONIFICADA, não o admin
  * que a personificou. É o comportamento certo para "como qual conta este
@@ -50,7 +60,8 @@ export declare function getAccountId(ctx: HttpContext): string | null;
  */
 export declare function realAccountId(ctx: HttpContext): string | null;
 /**
- * `true` quando o request carrega uma sessão de conta do console.
+ * `true` quando o request carrega uma sessão de conta do console. Só a SESSÃO:
+ * uma identidade bearer (`oidcBearerGuard`) não conta — use `getAccountId`.
  */
 export declare function hasAccountSession(ctx: HttpContext): boolean;
 /**