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

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

@@ -1,25 +0,0 @@
-import type { PoppyLimiter, PoppyReplayStore } from './config.js';
-export declare const JTI_TABLE = "auth_poppy_jtis";
-/** Chave curta e de tamanho fixo para um `jti` de um tipo/agente. */
-export declare function replayKey(kind: string, ...parts: string[]): string;
-/** Em memória, por processo. Só serve com uma instância. */
-export declare function memoryReplayStore(options?: {
-    max?: number;
-    now?: () => number;
-}): PoppyReplayStore;
-/**
- * Na tabela lib-owned `auth_poppy_jtis` (PK = chave): o INSERT de uma chave que
- * já existe falha — atômico entre instâncias. Linhas vencidas saem aos poucos.
- */
-export declare function databaseReplayStore(conn: () => any, options?: {
-    now?: () => Date;
-}): PoppyReplayStore;
-/** Numa conexão Redis (`SET key 1 PX ttl NX`). */
-export declare function redisReplayStore(redis: {
-    set: (...args: any[]) => Promise<unknown>;
-}): PoppyReplayStore;
-/** Janelas fixas em memória, por processo: `sessionsPerMinute` por agente, `mediatedPerHour` por (agente, usuário). */
-export declare function memoryLimiter(limits: {
-    sessionsPerMinute: number;
-    mediatedPerHour: number;
-}, now?: () => number): PoppyLimiter;

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

@@ -1,106 +0,0 @@
-/**
- * Proteção contra replay (`jti` de asserções, client assertions, provas DPoP e
- * asserções de navegador) e limites de taxa do Poppy.
- */
-import { createHash } from 'node:crypto';
-export const JTI_TABLE = 'auth_poppy_jtis';
-/** Chave curta e de tamanho fixo para um `jti` de um tipo/agente. */
-export function replayKey(kind, ...parts) {
-    return `${kind}:${createHash('sha256').update(parts.join('\u0000')).digest('base64url')}`;
-}
-/** Em memória, por processo. Só serve com uma instância. */
-export function memoryReplayStore(options = {}) {
-    const seen = new Map();
-    const max = options.max ?? 100_000;
-    const now = options.now ?? Date.now;
-    let claims = 0;
-    return {
-        async claim(key, expiresAt) {
-            const t = now();
-            if (++claims % 1000 === 0 || seen.size >= max) {
-                for (const [k, exp] of seen)
-                    if (exp <= t)
-                        seen.delete(k);
-            }
-            const existing = seen.get(key);
-            if (existing !== undefined && existing > t)
-                return false;
-            if (seen.size >= max)
-                seen.delete(seen.keys().next().value);
-            seen.set(key, expiresAt.getTime());
-            return true;
-        },
-    };
-}
-/**
- * Na tabela lib-owned `auth_poppy_jtis` (PK = chave): o INSERT de uma chave que
- * já existe falha — atômico entre instâncias. Linhas vencidas saem aos poucos.
- */
-export function databaseReplayStore(conn, options = {}) {
-    const now = options.now ?? (() => new Date());
-    let claims = 0;
-    return {
-        async claim(key, expiresAt) {
-            const t = now();
-            if (++claims % 200 === 1) {
-                await conn().from(JTI_TABLE).where('expires_at', '<', t).delete();
-            }
-            try {
-                await conn().table(JTI_TABLE).insert({ key, expires_at: expiresAt });
-                return true;
-            }
-            catch (error) {
-                // Chave já usada — a não ser que a linha vencida ainda não tenha saído.
-                const row = await conn().from(JTI_TABLE).where('key', key).first();
-                if (!row)
-                    throw error;
-                const exp = row.expires_at instanceof Date
-                    ? row.expires_at
-                    : new Date(Number(row.expires_at) || row.expires_at);
-                if (exp.getTime() > t.getTime())
-                    return false;
-                const updated = await conn()
-                    .from(JTI_TABLE)
-                    .where('key', key)
-                    .where('expires_at', '<=', t)
-                    .update({ expires_at: expiresAt });
-                return ((typeof updated === 'number' ? updated : Array.isArray(updated) ? updated.length : 0) > 0);
-            }
-        },
-    };
-}
-/** Numa conexão Redis (`SET key 1 PX ttl NX`). */
-export function redisReplayStore(redis) {
-    return {
-        async claim(key, expiresAt) {
-            const ttl = Math.max(1000, expiresAt.getTime() - Date.now());
-            const result = await redis.set(`authkit:poppy:jti:${key}`, '1', 'PX', ttl, 'NX');
-            return result === 'OK';
-        },
-    };
-}
-/** Janelas fixas em memória, por processo: `sessionsPerMinute` por agente, `mediatedPerHour` por (agente, usuário). */
-export function memoryLimiter(limits, now = Date.now) {
-    const windows = new Map();
-    return async ({ action, key }) => {
-        const [limit, windowMs] = action === 'session'
-            ? [limits.sessionsPerMinute, 60_000]
-            : [limits.mediatedPerHour, 3_600_000];
-        const t = now();
-        const id = `${action}:${key}`;
-        let w = windows.get(id);
-        if (!w || t - w.start >= windowMs) {
-            w = { start: t, count: 0 };
-            windows.set(id, w);
-            if (windows.size > 50_000) {
-                for (const [k, v] of windows)
-                    if (t - v.start >= 3_600_000)
-                        windows.delete(k);
-            }
-        }
-        if (w.count >= limit)
-            return Math.ceil((w.start + windowMs - t) / 1000);
-        w.count++;
-        return null;
-    };
-}

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

@@ -1,100 +0,0 @@
-/**
- * Lado resource server do Poppy (§4.5, §5.3, §7): verificar o header `Poppy-Session` e o access
- * token de uma request às APIs/conversas do app — e o slot GLOBAL que o `@adonis-agora/agent` usa
- * para autenticar o endpoint de conversas sem importar este pacote.
- *
- * Contrato do slot (o mesmo padrão do `Symbol.for('@adonis-agora/oauth:resources')`):
- *
- * ```ts
- * const authenticate = globalThis[Symbol.for('@adonis-agora/poppy:authenticate')]
- * const result = await authenticate({ method, url, headers }, { scopes?, signedIn?, resource? })
- * // { ok: true, principal } | { ok: false, status, error, scope?, wwwAuthenticate, headers }
- * ```
- */
-import type { HttpContext } from '@adonisjs/core/http';
-import type { PoppyPrincipalBase } from './config.js';
-import type { PoppyAuthError, PoppyService, PoppyVerifyOptions } from './service.js';
-/** Símbolo do slot global de autenticação Poppy. */
-export declare const POPPY_AUTHENTICATE_SLOT: unique symbol;
-/**
- * O principal de uma request verificada.
- *
- * @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 interface PoppyPrincipal extends PoppyPrincipalBase {
-    /** O que `personalAgents.poppy.toActor` devolveu, quando configurado. */
-    actor?: unknown;
-}
-/**
- * @experimental Poppy (Personal Agent Protocol) Draft 0.3 — pode mudar de forma incompatível enquanto a spec for draft.
- */
-export type PoppyAuthResult = {
-    ok: true;
-    principal: PoppyPrincipal;
-} | {
-    ok: false;
-    status: 400 | 401 | 403 | 429;
-    /** `null`: challenge sem código (falta o access token, §7) ou limite de taxa (§5.6). */
-    error: PoppyAuthError | null;
-    /** Scopes exigidos (challenge e `insufficient_scope`). */
-    scope?: string;
-    /** Valor pronto do header `WWW-Authenticate`; `null` em `invalid_session` e no 429. */
-    wwwAuthenticate: string | null;
-    /** Texto para logs/corpo — nunca contém o token. */
-    description: string;
-    /** Headers extras a devolver (`DPoP-Nonce`, `Retry-After`). */
-    headers: Record<string, string>;
-};
-/** Request no formato do slot (sem `HttpContext`). */
-export interface PoppySlotRequest {
-    method: string;
-    /** URL pública completa da request (a query é ignorada). */
-    url: string;
-    headers: Record<string, string | string[] | undefined>;
-}
-export type PoppyAuthenticate = (request: PoppySlotRequest, options?: PoppyVerifyOptions) => Promise<PoppyAuthResult>;
-/** URL pública da request: atrás de proxy TLS, o esquema segue o do issuer. */
-export declare function publicRequestUrl(ctx: HttpContext, poppy: PoppyService): string;
-/**
- * Verifica o header `Poppy-Session` de uma request e, se houver, o access token. Aceita o
- * `HttpContext` ou `{ method, url, headers }`.
- *
- * @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 verifyPoppyRequest(input: HttpContext | PoppySlotRequest, options?: PoppyVerifyOptions): Promise<PoppyAuthResult>;
-/** Escreve a resposta de erro de um {@link PoppyAuthResult} recusado. */
-export declare function writePoppyAuthError(ctx: HttpContext, result: Extract<PoppyAuthResult, {
-    ok: false;
-}>): void;
-/**
- * O principal Poppy da request — preenchido por {@link poppyAuth}.
- *
- * @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 poppyOf(ctx: HttpContext): PoppyPrincipal | null;
-/**
- * Middleware das APIs/rotas que usam a Session Poppy.
- *
- * ```ts
- * router.post('/orders/:id/exchanges', [Orders, 'exchange'])
- *   .use(poppyAuth({ scopes: ['orders:write'] }))
- * ```
- *
- * Isente essas rotas do CSRF (são chamadas por agentes, sem navegador).
- *
- * @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 poppyAuth(options?: PoppyVerifyOptions): (ctx: HttpContext, next: () => Promise<void>) => Promise<void>;
-/**
- * Publica o slot global `Symbol.for('@adonis-agora/poppy:authenticate')` (e
- * `Symbol.for('@adonis-agora/poppy:issuer')`). Chamado no boot do provider
- * quando `personalAgents.poppy` está no config.
- *
- * @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 installPoppySlots(issuer: string): void;

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

@@ -1,129 +0,0 @@
-import { getBootedApp } from '../../../services/booted_app.js';
-import { buildPersonalAgentsRuntime, personalAgentsFor } from '../runtime.js';
-/** Símbolo do slot global de autenticação Poppy. */
-export const POPPY_AUTHENTICATE_SLOT = Symbol.for('@adonis-agora/poppy:authenticate');
-/** URL pública da request: atrás de proxy TLS, o esquema segue o do issuer. */
-export function publicRequestUrl(ctx, poppy) {
-    const url = new URL(ctx.request.completeUrl(false));
-    if (new URL(poppy.urls.origin).protocol === 'https:' && url.protocol === 'http:') {
-        url.protocol = 'https:';
-    }
-    return url.toString();
-}
-function requestFromCtx(ctx, poppy) {
-    return {
-        method: ctx.request.method(),
-        url: publicRequestUrl(ctx, poppy),
-        headers: ctx.request.headers(),
-    };
-}
-const NOT_ENABLED = {
-    ok: false,
-    status: 400,
-    error: 'invalid_session',
-    description: 'Poppy is not enabled',
-    wwwAuthenticate: null,
-    headers: {},
-};
-async function verifyWith(poppy, input, options) {
-    const result = await poppy.verifyAccess(input, options);
-    if (!result.ok) {
-        const { ok: _ok, ...rest } = result;
-        return { ok: false, ...rest };
-    }
-    const principal = { ...result.principal };
-    if (poppy.cfg.toActor)
-        principal.actor = await poppy.cfg.toActor(result.principal);
-    return { ok: true, principal };
-}
-async function poppyFromBootedApp() {
-    const app = getBootedApp();
-    const service = await app.container.make('authkit.server');
-    const runtime = await buildPersonalAgentsRuntime(service, () => app.container.make('lucid.db'), { make: (binding) => app.container.make(binding) });
-    return runtime?.poppy ?? null;
-}
-/**
- * Verifica o header `Poppy-Session` de uma request e, se houver, o access token. Aceita o
- * `HttpContext` ou `{ method, url, headers }`.
- *
- * @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 async function verifyPoppyRequest(input, options = {}) {
-    if ('request' in input && typeof input.request?.method === 'function') {
-        const ctx = input;
-        const poppy = (await personalAgentsFor(ctx))?.poppy;
-        if (!poppy)
-            return NOT_ENABLED;
-        return verifyWith(poppy, requestFromCtx(ctx, poppy), options);
-    }
-    const poppy = await poppyFromBootedApp();
-    if (!poppy)
-        return NOT_ENABLED;
-    return verifyWith(poppy, input, options);
-}
-/** Escreve a resposta de erro de um {@link PoppyAuthResult} recusado. */
-export function writePoppyAuthError(ctx, result) {
-    if (result.wwwAuthenticate)
-        ctx.response.header('WWW-Authenticate', result.wwwAuthenticate);
-    for (const [k, v] of Object.entries(result.headers))
-        ctx.response.header(k, v);
-    ctx.response.header('Cache-Control', 'no-store');
-    // Erros do access token vão no header, como no OAuth; `invalid_session` vai no corpo (§7).
-    if (result.error !== 'invalid_session')
-        return ctx.response.status(result.status).send('');
-    return ctx.response
-        .status(result.status)
-        .json({ error: result.error, error_description: result.description });
-}
-/** Guardado fora do `HttpContext` (sem augmentation — ver `augmentation_isolation.spec.ts`). */
-const principals = new WeakMap();
-/**
- * O principal Poppy da request — preenchido por {@link poppyAuth}.
- *
- * @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 poppyOf(ctx) {
-    return principals.get(ctx) ?? null;
-}
-/**
- * Middleware das APIs/rotas que usam a Session Poppy.
- *
- * ```ts
- * router.post('/orders/:id/exchanges', [Orders, 'exchange'])
- *   .use(poppyAuth({ scopes: ['orders:write'] }))
- * ```
- *
- * Isente essas rotas do CSRF (são chamadas por agentes, sem navegador).
- *
- * @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 poppyAuth(options = {}) {
-    return async (ctx, next) => {
-        const result = await verifyPoppyRequest(ctx, options);
-        if (!result.ok)
-            return writePoppyAuthError(ctx, result);
-        principals.set(ctx, result.principal);
-        return next();
-    };
-}
-/**
- * Publica o slot global `Symbol.for('@adonis-agora/poppy:authenticate')` (e
- * `Symbol.for('@adonis-agora/poppy:issuer')`). Chamado no boot do provider
- * quando `personalAgents.poppy` está no config.
- *
- * @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 installPoppySlots(issuer) {
-    const slot = globalThis;
-    const authenticate = (request, options) => verifyPoppyRequest({
-        method: request.method,
-        url: request.url,
-        headers: request.headers ?? {},
-    }, options);
-    slot[POPPY_AUTHENTICATE_SLOT] = authenticate;
-    slot[Symbol.for('@adonis-agora/poppy:issuer')] = issuer;
-}

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

@@ -1,48 +0,0 @@
-/**
- * `fetch` de documentos JSON de terceiros à prova de SSRF.
- *
- * O `client_id` de um agente Poppy é uma URL que QUALQUER um escolhe — buscá-la
- * sem cuidado faria deste app um proxy para a rede interna. Regras:
- *  - só `https:`; sem credenciais na URL; porta qualquer;
- *  - o IP é conferido NA CONEXÃO (o `lookup` do socket), não num DNS separado —
- *    sem janela para DNS rebinding; loopback, privados, link-local, CGNAT,
- *    multicast, reservados e os equivalentes IPv6 são recusados;
- *  - IP literal na URL passa pela mesma regra;
- *  - sem redirects (o `client_id` tem de ser exatamente a URL buscada);
- *  - teto de tempo e de bytes.
- */
-import { type LookupAddress } from 'node:dns';
-export declare class SafeFetchError extends Error {
-    constructor(message: string);
-}
-export interface FetchedJson {
-    status: number;
-    body: unknown;
-    /** `max-age` do `Cache-Control`, em segundos, quando há. */
-    maxAge: number | null;
-}
-/** Busca um JSON (GET). Lança {@link SafeFetchError} em qualquer recusa. */
-export type JsonFetcher = (url: string) => Promise<FetchedJson>;
-export type LookupFn = (hostname: string, options: {
-    all: true;
-}, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void) => void;
-export interface SafeFetchOptions {
-    timeoutMs?: number;
-    maxBytes?: number;
-    /** Resolução de nomes — injetável nos testes. Default: `dns.lookup`. */
-    lookup?: LookupFn;
-}
-/** `true` quando o IP não pode ser alvo de uma busca de saída. */
-export declare function isBlockedAddress(ip: string): boolean;
-/**
- * Busca `url` e devolve o JSON. Só HTTPS, sem redirect, IP público conferido na
- * conexão, `timeoutMs` (default 5 s) e `maxBytes` (default 64 KiB).
- */
-export declare function safeFetchJson(url: string, options?: SafeFetchOptions): Promise<FetchedJson>;
-/**
- * SÓ DEV/TESTE (`personalAgents.poppy.allowInsecureClientIds`): busca um JSON por
- * `http:` ou `https:` SEM a guarda de SSRF — loopback e rede privada liberados,
- * para um agente local (`http://localhost:7777/agent.json`). Mantém sem redirect,
- * teto de tempo e de bytes. Nunca use em produção (a config recusa).
- */
-export declare function insecureDevFetchJson(url: string, options?: Omit<SafeFetchOptions, 'lookup'>): Promise<FetchedJson>;

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

@@ -1,262 +0,0 @@
-/**
- * `fetch` de documentos JSON de terceiros à prova de SSRF.
- *
- * O `client_id` de um agente Poppy é uma URL que QUALQUER um escolhe — buscá-la
- * sem cuidado faria deste app um proxy para a rede interna. Regras:
- *  - só `https:`; sem credenciais na URL; porta qualquer;
- *  - o IP é conferido NA CONEXÃO (o `lookup` do socket), não num DNS separado —
- *    sem janela para DNS rebinding; loopback, privados, link-local, CGNAT,
- *    multicast, reservados e os equivalentes IPv6 são recusados;
- *  - IP literal na URL passa pela mesma regra;
- *  - sem redirects (o `client_id` tem de ser exatamente a URL buscada);
- *  - teto de tempo e de bytes.
- */
-import { lookup as dnsLookup } from 'node:dns';
-import { request as httpsRequest } from 'node:https';
-import { isIP } from 'node:net';
-export class SafeFetchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'SafeFetchError';
-    }
-}
-function ipv4ToInt(ip) {
-    return ip.split('.').reduce((acc, part) => (acc << 8) + Number(part), 0) >>> 0;
-}
-function inV4(ip, cidr) {
-    const [base, bits] = cidr.split('/');
-    const mask = Number(bits) === 0 ? 0 : (~0 << (32 - Number(bits))) >>> 0;
-    return (ip & mask) === (ipv4ToInt(base) & mask);
-}
-const BLOCKED_V4 = [
-    '0.0.0.0/8',
-    '10.0.0.0/8',
-    '100.64.0.0/10',
-    '127.0.0.0/8',
-    '169.254.0.0/16',
-    '172.16.0.0/12',
-    '192.0.0.0/24',
-    '192.0.2.0/24',
-    '192.88.99.0/24',
-    '192.168.0.0/16',
-    '198.18.0.0/15',
-    '198.51.100.0/24',
-    '203.0.113.0/24',
-    '224.0.0.0/4',
-    '240.0.0.0/4',
-];
-/** Expande um IPv6 em 8 grupos de 16 bits. */
-function ipv6Groups(ip) {
-    let addr = ip.toLowerCase().split('%')[0];
-    // Sufixo IPv4 (::ffff:1.2.3.4).
-    const v4 = /(\d+\.\d+\.\d+\.\d+)$/.exec(addr);
-    if (v4) {
-        const n = ipv4ToInt(v4[1]);
-        addr = `${addr.slice(0, -v4[1].length)}${(n >>> 16).toString(16)}:${(n & 0xffff).toString(16)}`;
-    }
-    const [head, tail] = addr.split('::');
-    const h = head ? head.split(':') : [];
-    const t = tail !== undefined ? (tail ? tail.split(':') : []) : [];
-    const fill = addr.includes('::') ? 8 - h.length - t.length : 0;
-    const groups = [...h, ...Array(fill).fill('0'), ...t].map((g) => Number.parseInt(g || '0', 16));
-    return groups.length === 8 && groups.every((g) => g >= 0 && g <= 0xffff) ? groups : null;
-}
-/** `true` quando o IP não pode ser alvo de uma busca de saída. */
-export function isBlockedAddress(ip) {
-    const family = isIP(ip);
-    if (family === 4) {
-        const n = ipv4ToInt(ip);
-        return BLOCKED_V4.some((cidr) => inV4(n, cidr));
-    }
-    if (family !== 6)
-        return true;
-    const g = ipv6Groups(ip);
-    if (!g)
-        return true;
-    if (g.every((x) => x === 0))
-        return true; // ::
-    if (g.slice(0, 7).every((x) => x === 0) && g[7] === 1)
-        return true; // ::1
-    // IPv4-translated (::ffff:0:a.b.c.d) e NAT64 (64:ff9b::a.b.c.d) também chegam a um IPv4.
-    const translated = g.slice(0, 4).every((x) => x === 0) && g[4] === 0xffff && g[5] === 0;
-    const nat64 = g[0] === 0x64 && g[1] === 0xff9b && g.slice(2, 6).every((x) => x === 0);
-    if (translated || nat64) {
-        return isBlockedAddress(`${g[6] >> 8}.${g[6] & 255}.${g[7] >> 8}.${g[7] & 255}`);
-    }
-    // IPv4-mapped (::ffff:a.b.c.d) e IPv4-compatible: decide pelo IPv4.
-    if (g.slice(0, 5).every((x) => x === 0) && (g[5] === 0xffff || g[5] === 0)) {
-        const v4 = `${g[6] >> 8}.${g[6] & 255}.${g[7] >> 8}.${g[7] & 255}`;
-        return isBlockedAddress(v4);
-    }
-    if ((g[0] & 0xfe00) === 0xfc00)
-        return true; // fc00::/7 (ULA)
-    if ((g[0] & 0xffc0) === 0xfe80)
-        return true; // fe80::/10 (link-local)
-    if ((g[0] & 0xffc0) === 0xfec0)
-        return true; // fec0::/10 (site-local)
-    if ((g[0] & 0xff00) === 0xff00)
-        return true; // ff00::/8 (multicast)
-    if (g[0] === 0x2001 && g[1] === 0x0db8)
-        return true; // 2001:db8::/32 (doc)
-    if (g[0] === 0x64 && g[1] === 0xff9b)
-        return true; // 64:ff9b::/96 (NAT64)
-    if (g[0] === 0x2002) {
-        // 6to4: o IPv4 embutido.
-        return isBlockedAddress(`${g[1] >> 8}.${g[1] & 255}.${g[2] >> 8}.${g[2] & 255}`);
-    }
-    return false;
-}
-function parseMaxAge(header) {
-    const value = Array.isArray(header) ? header.join(',') : header;
-    if (!value)
-        return null;
-    if (/\bno-store\b|\bno-cache\b/i.test(value))
-        return 0;
-    const match = /\bmax-age=(\d+)/i.exec(value);
-    return match ? Number(match[1]) : null;
-}
-/**
- * Busca `url` e devolve o JSON. Só HTTPS, sem redirect, IP público conferido na
- * conexão, `timeoutMs` (default 5 s) e `maxBytes` (default 64 KiB).
- */
-export function safeFetchJson(url, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 5000;
-    const maxBytes = options.maxBytes ?? 64 * 1024;
-    const resolve = options.lookup ?? dnsLookup;
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        return Promise.reject(new SafeFetchError('invalid URL'));
-    }
-    if (parsed.protocol !== 'https:')
-        return Promise.reject(new SafeFetchError('only https URLs'));
-    if (parsed.username || parsed.password) {
-        return Promise.reject(new SafeFetchError('credentials in URL'));
-    }
-    const host = parsed.hostname.replace(/^\[|\]$/g, '');
-    if (isIP(host) && isBlockedAddress(host)) {
-        return Promise.reject(new SafeFetchError('blocked address'));
-    }
-    // `lookup` do socket: resolve e recusa se QUALQUER endereço for interno.
-    const guardedLookup = (hostname, opts, callback) => {
-        resolve(hostname, { all: true }, (err, addresses) => {
-            if (err)
-                return callback(err);
-            const list = addresses ?? [];
-            if (list.length === 0)
-                return callback(new SafeFetchError('no address'));
-            if (list.some((a) => isBlockedAddress(a.address))) {
-                return callback(new SafeFetchError('blocked address'));
-            }
-            if (opts?.all)
-                return callback(null, list);
-            return callback(null, list[0].address, list[0].family);
-        });
-    };
-    return new Promise((done, reject) => {
-        let settled = false;
-        const finish = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            fn();
-        };
-        const req = httpsRequest(parsed, {
-            method: 'GET',
-            headers: { accept: 'application/json', 'user-agent': 'authkit-poppy/0.3' },
-            lookup: guardedLookup,
-            // IP literal: o `lookup` não roda — já conferido acima.
-        }, (res) => {
-            const status = res.statusCode ?? 0;
-            if (status >= 300 && status < 400) {
-                res.resume();
-                return finish(() => reject(new SafeFetchError('redirects are not followed')));
-            }
-            const chunks = [];
-            let size = 0;
-            res.on('data', (chunk) => {
-                size += chunk.length;
-                if (size > maxBytes) {
-                    req.destroy();
-                    finish(() => reject(new SafeFetchError('response too large')));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            res.on('end', () => finish(() => {
-                if (status !== 200)
-                    return reject(new SafeFetchError(`HTTP ${status}`));
-                try {
-                    done({
-                        status,
-                        body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-                        maxAge: parseMaxAge(res.headers['cache-control']),
-                    });
-                }
-                catch {
-                    reject(new SafeFetchError('invalid JSON'));
-                }
-            }));
-            res.on('error', (e) => finish(() => reject(new SafeFetchError(e.message))));
-        });
-        const timer = setTimeout(() => {
-            req.destroy();
-            finish(() => reject(new SafeFetchError('timeout')));
-        }, timeoutMs);
-        req.on('error', (e) => finish(() => reject(e instanceof SafeFetchError ? e : new SafeFetchError(e.message))));
-        req.end();
-    });
-}
-/**
- * SÓ DEV/TESTE (`personalAgents.poppy.allowInsecureClientIds`): busca um JSON por
- * `http:` ou `https:` SEM a guarda de SSRF — loopback e rede privada liberados,
- * para um agente local (`http://localhost:7777/agent.json`). Mantém sem redirect,
- * teto de tempo e de bytes. Nunca use em produção (a config recusa).
- */
-export async function insecureDevFetchJson(url, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 5000;
-    const maxBytes = options.maxBytes ?? 64 * 1024;
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        throw new SafeFetchError('invalid URL');
-    }
-    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
-        throw new SafeFetchError('only http(s) URLs');
-    }
-    if (parsed.username || parsed.password)
-        throw new SafeFetchError('credentials in URL');
-    let res;
-    try {
-        res = await fetch(parsed, {
-            redirect: 'manual',
-            headers: { accept: 'application/json', 'user-agent': 'authkit-poppy/0.3 (insecure-dev)' },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-    }
-    catch (error) {
-        throw new SafeFetchError(error.name === 'TimeoutError' ? 'timeout' : 'unreachable');
-    }
-    if (res.status >= 300 && res.status < 400)
-        throw new SafeFetchError('redirects are not followed');
-    const buf = Buffer.from(await res.arrayBuffer());
-    if (buf.length > maxBytes)
-        throw new SafeFetchError('response too large');
-    if (res.status !== 200)
-        throw new SafeFetchError(`HTTP ${res.status}`);
-    try {
-        return {
-            status: res.status,
-            body: JSON.parse(buf.toString('utf8')),
-            maxAge: parseMaxAge(res.headers.get('cache-control') ?? undefined),
-        };
-    }
-    catch {
-        throw new SafeFetchError('invalid JSON');
-    }
-}