@adonis-agora/authkit-server 0.73.0 → 0.75.0

package/README.md

@@ -11,6 +11,10 @@ wrapper around [`oidc-provider`](https://github.com/panva/node-oidc-provider).
 - **Passwordless** — magic-link email login and passkey-first login.
 - **Protocol extensions** — Device Flow (RFC 8628), DPoP (RFC 9449), PAR (RFC 9126), step-up
   auth via `acr_values`, Dynamic Client Registration (RFC 7591/7592).
+- **Native apps** — RFC 8252 native clients (`authkit:clients:create --native`: private-use
+  scheme / claimed https / loopback redirects, always public + PKCE) and the `@adonisjs/auth`
+  guards `oidcRpGuard` (session) and `oidcBearerGuard` (`Authorization: Bearer` access tokens,
+  in-process or remote resource server).
 - **Admin console** — user CRUD (+ disable), client CRUD, sessions, audit log (opt-in,
   role-gated).
 - **Account console** — self-service apps/consent, security (password/email/sessions),

package/build/commands/clients_create.d.ts

@@ -10,6 +10,7 @@ import type { CommandOptions } from '@adonisjs/core/types/ace';
  *   node ace authkit:clients:create --client-id=my-spa --redirect-uri=https://app/cb --public
  *   node ace authkit:clients:create --client-id=my-api --redirect-uri=https://api/cb --redirect-uri=https://api/cb2 --grant=client_credentials
  *   node ace authkit:clients:create --redirect-uri=https://app/cb --json
+ *   node ace authkit:clients:create --client-id=my-mobile --native --redirect-uri=com.example.app:/oauth
  */
 export default class AuthkitClientsCreate extends BaseCommand {
     static commandName: string;
@@ -21,6 +22,7 @@ export default class AuthkitClientsCreate extends BaseCommand {
     postLogoutUri?: string[];
     grant?: string[];
     public?: boolean;
+    native?: boolean;
     backchannelLogoutUri?: string;
     json?: boolean;
     run(): Promise<void>;

package/build/commands/clients_create.js

@@ -15,6 +15,7 @@ import { BaseCommand, flags } from '@adonisjs/core/ace';
  *   node ace authkit:clients:create --client-id=my-spa --redirect-uri=https://app/cb --public
  *   node ace authkit:clients:create --client-id=my-api --redirect-uri=https://api/cb --redirect-uri=https://api/cb2 --grant=client_credentials
  *   node ace authkit:clients:create --redirect-uri=https://app/cb --json
+ *   node ace authkit:clients:create --client-id=my-mobile --native --redirect-uri=com.example.app:/oauth
  */
 export default class AuthkitClientsCreate extends BaseCommand {
     static commandName = 'authkit:clients:create';
@@ -31,10 +32,15 @@ export default class AuthkitClientsCreate extends BaseCommand {
         '  --post-logout-uri   URI(s) de post-logout redirect.',
         '  --grant             Grant types. Default: authorization_code + refresh_token.',
         '',
+        'App nativo (React Native/Expo, iOS, Android, desktop — RFC 8252): use --native.',
+        'Implica client público (sem secret; PKCE já é obrigatório) e aceita redirect de',
+        'esquema privado (com.example.app:/oauth), https claimed e loopback http://127.0.0.1.',
+        '',
         'Exemplos:',
         '  node ace authkit:clients:create --client-id=my-spa --redirect-uri=https://app/cb --public',
         '  node ace authkit:clients:create --redirect-uri=https://app/cb --backchannel-logout-uri=https://app/bc',
         '  node ace authkit:clients:create --client-id=my-app --redirect-uri=https://a/cb --redirect-uri=https://b/cb --json',
+        '  node ace authkit:clients:create --client-id=my-mobile --native --redirect-uri=com.example.app:/oauth',
     ];
     static options = { startApp: true };
     async run() {
@@ -48,17 +54,31 @@ export default class AuthkitClientsCreate extends BaseCommand {
         const { AdminClientsService } = await import('../src/host/admin_clients_service.js');
         const svc = new AdminClientsService(service);
         const grantTypes = this.grant && this.grant.length > 0 ? this.grant : ['authorization_code', 'refresh_token'];
-        const tokenEndpointAuthMethod = this.public
-            ? 'none'
-            : 'client_secret_basic';
-        const created = await svc.create({
-            clientId: this.clientId,
-            redirectUris,
-            postLogoutRedirectUris: this.postLogoutUri ?? [],
-            grantTypes,
-            tokenEndpointAuthMethod,
-            backchannelLogoutUri: this.backchannelLogoutUri,
-        });
+        // App nativo é sempre público (RFC 8252 §8.5): `--native` implica `--public`.
+        const isPublic = !!this.public || !!this.native;
+        const applicationType = this.native ? 'native' : 'web';
+        const tokenEndpointAuthMethod = isPublic ? 'none' : 'client_secret_basic';
+        const { ClientMetadataError } = await import('../src/host/client_metadata.js');
+        let created;
+        try {
+            created = await svc.create({
+                clientId: this.clientId,
+                applicationType,
+                redirectUris,
+                postLogoutRedirectUris: this.postLogoutUri ?? [],
+                grantTypes,
+                tokenEndpointAuthMethod,
+                backchannelLogoutUri: this.backchannelLogoutUri,
+            });
+        }
+        catch (err) {
+            if (err instanceof ClientMetadataError) {
+                this.logger.logError(`❌ ${err.message}`);
+                this.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
         if (this.json) {
             const out = {
                 clientId: created.clientId,
@@ -66,7 +86,8 @@ export default class AuthkitClientsCreate extends BaseCommand {
                 postLogoutRedirectUris: this.postLogoutUri ?? [],
                 grantTypes,
                 tokenEndpointAuthMethod,
-                confidential: !this.public,
+                applicationType,
+                confidential: !isPublic,
             };
             if (created.clientSecret)
                 out.clientSecret = created.clientSecret;
@@ -78,7 +99,9 @@ export default class AuthkitClientsCreate extends BaseCommand {
         this.logger.success(`Client criado: ${created.clientId}`);
         this.logger.info(`  redirect_uris: ${redirectUris.join(', ')}`);
         this.logger.info(`  grant_types:   ${grantTypes.join(', ')}`);
-        this.logger.info(`  type:          ${this.public ? 'publico (sem secret)' : 'confidencial'}`);
+        this.logger.info(`  type:          ${isPublic ? 'publico (sem secret)' : 'confidencial'}`);
+        if (this.native)
+            this.logger.info('  application:   native (RFC 8252)');
         if (this.backchannelLogoutUri) {
             this.logger.info(`  backchannel:   ${this.backchannelLogoutUri}`);
         }
@@ -109,6 +132,11 @@ __decorate([
         description: 'Cria um client público (sem secret; token_endpoint_auth_method=none). Default: false (confidencial).',
     })
 ], AuthkitClientsCreate.prototype, "public", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Client de app nativo (application_type=native, RFC 8252): aceita redirect de esquema privado/loopback. Implica --public.',
+    })
+], AuthkitClientsCreate.prototype, "native", void 0);
 __decorate([
     flags.string({
         description: 'Endpoint de OIDC Back-Channel Logout do RP (POST de logout_token).',

package/build/commands/commands.json

@@ -109,6 +109,13 @@
           "type": "boolean",
           "description": "Cria um client público (sem secret; token_endpoint_auth_method=none)."
         },
+        {
+          "name": "native",
+          "flagName": "native",
+          "required": false,
+          "type": "boolean",
+          "description": "Client de app nativo (application_type=native, RFC 8252): aceita redirect de esquema privado/loopback. Implica --public."
+        },
         {
           "name": "backchannelLogoutUri",
           "flagName": "backchannel-logout-uri",

package/build/index.d.ts

@@ -16,6 +16,8 @@ export type { AdminApiConfigInput, AdminConfigInput, AuthHostRenderer, AuthMetho
 export { adapters, defineConfig, resolveAdmin, resolveAdminApi, resolveAuthMethodsConfig, resolveDynamicRegistration, resolveLogin, resolveNotifications, resolveOrganizations, resolvePasswordless, resolveRateLimit, resolveRegistration, resolveWebauthn, toSeconds, } from './src/define_config.js';
 export type { EventsConfigInput, ResolvedEventsConfig } from './src/events/dispatcher.js';
 export { buildWebhookBody, composeAuditSink, resolveEvents, signWebhookBody, } from './src/events/dispatcher.js';
+export type { AccessTokenVerifier, InProcessIssuer, IssueAccessTokenOptions, RemoteAccessTokenVerifierOptions, VerifiedAccessToken, } from './src/host/access_token_verifier.js';
+export { inProcessAccessTokenVerifier, remoteAccessTokenVerifier, } from './src/host/access_token_verifier.js';
 export type { DeletionActor, DeletionResult, } from './src/host/account_deletion_service.js';
 export { AccountDeletionService } from './src/host/account_deletion_service.js';
 export type { AccountExport } from './src/host/account_export_service.js';
@@ -59,6 +61,8 @@ export type { BotProtectionAction, BotProtectionConfigInput, BotProtectionSettin
 export { botProtectionApplies, DEFAULT_BOT_TOKEN_FIELDS, extractBotToken, guardBotProtection, resolveBotProtection, resolveEffectiveBotProtection, verifyBotProtection, } from './src/host/bot_protection.js';
 export type { BrandingConfig, ClientBrand } from './src/host/branding.js';
 export { brandFor, isFirstParty, isFirstPartyClient } from './src/host/branding.js';
+export type { ApplicationType } from './src/host/client_metadata.js';
+export { assertClientMetadata, ClientMetadataError, redirectUriProblem, } from './src/host/client_metadata.js';
 export type { PolicyRouteOption } from './src/host/config_locks.js';
 export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROUTE_OPTIONS, resetLockedSettingKeys, SettingLockedError, setLockedSettingKeys, } from './src/host/config_locks.js';
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
@@ -76,6 +80,8 @@ export type { ImpersonationStartErrorCode, ImpersonationState, StartImpersonatio
 export { ImpersonationStartError, impersonationState, refreshAccessToken, rememberAccessToken, rememberRefreshToken, startImpersonation, stopImpersonation, } from './src/host/impersonation_session.js';
 export type { KeysStatus as ServerKeysStatus } from './src/host/key_rotation_actions.js';
 export { buildKeysStatus, rotateNow } from './src/host/key_rotation_actions.js';
+export type { OidcBearerGuardEvents, OidcBearerGuardOptions, OidcBearerGuardPolicy, } from './src/host/oidc_bearer_guard.js';
+export { OidcBearerGuard, oidcBearerGuard } from './src/host/oidc_bearer_guard.js';
 export type { OidcRpGuardEvents, OidcRpGuardOptions } from './src/host/oidc_rp_guard.js';
 export { OidcRpGuard, oidcRpGuard } from './src/host/oidc_rp_guard.js';
 export { evaluateLoginOtp, generateOtpCode, OTP_LOGIN_DEFAULTS, type OtpLoginConfigInput, type OtpVerifyOutcome, type ResolvedOtpLoginConfig, resolveOtpLoginConfig, } from './src/host/otp_login.js';

package/build/index.js

@@ -10,6 +10,7 @@ export { lucidStores } from './src/accounts/lucid_stores.js';
 export { lucidAuditSink } from './src/audit/lucid_audit_sink.js';
 export { adapters, defineConfig, resolveAdmin, resolveAdminApi, resolveAuthMethodsConfig, resolveDynamicRegistration, resolveLogin, resolveNotifications, resolveOrganizations, resolvePasswordless, resolveRateLimit, resolveRegistration, resolveWebauthn, toSeconds, } from './src/define_config.js';
 export { buildWebhookBody, composeAuditSink, resolveEvents, signWebhookBody, } from './src/events/dispatcher.js';
+export { inProcessAccessTokenVerifier, remoteAccessTokenVerifier, } from './src/host/access_token_verifier.js';
 export { AccountDeletionService } from './src/host/account_deletion_service.js';
 export { AccountExportService } from './src/host/account_export_service.js';
 /**
@@ -46,6 +47,7 @@ export { computeAdminStats } from './src/host/admin_stats_service.js';
 export { authkitUserProvider } from './src/host/adonis_auth_user_provider.js';
 export { botProtectionApplies, DEFAULT_BOT_TOKEN_FIELDS, extractBotToken, guardBotProtection, resolveBotProtection, resolveEffectiveBotProtection, verifyBotProtection, } from './src/host/bot_protection.js';
 export { brandFor, isFirstParty, isFirstPartyClient } from './src/host/branding.js';
+export { assertClientMetadata, ClientMetadataError, redirectUriProblem, } from './src/host/client_metadata.js';
 export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROUTE_OPTIONS, resetLockedSettingKeys, SettingLockedError, setLockedSettingKeys, } from './src/host/config_locks.js';
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
 export { authkitCsrfExceptions } from './src/host/csrf.js';
@@ -60,6 +62,11 @@ export { buildImpersonationPanel } from './src/host/impersonation.js';
 export { ImpersonationStartError, impersonationState, refreshAccessToken, rememberAccessToken, rememberRefreshToken, startImpersonation, stopImpersonation, } from './src/host/impersonation_session.js';
 // Key rotation actions — shared between the Admin REST API controller and the SDK embedded driver.
 export { buildKeysStatus, rotateNow } from './src/host/key_rotation_actions.js';
+// @adonisjs/auth integration (opt-in) — guard de access token (Authorization:
+// Bearer) pra APIs chamadas por apps nativos (RFC 8252), SPAs e serviços. Par do
+// oidcRpGuard para clientes sem sessão web; verifica in-process (issuer embarcado)
+// ou como resource server remoto (JWKS / introspecção).
+export { OidcBearerGuard, oidcBearerGuard } from './src/host/oidc_bearer_guard.js';
 // @adonisjs/auth integration (opt-in) — guard pra Relying Parties OIDC.
 // O RP não autentica ninguém (sem senha); a identidade vem da sessão gravada
 // pelo callback OIDC. Plugado em config/auth.ts, faz ctx.auth.user funcionar

package/build/src/commands/import_clients.js

@@ -44,6 +44,7 @@ export async function importClients(clients, svc, options = {}) {
         }
         // Determina o auth method a partir do config estático.
         const authMethod = client.tokenEndpointAuthMethod ?? (client.clientSecret ? 'client_secret_basic' : 'none');
+        const applicationType = client.applicationType ?? 'web';
         try {
             // Cria via AdminClientsService, que usa o mesmo caminho do console admin / registro dinâmico.
             // Para preservar o client_secret do config estático, escrevemos diretamente via adapter —
@@ -52,6 +53,7 @@ export async function importClients(clients, svc, options = {}) {
             const preservedSecret = client.clientSecret;
             const created = await svc.createWithSecret({
                 clientId,
+                applicationType,
                 redirectUris: client.redirectUris ?? [],
                 postLogoutRedirectUris: client.postLogoutRedirectUris ?? [],
                 grantTypes: client.grants ?? ['authorization_code', 'refresh_token'],

package/build/src/define_config.d.ts

@@ -622,11 +622,19 @@ export interface AdminConfigInput {
      * não altera mais o valor.
      */
     impersonation?: boolean;
+    /**
+     * Permite impersonar uma conta que também tem um dos `roles` de admin. Com
+     * `false`, o token-exchange recusa alvo admin (`invalid_grant`): um admin não
+     * assume a identidade de outro. Default: **`true`** (back-compat; virar o
+     * default é decisão de major, mesma regra de `impersonation`).
+     */
+    impersonateAdmins?: boolean;
 }
 export interface ResolvedAdminConfig {
     enabled: boolean;
     roles: string[];
     impersonation: boolean;
+    impersonateAdmins: boolean;
 }
 export declare function resolveAdmin(input?: AdminConfigInput): ResolvedAdminConfig;
 /**

package/build/src/define_config.js

@@ -174,6 +174,7 @@ export function resolveAdmin(input) {
         // Default `true`: preserva o comportamento histórico (grant sempre
         // registrado). Ver o docblock de `AdminConfigInput.impersonation`.
         impersonation: input?.impersonation !== false,
+        impersonateAdmins: input?.impersonateAdmins !== false,
     };
 }
 /** Lê API keys de `AUTHKIT_ADMIN_API_KEY` (uma ou várias, separadas por vírgula). */

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

@@ -0,0 +1,107 @@
+/**
+ * Access token já verificado — a forma comum que o `oidcBearerGuard` consome,
+ * qualquer que seja o modo de verificação (in-process ou resource server remoto)
+ * e o formato do token (opaco ou JWT RFC 9068).
+ */
+export interface VerifiedAccessToken {
+    /** `opaque` (referência no adapter / introspecção) ou `jwt` (RFC 9068, auto-contido). */
+    format: 'opaque' | 'jwt';
+    /** `sub` — o id da conta. */
+    sub: string;
+    /** Client que recebeu o token. */
+    clientId: string | null;
+    /** Escopos concedidos. */
+    scopes: string[];
+    /** Audience(s) do token (resource indicators, RFC 8707). Vazio = sem `aud`. */
+    audience: string[];
+    /** Expiração (epoch em segundos), quando conhecida. */
+    exp: number | null;
+    /** Id do token (`jti`), quando conhecido. */
+    jti: string | null;
+    /**
+     * Quem está AGINDO quando o token é de impersonation (RFC 8693 `act.sub`, o
+     * admin que trocou o próprio token pelo do `sub`). `null` num token comum.
+     * É o que deixa o resource server tratar a request como impersonation
+     * (`impersonationState`/`realAccountId`) em vez de confundi-la com o alvo.
+     */
+    actor: string | null;
+}
+/**
+ * Estratégia de verificação de access token plugável no `oidcBearerGuard`.
+ * `verify` devolve `null` para QUALQUER token não aceitável (desconhecido,
+ * expirado, revogado, assinatura inválida, sender-constrained) — o guard não
+ * distingue os motivos na resposta (401 genérico).
+ */
+export interface AccessTokenVerifier {
+    verify(token: string): Promise<VerifiedAccessToken | null>;
+    /**
+     * Emite um access token de verdade para `accountId` — usado pelo
+     * `authenticateAsClient` do guard em testes. Só existe no modo in-process.
+     */
+    issue?(accountId: string, options?: IssueAccessTokenOptions): Promise<string>;
+}
+/** Opções de {@link AccessTokenVerifier.issue}. */
+export interface IssueAccessTokenOptions {
+    /** Client "dono" do token. Default: `'authkit-test-client'`. */
+    clientId?: string;
+    /** Escopos do token. Default: `['openid']`. */
+    scopes?: string[];
+}
+/** O mínimo do `OidcService` que a verificação in-process usa. */
+export interface InProcessIssuer {
+    readonly provider: any;
+    readonly publicJwks: {
+        keys: Record<string, any>[];
+    };
+    readonly config: {
+        issuer: string;
+    };
+}
+/**
+ * Verificação IN-PROCESS: o app hospeda o issuer (`authkit.server`).
+ *
+ *   - token opaco → `AccessToken.find` do oidc-provider (mesma rota do
+ *     {@link TokenVerifyService}). Revogação (`/revoke`, logout, revogação de
+ *     grant/sessão pelo admin) apaga o artefato, então revogado = não encontrado.
+ *   - JWT (RFC 9068, `accessTokens.format: 'jwt'`) → assinatura contra o JWKS
+ *     PÚBLICO do provider atual, `iss` e `typ: at+jwt`. JWT AT é auto-contido: o
+ *     oidc-provider não o persiste, então ele vale até o `exp` mesmo após revogar o
+ *     grant — mantenha o TTL do access token curto.
+ *
+ * `resolveIssuer` é chamado a cada verificação (e não guardado): o `OidcService`
+ * troca a instância do provider em `reloadKeys`/rotação de chaves.
+ */
+export declare function inProcessAccessTokenVerifier(resolveIssuer: () => Promise<InProcessIssuer>): AccessTokenVerifier;
+/** Opções do modo resource server REMOTO. */
+export interface RemoteAccessTokenVerifierOptions {
+    /** Issuer do authkit (o mesmo `issuer` do `config/authkit.ts` do IdP). */
+    issuer: string;
+    /**
+     * URL do JWKS. Default: o `jwks_uri` da discovery
+     * (`{issuer}/.well-known/openid-configuration`).
+     */
+    jwksUri?: string;
+    /**
+     * Introspecção (RFC 7662) para tokens OPACOS, autenticada com as credenciais de
+     * um client CONFIDENCIAL do issuer (o resource server). Sem isto, só JWT access
+     * tokens (RFC 9068) são aceitos.
+     */
+    introspection?: {
+        clientId: string;
+        clientSecret: string;
+        /** Default: o `introspection_endpoint` da discovery. */
+        endpoint?: string;
+    };
+    /** `fetch` alternativo (testes, proxy). Default: o global. */
+    fetch?: typeof fetch;
+}
+/**
+ * Verificação de RESOURCE SERVER remoto: a API NÃO hospeda o issuer.
+ *
+ *   - JWT (RFC 9068) → assinatura contra o JWKS remoto (cacheado e recarregado
+ *     pelo `jose` quando aparece um `kid` novo), `iss` e `typ: at+jwt`.
+ *   - opaco → introspecção (RFC 7662) com client credentials; exige
+ *     `active: true` e `token_type` Bearer (refresh token introspectado vem sem
+ *     `token_type` e é recusado).
+ */
+export declare function remoteAccessTokenVerifier(options: RemoteAccessTokenVerifierOptions): AccessTokenVerifier;

package/build/src/host/access_token_verifier.js

@@ -0,0 +1,248 @@
+import { createLocalJWKSet, createRemoteJWKSet, customFetch, errors as joseErrors, jwtVerify, } from 'jose';
+import { errors as providerErrors } from 'oidc-provider';
+/**
+ * Token recusado (assinatura, `iss`, `exp`, formato…) vira `null` → 401. Falha de
+ * infraestrutura (banco fora, rede, JWKS inalcançável) SOBE: responder
+ * `invalid_token` num apagão ensinaria o cliente a jogar fora um token bom.
+ */
+function rejectedJwt(error) {
+    return (error instanceof joseErrors.JOSEError &&
+        !(error instanceof joseErrors.JWKSTimeout) &&
+        !(error instanceof joseErrors.JWKSInvalid));
+}
+/** `act.sub` (RFC 8693 §4.1) de um payload/`extra`/introspecção, ou `null`. */
+function actorOf(source) {
+    const act = source?.act;
+    return typeof act?.sub === 'string' && act.sub ? act.sub : null;
+}
+/** `header.payload.signature` em base64url — o formato compacto de um JWS. */
+const JWS_COMPACT = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+function looksLikeJwt(token) {
+    return JWS_COMPACT.test(token);
+}
+function splitScope(scope) {
+    return typeof scope === 'string' ? scope.split(' ').filter(Boolean) : [];
+}
+function toAudience(aud) {
+    if (typeof aud === 'string')
+        return [aud];
+    if (Array.isArray(aud))
+        return aud.filter((a) => typeof a === 'string');
+    return [];
+}
+/**
+ * JWT access token (RFC 9068) → {@link VerifiedAccessToken}. Recusa token com
+ * `cnf` (DPoP / mTLS): ele é sender-constrained e apresentá-lo como Bearer puro,
+ * sem a prova de posse, é exatamente o que o `cnf` existe para impedir.
+ */
+function fromJwtPayload(payload) {
+    if (payload.cnf)
+        return null;
+    if (typeof payload.sub !== 'string' || !payload.sub)
+        return null;
+    const clientId = payload.client_id;
+    return {
+        format: 'jwt',
+        sub: payload.sub,
+        clientId: typeof clientId === 'string' ? clientId : null,
+        scopes: splitScope(payload.scope),
+        audience: toAudience(payload.aud),
+        exp: typeof payload.exp === 'number' ? payload.exp : null,
+        jti: typeof payload.jti === 'string' ? payload.jti : null,
+        actor: actorOf(payload),
+    };
+}
+/**
+ * Verificação IN-PROCESS: o app hospeda o issuer (`authkit.server`).
+ *
+ *   - token opaco → `AccessToken.find` do oidc-provider (mesma rota do
+ *     {@link TokenVerifyService}). Revogação (`/revoke`, logout, revogação de
+ *     grant/sessão pelo admin) apaga o artefato, então revogado = não encontrado.
+ *   - JWT (RFC 9068, `accessTokens.format: 'jwt'`) → assinatura contra o JWKS
+ *     PÚBLICO do provider atual, `iss` e `typ: at+jwt`. JWT AT é auto-contido: o
+ *     oidc-provider não o persiste, então ele vale até o `exp` mesmo após revogar o
+ *     grant — mantenha o TTL do access token curto.
+ *
+ * `resolveIssuer` é chamado a cada verificação (e não guardado): o `OidcService`
+ * troca a instância do provider em `reloadKeys`/rotação de chaves.
+ */
+export function inProcessAccessTokenVerifier(resolveIssuer) {
+    // JWKS local memoizado por identidade: o `publicJwks` só muda (novo objeto)
+    // quando o provider é reconstruído.
+    let cachedJwks;
+    let cachedKeySet;
+    const keySetFor = (jwks) => {
+        if (jwks !== cachedJwks || !cachedKeySet) {
+            cachedJwks = jwks;
+            cachedKeySet = createLocalJWKSet(jwks);
+        }
+        return cachedKeySet;
+    };
+    return {
+        async verify(token) {
+            if (!token)
+                return null;
+            const issuer = await resolveIssuer();
+            if (looksLikeJwt(token)) {
+                try {
+                    const { payload } = await jwtVerify(token, keySetFor(issuer.publicJwks), {
+                        issuer: issuer.config.issuer,
+                        typ: 'at+jwt',
+                    });
+                    return fromJwtPayload(payload);
+                }
+                catch (error) {
+                    if (rejectedJwt(error))
+                        return null;
+                    throw error;
+                }
+            }
+            let at;
+            try {
+                at = await issuer.provider?.AccessToken?.find(token);
+            }
+            catch (error) {
+                // Só erro do próprio provider (token malformado) é recusa; erro do adapter sobe.
+                if (error instanceof providerErrors.OIDCProviderError)
+                    return null;
+                throw error;
+            }
+            if (!at)
+                return null;
+            // O oidc-provider já recusa artefato expirado no `find`; isto é guarda extra.
+            if (at.isExpired === true)
+                return null;
+            if (typeof at.exp === 'number' && at.exp <= Math.floor(Date.now() / 1000))
+                return null;
+            // Sender-constrained (DPoP `jkt` / mTLS `x5t#S256`): sem a prova, não aceita.
+            if (at.jkt || at['x5t#S256'])
+                return null;
+            if (typeof at.accountId !== 'string' || !at.accountId)
+                return null;
+            return {
+                format: 'opaque',
+                sub: at.accountId,
+                clientId: typeof at.clientId === 'string' ? at.clientId : null,
+                scopes: splitScope(at.scope),
+                audience: toAudience(at.aud),
+                exp: typeof at.exp === 'number' ? at.exp : null,
+                jti: typeof at.jti === 'string' ? at.jti : null,
+                actor: actorOf(at.extra),
+            };
+        },
+        async issue(accountId, options = {}) {
+            const { provider } = await resolveIssuer();
+            const at = new provider.AccessToken({
+                accountId,
+                clientId: options.clientId ?? 'authkit-test-client',
+                scope: (options.scopes ?? ['openid']).join(' '),
+                gty: 'authorization_code',
+            });
+            return at.save();
+        },
+    };
+}
+/**
+ * Verificação de RESOURCE SERVER remoto: a API NÃO hospeda o issuer.
+ *
+ *   - JWT (RFC 9068) → assinatura contra o JWKS remoto (cacheado e recarregado
+ *     pelo `jose` quando aparece um `kid` novo), `iss` e `typ: at+jwt`.
+ *   - opaco → introspecção (RFC 7662) com client credentials; exige
+ *     `active: true` e `token_type` Bearer (refresh token introspectado vem sem
+ *     `token_type` e é recusado).
+ */
+export function remoteAccessTokenVerifier(options) {
+    const doFetch = options.fetch ?? globalThis.fetch;
+    const issuer = options.issuer.replace(/\/+$/, '');
+    let discovery;
+    const discover = () => {
+        discovery ??= (async () => {
+            const res = await doFetch(`${issuer}/.well-known/openid-configuration`);
+            if (!res.ok)
+                throw new Error(`discovery ${res.status}`);
+            return (await res.json());
+        })().catch((error) => {
+            // Falha transitória não fica memoizada: a próxima request tenta de novo.
+            discovery = undefined;
+            throw error;
+        });
+        return discovery;
+    };
+    let keySet;
+    const remoteKeySet = async () => {
+        if (keySet)
+            return keySet;
+        const jwksUri = options.jwksUri ?? (await discover()).jwks_uri;
+        if (!jwksUri)
+            throw new Error('issuer sem jwks_uri');
+        keySet = createRemoteJWKSet(new URL(jwksUri), options.fetch ? { [customFetch]: options.fetch } : undefined);
+        return keySet;
+    };
+    const introspect = async (token) => {
+        const creds = options.introspection;
+        if (!creds)
+            return null;
+        const endpoint = creds.endpoint ?? (await discover()).introspection_endpoint;
+        if (!endpoint)
+            return null;
+        // RFC 6749 §2.3.1: client_id/secret form-urlencoded antes do Basic.
+        const basic = Buffer.from(`${encodeURIComponent(creds.clientId)}:${encodeURIComponent(creds.clientSecret)}`).toString('base64');
+        const res = await doFetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+                accept: 'application/json',
+                authorization: `Basic ${basic}`,
+            },
+            body: new URLSearchParams({ token, token_type_hint: 'access_token' }).toString(),
+        });
+        // 5xx ou credencial do resource server recusada: problema de infra/config, não do token.
+        if (!res.ok)
+            throw new Error(`authkit: introspecção falhou (HTTP ${res.status})`);
+        const body = (await res.json());
+        if (body.active !== true)
+            return null;
+        if (typeof body.token_type !== 'string' || body.token_type.toLowerCase() !== 'bearer') {
+            return null;
+        }
+        if (body.cnf)
+            return null;
+        if (typeof body.sub !== 'string' || !body.sub)
+            return null;
+        if (typeof body.exp === 'number' && body.exp <= Math.floor(Date.now() / 1000))
+            return null;
+        return {
+            format: 'opaque',
+            sub: body.sub,
+            clientId: typeof body.client_id === 'string' ? body.client_id : null,
+            scopes: splitScope(body.scope),
+            audience: toAudience(body.aud),
+            exp: typeof body.exp === 'number' ? body.exp : null,
+            jti: typeof body.jti === 'string' ? body.jti : null,
+            actor: actorOf(body),
+        };
+    };
+    return {
+        async verify(token) {
+            if (!token)
+                return null;
+            if (looksLikeJwt(token)) {
+                try {
+                    const { payload } = await jwtVerify(token, await remoteKeySet(), {
+                        // Mesma forma da discovery (sem barra final), aceitando o `iss` com ou sem ela.
+                        issuer: [issuer, `${issuer}/`],
+                        typ: 'at+jwt',
+                    });
+                    return fromJwtPayload(payload);
+                }
+                catch (error) {
+                    if (rejectedJwt(error))
+                        return null;
+                    throw error;
+                }
+            }
+            // Introspecção fora do ar sobe como erro (não é "token inválido").
+            return introspect(token);
+        },
+    };
+}

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

@@ -14,6 +14,7 @@ export default class ApiClientsController {
             redirectUris: string[];
             postLogoutRedirectUris: string[];
             tokenEndpointAuthMethod: string;
+            applicationType: import("../client_metadata.js").ApplicationType;
             backchannelLogoutUri: string | null;
             backchannelLogoutSessionRequired: boolean;
         }[];
@@ -26,10 +27,11 @@ export default class ApiClientsController {
         redirectUris: string[];
         postLogoutRedirectUris: string[];
         tokenEndpointAuthMethod: string;
+        applicationType: import("../client_metadata.js").ApplicationType;
         backchannelLogoutUri: string | null;
         backchannelLogoutSessionRequired: boolean;
     }>;
-    store(ctx: HttpContext): Promise<{
+    store(ctx: HttpContext): Promise<void | {
         clientId: string;
         clientSecret: string | null;
     }>;
@@ -40,6 +42,7 @@ export default class ApiClientsController {
         redirectUris: string[];
         postLogoutRedirectUris: string[];
         tokenEndpointAuthMethod: string;
+        applicationType: import("../client_metadata.js").ApplicationType;
         backchannelLogoutUri: string | null;
         backchannelLogoutSessionRequired: boolean;
     }>;