@adonis-agora/authkit-server 0.78.0 → 0.80.0

package/build/index.d.ts

@@ -19,6 +19,7 @@ export { personalAgentAuth, personalAgentOf, personalAgentReceipt, personalAgent
 export type { PoppyAgentProtocolEntry, PoppyApiEntry, PoppyBrowserLogin, PoppyClientsConfigInput, PoppyConfigInput, PoppyLimiter, PoppyMediatedConfigInput, PoppyMediatedField, PoppyMediatedResult, PoppyMediatedVerifyInput, PoppyPrincipalBase, PoppyReplayStore, ResolvedPoppyConfig, } from './src/agents/poppy/config.js';
 export { POPPY_READ, POPPY_WRITE } from './src/agents/poppy/config.js';
 export { accessTokenHash, type DpopNonceSource, type DpopResult, hmacNonceSource, type VerifyDpopInput, verifyDpopProof, } from './src/agents/poppy/dpop.js';
+export { maskEmail, type PoppyEmailCodeSignInOptions, poppyEmailCodeSignIn, } from './src/agents/poppy/email_code_sign_in.js';
 export { PoppyError, type PoppyErrorCode } from './src/agents/poppy/errors.js';
 export { databaseReplayStore, memoryReplayStore, redisReplayStore, } from './src/agents/poppy/replay.js';
 export { installPoppySlots, POPPY_AUTHENTICATE_SLOT, type PoppyAuthenticate, type PoppyAuthResult, type PoppyPrincipal, type PoppySlotRequest, poppyAuth, poppyOf, verifyPoppyRequest, writePoppyAuthError, } from './src/agents/poppy/resource.js';

package/build/index.js

@@ -11,6 +11,7 @@ export { PersonalAgentVerifier } from './src/agents/agent_identity.js';
 export { personalAgentAuth, personalAgentOf, personalAgentReceipt, personalAgentSecurity, personalAgentStepUp, } from './src/agents/middleware.js';
 export { POPPY_READ, POPPY_WRITE } from './src/agents/poppy/config.js';
 export { accessTokenHash, hmacNonceSource, verifyDpopProof, } from './src/agents/poppy/dpop.js';
+export { maskEmail, poppyEmailCodeSignIn, } from './src/agents/poppy/email_code_sign_in.js';
 export { PoppyError } from './src/agents/poppy/errors.js';
 export { databaseReplayStore, memoryReplayStore, redisReplayStore, } from './src/agents/poppy/replay.js';
 export { installPoppySlots, POPPY_AUTHENTICATE_SLOT, poppyAuth, poppyOf, verifyPoppyRequest, writePoppyAuthError, } from './src/agents/poppy/resource.js';

package/build/src/agents/config.d.ts

@@ -103,6 +103,8 @@ export interface ResolvedPersonalAgentsConfig {
     /** `''` quando o PACT está desligado. */
     audience: string;
     resolveAgent: PersonalAgentResolver;
+    /** A lista `agents` do config quando é um array (o console mostra); `null` = resolver do host. */
+    staticAgents: PersonalAgentRegistration[] | null;
     open: boolean;
     delegation?: ResolvedPersonalAgentDelegationConfig;
     prefix: string;

package/build/src/agents/config.js

@@ -51,10 +51,12 @@ export function resolvePersonalAgentsConfig(input) {
         throw new Error('authkit: o Poppy não é um `protocol` do PACT — configure-o em `personalAgents.poppy` (os dois convivem).');
     }
     let resolveAgent;
+    let staticAgents = null;
     if (typeof input.agents === 'function') {
         resolveAgent = input.agents;
     }
     else {
+        staticAgents = [...(input.agents ?? [])];
         const byIssuer = new Map();
         for (const agent of input.agents ?? []) {
             assertUrl(agent.issuer, `agents[].issuer`);
@@ -101,6 +103,7 @@ export function resolvePersonalAgentsConfig(input) {
         protocol,
         audience: pact ? input.audience : '',
         resolveAgent,
+        staticAgents,
         open: input.open === true,
         delegation,
         prefix,

package/build/src/agents/delegation_store.d.ts

@@ -37,7 +37,13 @@ export interface GrantRow {
     createdAt: Date;
     updatedAt: Date;
 }
+export interface LiveGrantFilter {
+    protocol?: 'pact' | 'poppy';
+    clientId?: string;
+    accountId?: string;
+}
 export declare class DelegationStore {
+    #private;
     private conn;
     /** `conn` = uma conexão Lucid (`db.connection(name?)`) — ou uma transação. */
     constructor(conn: () => any);
@@ -75,6 +81,16 @@ export declare class DelegationStore {
     /** Revoga um grant DA CONTA. `false` = não existe, é de outra conta ou já revogado. */
     revokeGrant(accountId: string, id: string, at: Date): Promise<boolean>;
     revokeAllGrants(accountId: string, at: Date): Promise<number>;
+    listLiveGrants(input: LiveGrantFilter & {
+        now: Date;
+        offset: number;
+        limit: number;
+    }): Promise<GrantRow[]>;
+    countLiveGrants(now: Date, filter?: LiveGrantFilter): Promise<number>;
+    /** Conexões vivas de um protocolo por agente: `client_id` → número de grants. */
+    countLiveGrantsByClient(now: Date, protocol: 'pact' | 'poppy'): Promise<Map<string, number>>;
+    /** Ids dos grants não revogados de um agente (vivos ou não) — para revogar todos. */
+    unrevokedGrantIdsOfClient(clientId: string): Promise<string[]>;
     /** Revoga um grant sem checar a conta — reação a reuso de refresh token. */
     revokeGrantById(id: string, at: Date): Promise<void>;
     insertRefreshToken(row: {

package/build/src/agents/delegation_store.js

@@ -183,6 +183,50 @@ export class DelegationStore {
             .update({ revoked_at: at, updated_at: at });
         return affected(result);
     }
+    // ─── console admin (todas as contas) ──────────────────────────────────────
+    /**
+     * Grants vivos (não revogados nem expirados em `now`), de todas as contas. O
+     * protocolo sai do prefixo do id: `agrant_` (PACT) ou `pgrant_` (Poppy).
+     */
+    #live(now, filter = {}) {
+        let q = this.conn().from(GRANT_TABLE).whereNull('revoked_at').where('expires_at', '>', now);
+        if (filter.protocol)
+            q = q.where('id', 'like', filter.protocol === 'poppy' ? 'pgrant_%' : 'agrant_%');
+        if (filter.clientId)
+            q = q.where('client_id', filter.clientId);
+        if (filter.accountId)
+            q = q.where('account_id', filter.accountId);
+        return q;
+    }
+    async listLiveGrants(input) {
+        const rows = await this.#live(input.now, input)
+            .orderBy('created_at', 'desc')
+            .orderBy('id', 'asc')
+            .offset(input.offset)
+            .limit(input.limit);
+        return rows.map(toGrant);
+    }
+    async countLiveGrants(now, filter = {}) {
+        const row = await this.#live(now, filter).count('* as total').first();
+        return Number(row?.total ?? 0);
+    }
+    /** Conexões vivas de um protocolo por agente: `client_id` → número de grants. */
+    async countLiveGrantsByClient(now, protocol) {
+        const rows = await this.#live(now, { protocol })
+            .select('client_id')
+            .count('* as total')
+            .groupBy('client_id');
+        return new Map(rows.map((r) => [r.client_id, Number(r.total)]));
+    }
+    /** Ids dos grants não revogados de um agente (vivos ou não) — para revogar todos. */
+    async unrevokedGrantIdsOfClient(clientId) {
+        const rows = await this.conn()
+            .from(GRANT_TABLE)
+            .where('client_id', clientId)
+            .whereNull('revoked_at')
+            .select('id');
+        return rows.map((r) => r.id);
+    }
     /** Revoga um grant sem checar a conta — reação a reuso de refresh token. */
     async revokeGrantById(id, at) {
         await this.conn()

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

@@ -332,6 +332,9 @@ export interface ResolvedPoppyConfig {
         requireRegistration: boolean;
         isRegistered: (clientId: string) => Promise<boolean>;
         isBlocked: (clientId: string) => Promise<boolean>;
+        /** As listas do config quando são arrays (o console mostra); `null` = função do host. */
+        registeredList: string[] | null;
+        blockedList: string[] | null;
     };
     /** Dev/teste: `client_id` http e busca sem guarda de SSRF (ver o input). */
     allowInsecureClientIds: boolean;

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

@@ -47,6 +47,11 @@ function membership(value) {
     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;
@@ -180,6 +185,8 @@ export function resolvePoppyConfig(input, fallbackScopes) {
             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,
         sessionTokenTtl: positive(input.sessionTokenTtl, 3600, 'sessionTokenTtl'),

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

@@ -0,0 +1,27 @@
+import { type AuthAccount } from '../../accounts/account_store.js';
+import type { PoppyMediatedConfigInput } from './config.js';
+export interface PoppyEmailCodeSignInOptions {
+    /** Scopes que este sign-in pode conceder. Default: `['poppy:read']` (o default do Mediated). */
+    scopes?: string[];
+    /** Validade do código, em segundos. Default: 600. */
+    codeTtl?: number;
+    /** Tentativas de código antes de `failed`. 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

@@ -0,0 +1,140 @@
+/**
+ * @experimental Poppy (Personal Agent Protocol) Draft 0.1 — pode mudar de forma incompatível enquanto a spec for draft.
+ *
+ * Mediated Sign-In pronto (§4.7): 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() } },
+ * }
+ * ```
+ *
+ * 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 }],
+        ...(options.scopes ? { 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/service.d.ts

@@ -276,5 +276,11 @@ export declare class PoppyService {
     revokeAccountGrant(accountId: string, grantId: string): Promise<boolean>;
     /** Revoga todos os Account Tokens da conta (sair de tudo, conta suspensa…). */
     revokeAllAccountGrants(accountId: string): Promise<number>;
+    /**
+     * Bloqueio pelo console admin: revoga todos os Account Tokens do agente (todas as
+     * contas) e encerra as Sessions dele — os Session Tokens param na próxima request.
+     * Devolve quantos Account Tokens estavam vivos.
+     */
+    disconnectClient(clientId: string): Promise<number>;
 }
 export type { RequestRow };

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

@@ -1277,6 +1277,18 @@ export class PoppyService {
             await this.revokeGrant(g.id);
         return live.length;
     }
+    /**
+     * Bloqueio pelo console admin: revoga todos os Account Tokens do agente (todas as
+     * contas) e encerra as Sessions dele — os Session Tokens param na próxima request.
+     * Devolve quantos Account Tokens estavam vivos.
+     */
+    async disconnectClient(clientId) {
+        const ids = (await this.#grants.unrevokedGrantIdsOfClient(clientId)).filter((id) => id.startsWith('pgrant_'));
+        for (const id of ids)
+            await this.revokeGrant(id);
+        await this.#store.endSessionsOfClient(clientId, this.#now());
+        return ids.length;
+    }
     // ─── internos ─────────────────────────────────────────────────────────────
     /** Scopes de um pedido de sign-in: obrigatórios, conhecidos e do tipo (§4.4). */
     #signInScopes(raw, type) {

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

@@ -82,6 +82,8 @@ export declare class PoppyStore {
     }): Promise<boolean>;
     /** Sign-out (§4.9): as Sessions logadas com o grant continuam, deslogadas. */
     signOutSessionsOfGrant(grantId: string, at: Date): Promise<number>;
+    /** Encerra todas as Sessions de um agente (bloqueio no console): os tokens param na hora. */
+    endSessionsOfClient(clientId: string, at: Date): Promise<number>;
     insertToken(row: TokenRow): Promise<void>;
     findToken(hash: string): Promise<TokenRow | null>;
     deleteToken(hash: string): Promise<boolean>;

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

@@ -152,6 +152,15 @@ export class PoppyStore {
             .update({ grant_id: null, scope: '', updated_at: at });
         return affected(result);
     }
+    /** Encerra todas as Sessions de um agente (bloqueio no console): os tokens param na hora. */
+    async endSessionsOfClient(clientId, at) {
+        const result = await this.conn()
+            .from(SESSION_TABLE)
+            .where('client_id', clientId)
+            .whereNull('ended_at')
+            .update({ ended_at: at, grant_id: null, scope: '', updated_at: at });
+        return affected(result);
+    }
     // ─── session tokens ───────────────────────────────────────────────────────
     async insertToken(row) {
         await this.conn().table(TOKEN_TABLE).insert({

package/build/src/agents/registry_store.d.ts

@@ -0,0 +1,41 @@
+export declare const REGISTRY_TABLE = "auth_agent_registry";
+export type AgentProtocolId = 'pact' | 'poppy';
+export type AgentRegistryStatus = 'allowed' | 'blocked';
+export interface AgentRegistryRow {
+    id: string;
+    protocol: AgentProtocolId;
+    /** PACT: o `iss` do agente. Poppy: o `client_id` (URL do documento de metadata). */
+    identifier: string;
+    status: AgentRegistryStatus;
+    name: string | null;
+    /** JWKS do agente PACT (obrigatório num `allowed` PACT). */
+    jwksUri: string | null;
+    /** Conta do admin que fez a mudança. */
+    updatedBy: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Quanto tempo o snapshot vale antes de reler a tabela. */
+export declare const SNAPSHOT_TTL_MS: number;
+export declare class AgentRegistryStore {
+    #private;
+    constructor(conn: () => any, options?: {
+        now?: () => number;
+    });
+    /** Todas as linhas, mais recentes primeiro. Lê do banco (console). */
+    list(): Promise<AgentRegistryRow[]>;
+    /** A linha do agente, pelo snapshot. `null` = o console não diz nada sobre ele. */
+    find(protocol: AgentProtocolId, identifier: string): Promise<AgentRegistryRow | null>;
+    findById(id: string): Promise<AgentRegistryRow | null>;
+    /** Cria ou troca a linha de (protocolo, identificador). */
+    upsert(input: {
+        protocol: AgentProtocolId;
+        identifier: string;
+        status: AgentRegistryStatus;
+        name?: string | null;
+        jwksUri?: string | null;
+        updatedBy?: string | null;
+    }): Promise<AgentRegistryRow>;
+    delete(id: string): Promise<boolean>;
+    invalidate(): void;
+}

package/build/src/agents/registry_store.js

@@ -0,0 +1,138 @@
+/**
+ * Registro de personal agents feito pelo console admin — tabela LIB-OWNED
+ * `auth_agent_registry` (ver `schema/ensure.ts`). SOMA ao `defineConfig`:
+ *
+ * - `allowed`: o agente entra mesmo fora da lista do config (PACT: issuer + JWKS;
+ *   Poppy: `client_id` registrado quando `clients.requireRegistration`).
+ * - `blocked`: o agente é recusado mesmo que o config o liste — bloquear é a
+ *   ação de emergência, e precisa valer sem deploy.
+ *
+ * O que o config bloqueia continua bloqueado: o console não desfaz o config.
+ *
+ * A tabela é pequena e lida em TODA verificação de agente PACT, então as linhas
+ * ficam num snapshot em memória por {@link SNAPSHOT_TTL_MS}. Escritas por este
+ * processo invalidam na hora; em outras instâncias o efeito chega no próximo
+ * refresh — o bloqueio corta os tokens já emitidos pelo banco (grants revogados,
+ * Sessions encerradas), então o atraso só vale para um agente começando do zero.
+ */
+import { randomBytes } from 'node:crypto';
+export const REGISTRY_TABLE = 'auth_agent_registry';
+/** Quanto tempo o snapshot vale antes de reler a tabela. */
+export const SNAPSHOT_TTL_MS = 15 * 1000;
+function toDate(value) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value === 'number')
+        return new Date(value);
+    if (typeof value === 'string' && /^\d+$/.test(value))
+        return new Date(Number(value));
+    return new Date(String(value));
+}
+function toRow(row) {
+    return {
+        id: row.id,
+        protocol: row.protocol,
+        identifier: row.identifier,
+        status: row.status,
+        name: row.name ?? null,
+        jwksUri: row.jwks_uri ?? null,
+        updatedBy: row.updated_by ?? null,
+        createdAt: toDate(row.created_at),
+        updatedAt: toDate(row.updated_at),
+    };
+}
+const key = (protocol, identifier) => `${protocol} ${identifier}`;
+export class AgentRegistryStore {
+    #conn;
+    #now;
+    #snapshot = null;
+    #loading = null;
+    constructor(conn, options = {}) {
+        this.#conn = conn;
+        this.#now = options.now ?? Date.now;
+    }
+    /** Todas as linhas, mais recentes primeiro. Lê do banco (console). */
+    async list() {
+        const rows = await this.#conn().from(REGISTRY_TABLE).orderBy('updated_at', 'desc');
+        return rows.map(toRow);
+    }
+    /** A linha do agente, pelo snapshot. `null` = o console não diz nada sobre ele. */
+    async find(protocol, identifier) {
+        return (await this.#rows()).get(key(protocol, identifier)) ?? null;
+    }
+    async findById(id) {
+        const row = await this.#conn().from(REGISTRY_TABLE).where('id', id).first();
+        return row ? toRow(row) : null;
+    }
+    /** Cria ou troca a linha de (protocolo, identificador). */
+    async upsert(input) {
+        const now = new Date(this.#now());
+        const existing = await this.#conn()
+            .from(REGISTRY_TABLE)
+            .where('protocol', input.protocol)
+            .where('identifier', input.identifier)
+            .first();
+        const values = {
+            status: input.status,
+            name: input.name ?? null,
+            jwks_uri: input.jwksUri ?? null,
+            updated_by: input.updatedBy ?? null,
+            updated_at: now,
+        };
+        if (existing) {
+            await this.#conn().from(REGISTRY_TABLE).where('id', existing.id).update(values);
+        }
+        else {
+            await this.#conn()
+                .table(REGISTRY_TABLE)
+                .insert({
+                id: `areg_${randomBytes(12).toString('base64url')}`,
+                protocol: input.protocol,
+                identifier: input.identifier,
+                created_at: now,
+                ...values,
+            });
+        }
+        this.invalidate();
+        const row = await this.#conn()
+            .from(REGISTRY_TABLE)
+            .where('protocol', input.protocol)
+            .where('identifier', input.identifier)
+            .first();
+        return toRow(row);
+    }
+    async delete(id) {
+        const result = await this.#conn().from(REGISTRY_TABLE).where('id', id).delete();
+        this.invalidate();
+        return (typeof result === 'number' ? result : Array.isArray(result) ? result.length : 0) > 0;
+    }
+    invalidate() {
+        this.#snapshot = null;
+    }
+    async #rows() {
+        const now = this.#now();
+        if (this.#snapshot && this.#snapshot.expiresAt > now)
+            return this.#snapshot.rows;
+        if (!this.#loading) {
+            this.#loading = (async () => {
+                try {
+                    const rows = (await this.#conn().from(REGISTRY_TABLE)).map(toRow);
+                    const map = new Map(rows.map((r) => [key(r.protocol, r.identifier), r]));
+                    this.#snapshot = { rows: map, expiresAt: this.#now() + SNAPSHOT_TTL_MS };
+                    return map;
+                }
+                catch {
+                    // Banco fora (ou tabela ainda não criada): fica com o último snapshot, ou
+                    // nenhum — o config continua valendo sozinho. Tenta de novo logo.
+                    const rows = this.#snapshot?.rows ?? new Map();
+                    this.#snapshot = { rows, expiresAt: this.#now() + 1000 };
+                    return rows;
+                }
+                finally {
+                    this.#loading = null;
+                }
+            })();
+        }
+        return this.#loading;
+    }
+}

package/build/src/agents/runtime.d.ts

@@ -3,8 +3,10 @@ import type { OidcService } from '../provider/oidc_service.js';
 import { PersonalAgentVerifier } from './agent_identity.js';
 import type { ResolvedPersonalAgentsConfig } from './config.js';
 import { PersonalAgentDelegation } from './delegation_service.js';
+import { DelegationStore, type GrantRow } from './delegation_store.js';
 import type { JsonFetcher } from './poppy/safe_fetch.js';
 import { PoppyService } from './poppy/service.js';
+import { type AgentProtocolId, AgentRegistryStore } from './registry_store.js';
 /** URLs públicas do authorization server de delegação. */
 export interface PersonalAgentUrls {
     /** `issuer` (RFC 8414) — também o `iss` dos tokens de delegação. */
@@ -35,6 +37,17 @@ export interface PersonalAgentsRuntime {
     revokeAgentGrant(accountId: string, grantId: string): Promise<boolean>;
     /** Revoga todos os grants de personal agents da conta. Devolve quantos estavam vivos. */
     revokeAllAgentGrants(accountId: string): Promise<number>;
+    /**
+     * Registro do console admin (agentes liberados/bloqueados além do config).
+     * `null` sem banco (PACT só de identidade sem `lucid.db`).
+     */
+    registry: AgentRegistryStore | null;
+    /** Grants de todas as contas (console admin). `null` sem banco. */
+    grants: DelegationStore | null;
+    /** Revoga um grant de QUALQUER conta (console admin). Devolve o grant, ou `null` se já não valia. */
+    revokeGrantById(grantId: string): Promise<GrantRow | null>;
+    /** Desconecta um agente de todas as contas (bloqueio). Devolve quantos grants estavam vivos. */
+    disconnectAgent(protocol: AgentProtocolId, identifier: string): Promise<number>;
 }
 export interface BuildPersonalAgentsOptions {
     /** Resolve serviços do container (redis do replay store). */