@adonis-agora/authkit-server 0.68.4 → 0.70.0

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

@@ -1,6 +1,7 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
 import { supportsLoginMethodsPreference, supportsMagicLink, supportsPasskeys, supportsProviderIdentity, } from '../../accounts/account_store.js';
+import { normalizeEmailIdentifier, resolveEmailIdentifier } from '../email_identifier.js';
 import { assertLoginAllowed } from '../login_attempt.js';
 import { resolveRuntimeSettingsOrNoop } from '../runtime_settings.js';
 import { resolveEffectiveAuthMethods } from '../runtime_toggles.js';
@@ -54,7 +55,10 @@ export default class AuthSocialController {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const store = cfg.accountStore;
-        const email = profile.email ?? undefined;
+        // Normaliza o e-mail do provider com a MESMA regra do cadastro/login: sem
+        // isto, um provider que devolve o endereço com maiúsculas criava uma conta
+        // que o login (normalizado) não encontrava mais.
+        const email = profile.email ? normalizeEmailIdentifier(profile.email) : undefined;
         // Account linking exige a capacidade de provider-identity (model wired no store).
         // Ausente → não há como ligar a identidade; volta ao login em vez de quebrar.
         if (!supportsProviderIdentity(store)) {
@@ -67,7 +71,12 @@ export default class AuthSocialController {
         //  3. Senão → cria conta nova e liga a identidade.
         let user = await store.findByProviderIdentity(provider, profile.id);
         if (!user && email) {
-            const byEmail = await store.findByEmail(email);
+            // Ponte legada: sem ela, quem tem a conta gravada com o endereço mutilado
+            // pelo cadastro antigo ganharia uma SEGUNDA conta ao "Continuar com o
+            // Google" em vez de ligar a identidade à conta que já tem.
+            const byEmail = (await resolveEmailIdentifier(store, profile.email, {
+                legacyFallback: cfg.login?.legacyEmailFallback ?? true,
+            })).account;
             if (byEmail) {
                 await store.linkProviderIdentity({
                     accountId: byEmail.id,

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

@@ -0,0 +1,92 @@
+import type { AuthAccount } from '../accounts/account_store.js';
+/**
+ * Normalização ÚNICA e CONSERVADORA do e-mail usado como identidade da conta.
+ *
+ * Faz `trim()` + `toLowerCase()` e MAIS NADA. O endereço que a pessoa digitou é a
+ * identidade dela: a lib NÃO decide que `a.b@gmail.com` e `ab@gmail.com` são a
+ * mesma pessoa, nem descarta o sub-endereço (`+tag`) que ela escolheu usar.
+ *
+ * POR QUE ISTO EXISTE: até a v0.68 o cadastro validava o e-mail com
+ * `.normalizeEmail()` do VineJS (os defaults do validator.js), que para o gmail
+ * REMOVE os pontos e o `+tag` do local part. A conta nascia com um endereço
+ * DIFERENTE do digitado (`davi.carvalho96@gmail.com` → `davicarvalho96@gmail.com`)
+ * enquanto o passo de identificador do login não normalizava NADA e buscava por
+ * igualdade exata — resultado: quem tinha ponto ou `+tag` no gmail ficava
+ * trancado do lado de fora, e, por o login ser à prova de enumeração, sem
+ * nenhuma mensagem de erro. Uma normalização só, usada nos DOIS lados, fecha a
+ * assimetria.
+ *
+ * Use em TODO ponto que grava ou busca a identidade: cadastro (com e sem senha),
+ * "esqueci a senha", troca de e-mail, criação por admin, convite de organização,
+ * import de usuários, cadastro social e o passo de identificador do login.
+ */
+export declare function normalizeEmailIdentifier(raw: unknown): string;
+/**
+ * Réplica da normalização LEGADA — `normalizeEmail()` do validator.js com os
+ * defaults, que é o que o `.normalizeEmail()` do VineJS aplicava no cadastro até
+ * a v0.68. Existe SÓ para reencontrar as contas que nasceram com o endereço
+ * mutilado; nada novo deve ser gravado com ela.
+ *
+ * É uma PONTE TEMPORÁRIA: quando as contas antigas tiverem sido migradas para o
+ * endereço real (ou o suficiente delas), esta função, a opção
+ * `login.legacyEmailFallback` e {@link resolveEmailIdentifier} podem sair.
+ *
+ * Retorna `null` para entradas que o validator.js também recusaria (local part
+ * vazio depois do colapso) ou que não são um endereço com `@`.
+ */
+export declare function legacyNormalizeEmailIdentifier(raw: unknown): string | null;
+/** Só o que {@link resolveEmailIdentifier} precisa do account store. */
+export interface EmailIdentifierLookup {
+    findByEmail(email: string): Promise<AuthAccount | null>;
+}
+export interface ResolvedEmailIdentifier {
+    /** O que a pessoa digitou, normalizado. É o que a tela SEMPRE mostra. */
+    email: string;
+    /**
+     * E-mail sob o qual a conta está GRAVADA — o que deve ir para o store em
+     * qualquer busca/emissão de token. Igual a {@link email} quando a conta foi
+     * achada direto (ou quando não foi achada nenhuma).
+     */
+    lookupEmail: string;
+    /** A conta, quando alguma foi encontrada. */
+    account: AuthAccount | null;
+    /** `true` quando a conta só foi alcançada pela ponte legada. */
+    viaLegacyFallback: boolean;
+}
+/**
+ * Resolve o e-mail digitado na conta correspondente.
+ *
+ * Passe o valor **CRU** (como veio do formulário, do provider ou do arquivo): a
+ * normalização acontece aqui dentro, e a forma crua é uma das candidatas da
+ * ponte. Passar um valor já normalizado apaga essa candidata e reduz o alcance
+ * da ponte às contas gravadas com o endereço mutilado.
+ *
+ * 1. Busca pela forma normalizada NOVA (trim + lowercase) — o caminho de sempre,
+ *    uma única query por igualdade (indexada).
+ * 2. Não achando, e com a ponte ligada (`login.legacyEmailFallback`, default
+ *    `true`), tenta as formas de compatibilidade:
+ *    - o endereço EXATAMENTE como digitado (só com `trim`), para as contas que
+ *      foram gravadas com maiúsculas antes desta normalização existir (import,
+ *      convite, criação por admin, provider social);
+ *    - a {@link legacyNormalizeEmailIdentifier normalização legada}, para as
+ *      contas que nasceram com o endereço mutilado.
+ *    O resultado só é aceito quando as formas de compatibilidade apontam para
+ *    EXATAMENTE UMA conta. Duas contas distintas (ex.: `Davi.C@Gmail.com` criada
+ *    pelo social E `davic@gmail.com` criada pelo cadastro legado) são um empate:
+ *    a lib não adivinha qual é a pessoa e trata como "não achei".
+ *
+ * LIMITE CONHECIDO: a ponte só alcança grafias que dá para derivar do que foi
+ * digitado. Uma conta gravada `Davi@Acme.com` é alcançada por quem digita
+ * `Davi@Acme.com` (a forma crua), mas NÃO por quem digita `davi@acme.com` — aí as
+ * três formas coincidem e só uma busca case-insensitive no store resolveria, o
+ * que exigiria varrer a tabela a cada login com e-mail desconhecido (justamente o
+ * caminho de ataque). Essas contas pedem migração do endereço gravado, não ponte.
+ *
+ * À PROVA DE ENUMERAÇÃO: nunca lança, nunca sinaliza nada para fora — quem chama
+ * segue com `account: null` exatamente como seguia antes. As buscas extras só
+ * acontecem quando as formas de compatibilidade DIFEREM da normalizada (e-mail
+ * digitado em minúsculas e sem ponto/tag → uma query só, como hoje).
+ */
+export declare function resolveEmailIdentifier(store: EmailIdentifierLookup, raw: unknown, options?: {
+    legacyFallback?: boolean;
+}): Promise<ResolvedEmailIdentifier>;

package/build/src/host/email_identifier.js

@@ -0,0 +1,234 @@
+/**
+ * Normalização ÚNICA e CONSERVADORA do e-mail usado como identidade da conta.
+ *
+ * Faz `trim()` + `toLowerCase()` e MAIS NADA. O endereço que a pessoa digitou é a
+ * identidade dela: a lib NÃO decide que `a.b@gmail.com` e `ab@gmail.com` são a
+ * mesma pessoa, nem descarta o sub-endereço (`+tag`) que ela escolheu usar.
+ *
+ * POR QUE ISTO EXISTE: até a v0.68 o cadastro validava o e-mail com
+ * `.normalizeEmail()` do VineJS (os defaults do validator.js), que para o gmail
+ * REMOVE os pontos e o `+tag` do local part. A conta nascia com um endereço
+ * DIFERENTE do digitado (`davi.carvalho96@gmail.com` → `davicarvalho96@gmail.com`)
+ * enquanto o passo de identificador do login não normalizava NADA e buscava por
+ * igualdade exata — resultado: quem tinha ponto ou `+tag` no gmail ficava
+ * trancado do lado de fora, e, por o login ser à prova de enumeração, sem
+ * nenhuma mensagem de erro. Uma normalização só, usada nos DOIS lados, fecha a
+ * assimetria.
+ *
+ * Use em TODO ponto que grava ou busca a identidade: cadastro (com e sem senha),
+ * "esqueci a senha", troca de e-mail, criação por admin, convite de organização,
+ * import de usuários, cadastro social e o passo de identificador do login.
+ */
+export function normalizeEmailIdentifier(raw) {
+    return typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+}
+// ─── Ponte de compatibilidade com a normalização LEGADA ─────────────────────
+/** Domínios do gmail (pontos e sub-endereço eram removidos do local part). */
+const GMAIL_DOMAINS = ['gmail.com', 'googlemail.com'];
+/** Domínios do iCloud (sub-endereço `+tag` removido). */
+const ICLOUD_DOMAINS = ['icloud.com', 'me.com'];
+/** Domínios do Outlook.com/Hotmail/Live (sub-endereço `+tag` removido). */
+const OUTLOOK_DOMAINS = [
+    'hotmail.at',
+    'hotmail.be',
+    'hotmail.ca',
+    'hotmail.cl',
+    'hotmail.co.il',
+    'hotmail.co.nz',
+    'hotmail.co.th',
+    'hotmail.co.uk',
+    'hotmail.com',
+    'hotmail.com.ar',
+    'hotmail.com.au',
+    'hotmail.com.br',
+    'hotmail.com.gr',
+    'hotmail.com.mx',
+    'hotmail.com.pe',
+    'hotmail.com.tr',
+    'hotmail.com.vn',
+    'hotmail.cz',
+    'hotmail.de',
+    'hotmail.dk',
+    'hotmail.es',
+    'hotmail.fr',
+    'hotmail.hu',
+    'hotmail.id',
+    'hotmail.ie',
+    'hotmail.in',
+    'hotmail.it',
+    'hotmail.jp',
+    'hotmail.kr',
+    'hotmail.lv',
+    'hotmail.my',
+    'hotmail.ph',
+    'hotmail.pt',
+    'hotmail.sa',
+    'hotmail.sg',
+    'hotmail.sk',
+    'live.be',
+    'live.co.uk',
+    'live.com',
+    'live.com.ar',
+    'live.com.mx',
+    'live.de',
+    'live.es',
+    'live.eu',
+    'live.fr',
+    'live.it',
+    'live.nl',
+    'msn.com',
+    'outlook.at',
+    'outlook.be',
+    'outlook.cl',
+    'outlook.co.il',
+    'outlook.co.nz',
+    'outlook.co.th',
+    'outlook.com',
+    'outlook.com.ar',
+    'outlook.com.au',
+    'outlook.com.br',
+    'outlook.com.gr',
+    'outlook.com.pe',
+    'outlook.com.tr',
+    'outlook.com.vn',
+    'outlook.cz',
+    'outlook.de',
+    'outlook.dk',
+    'outlook.es',
+    'outlook.fr',
+    'outlook.hu',
+    'outlook.id',
+    'outlook.ie',
+    'outlook.in',
+    'outlook.it',
+    'outlook.jp',
+    'outlook.kr',
+    'outlook.lv',
+    'outlook.my',
+    'outlook.ph',
+    'outlook.pt',
+    'outlook.sa',
+    'outlook.sg',
+    'outlook.sk',
+    'passport.com',
+];
+/** Domínios do Yahoo (sub-endereço `-tag` removido). */
+const YAHOO_DOMAINS = [
+    'rocketmail.com',
+    'yahoo.ca',
+    'yahoo.co.uk',
+    'yahoo.com',
+    'yahoo.de',
+    'yahoo.fr',
+    'yahoo.in',
+    'yahoo.it',
+    'ymail.com',
+];
+/** Domínios do Yandex (todos colapsavam em `yandex.ru`). */
+const YANDEX_DOMAINS = ['yandex.ru', 'yandex.ua', 'yandex.kz', 'yandex.com', 'yandex.by', 'ya.ru'];
+/** Remove pontos SOLTOS do local part (pontos consecutivos ficam — regra do validator.js). */
+function stripSingleDots(local) {
+    return local.replace(/\.+/g, (match) => (match.length > 1 ? match : ''));
+}
+/**
+ * Réplica da normalização LEGADA — `normalizeEmail()` do validator.js com os
+ * defaults, que é o que o `.normalizeEmail()` do VineJS aplicava no cadastro até
+ * a v0.68. Existe SÓ para reencontrar as contas que nasceram com o endereço
+ * mutilado; nada novo deve ser gravado com ela.
+ *
+ * É uma PONTE TEMPORÁRIA: quando as contas antigas tiverem sido migradas para o
+ * endereço real (ou o suficiente delas), esta função, a opção
+ * `login.legacyEmailFallback` e {@link resolveEmailIdentifier} podem sair.
+ *
+ * Retorna `null` para entradas que o validator.js também recusaria (local part
+ * vazio depois do colapso) ou que não são um endereço com `@`.
+ */
+export function legacyNormalizeEmailIdentifier(raw) {
+    const email = normalizeEmailIdentifier(raw);
+    const at = email.lastIndexOf('@');
+    if (at <= 0 || at === email.length - 1)
+        return null;
+    let local = email.slice(0, at);
+    let domain = email.slice(at + 1);
+    if (GMAIL_DOMAINS.includes(domain)) {
+        local = local.split('+')[0];
+        local = stripSingleDots(local);
+        domain = 'gmail.com';
+    }
+    else if (ICLOUD_DOMAINS.includes(domain) || OUTLOOK_DOMAINS.includes(domain)) {
+        local = local.split('+')[0];
+    }
+    else if (YAHOO_DOMAINS.includes(domain)) {
+        const parts = local.split('-');
+        local = parts.length > 1 ? parts.slice(0, -1).join('-') : parts[0];
+    }
+    else if (YANDEX_DOMAINS.includes(domain)) {
+        domain = 'yandex.ru';
+    }
+    if (!local.length)
+        return null;
+    return `${local}@${domain}`;
+}
+/**
+ * Resolve o e-mail digitado na conta correspondente.
+ *
+ * Passe o valor **CRU** (como veio do formulário, do provider ou do arquivo): a
+ * normalização acontece aqui dentro, e a forma crua é uma das candidatas da
+ * ponte. Passar um valor já normalizado apaga essa candidata e reduz o alcance
+ * da ponte às contas gravadas com o endereço mutilado.
+ *
+ * 1. Busca pela forma normalizada NOVA (trim + lowercase) — o caminho de sempre,
+ *    uma única query por igualdade (indexada).
+ * 2. Não achando, e com a ponte ligada (`login.legacyEmailFallback`, default
+ *    `true`), tenta as formas de compatibilidade:
+ *    - o endereço EXATAMENTE como digitado (só com `trim`), para as contas que
+ *      foram gravadas com maiúsculas antes desta normalização existir (import,
+ *      convite, criação por admin, provider social);
+ *    - a {@link legacyNormalizeEmailIdentifier normalização legada}, para as
+ *      contas que nasceram com o endereço mutilado.
+ *    O resultado só é aceito quando as formas de compatibilidade apontam para
+ *    EXATAMENTE UMA conta. Duas contas distintas (ex.: `Davi.C@Gmail.com` criada
+ *    pelo social E `davic@gmail.com` criada pelo cadastro legado) são um empate:
+ *    a lib não adivinha qual é a pessoa e trata como "não achei".
+ *
+ * LIMITE CONHECIDO: a ponte só alcança grafias que dá para derivar do que foi
+ * digitado. Uma conta gravada `Davi@Acme.com` é alcançada por quem digita
+ * `Davi@Acme.com` (a forma crua), mas NÃO por quem digita `davi@acme.com` — aí as
+ * três formas coincidem e só uma busca case-insensitive no store resolveria, o
+ * que exigiria varrer a tabela a cada login com e-mail desconhecido (justamente o
+ * caminho de ataque). Essas contas pedem migração do endereço gravado, não ponte.
+ *
+ * À PROVA DE ENUMERAÇÃO: nunca lança, nunca sinaliza nada para fora — quem chama
+ * segue com `account: null` exatamente como seguia antes. As buscas extras só
+ * acontecem quando as formas de compatibilidade DIFEREM da normalizada (e-mail
+ * digitado em minúsculas e sem ponto/tag → uma query só, como hoje).
+ */
+export async function resolveEmailIdentifier(store, raw, options = {}) {
+    const email = normalizeEmailIdentifier(raw);
+    const miss = {
+        email,
+        lookupEmail: email,
+        account: null,
+        viaLegacyFallback: false,
+    };
+    if (!email)
+        return miss;
+    const direct = await store.findByEmail(email);
+    if (direct)
+        return { email, lookupEmail: email, account: direct, viaLegacyFallback: false };
+    if (options.legacyFallback === false)
+        return miss;
+    const typed = typeof raw === 'string' ? raw.trim() : '';
+    const legacy = legacyNormalizeEmailIdentifier(email);
+    const candidates = [typed, legacy].filter((candidate) => !!candidate && candidate !== email);
+    const byId = new Map();
+    for (const candidate of new Set(candidates)) {
+        const found = await store.findByEmail(candidate);
+        if (found)
+            byId.set(found.id, found);
+    }
+    if (byId.size !== 1)
+        return miss;
+    const account = [...byId.values()][0];
+    return { email, lookupEmail: account.email, account, viaLegacyFallback: true };
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Ponte SSO: sessão do IdP → sessão do console de conta (`/account/*`, `/admin/*`).
+ *
+ * POR QUE EXISTE. São duas sessões diferentes no mesmo host:
+ *
+ *   - a sessão do IdP (oidc-provider): cookie `_session`, criada quando o
+ *     usuário completa a interaction de login do `/oidc/auth` (senha, magic
+ *     link, OTP, passkey, social). É ela que dá o SSO entre os clients OIDC;
+ *   - a sessão do console: a chave `ACCOUNT_SESSION_KEY` na sessão do Adonis,
+ *     criada SÓ pelo login do próprio console (`POST /account/login`).
+ *
+ * O login do IdP nunca escrevia a segunda, então um usuário que acabou de
+ * entrar num app OIDC (inclusive o próprio host, quando ele é IdP e RP ao mesmo
+ * tempo) e abria `/account/*` levava um SEGUNDO pedido de login.
+ *
+ * Com `accountSession.acceptIdpSession: true`, os guards do console aceitam a
+ * sessão ATIVA do IdP: sem sessão de console, mas com uma sessão do IdP válida
+ * (cookie assinado + registro no adapter, não expirado) de uma conta existente
+ * e habilitada, o console é aberto para essa conta. A ponte fica AMARRADA à
+ * sessão do IdP que a originou (o `uid` dela vai na sessão do Adonis): quando a
+ * sessão do IdP acaba (logout OIDC, expiração, troca de conta), o console
+ * derivado dela acaba junto no próximo request.
+ *
+ * Default `false`: quem não liga continua exatamente como antes.
+ */
+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 {
+    uid: string;
+    accountId?: string;
+    destroy(): Promise<void>;
+}
+/**
+ * Lê a sessão do IdP a partir do cookie do request (mesma leitura que o
+ * 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>;
+/**
+ * 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.
+ *
+ * Sem `accountSession.acceptIdpSession`, é só "existe `ACCOUNT_SESSION_KEY`?" —
+ * o comportamento de sempre, sem tocar no provider.
+ */
+export declare function ensureConsoleSession(ctx: HttpContext): Promise<boolean>;
+/**
+ * Logout do console de uma sessão que veio da ponte: encerra também a sessão
+ * do IdP que a originou — senão o próximo request reabriria o console pela
+ * 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

@@ -0,0 +1,108 @@
+import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { syncAdonisAuthLogin } from './adonis_auth_sync.js';
+import { impersonationState } from './impersonation_session.js';
+import { assertAccountEnabled } from './login_attempt.js';
+/** Chave da sessão Adonis com o `uid` da sessão do IdP que originou o console. */
+export const ACCOUNT_IDP_SESSION_KEY = 'authkit_idp_session_uid';
+/**
+ * Lê a sessão do IdP a partir do cookie do request (mesma leitura que o
+ * 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) {
+    const provider = service?.provider;
+    if (!provider?.Session || typeof provider.createContext !== 'function')
+        return null;
+    try {
+        const kctx = provider.createContext(ctx.request.request, ctx.response.response);
+        const id = kctx.cookies.get(provider.cookieName('session'));
+        if (!id)
+            return null;
+        const session = (await provider.Session.find(id));
+        return session?.accountId ? session : null;
+    }
+    catch {
+        // Fail-safe: sem ponte (o guard segue para o login normal).
+        return null;
+    }
+}
+function acceptsIdpSession(service) {
+    return service?.config?.accountSession?.acceptIdpSession === true;
+}
+/** Id do humano por trás da sessão do console (impersonation → o admin real). */
+function realConsoleAccount(ctx, current) {
+    try {
+        return impersonationState(ctx).impersonatorId ?? current;
+    }
+    catch {
+        return current;
+    }
+}
+/**
+ * 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.
+ *
+ * Sem `accountSession.acceptIdpSession`, é só "existe `ACCOUNT_SESSION_KEY`?" —
+ * o comportamento de sempre, sem tocar no provider.
+ */
+export async function ensureConsoleSession(ctx) {
+    const current = ctx.session?.get(ACCOUNT_SESSION_KEY);
+    const service = await ctx.containerResolver?.make('authkit.server').catch(() => null);
+    if (!acceptsIdpSession(service))
+        return Boolean(current);
+    const bridgedUid = ctx.session?.get(ACCOUNT_IDP_SESSION_KEY);
+    // Login próprio do console (não veio da ponte): intocado.
+    if (current && !bridgedUid)
+        return true;
+    const idp = await readIdpSession(ctx, service);
+    if (current && bridgedUid) {
+        if (idp && idp.uid === bridgedUid && idp.accountId === realConsoleAccount(ctx, current)) {
+            return true;
+        }
+        // A sessão do IdP que originou o console acabou (ou virou outra conta):
+        // encerra o console derivado dela. Se houver outra sessão do IdP viva, a
+        // ponte abaixo reabre para a conta dela.
+        ctx.session.forget(ACCOUNT_SESSION_KEY);
+        ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
+    }
+    if (!idp?.accountId)
+        return false;
+    const cfg = service.config;
+    const account = await cfg.accountStore.findById(idp.accountId);
+    if (!account)
+        return false;
+    const gate = await assertAccountEnabled(cfg, account.id, {
+        email: account.email ?? '',
+        ip: ctx.request.ip?.() ?? null,
+    });
+    if (!gate.allowed)
+        return false;
+    // Elevação anônimo → autenticado: troca o id da sessão (anti-fixation), como
+    // 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);
+    return true;
+}
+/**
+ * Logout do console de uma sessão que veio da ponte: encerra também a sessão
+ * do IdP que a originou — senão o próximo request reabriria o console pela
+ * própria ponte e o "Sair" não teria efeito. No-op fora da ponte.
+ */
+export async function endBridgedIdpSession(ctx) {
+    const bridgedUid = ctx.session?.get(ACCOUNT_IDP_SESSION_KEY);
+    if (!bridgedUid)
+        return;
+    ctx.session.forget(ACCOUNT_IDP_SESSION_KEY);
+    const service = await ctx.containerResolver?.make('authkit.server').catch(() => null);
+    const idp = await readIdpSession(ctx, service);
+    if (idp && idp.uid === bridgedUid) {
+        try {
+            await idp.destroy();
+        }
+        catch {
+            // best-effort
+        }
+    }
+}

package/build/src/host/middleware/account_auth.js

@@ -1,11 +1,12 @@
 import '../augmentations.js';
 import { getAccountLoginUrl } from '../account_login_url.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
+import { ensureConsoleSession } from '../idp_session_bridge.js';
 export { ACCOUNT_SESSION_KEY };
 export default class AccountAuthMiddleware {
     async handle(ctx, next) {
-        const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        if (!userId) {
+        // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
+        if (!(await ensureConsoleSession(ctx))) {
             // Destino configurável (`accountLoginUrl`): default `/account/login`.
             return ctx.response.redirect(getAccountLoginUrl());
         }

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

@@ -0,0 +1,26 @@
+/**
+ * Política EFETIVA de organizações — ponto de verdade ÚNICO das duas
+ * superfícies member-facing.
+ *
+ * O console HTML (`AccountOrgsController`) e o espelho JSON
+ * (`AccountOrgsApiController`) precisam responder à MESMA pergunta — "este
+ * usuário pode criar org? que papéis existem? quanto tempo o convite vale?" —
+ * e a resposta não está no config estático: ela é resolvida na ordem setting da
+ * org → setting global → `config.organizations` → default da lib.
+ *
+ * Mora num módulo próprio, e não dentro de um dos controllers, porque duas
+ * cópias desta resolução são exatamente como o caminho JSON acaba mais frouxo
+ * (ou mais apertado) que o formulário que ele espelha — o bug que este pacote
+ * de mudanças existe para não ter.
+ */
+import './augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+import { type OrganizationsPolicyConfigDefaults, type ResolvedOrganizationsPolicySetting } from './runtime_toggles.js';
+/** Defaults estáticos da política de org (config do host) — o fallback da setting. */
+export declare function orgPolicyDefaults(cfg: any): OrganizationsPolicyConfigDefaults;
+/**
+ * Política efetiva para o `orgId` (ou global, quando ausente). `settings` nulo —
+ * DB fora do ar, app sem lucid — cai no config estático, fail-safe herdado de
+ * {@link resolveEffectiveOrganizationsPolicy}.
+ */
+export declare function effectiveOrgPolicy(ctx: HttpContext, cfg: any, orgId?: string | null): Promise<ResolvedOrganizationsPolicySetting>;

package/build/src/host/org_policy.js

@@ -0,0 +1,35 @@
+/**
+ * Política EFETIVA de organizações — ponto de verdade ÚNICO das duas
+ * superfícies member-facing.
+ *
+ * O console HTML (`AccountOrgsController`) e o espelho JSON
+ * (`AccountOrgsApiController`) precisam responder à MESMA pergunta — "este
+ * usuário pode criar org? que papéis existem? quanto tempo o convite vale?" —
+ * e a resposta não está no config estático: ela é resolvida na ordem setting da
+ * org → setting global → `config.organizations` → default da lib.
+ *
+ * Mora num módulo próprio, e não dentro de um dos controllers, porque duas
+ * cópias desta resolução são exatamente como o caminho JSON acaba mais frouxo
+ * (ou mais apertado) que o formulário que ele espelha — o bug que este pacote
+ * de mudanças existe para não ter.
+ */
+import './augmentations.js';
+import { resolveRuntimeSettings } from './runtime_settings.js';
+import { resolveEffectiveOrganizationsPolicy, } from './runtime_toggles.js';
+/** Defaults estáticos da política de org (config do host) — o fallback da setting. */
+export function orgPolicyDefaults(cfg) {
+    return {
+        roles: cfg.organizations.roles,
+        allowSelfCreate: cfg.organizations.allowSelfCreate,
+        invitationTtlHours: cfg.organizations.invitationTtlHours,
+    };
+}
+/**
+ * Política efetiva para o `orgId` (ou global, quando ausente). `settings` nulo —
+ * DB fora do ar, app sem lucid — cai no config estático, fail-safe herdado de
+ * {@link resolveEffectiveOrganizationsPolicy}.
+ */
+export async function effectiveOrgPolicy(ctx, cfg, orgId) {
+    const settings = await resolveRuntimeSettings(ctx);
+    return resolveEffectiveOrganizationsPolicy(settings, orgPolicyDefaults(cfg), orgId);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Chave de sessão do desafio WebAuthn PENDENTE de REGISTRO de passkey.
+ *
+ * Mora num módulo próprio porque a cerimônia agora tem DOIS pares de rotas — o
+ * clássico (`/account/mfa/passkeys/{options,verify}`, que responde redirect numa
+ * navegação) e o JSON (`/account/api/mfa/passkeys/{options,verify}`, que nunca
+ * navega). Os dois precisam ler e escrever o MESMO slot: um `begin` feito por um
+ * caminho tem de poder ser finalizado pelo outro, e — mais importante — um
+ * desafio só pode existir UMA vez por sessão. Duas constantes com o mesmo valor
+ * em arquivos diferentes seriam a mesma coisa até alguém mudar uma delas.
+ */
+export declare const PASSKEY_REG_CHALLENGE_KEY = "authkit_passkey_reg_challenge";

package/build/src/host/passkey_registration_challenge.js

@@ -0,0 +1,12 @@
+/**
+ * Chave de sessão do desafio WebAuthn PENDENTE de REGISTRO de passkey.
+ *
+ * Mora num módulo próprio porque a cerimônia agora tem DOIS pares de rotas — o
+ * clássico (`/account/mfa/passkeys/{options,verify}`, que responde redirect numa
+ * navegação) e o JSON (`/account/api/mfa/passkeys/{options,verify}`, que nunca
+ * navega). Os dois precisam ler e escrever o MESMO slot: um `begin` feito por um
+ * caminho tem de poder ser finalizado pelo outro, e — mais importante — um
+ * desafio só pode existir UMA vez por sessão. Duas constantes com o mesmo valor
+ * em arquivos diferentes seriam a mesma coisa até alguém mudar uma delas.
+ */
+export const PASSKEY_REG_CHALLENGE_KEY = 'authkit_passkey_reg_challenge';