@adonis-agora/authkit-server 1.0.0-rc.1 → 1.0.0-rc.10

package/build/src/agents/poppy/config.js

@@ -1,228 +0,0 @@
-/** Parâmetros que um campo do Mediated Sign-In não pode usar (extensão, §2). */
-const RESERVED_FIELDS = new Set([
-    'grant_type',
-    'scope',
-    'resource',
-    'client_id',
-    'client_secret',
-    'client_assertion',
-    'client_assertion_type',
-    'sign_in_id',
-    'one_time_code',
-]);
-const SCOPE_ID = /^[\x21\x23-\x5B\x5D-\x7E]+$/; // RFC 6749 §3.3 scope-token
-const DOMAIN = /^(?=.{1,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/;
-function fail(message) {
-    throw new Error(`authkit: personalAgents.poppy.${message}`);
-}
-function positive(value, fallback, what) {
-    if (value === undefined)
-        return fallback;
-    if (!Number.isFinite(value) || value <= 0)
-        fail(`${what} precisa ser > 0.`);
-    return Math.floor(value);
-}
-function absoluteUrl(value, what) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        fail(`${what} precisa ser uma URL absoluta (recebeu "${value}").`);
-    }
-    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
-        fail(`${what} precisa ser http(s) (recebeu "${value}").`);
-    }
-}
-export function normalizePoppyPrefix(prefix) {
-    const trimmed = (prefix ?? '/poppy').trim().replace(/\/+$/, '');
-    if (!trimmed)
-        return '/poppy';
-    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-}
-function membership(value) {
-    if (typeof value === 'function')
-        return async (id) => (await value(id)) === true;
-    const set = new Set(value ?? []);
-    return async (id) => set.has(id);
-}
-function listOf(value) {
-    if (typeof value === 'function')
-        return null;
-    return [...new Set(value ?? [])];
-}
-function typeScopes(input, all, what) {
-    if (input === false)
-        return null;
-    const scopes = typeof input === 'object' && input.scopes ? [...new Set(input.scopes)] : all;
-    for (const id of scopes) {
-        if (!all.includes(id))
-            fail(`signIn.${what}.scopes — scope desconhecido "${id}".`);
-    }
-    if (scopes.length === 0)
-        fail(`signIn.${what}.scopes precisa de pelo menos um scope.`);
-    return { scopes };
-}
-export function resolvePoppyConfig(input, fallbackScopes) {
-    if (!input)
-        return undefined;
-    const org = input.organization;
-    if (!org?.name?.trim())
-        fail('organization.name é obrigatório.');
-    // Domínios comparados só ignorando caixa, sem nenhuma outra normalização (§3.1).
-    const domains = [org.domain, ...(org.aliases ?? [])].map((d) => (d ?? '').toLowerCase().replace(/\.$/, ''));
-    for (const d of domains) {
-        if (!DOMAIN.test(d))
-            fail(`organization — domínio inválido "${d}" (só o host, sem esquema).`);
-    }
-    const scopes = { ...(input.scopes ?? fallbackScopes ?? {}) };
-    for (const id of Object.keys(scopes)) {
-        if (!SCOPE_ID.test(id))
-            fail(`scopes — id inválido "${id}" (sem espaços/aspas).`);
-    }
-    const all = Object.keys(scopes);
-    const scopeHints = { ...(input.scopeHints ?? {}) };
-    for (const [id, hint] of Object.entries(scopeHints)) {
-        if (!['none', 'reversible', 'irreversible'].includes(hint?.changes)) {
-            fail(`scopeHints.${id}.changes precisa ser none, reversible ou irreversible.`);
-        }
-        if (typeof hint.personal_data !== 'boolean') {
-            fail(`scopeHints.${id}.personal_data é obrigatório (boolean).`);
-        }
-    }
-    const signInInput = input.signIn ?? {};
-    let mediated = null;
-    if (signInInput.mediated) {
-        const m = signInInput.mediated;
-        if (!Array.isArray(m.fields) || m.fields.length === 0) {
-            fail('signIn.mediated.fields precisa de pelo menos um campo.');
-        }
-        const names = new Set();
-        for (const f of m.fields) {
-            if (!f?.name || !f.label || typeof f.secret !== 'boolean') {
-                fail('signIn.mediated.fields — cada campo precisa de name, label e secret.');
-            }
-            if (RESERVED_FIELDS.has(f.name)) {
-                fail(`signIn.mediated.fields — "${f.name}" é um parâmetro reservado.`);
-            }
-            if (names.has(f.name))
-                fail(`signIn.mediated.fields — campo duplicado "${f.name}".`);
-            names.add(f.name);
-        }
-        if (typeof m.verify !== 'function')
-            fail('signIn.mediated.verify é obrigatório.');
-        if (!Array.isArray(m.scopes))
-            fail('signIn.mediated.scopes é obrigatório.');
-        const mediatedScopes = typeScopes({ scopes: m.scopes }, all, 'mediated').scopes;
-        mediated = {
-            fields: m.fields.map((f) => ({ name: f.name, label: f.label, secret: f.secret })),
-            scopes: mediatedScopes,
-            verify: m.verify,
-            verifyCode: m.verifyCode,
-            codeTtl: positive(m.codeTtl, 600, 'signIn.mediated.codeTtl'),
-            maxCodeAttempts: positive(m.maxCodeAttempts, 5, 'signIn.mediated.maxCodeAttempts'),
-        };
-    }
-    if (all.length === 0 && (signInInput.direct !== false || signInInput.device !== false)) {
-        fail('nenhum scope: declare `scopes` ou desligue signIn.direct e signIn.device.');
-    }
-    for (const entry of input.agent?.protocols ?? []) {
-        if (!entry.type)
-            fail('agent.protocols[].type é obrigatório.');
-        absoluteUrl(entry.endpoint, 'agent.protocols[].endpoint');
-        if (entry.resource)
-            absoluteUrl(entry.resource, 'agent.protocols[].resource');
-        if (entry.access && entry.access !== 'session' && entry.access !== 'signed_in') {
-            fail('agent.protocols[].access precisa ser session ou signed_in.');
-        }
-    }
-    for (const api of input.apis ?? []) {
-        if (!api.type)
-            fail('apis[].type é obrigatório.');
-        absoluteUrl(api.url, 'apis[].url');
-        if (api.resource)
-            absoluteUrl(api.resource, 'apis[].resource');
-        if (typeof api.description !== 'string')
-            fail('apis[].description é obrigatório.');
-    }
-    if (input.feedback)
-        absoluteUrl(input.feedback.endpoint, 'feedback.endpoint');
-    if (input.excludedTasks)
-        absoluteUrl(input.excludedTasks.url, 'excludedTasks.url');
-    const redirectTo = input.web ? (input.web.redirectTo ?? '/') : '/';
-    if (!redirectTo.startsWith('/') || redirectTo.startsWith('//')) {
-        fail('web.redirectTo precisa ser um path do site.');
-    }
-    for (const name of Object.keys(input.extensions ?? {})) {
-        if (typeof input.extensions[name]?.version !== 'string') {
-            fail(`extensions.${name}.version é obrigatório (string).`);
-        }
-    }
-    const dpopAlgs = input.dpop?.algorithms ?? ['ES256'];
-    if (dpopAlgs.length === 0 || dpopAlgs.some((a) => a === 'none' || a.startsWith('HS'))) {
-        fail('dpop.algorithms precisa de algoritmos assimétricos.');
-    }
-    const allowInsecureClientIds = input.allowInsecureClientIds === true;
-    if (allowInsecureClientIds && process.env.NODE_ENV === 'production') {
-        fail('allowInsecureClientIds é só para desenvolvimento/teste e não pode ser ligado com NODE_ENV=production.');
-    }
-    let rateLimit;
-    if (input.rateLimit === false)
-        rateLimit = false;
-    else if (typeof input.rateLimit === 'function')
-        rateLimit = input.rateLimit;
-    else {
-        rateLimit = {
-            sessionsPerMinute: positive(input.rateLimit?.sessionsPerMinute, 120, 'rateLimit.sessionsPerMinute'),
-            mediatedPerHour: positive(input.rateLimit?.mediatedPerHour, 10, 'rateLimit.mediatedPerHour'),
-        };
-    }
-    return {
-        organization: { name: org.name, domain: domains[0], aliases: domains.slice(1) },
-        prefix: normalizePoppyPrefix(input.prefix),
-        scopes,
-        scopeHints,
-        signIn: {
-            direct: typeScopes(signInInput.direct, all, 'direct'),
-            device: typeScopes(signInInput.device, all, 'device'),
-            mediated,
-        },
-        agent: input.agent?.protocols?.length ? { protocols: [...input.agent.protocols] } : null,
-        apis: [...(input.apis ?? [])],
-        feedback: input.feedback ?? null,
-        excludedTasks: input.excludedTasks ?? null,
-        web: input.web === false
-            ? null
-            : {
-                browserSession: input.web?.browserSession !== false,
-                login: input.web?.login,
-                redirectTo,
-            },
-        extensions: { ...(input.extensions ?? {}) },
-        clients: {
-            requireRegistration: input.clients?.requireRegistration === true,
-            isRegistered: membership(input.clients?.registered),
-            isBlocked: membership(input.clients?.blocked),
-            registeredList: listOf(input.clients?.registered),
-            blockedList: listOf(input.clients?.blocked),
-        },
-        allowInsecureClientIds,
-        accessTokenTtl: positive(input.accessTokenTtl, 3600, 'accessTokenTtl'),
-        refreshTokenTtl: positive(input.refreshTokenTtl, 30 * 24 * 3600, 'refreshTokenTtl'),
-        sessionTtl: positive(input.sessionTtl, 30 * 24 * 3600, 'sessionTtl'),
-        authorizationCodeTtl: positive(input.authorizationCodeTtl, 60, 'authorizationCodeTtl'),
-        deviceCodeTtl: positive(input.deviceCodeTtl, 600, 'deviceCodeTtl'),
-        pollInterval: positive(input.pollInterval, 5, 'pollInterval'),
-        assertionMaxLifetime: positive(input.assertionMaxLifetime, 300, 'assertionMaxLifetime'),
-        sessionJwt: { maxAge: positive(input.sessionJwt?.maxAge, 60, 'sessionJwt.maxAge') },
-        dpop: {
-            required: input.dpop?.required === true,
-            requireNonce: input.dpop?.requireNonce === true,
-            maxAge: positive(input.dpop?.maxAge, 60, 'dpop.maxAge'),
-            algorithms: [...dpopAlgs],
-        },
-        replay: input.replay ?? 'database',
-        rateLimit,
-        toActor: input.toActor,
-    };
-}

package/build/src/agents/poppy/dpop.d.ts

@@ -1,61 +0,0 @@
-import type { PoppyReplayStore } from './config.js';
-export type DpopFailure = {
-    ok: false;
-    error: 'invalid_dpop_proof' | 'use_dpop_nonce';
-    description: string;
-};
-export type DpopResult = {
-    ok: true;
-    jkt: string;
-    jti: string;
-} | DpopFailure;
-export interface DpopNonceSource {
-    /** Nonce novo para o header `DPoP-Nonce`. */
-    issue(): string;
-    /** O nonce ainda vale? */
-    valid(nonce: string): boolean;
-}
-/**
- * Nonces sem estado: `base64url(ts).base64url(hmac(ts))`, válidos por
- * `ttlSeconds` (default 300). Qualquer instância com o mesmo segredo valida.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export declare function hmacNonceSource(secret: Buffer | string, options?: {
-    ttlSeconds?: number;
-    now?: () => number;
-}): DpopNonceSource;
-/** `ath`: base64url(SHA-256(access token)). */
-export declare function accessTokenHash(token: string): string;
-/**
- * `htu` normalizado para comparação: esquema e host minúsculos, sem porta
- * default, sem query nem fragmento. `null` se não for URL http(s).
- */
-export declare function normalizeHtu(value: string): string | null;
-export interface VerifyDpopInput {
-    /** Valor do(s) header(s) `DPoP`. Mais de um = inválido. */
-    proof: string | string[] | undefined | null;
-    method: string;
-    /** URL da request (a query é ignorada). */
-    url: string;
-    /** Access token apresentado junto (resource server) — exige `ath`. */
-    accessToken?: string;
-    /** Thumbprint (RFC 7638) a que o token está preso. */
-    expectedJkt?: string;
-    algorithms: string[];
-    /** Janela do `iat`, em segundos. */
-    maxAge: number;
-    /** Tolerância de relógio para `iat` no futuro, em segundos. Default: 5. */
-    clockSkew?: number;
-    replay: PoppyReplayStore;
-    nonce?: {
-        required: boolean;
-        source: DpopNonceSource;
-    };
-    now?: () => number;
-}
-/**
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — pode mudar de forma incompatível enquanto a spec for draft.
- */
-export declare function verifyDpopProof(input: VerifyDpopInput): Promise<DpopResult>;

package/build/src/agents/poppy/dpop.js

@@ -1,158 +0,0 @@
-/**
- * Verificação de provas DPoP (RFC 9449) — utilitário genérico para o token
- * endpoint e para resource servers (§4.5 do Poppy).
- *
- * Confere: um único header `DPoP`; `typ` `dpop+jwt`; algoritmo permitido; `jwk`
- * público no header e a assinatura com ele; `jti`, `htm`, `htu` (sem query nem
- * fragmento), `iat` dentro da janela; `ath` = SHA-256 do access token; o
- * `nonce` quando exigido; replay do `jti` na janela; e, num resource server, que
- * a chave é a do token (`cnf.jkt`).
- */
-import { createHash, createHmac, timingSafeEqual } from 'node:crypto';
-import { calculateJwkThumbprint, decodeProtectedHeader, EmbeddedJWK, jwtVerify, } from 'jose';
-import { replayKey } from './replay.js';
-/**
- * Nonces sem estado: `base64url(ts).base64url(hmac(ts))`, válidos por
- * `ttlSeconds` (default 300). Qualquer instância com o mesmo segredo valida.
- *
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — acompanha a spec em desenvolvimento e PODE MUDAR
- *   de forma incompatível fora de majors enquanto ela for draft.
- */
-export function hmacNonceSource(secret, options = {}) {
-    const ttl = (options.ttlSeconds ?? 300) * 1000;
-    const now = options.now ?? Date.now;
-    const mac = (ts) => createHmac('sha256', secret).update(`dpop-nonce:${ts}`).digest('base64url');
-    return {
-        issue() {
-            const ts = Buffer.from(String(now())).toString('base64url');
-            return `${ts}.${mac(ts)}`;
-        },
-        valid(nonce) {
-            const [ts, sig] = nonce.split('.');
-            if (!ts || !sig)
-                return false;
-            const expected = Buffer.from(mac(ts));
-            const given = Buffer.from(sig);
-            if (expected.length !== given.length || !timingSafeEqual(expected, given))
-                return false;
-            const issuedAt = Number(Buffer.from(ts, 'base64url').toString());
-            const t = now();
-            return Number.isFinite(issuedAt) && issuedAt <= t + 5000 && t - issuedAt <= ttl;
-        },
-    };
-}
-/** `ath`: base64url(SHA-256(access token)). */
-export function accessTokenHash(token) {
-    return createHash('sha256').update(token).digest('base64url');
-}
-/**
- * `htu` normalizado para comparação: esquema e host minúsculos, sem porta
- * default, sem query nem fragmento. `null` se não for URL http(s).
- */
-export function normalizeHtu(value) {
-    try {
-        const url = new URL(value);
-        if (url.protocol !== 'https:' && url.protocol !== 'http:')
-            return null;
-        url.hash = '';
-        url.search = '';
-        return url.toString();
-    }
-    catch {
-        return null;
-    }
-}
-function failure(error, description) {
-    return { ok: false, error, description };
-}
-/**
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — pode mudar de forma incompatível enquanto a spec for draft.
- */
-export async function verifyDpopProof(input) {
-    const raw = input.proof;
-    if (raw === undefined || raw === null || raw === '') {
-        return failure('invalid_dpop_proof', 'DPoP proof is missing');
-    }
-    if (Array.isArray(raw) ? raw.length !== 1 : raw.includes(',')) {
-        return failure('invalid_dpop_proof', 'Exactly one DPoP proof is allowed');
-    }
-    const proof = Array.isArray(raw) ? raw[0] : raw;
-    let header;
-    try {
-        header = decodeProtectedHeader(proof);
-    }
-    catch {
-        return failure('invalid_dpop_proof', 'Malformed DPoP proof');
-    }
-    if (header.typ !== 'dpop+jwt')
-        return failure('invalid_dpop_proof', 'typ must be dpop+jwt');
-    if (!header.alg || !input.algorithms.includes(header.alg)) {
-        return failure('invalid_dpop_proof', 'Unsupported DPoP algorithm');
-    }
-    const jwk = header.jwk;
-    if (!jwk || typeof jwk !== 'object')
-        return failure('invalid_dpop_proof', 'jwk header is required');
-    if ('d' in jwk || jwk.kty === 'oct') {
-        return failure('invalid_dpop_proof', 'jwk must be a public key');
-    }
-    const nowMs = (input.now ?? Date.now)();
-    let payload;
-    try {
-        ({ payload } = await jwtVerify(proof, EmbeddedJWK, {
-            algorithms: input.algorithms,
-            typ: 'dpop+jwt',
-            currentDate: new Date(nowMs),
-        }));
-    }
-    catch {
-        return failure('invalid_dpop_proof', 'DPoP proof signature is invalid');
-    }
-    const { jti, htm, htu, iat, ath, nonce } = payload;
-    if (typeof jti !== 'string' || jti.length < 8 || jti.length > 256) {
-        return failure('invalid_dpop_proof', 'jti is required');
-    }
-    if (typeof htm !== 'string' || htm !== input.method.toUpperCase()) {
-        return failure('invalid_dpop_proof', 'htm does not match the request method');
-    }
-    const expectedHtu = normalizeHtu(input.url);
-    if (typeof htu !== 'string' || !expectedHtu || normalizeHtu(htu) !== expectedHtu) {
-        return failure('invalid_dpop_proof', 'htu does not match the request URL');
-    }
-    const nowS = Math.floor(nowMs / 1000);
-    const skew = input.clockSkew ?? 5;
-    if (typeof iat !== 'number' || iat > nowS + skew || iat < nowS - input.maxAge) {
-        return failure('invalid_dpop_proof', 'iat is outside the acceptance window');
-    }
-    if (input.accessToken !== undefined) {
-        if (typeof ath !== 'string' || ath !== accessTokenHash(input.accessToken)) {
-            return failure('invalid_dpop_proof', 'ath does not match the access token');
-        }
-    }
-    let jkt;
-    try {
-        jkt = await calculateJwkThumbprint(jwk, 'sha256');
-    }
-    catch {
-        return failure('invalid_dpop_proof', 'Invalid jwk');
-    }
-    if (input.expectedJkt !== undefined && jkt !== input.expectedJkt) {
-        return failure('invalid_dpop_proof', 'DPoP key does not match the token binding');
-    }
-    if (input.nonce?.required) {
-        if (typeof nonce !== 'string' || !input.nonce.source.valid(nonce)) {
-            return failure('use_dpop_nonce', 'A DPoP nonce issued by the server is required');
-        }
-    }
-    else if (nonce !== undefined && input.nonce && typeof nonce === 'string') {
-        // Nonce mandado sem ser exigido: se vier, tem de ser um nosso e válido.
-        if (!input.nonce.source.valid(nonce)) {
-            return failure('use_dpop_nonce', 'The DPoP nonce is invalid or expired');
-        }
-    }
-    // Replay por último: uma prova inválida não queima o `jti`.
-    const expiresAt = new Date((iat + input.maxAge + skew) * 1000);
-    if (!(await input.replay.claim(replayKey('dpop', jkt, jti), expiresAt))) {
-        return failure('invalid_dpop_proof', 'DPoP proof was already used');
-    }
-    return { ok: true, jkt, jti };
-}

package/build/src/agents/poppy/email_code_sign_in.d.ts

@@ -1,27 +0,0 @@
-import { type AuthAccount } from '../../accounts/account_store.js';
-import type { PoppyMediatedConfigInput } from './config.js';
-export interface PoppyEmailCodeSignInOptions {
-    /** Scopes que este sign-in pode conceder. */
-    scopes: string[];
-    /** Validade do código, em segundos. Default: 600. */
-    codeTtl?: number;
-    /** Tentativas de código antes de `invalid_grant`. Default: 5. */
-    maxCodeAttempts?: number;
-    /**
-     * Quem pode entrar por aqui (ex.: só pacientes, não profissionais). `false` = recebe a
-     * resposta de conta inexistente. Default: toda conta ativa.
-     */
-    eligible?: (account: AuthAccount) => boolean | Promise<boolean>;
-    /**
-     * Códigos por e-mail por hora, nesta instância — impede um agente de lotar a caixa de
-     * alguém. Acima disso a resposta é a mesma, sem e-mail. Default: 5.
-     */
-    maxPerHour?: number;
-    /** Rótulo do campo que o agente mostra ao usuário. Default: `'Email address'`. */
-    label?: string;
-    /** Texto de `sentTo` a partir do e-mail mascarado. Default: `` `Email to ${masked}` ``. */
-    sentTo?: (masked: string) => string;
-}
-/** `ana.souza@gmail.com` → `a***@gmail.com`: o bastante para a pessoa reconhecer. */
-export declare function maskEmail(email: string): string;
-export declare function poppyEmailCodeSignIn(options: PoppyEmailCodeSignInOptions): PoppyMediatedConfigInput;

package/build/src/agents/poppy/email_code_sign_in.js

@@ -1,140 +0,0 @@
-/**
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — pode mudar de forma incompatível enquanto a spec for draft.
- *
- * Mediated Sign-In pronto (extensão `mediated-sign-in`): o agente pede o e-mail da conta, o authkit manda
- * um código de 6 dígitos para ele e o agente devolve o código. Usa as contas
- * (`accountStore`) e o e-mail (hook `mail.onPoppySignInCode` ou o mailer default)
- * do próprio authkit — o app só liga:
- *
- * ```ts
- * personalAgents: {
- *   poppy: { signIn: { mediated: poppyEmailCodeSignIn({ scopes: ['orders:read'] }) } },
- * }
- * ```
- *
- * Sem enumeração de contas: e-mail sem conta, conta desativada, conta recusada
- * por `eligible` ou e-mail acima do limite recebem a MESMA resposta, sem código
- * (`accountId: null`) — a lib recusa qualquer código como errado. O envio não é
- * esperado, então o tempo de resposta também não denuncia.
- */
-import { randomInt } from 'node:crypto';
-import { supportsAccountStatus } from '../../accounts/account_store.js';
-import { sendPoppySignInCodeEmail } from '../../host/default_mailer.js';
-import { personalAgentsFor } from '../runtime.js';
-/** `ana.souza@gmail.com` → `a***@gmail.com`: o bastante para a pessoa reconhecer. */
-export function maskEmail(email) {
-    const at = email.lastIndexOf('@');
-    const user = at > 0 ? email.slice(0, at) : '';
-    const domain = at > 0 ? email.slice(at + 1) : '';
-    if (!user || !domain)
-        return '***';
-    return `${user[0]}***@${domain}`;
-}
-const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-const HOUR_MS = 3600 * 1000;
-const MAX_TRACKED = 10_000;
-export function poppyEmailCodeSignIn(options) {
-    const positive = (value, fallback, what) => {
-        if (value === undefined)
-            return fallback;
-        if (!Number.isFinite(value) || value < 1) {
-            throw new Error(`authkit: poppyEmailCodeSignIn ${what} precisa ser um número >= 1.`);
-        }
-        return Math.floor(value);
-    };
-    const codeTtl = positive(options.codeTtl, 600, 'codeTtl');
-    const maxPerHour = positive(options.maxPerHour, 5, 'maxPerHour');
-    const maxCodeAttempts = positive(options.maxCodeAttempts, 5, 'maxCodeAttempts');
-    const sentToText = options.sentTo ?? ((masked) => `Email to ${masked}`);
-    const sends = new Map();
-    /** `true` = ainda cabe um envio para este e-mail na última hora (e conta este). */
-    const claim = (email) => {
-        const now = Date.now();
-        const recent = (sends.get(email) ?? []).filter((t) => now - t < HOUR_MS);
-        if (recent.length >= maxPerHour) {
-            sends.set(email, recent);
-            return false;
-        }
-        recent.push(now);
-        sends.delete(email);
-        sends.set(email, recent);
-        if (sends.size > MAX_TRACKED)
-            sends.delete(sends.keys().next().value);
-        return true;
-    };
-    const eligibleAccount = async (ctx, email) => {
-        const service = await ctx.containerResolver.make('authkit.server');
-        const store = service.config.accountStore;
-        const account = await store.findByEmail(email);
-        if (!account)
-            return null;
-        if (supportsAccountStatus(store) && (await store.isDisabled(account.id)))
-            return null;
-        if (options.eligible) {
-            // Um `eligible` que lança vira "não elegível": um 500 só para algumas contas as denunciaria.
-            try {
-                if (!(await options.eligible(account)))
-                    return null;
-            }
-            catch (error) {
-                ctx.logger.error({ err: error }, 'authkit: poppyEmailCodeSignIn eligible lançou');
-                return null;
-            }
-        }
-        return account;
-    };
-    return {
-        fields: [{ name: 'email', label: options.label ?? 'Email address', secret: false }],
-        scopes: options.scopes,
-        codeTtl,
-        maxCodeAttempts,
-        async verify({ credentials, clientId, ctx }) {
-            const email = (credentials.email ?? '').trim().toLowerCase();
-            if (!EMAIL.test(email))
-                return { status: 'failed' };
-            const sentTo = sentToText(maskEmail(email));
-            const decoy = { status: 'code_required', accountId: null, sentTo };
-            // O limite conta para qualquer e-mail — com ou sem conta, a resposta não muda.
-            if (!claim(email))
-                return decoy;
-            const account = await eligibleAccount(ctx, email);
-            if (!account)
-                return decoy;
-            const code = String(randomInt(0, 1_000_000)).padStart(6, '0');
-            // Sem `await`: o caminho com conta não pode demorar mais que o sem conta.
-            void deliver(ctx, { email, code, clientId, expiresInMinutes: Math.ceil(codeTtl / 60) });
-            return { status: 'code_required', accountId: account.id, sentTo, code };
-        },
-    };
-}
-function hostOf(clientId) {
-    try {
-        return new URL(clientId).host;
-    }
-    catch {
-        return clientId;
-    }
-}
-async function deliver(ctx, data) {
-    try {
-        const runtime = await personalAgentsFor(ctx);
-        const agentName = runtime?.poppy
-            ? await runtime.poppy.registry.displayName(data.clientId)
-            : hostOf(data.clientId);
-        const service = await ctx.containerResolver.make('authkit.server');
-        const hook = service.config.mail?.onPoppySignInCode;
-        const input = {
-            email: data.email,
-            code: data.code,
-            agentName,
-            expiresInMinutes: data.expiresInMinutes,
-        };
-        if (hook)
-            await hook(input);
-        else
-            await sendPoppySignInCodeEmail(ctx, input);
-    }
-    catch (error) {
-        ctx.logger.error({ err: error }, 'authkit: o código do Poppy Mediated Sign-In não saiu');
-    }
-}

package/build/src/agents/poppy/errors.d.ts

@@ -1,25 +0,0 @@
-/**
- * Erros OAuth do Poppy (§4.7, RFC 6749 §5.2, RFC 8628 §3.5, RFC 9449, extensão Mediated Sign-In)
- * — viram `{ error, error_description }` com o status da spec.
- */
-export type PoppyErrorCode = 'invalid_request' | 'invalid_client' | 'invalid_grant' | 'invalid_session' | 'invalid_dpop_proof' | 'use_dpop_nonce'
-/** Interno: HTTP 429 com `Retry-After`, sem corpo (§5.6). */
- | 'too_many_requests' | 'code_required' | 'invalid_scope' | 'invalid_target' | 'unsupported_grant_type' | 'unsupported_token_type' | 'unauthorized_client' | 'authorization_pending' | 'slow_down' | 'access_denied' | 'expired_token';
-export declare class PoppyError extends Error {
-    readonly code: PoppyErrorCode;
-    readonly description: string;
-    readonly status: number;
-    /** Headers extras da resposta (`DPoP-Nonce`, `Retry-After`). */
-    readonly headers: Record<string, string>;
-    /** Campos extras do corpo (`sign_in_id`, `sent_to`, `expires_in` do `code_required`). */
-    readonly extra: Record<string, unknown>;
-    constructor(code: PoppyErrorCode, description: string, options?: {
-        status?: number;
-        headers?: Record<string, string>;
-        extra?: Record<string, unknown>;
-    });
-    toJSON(): {
-        error: PoppyErrorCode;
-        error_description: string;
-    };
-}

package/build/src/agents/poppy/errors.js

@@ -1,25 +0,0 @@
-const STATUS = {
-    invalid_client: 401,
-    too_many_requests: 429,
-};
-export class PoppyError extends Error {
-    code;
-    description;
-    status;
-    /** Headers extras da resposta (`DPoP-Nonce`, `Retry-After`). */
-    headers;
-    /** Campos extras do corpo (`sign_in_id`, `sent_to`, `expires_in` do `code_required`). */
-    extra;
-    constructor(code, description, options = {}) {
-        super(description);
-        this.code = code;
-        this.description = description;
-        this.name = 'PoppyError';
-        this.status = options.status ?? STATUS[code] ?? 400;
-        this.headers = options.headers ?? {};
-        this.extra = options.extra ?? {};
-    }
-    toJSON() {
-        return { error: this.code, error_description: this.description, ...this.extra };
-    }
-}