@hed-hog/core 0.0.328 → 0.0.330

package/src/mcp/mcp.module.ts

@@ -0,0 +1,36 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { DiscoveryModule } from '@nestjs/core';
+import { SettingModule } from '../setting/setting.module';
+import { TokenModule } from '../token/token.module';
+import { UserModule } from '../user/user.module';
+import { McpAuthGuard } from './guards/mcp-auth.guard';
+import { McpPermissionGuard } from './guards/mcp-permission.guard';
+import { McpAuditService } from './mcp-audit.service';
+import { McpRegistryService } from './mcp-registry.service';
+import { McpServerService } from './mcp-server.service';
+import { McpController } from './mcp.controller';
+import { CoreSettingsMcpTools } from './tools/core-settings.mcp-tools';
+import { CoreUsersMcpTools } from './tools/core-users.mcp-tools';
+
+@Module({
+  imports: [
+    DiscoveryModule,
+    forwardRef(() => PrismaModule),
+    forwardRef(() => TokenModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => UserModule),
+  ],
+  controllers: [McpController],
+  providers: [
+    McpRegistryService,
+    McpServerService,
+    McpAuditService,
+    McpAuthGuard,
+    McpPermissionGuard,
+    CoreSettingsMcpTools,
+    CoreUsersMcpTools,
+  ],
+  exports: [McpRegistryService, McpServerService],
+})
+export class McpModule {}

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

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import { SettingService } from '../../setting/setting.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreSettingsMcpTools {
+  constructor(private readonly settingService: SettingService) {}
+
+  @McpTool({
+    name: 'core.settings.get',
+    description: 'Returns effective settings for the authenticated user',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getEffectiveSettings(
+    _args: Record<string, any>,
+    context: McpContext,
+  ): Promise<any> {
+    return this.settingService.getEffectiveSettings(context.userId);
+  }
+
+  @McpTool({
+    name: 'core.settings.set',
+    description:
+      'Updates a user-overridable setting value for the authenticated user. Only settings with user_override=true can be changed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: {
+          type: 'string',
+          description: 'The slug identifier of the setting to update',
+        },
+        value: {
+          type: 'string',
+          description: 'The new value for the setting',
+        },
+      },
+      required: ['slug', 'value'],
+    },
+  })
+  async setUserSetting(
+    args: { slug: string; value: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.settingService.setSettingUserValue(
+      context.locale,
+      context.userId,
+      args.slug,
+      args.value,
+    );
+  }
+}

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

@@ -0,0 +1,267 @@
+import { Injectable } from '@nestjs/common';
+import { UserService } from '../../user/user.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreUsersMcpTools {
+  constructor(private readonly userService: UserService) {}
+
+  @McpTool({
+    name: 'core.users.me',
+    description: 'Returns the authenticated user profile',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getMe(_args: Record<string, any>, context: McpContext): Promise<any> {
+    return this.userService.findUserById(context.locale, context.userId);
+  }
+
+  @McpTool({
+    name: 'core.users.list',
+    description: 'Lists all users 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 users' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listUsers(
+    args: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: string;
+    },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.userService.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.users.get',
+    description: 'Returns a single user by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+      },
+      required: ['userId'],
+    },
+    readOnly: true,
+  })
+  async getUser(
+    args: { userId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.get(context.locale, args.userId);
+  }
+
+  @McpTool({
+    name: 'core.users.create',
+    description: 'Creates a new user with email and password. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'User email address' },
+        password: { type: 'string', description: 'User password' },
+        name: { type: 'string', description: 'User full name' },
+      },
+      required: ['email', 'password', 'name'],
+    },
+  })
+  async createUser(
+    args: { email: string; password: string; name: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.createWithEmailAndPassword(context.locale, args as any);
+  }
+
+  @McpTool({
+    name: 'core.users.update',
+    description: 'Updates a user name by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+        name: { type: 'string', description: 'New user name' },
+      },
+      required: ['userId'],
+    },
+  })
+  async updateUser(
+    args: { userId: number; name?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.update(context.locale, args.userId, { name: args.name } as any);
+  }
+
+  @McpTool({
+    name: 'core.users.reset-password',
+    description: 'Resets the password of a user by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+        password: { type: 'string', description: 'New password (must meet strength requirements)' },
+      },
+      required: ['userId'],
+    },
+  })
+  async resetPassword(
+    args: { userId: number; password?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.resetPassword(context.locale, args.userId, { password: args.password } as any);
+  }
+
+  @McpTool({
+    name: 'core.users.delete',
+    description: 'Deletes one or more users by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: {
+          type: 'array',
+          items: { type: 'number' },
+          description: 'Array of user IDs to delete',
+        },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteUsers(
+    args: { ids: number[] },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.delete(context.locale, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.users.roles',
+    description: 'Returns the roles assigned to a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+      },
+      required: ['userId'],
+    },
+    readOnly: true,
+  })
+  async getUserRoles(
+    args: { userId: number },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.userService.getUserRoles(args.userId);
+  }
+
+  @McpTool({
+    name: 'core.users.menus',
+    description: 'Returns the menu items accessible to a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+      },
+      required: ['userId'],
+    },
+    readOnly: true,
+  })
+  async getUserMenus(
+    args: { userId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.getUserMenus(context.locale, args.userId);
+  }
+
+  @McpTool({
+    name: 'core.users.routes',
+    description: 'Returns the routes accessible to a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+      },
+      required: ['userId'],
+    },
+    readOnly: true,
+  })
+  async getUserRoutes(
+    args: { userId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.getUserRoutes(context.locale, args.userId);
+  }
+
+  @McpTool({
+    name: 'core.users.assign-role',
+    description: 'Assigns a role to a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+        roleId: { type: 'number', description: 'Role ID to assign' },
+      },
+      required: ['userId', 'roleId'],
+    },
+  })
+  async assignRole(
+    args: { userId: number; roleId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.assignRoleToUser(context.locale, args.userId, args.roleId);
+  }
+
+  @McpTool({
+    name: 'core.users.remove-role',
+    description: 'Removes a role from a user. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+        roleId: { type: 'number', description: 'Role ID to remove' },
+      },
+      required: ['userId', 'roleId'],
+    },
+  })
+  async removeRole(
+    args: { userId: number; roleId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.removeRoleFromUser(context.locale, args.userId, args.roleId);
+  }
+
+  @McpTool({
+    name: 'core.users.verify-identifier',
+    description: 'Verifies a user identifier (e.g. email confirmation). Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        userId: { type: 'number', description: 'User ID' },
+        identifierId: { type: 'number', description: 'Identifier ID to verify' },
+      },
+      required: ['userId', 'identifierId'],
+    },
+  })
+  async verifyIdentifier(
+    args: { userId: number; identifierId: number },
+    context: McpContext,
+  ): Promise<any> {
+    return this.userService.verifyIdentifier(context.locale, args.userId, args.identifierId);
+  }
+}

package/src/mcp/types/mcp-context.type.ts

@@ -0,0 +1,6 @@
+export type McpContext = {
+  userId: number;
+  sessionId: string;
+  locale: string;
+  toolName: string;
+};

package/src/mcp-chat/dto/create-conversation.dto.ts

@@ -0,0 +1,7 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class CreateConversationDTO {
+  @IsOptional()
+  @IsString()
+  title?: string;
+}

package/src/mcp-chat/dto/send-message.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class SendMessageDTO {
+  @IsString()
+  @IsNotEmpty()
+  message: string;
+}

package/src/mcp-chat/mcp-chat.controller.ts

@@ -0,0 +1,60 @@
+import { Role, User } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Post,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { CreateConversationDTO } from './dto/create-conversation.dto';
+import { SendMessageDTO } from './dto/send-message.dto';
+import { McpChatService } from './mcp-chat.service';
+
+@Role()
+@Controller('mcp-chat')
+export class McpChatController {
+  constructor(private readonly service: McpChatService) {}
+
+  @Get()
+  listConversations(@User() { id }: { id: number }) {
+    return this.service.listConversations(id);
+  }
+
+  @Post()
+  createConversation(
+    @User() { id }: { id: number },
+    @Body() dto: CreateConversationDTO,
+  ) {
+    return this.service.createConversation(id, dto);
+  }
+
+  @Delete()
+  deleteConversations(
+    @User() { id }: { id: number },
+    @Body() dto: DeleteDTO,
+  ) {
+    return this.service.deleteConversations(id, dto.ids);
+  }
+
+  @Get(':id/messages')
+  getMessages(
+    @User() { id }: { id: number },
+    @Param('id', ParseIntPipe) conversationId: number,
+  ) {
+    return this.service.getMessages(conversationId, id);
+  }
+
+  @Post(':id/messages')
+  sendMessage(
+    @User() { id }: { id: number },
+    @Param('id', ParseIntPipe) conversationId: number,
+    @Body() dto: SendMessageDTO,
+    @Locale() locale: string,
+  ) {
+    return this.service.sendMessage(conversationId, id, locale, dto.message);
+  }
+}

package/src/mcp-chat/mcp-chat.module.ts

@@ -0,0 +1,17 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { Module, forwardRef } from '@nestjs/common';
+import { McpModule } from '../mcp/mcp.module';
+import { SettingModule } from '../setting/setting.module';
+import { McpChatController } from './mcp-chat.controller';
+import { McpChatService } from './mcp-chat.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => McpModule),
+  ],
+  controllers: [McpChatController],
+  providers: [McpChatService],
+})
+export class McpChatModule {}