@adonis-agora/authkit-server 0.34.0 → 0.35.0

package/build/index.d.ts

@@ -113,3 +113,4 @@ export { getAccountId, hasAccountSession, consoleLoginUrl, } from './src/host/co
 export { ACCOUNT_SESSION_KEY } from './src/host/middleware/account_auth.js';
 export { SUDO_SESSION_KEY, SUDO_MODE_DEFAULTS, requireSudo, isSudoActive, markSudo, resolveEffectiveSudoMode, } from './src/host/sudo_mode.js';
 export type { SudoModeSetting, ResolvedSudoModeSetting, } from './src/host/sudo_mode.js';
+export { authkitUserProvider } from './src/host/adonis_auth_user_provider.js';

package/build/index.js

@@ -74,3 +74,8 @@ export { getAccountId, hasAccountSession, consoleLoginUrl, } from './src/host/co
 export { ACCOUNT_SESSION_KEY } from './src/host/middleware/account_auth.js';
 // Sudo mode — helpers for host controllers that require step-up authentication.
 export { SUDO_SESSION_KEY, SUDO_MODE_DEFAULTS, requireSudo, isSudoActive, markSudo, resolveEffectiveSudoMode, } from './src/host/sudo_mode.js';
+// @adonisjs/auth integration (opt-in) — user provider for config/auth.ts's
+// sessionGuard(), backed by authkit's own accountStore. Pair with
+// `adonisAuth: { guard: '...' }` in config/authkit.ts so the account console's
+// login/logout also sync ctx.auth. See src/host/adonis_auth_user_provider.ts.
+export { authkitUserProvider } from './src/host/adonis_auth_user_provider.js';

package/build/providers/authkit_server_provider.js

@@ -12,12 +12,27 @@ import { defaultEncryptForStore } from '../src/define_config.js';
 import { resolveKeystoreVault, KeystoreManager } from '../src/keys/keystore_manager.js';
 import { KeystoreCodec } from '../src/keys/keystore_codec.js';
 import { loadEncryptionService } from '../src/keys/keystore_crypto.js';
+import { resolveAppKey } from '../src/host/app_key.js';
 export default class AuthkitServerProvider {
     app;
     constructor(app) {
         this.app = app;
     }
     async boot() {
+        // EAGER + LOUD (fail-fast): se o host configurou `config/authkit.ts`, a
+        // `appKey` é indispensável — o oidc-provider a usa para assinar TODOS os
+        // cookies (keygrip). Antes, essa validação só rodava dentro do factory
+        // lazy do `authkit.server` (registrado abaixo): sem nada que resolvesse o
+        // binding no boot, o app subia normalmente e o erro só aparecia (a) na
+        // 1ª request que tocasse uma rota do authkit, como um 500 sem contexto
+        // fora do modo dev, OU (b) nunca, porque `#startKeystoreReloadPoll`/
+        // `#startKeyRotationScheduler` engolem qualquer erro do `container.make`
+        // via `.catch(() => null)`. Validar aqui, fora do try/catch fail-safe
+        // abaixo, propaga o erro para `app.boot()` e derruba o boot do processo
+        // com a mensagem certa — em vez de um 500 misterioso depois.
+        if (this.app.config.get('authkit')) {
+            resolveAppKey(this.app);
+        }
         // Config locks: trava as settings definidas explicitamente no defineConfig
         // (config vence em runtime; a UI/Admin API não pode alterá-las). Fail-safe:
         // qualquer erro → sem locks (comportamento legado).
@@ -76,19 +91,12 @@ export default class AuthkitServerProvider {
             if (!config) {
                 throw new RuntimeException('Config inválido em "config/authkit.ts". Use o método defineConfig de @adonis-agora/authkit-server.');
             }
-            // `app.appKey` pode ser uma string crua ou um `Secret` do AdonisJS (config/app.ts
-            // expõe `export const appKey = new Secret(env.get('APP_KEY'))`). O oidc-provider
-            // assina cookies via keygrip e exige uma string — então liberamos o Secret aqui.
-            // Sem isso, a chave chegaria como objeto/undefined e o fluxo de authorize quebraria
-            // (keygrip: "key argument must be of type string ...").
-            const rawAppKey = this.app.config.get('app.appKey');
-            const appKey = rawAppKey && typeof rawAppKey.release === 'function'
-                ? rawAppKey.release()
-                : rawAppKey;
-            if (!appKey || typeof appKey !== 'string') {
-                throw new RuntimeException('APP_KEY ausente: defina `export const appKey = new Secret(env.get(\'APP_KEY\'))` em config/app.ts. ' +
-                    'O @adonis-agora/authkit-server precisa dele para assinar os cookies do oidc-provider.');
-            }
+            // `app.appKey` pode ser uma string crua ou um `Secret` do AdonisJS — ver
+            // `resolveAppKey` para o porquê e para a mensagem de erro (agora também
+            // validada EAGER no `boot()`, acima; mantida aqui para o caso raro de
+            // alguém resolver `authkit.server` diretamente sem passar pelo boot do
+            // provider, ex.: testes unitários do binding).
+            const appKey = resolveAppKey(this.app);
             const metrics = await this.app.container.make('authkit.metrics');
             const jwksInput = config.jwksConfig;
             let jwksLoader;

package/build/src/define_config.d.ts

@@ -521,7 +521,12 @@ export interface AuthServerConfigInput {
      * Hosts que preferem mandar o usuário direto pro app podem apontar pra rota deles.
      */
     accountHome?: string;
-    /** Renderer de páginas do host (Inertia ou Edge). */
+    /**
+     * Renderer de páginas do host (Inertia ou Edge). Default (quando omitido):
+     * {@link edgeRenderer}. Sem isso, TODA request a `/account/*` e
+     * `/auth/interaction/*` estourava um 500 sem explicação — `render` era
+     * `undefined` e o controller chamava `render(ctx, ...)` diretamente.
+     */
     render?: AuthHostRenderer;
     /** Configuração de branding por cliente. */
     branding?: BrandingConfig;
@@ -662,6 +667,27 @@ export interface AuthServerConfigInput {
     accountLifecycle?: {
         durable?: boolean;
     };
+    /**
+     * Integração OPT-IN com `@adonisjs/auth`. authkit-server autentica a área de
+     * conta (`/account/*`) com sua PRÓPRIA sessão (`ACCOUNT_SESSION_KEY`, via
+     * `@adonisjs/session` diretamente) — nunca chamou `@adonisjs/auth` em lugar
+     * nenhum, então `ctx.auth.user`/`middleware.auth()`/Bouncer's
+     * `() => ctx.auth.user` ficavam sempre `undefined` num host que os use.
+     *
+     * Quando `adonisAuth.guard` é setado, `AccountSessionController#login`/`logout`
+     * TAMBÉM chamam `ctx.auth.use(guard).login(account)`/`.logout()` do guard
+     * indicado — em paralelo ao cookie bespoke do authkit, que continua sendo a
+     * fonte de verdade das rotas do próprio authkit. Requer um user provider
+     * plugado nesse guard em `config/auth.ts` — veja {@link authkitUserProvider}.
+     *
+     * Default (ausente): comportamento de sempre, sem tocar em `ctx.auth`.
+     * Degrada limpo mesmo sem `@adonisjs/auth` instalado (peer opcional): o
+     * código só acessa `ctx.auth` quando esta opção está setada E a propriedade
+     * existe no ctx (host com `@adonisjs/auth` de fato inicializado).
+     */
+    adonisAuth?: {
+        guard: string;
+    };
 }
 export interface ResolvedServerConfig {
     issuer: string;
@@ -755,6 +781,10 @@ export interface ResolvedServerConfig {
     };
     /** Keys de `auth_settings` travadas por terem sido definidas no defineConfig. */
     lockedSettingKeys: string[];
+    /** Integração opt-in com `@adonisjs/auth` (ausente = não integrado; comportamento de sempre). */
+    adonisAuth?: {
+        guard: string;
+    };
 }
 export declare function toSeconds(value: string | number | undefined, fallback: number): number;
 /**

package/build/src/define_config.js

@@ -9,6 +9,7 @@ import { resolveMessages, } from "./host/i18n.js";
 import { resolveTrustedDevices, } from "./host/trusted_device.js";
 import { resolveBotProtection, } from "./host/bot_protection.js";
 import { deriveLockedSettingKeys } from "./host/config_locks.js";
+import { edgeRenderer } from "./host/renderers/edge_renderer.js";
 export { adapters };
 const RATE_LIMIT_DEFAULTS = {
     login: { points: 10, duration: "1 min" },
@@ -296,7 +297,14 @@ export function defineConfig(config) {
             accountStore: config.accountStore,
             patStore: config.patStore,
             mountPath: config.mountPath ?? "/oidc",
-            render: config.render,
+            // Default de runtime: sem isso, `render` ficava `undefined` e TODA
+            // request a `/account/*`/`/auth/interaction/*` estourava um 500 sem
+            // contexto (os controllers fazem `cfg.render!(...)`). `edgeRenderer()`
+            // só usa `ctx.view` quando de fato invocado por uma request — não
+            // importa `edge.js` eagerly, então é seguro construir mesmo em hosts
+            // sem o peer opcional instalado (só quebraria se a request realmente
+            // chegasse sem Edge configurado, exatamente como hoje).
+            render: config.render ?? edgeRenderer(),
             branding: config.branding,
             social: config.social,
             patIntrospectionSecret: config.patIntrospectionSecret,
@@ -346,6 +354,8 @@ export function defineConfig(config) {
             // Keys de auth_settings travadas porque foram definidas no defineConfig:
             // config vence e a UI/Admin API não pode alterá-las (ver host/config_locks.ts).
             lockedSettingKeys: deriveLockedSettingKeys(config),
+            // Opt-in: ausente = authkit nunca toca `ctx.auth` (comportamento de sempre).
+            adonisAuth: config.adonisAuth,
         };
     });
 }

package/build/src/events/dispatcher.d.ts

@@ -35,6 +35,37 @@ export declare function resolveEvents(input?: EventsConfigInput): ResolvedEvents
 export declare function buildWebhookBody(event: AuditEvent): string;
 /** Calcula o header de assinatura `sha256=<hmac>` para um corpo + segredo. */
 export declare function signWebhookBody(body: string, secret: string): string;
+/**
+ * Projeta um {@link AuditEvent} para o barramento `@agora/diagnostics` SEM PII
+ * direta (LGPD/GDPR — completude do "direito ao esquecimento").
+ *
+ * Motivação: o ramo de diagnostics espelha CADA evento de auditoria no barramento,
+ * de onde o Telescope o captura como um `diagnostic` INDEPENDENTE (tag
+ * `lib:authkit`) na SUA PRÓPRIA store. Esse espelho NÃO é alcançado pelo cascade de
+ * deleção de conta — o passo `anonymizeAudit` só anonimiza as linhas do audit-sink,
+ * não as cópias que vazaram para o Telescope. Se o evento bruto fosse para o
+ * barramento, o `email`/`ip` de uma conta deletada sobreviveria no store do
+ * Telescope.
+ *
+ * Para fechar isso na origem (mais robusto que um purge cross-store), a projeção que
+ * vai para o barramento já NASCE sem os identificadores diretos:
+ *
+ *   - REMOVE `email` e `ip` (PII direta);
+ *   - REMOVE `metadata` — é livre (`Record<string, unknown>`) e pode carregar PII,
+ *     p.ex. `{ email }` (convites de org) ou `{ oldEmail, newEmail }` (troca de
+ *     e-mail). Nenhum data provider do dashboard lê `metadata`, então dropá-lo é
+ *     seguro;
+ *   - MANTÉM `type` (a família do evento — o que os providers agregam) e os ids
+ *     internos opacos `accountId`/`actorId`/`clientId` (correlação de subject/actor
+ *     no dashboard; NÃO são PII direta e, sem `email`/`ip`/`metadata` e com a linha
+ *     da conta já deletada, não são reidentificáveis).
+ *
+ * Assim o Telescope nunca armazena PII bruta e a deleção de conta não precisa de uma
+ * etapa de purge cross-lib. Os ramos `onEvent`/`webhook` (integrações que o host
+ * habilita explicitamente) continuam recebendo o evento COMPLETO — só a ponte de
+ * diagnostics é redigida.
+ */
+export declare function redactAuditEventForDiagnostics(event: AuditEvent): AuditEvent;
 /**
  * Decora um AuditSink (ou cria um do zero) num sink fan-out: cada `record`
  * persiste no sink original (se houver) E dispara onEvent + webhook. Falhas em

package/build/src/events/dispatcher.js

@@ -29,6 +29,44 @@ export function buildWebhookBody(event) {
 export function signWebhookBody(body, secret) {
     return "sha256=" + createHmac("sha256", secret).update(body).digest("hex");
 }
+/**
+ * Projeta um {@link AuditEvent} para o barramento `@agora/diagnostics` SEM PII
+ * direta (LGPD/GDPR — completude do "direito ao esquecimento").
+ *
+ * Motivação: o ramo de diagnostics espelha CADA evento de auditoria no barramento,
+ * de onde o Telescope o captura como um `diagnostic` INDEPENDENTE (tag
+ * `lib:authkit`) na SUA PRÓPRIA store. Esse espelho NÃO é alcançado pelo cascade de
+ * deleção de conta — o passo `anonymizeAudit` só anonimiza as linhas do audit-sink,
+ * não as cópias que vazaram para o Telescope. Se o evento bruto fosse para o
+ * barramento, o `email`/`ip` de uma conta deletada sobreviveria no store do
+ * Telescope.
+ *
+ * Para fechar isso na origem (mais robusto que um purge cross-store), a projeção que
+ * vai para o barramento já NASCE sem os identificadores diretos:
+ *
+ *   - REMOVE `email` e `ip` (PII direta);
+ *   - REMOVE `metadata` — é livre (`Record<string, unknown>`) e pode carregar PII,
+ *     p.ex. `{ email }` (convites de org) ou `{ oldEmail, newEmail }` (troca de
+ *     e-mail). Nenhum data provider do dashboard lê `metadata`, então dropá-lo é
+ *     seguro;
+ *   - MANTÉM `type` (a família do evento — o que os providers agregam) e os ids
+ *     internos opacos `accountId`/`actorId`/`clientId` (correlação de subject/actor
+ *     no dashboard; NÃO são PII direta e, sem `email`/`ip`/`metadata` e com a linha
+ *     da conta já deletada, não são reidentificáveis).
+ *
+ * Assim o Telescope nunca armazena PII bruta e a deleção de conta não precisa de uma
+ * etapa de purge cross-lib. Os ramos `onEvent`/`webhook` (integrações que o host
+ * habilita explicitamente) continuam recebendo o evento COMPLETO — só a ponte de
+ * diagnostics é redigida.
+ */
+export function redactAuditEventForDiagnostics(event) {
+    return {
+        type: event.type,
+        accountId: event.accountId ?? null,
+        actorId: event.actorId ?? null,
+        clientId: event.clientId ?? null,
+    };
+}
 /**
  * Dispara o webhook de forma fire-and-forget: timeout de 5s via AbortSignal,
  * captura QUALQUER erro (rede, abort, HMAC) sem propagar. Nunca lança.
@@ -87,7 +125,9 @@ export function composeAuditSink(original, events = {}) {
             }
             // Diagnostics Agora (best-effort, sempre ligado, no-op sem o slot).
             // Canal: `agora:authkit:<AuditEventType>` (o `type` É o sufixo).
-            emitDiagnostic(event.type, event);
+            // Emite uma projeção REDIGIDA (sem `email`/`ip`/`metadata`) para que o
+            // Telescope nunca armazene PII bruta — ver `redactAuditEventForDiagnostics`.
+            emitDiagnostic(event.type, redactAuditEventForDiagnostics(event));
         },
     };
     // Preserva a capacidade de consulta do sink original (console admin).

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

@@ -35,6 +35,7 @@ import { AdminSessionsService } from '../admin_sessions_service.js';
 import { enrichSessionsWithContext } from '../session_context.js';
 import { PasswordPolicyError } from '../../password/password_manager.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { syncAdonisAuthLogout } from '../adonis_auth_sync.js';
 import { resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from '../runtime_toggles.js';
 import { dispatchSecurityNotice } from '../security_notice_service.js';
 import { requireSudo, isSudoActive, SUDO_MODE_DEFAULTS, resolveEffectiveSudoMode } from '../sudo_mode.js';
@@ -515,6 +516,7 @@ export default class AccountApiController {
         // Encerrar a sessão Adonis do console (logout global do self-service).
         ctx.session.forget(ACCOUNT_SESSION_KEY);
         await ctx.session.regenerate();
+        await syncAdonisAuthLogout(ctx, cfg);
         return { ok: true, signedOut: true, ...result };
     }
     // ─── GET /account/api/apps ──────────────────────────────────────────────

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

@@ -0,0 +1,27 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedServerConfig } from '../define_config.js';
+import type { AuthAccount } from '../accounts/account_store.js';
+/**
+ * Sincroniza `ctx.auth` (`@adonisjs/auth`) com um login bem-sucedido no console
+ * de conta do authkit. Ver `adonisAuth` em `define_config.ts` pro porquê: sem
+ * isso, `ctx.auth.user` nunca é populado por nenhum fluxo do authkit-server —
+ * mesmo num host que roda `@adonisjs/auth` normalmente.
+ *
+ * NO-OP quando:
+ *   - `adonisAuth.guard` não está configurado (opt-in; default é não tocar em
+ *     `ctx.auth` — comportamento de sempre).
+ *   - `ctx.auth` não existe nesta request (host sem `InitializeAuthMiddleware`
+ *     de `@adonisjs/auth` registrado — o peer é opcional).
+ *
+ * BEST-EFFORT: uma falha aqui (ex.: guard mal configurado em `config/auth.ts`)
+ * NUNCA quebra o login do authkit — o cookie bespoke (`ACCOUNT_SESSION_KEY`)
+ * já é a fonte de verdade das rotas do próprio authkit e continua funcionando
+ * mesmo se a sincronização com `@adonisjs/auth` falhar. Loga um warning para
+ * não mascarar um guard mal configurado silenciosamente.
+ */
+export declare function syncAdonisAuthLogin(ctx: HttpContext, cfg: Pick<ResolvedServerConfig, 'adonisAuth'>, account: AuthAccount): Promise<void>;
+/**
+ * Sincroniza `ctx.auth` com um logout do console de conta. Ver
+ * {@link syncAdonisAuthLogin} para as mesmas regras de no-op/best-effort.
+ */
+export declare function syncAdonisAuthLogout(ctx: HttpContext, cfg: Pick<ResolvedServerConfig, 'adonisAuth'>): Promise<void>;

package/build/src/host/adonis_auth_sync.js

@@ -0,0 +1,47 @@
+/**
+ * Sincroniza `ctx.auth` (`@adonisjs/auth`) com um login bem-sucedido no console
+ * de conta do authkit. Ver `adonisAuth` em `define_config.ts` pro porquê: sem
+ * isso, `ctx.auth.user` nunca é populado por nenhum fluxo do authkit-server —
+ * mesmo num host que roda `@adonisjs/auth` normalmente.
+ *
+ * NO-OP quando:
+ *   - `adonisAuth.guard` não está configurado (opt-in; default é não tocar em
+ *     `ctx.auth` — comportamento de sempre).
+ *   - `ctx.auth` não existe nesta request (host sem `InitializeAuthMiddleware`
+ *     de `@adonisjs/auth` registrado — o peer é opcional).
+ *
+ * BEST-EFFORT: uma falha aqui (ex.: guard mal configurado em `config/auth.ts`)
+ * NUNCA quebra o login do authkit — o cookie bespoke (`ACCOUNT_SESSION_KEY`)
+ * já é a fonte de verdade das rotas do próprio authkit e continua funcionando
+ * mesmo se a sincronização com `@adonisjs/auth` falhar. Loga um warning para
+ * não mascarar um guard mal configurado silenciosamente.
+ */
+export async function syncAdonisAuthLogin(ctx, cfg, account) {
+    const guard = cfg.adonisAuth?.guard;
+    const auth = ctx.auth;
+    if (!guard || !auth)
+        return;
+    try {
+        await auth.use(guard).login(account);
+    }
+    catch (error) {
+        ctx.logger?.warn({ err: error, guard }, 'authkit: falha ao sincronizar login com @adonisjs/auth (adonisAuth.guard) — ' +
+            'ctx.auth.user pode não refletir a conta logada; o cookie do authkit segue normal');
+    }
+}
+/**
+ * Sincroniza `ctx.auth` com um logout do console de conta. Ver
+ * {@link syncAdonisAuthLogin} para as mesmas regras de no-op/best-effort.
+ */
+export async function syncAdonisAuthLogout(ctx, cfg) {
+    const guard = cfg.adonisAuth?.guard;
+    const auth = ctx.auth;
+    if (!guard || !auth)
+        return;
+    try {
+        await auth.use(guard).logout();
+    }
+    catch (error) {
+        ctx.logger?.warn({ err: error, guard }, 'authkit: falha ao sincronizar logout com @adonisjs/auth (adonisAuth.guard)');
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { ConfigProvider } from '@adonisjs/core/types';
+import type { SessionUserProviderContract } from '@adonisjs/auth/types/session';
+import type { AuthAccount } from '../accounts/account_store.js';
+/**
+ * User provider de `@adonisjs/auth` (session guard) apoiado no `accountStore`
+ * do próprio authkit — a MESMA fonte de identidade que o login do console de
+ * conta autentica. Plugado em `config/auth.ts`:
+ *
+ * ```ts
+ * import { sessionGuard } from '@adonisjs/auth/session'
+ * import { authkitUserProvider } from '@adonis-agora/authkit-server'
+ *
+ * export default defineConfig({
+ *   default: 'web',
+ *   guards: {
+ *     web: sessionGuard({
+ *       useRememberMeTokens: false,
+ *       provider: authkitUserProvider(),
+ *     }),
+ *   },
+ * })
+ * ```
+ *
+ * Junto com `adonisAuth: { guard: 'web' }` em `config/authkit.ts`, o login do
+ * console de conta (`AccountSessionController#login`) passa a chamar
+ * `ctx.auth.use('web').login(account)` no sucesso — populando `ctx.auth.user`
+ * com um {@link AuthAccount} de verdade para o resto do app (Bouncer,
+ * `middleware.auth()`, etc.), sem duplicar a sessão bespoke do authkit
+ * (`ACCOUNT_SESSION_KEY`), que continua sendo a fonte de verdade das próprias
+ * rotas do authkit.
+ *
+ * Devolve um `ConfigProvider` (mesmo padrão do `sessionUserProvider()` nativo
+ * de `@adonisjs/auth`) — a resolução (incluindo o import dinâmico de
+ * `@adonisjs/auth` para o símbolo `PROVIDER_REAL_USER` exigido pelo contrato)
+ * só acontece quando o HOST resolve a config do guard no boot, nunca no
+ * carregamento deste módulo.
+ */
+export declare function authkitUserProvider(): ConfigProvider<SessionUserProviderContract<AuthAccount>>;

package/build/src/host/adonis_auth_user_provider.js

@@ -0,0 +1,74 @@
+import { configProvider } from '@adonisjs/core';
+import { RuntimeException } from '@adonisjs/core/exceptions';
+/**
+ * User provider de `@adonisjs/auth` (session guard) apoiado no `accountStore`
+ * do próprio authkit — a MESMA fonte de identidade que o login do console de
+ * conta autentica. Plugado em `config/auth.ts`:
+ *
+ * ```ts
+ * import { sessionGuard } from '@adonisjs/auth/session'
+ * import { authkitUserProvider } from '@adonis-agora/authkit-server'
+ *
+ * export default defineConfig({
+ *   default: 'web',
+ *   guards: {
+ *     web: sessionGuard({
+ *       useRememberMeTokens: false,
+ *       provider: authkitUserProvider(),
+ *     }),
+ *   },
+ * })
+ * ```
+ *
+ * Junto com `adonisAuth: { guard: 'web' }` em `config/authkit.ts`, o login do
+ * console de conta (`AccountSessionController#login`) passa a chamar
+ * `ctx.auth.use('web').login(account)` no sucesso — populando `ctx.auth.user`
+ * com um {@link AuthAccount} de verdade para o resto do app (Bouncer,
+ * `middleware.auth()`, etc.), sem duplicar a sessão bespoke do authkit
+ * (`ACCOUNT_SESSION_KEY`), que continua sendo a fonte de verdade das próprias
+ * rotas do authkit.
+ *
+ * Devolve um `ConfigProvider` (mesmo padrão do `sessionUserProvider()` nativo
+ * de `@adonisjs/auth`) — a resolução (incluindo o import dinâmico de
+ * `@adonisjs/auth` para o símbolo `PROVIDER_REAL_USER` exigido pelo contrato)
+ * só acontece quando o HOST resolve a config do guard no boot, nunca no
+ * carregamento deste módulo.
+ */
+export function authkitUserProvider() {
+    return configProvider.create(async (app) => {
+        let PROVIDER_REAL_USER;
+        try {
+            const auth = (await import('@adonisjs/auth'));
+            PROVIDER_REAL_USER = auth.symbols.PROVIDER_REAL_USER;
+        }
+        catch (error) {
+            throw new RuntimeException('authkitUserProvider() precisa de "@adonisjs/auth" instalado (é um peer opcional do ' +
+                '@adonis-agora/authkit-server, só necessário se você plugar este provider em config/auth.ts). ' +
+                'Rode `npm i @adonisjs/auth` (ou pnpm/yarn) e configure um sessionGuard em config/auth.ts.', { cause: error });
+        }
+        // `PROVIDER_REAL_USER` chega em runtime como um `symbol` (não um "unique
+        // symbol" literal) — o cast final é seguro pq o valor É literalmente o
+        // símbolo exportado por `@adonisjs/auth`, só que o TS não consegue provar
+        // isso estruturalmente a partir de um import dinâmico.
+        const provider = {
+            [PROVIDER_REAL_USER]: undefined,
+            async createUserForGuard(user) {
+                return {
+                    getId: () => user.id,
+                    getOriginal: () => user,
+                };
+            },
+            async findById(identifier) {
+                const store = await app.container.make('authkit.accountStore');
+                const account = await store.findById(String(identifier));
+                if (!account)
+                    return null;
+                return {
+                    getId: () => account.id,
+                    getOriginal: () => account,
+                };
+            },
+        };
+        return provider;
+    });
+}

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

@@ -0,0 +1,18 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Mensagem única (compartilhada entre o check EAGER do `boot()` e o resolver
+ * LAZY do `register()`) para o erro de `appKey` ausente — um só lugar para
+ * editar o texto, e garante que os dois caminhos falem exatamente a mesma coisa.
+ */
+export declare const MISSING_APP_KEY_MESSAGE: string;
+/**
+ * Lê e valida `app.appKey` (usado pelo oidc-provider para assinar cookies via
+ * keygrip). `app.appKey` pode ser uma string crua ou um `Secret` do AdonisJS
+ * (`config/app.ts` expõe `export const appKey = new Secret(env.get('APP_KEY'))`).
+ *
+ * Lança {@link RuntimeException} com uma mensagem que NOMEIA o arquivo e o campo
+ * exatos a corrigir — nunca deixa o app seguir com uma appKey ausente/inválida
+ * (o oidc-provider quebraria mais adiante com um erro genérico do keygrip,
+ * sem apontar a causa raiz).
+ */
+export declare function resolveAppKey(app: ApplicationService): string;

package/build/src/host/app_key.js

@@ -0,0 +1,28 @@
+import { RuntimeException } from '@adonisjs/core/exceptions';
+/**
+ * Mensagem única (compartilhada entre o check EAGER do `boot()` e o resolver
+ * LAZY do `register()`) para o erro de `appKey` ausente — um só lugar para
+ * editar o texto, e garante que os dois caminhos falem exatamente a mesma coisa.
+ */
+export const MISSING_APP_KEY_MESSAGE = 'APP_KEY ausente: defina `export const appKey = new Secret(env.get(\'APP_KEY\'))` em config/app.ts. ' +
+    'O @adonis-agora/authkit-server precisa dele para assinar os cookies do oidc-provider (NÃO usa config/encryption.ts).';
+/**
+ * Lê e valida `app.appKey` (usado pelo oidc-provider para assinar cookies via
+ * keygrip). `app.appKey` pode ser uma string crua ou um `Secret` do AdonisJS
+ * (`config/app.ts` expõe `export const appKey = new Secret(env.get('APP_KEY'))`).
+ *
+ * Lança {@link RuntimeException} com uma mensagem que NOMEIA o arquivo e o campo
+ * exatos a corrigir — nunca deixa o app seguir com uma appKey ausente/inválida
+ * (o oidc-provider quebraria mais adiante com um erro genérico do keygrip,
+ * sem apontar a causa raiz).
+ */
+export function resolveAppKey(app) {
+    const rawAppKey = app.config.get('app.appKey');
+    const appKey = rawAppKey && typeof rawAppKey.release === 'function'
+        ? rawAppKey.release()
+        : rawAppKey;
+    if (!appKey || typeof appKey !== 'string') {
+        throw new RuntimeException(MISSING_APP_KEY_MESSAGE);
+    }
+    return appKey;
+}

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

@@ -15,6 +15,7 @@ import { resolveRuntimeSettings } from "../runtime_settings.js";
 import { resolveEffectiveEmailChange, resolveEffectivePasswordHistory, } from "../runtime_toggles.js";
 import { dispatchSecurityNotice } from "../security_notice_service.js";
 import { requireSudo } from "../sudo_mode.js";
+import { syncAdonisAuthLogout } from "../adonis_auth_sync.js";
 /** Resolve os password history settings em runtime (fail-safe). */
 async function resolvePasswordHistorySettings(ctx) {
     try {
@@ -193,6 +194,7 @@ export default class AccountSecurityController {
         }
         // Encerra a sessão e leva ao login com a mensagem de sucesso.
         ctx.session.forget(ACCOUNT_SESSION_KEY);
+        await syncAdonisAuthLogout(ctx, cfg);
         ctx.session.flash("accountDeleted", translate(cfg.messages, "account.delete.deleted"));
         return ctx.response.redirect("/account/login");
     }

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

@@ -6,6 +6,7 @@ import { notifyLoginSuccess } from '../login_notify.js';
 import { markSudo } from '../sudo_mode.js';
 import { accountHome } from '../account_home.js';
 import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { syncAdonisAuthLogin, syncAdonisAuthLogout } from '../adonis_auth_sync.js';
 /**
  * Valida um valor de `return_to` recebido da query-string ou de um campo hidden.
  *
@@ -95,11 +96,16 @@ export default class AccountSessionController {
         ctx.session.put(ACCOUNT_SESSION_KEY, acc.id);
         // Login com senha = confirmação de identidade → marca sudo (graça a partir do login).
         markSudo(ctx);
+        // Opt-in: sincroniza ctx.auth.use(cfg.adonisAuth.guard) com a mesma conta —
+        // no-op sem `adonisAuth` configurado ou sem @adonisjs/auth inicializado.
+        await syncAdonisAuthLogin(ctx, cfg, acc);
         await notifyLoginSuccess(ctx, cfg, { accountId: acc.id, email, ip });
         // Redireciona pro destino original (validado), ou cai no accountHome configurado.
         return ctx.response.redirect(returnTo ?? accountHome(cfg));
     }
     async logout(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
         // M6: não basta `forget(ACCOUNT_SESSION_KEY)` — sobravam na sessão
         // `authkit_sudo_at` (sudo), `authkit_last_seen` e qualquer outro estado
         // sensível, com o session id INALTERADO. Regenerar a sessão troca o id E
@@ -108,6 +114,8 @@ export default class AccountSessionController {
         // (belt-and-braces) caso o store de sessão não suporte regenerate.
         ctx.session.forget(ACCOUNT_SESSION_KEY);
         await ctx.session.regenerate();
+        // Opt-in: espelha o logout no guard de @adonisjs/auth (ver adonisAuth em define_config.ts).
+        await syncAdonisAuthLogout(ctx, cfg);
         return ctx.response.redirect('/account/login');
     }
 }