@adonis-agora/authkit-server 0.75.0 → 0.77.0

package/build/src/host/whatsapp_code_sender.d.ts

@@ -0,0 +1,20 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/** Provider-neutral delivery input. Only the host generates and verifies the OTP. */
+export interface WhatsappCodeInput {
+    phone: string;
+    code: string;
+    locale: string;
+    expiresInSeconds: number;
+    /** Optional host-localized copy for transports that send free-form messages. */
+    text?: string;
+}
+/** Implement this interface to support any WhatsApp provider. Reject on failed delivery. */
+export interface WhatsappCodeSender {
+    sendCode(input: WhatsappCodeInput): Promise<void>;
+}
+/** A configured instance, or an injectable class resolved by the request container. */
+export type WhatsappCodeSenderConstructor = new (...args: never[]) => WhatsappCodeSender;
+export type WhatsappCodeSenderBinding = WhatsappCodeSender | WhatsappCodeSenderConstructor;
+export declare function resolveWhatsappCodeSender(resolver: Pick<HttpContext['containerResolver'], 'make'>, binding: WhatsappCodeSenderBinding): Promise<WhatsappCodeSender>;
+export { MetaWhatsappCodeSender, type MetaWhatsappCodeSenderOptions, } from './whatsapp_senders/meta_whatsapp_code_sender.js';
+export { WhatsmiauCodeSender, type WhatsmiauCodeSenderOptions, } from './whatsapp_senders/whatsmiau_code_sender.js';

package/build/src/host/whatsapp_code_sender.js

@@ -0,0 +1,9 @@
+export async function resolveWhatsappCodeSender(resolver, binding) {
+    const sender = typeof binding === 'function' ? await resolver.make(binding) : binding;
+    if (!sender || typeof sender.sendCode !== 'function') {
+        throw new Error('Invalid WhatsApp code sender: expected sendCode(input)');
+    }
+    return sender;
+}
+export { MetaWhatsappCodeSender, } from './whatsapp_senders/meta_whatsapp_code_sender.js';
+export { WhatsmiauCodeSender, } from './whatsapp_senders/whatsmiau_code_sender.js';

package/build/src/host/whatsapp_senders/http.d.ts

@@ -0,0 +1,5 @@
+/** Never include configuration values in validation errors. */
+export declare function requireString(value: string, field: string): void;
+export declare function recipientPhone(phone: string): string;
+/** Response bodies and fetch causes can contain credentials and OTPs: discard both. */
+export declare function postJson(provider: string, url: URL, headers: Record<string, string>, body: unknown): Promise<void>;

package/build/src/host/whatsapp_senders/http.js

@@ -0,0 +1,33 @@
+/** Never include configuration values in validation errors. */
+export function requireString(value, field) {
+    if (typeof value !== 'string' || !value.trim() || /[\r\n]/.test(value)) {
+        throw new Error(`Invalid WhatsApp sender ${field}`);
+    }
+}
+export function recipientPhone(phone) {
+    if (typeof phone !== 'string' || !/^\+?[1-9]\d{6,14}$/.test(phone)) {
+        throw new Error('Invalid WhatsApp recipient phone');
+    }
+    return phone.replace(/^\+/, '');
+}
+/** Response bodies and fetch causes can contain credentials and OTPs: discard both. */
+export async function postJson(provider, url, headers, body) {
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+            redirect: 'error',
+        });
+    }
+    catch {
+        throw new Error(`WhatsApp code delivery failed (${provider})`);
+    }
+    // Do not parse or log the body, even when a provider echoes the submitted code.
+    void response.body?.cancel().catch(() => { });
+    if (!response.ok) {
+        throw new Error(`WhatsApp code delivery failed (${provider}, HTTP ${response.status})`);
+    }
+}

package/build/src/host/whatsapp_senders/meta_whatsapp_code_sender.d.ts

@@ -0,0 +1,20 @@
+import type { WhatsappCodeInput, WhatsappCodeSender } from '../whatsapp_code_sender.js';
+export interface MetaWhatsappCodeSenderOptions {
+    accessToken: string;
+    phoneNumberId: string;
+    /** Explicit supported Graph API version, for example v23.0. */
+    apiVersion: string;
+    /** An approved authentication template with an OTP URL button. */
+    templateName: string;
+    /** Overrides the host locale when the template uses a different language. */
+    languageCode?: string;
+}
+/** Meta Cloud API authentication template transport (copy-code / OTP URL button). */
+export declare class MetaWhatsappCodeSender implements WhatsappCodeSender {
+    private readonly accessToken;
+    private readonly endpoint;
+    private readonly templateName;
+    private readonly languageCode?;
+    constructor(options: MetaWhatsappCodeSenderOptions);
+    sendCode(input: WhatsappCodeInput): Promise<void>;
+}

package/build/src/host/whatsapp_senders/meta_whatsapp_code_sender.js

@@ -0,0 +1,51 @@
+import { postJson, recipientPhone, requireString } from './http.js';
+const LANGUAGE_CODES = { 'pt-BR': 'pt_BR', en: 'en_US', es: 'es' };
+/** Meta Cloud API authentication template transport (copy-code / OTP URL button). */
+export class MetaWhatsappCodeSender {
+    accessToken;
+    endpoint;
+    templateName;
+    languageCode;
+    constructor(options) {
+        requireString(options.accessToken, 'accessToken');
+        if (typeof options.apiVersion !== 'string' || !/^v\d+\.\d+$/.test(options.apiVersion)) {
+            throw new Error('Invalid WhatsApp sender apiVersion');
+        }
+        if (typeof options.phoneNumberId !== 'string' || !/^\d+$/.test(options.phoneNumberId)) {
+            throw new Error('Invalid WhatsApp sender phoneNumberId');
+        }
+        if (typeof options.templateName !== 'string' || !/^[a-z0-9_]+$/.test(options.templateName)) {
+            throw new Error('Invalid WhatsApp sender templateName');
+        }
+        if (options.languageCode !== undefined) {
+            requireString(options.languageCode, 'languageCode');
+        }
+        this.endpoint = new URL(`https://graph.facebook.com/${options.apiVersion}/${options.phoneNumberId}/messages`);
+        this.accessToken = options.accessToken;
+        this.templateName = options.templateName;
+        this.languageCode = options.languageCode;
+    }
+    async sendCode(input) {
+        await postJson('Meta', this.endpoint, { Authorization: `Bearer ${this.accessToken}` }, {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: recipientPhone(input.phone),
+            type: 'template',
+            template: {
+                name: this.templateName,
+                language: {
+                    code: this.languageCode ?? LANGUAGE_CODES[input.locale] ?? input.locale.replace(/-/g, '_'),
+                },
+                components: [
+                    { type: 'body', parameters: [{ type: 'text', text: input.code }] },
+                    {
+                        type: 'button',
+                        sub_type: 'url',
+                        index: '0',
+                        parameters: [{ type: 'text', text: input.code }],
+                    },
+                ],
+            },
+        });
+    }
+}

package/build/src/host/whatsapp_senders/whatsmiau_code_sender.d.ts

@@ -0,0 +1,14 @@
+import type { WhatsappCodeInput, WhatsappCodeSender } from '../whatsapp_code_sender.js';
+export interface WhatsmiauCodeSenderOptions {
+    apiKey: string;
+    instanceName: string;
+    /** Includes the API version path. Defaults to Whatsmiau Cloud's /v2 endpoint. */
+    baseUrl?: string;
+}
+/** Whatsmiau Cloud v2 / Evolution-compatible free-form text transport. */
+export declare class WhatsmiauCodeSender implements WhatsappCodeSender {
+    private readonly apiKey;
+    private readonly endpoint;
+    constructor(options: WhatsmiauCodeSenderOptions);
+    sendCode(input: WhatsappCodeInput): Promise<void>;
+}

package/build/src/host/whatsapp_senders/whatsmiau_code_sender.js

@@ -0,0 +1,36 @@
+import { postJson, recipientPhone, requireString } from './http.js';
+/** Whatsmiau Cloud v2 / Evolution-compatible free-form text transport. */
+export class WhatsmiauCodeSender {
+    apiKey;
+    endpoint;
+    constructor(options) {
+        requireString(options.apiKey, 'apiKey');
+        if (typeof options.instanceName !== 'string' ||
+            !/^[A-Za-z0-9_-]+$/.test(options.instanceName)) {
+            throw new Error('Invalid WhatsApp sender instanceName');
+        }
+        let baseUrl;
+        try {
+            baseUrl = new URL(options.baseUrl ?? 'https://api.whatsmiau.dev/v2');
+        }
+        catch {
+            throw new Error('Invalid WhatsApp sender baseUrl');
+        }
+        if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+            baseUrl.username ||
+            baseUrl.password ||
+            baseUrl.search ||
+            baseUrl.hash) {
+            throw new Error('Invalid WhatsApp sender baseUrl');
+        }
+        baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, '')}/message/sendText/${options.instanceName}`;
+        this.endpoint = baseUrl;
+        this.apiKey = options.apiKey;
+    }
+    async sendCode(input) {
+        await postJson('Whatsmiau', this.endpoint, { apikey: this.apiKey }, {
+            number: recipientPhone(input.phone),
+            text: input.text ?? input.code,
+        });
+    }
+}

package/build/src/mcp/mcp_oauth.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Login OAuth de clientes MCP (Claude Code, Claude, ChatGPT, VS Code, Cursor) — a autorização da
+ * spec do MCP: OAuth 2.1 com PKCE, registro dinâmico (RFC 7591), metadata do servidor de
+ * autorização (RFC 8414) e o token amarrado ao servidor MCP pelo `resource` (RFC 8707).
+ *
+ * `mcp: true` na config liga tudo de uma vez:
+ *   - o registro dinâmico ABERTO, restrito aos redirects dos clientes MCP conhecidos
+ *     ({@link MCP_CLIENT_REDIRECTS}) — loopback para os de linha de comando;
+ *   - o refresh token desses clientes: o registro pede `offline_access` e o authorize ganha
+ *     `prompt=consent` (OIDC Core §11), então a pessoa consente uma vez e o cliente não precisa
+ *     logar de novo a cada hora;
+ *   - os `resource` dos servidores MCP: os de `mcp.resources` e os REGISTRADOS em runtime
+ *     ({@link registerOAuthResource}) — é por aí que o MCP do `@adonis-agora/agent` se anuncia
+ *     sem o app listar a URL dele aqui.
+ *
+ * Os clientes registrados pelo `/reg` se distinguem pelo `client_id_issued_at`, que só o registro
+ * dinâmico grava: clients estáticos ou criados pelo console/CLI não mudam de comportamento.
+ */
+import type { RedirectUriPolicy, ResolvedRedirectUriPolicy } from '../provider/registration_policy.js';
+/** Callbacks dos clientes MCP conhecidos. Loopback (Claude Code, CLIs) já entra pela política. */
+export declare const MCP_CLIENT_REDIRECTS: Required<RedirectUriPolicy>;
+/** Escopos de um token de servidor MCP: identidade + refresh. */
+export declare const MCP_RESOURCE_SCOPES: string[];
+export interface McpOAuthConfigInput {
+    /**
+     * Redirects aceitos ALÉM dos clientes MCP conhecidos — ex.: o callback de um cliente próprio.
+     * Somados a {@link MCP_CLIENT_REDIRECTS}.
+     */
+    redirectUris?: RedirectUriPolicy;
+    /**
+     * URLs dos servidores MCP para os quais este IdP emite tokens, além dos que se registram em
+     * runtime ({@link registerOAuthResource}). Ex.: `['https://app.example.com/mcp']`.
+     */
+    resources?: string[];
+}
+export interface ResolvedMcpOAuthConfig {
+    enabled: boolean;
+    redirectUriPolicy: ResolvedRedirectUriPolicy;
+    resources: string[];
+}
+export declare function resolveMcpOAuth(input?: boolean | McpOAuthConfigInput): ResolvedMcpOAuthConfig;
+/**
+ * Um servidor protegido (RFC 9728) que aceita tokens deste IdP. `url` é o `resource` exato; sem
+ * ela, `path` casa com qualquer `resource` na origem do issuer (quem registra no boot nem sempre
+ * sabe a URL pública).
+ */
+export interface OAuthResourceRegistration {
+    url?: string;
+    path?: string;
+    /** Escopos do token para este resource. Default: {@link MCP_RESOURCE_SCOPES}. */
+    scopes?: string[];
+}
+export declare function registerOAuthResource(resource: OAuthResourceRegistration): void;
+export declare function registeredOAuthResources(): readonly OAuthResourceRegistration[];
+/**
+ * O resource MCP que `indicator` nomeia, ou `null`. Casa com `mcp.resources`, com uma URL
+ * registrada, ou com um `path` registrado na origem do issuer. Barra final tolerada.
+ */
+export declare function findMcpResource(indicator: string, issuer: string, config: ResolvedMcpOAuthConfig): {
+    audience: string;
+    scopes: string[];
+} | null;
+/**
+ * Registro de um cliente MCP: quem pede `refresh_token` ganha `openid offline_access` no escopo
+ * registrado, senão o provider recusaria pedi-los no authorize.
+ */
+export declare function mcpClientRegistration(metadata: Record<string, unknown>): Record<string, unknown>;
+/**
+ * `scope`/`prompt` do authorize de um cliente MCP para que saia um refresh token: `offline_access`
+ * no escopo e `consent` no prompt (sem ele o provider descarta o `offline_access`). `null` quando
+ * já estão lá. `prompt=none` pede "sem interação", o contrário de consentir: sai.
+ */
+export declare function withOfflineAccess(params: Record<string, unknown>): {
+    scope: string;
+    prompt: string;
+} | null;
+/**
+ * Middleware do provider (Koa) que aplica {@link withOfflineAccess} ao `GET /auth` de um client
+ * registrado dinamicamente que tem o grant `refresh_token`.
+ */
+export declare function mcpAuthorizeMiddleware(provider: {
+    Client: {
+        find(id: string): Promise<any>;
+    };
+}): (ctx: any, next: () => Promise<void>) => Promise<void>;

package/build/src/mcp/mcp_oauth.js

@@ -0,0 +1,154 @@
+import { resolveRedirectUriPolicy } from '../provider/registration_policy.js';
+/** Callbacks dos clientes MCP conhecidos. Loopback (Claude Code, CLIs) já entra pela política. */
+export const MCP_CLIENT_REDIRECTS = {
+    loopback: true,
+    exact: [
+        'https://claude.ai/api/mcp/auth_callback',
+        'https://claude.com/api/mcp/auth_callback',
+        'https://chatgpt.com/connector_platform_oauth_redirect',
+        'https://vscode.dev/redirect',
+        'https://insiders.vscode.dev/redirect',
+    ],
+    appSchemes: ['cursor', 'vscode', 'vscode-insiders'],
+    anyHttps: false,
+};
+/** Escopos de um token de servidor MCP: identidade + refresh. */
+export const MCP_RESOURCE_SCOPES = ['openid', 'profile', 'email', 'offline_access'];
+export function resolveMcpOAuth(input) {
+    const options = typeof input === 'object' ? input : {};
+    const extra = options.redirectUris ?? {};
+    return {
+        enabled: input === true || typeof input === 'object',
+        redirectUriPolicy: resolveRedirectUriPolicy({
+            loopback: extra.loopback ?? MCP_CLIENT_REDIRECTS.loopback,
+            exact: [...new Set([...MCP_CLIENT_REDIRECTS.exact, ...(extra.exact ?? [])])],
+            appSchemes: [...new Set([...MCP_CLIENT_REDIRECTS.appSchemes, ...(extra.appSchemes ?? [])])],
+            anyHttps: extra.anyHttps ?? MCP_CLIENT_REDIRECTS.anyHttps,
+        }),
+        resources: [...(options.resources ?? [])],
+    };
+}
+/**
+ * Registro em runtime — um slot global, para que outra lib (o MCP do `@adonis-agora/agent`) se
+ * registre sem importar esta: o contrato é o símbolo, não o módulo.
+ */
+const REGISTRY = Symbol.for('@adonis-agora/oauth:resources');
+function registry() {
+    const slot = globalThis;
+    if (!Array.isArray(slot[REGISTRY]))
+        slot[REGISTRY] = [];
+    return slot[REGISTRY];
+}
+export function registerOAuthResource(resource) {
+    if (!resource.url && !resource.path) {
+        throw new Error('authkit: registerOAuthResource precisa de `url` ou `path`.');
+    }
+    registry().push({ ...resource });
+}
+export function registeredOAuthResources() {
+    return registry();
+}
+const trim = (value) => value.replace(/\/+$/, '');
+function normalizePath(path) {
+    return `/${path.replace(/^\/+|\/+$/g, '')}`;
+}
+/**
+ * O resource MCP que `indicator` nomeia, ou `null`. Casa com `mcp.resources`, com uma URL
+ * registrada, ou com um `path` registrado na origem do issuer. Barra final tolerada.
+ */
+export function findMcpResource(indicator, issuer, config) {
+    if (!config.enabled)
+        return null;
+    let url;
+    try {
+        url = new URL(indicator);
+    }
+    catch {
+        return null;
+    }
+    const wanted = trim(url.href);
+    for (const declared of config.resources) {
+        if (trim(declared) === wanted)
+            return { audience: trim(declared), scopes: MCP_RESOURCE_SCOPES };
+    }
+    const issuerOrigin = new URL(issuer).origin;
+    for (const resource of registeredOAuthResources()) {
+        const scopes = resource.scopes ?? MCP_RESOURCE_SCOPES;
+        if (resource.url && trim(resource.url) === wanted)
+            return { audience: trim(resource.url), scopes };
+        if (resource.path &&
+            url.origin === issuerOrigin &&
+            trim(url.pathname) === normalizePath(resource.path) &&
+            !url.search) {
+            return { audience: wanted, scopes };
+        }
+    }
+    return null;
+}
+/**
+ * Registro de um cliente MCP: quem pede `refresh_token` ganha `openid offline_access` no escopo
+ * registrado, senão o provider recusaria pedi-los no authorize.
+ */
+export function mcpClientRegistration(metadata) {
+    const grants = Array.isArray(metadata.grant_types)
+        ? metadata.grant_types
+        : ['authorization_code'];
+    if (!grants.includes('refresh_token') || typeof metadata.scope !== 'string')
+        return metadata;
+    const scopes = metadata.scope.split(' ').filter(Boolean);
+    for (const needed of ['openid', 'offline_access']) {
+        if (!scopes.includes(needed))
+            scopes.push(needed);
+    }
+    return { ...metadata, scope: scopes.join(' ') };
+}
+/**
+ * `scope`/`prompt` do authorize de um cliente MCP para que saia um refresh token: `offline_access`
+ * no escopo e `consent` no prompt (sem ele o provider descarta o `offline_access`). `null` quando
+ * já estão lá. `prompt=none` pede "sem interação", o contrário de consentir: sai.
+ */
+export function withOfflineAccess(params) {
+    const scopes = String(params.scope ?? '')
+        .split(' ')
+        .filter(Boolean);
+    const prompts = String(params.prompt ?? '')
+        .split(' ')
+        .filter(Boolean);
+    const needsScope = !scopes.includes('offline_access');
+    const needsPrompt = !prompts.includes('consent');
+    if (!needsScope && !needsPrompt)
+        return null;
+    if (!scopes.includes('openid'))
+        scopes.unshift('openid');
+    if (needsScope)
+        scopes.push('offline_access');
+    const prompt = needsPrompt ? [...prompts.filter((p) => p !== 'none'), 'consent'] : prompts;
+    return { scope: scopes.join(' '), prompt: prompt.join(' ') };
+}
+/**
+ * Middleware do provider (Koa) que aplica {@link withOfflineAccess} ao `GET /auth` de um client
+ * registrado dinamicamente que tem o grant `refresh_token`.
+ */
+export function mcpAuthorizeMiddleware(provider) {
+    return async (ctx, next) => {
+        if (ctx.method !== 'GET' || ctx.path !== '/auth')
+            return next();
+        const query = ctx.query;
+        const clientId = typeof query.client_id === 'string' ? query.client_id : '';
+        if (!clientId || (query.response_type !== undefined && query.response_type !== 'code')) {
+            return next();
+        }
+        const client = await provider.Client.find(clientId).catch(() => undefined);
+        const metadata = client?.metadata?.() ?? {};
+        const grants = metadata.grant_types;
+        if (metadata.client_id_issued_at === undefined ||
+            !Array.isArray(grants) ||
+            !grants.includes('refresh_token')) {
+            return next();
+        }
+        const widened = withOfflineAccess(query);
+        if (widened)
+            ctx.query = { ...query, ...widened };
+        return next();
+    };
+}

package/build/src/provider/build_provider.js

@@ -2,6 +2,7 @@ import * as oidc from 'oidc-provider';
 import { pickModelAdapterClass } from '../adapters/factory.js';
 import { normalizeActiveOrg, readActiveOrgFromKoaCtx } from '../host/active_org_cookie.js';
 import { assertClientMetadata } from '../host/client_metadata.js';
+import { findMcpResource, mcpAuthorizeMiddleware } from '../mcp/mcp_oauth.js';
 import { createDeviceSources } from './device_sources.js';
 import { createLogoutSources } from './logout_sources.js';
 import { registrationPolicyMiddleware } from './registration_policy.js';
@@ -77,7 +78,8 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
         const key = declaredResources.find((k) => k.replace(/\/+$/, '') === trimmed);
         return key ? { key, rc: at.resources[key] } : null;
     };
-    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0
+    const mcp = config.mcp;
+    const resourceIndicatorFeatures = at.anyJwt || declaredResources.length > 0 || mcp.enabled
         ? {
             resourceIndicators: {
                 enabled: true,
@@ -94,6 +96,15 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
                 getResourceServerInfo: (_ctx, resourceIndicator, _client) => {
                     const found = findResource(resourceIndicator);
                     const isDefault = at.anyJwt && resourceIndicator === at.audience;
+                    // Servidores MCP (`mcp`): os declarados e os registrados em runtime.
+                    const mcpResource = found || isDefault ? null : findMcpResource(resourceIndicator, config.issuer, mcp);
+                    if (mcpResource) {
+                        return {
+                            scope: mcpResource.scopes.join(' '),
+                            audience: mcpResource.audience,
+                            accessTokenFormat: 'opaque',
+                        };
+                    }
                     if (!found && !isDefault) {
                         throw new oidc.errors.InvalidTarget(`resource indicator not allowed: ${resourceIndicator}`);
                     }
@@ -341,6 +352,9 @@ export function buildProvider(config, options, sessionTtlHolder, tokenTtlHolder)
             validate: dynReg.validateRegistration,
         }));
     }
+    // Refresh token dos clientes MCP registrados dinamicamente (ver mcp/mcp_oauth.ts).
+    if (mcp.enabled)
+        provider.use(mcpAuthorizeMiddleware(provider));
     provider.proxy = true;
     return provider;
 }

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

@@ -17,6 +17,14 @@ export declare class OidcService {
     get publicJwks(): {
         keys: Record<string, any>[];
     };
+    /**
+     * @internal JWKS PRIVADO em uso (mesmas chaves do `publicJwks`). Só para quem
+     * assina in-process com o keystore do IdP — tokens de delegação e recibos de
+     * personal agents. Troca junto com o provider numa rotação.
+     */
+    get signingJwks(): {
+        keys: Record<string, any>[];
+    };
     /** Pathname do issuer sem barra final (ex.: `/oidc`). Vazio quando montado na raiz. */
     readonly mountPath: string;
     readonly recorder: MetricsRecorder;

package/build/src/provider/oidc_service.js

@@ -14,6 +14,7 @@ export class OidcService {
     #callback;
     #interactions;
     #publicJwks;
+    #signingJwks;
     #appKey;
     get provider() {
         return this.#provider;
@@ -32,6 +33,14 @@ export class OidcService {
     get publicJwks() {
         return this.#publicJwks;
     }
+    /**
+     * @internal JWKS PRIVADO em uso (mesmas chaves do `publicJwks`). Só para quem
+     * assina in-process com o keystore do IdP — tokens de delegação e recibos de
+     * personal agents. Troca junto com o provider numa rotação.
+     */
+    get signingJwks() {
+        return this.#signingJwks;
+    }
     /** Pathname do issuer sem barra final (ex.: `/oidc`). Vazio quando montado na raiz. */
     mountPath;
     recorder;
@@ -128,8 +137,12 @@ export class OidcService {
                     claims: async (_use, _scope) => {
                         const base = {
                             sub: user.id,
-                            email: user.email,
-                            email_verified: true,
+                            ...(user.email
+                                ? {
+                                    email: user.email,
+                                    email_verified: (await config.accountStore.isEmailVerified?.(user.id)) ?? false,
+                                }
+                                : {}),
                             name: user.name,
                             picture: user.avatarUrl,
                         };
@@ -216,6 +229,7 @@ export class OidcService {
         this.#callback = callback;
         this.#interactions = interactions;
         this.#publicJwks = toPublicJwks(jwks);
+        this.#signingJwks = jwks;
     }
     /**
      * Recarrega as chaves de assinatura AO VIVO: relê o keystore do cofre e reconstrói

package/build/src/schema/ensure.js

@@ -203,6 +203,98 @@ const TABLES = [
             updated_at: (t) => t.timestamp('updated_at', { useTz: true }).nullable(),
         },
     },
+    /*
+     * As três tabelas de personal agents usam `dateTime(…, precision 3)` e não
+     * `timestamp`: no MySQL o TIMESTAMP sem fração arredonda o `last_polled_at`
+     * (um agente que respeita o `interval` levaria `slow_down`) e, com
+     * `explicit_defaults_for_timestamp=OFF`, o primeiro TIMESTAMP NOT NULL da
+     * tabela ganha `ON UPDATE CURRENT_TIMESTAMP` — marcar um refresh como usado
+     * reescreveria a validade dele. DATETIME não tem nenhum dos dois; no Postgres
+     * vira o mesmo `timestamptz`.
+     */
+    {
+        name: 'auth_agent_device_codes',
+        /**
+         * Pedidos de delegação de personal agents (device flow, RFC 8628). O
+         * `device_code` só existe como hash; o `user_code` é o que o usuário vê.
+         * Linhas expiradas são apagadas no próximo pedido.
+         */
+        create: (t) => {
+            t.string('id').primary();
+            t.string('device_code_hash', 64).notNullable().unique();
+            t.string('user_code', 16).notNullable().unique();
+            t.string('client_id', 2048).notNullable();
+            t.string('agent_sub').notNullable();
+            t.text('requested_scope').notNullable();
+            t.string('status', 16).notNullable();
+            t.string('account_id').nullable();
+            t.string('grant_id').nullable();
+            t.integer('interval_seconds').notNullable();
+            t.dateTime('last_polled_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable().index();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            device_code_hash: (t) => t.string('device_code_hash', 64),
+            user_code: (t) => t.string('user_code', 16),
+            client_id: (t) => t.string('client_id', 2048),
+            agent_sub: (t) => t.string('agent_sub'),
+            requested_scope: (t) => t.text('requested_scope'),
+            status: (t) => t.string('status', 16),
+            account_id: (t) => t.string('account_id').nullable(),
+            grant_id: (t) => t.string('grant_id').nullable(),
+            interval_seconds: (t) => t.integer('interval_seconds'),
+            last_polled_at: (t) => t.dateTime('last_polled_at', { useTz: true, precision: 3 }).nullable(),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
+    {
+        name: 'auth_agent_grants',
+        /**
+         * O que um usuário autorizou um personal agent a fazer na conta dele: um
+         * grant por (conta, agente, usuário do agente); aprovar mais scopes soma.
+         * `revoked_at` preenchido = revogado (os tokens param na próxima request).
+         */
+        create: (t) => {
+            t.string('id').primary();
+            t.string('account_id').notNullable().index();
+            t.string('client_id', 2048).notNullable();
+            t.string('agent_sub').notNullable();
+            t.text('scope').notNullable();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('revoked_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('updated_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            account_id: (t) => t.string('account_id'),
+            client_id: (t) => t.string('client_id', 2048),
+            agent_sub: (t) => t.string('agent_sub'),
+            scope: (t) => t.text('scope'),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            revoked_at: (t) => t.dateTime('revoked_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+            updated_at: (t) => t.dateTime('updated_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
+    {
+        name: 'auth_agent_refresh_tokens',
+        /** Refresh tokens dos grants de personal agents — só o hash, uso único. */
+        create: (t) => {
+            t.string('token_hash', 64).primary();
+            t.string('grant_id').notNullable().index();
+            t.dateTime('expires_at', { useTz: true, precision: 3 }).notNullable();
+            t.dateTime('used_at', { useTz: true, precision: 3 }).nullable();
+            t.dateTime('created_at', { useTz: true, precision: 3 }).notNullable();
+        },
+        columns: {
+            grant_id: (t) => t.string('grant_id').index(),
+            expires_at: (t) => t.dateTime('expires_at', { useTz: true, precision: 3 }).nullable(),
+            used_at: (t) => t.dateTime('used_at', { useTz: true, precision: 3 }).nullable(),
+            created_at: (t) => t.dateTime('created_at', { useTz: true, precision: 3 }).nullable(),
+        },
+    },
 ];
 /**
  * Probe searchPath-aware: `schema.hasTable` no Postgres ignora o