@adonis-agora/authkit-server 0.85.1 → 0.87.0

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

@@ -1,5 +1,5 @@
 import { PoppyError } from '../../agents/poppy/errors.js';
-import { publicRequestUrl, writePoppyAuthError } from '../../agents/poppy/resource.js';
+import { publicRequestUrl, writePoppyAuthError, } from '../../agents/poppy/resource.js';
 import { loginPoppyBrowser } from '../../agents/poppy/web_session.js';
 import { personalAgentsFor } from '../../agents/runtime.js';
 function noStore(ctx) {
@@ -15,6 +15,9 @@ function oauthError(ctx, error) {
     noStore(ctx);
     for (const [k, v] of Object.entries(error.headers))
         ctx.response.header(k, v);
+    // Limite de taxa: 429 com `Retry-After`, sem corpo próprio (§5.6).
+    if (error.status === 429)
+        return ctx.response.status(429).send('');
     if (error.code === 'invalid_dpop_proof' || error.code === 'use_dpop_nonce') {
         ctx.response.header('WWW-Authenticate', `DPoP error="${error.code}"`);
     }
@@ -31,25 +34,43 @@ function form(ctx) {
     return ctx.request.all();
 }
 /**
- * Endpoints server-to-server do Poppy (§3, §4): descoberta, metadata RFC 8414,
- * token, revogação, device authorization, Mediated Sign-In e a sessão de
- * navegador (§5). Todos isentos de CSRF — ver `authkitCsrfExceptions`.
+ * Endpoints do Poppy (§3, §4, §6): descoberta, protected resource metadata, metadata RFC 8414,
+ * token, revogação, device authorization e a entrada do navegador na Session. Os POSTs são isentos
+ * de CSRF — ver `authkitCsrfExceptions`.
  */
 export default class PoppyController {
-    /** `GET /.well-known/poppy.json` — só no domínio da empresa (ignorando `www.`). */
+    /** `GET /.well-known/poppy.json` — só no domínio da empresa; `www.` redireciona para ele. */
     async discovery(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy)
             return;
         // `host()` mantém a porta (dev em `localhost:3333`): o `browser_session_endpoint` sai dele.
-        const doc = poppy.discoveryDocument(ctx.request.host() ?? ctx.request.hostname() ?? '');
+        const host = ctx.request.host() ?? ctx.request.hostname() ?? '';
+        const redirect = poppy.discoveryRedirect(host);
+        if (redirect) {
+            ctx.response.header('Location', redirect);
+            return ctx.response.status(308).send('');
+        }
+        const doc = poppy.discoveryDocument(host);
         if (!doc)
             return ctx.response.notFound();
         ctx.response.header('Access-Control-Allow-Origin', '*');
         ctx.response.header('Cache-Control', 'public, max-age=300');
         return ctx.response.json(doc);
     }
-    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `poppy_domains`). */
+    /** `GET /.well-known/oauth-protected-resource` do domínio (§3.2, RFC 9728). */
+    async protectedResource(ctx) {
+        const poppy = await poppyOr404(ctx);
+        if (!poppy)
+            return;
+        const doc = poppy.protectedResourceMetadata(ctx.request.host() ?? ctx.request.hostname() ?? '');
+        if (!doc)
+            return ctx.response.notFound();
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        ctx.response.header('Cache-Control', 'public, max-age=300');
+        return ctx.response.json(doc);
+    }
+    /** `GET /.well-known/oauth-authorization-server{prefix}` (RFC 8414 + `protected_resources`). */
     async metadata(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy)
@@ -64,7 +85,7 @@ export default class PoppyController {
             return;
         withNonce(ctx, poppy);
         try {
-            const body = await poppy.token(form(ctx), ctx.request.header('dpop'));
+            const body = await poppy.token(form(ctx), ctx.request.header('dpop'), ctx);
             noStore(ctx);
             return ctx.response.json(body);
         }
@@ -105,89 +126,93 @@ export default class PoppyController {
             throw error;
         }
     }
-    /** `POST auth.mediated.endpoint` (§4.7) — com o Session Token (DPoP). */
-    async mediatedStart(ctx) {
+    /**
+     * `GET web.browser_session_endpoint` (§6, passo 1): a página com o código de uso único e o cookie
+     * que o prende a este navegador. Não mexe em Session nem nos outros cookies.
+     */
+    async browserSessionPage(ctx) {
         const poppy = await poppyOr404(ctx);
-        if (!poppy?.cfg.signIn.mediated)
+        if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        const auth = await poppy.verifyAccess({
-            method: ctx.request.method(),
-            url: publicRequestUrl(ctx, poppy),
-            headers: ctx.request.headers(),
-        });
-        if (!auth.ok) {
-            const { ok: _ok, ...rest } = auth;
-            return writePoppyAuthError(ctx, { ok: false, ...rest });
-        }
-        try {
-            const body = await poppy.mediatedStart(auth.principal, auth.jkt, ctx.request.body(), ctx);
-            noStore(ctx);
-            return ctx.response.json(body);
-        }
-        catch (error) {
-            if (error instanceof PoppyError)
-                return oauthError(ctx, error);
-            throw error;
-        }
+        const { code, cookie, maxAge } = await poppy.startBrowserJoin();
+        const name = joinCookieName(poppy);
+        ctx.response.append('Set-Cookie', `${name}=${cookie}; Path=/; Max-Age=${maxAge}; ${cookieSecure(poppy)}HttpOnly; SameSite=Strict`);
+        browserHeaders(ctx);
+        // `code` só tem caracteres base64url; o `action` é o path do próprio endpoint.
+        const action = new URL(poppy.urls.browserSession).pathname;
+        return ctx.response
+            .status(200)
+            .send(`<!doctype html><html><head><meta charset="utf-8"><title>Connecting</title></head><body><form method="post" action="${action}"><input type="hidden" name="code" value="${code}"><button>Continue</button></form></body></html>`);
     }
-    /** `POST {mediated}/{sign_in_id}` (§4.7). */
-    async mediatedCode(ctx) {
+    /**
+     * `POST {browser_session_endpoint}/authorize` (§6, passo 2): o agente autoriza o código, com o
+     * header da Session e, se logado, o access token. 204; código inválido → 400 `invalid_request`.
+     */
+    async browserSessionAuthorize(ctx) {
         const poppy = await poppyOr404(ctx);
-        if (!poppy?.cfg.signIn.mediated)
+        if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        const auth = await poppy.verifyAccess({
-            method: ctx.request.method(),
-            url: publicRequestUrl(ctx, poppy),
-            headers: ctx.request.headers(),
-        });
-        if (!auth.ok) {
-            const { ok: _ok, ...rest } = auth;
-            return writePoppyAuthError(ctx, { ok: false, ...rest });
-        }
+        noStore(ctx);
         try {
-            const body = await poppy.mediatedCode(auth.principal, auth.jkt, String(ctx.request.param('id') ?? ''), ctx.request.body());
-            noStore(ctx);
-            if (!body) {
-                return ctx.response
-                    .status(404)
-                    .json({ error: 'invalid_request', error_description: 'Unknown sign_in_id' });
-            }
-            return ctx.response.json(body);
+            const result = await poppy.authorizeBrowserJoin({
+                method: ctx.request.method(),
+                url: publicRequestUrl(ctx, poppy),
+                headers: ctx.request.headers(),
+            }, ctx.request.body()?.code);
+            if (!result.ok)
+                return writePoppyAuthError(ctx, result);
+            return ctx.response.status(204).send('');
         }
         catch (error) {
-            if (error instanceof PoppyError)
-                return oauthError(ctx, error);
+            if (error instanceof PoppyError) {
+                return ctx.response.status(400).json({ error: 'invalid_request' });
+            }
             throw error;
         }
     }
     /**
-     * `POST web.browser_session_endpoint` (§5): asserção no corpo → cookie do app
-     * para a Session e 303 para `return_to`; qualquer falha → 400, sem cookie.
+     * `POST web.browser_session_endpoint` (§6, passo 3): o navegador submete o código → cookie do app
+     * para a Session, limpa o cookie do passo 1 e redireciona para o site; falha → página de erro.
      */
     async browserSession(ctx) {
         const poppy = await poppyOr404(ctx);
         if (!poppy?.cfg.web?.browserSession)
             return poppy ? ctx.response.notFound() : undefined;
-        noStore(ctx);
-        // A asserção vai NO CORPO, nunca na URL (§5).
-        if (ctx.request.qs().assertion !== undefined)
+        browserHeaders(ctx);
+        const name = joinCookieName(poppy);
+        const result = await poppy.completeBrowserJoin(ctx.request.input('code'), readCookie(ctx.request.header('cookie'), name));
+        if (!result)
             return badBrowserRequest(ctx);
-        let result;
-        try {
-            result = await poppy.verifyBrowserAssertion(ctx.request.input('assertion'), new URL(publicRequestUrl(ctx, poppy)).origin);
-        }
-        catch (error) {
-            if (error instanceof PoppyError)
-                return badBrowserRequest(ctx);
-            throw error;
-        }
         await loginPoppyBrowser(ctx, result);
-        ctx.response.header('Location', result.returnTo);
+        ctx.response.append('Set-Cookie', `${name}=; Path=/; Max-Age=0; ${cookieSecure(poppy)}HttpOnly; SameSite=Strict`);
+        ctx.response.header('Location', poppy.cfg.web.redirectTo);
         return ctx.response.status(303).send('');
     }
 }
-function badBrowserRequest(ctx) {
+/** `__Host-` exige `Secure`; em dev com o issuer em http o cookie sai sem os dois. */
+function joinCookieName(poppy) {
+    return new URL(poppy.urls.origin).protocol === 'https:' ? '__Host-poppy_join' : 'poppy_join';
+}
+function cookieSecure(poppy) {
+    return new URL(poppy.urls.origin).protocol === 'https:' ? 'Secure; ' : '';
+}
+function readCookie(header, name) {
+    for (const part of (header ?? '').split(';')) {
+        const eq = part.indexOf('=');
+        if (eq > 0 && part.slice(0, eq).trim() === name)
+            return part.slice(eq + 1).trim();
+    }
+    return undefined;
+}
+/** Sem cache, sem moldura e sem referência da página que abriu (§6, passo 1). */
+function browserHeaders(ctx) {
+    noStore(ctx);
     ctx.response.header('Content-Type', 'text/html; charset=utf-8');
+    ctx.response.header('Content-Security-Policy', "frame-ancestors 'none'");
+    ctx.response.header('Cross-Origin-Opener-Policy', 'same-origin');
+    ctx.response.header('Referrer-Policy', 'no-referrer');
+}
+function badBrowserRequest(ctx) {
     return ctx.response
         .status(400)
         .send('<!doctype html><html><head><meta charset="utf-8"><title>Bad request</title></head><body><h1>Invalid browser session request</h1></body></html>');

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

@@ -11,10 +11,8 @@ export interface AuthkitCsrfOptions {
      */
     personalAgentsPrefix?: string | false;
     /**
-     * Prefixo do Poppy: isenta token/revoke/device authorization, o Mediated
-     * Sign-In e a sessão de navegador (POST cross-site autenticado pela asserção).
-     * Default: o do config. As telas `{prefix}/oauth/authorize` e `{prefix}/device`
-     * continuam protegidas. `false` desliga.
+     * 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).
      */
     poppyPrefix?: string | false;
 }

package/build/src/host/csrf.js

@@ -44,9 +44,8 @@ export function authkitCsrfExceptions(url, options = {}) {
         (path === `${poppyPrefix}/oauth/token` ||
             path === `${poppyPrefix}/oauth/revoke` ||
             path === `${poppyPrefix}/oauth/device` ||
-            path === `${poppyPrefix}/sign-in` ||
-            path.startsWith(`${poppyPrefix}/sign-in/`) ||
-            path === `${poppyPrefix}/browser-session`);
+            path === `${poppyPrefix}/browser-session` ||
+            path === `${poppyPrefix}/browser-session/authorize`);
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
         (backchannel !== null && url === backchannel) ||

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

@@ -29,6 +29,21 @@ export declare const adminGuard: (ctx: any, next: () => Promise<void>) => Promis
  * (o `adminGuard` 404a quando `config.admin.enabled` é false). Mantenha-os em
  * sincronia; os guards garantem que a divergência não vire um bypass.
  */
+/**
+ * Rotas do fluxo de login que o host pode querer reforçar por conta própria
+ * (throttle mais apertado, WAF, log de auditoria, feature flag…).
+ *
+ * A lib continua aplicando o throttle padrão (`rateLimit`), mas estas são as
+ * rotas em que o host tem contexto para ir além — ex.: limitar `/identifier`
+ * por e-mail em vez de só por IP.
+ */
+export type AuthHostRouteKey = 'interaction' | 'identifier' | 'login' | 'mfa' | 'mfaCustomBegin' | 'mfaCustomVerify' | 'passwordExpired' | 'passkeyOptions' | 'passkeyVerify' | 'magic' | 'magicConsume' | 'otpVerify' | 'consent' | 'switchIdentifier';
+/**
+ * Middleware do AdonisJS aceito por `route.use` — função, import lazy, o nome de um
+ * middleware do router, ou a tupla `[middleware, options]`. Tipado frouxo de propósito:
+ * a lib não conhece os middlewares do host e não deve inferir a forma deles.
+ */
+export type AuthHostMiddleware = unknown;
 export interface AuthHostOptions {
     /**
      * Onde o provider OIDC é montado. Deve casar com o final do issuer. OPCIONAL:
@@ -58,6 +73,26 @@ export interface AuthHostOptions {
      * NÃO espelhe o config aqui — omitir a chave já herda dele.
      */
     rateLimit?: RateLimitConfigInput;
+    /**
+     * Middleware EXTRA por rota do fluxo de login, aplicado DEPOIS do throttle da lib.
+     *
+     * É o escape hatch para quem quer política própria sem fork: a rota continua sendo
+     * da lib (handler, validação, OIDC), mas o host pendura o que quiser nela —
+     * `throttle` do AdonisJS, verificação de origem, auditoria:
+     *
+     * ```ts
+     * registerAuthHost(router, {
+     *   extraMiddleware: {
+     *     identifier: [throttle({ limit: 5, window: '1 minute' })],
+     *   },
+     * })
+     * ```
+     *
+     * Não é opção de POLÍTICA (não é travada pelo `defineConfig`): é encanamento.
+     * Rodeu antes do throttle da lib? Não: a ordem é lib → host, então o seu middleware
+     * vê a requisição depois da barreira padrão.
+     */
+    extraMiddleware?: Partial<Record<AuthHostRouteKey, readonly AuthHostMiddleware[]>>;
     /**
      * Console admin opt-in (B6).
      *
@@ -272,6 +307,24 @@ export interface AuthHostRouteMap {
     } | null;
     /** Nomes das rotas nomeadas (as demais herdam o auto-naming do AdonisJS). */
     names: Record<string, string>;
+    /**
+     * Handles das rotas do fluxo de login (os `Route` do AdonisJS), por chave estável.
+     *
+     * Serve para o host pendurar middleware DEPOIS do registro (`route.use([...])`) ou
+     * inspecionar o que já está aplicado. Para o mesmo efeito de forma declarativa, use
+     * a opção `extraMiddleware` ao chamar `registerAuthHost`.
+     */
+    routes: Partial<Record<AuthHostRouteKey, ReturnType<Router['post']>>>;
+    /** Pattern de cada rota do fluxo (para montar href sem hardcodar). `:uid` incluído. */
+    urls: Record<AuthHostRouteKey, string>;
+    /**
+     * URL concreta de uma rota do fluxo, com o `:uid` já preenchido.
+     *
+     * ```ts
+     * map.interactionUrl('magic', uid) // '/auth/interaction/<uid>/magic'
+     * ```
+     */
+    interactionUrl: (key: AuthHostRouteKey, uid: string) => string;
     /** Ids dos métodos de sudo cujas rotas foram montadas, na ordem de montagem. */
     sudoMethods: string[];
     /**

package/build/src/host/register_auth_host.js

@@ -389,6 +389,7 @@ export function registerAuthHost(router, opts = {}) {
     const withLogin = (route) => {
         if (throttles)
             route.use([throttles.login]);
+        return route;
     };
     const withIntrospection = (route) => {
         if (throttles)
@@ -406,6 +407,33 @@ export function registerAuthHost(router, opts = {}) {
     const withOtpLogin = (route) => {
         if (throttles)
             route.use([throttles.otpLogin]);
+        return route;
+    };
+    const hostRoutes = {};
+    const interactionUrls = {
+        interaction: '/auth/interaction/:uid',
+        identifier: '/auth/interaction/:uid/identifier',
+        login: '/auth/interaction/:uid/login',
+        mfa: '/auth/interaction/:uid/mfa',
+        mfaCustomBegin: '/auth/interaction/:uid/mfa/custom/:method/begin',
+        mfaCustomVerify: '/auth/interaction/:uid/mfa/custom/:method/verify',
+        passwordExpired: '/auth/interaction/:uid/password-expired',
+        passkeyOptions: '/auth/interaction/:uid/passkey/options',
+        passkeyVerify: '/auth/interaction/:uid/passkey/verify',
+        magic: '/auth/interaction/:uid/magic',
+        magicConsume: '/auth/interaction/:uid/magic',
+        otpVerify: '/auth/interaction/:uid/otp-verify',
+        consent: '/auth/interaction/:uid/consent',
+        switchIdentifier: '/auth/interaction/:uid/switch',
+    };
+    const keep = (key, route) => {
+        hostRoutes[key] = route;
+        const extraForRoute = opts.extraMiddleware?.[key];
+        if (extraForRoute && extraForRoute.length > 0) {
+            // `use` espera o MiddlewareList do AdonisJS; aqui é lista opaca do host.
+            route.use([...extraForRoute]);
+        }
+        return route;
     };
     // ─── Assets estáticos do host-kit (públicos, sem autenticação) ─────────────
     // Bundle do @simplewebauthn/browser servido pelo próprio app, no lugar do
@@ -452,38 +480,46 @@ export function registerAuthHost(router, opts = {}) {
     router.any(`${mount}/*`, [C.oidc]).as('authkit.oidc.wildcard');
     router.any(mount, [C.oidc]).as('authkit.oidc.root');
     // Interaction (login multi-step + consent + signup).
-    router.get('/auth/interaction/:uid', [C.interaction, 'show']);
-    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', [
+    // Cada rota passa por `keep(key, …)`: entra em `AuthHostRouteMap.routes`/`urls` e
+    // recebe o `extraMiddleware` do host (depois do throttle da lib).
+    keep('interaction', router.get('/auth/interaction/:uid', [C.interaction, 'show']));
+    // `/identifier` é a ENTRADA do fluxo: recebe só o e-mail e abre/avança a interaction.
+    // Sem throttle, um anônimo cria estado de interaction sem limite (Redis) e o passo
+    // fica de fora do orçamento que o resto do login respeita. Bucket `login` (por IP),
+    // o mesmo do `/magic`: um login normal gasta 2 dos 10 pontos por minuto.
+    keep('identifier', withLogin(router.post('/auth/interaction/:uid/identifier', [C.interaction, 'identifier'])));
+    withLogin(keep('login', router.post('/auth/interaction/:uid/login', [C.interaction, 'login'])));
+    withLogin(keep('mfa', router.post('/auth/interaction/:uid/mfa', [C.interaction, 'mfaVerify'])));
+    const customMfaBeginRoute = keep('mfaCustomBegin', 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', [
+    const customMfaVerifyRoute = keep('mfaCustomVerify', 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', [
+    withLogin(keep('passwordExpired', router.post('/auth/interaction/:uid/password-expired', [
         C.interaction,
         'changeExpiredPassword',
-    ]));
+    ])));
     // Passkey como 2º fator alternativo no login (begin/finish; challenge na sessão).
-    router.post('/auth/interaction/:uid/passkey/options', [C.interaction, 'passkeyOptions']);
-    withLogin(router.post('/auth/interaction/:uid/passkey/verify', [C.interaction, 'passkeyVerify']));
+    // O `options` também cria estado (challenge) e é anônimo: mesmo bucket `login` do
+    // `/identifier` e do `/magic`. Um login normal gasta 1 ponto aqui quando usa passkey.
+    keep('passkeyOptions', withLogin(router.post('/auth/interaction/:uid/passkey/options', [C.interaction, 'passkeyOptions'])));
+    withLogin(keep('passkeyVerify', router.post('/auth/interaction/:uid/passkey/verify', [C.interaction, 'passkeyVerify'])));
     // Magic link (passwordless): POST emite (throttled), GET consome o token do link.
-    withLogin(router.post('/auth/interaction/:uid/magic', [C.interaction, 'magicLinkRequest']));
-    router.get('/auth/interaction/:uid/magic', [C.interaction, 'magicLinkConsume']);
+    withLogin(keep('magic', router.post('/auth/interaction/:uid/magic', [C.interaction, 'magicLinkRequest'])));
+    keep('magicConsume', router.get('/auth/interaction/:uid/magic', [C.interaction, 'magicLinkConsume']));
     // Login por OTP (código digitável): verifica o código no bucket dedicado
     // `authkit_otp_login` (por IP, mais apertado que o login).
-    withOtpLogin(router.post('/auth/interaction/:uid/otp-verify', [C.interaction, 'otpVerify']));
-    router.post('/auth/interaction/:uid/consent', [C.interaction, 'consent']);
-    router.get('/auth/interaction/:uid/switch', [C.interaction, 'switchIdentifier']);
+    keep('otpVerify', withOtpLogin(router.post('/auth/interaction/:uid/otp-verify', [C.interaction, 'otpVerify'])));
+    keep('consent', router.post('/auth/interaction/:uid/consent', [C.interaction, 'consent']));
+    keep('switchIdentifier', router.get('/auth/interaction/:uid/switch', [C.interaction, 'switchIdentifier']));
     // OTP unlock: link enviado por e-mail quando o fator TOTP/recovery é travado.
     router.get('/auth/otp-unlock/:token', [C.interaction, 'otpUnlock']);
     router.get('/auth/interaction/:uid/signup', [C.registration, 'showSignup']);
@@ -537,6 +573,9 @@ export function registerAuthHost(router, opts = {}) {
         // 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');
@@ -548,14 +587,16 @@ export function registerAuthHost(router, opts = {}) {
         router
             .post(`${poppyPrefix}/oauth/device`, [C.poppy, 'deviceAuthorization'])
             .as('authkit.poppy.device_authorization');
-        // Credenciais e códigos de uso único: throttle por IP (§4.7 exige rate limit).
-        withLogin(router.post(`${poppyPrefix}/sign-in`, [C.poppy, 'mediatedStart']).as('authkit.poppy.sign_in'));
-        withOtpLogin(router
-            .post(`${poppyPrefix}/sign-in/:id`, [C.poppy, 'mediatedCode'])
-            .as('authkit.poppy.sign_in_code'));
+        // 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
@@ -1026,6 +1067,9 @@ export function registerAuthHost(router, opts = {}) {
     // inteiro, e não só metade (certo no servidor, errado na UI).
     return {
         mountPath: mount,
+        routes: hostRoutes,
+        urls: interactionUrls,
+        interactionUrl: (key, uid) => interactionUrls[key].replace(':uid', encodeURIComponent(uid)),
         account: {
             prefix: accountPrefix(),
             api: apiBase,

package/build/src/schema/ensure.js

@@ -334,22 +334,23 @@ const TABLES = [
         },
     },
     /*
-     * Personal Agent Protocol (Poppy). Os Account Tokens são grants de
+     * Personal Agent Protocol (Poppy). Os refresh tokens são grants de
      * `auth_agent_grants` (prefixo `pgrant_`) com o hash em
-     * `auth_agent_refresh_tokens`; aqui ficam Sessions, Session Tokens, pedidos de
+     * `auth_agent_refresh_tokens`; aqui ficam Sessions, access tokens, pedidos de
      * sign-in e os `jti` vistos. Mesmas regras de data das tabelas acima.
      */
     {
         name: 'auth_poppy_sessions',
         /**
-         * Uma Session: um usuário do agente (`user_id`, opaco) num agente
-         * (`client_id`). `account_id` é a conta a que ficou PRESA ao logar (não troca);
-         * `grant_id` o Account Token com que está logada agora (`null` = deslogada).
+         * Uma Session: um usuário do agente (`user_id`, opaco) num agente (`client_id`), com o
+         * `agent_id` opcional. `account_id` é a conta que já usou. `grant_id` e `scope` ficaram da
+         * Draft 0.1, sem uso (o schema só é aditivo).
          */
         create: (t) => {
             t.string('id').primary();
             t.string('client_id', 2048).notNullable();
             t.string('user_id').notNullable();
+            t.string('agent_id').nullable();
             t.string('account_id').nullable().index();
             t.string('grant_id').nullable().index();
             t.text('scope').notNullable();
@@ -361,6 +362,7 @@ const TABLES = [
         columns: {
             client_id: (t) => t.string('client_id', 2048),
             user_id: (t) => t.string('user_id'),
+            agent_id: (t) => t.string('agent_id').nullable(),
             account_id: (t) => t.string('account_id').nullable().index(),
             grant_id: (t) => t.string('grant_id').nullable().index(),
             scope: (t) => t.text('scope'),
@@ -372,7 +374,10 @@ const TABLES = [
     },
     {
         name: 'auth_poppy_tokens',
-        /** Session Tokens — só o hash. `jkt` = chave DPoP; `null` = Bearer (MCP). */
+        /**
+         * Access tokens — só o hash. `jkt` = chave DPoP; `null` = Bearer. `session_id` e `user_id`
+         * ficaram da Draft 0.1 e saem vazios: o sign-in não conhece a Session.
+         */
         create: (t) => {
             t.string('token_hash', 64).primary();
             t.string('session_id').notNullable().index();
@@ -402,8 +407,8 @@ const TABLES = [
     {
         name: 'auth_poppy_requests',
         /**
-         * Pedidos de sign-in: `authorize` (Direct — vira código após o consentimento),
-         * `device` (RFC 8628) e `mediated` (§4.7, aguardando o código de uso único).
+         * Pedidos: `authorize` (Direct — vira código após o consentimento), `device` (RFC 8628),
+         * `mediated` (aguardando o código de uso único) e `browser` (entrada de um navegador, §6).
          * Códigos só como hash. Linhas expiradas são apagadas no próximo pedido.
          */
         create: (t) => {
@@ -448,7 +453,7 @@ const TABLES = [
     },
     {
         name: 'auth_poppy_jtis',
-        /** `jti` já aceitos (asserções, provas DPoP), até expirarem — anti-replay entre instâncias. */
+        /** `jti` já aceitos (client assertions, Session JWTs, provas DPoP), até expirarem — anti-replay entre instâncias. */
         create: (t) => {
             t.string('key', 100).primary();
             t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable().index();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.85.1",
+  "version": "0.87.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -117,7 +117,7 @@
   },
   "devDependencies": {
     "@adonis-agora/authkit-react": "0.26.0",
-    "@adonis-agora/durable": "0.53.0",
+    "@adonis-agora/durable": "0.54.1",
     "@adonis-agora/telescope": "0.23.0",
     "@adonisjs/ally": "6.3.2",
     "@adonisjs/auth": "10.1.0",
@@ -133,7 +133,7 @@
     "@poppinss/ts-exec": "1.5.1",
     "@tailwindcss/cli": "4.3.3",
     "@tanstack/intent": "0.5.6",
-    "@tanstack/react-query": "5.104.5",
+    "@tanstack/react-query": "5.105.0",
     "@types/better-sqlite3": "9.6.0",
     "@types/ioredis-mock": "8.2.8",
     "@types/koa": "3.0.3",