@adonis-agora/authkit-server 0.74.0 → 0.76.0

package/build/src/host/client_names.js

@@ -0,0 +1,12 @@
+/**
+ * Nome de exibição de cada client: o `client_name` que ele registrou (um cliente MCP registra o
+ * seu, ex.: "Claude Code"), senão o próprio `client_id`. Client que sumiu do adapter → o id.
+ */
+export async function clientDisplayNames(service, clientIds) {
+    const names = new Map();
+    await Promise.all([...new Set(clientIds)].map(async (clientId) => {
+        const client = await service.provider.Client.find(clientId).catch(() => null);
+        names.set(clientId, client?.clientName || clientId);
+    }));
+    return names;
+}

package/build/src/host/console_session.js

@@ -65,11 +65,9 @@ export function getAccountId(ctx) {
  * if (!id || !(await authz.hasRole(id, 'admin'))) throw new Error('forbidden')
  */
 export function realAccountId(ctx) {
-    // Sem sessão não há impersonation: mesma tolerância do `getAccountId` (que usa
-    // `ctx.session?.`), pois `impersonationState` assume uma sessão presente. Resta
-    // a identidade bearer (se o `oidcBearerGuard` autenticou a request).
-    if (!ctx.session)
-        return bearerAccountId(ctx);
+    // `impersonationState` cobre as duas fontes: a sessão do console e o access
+    // token bearer trocado (`act`, ex.: app nativo) — nos dois, o humano real é o
+    // impersonator. Sem impersonation, a conta da sessão ou do bearer.
     return impersonationState(ctx).impersonatorId ?? getAccountId(ctx);
 }
 /**

package/build/src/host/controllers/account_apps_controller.d.ts

@@ -12,4 +12,6 @@ export default class AccountAppsController {
     index(ctx: HttpContext): Promise<any>;
     /** POST /account/apps/:clientId/revoke — revoga o acesso de um client. */
     revoke(ctx: HttpContext): Promise<void>;
+    /** POST /account/apps/agents/:grantId/revoke — revoga a delegação de um personal agent. */
+    revokeAgent(ctx: HttpContext): Promise<void>;
 }

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

@@ -1,7 +1,10 @@
 import '../augmentations.js';
+import { displayNameFor } from '../../agents/agent_identity.js';
+import { personalAgentsFor } from '../../agents/runtime.js';
 import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { AdminSessionsService } from '../admin_sessions_service.js';
+import { clientDisplayNames } from '../client_names.js';
 /**
  * Self-service de consentimento ("apps com acesso") no console de conta. Lista os
  * Grants da própria conta agrupados por client (resolvendo o nome do client da
@@ -19,13 +22,26 @@ export default class AccountAppsController {
         const sessions = new AdminSessionsService(service);
         const supported = sessions.canList;
         const grantList = supported ? await sessions.listGrants(accountId) : [];
-        // Resolve o nome amigável do client: clientId é o fallback (config estática não
-        // carrega um display name).
-        const nameOf = (clientId) => clientId ?? '';
+        // O nome que o client registrou; sem ele, o clientId.
+        const names = await clientDisplayNames(service, grantList.map((g) => g.clientId).filter((id) => !!id));
+        const nameOf = (clientId) => clientId ? (names.get(clientId) ?? clientId) : '';
         const revoked = ctx.session.flashMessages.get('appRevoked');
+        // Personal agents com delegação ativa (só quando a feature está ligada).
+        const agentsRuntime = await personalAgentsFor(ctx);
+        const agents = agentsRuntime?.delegation
+            ? await Promise.all((await agentsRuntime.delegation.listGrants(accountId)).map(async (g) => ({
+                id: g.id,
+                name: displayNameFor((await agentsRuntime.config.resolveAgent(g.clientId)) ?? {
+                    issuer: g.clientId,
+                    jwksUri: '',
+                }),
+                scopes: g.scopes,
+            })))
+            : null;
         return render(ctx, 'account/apps', {
             csrfToken: ctx.request.csrfToken,
             supported,
+            agents,
             revoked: revoked ?? null,
             apps: grantList
                 .filter((g) => !!g.clientId)
@@ -59,4 +75,24 @@ export default class AccountAppsController {
         ctx.session.flash('appRevoked', cfg.messages['account.apps.revoked'] ?? 'account.apps.revoked');
         return ctx.response.redirect(accountPath('apps'));
     }
+    /** POST /account/apps/agents/:grantId/revoke — revoga a delegação de um personal agent. */
+    async revokeAgent(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const grantId = ctx.request.param('grantId');
+        if (await runtime.delegation.revokeGrant(accountId, grantId)) {
+            await cfg.audit?.record({
+                type: 'agent.grant_revoked',
+                accountId,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { grantId },
+            });
+        }
+        ctx.session.flash('appRevoked', cfg.messages['account.apps.revoked'] ?? 'account.apps.revoked');
+        return ctx.response.redirect(accountPath('apps'));
+    }
 }

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

@@ -11,6 +11,7 @@ import { revokeOrgAccess } from '../org_access_revocation.js';
 // ponto de verdade único, para as duas superfícies nunca divergirem.
 import { effectiveOrgPolicy, orgPolicyDefaults } from '../org_policy.js';
 import { authkitOrigin } from '../origin.js';
+import { redirectExact } from '../redirect_exact.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy } from '../runtime_toggles.js';
 /**
@@ -257,7 +258,7 @@ export default class AccountOrgsController {
             const loginUrl = getAccountLoginUrl();
             const returnTo = encodeURIComponent(`${accountPath('orgs')}/invitations/${params.token}/accept`);
             const sep = loginUrl.includes('?') ? '&' : '?';
-            return response.redirect(`${loginUrl}${sep}returnTo=${returnTo}`);
+            return redirectExact(response, `${loginUrl}${sep}returnTo=${returnTo}`);
         }
         const tokenHash = createHash('sha256').update(params.token).digest('hex');
         const invitation = await store.findInvitationByTokenHash(tokenHash);

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

@@ -8,6 +8,7 @@ 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 { redirectExact } from '../redirect_exact.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
 import { markSudo } from '../sudo_mode.js';
 /**
@@ -110,7 +111,7 @@ export default class AccountSessionController {
         await syncAdonisAuthLogin(ctx, cfg, acc);
         await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email: acc.email, ip });
         // Redireciona pro destino original (validado), ou cai no accountHome configurado.
-        return ctx.response.redirect(returnTo ?? accountHome(cfg));
+        return redirectExact(ctx.response, returnTo ?? accountHome(cfg));
     }
     async logout(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');

package/build/src/host/controllers/agent_consent_controller.d.ts

@@ -0,0 +1,17 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Tela de consentimento da delegação (PACT §5.3) — o `verification_uri` do
+ * device flow. Montada atrás do `accountGuard`: sem sessão o usuário passa pelo
+ * login DESTE app e volta com o `user_code` no `return_to`. O agente nunca vê
+ * esse login.
+ *
+ * Durante uma impersonation a tela recusa: um admin personificando alguém não
+ * pode entregar a conta dessa pessoa a um agente.
+ */
+export default class AgentConsentController {
+    /** GET {prefix}/consent?user_code=XXXX-XXXX */
+    show(ctx: HttpContext): Promise<any>;
+    /** POST {prefix}/consent — `decision=allow|deny`, `scope[]` marcados. */
+    decide(ctx: HttpContext): Promise<any>;
+}

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

@@ -0,0 +1,138 @@
+import '../augmentations.js';
+import { displayNameFor } from '../../agents/agent_identity.js';
+import { personalAgentsFor } from '../../agents/runtime.js';
+import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
+import { impersonationState } from '../impersonation_session.js';
+async function agentName(runtime, issuer) {
+    const registration = await runtime.config.resolveAgent(issuer);
+    return displayNameFor(registration ?? { issuer, jwksUri: '' });
+}
+/** Host do issuer para exibição — um resolver do host pode devolver issuer que não é URL. */
+function originOf(issuer) {
+    try {
+        return new URL(issuer).host;
+    }
+    catch {
+        return issuer;
+    }
+}
+/**
+ * Anti-clickjacking: o atacante pega um código na própria sessão de agente e
+ * emoldura o link já preenchido — um clique em "Permitir" entregaria a conta.
+ * A tela nunca pode ser renderizada num frame, com ou sem o shield do host.
+ */
+function denyFraming(ctx) {
+    ctx.response.header('X-Frame-Options', 'DENY');
+    ctx.response.header('Content-Security-Policy', "frame-ancestors 'none'");
+}
+/**
+ * Tela de consentimento da delegação (PACT §5.3) — o `verification_uri` do
+ * device flow. Montada atrás do `accountGuard`: sem sessão o usuário passa pelo
+ * login DESTE app e volta com o `user_code` no `return_to`. O agente nunca vê
+ * esse login.
+ *
+ * Durante uma impersonation a tela recusa: um admin personificando alguém não
+ * pode entregar a conta dessa pessoa a um agente.
+ */
+export default class AgentConsentController {
+    /** GET {prefix}/consent?user_code=XXXX-XXXX */
+    async show(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        denyFraming(ctx);
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        const base = {
+            csrfToken: ctx.request.csrfToken,
+            action: runtime.urls.consent,
+            request: null,
+            account: null,
+            error: null,
+        };
+        if (impersonationState(ctx).active) {
+            return render(ctx, 'agents/consent', { ...base, error: 'agents.consent.impersonating' });
+        }
+        const input = ctx.request.input('user_code');
+        if (!input)
+            return render(ctx, 'agents/consent', base);
+        const pending = await runtime.delegation.pendingRequest(input);
+        if (!pending) {
+            return render(ctx, 'agents/consent', { ...base, error: 'agents.consent.invalid_code' });
+        }
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const account = await service.config.accountStore.findById(accountId);
+        return render(ctx, 'agents/consent', {
+            ...base,
+            request: {
+                userCode: pending.userCode,
+                agentName: await agentName(runtime, pending.clientId),
+                agentOrigin: originOf(pending.clientId),
+                scopes: pending.scopes,
+            },
+            account: { email: account?.email ?? null },
+        });
+    }
+    /** POST {prefix}/consent — `decision=allow|deny`, `scope[]` marcados. */
+    async decide(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        denyFraming(ctx);
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        if (impersonationState(ctx).active) {
+            return render(ctx, 'agents/consent', {
+                csrfToken: ctx.request.csrfToken,
+                action: runtime.urls.consent,
+                request: null,
+                account: null,
+                error: 'agents.consent.impersonating',
+            });
+        }
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const rawCode = ctx.request.input('user_code');
+        const userCode = typeof rawCode === 'string' ? rawCode : '';
+        const pending = await runtime.delegation.pendingRequest(userCode);
+        if (!pending) {
+            return render(ctx, 'agents/done', { status: 'expired', agentName: null, scopes: [] });
+        }
+        const name = await agentName(runtime, pending.clientId);
+        const raw = ctx.request.input('scope');
+        const chosen = (Array.isArray(raw) ? raw : raw ? [raw] : []).map(String);
+        const approved = ctx.request.input('decision') === 'allow'
+            ? await runtime.delegation.approve({ userCode, accountId, scopes: chosen })
+            : null;
+        if (!approved) {
+            // Negou ou desmarcou tudo. Se nem negar deu, o pedido mudou de estado no
+            // meio do caminho (aprovado em outra aba, expirou).
+            if (!(await runtime.delegation.deny({ userCode, accountId }))) {
+                return render(ctx, 'agents/done', { status: 'expired', agentName: name, scopes: [] });
+            }
+            await cfg.audit?.record({
+                type: 'agent.delegation_denied',
+                accountId,
+                clientId: pending.clientId,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { requested: pending.scopes.map((s) => s.id) },
+            });
+            return render(ctx, 'agents/done', { status: 'denied', agentName: name, scopes: [] });
+        }
+        await cfg.audit?.record({
+            type: 'agent.delegation_approved',
+            accountId,
+            clientId: pending.clientId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { grantId: approved.grantId, scopes: approved.scopes },
+        });
+        return render(ctx, 'agents/done', {
+            status: 'approved',
+            agentName: name,
+            scopes: approved.scopes.map((id) => ({
+                id,
+                description: runtime.delegation.scopes[id] ?? id,
+            })),
+        });
+    }
+}

package/build/src/host/controllers/agent_oauth_controller.d.ts

@@ -0,0 +1,23 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Authorization server de delegação para personal agents (PACT §5.3): metadata
+ * RFC 8414, JWKS e os endpoints RFC 8628 que o AGENTE chama. O cliente OAuth é
+ * o agente, autenticado pelo JWT dele em `Authorization: Bearer` em toda
+ * chamada — `client_id` tem de ser o `iss` desse JWT.
+ */
+export default class AgentOAuthController {
+    #private;
+    metadata(ctx: HttpContext): Promise<void | {
+        issuer: string;
+        device_authorization_endpoint: string;
+        token_endpoint: string;
+        jwks_uri: string;
+        scopes_supported: string[];
+        grant_types_supported: string[];
+        response_types_supported: never[];
+    }>;
+    /** Chaves que assinam tokens de delegação e recibos — as mesmas do IdP. */
+    jwks(ctx: HttpContext): Promise<any>;
+    deviceAuthorization(ctx: HttpContext): Promise<void>;
+    token(ctx: HttpContext): Promise<void>;
+}

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

@@ -0,0 +1,110 @@
+import { AgentOAuthError, DEVICE_CODE_GRANT_TYPE, REFRESH_TOKEN_GRANT_TYPE, } from '../../agents/delegation_service.js';
+import { personalAgentUnauthorized } from '../../agents/middleware.js';
+import { personalAgentsFor } from '../../agents/runtime.js';
+function noStore(ctx) {
+    ctx.response.header('Cache-Control', 'no-store');
+    ctx.response.header('Pragma', 'no-cache');
+}
+function oauthError(ctx, error) {
+    noStore(ctx);
+    return ctx.response
+        .status(error.status)
+        .json({ error: error.code, error_description: error.description });
+}
+/**
+ * Authorization server de delegação para personal agents (PACT §5.3): metadata
+ * RFC 8414, JWKS e os endpoints RFC 8628 que o AGENTE chama. O cliente OAuth é
+ * o agente, autenticado pelo JWT dele em `Authorization: Bearer` em toda
+ * chamada — `client_id` tem de ser o `iss` desse JWT.
+ */
+export default class AgentOAuthController {
+    async metadata(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        return {
+            issuer: runtime.urls.issuer,
+            device_authorization_endpoint: runtime.urls.deviceAuthorization,
+            token_endpoint: runtime.urls.token,
+            jwks_uri: runtime.urls.jwks,
+            scopes_supported: Object.keys(runtime.delegation.scopes),
+            grant_types_supported: [DEVICE_CODE_GRANT_TYPE, REFRESH_TOKEN_GRANT_TYPE],
+            response_types_supported: [],
+            // Sem `token_endpoint_auth_methods_supported`: o agente se autentica com o
+            // JWT dele em `Authorization: Bearer` (PACT §5.3), método sem nome
+            // registrado — anunciar `private_key_jwt` levaria um cliente genérico a
+            // mandar `client_assertion` e tomar 401.
+        };
+    }
+    /** Chaves que assinam tokens de delegação e recibos — as mesmas do IdP. */
+    async jwks(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        const service = await ctx.containerResolver.make('authkit.server');
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        ctx.response.header('Cache-Control', 'public, max-age=300');
+        return service.publicJwks;
+    }
+    async deviceAuthorization(ctx) {
+        const auth = await this.#authenticate(ctx);
+        if (!auth)
+            return;
+        try {
+            const body = await auth.runtime.delegation.requestDevice(auth.agent, ctx.request.input('scope'));
+            noStore(ctx);
+            return ctx.response.json(body);
+        }
+        catch (error) {
+            if (error instanceof AgentOAuthError)
+                return oauthError(ctx, error);
+            throw error;
+        }
+    }
+    async token(ctx) {
+        const auth = await this.#authenticate(ctx);
+        if (!auth)
+            return;
+        const delegation = auth.runtime.delegation;
+        try {
+            const grantType = ctx.request.input('grant_type');
+            const body = grantType === DEVICE_CODE_GRANT_TYPE
+                ? await delegation.exchangeDeviceCode(auth.agent, ctx.request.input('device_code'))
+                : grantType === REFRESH_TOKEN_GRANT_TYPE
+                    ? await delegation.refresh(auth.agent, ctx.request.input('refresh_token'))
+                    : null;
+            if (!body) {
+                throw new AgentOAuthError('unsupported_grant_type', 'Unsupported grant_type');
+            }
+            noStore(ctx);
+            return ctx.response.json(body);
+        }
+        catch (error) {
+            if (error instanceof AgentOAuthError)
+                return oauthError(ctx, error);
+            throw error;
+        }
+    }
+    /**
+     * JWT do agente + `client_id` coerente. Já respondeu (401/404) quando
+     * devolve `null`.
+     */
+    async #authenticate(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation) {
+            ctx.response.notFound();
+            return null;
+        }
+        const agent = await runtime.verifier.verify(ctx.request.header('authorization'));
+        if (!agent) {
+            personalAgentUnauthorized(ctx, runtime.config.protocol);
+            return null;
+        }
+        if (ctx.request.input('client_id') !== agent.issuer) {
+            oauthError(ctx, new AgentOAuthError('invalid_client', 'client_id must equal the personal-agent issuer', 401));
+            return null;
+        }
+        return { runtime, agent };
+    }
+}

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

@@ -180,6 +180,7 @@ export default class AuthInteractionController {
                 params: details.params,
                 csrfToken: ctx.request.csrfToken,
                 brand,
+                ...(await consentSubject(service, details, cfg.messages)),
             });
         }
         const email = ctx.session.get(SESSION_KEY);
@@ -1564,3 +1565,30 @@ export default class AuthInteractionController {
         }
     }
 }
+/**
+ * Quem pede o acesso e o quê, para a tela de consent: o nome que o client registrou (um cliente
+ * MCP registra o seu, ex.: "Claude Code") e os escopos pedidos, com o rótulo de cada um. O nome
+ * vem de fora (registro dinâmico aberto) — `clientNameHtml` sai escapado para o `{{{ }}}`.
+ */
+async function consentSubject(service, details, messages) {
+    const clientId = String(details.params?.client_id ?? '');
+    const client = clientId ? await service.provider.Client.find(clientId).catch(() => null) : null;
+    const clientName = client?.clientName || clientId;
+    const requested = String(details.params?.scope ?? '')
+        .split(' ')
+        .filter((scope) => scope !== '' && scope !== 'openid');
+    const scopes = requested.map((scope) => {
+        const key = `consent.scope.${scope}`;
+        const label = translate(messages, key);
+        return { id: scope, label: label === key ? scope : label };
+    });
+    return { clientName, clientNameHtml: escapeHtml(clientName), scopes };
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}

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

@@ -1,29 +1,19 @@
-/**
- * Helper de exceções de CSRF para as rotas machine-to-machine do AuthKit.
- *
- * Os endpoints do IdP (token/introspection/PAT) e o back-channel logout são
- * server-to-server (sem browser/token XSRF). Em vez de cada app reescrever a
- * checagem de URL no `config/shield.ts`, use este helper:
- *
- * ```ts
- * // config/shield.ts
- * import { authkitCsrfExceptions } from '@adonis-agora/authkit-server'
- * csrf: {
- *   enabled: true,
- *   exceptRoutes: (ctx) => authkitCsrfExceptions(ctx.request.url(), { mountPath: '/oidc' })
- *     || ctx.request.url().includes('/api'),
- * }
- * ```
- */
 export interface AuthkitCsrfOptions {
     /** mountPath do IdP (mesmo de defineConfig/registerAuthHost). Default: `/oidc`. */
     mountPath?: string;
     /** Inclui a rota de back-channel logout do CLIENT (default: `/auth/backchannel-logout`). */
     backchannelLogoutPath?: string | false;
+    /**
+     * Prefixo de `personalAgents`: isenta os endpoints OAuth que os agentes chamam
+     * (`{prefix}/oauth/*`). Default: o prefixo do config quando `personalAgents`
+     * está ligado; nada quando não está. `false` desliga. A tela de
+     * consentimento (`{prefix}/consent`) continua protegida.
+     */
+    personalAgentsPrefix?: string | false;
 }
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
  * (machine-to-machine). Cobre o mountPath do IdP, a introspecção de PAT e a
- * rota de back-channel logout do client.
+ * rota de back-channel logout do client e os endpoints OAuth de personal agents.
  */
 export declare function authkitCsrfExceptions(url: string, options?: AuthkitCsrfOptions): boolean;

package/build/src/host/csrf.js

@@ -1,14 +1,40 @@
+/**
+ * Helper de exceções de CSRF para as rotas machine-to-machine do AuthKit.
+ *
+ * Os endpoints do IdP (token/introspection/PAT) e o back-channel logout são
+ * server-to-server (sem browser/token XSRF). Em vez de cada app reescrever a
+ * checagem de URL no `config/shield.ts`, use este helper:
+ *
+ * ```ts
+ * // config/shield.ts
+ * import { authkitCsrfExceptions } from '@adonis-agora/authkit-server'
+ * csrf: {
+ *   enabled: true,
+ *   exceptRoutes: (ctx) => authkitCsrfExceptions(ctx.request.url(), { mountPath: '/oidc' })
+ *     || ctx.request.url().includes('/api'),
+ * }
+ * ```
+ */
+import { normalizePersonalAgentsPrefix } from '../agents/config.js';
+import { getAuthHostConfig } from './auth_host_config.js';
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
  * (machine-to-machine). Cobre o mountPath do IdP, a introspecção de PAT e a
- * rota de back-channel logout do client.
+ * rota de back-channel logout do client e os endpoints OAuth de personal agents.
  */
 export function authkitCsrfExceptions(url, options = {}) {
     const mountPath = options.mountPath ?? '/oidc';
     const backchannel = options.backchannelLogoutPath === false
         ? null
         : (options.backchannelLogoutPath ?? '/auth/backchannel-logout');
+    const agentsPrefix = options.personalAgentsPrefix === false
+        ? undefined
+        : options.personalAgentsPrefix !== undefined
+            ? normalizePersonalAgentsPrefix(options.personalAgentsPrefix)
+            : getAuthHostConfig()?.personalAgents?.prefix;
+    const agentsOAuth = agentsPrefix ? `${agentsPrefix}/oauth/` : null;
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
-        (backchannel !== null && url === backchannel));
+        (backchannel !== null && url === backchannel) ||
+        (agentsOAuth !== null && url.startsWith(agentsOAuth)));
 }

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

@@ -97,6 +97,11 @@ export declare const DEFAULT_MESSAGES: {
     'consent.title': string;
     'consent.body': string;
     'consent.submit': string;
+    'consent.scopes_title': string;
+    'consent.scope.profile': string;
+    'consent.scope.email': string;
+    'consent.scope.offline_access': string;
+    'consent.scope.roles': string;
     'account.login.page_title': string;
     'account.login.title': string;
     'account.login.intro': string;
@@ -175,6 +180,28 @@ export declare const DEFAULT_MESSAGES: {
     'account.apps.revoke': string;
     'account.apps.revoke_confirm': string;
     'account.apps.revoked': string;
+    'account.apps.agents_title': string;
+    'account.apps.agents_intro': string;
+    'account.apps.agents_empty': string;
+    'agents.consent.page_title': string;
+    'agents.consent.title': string;
+    'agents.consent.body': string;
+    'agents.consent.signed_in_as': string;
+    'agents.consent.scopes_label': string;
+    'agents.consent.code': string;
+    'agents.consent.allow': string;
+    'agents.consent.deny': string;
+    'agents.consent.enter_code_title': string;
+    'agents.consent.enter_code_body': string;
+    'agents.consent.continue': string;
+    'agents.consent.invalid_code': string;
+    'agents.consent.impersonating': string;
+    'agents.done.approved_title': string;
+    'agents.done.denied_title': string;
+    'agents.done.return': string;
+    'agents.done.revoke_hint': string;
+    'agents.done.expired_title': string;
+    'agents.done.expired_body': string;
     'account.apps.not_supported': string;
     'account.orgs.page_title': string;
     'account.orgs.title': string;
@@ -820,6 +847,11 @@ export declare const PT_BR_MESSAGES: {
     'consent.title': string;
     'consent.body': string;
     'consent.submit': string;
+    'consent.scopes_title': string;
+    'consent.scope.profile': string;
+    'consent.scope.email': string;
+    'consent.scope.offline_access': string;
+    'consent.scope.roles': string;
     'account.login.page_title': string;
     'account.login.title': string;
     'account.login.intro': string;
@@ -898,6 +930,28 @@ export declare const PT_BR_MESSAGES: {
     'account.apps.revoke': string;
     'account.apps.revoke_confirm': string;
     'account.apps.revoked': string;
+    'account.apps.agents_title': string;
+    'account.apps.agents_intro': string;
+    'account.apps.agents_empty': string;
+    'agents.consent.page_title': string;
+    'agents.consent.title': string;
+    'agents.consent.body': string;
+    'agents.consent.signed_in_as': string;
+    'agents.consent.scopes_label': string;
+    'agents.consent.code': string;
+    'agents.consent.allow': string;
+    'agents.consent.deny': string;
+    'agents.consent.enter_code_title': string;
+    'agents.consent.enter_code_body': string;
+    'agents.consent.continue': string;
+    'agents.consent.invalid_code': string;
+    'agents.consent.impersonating': string;
+    'agents.done.approved_title': string;
+    'agents.done.denied_title': string;
+    'agents.done.return': string;
+    'agents.done.revoke_hint': string;
+    'agents.done.expired_title': string;
+    'agents.done.expired_body': string;
     'account.apps.not_supported': string;
     'account.orgs.page_title': string;
     'account.orgs.title': string;