@adonis-agora/authkit-server 0.34.0

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

@@ -0,0 +1,238 @@
+import '../augmentations.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { AdminOrgsService } from '../admin_api/admin_orgs_service.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { orgDto, orgDetailDto, apiError } from '../admin_api/dto.js';
+import { orgCreateValidator, orgUpdateValidator, orgAddMemberValidator, orgMemberRoleValidator, orgInvitationValidator, } from '../admin_validators.js';
+/**
+ * Endpoints JSON de organizações do console admin React.
+ * 404 honesto quando o store não suporta organizações (`capability_unsupported`).
+ *
+ * GET    {prefix}/api/orgs                                → lista orgs com contagem de membros
+ * POST   {prefix}/api/orgs                                → cria uma org
+ * GET    {prefix}/api/orgs/:id                            → detalhe da org (membros + convites)
+ * PATCH  {prefix}/api/orgs/:id                            → edita nome/slug/logo
+ * DELETE {prefix}/api/orgs/:id                            → remove a org
+ * POST   {prefix}/api/orgs/:id/members                    → adiciona membro (accountId + role)
+ * DELETE {prefix}/api/orgs/:id/members/:accountId         → remove membro
+ * PATCH  {prefix}/api/orgs/:id/members/:accountId         → altera role do membro
+ * POST   {prefix}/api/orgs/:id/invitations                → cria convite (email + role)
+ * DELETE {prefix}/api/orgs/:id/invitations/:invitationId  → revoga convite
+ */
+export default class ConsoleOrgsController {
+    async svc(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        return new AdminOrgsService(service.config);
+    }
+    actor(ctx) {
+        return {
+            actorId: ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null,
+            ip: ctx.request.ip?.() ?? null,
+            source: 'admin',
+        };
+    }
+    /** Resolve RuntimeSettings (fail-safe → null) para validação do catálogo de roles. */
+    async settings(ctx) {
+        return resolveRuntimeSettings(ctx);
+    }
+    /** GET {prefix}/api/orgs */
+    async index(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const result = await svc.listOrgs();
+        if (!Array.isArray(result)) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { data: result.map((o) => orgDto(o)) };
+    }
+    /** POST {prefix}/api/orgs */
+    async store(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const { name, slug, ownerAccountId, logoUrl } = await ctx.request.validateUsing(orgCreateValidator);
+        const result = await svc.createOrg({ name, slug, ownerAccountId, logoUrl: logoUrl ?? null }, this.actor(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'slug_taken') {
+                return ctx.response.unprocessableEntity(apiError('slug_taken', 'Este slug já está em uso.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return ctx.response.created(orgDto(result));
+    }
+    /** GET {prefix}/api/orgs/:id */
+    async show(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const id = ctx.request.param('id');
+        const result = await svc.getOrg(id);
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return orgDetailDto(result);
+    }
+    /** PATCH {prefix}/api/orgs/:id */
+    async update(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const id = ctx.request.param('id');
+        const { name, logoUrl } = await ctx.request.validateUsing(orgUpdateValidator);
+        const patch = {};
+        if (name !== undefined)
+            patch.name = name;
+        if (logoUrl !== undefined)
+            patch.logoUrl = logoUrl;
+        const result = await svc.updateOrg(id, patch, this.actor(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'slug_taken') {
+                return ctx.response.unprocessableEntity(apiError('slug_taken', 'Este slug já está em uso.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return orgDto(result);
+    }
+    /** DELETE {prefix}/api/orgs/:id */
+    async destroy(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const id = ctx.request.param('id');
+        const result = await svc.deleteOrg(id, this.actor(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { id, deleted: true };
+    }
+    /** POST {prefix}/api/orgs/:id/members */
+    async addMember(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const orgId = ctx.request.param('id');
+        const { accountId, role } = await ctx.request.validateUsing(orgAddMemberValidator);
+        const result = await svc.addMember(orgId, { accountId, role: role ?? 'member' }, this.actor(ctx), await this.settings(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'invalid_role') {
+                return ctx.response.unprocessableEntity(apiError('invalid_role', 'Role inválida — fora do catálogo da organização.'));
+            }
+            if (result.reason === 'account_not_found') {
+                return ctx.response.notFound(apiError('account_not_found', 'Conta não encontrada.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { ok: true };
+    }
+    /** DELETE {prefix}/api/orgs/:id/members/:accountId */
+    async removeMember(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const orgId = ctx.request.param('id');
+        const accountId = ctx.request.param('accountId');
+        const result = await svc.removeMember(orgId, accountId, this.actor(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'last_owner') {
+                return ctx.response.unprocessableEntity(apiError('last_owner', 'Não é possível remover o último owner da organização.'));
+            }
+            if (result.reason === 'member_not_found') {
+                return ctx.response.notFound(apiError('member_not_found', 'Membro não encontrado.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { ok: true };
+    }
+    /** PATCH {prefix}/api/orgs/:id/members/:accountId */
+    async updateMemberRole(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const orgId = ctx.request.param('id');
+        const accountId = ctx.request.param('accountId');
+        const { role } = await ctx.request.validateUsing(orgMemberRoleValidator);
+        const result = await svc.updateMemberRole(orgId, accountId, role, this.actor(ctx), await this.settings(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'invalid_role') {
+                return ctx.response.unprocessableEntity(apiError('invalid_role', 'Role inválida — fora do catálogo da organização.'));
+            }
+            if (result.reason === 'last_owner') {
+                return ctx.response.unprocessableEntity(apiError('last_owner', 'Não é possível alterar o role do último owner.'));
+            }
+            if (result.reason === 'member_not_found') {
+                return ctx.response.notFound(apiError('member_not_found', 'Membro não encontrado.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { ok: true };
+    }
+    /** POST {prefix}/api/orgs/:id/invitations */
+    async createInvitation(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const orgId = ctx.request.param('id');
+        const { email, role } = await ctx.request.validateUsing(orgInvitationValidator);
+        const origin = `${ctx.request.protocol()}://${ctx.request.host()}`;
+        const result = await svc.createInvitation(orgId, { email, role: role ?? 'member' }, this.actor(ctx), origin, await this.settings(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'invalid_role') {
+                return ctx.response.unprocessableEntity(apiError('invalid_role', 'Role inválida — fora do catálogo da organização.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const ok = result;
+        return ctx.response.created({ ok: true, invitation: ok.invitation });
+    }
+    /** DELETE {prefix}/api/orgs/:id/invitations/:invitationId */
+    async revokeInvitation(ctx) {
+        const svc = await this.svc(ctx);
+        if (!svc.supported) {
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        const orgId = ctx.request.param('id');
+        const invitationId = ctx.request.param('invitationId');
+        const result = await svc.revokeInvitation(orgId, invitationId, this.actor(ctx));
+        if ('ok' in result && result.ok === false) {
+            if (result.reason === 'not_found') {
+                return ctx.response.notFound(apiError('not_found', 'Organização não encontrada.'));
+            }
+            if (result.reason === 'invitation_not_found') {
+                return ctx.response.notFound(apiError('invitation_not_found', 'Convite não encontrado.'));
+            }
+            return ctx.response.notFound(apiError('capability_unsupported', 'O store não suporta organizações.'));
+        }
+        return { ok: true };
+    }
+}

package/build/src/host/admin_console/console_overview_controller.d.ts

@@ -0,0 +1,27 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * GET {prefix}/api/overview
+ *
+ * Métricas-resumo do IdP para o dashboard do console React. Reutiliza
+ * `computeAdminStats` (mesma fonte do console Edge) e adiciona:
+ * - `clientsCount`   — número de clients na config
+ * - `auditTotal`     — total de eventos de auditoria (0 quando sink não suporta)
+ * - `recentEvents`   — últimos 5 eventos de auditoria ([] quando não suporta)
+ */
+export default class ConsoleOverviewController {
+    handle(ctx: HttpContext): Promise<{
+        usersTotal: number;
+        activeSessions: number | null;
+        mau: number;
+        signInsTotal: number;
+        signUpsTotal: number;
+        signInsPerDay: import("../admin_stats_service.js").DailyPoint[];
+        signUpsPerDay: import("../admin_stats_service.js").DailyPoint[];
+        windowDays: number;
+        auditSupported: boolean;
+        clientsCount: any;
+        auditTotal: any;
+        recentEvents: any;
+    }>;
+}

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

@@ -0,0 +1,44 @@
+import '../augmentations.js';
+import { AdminSessionsService } from '../admin_sessions_service.js';
+import { computeAdminStats } from '../admin_stats_service.js';
+/**
+ * GET {prefix}/api/overview
+ *
+ * Métricas-resumo do IdP para o dashboard do console React. Reutiliza
+ * `computeAdminStats` (mesma fonte do console Edge) e adiciona:
+ * - `clientsCount`   — número de clients na config
+ * - `auditTotal`     — total de eventos de auditoria (0 quando sink não suporta)
+ * - `recentEvents`   — últimos 5 eventos de auditoria ([] quando não suporta)
+ */
+export default class ConsoleOverviewController {
+    async handle(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const sessions = new AdminSessionsService(service);
+        const stats = await computeAdminStats(cfg, sessions);
+        const clientsCount = cfg.clients.length;
+        const recentResult = typeof cfg.audit?.list === 'function' ? await cfg.audit.list({ page: 1, limit: 5 }) : null;
+        return {
+            usersTotal: stats.totalUsers,
+            activeSessions: stats.activeSessions,
+            mau: stats.mau,
+            signInsTotal: stats.signInsTotal,
+            signUpsTotal: stats.signUpsTotal,
+            signInsPerDay: stats.signInsPerDay,
+            signUpsPerDay: stats.signUpsPerDay,
+            windowDays: stats.windowDays,
+            auditSupported: stats.auditSupported,
+            clientsCount,
+            auditTotal: recentResult?.total ?? 0,
+            recentEvents: (recentResult?.data ?? []).map((e) => ({
+                id: e.id,
+                type: e.type,
+                accountId: e.accountId ?? null,
+                email: e.email ?? null,
+                actorId: e.actorId ?? null,
+                ip: e.ip ?? null,
+                createdAt: e.createdAt instanceof Date ? e.createdAt.toISOString() : (e.createdAt ?? null),
+            })),
+        };
+    }
+}

package/build/src/host/admin_console/console_roles_controller.d.ts

@@ -0,0 +1,31 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+import { type RoleCatalogEntry } from '../runtime_toggles.js';
+/**
+ * Endpoints JSON do catálogo de roles do console admin React.
+ *
+ * GET    {prefix}/api/roles        → lista o catálogo
+ * POST   {prefix}/api/roles        → criar nova role
+ * PATCH  {prefix}/api/roles/:name  → editar descrição
+ * DELETE {prefix}/api/roles/:name  → remover role (ADMIN protegido)
+ *
+ * 404 quando a tabela auth_settings não está disponível.
+ */
+export default class ConsoleRolesController {
+    /** GET {prefix}/api/roles */
+    index(ctx: HttpContext): Promise<void | {
+        data: RoleCatalogEntry[];
+    }>;
+    /** POST {prefix}/api/roles — { name, description? } */
+    store(ctx: HttpContext): Promise<void | {
+        name: string;
+        description: string | undefined;
+    }>;
+    /** PATCH {prefix}/api/roles/:name — { description? } */
+    update(ctx: HttpContext): Promise<void | RoleCatalogEntry>;
+    /** DELETE {prefix}/api/roles/:name */
+    destroy(ctx: HttpContext): Promise<void | {
+        ok: boolean;
+        deleted: string;
+    }>;
+}

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

@@ -0,0 +1,108 @@
+import '../augmentations.js';
+import { resolveRuntimeSettings } from '../runtime_settings.js';
+import { resolveEffectiveRolesCatalog, SETTING_KEYS, } from '../runtime_toggles.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { apiError } from '../admin_api/dto.js';
+import { roleCreateValidator, roleUpdateValidator } from '../admin_validators.js';
+/** Regex de validação: nome de role — letras maiúsculas, dígitos e underscore. */
+const ROLE_NAME_RE = /^[A-Z][A-Z0-9_]*$/;
+/** ADMIN é protegido: não pode ser removido. */
+const PROTECTED_ROLE = 'ADMIN';
+/**
+ * Endpoints JSON do catálogo de roles do console admin React.
+ *
+ * GET    {prefix}/api/roles        → lista o catálogo
+ * POST   {prefix}/api/roles        → criar nova role
+ * PATCH  {prefix}/api/roles/:name  → editar descrição
+ * DELETE {prefix}/api/roles/:name  → remover role (ADMIN protegido)
+ *
+ * 404 quando a tabela auth_settings não está disponível.
+ */
+export default class ConsoleRolesController {
+    /** GET {prefix}/api/roles */
+    async index(ctx) {
+        const rs = await resolveRuntimeSettings(ctx);
+        if (!rs)
+            return ctx.response.notFound(apiError('capability_unsupported', 'Tabela auth_settings não disponível.'));
+        const { roles } = await resolveEffectiveRolesCatalog(rs);
+        return { data: roles };
+    }
+    /** POST {prefix}/api/roles — { name, description? } */
+    async store(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const validated = await ctx.request.validateUsing(roleCreateValidator);
+        const name = validated.name.toUpperCase();
+        const description = validated.description ?? '';
+        // Formato (uppercase + regex) e mensagem custom continuam aqui — Vine só
+        // garante presença/tipo; a regra de domínio do nome é específica do catálogo.
+        if (!ROLE_NAME_RE.test(name)) {
+            return ctx.response.badRequest(apiError('invalid_name', cfg.messages['admin.roles.name_invalid'] ?? 'Nome de role inválido.'));
+        }
+        const rs = await resolveRuntimeSettings(ctx);
+        if (!rs)
+            return ctx.response.notFound(apiError('capability_unsupported', 'Tabela auth_settings não disponível.'));
+        const current = await resolveEffectiveRolesCatalog(rs);
+        if (current.roles.some((r) => r.name.toUpperCase() === name)) {
+            return ctx.response.conflict(apiError('name_taken', cfg.messages['admin.roles.name_taken'] ?? 'Nome de role já existe.'));
+        }
+        const newEntry = { name };
+        if (description)
+            newEntry.description = description;
+        const updated = [...current.roles, newEntry].sort((a, b) => a.name.localeCompare(b.name));
+        await rs.setSetting(SETTING_KEYS.ROLES_CATALOG, { roles: updated }, actorId);
+        await cfg.audit?.record({ type: 'roles_catalog.updated', actorId, ip, metadata: { action: 'create', role: name } });
+        return { name, description: description || undefined };
+    }
+    /** PATCH {prefix}/api/roles/:name — { description? } */
+    async update(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const roleName = decodeURIComponent(ctx.request.param('name'));
+        const { description: rawDescription } = await ctx.request.validateUsing(roleUpdateValidator);
+        const description = rawDescription ?? '';
+        const rs = await resolveRuntimeSettings(ctx);
+        if (!rs)
+            return ctx.response.notFound(apiError('capability_unsupported', 'Tabela auth_settings não disponível.'));
+        const current = await resolveEffectiveRolesCatalog(rs);
+        if (!current.roles.some((r) => r.name === roleName)) {
+            return ctx.response.notFound(apiError('not_found', 'Role não encontrada.'));
+        }
+        const updatedRoles = current.roles.map((r) => r.name === roleName
+            ? { name: r.name, ...(description ? { description } : {}) }
+            : r);
+        await rs.setSetting(SETTING_KEYS.ROLES_CATALOG, { roles: updatedRoles }, actorId);
+        await cfg.audit?.record({ type: 'roles_catalog.updated', actorId, ip, metadata: { action: 'edit', role: roleName } });
+        const found = updatedRoles.find((r) => r.name === roleName);
+        return found;
+    }
+    /** DELETE {prefix}/api/roles/:name */
+    async destroy(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const roleName = decodeURIComponent(ctx.request.param('name'));
+        if (roleName === PROTECTED_ROLE) {
+            return ctx.response.status(409).send(apiError('protected', cfg.messages['admin.roles.admin_protected'] ?? 'A role ADMIN é protegida.'));
+        }
+        const rs = await resolveRuntimeSettings(ctx);
+        if (!rs)
+            return ctx.response.notFound(apiError('capability_unsupported', 'Tabela auth_settings não disponível.'));
+        const current = await resolveEffectiveRolesCatalog(rs);
+        if (!current.roles.some((r) => r.name === roleName)) {
+            return ctx.response.notFound(apiError('not_found', 'Role não encontrada.'));
+        }
+        let updatedRoles = current.roles.filter((r) => r.name !== roleName);
+        if (!updatedRoles.some((r) => r.name === PROTECTED_ROLE)) {
+            updatedRoles.unshift({ name: PROTECTED_ROLE, description: 'Full access to the admin console' });
+        }
+        await rs.setSetting(SETTING_KEYS.ROLES_CATALOG, { roles: updatedRoles }, actorId);
+        await cfg.audit?.record({ type: 'roles_catalog.updated', actorId, ip, metadata: { action: 'delete', role: roleName } });
+        return { ok: true, deleted: roleName };
+    }
+}

package/build/src/host/admin_console/console_sessions_controller.d.ts

@@ -0,0 +1,91 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Endpoints JSON de sessões/grants do console admin React.
+ *
+ * GET    {prefix}/api/sessions?accountId=      → lista sessões + grants de uma conta (ou global)
+ * POST   {prefix}/api/sessions/revoke-all      → revoga todas as sessões de ?accountId=
+ * GET    {prefix}/api/users/:id/sessions       → lista sessões + grants de um usuário específico
+ * POST   {prefix}/api/users/:id/revoke-sessions → revoga todas as sessões de um usuário específico
+ */
+export default class ConsoleSessionsController {
+    /**
+     * Helper privado: lista sessões + grants de uma conta específica.
+     * Retorna o shape UserSessionsResult: { supported, truncated, sessions, grants }.
+     */
+    private listForAccount;
+    /** GET {prefix}/api/sessions?accountId= */
+    index(ctx: HttpContext): Promise<void | {
+        supported: boolean;
+        sessions: never[];
+        grants: never[];
+        truncated?: undefined;
+    } | {
+        supported: boolean;
+        truncated: boolean;
+        sessions: {
+            id: string;
+            accountId: string;
+            email: string | null;
+            loginTs: number | null;
+            amr: string[];
+            userAgent: string | null;
+            browser: string | null;
+            os: string | null;
+            ip: string | null;
+            location: string | null;
+        }[];
+        grants: {
+            id: string;
+            accountId: string;
+            clientId: string | null;
+            accessTokens: number;
+            refreshTokens: number;
+        }[];
+    }>;
+    /** GET {prefix}/api/users/:id/sessions */
+    userSessions(ctx: HttpContext): Promise<void | {
+        supported: boolean;
+        sessions: never[];
+        grants: never[];
+        truncated?: undefined;
+    } | {
+        supported: boolean;
+        truncated: boolean;
+        sessions: {
+            id: string;
+            accountId: string;
+            email: string | null;
+            loginTs: number | null;
+            amr: string[];
+            userAgent: string | null;
+            browser: string | null;
+            os: string | null;
+            ip: string | null;
+            location: string | null;
+        }[];
+        grants: {
+            id: string;
+            accountId: string;
+            clientId: string | null;
+            accessTokens: number;
+            refreshTokens: number;
+        }[];
+    }>;
+    /** POST {prefix}/api/users/:id/revoke-sessions */
+    userRevokeSessions(ctx: HttpContext): Promise<void | {
+        sessions: number;
+        grants: number;
+        accessTokens: number;
+        refreshTokens: number;
+        ok: boolean;
+    }>;
+    /** POST {prefix}/api/sessions/revoke-all?accountId= */
+    revokeAll(ctx: HttpContext): Promise<{
+        sessions: number;
+        grants: number;
+        accessTokens: number;
+        refreshTokens: number;
+        ok: boolean;
+    }>;
+}

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

@@ -0,0 +1,125 @@
+import '../augmentations.js';
+import { AdminSessionsService } from '../admin_sessions_service.js';
+import { enrichSessionsWithContext } from '../session_context.js';
+import { sessionDto, grantDto, apiError } from '../admin_api/dto.js';
+import { ACCOUNT_SESSION_KEY } from '../middleware/account_auth.js';
+import { sessionAccountValidator } from '../admin_validators.js';
+/**
+ * Endpoints JSON de sessões/grants do console admin React.
+ *
+ * GET    {prefix}/api/sessions?accountId=      → lista sessões + grants de uma conta (ou global)
+ * POST   {prefix}/api/sessions/revoke-all      → revoga todas as sessões de ?accountId=
+ * GET    {prefix}/api/users/:id/sessions       → lista sessões + grants de um usuário específico
+ * POST   {prefix}/api/users/:id/revoke-sessions → revoga todas as sessões de um usuário específico
+ */
+export default class ConsoleSessionsController {
+    /**
+     * Helper privado: lista sessões + grants de uma conta específica.
+     * Retorna o shape UserSessionsResult: { supported, truncated, sessions, grants }.
+     */
+    async listForAccount(ctx, accountId) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const adminSvc = new AdminSessionsService(service);
+        if (!adminSvc.canList) {
+            return { supported: false, sessions: [], grants: [] };
+        }
+        const account = await cfg.accountStore.findById(accountId);
+        if (!account)
+            return ctx.response.notFound(apiError('not_found', 'Usuário não encontrado.'));
+        const rawSessions = await adminSvc.listSessions(accountId);
+        const enriched = await enrichSessionsWithContext(cfg, accountId, rawSessions);
+        const grants = await adminSvc.listGrants(accountId);
+        return {
+            supported: true,
+            truncated: false,
+            sessions: enriched.map(sessionDto),
+            grants: grants.map(grantDto),
+        };
+    }
+    /** GET {prefix}/api/sessions?accountId= */
+    async index(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const accountId = ctx.request.input('accountId', '').trim();
+        const adminSvc = new AdminSessionsService(service);
+        if (!adminSvc.canList) {
+            return { supported: false, sessions: [], grants: [] };
+        }
+        // Sem accountId → listagem global de todas as sessões ativas
+        if (!accountId) {
+            const { sessions: rawSessions, truncated } = await adminSvc.listAllSessions();
+            return {
+                supported: true,
+                truncated,
+                sessions: rawSessions.map(sessionDto),
+                grants: [],
+            };
+        }
+        // Com accountId → delega ao helper por-conta
+        return this.listForAccount(ctx, accountId);
+    }
+    /** GET {prefix}/api/users/:id/sessions */
+    async userSessions(ctx) {
+        const accountId = ctx.params.id.trim();
+        if (!accountId) {
+            return ctx.response.badRequest(apiError('invalid_request', 'O parâmetro id é obrigatório.'));
+        }
+        return this.listForAccount(ctx, accountId);
+    }
+    /** POST {prefix}/api/users/:id/revoke-sessions */
+    async userRevokeSessions(ctx) {
+        const accountId = ctx.params.id.trim();
+        if (!accountId) {
+            return ctx.response.badRequest(apiError('invalid_request', 'O parâmetro id é obrigatório.'));
+        }
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        const sessions = new AdminSessionsService(service);
+        const result = await sessions.revokeAll(accountId);
+        await cfg.audit?.record({
+            type: 'session.revoked_all',
+            accountId,
+            actorId,
+            ip,
+            metadata: {
+                sessions: result.sessions,
+                grants: result.grants,
+                accessTokens: result.accessTokens,
+                refreshTokens: result.refreshTokens,
+                source: 'admin-console',
+            },
+        });
+        return { ok: true, ...result };
+    }
+    /** POST {prefix}/api/sessions/revoke-all?accountId= */
+    async revokeAll(ctx) {
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const actorId = ctx.session?.get(ACCOUNT_SESSION_KEY) ?? null;
+        const ip = ctx.request.ip?.() ?? null;
+        // accountId pode vir por query/body OU route param — Vine valida o valor já
+        // coalescido (validate() aceita qualquer dado, não só request.all()).
+        const { accountId } = await sessionAccountValidator.validate({
+            accountId: ctx.request.input('accountId') ??
+                ctx.request.param('accountId'),
+        });
+        const sessions = new AdminSessionsService(service);
+        const result = await sessions.revokeAll(accountId);
+        await cfg.audit?.record({
+            type: 'session.revoked_all',
+            accountId,
+            actorId,
+            ip,
+            metadata: {
+                sessions: result.sessions,
+                grants: result.grants,
+                accessTokens: result.accessTokens,
+                refreshTokens: result.refreshTokens,
+                source: 'admin-console',
+            },
+        });
+        return { ok: true, ...result };
+    }
+}