@hed-hog/core 0.0.349 → 0.0.351

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

@@ -1,53 +1,171 @@
-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,
-    );
-  }
-}
+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,
+    );
+  }
+
+  @McpTool({
+    name: 'core.settings.list',
+    description: 'Lists all settings 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' },
+        sortField: { type: 'string', description: 'Field to sort by' },
+        sortOrder: { type: 'string', enum: ['asc', 'desc'], description: 'Sort direction' },
+      },
+    },
+    readOnly: true,
+  })
+  async listSettings(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.settingService.listSettings(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.settings.get-by-id',
+    description: 'Returns a single setting by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        settingId: { type: 'number', description: 'Setting ID' },
+      },
+      required: ['settingId'],
+    },
+    readOnly: true,
+  })
+  async getSettingById(args: { settingId: number }, _context: McpContext): Promise<any> {
+    return this.settingService.get(args.settingId);
+  }
+
+  @McpTool({
+    name: 'core.settings.groups.list',
+    description: 'Lists setting groups with optional 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' },
+      },
+    },
+    readOnly: true,
+  })
+  async listSettingGroups(
+    args: { page?: number; pageSize?: number; search?: string },
+    context: McpContext,
+  ): Promise<any> {
+    return this.settingService.listSettingGroups(context.locale, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: args.search ?? '',
+      sortField: 'id',
+      sortOrder: 'asc' as any,
+      fields: '',
+    });
+  }
+
+  @McpTool({
+    name: 'core.settings.set-many',
+    description: 'Updates multiple settings at once. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        settings: { type: 'object', description: 'Key-value pairs of slug → value to update' },
+      },
+      required: ['settings'],
+    },
+  })
+  async setManySettings(args: { settings: Record<string, string> }, _context: McpContext): Promise<any> {
+    return this.settingService.setManySettings(args.settings as any);
+  }
+
+  @McpTool({
+    name: 'core.settings.update-from-slug',
+    description: 'Updates a single setting value by its slug. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        slug: { type: 'string', description: 'Setting slug' },
+        value: { type: 'string', description: 'New value' },
+      },
+      required: ['slug', 'value'],
+    },
+  })
+  async updateSettingFromSlug(args: { slug: string; value: string }, _context: McpContext): Promise<any> {
+    return this.settingService.updateFromSlug(args.slug, { value: args.value } as any);
+  }
+
+  @McpTool({
+    name: 'core.settings.delete',
+    description: 'Deletes one or more settings by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Setting IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteSettings(args: { ids: number[] }, context: McpContext): Promise<any> {
+    return this.settingService.delete(context.locale, { ids: args.ids });
+  }
+}

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

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { SystemService } from '../../core/system.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreSystemMcpTools {
+  constructor(private readonly systemService: SystemService) {}
+
+  @McpTool({
+    name: 'core.system.info',
+    description: 'Returns system information including OS, database, modules, and disk usage. Admin only.',
+    inputSchema: { type: 'object', properties: {} },
+    readOnly: true,
+  })
+  async getSystemInfo(_args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.systemService.index();
+  }
+}

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

@@ -0,0 +1,199 @@
+import { Injectable } from '@nestjs/common';
+import { WebhookIntegrationService } from '../../webhook-integration/webhook-integration.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+@Injectable()
+export class CoreWebhooksMcpTools {
+  constructor(private readonly webhookService: WebhookIntegrationService) {}
+
+  @McpTool({
+    name: 'core.webhooks.list',
+    description: 'Lists webhook integrations with optional 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 listWebhooks(
+    args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.webhookService.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.webhooks.get',
+    description: 'Returns a single webhook integration by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Webhook ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getWebhook(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.webhookService.get(args.id);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.create',
+    description: 'Creates a new webhook integration. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Webhook name' },
+        slug: { type: 'string', description: 'Webhook slug' },
+        description: { type: 'string', description: 'Webhook description' },
+      },
+      required: ['name'],
+    },
+  })
+  async createWebhook(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.webhookService.create(args);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.update',
+    description: 'Updates an existing webhook integration by ID. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Webhook ID' },
+        name: { type: 'string', description: 'New name' },
+        slug: { type: 'string', description: 'New slug' },
+        description: { type: 'string', description: 'New description' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateWebhook(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...data } = args;
+    return this.webhookService.update(id, data);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.delete',
+    description: 'Deletes one or more webhook integrations by their IDs. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: 'Webhook IDs to delete' },
+      },
+      required: ['ids'],
+    },
+  })
+  async deleteWebhooks(args: { ids: number[] }, _context: McpContext): Promise<any> {
+    return this.webhookService.delete({ ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.webhooks.actions.list',
+    description: 'Lists actions configured for a webhook. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Webhook ID' },
+      },
+      required: ['webhookId'],
+    },
+    readOnly: true,
+  })
+  async listWebhookActions(args: { webhookId: number }, _context: McpContext): Promise<any> {
+    return this.webhookService.listActions(args.webhookId);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.actions.create',
+    description: 'Creates a new action for a webhook. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Webhook ID' },
+        type: { type: 'string', description: 'Action type (e.g. email, http)' },
+        config: { type: 'object', description: 'Action configuration' },
+      },
+      required: ['webhookId', 'type'],
+    },
+  })
+  async createWebhookAction(args: { webhookId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { webhookId, ...data } = args;
+    return this.webhookService.createAction(webhookId, data);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.actions.update',
+    description: 'Updates an existing webhook action. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Webhook ID' },
+        actionId: { type: 'number', description: 'Action ID' },
+        type: { type: 'string', description: 'New action type' },
+        config: { type: 'object', description: 'New action configuration' },
+      },
+      required: ['webhookId', 'actionId'],
+    },
+  })
+  async updateWebhookAction(args: { webhookId: number; actionId: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { webhookId, actionId, ...data } = args;
+    return this.webhookService.updateAction(webhookId, actionId, data);
+  }
+
+  @McpTool({
+    name: 'core.webhooks.actions.delete',
+    description: 'Deletes one or more webhook actions. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Webhook ID' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Action IDs to delete' },
+      },
+      required: ['webhookId', 'ids'],
+    },
+  })
+  async deleteWebhookActions(args: { webhookId: number; ids: number[] }, _context: McpContext): Promise<any> {
+    return this.webhookService.deleteActions(args.webhookId, { ids: args.ids });
+  }
+
+  @McpTool({
+    name: 'core.webhooks.logs.list',
+    description: 'Lists execution logs for a webhook. Admin only.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        webhookId: { type: 'number', description: 'Webhook ID' },
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+      },
+      required: ['webhookId'],
+    },
+    readOnly: true,
+  })
+  async listWebhookLogs(args: { webhookId: number; page?: number; pageSize?: number }, _context: McpContext): Promise<any> {
+    return this.webhookService.listLogs(args.webhookId, {
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      search: '',
+      sortField: 'id',
+      sortOrder: 'desc' as any,
+      fields: '',
+    });
+  }
+}

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

@@ -1,60 +1,113 @@
-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);
-  }
-}
+import { Role, User } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Post,
+    Res,
+} from '@nestjs/common';
+import { Response } from 'express';
+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);
+  }
+
+  @Post(':id/messages/stream')
+  async sendMessageStream(
+    @User() { id }: { id: number },
+    @Param('id', ParseIntPipe) conversationId: number,
+    @Body() dto: SendMessageDTO,
+    @Locale() locale: string,
+    @Res() res: Response,
+  ) {
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+
+    const writeEvent = (payload: unknown) => {
+      res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    };
+
+    try {
+      const messages = await this.service.sendMessage(
+        conversationId,
+        id,
+        locale,
+        dto.message,
+      );
+
+      const lastAssistant = [...messages]
+        .reverse()
+        .find((msg) => msg.role === 'assistant');
+      const content = lastAssistant?.content ?? '';
+
+      if (content.length > 0) {
+        const chunkSize = Math.max(8, Math.min(32, Math.ceil(content.length / 80)));
+        for (let cursor = 0; cursor < content.length; cursor += chunkSize) {
+          writeEvent({
+            type: 'chunk',
+            content: content.slice(cursor, cursor + chunkSize),
+          });
+        }
+      }
+
+      writeEvent({ type: 'done', messages });
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : 'Failed to stream message';
+      writeEvent({ type: 'error', message });
+    } finally {
+      res.end();
+    }
+  }
+}