@adonis-agora/authkit-server 1.0.0-rc.0 → 1.0.0-rc.10

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

@@ -17,6 +17,19 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     backchannelLogoutSessionRequired: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine").VineBoolean>;
     clientName: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine/schema/base/literal").NullableModifier<import("@vinejs/vine").VineString>>;
     logoUri: import("@vinejs/vine/schema/base/literal").OptionalModifier<import("@vinejs/vine/schema/base/literal").NullableModifier<import("@vinejs/vine").VineString>>;
+    serviceTenant: import("@vinejs/vine").OptionalModifier<import("@vinejs/vine").NullableModifier<import("@vinejs/vine").VineObject<{
+        partition: import("@vinejs/vine").VineString;
+        capabilities: import("@vinejs/vine").OptionalModifier<import("@vinejs/vine").VineArray<import("@vinejs/vine").VineString>>;
+    }, {
+        capabilities?: string[] | null | undefined;
+        partition: string;
+    }, {
+        capabilities?: string[] | undefined;
+        partition: string;
+    }, {
+        capabilities?: string[] | undefined;
+        partition: string;
+    }>>>;
 }, {
     applicationType?: "native" | "web" | null | undefined;
     backchannelLogoutSessionRequired?: string | number | boolean | null | undefined;
@@ -27,6 +40,10 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     logoUri?: string | null | undefined;
     postLogoutRedirectUris?: string[] | null | undefined;
     redirectUris?: string[] | null | undefined;
+    serviceTenant?: {
+        capabilities?: string[] | null | undefined;
+        partition: string;
+    } | null | undefined;
     tokenEndpointAuthMethod?: "client_secret_basic" | "client_secret_post" | "none" | null | undefined;
 }, {
     applicationType?: "native" | "web" | undefined;
@@ -38,6 +55,10 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     logoUri?: string | null | undefined;
     postLogoutRedirectUris?: string[] | undefined;
     redirectUris?: string[] | undefined;
+    serviceTenant?: {
+        capabilities?: string[] | undefined;
+        partition: string;
+    } | null | undefined;
     tokenEndpointAuthMethod?: "client_secret_basic" | "client_secret_post" | "none" | undefined;
 }, {
     applicationType?: "native" | "web" | undefined;
@@ -49,6 +70,10 @@ export declare const clientInputValidator: import("@vinejs/vine").VineValidator<
     logoUri?: string | null | undefined;
     postLogoutRedirectUris?: string[] | undefined;
     redirectUris?: string[] | undefined;
+    serviceTenant?: {
+        capabilities?: string[] | undefined;
+        partition: string;
+    } | null | undefined;
     tokenEndpointAuthMethod?: "client_secret_basic" | "client_secret_post" | "none" | undefined;
 }>, Record<string, any> | undefined>;
 /** Forma validada de um client (saída do {@link clientInputValidator}). */
@@ -63,6 +88,10 @@ export type ClientInputFields = {
     backchannelLogoutSessionRequired?: boolean;
     clientName?: string | null;
     logoUri?: string | null;
+    serviceTenant?: {
+        partition: string;
+        capabilities?: string[];
+    } | null;
 };
 /**
  * Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults.

package/build/src/host/admin_validators.js

@@ -1,4 +1,5 @@
 import vine from '@vinejs/vine';
+import { CAPABILITY_PATTERN, MAX_CAPABILITIES, PARTITION_PATTERN, } from '../service_tenants/client_metadata.js';
 import { APPLICATION_TYPES, redirectUriProblem } from './client_metadata.js';
 import { normalizeEmailIdentifier } from './email_identifier.js';
 /**
@@ -103,6 +104,18 @@ export const clientInputValidator = vine.compile(vine.object({
     // `null` (update) removes them.
     clientName: vine.string().trim().maxLength(200).nullable().optional(),
     logoUri: vine.string().trim().url(URL_OPTS).nullable().optional(),
+    // Service tenant (`client_credentials` + partition claim). `null` (update) turns it
+    // back into a regular client.
+    serviceTenant: vine
+        .object({
+        partition: vine.string().trim().regex(PARTITION_PATTERN),
+        capabilities: vine
+            .array(vine.string().trim().regex(CAPABILITY_PATTERN))
+            .maxLength(MAX_CAPABILITIES)
+            .optional(),
+    })
+        .nullable()
+        .optional(),
 }));
 /**
  * Mapeia o input validado para um {@link ClientInput} COMPLETO (create), com defaults.
@@ -111,6 +124,21 @@ export const clientInputValidator = vine.compile(vine.object({
  */
 export function clientCreateInput(v) {
     const applicationType = v.applicationType ?? 'web';
+    // A service tenant only uses client_credentials: that is its default grant.
+    if (v.serviceTenant) {
+        return {
+            clientId: v.clientId?.trim() || undefined,
+            applicationType,
+            redirectUris: v.redirectUris ?? [],
+            postLogoutRedirectUris: v.postLogoutRedirectUris ?? [],
+            grantTypes: v.grantTypes ?? ['client_credentials'],
+            tokenEndpointAuthMethod: v.tokenEndpointAuthMethod ?? 'client_secret_basic',
+            backchannelLogoutUri: v.backchannelLogoutUri || undefined,
+            clientName: v.clientName || undefined,
+            logoUri: v.logoUri || undefined,
+            serviceTenant: v.serviceTenant,
+        };
+    }
     return {
         clientId: v.clientId?.trim() || undefined,
         applicationType,
@@ -148,6 +176,8 @@ export function clientPartialInput(v) {
         out.clientName = v.clientName?.trim() || null;
     if (v.logoUri !== undefined)
         out.logoUri = v.logoUri?.trim() || null;
+    if (v.serviceTenant !== undefined)
+        out.serviceTenant = v.serviceTenant;
     return out;
 }
 // ─── Usuários ───────────────────────────────────────────────────────────────

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

@@ -1,4 +1,6 @@
 import type { HttpContext } from '@adonisjs/core/http';
+import type { AccountConsoleConfig } from '../account/runtime.js';
+import type { ResolvedPersonalAgentExtension } from '../agents/extension.js';
 import type { AuthSocialConfig, ResolvedRateLimitConfig } from '../define_config.js';
 import type { PolicyRouteOption } from './config_locks.js';
 import type { AuthHostOptions } from './register_auth_host.js';
@@ -35,11 +37,21 @@ export interface AuthHostRuntimeConfig {
      * Ver `deriveLockedRouteOptions`.
      */
     lockedRouteOptions?: PolicyRouteOption[];
-    /** Personal agents ligados → prefixo das rotas deles (`/agents`) e do Poppy (`/poppy`). */
+    /**
+     * Personal agents ligados → prefixo das rotas do PACT (`/agents`) e as
+     * `personalAgents.extensions` resolvidas (rotas, isenções de CSRF, navegador do agente).
+     */
     personalAgents?: {
         prefix: string;
-        poppyPrefix?: string;
+        extensions?: readonly ResolvedPersonalAgentExtension[];
     };
+    /**
+     * `accountSession.acceptIdpSession: false` com `authMethods: { password: false }`:
+     * o console só entra por um `accountLoginUrl` do host (`registerAuthHost` recusa sem ele).
+     */
+    consoleNeedsLoginUrl?: boolean;
+    /** `accountConsole` do config: os overrides das páginas de extension. */
+    accountConsole?: AccountConsoleConfig;
     /**
      * API headless (Clerk-style). Presente quando o host a declarou — o provider o
      * stash no boot para `registerAuthHost` montar as rotas sem reler o config inteiro.

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

@@ -0,0 +1,6 @@
+/**
+ * The page a browser gets when `admin.authorize` denies the admin console
+ * (403), or asks for a sign-in it cannot do itself (401). Self-contained: no
+ * script and no external asset, so any CSP renders it.
+ */
+export declare function consoleDeniedPage(status: 401 | 403): string;

package/build/src/host/console_denied_page.js

@@ -0,0 +1,18 @@
+/**
+ * The page a browser gets when `admin.authorize` denies the admin console
+ * (403), or asks for a sign-in it cannot do itself (401). Self-contained: no
+ * script and no external asset, so any CSP renders it.
+ */
+export function consoleDeniedPage(status) {
+    const title = status === 401 ? 'Sign in required' : 'Access denied';
+    const body = status === 401
+        ? 'This console needs credentials this request did not carry.'
+        : 'You do not have access to this console.';
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${title}</title>
+<style>body{font-family:system-ui,sans-serif;background:#f9fafb;color:#111827;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:16px}
+.box{max-width:420px;text-align:center}h1{font-size:20px;margin:0 0 8px}p{color:#4b5563;font-size:14px;line-height:1.6;margin:0}
+.code{font-size:12px;color:#9ca3af;margin-bottom:8px}</style>
+</head><body><main class="box"><p class="code">${status}</p><h1>${title}</h1><p>${body}</p></main></body></html>`;
+}

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

@@ -0,0 +1,24 @@
+/** `client_id` do client interno do console. Reservado: não pode ser cadastrado. */
+export declare const CONSOLE_SSO_CLIENT_ID = "authkit-console";
+/** Rota que inicia o login do console pelo IdP. */
+export declare const CONSOLE_SSO_START_PATH = "/auth/console/sso";
+/** `redirect_uri` do client interno: valida o `state` e abre o console. */
+export declare const CONSOLE_SSO_CALLBACK_PATH = "/auth/console/callback";
+/** Chave da sessão Adonis com o `state` e o destino de um login em andamento. */
+export declare const CONSOLE_SSO_STATE_KEY = "authkit_console_sso";
+/** O que fica na sessão entre o início e o callback. */
+export interface ConsoleSsoState {
+    state: string;
+    returnTo: string | null;
+}
+/** Metadata do client interno para o `clients` estático do oidc-provider. */
+export declare function consoleSsoClientMetadata(issuer: string): Record<string, unknown>;
+/** Novo `state` opaco para um login do console. */
+export declare function newConsoleSsoState(): string;
+/**
+ * Path do authorize do provider. O issuer termina no `mountPath` (garantido por
+ * `registerAuthHost`), então o mount é o path do issuer.
+ */
+export declare function authorizationPath(issuer: string, provider?: any): string;
+/** URL do login do console pelo IdP, preservando o destino como `return_to`. */
+export declare function consoleSsoUrl(returnTo?: string | null): string;

package/build/src/host/console_sso.js

@@ -0,0 +1,70 @@
+/**
+ * Login do console pelo IdP (SSO), o jeito padrão de entrar em `/account/*` e no
+ * console admin.
+ *
+ * O console é tratado como mais um app do IdP, como o Keycloak faz com o
+ * `account-console` e o `security-admin-console`: sem sessão, o visitante vai
+ * para a tela de login do IdP (a mesma interaction de qualquer client: senha,
+ * magic link, OTP, passkey, social), volta, e a ponte de
+ * `idp_session_bridge.ts` abre o console para a conta da sessão do IdP.
+ *
+ * Para isso existe um client interno, `authkit-console`, injetado como client
+ * ESTÁTICO do provider (não fica no adapter, então não aparece na lista de
+ * clients do console nem pode ser editado):
+ *
+ *   - `response_types: ['none']`: o authorize não emite code nem token. O client
+ *     só usa o IdP para autenticar; o que abre o console é a sessão do IdP que o
+ *     login criou, lida pela ponte. Não há segredo, PKCE ou troca de code.
+ *   - o consent é concedido automaticamente (é a própria lib).
+ *   - a única `redirect_uri` é `/auth/console/callback`, no MESMO host do issuer.
+ *
+ * Só existe com `accountSession.acceptIdpSession` ligado (o default).
+ */
+import { randomBytes } from 'node:crypto';
+/** `client_id` do client interno do console. Reservado: não pode ser cadastrado. */
+export const CONSOLE_SSO_CLIENT_ID = 'authkit-console';
+/** Rota que inicia o login do console pelo IdP. */
+export const CONSOLE_SSO_START_PATH = '/auth/console/sso';
+/** `redirect_uri` do client interno: valida o `state` e abre o console. */
+export const CONSOLE_SSO_CALLBACK_PATH = '/auth/console/callback';
+/** Chave da sessão Adonis com o `state` e o destino de um login em andamento. */
+export const CONSOLE_SSO_STATE_KEY = 'authkit_console_sso';
+/** Metadata do client interno para o `clients` estático do oidc-provider. */
+export function consoleSsoClientMetadata(issuer) {
+    const origin = new URL(issuer).origin;
+    return {
+        client_id: CONSOLE_SSO_CLIENT_ID,
+        client_name: 'Account console',
+        application_type: 'web',
+        token_endpoint_auth_method: 'none',
+        response_types: ['none'],
+        grant_types: [],
+        redirect_uris: [`${origin}${CONSOLE_SSO_CALLBACK_PATH}`],
+    };
+}
+/** Novo `state` opaco para um login do console. */
+export function newConsoleSsoState() {
+    return randomBytes(24).toString('base64url');
+}
+/**
+ * Path do authorize do provider. O issuer termina no `mountPath` (garantido por
+ * `registerAuthHost`), então o mount é o path do issuer.
+ */
+export function authorizationPath(issuer, provider) {
+    const mount = new URL(issuer).pathname.replace(/\/+$/, '');
+    if (provider && typeof provider.pathFor === 'function') {
+        try {
+            return provider.pathFor('authorization', { mountPath: mount });
+        }
+        catch {
+            // cai no default do oidc-provider abaixo
+        }
+    }
+    return `${mount}/auth`;
+}
+/** URL do login do console pelo IdP, preservando o destino como `return_to`. */
+export function consoleSsoUrl(returnTo) {
+    if (!returnTo)
+        return CONSOLE_SSO_START_PATH;
+    return `${CONSOLE_SSO_START_PATH}?return_to=${encodeURIComponent(returnTo)}`;
+}

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

@@ -38,16 +38,19 @@ export default class AccountAppsController {
                 scopes: g.scopes,
             })))
             : null;
-        // Refresh tokens do Poppy: o agente é desconectado pela mesma lista (§5.5).
-        const poppy = agentsRuntime?.poppy;
-        const poppyAgents = poppy
-            ? await Promise.all((await poppy.listGrants(accountId)).map(async (g) => ({
-                id: g.id,
-                name: await poppy.registry.displayName(g.clientId),
-                scopes: g.scopes,
-            })))
-            : null;
-        const agents = pactAgents || poppyAgents ? [...(pactAgents ?? []), ...(poppyAgents ?? [])] : null;
+        // Conexões das `personalAgents.extensions`: desconectadas pela mesma lista.
+        let extensionAgents = null;
+        for (const { runtime } of agentsRuntime?.extensions.values() ?? []) {
+            extensionAgents ??= [];
+            for (const g of await runtime.listAccountGrants(accountId)) {
+                extensionAgents.push({
+                    id: g.id,
+                    name: await runtime.displayName(g.clientId),
+                    scopes: g.scopes,
+                });
+            }
+        }
+        const agents = pactAgents || extensionAgents ? [...(pactAgents ?? []), ...(extensionAgents ?? [])] : null;
         return render(ctx, 'account/apps', {
             csrfToken: ctx.request.csrfToken,
             supported,
@@ -89,8 +92,9 @@ export default class AccountAppsController {
     /** 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 && !runtime?.poppy)
+        if (!runtime || (!runtime.delegation && runtime.extensions.size === 0)) {
             return ctx.response.notFound();
+        }
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);

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

@@ -3,6 +3,7 @@ import { accountHome } from '../account_home.js';
 import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { syncAdonisAuthLogin, syncAdonisAuthLogout } from '../adonis_auth_sync.js';
+import { consoleSsoUrl } from '../console_sso.js';
 import { normalizeEmailIdentifier } from '../email_identifier.js';
 import { translate } from '../i18n.js';
 import { endBridgedIdpSession } from '../idp_session_bridge.js';
@@ -49,8 +50,16 @@ export default class AccountSessionController {
             return ctx.response.redirect(accountHome(cfg));
         }
         // Lê e valida o return_to da query-string — descarta valores inválidos (open-redirect).
-        const rawReturnTo = ctx.request.qs?.()?.return_to ?? ctx.request.input?.('return_to');
+        const qs = (ctx.request.qs?.() ?? {});
+        const rawReturnTo = qs.return_to ?? ctx.request.input?.('return_to');
         const returnTo = validateReturnTo(rawReturnTo);
+        // SSO (default): o console entra pelo login do IdP, a mesma tela de qualquer
+        // app. O formulário de senha daqui fica como porta alternativa
+        // (`?method=password`), e só quando a senha não foi desligada no config.
+        const passwordForm = qs.method === 'password' && cfg.authMethods?.password !== false;
+        if (cfg.accountSession?.acceptIdpSession === true && !passwordForm) {
+            return redirectExact(ctx.response, consoleSsoUrl(returnTo));
+        }
         const props = {
             csrfToken: ctx.request.csrfToken,
             returnTo,

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

@@ -0,0 +1,12 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Login do console pelo IdP (ver `console_sso.ts`).
+ *
+ *   GET /auth/console/sso?return_to=…   → authorize do client interno
+ *   GET /auth/console/callback?state=…  → valida o state, abre o console pela ponte
+ */
+export default class ConsoleSsoController {
+    start(ctx: HttpContext): Promise<unknown>;
+    callback(ctx: HttpContext): Promise<unknown>;
+}

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

@@ -0,0 +1,61 @@
+import '../augmentations.js';
+import { accountHome } from '../account_home.js';
+import { getAccountLoginUrl } from '../account_login_url.js';
+import { authorizationPath, CONSOLE_SSO_CALLBACK_PATH, CONSOLE_SSO_CLIENT_ID, CONSOLE_SSO_STATE_KEY, newConsoleSsoState, } from '../console_sso.js';
+import { ensureConsoleSession } from '../idp_session_bridge.js';
+import { redirectExact } from '../redirect_exact.js';
+import { validateReturnTo } from './account_session_controller.js';
+/**
+ * Login do console pelo IdP (ver `console_sso.ts`).
+ *
+ *   GET /auth/console/sso?return_to=…   → authorize do client interno
+ *   GET /auth/console/callback?state=…  → valida o state, abre o console pela ponte
+ */
+export default class ConsoleSsoController {
+    async start(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const returnTo = validateReturnTo(ctx.request.qs?.()?.return_to ?? ctx.request.input?.('return_to'));
+        // SSO desligado (`acceptIdpSession: false`): o console só tem o login próprio.
+        if (cfg.accountSession?.acceptIdpSession !== true) {
+            const login = getAccountLoginUrl();
+            const sep = login.includes('?') ? '&' : '?';
+            return redirectExact(ctx.response, returnTo ? `${login}${sep}return_to=${encodeURIComponent(returnTo)}` : login);
+        }
+        // Já tem sessão (de console ou do IdP): não precisa passar pelo IdP.
+        if (await ensureConsoleSession(ctx)) {
+            return redirectExact(ctx.response, returnTo ?? accountHome(cfg));
+        }
+        const state = newConsoleSsoState();
+        ctx.session.put(CONSOLE_SSO_STATE_KEY, { state, returnTo });
+        const origin = new URL(cfg.issuer).origin;
+        const query = new URLSearchParams({
+            client_id: CONSOLE_SSO_CLIENT_ID,
+            response_type: 'none',
+            scope: 'openid',
+            redirect_uri: `${origin}${CONSOLE_SSO_CALLBACK_PATH}`,
+            state,
+        });
+        return redirectExact(ctx.response, `${authorizationPath(cfg.issuer, service.provider)}?${query.toString()}`);
+    }
+    async callback(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const pending = ctx.session.get(CONSOLE_SSO_STATE_KEY);
+        ctx.session.forget(CONSOLE_SSO_STATE_KEY);
+        const qs = (ctx.request.qs?.() ?? {});
+        // `state` amarra o callback ao navegador que iniciou o login (anti-CSRF de login).
+        if (!pending || typeof qs.state !== 'string' || qs.state !== pending.state) {
+            return ctx.response.status(400).send('Invalid or expired sign-in request.');
+        }
+        // O IdP recusou (o usuário cancelou, conta desabilitada, …): sem console.
+        // Vai para a raiz, e não de volta ao console, para não entrar em loop.
+        if (typeof qs.error === 'string') {
+            return redirectExact(ctx.response, '/');
+        }
+        if (!(await ensureConsoleSession(ctx))) {
+            return redirectExact(ctx.response, '/');
+        }
+        return redirectExact(ctx.response, pending.returnTo ?? accountHome(cfg));
+    }
+}

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

@@ -5,6 +5,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
 import { brandFor, isFirstParty } from '../branding.js';
 import { consentRequestParams } from '../consent_params.js';
+import { CONSOLE_SSO_CLIENT_ID } from '../console_sso.js';
 import { isCustomLoginMethodId } from '../custom_login.js';
 import { completeCustomLoginSession } from '../custom_login_completion.js';
 import { beginCustomMfa, clearMfaFlow, customMfaViewProps, getMfaFlow, initializeMfaFlow, recordVerifiedMfaFactor, resolveCustomMfaMethods, verifyCustomMfa, } from '../custom_mfa.js';
@@ -254,7 +255,8 @@ export default class AuthInteractionController {
             }
         }
         if (details.prompt.name === 'consent' &&
-            isFirstParty(cfg.branding, details.params.client_id)) {
+            (details.params.client_id === CONSOLE_SSO_CLIENT_ID ||
+                isFirstParty(cfg.branding, details.params.client_id))) {
             // Clients first-party: auto-concede o consent (pula a tela de consent).
             // interactions.consent monta o Grant + interactionFinished e escreve o
             // redirect de volta para o client — opera via provider.interactionDetails,

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

@@ -11,10 +11,10 @@ export interface AuthkitCsrfOptions {
      */
     personalAgentsPrefix?: string | false;
     /**
-     * Prefixo do Poppy: isenta token/revoke/device authorization e a entrada do navegador
-     * (o código com o cookie `SameSite=Strict` é o que protege, §6).
+     * Isenta os `csrfExemptPaths` das `personalAgents.extensions` do config. Default: true.
+     * `false` desliga.
      */
-    poppyPrefix?: string | false;
+    personalAgentExtensions?: boolean;
 }
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF

package/build/src/host/csrf.js

@@ -16,7 +16,6 @@
  * ```
  */
 import { normalizePersonalAgentsPrefix } from '../agents/config.js';
-import { normalizePoppyPrefix } from '../agents/poppy/config.js';
 import { getAuthHostConfig } from './auth_host_config.js';
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
@@ -34,21 +33,12 @@ export function authkitCsrfExceptions(url, options = {}) {
             ? normalizePersonalAgentsPrefix(options.personalAgentsPrefix)
             : getAuthHostConfig()?.personalAgents?.prefix;
     const agentsOAuth = agentsPrefix ? `${agentsPrefix}/oauth/` : null;
-    const poppyPrefix = options.poppyPrefix === false
-        ? undefined
-        : options.poppyPrefix !== undefined
-            ? normalizePoppyPrefix(options.poppyPrefix)
-            : getAuthHostConfig()?.personalAgents?.poppyPrefix;
     const path = url.split('?')[0];
-    const poppyExempt = !!poppyPrefix &&
-        (path === `${poppyPrefix}/oauth/token` ||
-            path === `${poppyPrefix}/oauth/revoke` ||
-            path === `${poppyPrefix}/oauth/device` ||
-            path === `${poppyPrefix}/browser-session` ||
-            path === `${poppyPrefix}/browser-session/authorize`);
+    const extensionExempt = options.personalAgentExtensions !== false &&
+        (getAuthHostConfig()?.personalAgents?.extensions ?? []).some((e) => e.csrfExemptPaths?.includes(path));
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
         (backchannel !== null && url === backchannel) ||
         (agentsOAuth !== null && url.startsWith(agentsOAuth)) ||
-        poppyExempt);
+        extensionExempt);
 }

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

@@ -67,15 +67,20 @@ export declare function sendMagicLinkEmail(ctx: HttpContext, data: {
     channel?: 'code' | 'link';
 }): Promise<void>;
 /**
- * Envia o código do Mediated Sign-In pronto do Poppy (`poppyEmailCodeSignIn`) pelo
- * mailer default do host. Só código, sem link: quem digita é a pessoa, no agente.
- * Best-effort: no fallback (sem mail) loga o código, como o magic link loga o link; nunca lança.
+ * Envia um e-mail só com um código (sem link: quem digita é a pessoa, em outro lugar) pelo mailer
+ * default do host, com o branding e o i18n do authkit. Os textos saem do catálogo pelas chaves
+ * `{messages}.subject`, `.heading`, `.intro`, `.code_label` e `.fallback`, com `params`
+ * interpolados — uma extension registra as dela em `messages`. Best-effort: sem `@adonisjs/mail`
+ * loga o código (dev); nunca lança.
+ *
+ * Estável no 1.x (é o mailer das `personalAgents.extensions`).
  */
-export declare function sendPoppySignInCodeEmail(ctx: HttpContext, data: {
+export declare function sendAuthkitCodeEmail(ctx: HttpContext, data: {
     email: string;
     code: string;
-    agentName: string;
-    expiresInMinutes: number;
+    /** Prefixo das chaves no catálogo (`'mail.poppy_sign_in'`). */
+    messages: string;
+    params?: Record<string, string | number>;
 }): Promise<void>;
 /**
  * Envia o link de CONFIRMAÇÃO DE IDENTIDADE (sudo) pelo mailer default do host.

package/build/src/host/default_mailer.js

@@ -295,32 +295,36 @@ export async function sendMagicLinkEmail(ctx, data) {
     }
 }
 /**
- * Envia o código do Mediated Sign-In pronto do Poppy (`poppyEmailCodeSignIn`) pelo
- * mailer default do host. Só código, sem link: quem digita é a pessoa, no agente.
- * Best-effort: no fallback (sem mail) loga o código, como o magic link loga o link; nunca lança.
+ * Envia um e-mail só com um código (sem link: quem digita é a pessoa, em outro lugar) pelo mailer
+ * default do host, com o branding e o i18n do authkit. Os textos saem do catálogo pelas chaves
+ * `{messages}.subject`, `.heading`, `.intro`, `.code_label` e `.fallback`, com `params`
+ * interpolados — uma extension registra as dela em `messages`. Best-effort: sem `@adonisjs/mail`
+ * loga o código (dev); nunca lança.
+ *
+ * Estável no 1.x (é o mailer das `personalAgents.extensions`).
  */
-export async function sendPoppySignInCodeEmail(ctx, data) {
+export async function sendAuthkitCodeEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const params = { agent: data.agentName, minutes: data.expiresInMinutes };
+        const key = (name) => `${data.messages}.${name}`;
         const content = renderTransactionalEmail({
             brand,
             locale,
-            subject: translate(t, 'mail.poppy_sign_in.subject', params),
-            heading: translate(t, 'mail.poppy_sign_in.heading', params),
-            intro: translate(t, 'mail.poppy_sign_in.intro', params),
-            footnote: translate(t, 'mail.poppy_sign_in.fallback'),
+            subject: translate(t, key('subject'), data.params),
+            heading: translate(t, key('heading'), data.params),
+            intro: translate(t, key('intro'), data.params),
+            footnote: translate(t, key('fallback'), data.params),
             code: data.code,
-            codeLabel: translate(t, 'mail.poppy_sign_in.code_label'),
+            codeLabel: translate(t, key('code_label'), data.params),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
-            ctx.logger.info({ email: data.email, agent: data.agentName, code: data.code }, 'authkit: código do Poppy Mediated Sign-In (dev — @adonisjs/mail ausente)');
+            ctx.logger.info({ email: data.email, code: data.code, messages: data.messages, ...(data.params ?? {}) }, 'authkit: código por e-mail (dev — @adonisjs/mail ausente)');
         }
     }
     catch (error) {
-        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar o código do Poppy Mediated Sign-In');
+        ctx.logger.error({ err: error, email: data.email, messages: data.messages }, 'authkit: falha ao enviar o e-mail com código');
     }
 }
 /**