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

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

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.d.ts

@@ -20,6 +20,8 @@ export declare function wantsJson(ctx: any): boolean;
  *      (senão → `accountHome(cfg)`, default /account/security — NÃO revela a
  *      existência do /admin, e cai numa tela que o host controla via `accountHome`;
  *      se a tela default estiver desmontada, aponte `config.accountHome` para uma montada).
+ *   3. `config.admin.authorize` liberando (403/401/redirect conforme o resultado). Omitido:
+ *      aberto fora de produção, 403 em produção.
  * As roles permitidas são resolvidas em runtime do `authkit.server` (config lazy).
  */
 export declare const adminGuard: (ctx: any, next: () => Promise<void>) => Promise<any>;

package/build/src/host/register_auth_host.js

@@ -1,3 +1,5 @@
+import { getBootedApp } from '../../services/booted_app.js';
+import { resolveConsoleAuthorize, } from '../console_authorize.js';
 import { resolveRateLimit } from '../define_config.js';
 import { accountHome } from './account_home.js';
 import { getAccountLoginUrl, setAccountLoginUrl } from './account_login_url.js';
@@ -7,8 +9,9 @@ import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
 import { adminApiGuard } from './admin_api/admin_api_guard.js';
 import { normalizeAdminApiPrefix, normalizeAdminPrefix, setAdminApiPrefix, setAdminPrefix, } from './admin_prefix.js';
 import { getAuthHostConfig, markAuthHostAutoMounted, wasAuthHostAutoMounted, } from './auth_host_config.js';
-import { ensureConsoleSession } from './idp_session_bridge.js';
-import { POPPY_WEB_SESSION_KEY } from './poppy_session_key.js';
+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 { createAuthThrottles } from './rate_limit.js';
 import { redirectExact } from './redirect_exact.js';
 import { requestPathWithQuery } from './request_url.js';
@@ -67,7 +70,10 @@ async function checkAndRefreshIdle(ctx) {
         const lastSeen = ctx.session?.get(ACCOUNT_LAST_SEEN_KEY);
         const now = Date.now();
         if (lastSeen !== undefined && now - lastSeen > idleMs) {
-            // Idle excedido: encerra a sessão.
+            // Idle excedido: encerra a sessão. Console aberto pela sessão do IdP (SSO):
+            // encerra também essa sessão, senão a ponte reabriria o console no próximo
+            // request e o idle timeout não teria efeito.
+            await endBridgedIdpSession(ctx);
             ctx.session?.forget(ACCOUNT_SESSION_KEY);
             ctx.session?.forget(ACCOUNT_LAST_SEEN_KEY);
             return true;
@@ -114,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`,
@@ -142,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))) {
@@ -166,6 +183,8 @@ const accountGuard = async (ctx, next) => {
  *      (senão → `accountHome(cfg)`, default /account/security — NÃO revela a
  *      existência do /admin, e cai numa tela que o host controla via `accountHome`;
  *      se a tela default estiver desmontada, aponte `config.accountHome` para uma montada).
+ *   3. `config.admin.authorize` liberando (403/401/redirect conforme o resultado). Omitido:
+ *      aberto fora de produção, 403 em produção.
  * As roles permitidas são resolvidas em runtime do `authkit.server` (config lazy).
  */
 export const adminGuard = async (ctx, next) => {
@@ -177,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);
@@ -206,10 +225,63 @@ export const adminGuard = async (ctx, next) => {
                 .status(403)
                 .send({ error: { code: 'forbidden', message: 'Admin role required.' } });
         }
-        return ctx.response.redirect(accountHome(cfg));
+        return redirectExact(ctx.response, accountHome(cfg));
     }
+    // `admin.authorize`, after the roles: both must pass. Omitted, the console is open
+    // outside production and closed (403) in production.
+    const decision = cfg.admin.authorize
+        ? await adminAuthorizeChecker(cfg.admin.authorize)(ctx)
+        : appInProduction()
+            ? { allowed: false, status: 403 }
+            : { allowed: true };
+    if (!decision.allowed)
+        return consoleDenied(ctx, decision);
     return next();
 };
+/**
+ * Whether the app runs in production. Unknown (the provider did not register the
+ * app) counts as production, so an omitted `admin.authorize` fails closed.
+ */
+function appInProduction() {
+    try {
+        return getBootedApp().inProduction !== false;
+    }
+    catch {
+        return true;
+    }
+}
+/** The response for an `admin.authorize` denial: same rules in every `@adonis-agora` console. */
+function consoleDenied(ctx, decision) {
+    const json = wantsJson(ctx);
+    if (decision.redirectTo) {
+        if (json) {
+            return ctx.response
+                .status(401)
+                .send({ error: 'unauthenticated', redirectTo: decision.redirectTo });
+        }
+        return redirectExact(ctx.response, decision.redirectTo);
+    }
+    if (decision.status === 401) {
+        if (json)
+            return ctx.response.status(401).send({ error: 'unauthenticated' });
+        ctx.response.header('Content-Type', 'text/html; charset=utf-8');
+        return ctx.response.status(401).send(consoleDeniedPage(401));
+    }
+    if (json)
+        return ctx.response.status(403).send({ error: 'forbidden' });
+    ctx.response.header('Content-Type', 'text/html; charset=utf-8');
+    return ctx.response.status(403).send(consoleDeniedPage(403));
+}
+/** One checker per configured `admin.authorize`, so a lazy import runs once. */
+const adminAuthorizeCheckers = new WeakMap();
+function adminAuthorizeChecker(authorize) {
+    let checker = adminAuthorizeCheckers.get(authorize);
+    if (!checker) {
+        checker = resolveConsoleAuthorize(authorize);
+        adminAuthorizeCheckers.set(authorize, checker);
+    }
+    return checker;
+}
 const C = {
     oidc: () => import('../controllers/oidc_callback_controller.js'),
     authorizationServerMetadata: () => import('../controllers/authorization_server_metadata_controller.js'),
@@ -218,6 +290,7 @@ const C = {
     social: () => import('./controllers/social_controller.js'),
     patIntrospection: () => import('./controllers/pat_introspection_controller.js'),
     accountSession: () => import('./controllers/account_session_controller.js'),
+    consoleSso: () => import('./controllers/console_sso_controller.js'),
     accountTokens: () => import('./controllers/account_tokens_controller.js'),
     accountSecurity: () => import('./controllers/account_security_controller.js'),
     accountApps: () => import('./controllers/account_apps_controller.js'),
@@ -226,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'),
@@ -380,6 +451,17 @@ export function registerAuthHost(router, opts = {}) {
     if (accountLoginUrlOpt !== undefined) {
         setAccountLoginUrl(accountLoginUrlOpt);
     }
+    // Console sem porta de entrada: SSO desligado (`acceptIdpSession: false`) deixa só o
+    // login próprio do console, que é por senha; com a senha desligada ninguém entra em
+    // `/account/*` nem no console admin. Só passa com um `accountLoginUrl` do host (aqui
+    // ou em `routes.accountLoginUrl`) — por isso a checagem é no registro, não no config.
+    if (hostCfg?.consoleNeedsLoginUrl && !accountLoginUrlOpt) {
+        throw new Error('authkit: `accountSession.acceptIdpSession: false` com `authMethods: { password: false }` ' +
+            'deixa o console de conta e o console admin sem nenhum jeito de entrar (o login próprio ' +
+            'do console é por senha). Remova `acceptIdpSession: false` (o default entra pelo login ' +
+            'do IdP) ou passe `accountLoginUrl` (no `registerAuthHost` ou em `routes`) apontando ' +
+            'para um login do seu app.');
+    }
     // Montagem por tela do console de conta. `undefined` → tudo montado;
     // `false` → nada; objeto → cada flag ausente default `true`.
     const accountOpt = opts.account ?? routesCfg?.account;
@@ -506,6 +588,13 @@ export function registerAuthHost(router, opts = {}) {
     // Provider OIDC (wildcard + root) — o que registerOidcRoutes fazia.
     router.any(`${mount}/*`, [C.oidc]).as('authkit.oidc.wildcard');
     router.any(mount, [C.oidc]).as('authkit.oidc.root');
+    // Login do console pelo IdP (SSO; client interno `authkit-console`, ver
+    // `console_sso.ts`). Sempre montado: com `acceptIdpSession: false` o início só
+    // redireciona para o login próprio do console.
+    router.get(CONSOLE_SSO_START_PATH, [C.consoleSso, 'start']).as('authkit.console_sso.start');
+    router
+        .get(CONSOLE_SSO_CALLBACK_PATH, [C.consoleSso, 'callback'])
+        .as('authkit.console_sso.callback');
     // Interaction (login multi-step + consent + signup).
     // Cada rota passa por `keep(key, …)`: entra em `AuthHostRouteMap.routes`/`urls` e
     // recebe o `extraMiddleware` do host (depois do throttle da lib).
@@ -590,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