@hed-hog/core 0.0.327 → 0.0.329

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 {}

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

@@ -0,0 +1,332 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  ForbiddenException,
+  forwardRef,
+  HttpException,
+  HttpStatus,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import axios from 'axios';
+import { SettingService } from '../setting/setting.service';
+import { McpContext } from '../mcp/types/mcp-context.type';
+import { McpRegistryService } from '../mcp/mcp-registry.service';
+import { CreateConversationDTO } from './dto/create-conversation.dto';
+
+type OpenAiMessage =
+  | { role: 'system'; content: string }
+  | { role: 'user'; content: string }
+  | { role: 'assistant'; content: string | null; tool_calls?: OpenAiToolCall[] }
+  | { role: 'tool'; tool_call_id: string; content: string };
+
+interface OpenAiToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+const SYSTEM_PROMPT =
+  'You are a helpful assistant with access to tools from the HedHog system. ' +
+  'Use the available tools to answer the user\'s questions accurately. ' +
+  'Always respond in the same language the user writes in.';
+
+const sanitize = (n: string) => n.replace(/\./g, '__');
+const restore = (n: string) => n.replace(/__/g, '.');
+
+@Injectable()
+export class McpChatService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+    @Inject(forwardRef(() => McpRegistryService))
+    private readonly registry: McpRegistryService,
+  ) {}
+
+  async listConversations(userId: number) {
+    return this.prisma.mcp_conversation.findMany({
+      where: { user_id: userId },
+      orderBy: { created_at: 'desc' },
+      select: { id: true, title: true, created_at: true, updated_at: true },
+    });
+  }
+
+  async createConversation(userId: number, dto: CreateConversationDTO) {
+    return this.prisma.mcp_conversation.create({
+      data: {
+        user_id: userId,
+        title: dto.title ?? null,
+      },
+    });
+  }
+
+  async deleteConversations(userId: number, ids: number[]) {
+    await this.prisma.mcp_conversation.deleteMany({
+      where: { id: { in: ids }, user_id: userId },
+    });
+    return { count: ids.length };
+  }
+
+  async getMessages(conversationId: number, userId: number) {
+    await this.assertOwnership(conversationId, userId);
+    return this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+  }
+
+  async sendMessage(
+    conversationId: number,
+    userId: number,
+    locale: string,
+    message: string,
+  ) {
+    await this.assertOwnership(conversationId, userId);
+
+    const apiKey = await this.getOpenAiKey();
+
+    // Save user message
+    await this.prisma.mcp_conversation_message.create({
+      data: {
+        conversation_id: conversationId,
+        role: 'user',
+        content: message,
+      },
+    });
+
+    // Auto-set title on first message
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+    });
+    if (!conv!.title) {
+      await this.prisma.mcp_conversation.update({
+        where: { id: conversationId },
+        data: { title: message.slice(0, 60) },
+      });
+    }
+
+    // Build OpenAI messages from history
+    const history = await this.prisma.mcp_conversation_message.findMany({
+      where: { conversation_id: conversationId },
+      orderBy: { created_at: 'asc' },
+    });
+
+    const openAiMessages: OpenAiMessage[] = [
+      { role: 'system', content: SYSTEM_PROMPT },
+      ...this.toOpenAiMessages(history),
+    ];
+
+    // Build tool definitions
+    const tools = this.registry.getAll().map((entry) => ({
+      type: 'function' as const,
+      function: {
+        name: sanitize(entry.definition.name),
+        description: entry.definition.description,
+        parameters: entry.definition.inputSchema ?? {
+          type: 'object',
+          properties: {},
+        },
+      },
+    }));
+
+    // Tool-calling loop
+    let maxIterations = 10;
+    while (maxIterations-- > 0) {
+      let response: any;
+      try {
+        response = await axios.post(
+          'https://api.openai.com/v1/chat/completions',
+          {
+            model: 'gpt-4o-mini',
+            messages: openAiMessages,
+            tools: tools.length > 0 ? tools : undefined,
+            tool_choice: tools.length > 0 ? 'auto' : undefined,
+          },
+          {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+      } catch (err: any) {
+        const status = err?.response?.status;
+        const errBody = err?.response?.data?.error;
+        if (status === 429) {
+          throw new HttpException(
+            errBody?.message ?? 'OpenAI rate limit exceeded. Please try again later.',
+            HttpStatus.TOO_MANY_REQUESTS,
+          );
+        }
+        if (status === 401) {
+          throw new BadRequestException('Invalid OpenAI API key.');
+        }
+        throw new HttpException(
+          errBody?.message ?? 'OpenAI API error.',
+          status ?? HttpStatus.BAD_GATEWAY,
+        );
+      }
+
+      const choice = response.data?.choices?.[0];
+      const assistantMsg = choice?.message;
+
+      if (assistantMsg?.tool_calls?.length) {
+        // Add assistant tool-call message to context
+        openAiMessages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: assistantMsg.tool_calls,
+        });
+
+        // Execute each tool call
+        for (const toolCall of assistantMsg.tool_calls as OpenAiToolCall[]) {
+          const originalName = restore(toolCall.function.name);
+          const argsJson = toolCall.function.arguments;
+          let args: Record<string, any> = {};
+          try {
+            args = JSON.parse(argsJson);
+          } catch {
+            args = {};
+          }
+
+          // Persist tool_call message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_call',
+              content: argsJson,
+              tool_name: originalName,
+              tool_call_id: toolCall.id,
+            },
+          });
+
+          // Execute the tool
+          let resultContent: string;
+          const entry = this.registry.get(originalName);
+          if (entry) {
+            const context: McpContext = {
+              userId,
+              sessionId: '',
+              locale,
+              toolName: originalName,
+            };
+            try {
+              const result = await entry.handler(args, context);
+              resultContent = JSON.stringify(result);
+            } catch (e: any) {
+              resultContent = JSON.stringify({ error: e.message });
+            }
+          } else {
+            resultContent = JSON.stringify({ error: `Tool '${originalName}' not found` });
+          }
+
+          // Persist tool_result message
+          await this.prisma.mcp_conversation_message.create({
+            data: {
+              conversation_id: conversationId,
+              role: 'tool_result',
+              content: resultContent,
+              tool_name: originalName,
+              tool_call_id: toolCall.id,
+            },
+          });
+
+          // Add tool result to context for next iteration
+          openAiMessages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: resultContent,
+          });
+        }
+
+        continue; // next iteration with tool results
+      }
+
+      // Final assistant response
+      const finalContent: string = assistantMsg?.content || '';
+      await this.prisma.mcp_conversation_message.create({
+        data: {
+          conversation_id: conversationId,
+          role: 'assistant',
+          content: finalContent,
+        },
+      });
+
+      return this.prisma.mcp_conversation_message.findMany({
+        where: { conversation_id: conversationId },
+        orderBy: { created_at: 'asc' },
+      });
+    }
+
+    throw new BadRequestException('Maximum tool call iterations exceeded.');
+  }
+
+  private toOpenAiMessages(
+    history: Array<{
+      role: string;
+      content: string;
+      tool_name: string | null;
+      tool_call_id: string | null;
+    }>,
+  ): OpenAiMessage[] {
+    const messages: OpenAiMessage[] = [];
+    const toolCallMap = new Map<string, string>(); // tool_call_id → sanitized name
+
+    for (const msg of history) {
+      if (msg.role === 'user') {
+        messages.push({ role: 'user', content: msg.content });
+      } else if (msg.role === 'assistant') {
+        messages.push({ role: 'assistant', content: msg.content });
+      } else if (msg.role === 'tool_call' && msg.tool_call_id && msg.tool_name) {
+        const sanitizedName = sanitize(msg.tool_name);
+        toolCallMap.set(msg.tool_call_id, sanitizedName);
+        messages.push({
+          role: 'assistant',
+          content: null,
+          tool_calls: [
+            {
+              id: msg.tool_call_id,
+              type: 'function',
+              function: { name: sanitizedName, arguments: msg.content },
+            },
+          ],
+        });
+      } else if (msg.role === 'tool_result' && msg.tool_call_id) {
+        messages.push({
+          role: 'tool',
+          tool_call_id: msg.tool_call_id,
+          content: msg.content,
+        });
+      }
+    }
+
+    return messages;
+  }
+
+  private async assertOwnership(conversationId: number, userId: number) {
+    const conv = await this.prisma.mcp_conversation.findUnique({
+      where: { id: conversationId },
+      select: { user_id: true },
+    });
+    if (!conv) {
+      throw new NotFoundException(`Conversation ${conversationId} not found.`);
+    }
+    if (conv.user_id !== userId) {
+      throw new ForbiddenException('Access denied to this conversation.');
+    }
+  }
+
+  private async getOpenAiKey(): Promise<string> {
+    const settings = await this.setting.getSettingValues(['ai-openai-api-key']);
+    const key = settings['ai-openai-api-key'];
+    if (!key) {
+      throw new BadRequestException(
+        'OpenAI API key is not configured (setting "ai-openai-api-key").',
+      );
+    }
+    return key;
+  }
+}