@hed-hog/core 0.0.350 → 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: '',
+    });
+  }
+}