@adonis-agora/authkit-server 0.75.0 → 0.77.0

package/build/src/host/i18n.js

@@ -80,9 +80,11 @@ export const DEFAULT_MESSAGES = {
     'verify_email.invalid_title': 'Invalid link',
     'verify_email.invalid_body': 'The verification link is invalid or has already been used.',
     // Desafio de MFA no fluxo de login (mfa-challenge).
-    'mfa_challenge.page_title': 'Two-factor verification',
-    'mfa_challenge.title': 'Two-factor verification',
-    'mfa_challenge.intro': 'Open your authenticator app and enter the 6-digit code.',
+    'mfa_challenge.page_title': 'Multi-factor verification',
+    'mfa_challenge.title': 'Multi-factor verification',
+    'mfa_challenge.intro': 'Verify your identity using an available method.',
+    'mfa_challenge.start': 'Start verification',
+    'mfa_challenge.progress': '{completed} of {required} factors verified.',
     'mfa_challenge.code_label': 'Code',
     'mfa_challenge.submit': 'Verify',
     'mfa_challenge.recovery_summary': 'Use a recovery code',
@@ -97,6 +99,11 @@ export const DEFAULT_MESSAGES = {
     // raw na view). O nome vem do branding (config-trusted).
     'consent.body': 'The app <strong>{app}</strong> wants to access your account.',
     'consent.submit': 'Authorize',
+    'consent.scopes_title': 'It will be able to:',
+    'consent.scope.profile': 'See your name and photo',
+    'consent.scope.email': 'See your e-mail address',
+    'consent.scope.offline_access': 'Stay connected without asking you to sign in again',
+    'consent.scope.roles': 'See your roles and organization',
     // Console de conta — login (account/login).
     'account.login.page_title': 'My account',
     'account.login.title': 'My account',
@@ -183,6 +190,28 @@ export const DEFAULT_MESSAGES = {
     'account.apps.revoke': 'Revoke access',
     'account.apps.revoke_confirm': 'Revoke this app’s access? It will need to be authorized again and its tokens will stop working.',
     'account.apps.revoked': 'Access revoked.',
+    'account.apps.agents_title': 'Personal agents',
+    'account.apps.agents_intro': 'AI assistants you allowed to act on your account, and what each one can do.',
+    'account.apps.agents_empty': 'No personal agent can act on your account.',
+    'agents.consent.page_title': 'Authorize assistant',
+    'agents.consent.title': '{agent} wants to act on your account',
+    'agents.consent.body': 'The request came from {origin}. Choose what it can do — you can revoke access at any time.',
+    'agents.consent.signed_in_as': 'Signed in as {email}',
+    'agents.consent.scopes_label': 'Allow it to:',
+    'agents.consent.code': 'Request code: {code}. Make sure it matches the code your assistant shows.',
+    'agents.consent.allow': 'Allow',
+    'agents.consent.deny': 'Deny',
+    'agents.consent.enter_code_title': 'Connect an assistant',
+    'agents.consent.enter_code_body': 'Enter the code your assistant showed you.',
+    'agents.consent.continue': 'Continue',
+    'agents.consent.invalid_code': 'This code is invalid or expired. Ask your assistant for a new one.',
+    'agents.consent.impersonating': 'You cannot authorize an assistant while impersonating another account.',
+    'agents.done.approved_title': '{agent} can now:',
+    'agents.done.denied_title': 'Access denied',
+    'agents.done.return': 'You can close this page and return to your assistant.',
+    'agents.done.revoke_hint': 'To revoke this access later, go to the apps page of your account.',
+    'agents.done.expired_title': 'Request expired',
+    'agents.done.expired_body': 'This request is no longer valid. Ask your assistant to start again.',
     'account.apps.not_supported': 'The configured OIDC adapter does not support enumeration — listing apps is unavailable.',
     // Console de conta — organizations (account/orgs).
     'account.orgs.page_title': 'My Organizations',
@@ -893,9 +922,11 @@ export const PT_BR_MESSAGES = {
     'verify_email.invalid_title': 'Link inválido',
     'verify_email.invalid_body': 'O link de verificação é inválido ou já foi utilizado.',
     // Desafio de MFA no fluxo de login (mfa-challenge).
-    'mfa_challenge.page_title': 'Verificação em duas etapas',
-    'mfa_challenge.title': 'Verificação em duas etapas',
-    'mfa_challenge.intro': 'Abra seu app autenticador e informe o código de 6 dígitos.',
+    'mfa_challenge.page_title': 'Verificação multifator',
+    'mfa_challenge.title': 'Verificação multifator',
+    'mfa_challenge.intro': 'Verifique sua identidade usando um método disponível.',
+    'mfa_challenge.start': 'Iniciar verificação',
+    'mfa_challenge.progress': '{completed} de {required} fatores verificados.',
     'mfa_challenge.code_label': 'Código',
     'mfa_challenge.submit': 'Verificar',
     'mfa_challenge.recovery_summary': 'Usar um código de recuperação',
@@ -908,6 +939,11 @@ export const PT_BR_MESSAGES = {
     'consent.title': 'Autorizar acesso',
     'consent.body': 'O app <strong>{app}</strong> quer acessar sua conta.',
     'consent.submit': 'Autorizar',
+    'consent.scopes_title': 'Ele vai poder:',
+    'consent.scope.profile': 'Ver seu nome e foto',
+    'consent.scope.email': 'Ver seu e-mail',
+    'consent.scope.offline_access': 'Continuar conectado sem pedir que você entre de novo',
+    'consent.scope.roles': 'Ver seus papéis e sua organização',
     // Console de conta — login (account/login).
     'account.login.page_title': 'Minha conta',
     'account.login.title': 'Minha conta',
@@ -994,6 +1030,28 @@ export const PT_BR_MESSAGES = {
     'account.apps.revoke': 'Revogar acesso',
     'account.apps.revoke_confirm': 'Revogar o acesso deste app? Ele precisará ser autorizado novamente e seus tokens deixarão de funcionar.',
     'account.apps.revoked': 'Acesso revogado.',
+    'account.apps.agents_title': 'Assistentes pessoais',
+    'account.apps.agents_intro': 'Assistentes de IA que você autorizou a agir na sua conta, e o que cada um pode fazer.',
+    'account.apps.agents_empty': 'Nenhum assistente pessoal pode agir na sua conta.',
+    'agents.consent.page_title': 'Autorizar assistente',
+    'agents.consent.title': '{agent} quer agir na sua conta',
+    'agents.consent.body': 'O pedido veio de {origin}. Escolha o que ele pode fazer — você pode revogar o acesso quando quiser.',
+    'agents.consent.signed_in_as': 'Conectado como {email}',
+    'agents.consent.scopes_label': 'Permitir que ele:',
+    'agents.consent.code': 'Código do pedido: {code}. Confira se é o mesmo que o seu assistente mostra.',
+    'agents.consent.allow': 'Permitir',
+    'agents.consent.deny': 'Negar',
+    'agents.consent.enter_code_title': 'Conectar um assistente',
+    'agents.consent.enter_code_body': 'Digite o código que o seu assistente mostrou.',
+    'agents.consent.continue': 'Continuar',
+    'agents.consent.invalid_code': 'Este código é inválido ou expirou. Peça um novo ao seu assistente.',
+    'agents.consent.impersonating': 'Não é possível autorizar um assistente enquanto você personifica outra conta.',
+    'agents.done.approved_title': '{agent} agora pode:',
+    'agents.done.denied_title': 'Acesso negado',
+    'agents.done.return': 'Você pode fechar esta página e voltar ao seu assistente.',
+    'agents.done.revoke_hint': 'Para revogar este acesso depois, vá à página de apps da sua conta.',
+    'agents.done.expired_title': 'Pedido expirado',
+    'agents.done.expired_body': 'Este pedido não vale mais. Peça ao seu assistente para começar de novo.',
     'account.apps.not_supported': 'O adapter OIDC configurado não suporta enumeração — a listagem de apps fica indisponível.',
     // Console de conta — organizations (account/orgs).
     'account.orgs.page_title': 'Minhas Organizações',

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

@@ -27,7 +27,10 @@ import type { HttpContext } from '@adonisjs/core/http';
 /** Chave da sessão Adonis com o `uid` da sessão do IdP que originou o console. */
 export declare const ACCOUNT_IDP_SESSION_KEY = "authkit_idp_session_uid";
 /** O que interessa de uma sessão do oidc-provider (instância do model `Session`). */
-interface IdpSession {
+export interface IdpSession {
+    id: string;
+    transient?: boolean;
+    exp: number;
     uid: string;
     accountId?: string;
     destroy(): Promise<void>;
@@ -37,7 +40,7 @@ interface IdpSession {
  * provider faz: cookie `_session` assinado com as keys do provider, e o registro
  * no adapter, que já descarta expirados). `null` sem sessão logada.
  */
-export declare function readIdpSession(ctx: HttpContext, service: any): Promise<IdpSession | null>;
+export declare function readIdpSession(ctx: HttpContext, service: any, strict?: boolean): Promise<IdpSession | null>;
 /**
  * Garante a sessão do console, aceitando a sessão do IdP quando configurado.
  * Devolve `true` quando o request tem (ou passou a ter) sessão de console.
@@ -52,4 +55,3 @@ export declare function ensureConsoleSession(ctx: HttpContext): Promise<boolean>
  * própria ponte e o "Sair" não teria efeito. No-op fora da ponte.
  */
 export declare function endBridgedIdpSession(ctx: HttpContext): Promise<void>;
-export {};

package/build/src/host/idp_session_bridge.js

@@ -9,7 +9,7 @@ export const ACCOUNT_IDP_SESSION_KEY = 'authkit_idp_session_uid';
  * provider faz: cookie `_session` assinado com as keys do provider, e o registro
  * no adapter, que já descarta expirados). `null` sem sessão logada.
  */
-export async function readIdpSession(ctx, service) {
+export async function readIdpSession(ctx, service, strict = false) {
     const provider = service?.provider;
     if (!provider?.Session || typeof provider.createContext !== 'function')
         return null;
@@ -21,7 +21,9 @@ export async function readIdpSession(ctx, service) {
         const session = (await provider.Session.find(id));
         return session?.accountId ? session : null;
     }
-    catch {
+    catch (error) {
+        if (strict)
+            throw error;
         // Fail-safe: sem ponte (o guard segue para o login normal).
         return null;
     }
@@ -81,8 +83,8 @@ export async function ensureConsoleSession(ctx) {
     // o login do console faz.
     await ctx.session.regenerate();
     ctx.session.put(ACCOUNT_SESSION_KEY, account.id);
-    ctx.session.put(ACCOUNT_IDP_SESSION_KEY, idp.uid);
     await syncAdonisAuthLogin(ctx, cfg, account);
+    ctx.session.put(ACCOUNT_IDP_SESSION_KEY, idp.uid);
     return true;
 }
 /**

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

@@ -4,6 +4,7 @@ import type { SessionUserProviderContract } from '@adonisjs/auth/types/session';
 import type { HttpContext } from '@adonisjs/core/http';
 import type { ConfigProvider } from '@adonisjs/core/types';
 import type { EmitterLike } from '@adonisjs/core/types/events';
+import { type PersistentRpOptions } from './persistent_rp_session.js';
 type RealUser<UserProvider> = UserProvider extends SessionUserProviderContract<infer U> ? U : never;
 /**
  * Construtor do `E_UNAUTHORIZED_ACCESS` do `@adonisjs/auth` — a MESMA classe que
@@ -27,6 +28,8 @@ export declare function loadUnauthorizedAccess(guardFactoryName?: string): Promi
 export type OidcRpGuardOptions<UserProvider extends SessionUserProviderContract<unknown>> = {
     provider: UserProvider | ConfigProvider<UserProvider>;
     sessionKey?: string;
+    /** Same-host IdP: restore and renew remembered logins. Default: false. */
+    acceptIdpSession?: PersistentRpOptions['acceptIdpSession'];
 };
 export type OidcRpGuardEvents<User> = {
     'oidc_rp:login_succeeded': {
@@ -76,13 +79,14 @@ export type OidcRpGuardEvents<User> = {
  */
 export declare class OidcRpGuard<UserProvider extends SessionUserProviderContract<unknown>> implements GuardContract<RealUser<UserProvider>> {
     #private;
+    private persistent;
     [symbols.GUARD_KNOWN_EVENTS]: OidcRpGuardEvents<RealUser<UserProvider>>;
     driverName: 'oidc_rp';
     authenticationAttempted: boolean;
     isAuthenticated: boolean;
     isLoggedOut: boolean;
     user?: RealUser<UserProvider>;
-    constructor(name: string, ctx: HttpContext, sessionKey: string, emitter: EmitterLike<OidcRpGuardEvents<RealUser<UserProvider>>>, userProvider: UserProvider, unauthorized?: UnauthorizedAccessConstructor);
+    constructor(name: string, ctx: HttpContext, sessionKey: string, emitter: EmitterLike<OidcRpGuardEvents<RealUser<UserProvider>>>, userProvider: UserProvider, unauthorized?: UnauthorizedAccessConstructor, persistent?: PersistentRpOptions);
     getUserOrFail(): RealUser<UserProvider>;
     /**
      * Grava a identidade na sessão. Chamado pelo callback OIDC após validar o

package/build/src/host/oidc_rp_guard.js

@@ -1,5 +1,7 @@
 import { RuntimeException } from '@adonisjs/core/exceptions';
 import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { ACCOUNT_IDP_SESSION_KEY } from './idp_session_bridge.js';
+import { endRpSession, ensureRpSession, } from './persistent_rp_session.js';
 /** Memo do construtor entre instâncias — o `import()` só paga o custo uma vez. */
 let cachedUnauthorizedAccess;
 /** O construtor já resolvido por {@link loadUnauthorizedAccess}, se houver. */
@@ -52,6 +54,7 @@ export async function loadUnauthorizedAccess(guardFactoryName = 'oidcRpGuard') {
  * tudo funciona nativamente.
  */
 export class OidcRpGuard {
+    persistent;
     #name;
     #ctx;
     #sessionKey;
@@ -63,7 +66,8 @@ export class OidcRpGuard {
     isAuthenticated = false;
     isLoggedOut = false;
     user;
-    constructor(name, ctx, sessionKey, emitter, userProvider, unauthorized) {
+    constructor(name, ctx, sessionKey, emitter, userProvider, unauthorized, persistent = {}) {
+        this.persistent = persistent;
         this.#name = name;
         this.#ctx = ctx;
         this.#sessionKey = sessionKey;
@@ -96,6 +100,8 @@ export class OidcRpGuard {
      */
     async login(user) {
         const guardUser = await this.#userProvider.createUserForGuard(user);
+        if (this.persistent.acceptIdpSession)
+            this.#ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
         this.#ctx.session.put(this.#sessionKey, String(guardUser.getId()));
         this.user = user;
         this.isAuthenticated = true;
@@ -113,6 +119,8 @@ export class OidcRpGuard {
      */
     async logout() {
         const user = this.user ?? null;
+        if (this.persistent.acceptIdpSession)
+            await endRpSession(this.#ctx);
         this.#ctx.session.forget(this.#sessionKey);
         this.user = undefined;
         this.isAuthenticated = false;
@@ -129,6 +137,11 @@ export class OidcRpGuard {
         }
         this.authenticationAttempted = true;
         this.#unauthorized ??= await loadUnauthorizedAccess();
+        const acceptIdp = typeof this.persistent.acceptIdpSession === 'function'
+            ? this.persistent.acceptIdpSession(this.#ctx)
+            : this.persistent.acceptIdpSession;
+        if (acceptIdp)
+            await ensureRpSession(this.#ctx, this.#sessionKey);
         const userId = this.#ctx.session.get(this.#sessionKey);
         if (!userId) {
             this.#emitter.emit('oidc_rp:authentication_failed', {
@@ -197,7 +210,7 @@ export function oidcRpGuard(config) {
                 userProvider = config.provider;
             }
             return (ctx) => {
-                return new OidcRpGuard(name, ctx, sessionKey, emitter, userProvider, unauthorized);
+                return new OidcRpGuard(name, ctx, sessionKey, emitter, userProvider, unauthorized, { acceptIdpSession: config.acceptIdpSession });
             };
         },
     };

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

@@ -0,0 +1,8 @@
+import type { HttpContext } from '@adonisjs/core/http';
+export interface PersistentRpOptions {
+    acceptIdpSession?: boolean | ((ctx: HttpContext) => boolean);
+}
+/** Same-host RP restoration: the signed IdP cookie is the persistent credential. */
+export declare function ensureRpSession(ctx: HttpContext, sessionKey: string): Promise<void>;
+/** Logout must revoke the credential that could otherwise restore the RP. */
+export declare function endRpSession(ctx: HttpContext): Promise<void>;

package/build/src/host/persistent_rp_session.js

@@ -0,0 +1,74 @@
+import { ACCOUNT_IDP_SESSION_KEY, readIdpSession } from './idp_session_bridge.js';
+import { impersonationState } from './impersonation_session.js';
+import { assertAccountEnabled } from './login_attempt.js';
+/** Same-host RP restoration: the signed IdP cookie is the persistent credential. */
+export async function ensureRpSession(ctx, sessionKey) {
+    const service = await ctx.containerResolver.make('authkit.server');
+    // Provider interactions write to the raw Node response. Regenerating Adonis's
+    // session there migrates its data after headers are sent, leaving the browser
+    // with the old cookie and losing the pending RP state/PKCE verifier.
+    const path = ctx.request.url?.().split('?', 1)[0] ?? '';
+    const mount = service.mountPath || service.config.mountPath;
+    if (path.startsWith('/auth/interaction/') ||
+        (mount && mount !== '/' && (path === mount || path.startsWith(`${mount}/`))) ||
+        ctx.route?.name === 'authkit.oidc.root' ||
+        ctx.route?.name === 'authkit.oidc.wildcard')
+        return;
+    const current = ctx.session.get(sessionKey);
+    const linkedUid = ctx.session.get(ACCOUNT_IDP_SESSION_KEY);
+    const idp = await readIdpSession(ctx, service, true);
+    const realId = current ? (impersonationState(ctx).impersonatorId ?? current) : undefined;
+    if (current && linkedUid && (!idp || idp.uid !== linkedUid || idp.accountId !== realId)) {
+        ctx.session.clear();
+        return;
+    }
+    // An existing local login cannot silently become a different IdP account.
+    if (current && (!idp || idp.accountId !== realId || idp.transient))
+        return;
+    if (!idp?.accountId || idp.transient)
+        return;
+    const account = await service.config.accountStore.findById(idp.accountId);
+    if (!account ||
+        !(await assertAccountEnabled(service.config, account.id, {
+            email: account.email ?? '',
+            ip: ctx.request.ip(),
+        })).allowed) {
+        if (current)
+            ctx.session.clear();
+        return;
+    }
+    const adapter = service.provider.Session.adapter;
+    const ttl = service.sessionTtlHolder.rememberSec;
+    if (adapter.renewSession) {
+        if (!(await adapter.renewSession(idp.id, ttl))) {
+            if (linkedUid)
+                ctx.session.clear();
+            return;
+        }
+        const kctx = service.provider.createContext(ctx.request.request, ctx.response.response);
+        kctx.cookies.set(service.provider.cookieName('session'), idp.id, {
+            signed: true,
+            httpOnly: true,
+            sameSite: 'lax',
+            path: '/',
+            secure: kctx.secure,
+            maxAge: ttl * 1000,
+            overwrite: true,
+        });
+    }
+    // Custom adapters without atomic renewal restore until the existing IdP expiry.
+    if (!current) {
+        await ctx.session.regenerate();
+        ctx.session.put(sessionKey, account.id);
+    }
+    ctx.session.put(ACCOUNT_IDP_SESSION_KEY, idp.uid);
+}
+/** Logout must revoke the credential that could otherwise restore the RP. */
+export async function endRpSession(ctx) {
+    const service = await ctx.containerResolver.make('authkit.server');
+    const idp = await readIdpSession(ctx, service, true);
+    // The browser's signed IdP credential must be revoked even after its RP expired.
+    if (idp)
+        await idp.destroy();
+    ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Redireciona para `url` EXATAMENTE como a lib a montou.
+ *
+ * O starter do AdonisJS liga `redirect.forwardQueryString: true` no `config/app.ts`: todo
+ * `response.redirect(url)` passa a colar a query da request ATUAL no fim — e numa URL que já tem a
+ * dela, sai um destino quebrado (`/login?return_to=%2Fx%3Fa%3D1?a=1`). O argumento
+ * `forwardQueryString = false` do `redirect()` não desliga o que veio do config; só o
+ * `clearQs()` do builder desliga. Toda URL que a lib monta já carrega a query que precisa.
+ *
+ * Fora de uma Response do AdonisJS (dublês de teste), cai no `redirect(url)` de sempre.
+ */
+export declare function redirectExact(response: any, url: string): unknown;

package/build/src/host/redirect_exact.js

@@ -0,0 +1,17 @@
+/**
+ * Redireciona para `url` EXATAMENTE como a lib a montou.
+ *
+ * O starter do AdonisJS liga `redirect.forwardQueryString: true` no `config/app.ts`: todo
+ * `response.redirect(url)` passa a colar a query da request ATUAL no fim — e numa URL que já tem a
+ * dela, sai um destino quebrado (`/login?return_to=%2Fx%3Fa%3D1?a=1`). O argumento
+ * `forwardQueryString = false` do `redirect()` não desliga o que veio do config; só o
+ * `clearQs()` do builder desliga. Toda URL que a lib monta já carrega a query que precisa.
+ *
+ * Fora de uma Response do AdonisJS (dublês de teste), cai no `redirect(url)` de sempre.
+ */
+export function redirectExact(response, url) {
+    if (typeof response?.getStatus === 'function') {
+        return response.redirect().clearQs().toPath(url);
+    }
+    return response.redirect(url);
+}

package/build/src/host/register_auth_host.js

@@ -9,6 +9,8 @@ import { normalizeAdminApiPrefix, normalizeAdminPrefix, setAdminApiPrefix, setAd
 import { getAuthHostConfig, markAuthHostAutoMounted, wasAuthHostAutoMounted, } from './auth_host_config.js';
 import { ensureConsoleSession } from './idp_session_bridge.js';
 import { createAuthThrottles } from './rate_limit.js';
+import { redirectExact } from './redirect_exact.js';
+import { requestPathWithQuery } from './request_url.js';
 import { resolveRuntimeSettings } from './runtime_settings.js';
 import { resolveEffectiveSessionPolicy } from './runtime_toggles.js';
 import { magicLink as sudoMagicLink } from './sudo/methods/magic_link.js';
@@ -90,9 +92,7 @@ function buildLoginRedirect(ctx, extra) {
     // host que desmontou a tela de login (`account: { login: false }`) aponta para
     // a própria rota de login dele (ex.: `/login`). Ver `account_login_url.ts`.
     const loginUrl = getAccountLoginUrl();
-    const url = ctx.request?.url?.() ?? '';
-    const qs = ctx.request?.parsedUrl?.search ?? '';
-    const dest = qs ? `${url}${qs}` : url;
+    const dest = requestPathWithQuery(ctx.request);
     // Só inclui return_to quando há um caminho real (não vazio, não é o próprio login).
     if (dest && dest !== '/' && !dest.startsWith(loginUrl)) {
         const encoded = encodeURIComponent(dest);
@@ -116,12 +116,12 @@ function buildLoginRedirect(ctx, extra) {
 const accountGuard = async (ctx, next) => {
     // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
     if (!(await ensureConsoleSession(ctx))) {
-        return ctx.response.redirect(buildLoginRedirect(ctx));
+        return redirectExact(ctx.response, buildLoginRedirect(ctx));
     }
     // Idle timeout: encerra e redireciona com query param de motivo.
     const idleExpired = await checkAndRefreshIdle(ctx);
     if (idleExpired) {
-        return ctx.response.redirect(buildLoginRedirect(ctx, 'reason=idle'));
+        return redirectExact(ctx.response, buildLoginRedirect(ctx, 'reason=idle'));
     }
     return next();
 };
@@ -150,12 +150,12 @@ export const adminGuard = async (ctx, next) => {
     const accountId = ctx.session?.get(ACCOUNT_SESSION_KEY);
     if (!accountId) {
         // `/account/login` é sempre o login da conta — NÃO muda com o prefixo admin.
-        return ctx.response.redirect(buildLoginRedirect(ctx));
+        return redirectExact(ctx.response, buildLoginRedirect(ctx));
     }
     // Idle timeout: também protege o console admin.
     const idleExpired = await checkAndRefreshIdle(ctx);
     if (idleExpired) {
-        return ctx.response.redirect(buildLoginRedirect(ctx, 'reason=idle'));
+        return redirectExact(ctx.response, buildLoginRedirect(ctx, 'reason=idle'));
     }
     const allowed = cfg.admin.roles;
     const account = await cfg.accountStore.findById(accountId);
@@ -173,6 +173,7 @@ export const adminGuard = async (ctx, next) => {
 };
 const C = {
     oidc: () => import('../controllers/oidc_callback_controller.js'),
+    authorizationServerMetadata: () => import('../controllers/authorization_server_metadata_controller.js'),
     interaction: () => import('./controllers/interaction_controller.js'),
     registration: () => import('./controllers/registration_controller.js'),
     social: () => import('./controllers/social_controller.js'),
@@ -184,6 +185,8 @@ const C = {
     accountMfa: () => import('./controllers/account_mfa_controller.js'),
     accountOrgs: () => import('./controllers/account_orgs_controller.js'),
     accountConfirm: () => import('./controllers/account_confirm_controller.js'),
+    agentOAuth: () => import('./controllers/agent_oauth_controller.js'),
+    agentConsent: () => import('./controllers/agent_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'),
@@ -421,6 +424,15 @@ export function registerAuthHost(router, opts = {}) {
         .get('/authkit/assets/webauthn_confirm.js', [C.webauthnConfirmAsset])
         .as('authkit.assets.webauthnConfirm');
     router.get('/authkit/assets/submit_lock.js', [C.submitLockAsset]).as('authkit.assets.submitLock');
+    // Metadata do servidor de autorização no caminho da RFC 8414 §3.1 (issuer com path: os
+    // clientes MCP procuram `/.well-known/oauth-authorization-server/oidc` antes do OIDC Discovery).
+    // O issuer termina no mountPath, então o mount É o path do issuer.
+    const issuerPath = mount.replace(/\/+$/, '');
+    if (issuerPath !== '') {
+        router
+            .get(`/.well-known/oauth-authorization-server${issuerPath}`, [C.authorizationServerMetadata])
+            .as('authkit.oauth_authorization_server');
+    }
     // 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');
@@ -429,6 +441,18 @@ export function registerAuthHost(router, opts = {}) {
     router.post('/auth/interaction/:uid/identifier', [C.interaction, 'identifier']);
     withLogin(router.post('/auth/interaction/:uid/login', [C.interaction, 'login']));
     withLogin(router.post('/auth/interaction/:uid/mfa', [C.interaction, 'mfaVerify']));
+    const customMfaBeginRoute = router.post('/auth/interaction/:uid/mfa/custom/:method/begin', [
+        C.interaction,
+        'customMfaBegin',
+    ]);
+    withLogin(customMfaBeginRoute);
+    customMfaBeginRoute.as('authkit.mfa.custom.begin');
+    const customMfaVerifyRoute = router.post('/auth/interaction/:uid/mfa/custom/:method/verify', [
+        C.interaction,
+        'customMfaVerify',
+    ]);
+    withLogin(customMfaVerifyRoute);
+    customMfaVerifyRoute.as('authkit.mfa.custom.verify');
     // Troca de senha obrigatória quando a senha expirou (password expiration gate).
     withLogin(router.post('/auth/interaction/:uid/password-expired', [
         C.interaction,
@@ -463,6 +487,27 @@ export function registerAuthHost(router, opts = {}) {
     }
     // PAT introspection (server-to-server).
     withIntrospection(router.post('/authkit/pat/introspect', [C.patIntrospection, 'handle']));
+    // Personal agents (PACT §5): authorization server de delegação. Os endpoints
+    // OAuth são server-to-server (o agente se autentica pelo JWT dele, sem
+    // sessão); a tela de consentimento exige a sessão de conta — sem ela o
+    // `accountGuard` manda para o login com `return_to`, e o usuário volta com o
+    // `user_code`. Montado só quando `personalAgents` está no config.
+    const agentsPrefix = hostCfg?.personalAgents?.prefix;
+    if (agentsPrefix) {
+        const oauth = `${agentsPrefix}/oauth`;
+        router.get(`${oauth}/.well-known/oauth-authorization-server`, [C.agentOAuth, 'metadata']);
+        router.get(`${oauth}/jwks.json`, [C.agentOAuth, 'jwks']);
+        router.post(`${oauth}/device_authorization`, [C.agentOAuth, 'deviceAuthorization']);
+        router.post(`${oauth}/token`, [C.agentOAuth, 'token']);
+        // Throttle de código (bucket do OTP, por IP): o `user_code` tem 8 letras e
+        // a RFC 8628 §5.1 conta com rate limit para não ser adivinhável.
+        router
+            .group(() => {
+            withOtpLogin(router.get(`${agentsPrefix}/consent`, [C.agentConsent, 'show']));
+            withOtpLogin(router.post(`${agentsPrefix}/consent`, [C.agentConsent, 'decide']));
+        })
+            .use([accountGuard]);
+    }
     // Paths do console de conta (configuráveis/localizáveis via `accountRoutes`).
     // As TELAS vêm de `accountPath(key)` (prefixo + segmento configurável); os
     // action-subpaths concatenados (`/password`, `/enroll`, ...) são FIXOS —
@@ -531,6 +576,9 @@ export function registerAuthHost(router, opts = {}) {
         if (mountApps) {
             router.get(appsPath, [C.accountApps, 'index']);
             router.post(`${appsPath}/:clientId/revoke`, [C.accountApps, 'revoke']);
+            if (agentsPrefix) {
+                router.post(`${appsPath}/agents/:grantId/revoke`, [C.accountApps, 'revokeAgent']);
+            }
         }
         // MFA — TOTP + passkeys (tela `mfa`).
         if (mountMfa) {
@@ -642,6 +690,11 @@ export function registerAuthHost(router, opts = {}) {
         // Apps (grants).
         router.get(`${apiBase}/apps`, [C.accountApi, 'listApps']);
         router.delete(`${apiBase}/apps/:clientId`, [C.accountApi, 'revokeApp']);
+        // Personal agents com delegação (PACT).
+        if (agentsPrefix) {
+            router.get(`${apiBase}/agents`, [C.accountApi, 'listAgents']);
+            router.delete(`${apiBase}/agents/:id`, [C.accountApi, 'revokeAgent']);
+        }
         // MFA + passkeys.
         router.get(`${apiBase}/mfa`, [C.accountApi, 'mfaStatus']);
         // Login methods preference (self-service, por usuário).

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

@@ -0,0 +1,10 @@
+/**
+ * Path + query string da request atual, para montar um `return_to`.
+ *
+ * `request.url(true)` é a API do AdonisJS que inclui a query. O código antigo lia
+ * `request.parsedUrl.search`, que o AdonisJS 7 não tem mais (o `parsedUrl` virou
+ * `{ pathname, query }`) — todo redirect para o login perdia a query em silêncio,
+ * e o usuário voltava para a página sem os parâmetros (um `user_code`, uma
+ * paginação). O `search` fica como fallback para hosts/dublês que ainda o expõem.
+ */
+export declare function requestPathWithQuery(request: any): string;

package/build/src/host/request_url.js

@@ -0,0 +1,17 @@
+/**
+ * Path + query string da request atual, para montar um `return_to`.
+ *
+ * `request.url(true)` é a API do AdonisJS que inclui a query. O código antigo lia
+ * `request.parsedUrl.search`, que o AdonisJS 7 não tem mais (o `parsedUrl` virou
+ * `{ pathname, query }`) — todo redirect para o login perdia a query em silêncio,
+ * e o usuário voltava para a página sem os parâmetros (um `user_code`, uma
+ * paginação). O `search` fica como fallback para hosts/dublês que ainda o expõem.
+ */
+export function requestPathWithQuery(request) {
+    const withQuery = request?.url?.(true) ?? '';
+    if (withQuery.includes('?'))
+        return withQuery;
+    const parsed = request?.parsedUrl;
+    const legacy = parsed?.search ?? (parsed?.query ? `?${parsed.query}` : '');
+    return `${withQuery}${legacy}`;
+}

package/build/src/host/sudo/methods/magic_link.js

@@ -2,6 +2,7 @@ import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { accountPath } from '../../account_paths.js';
 import { sendSudoLinkEmail } from '../../default_mailer.js';
 import { translate } from '../../i18n.js';
+import { redirectExact } from '../../redirect_exact.js';
 import { isSudoMethodEnabled } from '../runtime.js';
 /** Token de sudo pendente, guardado na sessão que o pediu. */
 export const SUDO_LINK_SESSION_KEY = 'authkit_sudo_link';
@@ -170,7 +171,7 @@ export function magicLink() {
                 // `translate(...)` em `confirmError`, e a tela leria dois formatos
                 // diferentes se este aqui mandasse a chave.
                 ctx.session.flash('confirmNotice', translate(c.cfg.messages, 'account.confirm.magic_link_sent'));
-                return ctx.response.redirect(`${accountPath('confirm')}${qs}`);
+                return redirectExact(ctx.response, `${accountPath('confirm')}${qs}`);
             });
             router.get(`${accountPath('confirm')}/magic-link/:token`, async (ctx) => {
                 const c = await h.contextFrom(ctx);

package/build/src/host/sudo/runtime.js

@@ -3,6 +3,7 @@ import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { validateReturnTo } from '../controllers/account_session_controller.js';
 import { translate } from '../i18n.js';
+import { redirectExact } from '../redirect_exact.js';
 import { markSudo } from '../sudo_mode.js';
 /** Último método usado com sucesso — só ordena a tela, não restringe nada. */
 export const LAST_METHOD_SESSION_KEY = 'authkit_sudo_last_method';
@@ -362,7 +363,7 @@ export async function completeSudo(c, methodId) {
         ip: c.ctx.request.ip?.() ?? null,
         metadata: { method: methodId },
     });
-    return c.ctx.response.redirect(c.returnTo ?? accountHome(c.cfg));
+    return redirectExact(c.ctx.response, c.returnTo ?? accountHome(c.cfg));
 }
 /**
  * Falha de confirmação: flash + volta pro /account/confirm preservando o
@@ -372,7 +373,7 @@ export async function completeSudo(c, methodId) {
 export async function fail(c, messageKey) {
     c.ctx.session.flash('confirmError', translate(c.cfg.messages, messageKey));
     const qs = c.returnTo ? `?return_to=${encodeURIComponent(c.returnTo)}` : '';
-    return c.ctx.response.redirect(`${accountPath('confirm')}${qs}`);
+    return redirectExact(c.ctx.response, `${accountPath('confirm')}${qs}`);
 }
 /**
  * Filtra os métodos disponíveis para esta conta e promove o último usado.

package/build/src/host/sudo_mode.js

@@ -15,6 +15,8 @@
  */
 import { accountPath } from './account_paths.js';
 import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { redirectExact } from './redirect_exact.js';
+import { requestPathWithQuery } from './request_url.js';
 import { SETTING_KEYS } from './runtime_toggles.js';
 export const SUDO_MODE_DEFAULTS = {
     enabled: true,
@@ -235,11 +237,9 @@ export async function requireSudo(ctx, settings) {
     if (await isSudoSatisfied(ctx, settings))
         return true;
     // Fora da graça: redireciona para confirmação.
-    const rawUrl = ctx.request.url?.() ?? '';
-    const qs = ctx.request.parsedUrl?.search ?? '';
-    const dest = qs ? `${rawUrl}${qs}` : rawUrl;
+    const dest = requestPathWithQuery(ctx.request);
     const returnTo = dest && dest !== '/' && !dest.startsWith(accountPath('confirm'))
         ? `?return_to=${encodeURIComponent(dest)}`
         : '';
-    return ctx.response.redirect(`${accountPath('confirm')}${returnTo}`);
+    return redirectExact(ctx.response, `${accountPath('confirm')}${returnTo}`);
 }