@dudousxd/adonis-authkit-server 0.1.1 → 0.3.0

package/build/src/host/controllers/admin/admin_clients_controller.d.ts

@@ -1,10 +1,24 @@
 import '../../augmentations.js';
 import type { HttpContext } from '@adonisjs/core/http';
 /**
- * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
- * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
- * aqui — a view informa isso quando o registro dinâmico está ligado.
+ * CRUD de clients OIDC no console admin. Mostra os clients ESTÁTICOS da config
+ * (somente leitura, rotulados) lado a lado com os clients DINÂMICOS persistidos
+ * no adapter (registro dinâmico/RFC 7591 + os criados aqui). Quando o adapter não
+ * suporta enumeração (`listClients`), a seção dinâmica degrada graciosamente —
+ * espelhando o padrão da tela de auditoria.
  */
 export default class AdminClientsController {
     index(ctx: HttpContext): Promise<any>;
+    /** Formulário de criação. */
+    create(ctx: HttpContext): Promise<any>;
+    /** Persiste um client novo; mostra o secret UMA vez via flash. */
+    store(ctx: HttpContext): Promise<void>;
+    /** Formulário de edição de um client persistido. */
+    edit(ctx: HttpContext): Promise<any>;
+    /** Atualiza metadata editável (NÃO o secret). */
+    update(ctx: HttpContext): Promise<void>;
+    /** Regenera o secret de um client confidencial; mostra o novo valor UMA vez. */
+    regenerateSecret(ctx: HttpContext): Promise<void>;
+    /** Remove um client persistido. */
+    destroy(ctx: HttpContext): Promise<void>;
 }

package/build/src/host/controllers/admin/admin_clients_controller.js

@@ -1,24 +1,178 @@
 import '../../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../../middleware/account_auth.js';
+import { AdminClientsService, } from '../../admin_clients_service.js';
+const VALID_GRANTS = ['authorization_code', 'refresh_token', 'client_credentials'];
+const VALID_AUTH_METHODS = [
+    'client_secret_basic',
+    'client_secret_post',
+    'none',
+];
+/** Normaliza um textarea (1 item por linha) numa lista sem vazios nem duplicatas. */
+function parseLines(raw) {
+    return Array.from(new Set(String(raw ?? '')
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0)));
+}
+/** Lê os grants marcados no form (checkboxes); cai no default quando nenhum. */
+function parseGrants(ctx) {
+    const raw = ctx.request.input('grant_types', []);
+    const arr = Array.isArray(raw) ? raw : [raw];
+    const filtered = arr.filter((g) => VALID_GRANTS.includes(g));
+    return filtered.length ? filtered : ['authorization_code', 'refresh_token'];
+}
+function parseAuthMethod(ctx) {
+    const raw = ctx.request.input('token_endpoint_auth_method', 'client_secret_basic');
+    return (VALID_AUTH_METHODS.includes(raw)
+        ? raw
+        : 'client_secret_basic');
+}
+function readInput(ctx) {
+    return {
+        clientId: ctx.request.input('client_id', '').trim() || undefined,
+        redirectUris: parseLines(ctx.request.input('redirect_uris')),
+        postLogoutRedirectUris: parseLines(ctx.request.input('post_logout_redirect_uris')),
+        grantTypes: parseGrants(ctx),
+        tokenEndpointAuthMethod: parseAuthMethod(ctx),
+    };
+}
 /**
- * Listagem de OAuth clients. Mostra os clients ESTÁTICOS da config; clients
- * registrados dinamicamente (RFC 7591) vivem no adapter OIDC e não são listados
- * aqui — a view informa isso quando o registro dinâmico está ligado.
+ * CRUD de clients OIDC no console admin. Mostra os clients ESTÁTICOS da config
+ * (somente leitura, rotulados) lado a lado com os clients DINÂMICOS persistidos
+ * no adapter (registro dinâmico/RFC 7591 + os criados aqui). Quando o adapter não
+ * suporta enumeração (`listClients`), a seção dinâmica degrada graciosamente —
+ * espelhando o padrão da tela de auditoria.
  */
 export default class AdminClientsController {
     async index(ctx) {
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const render = cfg.render;
+        const admin = new AdminClientsService(service);
+        const dynamicSupported = admin.canList;
+        const dynamicClients = dynamicSupported ? await admin.list() : [];
+        const createdSecret = ctx.session.flashMessages.get('createdClientSecret');
         return render(ctx, 'admin/clients', {
             csrfToken: ctx.request.csrfToken,
             dynamicEnabled: cfg.dynamicRegistration.enabled,
-            clients: cfg.clients.map((c) => ({
+            dynamicSupported,
+            createdSecret: createdSecret ?? null,
+            staticClients: cfg.clients.map((c) => ({
                 clientId: c.clientId,
                 confidential: !!c.clientSecret,
                 grants: c.grants ?? ['authorization_code', 'refresh_token'],
                 redirectUris: c.redirectUris ?? [],
                 postLogoutRedirectUris: c.postLogoutRedirectUris ?? [],
             })),
+            dynamicClients,
+        });
+    }
+    /** Formulário de criação. */
+    async create(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        return render(ctx, 'admin/client_form', {
+            csrfToken: ctx.request.csrfToken,
+            mode: 'create',
+            client: {
+                clientId: '',
+                redirectUris: [],
+                postLogoutRedirectUris: [],
+                grants: ['authorization_code', 'refresh_token'],
+                tokenEndpointAuthMethod: 'client_secret_basic',
+            },
+        });
+    }
+    /** Persiste um client novo; mostra o secret UMA vez via flash. */
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const input = readInput(ctx);
+        const created = await admin.create(input);
+        if (created.clientSecret) {
+            ctx.session.flash('createdClientSecret', {
+                clientId: created.clientId,
+                clientSecret: created.clientSecret,
+            });
+        }
+        await cfg.audit?.record({
+            type: 'client.created',
+            clientId: created.clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Formulário de edição de um client persistido. */
+    async edit(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        const client = await admin.find(clientId);
+        if (!client)
+            return ctx.response.redirect('/admin/clients');
+        return render(ctx, 'admin/client_form', {
+            csrfToken: ctx.request.csrfToken,
+            mode: 'edit',
+            client,
+        });
+    }
+    /** Atualiza metadata editável (NÃO o secret). */
+    async update(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        const existing = await admin.find(clientId);
+        if (!existing)
+            return ctx.response.redirect('/admin/clients');
+        const input = { ...readInput(ctx), clientId };
+        await admin.update(clientId, input);
+        await cfg.audit?.record({
+            type: 'client.updated',
+            clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+        });
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Regenera o secret de um client confidencial; mostra o novo valor UMA vez. */
+    async regenerateSecret(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        try {
+            const secret = await admin.regenerateSecret(clientId);
+            ctx.session.flash('createdClientSecret', { clientId, clientSecret: secret });
+            await cfg.audit?.record({
+                type: 'client.updated',
+                clientId,
+                actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { action: 'regenerate_secret' },
+            });
+        }
+        catch {
+            // client inexistente ou public — sem secret a regenerar; volta silenciosamente.
+        }
+        return ctx.response.redirect('/admin/clients');
+    }
+    /** Remove um client persistido. */
+    async destroy(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const admin = new AdminClientsService(service);
+        const clientId = ctx.request.param('id');
+        await admin.delete(clientId);
+        await cfg.audit?.record({
+            type: 'client.deleted',
+            clientId,
+            actorId: ctx.session.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
         });
+        return ctx.response.redirect('/admin/clients');
     }
 }

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

@@ -1,7 +1,8 @@
 import '../augmentations.js';
 import { brandFor, isFirstParty } from '../branding.js';
 import { translate } from '../i18n.js';
-import { createAccountLockout } from '../account_lockout.js';
+import { attemptPasswordLogin } from '../login_attempt.js';
+import { supportsPasskeys } from '../../accounts/account_store.js';
 const SESSION_KEY = 'authkit_login_email';
 /** accountId aguardando o 2º fator depois da senha verificada. */
 const MFA_PENDING_KEY = 'authkit_mfa_pending';
@@ -80,35 +81,12 @@ export default class AuthInteractionController {
         const { password } = ctx.request.only(['password']);
         const ip = ctx.request.ip?.() ?? null;
         const clientId = details.params.client_id ?? null;
-        const lockout = createAccountLockout(cfg.lockout);
-        // Bloqueio progressivo (keyed por email da sessão): se travada, não verifica a senha.
-        const lock = await lockout.isLocked(email);
-        if (lock.locked) {
-            const found = await cfg.accountStore.findByEmail(email);
-            const account = found
-                ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
-                : null;
-            return render(ctx, 'login', {
-                uid: ctx.request.param('uid'),
-                csrfToken: ctx.request.csrfToken,
-                step: 'password',
-                email,
-                account,
-                error: translate(cfg.messages, 'errors.account_locked', {
-                    seconds: lock.retryAfterSec ?? 0,
-                }),
-                brand,
-            });
-        }
         // Verificamos as credenciais ANTES de finalizar a interaction, porque com MFA
         // ligado precisamos exigir o 2º fator e NÃO podemos chamar interactionFinished
-        // ainda. (`service.interactions.login` verifica E finaliza num passo só — por
-        // isso fazemos a verificação aqui via accountStore e finalizamos depois.)
-        const acc = await cfg.accountStore.verifyCredentials(email, password);
-        if (!acc) {
-            await cfg.audit?.record({ type: 'login.failure', email, ip, clientId });
-            await lockout.recordFailure(email, { sink: cfg.audit, ip });
-            // Re-render password step with error (keep email in session)
+        // ainda. A sequência verificação + lockout + auditoria de falha é centralizada
+        // em attemptPasswordLogin; a renderização (lookup p/ personalização) fica aqui.
+        const result = await attemptPasswordLogin(cfg, { email, password, ip, clientId });
+        if (!result.ok) {
             const found = await cfg.accountStore.findByEmail(email);
             const account = found
                 ? { fullName: found.name ?? null, globalRoles: found.globalRoles ?? [] }
@@ -119,12 +97,15 @@ export default class AuthInteractionController {
                 step: 'password',
                 email,
                 account,
-                error: translate(cfg.messages, 'errors.invalid_credentials'),
+                error: result.locked
+                    ? translate(cfg.messages, 'errors.account_locked', {
+                        seconds: result.retryAfterSec ?? 0,
+                    })
+                    : translate(cfg.messages, 'errors.invalid_credentials'),
                 brand,
             });
         }
-        // Senha correta: limpa o contador de falhas (o lockout protege a etapa de senha).
-        await lockout.clearFailures(email);
+        const acc = result.account;
         // MFA gate: se a conta tem TOTP ativo, NÃO finaliza a interaction agora —
         // guarda o accountId pendente na sessão e renderiza o desafio do 2º fator.
         const mfa = (await cfg.accountStore.getMfaState?.(acc.id)) ?? { enabled: false };
@@ -204,7 +185,7 @@ export default class AuthInteractionController {
     }
     /** true se o store suporta passkeys E a conta tem ao menos uma registrada. */
     async hasPasskeys(cfg, accountId) {
-        if (typeof cfg.accountStore.listPasskeys !== 'function')
+        if (!supportsPasskeys(cfg.accountStore))
             return false;
         const list = await cfg.accountStore.listPasskeys(accountId);
         return Array.isArray(list) && list.length > 0;

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

@@ -1,5 +1,6 @@
 import '../augmentations.js';
 import { randomUUID } from 'node:crypto';
+import { supportsProviderIdentity } from '../../accounts/account_store.js';
 const UID_SESSION_KEY = 'authkit_social_uid';
 /**
  * `AllyService.use()` é tipado contra a interface `SocialProviders`, que só é
@@ -37,6 +38,12 @@ export default class AuthSocialController {
         const cfg = service.config;
         const store = cfg.accountStore;
         const email = profile.email ?? undefined;
+        // Account linking exige a capacidade de provider-identity (model wired no store).
+        // Ausente → não há como ligar a identidade; volta ao login em vez de quebrar.
+        if (!supportsProviderIdentity(store)) {
+            ctx.session.forget(UID_SESSION_KEY);
+            return ctx.response.redirect(backToLogin);
+        }
         // Precedência do account linking:
         //  1. Identidade de provider já ligada → loga essa conta.
         //  2. Senão, e-mail conhecido → acha por e-mail e LIGA a identidade (linking).

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

@@ -148,6 +148,33 @@ export declare const DEFAULT_MESSAGES: {
     'admin.clients.grants': string;
     'admin.clients.redirect_uris': string;
     'admin.clients.dynamic_notice': string;
+    'admin.clients.static_section': string;
+    'admin.clients.dynamic_section': string;
+    'admin.clients.dynamic_empty': string;
+    'admin.clients.dynamic_not_supported': string;
+    'admin.clients.new': string;
+    'admin.clients.new_title': string;
+    'admin.clients.edit_title': string;
+    'admin.clients.edit': string;
+    'admin.clients.delete': string;
+    'admin.clients.delete_confirm': string;
+    'admin.clients.regenerate_secret': string;
+    'admin.clients.regenerate_confirm': string;
+    'admin.clients.back': string;
+    'admin.clients.cancel': string;
+    'admin.clients.save': string;
+    'admin.clients.create': string;
+    'admin.clients.secret_once_title': string;
+    'admin.clients.secret_once_notice': string;
+    'admin.clients.field_client_id': string;
+    'admin.clients.field_client_id_placeholder': string;
+    'admin.clients.field_client_id_help': string;
+    'admin.clients.field_redirect_uris': string;
+    'admin.clients.field_redirect_uris_help': string;
+    'admin.clients.field_post_logout_uris': string;
+    'admin.clients.field_post_logout_uris_help': string;
+    'admin.clients.field_grant_types': string;
+    'admin.clients.field_auth_method': string;
     'admin.audit.page_title': string;
     'admin.audit.title': string;
     'admin.audit.type_placeholder': string;

package/build/src/host/i18n.js

@@ -153,7 +153,34 @@ export const DEFAULT_MESSAGES = {
     'admin.clients.public': 'Público',
     'admin.clients.grants': 'Grants: {grants}',
     'admin.clients.redirect_uris': 'Redirects: {uris}',
-    'admin.clients.dynamic_notice': 'O registro dinâmico de clients está ligado — clients registrados via /reg vivem no adapter e não aparecem nesta lista.',
+    'admin.clients.dynamic_notice': 'O registro dinâmico de clients (RFC 7591) está ligado — clients registrados via /reg são persistidos no adapter e aparecem na seção dinâmica abaixo.',
+    'admin.clients.static_section': 'Clients estáticos (config)',
+    'admin.clients.dynamic_section': 'Clients dinâmicos (adapter)',
+    'admin.clients.dynamic_empty': 'Nenhum client dinâmico persistido.',
+    'admin.clients.dynamic_not_supported': 'O adapter OIDC configurado não suporta enumeração de clients — a gestão dinâmica fica indisponível.',
+    'admin.clients.new': 'Novo client',
+    'admin.clients.new_title': 'Novo client OIDC',
+    'admin.clients.edit_title': 'Editar client OIDC',
+    'admin.clients.edit': 'Editar',
+    'admin.clients.delete': 'Excluir',
+    'admin.clients.delete_confirm': 'Excluir este client? Esta ação não pode ser desfeita.',
+    'admin.clients.regenerate_secret': 'Regenerar secret',
+    'admin.clients.regenerate_confirm': 'Regenerar o secret? O secret atual deixará de funcionar imediatamente.',
+    'admin.clients.back': 'Voltar',
+    'admin.clients.cancel': 'Cancelar',
+    'admin.clients.save': 'Salvar',
+    'admin.clients.create': 'Criar client',
+    'admin.clients.secret_once_title': 'Guarde o client_secret agora',
+    'admin.clients.secret_once_notice': 'Este é o único momento em que o secret é exibido. Copie-o agora — ele não pode ser recuperado depois.',
+    'admin.clients.field_client_id': 'Client ID',
+    'admin.clients.field_client_id_placeholder': 'deixe em branco para gerar automaticamente',
+    'admin.clients.field_client_id_help': 'Opcional. Se vazio, um identificador aleatório será gerado.',
+    'admin.clients.field_redirect_uris': 'Redirect URIs',
+    'admin.clients.field_redirect_uris_help': 'Uma URI por linha.',
+    'admin.clients.field_post_logout_uris': 'Post-logout redirect URIs',
+    'admin.clients.field_post_logout_uris_help': 'Uma URI por linha (opcional).',
+    'admin.clients.field_grant_types': 'Grant types',
+    'admin.clients.field_auth_method': 'Token endpoint auth method',
     // Console admin — auditoria.
     'admin.audit.page_title': 'Auditoria',
     'admin.audit.title': 'Log de auditoria',

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

@@ -0,0 +1,39 @@
+import type { AuthAccount } from '../accounts/account_store.js';
+import type { ResolvedServerConfig } from '../define_config.js';
+/** Entrada de uma tentativa de login por senha (keyed por email). */
+export interface PasswordLoginInput {
+    email: string;
+    password: string;
+    /** IP da request (para auditoria + lockout). null quando indisponível. */
+    ip: string | null;
+    /**
+     * client_id da interaction OIDC, quando existir. Só é incluído no evento de
+     * auditoria nos fluxos que o têm (interaction); ausente no console de conta.
+     */
+    clientId?: string | null;
+}
+/** Resultado de {@link attemptPasswordLogin}. */
+export type PasswordLoginResult = {
+    ok: true;
+    account: AuthAccount;
+} | {
+    ok: false;
+    locked: boolean;
+    retryAfterSec?: number;
+};
+/**
+ * Sequência canônica de login por senha + bloqueio progressivo, compartilhada
+ * pelos dois fluxos que pedem senha (interaction OIDC e console de conta):
+ *
+ *   1. `lockout.isLocked(email)` — se travada, NÃO verifica a senha; devolve
+ *      `{ ok: false, locked: true, retryAfterSec }` (o controller renderiza o erro).
+ *   2. `verifyCredentials(email, password)` — em falha: emite `login.failure`
+ *      (com `clientId` apenas quando fornecido), registra a falha no lockout
+ *      (`{ sink: cfg.audit, ip }`) e devolve `{ ok: false, locked: false }`.
+ *   3. Em sucesso: limpa o contador de falhas e devolve `{ ok: true, account }`.
+ *
+ * O evento `login.success` e a finalização da sessão/interaction ficam a cargo de
+ * cada controller (os fluxos diferem: MFA gate na interaction, sessão no console),
+ * assim como toda a renderização.
+ */
+export declare function attemptPasswordLogin(cfg: ResolvedServerConfig, input: PasswordLoginInput): Promise<PasswordLoginResult>;

package/build/src/host/login_attempt.js

@@ -0,0 +1,37 @@
+import { createAccountLockout } from './account_lockout.js';
+/**
+ * Sequência canônica de login por senha + bloqueio progressivo, compartilhada
+ * pelos dois fluxos que pedem senha (interaction OIDC e console de conta):
+ *
+ *   1. `lockout.isLocked(email)` — se travada, NÃO verifica a senha; devolve
+ *      `{ ok: false, locked: true, retryAfterSec }` (o controller renderiza o erro).
+ *   2. `verifyCredentials(email, password)` — em falha: emite `login.failure`
+ *      (com `clientId` apenas quando fornecido), registra a falha no lockout
+ *      (`{ sink: cfg.audit, ip }`) e devolve `{ ok: false, locked: false }`.
+ *   3. Em sucesso: limpa o contador de falhas e devolve `{ ok: true, account }`.
+ *
+ * O evento `login.success` e a finalização da sessão/interaction ficam a cargo de
+ * cada controller (os fluxos diferem: MFA gate na interaction, sessão no console),
+ * assim como toda a renderização.
+ */
+export async function attemptPasswordLogin(cfg, input) {
+    const { email, password, ip } = input;
+    const lockout = createAccountLockout(cfg.lockout);
+    // Bloqueio progressivo (keyed por email): se travada, não verifica a senha.
+    const lock = await lockout.isLocked(email);
+    if (lock.locked) {
+        return { ok: false, locked: true, retryAfterSec: lock.retryAfterSec };
+    }
+    const account = await cfg.accountStore.verifyCredentials(email, password);
+    if (!account) {
+        // `clientId` só entra no evento quando o fluxo o fornece (interaction).
+        await cfg.audit?.record(input.clientId !== undefined
+            ? { type: 'login.failure', email, ip, clientId: input.clientId }
+            : { type: 'login.failure', email, ip });
+        await lockout.recordFailure(email, { sink: cfg.audit, ip });
+        return { ok: false, locked: false };
+    }
+    // Senha correta: limpa o contador de falhas (o lockout protege a etapa de senha).
+    await lockout.clearFailures(email);
+    return { ok: true, account };
+}

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

@@ -3,12 +3,25 @@ import type { AuthSocialConfig, RateLimitConfigInput } from '../define_config.js
 /**
  * Guard do console admin (B6). Como o `accountGuard`, é uma closure inline (forma
  * confiável do `.use()` num grupo). Exige:
+ *   0. `config.admin.enabled` ligado (senão → 404; ver nota de flag-drift abaixo);
  *   1. sessão de conta ativa (senão → /account/login);
  *   2. a conta logada com pelo menos UMA das `config.admin.roles` nas roles globais
  *      (senão → /account/tokens, evitando vazar a existência do /admin).
  * As roles permitidas são resolvidas em runtime do `authkit.server` (config lazy).
  */
 export declare const adminGuard: (ctx: any, next: () => Promise<void>) => Promise<any>;
+/**
+ * Opções de montagem das rotas do host-kit.
+ *
+ * NOTA (flag-drift): vários campos aqui (`social`, `rateLimit`, `admin`) ESPELHAM
+ * o config (`config/authkit.ts`) porque a decisão de MONTAR as rotas acontece em
+ * tempo de registro, antes de o config (lazy) resolver. Eles controlam apenas se
+ * as rotas existem; a fonte de verdade do COMPORTAMENTO continua sendo o config
+ * resolvido. Se um flag aqui divergir do config (ex.: `admin: true` aqui com
+ * `admin.enabled: false` no config), os guards das rotas são a rede de segurança
+ * (o `adminGuard` 404a quando `config.admin.enabled` é false). Mantenha-os em
+ * sincronia; os guards garantem que a divergência não vire um bypass.
+ */
 export interface AuthHostOptions {
     /** Onde o provider OIDC é montado (default '/oidc'). Deve casar com o final do issuer. */
     mountPath: string;

package/build/src/host/register_auth_host.js

@@ -16,18 +16,25 @@ const accountGuard = async (ctx, next) => {
 /**
  * Guard do console admin (B6). Como o `accountGuard`, é uma closure inline (forma
  * confiável do `.use()` num grupo). Exige:
+ *   0. `config.admin.enabled` ligado (senão → 404; ver nota de flag-drift abaixo);
  *   1. sessão de conta ativa (senão → /account/login);
  *   2. a conta logada com pelo menos UMA das `config.admin.roles` nas roles globais
  *      (senão → /account/tokens, evitando vazar a existência do /admin).
  * As roles permitidas são resolvidas em runtime do `authkit.server` (config lazy).
  */
 export const adminGuard = async (ctx, next) => {
+    const service = await ctx.containerResolver.make('authkit.server');
+    const cfg = service.config;
+    // Defesa contra flag-drift: as rotas são montadas com `admin: true` em tempo de
+    // registro, ANTES de o config resolver. Se o config tiver `admin.enabled: false`,
+    // as rotas existem mas o console deve estar desligado — 404 (não vaza a existência).
+    if (!cfg.admin.enabled) {
+        return ctx.response.notFound();
+    }
     const accountId = ctx.session?.get(ACCOUNT_SESSION_KEY);
     if (!accountId) {
         return ctx.response.redirect('/account/login');
     }
-    const service = await ctx.containerResolver.make('authkit.server');
-    const cfg = service.config;
     const allowed = cfg.admin.roles;
     const account = await cfg.accountStore.findById(accountId);
     const roles = account?.globalRoles ?? [];
@@ -126,6 +133,14 @@ export function registerAuthHost(router, opts) {
             router.get('/admin/users', [C.adminUsers, 'index']);
             router.post('/admin/users/:id/roles', [C.adminUsers, 'updateRoles']);
             router.get('/admin/clients', [C.adminClients, 'index']);
+            // CRUD de clients OIDC (adapter-backed). `/new` ANTES de `:id` p/ não casar
+            // "new" como id; todas as escritas são POST (com _csrf na view).
+            router.get('/admin/clients/new', [C.adminClients, 'create']);
+            router.post('/admin/clients', [C.adminClients, 'store']);
+            router.get('/admin/clients/:id/edit', [C.adminClients, 'edit']);
+            router.post('/admin/clients/:id/edit', [C.adminClients, 'update']);
+            router.post('/admin/clients/:id/regenerate-secret', [C.adminClients, 'regenerateSecret']);
+            router.post('/admin/clients/:id/delete', [C.adminClients, 'destroy']);
             router.get('/admin/audit', [C.adminAudit, 'index']);
         })
             .use([adminGuard]);

package/build/src/mixins/json_column.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Serializer canônico de coluna JSON para os mixins. Centraliza o par
+ * `prepare`/`consume` (`JSON.stringify`/`JSON.parse`) que cada mixin escrevia à
+ * mão com tratamentos de null/default ligeiramente diferentes.
+ *
+ * As opções parametrizam exatamente as variações observadas entre os mixins, de
+ * modo que o comportamento por coluna fica IDÊNTICO ao código original:
+ *
+ * - `fallback`: valor devolvido por `consume` quando a coluna é null/undefined
+ *   (ex.: `[]` para `globalRoles`/`scopes`; `null` para `recoveryCodes`/`metadata`).
+ * - `emptyOnWrite`: o que `prepare` grava quando o valor é "vazio" (null/undefined,
+ *   ou — quando `treatEmptyArrayAsEmpty` — um array de length 0). `'null'` grava
+ *   `null` na coluna; `'serialize'` ainda serializa (ex.: `globalRoles` grava
+ *   `"[]"`). Default: `'null'`.
+ * - `treatEmptyArrayAsEmpty`: quando true, um array vazio também conta como "vazio"
+ *   no write (caso do `transports`, que grava null em `[]`). Default: false.
+ * - `passthroughParsed`: quando true, `consume` aceita um valor JÁ desserializado
+ *   (array/objeto) e o devolve sem reparsear — alguns dialetos/drivers entregam o
+ *   JSON já decodificado. Default: false.
+ */
+export interface JsonColumnOptions<T> {
+    /** Valor devolvido por `consume` quando a coluna está null/undefined. */
+    fallback: T;
+    /** O que `prepare` grava para valores vazios. Default: 'null'. */
+    emptyOnWrite?: 'null' | 'serialize';
+    /** Trata array vazio como "vazio" no write (grava null). Default: false. */
+    treatEmptyArrayAsEmpty?: boolean;
+    /** Aceita valor já desserializado em `consume` (passthrough). Default: false. */
+    passthroughParsed?: boolean;
+}
+/**
+ * Devolve o par `{ prepare, consume }` para usar num `@column({...})`.
+ * `T` é o tipo lógico da coluna (ex.: `string[]` ou `Record<string, unknown>`).
+ */
+export declare function jsonColumn<T>(opts: JsonColumnOptions<T>): {
+    prepare: (value: T | null | undefined) => string | null;
+    consume: (value: unknown) => T;
+};

package/build/src/mixins/json_column.js

@@ -0,0 +1,31 @@
+/**
+ * Devolve o par `{ prepare, consume }` para usar num `@column({...})`.
+ * `T` é o tipo lógico da coluna (ex.: `string[]` ou `Record<string, unknown>`).
+ */
+export function jsonColumn(opts) {
+    const emptyOnWrite = opts.emptyOnWrite ?? 'null';
+    const treatEmptyArrayAsEmpty = opts.treatEmptyArrayAsEmpty ?? false;
+    const passthroughParsed = opts.passthroughParsed ?? false;
+    const isEmpty = (value) => {
+        if (value === null || value === undefined)
+            return true;
+        if (treatEmptyArrayAsEmpty && Array.isArray(value) && value.length === 0)
+            return true;
+        return false;
+    };
+    return {
+        prepare: (value) => {
+            if (isEmpty(value)) {
+                return emptyOnWrite === 'serialize' ? JSON.stringify(opts.fallback) : null;
+            }
+            return JSON.stringify(value);
+        },
+        consume: (value) => {
+            if (value === null || value === undefined)
+                return opts.fallback;
+            if (passthroughParsed && Array.isArray(value))
+                return value;
+            return JSON.parse(value);
+        },
+    };
+}

package/build/src/mixins/with_audit_log.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { column } from '@adonisjs/lucid/orm';
+import { jsonColumn } from './json_column.js';
 export function withAuditLog() {
     return (superclass) => {
         class AuditLogMixin extends superclass {
@@ -28,10 +29,7 @@ export function withAuditLog() {
             column()
         ], AuditLogMixin.prototype, "ip", void 0);
         __decorate([
-            column({
-                prepare: (value) => value ? JSON.stringify(value) : null,
-                consume: (value) => (value ? JSON.parse(value) : null),
-            })
+            column(jsonColumn({ fallback: null }))
         ], AuditLogMixin.prototype, "metadata", void 0);
         __decorate([
             column.dateTime({ autoCreate: true })

package/build/src/mixins/with_auth_user.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { column, beforeSave } from '@adonisjs/lucid/orm';
 import { Scrypt } from '@adonisjs/core/hash/drivers/scrypt';
+import { jsonColumn } from './json_column.js';
 const hasher = new Scrypt({});
 export function withAuthUser() {
     return (superclass) => {
@@ -26,10 +27,7 @@ export function withAuthUser() {
             column({ serializeAs: null })
         ], AuthUserMixin.prototype, "password", void 0);
         __decorate([
-            column({
-                prepare: (value) => JSON.stringify(value ?? []),
-                consume: (value) => (value ? JSON.parse(value) : []),
-            })
+            column(jsonColumn({ fallback: [], emptyOnWrite: 'serialize' }))
         ], AuthUserMixin.prototype, "globalRoles", void 0);
         __decorate([
             beforeSave()