@hed-hog/core 0.0.399 → 0.0.401

package/src/mcp/mcp-permission.service.ts

@@ -0,0 +1,184 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { SettingService } from '../setting/setting.service';
+
+type CacheEntry = { expiresAt: number; names: Set<string> };
+
+/** Setting com as tools que nenhum cliente OAuth externo pode chamar. */
+const DENIED_TOOLS_SETTING = 'mcp-connector-denied-tools';
+
+/**
+ * Quais tools MCP um usuário pode ver e chamar.
+ *
+ * Existe como service — e não inline no guard — porque a mesma resposta é usada
+ * em dois lugares que precisam concordar: o `tools/list`, que decide o que o
+ * cliente enxerga, e o `tools/call`, que decide o que ele executa. Duplicar a
+ * consulta é o caminho conhecido para os dois divergirem: tool que aparece na
+ * lista e devolve 403, ou — pior — tool que some da lista mas continua
+ * chamável.
+ *
+ * A fonte da verdade é a tabela `route` com `type = 'MCP'`, populada pelos
+ * arquivos `route.yaml` das libraries. Tool que existe em código mas não tem
+ * rota semeada não é concedida a ninguém.
+ */
+@Injectable()
+export class McpPermissionService {
+  /**
+   * Curto de propósito: o preço de errar é uma mudança de papel demorar até
+   * meio minuto para valer, e o ganho é não repetir a consulta a cada uma das
+   * centenas de tools de um `tools/list`. O cache é por processo, e a API roda
+   * com várias réplicas — o limite real de propagação é sempre o TTL, nunca a
+   * réplica que respondeu.
+   */
+  private static readonly CACHE_TTL_MS = 30_000;
+
+  /** Teto de usuários em cache antes de podar o que já expirou. */
+  private static readonly CACHE_MAX_ENTRIES = 500;
+
+  /**
+   * Usado quando a setting nao pode ser lida. Escrita no nucleo de seguranca:
+   * usuarios, papeis, rotas, telas, settings e revogacao de sessao. Ler esses
+   * dominios continua liberado — o que se nega e alterar.
+   */
+  private static readonly DEFAULT_DENIED_TOOLS = [
+    'core.roles.create', 'core.roles.delete', 'core.roles.menus.update',
+    'core.roles.routes.update', 'core.roles.screens.update', 'core.roles.update',
+    'core.roles.users.update',
+    'core.routes.create', 'core.routes.delete', 'core.routes.roles.update',
+    'core.routes.screens.update', 'core.routes.update',
+    'core.screens.create', 'core.screens.delete', 'core.screens.roles.update',
+    'core.screens.routes.update', 'core.screens.update',
+    'core.sessions.revoke', 'core.sessions.revoke-all', 'core.sessions.revoke-all-other',
+    'core.settings.delete', 'core.settings.set', 'core.settings.set-many',
+    'core.settings.update-from-slug',
+    'core.users.assign-role', 'core.users.create', 'core.users.delete',
+    'core.users.remove-role', 'core.users.reset-password', 'core.users.update',
+    'core.users.verify-identifier',
+  ];
+
+  private readonly cache = new Map<string, CacheEntry>();
+
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+  ) {}
+
+  /**
+   * `viaConnector` marca a chamada como vinda de um cliente OAuth externo.
+   *
+   * Um token de conector herda os papeis INTEIROS de quem autorizou — para um
+   * admin, todas as tools do sistema ao alcance de um prompt. Como o conteudo
+   * que o agente le pode vir de fora (um documento, um chamado, um e-mail), o
+   * papel sozinho nao e uma fronteira suficiente: e preciso um teto que valha
+   * mesmo para quem pode tudo.
+   *
+   * A negativa NAO se aplica ao caminho interno (chave `hedhog_mcp_`, JWT de
+   * login, mcp-chat): ali quem chama e o proprio operador, com a tela na frente.
+   */
+  async getAllowedToolNames(
+    userId: number,
+    viaConnector = false,
+  ): Promise<Set<string>> {
+    // Sem usuário não há concessão. A guarda não é teórica: `user_id: undefined`
+    // faz o Prisma *descartar* o filtro, e `role_user: { some: {} }` casaria com
+    // qualquer rota ligada a qualquer papel — liberando tudo em vez de nada.
+    if (!userId) return new Set();
+
+    // A chave inclui a origem: o mesmo usuario tem conjuntos diferentes pelo
+    // conector e pelo caminho interno, e uma chave so por id serviria o conjunto
+    // errado para quem usa os dois.
+    const cacheKey = viaConnector ? `c:${userId}` : `i:${userId}`;
+
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.names;
+    }
+
+    const rows = await this.prisma.route.findMany({
+      where: {
+        type: 'MCP' as any,
+        tool_name: { not: null },
+        role_route: {
+          some: {
+            role: {
+              role_user: {
+                some: { user_id: userId },
+              },
+            },
+          },
+        },
+      },
+      select: { tool_name: true },
+    });
+
+    const names = new Set(
+      rows
+        .map((row) => row.tool_name)
+        .filter((name): name is string => Boolean(name)),
+    );
+
+    if (viaConnector) {
+      for (const denied of await this.getDeniedTools()) {
+        names.delete(denied);
+      }
+    }
+
+    this.remember(cacheKey, names);
+
+    return names;
+  }
+
+  async canCall(
+    userId: number,
+    toolName: string,
+    viaConnector = false,
+  ): Promise<boolean> {
+    const allowed = await this.getAllowedToolNames(userId, viaConnector);
+    return allowed.has(toolName);
+  }
+
+  /**
+   * A lista vem de setting, e nao de constante, porque a fronteira do que um
+   * agente externo pode fazer muda com o uso — e mudar isso nao deve exigir
+   * deploy. O `getSettingValues` ja e cacheado por versao, entao ler aqui e
+   * barato.
+   *
+   * Falha de leitura NAO abre a porta: sem conseguir a lista, o servico assume
+   * o padrao embutido. Uma setting apagada por engano nao pode virar permissao.
+   */
+  private async getDeniedTools(): Promise<string[]> {
+    try {
+      const values = await this.setting.getSettingValues([DENIED_TOOLS_SETTING]);
+      const raw = values[DENIED_TOOLS_SETTING];
+      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        return parsed.map((t) => String(t));
+      }
+    } catch {
+      // cai no padrao abaixo
+    }
+
+    return McpPermissionService.DEFAULT_DENIED_TOOLS;
+  }
+
+  private remember(cacheKey: string, names: Set<string>): void {
+    if (this.cache.size >= McpPermissionService.CACHE_MAX_ENTRIES) {
+      const now = Date.now();
+      for (const [key, entry] of this.cache) {
+        if (entry.expiresAt <= now) this.cache.delete(key);
+      }
+      // Todas ainda válidas: o cache inteiro sai. Esvaziar custa uma consulta
+      // por usuário ativo; deixar crescer sem teto custa memória para sempre.
+      if (this.cache.size >= McpPermissionService.CACHE_MAX_ENTRIES) {
+        this.cache.clear();
+      }
+    }
+
+    this.cache.set(cacheKey, {
+      expiresAt: Date.now() + McpPermissionService.CACHE_TTL_MS,
+      names,
+    });
+  }
+}

package/src/mcp/mcp-server.service.spec.ts

@@ -32,11 +32,19 @@ const makeDeps = () => {
   const audit = {
     record: jest.fn<any>().mockResolvedValue(undefined),
   };
-  return { registry, audit };
+  const permissions = {
+    getAllowedToolNames: jest.fn<any>().mockResolvedValue(new Set<string>()),
+    canCall: jest.fn<any>().mockResolvedValue(true),
+  };
+  return { registry, audit, permissions };
 };
 
 const makeService = (deps = makeDeps()) => ({
-  service: new McpServerService(deps.registry as any, deps.audit as any),
+  service: new McpServerService(
+    deps.registry as any,
+    deps.audit as any,
+    deps.permissions as any,
+  ),
   deps,
 });
 
@@ -50,14 +58,21 @@ const context: McpContext = {
   sessionId: 'sess-1',
   locale: 'pt-BR',
   toolName: '',
+  clientId: null,
 };
 
+/** Mesmo usuario, mas a chamada vem de um cliente OAuth externo. */
+const connectorContext: McpContext = { ...context, clientId: 'claude-connector' };
+
 describe('McpServerService', () => {
   afterEach(() => jest.clearAllMocks());
 
   describe('buildServer / ListTools handler', () => {
     it('lista as ferramentas registradas mapeando definition para o schema MCP', async () => {
       const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(
+        new Set(['tool-a', 'tool-b']),
+      );
       deps.registry.getAll.mockReturnValue([
         {
           definition: { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
@@ -77,6 +92,55 @@ describe('McpServerService', () => {
         { name: 'tool-a', description: 'desc a', inputSchema: { type: 'object', properties: { x: {} } } },
         { name: 'tool-b', description: 'desc b', inputSchema: { type: 'object', properties: {} } },
       ]);
+      expect(deps.permissions.getAllowedToolNames).toHaveBeenCalledWith(
+        context.userId,
+        false,
+      );
+    });
+
+    it('omite da lista as ferramentas que o usuário não pode chamar', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set(['tool-a']));
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+        { definition: { name: 'tool-b', description: 'desc b' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(context);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+      const result = await listHandler();
+
+      expect(result.tools.map((t: any) => t.name)).toEqual(['tool-a']);
+    });
+
+    it('sinaliza a origem para o filtro quando a chamada vem de um conector', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set(['tool-a']));
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(connectorContext);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+      await listHandler();
+
+      expect(deps.permissions.getAllowedToolNames).toHaveBeenCalledWith(
+        connectorContext.userId,
+        true,
+      );
+    });
+
+    it('devolve lista vazia quando o usuário não tem nenhuma tool concedida', async () => {
+      const { service, deps } = makeService();
+      deps.permissions.getAllowedToolNames.mockResolvedValue(new Set<string>());
+      deps.registry.getAll.mockReturnValue([
+        { definition: { name: 'tool-a', description: 'desc a' }, handler: jest.fn() },
+      ]);
+
+      (service as any).buildServer(context);
+      const listHandler = getRegisteredHandler(ListToolsRequestSchema);
+
+      await expect(listHandler()).resolves.toEqual({ tools: [] });
     });
   });
 
@@ -123,6 +187,7 @@ describe('McpServerService', () => {
       expect(deps.audit.record).toHaveBeenCalledWith(
         expect.objectContaining({
           userId: context.userId,
+          clientId: null,
           toolName: 'tool-a',
           input: { a: 1 },
           success: true,
@@ -144,6 +209,23 @@ describe('McpServerService', () => {
       expect(handler).toHaveBeenCalledWith({}, expect.anything());
     });
 
+    // A auditoria precisa responder "quem pediu isso": sem o client, uma acao
+    // feita pelo Claude Desktop e indistinguivel de uma feita pelo Claude Code.
+    it('registra na auditoria o client que originou a chamada', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue({});
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(connectorContext);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+      await callHandler({ params: { name: 'tool-a', arguments: {} } });
+
+      expect(deps.audit.record).toHaveBeenCalledWith(
+        expect.objectContaining({ clientId: 'claude-connector' }),
+      );
+    });
+
     it('captura exceção do handler, audita success:false com o erro e retorna isError', async () => {
       const { service, deps } = makeService();
       const handler = jest.fn<any>().mockRejectedValue(new Error('boom'));

package/src/mcp/mcp-server.service.ts

@@ -1,87 +1,111 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { Injectable } from '@nestjs/common';
-import { Request, Response } from 'express';
-import { McpAuditService } from './mcp-audit.service';
-import { McpRegistryService } from './mcp-registry.service';
-import { McpContext } from './types/mcp-context.type';
-
-@Injectable()
-export class McpServerService {
-  constructor(
-    private readonly registry: McpRegistryService,
-    private readonly audit: McpAuditService,
-  ) {}
-
-  async handleRequest(req: Request, res: Response, context: McpContext): Promise<void> {
-    const server = this.buildServer(context);
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: undefined,
-    });
-    await server.connect(transport);
-    await transport.handleRequest(req, res, req.body);
-  }
-
-  private buildServer(context: McpContext): Server {
-    const server = new Server(
-      { name: 'hedhog-mcp', version: '1.0.0' },
-      { capabilities: { tools: {} } },
-    );
-
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: this.registry.getAll().map((e) => ({
-        name: e.definition.name,
-        description: e.definition.description,
-        inputSchema: e.definition.inputSchema ?? {
-          type: 'object',
-          properties: {},
-        },
-      })),
-    }));
-
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const toolName = request.params.name;
-      const args = (request.params.arguments ?? {}) as Record<string, any>;
-      const entry = this.registry.get(toolName);
-
-      if (!entry) {
-        return {
-          isError: true,
-          content: [{ type: 'text', text: `Tool '${toolName}' not found` }],
-        };
-      }
-
-      const start = Date.now();
-      try {
-        const result = await entry.handler(args, { ...context, toolName });
-        await this.audit.record({
-          userId: context.userId,
-          toolName,
-          input: args,
-          success: true,
-          durationMs: Date.now() - start,
-        });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-      } catch (e: any) {
-        await this.audit.record({
-          userId: context.userId,
-          toolName,
-          input: args,
-          success: false,
-          error: e.message,
-          durationMs: Date.now() - start,
-        });
-        return {
-          isError: true,
-          content: [{ type: 'text', text: e.message }],
-        };
-      }
-    });
-
-    return server;
-  }
-}
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { Injectable } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { McpAuditService } from './mcp-audit.service';
+import { McpPermissionService } from './mcp-permission.service';
+import { McpRegistryService } from './mcp-registry.service';
+import { McpContext } from './types/mcp-context.type';
+
+@Injectable()
+export class McpServerService {
+  constructor(
+    private readonly registry: McpRegistryService,
+    private readonly audit: McpAuditService,
+    private readonly permissions: McpPermissionService,
+  ) {}
+
+  async handleRequest(req: Request, res: Response, context: McpContext): Promise<void> {
+    const server = this.buildServer(context);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+      // Sem sessão o transporte só atende POST, e aí o SSE não compra nada: não
+      // há stream para retomar nem notificação do servidor para empurrar. O que
+      // ele custa é real — um `tools/list` de centenas de KB atravessa o ingress
+      // como um único evento, sujeito ao buffering do nginx. JSON puro entrega a
+      // mesma resposta sem esse caminho.
+      enableJsonResponse: true,
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  }
+
+  private buildServer(context: McpContext): Server {
+    const server = new Server(
+      { name: 'hedhog-mcp', version: '1.0.0' },
+      { capabilities: { tools: {} } },
+    );
+
+    // A lista sai filtrada pelas mesmas permissões que o McpPermissionGuard
+    // aplica no tools/call. Sem isso o cliente recebe as centenas de tools do
+    // registry inteiro e descobre o que pode usar tomando 403 — além de gastar
+    // o contexto da conversa com ferramentas que nunca vão funcionar.
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const allowed = await this.permissions.getAllowedToolNames(
+        context.userId,
+        context.clientId !== null,
+      );
+
+      return {
+        tools: this.registry
+          .getAll()
+          .filter((e) => allowed.has(e.definition.name))
+          .map((e) => ({
+            name: e.definition.name,
+            description: e.definition.description,
+            inputSchema: e.definition.inputSchema ?? {
+              type: 'object',
+              properties: {},
+            },
+          })),
+      };
+    });
+
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const toolName = request.params.name;
+      const args = (request.params.arguments ?? {}) as Record<string, any>;
+      const entry = this.registry.get(toolName);
+
+      if (!entry) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Tool '${toolName}' not found` }],
+        };
+      }
+
+      const start = Date.now();
+      try {
+        const result = await entry.handler(args, { ...context, toolName });
+        await this.audit.record({
+          userId: context.userId,
+          clientId: context.clientId,
+          toolName,
+          input: args,
+          success: true,
+          durationMs: Date.now() - start,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+      } catch (e: any) {
+        await this.audit.record({
+          userId: context.userId,
+          clientId: context.clientId,
+          toolName,
+          input: args,
+          success: false,
+          error: e.message,
+          durationMs: Date.now() - start,
+        });
+        return {
+          isError: true,
+          content: [{ type: 'text', text: e.message }],
+        };
+      }
+    });
+
+    return server;
+  }
+}

package/src/mcp/mcp.controller.ts

@@ -1,15 +1,19 @@
 import { NoRole } from '@hed-hog/api';
-import { All, Controller, Req, Res, UseGuards } from '@nestjs/common';
+import { All, Controller, Req, Res, UseFilters, UseGuards } from '@nestjs/common';
 import { Request, Response } from 'express';
 import { SettingService } from '../setting/setting.service';
 import { AllowMcpToken } from './decorators/allow-mcp-token.decorator';
 import { McpAuthGuard } from './guards/mcp-auth.guard';
 import { McpPermissionGuard } from './guards/mcp-permission.guard';
+import { McpChallengeFilter } from './filters/mcp-challenge.filter';
 import { McpServerService } from './mcp-server.service';
 
 @NoRole()
 @AllowMcpToken()
 @UseGuards(McpAuthGuard, McpPermissionGuard)
+// Captura tambem o 401 do AuthGuard global, que roda ANTES dos guards acima — e
+// que e justamente quem responde a sondagem sem token de um cliente OAuth.
+@UseFilters(McpChallengeFilter)
 @Controller('mcp')
 export class McpController {
   constructor(
@@ -37,6 +41,9 @@ export class McpController {
       sessionId: String(auth.sessionId),
       locale,
       toolName,
+      // `cid` so existe no token emitido pelo fluxo OAuth. Chave hedhog_mcp_ e
+      // JWT de login nao o tem, e e essa ausencia que marca o caminho interno.
+      clientId: auth.cid ?? null,
     });
   }
 }

package/src/mcp/mcp.module.ts

@@ -22,14 +22,17 @@ import { SettingModule } from '../setting/setting.module';
 import { TokenModule } from '../token/token.module';
 import { UserModule } from '../user/user.module';
 import { WebhookIntegrationModule } from '../webhook-integration/webhook-integration.module';
+import { McpChallengeFilter } from './filters/mcp-challenge.filter';
 import { McpAuthGuard } from './guards/mcp-auth.guard';
 import { McpPermissionGuard } from './guards/mcp-permission.guard';
 import { McpApiKeyController } from './mcp-api-key.controller';
 import { McpApiKeyService } from './mcp-api-key.service';
 import { McpAuditService } from './mcp-audit.service';
+import { McpPermissionService } from './mcp-permission.service';
 import { McpRegistryService } from './mcp-registry.service';
 import { McpServerService } from './mcp-server.service';
 import { McpController } from './mcp.controller';
+import { CoreAccessLogMcpTools } from './tools/core-access-log.mcp-tools';
 import { CoreAiMcpTools } from './tools/core-ai.mcp-tools';
 import { CoreDashboardItemsMcpTools } from './tools/core-dashboard-items.mcp-tools';
 import { CoreDashboardMcpTools } from './tools/core-dashboard.mcp-tools';
@@ -83,8 +86,10 @@ import { AccessLogModule } from '../access-log/access-log.module';
     McpRegistryService,
     McpServerService,
     McpAuditService,
+    McpPermissionService,
     McpAuthGuard,
     McpPermissionGuard,
+    McpChallengeFilter,
     McpApiKeyService,
     McpChatService,
     CoreSettingsMcpTools,
@@ -107,7 +112,8 @@ import { AccessLogModule } from '../access-log/access-log.module';
     CoreAiMcpTools,
     CoreMcpChatMcpTools,
     CoreSystemMcpTools,
+    CoreAccessLogMcpTools,
   ],
-  exports: [McpRegistryService, McpServerService, McpApiKeyService],
+  exports: [McpRegistryService, McpServerService, McpApiKeyService, McpPermissionService],
 })
 export class McpModule {}

package/src/mcp/tools/core-access-log.mcp-tools.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@nestjs/common';
+import { AccessLogService } from '../../access-log/access-log.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+const TYPES = ['http', 'mcp', 'all'] as const;
+const SIMULATED = ['all', 'only', 'exclude'] as const;
+
+@Injectable()
+export class CoreAccessLogMcpTools {
+  constructor(private readonly accessLogService: AccessLogService) {}
+
+  @McpTool({
+    name: 'core.access-log.list',
+    description:
+      'Lists the access log (the admin "Access log" screen): every authenticated HTTP request and MCP tool call, with user, method/URL or tool, IP, user agent and whether it happened during an access simulation. Newest first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        userId: { type: 'number', description: 'Filter by user id' },
+        userSearch: { type: 'string', description: 'Matches the user name' },
+        createdAtFrom: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
+        createdAtTo: { type: 'string', description: 'End date (YYYY-MM-DD), inclusive' },
+        type: {
+          type: 'string',
+          description: 'http = REST requests, mcp = MCP tool calls (default: all)',
+          enum: [...TYPES],
+        },
+        simulated: {
+          type: 'string',
+          description: 'only/exclude accesses made while an admin simulated another user (default: all)',
+          enum: [...SIMULATED],
+        },
+      },
+    },
+    readOnly: true,
+  })
+  async list(
+    args: {
+      page?: number;
+      pageSize?: number;
+      userId?: number;
+      userSearch?: string;
+      createdAtFrom?: string;
+      createdAtTo?: string;
+      type?: string;
+      simulated?: string;
+    },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.accessLogService.list({
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      userId: args.userId,
+      userSearch: args.userSearch,
+      createdAtFrom: args.createdAtFrom,
+      createdAtTo: args.createdAtTo,
+      type: TYPES.includes(args.type as any) ? (args.type as (typeof TYPES)[number]) : undefined,
+      simulated: SIMULATED.includes(args.simulated as any)
+        ? (args.simulated as (typeof SIMULATED)[number])
+        : undefined,
+    });
+  }
+}

package/src/mcp/tools/core-ai.mcp-tools.ts

@@ -46,7 +46,7 @@ export class CoreAiMcpTools {
       page: args.page ?? 1,
       pageSize: args.pageSize ?? 20,
       search: args.search ?? '',
-      sortField: args.sortField ?? 'id',
+      ...(args.sortField ? { sortField: args.sortField } : {}),
       sortOrder: (args.sortOrder as any) ?? 'asc',
       fields: '',
     });

package/src/mcp/tools/core-dashboard-items.mcp-tools.ts

@@ -22,7 +22,7 @@ export class CoreDashboardItemsMcpTools {
   })
   async listDashboardItems(args: { page?: number; pageSize?: number; dashboardId?: number }, context: McpContext): Promise<any> {
     return this.dashboardItemService.getAllDashboardItems(
-      { page: args.page ?? 1, pageSize: args.pageSize ?? 20, search: '', sortField: 'id', sortOrder: 'asc', fields: '' },
+      { page: args.page ?? 1, pageSize: args.pageSize ?? 20, search: '', sortOrder: 'asc', fields: '' },
       context.locale,
       args.dashboardId,
     );