@adonis-agora/authkit-server 0.68.0 → 0.68.1

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

@@ -26,3 +26,20 @@ export declare function decodeActiveOrgCookie(value: string | null | undefined):
  * NOTA: o oidc-provider ctx.cookies.get() nunca lança — retorna null se ausente.
  */
 export declare function readActiveOrgFromKoaCtx(koaCtx: any): ActiveOrgInfo | null;
+/**
+ * Normaliza um valor potencialmente vindo de um payload PERSISTIDO (o `activeOrg`
+ * do Grant) para `ActiveOrgInfo`. Retorna null quando a forma não bate — nunca
+ * confiamos num objeto só porque ele veio do banco.
+ */
+export declare function normalizeActiveOrg(value: unknown): ActiveOrgInfo | null;
+/**
+ * Lê a org ativa de um contexto de interaction do HOST (o `HttpContext` do
+ * AdonisJS usado pelas `InteractionActions`).
+ *
+ * No consent a request É do browser, então o cookie está presente — ao contrário
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
+ * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
+ * `request.cookie` (o MESMO caminho das leituras do console/account API), com
+ * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ */
+export declare function readActiveOrgFromHostCtx(ctx: unknown): ActiveOrgInfo | null;

package/build/src/host/active_org_cookie.js

@@ -26,6 +26,27 @@ export function decodeActiveOrgCookie(value) {
         return null;
     return { orgId, orgSlug, orgRole };
 }
+/**
+ * Parseia um valor de cookie possivelmente URL-encoded.
+ *
+ * O jar Koa do oidc-provider (`cookies`) devolve o valor COMO ESTÁ no header — sem
+ * URL-decode. Como o host grava o cookie via `response.cookie` (que serializa com
+ * `encodeURIComponent`, transformando os TABs em `%09`), é preciso tentar decodificar.
+ * Tentamos o valor cru primeiro (hosts que gravem sem encode) e o decodificado depois.
+ */
+function parseActiveOrgCookieValue(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const direct = decodeActiveOrgCookie(raw);
+    if (direct)
+        return direct;
+    try {
+        return decodeActiveOrgCookie(decodeURIComponent(raw));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Lê a org ativa de um contexto Koa (oidc-provider). O oidc-provider usa o Keygrip
  * das `cookieKeys` para assinar os cookies — lemos via `ctx.cookies.get(name, { signed: false })`
@@ -39,9 +60,50 @@ export function decodeActiveOrgCookie(value) {
 export function readActiveOrgFromKoaCtx(koaCtx) {
     try {
         const raw = koaCtx?.cookies?.get?.(ACTIVE_ORG_COOKIE, { signed: false });
-        return decodeActiveOrgCookie(raw);
+        return parseActiveOrgCookieValue(raw);
     }
     catch {
         return null;
     }
 }
+/**
+ * Normaliza um valor potencialmente vindo de um payload PERSISTIDO (o `activeOrg`
+ * do Grant) para `ActiveOrgInfo`. Retorna null quando a forma não bate — nunca
+ * confiamos num objeto só porque ele veio do banco.
+ */
+export function normalizeActiveOrg(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const { orgId, orgSlug, orgRole } = value;
+    if (typeof orgId !== 'string' ||
+        !orgId ||
+        typeof orgSlug !== 'string' ||
+        !orgSlug ||
+        typeof orgRole !== 'string' ||
+        !orgRole) {
+        return null;
+    }
+    return { orgId, orgSlug, orgRole };
+}
+/**
+ * Lê a org ativa de um contexto de interaction do HOST (o `HttpContext` do
+ * AdonisJS usado pelas `InteractionActions`).
+ *
+ * No consent a request É do browser, então o cookie está presente — ao contrário
+ * do mint do id_token no `/token` (server-a-servidor, sem cookies). O cookie é
+ * gravado UNSIGNED por `account_orgs_controller.activate` e lido aqui via
+ * `request.cookie` (o MESMO caminho das leituras do console/account API), com
+ * fallback para o caminho Koa caso o contexto recebido seja um ctx Koa.
+ */
+export function readActiveOrgFromHostCtx(ctx) {
+    try {
+        const raw = ctx?.request?.cookie?.(ACTIVE_ORG_COOKIE);
+        const parsed = parseActiveOrgCookieValue(raw);
+        if (parsed)
+            return parsed;
+    }
+    catch {
+        // contexto sem `request.cookie` — tenta o caminho Koa abaixo
+    }
+    return readActiveOrgFromKoaCtx(ctx);
+}

package/build/src/provider/build_provider.js

@@ -1,5 +1,6 @@
 import * as oidc from 'oidc-provider';
 import { pickModelAdapterClass } from '../adapters/factory.js';
+import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
 /** Atualiza o holder mutável do TTL de sessão com os valores da setting. */
@@ -117,6 +118,35 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                 : {}),
         })),
         findAccount: options.findAccount,
+        // Grant REAPROVEITADO (consent já lembrado): o org capturado no primeiro
+        // consent ficaria VELHO se o usuário trocasse de org no console e voltasse a
+        // autenticar sem novo consent. Esta função roda numa request do BROWSER (o
+        // authorize), então relemos o cookie aqui e atualizamos o Grant quando
+        // divergir — inclusive LIMPANDO quando o cookie some (org desativada). Sem
+        // isto o token continuaria emitindo a org antiga até o grant expirar.
+        // Assinatura/default confirmados no fonte instalado: `actions/authorization/
+        // session.js` chama `configuration.loadExistingGrant(ctx)`.
+        loadExistingGrant: async (ctx) => {
+            const grantId = ctx.oidc.result?.consent?.grantId || ctx.oidc.session.grantIdFor(ctx.oidc.client.clientId);
+            if (!grantId)
+                return undefined;
+            const grant = await ctx.oidc.provider.Grant.find(grantId);
+            if (!grant)
+                return undefined;
+            const activeOrg = readActiveOrgFromKoaCtx(ctx);
+            const current = normalizeActiveOrg(grant.activeOrg);
+            const changed = (activeOrg?.orgId ?? null) !== (current?.orgId ?? null) ||
+                (activeOrg?.orgSlug ?? null) !== (current?.orgSlug ?? null) ||
+                (activeOrg?.orgRole ?? null) !== (current?.orgRole ?? null);
+            if (changed) {
+                if (activeOrg)
+                    grant.activeOrg = activeOrg;
+                else
+                    delete grant.activeOrg;
+                await grant.save();
+            }
+            return grant;
+        },
         jwks: config.jwks,
         cookies: {
             keys: cookieKeys,
@@ -220,6 +250,29 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             url: (_ctx, interaction) => `/auth/interaction/${interaction.uid}`,
         },
     });
+    // ── Modelo Grant estendido: persiste a org ativa ─────────────────────────────
+    // O oidc-provider v9 NÃO expõe uma opção `models` no config (confirmado no fonte
+    // instalado: `provider.js` instancia os modelos por `models.getGrant(this)` e
+    // `helpers/defaults.js` não tem chave alguma `models`), e o `Grant` filtra o
+    // payload por `IN_PAYLOAD` (`lib/models/grant.js` + `base_model.js`), então
+    // qualquer prop de topo fora da lista é DESCARTADA no `save()`/`find()`.
+    // Estendemos `IN_PAYLOAD` com `activeOrg` e injetamos a subclasse na INSTÂNCIA
+    // do provider via `Object.defineProperty`, que sombreia o getter `Grant` do
+    // protótipo. O `name` é fixado em `'Grant'` para que o nome do ADAPTER e o
+    // `kind` persistido continuem sendo os MESMOS registros (`BaseModel` usa
+    // `constructor.name` para ambos) — sem isso, grants novos/antigos divergiriam.
+    const BaseGrant = provider.Grant;
+    const GrantWithOrg = class GrantWithOrg extends BaseGrant {
+        static get IN_PAYLOAD() {
+            return [...BaseGrant.IN_PAYLOAD, 'activeOrg'];
+        }
+    };
+    Object.defineProperty(GrantWithOrg, 'name', { value: 'Grant', configurable: true });
+    Object.defineProperty(provider, 'Grant', {
+        value: GrantWithOrg,
+        writable: true,
+        configurable: true,
+    });
     provider.proxy = true;
     return provider;
 }

package/build/src/provider/interaction_actions.js

@@ -1,3 +1,4 @@
+import { readActiveOrgFromHostCtx } from '../host/active_org_cookie.js';
 import { InteractionSessionLostException, isInteractionSessionLost, } from '../host/interaction_recovery.js';
 /**
  * Choke point ÚNICO de `interactionDetails`: converte o `SessionNotFound` do
@@ -51,9 +52,15 @@ export function createInteractionActions(provider, deps) {
         },
         async consent(ctx) {
             const details = await interactionDetailsOrRecover(provider, ctx);
+            // O consent roda numa request do BROWSER, então a org ativa (cookie) está
+            // disponível AQUI — ao contrário do mint do id_token no /token, que é
+            // server-a-servidor e não carrega os cookies do usuário. Persistimos a org
+            // no Grant para que o fluxo authorization code volte a emitir org_*.
+            const activeOrg = readActiveOrgFromHostCtx(ctx);
             const grant = new provider.Grant({
                 accountId: details.session.accountId,
                 clientId: details.params.client_id,
+                ...(activeOrg ? { activeOrg } : {}),
             });
             grant.addOIDCScope(String(details.params.scope ?? 'openid'));
             // Resource Indicators (RFC 8707): quando o authorize/token pede um `resource`

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 { readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
+import { normalizeActiveOrg, readActiveOrgFromKoaCtx } 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';
@@ -82,8 +82,13 @@ export class OidcService {
                 const user = await config.findAccount(sub);
                 if (!user)
                     return undefined;
-                // Lê a org ativa do cookie de sessão (se organizations estiver disponível).
-                const activeOrg = readActiveOrgFromKoaCtx(ctx);
+                // Fonte PRIMÁRIA: a org persistida no Grant no consent (request do
+                // browser). No fluxo authorization code o id_token é mintado no /token
+                // — 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) ??
+                    readActiveOrgFromKoaCtx(ctx);
                 // 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).

package/package.json

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