@adonis-agora/authkit-server 0.77.0 → 0.79.0

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,6 +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. */
@@ -23,14 +27,39 @@ export declare function personalAgentUrls(oidcIssuer: string, prefix: string): P
 export interface PersonalAgentsRuntime {
     config: ResolvedPersonalAgentsConfig;
     urls: PersonalAgentUrls;
+    /** Verificador do JWT do agente PACT (inerte quando o PACT está desligado — veja `config.pact`). */
     verifier: PersonalAgentVerifier;
     /** `null` quando o app não configurou `personalAgents.delegation`. */
     delegation: PersonalAgentDelegation | null;
+    /** `null` quando o app não configurou `personalAgents.poppy`. */
+    poppy: PoppyService | null;
+    /** Revoga um grant de personal agent DA CONTA (PACT ou Poppy). */
+    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). */
+    make?: (binding: string) => Promise<any>;
+    /** Busca de JSON (metadata/JWKS dos agentes Poppy) — injetável nos testes. */
+    fetchJson?: JsonFetcher;
+    now?: () => Date;
 }
 /**
  * Monta (uma vez por `OidcService`) o runtime de personal agents. `null` quando
  * `personalAgents` não está no config — as rotas respondem 404.
  */
-export declare function buildPersonalAgentsRuntime(service: OidcService, makeDb: () => Promise<any>): Promise<PersonalAgentsRuntime | null>;
+export declare function buildPersonalAgentsRuntime(service: OidcService, makeDb: () => Promise<any>, options?: BuildPersonalAgentsOptions): Promise<PersonalAgentsRuntime | null>;
 /** Runtime a partir de uma request. */
 export declare function personalAgentsFor(ctx: HttpContext): Promise<PersonalAgentsRuntime | null>;

package/build/src/agents/runtime.js

@@ -1,7 +1,14 @@
 import { supportsAccountStatus } from '../accounts/account_store.js';
+import { findMcpResource } from '../mcp/mcp_oauth.js';
 import { PersonalAgentVerifier } from './agent_identity.js';
 import { PersonalAgentDelegation } from './delegation_service.js';
 import { DelegationStore } from './delegation_store.js';
+import { PoppyClientRegistry } from './poppy/client_registry.js';
+import { hmacNonceSource } from './poppy/dpop.js';
+import { databaseReplayStore, memoryLimiter, memoryReplayStore, redisReplayStore, } from './poppy/replay.js';
+import { PoppyService, poppyUrls } from './poppy/service.js';
+import { PoppyStore } from './poppy/store.js';
+import { AgentRegistryStore } from './registry_store.js';
 import { keystoreSigner } from './signer.js';
 /**
  * Deriva as URLs da ORIGEM do issuer configurado — nunca do Host da request
@@ -20,11 +27,112 @@ export function personalAgentUrls(oidcIssuer, prefix) {
     };
 }
 const runtimes = new WeakMap();
+/** Ponte Poppy → oidc-provider: Bearer de MCP de Sessions logadas viram access tokens dele. */
+function mcpBridge(service, poppyApis) {
+    return {
+        isMcpResource(url) {
+            try {
+                return findMcpResource(url, service.config.issuer, service.config.mcp) !== null;
+            }
+            catch {
+                return false;
+            }
+        },
+        async mint(input) {
+            const provider = service.provider;
+            if (!provider?.AccessToken || !provider?.Grant)
+                return null;
+            // Só faz sentido quando a integração MCP do authkit está ligada, ou o MCP é de `apis`.
+            if (!service.config.mcp?.enabled &&
+                !poppyApis.some((a) => a.type === 'mcp' && a.url.replace(/\/+$/, '') === input.resource.replace(/\/+$/, ''))) {
+                return null;
+            }
+            const remaining = Math.max(60, Math.floor((input.grantExpiresAt.getTime() - Date.now()) / 1000));
+            let grant = await provider.Grant.find(input.grantId);
+            if (!grant) {
+                grant = new provider.Grant({
+                    jti: input.grantId,
+                    accountId: input.accountId,
+                    clientId: input.clientId,
+                    expiresIn: remaining,
+                });
+                await grant.save();
+            }
+            const at = new provider.AccessToken({
+                accountId: input.accountId,
+                clientId: input.clientId,
+                grantId: input.grantId,
+                scope: input.scope,
+                gty: 'poppy',
+                expiresIn: input.expiresIn,
+            });
+            at.aud = input.resource;
+            return at.save();
+        },
+        async revoke(grantId) {
+            const provider = service.provider;
+            if (!provider?.Grant)
+                return;
+            await provider.AccessToken?.revokeByGrantId?.(grantId);
+            const grant = await provider.Grant.find(grantId);
+            if (grant)
+                await grant.destroy();
+        },
+    };
+}
+async function resolveReplay(replay, conn, make) {
+    if (replay === 'memory')
+        return memoryReplayStore();
+    if (replay === 'database')
+        return databaseReplayStore(conn);
+    if (typeof replay.claim === 'function')
+        return replay;
+    const name = replay.redis;
+    if (!make)
+        throw new Error('authkit: personalAgents.poppy.replay { redis } exige o container.');
+    const redis = await make('redis');
+    return redisReplayStore(redis.connection(name));
+}
+/**
+ * Config com o registro do console por cima: um agente BLOQUEADO no console é
+ * recusado mesmo que o config o liste; um LIBERADO entra mesmo fora da lista.
+ * O que o config bloqueia continua bloqueado.
+ */
+function withRegistry(config, registry) {
+    const resolveAgent = async (issuer) => {
+        const row = await registry.find('pact', issuer);
+        if (row?.status === 'blocked') {
+            return { issuer, jwksUri: row.jwksUri ?? '', name: row.name ?? undefined, enabled: false };
+        }
+        const configured = await config.resolveAgent(issuer);
+        if (configured)
+            return configured;
+        if (row?.status === 'allowed' && row.jwksUri) {
+            return { issuer, jwksUri: row.jwksUri, name: row.name ?? undefined };
+        }
+        return null;
+    };
+    const poppy = config.poppy;
+    return {
+        ...config,
+        resolveAgent,
+        poppy: poppy && {
+            ...poppy,
+            clients: {
+                ...poppy.clients,
+                isBlocked: async (id) => (await poppy.clients.isBlocked(id)) ||
+                    (await registry.find('poppy', id))?.status === 'blocked',
+                isRegistered: async (id) => (await poppy.clients.isRegistered(id)) ||
+                    (await registry.find('poppy', id))?.status === 'allowed',
+            },
+        },
+    };
+}
 /**
  * Monta (uma vez por `OidcService`) o runtime de personal agents. `null` quando
  * `personalAgents` não está no config — as rotas respondem 404.
  */
-export function buildPersonalAgentsRuntime(service, makeDb) {
+export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
     let runtime = runtimes.get(service);
     if (!runtime) {
         runtime = (async () => {
@@ -32,25 +140,122 @@ export function buildPersonalAgentsRuntime(service, makeDb) {
             if (!config)
                 return null;
             const urls = personalAgentUrls(service.config.issuer, config.prefix);
-            let delegation = null;
-            if (config.delegation) {
+            // Conta apagada ou suspensa corta a delegação na hora.
+            const isAccountActive = async (accountId) => {
+                const store = service.config.accountStore;
+                if (!(await store.findById(accountId)))
+                    return false;
+                return !(supportsAccountStatus(store) && (await store.isDisabled(accountId)));
+            };
+            let conn = null;
+            const connection = service.config.schema.connection;
+            if (config.delegation || config.poppy) {
                 const db = await makeDb();
-                const connection = service.config.schema.connection;
+                conn = () => (connection ? db.connection(connection) : db.connection());
+            }
+            else {
+                // PACT só de identidade não precisa de banco; com ele, o console pode bloquear.
+                try {
+                    const db = await makeDb();
+                    if (db)
+                        conn = () => (connection ? db.connection(connection) : db.connection());
+                }
+                catch {
+                    conn = null;
+                }
+            }
+            const store = conn ? new DelegationStore(conn) : null;
+            const registry = conn ? new AgentRegistryStore(conn) : null;
+            const effective = registry ? withRegistry(config, registry) : config;
+            let delegation = null;
+            if (config.delegation && store) {
                 delegation = new PersonalAgentDelegation({
                     cfg: config.delegation,
-                    store: new DelegationStore(() => connection ? db.connection(connection) : db.connection()),
+                    store,
                     signer: keystoreSigner(service),
                     urls: { issuer: urls.issuer, consent: urls.consent },
-                    // Conta apagada ou suspensa corta a delegação na hora.
-                    isAccountActive: async (accountId) => {
-                        const store = service.config.accountStore;
-                        if (!(await store.findById(accountId)))
-                            return false;
-                        return !(supportsAccountStatus(store) && (await store.isDisabled(accountId)));
-                    },
+                    isAccountActive,
+                });
+            }
+            let poppy = null;
+            if (effective.poppy && store && conn) {
+                const cfg = effective.poppy;
+                const limiter = cfg.rateLimit === false
+                    ? null
+                    : typeof cfg.rateLimit === 'function'
+                        ? cfg.rateLimit
+                        : memoryLimiter(cfg.rateLimit);
+                const secret = service.deriveSecret('poppy-dpop-nonce');
+                poppy = new PoppyService({
+                    cfg,
+                    urls: poppyUrls(service.config.issuer, cfg.prefix),
+                    store: new PoppyStore(conn),
+                    grants: store,
+                    registry: new PoppyClientRegistry(cfg, { fetchJson: options.fetchJson }),
+                    replay: await resolveReplay(cfg.replay, conn, options.make),
+                    limiter,
+                    nonces: hmacNonceSource(secret),
+                    isAccountActive,
+                    mcp: mcpBridge(service, cfg.apis),
+                    now: options.now,
                 });
             }
-            return { config, urls, verifier: new PersonalAgentVerifier(config), delegation };
+            const revokeAgentGrant = async (accountId, grantId) => {
+                if (grantId.startsWith('pgrant_')) {
+                    return poppy ? poppy.revokeAccountGrant(accountId, grantId) : false;
+                }
+                return delegation ? delegation.revokeGrant(accountId, grantId) : false;
+            };
+            const revokeAllAgentGrants = async (accountId) => {
+                let count = 0;
+                if (poppy)
+                    count += await poppy.revokeAllAccountGrants(accountId);
+                if (delegation)
+                    count += await delegation.revokeAllGrants(accountId);
+                return count;
+            };
+            const revokeGrantById = async (grantId) => {
+                if (!store)
+                    return null;
+                const grant = await store.findGrant(grantId);
+                const now = options.now?.() ?? new Date();
+                // Expirado já não vale: revogar não muda nada (e não vira evento de auditoria).
+                if (!grant || grant.revokedAt || grant.expiresAt <= now)
+                    return null;
+                if (grantId.startsWith('pgrant_')) {
+                    if (!poppy)
+                        return null;
+                    await poppy.revokeGrant(grantId);
+                }
+                else {
+                    await store.revokeGrantById(grantId, now);
+                }
+                return grant;
+            };
+            const disconnectAgent = async (protocol, identifier) => {
+                if (!store)
+                    return 0;
+                if (protocol === 'poppy')
+                    return poppy ? poppy.disconnectClient(identifier) : 0;
+                const ids = (await store.unrevokedGrantIdsOfClient(identifier)).filter((id) => !id.startsWith('pgrant_'));
+                const at = options.now?.() ?? new Date();
+                for (const id of ids)
+                    await store.revokeGrantById(id, at);
+                return ids.length;
+            };
+            return {
+                config: effective,
+                urls,
+                verifier: new PersonalAgentVerifier(effective),
+                delegation,
+                poppy,
+                revokeAgentGrant,
+                revokeAllAgentGrants,
+                registry,
+                grants: store,
+                revokeGrantById,
+                disconnectAgent,
+            };
         })();
         // Falha (DB indisponível) não fica em cache — a próxima request tenta de novo.
         runtime.catch(() => runtimes.delete(service));
@@ -61,5 +266,7 @@ export function buildPersonalAgentsRuntime(service, makeDb) {
 /** Runtime a partir de uma request. */
 export async function personalAgentsFor(ctx) {
     const service = await ctx.containerResolver.make('authkit.server');
-    return buildPersonalAgentsRuntime(service, () => ctx.containerResolver.make('lucid.db'));
+    return buildPersonalAgentsRuntime(service, () => ctx.containerResolver.make('lucid.db'), {
+        make: (binding) => ctx.containerResolver.make(binding),
+    });
 }

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

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

package/build/src/audit/audit_sink.js

@@ -113,4 +113,10 @@ export const AUDIT_EVENT_TYPES = [
     'agent.delegation_approved',
     'agent.delegation_denied',
     'agent.grant_revoked',
+    // Console admin: um admin revogou a conexão de um usuário, ou liberou/bloqueou um
+    // agente (PACT pelo `iss`, Poppy pelo `client_id`).
+    'agent.grant_revoked_by_admin',
+    'agent.allowed',
+    'agent.blocked',
+    'agent.registry_removed',
 ];

package/build/src/define_config.js

@@ -353,6 +353,12 @@ export function defineConfig(config) {
             (personalAgents.prefix === oidcMount || personalAgents.prefix.startsWith(`${oidcMount}/`))) {
             throw new Error(`authkit: personalAgents.prefix "${personalAgents.prefix}" não pode ficar debaixo do mountPath do OIDC ("${oidcMount}").`);
         }
+        const poppyPrefix = personalAgents?.poppy?.prefix;
+        if (poppyPrefix &&
+            oidcMount &&
+            (poppyPrefix === oidcMount || poppyPrefix.startsWith(`${oidcMount}/`))) {
+            throw new Error(`authkit: personalAgents.poppy.prefix "${poppyPrefix}" não pode ficar debaixo do mountPath do OIDC ("${oidcMount}").`);
+        }
         // BACKSTOP DE SUDO. Um host cujo `sudo.methods` não tem um único método
         // satisfazível por conta sem senha fica bricado para TODA operação sob
         // `requireSudo` — e hoje isso só se descobre quando um usuário não consegue

package/build/src/host/account_api/account_api_controller.d.ts

@@ -159,7 +159,18 @@ export default class AccountApiController {
     }>;
     /** Personal agents com delegação ativa na conta (scopes aprovados). */
     listAgents(ctx: HttpContext): Promise<void | {
-        agents: import("../../agents/delegation_service.ts").DelegationGrantSummary[];
+        agents: {
+            id: string;
+            clientId: string;
+            scopes: {
+                id: string;
+                description: string;
+            }[];
+            createdAt: Date;
+            updatedAt: Date;
+            expiresAt: Date;
+            protocol: string;
+        }[];
     }>;
     /** Revoga a delegação de um personal agent (efeito imediato nos tokens). */
     revokeAgent(ctx: HttpContext): Promise<void | {

package/build/src/host/account_api/account_api_controller.js

@@ -617,20 +617,25 @@ export default class AccountApiController {
     /** Personal agents com delegação ativa na conta (scopes aprovados). */
     async listAgents(ctx) {
         const runtime = await personalAgentsFor(ctx);
-        if (!runtime?.delegation) {
+        if (!runtime?.delegation && !runtime?.poppy) {
             return ctx.response
                 .status(404)
                 .send(apiErr('capability_unsupported', 'Personal agent delegation is not enabled.'));
         }
         const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
-        const grants = await runtime.delegation.listGrants(userId);
-        return { agents: grants };
+        const pact = runtime.delegation
+            ? (await runtime.delegation.listGrants(userId)).map((g) => ({ ...g, protocol: 'pact' }))
+            : [];
+        const poppy = runtime.poppy
+            ? (await runtime.poppy.listGrants(userId)).map((g) => ({ ...g, protocol: 'poppy' }))
+            : [];
+        return { agents: [...pact, ...poppy] };
     }
     // ─── DELETE /account/api/agents/:id ──────────────────────────────────────
     /** Revoga a delegação de um personal agent (efeito imediato nos tokens). */
     async revokeAgent(ctx) {
         const runtime = await personalAgentsFor(ctx);
-        if (!runtime?.delegation) {
+        if (!runtime?.delegation && !runtime?.poppy) {
             return ctx.response
                 .status(404)
                 .send(apiErr('capability_unsupported', 'Personal agent delegation is not enabled.'));
@@ -638,7 +643,7 @@ export default class AccountApiController {
         const service = await ctx.containerResolver.make('authkit.server');
         const userId = ctx.session.get(ACCOUNT_SESSION_KEY);
         const grantId = ctx.request.param('id');
-        if (!(await runtime.delegation.revokeGrant(userId, grantId))) {
+        if (!(await runtime.revokeAgentGrant(userId, grantId))) {
             return ctx.response.status(404).send(apiErr('not_found', 'Grant not found.'));
         }
         await service.config.audit?.record({

package/build/src/host/admin_api/dto.d.ts

@@ -49,7 +49,7 @@ export declare function grantDto(grant: AdminGrant): {
 };
 export declare function auditDto(event: StoredAuditEvent): {
     id: string;
-    type: "account.deleted" | "account.expiration_warned" | "account.expired_login_blocked" | "account.exported" | "account.locked" | "account.signed_out_all" | "agent.delegation_approved" | "agent.delegation_denied" | "agent.grant_revoked" | "bot_protection.rejected" | "client.created" | "client.deleted" | "client.secret_regenerated" | "client.updated" | "email.change_requested" | "email.changed" | "email_change.cancelled" | "email_change.confirmed" | "email_change.requested" | "email_verification.consumed" | "email_verification.issued" | "grant.revoked_by_user" | "impersonation" | "impersonation.panel_viewed" | "impersonation.stopped" | "keys.rotated" | "login.failure" | "login.magic_link_sent" | "login.new_device" | "login.new_ip_notified" | "login.otp_failed" | "login.otp_invalidated" | "login.otp_sent" | "login.otp_verified" | "login.success" | "maintenance.disabled" | "maintenance.enabled" | "mfa.disabled" | "mfa.enabled" | "mfa.recovery_codes_regenerated" | "organization.created" | "organization.deactivated" | "organization.deleted" | "organization.invitation_accepted" | "organization.invitation_revoked" | "organization.invitation_sent" | "organization.member_added" | "organization.member_removed" | "organization.member_role_changed" | "organization.member_role_updated" | "organization.switched" | "organization.updated" | "otp.locked" | "otp.unlock_failed" | "otp.unlocked" | "passkey.registered" | "passkey.removed" | "password.changed" | "password.expired_change_forced" | "password.rehashed" | "password_reset.consumed" | "password_reset.issued" | "pat.issued" | "pat.revoked" | "pat.used" | "profile.updated" | "roles_catalog.updated" | "security_notice.sent" | "session.revoked" | "session.revoked_all" | "session.single_enforced" | "settings.updated" | "signup" | "sudo.confirmed" | "trusted_device.revoked" | "user.created" | "user.deleted" | "user.disabled" | "user.enabled" | "user.password_reset_sent";
+    type: "account.deleted" | "account.expiration_warned" | "account.expired_login_blocked" | "account.exported" | "account.locked" | "account.signed_out_all" | "agent.allowed" | "agent.blocked" | "agent.delegation_approved" | "agent.delegation_denied" | "agent.grant_revoked" | "agent.grant_revoked_by_admin" | "agent.registry_removed" | "bot_protection.rejected" | "client.created" | "client.deleted" | "client.secret_regenerated" | "client.updated" | "email.change_requested" | "email.changed" | "email_change.cancelled" | "email_change.confirmed" | "email_change.requested" | "email_verification.consumed" | "email_verification.issued" | "grant.revoked_by_user" | "impersonation" | "impersonation.panel_viewed" | "impersonation.stopped" | "keys.rotated" | "login.failure" | "login.magic_link_sent" | "login.new_device" | "login.new_ip_notified" | "login.otp_failed" | "login.otp_invalidated" | "login.otp_sent" | "login.otp_verified" | "login.success" | "maintenance.disabled" | "maintenance.enabled" | "mfa.disabled" | "mfa.enabled" | "mfa.recovery_codes_regenerated" | "organization.created" | "organization.deactivated" | "organization.deleted" | "organization.invitation_accepted" | "organization.invitation_revoked" | "organization.invitation_sent" | "organization.member_added" | "organization.member_removed" | "organization.member_role_changed" | "organization.member_role_updated" | "organization.switched" | "organization.updated" | "otp.locked" | "otp.unlock_failed" | "otp.unlocked" | "passkey.registered" | "passkey.removed" | "password.changed" | "password.expired_change_forced" | "password.rehashed" | "password_reset.consumed" | "password_reset.issued" | "pat.issued" | "pat.revoked" | "pat.used" | "profile.updated" | "roles_catalog.updated" | "security_notice.sent" | "session.revoked" | "session.revoked_all" | "session.single_enforced" | "settings.updated" | "signup" | "sudo.confirmed" | "trusted_device.revoked" | "user.created" | "user.deleted" | "user.disabled" | "user.enabled" | "user.password_reset_sent";
     accountId: string | null;
     email: string | null;
     clientId: string | null;

package/build/src/host/admin_console/admin_shell_controller.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
+import { accountPath } from '../account_paths.js';
 import { resolveAccountRoles } from '../account_roles.js';
 import { getAdminPrefix } from '../admin_prefix.js';
 // ─── Shell HTML cache ─────────────────────────────────────────────────────────
@@ -134,6 +135,12 @@ export default class AdminShellController {
             currentUser,
             endpoints: {
                 api: `${adminBase}/api`,
+                // Confirmação de identidade (sudo) das ações destrutivas.
+                confirm: accountPath('confirm'),
+            },
+            features: {
+                // A página de personal agents só aparece com `personalAgents` no config.
+                personalAgents: !!cfg.personalAgents,
             },
         };
         const { html: rawHtml } = await loadShell();