@adonis-agora/authkit-server 0.34.1 → 0.36.0

package/build/host/views/signup.edge

@@ -36,11 +36,19 @@
             class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none transition focus:border-gray-900 focus:ring-2 focus:ring-gray-900" />
         </div>
 
-        <div class="mt-4">
-          <label for="password" class="mb-1 block text-sm font-medium text-gray-700">{{ t('signup.password_label') }}</label>
-          <input id="password" name="password" type="password" required minlength="8"
-            class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none transition focus:border-gray-900 focus:ring-2 focus:ring-gray-900" />
-        </div>
+        {{-- Cadastro passwordless: sem campo de senha. O login vem por magic link. --}}
+        @if(!passwordlessSignup)
+          <div class="mt-4">
+            <label for="password" class="mb-1 block text-sm font-medium text-gray-700">{{ t('signup.password_label') }}</label>
+            <input id="password" name="password" type="password" required minlength="8"
+              class="w-full rounded-lg border border-gray-300 px-3 py-2 text-sm outline-none transition focus:border-gray-900 focus:ring-2 focus:ring-gray-900" />
+          </div>
+        @end
+
+        {{-- Passwordless: confirmação de link enviado (anti-enumeração). --}}
+        @if(magicLinkSent)
+          <p class="mt-4 rounded-lg bg-green-50 px-3 py-2 text-sm text-green-700">{{ t('signup.magic_link_sent') }}</p>
+        @end
 
         {{-- Bot protection: container do widget (config-trusted; HTML do host renderizado raw). --}}
         @if(botProtection && botProtection.html)

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

@@ -322,10 +322,19 @@ export interface PasswordlessConfigInput {
     magicLink?: boolean;
     /** Liga o "entrar com passkey" antes da senha. Default: false. */
     passkeyFirst?: boolean;
+    /**
+     * Liga o cadastro público passwordless: o signup pede só e-mail + nome (sem
+     * senha), cria a conta com uma senha aleatória inutilizável e envia um magic
+     * link que finaliza o login (o mesmo fluxo do login por magic link). Default:
+     * false. Exige que o accountStore implemente {@link MagicLinkCapability}; sem
+     * ela o cadastro passwordless fica indisponível e o fluxo de senha segue valendo.
+     */
+    signup?: boolean;
 }
 export interface ResolvedPasswordlessConfig {
     magicLink: boolean;
     passkeyFirst: boolean;
+    signup: boolean;
 }
 export declare function resolvePasswordless(input?: PasswordlessConfigInput): ResolvedPasswordlessConfig;
 /**
@@ -521,7 +530,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 +676,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 +790,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" },
@@ -91,6 +92,7 @@ export function resolvePasswordless(input) {
     return {
         magicLink: input?.magicLink ?? false,
         passkeyFirst: input?.passkeyFirst ?? false,
+        signup: input?.signup ?? false,
     };
 }
 export function resolveLogin(input) {
@@ -296,7 +298,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 +355,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/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');
     }
 }

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

@@ -1,6 +1,7 @@
 import '../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
 export default class AuthRegistrationController {
+    #private;
     /** GET /auth/interaction/:uid/signup — tela de cadastro (dentro do fluxo OIDC). */
     showSignup(ctx: HttpContext): Promise<any>;
     /** POST /auth/interaction/:uid/signup — cria o usuário e finaliza o login. */

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

@@ -1,7 +1,8 @@
 import '../augmentations.js';
 import { brandFor } from '../branding.js';
-import { signupValidator, forgotPasswordValidator, resetPasswordValidator } from '../validators.js';
-import { sendPasswordResetEmail, sendEmailVerificationEmail } from '../default_mailer.js';
+import { randomBytes } from 'node:crypto';
+import { signupValidator, passwordlessSignupValidator, forgotPasswordValidator, resetPasswordValidator, } from '../validators.js';
+import { sendPasswordResetEmail, sendEmailVerificationEmail, sendMagicLinkEmail, } from '../default_mailer.js';
 import { translate } from '../i18n.js';
 import { PasswordPolicyError } from '../../password/password_manager.js';
 import { guardBotProtection, resolveEffectiveBotProtection } from '../bot_protection.js';
@@ -54,6 +55,7 @@ export default class AuthRegistrationController {
             uid: details.uid,
             csrfToken: ctx.request.csrfToken,
             brand,
+            passwordlessSignup: cfg.passwordless?.signup ?? false,
             botProtection: effectiveBot?.on.includes('signup') ? effectiveBot.widget : undefined,
         });
     }
@@ -102,6 +104,12 @@ export default class AuthRegistrationController {
                 botProtection: effectiveBotSignup?.widget,
             });
         }
+        // Cadastro passwordless (config): só e-mail + nome. Cria conta com senha random
+        // inutilizável e envia um magic link — mesmo fluxo do login por magic link.
+        if (cfg.passwordless?.signup &&
+            typeof cfg.accountStore.issueMagicLinkToken === 'function') {
+            return this.#passwordlessSignup(ctx, { cfg, brand, details });
+        }
         const data = await ctx.request.validateUsing(signupValidator);
         const accountStore = cfg.accountStore;
         const existing = await accountStore.findByEmail(data.email);
@@ -183,6 +191,55 @@ export default class AuthRegistrationController {
             ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar verificação de e-mail');
         }
     }
+    /**
+     * Cadastro passwordless: valida e-mail + nome, cria a conta (senha random
+     * inutilizável) se ainda não existe, emite um magic link e o envia. Sempre
+     * responde "link enviado" (anti-enumeração), exista a conta ou não. Consumir o
+     * link finaliza o login pelo fluxo de magic link já existente (GET /magic).
+     */
+    async #passwordlessSignup(ctx, deps) {
+        const { cfg, brand, details } = deps;
+        const render = cfg.render;
+        const accountStore = cfg.accountStore;
+        const uid = ctx.request.param('uid');
+        const data = await ctx.request.validateUsing(passwordlessSignupValidator);
+        // Cria a conta se ainda não existe. Senha random inutilizável: o login é 100%
+        // passwordless (mesmo precedente das contas criadas por identidade social).
+        const existing = await accountStore.findByEmail(data.email);
+        if (!existing) {
+            const created = await accountStore.create({
+                email: data.email,
+                fullName: data.fullName,
+                password: randomBytes(24).toString('hex'),
+            });
+            await cfg.audit?.record({
+                type: 'signup',
+                accountId: created.id,
+                email: data.email,
+                ip: ctx.request.ip?.() ?? null,
+                clientId: details.params.client_id ?? null,
+            });
+        }
+        // Emite + envia o magic link (mesma construção do login por magic link).
+        const issued = await accountStore.issueMagicLinkToken(data.email);
+        if (issued) {
+            const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+            const magicUrl = `${origin}/auth/interaction/${uid}/magic?token=${encodeURIComponent(issued.token)}`;
+            if (cfg.mail?.onMagicLink) {
+                await cfg.mail.onMagicLink({ email: data.email, magicUrl, token: issued.token });
+            }
+            else {
+                await sendMagicLinkEmail(ctx, { email: data.email, magicUrl });
+            }
+        }
+        // Resposta uniforme: "enviamos um link" (não vaza existência da conta).
+        return render(ctx, 'signup', {
+            uid,
+            csrfToken: ctx.request.csrfToken,
+            brand,
+            magicLinkSent: true,
+        });
+    }
     /** GET /auth/forgot-password — tela standalone. */
     async showForgot(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');

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

@@ -48,6 +48,7 @@ export declare const DEFAULT_MESSAGES: {
     "account.login.idle_timeout": string;
     "login.magic_link_button": string;
     "login.magic_link_sent": string;
+    "signup.magic_link_sent": string;
     "login.passkey_button": string;
     "signup.page_title": string;
     "signup.title": string;
@@ -734,6 +735,7 @@ export declare const PT_BR_MESSAGES: {
     "account.login.idle_timeout": string;
     "login.magic_link_button": string;
     "login.magic_link_sent": string;
+    "signup.magic_link_sent": string;
     "login.passkey_button": string;
     "signup.page_title": string;
     "signup.title": string;

package/build/src/host/i18n.js

@@ -39,6 +39,7 @@ export const DEFAULT_MESSAGES = {
     // Passwordless (login).
     "login.magic_link_button": "Email me a login link",
     "login.magic_link_sent": "If the account exists, we sent you a login link.",
+    "signup.magic_link_sent": "Check your email — we sent you a link to finish creating your account.",
     "login.passkey_button": "Sign in with a passkey",
     // Tela de cadastro (signup).
     "signup.page_title": "Create account",
@@ -803,6 +804,7 @@ export const PT_BR_MESSAGES = {
     // Passwordless (login).
     "login.magic_link_button": "Me envie um link de login",
     "login.magic_link_sent": "Se a conta existir, enviamos um link de login.",
+    "signup.magic_link_sent": "Enviamos um link para o seu e-mail. Abra-o para concluir o cadastro.",
     "login.passkey_button": "Entrar com passkey",
     // Tela de cadastro (signup).
     "signup.page_title": "Criar conta",

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

@@ -1,3 +1,17 @@
+/** Cadastro passwordless: só e-mail + nome (sem senha). O login vem por magic link. */
+export declare const passwordlessSignupValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
+    email: import("@vinejs/vine").VineString;
+    fullName: import("@vinejs/vine").VineString;
+}, {
+    email: string;
+    fullName: string;
+}, {
+    email: string;
+    fullName: string;
+}, {
+    email: string;
+    fullName: string;
+}>, Record<string, any> | undefined>;
 export declare const signupValidator: import("@vinejs/vine").VineValidator<import("@vinejs/vine").VineObject<{
     email: import("@vinejs/vine").VineString;
     fullName: import("@vinejs/vine").VineString;

package/build/src/host/validators.js

@@ -1,4 +1,9 @@
 import vine from '@vinejs/vine';
+/** Cadastro passwordless: só e-mail + nome (sem senha). O login vem por magic link. */
+export const passwordlessSignupValidator = vine.compile(vine.object({
+    email: vine.string().trim().email().normalizeEmail(),
+    fullName: vine.string().trim().minLength(2).maxLength(255),
+}));
 export const signupValidator = vine.compile(vine.object({
     email: vine.string().trim().email().normalizeEmail(),
     fullName: vine.string().trim().minLength(2).maxLength(255),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.34.1",
+  "version": "0.36.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",
@@ -56,15 +56,16 @@
   "peerDependencies": {
     "@adonis-agora/durable": "^0.2.0",
     "@adonis-agora/telescope": "^0.1.0",
-    "@adonisjs/ally": "6.3.0",
-    "@adonisjs/core": "7.3.3",
-    "@adonisjs/drive": "4.0.0",
-    "@adonisjs/lock": "2.1.0",
-    "@adonisjs/lucid": "22.4.2",
-    "@adonisjs/redis": "9.2.0",
-    "@adonisjs/session": "8.1.0",
-    "@adonisjs/shield": "9.0.0",
-    "edge.js": "6.5.1"
+    "@adonisjs/ally": "^6.3.0",
+    "@adonisjs/auth": "^10.1.0",
+    "@adonisjs/core": "^7.3.3",
+    "@adonisjs/drive": "^4.0.0",
+    "@adonisjs/lock": "^2.1.0",
+    "@adonisjs/lucid": "^22.4.2",
+    "@adonisjs/redis": "^9.2.0",
+    "@adonisjs/session": "^8.1.0",
+    "@adonisjs/shield": "^9.0.0",
+    "edge.js": "^6.5.1"
   },
   "peerDependenciesMeta": {
     "@adonis-agora/durable": {
@@ -79,6 +80,9 @@
     "@adonisjs/ally": {
       "optional": true
     },
+    "@adonisjs/auth": {
+      "optional": true
+    },
     "@adonisjs/drive": {
       "optional": true
     },
@@ -104,7 +108,8 @@
     "@adonis-agora/durable": "^0.2.0",
     "@adonis-agora/telescope": "^0.1.0",
     "@adonisjs/ally": "6.3.0",
-    "@adonisjs/core": "7.3.3",
+    "@adonisjs/auth": "10.1.0",
+    "@adonisjs/core": "7.3.5",
     "@adonisjs/drive": "4.0.0",
     "@adonisjs/lucid": "22.4.2",
     "@adonisjs/session": "8.1.0",
@@ -135,7 +140,7 @@
     "react-error-boundary": "6.1.2",
     "nuqs": "2.8.9",
     "recharts": "3.8.1",
-    "@adonis-agora/authkit-react": "0.13.0"
+    "@adonis-agora/authkit-react": "0.14.0"
   },
   "scripts": {
     "build": "node scripts/build_host_css.mjs && node scripts/build_ui.mjs && tsc && node -e \"require('node:fs').cpSync('stubs','build/stubs',{recursive:true,filter:(s)=>!s.endsWith('.ts')})\" && node -e \"const fs=require('node:fs');if(fs.existsSync('assets'))fs.cpSync('assets','build/assets',{recursive:true})\" && node -e \"require('node:fs').cpSync('src/host/views','build/host/views',{recursive:true})\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/host/ui',{recursive:true});fs.readdirSync('src/host/ui').filter(f=>f.endsWith('.html')).forEach(f=>fs.copyFileSync('src/host/ui/'+f,'build/host/ui/'+f))\" && node -e \"require('node:fs').copyFileSync('commands/commands.json','build/commands/commands.json')\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/password',{recursive:true});fs.copyFileSync('src/password/common_passwords.txt','build/password/common_passwords.txt')\"",