@adonis-agora/authkit-server 0.69.0 → 0.71.0

package/build/commands/commands.json

@@ -153,6 +153,24 @@
       "options": { "startApp": true },
       "filePath": "import_users.js"
     },
+    {
+      "commandName": "authkit:users:normalize-emails",
+      "description": "Migra os e-mails gravados para a forma normalizada da identidade (trim + lowercase). Sem --apply apenas relata.",
+      "namespace": "authkit",
+      "aliases": [],
+      "flags": [
+        {
+          "name": "apply",
+          "flagName": "apply",
+          "required": false,
+          "type": "boolean",
+          "description": "Grava a normalização (sem ele, apenas relata)."
+        }
+      ],
+      "args": [],
+      "options": { "startApp": true },
+      "filePath": "normalize_emails.js"
+    },
     {
       "commandName": "authkit:settings:list",
       "description": "Lista todas as runtime settings presentes em `auth_settings`.",

package/build/commands/normalize_emails.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+import type { CommandOptions } from '@adonisjs/core/types/ace';
+/**
+ * Migra os endereços GRAVADOS para a forma normalizada da identidade (`trim` +
+ * `toLowerCase`) — a MESMA que o cadastro grava e que o login busca.
+ *
+ * É PASSO OBRIGATÓRIO do upgrade para quem tem contas criadas antes da v0.69:
+ * o cadastro antigo gravava o endereço mutilado (`.normalizeEmail()` do VineJS
+ * removia pontos e `+tag` no gmail) e import/convite/provider social gravavam a
+ * grafia crua, com maiúsculas. O login busca UMA forma só; qualquer outra grafia
+ * gravada deixa a conta INALCANÇÁVEL, sem mensagem de erro (a tela é à prova de
+ * enumeração).
+ */
+export default class AuthkitNormalizeEmails extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static help: string[];
+    static options: CommandOptions;
+    apply?: boolean;
+    run(): Promise<void>;
+}

package/build/commands/normalize_emails.js

@@ -0,0 +1,106 @@
+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 { normalizeAccountEmails } from '../src/commands/normalize_emails.js';
+import { resolveAuthkitConfig } from '../src/commands/resolve_config.js';
+/**
+ * Migra os endereços GRAVADOS para a forma normalizada da identidade (`trim` +
+ * `toLowerCase`) — a MESMA que o cadastro grava e que o login busca.
+ *
+ * É PASSO OBRIGATÓRIO do upgrade para quem tem contas criadas antes da v0.69:
+ * o cadastro antigo gravava o endereço mutilado (`.normalizeEmail()` do VineJS
+ * removia pontos e `+tag` no gmail) e import/convite/provider social gravavam a
+ * grafia crua, com maiúsculas. O login busca UMA forma só; qualquer outra grafia
+ * gravada deixa a conta INALCANÇÁVEL, sem mensagem de erro (a tela é à prova de
+ * enumeração).
+ */
+export default class AuthkitNormalizeEmails extends BaseCommand {
+    static commandName = 'authkit:users:normalize-emails';
+    static description = 'Migra os e-mails gravados para a forma normalizada da identidade (trim + lowercase). Sem --apply apenas relata.';
+    static help = [
+        'Sem --apply o comando NÃO escreve nada: varre as contas e relata quantas mudariam,',
+        'quais, e as COLISÕES (duas contas que colapsam no mesmo endereço).',
+        'Com --apply grava, recusando-se a tocar em qualquer conta envolvida numa colisão —',
+        'a migração nunca funde contas nem escolhe vencedor: as colididas saem listadas para',
+        'decisão humana.',
+        '',
+        'Sai com código != 0 quando há colisões (ou erro de escrita): é a sua deixa de que',
+        'a base ainda precisa de decisão humana.',
+        '',
+        'Exemplos:',
+        '  node ace authkit:users:normalize-emails',
+        '  node ace authkit:users:normalize-emails --apply',
+    ];
+    static options = { startApp: true };
+    async run() {
+        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 report;
+        try {
+            report = await normalizeAccountEmails(store, { apply: this.apply });
+        }
+        catch (error) {
+            this.logger.logError(`❌ ${error.message}`);
+            this.exitCode = 1;
+            return;
+        }
+        if (!this.apply) {
+            this.logger.info('🧪 Relatório — nenhum dado foi alterado (use --apply para gravar).');
+        }
+        this.logger.info(`🔎 ${report.scanned} conta(s) varrida(s); ${report.alreadyNormalized} já normalizada(s).`);
+        if (report.changes.length === 0) {
+            this.logger.success('✅ Nenhum endereço a normalizar.');
+        }
+        else if (this.apply) {
+            this.logger.success(`✅ ${report.applied} endereço(s) normalizado(s).`);
+        }
+        else {
+            this.logger.warning(`⚠️  ${report.changes.length} endereço(s) seriam normalizado(s):`);
+        }
+        for (const change of report.changes) {
+            if (change.error)
+                continue;
+            this.logger.info(`   ${change.from} → ${change.to}`);
+        }
+        const failures = report.changes.filter((change) => !!change.error);
+        if (failures.length > 0) {
+            this.logger.logError(`❌ ${failures.length} não gravada(s):`);
+            for (const change of failures) {
+                this.logger.logError(`   ${change.from} → ${change.to}: ${change.error}`);
+            }
+            this.exitCode = 1;
+        }
+        if (report.unusable.length > 0) {
+            // Não entram em "já normalizada": o relatório não dá por boa uma linha que
+            // deixou para trás.
+            this.logger.warning(`⚠️  ${report.unusable.length} conta(s) com e-mail vazio/inutilizável — NÃO migrada(s):`);
+            for (const account of report.unusable) {
+                this.logger.warning(`   id ${account.accountId}: ${JSON.stringify(account.email)}`);
+            }
+        }
+        if (report.collisions.length > 0) {
+            this.logger.logError(`❌ ${report.collisions.length} colisão(ões) — ${report.skippedByCollision} conta(s) NÃO tocada(s). Decida à mão (a migração não funde contas):`);
+            for (const collision of report.collisions) {
+                this.logger.logError(`   ${collision.email}:`);
+                for (const account of collision.accounts) {
+                    this.logger.logError(`     - ${account.email} (id ${account.accountId})`);
+                }
+            }
+            this.exitCode = 1;
+        }
+    }
+}
+__decorate([
+    flags.boolean({ description: 'Grava a normalização (sem ele, apenas relata).' })
+], AuthkitNormalizeEmails.prototype, "apply", void 0);

package/build/index.d.ts

@@ -3,8 +3,8 @@
  * O comando do AdonisJS importa o entrypoint principal e procura por estes exports.
  */
 export { configure } from './commands/configure.js';
-export type { AccountDeletionCapability, AccountImportCapability, AccountSecurityCapability, AccountStatusCapability, AccountStore, ActiveOrgInfo, AdminCapability, AuthAccount, CoreAccountStore, CreateAccountInput, EmailVerificationStatusCapability, ImportAccountInput, LinkProviderIdentityInput, ListAccountsParams, LoginMethodsPreferenceCapability, MagicLinkCapability, MfaCapability, OrganizationsCapability, OrgInvitation, OrgMember, OrgSummary, OtpLoginCapability, OtpLoginVerifyResult, Paginated, PasskeySummary, ProfileCapability, ProviderIdentityCapability, ProviderIdentitySummary, WebauthnCapability, } from './src/accounts/account_store.js';
-export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
+export type { AccountDeletionCapability, AccountEmailRewriteCapability, AccountImportCapability, AccountSecurityCapability, AccountStatusCapability, AccountStore, ActiveOrgInfo, AdminCapability, AuthAccount, CoreAccountStore, CreateAccountInput, EmailVerificationStatusCapability, ImportAccountInput, LinkProviderIdentityInput, ListAccountsParams, LoginMethodsPreferenceCapability, MagicLinkCapability, MfaCapability, OrganizationsCapability, OrgInvitation, OrgMember, OrgSummary, OtpLoginCapability, OtpLoginVerifyResult, Paginated, PasskeySummary, ProfileCapability, ProviderIdentityCapability, ProviderIdentitySummary, WebauthnCapability, } from './src/accounts/account_store.js';
+export { supportsAccountDeletion, supportsAccountEmailRewrite, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export type { AccountSecretEncrypter, LucidAccountStoreOptions, } from './src/accounts/lucid_account_store.js';
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
@@ -64,6 +64,7 @@ export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROU
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
 export type { AuthkitCsrfOptions } from './src/host/csrf.js';
 export { authkitCsrfExceptions } from './src/host/csrf.js';
+export { normalizeEmailIdentifier } from './src/host/email_identifier.js';
 export type { ResolveGeo } from './src/host/geo.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export type { AuthMessages, I18nConfig } from './src/host/i18n.js';
@@ -94,7 +95,7 @@ export { sudoMethods } from './src/host/sudo/index.js';
 export { completeSudo, fail as failSudo, LAST_METHOD_SESSION_KEY, sudoContextFrom, } from './src/host/sudo/runtime.js';
 export type { SudoContext, SudoMethod, SudoMethodDescriptor, SudoRouteHelpers, } from './src/host/sudo/types.js';
 export type { ResolvedSudoModeSetting, SudoModeSetting, } from './src/host/sudo_mode.js';
-export { isSudoActive, markSudo, requireSudo, resolveEffectiveSudoMode, SUDO_ACCOUNT_SESSION_KEY, SUDO_MODE_DEFAULTS, SUDO_SESSION_KEY, } from './src/host/sudo_mode.js';
+export { isSudoActive, isSudoSatisfied, markSudo, requireSudo, resolveEffectiveSudoMode, SUDO_ACCOUNT_SESSION_KEY, SUDO_MODE_DEFAULTS, SUDO_SESSION_KEY, } from './src/host/sudo_mode.js';
 export { barChartSvg } from './src/host/svg_chart.js';
 export type { ResolvedTrustedDevicesConfig, TrustedDevicePayload, TrustedDevicesConfigInput, } from './src/host/trusted_device.js';
 export { buildTrustedDevicePayload, isTrustedDeviceValid, resolveTrustedDevices, TRUSTED_DEVICE_COOKIE, } from './src/host/trusted_device.js';

package/build/index.js

@@ -3,7 +3,7 @@
  * O comando do AdonisJS importa o entrypoint principal e procura por estes exports.
  */
 export { configure } from './commands/configure.js';
-export { supportsAccountDeletion, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
+export { supportsAccountDeletion, supportsAccountEmailRewrite, supportsAccountImport, supportsAccountSecurity, supportsAccountStatus, supportsEmailVerificationStatus, supportsLoginMethodsPreference, supportsMagicLink, supportsMfa, supportsOrganizations, supportsOtpLogin, supportsPasskeys, supportsProfile, supportsProviderIdentity, } from './src/accounts/account_store.js';
 export { appKeyEncrypter, lucidAccountStore } from './src/accounts/lucid_account_store.js';
 export { AuthOrganization, AuthOrganizationInvitation, AuthOrganizationMember, defaultOrganizationModels, } from './src/accounts/lucid_store/organization_models.js';
 export { lucidStores } from './src/accounts/lucid_stores.js';
@@ -49,6 +49,7 @@ export { brandFor, isFirstParty, isFirstPartyClient } from './src/host/branding.
 export { deriveLockedSettingKeys, isSettingLocked, lockedSettingKeys, POLICY_ROUTE_OPTIONS, resetLockedSettingKeys, SettingLockedError, setLockedSettingKeys, } from './src/host/config_locks.js';
 export { consoleLoginUrl, getAccountId, hasAccountSession, realAccountId, } from './src/host/console_session.js';
 export { authkitCsrfExceptions } from './src/host/csrf.js';
+export { normalizeEmailIdentifier } from './src/host/email_identifier.js';
 export { GEO_RESOLVE_TIMEOUT_MS, resolveGeoSafe } from './src/host/geo.js';
 export { BUILTIN_MESSAGES, DEFAULT_LOCALE, DEFAULT_MESSAGES, PT_BR_MESSAGES, resolveMessages, translate, } from './src/host/i18n.js';
 export { ensureConsoleSession } from './src/host/idp_session_bridge.js';
@@ -90,7 +91,10 @@ export { sudoMethods } from './src/host/sudo/index.js';
 // `returnTo` montado na mão é um open redirect esperando acontecer.
 export { completeSudo, fail as failSudo, LAST_METHOD_SESSION_KEY, sudoContextFrom, } from './src/host/sudo/runtime.js';
 // Sudo mode — helpers for host controllers that require step-up authentication.
-export { isSudoActive, markSudo, requireSudo, resolveEffectiveSudoMode, SUDO_ACCOUNT_SESSION_KEY, SUDO_MODE_DEFAULTS, SUDO_SESSION_KEY, } from './src/host/sudo_mode.js';
+export { isSudoActive, 
+// A DECISÃO de sudo sem efeito na resposta — o que o host chama quando quer
+// recusar em JSON em vez de redirecionar para `/account/confirm`.
+isSudoSatisfied, markSudo, requireSudo, resolveEffectiveSudoMode, SUDO_ACCOUNT_SESSION_KEY, SUDO_MODE_DEFAULTS, SUDO_SESSION_KEY, } from './src/host/sudo_mode.js';
 export { barChartSvg } from './src/host/svg_chart.js';
 export { buildTrustedDevicePayload, isTrustedDeviceValid, resolveTrustedDevices, TRUSTED_DEVICE_COOKIE, } from './src/host/trusted_device.js';
 export { parseUserAgent } from './src/host/user_agent.js';

package/build/src/accounts/account_store.d.ts

@@ -278,6 +278,26 @@ export interface MfaCapability {
     consumeRecoveryCode(accountId: string, code: string): Promise<boolean>;
     /** Desliga o MFA: limpa segredo + mfaEnabledAt + recovery codes. */
     disableMfa(accountId: string): Promise<void>;
+    /**
+     * Quantos recovery codes AINDA não foram consumidos. OPCIONAL: existe para a
+     * tela de segundo fator dizer "restam N" sem revelar os códigos (só o hash
+     * fica guardado). `null` quando o MFA não está ativo.
+     *
+     * Opcional de propósito: um store de terceiro escrito contra a versão
+     * anterior de {@link MfaCapability} continua satisfazendo o tipo, e os
+     * callers fazem capability-probe (`typeof store.countRecoveryCodes ===
+     * 'function'`) antes de chamar.
+     */
+    countRecoveryCodes?(accountId: string): Promise<number | null>;
+    /**
+     * Regenera os recovery codes de uma conta com MFA ATIVO: descarta os antigos
+     * (inclusive os não usados) e devolve os novos em claro — uma única vez, como
+     * no {@link MfaCapability.confirmTotpEnrollment}. `null` quando o MFA não
+     * está ativo (não há o que regenerar).
+     *
+     * Opcional pelo mesmo motivo de {@link MfaCapability.countRecoveryCodes}.
+     */
+    regenerateRecoveryCodes?(accountId: string): Promise<string[] | null>;
 }
 /**
  * MFA / WebAuthn (passkeys) — 2º fator alternativo ao TOTP. Como o TOTP, é uma
@@ -421,6 +441,28 @@ export interface AccountImportCapability {
      */
     importAccount(input: ImportAccountInput): Promise<AuthAccount | null>;
 }
+/**
+ * Regravação ADMINISTRATIVA do endereço da conta (comando
+ * `authkit:users:normalize-emails`). CAPACIDADE opcional, presente no store
+ * Lucid default.
+ *
+ * Distinta de {@link AccountSecurityCapability.requestEmailChange}: NÃO há
+ * cerimônia de confirmação (nenhum token viaja, nenhum e-mail é enviado) e o
+ * estado de "e-mail verificado" fica COMO ESTÁ — a migração só canonicaliza a
+ * grafia de uma caixa postal que já era a mesma (`trim` + `toLowerCase`), então
+ * marcar como verificado seria conceder uma prova que ninguém deu.
+ *
+ * Não é um caminho para trocar de titular: quem quer mudar de caixa postal passa
+ * pelo fluxo com confirmação. Um store pode simplesmente não a implementar — aí
+ * o `--apply` do comando recusa e a base é migrada por SQL do host.
+ */
+export interface AccountEmailRewriteCapability {
+    /**
+     * Regrava o e-mail da conta. Retorna `false` quando a conta não existe ou
+     * quando o endereço já pertence a OUTRA conta (a migração nunca funde contas).
+     */
+    rewriteAccountEmail(accountId: string, email: string): Promise<boolean>;
+}
 /**
  * Login sem senha por "magic link" — um token de uso único e curta duração
  * enviado por e-mail. CAPACIDADE opcional: stores sem suporte omitem os métodos e
@@ -641,7 +683,7 @@ export type AccountStore = CoreAccountStore & {
      * Undefined → `users` (back-compat com stores próprios).
      */
     readonly accountTable?: string;
-} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
+} & Partial<MfaCapability & WebauthnCapability & ProviderIdentityCapability & AccountSecurityCapability & AccountStatusCapability & ProfileCapability & MagicLinkCapability & OtpLoginCapability & EmailVerificationStatusCapability & AccountDeletionCapability & AccountImportCapability & AccountEmailRewriteCapability & OrganizationsCapability & PasswordHistoryCapability & PasswordExpirationCapability & LoginMethodsPreferenceCapability>;
 /** Type guard: o store implementa a capacidade de MFA / TOTP. */
 export declare function supportsMfa(store: AccountStore): store is AccountStore & MfaCapability;
 /**
@@ -654,6 +696,26 @@ export declare function supportsCountByGlobalRole(store: AccountStore): store is
 };
 /** Type guard: o store implementa a capacidade de passkeys / WebAuthn. */
 export declare function supportsPasskeys(store: AccountStore): store is AccountStore & WebauthnCapability;
+/**
+ * Type guard: o store sabe REGENERAR recovery codes
+ * ({@link MfaCapability.regenerateRecoveryCodes}).
+ *
+ * Guard PRÓPRIO, separado de {@link supportsMfa}, porque o método é opcional
+ * dentro da capacidade: um store escrito antes desta versão implementa MFA
+ * inteiro e não implementa este método. Quem oferece o botão "gerar novos
+ * códigos" pergunta por aqui.
+ */
+export declare function supportsRecoveryCodeRegeneration(store: AccountStore): store is AccountStore & MfaCapability & {
+    regenerateRecoveryCodes(accountId: string): Promise<string[] | null>;
+};
+/**
+ * Type guard: o store sabe CONTAR recovery codes restantes
+ * ({@link MfaCapability.countRecoveryCodes}). Mesmo motivo do
+ * {@link supportsRecoveryCodeRegeneration} para ser um guard separado.
+ */
+export declare function supportsRecoveryCodeCount(store: AccountStore): store is AccountStore & MfaCapability & {
+    countRecoveryCodes(accountId: string): Promise<number | null>;
+};
 /** Type guard: o store implementa account linking por identidade de provider. */
 export declare function supportsProviderIdentity(store: AccountStore): store is AccountStore & ProviderIdentityCapability;
 /** Type guard: o store implementa o self-service de segurança (senha/e-mail). */
@@ -672,6 +734,8 @@ export declare function supportsEmailVerificationStatus(store: AccountStore): st
 export declare function supportsAccountDeletion(store: AccountStore): store is AccountStore & AccountDeletionCapability;
 /** Type guard: o store implementa o import em massa de contas. */
 export declare function supportsAccountImport(store: AccountStore): store is AccountStore & AccountImportCapability;
+/** Type guard: o store implementa a regravação administrativa do e-mail. */
+export declare function supportsAccountEmailRewrite(store: AccountStore): store is AccountStore & AccountEmailRewriteCapability;
 /** Type guard: o store implementa histórico de senhas (disallow_password_reuse). */
 export declare function supportsPasswordHistory(store: AccountStore): store is AccountStore & PasswordHistoryCapability;
 /** Type guard: o store implementa expiração de senha (password_changed_at coluna). */

package/build/src/accounts/account_store.js

@@ -18,6 +18,26 @@ export function supportsCountByGlobalRole(store) {
 export function supportsPasskeys(store) {
     return typeof store.listPasskeys === 'function';
 }
+/**
+ * Type guard: o store sabe REGENERAR recovery codes
+ * ({@link MfaCapability.regenerateRecoveryCodes}).
+ *
+ * Guard PRÓPRIO, separado de {@link supportsMfa}, porque o método é opcional
+ * dentro da capacidade: um store escrito antes desta versão implementa MFA
+ * inteiro e não implementa este método. Quem oferece o botão "gerar novos
+ * códigos" pergunta por aqui.
+ */
+export function supportsRecoveryCodeRegeneration(store) {
+    return typeof store.regenerateRecoveryCodes === 'function';
+}
+/**
+ * Type guard: o store sabe CONTAR recovery codes restantes
+ * ({@link MfaCapability.countRecoveryCodes}). Mesmo motivo do
+ * {@link supportsRecoveryCodeRegeneration} para ser um guard separado.
+ */
+export function supportsRecoveryCodeCount(store) {
+    return typeof store.countRecoveryCodes === 'function';
+}
 /** Type guard: o store implementa account linking por identidade de provider. */
 export function supportsProviderIdentity(store) {
     return typeof store.findByProviderIdentity === 'function';
@@ -55,6 +75,10 @@ export function supportsAccountDeletion(store) {
 export function supportsAccountImport(store) {
     return typeof store.importAccount === 'function';
 }
+/** Type guard: o store implementa a regravação administrativa do e-mail. */
+export function supportsAccountEmailRewrite(store) {
+    return typeof store.rewriteAccountEmail === 'function';
+}
 /** Type guard: o store implementa histórico de senhas (disallow_password_reuse). */
 export function supportsPasswordHistory(store) {
     return typeof store.isPasswordReused === 'function';

package/build/src/accounts/lucid_store/core.d.ts

@@ -1,4 +1,4 @@
-import type { AccountImportCapability, AccountSecurityCapability, CoreAccountStore, MagicLinkCapability, OtpLoginCapability } from '../account_store.js';
+import type { AccountEmailRewriteCapability, AccountImportCapability, AccountSecurityCapability, CoreAccountStore, MagicLinkCapability, OtpLoginCapability } from '../account_store.js';
 import type { LucidStoreContext } from './shared.js';
 /**
  * Núcleo SEMPRE presente do {@link CoreAccountStore} sobre um model Lucid:
@@ -6,4 +6,4 @@ import type { LucidStoreContext } from './shared.js';
  * (listagem paginada + roles globais) e o self-service de segurança
  * ({@link AccountSecurityCapability}: trocar senha/e-mail).
  */
-export declare function buildCore(ctx: LucidStoreContext): CoreAccountStore & AccountSecurityCapability & MagicLinkCapability & OtpLoginCapability & AccountImportCapability;
+export declare function buildCore(ctx: LucidStoreContext): CoreAccountStore & AccountSecurityCapability & MagicLinkCapability & OtpLoginCapability & AccountImportCapability & AccountEmailRewriteCapability;

package/build/src/accounts/lucid_store/core.js

@@ -432,6 +432,22 @@ export function buildCore(ctx) {
             await row.save();
             return { token, account: toAccount(row), newEmail };
         },
+        async rewriteAccountEmail(accountId, email) {
+            const row = await Model.find(accountId);
+            if (!row)
+                return false;
+            // Nunca funde contas: se o endereço já é de OUTRA conta, recusa. O comando
+            // já detecta a colisão antes de chegar aqui; isto é a rede de baixo, para
+            // a corrida (outra conta gravada entre o relatório e a escrita).
+            const taken = await Model.query().where('email', email).first();
+            if (taken && taken.id !== row.id)
+                return false;
+            row.email = email;
+            // `emailVerifiedAt` fica COMO ESTÁ: a caixa postal é a mesma, só a grafia
+            // gravada muda — não há prova nova para registrar.
+            await row.save();
+            return true;
+        },
         async confirmEmailChange(token) {
             if (!token || !token.startsWith(EMAIL_CHANGE_PREFIX))
                 return { ok: false };

package/build/src/accounts/lucid_store/mfa.js

@@ -100,6 +100,28 @@ export function buildMfa(ctx) {
             await repo.upsert(accountId, { recoveryCodes: remaining });
             return true;
         },
+        async countRecoveryCodes(accountId) {
+            const state = await repo.read(accountId);
+            // Sem MFA ativo não há conjunto de códigos a contar — `null` diz "não se
+            // aplica", diferente de `0` ("acabaram, gere novos").
+            if (!state || !state.mfaEnabledAt)
+                return null;
+            return Array.isArray(state.recoveryCodes) ? state.recoveryCodes.length : 0;
+        },
+        async regenerateRecoveryCodes(accountId) {
+            const state = await repo.read(accountId);
+            // Só regenera sobre MFA JÁ ATIVO. Num enrollment pendente os códigos saem
+            // do `confirmTotpEnrollment`; deixar regenerar antes disso criaria um
+            // conjunto válido de credenciais de recuperação para um fator que o
+            // usuário ainda não provou possuir.
+            if (!state || !state.mfaEnabledAt)
+                return null;
+            const codes = Array.from({ length: recoveryCodeCount }, () => generateRecoveryCode());
+            // Substitui o conjunto inteiro: os antigos (inclusive os não usados)
+            // param de valer no mesmo instante — é esse o ponto de "regenerar".
+            await repo.upsert(accountId, { recoveryCodes: codes.map(sha256) });
+            return codes;
+        },
         async disableMfa(accountId) {
             // Limpa todo o estado de MFA. Inclui o anti-replay: um futuro re-enroll começa do zero.
             await repo.clear(accountId);

package/build/src/audit/audit_sink.d.ts

@@ -8,7 +8,7 @@
  * varre os `audit.record({ type: ... })` do `src/` e falha quando um evento
  * emitido não está aqui.
  */
-export declare const AUDIT_EVENT_TYPES: readonly ['login.success', 'login.failure', 'signup', 'password_reset.issued', 'password_reset.consumed', 'pat.issued', 'pat.revoked', 'pat.used', 'impersonation', 'impersonation.panel_viewed', 'impersonation.stopped', 'mfa.enabled', 'mfa.disabled', 'account.locked', 'passkey.registered', 'passkey.removed', 'email_verification.issued', 'email_verification.consumed', 'client.created', 'client.updated', 'client.deleted', 'session.revoked_all', 'password.changed', 'password.rehashed', 'email.change_requested', 'email.changed', 'login.new_ip_notified', 'login.new_device', 'login.otp_sent', 'login.otp_verified', 'login.otp_failed', 'login.otp_invalidated', 'bot_protection.rejected', 'grant.revoked_by_user', 'user.created', 'user.password_reset_sent', 'user.disabled', 'user.enabled', 'user.deleted', 'profile.updated', 'account.deleted', 'account.exported', 'keys.rotated', 'organization.created', 'organization.updated', 'organization.deleted', 'organization.member_added', 'organization.member_removed', 'organization.member_role_changed', 'organization.member_role_updated', 'organization.switched', 'organization.deactivated', 'organization.invitation_sent', 'organization.invitation_accepted', 'organization.invitation_revoked', 'email_change.requested', 'email_change.confirmed', 'email_change.cancelled', 'security_notice.sent', 'settings.updated', 'maintenance.enabled', 'maintenance.disabled', 'trusted_device.revoked', 'password.expired_change_forced', 'otp.locked', 'otp.unlocked', 'otp.unlock_failed', 'sudo.confirmed', 'session.single_enforced', 'account.expired_login_blocked', 'account.expiration_warned', 'login.magic_link_sent', 'session.revoked', 'account.signed_out_all', 'client.secret_regenerated', 'roles_catalog.updated'];
+export declare const AUDIT_EVENT_TYPES: readonly ['login.success', 'login.failure', 'signup', 'password_reset.issued', 'password_reset.consumed', 'pat.issued', 'pat.revoked', 'pat.used', 'impersonation', 'impersonation.panel_viewed', 'impersonation.stopped', 'mfa.enabled', 'mfa.disabled', 'mfa.recovery_codes_regenerated', 'account.locked', 'passkey.registered', 'passkey.removed', 'email_verification.issued', 'email_verification.consumed', 'client.created', 'client.updated', 'client.deleted', 'session.revoked_all', 'password.changed', 'password.rehashed', 'email.change_requested', 'email.changed', 'login.new_ip_notified', 'login.new_device', 'login.otp_sent', 'login.otp_verified', 'login.otp_failed', 'login.otp_invalidated', 'bot_protection.rejected', 'grant.revoked_by_user', 'user.created', 'user.password_reset_sent', 'user.disabled', 'user.enabled', 'user.deleted', 'profile.updated', 'account.deleted', 'account.exported', 'keys.rotated', 'organization.created', 'organization.updated', 'organization.deleted', 'organization.member_added', 'organization.member_removed', 'organization.member_role_changed', 'organization.member_role_updated', 'organization.switched', 'organization.deactivated', 'organization.invitation_sent', 'organization.invitation_accepted', 'organization.invitation_revoked', 'email_change.requested', 'email_change.confirmed', 'email_change.cancelled', 'security_notice.sent', 'settings.updated', 'maintenance.enabled', 'maintenance.disabled', 'trusted_device.revoked', 'password.expired_change_forced', 'otp.locked', 'otp.unlocked', 'otp.unlock_failed', 'sudo.confirmed', 'session.single_enforced', 'account.expired_login_blocked', 'account.expiration_warned', 'login.magic_link_sent', 'session.revoked', 'account.signed_out_all', 'client.secret_regenerated', 'roles_catalog.updated'];
 /** Tipos de eventos de auditoria relevantes para segurança emitidos pelo IdP. */
 export type AuditEventType = (typeof AUDIT_EVENT_TYPES)[number];
 /**

package/build/src/audit/audit_sink.js

@@ -29,6 +29,10 @@ export const AUDIT_EVENT_TYPES = [
     'impersonation.stopped',
     'mfa.enabled',
     'mfa.disabled',
+    // Os recovery codes foram TROCADOS: os antigos (inclusive os não usados)
+    // deixaram de valer no mesmo instante. Evento próprio, e não `mfa.enabled`,
+    // porque o fator não mudou — mudou o conjunto de credenciais de contorno.
+    'mfa.recovery_codes_regenerated',
     'account.locked',
     'passkey.registered',
     'passkey.removed',

package/build/src/commands/import_users.js

@@ -1,4 +1,5 @@
 import { supportsAccountImport } from '../accounts/account_store.js';
+import { normalizeEmailIdentifier } from '../host/email_identifier.js';
 /**
  * Faz o parse do conteúdo do arquivo: aceita NDJSON (uma linha JSON por usuário)
  * OU um array JSON. Retorna os registros + os erros de parsing por linha. PURO
@@ -52,12 +53,16 @@ export async function importUsers(store, records, options = {}) {
     const report = { created: 0, skippedDuplicate: 0, errors: [] };
     const canImport = supportsAccountImport(store);
     for (const { line, record } of records) {
-        const email = record.email?.trim();
+        // MESMA normalização do cadastro/login (`trim` + `toLowerCase`) — sem ela o
+        // import gravava `Davi@Acme.com` e o login (normalizado) não achava a conta.
+        const email = normalizeEmailIdentifier(record.email);
         if (!email) {
             report.errors.push({ line, reason: 'missing email' });
             continue;
         }
-        // Duplicado: e-mail já existe → pula.
+        // Duplicado pela MESMA forma que o login busca — a normalizada. Uma base com
+        // endereços gravados em outra grafia pede `authkit:users:normalize-emails`
+        // ANTES do import, senão o duplicado passa despercebido.
         const existing = await store.findByEmail(email);
         if (existing) {
             report.skippedDuplicate++;

package/build/src/commands/normalize_emails.d.ts

@@ -0,0 +1,78 @@
+import type { AccountStore } from '../accounts/account_store.js';
+/** Uma conta cujo endereço gravado difere da forma normalizada. */
+export interface EmailNormalizationChange {
+    accountId: string;
+    /** Endereço como está gravado hoje. */
+    from: string;
+    /** Forma normalizada (`trim` + `toLowerCase`) — o que o login busca. */
+    to: string;
+    /** `true` quando o `--apply` gravou; `false` no relatório e quando a escrita falhou. */
+    applied: boolean;
+    /** Motivo da escrita não ter acontecido (só com `--apply`). */
+    error?: string;
+}
+/**
+ * Duas ou mais contas que colapsam no MESMO endereço normalizado — por exemplo
+ * `Davi@Acme.com` e `davi@acme.com`. A migração NÃO escolhe vencedor e NÃO funde
+ * contas: lista as envolvidas e não toca em nenhuma delas.
+ */
+export interface EmailNormalizationCollision {
+    /** A forma normalizada em que as contas colidem. */
+    email: string;
+    /** As contas envolvidas, com o endereço que cada uma tem gravado hoje. */
+    accounts: {
+        accountId: string;
+        email: string;
+    }[];
+}
+export interface NormalizeEmailsReport {
+    /** Contas varridas. */
+    scanned: number;
+    /** Contas que já estão na forma normalizada (não são tocadas). */
+    alreadyNormalized: number;
+    /** As que mudariam (ou mudaram, com `--apply`), fora de colisão. */
+    changes: EmailNormalizationChange[];
+    /** Quantas foram efetivamente gravadas (0 sem `--apply`). */
+    applied: number;
+    /** Colisões encontradas — decisão humana. */
+    collisions: EmailNormalizationCollision[];
+    /** Contas que a colisão impediu de mexer (soma das contas de `collisions`). */
+    skippedByCollision: number;
+    /**
+     * Contas cujo endereço gravado NÃO normaliza para nada (coluna nula, vazia ou
+     * só espaços). Não entram em `alreadyNormalized`: gravar string vazia como
+     * identidade seria pior que deixar como está, e um operador que lê "já
+     * normalizada" não pode achar que estas linhas estão bem.
+     */
+    unusable: {
+        accountId: string;
+        email: string;
+    }[];
+}
+/**
+ * Migração dos endereços GRAVADOS para a forma normalizada da identidade
+ * (`normalizeEmailIdentifier`: `trim` + `toLowerCase`).
+ *
+ * POR QUE ELA EXISTE: até a v0.68 o cadastro gravava o endereço mutilado pelo
+ * `.normalizeEmail()` do VineJS (no gmail, sem pontos e sem `+tag`), e import,
+ * convite e provider social gravavam a grafia crua, com maiúsculas. O login
+ * busca UMA forma só — a normalizada. Uma conta gravada em qualquer outra grafia
+ * fica INALCANÇÁVEL, e, por o login ser à prova de enumeração, sem nenhuma
+ * mensagem de erro. Esta migração é o que reencontra essas contas.
+ *
+ * Em modo RELATÓRIO (default) não escreve nada: varre, calcula e devolve o que
+ * mudaria. Com `apply`, grava — RECUSANDO-SE a tocar em qualquer conta envolvida
+ * numa colisão (duas contas que colapsam no mesmo endereço). Nunca funde contas,
+ * nunca escolhe vencedor: as colididas saem listadas para decisão humana.
+ *
+ * A varredura acontece INTEIRA antes de qualquer escrita, de propósito: a
+ * listagem é ordenada por e-mail, e reescrever endereços no meio da paginação
+ * moveria linhas entre páginas — contas seriam puladas sem nenhum sinal.
+ *
+ * Lógica PURA quanto a CLI (recebe o store, devolve o relatório) — testável sem
+ * ace e sem banco.
+ */
+export declare function normalizeAccountEmails(store: AccountStore, options?: {
+    apply?: boolean;
+    pageSize?: number;
+}): Promise<NormalizeEmailsReport>;