@adonis-agora/authkit-server 0.53.0 → 0.55.0

package/build/src/host/sudo/runtime.d.ts

@@ -18,8 +18,17 @@ export declare function sudoContextFrom(ctx: HttpContext): Promise<SudoContext>;
  * Registra a lista montada. Chamado UMA vez por `registerAuthHost`, e
  * SUBSTITUI (não acumula): registrar o host de novo é redefinir o que existe,
  * não somar ao que existia.
+ *
+ * `fromDefaults` distingue "esta é a lista de defaults da LIB" de "esta é a
+ * lista que o HOST escreveu" (argumento de `registerAuthHost` ou
+ * `config.sudo.methods`). A distinção existe porque a derivação do deadlock
+ * (`derivedSudoMethods`) só pode mexer na primeira: mexer na segunda seria
+ * mudar, sem pedir, o que um host declarou explicitamente — e a promessa de
+ * `sudoMethods` é que ele SUBSTITUI os defaults.
  */
-export declare function setMountedSudoMethods(methods: SudoMethod[]): void;
+export declare function setMountedSudoMethods(methods: SudoMethod[], opts?: {
+    fromDefaults?: boolean;
+}): void;
 /** Um método com este id teve rotas montadas? Usado só para avisar de drift. */
 export declare function isSudoMethodMounted(methodId: string): boolean;
 /**
@@ -33,6 +42,29 @@ export declare function isSudoMethodMounted(methodId: string): boolean;
  * circular se os métodos importassem de volta o controller.
  */
 export declare function explicitSudoMethods(cfg: ResolvedServerConfig): SudoMethod[] | null;
+/**
+ * O DEFAULT da lib, resolvido contra o config — o conserto do deadlock.
+ *
+ * `registerAuthHost` monta `[password, passkey, magicLink]` sem saber nada do
+ * config (a montagem acontece antes de o config lazy resolver). Aqui o config
+ * está resolvido, e é aqui que se decide qual metade vale:
+ *
+ * - host COM senha → `[password, passkey]`, o histórico byte a byte. O endpoint
+ *   do magic link fica montado e inerte: quem quiser oferecê-lo declara
+ *   `config.sudo.methods` — e agora isso FUNCIONA, porque a rota existe (era
+ *   metade da promessa de 0.46 que ficava faltando).
+ * - host que declarou `authMethods: { password: false }` → `[passkey, magicLink]`.
+ *   Sai o campo de senha, que nesse deployment é uma opção que não pode dar
+ *   certo, e entra o único método que uma conta sem credencial prévia consegue
+ *   satisfazer (ver `CREDENTIAL_FREE_SUDO_METHOD_IDS` em `sudo/satisfiability.ts`).
+ *
+ * SÓ MEXE NA LISTA DE DEFAULTS (`mountedFromDefaults`). Lista escrita pelo host
+ * passa intacta — inclusive quando isso o deixa em deadlock, caso em que o aviso
+ * de boot (`define_config.ts`) é quem fala. Adivinhar a intenção de uma lista
+ * explícita seria pior: é a lista dele, e a promessa documentada é que ela
+ * SUBSTITUI os defaults.
+ */
+export declare function derivedSudoMethods(cfg: ResolvedServerConfig): SudoMethod[];
 /**
  * O método `methodId` está habilitado para ESTE host?
  *
@@ -41,9 +73,11 @@ export declare function explicitSudoMethods(cfg: ResolvedServerConfig): SudoMeth
  * continuaria vivo e concedendo sudo — uma config que aparenta restringir e não
  * restringe é pior que nenhuma config.
  *
- * Sem configuração explícita nada foi restringido: vale o que tem rota montada.
- * Isso é deliberado — a lista de defaults não é a fonte de verdade do que está
- * montado, e tratá-la como tal derrubaria um método customizado do host.
+ * Sem configuração explícita nada foi restringido: vale o que tem rota montada,
+ * MENOS o que a derivação do default tirou (ver `isDefaultSudoMethodDerivedOut`).
+ * Continua não sendo a lista de defaults a fonte de verdade do que está montado —
+ * tratá-la como tal derrubaria um método customizado do host —, e a derivação só
+ * remove ids que a própria lib pôs na lista.
  */
 export declare function isSudoMethodEnabled(cfg: ResolvedServerConfig, methodId: string): boolean;
 /**
@@ -64,6 +98,12 @@ export declare function isSudoMethodEnabled(cfg: ResolvedServerConfig, methodId:
  * fica estruturalmente impossível no caso sem config: é literalmente a mesma
  * lista. O aviso de flag-drift do controller passa a valer só para o caso que
  * sobra — config explícita divergindo do que foi montado.
+ *
+ * "A lista montada" é a lista montada DERIVADA (`derivedSudoMethods`), e os
+ * handlers aplicam a MESMA derivação pela mesma função — o drift continua
+ * impossível. A derivação existe porque a montagem não conhece o config: ela é
+ * quem tira o campo de senha de um host que declarou não ter senha, e quem
+ * mantém o default histórico intacto para quem tem.
  */
 export declare function configuredSudoMethods(cfg: ResolvedServerConfig): SudoMethod[];
 /**

package/build/src/host/sudo/runtime.js

@@ -40,13 +40,28 @@ export async function sudoContextFrom(ctx) {
  * ver `configuredSudoMethods`.
  */
 const mountedSudoMethods = [];
+/**
+ * A lista montada é a de DEFAULTS da lib (e não uma escrita pelo host)?
+ *
+ * Só a lista de defaults é derivada do config (`derivedSudoMethods`). Uma lista
+ * que o host escreveu vale ao pé da letra — ver o docblock de `setMountedSudoMethods`.
+ */
+let mountedFromDefaults = false;
 /**
  * Registra a lista montada. Chamado UMA vez por `registerAuthHost`, e
  * SUBSTITUI (não acumula): registrar o host de novo é redefinir o que existe,
  * não somar ao que existia.
+ *
+ * `fromDefaults` distingue "esta é a lista de defaults da LIB" de "esta é a
+ * lista que o HOST escreveu" (argumento de `registerAuthHost` ou
+ * `config.sudo.methods`). A distinção existe porque a derivação do deadlock
+ * (`derivedSudoMethods`) só pode mexer na primeira: mexer na segunda seria
+ * mudar, sem pedir, o que um host declarou explicitamente — e a promessa de
+ * `sudoMethods` é que ele SUBSTITUI os defaults.
  */
-export function setMountedSudoMethods(methods) {
+export function setMountedSudoMethods(methods, opts = {}) {
     mountedSudoMethods.splice(0, mountedSudoMethods.length, ...methods);
+    mountedFromDefaults = opts.fromDefaults === true;
 }
 /** Um método com este id teve rotas montadas? Usado só para avisar de drift. */
 export function isSudoMethodMounted(methodId) {
@@ -66,6 +81,67 @@ export function explicitSudoMethods(cfg) {
     const configured = cfg?.sudo?.methods;
     return Array.isArray(configured) && configured.length ? configured : null;
 }
+/**
+ * O host declarou, PELO CONFIG, que este deployment não tem senha usável?
+ *
+ * `authMethods: { password: false }` é pin de config e é autoritativo — tem
+ * prioridade sobre o runtime setting e o console admin mostra o toggle travado.
+ * Quem declara isso está dizendo que ninguém entra por senha; contas criadas
+ * pelo signup passwordless nem têm senha (a coluna leva um hash aleatório
+ * inutilizável, indistinguível de um hash real de dentro do pacote).
+ *
+ * NÃO usa `passwordless.*`: aquelas flags LIGAM vias alternativas de login sem
+ * desligar a senha, então um host com `passwordless.magicLink: true` pode
+ * perfeitamente ter usuários que conhecem a própria senha. Só o pin em `false`
+ * é uma afirmação sobre o deployment inteiro.
+ */
+function isPasswordlessHost(cfg) {
+    return cfg?.authMethods?.password === false;
+}
+/**
+ * O DEFAULT da lib, resolvido contra o config — o conserto do deadlock.
+ *
+ * `registerAuthHost` monta `[password, passkey, magicLink]` sem saber nada do
+ * config (a montagem acontece antes de o config lazy resolver). Aqui o config
+ * está resolvido, e é aqui que se decide qual metade vale:
+ *
+ * - host COM senha → `[password, passkey]`, o histórico byte a byte. O endpoint
+ *   do magic link fica montado e inerte: quem quiser oferecê-lo declara
+ *   `config.sudo.methods` — e agora isso FUNCIONA, porque a rota existe (era
+ *   metade da promessa de 0.46 que ficava faltando).
+ * - host que declarou `authMethods: { password: false }` → `[passkey, magicLink]`.
+ *   Sai o campo de senha, que nesse deployment é uma opção que não pode dar
+ *   certo, e entra o único método que uma conta sem credencial prévia consegue
+ *   satisfazer (ver `CREDENTIAL_FREE_SUDO_METHOD_IDS` em `sudo/satisfiability.ts`).
+ *
+ * SÓ MEXE NA LISTA DE DEFAULTS (`mountedFromDefaults`). Lista escrita pelo host
+ * passa intacta — inclusive quando isso o deixa em deadlock, caso em que o aviso
+ * de boot (`define_config.ts`) é quem fala. Adivinhar a intenção de uma lista
+ * explícita seria pior: é a lista dele, e a promessa documentada é que ela
+ * SUBSTITUI os defaults.
+ */
+export function derivedSudoMethods(cfg) {
+    return mountedSudoMethods.filter((m) => !isDefaultSudoMethodDerivedOut(cfg, m?.id));
+}
+/**
+ * Este id foi DERIVADO PARA FORA da lista de defaults neste host?
+ *
+ * Ponto único da regra, consultado pelos DOIS lados (a tela, via
+ * `configuredSudoMethods`, e os handlers, via `isSudoMethodEnabled`) — é o que
+ * torna o drift entre eles estruturalmente impossível também no caso derivado.
+ *
+ * Nunca responde `true` para uma lista de host, nem para um id que não seja um
+ * dos dois built-in do default. Ou seja: só REMOVE, e só remove o que a própria
+ * lib pôs lá.
+ */
+function isDefaultSudoMethodDerivedOut(cfg, methodId) {
+    if (!mountedFromDefaults)
+        return false;
+    // Host passwordless: cai a senha (não há senha usável neste deployment).
+    // Host com senha: cai o magic link (posture histórica preservada — o default
+    // não passa a oferecer um step-up por e-mail a quem nunca pediu).
+    return isPasswordlessHost(cfg) ? methodId === 'password' : methodId === 'magic-link';
+}
 /**
  * O método `methodId` está habilitado para ESTE host?
  *
@@ -74,14 +150,16 @@ export function explicitSudoMethods(cfg) {
  * continuaria vivo e concedendo sudo — uma config que aparenta restringir e não
  * restringe é pior que nenhuma config.
  *
- * Sem configuração explícita nada foi restringido: vale o que tem rota montada.
- * Isso é deliberado — a lista de defaults não é a fonte de verdade do que está
- * montado, e tratá-la como tal derrubaria um método customizado do host.
+ * Sem configuração explícita nada foi restringido: vale o que tem rota montada,
+ * MENOS o que a derivação do default tirou (ver `isDefaultSudoMethodDerivedOut`).
+ * Continua não sendo a lista de defaults a fonte de verdade do que está montado —
+ * tratá-la como tal derrubaria um método customizado do host —, e a derivação só
+ * remove ids que a própria lib pôs na lista.
  */
 export function isSudoMethodEnabled(cfg, methodId) {
     const explicit = explicitSudoMethods(cfg);
     if (explicit === null)
-        return true;
+        return !isDefaultSudoMethodDerivedOut(cfg, methodId);
     return explicit.some((m) => m?.id === methodId);
 }
 /**
@@ -102,9 +180,15 @@ export function isSudoMethodEnabled(cfg, methodId) {
  * fica estruturalmente impossível no caso sem config: é literalmente a mesma
  * lista. O aviso de flag-drift do controller passa a valer só para o caso que
  * sobra — config explícita divergindo do que foi montado.
+ *
+ * "A lista montada" é a lista montada DERIVADA (`derivedSudoMethods`), e os
+ * handlers aplicam a MESMA derivação pela mesma função — o drift continua
+ * impossível. A derivação existe porque a montagem não conhece o config: ela é
+ * quem tira o campo de senha de um host que declarou não ter senha, e quem
+ * mantém o default histórico intacto para quem tem.
  */
 export function configuredSudoMethods(cfg) {
-    return explicitSudoMethods(cfg) ?? mountedSudoMethods;
+    return explicitSudoMethods(cfg) ?? derivedSudoMethods(cfg);
 }
 /**
  * Verbos HTTP com a forma `(pattern, handler, ...)` — o handler é o SEGUNDO

package/build/src/host/sudo/satisfiability.d.ts

@@ -0,0 +1,62 @@
+/**
+ * "Este host consegue satisfazer o próprio sudo?" — a pergunta que ninguém
+ * fazia, e cuja resposta "não" trancava o usuário fora de exportar/excluir os
+ * próprios dados.
+ *
+ * MÓDULO FOLHA DE PROPÓSITO: importa só TIPOS. `define_config.ts` precisa
+ * chamar o aviso de boot daqui, e `sudo/runtime.ts` precisa da mesma lista de
+ * ids — importar `runtime.ts` de dentro do `define_config` fecharia um ciclo
+ * (`runtime` → controllers → ... → `define_config`) cuja ordem de avaliação é
+ * exatamente o tipo de coisa que quebra em produção e não em teste.
+ */
+import type { SudoMethod } from './types.js';
+/**
+ * Métodos built-in que uma conta SEM senha e SEM passkey consegue satisfazer —
+ * os únicos que quebram o deadlock do host passwordless.
+ *
+ * `oidc-step-up` não exige nada previamente cadastrado (é o `prompt=login` do
+ * próprio protocolo); `magic-link` exige apenas que a conta tenha e-mail, e a
+ * ENTREGA tem fallback para o mailer default do host-kit, então nem hook é
+ * obrigatório. Os outros dois built-in — `password` e `passkey` — exigem, por
+ * definição, uma credencial que o usuário teria de ter cadastrado ANTES, e é
+ * essa a pré-condição que um host passwordless não satisfaz.
+ */
+export declare const CREDENTIAL_FREE_SUDO_METHOD_IDS: readonly string[];
+/**
+ * Avisa, NO BOOT, quando a configuração de sudo deste host não tem um único
+ * método que uma conta sem senha possa satisfazer.
+ *
+ * QUANDO DISPARA (as quatro condições, todas necessárias):
+ *
+ * 1. O host declarou `sudo.methods` EXPLICITAMENTE. Sem declaração vale o
+ *    default derivado, que já resolve o caso passwordless — não há o que avisar.
+ * 2. O deployment tem contas sem senha usável: `authMethods.password === false`
+ *    (ninguém entra por senha) ou `passwordless.signup === true` (o cadastro
+ *    público cria contas com um hash aleatório inutilizável).
+ * 3. Nenhum dos métodos declarados é credential-free.
+ * 4. TODOS os métodos declarados são built-in deste pacote — ou seja, o pacote
+ *    consegue de fato PROVAR que a lista exige credencial prévia.
+ *
+ * WARN, NÃO THROW. Recusar o boot seria transformar um upgrade de patch/minor
+ * numa aplicação que não sobe, em produção, por uma condição que é
+ * DEGRADAÇÃO — a tela de confirmação fica sem opções, o que já falha fechado — e
+ * não uma brecha. Pior: a remediação nem sempre é uma linha de config
+ * (`oidcStepUp` exige uma rota e um callback no host), então o app ficaria fora
+ * do ar até alguém escrever código. E a detecção é, por construção, incompleta
+ * (item 4): um throw baseado numa heurística derruba host correto. O irmão
+ * `adonis-agent` recusa montar quando a superfície PROVADAMENTE não funciona;
+ * aqui não há prova — há forte suspeita, e o lugar disso é um aviso alto.
+ *
+ * @returns a mensagem emitida, ou `null` quando não havia nada a avisar (para
+ * teste; o efeito de verdade é o `console.warn`).
+ */
+export declare function warnUnsatisfiableSudoConfig(input: {
+    /** `config.sudo.methods` — a lista que o host declarou, se declarou. */
+    methods?: SudoMethod[];
+    /** `authMethods.password` pinado em `false`? */
+    passwordPinnedOff: boolean;
+    /** `passwordless.signup` ligado? */
+    passwordlessSignup: boolean;
+    /** Injeção para teste. Default: `console.warn`. */
+    warn?: (message: string) => void;
+}): string | null;

package/build/src/host/sudo/satisfiability.js

@@ -0,0 +1,89 @@
+/**
+ * "Este host consegue satisfazer o próprio sudo?" — a pergunta que ninguém
+ * fazia, e cuja resposta "não" trancava o usuário fora de exportar/excluir os
+ * próprios dados.
+ *
+ * MÓDULO FOLHA DE PROPÓSITO: importa só TIPOS. `define_config.ts` precisa
+ * chamar o aviso de boot daqui, e `sudo/runtime.ts` precisa da mesma lista de
+ * ids — importar `runtime.ts` de dentro do `define_config` fecharia um ciclo
+ * (`runtime` → controllers → ... → `define_config`) cuja ordem de avaliação é
+ * exatamente o tipo de coisa que quebra em produção e não em teste.
+ */
+/**
+ * Métodos built-in que uma conta SEM senha e SEM passkey consegue satisfazer —
+ * os únicos que quebram o deadlock do host passwordless.
+ *
+ * `oidc-step-up` não exige nada previamente cadastrado (é o `prompt=login` do
+ * próprio protocolo); `magic-link` exige apenas que a conta tenha e-mail, e a
+ * ENTREGA tem fallback para o mailer default do host-kit, então nem hook é
+ * obrigatório. Os outros dois built-in — `password` e `passkey` — exigem, por
+ * definição, uma credencial que o usuário teria de ter cadastrado ANTES, e é
+ * essa a pré-condição que um host passwordless não satisfaz.
+ */
+export const CREDENTIAL_FREE_SUDO_METHOD_IDS = ['oidc-step-up', 'magic-link'];
+/**
+ * Ids dos métodos que ESTE pacote implementa.
+ *
+ * Serve para o aviso abaixo se CALAR diante de um método customizado: de um
+ * método do SPI o pacote não tem como saber se ele exige credencial prévia, e um
+ * aviso de boot que grita para uma configuração correta é um aviso que o host
+ * aprende a ignorar — justamente o que não pode acontecer com este.
+ */
+const BUILTIN_SUDO_METHOD_IDS = [
+    'password',
+    'passkey',
+    'oidc-step-up',
+    'magic-link',
+];
+/**
+ * Avisa, NO BOOT, quando a configuração de sudo deste host não tem um único
+ * método que uma conta sem senha possa satisfazer.
+ *
+ * QUANDO DISPARA (as quatro condições, todas necessárias):
+ *
+ * 1. O host declarou `sudo.methods` EXPLICITAMENTE. Sem declaração vale o
+ *    default derivado, que já resolve o caso passwordless — não há o que avisar.
+ * 2. O deployment tem contas sem senha usável: `authMethods.password === false`
+ *    (ninguém entra por senha) ou `passwordless.signup === true` (o cadastro
+ *    público cria contas com um hash aleatório inutilizável).
+ * 3. Nenhum dos métodos declarados é credential-free.
+ * 4. TODOS os métodos declarados são built-in deste pacote — ou seja, o pacote
+ *    consegue de fato PROVAR que a lista exige credencial prévia.
+ *
+ * WARN, NÃO THROW. Recusar o boot seria transformar um upgrade de patch/minor
+ * numa aplicação que não sobe, em produção, por uma condição que é
+ * DEGRADAÇÃO — a tela de confirmação fica sem opções, o que já falha fechado — e
+ * não uma brecha. Pior: a remediação nem sempre é uma linha de config
+ * (`oidcStepUp` exige uma rota e um callback no host), então o app ficaria fora
+ * do ar até alguém escrever código. E a detecção é, por construção, incompleta
+ * (item 4): um throw baseado numa heurística derruba host correto. O irmão
+ * `adonis-agent` recusa montar quando a superfície PROVADAMENTE não funciona;
+ * aqui não há prova — há forte suspeita, e o lugar disso é um aviso alto.
+ *
+ * @returns a mensagem emitida, ou `null` quando não havia nada a avisar (para
+ * teste; o efeito de verdade é o `console.warn`).
+ */
+export function warnUnsatisfiableSudoConfig(input) {
+    const declared = Array.isArray(input.methods) ? input.methods : [];
+    if (!declared.length)
+        return null;
+    if (!input.passwordPinnedOff && !input.passwordlessSignup)
+        return null;
+    const ids = declared.map((m) => m?.id).filter((id) => typeof id === 'string');
+    if (ids.length !== declared.length)
+        return null; // lista malformada: não é este o aviso
+    if (ids.some((id) => CREDENTIAL_FREE_SUDO_METHOD_IDS.includes(id)))
+        return null;
+    if (!ids.every((id) => BUILTIN_SUDO_METHOD_IDS.includes(id)))
+        return null;
+    const trigger = input.passwordPinnedOff
+        ? 'authMethods: { password: false }'
+        : 'passwordless: { signup: true }';
+    const message = [
+        `authkit: sudo mode SEM SAÍDA para contas sem senha. Este host declarou \`${trigger}\`, então existem contas sem senha usável — mas \`sudo.methods\` só lista [${ids.join(', ')}], e todos exigem uma credencial cadastrada ANTES.`,
+        'Consequência: essas contas ficam trancadas fora de TODA operação sob `requireSudo` — exportar/excluir dados (LGPD), MFA, Personal Access Tokens, troca de e-mail — inclusive fora do cadastro de passkey, que é o que destravaria o resto.',
+        'Saída: acrescente `sudoMethods.oidcStepUp({ url: "/auth/step-up" })` (reautenticação no seu IdP) ou `sudoMethods.magicLink()` (link de confirmação por e-mail, enviado pelo mailer do app quando não há hook `mail.onSudoLink`) à lista de `sudo.methods`.',
+    ].join(' ');
+    (input.warn ?? console.warn)(message);
+    return message;
+}

package/build/src/password/common_passwords.js

@@ -11,7 +11,7 @@
  * Fonte dos dados: compilação de senhas comuns de domínio público.
  * Licença do arquivo de dados: CC0 / Public Domain.
  */
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 /**
@@ -23,16 +23,36 @@ let _commonPasswordsSet = null;
 /**
  * Carrega o arquivo de senhas comuns uma única vez (lazy).
  *
- * FAIL-SAFE: se o arquivo não existir ou não puder ser lido (ex.: bundle sem
- * assets), retorna um Set vazio — a checagem vira no-op sem quebrar o fluxo.
+ * Onde o arquivo é esperado: o build script copia `common_passwords.txt`
+ * para o mesmo diretório do módulo compilado (`build/src/password/`, já que
+ * `tsc` com `rootDir: "./"` preserva o subcaminho `src/`). Em dev via
+ * ts-exec (sem build), o módulo roda direto de `src/password/`, onde o
+ * `.txt` já mora ao lado do `.ts` no repo.
+ *
+ * Checamos mais de um candidato — não só o caminho-irmão — para sobreviver
+ * a uma mudança futura em `rootDir`/`outDir` ou a uma regressão no script de
+ * cópia do build: o caminho-irmão cobre o layout atual (build e dev); os
+ * demais são fallbacks para o layout antigo (`build/password/`) e para ler
+ * direto de `src/` a partir de um build.
+ *
+ * FAIL-SAFE: se o arquivo não existir em nenhum candidato, ou não puder ser
+ * lido (ex.: bundle sem assets), retorna um Set vazio — a checagem vira
+ * no-op sem quebrar o fluxo. Uma senha comum indevidamente aceita é sempre
+ * preferível a um login/signup quebrado por um asset ausente.
  */
 function loadCommonPasswords() {
     if (_commonPasswordsSet !== null)
         return _commonPasswordsSet;
     try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dir = dirname(__filename);
-        const filePath = join(__dir, 'common_passwords.txt');
+        const __dir = dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            join(__dir, 'common_passwords.txt'), // caminho-irmão: build/src/password/ (prod) ou src/password/ (dev via ts-exec)
+            join(__dir, '..', '..', 'password', 'common_passwords.txt'), // layout antigo: build/password/
+            join(__dir, '..', '..', '..', 'src', 'password', 'common_passwords.txt'), // fallback: src/ a partir de um build
+        ];
+        const filePath = candidates.find((p) => existsSync(p));
+        if (!filePath)
+            throw new Error('common_passwords.txt not found in any candidate path');
         const content = readFileSync(filePath, 'utf-8');
         const entries = content
             .split('\n')
@@ -41,7 +61,7 @@ function loadCommonPasswords() {
         _commonPasswordsSet = new Set(entries);
     }
     catch {
-        // Fail-safe: arquivo ausente → Set vazio (no-op check).
+        // Fail-safe: arquivo ausente em todos os candidatos → Set vazio (no-op check).
         _commonPasswordsSet = new Set();
     }
     return _commonPasswordsSet;

package/build/src/provider/oidc_service.js

@@ -118,19 +118,31 @@ export class OidcService {
             },
         }, this.sessionTtlHolder, this.tokenTtlHolder);
         wireProviderEvents(provider, this.recorder);
-        registerTokenExchange(provider, {
-            findAccount: config.findAccount,
-            globalRolesClaim: config.globalRolesClaim,
-            resolveTokenRoles: config.resolveTokenRoles,
-            // Resource indicators (RFC 8707) suportados: o `audience` default + cada
-            // resource declarado. Usado para validar `audience`/`resource` no pedido de
-            // token-exchange — alvos fora desta lista são rejeitados (invalid_target).
-            supportedResources: [
-                config.accessTokens.audience,
-                ...Object.keys(config.accessTokens.resources),
-            ],
-            audit: config.audit,
-        });
+        // KILL SWITCH de impersonation (`admin.impersonation`, default `true`).
+        // Com a flag em `false` o grant simplesmente NÃO EXISTE no provider — o
+        // token endpoint responde `unsupported_grant_type` — em vez de existir e
+        // recusar caso a caso. É a mesma flag que fecha o painel do console
+        // (`console_impersonation_controller.ts`): uma declaração, duas superfícies.
+        if (config.admin.impersonation) {
+            registerTokenExchange(provider, {
+                findAccount: config.findAccount,
+                globalRolesClaim: config.globalRolesClaim,
+                resolveTokenRoles: config.resolveTokenRoles,
+                // Resource indicators (RFC 8707) suportados: o `audience` default + cada
+                // resource declarado. Usado para validar `audience`/`resource` no pedido de
+                // token-exchange — alvos fora desta lista são rejeitados (invalid_target).
+                supportedResources: [
+                    config.accessTokens.audience,
+                    ...Object.keys(config.accessTokens.resources),
+                ],
+                // LOAD-BEARING: sem isto o gate de status do alvo dentro de
+                // `token_exchange.ts` degrada para "allowed" (o campo é opcional, para não
+                // quebrar hosts com stores mínimos) e um admin consegue impersonar uma
+                // conta que acabou de desabilitar, recebendo tokens plenamente funcionais.
+                accountStore: config.accountStore,
+                audit: config.audit,
+            });
+        }
         // Quando o issuer tem um path (ex.: http://host/oidc), o provider precisa ser
         // MONTADO sob esse path via koa-mount. Isso faz o oidc-provider gerar URLs de
         // discovery e redirects de resume/interaction CORRETAMENTE prefixados (ex.:

package/build/src/provider/token_exchange.d.ts

@@ -1,4 +1,4 @@
-import type { AuthAccount } from '../accounts/account_store.js';
+import type { AccountStore, AuthAccount } from '../accounts/account_store.js';
 import type { AuditSink } from '../audit/audit_sink.js';
 export interface TokenExchangeAccount {
     id: string;
@@ -32,5 +32,16 @@ export interface TokenExchangeDeps {
     supportedResources?: string[];
     /** Sink de auditoria (best-effort). Quando presente, registra `impersonation`. */
     audit?: AuditSink;
+    /**
+     * AccountStore do host, usado para checar se o alvo da impersonação está
+     * desabilitado/expirado (mesmo gate de `attemptPasswordLogin`, via
+     * `assertAccountEnabled`). Impersonar uma conta desabilitada mintaria tokens
+     * funcionais para uma identidade que deveria estar sem acesso algum.
+     *
+     * OPCIONAL e capability-probed (via `supportsAccountStatus`, dentro do
+     * helper): ausente ou sem a capacidade → degrada para "permitido" (mesma
+     * regra de todo o resto da lib — nunca quebra hosts com um store mínimo).
+     */
+    accountStore?: AccountStore;
 }
 export declare function registerTokenExchange(provider: any, deps: TokenExchangeDeps): void;

package/build/src/provider/token_exchange.js

@@ -1,4 +1,5 @@
 import { errors } from 'oidc-provider';
+import { assertAccountEnabled } from '../host/login_attempt.js';
 const TOKEN_EXCHANGE = 'urn:ietf:params:oauth:grant-type:token-exchange';
 const ACCESS_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:access_token';
 /**
@@ -46,6 +47,17 @@ export function registerTokenExchange(provider, deps) {
         if (!target) {
             throw new errors.InvalidGrant('requested_subject not found');
         }
+        // Status do alvo (disabled/expirado): mesmo gate de `attemptPasswordLogin`.
+        // Sem isso, impersonar um alvo desabilitado mintava tokens funcionais para
+        // uma identidade que o admin acreditava ter revogado. `accountStore` é
+        // opcional/capability-probed — sem ele (ou sem a capacidade), permanece
+        // "permitido" como antes.
+        if (deps.accountStore) {
+            const statusGate = await assertAccountEnabled({ accountStore: deps.accountStore, audit: deps.audit }, target.id, { email: target.email ?? '', ip: ctx.req?.socket?.remoteAddress ?? null });
+            if (!statusGate.allowed) {
+                throw new errors.InvalidGrant('requested_subject is disabled');
+            }
+        }
         // audience/resource: se o pedido vier com um alvo, ele PRECISA estar entre os
         // resource indicators suportados. Caso contrário rejeitamos (conservador) —
         // nunca embutimos audiência arbitrária no token emitido.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonis-agora/authkit-server",
-  "version": "0.53.0",
+  "version": "0.55.0",
   "description": "AdonisJS OIDC/OAuth2 provider (Identity Provider) toolkit: ejectable auth server with sessions, rate-limiting, MFA/TOTP, audit log, federated logout and OpenTelemetry metrics.",
   "license": "MIT",
   "author": "dudousxd",
@@ -124,6 +124,8 @@
     "@japa/assert": "4.2.0",
     "@japa/runner": "5.3.0",
     "@poppinss/ts-exec": "1.4.4",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/ioredis-mock": "^8.2.7",
     "@types/koa": "^2.15.2",
     "@types/koa-mount": "^4.0.5",
     "@types/luxon": "3.7.1",
@@ -151,11 +153,12 @@
     "@adonis-agora/authkit-react": "0.18.0"
   },
   "scripts": {
-    "build": "node scripts/build_host_css.mjs && node scripts/build_webauthn.mjs && node scripts/build_ui.mjs && node -e \"const fs=require('node:fs');for(const d of ['build/stubs','build/host/views'])fs.rmSync(d,{recursive:true,force:true})\" && tsc && node -e \"require('node:fs').cpSync('src/host/assets','build/src/host/assets',{recursive:true})\" && node -e \"require('node:fs').cpSync('stubs','build/stubs',{recursive:true,filter:(s)=>!s.endsWith('.ts')})\" && node -e \"const fs=require('node:fs');if(fs.existsSync('assets'))fs.cpSync('assets','build/assets',{recursive:true})\" && node -e \"require('node:fs').cpSync('src/host/views','build/host/views',{recursive:true})\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/host/ui',{recursive:true});fs.readdirSync('src/host/ui').filter(f=>f.endsWith('.html')).forEach(f=>fs.copyFileSync('src/host/ui/'+f,'build/host/ui/'+f))\" && node -e \"require('node:fs').copyFileSync('commands/commands.json','build/commands/commands.json')\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/password',{recursive:true});fs.copyFileSync('src/password/common_passwords.txt','build/password/common_passwords.txt')\"",
+    "build": "node scripts/build_host_css.mjs && node scripts/build_webauthn.mjs && node scripts/build_ui.mjs && node -e \"const fs=require('node:fs');for(const d of ['build/stubs','build/host/views'])fs.rmSync(d,{recursive:true,force:true})\" && tsc && node -e \"require('node:fs').cpSync('src/host/assets','build/src/host/assets',{recursive:true})\" && node -e \"require('node:fs').cpSync('stubs','build/stubs',{recursive:true,filter:(s)=>!s.endsWith('.ts')})\" && node -e \"const fs=require('node:fs');if(fs.existsSync('assets'))fs.cpSync('assets','build/assets',{recursive:true})\" && node -e \"require('node:fs').cpSync('src/host/views','build/host/views',{recursive:true})\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/host/ui',{recursive:true});fs.readdirSync('src/host/ui').filter(f=>f.endsWith('.html')).forEach(f=>fs.copyFileSync('src/host/ui/'+f,'build/host/ui/'+f))\" && node -e \"require('node:fs').copyFileSync('commands/commands.json','build/commands/commands.json')\" && node -e \"const fs=require('node:fs');fs.mkdirSync('build/src/password',{recursive:true});fs.copyFileSync('src/password/common_passwords.txt','build/src/password/common_passwords.txt')\"",
     "build:ui": "node scripts/build_ui.mjs",
     "build:webauthn": "node scripts/build_webauthn.mjs",
     "check:webauthn-bundle": "node scripts/check_webauthn_bundle.mjs",
-    "typecheck": "tsc --noEmit && node scripts/typecheck_ui.mjs",
+    "typecheck": "tsc --noEmit && node scripts/typecheck_ui.mjs && node scripts/typecheck_tests.mjs",
+    "typecheck:tests": "node scripts/typecheck_tests.mjs",
     "test": "node --import=@poppinss/ts-exec bin/test.ts",
     "build:host-css": "node scripts/build_host_css.mjs"
   }