@adonis-agora/authkit-server 0.74.0 → 0.76.0

package/build/src/host/i18n.js

@@ -97,6 +97,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 +188,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',
@@ -908,6 +935,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 +1026,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/impersonation_session.d.ts

@@ -61,6 +61,11 @@ export interface ImpersonationState {
      * do lado do IdP, NÃO impõe expiração na sessão (só `maxAge` faz isso).
      */
     exchangeExpiresIn?: number;
+    /**
+     * De onde veio a impersonation: `session` (console/web, keys de sessão) ou
+     * `bearer` (access token trocado com `act`, ex.: app nativo). Só quando `active`.
+     */
+    source?: 'session' | 'bearer';
 }
 /** Metadados aproveitados da resposta do token-exchange (só o que não é segredo). */
 export interface TokenExchangeResult {

package/build/src/host/impersonation_session.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { bearerAccountId, bearerImpersonation } from './bearer_account.js';
 /**
  * Ergonômico de SESSÃO de browser no RP para "personificar" (impersonate) um
  * usuário e navegar como ele — roteado pelo token-exchange RFC 8693 que o IdP já
@@ -304,11 +305,16 @@ export async function startImpersonation(ctx, params) {
  * false }` puro quando nunca houve impersonation.
  */
 export function impersonationState(ctx) {
-    const impersonatorId = ctx.session.get(IMPERSONATOR_SESSION_KEY);
-    if (!impersonatorId)
-        return { active: false };
+    const impersonatorId = ctx.session?.get(IMPERSONATOR_SESSION_KEY);
+    if (!impersonatorId) {
+        // Sessão de console logada manda (mesma regra do `getAccountId`): o bearer só
+        // conta quando a request não tem conta na sessão.
+        if (ctx.session?.get(ACCOUNT_SESSION_KEY))
+            return { active: false };
+        return bearerImpersonationState(ctx);
+    }
     const targetId = ctx.session.get(ACCOUNT_SESSION_KEY);
-    const state = { active: true, targetId, impersonatorId };
+    const state = { active: true, targetId, impersonatorId, source: 'session' };
     const impersonationId = ctx.session.get(IMPERSONATION_ID_SESSION_KEY);
     if (impersonationId)
         state.impersonationId = impersonationId;
@@ -329,6 +335,33 @@ export function impersonationState(ctx) {
     }
     return state;
 }
+/**
+ * Impersonation pelo ACCESS TOKEN (sem sessão): o `oidcBearerGuard` autenticou
+ * um token trocado que carrega `act`. O alvo é o `sub` do token; o impersonator,
+ * o `act.sub`; a expiração, o `exp` do token (o token trocado não tem refresh).
+ * Só existe depois que o guard bearer rodou na request, como o `getAccountId`.
+ */
+function bearerImpersonationState(ctx) {
+    const bearer = bearerImpersonation(ctx);
+    const targetId = bearerAccountId(ctx);
+    if (!bearer || !targetId)
+        return { active: false };
+    const state = {
+        active: true,
+        targetId,
+        impersonatorId: bearer.actorId,
+        actSub: bearer.actorId,
+        source: 'bearer',
+    };
+    if (bearer.jti)
+        state.impersonationId = bearer.jti;
+    if (bearer.exp !== null) {
+        state.expiresAt = bearer.exp * 1000;
+        if (Date.now() > state.expiresAt)
+            state.active = false;
+    }
+    return state;
+}
 /**
  * Encerra a impersonation: restaura `account_user_id = impersonator`, remove
  * TODAS as keys de sessão de impersonation (id, tempos, prova do exchange) e

package/build/src/host/oidc_bearer_guard.js

@@ -1,6 +1,6 @@
 import { RuntimeException } from '@adonisjs/core/exceptions';
 import { inProcessAccessTokenVerifier, remoteAccessTokenVerifier, } from './access_token_verifier.js';
-import { clearBearerAccountId, setBearerAccountId } from './bearer_account.js';
+import { clearBearerAccountId, setBearerAccountId, setBearerImpersonation, } from './bearer_account.js';
 import { cachedUnauthorizedAccessConstructor, loadUnauthorizedAccess, } from './oidc_rp_guard.js';
 /**
  * Driver do `E_UNAUTHORIZED_ACCESS` lançado pelo guard. `access_tokens` é o
@@ -144,10 +144,19 @@ export class OidcBearerGuard {
         const guardUser = await this.#userProvider.findById(token.sub);
         if (!guardUser)
             throw this.#fail('invalid_token');
+        // Token de impersonation: o ator (o admin) também tem que existir AGORA. Conta
+        // apagada/desativada depois da troca derruba o acesso na próxima request, sem
+        // esperar o `exp` do token.
+        if (token.actor && !(await this.#userProvider.findById(token.actor))) {
+            throw this.#fail('invalid_token');
+        }
         this.user = guardUser.getOriginal();
         this.accessToken = token;
         this.isAuthenticated = true;
         setBearerAccountId(this.#ctx, String(guardUser.getId()));
+        if (token.actor) {
+            setBearerImpersonation(this.#ctx, { actorId: token.actor, exp: token.exp, jti: token.jti });
+        }
         this.#emitter.emit('oidc_bearer:authentication_succeeded', {
             ctx: this.#ctx,
             guardName: this.#name,

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');
@@ -463,6 +475,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 +564,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 +678,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}`);
 }

package/build/src/mcp/mcp_oauth.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Login OAuth de clientes MCP (Claude Code, Claude, ChatGPT, VS Code, Cursor) — a autorização da
+ * spec do MCP: OAuth 2.1 com PKCE, registro dinâmico (RFC 7591), metadata do servidor de
+ * autorização (RFC 8414) e o token amarrado ao servidor MCP pelo `resource` (RFC 8707).
+ *
+ * `mcp: true` na config liga tudo de uma vez:
+ *   - o registro dinâmico ABERTO, restrito aos redirects dos clientes MCP conhecidos
+ *     ({@link MCP_CLIENT_REDIRECTS}) — loopback para os de linha de comando;
+ *   - o refresh token desses clientes: o registro pede `offline_access` e o authorize ganha
+ *     `prompt=consent` (OIDC Core §11), então a pessoa consente uma vez e o cliente não precisa
+ *     logar de novo a cada hora;
+ *   - os `resource` dos servidores MCP: os de `mcp.resources` e os REGISTRADOS em runtime
+ *     ({@link registerOAuthResource}) — é por aí que o MCP do `@adonis-agora/agent` se anuncia
+ *     sem o app listar a URL dele aqui.
+ *
+ * Os clientes registrados pelo `/reg` se distinguem pelo `client_id_issued_at`, que só o registro
+ * dinâmico grava: clients estáticos ou criados pelo console/CLI não mudam de comportamento.
+ */
+import type { RedirectUriPolicy, ResolvedRedirectUriPolicy } from '../provider/registration_policy.js';
+/** Callbacks dos clientes MCP conhecidos. Loopback (Claude Code, CLIs) já entra pela política. */
+export declare const MCP_CLIENT_REDIRECTS: Required<RedirectUriPolicy>;
+/** Escopos de um token de servidor MCP: identidade + refresh. */
+export declare const MCP_RESOURCE_SCOPES: string[];
+export interface McpOAuthConfigInput {
+    /**
+     * Redirects aceitos ALÉM dos clientes MCP conhecidos — ex.: o callback de um cliente próprio.
+     * Somados a {@link MCP_CLIENT_REDIRECTS}.
+     */
+    redirectUris?: RedirectUriPolicy;
+    /**
+     * URLs dos servidores MCP para os quais este IdP emite tokens, além dos que se registram em
+     * runtime ({@link registerOAuthResource}). Ex.: `['https://app.example.com/mcp']`.
+     */
+    resources?: string[];
+}
+export interface ResolvedMcpOAuthConfig {
+    enabled: boolean;
+    redirectUriPolicy: ResolvedRedirectUriPolicy;
+    resources: string[];
+}
+export declare function resolveMcpOAuth(input?: boolean | McpOAuthConfigInput): ResolvedMcpOAuthConfig;
+/**
+ * Um servidor protegido (RFC 9728) que aceita tokens deste IdP. `url` é o `resource` exato; sem
+ * ela, `path` casa com qualquer `resource` na origem do issuer (quem registra no boot nem sempre
+ * sabe a URL pública).
+ */
+export interface OAuthResourceRegistration {
+    url?: string;
+    path?: string;
+    /** Escopos do token para este resource. Default: {@link MCP_RESOURCE_SCOPES}. */
+    scopes?: string[];
+}
+export declare function registerOAuthResource(resource: OAuthResourceRegistration): void;
+export declare function registeredOAuthResources(): readonly OAuthResourceRegistration[];
+/**
+ * O resource MCP que `indicator` nomeia, ou `null`. Casa com `mcp.resources`, com uma URL
+ * registrada, ou com um `path` registrado na origem do issuer. Barra final tolerada.
+ */
+export declare function findMcpResource(indicator: string, issuer: string, config: ResolvedMcpOAuthConfig): {
+    audience: string;
+    scopes: string[];
+} | null;
+/**
+ * Registro de um cliente MCP: quem pede `refresh_token` ganha `openid offline_access` no escopo
+ * registrado, senão o provider recusaria pedi-los no authorize.
+ */
+export declare function mcpClientRegistration(metadata: Record<string, unknown>): Record<string, unknown>;
+/**
+ * `scope`/`prompt` do authorize de um cliente MCP para que saia um refresh token: `offline_access`
+ * no escopo e `consent` no prompt (sem ele o provider descarta o `offline_access`). `null` quando
+ * já estão lá. `prompt=none` pede "sem interação", o contrário de consentir: sai.
+ */
+export declare function withOfflineAccess(params: Record<string, unknown>): {
+    scope: string;
+    prompt: string;
+} | null;
+/**
+ * Middleware do provider (Koa) que aplica {@link withOfflineAccess} ao `GET /auth` de um client
+ * registrado dinamicamente que tem o grant `refresh_token`.
+ */
+export declare function mcpAuthorizeMiddleware(provider: {
+    Client: {
+        find(id: string): Promise<any>;
+    };
+}): (ctx: any, next: () => Promise<void>) => Promise<void>;