@hed-hog/core 0.0.350 → 0.0.353

package/src/mcp/mcp.controller.ts

@@ -1,30 +1,40 @@
-import { NoRole } from '@hed-hog/api';
-import { All, Controller, Req, Res, UseGuards } from '@nestjs/common';
-import { Request, Response } from 'express';
-import { McpAuthGuard } from './guards/mcp-auth.guard';
-import { McpPermissionGuard } from './guards/mcp-permission.guard';
-import { McpServerService } from './mcp-server.service';
-
-@NoRole()
-@UseGuards(McpAuthGuard, McpPermissionGuard)
-@Controller('mcp')
-export class McpController {
-  constructor(private readonly mcpServer: McpServerService) {}
-
-  @All()
-  async handle(@Req() req: Request, @Res() res: Response): Promise<void> {
-    const auth = (req as any).auth;
-    const locale =
-      req.headers['accept-language']?.split(',')[0]?.split('-')[0] ?? 'en';
-    const body = req.body as any;
-    const toolName: string =
-      body?.method === 'tools/call' ? (body?.params?.name ?? '') : '';
-
-    await this.mcpServer.handleRequest(req, res, {
-      userId: auth.sub,
-      sessionId: String(auth.sessionId),
-      locale,
-      toolName,
-    });
-  }
-}
+import { NoRole } from '@hed-hog/api';
+import { All, Controller, Req, Res, UseGuards } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { SettingService } from '../setting/setting.service';
+import { McpAuthGuard } from './guards/mcp-auth.guard';
+import { McpPermissionGuard } from './guards/mcp-permission.guard';
+import { McpServerService } from './mcp-server.service';
+
+@NoRole()
+@UseGuards(McpAuthGuard, McpPermissionGuard)
+@Controller('mcp')
+export class McpController {
+  constructor(
+    private readonly mcpServer: McpServerService,
+    private readonly setting: SettingService,
+  ) {}
+
+  @All()
+  async handle(@Req() req: Request, @Res() res: Response): Promise<void> {
+    const settings = await this.setting.getSettingValues(['mcp-enabled']);
+    if (settings['mcp-enabled'] === false) {
+      res.status(503).json({ message: 'MCP server is disabled.' });
+      return;
+    }
+
+    const auth = (req as any).auth;
+    const locale =
+      req.headers['accept-language']?.split(',')[0]?.split('-')[0] ?? 'en';
+    const body = req.body as any;
+    const toolName: string =
+      body?.method === 'tools/call' ? (body?.params?.name ?? '') : '';
+
+    await this.mcpServer.handleRequest(req, res, {
+      userId: auth.sub,
+      sessionId: String(auth.sessionId),
+      locale,
+      toolName,
+    });
+  }
+}

package/src/mcp/mcp.module.ts

@@ -2,10 +2,26 @@ import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { Module, forwardRef } from '@nestjs/common';
 import { DiscoveryModule } from '@nestjs/core';
+import { AiModule } from '../ai/ai.module';
+import { SystemModule } from '../core/system.module';
+import { DashboardModule } from '../dashboard/dashboard.module';
+import { FileModule } from '../file/file.module';
+import { MailModule } from '../mail/mail.module';
+import { MailProfileModule } from '../mail-profile/mail-profile.module';
+import { MailSentModule } from '../mail-sent/mail-sent.module';
+import { McpChatService } from '../mcp-chat/mcp-chat.service';
+import { MenuModule } from '../menu/menu.module';
+import { NotificationModule } from '../notification/notification.module';
+import { ProfileModule } from '../profile/profile.module';
+import { RoleModule } from '../role/role.module';
+import { RouteModule } from '../route/route.module';
+import { ScreenModule } from '../screen/screen.module';
 import { SecurityModule } from '../security/security.module';
+import { SessionModule } from '../session/session.module';
 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 { McpAuthGuard } from './guards/mcp-auth.guard';
 import { McpPermissionGuard } from './guards/mcp-permission.guard';
 import { McpApiKeyController } from './mcp-api-key.controller';
@@ -14,18 +30,54 @@ import { McpAuditService } from './mcp-audit.service';
 import { McpRegistryService } from './mcp-registry.service';
 import { McpServerService } from './mcp-server.service';
 import { McpController } from './mcp.controller';
+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';
+import { CoreEventWebhooksMcpTools } from './tools/core-event-webhooks.mcp-tools';
+import { CoreFilesMcpTools } from './tools/core-files.mcp-tools';
+import { CoreIntegrationEventsMcpTools } from './tools/core-integration-events.mcp-tools';
+import { CoreMailMcpTools } from './tools/core-mail.mcp-tools';
+import { CoreMailProfileMcpTools } from './tools/core-mail-profile.mcp-tools';
+import { CoreMailSentMcpTools } from './tools/core-mail-sent.mcp-tools';
+import { CoreMcpChatMcpTools } from './tools/core-mcp-chat.mcp-tools';
+import { CoreMenusMcpTools } from './tools/core-menus.mcp-tools';
+import { CoreNotificationsMcpTools } from './tools/core-notifications.mcp-tools';
+import { CoreProfileMcpTools } from './tools/core-profile.mcp-tools';
+import { CoreRolesMcpTools } from './tools/core-roles.mcp-tools';
+import { CoreRoutesMcpTools } from './tools/core-routes.mcp-tools';
+import { CoreScreensMcpTools } from './tools/core-screens.mcp-tools';
+import { CoreSessionsMcpTools } from './tools/core-sessions.mcp-tools';
 import { CoreSettingsMcpTools } from './tools/core-settings.mcp-tools';
+import { CoreSystemMcpTools } from './tools/core-system.mcp-tools';
 import { CoreUsersMcpTools } from './tools/core-users.mcp-tools';
+import { CoreWebhooksMcpTools } from './tools/core-webhooks.mcp-tools';
+import { AccessLogModule } from '../access-log/access-log.module';
 
 @Module({
   imports: [
     DiscoveryModule,
     forwardRef(() => PrismaModule),
+    forwardRef(() => AccessLogModule),
     forwardRef(() => PaginationModule),
     forwardRef(() => TokenModule),
     forwardRef(() => SettingModule),
     forwardRef(() => UserModule),
     forwardRef(() => SecurityModule),
+    forwardRef(() => RoleModule),
+    forwardRef(() => RouteModule),
+    forwardRef(() => MenuModule),
+    forwardRef(() => ScreenModule),
+    forwardRef(() => FileModule),
+    forwardRef(() => MailModule),
+    forwardRef(() => MailProfileModule),
+    forwardRef(() => MailSentModule),
+    forwardRef(() => SessionModule),
+    forwardRef(() => NotificationModule),
+    forwardRef(() => DashboardModule),
+    forwardRef(() => WebhookIntegrationModule),
+    forwardRef(() => AiModule),
+    forwardRef(() => ProfileModule),
+    forwardRef(() => SystemModule),
   ],
   controllers: [McpController, McpApiKeyController],
   providers: [
@@ -35,8 +87,28 @@ import { CoreUsersMcpTools } from './tools/core-users.mcp-tools';
     McpAuthGuard,
     McpPermissionGuard,
     McpApiKeyService,
+    McpChatService,
     CoreSettingsMcpTools,
     CoreUsersMcpTools,
+    CoreRolesMcpTools,
+    CoreRoutesMcpTools,
+    CoreMenusMcpTools,
+    CoreScreensMcpTools,
+    CoreProfileMcpTools,
+    CoreSessionsMcpTools,
+    CoreFilesMcpTools,
+    CoreMailMcpTools,
+    CoreMailProfileMcpTools,
+    CoreMailSentMcpTools,
+    CoreNotificationsMcpTools,
+    CoreDashboardMcpTools,
+    CoreDashboardItemsMcpTools,
+    CoreWebhooksMcpTools,
+    CoreEventWebhooksMcpTools,
+    CoreIntegrationEventsMcpTools,
+    CoreAiMcpTools,
+    CoreMcpChatMcpTools,
+    CoreSystemMcpTools,
   ],
   exports: [McpRegistryService, McpServerService],
 })

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

@@ -0,0 +1,156 @@
+import { Injectable } from '@nestjs/common';
+import { AiService } from '../../ai/ai.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreAiMcpTools {
+  constructor(private readonly aiService: AiService) {}
+
+  @McpTool({
+    name: 'core.ai.chat',
+    description: 'Sends a message to the AI and returns a response.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'Message to send to the AI' },
+        context: { type: 'string', description: 'Additional context for the AI' },
+      },
+      required: ['message'],
+    },
+  })
+  async chat(args: { message: string; context?: string }, _context: McpContext): Promise<any> {
+    return this.aiService.chat({ message: args.message, context: args.context } as any);
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.list',
+    description: 'Lists AI agents with optional pagination. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listAgents(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.aiService.listAgents({
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: args.search ?? '',
+      sortField: args.sortField ?? 'id',
+      sortOrder: (args.sortOrder as any) ?? 'asc',
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.get',
+    description: 'Returns a single AI agent by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'number', description: 'Agent ID' },
+      },
+      required: ['agentId'],
+    },
+    readOnly: true,
+  })
+  async getAgent(args: { agentId: number }, _context: McpContext): Promise<any> {
+    return this.aiService.getAgentById(args.agentId);
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.get-by-slug',
+    description: 'Returns a single AI agent by slug.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Agent slug' },
+      },
+      required: ['slug'],
+    },
+    readOnly: true,
+  })
+  async getAgentBySlug(args: { slug: string }, _context: McpContext): Promise<any> {
+    return this.aiService.getAgentBySlug(args.slug);
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.create',
+    description: 'Creates a new AI agent. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Agent slug (unique identifier)' },
+        provider: { type: 'string', description: 'AI provider (e.g. openai, gemini)' },
+        model: { type: 'string', description: 'AI model identifier' },
+        instructions: { type: 'string', description: 'System instructions for the agent' },
+      },
+      required: ['slug'],
+    },
+  })
+  async createAgent(args: { slug: string; provider?: string; model?: string; instructions?: string }, _context: McpContext): Promise<any> {
+    return this.aiService.createAgent(args as any);
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.update',
+    description: 'Updates an existing AI agent by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'number', description: 'Agent ID' },
+        slug: { type: 'string', description: 'New slug' },
+        provider: { type: 'string', description: 'New AI provider' },
+        model: { type: 'string', description: 'New AI model' },
+        instructions: { type: 'string', description: 'New system instructions' },
+      },
+      required: ['agentId'],
+    },
+  })
+  async updateAgent(args: { agentId: number; slug?: string; provider?: string; model?: string; instructions?: string }, _context: McpContext): Promise<any> {
+    const { agentId, ...data } = args;
+    return this.aiService.updateAgent(agentId, data as any);
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.delete',
+    description: 'Deletes one or more AI agents by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Agent IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteAgents(args: { ids: number[] }, _context: McpContext): Promise<any> {
+    return this.aiService.deleteAgents({ ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.ai.agents.chat',
+    description: 'Sends a message to a specific AI agent and returns a response.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Agent slug' },
+        message: { type: 'string', description: 'Message to send to the agent' },
+        context: { type: 'string', description: 'Additional context for the agent' },
+      },
+      required: ['slug', 'message'],
+    },
+  })
+  async chatWithAgent(args: { slug: string; message: string; context?: string }, _context: McpContext): Promise<any> {
+    return this.aiService.chatWithAgent(args.slug, { message: args.message, context: args.context } as any);
+  }
+}

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

@@ -0,0 +1,63 @@
+import { Injectable } from '@nestjs/common';
+import { DashboardItemService } from '../../dashboard/dashboard-item/dashboard-item.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreDashboardItemsMcpTools {
+  constructor(private readonly dashboardItemService: DashboardItemService) {}
+
+  @McpTool({
+    name: 'core.dashboard-items.list',
+    description: 'Lists dashboard items, optionally filtered by dashboard ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        dashboardId: { type: 'number', description: 'Filter by dashboard ID' },
+      },
+    },
+    readOnly: true,
+  })
+  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: '' },
+      context.locale,
+      args.dashboardId,
+    );
+  }
+
+  @McpTool({
+    name: 'core.dashboard-items.create',
+    description: 'Creates a new dashboard item (widget placement). Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dashboardId: { type: 'number', description: 'Dashboard ID' },
+        componentId: { type: 'number', description: 'Component ID' },
+        position: { type: 'object', description: 'Position/layout config (x, y, w, h)' },
+        config: { type: 'object', description: 'Component configuration' },
+      },
+      required: ['dashboardId', 'componentId'],
+    },
+  })
+  async createDashboardItem(args: { dashboardId: number; componentId: number; position?: any; config?: any }, context: McpContext): Promise<any> {
+    return this.dashboardItemService.createDashboardItem(args as any, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.dashboard-items.delete',
+    description: 'Deletes a dashboard item by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Dashboard item ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteDashboardItem(args: { id: number }, context: McpContext): Promise<any> {
+    return this.dashboardItemService.deleteDashboardItem(args.id, context.locale);
+  }
+}

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

@@ -0,0 +1,103 @@
+import { Injectable } from '@nestjs/common';
+import { DashboardService } from '../../dashboard/dashboard/dashboard.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreDashboardMcpTools {
+  constructor(private readonly dashboardService: DashboardService) {}
+
+  @McpTool({
+    name: 'core.dashboard.list',
+    description: 'Lists all dashboards with optional pagination. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listDashboards(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.dashboardService.getAllDashboards({
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: args.search ?? '',
+      sortField: args.sortField ?? 'id',
+      sortOrder: args.sortOrder ?? 'asc',
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.dashboard.get',
+    description: 'Returns a single dashboard by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Dashboard ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getDashboard(args: { id: number }, context: McpContext): Promise<any> {
+    return this.dashboardService.getDashboard(args.id, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.dashboard.create',
+    description: 'Creates a new dashboard. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Dashboard name' },
+        description: { type: 'string', description: 'Dashboard description' },
+      },
+      required: ['name'],
+    },
+  })
+  async createDashboard(args: { name: string; description?: string }, context: McpContext): Promise<any> {
+    return this.dashboardService.createDashboard(args as any, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.dashboard.update',
+    description: 'Updates an existing dashboard by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Dashboard ID' },
+        name: { type: 'string', description: 'New name' },
+        description: { type: 'string', description: 'New description' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateDashboard(args: { id: number; name?: string; description?: string }, context: McpContext): Promise<any> {
+    const { id, ...data } = args;
+    return this.dashboardService.updateDashboard(id, data as any, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.dashboard.delete',
+    description: 'Deletes a dashboard by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Dashboard ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteDashboard(args: { id: number }, context: McpContext): Promise<any> {
+    return this.dashboardService.deleteDashboard(args.id, context.locale);
+  }
+}

package/src/mcp/tools/core-event-webhooks.mcp-tools.ts

@@ -0,0 +1,134 @@
+import { Injectable } from '@nestjs/common';
+import { EventWebhookService } from '../../webhook-integration/event-webhook.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreEventWebhooksMcpTools {
+  constructor(private readonly eventWebhookService: EventWebhookService) {}
+
+  @McpTool({
+    name: 'core.event-webhooks.list',
+    description: 'Lists event-driven webhooks with optional pagination. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listEventWebhooks(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.eventWebhookService.list({
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: args.search ?? '',
+      sortField: args.sortField ?? 'id',
+      sortOrder: (args.sortOrder as any) ?? 'asc',
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.event-webhooks.get',
+    description: 'Returns a single event webhook by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Event webhook ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getEventWebhook(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.eventWebhookService.get(args.id);
+  }
+
+  @McpTool({
+    name: 'core.event-webhooks.create',
+    description: 'Creates a new event webhook. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Webhook name' },
+        slug: { type: 'string', description: 'Webhook slug' },
+        url: { type: 'string', description: 'Target URL to POST events to' },
+        method: { type: 'string', description: 'HTTP method (default: POST)' },
+        status: { type: 'string', description: 'Status (active, inactive)' },
+        events: { type: 'array', items: { type: 'string' }, description: 'Event slugs to subscribe to' },
+      },
+      required: ['name', 'url'],
+    },
+  })
+  async createEventWebhook(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.eventWebhookService.create(args);
+  }
+
+  @McpTool({
+    name: 'core.event-webhooks.update',
+    description: 'Updates an existing event webhook by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Event webhook ID' },
+        name: { type: 'string', description: 'New name' },
+        url: { type: 'string', description: 'New target URL' },
+        status: { type: 'string', description: 'New status (active, inactive)' },
+        events: { type: 'array', items: { type: 'string' }, description: 'New event slugs to subscribe to' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateEventWebhook(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...data } = args;
+    return this.eventWebhookService.update(id, data);
+  }
+
+  @McpTool({
+    name: 'core.event-webhooks.delete',
+    description: 'Deletes one or more event webhooks by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Event webhook IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteEventWebhooks(args: { ids: number[] }, _context: McpContext): Promise<any> {
+    return this.eventWebhookService.delete({ ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.event-webhooks.logs.list',
+    description: 'Lists delivery logs for an event webhook. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Event webhook ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['webhookId'],
+    },
+    readOnly: true,
+  })
+  async listEventWebhookLogs(args: { webhookId: number; page?: number; pageSize?: number }, _context: McpContext): Promise<any> {
+    return this.eventWebhookService.listLogs(args.webhookId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: 'desc' as any,
+      fields: '',
+    });
+  }
+}