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

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

@@ -1,4 +1,5 @@
 import type { HttpContext } from '@adonisjs/core/http';
+import type { ResolvedPersonalAgentExtension } from '../agents/extension.js';
 import type { AuthSocialConfig, ResolvedRateLimitConfig } from '../define_config.js';
 import type { PolicyRouteOption } from './config_locks.js';
 import type { AuthHostOptions } from './register_auth_host.js';
@@ -35,10 +36,13 @@ export interface AuthHostRuntimeConfig {
      * Ver `deriveLockedRouteOptions`.
      */
     lockedRouteOptions?: PolicyRouteOption[];
-    /** Personal agents ligados → prefixo das rotas deles (`/agents`) e do Poppy (`/poppy`). */
+    /**
+     * Personal agents ligados → prefixo das rotas do PACT (`/agents`) e as
+     * `personalAgents.extensions` resolvidas (rotas, isenções de CSRF, navegador do agente).
+     */
     personalAgents?: {
         prefix: string;
-        poppyPrefix?: string;
+        extensions?: readonly ResolvedPersonalAgentExtension[];
     };
     /**
      * `accountSession.acceptIdpSession: false` com `authMethods: { password: false }`:

package/build/src/host/controllers/account_apps_controller.js

@@ -38,16 +38,19 @@ export default class AccountAppsController {
                 scopes: g.scopes,
             })))
             : null;
-        // Refresh tokens do Poppy: o agente é desconectado pela mesma lista (§5.5).
-        const poppy = agentsRuntime?.poppy;
-        const poppyAgents = poppy
-            ? await Promise.all((await poppy.listGrants(accountId)).map(async (g) => ({
-                id: g.id,
-                name: await poppy.registry.displayName(g.clientId),
-                scopes: g.scopes,
-            })))
-            : null;
-        const agents = pactAgents || poppyAgents ? [...(pactAgents ?? []), ...(poppyAgents ?? [])] : null;
+        // Conexões das `personalAgents.extensions`: desconectadas pela mesma lista.
+        let extensionAgents = null;
+        for (const { runtime } of agentsRuntime?.extensions.values() ?? []) {
+            extensionAgents ??= [];
+            for (const g of await runtime.listAccountGrants(accountId)) {
+                extensionAgents.push({
+                    id: g.id,
+                    name: await runtime.displayName(g.clientId),
+                    scopes: g.scopes,
+                });
+            }
+        }
+        const agents = pactAgents || extensionAgents ? [...(pactAgents ?? []), ...(extensionAgents ?? [])] : null;
         return render(ctx, 'account/apps', {
             csrfToken: ctx.request.csrfToken,
             supported,
@@ -89,8 +92,9 @@ export default class AccountAppsController {
     /** POST /account/apps/agents/:grantId/revoke — revoga a delegação de um personal agent. */
     async revokeAgent(ctx) {
         const runtime = await personalAgentsFor(ctx);
-        if (!runtime?.delegation && !runtime?.poppy)
+        if (!runtime || (!runtime.delegation && runtime.extensions.size === 0)) {
             return ctx.response.notFound();
+        }
         const service = await ctx.containerResolver.make('authkit.server');
         const cfg = service.config;
         const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);

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

@@ -11,10 +11,10 @@ export interface AuthkitCsrfOptions {
      */
     personalAgentsPrefix?: string | false;
     /**
-     * Prefixo do Poppy: isenta token/revoke/device authorization e a entrada do navegador
-     * (o código com o cookie `SameSite=Strict` é o que protege, §6).
+     * Isenta os `csrfExemptPaths` das `personalAgents.extensions` do config. Default: true.
+     * `false` desliga.
      */
-    poppyPrefix?: string | false;
+    personalAgentExtensions?: boolean;
 }
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF

package/build/src/host/csrf.js

@@ -16,7 +16,6 @@
  * ```
  */
 import { normalizePersonalAgentsPrefix } from '../agents/config.js';
-import { normalizePoppyPrefix } from '../agents/poppy/config.js';
 import { getAuthHostConfig } from './auth_host_config.js';
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
@@ -34,21 +33,12 @@ export function authkitCsrfExceptions(url, options = {}) {
             ? normalizePersonalAgentsPrefix(options.personalAgentsPrefix)
             : getAuthHostConfig()?.personalAgents?.prefix;
     const agentsOAuth = agentsPrefix ? `${agentsPrefix}/oauth/` : null;
-    const poppyPrefix = options.poppyPrefix === false
-        ? undefined
-        : options.poppyPrefix !== undefined
-            ? normalizePoppyPrefix(options.poppyPrefix)
-            : getAuthHostConfig()?.personalAgents?.poppyPrefix;
     const path = url.split('?')[0];
-    const poppyExempt = !!poppyPrefix &&
-        (path === `${poppyPrefix}/oauth/token` ||
-            path === `${poppyPrefix}/oauth/revoke` ||
-            path === `${poppyPrefix}/oauth/device` ||
-            path === `${poppyPrefix}/browser-session` ||
-            path === `${poppyPrefix}/browser-session/authorize`);
+    const extensionExempt = options.personalAgentExtensions !== false &&
+        (getAuthHostConfig()?.personalAgents?.extensions ?? []).some((e) => e.csrfExemptPaths?.includes(path));
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
         (backchannel !== null && url === backchannel) ||
         (agentsOAuth !== null && url.startsWith(agentsOAuth)) ||
-        poppyExempt);
+        extensionExempt);
 }

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

@@ -67,15 +67,20 @@ export declare function sendMagicLinkEmail(ctx: HttpContext, data: {
     channel?: 'code' | 'link';
 }): Promise<void>;
 /**
- * Envia o código do Mediated Sign-In pronto do Poppy (`poppyEmailCodeSignIn`) pelo
- * mailer default do host. Só código, sem link: quem digita é a pessoa, no agente.
- * Best-effort: no fallback (sem mail) loga o código, como o magic link loga o link; nunca lança.
+ * Envia um e-mail só com um código (sem link: quem digita é a pessoa, em outro lugar) pelo mailer
+ * default do host, com o branding e o i18n do authkit. Os textos saem do catálogo pelas chaves
+ * `{messages}.subject`, `.heading`, `.intro`, `.code_label` e `.fallback`, com `params`
+ * interpolados — uma extension registra as dela em `messages`. Best-effort: sem `@adonisjs/mail`
+ * loga o código (dev); nunca lança.
+ *
+ * Estável no 1.x (é o mailer das `personalAgents.extensions`).
  */
-export declare function sendPoppySignInCodeEmail(ctx: HttpContext, data: {
+export declare function sendAuthkitCodeEmail(ctx: HttpContext, data: {
     email: string;
     code: string;
-    agentName: string;
-    expiresInMinutes: number;
+    /** Prefixo das chaves no catálogo (`'mail.poppy_sign_in'`). */
+    messages: string;
+    params?: Record<string, string | number>;
 }): Promise<void>;
 /**
  * Envia o link de CONFIRMAÇÃO DE IDENTIDADE (sudo) pelo mailer default do host.

package/build/src/host/default_mailer.js

@@ -295,32 +295,36 @@ export async function sendMagicLinkEmail(ctx, data) {
     }
 }
 /**
- * Envia o código do Mediated Sign-In pronto do Poppy (`poppyEmailCodeSignIn`) pelo
- * mailer default do host. Só código, sem link: quem digita é a pessoa, no agente.
- * Best-effort: no fallback (sem mail) loga o código, como o magic link loga o link; nunca lança.
+ * Envia um e-mail só com um código (sem link: quem digita é a pessoa, em outro lugar) pelo mailer
+ * default do host, com o branding e o i18n do authkit. Os textos saem do catálogo pelas chaves
+ * `{messages}.subject`, `.heading`, `.intro`, `.code_label` e `.fallback`, com `params`
+ * interpolados — uma extension registra as dela em `messages`. Best-effort: sem `@adonisjs/mail`
+ * loga o código (dev); nunca lança.
+ *
+ * Estável no 1.x (é o mailer das `personalAgents.extensions`).
  */
-export async function sendPoppySignInCodeEmail(ctx, data) {
+export async function sendAuthkitCodeEmail(ctx, data) {
     try {
         const brand = resolveBrand(ctx);
         const { messages: t, locale } = resolveMailMessages(ctx);
-        const params = { agent: data.agentName, minutes: data.expiresInMinutes };
+        const key = (name) => `${data.messages}.${name}`;
         const content = renderTransactionalEmail({
             brand,
             locale,
-            subject: translate(t, 'mail.poppy_sign_in.subject', params),
-            heading: translate(t, 'mail.poppy_sign_in.heading', params),
-            intro: translate(t, 'mail.poppy_sign_in.intro', params),
-            footnote: translate(t, 'mail.poppy_sign_in.fallback'),
+            subject: translate(t, key('subject'), data.params),
+            heading: translate(t, key('heading'), data.params),
+            intro: translate(t, key('intro'), data.params),
+            footnote: translate(t, key('fallback'), data.params),
             code: data.code,
-            codeLabel: translate(t, 'mail.poppy_sign_in.code_label'),
+            codeLabel: translate(t, key('code_label'), data.params),
         });
         const sent = await sendEmail(ctx, data.email, content);
         if (!sent) {
-            ctx.logger.info({ email: data.email, agent: data.agentName, code: data.code }, 'authkit: código do Poppy Mediated Sign-In (dev — @adonisjs/mail ausente)');
+            ctx.logger.info({ email: data.email, code: data.code, messages: data.messages, ...(data.params ?? {}) }, 'authkit: código por e-mail (dev — @adonisjs/mail ausente)');
         }
     }
     catch (error) {
-        ctx.logger.error({ err: error, email: data.email }, 'authkit: falha ao enviar o código do Poppy Mediated Sign-In');
+        ctx.logger.error({ err: error, email: data.email, messages: data.messages }, 'authkit: falha ao enviar o e-mail com código');
     }
 }
 /**

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

@@ -560,11 +560,6 @@ export declare const DEFAULT_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
-    'mail.poppy_sign_in.subject': string;
-    'mail.poppy_sign_in.heading': string;
-    'mail.poppy_sign_in.intro': string;
-    'mail.poppy_sign_in.code_label': string;
-    'mail.poppy_sign_in.fallback': string;
     'mail.sudo_link.subject': string;
     'mail.sudo_link.heading': string;
     'mail.sudo_link.intro': string;
@@ -1318,11 +1313,6 @@ export declare const PT_BR_MESSAGES: {
     'mail.magic_link.code_subject': string;
     'mail.magic_link.code_intro': string;
     'mail.magic_link.code_only_label': string;
-    'mail.poppy_sign_in.subject': string;
-    'mail.poppy_sign_in.heading': string;
-    'mail.poppy_sign_in.intro': string;
-    'mail.poppy_sign_in.code_label': string;
-    'mail.poppy_sign_in.fallback': string;
     'mail.sudo_link.subject': string;
     'mail.sudo_link.heading': string;
     'mail.sudo_link.intro': string;
@@ -1547,11 +1537,10 @@ export declare const PT_BR_MESSAGES: {
  */
 export declare const BUILTIN_MESSAGES: Record<string, AuthMessages>;
 /**
- * Resolve o catálogo ativo. Começa do catálogo embutido do locale selecionado
- * (ou do default `en` quando o locale não é embutido), depois mescla os
- * overrides do host por cima. Sem config, retorna o default `en` intacto.
- * Chaves omitidas caem no default `en` (fallback de cobertura).
+ * Soma os catálogos de uma extension (`messages`) aos embutidos. Chamado quando o config resolve;
+ * os overrides do host (`i18n.messages`) continuam vencendo.
  */
+export declare function registerExtensionMessages(catalogs: Readonly<Record<string, Readonly<Record<string, string>>>>): void;
 export declare function resolveMessages(i18n?: I18nConfig): AuthMessages;
 /**
  * Retorna a string para `key` (cai na própria `key` quando ausente) com

package/build/src/host/i18n.js

@@ -603,12 +603,6 @@ export const DEFAULT_MESSAGES = {
     'mail.magic_link.code_subject': 'Your login code',
     'mail.magic_link.code_intro': 'Use the code below to sign in. It expires shortly and can be used once.',
     'mail.magic_link.code_only_label': 'Enter this code to sign in:',
-    // Código do Mediated Sign-In do Poppy: um personal agent pede para entrar na conta.
-    'mail.poppy_sign_in.subject': 'Your code to connect {agent}',
-    'mail.poppy_sign_in.heading': 'Connect {agent} to your account',
-    'mail.poppy_sign_in.intro': '{agent} asked to sign in to your account. If that was you, give it the code below. It expires in {minutes} minutes and works once.',
-    'mail.poppy_sign_in.code_label': 'Your code:',
-    'mail.poppy_sign_in.fallback': 'If you did not ask for this, ignore this email — nobody gets in without the code. Never share it with anyone else.',
     // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo). Copy DISTINTA da do magic link de
     // login de propósito: este link não autentica ninguém — quem o abre já está
     // logado e só reprova que é quem diz ser. Prometer "entre na sua conta" num
@@ -1447,12 +1441,6 @@ export const PT_BR_MESSAGES = {
     'mail.magic_link.code_subject': 'Seu código de login',
     'mail.magic_link.code_intro': 'Use o código abaixo para entrar. Ele expira em instantes e serve para um único acesso.',
     'mail.magic_link.code_only_label': 'Digite este código para entrar:',
-    // Código do Mediated Sign-In do Poppy — ver o comentário no catálogo `en`.
-    'mail.poppy_sign_in.subject': 'Seu código para conectar {agent}',
-    'mail.poppy_sign_in.heading': 'Conecte {agent} à sua conta',
-    'mail.poppy_sign_in.intro': '{agent} pediu para entrar na sua conta. Se foi você, informe o código abaixo. Ele expira em {minutes} minutos e serve uma única vez.',
-    'mail.poppy_sign_in.code_label': 'Seu código:',
-    'mail.poppy_sign_in.fallback': 'Se não foi você, ignore este e-mail — ninguém entra sem o código. Nunca o compartilhe com outra pessoa.',
     // Link de CONFIRMAÇÃO DE IDENTIDADE (sudo) — ver o comentário no catálogo `en`.
     'mail.sudo_link.subject': 'Confirme que é você',
     'mail.sudo_link.heading': 'Confirme sua identidade',
@@ -1713,13 +1701,27 @@ export const BUILTIN_MESSAGES = {
  * overrides do host por cima. Sem config, retorna o default `en` intacto.
  * Chaves omitidas caem no default `en` (fallback de cobertura).
  */
+/** Catálogos das `personalAgents.extensions`, por locale (ver {@link registerExtensionMessages}). */
+const extensionMessages = {};
+/**
+ * Soma os catálogos de uma extension (`messages`) aos embutidos. Chamado quando o config resolve;
+ * os overrides do host (`i18n.messages`) continuam vencendo.
+ */
+export function registerExtensionMessages(catalogs) {
+    for (const [locale, messages] of Object.entries(catalogs)) {
+        extensionMessages[locale] = { ...(extensionMessages[locale] ?? {}), ...messages };
+    }
+}
 export function resolveMessages(i18n) {
     const locale = i18n?.locale ?? DEFAULT_LOCALE;
     // Base: sempre o default `en` para garantir cobertura total das chaves; o
-    // catálogo embutido do locale (ex.: pt-BR) é mesclado por cima.
+    // catálogo embutido do locale (ex.: pt-BR) é mesclado por cima. Os das extensions entram
+    // em cada camada, abaixo dos overrides do host.
     const base = {
         ...DEFAULT_MESSAGES,
+        ...(extensionMessages[DEFAULT_LOCALE] ?? {}),
         ...(BUILTIN_MESSAGES[locale] ?? {}),
+        ...(locale === DEFAULT_LOCALE ? {} : (extensionMessages[locale] ?? {})),
     };
     const overrides = i18n?.messages?.[locale];
     if (!overrides)

package/build/src/host/register_auth_host.js

@@ -12,7 +12,6 @@ import { getAuthHostConfig, markAuthHostAutoMounted, wasAuthHostAutoMounted, } f
 import { consoleDeniedPage } from './console_denied_page.js';
 import { CONSOLE_SSO_CALLBACK_PATH, CONSOLE_SSO_START_PATH } from './console_sso.js';
 import { endBridgedIdpSession, ensureConsoleSession } from './idp_session_bridge.js';
-import { POPPY_WEB_SESSION_KEY } from './poppy_session_key.js';
 import { createAuthThrottles } from './rate_limit.js';
 import { redirectExact } from './redirect_exact.js';
 import { requestPathWithQuery } from './request_url.js';
@@ -121,10 +120,21 @@ function buildLoginRedirect(ctx, extra) {
  * classe NÃO era aplicada em runtime num grupo, deixando /account/tokens e
  * /account/mfa acessíveis sem sessão.
  */
-/** A sessão é do navegador de um personal agent Poppy (§5)? */
-function isPoppyBrowser(ctx) {
-    const marker = ctx.session?.get?.(POPPY_WEB_SESSION_KEY);
-    return typeof marker === 'object' && marker !== null && typeof marker.sessionId === 'string';
+/**
+ * A sessão é do navegador de um personal agent (`isAgentBrowser` de uma extension)? Um hook que
+ * lança conta como "é": na dúvida, o console fica fechado.
+ */
+function isAgentBrowser(ctx) {
+    for (const extension of getAuthHostConfig()?.personalAgents?.extensions ?? []) {
+        try {
+            if (extension.isAgentBrowser?.(ctx))
+                return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
 }
 /**
  * `true` when the caller wants JSON (an `Accept` that prefers `application/json`,
@@ -149,9 +159,9 @@ function unauthenticated(ctx, redirectTo) {
     return redirectExact(ctx.response, redirectTo);
 }
 const accountGuard = async (ctx, next) => {
-    // O navegador de um personal agent Poppy (§5) não entra no console de conta nem
-    // nas telas de consentimento: a sessão é do agente, não do usuário.
-    if (isPoppyBrowser(ctx))
+    // O navegador de um personal agent não entra no console de conta nem nas telas de
+    // consentimento: a sessão é do agente, não do usuário.
+    if (isAgentBrowser(ctx))
         return ctx.response.status(403).send('');
     // Sessão do console — ou, com `accountSession.acceptIdpSession`, a do IdP (SSO).
     if (!(await ensureConsoleSession(ctx))) {
@@ -186,7 +196,7 @@ export const adminGuard = async (ctx, next) => {
     if (!cfg.admin.enabled) {
         return ctx.response.notFound();
     }
-    if (isPoppyBrowser(ctx))
+    if (isAgentBrowser(ctx))
         return ctx.response.status(403).send('');
     // Com `accountSession.acceptIdpSession`, a sessão do IdP também abre o console.
     await ensureConsoleSession(ctx);
@@ -289,8 +299,6 @@ const C = {
     accountConfirm: () => import('./controllers/account_confirm_controller.js'),
     agentOAuth: () => import('./controllers/agent_oauth_controller.js'),
     agentConsent: () => import('./controllers/agent_consent_controller.js'),
-    poppy: () => import('./controllers/poppy_controller.js'),
-    poppyConsent: () => import('./controllers/poppy_consent_controller.js'),
     webauthnAsset: () => import('./controllers/webauthn_asset_controller.js'),
     logoutAsset: () => import('./controllers/logout_asset_controller.js'),
     passkeyAutofillAsset: () => import('./controllers/passkey_autofill_asset_controller.js'),
@@ -671,56 +679,13 @@ export function registerAuthHost(router, opts = {}) {
         })
             .use([accountGuard]);
     }
-    // Personal Agent Protocol (Poppy): descoberta, authorization server (token,
-    // revogação, device authorization), Mediated Sign-In e sessão de navegador —
-    // server-to-server ou POST cross-site do navegador do agente (sem CSRF, ver
-    // `authkitCsrfExceptions`). As telas do usuário (authorize/device) exigem a
-    // sessão de conta e mantêm o CSRF.
-    const poppyPrefix = hostCfg?.personalAgents?.poppyPrefix;
-    if (poppyPrefix) {
-        // Nomes explícitos: o Router nomeia pela dupla controller.método, e as duas URLs da metadata
-        // (RFC 8414 na raiz e debaixo do issuer) usam o mesmo — "poppy.metadata already exists" no boot.
-        router.get('/.well-known/poppy.json', [C.poppy, 'discovery']).as('authkit.poppy.discovery');
-        router
-            .get('/.well-known/oauth-protected-resource', [C.poppy, 'protectedResource'])
-            .as('authkit.poppy.protected_resource');
-        router
-            .get(`/.well-known/oauth-authorization-server${poppyPrefix}`, [C.poppy, 'metadata'])
-            .as('authkit.poppy.metadata');
-        router
-            .get(`${poppyPrefix}/.well-known/oauth-authorization-server`, [C.poppy, 'metadata'])
-            .as('authkit.poppy.metadata_under_issuer');
-        router.post(`${poppyPrefix}/oauth/token`, [C.poppy, 'token']).as('authkit.poppy.token');
-        router.post(`${poppyPrefix}/oauth/revoke`, [C.poppy, 'revoke']).as('authkit.poppy.revoke');
-        router
-            .post(`${poppyPrefix}/oauth/device`, [C.poppy, 'deviceAuthorization'])
-            .as('authkit.poppy.device_authorization');
-        // A página grava um pedido sem autenticação: throttle por IP.
-        withLogin(router
-            .get(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSessionPage'])
-            .as('authkit.poppy.browser_session_page'));
-        router
-            .post(`${poppyPrefix}/browser-session`, [C.poppy, 'browserSession'])
-            .as('authkit.poppy.browser_session');
-        router
-            .post(`${poppyPrefix}/browser-session/authorize`, [C.poppy, 'browserSessionAuthorize'])
-            .as('authkit.poppy.browser_session_authorize');
-        router
-            .group(() => {
-            router
-                .get(`${poppyPrefix}/oauth/authorize`, [C.poppyConsent, 'authorize'])
-                .as('authkit.poppy.authorize');
-            router
-                .post(`${poppyPrefix}/oauth/authorize`, [C.poppyConsent, 'decideAuthorization'])
-                .as('authkit.poppy.authorize_decide');
-            withOtpLogin(router
-                .get(`${poppyPrefix}/device`, [C.poppyConsent, 'device'])
-                .as('authkit.poppy.device'));
-            withOtpLogin(router
-                .post(`${poppyPrefix}/device`, [C.poppyConsent, 'decideDevice'])
-                .as('authkit.poppy.device_decide'));
-        })
-            .use([accountGuard]);
+    // `personalAgents.extensions`: cada uma monta as rotas dela, com o guard de conta e os
+    // buckets de rate limit das telas embutidas.
+    for (const extension of hostCfg?.personalAgents?.extensions ?? []) {
+        extension.routes?.(router, {
+            accountGuard,
+            throttle: { login: (route) => withLogin(route), otp: (route) => withOtpLogin(route) },
+        });
     }
     // Paths do console de conta (configuráveis/localizáveis via `accountRoutes`).
     // As TELAS vêm de `accountPath(key)` (prefixo + segmento configurável); os
@@ -1032,6 +997,8 @@ export function registerAuthHost(router, opts = {}) {
             router.get(`${ap}/api/clients/:id`, [C.consoleClients, 'show']);
             router.patch(`${ap}/api/clients/:id`, [C.consoleClients, 'update']);
             router.delete(`${ap}/api/clients/:id`, [C.consoleClients, 'destroy']);
+            router.post(`${ap}/api/clients/:id/disable`, [C.consoleClients, 'disable']);
+            router.post(`${ap}/api/clients/:id/enable`, [C.consoleClients, 'enable']);
             router.post(`${ap}/api/clients/:id/regenerate-secret`, [
                 C.consoleClients,
                 'regenerateSecret',
@@ -1131,6 +1098,8 @@ export function registerAuthHost(router, opts = {}) {
             withApiThrottle(router.patch('/clients/:id', [C.apiClients, 'update']));
             withApiThrottle(router.post('/clients/:id/regenerate-secret', [C.apiClients, 'regenerateSecret']));
             withApiThrottle(router.delete('/clients/:id', [C.apiClients, 'destroy']));
+            withApiThrottle(router.post('/clients/:id/disable', [C.apiClients, 'disable']));
+            withApiThrottle(router.post('/clients/:id/enable', [C.apiClients, 'enable']));
             // Organizações.
             withApiThrottle(router.get('/organizations', [C.apiOrgs, 'index']));
             withApiThrottle(router.post('/organizations', [C.apiOrgs, 'store']));