@hed-hog/core 0.0.366 → 0.0.368

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/notification/events/notification-stale-progress-check.event.ts

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

package/src/notification/notification.service.ts

@@ -11,12 +11,17 @@ import {
     OnModuleDestroy,
     OnModuleInit,
 } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import type { Request, Response } from 'express';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import { Client, type Notification as PgNotification } from 'pg';
 import { CreateNotificationDto } from './dto/create-notification.dto';
 import { UpdateProgressDto } from './dto/update-progress.dto';
+import {
+    NOTIFICATION_STALE_PROGRESS_CHECK,
+    NotificationStaleProgressCheckEvent,
+} from './events/notification-stale-progress-check.event';
 
 type NotificationStreamEventType =
   | 'ready'
@@ -47,6 +52,7 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
     private readonly prisma: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly pagination: PaginationService,
+    private readonly eventEmitter: EventEmitter2,
   ) {
     this.notificationEvents.setMaxListeners(0);
   }
@@ -106,32 +112,13 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
   }
 
   private async cleanupStaleProgressNotifications(userId: number) {
-    const stale = await this.prisma.$queryRaw<{ id: number }[]>`
-      SELECT n.id
-      FROM notification n
-      WHERE n.user_id = ${userId}
-        AND n.progress IS NOT NULL
-        AND n.progress < 100
-        AND n.finished_at IS NULL
-        AND (n.action_data->>'queueJobId') IS NOT NULL
-        AND NOT EXISTS (
-          SELECT 1 FROM queue_job qj
-          WHERE qj.id = (n.action_data->>'queueJobId')::int
-        )
-    `;
-
-    if (!stale.length) return;
-
-    await this.prisma.notification.updateMany({
-      where: { id: { in: stale.map((n) => n.id) } },
-      data: {
-        progress: 100,
-        type: 'error' as any,
-        body: 'O processamento foi interrompido (job não encontrado).',
-        finished_at: new Date(),
-      },
-    });
+    await this.eventEmitter.emitAsync(
+      NOTIFICATION_STALE_PROGRESS_CHECK,
+      new NotificationStaleProgressCheckEvent(userId),
+    );
+  }
 
+  async notifyUpdated(userId: number) {
     await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
   }
 

package/src/route/dto/create.dto.ts

@@ -1,32 +1,32 @@
-import { getLocaleText } from '@hed-hog/api-locale';
-import { IsIn, IsOptional, IsString } from 'class-validator';
-import { HttpMethod } from '../../types/http-method';
-
-export type RouteType = 'HTTP' | 'MCP';
-
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
-
-export class CreateDTO {
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
-  url?: string;
-
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
-  @IsIn(HTTP_METHODS, {
-    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
-  })
-  method?: HttpMethod;
-
-  @IsOptional()
-  @IsIn(['HTTP', 'MCP'])
-  type?: RouteType;
-
-  @IsOptional()
-  @IsString()
-  tool_name?: string;
-
-  @IsOptional()
-  @IsString()
-  name?: string;
-}
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+
+export type RouteType = 'HTTP' | 'MCP';
+
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+
+export class CreateDTO {
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  url?: string;
+
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsIn(HTTP_METHODS, {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method?: HttpMethod;
+
+  @IsOptional()
+  @IsIn(['HTTP', 'MCP'])
+  type?: RouteType;
+
+  @IsOptional()
+  @IsString()
+  tool_name?: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+}

package/src/route/dto/update.dto.ts

@@ -1,31 +1,31 @@
-import { getLocaleText } from '@hed-hog/api-locale';
-import { IsIn, IsOptional, IsString } from 'class-validator';
-import { HttpMethod } from '../../types/http-method';
-import { RouteType } from './create.dto';
-
-const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
-
-export class UpdateDTO {
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
-  url?: string;
-
-  @IsOptional()
-  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
-  @IsIn(HTTP_METHODS, {
-    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
-  })
-  method?: HttpMethod;
-
-  @IsOptional()
-  @IsIn(['HTTP', 'MCP'])
-  type?: RouteType;
-
-  @IsOptional()
-  @IsString()
-  tool_name?: string;
-
-  @IsOptional()
-  @IsString()
-  name?: string;
-}
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsIn, IsOptional, IsString } from 'class-validator';
+import { HttpMethod } from '../../types/http-method';
+import { RouteType } from './create.dto';
+
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+
+export class UpdateDTO {
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.urlMustBeString', args.value) })
+  url?: string;
+
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.methodMustBeString', args.value) })
+  @IsIn(HTTP_METHODS, {
+    message: (args) => getLocaleText('validation.methodMustBeValid', args.value),
+  })
+  method?: HttpMethod;
+
+  @IsOptional()
+  @IsIn(['HTTP', 'MCP'])
+  type?: RouteType;
+
+  @IsOptional()
+  @IsString()
+  tool_name?: string;
+
+  @IsOptional()
+  @IsString()
+  name?: string;
+}

package/src/task/task.service.ts

@@ -42,6 +42,9 @@ export class TasksService {
     await this.clearOldNotifications();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
+    await this.clearStaleAsyncNotifications();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
     await this.clearOldAccessLogs();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
@@ -322,4 +325,53 @@ export class TasksService {
       `Old notifications cleaned up in ${Date.now() - startAt}ms`,
     );
   }
+
+  /**
+   * Remove notificações assíncronas que ficaram "travadas" em andamento por tempo demais.
+   *
+   * Uma notificação assíncrona está em andamento quando possui acompanhamento de progresso
+   * (progress IS NOT NULL) que ainda não chegou ao fim (progress < 100) e que nunca foi
+   * finalizada (finished_at IS NULL). Se o job que a alimenta morre ou trava, a notificação
+   * permanece eternamente "rodando".
+   *
+   * Remove registros da tabela notification que:
+   * - Estão em andamento (progress IS NOT NULL AND progress < 100 AND finished_at IS NULL)
+   * - Começaram a rodar há mais horas do que o valor de stale-async-notification-hours,
+   *   medido por COALESCE(started_at, created_at)
+   *
+   * Por quê: notificações assíncronas presas poluem a interface (barra de progresso eterna)
+   * e o banco. A remoção periódica baseada em tempo as descarta de forma previsível.
+   *
+   * Limite: cleanup-batch-limit registros por execução para evitar lock prolongado da tabela.
+   */
+  private async clearStaleAsyncNotifications(): Promise<void> {
+    const settings = await this.settingService.getSettingValues([
+      'cleanup-batch-limit',
+      'stale-async-notification-hours',
+    ]);
+    const batchLimit = Number(settings['cleanup-batch-limit']) || 20000;
+    const staleHours = Number(settings['stale-async-notification-hours']) || 24;
+    this.logger.verbose('Starting cleanup of stale async notifications');
+    const startAt = Date.now();
+
+    await this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM notification
+        WHERE progress IS NOT NULL
+          AND progress < 100
+          AND finished_at IS NULL
+          AND COALESCE(started_at, created_at) < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(staleHours))} hours'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM notification n
+      USING del
+      WHERE n.id = del.id
+    `;
+
+    this.logger.verbose(
+      `Stale async notifications cleaned up in ${Date.now() - startAt}ms`,
+    );
+  }
 }

package/src/user/user.controller.ts

@@ -1,4 +1,4 @@
-import { Public, Role } from '@hed-hog/api';
+import { Public, Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
@@ -64,9 +64,10 @@ export class UserController {
   async update(
     @Param('userId', ParseIntPipe) userId: number,
     @Body() data: UpdateDTO,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.update(locale, userId, data);
+    return this.userService.update(locale, userId, data, actor?.id);
   }
 
   @Patch(':userId/reset-password')
@@ -74,8 +75,9 @@ export class UserController {
     @Param('userId', ParseIntPipe) userId: number,
     @Body() data: ResetPasswordDTO,
     @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.resetPassword(locale, userId, data);
+    return this.userService.resetPassword(locale, userId, data, actor?.id);
   }
 
   @UseInterceptors(
@@ -93,8 +95,9 @@ export class UserController {
     @Locale() locale: string,
     @Param('userId', ParseIntPipe) userId: number,
     @UploadedFile() avatar: MulterFile,
+    @User() actor,
   ) {
-    return this.userService.changeAvatar(locale, userId, avatar)
+    return this.userService.changeAvatar(locale, userId, avatar, actor?.id)
   }
 
   @Post(':userId/verify-identifier/:identifierId')
@@ -132,21 +135,32 @@ export class UserController {
     return this.userService.getUserRoutes(locale, userId);
   }
 
+  @Get(':userId/log')
+  async listLogs(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Pagination() paginationParams,
+    @Locale() locale: string,
+  ) {
+    return this.userService.listUserChangeLogs(locale, userId, paginationParams);
+  }
+
   @Post(':userId/role/:roleId')
   async assignRoleToUser(
     @Param('userId', ParseIntPipe) userId: number,
     @Param('roleId', ParseIntPipe) roleId: number,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.assignRoleToUser(locale, userId, roleId);
+    return this.userService.assignRoleToUser(locale, userId, roleId, actor?.id);
   }
 
   @Delete(':userId/role/:roleId')
   async removeRoleFromUser(
     @Param('userId', ParseIntPipe) userId: number,
     @Param('roleId', ParseIntPipe) roleId: number,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.removeRoleFromUser(locale, userId, roleId);
+    return this.userService.removeRoleFromUser(locale, userId, roleId, actor?.id);
   }
 }