@adonis-agora/authkit-server 0.71.0 → 0.73.0

package/build/host/views/mfa-challenge.edge

@@ -17,8 +17,11 @@
       @end
 
       {{-- Step-up sem MFA enrolado: bloqueia o login e instrui a configurar o MFA;
-           não renderiza o campo de código (não há 2º fator a desafiar). --}}
-      @if(!noEnrollment)
+           não renderiza o campo de código (não há 2º fator a desafiar).
+           `totpAvailable === false` = a conta só tem passkey, sem app autenticador
+           confirmado: pedir um código de 6 dígitos seria pedir o impossível. Ausente
+           (stores que não reportam o estado) mantém o campo visível. --}}
+      @if(!noEnrollment && totpAvailable !== false)
         <div class="mt-6">
           <label for="code" class="mb-1 block text-sm font-medium text-gray-700">{{ t('mfa_challenge.code_label') }}</label>
           <input id="code" name="code" inputmode="numeric" autocomplete="one-time-code"
@@ -56,7 +59,9 @@
       <p id="passkey-error" class="mt-3 hidden text-sm text-red-600">{{ t('mfa_challenge.passkey_error') }}</p>
     @end
 
-    @if(!noEnrollment)
+    {{-- Códigos de recuperação só existem junto com o TOTP (são gerados no
+         enrollment); sem ele, a seção não tem o que receber. --}}
+    @if(!noEnrollment && totpAvailable !== false)
       <details class="mt-6 text-sm text-gray-600">
         <summary class="cursor-pointer hover:underline">{{ t('mfa_challenge.recovery_summary') }}</summary>
         <form method="POST" action="/auth/interaction/{{ uid }}/mfa" class="mt-3">

package/build/src/accounts/account_store.d.ts

@@ -250,10 +250,18 @@ export interface MfaCapability {
      * mecanismo de "trusted devices": um cookie de confiança emitido ANTES desse
      * instante é considerado inválido (re-enrolar MFA revoga a confiança). Pode ser
      * `null`/ausente quando o MFA não está ativo ou o store não rastreia o instante.
+     *
+     * `totp` diz se há um app autenticador CONFIRMADO (segredo + códigos de
+     * recuperação). É diferente de `enabled`: registrar uma passkey também liga o
+     * MFA, e remover a última passkey não o desliga — então `enabled` sozinho não
+     * responde "existe um segundo fator que esta pessoa consegue apresentar?".
+     * Quem decide mostrar (ou não) o desafio precisa de `totp`; stores antigos que
+     * o omitem continuam funcionando, só não distinguem os dois casos.
      */
     getMfaState(accountId: string): Promise<{
         enabled: boolean;
         enabledAt?: number | null;
+        totp?: boolean;
     }>;
     /**
      * Inicia o enrollment TOTP: gera um segredo PENDENTE (mfaEnabledAt continua

package/build/src/accounts/lucid_store/mfa.js

@@ -25,7 +25,15 @@ export function buildMfa(ctx) {
             const state = await repo.read(accountId);
             // `enabledAt` (epoch ms) habilita o trusted-device check: um cookie de
             // confiança emitido ANTES deste instante é inválido (re-enrolar revoga).
-            return { enabled: !!state?.mfaEnabledAt, enabledAt: state?.mfaEnabledAt ?? null };
+            // `totp` é o fator REALMENTE utilizável: segredo confirmado + códigos de
+            // recuperação gravados. `enabled` também liga ao registrar passkey (ver
+            // `webauthn.ts`) e não desliga ao remover a última — sozinho, não diz se
+            // sobrou algum fator para desafiar.
+            return {
+                enabled: !!state?.mfaEnabledAt,
+                enabledAt: state?.mfaEnabledAt ?? null,
+                totp: !!(state?.mfaEnabledAt && state?.totpSecret && state?.recoveryCodes),
+            };
         },
         async startTotpEnrollment(accountId) {
             // O email/QR vem do model principal; só o ESTADO de MFA vive em auth_mfa.

package/build/src/host/account_api/account_orgs_api_controller.js

@@ -52,6 +52,7 @@ import { accountPath } from '../account_paths.js';
 import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { ACTIVE_ORG_COOKIE, ACTIVE_ORG_COOKIE_TTL, encodeActiveOrgCookie, } from '../active_org_cookie.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
+import { revokeOrgAccess } from '../org_access_revocation.js';
 // Política efetiva: o MESMO módulo que o console HTML usa. Duas cópias da
 // resolução são como o espelho JSON acabaria mais frouxo que o formulário.
 import { effectiveOrgPolicy, orgPolicyDefaults } from '../org_policy.js';
@@ -213,6 +214,8 @@ export default class AccountOrgsApiController {
             }
             return ctx.response.notFound(apiErr('not_found', 'Membership not found.'));
         }
+        // Os grants que carregam esta org para a conta caem já — não no refresh.
+        await revokeOrgAccess(c.service, orgId, c.accountId);
         await c.cfg.audit?.record({
             type: 'organization.member_removed',
             accountId: c.accountId,
@@ -335,6 +338,8 @@ export default class AccountOrgsApiController {
             }
             return ctx.response.notFound(apiErr('not_found', 'Member not found in this organization.'));
         }
+        // Os grants que carregam esta org para a conta caem já — não no refresh.
+        await revokeOrgAccess(c.service, orgId, targetId);
         await c.cfg.audit?.record({
             type: 'organization.member_removed',
             actorId: c.accountId,
@@ -446,7 +451,7 @@ export default class AccountOrgsApiController {
             ctx.response.unauthorized(apiErr('unauthorized', 'Not authenticated.'));
             return null;
         }
-        return { cfg, store, accountId };
+        return { cfg, store, accountId, service };
     }
     /**
      * Exige que o ator seja owner/admin NA ORG DO PATH. Responde 403 e devolve

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

@@ -1,4 +1,4 @@
-import type { ActiveOrgInfo } from '../accounts/account_store.js';
+import type { AccountStore, ActiveOrgInfo } from '../accounts/account_store.js';
 /** Nome do cookie da org ativa. HttpOnly, SameSite=Lax, Secure em prod. */
 export declare const ACTIVE_ORG_COOKIE = "authkit_active_org";
 /** TTL máximo do cookie da org ativa (30 dias em segundos). */
@@ -51,3 +51,23 @@ export declare function normalizeActiveOrg(value: unknown): ActiveOrgInfo | null
 export declare function readActiveOrgFromHostCtx(ctx: unknown, opts?: {
     appKey?: string;
 }): ActiveOrgInfo | null;
+/**
+ * Confere, NO STORE, se a org que a sessão diz ser a ativa ainda vale para a conta,
+ * e devolve os dados ATUAIS dela — ou `null` quando não vale mais.
+ *
+ * O `activeOrg` que chega aqui é um RETRATO: foi gravado no Grant no consent (ou lido
+ * do cookie) e o refresh token o reemite por até 30 dias. Sem esta conferência, quem
+ * é removido da equipe continua recebendo `org_*` até o grant expirar, e um rebaixado
+ * continua recebendo o papel antigo. Por isso:
+ *
+ *  - a conta precisa ser membro da org AGORA (`getOrgMembership`);
+ *  - a org precisa existir AGORA (`findOrgById`) — o slug sai daqui, não do retrato;
+ *  - o papel é o da membership ATUAL, nunca o `orgRole` do retrato.
+ *
+ * Store sem `findOrgById`/`getOrgMembership`: não há como conferir, então não há
+ * claim (fail-closed). As rotas que gravam o cookie de org só existem com a capacidade.
+ *
+ * Erro do store PROPAGA: um banco fora do ar não pode virar, em silêncio, um token
+ * sem org (que o app leria como "usuário sem tenant") nem um token com a org velha.
+ */
+export declare function verifyActiveOrgMembership(store: AccountStore, accountId: string, claimed: ActiveOrgInfo | null): Promise<ActiveOrgInfo | null>;

package/build/src/host/active_org_cookie.js

@@ -158,3 +158,41 @@ export function readActiveOrgFromHostCtx(ctx, opts) {
     }
     return readActiveOrgFromKoaCtx(ctx, opts);
 }
+/**
+ * Confere, NO STORE, se a org que a sessão diz ser a ativa ainda vale para a conta,
+ * e devolve os dados ATUAIS dela — ou `null` quando não vale mais.
+ *
+ * O `activeOrg` que chega aqui é um RETRATO: foi gravado no Grant no consent (ou lido
+ * do cookie) e o refresh token o reemite por até 30 dias. Sem esta conferência, quem
+ * é removido da equipe continua recebendo `org_*` até o grant expirar, e um rebaixado
+ * continua recebendo o papel antigo. Por isso:
+ *
+ *  - a conta precisa ser membro da org AGORA (`getOrgMembership`);
+ *  - a org precisa existir AGORA (`findOrgById`) — o slug sai daqui, não do retrato;
+ *  - o papel é o da membership ATUAL, nunca o `orgRole` do retrato.
+ *
+ * Store sem `findOrgById`/`getOrgMembership`: não há como conferir, então não há
+ * claim (fail-closed). As rotas que gravam o cookie de org só existem com a capacidade.
+ *
+ * Erro do store PROPAGA: um banco fora do ar não pode virar, em silêncio, um token
+ * sem org (que o app leria como "usuário sem tenant") nem um token com a org velha.
+ */
+export async function verifyActiveOrgMembership(store, accountId, claimed) {
+    if (!claimed)
+        return null;
+    // Sonda os DOIS métodos que esta função usa — não o `createOrg` do
+    // `supportsOrganizations`. Um store com a capacidade PARCIAL (sem um deles)
+    // derrubaria todo mint com TypeError; aqui ele só deixa de emitir a claim.
+    const orgs = store;
+    if (typeof orgs.findOrgById !== 'function' || typeof orgs.getOrgMembership !== 'function') {
+        return null;
+    }
+    // Org primeiro: apagada, nem pergunta pela membership.
+    const org = await orgs.findOrgById(claimed.orgId);
+    if (!org)
+        return null;
+    const membership = await orgs.getOrgMembership(claimed.orgId, accountId);
+    if (!membership || typeof membership.role !== 'string' || !membership.role)
+        return null;
+    return { orgId: org.id, orgSlug: org.slug, orgRole: membership.role };
+}

package/build/src/host/admin_api/admin_orgs_service.d.ts

@@ -1,6 +1,7 @@
 import type { HttpContext } from '@adonisjs/core/http';
 import type { OrgInvitation, OrgMember, OrgSummary } from '../../accounts/account_store.js';
 import type { ResolvedServerConfig } from '../../define_config.js';
+import type { OidcService } from '../../provider/oidc_service.js';
 import type { SettingsCapability } from '../runtime_settings.js';
 import type { AdminActor } from './admin_users_service.js';
 export interface OrgWithMemberCount extends OrgSummary {
@@ -52,7 +53,12 @@ export type InvalidRoleResult = {
  */
 export declare class AdminOrgsService {
     private cfg;
-    constructor(cfg: ResolvedServerConfig);
+    private oidc?;
+    /**
+     * @param oidc Serviço OIDC — onde vivem os grants a revogar quando um membro sai
+     *   ou a org é apagada ({@link revokeOrgAccess}). Opcional para quem só lê.
+     */
+    constructor(cfg: ResolvedServerConfig, oidc?: Pick<OidcService, 'config'> | undefined);
     get supported(): boolean;
     /**
      * Resolve o catálogo efetivo de roles de org (runtime settings → config →

package/build/src/host/admin_api/admin_orgs_service.js

@@ -2,6 +2,7 @@ import { supportsOrganizations } from '../../accounts/account_store.js';
 import { ADMIN_LIST_DEFAULT_SIZE, LIST_FIRST_PAGE } from '../../pagination.js';
 import { accountPath } from '../account_paths.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
+import { revokeOrgAccess } from '../org_access_revocation.js';
 import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy, resolveRoleCatalogList, } from '../runtime_toggles.js';
 /**
  * Lógica de gestão de organizações compartilhada entre o console admin (HTML)
@@ -10,8 +11,14 @@ import { isRoleInCatalog, resolveEffectiveOrganizationsPolicy, resolveRoleCatalo
  */
 export class AdminOrgsService {
     cfg;
-    constructor(cfg) {
+    oidc;
+    /**
+     * @param oidc Serviço OIDC — onde vivem os grants a revogar quando um membro sai
+     *   ou a org é apagada ({@link revokeOrgAccess}). Opcional para quem só lê.
+     */
+    constructor(cfg, oidc) {
         this.cfg = cfg;
+        this.oidc = oidc;
     }
     get supported() {
         return supportsOrganizations(this.cfg.accountStore);
@@ -157,6 +164,8 @@ export class AdminOrgsService {
         if (!existing)
             return { ok: false, reason: 'not_found' };
         await store.deleteOrg(orgId);
+        // Grants que carregam esta org (de qualquer conta) caem já — não no refresh.
+        await revokeOrgAccess(this.oidc, orgId);
         await this.cfg.audit?.record({
             type: 'organization.deleted',
             actorId: actor.actorId,
@@ -210,6 +219,7 @@ export class AdminOrgsService {
                 return { ok: false, reason: 'last_owner' };
             return { ok: false, reason: 'member_not_found' };
         }
+        await revokeOrgAccess(this.oidc, orgId, accountId);
         await this.cfg.audit?.record({
             type: 'organization.member_removed',
             actorId: actor.actorId,

package/build/src/host/admin_api/api_orgs_controller.js

@@ -22,8 +22,8 @@ function notSupported(ctx) {
 export default class ApiOrgsController {
     /** GET /organizations — lista todas as orgs com contagem de membros. */
     async index(ctx) {
-        const { cfg } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const result = await svc.listOrgs();
         if (!Array.isArray(result)) {
             if (result.reason === 'not_supported')
@@ -36,8 +36,8 @@ export default class ApiOrgsController {
     }
     /** POST /organizations — cria uma org. Body: { name, slug, ownerAccountId, logoUrl? } */
     async store(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const { name, slug, ownerAccountId, logoUrl } = await ctx.request.validateUsing(orgCreateValidator);
         const result = await svc.createOrg({ name, slug, logoUrl: logoUrl ?? null, ownerAccountId }, actor);
         if ('ok' in result && result.ok === false) {
@@ -50,8 +50,8 @@ export default class ApiOrgsController {
     }
     /** GET /organizations/:id — obtém uma org com membros e convites. */
     async show(ctx) {
-        const { cfg } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const id = ctx.request.param('id');
         const result = await svc.getOrg(id);
         if ('ok' in result && result.ok === false) {
@@ -63,8 +63,8 @@ export default class ApiOrgsController {
     }
     /** PATCH /organizations/:id — atualiza nome e/ou logo. */
     async update(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const id = ctx.request.param('id');
         const { name, logoUrl } = await ctx.request.validateUsing(orgUpdateValidator);
         const patch = {};
@@ -84,8 +84,8 @@ export default class ApiOrgsController {
     }
     /** DELETE /organizations/:id */
     async destroy(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const id = ctx.request.param('id');
         const result = await svc.deleteOrg(id, actor);
         if (!result.ok) {
@@ -97,8 +97,8 @@ export default class ApiOrgsController {
     }
     /** POST /organizations/:id/members — adiciona membro. Body: { accountId, role } */
     async addMember(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const orgId = ctx.request.param('id');
         const { accountId, role } = await ctx.request.validateUsing(orgAddMemberValidator);
         const result = await svc.addMember(orgId, { accountId, role: role ?? 'member' }, actor, await resolveRuntimeSettings(ctx));
@@ -116,8 +116,8 @@ export default class ApiOrgsController {
     }
     /** DELETE /organizations/:id/members/:accountId */
     async removeMember(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const orgId = ctx.request.param('id');
         const accountId = ctx.request.param('accountId');
         const result = await svc.removeMember(orgId, accountId, actor);
@@ -134,8 +134,8 @@ export default class ApiOrgsController {
     }
     /** PATCH /organizations/:id/members/:accountId — troca o papel. Body: { role } */
     async updateMemberRole(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const orgId = ctx.request.param('id');
         const accountId = ctx.request.param('accountId');
         const { role } = await ctx.request.validateUsing(orgMemberRoleValidator);
@@ -155,8 +155,8 @@ export default class ApiOrgsController {
     }
     /** POST /organizations/:id/invitations — cria convite. Body: { email, role } */
     async createInvitation(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const orgId = ctx.request.param('id');
         const { email, role } = await ctx.request.validateUsing(orgInvitationValidator);
         const origin = authkitOrigin(cfg);
@@ -173,8 +173,8 @@ export default class ApiOrgsController {
     }
     /** DELETE /organizations/:id/invitations/:invitationId */
     async revokeInvitation(ctx) {
-        const { cfg, actor } = await ctxBits(ctx);
-        const svc = new AdminOrgsService(cfg);
+        const { cfg, actor, service } = await ctxBits(ctx);
+        const svc = new AdminOrgsService(cfg, service);
         const orgId = ctx.request.param('id');
         const invitationId = ctx.request.param('invitationId');
         const result = await svc.revokeInvitation(orgId, invitationId, actor);

package/build/src/host/admin_console/console_orgs_controller.js

@@ -23,7 +23,7 @@ import { resolveRuntimeSettings } from '../runtime_settings.js';
 export default class ConsoleOrgsController {
     async svc(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
-        return new AdminOrgsService(service.config);
+        return new AdminOrgsService(service.config, service);
     }
     actor(ctx) {
         return {

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

@@ -118,4 +118,25 @@ export declare class AdminSessionsService {
      * contagens do que foi removido.
      */
     revokeClientGrants(accountId: string, clientId: string): Promise<RevokeResult>;
+    /**
+     * Revoga os grants que carregam a org `orgId` como org ativa (`Grant.activeOrg`,
+     * gravado no consent) — de UMA conta (`accountId`) ou de TODAS (omitido, usado
+     * quando a org é apagada). Destrói os AT/RT desses grants e os próprios grants,
+     * como {@link revokeClientGrants}; depois grava a revogação por `sub` de cada conta
+     * afetada, para que clients COOKIE-BASED derrubem a sessão já na próxima request.
+     *
+     * Por que existe: o `org_*` do token sai do grant. Quem é removido da org (ou
+     * perde a org inteira) seguiria com o access token e o refresh token daquele grant
+     * até o fim do TTL. A emissão já confere a membership no store a cada mint (ver
+     * `verifyActiveOrgMembership`); esta revogação faz a mudança valer AGORA — o
+     * access token opaco para de introspectar, o refresh falha e o client volta ao
+     * authorize, onde o novo grant sai sem a org.
+     *
+     * Grants de OUTRAS orgs (e sem org) ficam intactos. Sessões do IdP não carregam
+     * org (a org vive no grant e no cookie), então não são tocadas.
+     *
+     * Sem enumeração no adapter não há como achar os grants: devolve zeros e fica
+     * valendo só a conferência da emissão (no próximo refresh).
+     */
+    revokeOrgGrants(orgId: string, accountId?: string): Promise<RevokeResult>;
 }

package/build/src/host/admin_sessions_service.js

@@ -1,5 +1,6 @@
 import { getBootedApp } from '../../services/booted_app.js';
 import { pickModelAdapterClass } from '../adapters/factory.js';
+import { normalizeActiveOrg } from './active_org_cookie.js';
 /**
  * Serviço de inspeção/revogação das SESSÕES e GRANTS ativos de uma conta.
  * Lê/escreve via `pickModelAdapterClass` (a MESMA regra do provider): com
@@ -302,6 +303,54 @@ export class AdminSessionsService {
         }
         return { sessions: 0, grants: grants.length, accessTokens, refreshTokens };
     }
+    /**
+     * Revoga os grants que carregam a org `orgId` como org ativa (`Grant.activeOrg`,
+     * gravado no consent) — de UMA conta (`accountId`) ou de TODAS (omitido, usado
+     * quando a org é apagada). Destrói os AT/RT desses grants e os próprios grants,
+     * como {@link revokeClientGrants}; depois grava a revogação por `sub` de cada conta
+     * afetada, para que clients COOKIE-BASED derrubem a sessão já na próxima request.
+     *
+     * Por que existe: o `org_*` do token sai do grant. Quem é removido da org (ou
+     * perde a org inteira) seguiria com o access token e o refresh token daquele grant
+     * até o fim do TTL. A emissão já confere a membership no store a cada mint (ver
+     * `verifyActiveOrgMembership`); esta revogação faz a mudança valer AGORA — o
+     * access token opaco para de introspectar, o refresh falha e o client volta ao
+     * authorize, onde o novo grant sai sem a org.
+     *
+     * Grants de OUTRAS orgs (e sem org) ficam intactos. Sessões do IdP não carregam
+     * org (a org vive no grant e no cookie), então não são tocadas.
+     *
+     * Sem enumeração no adapter não há como achar os grants: devolve zeros e fica
+     * valendo só a conferência da emissão (no próximo refresh).
+     */
+    async revokeOrgGrants(orgId, accountId) {
+        const grantAdapter = this.#adapter('Grant');
+        const rows = await this.#listModel('Grant');
+        const grants = rows.filter((r) => {
+            if (normalizeActiveOrg(r.payload.activeOrg)?.orgId !== orgId)
+                return false;
+            return accountId === undefined || r.payload.accountId === accountId;
+        });
+        if (grants.length === 0) {
+            return { sessions: 0, grants: 0, accessTokens: 0, refreshTokens: 0 };
+        }
+        const grantIds = new Set(grants.map((g) => g.id));
+        const accessTokens = await this.#destroyTokensOfGrants('AccessToken', grantIds);
+        const refreshTokens = await this.#destroyTokensOfGrants('RefreshToken', grantIds);
+        for (const g of grants) {
+            await grantAdapter.revokeByGrantId(g.id);
+            await grantAdapter.destroy(g.id);
+        }
+        // Clients cookie-based não têm refresh para falhar: sem a linha por `sub`, o
+        // id_token com a org velha seguiria valendo na sessão do client até expirar.
+        const accounts = new Set(grants
+            .map((g) => g.payload.accountId)
+            .filter((id) => typeof id === 'string' && id.length > 0));
+        for (const id of accounts) {
+            await this.recordSubRevocation(id);
+        }
+        return { sessions: 0, grants: grants.length, accessTokens, refreshTokens };
+    }
     /** Destrói (quando enumerável) os artefatos de um model token cujos grantId estão em `grantIds`. */
     async #destroyTokensOfGrants(model, grantIds) {
         const adapter = this.#adapter(model);

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

@@ -6,6 +6,7 @@ import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
 import { ACTIVE_ORG_COOKIE, ACTIVE_ORG_COOKIE_TTL, encodeActiveOrgCookie, } from '../active_org_cookie.js';
 import { sendOrgInvitationEmail } from '../default_mailer.js';
 import { ensureConsoleSession } from '../idp_session_bridge.js';
+import { revokeOrgAccess } from '../org_access_revocation.js';
 // Política efetiva compartilhada com o espelho JSON (`account_orgs_api_controller`):
 // ponto de verdade único, para as duas superfícies nunca divergirem.
 import { effectiveOrgPolicy, orgPolicyDefaults } from '../org_policy.js';
@@ -154,6 +155,7 @@ export default class AccountOrgsController {
             return response.forbidden();
         const result = await store.removeOrgMember(params.id, accountId);
         if (result.ok) {
+            await revokeOrgAccess(service, params.id, accountId);
             await cfg.audit?.record({
                 type: 'organization.member_removed',
                 accountId,
@@ -314,6 +316,7 @@ export default class AccountOrgsController {
         }
         const result = await store.removeOrgMember(params.id, params.accountId);
         if (result.ok) {
+            await revokeOrgAccess(service, params.id, params.accountId);
             await cfg.audit?.record({
                 type: 'organization.member_removed',
                 actorId,

package/build/src/host/controllers/interaction_controller.d.ts

@@ -41,6 +41,51 @@ export default class AuthInteractionController {
      * Retorna `undefined` quando não há step-up — completeLogin usa o default.
      */
     private stepUpExtra;
+    /**
+     * acr/amr de um login que PASSOU pelo desafio do 2º fator: `amr` =
+     * `[primário, 'mfa', método]` (RFC 8176), SEMPRE — não só no step-up. Antes o
+     * `completeLogin` só recebia amr no step-up; fora dele o id_token saía sem `amr`
+     * nenhum, e o fator primário (senha ou e-mail) se perdia. O step-up continua
+     * carimbando o `acr`.
+     *
+     * `primary` ausente (sessão gravada antes desta versão, ou valor adulterado):
+     * o amr sai sem o primário, em vez de inventar um.
+     */
+    private mfaCompletion;
+    /**
+     * Lê E esquece o desafio pendente do 2º fator (accountId + fator primário). Os
+     * dois saem juntos: um primário sobrando na sessão não pode colar no próximo login.
+     */
+    private takeMfaPending;
+    /**
+     * Gate do segundo fator, compartilhado pelos caminhos de login: senha, link
+     * mágico, código por e-mail e troca forçada de senha. Antes disto só o login
+     * por senha passava pelo MFA — link e código completavam a interaction direto,
+     * então uma conta com TOTP ou passkey entrava apresentando só o e-mail e o
+     * segundo fator virava enfeite.
+     *
+     * A pergunta que o gate responde é "existe um fator que esta pessoa consegue
+     * apresentar AGORA?", e não `mfa.enabled` — que liga ao registrar uma passkey
+     * e não desliga ao remover a última. Fator utilizável = TOTP confirmado
+     * (`mfa.totp`) OU ao menos uma passkey registrada. Pela regra antiga, quem
+     * registrava uma passkey e depois a removia ficava preso num desafio TOTP que
+     * não tinha como responder.
+     *
+     *  - sem fator e sem step-up → `none`, o login segue;
+     *  - step-up (acr) exigindo MFA numa conta sem fator → `challenge` com a
+     *    instrução de enrolar (não há o que desafiar);
+     *  - fator presente, trusted-device válido e sem step-up → `trusted`; quem
+     *    chamou decide como finalizar, porque o amr muda conforme o caminho;
+     *  - caso geral → `challenge`, com o accountId em `MFA_PENDING_KEY` e o fator
+     *    primário (`primary`) em `MFA_PRIMARY_KEY`.
+     */
+    private secondFactorGate;
+    /**
+     * true se a conta tem um app autenticador CONFIRMADO. Stores que não reportam
+     * `totp` (a chave é opcional em {@link MfaCapability}) caem no `enabled`, o
+     * comportamento antigo.
+     */
+    private hasTotp;
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     private hasPasskeys;
     /**

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

@@ -45,6 +45,12 @@ function accountStatusErrorKey(reason) {
 const SESSION_KEY = 'authkit_login_email';
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
+/**
+ * Fator PRIMÁRIO que levou ao desafio do 2º fator (`pwd` ou `email`), guardado JUNTO
+ * do {@link MFA_PENDING_KEY}. Sem ele, quem completa o 2º fator não sabe como o login
+ * começou e o `amr` do id_token perdia o primeiro fator (ver `mfaCompletion`).
+ */
+const MFA_PRIMARY_KEY = 'authkit_mfa_primary';
 /** Desafio WebAuthn pendente (autenticação) guardado entre begin/finish no login. */
 const PASSKEY_AUTH_CHALLENGE_KEY = 'authkit_passkey_auth_challenge';
 /**
@@ -405,55 +411,24 @@ export default class AuthInteractionController {
             }
             // Admin: prossegue normalmente (sem bloqueio).
         }
-        // Step-up auth (acr_values): o client pode EXIGIR MFA nesta requisição
-        // solicitando o `mfaAcr` em acr_values, mesmo que a conta tenha MFA opcional.
-        const mfaRequired = this.acrRequiresMfa(cfg, details);
-        // MFA gate: força o 2º fator se a conta tem TOTP ativo OU se o client exige MFA
-        // via acr. Não finaliza a interaction agora — guarda o accountId pendente.
-        const mfa = (await cfg.accountStore.getMfaState?.(acc.id)) ?? { enabled: false };
-        if (mfa.enabled || mfaRequired) {
-            if (mfaRequired && !mfa.enabled) {
-                // Client exige MFA mas a conta não tem MFA enrolado: bloqueia este login
-                // com a instrução de configurar MFA no console (não há 2º fator a desafiar).
-                return render(ctx, 'mfa-challenge', {
-                    uid: ctx.request.param('uid'),
-                    csrfToken: ctx.request.csrfToken,
-                    brand,
-                    passkeyAvailable: false,
-                    error: translate(cfg.messages, 'mfa_challenge.required_no_enrollment'),
-                    noEnrollment: true,
-                });
-            }
-            // Trusted device: se o mecanismo está ligado, a conta JÁ tem MFA enrolado e
-            // o request NÃO é um step-up (que sempre força o MFA), um cookie de confiança
-            // válido para ESTA conta pula o 2º fator. amr fica `['pwd']` (sem acr de MFA).
-            if (cfg.trustedDevices.enabled && mfa.enabled && !mfaRequired) {
-                const trusted = await this.checkTrustedDevice(ctx, acc.id, mfa.enabledAt ?? null);
-                if (trusted) {
-                    await service.interactions.completeLogin(ctx, acc.id, { amr: ['pwd'] });
-                    await notifyLoginSuccess(ctx, cfg, {
-                        accountId: acc.id,
-                        email,
-                        ip,
-                        clientId,
-                        trustedDevice: true,
-                    });
-                    forgetLoginEmail(ctx);
-                    return;
-                }
-            }
-            ctx.session.put(MFA_PENDING_KEY, acc.id);
-            // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
-            // tem ao menos uma credencial registrada.
-            const passkeyAvailable = await this.hasPasskeys(cfg, acc.id);
-            return render(ctx, 'mfa-challenge', {
-                uid: ctx.request.param('uid'),
-                csrfToken: ctx.request.csrfToken,
-                brand,
-                passkeyAvailable,
-                trustedDevicesEnabled: cfg.trustedDevices.enabled,
-                trustedDeviceDays: cfg.trustedDevices.days,
+        // Gate do 2º fator — a MESMA regra dos três caminhos de login (ver
+        // `secondFactorGate`). Quando desafia, não finaliza a interaction: guarda o
+        // accountId pendente e devolve a tela.
+        const gate = await this.secondFactorGate(ctx, cfg, acc.id, details, 'pwd');
+        if (gate.kind === 'challenge')
+            return gate.response;
+        if (gate.kind === 'trusted') {
+            // Dispositivo confiável: pula o 2º fator. amr fica `['pwd']` (sem acr de MFA).
+            await service.interactions.completeLogin(ctx, acc.id, { amr: ['pwd'] });
+            await notifyLoginSuccess(ctx, cfg, {
+                accountId: acc.id,
+                email,
+                ip,
+                clientId,
+                trustedDevice: true,
             });
+            forgetLoginEmail(ctx);
+            return;
         }
         // Sem MFA: finaliza a interaction (escreve o 303 de volta para o client).
         // Resolve session_policy para remember-me e single-session.
@@ -531,6 +506,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.otp_locked'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
                 otpLocked: true,
@@ -564,6 +540,7 @@ export default class AuthInteractionController {
                     error: translate(cfg.messages, 'errors.otp_locked'),
                     brand,
                     passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                    totpAvailable: await this.hasTotp(cfg, accountId),
                     trustedDevicesEnabled: cfg.trustedDevices.enabled,
                     trustedDeviceDays: cfg.trustedDevices.days,
                     otpLocked: true,
@@ -575,6 +552,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.invalid_code'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -584,7 +562,7 @@ export default class AuthInteractionController {
         // Sucesso no 2º fator: opcionalmente confia neste dispositivo (checkbox).
         await this.maybeTrustDevice(ctx, cfg, accountId);
         // Finaliza a interaction para o accountId pendente.
-        ctx.session.forget(MFA_PENDING_KEY);
+        const { primary } = this.takeMfaPending(ctx);
         forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
@@ -592,9 +570,9 @@ export default class AuthInteractionController {
             clientId,
             metadata: { mfa: usedRecovery ? 'recovery' : 'totp' },
         });
-        // Step-up: um 2º fator foi de fato verificado — carimba acr/amr no id_token
-        // se o client solicitou o mfaAcr nesta requisição.
-        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, usedRecovery ? 'recovery' : 'totp'));
+        // Um 2º fator foi de fato verificado: amr = [primário, 'mfa', método]. Com
+        // step-up (mfaAcr solicitado nesta requisição), carimba também o acr.
+        await service.interactions.completeLogin(ctx, accountId, this.mfaCompletion(cfg, details, primary, usedRecovery ? 'recovery' : 'totp'));
     }
     /**
      * true se o authorize request exige MFA via acr_values (contém o mfaAcr da
@@ -619,6 +597,113 @@ export default class AuthInteractionController {
             return undefined;
         return { acr: cfg.stepUp.mfaAcr, amr: ['mfa', method] };
     }
+    /**
+     * acr/amr de um login que PASSOU pelo desafio do 2º fator: `amr` =
+     * `[primário, 'mfa', método]` (RFC 8176), SEMPRE — não só no step-up. Antes o
+     * `completeLogin` só recebia amr no step-up; fora dele o id_token saía sem `amr`
+     * nenhum, e o fator primário (senha ou e-mail) se perdia. O step-up continua
+     * carimbando o `acr`.
+     *
+     * `primary` ausente (sessão gravada antes desta versão, ou valor adulterado):
+     * o amr sai sem o primário, em vez de inventar um.
+     */
+    mfaCompletion(cfg, details, primary, method) {
+        const amr = [...(primary ? [primary] : []), 'mfa', method];
+        const stepUp = this.stepUpExtra(cfg, details, method);
+        return stepUp ? { acr: stepUp.acr, amr } : { amr };
+    }
+    /**
+     * Lê E esquece o desafio pendente do 2º fator (accountId + fator primário). Os
+     * dois saem juntos: um primário sobrando na sessão não pode colar no próximo login.
+     */
+    takeMfaPending(ctx) {
+        const raw = ctx.session.get(MFA_PRIMARY_KEY);
+        ctx.session.forget(MFA_PENDING_KEY);
+        ctx.session.forget(MFA_PRIMARY_KEY);
+        return { primary: raw === 'pwd' || raw === 'email' ? raw : undefined };
+    }
+    /**
+     * Gate do segundo fator, compartilhado pelos caminhos de login: senha, link
+     * mágico, código por e-mail e troca forçada de senha. Antes disto só o login
+     * por senha passava pelo MFA — link e código completavam a interaction direto,
+     * então uma conta com TOTP ou passkey entrava apresentando só o e-mail e o
+     * segundo fator virava enfeite.
+     *
+     * A pergunta que o gate responde é "existe um fator que esta pessoa consegue
+     * apresentar AGORA?", e não `mfa.enabled` — que liga ao registrar uma passkey
+     * e não desliga ao remover a última. Fator utilizável = TOTP confirmado
+     * (`mfa.totp`) OU ao menos uma passkey registrada. Pela regra antiga, quem
+     * registrava uma passkey e depois a removia ficava preso num desafio TOTP que
+     * não tinha como responder.
+     *
+     *  - sem fator e sem step-up → `none`, o login segue;
+     *  - step-up (acr) exigindo MFA numa conta sem fator → `challenge` com a
+     *    instrução de enrolar (não há o que desafiar);
+     *  - fator presente, trusted-device válido e sem step-up → `trusted`; quem
+     *    chamou decide como finalizar, porque o amr muda conforme o caminho;
+     *  - caso geral → `challenge`, com o accountId em `MFA_PENDING_KEY` e o fator
+     *    primário (`primary`) em `MFA_PRIMARY_KEY`.
+     */
+    async secondFactorGate(ctx, cfg, accountId, details, primary) {
+        const mfaRequired = this.acrRequiresMfa(cfg, details);
+        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
+        // Passkey disponível como alternativa ao TOTP se o store suporta E a conta
+        // tem ao menos uma credencial registrada.
+        const passkeyAvailable = await this.hasPasskeys(cfg, accountId);
+        // Store que não reporta `totp` (a chave é opcional) cai no `enabled` — o
+        // comportamento antigo. Nunca o contrário: assumir "sem TOTP" por omissão
+        // deixaria de desafiar quem tem o fator.
+        const totpAvailable = mfa.totp ?? !!mfa.enabled;
+        const hasFactor = passkeyAvailable || totpAvailable;
+        if (!hasFactor && !mfaRequired)
+            return { kind: 'none' };
+        const render = cfg.render;
+        const brand = brandFor(cfg.branding, details.params.client_id, details.params.audience);
+        const uid = ctx.request.param('uid');
+        if (!hasFactor) {
+            return {
+                kind: 'challenge',
+                response: await render(ctx, 'mfa-challenge', {
+                    uid,
+                    csrfToken: ctx.request.csrfToken,
+                    brand,
+                    passkeyAvailable: false,
+                    error: translate(cfg.messages, 'mfa_challenge.required_no_enrollment'),
+                    noEnrollment: true,
+                }),
+            };
+        }
+        if (cfg.trustedDevices.enabled && !mfaRequired) {
+            const trusted = await this.checkTrustedDevice(ctx, accountId, mfa.enabledAt ?? null);
+            if (trusted)
+                return { kind: 'trusted' };
+        }
+        ctx.session.put(MFA_PENDING_KEY, accountId);
+        // O fator primário viaja junto: quem completa o desafio (TOTP, recovery ou
+        // passkey) precisa dele para montar o `amr` inteiro.
+        ctx.session.put(MFA_PRIMARY_KEY, primary);
+        return {
+            kind: 'challenge',
+            response: await render(ctx, 'mfa-challenge', {
+                uid,
+                csrfToken: ctx.request.csrfToken,
+                brand,
+                passkeyAvailable,
+                totpAvailable,
+                trustedDevicesEnabled: cfg.trustedDevices.enabled,
+                trustedDeviceDays: cfg.trustedDevices.days,
+            }),
+        };
+    }
+    /**
+     * true se a conta tem um app autenticador CONFIRMADO. Stores que não reportam
+     * `totp` (a chave é opcional em {@link MfaCapability}) caem no `enabled`, o
+     * comportamento antigo.
+     */
+    async hasTotp(cfg, accountId) {
+        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
+        return mfa.totp ?? !!mfa.enabled;
+    }
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     async hasPasskeys(cfg, accountId) {
         if (!supportsPasskeys(cfg.accountStore))
@@ -920,12 +1005,21 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, accountStatusErrorKey(magicLinkStatusGate.reason)),
             });
         }
+        // Conta com segundo fator não termina o login só com o e-mail.
+        const magicGate = await this.secondFactorGate(ctx, cfg, acc.id, await service.interactions.details(ctx), 'email');
+        if (magicGate.kind === 'challenge')
+            return magicGate.response;
         await notifyLoginSuccess(ctx, cfg, {
             accountId: acc.id,
             email: acc.email,
             ip,
             clientId: clientId ?? null,
             metadata: { method: 'magic_link' },
+            // `trusted` = o gate já validou o cookie de confiança nesta request; dizer
+            // isso aqui poupa `notifyLoginSuccess` de reler o mesmo cookie para decidir
+            // se é dispositivo novo. O amr continua `['email']`: o fator primário foi o
+            // e-mail, a confiança só dispensou o segundo.
+            trustedDevice: magicGate.kind === 'trusted',
         });
         forgetLoginEmail(ctx);
         await service.interactions.completeLogin(ctx, acc.id, { amr: ['email'] });
@@ -1033,12 +1127,17 @@ export default class AuthInteractionController {
                 ip,
                 clientId,
             });
+            // Conta com segundo fator não termina o login só com o código do e-mail.
+            const otpGate = await this.secondFactorGate(ctx, cfg, result.account.id, await service.interactions.details(ctx), 'email');
+            if (otpGate.kind === 'challenge')
+                return otpGate.response;
             await notifyLoginSuccess(ctx, cfg, {
                 accountId: result.account.id,
                 email: result.account.email,
                 ip,
                 clientId: clientId ?? null,
                 metadata: { method: 'otp' },
+                trustedDevice: otpGate.kind === 'trusted',
             });
             forgetLoginEmail(ctx);
             return service.interactions.completeLogin(ctx, result.account.id, { amr: ['email'] });
@@ -1225,6 +1324,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'mfa_challenge.passkey_error'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -1247,6 +1347,7 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, 'errors.email_unverified'),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
@@ -1277,13 +1378,17 @@ export default class AuthInteractionController {
                 error: translate(cfg.messages, accountStatusErrorKey(passkeyStatusGate.reason)),
                 brand,
                 passkeyAvailable: await this.hasPasskeys(cfg, accountId),
+                totpAvailable: await this.hasTotp(cfg, accountId),
                 trustedDevicesEnabled: cfg.trustedDevices.enabled,
                 trustedDeviceDays: cfg.trustedDevices.days,
             });
         }
         // Passkey OK: opcionalmente confia neste dispositivo (checkbox no challenge).
         await this.maybeTrustDevice(ctx, cfg, accountId);
-        ctx.session.forget(MFA_PENDING_KEY);
+        // Passkey como 2º fator (havia desafio pendente) ou passkey-first (não havia)?
+        // Lido ANTES de esquecer: é o que decide o amr abaixo.
+        const wasSecondFactor = ctx.session.get(MFA_PENDING_KEY) === accountId;
+        const { primary } = this.takeMfaPending(ctx);
         forgetLoginEmail(ctx);
         await notifyLoginSuccess(ctx, cfg, {
             accountId,
@@ -1291,9 +1396,12 @@ export default class AuthInteractionController {
             clientId,
             metadata: { mfa: 'webauthn' },
         });
-        // Step-up carimba acr/amr quando solicitado; senão a passkey conta como o fator
-        // forte do login (amr `['webauthn']`) — vale tanto p/ MFA quanto passkey-first.
-        await service.interactions.completeLogin(ctx, accountId, this.stepUpExtra(cfg, details, 'webauthn') ?? { amr: ['webauthn'] });
+        // 2º fator: amr = [primário, 'mfa', 'webauthn'] (+ acr no step-up), igual ao
+        // TOTP. Passkey-first: a passkey É o login (amr `['webauthn']`); o step-up
+        // carimba acr/amr quando solicitado.
+        await service.interactions.completeLogin(ctx, accountId, wasSecondFactor
+            ? this.mfaCompletion(cfg, details, primary, 'webauthn')
+            : (this.stepUpExtra(cfg, details, 'webauthn') ?? { amr: ['webauthn'] }));
     }
     /**
      * GET /auth/interaction/:uid/switch
@@ -1373,20 +1481,10 @@ export default class AuthInteractionController {
         });
         // Senha trocada: limpa o step e finaliza o login.
         ctx.session.forget(PASSWORD_EXPIRED_KEY);
-        // Verifica se precisa de MFA mesmo após a troca.
-        const mfa = (await cfg.accountStore.getMfaState?.(accountId)) ?? { enabled: false };
-        if (mfa.enabled) {
-            ctx.session.put(MFA_PENDING_KEY, accountId);
-            const passkeyAvailable = await this.hasPasskeys(cfg, accountId);
-            return render(ctx, 'mfa-challenge', {
-                uid: ctx.request.param('uid'),
-                csrfToken: ctx.request.csrfToken,
-                brand,
-                passkeyAvailable,
-                trustedDevicesEnabled: cfg.trustedDevices.enabled,
-                trustedDeviceDays: cfg.trustedDevices.days,
-            });
-        }
+        // Verifica se precisa de MFA mesmo após a troca — mesma regra do resto.
+        const expiredGate = await this.secondFactorGate(ctx, cfg, accountId, details, 'pwd');
+        if (expiredGate.kind === 'challenge')
+            return expiredGate.response;
         await service.interactions.completeLogin(ctx, accountId);
         const account = await cfg.accountStore.findById(accountId);
         await notifyLoginSuccess(ctx, cfg, {

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

@@ -0,0 +1,20 @@
+import type { OidcService } from '../provider/oidc_service.js';
+import { type RevokeResult } from './admin_sessions_service.js';
+/**
+ * Derruba os grants (e os tokens deles) que carregam a org `orgId` — de uma conta
+ * (membro removido / saiu da org) ou de todas (org apagada, `accountId` omitido).
+ *
+ * Chamado DEPOIS que o store confirmou a remoção. Os quatro caminhos que removem
+ * membro (form `/account/orgs`, `/account/api/orgs`, console admin, Admin API) e o
+ * `deleteOrg` passam por aqui, para que a regra seja uma só.
+ *
+ * Best-effort, e nunca silencioso: a membership JÁ saiu do store, então falhar a
+ * request aqui só mentiria para quem removeu ("deu erro", mas o membro saiu). A
+ * conferência da emissão (`verifyActiveOrgMembership`) continua sendo a rede de
+ * segurança — no pior caso, o claim cai no próximo refresh. A falha é logada em
+ * `error`, porque uma revogação que não aconteceu precisa aparecer.
+ *
+ * `service` sem `config.AdapterClass` (um ctx de teste que só carrega a config)
+ * não tem adapter OIDC onde revogar: devolve `null` sem tentar.
+ */
+export declare function revokeOrgAccess(service: Pick<OidcService, 'config'> | undefined, orgId: string, accountId?: string): Promise<RevokeResult | null>;

package/build/src/host/org_access_revocation.js

@@ -0,0 +1,41 @@
+import { getBootedApp } from '../../services/booted_app.js';
+import { AdminSessionsService } from './admin_sessions_service.js';
+/**
+ * Derruba os grants (e os tokens deles) que carregam a org `orgId` — de uma conta
+ * (membro removido / saiu da org) ou de todas (org apagada, `accountId` omitido).
+ *
+ * Chamado DEPOIS que o store confirmou a remoção. Os quatro caminhos que removem
+ * membro (form `/account/orgs`, `/account/api/orgs`, console admin, Admin API) e o
+ * `deleteOrg` passam por aqui, para que a regra seja uma só.
+ *
+ * Best-effort, e nunca silencioso: a membership JÁ saiu do store, então falhar a
+ * request aqui só mentiria para quem removeu ("deu erro", mas o membro saiu). A
+ * conferência da emissão (`verifyActiveOrgMembership`) continua sendo a rede de
+ * segurança — no pior caso, o claim cai no próximo refresh. A falha é logada em
+ * `error`, porque uma revogação que não aconteceu precisa aparecer.
+ *
+ * `service` sem `config.AdapterClass` (um ctx de teste que só carrega a config)
+ * não tem adapter OIDC onde revogar: devolve `null` sem tentar.
+ */
+export async function revokeOrgAccess(service, orgId, accountId) {
+    if (!service?.config?.AdapterClass)
+        return null;
+    try {
+        return await new AdminSessionsService(service).revokeOrgGrants(orgId, accountId);
+    }
+    catch (error) {
+        await logFailure(error, orgId, accountId);
+        return null;
+    }
+}
+async function logFailure(error, orgId, accountId) {
+    const msg = 'authkit: falha ao revogar os grants da org — o claim de org cai só no próximo refresh';
+    try {
+        const logger = await getBootedApp().container.make('logger');
+        logger.error({ err: error, orgId, accountId }, msg);
+    }
+    catch {
+        // eslint-disable-next-line no-console
+        console.error(msg, { orgId, accountId, error });
+    }
+}

package/build/src/provider/oidc_service.js

@@ -2,7 +2,7 @@ import { timingSafeEqual } from 'node:crypto';
 import { NoopRecorder } from '@adonis-agora/authkit-core';
 import Koa from 'koa';
 import mount from 'koa-mount';
-import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
+import { normalizeActiveOrg, readActiveOrgFromKoaCtx, verifyActiveOrgMembership, } from '../host/active_org_cookie.js';
 import { isFirstPartyClient } from '../host/branding.js';
 import { listKeyInfos, signingKeyAgeDays } from '../keys/keystore.js';
 import { wireProviderEvents } from '../observability/wire_provider_events.js';
@@ -87,8 +87,15 @@ export class OidcService {
                 // — server-a-servidor, SEM cookies — então o cookie abaixo não existe
                 // ali. O cookie continua como FALLBACK para fluxos em que o id_token
                 // sai no próprio authorize (implicit/hybrid), onde a request é do browser.
-                const activeOrg = normalizeActiveOrg(ctx?.oidc?.entities?.Grant?.activeOrg) ??
+                const claimedOrg = normalizeActiveOrg(ctx?.oidc?.entities?.Grant?.activeOrg) ??
                     readActiveOrgFromKoaCtx(ctx);
+                // O `claimedOrg` é um RETRATO do consent (ou do cookie): o refresh o
+                // reemite por até 30 dias. Antes de virar claim, ele é conferido no store
+                // — membership e org ATUAIS, papel ATUAL (ver `verifyActiveOrgMembership`).
+                // Memoizado por chamada de `findAccount`: `claims()` pode rodar mais de uma
+                // vez no mesmo mint (id_token + userinfo) e a pergunta é a mesma.
+                let verifiedOrg;
+                const currentOrg = () => (verifiedOrg ??= verifyActiveOrgMembership(config.accountStore, user.id, claimedOrg));
                 // GATE de least-privilege: roles globais e claims de org só são emitidas
                 // para clients FIRST-PARTY. Capturamos o clientId aqui (fora do closure
                 // `claims()`, pois o `ctx` da request vive neste escopo).
@@ -119,10 +126,12 @@ export class OidcService {
                         };
                         // roles/org_* são dados de autorização interna: só para first-party.
                         if (firstParty) {
+                            const activeOrg = await currentOrg();
                             base[config.globalRolesClaim] = config.resolveTokenRoles
                                 ? await config.resolveTokenRoles(user, { clientId, activeOrg })
                                 : (user.globalRoles ?? []);
-                            // Emite claims de org somente quando há uma org ativa na sessão.
+                            // Emite claims de org somente quando há uma org ativa na sessão E a
+                            // conta ainda é membro dela (conferido no store, papel atual).
                             if (activeOrg) {
                                 base.org_id = activeOrg.orgId;
                                 base.org_slug = activeOrg.orgSlug;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.71.0",
+  "version": "0.73.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",