@hed-hog/core 0.0.350 → 0.0.353

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

@@ -0,0 +1,197 @@
+import { Injectable } from '@nestjs/common';
+import { PageOrderDirection } from '@hed-hog/api-pagination';
+import { MenuService } from '../../menu/menu.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreMenusMcpTools {
+  constructor(private readonly menuService: MenuService) {}
+
+  @McpTool({
+    name: 'core.menus.system',
+    description: 'Returns the system menu for the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getSystemMenu(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.menuService.getSystemMenu(context.locale, context.userId);
+  }
+
+  @McpTool({
+    name: 'core.menus.stats',
+    description: 'Returns menu statistics. Admin only.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getMenuStats(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.menuService.stats();
+  }
+
+  @McpTool({
+    name: 'core.menus.all',
+    description: 'Returns all menus as a flat list (no pagination). Admin only.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async listAllMenus(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.menuService.listAll(context.locale);
+  }
+
+  @McpTool({
+    name: 'core.menus.list',
+    description: 'Lists menus with 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 listMenus(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.menuService.list(context.locale, {
+      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.menus.get',
+    description: 'Returns a single menu by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        menuId: { type: 'number', description: 'Menu ID' },
+      },
+      required: ['menuId'],
+    },
+    readOnly: true,
+  })
+  async getMenu(args: { menuId: number }, context: McpContext): Promise<any> {
+    return this.menuService.get(context.locale, args.menuId);
+  }
+
+  @McpTool({
+    name: 'core.menus.create',
+    description: 'Creates a new menu item. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Menu slug' },
+        url: { type: 'string', description: 'Target URL' },
+        icon: { type: 'string', description: 'Icon identifier' },
+        order: { type: 'number', description: 'Display order' },
+        menu_id: { type: 'number', description: 'Parent menu ID' },
+        locale: { type: 'object', description: 'Locale translations, e.g. {"en": {"name": "Dashboard"}}' },
+      },
+    },
+  })
+  async createMenu(args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.menuService.create(context.locale, args as any);
+  }
+
+  @McpTool({
+    name: 'core.menus.update',
+    description: 'Updates an existing menu item by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        menuId: { type: 'number', description: 'Menu ID' },
+        slug: { type: 'string', description: 'New slug' },
+        url: { type: 'string', description: 'New URL' },
+        icon: { type: 'string', description: 'New icon' },
+        order: { type: 'number', description: 'New display order' },
+        menu_id: { type: 'number', description: 'New parent menu ID' },
+        locale: { type: 'object', description: 'Updated locale translations' },
+      },
+      required: ['menuId'],
+    },
+  })
+  async updateMenu(args: { menuId: number; [key: string]: any }, context: McpContext): Promise<any> {
+    const { menuId, ...data } = args;
+    return this.menuService.update(context.locale, { id: menuId, data: data as any });
+  }
+
+  @McpTool({
+    name: 'core.menus.delete',
+    description: 'Deletes one or more menu items by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Menu IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteMenus(args: { ids: number[] }, context: McpContext): Promise<any> {
+    return this.menuService.delete(context.locale, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.menus.order',
+    description: 'Updates the display order of menus. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Menu IDs in the desired order' },
+      },
+      required: ['ids'],
+    },
+  })
+  async updateMenuOrder(args: { ids: number[] }, context: McpContext): Promise<any> {
+    return this.menuService.updateOrder(context.locale, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.menus.roles.list',
+    description: 'Lists roles assigned to a menu. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        menuId: { type: 'number', description: 'Menu ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['menuId'],
+    },
+    readOnly: true,
+  })
+  async listMenuRoles(args: { menuId: number; page?: number; pageSize?: number }, context: McpContext): Promise<any> {
+    return this.menuService.listRoles(context.locale, args.menuId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: PageOrderDirection.Asc,
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.menus.roles.update',
+    description: 'Replaces all roles assigned to a menu. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        menuId: { type: 'number', description: 'Menu ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Role IDs to assign' },
+      },
+      required: ['menuId', 'ids'],
+    },
+  })
+  async updateMenuRoles(args: { menuId: number; ids: number[] }, context: McpContext): Promise<any> {
+    return this.menuService.updateRoles(context.locale, args.menuId, { ids: args.ids });
+  }
+}

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

@@ -0,0 +1,128 @@
+import { Injectable } from '@nestjs/common';
+import { NotificationService } from '../../notification/notification.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreNotificationsMcpTools {
+  constructor(private readonly notificationService: NotificationService) {}
+
+  @McpTool({
+    name: 'core.notifications.list',
+    description: 'Lists notifications for the authenticated user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listNotifications(args: { page?: number; pageSize?: number }, context: McpContext): Promise<any> {
+    return this.notificationService.list(context.userId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: 'desc',
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.notifications.unread-count',
+    description: 'Returns the unread notification count for the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getUnreadCount(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.notificationService.unreadCount(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.notifications.mark-read',
+    description: 'Marks a specific notification as read.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Notification ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async markRead(args: { id: number }, context: McpContext): Promise<any> {
+    return this.notificationService.markRead(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'core.notifications.mark-all-read',
+    description: 'Marks all notifications as read for the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+  })
+  async markAllRead(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.notificationService.markAllRead(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.notifications.create',
+    description: 'Creates a new notification for a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'Target user ID' },
+        title: { type: 'string', description: 'Notification title' },
+        message: { type: 'string', description: 'Notification message' },
+        type: { type: 'string', description: 'Notification type (e.g. info, success, error)' },
+      },
+      required: ['userId', 'title', 'message'],
+    },
+  })
+  async createNotification(args: { userId: number; title: string; message: string; type?: string }, _context: McpContext): Promise<any> {
+    return this.notificationService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'core.notifications.delete',
+    description: 'Deletes a specific notification for the authenticated user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Notification ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteNotification(args: { id: number }, context: McpContext): Promise<any> {
+    return this.notificationService.delete(context.userId, args.id);
+  }
+
+  @McpTool({
+    name: 'core.notifications.delete-all',
+    description: 'Deletes all notifications for the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+  })
+  async deleteAllNotifications(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.notificationService.deleteAll(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.notifications.update-progress',
+    description: 'Updates the progress of a notification (e.g. for background job tracking).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Notification ID' },
+        progress: { type: 'number', description: 'Progress value (0-100)' },
+        status: { type: 'string', description: 'Status (e.g. in_progress, completed, failed)' },
+      },
+      required: ['id', 'progress'],
+    },
+  })
+  async updateProgress(args: { id: number; progress: number; status?: string }, context: McpContext): Promise<any> {
+    return this.notificationService.updateProgress(context.userId, args.id, {
+      progress: args.progress,
+      success: args.status === 'failed' ? false : args.status === 'completed' ? true : undefined,
+    });
+  }
+}

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

@@ -0,0 +1,74 @@
+import { Injectable } from '@nestjs/common';
+import { ProfileService } from '../../profile/profile.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreProfileMcpTools {
+  constructor(private readonly profileService: ProfileService) {}
+
+  @McpTool({
+    name: 'core.profile.get',
+    description: 'Returns the authenticated user profile.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getProfile(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.profileService.getProfile(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.profile.update',
+    description: 'Updates the authenticated user profile name.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'New display name' },
+      },
+    },
+  })
+  async updateProfile(args: { name?: string }, context: McpContext): Promise<any> {
+    return this.profileService.update(context.userId, { name: args.name } as any);
+  }
+
+  @McpTool({
+    name: 'core.profile.update-preferences',
+    description: 'Updates authenticated user preferences such as theme and language.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        theme: { type: 'string', description: 'UI theme (e.g. dark, light)' },
+        language: { type: 'string', description: 'Locale code (e.g. en, pt-BR)' },
+      },
+    },
+  })
+  async updatePreferences(args: { theme?: string; language?: string }, context: McpContext): Promise<any> {
+    return this.profileService.updatePreferences(context.locale, context.userId, args as any);
+  }
+
+  @McpTool({
+    name: 'core.profile.mfa.list',
+    description: 'Returns the MFA methods configured for the authenticated user.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getMfaMethods(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.profileService.getMFAMethods(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.profile.change-password',
+    description: 'Changes the password of the authenticated user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        currentPassword: { type: 'string', description: 'Current password' },
+        newPassword: { type: 'string', description: 'New password (must meet strength requirements)' },
+      },
+      required: ['currentPassword', 'newPassword'],
+    },
+  })
+  async changePassword(args: { currentPassword: string; newPassword: string }, context: McpContext): Promise<any> {
+    return this.profileService.changePassword(context.locale, context.userId, args as any);
+  }
+}

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

@@ -0,0 +1,288 @@
+import { Injectable } from '@nestjs/common';
+import { PageOrderDirection } from '@hed-hog/api-pagination';
+import { RoleService } from '../../role/role.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreRolesMcpTools {
+  constructor(private readonly roleService: RoleService) {}
+
+  @McpTool({
+    name: 'core.roles.list',
+    description: 'Lists all roles with optional pagination and search. 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 to filter roles' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listRoles(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.roleService.list(
+      {
+        page: args.page ?? 1,
+        pageSize: args.pageSize ?? 20,
+        search: args.search ?? '',
+        sortField: args.sortField ?? 'id',
+        sortOrder: (args.sortOrder as any) ?? 'asc',
+        fields: '',
+      },
+      context.locale,
+    );
+  }
+
+  @McpTool({
+    name: 'core.roles.get',
+    description: 'Returns a single role by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+      },
+      required: ['roleId'],
+    },
+    readOnly: true,
+  })
+  async getRole(args: { roleId: number }, _context: McpContext): Promise<any> {
+    return this.roleService.get(args.roleId);
+  }
+
+  @McpTool({
+    name: 'core.roles.create',
+    description: 'Creates a new role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Role slug (unique identifier)' },
+        locale: {
+          type: 'object',
+          description: 'Locale translations keyed by locale code, e.g. {"en": {"name": "Admin", "description": "..."}}',
+        },
+      },
+      required: ['slug'],
+    },
+  })
+  async createRole(args: { slug: string; locale?: Record<string, { name: string; description?: string }> }, _context: McpContext): Promise<any> {
+    return this.roleService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'core.roles.update',
+    description: 'Updates an existing role by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        slug: { type: 'string', description: 'New slug' },
+        locale: { type: 'object', description: 'Updated locale translations' },
+      },
+      required: ['roleId'],
+    },
+  })
+  async updateRole(
+    args: { roleId: number; slug?: string; locale?: Record<string, any> },
+    context: McpContext,
+  ): Promise<any> {
+    const { roleId, ...data } = args;
+    return this.roleService.update(roleId, data as any, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.roles.delete',
+    description: 'Deletes one or more roles by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Array of role IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteRoles(args: { ids: number[] }, context: McpContext): Promise<any> {
+    return this.roleService.delete({ ids: args.ids }, context.locale);
+  }
+
+  @McpTool({
+    name: 'core.roles.users.list',
+    description: 'Lists users assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['roleId'],
+    },
+    readOnly: true,
+  })
+  async listRoleUsers(args: { roleId: number; page?: number; pageSize?: number }, _context: McpContext): Promise<any> {
+    return this.roleService.listUsers(args.roleId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: PageOrderDirection.Asc,
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.roles.users.update',
+    description: 'Replaces all users assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'User IDs to assign' },
+      },
+      required: ['roleId', 'ids'],
+    },
+  })
+  async updateRoleUsers(args: { roleId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.roleService.updateUsers(args.roleId, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.roles.menus.list',
+    description: 'Lists menus assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['roleId'],
+    },
+    readOnly: true,
+  })
+  async listRoleMenus(args: { roleId: number; page?: number; pageSize?: number }, context: McpContext): Promise<any> {
+    return this.roleService.listMenus(context.locale, args.roleId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: PageOrderDirection.Asc,
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.roles.menus.update',
+    description: 'Replaces all menus assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Menu IDs to assign' },
+      },
+      required: ['roleId', 'ids'],
+    },
+  })
+  async updateRoleMenus(args: { roleId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.roleService.updateMenus(args.roleId, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.roles.routes.list',
+    description: 'Lists routes assigned to a role with optional URL filter. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search filter for URL' },
+        method: { type: 'string', description: 'HTTP method filter (GET, POST, etc.)' },
+      },
+      required: ['roleId'],
+    },
+    readOnly: true,
+  })
+  async listRoleRoutes(
+    args: { roleId: number; page?: number; pageSize?: number; search?: string; method?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.roleService.listRoutes(
+      args.roleId,
+      {
+        page: args.page ?? 1,
+        pageSize: args.pageSize ?? 20,
+        search: '',
+        sortField: 'id',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+      },
+      args.search,
+      'contains',
+      args.method,
+    );
+  }
+
+  @McpTool({
+    name: 'core.roles.routes.update',
+    description: 'Replaces all routes assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Route IDs to assign' },
+      },
+      required: ['roleId', 'ids'],
+    },
+  })
+  async updateRoleRoutes(args: { roleId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.roleService.updateRoutes(args.roleId, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.roles.screens.list',
+    description: 'Lists screens assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['roleId'],
+    },
+    readOnly: true,
+  })
+  async listRoleScreens(args: { roleId: number; page?: number; pageSize?: number }, context: McpContext): Promise<any> {
+    return this.roleService.listScreens(context.locale, args.roleId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: PageOrderDirection.Asc,
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.roles.screens.update',
+    description: 'Replaces all screens assigned to a role. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        roleId: { type: 'number', description: 'Role ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Screen IDs to assign' },
+      },
+      required: ['roleId', 'ids'],
+    },
+  })
+  async updateRoleScreens(args: { roleId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.roleService.updateScreens(args.roleId, { ids: args.ids });
+  }
+}