@adonis-agora/authkit-server 1.0.0-rc.1 → 1.0.0-rc.2

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

@@ -31,10 +31,21 @@ function enabledProtocols(runtime) {
     const out = [];
     if (runtime.config.pact)
         out.push('pact');
-    if (runtime.config.poppy)
-        out.push('poppy');
+    out.push(...runtime.extensions.keys());
     return out;
 }
+/** O protocolo dono de um grant, pelo prefixo do id. */
+function protocolOfGrant(runtime, grantId) {
+    for (const [id, { extension }] of runtime.extensions) {
+        if (grantId.startsWith(extension.grantIdPrefix))
+            return id;
+    }
+    return 'pact';
+}
+/** Prefixo de id dos grants de um protocolo (`agrant_` = PACT). */
+function grantPrefixOf(runtime, protocol) {
+    return runtime.extensions.get(protocol)?.extension.grantIdPrefix ?? 'agrant_';
+}
 function isUrl(value, allowHttp) {
     if (typeof value !== 'string' || value.length > 2048)
         return false;
@@ -52,14 +63,14 @@ function isUrl(value, allowHttp) {
 async function agentName(runtime, protocol, identifier, fallback) {
     if (fallback)
         return fallback;
-    if (protocol === 'poppy' && runtime.poppy) {
-        return runtime.poppy.registry.displayName(identifier);
-    }
+    const extension = runtime.extensions.get(protocol);
+    if (extension)
+        return extension.runtime.displayName(identifier);
     const registration = await runtime.config.resolveAgent(identifier);
     return displayNameFor(registration ?? { issuer: identifier, jwksUri: '' });
 }
 /**
- * Endpoints JSON de personal agents (PACT e Poppy) do console admin React.
+ * Endpoints JSON de personal agents (PACT e `personalAgents.extensions`) do console admin React.
  *
  * GET    {prefix}/api/personal-agents                          → agentes (config + console + conectados)
  * GET    {prefix}/api/personal-agents/connections?clientId=&accountId=&protocol=&page=&size=
@@ -105,17 +116,20 @@ export default class ConsolePersonalAgentsController {
                 e.jwksUri = agent.jwksUri;
                 names.set(keyOf('pact', agent.issuer), agent.name ?? null);
             }
-            for (const [clientId, count] of await runtime.grants.countLiveGrantsByClient(now, 'pact')) {
+            for (const [clientId, count] of await runtime.grants.countLiveGrantsByClient(now, 'agrant_')) {
                 entry('pact', clientId).connections = count;
             }
         }
-        if (cfg.poppy) {
-            for (const id of cfg.poppy.clients.registeredList ?? [])
-                entry('poppy', id).config = 'allowed';
-            for (const id of cfg.poppy.clients.blockedList ?? [])
-                entry('poppy', id).config = 'blocked';
-            for (const [clientId, count] of await runtime.grants.countLiveGrantsByClient(now, 'poppy')) {
-                entry('poppy', clientId).connections = count;
+        const summaries = {};
+        for (const [protocol, { extension, runtime: ext }] of runtime.extensions) {
+            const summary = ext.consoleSummary();
+            summaries[protocol] = { label: extension.label, ...summary };
+            for (const id of summary.configured.allowed)
+                entry(protocol, id).config = 'allowed';
+            for (const id of summary.configured.blocked)
+                entry(protocol, id).config = 'blocked';
+            for (const [clientId, count] of await runtime.grants.countLiveGrantsByClient(now, extension.grantIdPrefix)) {
+                entry(protocol, clientId).connections = count;
             }
         }
         for (const row of await runtime.registry.list()) {
@@ -153,13 +167,17 @@ export default class ConsolePersonalAgentsController {
                         hostResolver: cfg.staticAgents === null,
                     }
                     : null,
-                poppy: cfg.poppy
-                    ? {
-                        requireRegistration: cfg.poppy.clients.requireRegistration,
-                        hostResolver: cfg.poppy.clients.registeredList === null || cfg.poppy.clients.blockedList === null,
-                        allowInsecureClientIds: cfg.poppy.allowInsecureClientIds,
-                    }
-                    : null,
+                ...Object.fromEntries(Object.entries(summaries).map(([protocol, summary]) => [
+                    protocol,
+                    {
+                        label: summary.label,
+                        requireRegistration: summary.requireRegistration,
+                        hostResolver: summary.hostResolver,
+                        allowHttpIdentifiers: summary.allowHttpIdentifiers,
+                        identifierLabel: summary.identifierLabel,
+                        identifierPlaceholder: summary.identifierPlaceholder ?? null,
+                    },
+                ])),
             },
             agents,
         };
@@ -172,11 +190,9 @@ export default class ConsolePersonalAgentsController {
         const qs = ctx.request.qs();
         const page = parseListPage(qs.page);
         const size = parseListSize(qs.size);
-        const protocol = qs.protocol === 'pact' || qs.protocol === 'poppy'
-            ? qs.protocol
-            : undefined;
+        const protocol = qs.protocol && enabledProtocols(runtime).includes(qs.protocol) ? qs.protocol : undefined;
         const filter = {
-            protocol,
+            idPrefix: protocol ? grantPrefixOf(runtime, protocol) : undefined,
             clientId: qs.clientId?.trim() || undefined,
             accountId: qs.accountId?.trim() || undefined,
         };
@@ -189,7 +205,7 @@ export default class ConsolePersonalAgentsController {
         const emails = new Map();
         const nameCache = new Map();
         const data = await Promise.all(rows.map(async (g) => {
-            const rowProtocol = g.id.startsWith('pgrant_') ? 'poppy' : 'pact';
+            const rowProtocol = protocolOfGrant(runtime, g.id);
             if (!emails.has(g.accountId)) {
                 const account = await store.findById(g.accountId).catch(() => null);
                 emails.set(g.accountId, account?.email ?? null);
@@ -248,17 +264,21 @@ export default class ConsolePersonalAgentsController {
         const invalid = (message) => ctx.response.unprocessableEntity(apiError('invalid_request', message));
         const protocol = body.protocol;
         if (!enabledProtocols(runtime).includes(protocol)) {
-            return invalid('`protocol` precisa ser um protocolo ligado (`pact` ou `poppy`).');
+            return invalid(`\`protocol\` precisa ser um protocolo ligado (${enabledProtocols(runtime)
+                .map((p) => `\`${p}\``)
+                .join(', ')}).`);
         }
         const status = body.status;
         if (status !== 'allowed' && status !== 'blocked') {
             return invalid('`status` precisa ser `allowed` ou `blocked`.');
         }
-        const allowHttp = protocol === 'poppy' && !!runtime.config.poppy?.allowInsecureClientIds;
+        const extension = runtime.extensions.get(protocol);
+        const summary = extension?.runtime.consoleSummary();
+        const allowHttp = !!summary?.allowHttpIdentifiers;
         const identifier = typeof body.identifier === 'string' ? body.identifier.trim() : '';
         if (!isUrl(identifier, allowHttp)) {
-            return invalid(protocol === 'poppy'
-                ? '`identifier` precisa ser o `client_id` do agente (URL HTTPS do documento de metadata).'
+            return invalid(summary
+                ? `\`identifier\` precisa ser uma URL ${allowHttp ? 'http(s)' : 'HTTPS'}: ${summary.identifierLabel}.`
                 : '`identifier` precisa ser o `iss` do agente (URL HTTPS).');
         }
         const name = typeof body.name === 'string' && body.name.trim() ? body.name.trim().slice(0, 200) : null;

package/build/src/host/admin_sessions_service.js

@@ -87,7 +87,7 @@ export class AdminSessionsService {
     /**
      * Revogação total também corta os personal agents: "sair de todas as sessões",
      * reset de senha, a ação do admin e a exclusão de conta não podem deixar um
-     * agente agindo na conta (delegações do PACT e refresh tokens do Poppy). Sem
+     * agente agindo na conta (delegações do PACT e conexões das extensions). Sem
      * `personalAgents` é no-op — e aí nem resolve o banco. Diferente do
      * `recordSubRevocation`, uma falha AQUI propaga: não há outra camada que corte
      * esses tokens.
@@ -142,11 +142,14 @@ export class AdminSessionsService {
             return [];
         return (await adapter.list()).filter((r) => grantIds.has(r.payload.grantId));
     }
-    /** Grants da conta, exceto os espelhos `pgrant_` de refresh tokens do Poppy. */
+    /**
+     * Grants da conta, exceto os espelhos dos grants das `personalAgents.extensions` (os access
+     * tokens de MCP que elas emitem pelo oidc-provider usam o id do grant delas) — aparecem e são
+     * revogados como personal agent, não como app OIDC.
+     */
     async #accountGrants(accountId) {
-        // Os grants `pgrant_` são o espelho de um refresh token do Poppy (Bearer de MCP) — aparecem e
-        // são revogados como personal agent, não como app OIDC.
-        return (await this.#listModelOfAccount('Grant', accountId)).filter((r) => !r.id.startsWith('pgrant_'));
+        const prefixes = (this.#oidc.config.personalAgents?.extensions ?? []).map((e) => e.grantIdPrefix);
+        return (await this.#listModelOfAccount('Grant', accountId)).filter((r) => !prefixes.some((prefix) => r.id.startsWith(prefix)));
     }
     /**
      * Conta TODAS as sessões ativas do IdP (todas as contas). 0 quando o adapter não

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

@@ -1,4 +1,5 @@
 import type { HttpContext } from '@adonisjs/core/http';
+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,10 +36,13 @@ 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 }`:

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/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');
     }
 }
 /**

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

@@ -560,11 +560,6 @@ export declare const DEFAULT_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
-    'mail.poppy_sign_in.subject': string;
-    'mail.poppy_sign_in.heading': string;
-    'mail.poppy_sign_in.intro': string;
-    'mail.poppy_sign_in.code_label': string;
-    'mail.poppy_sign_in.fallback': string;
     'mail.sudo_link.subject': string;
     'mail.sudo_link.heading': string;
     'mail.sudo_link.intro': string;
@@ -1318,11 +1313,6 @@ export declare const PT_BR_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
-    'mail.poppy_sign_in.subject': string;
-    'mail.poppy_sign_in.heading': string;
-    'mail.poppy_sign_in.intro': string;
-    'mail.poppy_sign_in.code_label': string;
-    'mail.poppy_sign_in.fallback': string;
     'mail.sudo_link.subject': string;
     'mail.sudo_link.heading': string;
     'mail.sudo_link.intro': string;
@@ -1547,11 +1537,10 @@ export declare const PT_BR_MESSAGES: {
  */
 export declare const BUILTIN_MESSAGES: Record<string, AuthMessages>;
 /**
- * Resolve o catálogo ativo. Começa do catálogo embutido do locale selecionado
- * (ou do default `en` quando o locale não é embutido), depois mescla os
- * overrides do host por cima. Sem config, retorna o default `en` intacto.
- * Chaves omitidas caem no default `en` (fallback de cobertura).
+ * Soma os catálogos de uma extension (`messages`) aos embutidos. Chamado quando o config resolve;
+ * os overrides do host (`i18n.messages`) continuam vencendo.
  */
+export declare function registerExtensionMessages(catalogs: Readonly<Record<string, Readonly<Record<string, string>>>>): void;
 export declare function resolveMessages(i18n?: I18nConfig): AuthMessages;
 /**
  * Retorna a string para `key` (cai na própria `key` quando ausente) com

package/build/src/host/i18n.js

@@ -603,12 +603,6 @@ export const DEFAULT_MESSAGES = {
     'mail.magic_link.code_subject': 'Your login code',
     'mail.magic_link.code_intro': 'Use the code below to sign in. It expires shortly and can be used once.',
     'mail.magic_link.code_only_label': 'Enter this code to sign in:',
-    // Código do Mediated Sign-In do Poppy: um personal agent pede para entrar na conta.
-    'mail.poppy_sign_in.subject': 'Your code to connect {agent}',
-    'mail.poppy_sign_in.heading': 'Connect {agent} to your account',
-    'mail.poppy_sign_in.intro': '{agent} asked to sign in to your account. If that was you, give it the code below. It expires in {minutes} minutes and works once.',
-    'mail.poppy_sign_in.code_label': 'Your code:',
-    'mail.poppy_sign_in.fallback': 'If you did not ask for this, ignore this email — nobody gets in without the code. Never share it with anyone else.',
     // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo). Copy DISTINTA da do magic link de
     // login de propósito: este link não autentica ninguém — quem o abre já está
     // logado e só reprova que é quem diz ser. Prometer "entre na sua conta" num
@@ -1447,12 +1441,6 @@ export const PT_BR_MESSAGES = {
     'mail.magic_link.code_subject': 'Seu código de login',
     'mail.magic_link.code_intro': 'Use o código abaixo para entrar. Ele expira em instantes e serve para um único acesso.',
     'mail.magic_link.code_only_label': 'Digite este código para entrar:',
-    // Código do Mediated Sign-In do Poppy — ver o comentário no catálogo `en`.
-    'mail.poppy_sign_in.subject': 'Seu código para conectar {agent}',
-    'mail.poppy_sign_in.heading': 'Conecte {agent} à sua conta',
-    'mail.poppy_sign_in.intro': '{agent} pediu para entrar na sua conta. Se foi você, informe o código abaixo. Ele expira em {minutes} minutos e serve uma única vez.',
-    'mail.poppy_sign_in.code_label': 'Seu código:',
-    'mail.poppy_sign_in.fallback': 'Se não foi você, ignore este e-mail — ninguém entra sem o código. Nunca o compartilhe com outra pessoa.',
     // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo) — ver o comentário no catálogo `en`.
     'mail.sudo_link.subject': 'Confirme que é você',
     'mail.sudo_link.heading': 'Confirme sua identidade',
@@ -1713,13 +1701,27 @@ export const BUILTIN_MESSAGES = {
  * overrides do host por cima. Sem config, retorna o default `en` intacto.
  * Chaves omitidas caem no default `en` (fallback de cobertura).
  */
+/** Catálogos das `personalAgents.extensions`, por locale (ver {@link registerExtensionMessages}). */
+const extensionMessages = {};
+/**
+ * Soma os catálogos de uma extension (`messages`) aos embutidos. Chamado quando o config resolve;
+ * os overrides do host (`i18n.messages`) continuam vencendo.
+ */
+export function registerExtensionMessages(catalogs) {
+    for (const [locale, messages] of Object.entries(catalogs)) {
+        extensionMessages[locale] = { ...(extensionMessages[locale] ?? {}), ...messages };
+    }
+}
 export function resolveMessages(i18n) {
     const locale = i18n?.locale ?? DEFAULT_LOCALE;
     // Base: sempre o default `en` para garantir cobertura total das chaves; o
-    // catálogo embutido do locale (ex.: pt-BR) é mesclado por cima.
+    // catálogo embutido do locale (ex.: pt-BR) é mesclado por cima. Os das extensions entram
+    // em cada camada, abaixo dos overrides do host.
     const base = {
         ...DEFAULT_MESSAGES,
+        ...(extensionMessages[DEFAULT_LOCALE] ?? {}),
         ...(BUILTIN_MESSAGES[locale] ?? {}),
+        ...(locale === DEFAULT_LOCALE ? {} : (extensionMessages[locale] ?? {})),
     };
     const overrides = i18n?.messages?.[locale];
     if (!overrides)

package/build/src/host/register_auth_host.js

@@ -12,7 +12,6 @@ import { getAuthHostConfig, markAuthHostAutoMounted, wasAuthHostAutoMounted, } f
 import { consoleDeniedPage } from './console_denied_page.js';
 import { CONSOLE_SSO_CALLBACK_PATH, CONSOLE_SSO_START_PATH } from './console_sso.js';
 import { endBridgedIdpSession, ensureConsoleSession } from './idp_session_bridge.js';
-import { POPPY_WEB_SESSION_KEY } from './poppy_session_key.js';
 import { createAuthThrottles } from './rate_limit.js';
 import { redirectExact } from './redirect_exact.js';
 import { requestPathWithQuery } from './request_url.js';
@@ -121,10 +120,21 @@ function buildLoginRedirect(ctx, extra) {
  * classe NÃO era aplicada em runtime num grupo, deixando /account/tokens e
  * /account/mfa acessíveis sem sessão.
  */
-/** A sessão é do navegador de um personal agent Poppy (§5)? */
-function isPoppyBrowser(ctx) {
-    const marker = ctx.session?.get?.(POPPY_WEB_SESSION_KEY);
-    return typeof marker === 'object' && marker !== null && typeof marker.sessionId === 'string';
+/**
+ * A sessão é do navegador de um personal agent (`isAgentBrowser` de uma extension)? Um hook que
+ * lança conta como "é": na dúvida, o console fica fechado.
+ */
+function isAgentBrowser(ctx) {
+    for (const extension of getAuthHostConfig()?.personalAgents?.extensions ?? []) {
+        try {
+            if (extension.isAgentBrowser?.(ctx))
+                return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
 }
 /**
  * `true` when the caller wants JSON (an `Accept` that prefers `application/json`,
@@ -149,9 +159,9 @@ function unauthenticated(ctx, redirectTo) {
     return redirectExact(ctx.response, redirectTo);
 }
 const accountGuard = async (ctx, next) => {
-    // O navegador de um personal agent Poppy (§5) não entra no console de conta nem
-    // nas telas de consentimento: a sessão é do agente, não do usuário.
-    if (isPoppyBrowser(ctx))
+    // O navegador de um personal agent não entra no console de conta nem nas telas de
+    // consentimento: a sessão é do agente, não do usuário.
+    if (isAgentBrowser(ctx))
         return ctx.response.status(403).send('');
     // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
     if (!(await ensureConsoleSession(ctx))) {
@@ -186,7 +196,7 @@ export const adminGuard = async (ctx, next) => {
     if (!cfg.admin.enabled) {
         return ctx.response.notFound();
     }
-    if (isPoppyBrowser(ctx))
+    if (isAgentBrowser(ctx))
         return ctx.response.status(403).send('');
     // Com `accountSession.acceptIdpSession`, a sessão do IdP também abre o console.
     await ensureConsoleSession(ctx);
@@ -289,8 +299,6 @@ const C = {
     accountConfirm: () => import('./controllers/account_confirm_controller.js'),
     agentOAuth: () => import('./controllers/agent_oauth_controller.js'),
     agentConsent: () => import('./controllers/agent_consent_controller.js'),
-    poppy: () => import('./controllers/poppy_controller.js'),
-    poppyConsent: () => import('./controllers/poppy_consent_controller.js'),
     webauthnAsset: () => import('./controllers/webauthn_asset_controller.js'),
     logoutAsset: () => import('./controllers/logout_asset_controller.js'),
     passkeyAutofillAsset: () => import('./controllers/passkey_autofill_asset_controller.js'),
@@ -671,56 +679,13 @@ export function registerAuthHost(router, opts = {}) {
         })
             .use([accountGuard]);
     }
-    // Personal Agent Protocol (Poppy): descoberta, authorization server (token,
-    // revogação, device authorization), Mediated Sign-In e sessão de navegador —
-    // server-to-server ou POST cross-site do navegador do agente (sem CSRF, ver
-    // `authkitCsrfExceptions`). As telas do usuário (authorize/device) exigem a
-    // sessão de conta e mantêm o CSRF.
-    const poppyPrefix = hostCfg?.personalAgents?.poppyPrefix;
-    if (poppyPrefix) {
-        // Nomes explícitos: o Router nomeia pela dupla controller.método, e as duas URLs da metadata
-        // (RFC 8414 na raiz e debaixo do issuer) usam o mesmo — "poppy.metadata already exists" no boot.
-        router.get('/.well-known/poppy.json', [C.poppy, 'discovery']).as('authkit.poppy.discovery');
-        router
-            .get('/.well-known/oauth-protected-resource', [C.poppy, 'protectedResource'])
-            .as('authkit.poppy.protected_resource');
-        router
-            .get(`/.well-known/oauth-authorization-server${poppyPrefix}`, [C.poppy, 'metadata'])
-            .as('authkit.poppy.metadata');
-        router
-            .get(`${poppyPrefix}/.well-known/oauth-authorization-server`, [C.poppy, 'metadata'])
-            .as('authkit.poppy.metadata_under_issuer');
-        router.post(`${poppyPrefix}/oauth/token`, [C.poppy, 'token']).as('authkit.poppy.token');
-        router.post(`${poppyPrefix}/oauth/revoke`, [C.poppy, 'revoke']).as('authkit.poppy.revoke');
-        router
-            .post(`${poppyPrefix}/oauth/device`, [C.poppy, 'deviceAuthorization'])
-            .as('authkit.poppy.device_authorization');
-        // A página grava um pedido sem autenticação: throttle por IP.
-        withLogin(router
-            .get(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSessionPage'])
-            .as('authkit.poppy.browser_session_page'));
-        router
-            .post(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSession'])
-            .as('authkit.poppy.browser_session');
-        router
-            .post(`${poppyPrefix}/browser-session/authorize`, [C.poppy, 'browserSessionAuthorize'])
-            .as('authkit.poppy.browser_session_authorize');
-        router
-            .group(() => {
-            router
-                .get(`${poppyPrefix}/oauth/authorize`, [C.poppyConsent, 'authorize'])
-                .as('authkit.poppy.authorize');
-            router
-                .post(`${poppyPrefix}/oauth/authorize`, [C.poppyConsent, 'decideAuthorization'])
-                .as('authkit.poppy.authorize_decide');
-            withOtpLogin(router
-                .get(`${poppyPrefix}/device`, [C.poppyConsent, 'device'])
-                .as('authkit.poppy.device'));
-            withOtpLogin(router
-                .post(`${poppyPrefix}/device`, [C.poppyConsent, 'decideDevice'])
-                .as('authkit.poppy.device_decide'));
-        })
-            .use([accountGuard]);
+    // `personalAgents.extensions`: cada uma monta as rotas dela, com o guard de conta e os
+    // buckets de rate limit das telas embutidas.
+    for (const extension of hostCfg?.personalAgents?.extensions ?? []) {
+        extension.routes?.(router, {
+            accountGuard,
+            throttle: { login: (route) => withLogin(route), otp: (route) => withOtpLogin(route) },
+        });
     }
     // Paths do console de conta (configuráveis/localizáveis via `accountRoutes`).
     // As TELAS vêm de `accountPath(key)` (prefixo + segmento configurável); os