@hed-hog/core 0.0.368 → 0.0.371

package/src/mail/mail.controller.ts

@@ -1,5 +1,6 @@
 import { DeleteDTO, Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
+import { renderMailTemplate } from '@hed-hog/api-mail';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
     Body,
@@ -56,35 +57,10 @@ export class MailController {
   ) {
     const locale = queryLocale || decoratorLocale;
     const mail = await this.mailService.get(locale, id);
-    
-    const html = `<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${mail.subject}</title>
-    <style>
-      body {
-        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-        line-height: 1.6;
-        color: #333;
-        max-width: 600px;
-        margin: 0 auto;
-        padding: 20px;
-      }
-      a {
-        color: #0066cc;
-        text-decoration: none;
-      }
-      a:hover {
-        text-decoration: underline;
-      }
-    </style>
-  </head>
-  <body>
-    ${mail.body}
-  </body>
-</html>`;
+    const html = renderMailTemplate({
+      subject: mail.subject,
+      body: mail.body,
+    });
 
     res.setHeader('Content-Disposition', `attachment; filename="${mail.slug}-${locale}.html"`);
     res.send(html);

package/src/mail/mail.module.ts

@@ -28,16 +28,16 @@ import { MailService } from './mail.service';
             profileSettings.map((item) => [item.slug, item.value]),
           );
 
-          const profileId = Number(
-            profileSettingsMap.get('mail-integration-profile-id'),
-          );
+          const profileSlug = String(
+            profileSettingsMap.get('mail-integration-profile-id') ?? '',
+          ).trim();
 
-          if (!profileId || profileId <= 0) {
+          if (!profileSlug) {
             return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;
           }
 
           const profile = await (prisma as any).integration_profile.findUnique({
-            where: { id: profileId },
+            where: { slug: profileSlug },
             include: {
               integration_provider: { select: { slug: true } },
               integration_type: { select: { slug: true } },

package/src/mail/mail.service.ts

@@ -76,20 +76,22 @@ export class MailService implements OnModuleInit {
       const settings = await this.setting.getSettingValues([
         this.integrationProfileSettingSlug,
       ]);
-      const profileId = settings[this.integrationProfileSettingSlug];
+      const profileSlug = String(
+        settings[this.integrationProfileSettingSlug] ?? '',
+      ).trim();
 
-      if (!profileId || Number(profileId) <= 0) {
+      if (!profileSlug) {
         await this.setting.setValue('configured-mail', 'false');
         return;
       }
 
-      const { from, config } = await this.reloadConfig();
+      const { from } = await this.reloadConfig();
 
       await this.mailMainService.send({
         to: from,
         from,
         subject: '[HedHog] Mail configuration validation',
-        body: `This is an automatic validation email for the configured profile (id: ${profileId}).`,
+        body: `This is an automatic validation email for the configured profile (slug: ${profileSlug}).`,
       });
 
       await this.setting.setValue('configured-mail', 'true');
@@ -103,27 +105,29 @@ export class MailService implements OnModuleInit {
 
   /**
    * Reload mail configuration from database and update MailMainService.
-   * When profileId is provided, that profile is used directly.
+   * When profileSlug is provided, that profile is used directly.
     * Otherwise the global integration profile setting is read.
    * Returns the active from address and the built config object.
    */
-  async reloadConfig(profileId?: number): Promise<{ success: boolean; provider: string; from: string; config: any }> {
+  async reloadConfig(profileSlug?: string): Promise<{ success: boolean; provider: string; from: string; config: any }> {
     try {
-      let resolvedProfileId = profileId;
+      let resolvedProfileSlug = String(profileSlug ?? '').trim();
 
-      if (!resolvedProfileId) {
+      if (!resolvedProfileSlug) {
         const settings = await this.setting.getSettingValues([
           this.integrationProfileSettingSlug,
         ]);
-        resolvedProfileId = Number(settings[this.integrationProfileSettingSlug]);
+        resolvedProfileSlug = String(
+          settings[this.integrationProfileSettingSlug] ?? '',
+        ).trim();
       }
 
-      if (!resolvedProfileId || resolvedProfileId <= 0) {
+      if (!resolvedProfileSlug) {
         throw new BadRequestException('No mail profile configured. Set a mail profile in the Mail settings.');
       }
 
       const profile = await this.prismaService.integration_profile.findUnique({
-        where: { id: resolvedProfileId },
+        where: { slug: resolvedProfileSlug },
         include: {
           integration_provider: { select: { slug: true } },
           integration_type: { select: { slug: true } },
@@ -131,12 +135,12 @@ export class MailService implements OnModuleInit {
       });
 
       if (!profile) {
-        throw new NotFoundException(`Mail profile with id ${profileId} not found.`);
+        throw new NotFoundException(`Mail profile with slug "${resolvedProfileSlug}" not found.`);
       }
 
       if (profile.integration_type?.slug !== 'email') {
         throw new BadRequestException(
-          `Integration profile ${resolvedProfileId} is not an email profile.`,
+          `Integration profile "${resolvedProfileSlug}" is not an email profile.`,
         );
       }
 
@@ -155,6 +159,26 @@ export class MailService implements OnModuleInit {
     }
   }
 
+  /**
+   * Sends an ad-hoc HTML email using the configured (or given) mail profile,
+   * without requiring a stored template. Used by other modules (e.g. agent
+   * human-approval notifications).
+   */
+  async sendRawMail({
+    to,
+    subject,
+    html,
+    profileSlug,
+  }: {
+    to: string;
+    subject: string;
+    html: string;
+    profileSlug?: string;
+  }) {
+    const { from } = await this.reloadConfig(profileSlug);
+    return this.mailMainService.send({ to, from, subject, body: html } as any);
+  }
+
 
   async list(locale: string, paginationParams: PaginationDTO) {
     const result = await this.localeService.listModelWithLocale(

package/src/mcp/decorators/mcp-tool.decorator.ts

@@ -1,7 +1,7 @@
-import { SetMetadata } from '@nestjs/common';
-import { McpToolDefinition } from '../interfaces/mcp-tool-definition.interface';
-
-export const MCP_TOOL_METADATA = 'mcp:tool';
-
-export const McpTool = (definition: McpToolDefinition): MethodDecorator =>
-  SetMetadata(MCP_TOOL_METADATA, definition);
+import { SetMetadata } from '@nestjs/common';
+import { McpToolDefinition } from '../interfaces/mcp-tool-definition.interface';
+
+export const MCP_TOOL_METADATA = 'mcp:tool';
+
+export const McpTool = (definition: McpToolDefinition): MethodDecorator =>
+  SetMetadata(MCP_TOOL_METADATA, definition);

package/src/mcp/guards/mcp-permission.guard.ts

@@ -1,51 +1,51 @@
-import { PrismaService } from '@hed-hog/api-prisma';
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-} from '@nestjs/common';
-import { Request } from 'express';
-
-@Injectable()
-export class McpPermissionGuard implements CanActivate {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest<Request>();
-
-    // Only POST requests carry tool invocations
-    if (request.method !== 'POST') return true;
-
-    const body = request.body as any;
-    const toolName: string | undefined =
-      body?.method === 'tools/call' ? body?.params?.name : undefined;
-
-    // tools/list, initialize, ping, etc. — no per-tool permission check needed
-    if (!toolName) return true;
-
-    const userId = (request as any)?.auth?.sub;
-
-    const count = await this.prisma.route.count({
-      where: {
-        type: 'MCP' as any,
-        tool_name: toolName,
-        role_route: {
-          some: {
-            role: {
-              role_user: {
-                some: { user_id: userId },
-              },
-            },
-          },
-        },
-      },
-    });
-
-    if (count === 0) {
-      throw new ForbiddenException(`Access denied to MCP tool '${toolName}'`);
-    }
-
-    return true;
-  }
-}
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+} from '@nestjs/common';
+import { Request } from 'express';
+
+@Injectable()
+export class McpPermissionGuard implements CanActivate {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request>();
+
+    // Only POST requests carry tool invocations
+    if (request.method !== 'POST') return true;
+
+    const body = request.body as any;
+    const toolName: string | undefined =
+      body?.method === 'tools/call' ? body?.params?.name : undefined;
+
+    // tools/list, initialize, ping, etc. — no per-tool permission check needed
+    if (!toolName) return true;
+
+    const userId = (request as any)?.auth?.sub;
+
+    const count = await this.prisma.route.count({
+      where: {
+        type: 'MCP' as any,
+        tool_name: toolName,
+        role_route: {
+          some: {
+            role: {
+              role_user: {
+                some: { user_id: userId },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (count === 0) {
+      throw new ForbiddenException(`Access denied to MCP tool '${toolName}'`);
+    }
+
+    return true;
+  }
+}

package/src/mcp/interfaces/mcp-tool-definition.interface.ts

@@ -1,6 +1,6 @@
-export interface McpToolDefinition {
-  name: string;
-  description: string;
-  inputSchema?: Record<string, any>;
-  readOnly?: boolean;
-}
+export interface McpToolDefinition {
+  name: string;
+  description: string;
+  inputSchema?: Record<string, any>;
+  readOnly?: boolean;
+}

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

@@ -1,87 +1,87 @@
-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 { 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;
+  }
+}

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

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

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

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

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

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

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

@@ -860,28 +860,28 @@ export class McpChatService {
 
   private async getProviderKey(): Promise<{ provider: 'openai' | 'gemini'; apiKey: string }> {
     const settings = await this.setting.getSettingValues(['mcp-ai-profile-id']);
-    const profileId = Number(settings['mcp-ai-profile-id']);
+    const profileSlug = String(settings['mcp-ai-profile-id'] ?? '').trim();
 
-    if (!profileId) {
+    if (!profileSlug) {
       throw new BadRequestException(
         'No MCP AI profile configured. Select one in Settings → MCP.',
       );
     }
 
     const profile = await this.prisma.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: { integration_provider: { select: { slug: true } } },
     });
 
     if (!profile) {
-      throw new BadRequestException(`MCP AI profile ${profileId} not found.`);
+      throw new BadRequestException(`MCP AI profile "${profileSlug}" not found.`);
     }
 
     const providerSlug = profile.integration_provider.slug;
     const { apiKey } = buildAiConfigFromIntegration(providerSlug, profile.config);
 
     if (!apiKey) {
-      throw new BadRequestException(`MCP AI profile ${profileId} has no API key configured.`);
+      throw new BadRequestException(`MCP AI profile "${profileSlug}" has no API key configured.`);
     }
 
     return { provider: providerSlug === 'gemini' ? 'gemini' : 'openai', apiKey };

package/src/notification/events/notification-stale-progress-check.event.ts

@@ -1,5 +1,5 @@
-export const NOTIFICATION_STALE_PROGRESS_CHECK = 'notification.stale-progress-check';
-
-export class NotificationStaleProgressCheckEvent {
-  constructor(public readonly userId: number) {}
-}
+export const NOTIFICATION_STALE_PROGRESS_CHECK = 'notification.stale-progress-check';
+
+export class NotificationStaleProgressCheckEvent {
+  constructor(public readonly userId: number) {}
+}