@adonis-agora/authkit-server 0.34.0

package/build/commands/expire_scan.js

@@ -0,0 +1,92 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+import { runExpireScan } from '../src/commands/expire_scan_command.js';
+/**
+ * Varre contas inativas e reporta expiradas/a expirar.
+ *
+ * Mecânica:
+ *   - "Última atividade" = último `login.success` da conta no audit (list capability).
+ *   - Sem audit queryável → aborta com aviso.
+ *   - --warn: envia e-mail de aviso às contas a expirar em breve (deduplicado via audit).
+ *   - --dry-run: reporta sem enviar e-mails nem auditar.
+ *   - --json: output machine-readable (estrutura ExpireScanResult).
+ *
+ * Exemplos:
+ *   node ace authkit:accounts:expire-scan
+ *   node ace authkit:accounts:expire-scan --dry-run
+ *   node ace authkit:accounts:expire-scan --warn
+ *   node ace authkit:accounts:expire-scan --warn --json
+ */
+export default class AuthkitExpireScan extends BaseCommand {
+    static commandName = 'authkit:accounts:expire-scan';
+    static description = 'Varre contas inativas (account_expiration setting) e reporta expiradas/a expirar. Com --warn envia e-mail de aviso. Pensado para cron do host.';
+    static help = [
+        'Varre o account store buscando contas inativas (sem login.success no audit há N dias).',
+        'Requer account_expiration.enabled = true na auth_settings E audit sink queryável (list).',
+        '',
+        'Exemplos:',
+        '  node ace authkit:accounts:expire-scan              # lista sem e-mail',
+        '  node ace authkit:accounts:expire-scan --dry-run    # preview sem auditar',
+        '  node ace authkit:accounts:expire-scan --warn       # envia e-mails de aviso',
+        '  node ace authkit:accounts:expire-scan --warn --json',
+    ];
+    static options = { startApp: true };
+    async run() {
+        const result = await runExpireScan(this.app, {
+            dryRun: this.dryRun,
+            warn: this.warn,
+            json: this.json,
+            logger: {
+                info: (m) => this.logger.info(m),
+                warn: (m) => this.logger.warning(m),
+                error: (m) => this.logger.error(m),
+            },
+        });
+        if (this.json) {
+            this.logger.info(JSON.stringify(result, null, 2));
+            return;
+        }
+        const { summary, expired, warnSoon } = result;
+        this.logger.info(`[expire-scan] Scanned: ${summary.scanned} accounts`);
+        this.logger.info(`[expire-scan] Expired (blocked at login): ${summary.expired}`);
+        this.logger.info(`[expire-scan] Expiring soon (within ${summary.warnDays}d): ${summary.warnSoon}`);
+        if (result.warned > 0) {
+            this.logger.info(`[expire-scan] Warning emails sent: ${result.warned}`);
+        }
+        if (result.deduped > 0) {
+            this.logger.info(`[expire-scan] Deduped (already warned): ${result.deduped}`);
+        }
+        if (expired.length > 0) {
+            this.logger.warning(`[expire-scan] Expired accounts:`);
+            for (const acc of expired) {
+                this.logger.warning(`  ${acc.email} (${acc.accountId}) — last activity ${acc.lastActivityDaysAgo ?? '?'} days ago`);
+            }
+        }
+        if (warnSoon.length > 0) {
+            this.logger.info(`[expire-scan] Expiring soon:`);
+            for (const acc of warnSoon) {
+                this.logger.info(`  ${acc.email} (${acc.accountId}) — expires in ${acc.expiresInDays} days`);
+            }
+        }
+        if (!summary.auditSupported) {
+            this.logger.warning(`[expire-scan] Audit sink does not support list(). Feature unavailable.`);
+        }
+        if (summary.dryRun) {
+            this.logger.info(`[expire-scan] DRY RUN — no emails sent, no audit events recorded.`);
+        }
+    }
+}
+__decorate([
+    flags.boolean({ description: 'Reporta sem enviar e-mails nem auditar.' })
+], AuthkitExpireScan.prototype, "dryRun", void 0);
+__decorate([
+    flags.boolean({ description: 'Envia e-mail de aviso às contas a expirar em breve (deduplicado via audit).' })
+], AuthkitExpireScan.prototype, "warn", void 0);
+__decorate([
+    flags.boolean({ description: 'Output em JSON machine-readable (estrutura ExpireScanResult).' })
+], AuthkitExpireScan.prototype, "json", void 0);

package/build/commands/import_users.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Importa usuários de outro sistema para o account store do AuthKit. Os hashes
+ * de senha entram COMO ESTÃO (sem re-hash) — o lazy rehash no primeiro login
+ * migra cada conta para o hasher atual (padrão Auth0/Clerk). Os e-mails
+ * duplicados são pulados (idempotente).
+ */
+export default class AuthkitImportUsers extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    file?: string;
+    dryRun?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/import_users.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { readFile } from 'node:fs/promises';
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+import { parseImportFile, importUsers } from '../src/commands/import_users.js';
+import { resolveAuthkitConfig } from '../src/commands/resolve_config.js';
+/**
+ * Importa usuários de outro sistema para o account store do AuthKit. Os hashes
+ * de senha entram COMO ESTÃO (sem re-hash) — o lazy rehash no primeiro login
+ * migra cada conta para o hasher atual (padrão Auth0/Clerk). Os e-mails
+ * duplicados são pulados (idempotente).
+ */
+export default class AuthkitImportUsers extends BaseCommand {
+    static commandName = 'authkit:users:import';
+    static description = 'Importa usuários de um arquivo JSON/NDJSON pelo account store (hashes entram como estão; lazy rehash no login).';
+    static help = [
+        'Cada registro aceita: email (obrigatório), password_hash (opcional, qualquer formato),',
+        'name, email_verified, global_roles. Aceita um array JSON ou NDJSON (uma linha por usuário).',
+        'Hashes legados de outros sistemas entram COMO ESTÃO — configure password.legacyVerifier no',
+        'accountStore para que o lazy rehash os migre no primeiro login.',
+        '',
+        'Exemplos:',
+        '  node ace authkit:users:import --file=users.ndjson',
+        '  node ace authkit:users:import --file=users.json --dry-run',
+    ];
+    static options = { startApp: true };
+    async run() {
+        if (!this.file) {
+            this.logger.logError('❌ --file é obrigatório (caminho do arquivo JSON/NDJSON).');
+            this.exitCode = 1;
+            return;
+        }
+        const config = await this.app.container.make('config');
+        // Resolve o config provider exportado por defineConfig (provider cru não tem accountStore).
+        const authkitConfig = await resolveAuthkitConfig(this.app, config.get('authkit', null));
+        const store = authkitConfig?.accountStore;
+        if (!store) {
+            this.logger.logError("❌ config('authkit').accountStore ausente.");
+            this.exitCode = 1;
+            return;
+        }
+        let content;
+        try {
+            content = await readFile(this.app.makePath(this.file), 'utf-8');
+        }
+        catch (error) {
+            this.logger.logError(`❌ Não foi possível ler o arquivo: ${error.message}`);
+            this.exitCode = 1;
+            return;
+        }
+        const { records, parseErrors } = parseImportFile(content);
+        const report = await importUsers(store, records, { dryRun: this.dryRun });
+        // Erros de parsing entram no relatório agregado.
+        report.errors.unshift(...parseErrors);
+        if (this.dryRun) {
+            this.logger.info('🧪 Dry-run — nenhum dado foi persistido.');
+        }
+        this.logger.success(`✅ ${report.created} usuário(s) ${this.dryRun ? 'seriam criados' : 'criados'}.`);
+        if (report.skippedDuplicate > 0) {
+            this.logger.warning(`⚠️  ${report.skippedDuplicate} pulado(s) (e-mail já existente).`);
+        }
+        if (report.errors.length > 0) {
+            this.logger.logError(`❌ ${report.errors.length} erro(s):`);
+            for (const e of report.errors) {
+                this.logger.logError(`   linha ${e.line}: ${e.reason}`);
+            }
+            this.exitCode = 1;
+        }
+    }
+}
+__decorate([
+    flags.string({ description: 'Caminho do arquivo JSON/NDJSON com os usuários.' })
+], AuthkitImportUsers.prototype, "file", void 0);
+__decorate([
+    flags.boolean({ description: 'Valida e relata SEM persistir nada.' })
+], AuthkitImportUsers.prototype, "dryRun", void 0);

package/build/commands/keys_rotate.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Rotação de chaves de assinatura JWKS (padrão OIDC). Gera uma chave nova, passa a
+ * ASSINAR com ela e mantém as antigas publicadas no JWKS por um período de graça
+ * (tokens emitidos antes continuam validando). `--retire` remove TODAS as antigas
+ * de imediato; `--dry-run` apenas imprime o plano sem tocar o keystore.
+ *
+ * Substitui o legado `authkit:rotate-keys` (mantido como alias). Quando a config
+ * resolvida traz um `audit` sink, registra o evento `keys.rotated` (best-effort).
+ */
+export default class AuthkitKeysRotate extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    keep?: number;
+    dryRun?: boolean;
+    retire?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/keys_rotate.js

@@ -0,0 +1,126 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+import { signingKeyAgeDays } from '../src/keys/keystore.js';
+import { KeystoreManager, resolveKeystoreVault } from '../src/keys/keystore_manager.js';
+import { KeystoreCodec } from '../src/keys/keystore_codec.js';
+import { loadEncryptionService } from '../src/keys/keystore_crypto.js';
+import { defaultEncryptForStore } from '../src/define_config.js';
+import { resolveAuthkitConfig } from '../src/commands/resolve_config.js';
+/**
+ * Rotação de chaves de assinatura JWKS (padrão OIDC). Gera uma chave nova, passa a
+ * ASSINAR com ela e mantém as antigas publicadas no JWKS por um período de graça
+ * (tokens emitidos antes continuam validando). `--retire` remove TODAS as antigas
+ * de imediato; `--dry-run` apenas imprime o plano sem tocar o keystore.
+ *
+ * Substitui o legado `authkit:rotate-keys` (mantido como alias). Quando a config
+ * resolvida traz um `audit` sink, registra o evento `keys.rotated` (best-effort).
+ */
+export default class AuthkitKeysRotate extends BaseCommand {
+    static commandName = 'authkit:keys:rotate';
+    static description = 'Rotaciona as chaves de assinatura JWKS managed: gera uma nova chave (novo kid) que passa a assinar e mantém as anteriores no JWKS por um período de graça (--retire remove de imediato; --dry-run só mostra o plano).';
+    static help = [
+        'Requer `jwks: { source: "managed", store: "<arquivo>" }` na config authkit.',
+        'A chave nova vira a de assinatura corrente; as `--keep` mais recentes são',
+        'preservadas no JWKS público para que tokens emitidos antes ainda validem.',
+        '',
+        '  node ace authkit:keys:rotate            # rotaciona mantendo 2 chaves',
+        '  node ace authkit:keys:rotate --dry-run  # só mostra o plano',
+        '  node ace authkit:keys:rotate --retire   # remove TODAS as chaves antigas',
+        '  node ace authkit:keys:rotate --keep=3   # mantém 3 chaves no JWKS',
+    ];
+    static options = { startApp: true };
+    async run() {
+        const config = await this.app.container.make('config');
+        // Resolve o config provider; no resolvido o `jwks` vira keyset materializado,
+        // então o shape de input (source/store) é lido de `jwksConfig`.
+        const authkitConfig = await resolveAuthkitConfig(this.app, config.get('authkit', null));
+        const jwksInput = (authkitConfig?.jwksConfig ?? authkitConfig?.jwks);
+        if (!jwksInput) {
+            this.logger.logError("❌ config('authkit').jwks ausente.");
+            this.exitCode = 1;
+            return;
+        }
+        const { source, store, algorithm } = jwksInput;
+        if (source !== 'managed') {
+            this.logger.logError('❌ Rotação só se aplica a jwks.source = "managed".');
+            this.exitCode = 1;
+            return;
+        }
+        if (!store) {
+            this.logger.logError('❌ jwks.store não configurado. A rotação exige um keystore persistido em arquivo ' +
+                '(ex.: jwks: { source: "managed", store: "tmp/authkit_jwks.json" }). ' +
+                'Sem store, o modo managed gera uma chave efêmera por boot e rotacionar não tem efeito.');
+            this.exitCode = 1;
+            return;
+        }
+        const alg = algorithm ?? 'RS256';
+        const keep = this.keep ?? 2;
+        const retire = this.retire ?? false;
+        const vault = resolveKeystoreVault(store, { makePath: (p) => this.app.makePath(p), container: this.app.container });
+        const encrypt = jwksInput.encrypt ?? defaultEncryptForStore(store);
+        const enc = encrypt ? await loadEncryptionService() : undefined;
+        const manager = new KeystoreManager(vault, new KeystoreCodec({ encrypt, enc }), alg);
+        const current = await manager.read();
+        const ageDays = signingKeyAgeDays(current);
+        if (ageDays !== null) {
+            this.logger.info(`Chave de assinatura corrente tem ~${ageDays} dia(s) de idade.`);
+        }
+        // --dry-run: imprime o plano (puro, sem gerar chave nem tocar disco) e sai.
+        if (this.dryRun) {
+            const plan = await manager.plan(keep, retire);
+            this.logger.info('Plano de rotação (dry-run — nada foi alterado):');
+            this.logger.info(`  • chave corrente: ${plan.currentKid ?? '(nenhuma — keystore vazio)'}`);
+            this.logger.info(`  • após rotação o JWKS manteria ${plan.keep} chave(s)`);
+            this.logger.info(`  • mantidas: ${plan.keptKids.join(', ')}`);
+            if (plan.retiredKids.length) {
+                this.logger.warning(`  • aposentadas: ${plan.retiredKids.join(', ')}`);
+            }
+            else {
+                this.logger.info('  • aposentadas: nenhuma');
+            }
+            return;
+        }
+        const { newKid, retiredKids, store: result } = await manager.rotate(keep, retire);
+        this.logger.success(`✅ Nova chave de assinatura gerada: kid=${newKid} (alg=${alg}).`);
+        this.logger.info(`JWKS agora serve ${result.keys.length} chave(s) (kids: ${result.keys.map((k) => k.kid).join(', ')}).`);
+        if (retiredKids.length) {
+            this.logger.warning(`⚠️  Chaves aposentadas (tokens assinados por elas deixarão de validar): ${retiredKids.join(', ')}`);
+        }
+        this.logger.info('Reinicie o processo (ou recarregue a config) para passar a assinar com a nova chave.');
+        // Audit event best-effort: a config resolvida expõe o sink em `audit`.
+        const sink = authkitConfig?.audit;
+        if (sink && typeof sink.record === 'function') {
+            try {
+                await sink.record({
+                    type: 'keys.rotated',
+                    metadata: {
+                        newKid,
+                        retiredKids,
+                        keptKids: result.keys.map((k) => k.kid),
+                        retire,
+                        alg,
+                    },
+                });
+            }
+            catch {
+                // best-effort: nunca falha a rotação por causa do log de auditoria.
+            }
+        }
+    }
+}
+__decorate([
+    flags.number({ description: 'Quantas chaves manter no JWKS (default 2).' })
+], AuthkitKeysRotate.prototype, "keep", void 0);
+__decorate([
+    flags.boolean({ description: 'Apenas mostra o plano da rotação; NÃO altera o keystore.' })
+], AuthkitKeysRotate.prototype, "dryRun", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Remove TODAS as chaves antigas de imediato (sem período de graça).',
+    })
+], AuthkitKeysRotate.prototype, "retire", void 0);

package/build/commands/main.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lê os metadados dos commands a partir do arquivo commands.json.
+ * O Ace usa esta função para listar os comandos disponíveis do pacote.
+ */
+export declare function getMetaData(): Promise<any[] | undefined>;
+/**
+ * Importa a classe do comando pelo `commandName`.
+ * O Ace chama esta função quando precisa executar um comando do pacote.
+ */
+export declare function getCommand(metaData: {
+    commandName: string;
+}): Promise<any>;

package/build/commands/main.js

@@ -0,0 +1,38 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readFile } from 'node:fs/promises';
+/**
+ * Cache in-memory após primeira leitura
+ */
+let commandsMetaData;
+/**
+ * Lê os metadados dos commands a partir do arquivo commands.json.
+ * O Ace usa esta função para listar os comandos disponíveis do pacote.
+ */
+export async function getMetaData() {
+    if (commandsMetaData) {
+        return commandsMetaData;
+    }
+    const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8');
+    commandsMetaData = JSON.parse(commandsIndex).commands;
+    return commandsMetaData;
+}
+/**
+ * Importa a classe do comando pelo `commandName`.
+ * O Ace chama esta função quando precisa executar um comando do pacote.
+ */
+export async function getCommand(metaData) {
+    const commands = await getMetaData();
+    const command = commands.find(({ commandName }) => metaData.commandName === commandName);
+    if (!command) {
+        return null;
+    }
+    const { default: commandConstructor } = await import(__rewriteRelativeImportExtension(new URL(command.filePath, import.meta.url).href));
+    return commandConstructor;
+}

package/build/commands/settings_get.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Obtém uma runtime setting por key.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:get lockout
+ *   node ace authkit:settings:get lockout --json
+ */
+export default class AuthkitSettingsGet extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    key: string;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/settings_get.js

@@ -0,0 +1,43 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { settingsGet } from '../src/commands/settings_commands.js';
+/**
+ * Obtém uma runtime setting por key.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:get lockout
+ *   node ace authkit:settings:get lockout --json
+ */
+export default class AuthkitSettingsGet extends BaseCommand {
+    static commandName = 'authkit:settings:get';
+    static description = 'Obtém uma runtime setting por key de `auth_settings`.';
+    static help = [
+        'Obtém o valor atual de uma setting pelo nome da key.',
+        'Retorna aviso quando a setting não está definida (config/default aplica).',
+        '',
+        'Exemplos:',
+        '  node ace authkit:settings:get lockout',
+        '  node ace authkit:settings:get session_policy --json',
+    ];
+    static options = { startApp: true };
+    async run() {
+        await settingsGet(this.app, this.key, {
+            json: this.json,
+            logger: {
+                info: (m) => this.logger.info(m),
+                warn: (m) => this.logger.warning(m),
+            },
+        });
+    }
+}
+__decorate([
+    args.string({ description: 'Nome da setting (ex.: lockout, session_policy).' })
+], AuthkitSettingsGet.prototype, "key", void 0);
+__decorate([
+    flags.boolean({ description: 'Output em JSON machine-readable.' })
+], AuthkitSettingsGet.prototype, "json", void 0);

package/build/commands/settings_list.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Lista todas as runtime settings presentes em `auth_settings`.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:list
+ *   node ace authkit:settings:list --json
+ */
+export default class AuthkitSettingsList extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/settings_list.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, flags } from '@adonisjs/core/ace';
+import { settingsList } from '../src/commands/settings_commands.js';
+/**
+ * Lista todas as runtime settings presentes em `auth_settings`.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:list
+ *   node ace authkit:settings:list --json
+ */
+export default class AuthkitSettingsList extends BaseCommand {
+    static commandName = 'authkit:settings:list';
+    static description = 'Lista todas as runtime settings presentes em `auth_settings`.';
+    static help = [
+        'Lista todas as settings salvas na tabela `auth_settings`, com key, valor e metadados.',
+        '',
+        'Exemplos:',
+        '  node ace authkit:settings:list',
+        '  node ace authkit:settings:list --json',
+    ];
+    static options = { startApp: true };
+    async run() {
+        await settingsList(this.app, {
+            json: this.json,
+            logger: {
+                info: (m) => this.logger.info(m),
+                warn: (m) => this.logger.warning(m),
+            },
+        });
+    }
+}
+__decorate([
+    flags.boolean({ description: 'Output em JSON machine-readable.' })
+], AuthkitSettingsList.prototype, "json", void 0);

package/build/commands/settings_set.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Grava (upsert) uma runtime setting em `auth_settings`.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:set lockout '{"enabled":true,"maxAttempts":3}'
+ *   node ace authkit:settings:set lockout '{"enabled":false}' --json
+ *   node ace authkit:settings:set my_custom_key '{"foo":"bar"}'
+ */
+export default class AuthkitSettingsSet extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    key: string;
+    value: string;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/settings_set.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { settingsSet } from '../src/commands/settings_commands.js';
+/**
+ * Grava (upsert) uma runtime setting em `auth_settings`.
+ *
+ * Exemplo:
+ *   node ace authkit:settings:set lockout '{"enabled":true,"maxAttempts":3}'
+ *   node ace authkit:settings:set lockout '{"enabled":false}' --json
+ *   node ace authkit:settings:set my_custom_key '{"foo":"bar"}'
+ */
+export default class AuthkitSettingsSet extends BaseCommand {
+    static commandName = 'authkit:settings:set';
+    static description = 'Grava (upsert) uma runtime setting em `auth_settings`. Valida shape para keys conhecidas.';
+    static help = [
+        'Grava ou atualiza uma setting pelo nome da key com o valor JSON fornecido.',
+        'Para keys conhecidas do catálogo AuthKit, valida o shape antes de persistir.',
+        'Keys desconhecidas são aceitas com aviso (stored as-is).',
+        'Audita settings.updated com actor "cli".',
+        '',
+        'Exemplos:',
+        '  node ace authkit:settings:set lockout \'{"enabled":true,"maxAttempts":3,"windowSec":900}\'',
+        '  node ace authkit:settings:set session_policy \'{"rememberEnabled":true,"rememberDays":14}\'',
+        '  node ace authkit:settings:set token_ttl \'{"accessTokenSec":1800}\'',
+        '  node ace authkit:settings:set my_flag \'{"enabled":true}\'',
+        '  node ace authkit:settings:set lockout \'{"enabled":false}\' --json',
+    ];
+    static options = { startApp: true };
+    async run() {
+        const ok = await settingsSet(this.app, this.key, this.value, {
+            json: this.json,
+            logger: {
+                info: (m) => this.logger.info(m),
+                warn: (m) => this.logger.warning(m),
+                error: (m) => this.logger.logError(m),
+            },
+        });
+        if (!ok)
+            this.exitCode = 1;
+    }
+}
+__decorate([
+    args.string({ description: 'Nome da setting (ex.: lockout, session_policy, token_ttl).' })
+], AuthkitSettingsSet.prototype, "key", void 0);
+__decorate([
+    args.string({ description: 'Valor JSON da setting (deve ser um objeto JSON válido).' })
+], AuthkitSettingsSet.prototype, "value", void 0);
+__decorate([
+    flags.boolean({ description: 'Output em JSON machine-readable.' })
+], AuthkitSettingsSet.prototype, "json", void 0);

package/build/commands/settings_unset.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Remove uma runtime setting de `auth_settings` (reset to config/default).
+ *
+ * Exemplo:
+ *   node ace authkit:settings:unset lockout
+ *   node ace authkit:settings:unset lockout --json
+ */
+export default class AuthkitSettingsUnset extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    key: string;
+    json?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/settings_unset.js

@@ -0,0 +1,46 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { settingsUnset } from '../src/commands/settings_commands.js';
+/**
+ * Remove uma runtime setting de `auth_settings` (reset to config/default).
+ *
+ * Exemplo:
+ *   node ace authkit:settings:unset lockout
+ *   node ace authkit:settings:unset lockout --json
+ */
+export default class AuthkitSettingsUnset extends BaseCommand {
+    static commandName = 'authkit:settings:unset';
+    static description = 'Remove uma runtime setting de `auth_settings` (reset ao config/default).';
+    static help = [
+        'Remove a setting pelo nome da key. Após a remoção, o config estático ou o default',
+        'da lib passa a ser a fonte de verdade para aquela setting.',
+        'Avisa quando a key não estava definida (nada é apagado).',
+        'Audita settings.updated (action: deleted) com actor "cli".',
+        '',
+        'Exemplos:',
+        '  node ace authkit:settings:unset lockout',
+        '  node ace authkit:settings:unset session_policy --json',
+    ];
+    static options = { startApp: true };
+    async run() {
+        await settingsUnset(this.app, this.key, {
+            json: this.json,
+            logger: {
+                info: (m) => this.logger.info(m),
+                warn: (m) => this.logger.warning(m),
+                error: (m) => this.logger.logError(m),
+            },
+        });
+    }
+}
+__decorate([
+    args.string({ description: 'Nome da setting a remover (ex.: lockout, session_policy).' })
+], AuthkitSettingsUnset.prototype, "key", void 0);
+__decorate([
+    flags.boolean({ description: 'Output em JSON machine-readable.' })
+], AuthkitSettingsUnset.prototype, "json", void 0);