@adonis-agora/authkit-server 0.72.0 → 0.73.0

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,22 @@ 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
@@ -60,7 +76,8 @@ export default class AuthInteractionController {
      *    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`.
+     *  - caso geral → `challenge`, com o accountId em `MFA_PENDING_KEY` e o fator
+     *    primário (`primary`) em `MFA_PRIMARY_KEY`.
      */
     private secondFactorGate;
     /**

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';
 /**
@@ -408,7 +414,7 @@ export default class AuthInteractionController {
         // 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);
+        const gate = await this.secondFactorGate(ctx, cfg, acc.id, details, 'pwd');
         if (gate.kind === 'challenge')
             return gate.response;
         if (gate.kind === 'trusted') {
@@ -556,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,
@@ -564,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
@@ -591,6 +597,31 @@ 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
@@ -610,9 +641,10 @@ export default class AuthInteractionController {
      *    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`.
+     *  - 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) {
+    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
@@ -647,6 +679,9 @@ export default class AuthInteractionController {
                 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', {
@@ -971,7 +1006,7 @@ export default class AuthInteractionController {
             });
         }
         // 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));
+        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, {
@@ -1093,7 +1128,7 @@ export default class AuthInteractionController {
                 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));
+            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, {
@@ -1350,7 +1385,10 @@ export default class AuthInteractionController {
         }
         // 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,
@@ -1358,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
@@ -1441,7 +1482,7 @@ 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 — mesma regra do resto.
-        const expiredGate = await this.secondFactorGate(ctx, cfg, accountId, details);
+        const expiredGate = await this.secondFactorGate(ctx, cfg, accountId, details, 'pwd');
         if (expiredGate.kind === 'challenge')
             return expiredGate.response;
         await service.interactions.completeLogin(ctx, accountId);

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.72.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",